Skip to content

Composio powers 1000+ toolkits, tool search, context management, authentication, and a sandboxed workbench to help you build AI agents that turn intent into action.

fix(providers): normalize string tool-call arguments across all providers (TS + Python) (#3514)

Alberto Schiabelce4b21336165
diff --git a/.changeset/normalize-tool-arguments-2406.md b/.changeset/normalize-tool-arguments-2406.md
new file mode 100644
index 000000000..0de61b4a7
--- /dev/null
+++ b/.changeset/normalize-tool-arguments-2406.md
@@ -0,0 +1,28 @@
+---
+'@composio/core': patch
+'@composio/vercel': patch
+'@composio/openai-agents': patch
+'@composio/cloudflare': patch
+'@composio/anthropic': patch
+'@composio/google': patch
+'@composio/langchain': patch
+'@composio/llamaindex': patch
+'@composio/claude-agent-sdk': patch
+'@composio/mastra': patch
+'@composio/openai': patch
+---
+
+fix(providers): normalize string tool-call arguments across all providers
+
+Models occasionally emit tool-call arguments as a JSON string instead of an
+object (most visibly with `COMPOSIO_MULTI_EXECUTE_TOOL` on the Vercel AI SDK),
+which broke downstream validation with errors like
+`tool_use.input: Input should be a valid dictionary`.
+
+`@composio/core` now exposes a single `normalizeToolArguments` helper, and every
+provider routes model-supplied arguments through it. Object payloads pass
+through unchanged, JSON strings are parsed, empty/`null` payloads become `{}`,
+and anything that cannot resolve to an object throws a typed
+`ComposioInvalidToolArgumentsError` instead of a raw `SyntaxError` or a silently
+forwarded malformed string. This replaces the inconsistent per-provider guards
+that previously existed only in vercel, cloudflare and openai-agents.
diff --git a/python/composio/core/provider/_openai.py b/python/composio/core/provider/_openai.py
index 33217406d..cb2b3e9ec 100644
--- a/python/composio/core/provider/_openai.py
+++ b/python/composio/core/provider/_openai.py
@@ -21,6 +21,7 @@ from openai.types.shared_params.function_parameters import FunctionParameters
from composio.core.provider import NonAgenticProvider
from composio.types import Modifiers, Tool, ToolExecutionResponse
+from composio.utils.shared import normalize_tool_arguments
OpenAITool: t.TypeAlias = ChatCompletionToolParam
OpenAIToolCollection: t.TypeAlias = t.List[OpenAITool]
@@ -57,9 +58,11 @@ class OpenAIProvider(
:param user_id: User ID to use for executing the function call.
:return: Object containing output data from the tool call.
"""
+ # OpenAI always serializes tool arguments as a JSON string; normalize
+ # tolerates empty / object-shaped payloads too (issue #2406).
return self.execute_tool(
slug=tool_call.function.name,
- arguments=json.loads(tool_call.function.arguments),
+ arguments=normalize_tool_arguments(tool_call.function.arguments),
modifiers=modifiers,
user_id=user_id,
)
diff --git a/python/composio/core/provider/_openai_responses.py b/python/composio/core/provider/_openai_responses.py
index 732e0fe40..2e3b72917 100644
--- a/python/composio/core/provider/_openai_responses.py
+++ b/python/composio/core/provider/_openai_responses.py
@@ -4,7 +4,6 @@ OpenAI Responses API provider implementation.
from __future__ import annotations
-import json
import typing as t
from openai.types.responses.response import Response
@@ -12,6 +11,7 @@ from openai.types.responses.response_output_item import ResponseFunctionToolCall
from composio.core.provider import NonAgenticProvider
from composio.types import Modifiers, Tool, ToolExecutionResponse
+from composio.utils.shared import normalize_tool_arguments
# Responses API uses a flattened tool structure
ResponsesTool = t.Dict[str, t.Any]
@@ -49,8 +49,10 @@ class OpenAIResponsesProvider(
:param modifiers: Optional modifiers for tool execution.
:return: Object containing output data from the tool call.
"""
+ # OpenAI always serializes tool arguments as a JSON string; normalize
+ # tolerates empty / object-shaped payloads too (issue #2406).
slug = tool_call.name
- arguments = json.loads(tool_call.arguments)
+ arguments = normalize_tool_arguments(tool_call.arguments)
return self.execute_tool(
slug=slug,
diff --git a/python/composio/utils/shared.py b/python/composio/utils/shared.py
index f9ebb618b..6509905ac 100644
--- a/python/composio/utils/shared.py
+++ b/python/composio/utils/shared.py
@@ -3,6 +3,7 @@ Shared utils.
"""
import copy
+import json
import keyword
import typing as t
import uuid
@@ -11,6 +12,7 @@ from inspect import Parameter
from pydantic import BaseModel, Field, create_model
from pydantic.fields import FieldInfo
+from composio.exceptions import InvalidParams
from composio.utils.logging import get as get_logger
from composio.utils.schema_converter import (
CONTAINER_TYPE,
@@ -36,6 +38,7 @@ __all__ = [
"generate_request_id",
"substitute_reserved_python_keywords",
"reinstate_reserved_python_keywords",
+ "normalize_tool_arguments",
]
reserved_names = ["validate"]
@@ -43,6 +46,52 @@ reserved_names = ["validate"]
_OBJ_MARKER = "-_object_-"
+def normalize_tool_arguments(arguments: t.Any) -> t.Dict[str, t.Any]:
+ """Coerce model-supplied tool arguments into a dict.
+
+ Models (and some MCP transports) occasionally emit tool-call arguments as a
+ JSON string instead of a dict, which breaks execution with errors such as
+ ``tool_use.input: Input should be a valid dictionary``. This is the single
+ coercion every provider routes through so behaviour is identical everywhere.
+
+ See https://github.com/ComposioHQ/composio/issues/2406.
+
+ - ``None`` becomes ``{}`` (some models send no arguments for no-arg tools).
+ - A dict is returned unchanged.
+ - A string is JSON-parsed; an empty / whitespace-only string becomes ``{}``.
+ - Anything that does not resolve to a dict (lists, primitives, unparseable
+ strings, JSON that parses to a non-object) raises :class:`InvalidParams`.
+
+ :param arguments: Raw arguments as received from the model / framework.
+ :return: The normalized arguments as a dict.
+ :raises InvalidParams: If the arguments cannot be resolved to a dict.
+ """
+ if arguments is None:
+ return {}
+
+ if isinstance(arguments, str):
+ stripped = arguments.strip()
+ if not stripped:
+ return {}
+ try:
+ parsed = json.loads(stripped)
+ except json.JSONDecodeError as e:
+ raise InvalidParams(
+ f"Tool arguments were provided as a string that is not valid JSON: {e}"
+ ) from e
+ return _as_dict(parsed)
+
+ return _as_dict(arguments)
+
+
+def _as_dict(value: t.Any) -> t.Dict[str, t.Any]:
+ if isinstance(value, dict):
+ return value
+ raise InvalidParams(
+ f"Tool arguments must resolve to an object, received {type(value).__name__}"
+ )
+
+
def _make_safe_name(name: str) -> str:
"""Append ``_rs`` to a Python keyword so it can be used as a parameter name."""
return f"{name}_rs"
diff --git a/python/providers/anthropic/composio_anthropic/provider.py b/python/providers/anthropic/composio_anthropic/provider.py
index 63f2fd1a0..5115fe948 100644
--- a/python/providers/anthropic/composio_anthropic/provider.py
+++ b/python/providers/anthropic/composio_anthropic/provider.py
@@ -7,6 +7,7 @@ from anthropic.types.tool_use_block import ToolUseBlock
from composio.core.provider import NonAgenticProvider
from composio.types import Modifiers, Tool, ToolExecutionResponse
+from composio.utils.shared import normalize_tool_arguments
class AnthropicProvider(
@@ -41,9 +42,10 @@ class AnthropicProvider(
:param modifiers: Modifiers to use for executing function calls.
:return: Object containing output data from the tool call.
"""
+ # Models occasionally emit tool input as a JSON string rather than a dict (issue #2406).
return self.execute_tool(
slug=tool_call.name,
- arguments=t.cast(t.Dict, tool_call.input),
+ arguments=normalize_tool_arguments(tool_call.input),
modifiers=modifiers,
user_id=user_id,
)
diff --git a/python/providers/autogen/composio_autogen/provider.py b/python/providers/autogen/composio_autogen/provider.py
index 830b5821a..f62618288 100644
--- a/python/providers/autogen/composio_autogen/provider.py
+++ b/python/providers/autogen/composio_autogen/provider.py
@@ -12,6 +12,7 @@ from composio.core.provider import AgenticProvider
from composio.core.provider.agentic import AgenticProviderExecuteFn
from composio.utils.shared import (
get_signature_format_from_schema_params,
+ normalize_tool_arguments,
reinstate_reserved_python_keywords,
substitute_reserved_python_keywords,
)
@@ -78,7 +79,10 @@ class AutogenProvider(
kwargs = reinstate_reserved_python_keywords(
request=kwargs, keywords=keywords
)
- return execute_tool(slug=tool.slug, arguments=kwargs)
+ # Normalize defensively so a stringified payload is coerced to a dict (issue #2406).
+ return execute_tool(
+ slug=tool.slug, arguments=normalize_tool_arguments(kwargs)
+ )
# Create function with proper signature
function = types.FunctionType(
diff --git a/python/providers/claude_agent_sdk/composio_claude_agent_sdk/provider.py b/python/providers/claude_agent_sdk/composio_claude_agent_sdk/provider.py
index 3f4a43969..ae923e21e 100644
--- a/python/providers/claude_agent_sdk/composio_claude_agent_sdk/provider.py
+++ b/python/providers/claude_agent_sdk/composio_claude_agent_sdk/provider.py
@@ -21,6 +21,7 @@ from claude_agent_sdk import (
from composio.core.provider import AgenticProvider
from composio.core.provider.agentic import AgenticProviderExecuteFn
from composio.types import Tool
+from composio.utils.shared import normalize_tool_arguments
class ClaudeAgentSDKProvider(
@@ -104,7 +105,8 @@ class ClaudeAgentSDKProvider(
result = await asyncio.to_thread(
execute_tool,
tool.slug,
- args,
+ # Models occasionally emit tool input as a JSON string (issue #2406).
+ normalize_tool_arguments(args),
)
# Format the result for Claude Agent SDK
result_text = result if isinstance(result, str) else json.dumps(result)
diff --git a/python/providers/crewai/composio_crewai/providers.py b/python/providers/crewai/composio_crewai/providers.py
index 219071a49..d963310c2 100644
--- a/python/providers/crewai/composio_crewai/providers.py
+++ b/python/providers/crewai/composio_crewai/providers.py
@@ -6,7 +6,7 @@ from crewai.tools import BaseTool
from composio.core.provider import AgenticProvider, AgenticProviderExecuteFn
from composio.types import Tool
from composio.utils.pydantic import parse_pydantic_error
-from composio.utils.shared import json_schema_to_model
+from composio.utils.shared import json_schema_to_model, normalize_tool_arguments
class CrewAIProvider(AgenticProvider[BaseTool, list[BaseTool]], name="crewai"):
@@ -24,7 +24,10 @@ class CrewAIProvider(AgenticProvider[BaseTool, list[BaseTool]], name="crewai"):
class Wrapper(BaseTool):
def _run(self, **kwargs):
try:
- return execute_tool(slug=tool.slug, arguments=kwargs)
+ # Normalize defensively so a stringified payload is coerced to a dict (issue #2406).
+ return execute_tool(
+ slug=tool.slug, arguments=normalize_tool_arguments(kwargs)
+ )
except pydantic.ValidationError as e:
return {
"successful": False,
diff --git a/python/providers/gemini/composio_gemini/provider.py b/python/providers/gemini/composio_gemini/provider.py
index a68140694..c7e3dc2ea 100644
--- a/python/providers/gemini/composio_gemini/provider.py
+++ b/python/providers/gemini/composio_gemini/provider.py
@@ -14,6 +14,7 @@ from composio.core.provider import AgenticProvider
from composio.core.provider.agentic import AgenticProviderExecuteFn
from composio.utils.shared import (
get_pydantic_signature_format_from_schema_params,
+ normalize_tool_arguments,
reinstate_reserved_python_keywords,
substitute_reserved_python_keywords,
)
@@ -109,7 +110,8 @@ class GeminiProvider(AgenticProvider[t.Callable, list[t.Callable]], name="gemini
kwargs = reinstate_reserved_python_keywords(
request=kwargs, keywords=keywords
)
- result = execute_tool(tool.slug, kwargs)
+ # Normalize defensively so a stringified payload is coerced to a dict (issue #2406).
+ result = execute_tool(tool.slug, normalize_tool_arguments(kwargs))
return _process_execution_result(result)
# Create a real function object (passes inspect.isfunction)
@@ -188,7 +190,9 @@ class GeminiProvider(AgenticProvider[t.Callable, list[t.Callable]], name="gemini
if fc.name not in self._executors:
continue
- result = self._executors[fc.name](slug=fc.name, arguments=dict(fc.args))
+ result = self._executors[fc.name](
+ slug=fc.name, arguments=normalize_tool_arguments(dict(fc.args))
+ )
processed = _process_execution_result(result)
function_responses.append(
diff --git a/python/providers/google/composio_google/provider.py b/python/providers/google/composio_google/provider.py
index 0b897d324..6604bece6 100644
--- a/python/providers/google/composio_google/provider.py
+++ b/python/providers/google/composio_google/provider.py
@@ -14,6 +14,7 @@ from vertexai.generative_models import (
from composio.core.provider import NonAgenticProvider
from composio.types import Modifiers, Tool, ToolExecutionResponse
+from composio.utils.shared import normalize_tool_arguments
def _convert_map_composite(obj):
@@ -69,13 +70,12 @@ class GoogleProvider(
:param user_id: User ID to use for executing the function call.
:return: Object containing output data from the function call.
"""
+ # Gemini returns args as a MapComposite; normalize after converting to a
+ # plain dict so a stringified payload is handled uniformly too (issue #2406).
return self.execute_tool(
slug=function_call.name,
- arguments=t.cast(
- dict,
- _convert_map_composite(
- function_call.args,
- ),
+ arguments=normalize_tool_arguments(
+ _convert_map_composite(function_call.args)
),
modifiers=modifiers,
user_id=user_id,
diff --git a/python/providers/google_adk/composio_google_adk/provider.py b/python/providers/google_adk/composio_google_adk/provider.py
index 4b2fc59fd..ce84c0526 100644
--- a/python/providers/google_adk/composio_google_adk/provider.py
+++ b/python/providers/google_adk/composio_google_adk/provider.py
@@ -8,10 +8,11 @@ from composio.client.types import Tool
from composio.core.provider import AgenticProvider
from composio.core.provider.agentic import AgenticProviderExecuteFn
from composio.utils.openapi import function_signature_from_jsonschema
+from composio.utils.shared import normalize_tool_arguments
class GoogleAdkProvider(
- AgenticProvider[FunctionTool, list[FunctionTool]], name="gemini"
+ AgenticProvider[FunctionTool, list[FunctionTool]], name="google_adk"
):
"""
Composio toolset for Google ADK framework.
@@ -26,9 +27,22 @@ class GoogleAdkProvider(
) -> FunctionTool:
"""Wraps composio tool as Google Genai SDK compatible function calling object."""
- docstring = tool.description
+ input_parameters = t.cast(
+ t.Dict[str, t.Any],
+ tool.input_parameters
+ or {
+ "type": "object",
+ "properties": {},
+ "required": [],
+ },
+ )
+ properties = t.cast(
+ t.Dict[str, t.Dict[str, t.Any]],
+ input_parameters.get("properties", {}),
+ )
+ docstring = tool.description or f"Execute {tool.slug}"
docstring += "\nArgs:"
- for _param, _schema in tool.input_parameters["properties"].items(): # type: ignore
+ for _param, _schema in properties.items():
docstring += "\n "
docstring += _param + ": " + _schema.get("description", _param.title())
@@ -36,7 +50,10 @@ class GoogleAdkProvider(
docstring += "\n A dictionary containing response from the action"
def _execute(**kwargs: t.Any) -> t.Dict:
- return execute_tool(slug=tool.slug, arguments=kwargs)
+ # Normalize defensively so a stringified payload is coerced to a dict (issue #2406).
+ return execute_tool(
+ slug=tool.slug, arguments=normalize_tool_arguments(kwargs)
+ )
function = types.FunctionType(
code=_execute.__code__,
@@ -45,7 +62,7 @@ class GoogleAdkProvider(
closure=_execute.__closure__,
)
parameters = function_signature_from_jsonschema(
- schema=tool.input_parameters,
+ schema=input_parameters,
skip_default=self.skip_default,
)
setattr(function, "__signature__", Signature(parameters=parameters))
diff --git a/python/providers/langchain/composio_langchain/provider.py b/python/providers/langchain/composio_langchain/provider.py
index 158224e70..0a3d36f25 100644
--- a/python/providers/langchain/composio_langchain/provider.py
+++ b/python/providers/langchain/composio_langchain/provider.py
@@ -13,6 +13,7 @@ from composio.utils.pydantic import parse_pydantic_error
from composio.utils.shared import (
get_signature_format_from_schema_params,
json_schema_to_model,
+ normalize_tool_arguments,
reinstate_reserved_python_keywords,
substitute_reserved_python_keywords,
)
@@ -51,7 +52,8 @@ class LangchainProvider(
request=kwargs,
keywords=keywords,
)
- return execute_tool(tool.slug, kwargs)
+ # Normalize defensively so a stringified payload is coerced to a dict (issue #2406).
+ return execute_tool(tool.slug, normalize_tool_arguments(kwargs))
action_func = types.FunctionType(
function.__code__,
diff --git a/python/providers/langgraph/composio_langgraph/provider.py b/python/providers/langgraph/composio_langgraph/provider.py
index 21bced11d..8eb14e883 100644
--- a/python/providers/langgraph/composio_langgraph/provider.py
+++ b/python/providers/langgraph/composio_langgraph/provider.py
@@ -13,6 +13,7 @@ from composio.utils.pydantic import parse_pydantic_error
from composio.utils.shared import (
get_signature_format_from_schema_params,
json_schema_to_model,
+ normalize_tool_arguments,
reinstate_reserved_python_keywords,
substitute_reserved_python_keywords,
)
@@ -47,7 +48,8 @@ class LanggraphProvider(
kwargs = reinstate_reserved_python_keywords(
request=kwargs, keywords=keywords
)
- return execute_tool(tool, kwargs)
+ # Normalize defensively so a stringified payload is coerced to a dict (issue #2406).
+ return execute_tool(tool, normalize_tool_arguments(kwargs))
action_func = types.FunctionType(
function.__code__,
diff --git a/python/providers/llamaindex/composio_llamaindex/provider.py b/python/providers/llamaindex/composio_llamaindex/provider.py
index 2fc6ef5bd..1ae166817 100644
--- a/python/providers/llamaindex/composio_llamaindex/provider.py
+++ b/python/providers/llamaindex/composio_llamaindex/provider.py
@@ -10,6 +10,7 @@ from composio.core.provider import AgenticProvider, AgenticProviderExecuteFn
from composio.types import Tool
from composio.utils.shared import (
get_signature_format_from_schema_params,
+ normalize_tool_arguments,
reinstate_reserved_python_keywords,
substitute_reserved_python_keywords,
)
@@ -40,7 +41,10 @@ class LlamaIndexProvider(
kwargs = reinstate_reserved_python_keywords(
request=kwargs, keywords=keywords
)
- return execute_tool(slug=tool.slug, arguments=kwargs)
+ # Normalize defensively so a stringified payload is coerced to a dict (issue #2406).
+ return execute_tool(
+ slug=tool.slug, arguments=normalize_tool_arguments(kwargs)
+ )
action_func = types.FunctionType(
function.__code__,
diff --git a/python/providers/openai_agents/composio_openai_agents/provider.py b/python/providers/openai_agents/composio_openai_agents/provider.py
index b8b505e94..6ba95953c 100644
--- a/python/providers/openai_agents/composio_openai_agents/provider.py
+++ b/python/providers/openai_agents/composio_openai_agents/provider.py
@@ -9,6 +9,7 @@ from composio.core.provider import AgenticProvider
from composio.core.provider.agentic import AgenticProviderExecuteFn
from composio.types import Tool
from composio.utils.pydantic import parse_pydantic_error
+from composio.utils.shared import normalize_tool_arguments
# Recursively remove 'examples' keys from the schema properties
@@ -86,7 +87,8 @@ class OpenAIAgentsProvider(
await asyncio.to_thread( # Running a thread since `execute_tool` is not async
execute_tool,
slug=tool.slug,
- arguments=json.loads(payload) if payload else {},
+ # Models occasionally emit arguments as a JSON string (issue #2406).
+ arguments=normalize_tool_arguments(payload),
)
)
)
diff --git a/python/tests/test_normalize_tool_arguments.py b/python/tests/test_normalize_tool_arguments.py
new file mode 100644
index 000000000..d7d1ccd09
--- /dev/null
+++ b/python/tests/test_normalize_tool_arguments.py
@@ -0,0 +1,44 @@
+"""Tests for normalize_tool_arguments (issue #2406)."""
+
+import pytest
+
+from composio.exceptions import InvalidParams
+from composio.utils.shared import normalize_tool_arguments
+
+pytestmark = pytest.mark.core
+
+
+class TestNormalizeToolArguments:
+ def test_dict_is_returned_unchanged(self):
+ payload = {"to": "[email protected]", "subject": "hi"}
+ assert normalize_tool_arguments(payload) is payload
+
+ def test_json_string_is_parsed(self):
+ payload = {"to": "[email protected]", "subject": "hi", "body": "Hello"}
+ assert (
+ normalize_tool_arguments(
+ '{"to": "[email protected]", "subject": "hi", "body": "Hello"}'
+ )
+ == payload
+ )
+
+ def test_none_becomes_empty_dict(self):
+ assert normalize_tool_arguments(None) == {}
+
+ @pytest.mark.parametrize("value", ["", " ", "\n\t "])
+ def test_empty_string_becomes_empty_dict(self, value):
+ assert normalize_tool_arguments(value) == {}
+
+ def test_malformed_json_string_raises(self):
+ with pytest.raises(InvalidParams, match="not valid JSON"):
+ normalize_tool_arguments('{"to": "[email protected]"')
+
+ @pytest.mark.parametrize("value", ["[1, 2, 3]", "42", '"hello"'])
+ def test_non_object_json_raises(self, value):
+ with pytest.raises(InvalidParams, match="must resolve to an object"):
+ normalize_tool_arguments(value)
+
+ @pytest.mark.parametrize("value", [[1, 2, 3], 42, True])
+ def test_non_dict_value_raises(self, value):
+ with pytest.raises(InvalidParams, match="must resolve to an object"):
+ normalize_tool_arguments(value)
diff --git a/ts/packages/core/src/errors/ToolErrors.ts b/ts/packages/core/src/errors/ToolErrors.ts
index 8f1427f4b..45c0e398b 100644
--- a/ts/packages/core/src/errors/ToolErrors.ts
+++ b/ts/packages/core/src/errors/ToolErrors.ts
@@ -7,6 +7,7 @@ export const ToolErrorCodes = {
TOOL_NOT_FOUND: 'TOOL_NOT_FOUND',
INVALID_MODIFIER: 'INVALID_MODIFIER',
TOOL_EXECUTION_ERROR: 'TOOL_EXECUTION_ERROR',
+ INVALID_TOOL_ARGUMENTS: 'INVALID_TOOL_ARGUMENTS',
INVALID_EXECUTE_FUNCTION: 'INVALID_EXECUTE_FUNCTION',
GLOBAL_EXECUTE_TOOL_FN_NOT_SET: 'GLOBAL_EXECUTE_TOOL_FN_NOT_SET',
TOOL_VERSION_REQUIRED: 'TOOL_VERSION_REQUIRED',
@@ -76,6 +77,23 @@ export class ComposioToolExecutionError extends ComposioError {
}
}
+export class ComposioInvalidToolArgumentsError extends ComposioError {
+ constructor(
+ message: string = 'Invalid tool arguments',
+ options: Omit<ComposioErrorOptions, 'code'> = {}
+ ) {
+ super(message, {
+ ...options,
+ code: ToolErrorCodes.INVALID_TOOL_ARGUMENTS,
+ possibleFixes: options.possibleFixes || [
+ 'Tool arguments must be a JSON object (or a string that parses to one)',
+ 'If a model emitted the arguments as a string, ensure it is valid JSON',
+ ],
+ });
+ this.name = 'ComposioInvalidToolArgumentsError';
+ }
+}
+
export class ComposioInvalidExecuteFunctionError extends ComposioError {
constructor(
message: string = 'Invalid execute function',
diff --git a/ts/packages/core/src/index.ts b/ts/packages/core/src/index.ts
index 7d828eb36..cedb08d5e 100644
--- a/ts/packages/core/src/index.ts
+++ b/ts/packages/core/src/index.ts
@@ -15,6 +15,7 @@ export type {
UnresolvedRefStrategy,
} from './utils/jsonSchema';
export { getExtensionFromMimeType } from './utils/mime';
+export { normalizeToolArguments } from './utils/toolArguments';
export { AuthScheme } from './models/AuthScheme';
export { MCP } from './models/MCP';
export { RemoteFile } from './models/RemoteFile';
diff --git a/ts/packages/core/src/provider/OpenAIProvider.ts b/ts/packages/core/src/provider/OpenAIProvider.ts
index cfef7482c..1f1d426d4 100644
--- a/ts/packages/core/src/provider/OpenAIProvider.ts
+++ b/ts/packages/core/src/provider/OpenAIProvider.ts
@@ -15,6 +15,7 @@ import logger from '../utils/logger';
import { ExecuteToolModifiers } from '../types/modifiers.types';
import { ExecuteToolFnOptions } from '../types/provider.types';
import { McpUrlResponse, McpServerGetResponse } from '../types/mcp.types';
+import { normalizeToolArguments } from '../utils/toolArguments';
export type OpenAiTool = OpenAI.ChatCompletionTool;
export type OpenAiToolCollection = Array<OpenAiTool>;
@@ -184,7 +185,9 @@ export class OpenAIProvider extends BaseNonAgenticProvider<
modifiers?: ExecuteToolModifiers
): Promise<string> {
const payload: ToolExecuteParams = {
- arguments: JSON.parse(tool.function.arguments),
+ // OpenAI always serializes tool arguments as a JSON string; normalize tolerates
+ // empty / object-shaped payloads too (issue #2406).
+ arguments: normalizeToolArguments(tool.function.arguments, tool.function.name),
connectedAccountId: options?.connectedAccountId,
customAuthParams: options?.customAuthParams,
customConnectionData: options?.customConnectionData,
diff --git a/ts/packages/core/src/utils/toolArguments.ts b/ts/packages/core/src/utils/toolArguments.ts
new file mode 100644
index 000000000..beefeb6bc
--- /dev/null
+++ b/ts/packages/core/src/utils/toolArguments.ts
@@ -0,0 +1,73 @@
+/**
+ * Tool-argument normalization.
+ *
+ * Models (and MCP transports) occasionally emit tool-call arguments as a JSON
+ * *string* instead of an object. `COMPOSIO_MULTI_EXECUTE_TOOL` and Vercel AI
+ * SDK streaming are common triggers. Forwarding that raw string to execution
+ * surfaces opaque downstream errors such as
+ * `tool_use.input: Input should be a valid dictionary`.
+ *
+ * `normalizeToolArguments` is the single coercion every provider routes through
+ * so the behaviour is identical everywhere instead of being re-implemented
+ * (inconsistently) per provider.
+ *
+ * @see https://github.com/ComposioHQ/composio/issues/2406
+ */
+import { ComposioInvalidToolArgumentsError } from '../errors/ToolErrors';
+
+/**
+ * Coerce model-supplied tool arguments into a plain object.
+ *
+ * Rules:
+ * - `null` / `undefined` → `{}` (some models send no arguments for no-arg tools).
+ * - A plain object is returned unchanged.
+ * - A string is JSON-parsed; an empty / whitespace-only string becomes `{}`.
+ * - Anything that does not resolve to a plain object (arrays, primitives,
+ * unparseable strings, JSON that parses to a non-object) throws a typed
+ * {@link ComposioInvalidToolArgumentsError} so callers get an actionable
+ * message instead of a raw `SyntaxError` or a silent malformed payload.
+ *
+ * @param input - Raw arguments as received from the model / framework.
+ * @param toolSlug - Optional tool slug, used to enrich the error message.
+ * @returns The normalized arguments as a `Record<string, unknown>`.
+ */
+export function normalizeToolArguments(input: unknown, toolSlug?: string): Record<string, unknown> {
+ if (input === null || input === undefined) {
+ return {};
+ }
+
+ if (typeof input === 'string') {
+ const trimmed = input.trim();
+ if (trimmed === '') {
+ return {};
+ }
+
+ let parsed: unknown;
+ try {
+ parsed = JSON.parse(trimmed);
+ } catch (cause) {
+ throw new ComposioInvalidToolArgumentsError(
+ `${describeTool(toolSlug)} received arguments as a string that is not valid JSON`,
+ { cause: cause instanceof Error ? cause : undefined }
+ );
+ }
+ return assertPlainObject(parsed, toolSlug);
+ }
+
+ return assertPlainObject(input, toolSlug);
+}
+
+function assertPlainObject(value: unknown, toolSlug?: string): Record<string, unknown> {
+ if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+ return value as Record<string, unknown>;
+ }
+
+ const actual = Array.isArray(value) ? 'array' : typeof value;
+ throw new ComposioInvalidToolArgumentsError(
+ `${describeTool(toolSlug)} expected arguments to be an object, received ${actual}`
+ );
+}
+
+function describeTool(toolSlug?: string): string {
+ return toolSlug ? `Tool '${toolSlug}'` : 'Tool';
+}
diff --git a/ts/packages/core/test/provider/openai-provider.test.ts b/ts/packages/core/test/provider/openai-provider.test.ts
index 830782836..06642648c 100644
--- a/ts/packages/core/test/provider/openai-provider.test.ts
+++ b/ts/packages/core/test/provider/openai-provider.test.ts
@@ -108,6 +108,22 @@ describe('OpenAIProvider', () => {
expect(result).toBe(JSON.stringify({ result: 'success' }));
});
+ it('should coerce empty-string arguments to an empty object (issue #2406)', async () => {
+ const toolCall = {
+ id: 'call-123',
+ type: 'function',
+ function: { name: 'test-tool', arguments: '' },
+ } as OpenAI.ChatCompletionMessageFunctionToolCall;
+
+ await provider.executeToolCall('test-user', toolCall);
+
+ expect(mockExecuteToolFn).toHaveBeenCalledWith(
+ 'test-tool',
+ expect.objectContaining({ arguments: {} }),
+ undefined
+ );
+ });
+
it('should pass options to executeTool', async () => {
const userId = 'test-user';
const toolCall = {
diff --git a/ts/packages/core/test/utils/toolArguments.test.ts b/ts/packages/core/test/utils/toolArguments.test.ts
new file mode 100644
index 000000000..a95a26ee0
--- /dev/null
+++ b/ts/packages/core/test/utils/toolArguments.test.ts
@@ -0,0 +1,66 @@
+import { describe, it, expect } from 'vitest';
+import { normalizeToolArguments } from '../../src/utils/toolArguments';
+import { ComposioInvalidToolArgumentsError } from '../../src/errors/ToolErrors';
+
+describe('normalizeToolArguments (issue #2406)', () => {
+ it('returns a plain object unchanged', () => {
+ const input = { to: '[email protected]', subject: 'hi' };
+ expect(normalizeToolArguments(input)).toBe(input);
+ });
+
+ it('parses a stringified JSON object into an object', () => {
+ const params = { to: '[email protected]', subject: 'hi', body: 'Hello' };
+ expect(normalizeToolArguments(JSON.stringify(params))).toEqual(params);
+ });
+
+ it.each([null, undefined])('coerces %s to an empty object', value => {
+ expect(normalizeToolArguments(value)).toEqual({});
+ });
+
+ it.each(['', ' ', '\n\t '])(
+ 'coerces an empty/whitespace string %j to an empty object',
+ value => {
+ expect(normalizeToolArguments(value)).toEqual({});
+ }
+ );
+
+ it('throws a typed error when the string is not valid JSON', () => {
+ expect(() => normalizeToolArguments('{"to": "[email protected]"', 'GMAIL_SEND')).toThrow(
+ ComposioInvalidToolArgumentsError
+ );
+ try {
+ normalizeToolArguments('not json at all', 'GMAIL_SEND');
+ } catch (error) {
+ expect(error).toBeInstanceOf(ComposioInvalidToolArgumentsError);
+ expect((error as Error).message).toContain("Tool 'GMAIL_SEND'");
+ // The original SyntaxError is preserved as the cause for debugging.
+ expect((error as { cause?: unknown }).cause).toBeInstanceOf(SyntaxError);
+ }
+ });
+
+ it.each([
+ ['a JSON array string', '[1, 2, 3]'],
+ ['a JSON number string', '42'],
+ ['a JSON string literal', '"hello"'],
+ ])('throws when the parsed JSON %s is not an object', (_label, value) => {
+ expect(() => normalizeToolArguments(value)).toThrow(ComposioInvalidToolArgumentsError);
+ });
+
+ it.each([
+ ['an array', [1, 2, 3]],
+ ['a number', 42],
+ ['a boolean', true],
+ ])('throws when given %s directly', (_label, value) => {
+ expect(() => normalizeToolArguments(value)).toThrow(ComposioInvalidToolArgumentsError);
+ });
+
+ it('mentions the tool slug in the error message when provided', () => {
+ expect(() => normalizeToolArguments(42, 'SLACK_SEND_MESSAGE')).toThrow(
+ /Tool 'SLACK_SEND_MESSAGE'/
+ );
+ });
+
+ it('falls back to a generic label when no slug is provided', () => {
+ expect(() => normalizeToolArguments(42)).toThrow(/^.*\bTool expected arguments/);
+ });
+});
diff --git a/ts/packages/providers/anthropic/src/index.ts b/ts/packages/providers/anthropic/src/index.ts
index 29f11ea69..040c0dedb 100644
--- a/ts/packages/providers/anthropic/src/index.ts
+++ b/ts/packages/providers/anthropic/src/index.ts
@@ -15,6 +15,7 @@ import {
ToolExecuteParams,
logger,
McpUrlResponse,
+ normalizeToolArguments,
} from '@composio/core';
import Anthropic from '@anthropic-ai/sdk';
import { AnthropicTool, InputSchema } from './types';
@@ -211,7 +212,8 @@ export class AnthropicProvider extends BaseNonAgenticProvider<
modifiers?: ExecuteToolModifiers
): Promise<string> {
const payload: ToolExecuteParams = {
- arguments: toolUse.input,
+ // Models occasionally emit tool input as a JSON string rather than an object (issue #2406).
+ arguments: normalizeToolArguments(toolUse.input, toolUse.name),
connectedAccountId: options?.connectedAccountId,
customAuthParams: options?.customAuthParams,
customConnectionData: options?.customConnectionData,
diff --git a/ts/packages/providers/anthropic/test/anthropic.test.ts b/ts/packages/providers/anthropic/test/anthropic.test.ts
index a6edb0016..8414cb5ad 100644
--- a/ts/packages/providers/anthropic/test/anthropic.test.ts
+++ b/ts/packages/providers/anthropic/test/anthropic.test.ts
@@ -172,6 +172,37 @@ describe('AnthropicProvider', () => {
expect(result).toBe(JSON.stringify({ result: 'success' }));
});
+ it('should normalize a stringified-JSON input to an object before executing (issue #2406)', async () => {
+ const params = { input: 'test-value' };
+ const toolUse: AnthropicToolUseBlock = {
+ type: 'tool_use',
+ id: 'tu_123',
+ name: 'test-tool',
+ input: JSON.stringify(params) as unknown as Record<string, unknown>,
+ };
+
+ await provider.executeToolCall('test-user', toolUse);
+
+ expect(mockExecuteToolFn).toHaveBeenCalledWith(
+ 'test-tool',
+ expect.objectContaining({ arguments: params }),
+ undefined
+ );
+ });
+
+ it('should throw a typed error for a malformed-JSON string input (issue #2406)', async () => {
+ const toolUse: AnthropicToolUseBlock = {
+ type: 'tool_use',
+ id: 'tu_123',
+ name: 'test-tool',
+ input: '{"input":' as unknown as Record<string, unknown>,
+ };
+
+ await expect(provider.executeToolCall('test-user', toolUse)).rejects.toThrow(
+ /not valid JSON/
+ );
+ });
+
it('should pass options to executeTool', async () => {
const userId = 'test-user';
const toolUse: AnthropicToolUseBlock = {
diff --git a/ts/packages/providers/claude-agent-sdk/src/index.ts b/ts/packages/providers/claude-agent-sdk/src/index.ts
index 9c47a87f1..41750cd11 100644
--- a/ts/packages/providers/claude-agent-sdk/src/index.ts
+++ b/ts/packages/providers/claude-agent-sdk/src/index.ts
@@ -15,6 +15,7 @@ import {
McpUrlResponse,
McpServerGetResponse,
jsonSchemaToZodSchema,
+ normalizeToolArguments,
} from '@composio/core';
import {
tool as sdkTool,
@@ -114,7 +115,11 @@ export class ClaudeAgentSDKProvider extends BaseAgenticProvider<
inputZodShape,
async args => {
try {
- const result = await executeTool(composioTool.slug, args);
+ // Models occasionally emit tool input as a JSON string rather than an object (issue #2406).
+ const result = await executeTool(
+ composioTool.slug,
+ normalizeToolArguments(args, composioTool.slug)
+ );
return {
content: [
{
diff --git a/ts/packages/providers/claude-agent-sdk/test/claude-agent-sdk.test.ts b/ts/packages/providers/claude-agent-sdk/test/claude-agent-sdk.test.ts
index 9945cde0b..2ec1fb841 100644
--- a/ts/packages/providers/claude-agent-sdk/test/claude-agent-sdk.test.ts
+++ b/ts/packages/providers/claude-agent-sdk/test/claude-agent-sdk.test.ts
@@ -173,6 +173,29 @@ describe('ClaudeAgentSDKProvider', () => {
});
});
+ it('should normalize a stringified-JSON input to an object before executing (issue #2406)', async () => {
+ provider.wrapTool(mockTool, mockExecuteToolFn);
+ const handler = (tool as any).mock.calls[0][3];
+
+ const params = { to: '[email protected]', subject: 'Test', body: 'Hello' };
+ await handler(JSON.stringify(params));
+
+ expect(mockExecuteToolFn).toHaveBeenCalledWith(mockTool.slug, params);
+ });
+
+ it('should surface a typed error for a malformed-JSON string input (issue #2406)', async () => {
+ provider.wrapTool(mockTool, mockExecuteToolFn);
+ const handler = (tool as any).mock.calls[0][3];
+
+ const result = await handler('{"to":');
+
+ expect(mockExecuteToolFn).not.toHaveBeenCalled();
+ expect(JSON.parse(result.content[0].text)).toMatchObject({
+ successful: false,
+ error: expect.stringContaining('not valid JSON'),
+ });
+ });
+
it('should handle string results from tool execution', async () => {
mockExecuteToolFn.mockResolvedValueOnce('Simple string result');
provider.wrapTool(mockTool, mockExecuteToolFn);
diff --git a/ts/packages/providers/cloudflare/src/index.ts b/ts/packages/providers/cloudflare/src/index.ts
index 5de686bfe..b71687f99 100644
--- a/ts/packages/providers/cloudflare/src/index.ts
+++ b/ts/packages/providers/cloudflare/src/index.ts
@@ -18,6 +18,7 @@ import {
ExecuteToolFnOptions,
McpUrlResponse,
McpServerGetResponse,
+ normalizeToolArguments,
} from '@composio/core';
type AiToolCollection = Record<string, AiTextGenerationToolInput>;
@@ -230,7 +231,8 @@ export class CloudflareProvider extends BaseNonAgenticProvider<
modifiers?: ExecuteToolModifiers
): Promise<string> {
const payload: ToolExecuteParams = {
- arguments: typeof tool.arguments === 'string' ? JSON.parse(tool.arguments) : tool.arguments,
+ // Models occasionally emit tool arguments as a JSON string rather than an object (issue #2406).
+ arguments: normalizeToolArguments(tool.arguments, tool.name),
connectedAccountId: options.connectedAccountId,
customAuthParams: options.customAuthParams,
customConnectionData: options.customConnectionData,
diff --git a/ts/packages/providers/google/src/index.ts b/ts/packages/providers/google/src/index.ts
index d410e7854..77d65ebef 100644
--- a/ts/packages/providers/google/src/index.ts
+++ b/ts/packages/providers/google/src/index.ts
@@ -15,6 +15,7 @@ import {
ExecuteToolFnOptions,
McpUrlResponse,
McpServerGetResponse,
+ normalizeToolArguments,
} from '@composio/core';
import { FunctionDeclaration, Schema } from '@google/genai';
@@ -242,7 +243,8 @@ export class GoogleProvider extends BaseNonAgenticProvider<
modifiers?: ExecuteToolModifiers
): Promise<string> {
const payload: ToolExecuteParams = {
- arguments: tool.args,
+ // Models occasionally emit tool args as a JSON string rather than an object (issue #2406).
+ arguments: normalizeToolArguments(tool.args, tool.name),
connectedAccountId: options?.connectedAccountId,
customAuthParams: options?.customAuthParams,
customConnectionData: options?.customConnectionData,
diff --git a/ts/packages/providers/google/test/google.test.ts b/ts/packages/providers/google/test/google.test.ts
index d71e887a4..457498f33 100644
--- a/ts/packages/providers/google/test/google.test.ts
+++ b/ts/packages/providers/google/test/google.test.ts
@@ -157,6 +157,27 @@ describe('GoogleProvider', () => {
);
});
+ it('should normalize a stringified-JSON args into an object before executing (issue #2406)', async () => {
+ const args = { input: 'test-value' };
+ const toolCall = { name: 'test-tool', args: JSON.stringify(args) as unknown as object };
+
+ await provider.executeToolCall('test-user', toolCall);
+
+ expect(mockExecuteToolFn).toHaveBeenCalledWith(
+ 'test-tool',
+ expect.objectContaining({ arguments: args }),
+ undefined
+ );
+ });
+
+ it('should throw a typed error for malformed-JSON args (issue #2406)', async () => {
+ const toolCall = { name: 'test-tool', args: 'not json' as unknown as object };
+
+ await expect(provider.executeToolCall('test-user', toolCall)).rejects.toThrow(
+ /not valid JSON/
+ );
+ });
+
it('should pass options to executeTool', async () => {
const userId = 'test-user';
const toolCall = {
diff --git a/ts/packages/providers/langchain/src/index.ts b/ts/packages/providers/langchain/src/index.ts
index 25eef11ae..7f2ed509f 100644
--- a/ts/packages/providers/langchain/src/index.ts
+++ b/ts/packages/providers/langchain/src/index.ts
@@ -16,6 +16,7 @@ import {
ExecuteToolFn,
McpUrlResponse,
McpServerGetResponse,
+ normalizeToolArguments,
} from '@composio/core';
import { DynamicStructuredTool } from '@langchain/core/tools';
@@ -128,7 +129,8 @@ export class LangchainProvider extends BaseAgenticProvider<
throw new Error('App name is not defined');
}
const func = async (...args: unknown[]): Promise<unknown> => {
- const result = await executeTool(toolName, args[0] as Record<string, unknown>);
+ // Models occasionally emit tool input as a JSON string rather than an object (issue #2406).
+ const result = await executeTool(toolName, normalizeToolArguments(args[0], toolName));
return JSON.stringify(result);
};
if (!tool.inputParameters) {
diff --git a/ts/packages/providers/langchain/test/langchain.test.ts b/ts/packages/providers/langchain/test/langchain.test.ts
index bd7764d09..1446fc719 100644
--- a/ts/packages/providers/langchain/test/langchain.test.ts
+++ b/ts/packages/providers/langchain/test/langchain.test.ts
@@ -154,5 +154,25 @@ describe('LangchainProvider', () => {
expect(typeof result).toBe('string');
expect(() => JSON.parse(result as string)).not.toThrow();
});
+
+ it('should normalize a stringified-JSON input to an object before executing (issue #2406)', async () => {
+ const wrappedTool = provider.wrapTool(sampleTool, executeToolFn);
+
+ const result = await wrappedTool.func(
+ JSON.stringify({ query: 'test query' }) as unknown as Record<string, unknown>
+ );
+
+ // The mock echoes back the params it received; confirm it saw a parsed object.
+ expect(executeToolFn).toHaveBeenCalledWith(sampleTool.slug, { query: 'test query' });
+ expect(JSON.parse(result as string).data.params).toEqual({ query: 'test query' });
+ });
+
+ it('should throw a typed error for a malformed-JSON string input (issue #2406)', async () => {
+ const wrappedTool = provider.wrapTool(sampleTool, executeToolFn);
+
+ await expect(
+ wrappedTool.func('{"query":' as unknown as Record<string, unknown>)
+ ).rejects.toThrow(/not valid JSON/);
+ });
});
});
diff --git a/ts/packages/providers/llamaindex/src/index.ts b/ts/packages/providers/llamaindex/src/index.ts
index 1cddb008b..fe515158c 100644
--- a/ts/packages/providers/llamaindex/src/index.ts
+++ b/ts/packages/providers/llamaindex/src/index.ts
@@ -13,6 +13,7 @@ import {
McpServerGetResponse,
McpUrlResponse,
jsonSchemaToZodSchema,
+ normalizeToolArguments,
} from '@composio/core';
import { tool as createLlamaindexTool, JSONValue } from 'llamaindex';
@@ -39,7 +40,8 @@ export class LlamaindexProvider extends BaseAgenticProvider<
description: tool.description ?? tool.name ?? '',
parameters: inputParametersSchema,
execute: async input => {
- const result = await executeTool(tool.slug, input as Record<string, unknown>);
+ // Models occasionally emit tool input as a JSON string rather than an object (issue #2406).
+ const result = await executeTool(tool.slug, normalizeToolArguments(input, tool.slug));
return JSON.stringify(result);
},
});
diff --git a/ts/packages/providers/llamaindex/test/llamaindex.test.ts b/ts/packages/providers/llamaindex/test/llamaindex.test.ts
index 6f85954fc..99f8d9211 100644
--- a/ts/packages/providers/llamaindex/test/llamaindex.test.ts
+++ b/ts/packages/providers/llamaindex/test/llamaindex.test.ts
@@ -209,6 +209,25 @@ describe('LlamaindexProvider', () => {
await expect(wrappedTool.call({ query: 'test' })).rejects.toThrow('Tool execution failed');
});
+
+ it('should normalize a stringified-JSON input to an object before executing (issue #2406)', async () => {
+ const wrappedTool = provider.wrapTool(sampleTool, executeToolFn);
+
+ const result = await wrappedTool.call(
+ JSON.stringify({ query: 'test query' }) as unknown as Record<string, unknown>
+ );
+
+ expect(executeToolFn).toHaveBeenCalledWith(sampleTool.slug, { query: 'test query' });
+ expect(JSON.parse(result as string).data.params).toEqual({ query: 'test query' });
+ });
+
+ it('should throw a typed error for a malformed-JSON string input (issue #2406)', async () => {
+ const wrappedTool = provider.wrapTool(sampleTool, executeToolFn);
+
+ await expect(
+ wrappedTool.call('{"query":' as unknown as Record<string, unknown>)
+ ).rejects.toThrow(/not valid JSON/);
+ });
});
describe('MCP Server Response Transformation', () => {
diff --git a/ts/packages/providers/mastra/src/index.ts b/ts/packages/providers/mastra/src/index.ts
index 1404d05a2..08be5946a 100644
--- a/ts/packages/providers/mastra/src/index.ts
+++ b/ts/packages/providers/mastra/src/index.ts
@@ -16,6 +16,7 @@ import {
removeNonRequiredProperties,
telemetry,
type UnresolvedRefReason,
+ normalizeToolArguments,
} from '@composio/core';
import { applyCompatLayer } from '@mastra/schema-compat';
import { createTool } from '@mastra/core/tools';
@@ -141,7 +142,8 @@ export class MastraProvider extends BaseAgenticProvider<
// @ts-ignore
outputSchema,
execute: async (inputData, _context) => {
- const result = await executeTool(tool.slug, inputData as Record<string, unknown>);
+ // Models occasionally emit tool input as a JSON string rather than an object (issue #2406).
+ const result = await executeTool(tool.slug, normalizeToolArguments(inputData, tool.slug));
return result;
},
});
diff --git a/ts/packages/providers/mastra/test/mastra.test.ts b/ts/packages/providers/mastra/test/mastra.test.ts
index 3804335ed..a28b925e9 100644
--- a/ts/packages/providers/mastra/test/mastra.test.ts
+++ b/ts/packages/providers/mastra/test/mastra.test.ts
@@ -120,6 +120,24 @@ describe('MastraProvider', () => {
expect(wrapped._isMockedMastraTool).toBe(true);
});
+ it('should normalize a stringified-JSON input to an object before executing (issue #2406)', async () => {
+ const wrapped = provider.wrapTool(mockTool, mockExecuteToolFn) as unknown as MockedMastraTool;
+ const params = { input: 'test-value' };
+
+ await wrapped.execute(params, {});
+ expect(mockExecuteToolFn).toHaveBeenCalledWith(mockTool.slug, params);
+
+ vi.clearAllMocks();
+ await wrapped.execute(JSON.stringify(params), {});
+ expect(mockExecuteToolFn).toHaveBeenCalledWith(mockTool.slug, params);
+ });
+
+ it('should throw a typed error for a malformed-JSON string input (issue #2406)', async () => {
+ const wrapped = provider.wrapTool(mockTool, mockExecuteToolFn) as unknown as MockedMastraTool;
+
+ await expect(wrapped.execute('{"input":', {})).rejects.toThrow(/not valid JSON/);
+ });
+
it('should handle tools without input parameters', () => {
const toolWithoutInputParams: Tool = {
...mockTool,
@@ -255,10 +273,11 @@ describe('MastraProvider', () => {
// Extract the execute function from the call to createTool()
const executeFunction = (createTool as any).mock.calls[0][0].execute;
- // Test the execute function without any parameters
+ // Test the execute function without any parameters: a missing payload is
+ // normalized to an empty object rather than forwarded as undefined (issue #2406).
const result = await executeFunction(undefined);
- expect(mockExecuteToolFn).toHaveBeenCalledWith(mockTool.slug, undefined);
+ expect(mockExecuteToolFn).toHaveBeenCalledWith(mockTool.slug, {});
expect(result).toEqual({
data: { result: 'success' },
error: null,
diff --git a/ts/packages/providers/openai-agents/src/index.ts b/ts/packages/providers/openai-agents/src/index.ts
index 930fdacd0..8a50a179c 100644
--- a/ts/packages/providers/openai-agents/src/index.ts
+++ b/ts/packages/providers/openai-agents/src/index.ts
@@ -16,6 +16,7 @@ import {
ExecuteToolFn,
McpUrlResponse,
McpServerGetResponse,
+ normalizeToolArguments,
} from '@composio/core';
import type { Tool as OpenAIAgentTool } from '@openai/agents';
import { tool as createOpenAIAgentTool } from '@openai/agents';
@@ -132,8 +133,11 @@ export class OpenAIAgentsProvider extends BaseAgenticProvider<
},
strict: false,
execute: async params => {
- const input = typeof params === 'string' ? JSON.parse(params) : params;
- return await executeTool(composioTool.slug, input);
+ // Models occasionally emit tool input as a JSON string rather than an object (issue #2406).
+ return await executeTool(
+ composioTool.slug,
+ normalizeToolArguments(params, composioTool.slug)
+ );
},
});
}
diff --git a/ts/packages/providers/openai-agents/test/openai-agents.test.ts b/ts/packages/providers/openai-agents/test/openai-agents.test.ts
index 1b9362f71..a406d036c 100644
--- a/ts/packages/providers/openai-agents/test/openai-agents.test.ts
+++ b/ts/packages/providers/openai-agents/test/openai-agents.test.ts
@@ -112,6 +112,30 @@ describe('OpenAIAgentsProvider', () => {
expect(wrapped._isMockedOpenAIAgentTool).toBe(true);
});
+
+ it('should normalize a stringified-JSON input to an object before executing (issue #2406)', async () => {
+ const wrapped = provider.wrapTool(
+ mockTool,
+ mockExecuteToolFn
+ ) as unknown as MockedOpenAIAgentTool;
+ const params = { input: 'test-value' };
+
+ await wrapped.execute(params);
+ expect(mockExecuteToolFn).toHaveBeenCalledWith(mockTool.slug, params);
+
+ vi.clearAllMocks();
+ await wrapped.execute(JSON.stringify(params));
+ expect(mockExecuteToolFn).toHaveBeenCalledWith(mockTool.slug, params);
+ });
+
+ it('should throw a typed error for a malformed-JSON string input (issue #2406)', async () => {
+ const wrapped = provider.wrapTool(
+ mockTool,
+ mockExecuteToolFn
+ ) as unknown as MockedOpenAIAgentTool;
+
+ await expect(wrapped.execute('{"input":')).rejects.toThrow(/not valid JSON/);
+ });
});
describe('wrapTools', () => {
diff --git a/ts/packages/providers/openai/src/OpenAIResponsesProvider.ts b/ts/packages/providers/openai/src/OpenAIResponsesProvider.ts
index ae1e0ab97..57092a3f6 100644
--- a/ts/packages/providers/openai/src/OpenAIResponsesProvider.ts
+++ b/ts/packages/providers/openai/src/OpenAIResponsesProvider.ts
@@ -18,6 +18,7 @@ import {
ExecuteToolFnOptions,
removeNonRequiredProperties,
McpUrlResponse,
+ normalizeToolArguments,
} from '@composio/core';
export type OpenAiTool = OpenAI.Responses.FunctionTool;
@@ -221,7 +222,9 @@ export class OpenAIResponsesProvider extends BaseNonAgenticProvider<
modifiers?: ExecuteToolModifiers
): Promise<string> {
const payload: ToolExecuteParams = {
- arguments: JSON.parse(tool.arguments),
+ // OpenAI always serializes tool arguments as a JSON string; normalize tolerates
+ // empty / object-shaped payloads too (issue #2406).
+ arguments: normalizeToolArguments(tool.arguments, tool.name),
connectedAccountId: options?.connectedAccountId,
customAuthParams: options?.customAuthParams,
customConnectionData: options?.customConnectionData,
diff --git a/ts/packages/providers/openai/test/opeanai-responses.test.ts b/ts/packages/providers/openai/test/opeanai-responses.test.ts
index a1fa67e62..10cfa0afc 100644
--- a/ts/packages/providers/openai/test/opeanai-responses.test.ts
+++ b/ts/packages/providers/openai/test/opeanai-responses.test.ts
@@ -181,6 +181,24 @@ describe('OpenAIResponsesProvider', () => {
);
});
+ it('should coerce empty-string arguments to an empty object (issue #2406)', async () => {
+ const toolCall = {
+ id: 'call-123',
+ type: 'function',
+ name: 'test-tool',
+ arguments: '',
+ call_id: 'call-123',
+ } as unknown as OpenAI.Responses.ResponseFunctionToolCall;
+
+ await provider.executeToolCall('test-user', toolCall);
+
+ expect(mockExecuteToolFn).toHaveBeenCalledWith(
+ 'test-tool',
+ expect.objectContaining({ arguments: {} }),
+ undefined
+ );
+ });
+
it('should pass options to executeTool', async () => {
const userId = 'test-user';
const toolCall = {
diff --git a/ts/packages/providers/vercel/src/index.ts b/ts/packages/providers/vercel/src/index.ts
index 52ae0ec9b..774d6b5d9 100644
--- a/ts/packages/providers/vercel/src/index.ts
+++ b/ts/packages/providers/vercel/src/index.ts
@@ -18,6 +18,7 @@ import {
McpServerGetResponse,
removeNonRequiredProperties,
jsonSchemaToZodSchema,
+ normalizeToolArguments,
} from '@composio/core';
import type { ToolSet as VercelToolSet, Tool as VercelTool } from 'ai';
import { tool } from 'ai';
@@ -126,8 +127,11 @@ export class VercelProvider extends BaseAgenticProvider<
inputSchema: inputParametersSchema,
execute: async params => {
- const input = typeof params === 'string' ? JSON.parse(params) : params;
- return await executeTool(composioTool.slug, input);
+ // Models occasionally emit tool input as a JSON string rather than an object (issue #2406).
+ return await executeTool(
+ composioTool.slug,
+ normalizeToolArguments(params, composioTool.slug)
+ );
},
});
}