SDK regeneration

Author: fern-api[bot]

.fern/metadata.json

@@ -16,6 +16,6 @@
       "skip_validation": true
     }
   },
-  "originGitCommit": "aa8e0677bcaea82c02a5934c61d195b35921b33d",
+  "originGitCommit": "14bcc648246f9ac9fb131ba74e7bdaf0cc515238",
   "sdkVersion": "6.1.2"
 }

poetry.lock

@@ -3,7 +3,9 @@
 import json
 import logging
 import typing
+from json.decoder import JSONDecodeError
 
+import websockets
 import websockets.sync.connection as websockets_sync_connection
 from ...core.events import EventEmitterMixin, EventType
 from ...core.unchecked_base_model import construct_type
@@ -37,26 +39,6 @@
     from websockets import WebSocketClientProtocol  # type: ignore
 
 _logger = logging.getLogger(__name__)
-
-
-def _sanitize_numeric_types(obj: typing.Any) -> typing.Any:
-    """
-    Recursively convert float values that are whole numbers to int.
-
-    Workaround for Fern-generated models that type integer API fields
-    (like sample_rate) as float, causing JSON serialization to produce
-    values like 44100.0 instead of 44100. The Deepgram API rejects
-    float representations of integer fields.
-
-    See: https://github.com/deepgram/internal-api-specs/issues/205
-    """
-    if isinstance(obj, dict):
-        return {k: _sanitize_numeric_types(v) for k, v in obj.items()}
-    elif isinstance(obj, list):
-        return [_sanitize_numeric_types(item) for item in obj]
-    elif isinstance(obj, float) and obj.is_integer():
-        return int(obj)
-    return obj
 V1SocketClientResponse = typing.Union[
     AgentV1ReceiveFunctionCallResponse,
     AgentV1PromptUpdated,
@@ -88,7 +70,7 @@ async def __aiter__(self):
                 yield message
             else:
                 try:
-                    yield construct_type(type_=V1SocketClientResponse, object_=json.loads(message))  # type: ignore
+                    yield construct_type(V1SocketClientResponse, json.loads(message))  # type: ignore
                 except Exception:
                     _logger.warning(
                         "Skipping unknown WebSocket message; update your SDK version to support new message types."
@@ -113,14 +95,14 @@ async def start_listening(self):
                 else:
                     json_data = json.loads(raw_message)
                     try:
-                        parsed = construct_type(type_=V1SocketClientResponse, object_=json_data)  # type: ignore
+                        parsed = construct_type(V1SocketClientResponse, json_data)  # type: ignore
                     except Exception:
                         _logger.warning(
                             "Skipping unknown WebSocket message; update your SDK version to support new message types."
                         )
                         continue
                 await self._emit_async(EventType.MESSAGE, parsed)
-        except Exception as exc:
+        except (websockets.WebSocketException, JSONDecodeError) as exc:
             await self._emit_async(EventType.ERROR, exc)
         finally:
             await self._emit_async(EventType.CLOSE, None)
@@ -160,12 +142,12 @@ async def send_function_call_response(self, message: AgentV1SendFunctionCallResp
         """
         await self._send_model(message)
 
-    async def send_keep_alive(self, message: typing.Optional[AgentV1KeepAlive] = None) -> None:
+    async def send_keep_alive(self, message: AgentV1KeepAlive) -> None:
         """
         Send a message to the websocket connection.
         The message will be sent as a AgentV1KeepAlive.
         """
-        await self._send_model(message or AgentV1KeepAlive(type="KeepAlive"))
+        await self._send_model(message)
 
     async def send_update_prompt(self, message: AgentV1UpdatePrompt) -> None:
         """
@@ -197,7 +179,7 @@ async def recv(self) -> V1SocketClientResponse:
             return data  # type: ignore
         json_data = json.loads(data)
         try:
-            return construct_type(type_=V1SocketClientResponse, object_=json_data)  # type: ignore
+            return construct_type(V1SocketClientResponse, json_data)  # type: ignore
         except Exception:
             _logger.warning("Skipping unknown WebSocket message; update your SDK version to support new message types.")
             return json_data  # type: ignore
@@ -214,7 +196,7 @@ async def _send_model(self, data: typing.Any) -> None:
         """
         Send a Pydantic model to the websocket connection.
         """
-        await self._send(_sanitize_numeric_types(data.dict()))
+        await self._send(data.dict())
 
 
 class V1SocketClient(EventEmitterMixin):
@@ -228,7 +210,7 @@ def __iter__(self):
                 yield message
             else:
                 try:
-                    yield construct_type(type_=V1SocketClientResponse, object_=json.loads(message))  # type: ignore
+                    yield construct_type(V1SocketClientResponse, json.loads(message))  # type: ignore
                 except Exception:
                     _logger.warning(
                         "Skipping unknown WebSocket message; update your SDK version to support new message types."
@@ -253,14 +235,14 @@ def start_listening(self):
                 else:
                     json_data = json.loads(raw_message)
                     try:
-                        parsed = construct_type(type_=V1SocketClientResponse, object_=json_data)  # type: ignore
+                        parsed = construct_type(V1SocketClientResponse, json_data)  # type: ignore
                     except Exception:
                         _logger.warning(
                             "Skipping unknown WebSocket message; update your SDK version to support new message types."
                         )
                         continue
                 self._emit(EventType.MESSAGE, parsed)
-        except Exception as exc:
+        except (websockets.WebSocketException, JSONDecodeError) as exc:
             self._emit(EventType.ERROR, exc)
         finally:
             self._emit(EventType.CLOSE, None)
@@ -300,12 +282,12 @@ def send_function_call_response(self, message: AgentV1SendFunctionCallResponse)
         """
         self._send_model(message)
 
-    def send_keep_alive(self, message: typing.Optional[AgentV1KeepAlive] = None) -> None:
+    def send_keep_alive(self, message: AgentV1KeepAlive) -> None:
         """
         Send a message to the websocket connection.
         The message will be sent as a AgentV1KeepAlive.
         """
-        self._send_model(message or AgentV1KeepAlive(type="KeepAlive"))
+        self._send_model(message)
 
     def send_update_prompt(self, message: AgentV1UpdatePrompt) -> None:
         """
@@ -337,7 +319,7 @@ def recv(self) -> V1SocketClientResponse:
             return data  # type: ignore
         json_data = json.loads(data)
         try:
-            return construct_type(type_=V1SocketClientResponse, object_=json_data)  # type: ignore
+            return construct_type(V1SocketClientResponse, json_data)  # type: ignore
         except Exception:
             _logger.warning("Skipping unknown WebSocket message; update your SDK version to support new message types.")
             return json_data  # type: ignore
@@ -354,4 +336,4 @@ def _send_model(self, data: typing.Any) -> None:
         """
         Send a Pydantic model to the websocket connection.
         """
-        self._send(_sanitize_numeric_types(data.dict()))
+        self._send(data.dict())

src/deepgram/agent/v1/socket_client.py

@@ -3,7 +3,9 @@
 import json
 import logging
 import typing
+from json.decoder import JSONDecodeError
 
+import websockets
 import websockets.sync.connection as websockets_sync_connection
 from ...core.events import EventEmitterMixin, EventType
 from ...core.unchecked_base_model import construct_type
@@ -35,7 +37,7 @@ async def __aiter__(self):
                 yield message
             else:
                 try:
-                    yield construct_type(type_=V1SocketClientResponse, object_=json.loads(message))  # type: ignore
+                    yield construct_type(V1SocketClientResponse, json.loads(message))  # type: ignore
                 except Exception:
                     _logger.warning(
                         "Skipping unknown WebSocket message; update your SDK version to support new message types."
@@ -60,14 +62,14 @@ async def start_listening(self):
                 else:
                     json_data = json.loads(raw_message)
                     try:
-                        parsed = construct_type(type_=V1SocketClientResponse, object_=json_data)  # type: ignore
+                        parsed = construct_type(V1SocketClientResponse, json_data)  # type: ignore
                     except Exception:
                         _logger.warning(
                             "Skipping unknown WebSocket message; update your SDK version to support new message types."
                         )
                         continue
                 await self._emit_async(EventType.MESSAGE, parsed)
-        except Exception as exc:
+        except (websockets.WebSocketException, JSONDecodeError) as exc:
             await self._emit_async(EventType.ERROR, exc)
         finally:
             await self._emit_async(EventType.CLOSE, None)
@@ -79,26 +81,26 @@ async def send_media(self, message: bytes) -> None:
         """
         await self._send(message)
 
-    async def send_finalize(self, message: typing.Optional[ListenV1Finalize] = None) -> None:
+    async def send_finalize(self, message: ListenV1Finalize) -> None:
         """
         Send a message to the websocket connection.
         The message will be sent as a ListenV1Finalize.
         """
-        await self._send_model(message or ListenV1Finalize(type="Finalize"))
+        await self._send_model(message)
 
-    async def send_close_stream(self, message: typing.Optional[ListenV1CloseStream] = None) -> None:
+    async def send_close_stream(self, message: ListenV1CloseStream) -> None:
         """
         Send a message to the websocket connection.
         The message will be sent as a ListenV1CloseStream.
         """
-        await self._send_model(message or ListenV1CloseStream(type="CloseStream"))
+        await self._send_model(message)
 
-    async def send_keep_alive(self, message: typing.Optional[ListenV1KeepAlive] = None) -> None:
+    async def send_keep_alive(self, message: ListenV1KeepAlive) -> None:
         """
         Send a message to the websocket connection.
         The message will be sent as a ListenV1KeepAlive.
         """
-        await self._send_model(message or ListenV1KeepAlive(type="KeepAlive"))
+        await self._send_model(message)
 
     async def recv(self) -> V1SocketClientResponse:
         """
@@ -109,7 +111,7 @@ async def recv(self) -> V1SocketClientResponse:
             return data  # type: ignore
         json_data = json.loads(data)
         try:
-            return construct_type(type_=V1SocketClientResponse, object_=json_data)  # type: ignore
+            return construct_type(V1SocketClientResponse, json_data)  # type: ignore
         except Exception:
             _logger.warning("Skipping unknown WebSocket message; update your SDK version to support new message types.")
             return json_data  # type: ignore
@@ -140,7 +142,7 @@ def __iter__(self):
                 yield message
             else:
                 try:
-                    yield construct_type(type_=V1SocketClientResponse, object_=json.loads(message))  # type: ignore
+                    yield construct_type(V1SocketClientResponse, json.loads(message))  # type: ignore
                 except Exception:
                     _logger.warning(
                         "Skipping unknown WebSocket message; update your SDK version to support new message types."
@@ -165,14 +167,14 @@ def start_listening(self):
                 else:
                     json_data = json.loads(raw_message)
                     try:
-                        parsed = construct_type(type_=V1SocketClientResponse, object_=json_data)  # type: ignore
+                        parsed = construct_type(V1SocketClientResponse, json_data)  # type: ignore
                     except Exception:
                         _logger.warning(
                             "Skipping unknown WebSocket message; update your SDK version to support new message types."
                         )
                         continue
                 self._emit(EventType.MESSAGE, parsed)
-        except Exception as exc:
+        except (websockets.WebSocketException, JSONDecodeError) as exc:
             self._emit(EventType.ERROR, exc)
         finally:
             self._emit(EventType.CLOSE, None)
@@ -184,26 +186,26 @@ def send_media(self, message: bytes) -> None:
         """
         self._send(message)
 
-    def send_finalize(self, message: typing.Optional[ListenV1Finalize] = None) -> None:
+    def send_finalize(self, message: ListenV1Finalize) -> None:
         """
         Send a message to the websocket connection.
         The message will be sent as a ListenV1Finalize.
         """
-        self._send_model(message or ListenV1Finalize(type="Finalize"))
+        self._send_model(message)
 
-    def send_close_stream(self, message: typing.Optional[ListenV1CloseStream] = None) -> None:
+    def send_close_stream(self, message: ListenV1CloseStream) -> None:
         """
         Send a message to the websocket connection.
         The message will be sent as a ListenV1CloseStream.
         """
-        self._send_model(message or ListenV1CloseStream(type="CloseStream"))
+        self._send_model(message)
 
-    def send_keep_alive(self, message: typing.Optional[ListenV1KeepAlive] = None) -> None:
+    def send_keep_alive(self, message: ListenV1KeepAlive) -> None:
         """
         Send a message to the websocket connection.
         The message will be sent as a ListenV1KeepAlive.
         """
-        self._send_model(message or ListenV1KeepAlive(type="KeepAlive"))
+        self._send_model(message)
 
     def recv(self) -> V1SocketClientResponse:
         """
@@ -214,7 +216,7 @@ def recv(self) -> V1SocketClientResponse:
             return data  # type: ignore
         json_data = json.loads(data)
         try:
-            return construct_type(type_=V1SocketClientResponse, object_=json_data)  # type: ignore
+            return construct_type(V1SocketClientResponse, json_data)  # type: ignore
         except Exception:
             _logger.warning("Skipping unknown WebSocket message; update your SDK version to support new message types.")
             return json_data  # type: ignore