FunctionCallRequest seems outdated for new API version

[ArturZhukovets]

Following your migration guide, I started updating to the new API version using the Python SDK.

According to your latest specification, a FunctionCallRequest now looks like this:

{
  "type": "FunctionCallRequest",
  "functions": [
    {
      "id": "fc_12345678-90ab-cdef-1234-567890abcdef",
      "name": "get_weather",
      "arguments": "{\"location\": \"Fremont, CA 94539\"}",
      "client_side": true
    }
  ]
}

However, the SDK's corresponding dataclass that handles this structure and deserializes it from JSON appears to be outdated:

@dataclass
class FunctionCallRequest(BaseResponse):
    """
    The FunctionCallRequest message is used to call a function from the server to the client.
    """
    type: str
    function_name: str
    function_call_id: str
    input: str

It looks like the SDK needs to be updated to reflect the new schema.

Upd: The same issue with FunctionCallResponse
Upd2.0: It feels like no one cares. For those who will be reading this issue, I recommend not using the Agent SDK, but using the API instead to save time.

[jpvajda]

@ArturZhukovets You definitely found an issue here, based on my analysis here's a possible path forward we'll consider soon:
.

Complete Analysis: Official Specification vs Current SDK

Official FunctionCallRequest:

required: [type, functions]
properties:
  type: const FunctionCallRequest
  functions:
    type: array
    items:
      required: [id, name, arguments, client_side]
      properties:
        id: string (unique identifier)
        name: string (function name)
        arguments: string (JSON string with function arguments)
        client_side: boolean (whether executed client-side)

Official FunctionCallResponse:

properties:
  type: const FunctionCallResponse
  id: string (unique identifier)
  name: string (function name)
  content: string (function result/content)

Current SDK Problems:

1. FunctionCallRequest: Uses flat structure (function_name, function_call_id, input) instead of functions array
2. FunctionCallResponse: Uses function_call_id, output instead of id, name, content

Corrected Implementation

Next Step: Create the updated dataclass implementations that match the official specification.

Here's the complete corrected implementation based on the official specification:

Updated Dataclass Implementations

File: deepgram/clients/agent/v1/websocket/response.py

# Add this new dataclass for function call items
@dataclass
class FunctionCall(BaseResponse):
    """
    Individual function call within a FunctionCallRequest.
    """
    id: str
    name: str
    arguments: str
    client_side: bool

@dataclass
class FunctionCallRequest(BaseResponse):
    """
    The FunctionCallRequest message is used to call a function from the server to the client.
    """
    type: str
    functions: List[FunctionCall]

    def __post_init__(self):
        """Convert dict functions to FunctionCall objects if needed."""
        if self.functions and isinstance(self.functions[0], dict):
            self.functions = [
                FunctionCall.from_dict(func) if isinstance(func, dict) else func
                for func in self.functions
            ]

    def __getitem__(self, key):
        _dict = self.to_dict()
        if "functions" in _dict and isinstance(_dict["functions"], list):
            _dict["functions"] = [
                FunctionCall.from_dict(func) if isinstance(func, dict) else func
                for func in _dict["functions"]
            ]
        return _dict[key]

File: deepgram/clients/agent/v1/websocket/options.py

@dataclass
class FunctionCallResponse(BaseResponse):
    """
    The FunctionCallResponse message is a JSON command that the client should reply with every time there is a FunctionCallRequest received.
    """
    type: str = "FunctionCallResponse"
    id: str = field(default="")
    name: str = field(default="")
    content: str = field(default="")

Breaking Changes and Migration Guide

For FunctionCallRequest:

Old Structure:

# Old way - accessing flat structure
function_call_request.function_name
function_call_request.function_call_id
function_call_request.input

New Structure:

# New way - accessing functions array
for function in function_call_request.functions:
    function.id          # was function_call_id
    function.name        # was function_name
    function.arguments   # was input
    function.client_side # new field

For FunctionCallResponse:

Old Structure:

# Old way
response = FunctionCallResponse(
    function_call_id=request.function_call_id,
    output="Function result"
)

New Structure:

# New way
response = FunctionCallResponse(
    id=request.functions[0].id,
    name=request.functions[0].name,
    content="Function result"
)

Updated Example Usage

Old Example:

def on_function_call_request(self, function_call_request: FunctionCallRequest, **kwargs):
    try:
        response = FunctionCallResponse(
            function_call_id=function_call_request.function_call_id,
            output="Function response here",
        )
        dg_connection.send_function_call_response(response)
    except Exception as e:
        print(f"Error in function call: {e}")

New Example:

def on_function_call_request(self, function_call_request: FunctionCallRequest, **kwargs):
    try:
        # Handle multiple functions
        for function in function_call_request.functions:
            response = FunctionCallResponse(
                id=function.id,
                name=function.name,
                content="Function response here",
            )
            dg_connection.send_function_call_response(response)
    except Exception as e:
        print(f"Error in function call: {e}")

Files That Need Updates

1. deepgram/clients/agent/v1/websocket/response.py - Update FunctionCallRequest
2. deepgram/clients/agent/v1/websocket/options.py - Update FunctionCallResponse
3. examples/agent/simple/main.py - Update example usage
4. tests/daily_test/test_daily_agent_websocket.py - Update test code
5. All other examples and tests using function calls

Future Steps: The next steps would be to:

1. Implement these changes across all files
2. Update imports and exports
3. Add backward compatibility if needed
4. Update documentation and examples
5. Test the updated implementation