Composio powers 1000+ toolkits, tool search, context management, authentication, and a sandboxed workbench to help you build AI agents that turn intent into action.
TypeScript agentic-aiagentsaiai-agentsaiagentsdeveloper-toolsfunction-callinggpt-4javascriptjsllmllmopsmcppythonremote-mcp-serverssetypescript
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.mdnew file mode 100644index 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.pyindex 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 FunctionParametersfrom composio.core.provider import NonAgenticProviderfrom composio.types import Modifiers, Tool, ToolExecutionResponse+from composio.utils.shared import normalize_tool_argumentsOpenAITool: t.TypeAlias = ChatCompletionToolParamOpenAIToolCollection: 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.pyindex 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 jsonimport typing as tfrom openai.types.responses.response import Response@@ -12,6 +11,7 @@ from openai.types.responses.response_output_item import ResponseFunctionToolCallfrom composio.core.provider import NonAgenticProviderfrom composio.types import Modifiers, Tool, ToolExecutionResponse+from composio.utils.shared import normalize_tool_arguments# Responses API uses a flattened tool structureResponsesTool = 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.pyindex f9ebb618b..6509905ac 100644--- a/python/composio/utils/shared.py+++ b/python/composio/utils/shared.py@@ -3,6 +3,7 @@ Shared utils."""import copy+import jsonimport keywordimport typing as timport uuid@@ -11,6 +12,7 @@ from inspect import Parameterfrom pydantic import BaseModel, Field, create_modelfrom pydantic.fields import FieldInfo+from composio.exceptions import InvalidParamsfrom composio.utils.logging import get as get_loggerfrom 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.pyindex 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 ToolUseBlockfrom composio.core.provider import NonAgenticProviderfrom composio.types import Modifiers, Tool, ToolExecutionResponse+from composio.utils.shared import normalize_tool_argumentsclass 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.pyindex 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 AgenticProviderfrom composio.core.provider.agentic import AgenticProviderExecuteFnfrom 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 signaturefunction = 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.pyindex 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 AgenticProviderfrom composio.core.provider.agentic import AgenticProviderExecuteFnfrom composio.types import Tool+from composio.utils.shared import normalize_tool_argumentsclass 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 SDKresult_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.pyindex 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 BaseToolfrom composio.core.provider import AgenticProvider, AgenticProviderExecuteFnfrom composio.types import Toolfrom 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_argumentsclass 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.pyindex 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 AgenticProviderfrom composio.core.provider.agentic import AgenticProviderExecuteFnfrom 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="geminikwargs = 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="geminiif 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.pyindex 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 NonAgenticProviderfrom composio.types import Modifiers, Tool, ToolExecutionResponse+from composio.utils.shared import normalize_tool_argumentsdef _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.pyindex 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 Toolfrom composio.core.provider import AgenticProviderfrom composio.core.provider.agentic import AgenticProviderExecuteFnfrom composio.utils.openapi import function_signature_from_jsonschema+from composio.utils.shared import normalize_tool_argumentsclass 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.pyindex 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_errorfrom 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.pyindex 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_errorfrom 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.pyindex 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, AgenticProviderExecuteFnfrom composio.types import Toolfrom 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.pyindex 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 AgenticProviderfrom composio.core.provider.agentic import AgenticProviderExecuteFnfrom composio.types import Toolfrom 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 asyncexecute_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.pynew file mode 100644index 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.tsindex 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.tsindex 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.tsindex 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.tsnew file mode 100644index 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.tsindex 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.tsnew file mode 100644index 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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-ignoreoutputSchema,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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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)+ );},});}