Composio powers 1000+ toolkits, tool search, context management, authentication, and a sandboxed workbench to help you build AI agents that turn intent into action.
docs(changesets): explain each behavior change with a before and after
jkomyno committed
Aug 6, 2026 at 22:50 UTC
063f03a72f6603c45896c2f96133cc9078b0bbfa
3 files changed
+96
-5
.changeset/claude-agent-sdk-complete-schema-registration.md
+35
-3
@@ -2,8 +2,40 @@
2
'@composio/claude-agent-sdk': minor
3
---
4
5
-Register tools with their complete Zod object schema instead of a raw property shape, so root-level constraints survive registration.
5
+Register each tool with its complete schema, so root rules reach the Claude Agent SDK.
6
7
-A raw shape is only the per-property map, so `additionalProperties` — boolean or schema-valued — and `patternProperties` were structurally unrepresentable and dropped before the Claude Agent SDK ever saw them. Free-form object arguments lost the content they exist to carry, and unknown keys were silently stripped from tool input rather than rejected.
7
+The provider used to register a raw property shape. A raw shape is only the map of named properties, so it cannot carry any root rule. `additionalProperties` and `patternProperties` were dropped before the SDK saw them.
8
9
-Behavior change: a tool whose schema names properties and omits `additionalProperties` is strict, so an argument the model invents now fails validation with an MCP invalid-params error instead of being quietly removed before execution. Tools with no input parameters stay closed for the same reason.
9
+Two things went wrong because of that. Free-form object arguments lost their content. An argument the tool never declared was quietly removed, and the tool ran anyway.
10
+
11
+Both are fixed. The provider now registers the whole object schema.
12
+
13
+**What no longer works**
14
+
15
+An undeclared argument no longer passes silently.
16
+
17
+```ts
18
+// The tool declares `to` and nothing else. The model also sends `hallucinated`.
19
+{ to: 'someone@example.com', hallucinated: 'value' }
20
+
21
+// before: `hallucinated` was stripped, and the tool ran with { to: '...' }
22
+// now: the call is rejected with an MCP invalid-params error (-32602)
23
+```
24
+
25
+Tools with no input parameters behave the same way. They stay closed and reject every argument.
26
+
27
+**What to do instead**
28
+
29
+If the model should be allowed to send extra keys, say so in the tool schema:
30
+
31
+```json
32
+{
33
+ "type": "object",
34
+ "properties": { "to": { "type": "string" } },
35
+ "additionalProperties": true
36
+}
37
+```
38
+
39
+If an argument is one the tool really accepts, declare it in `properties`. Rejection is usually the better outcome, because the agent sees the error and can correct itself instead of running with a silently dropped argument.
40
+
41
+This brings the provider in line with `@composio/vercel`, `@composio/langchain`, and `@composio/llamaindex`, which already registered complete schemas.
.changeset/fix-property-less-object-conversion.md
+29
-1
@@ -2,4 +2,32 @@
2
'@composio/json-schema-to-zod': minor
3
---
4
5
-Accept and preserve arbitrary content in property-less objects (`{ type: "object" }` or `properties: {}`) at root, nested, and array-item positions, instead of collapsing them to a strict empty object. Dynamic keys are also routed correctly: every matching `patternProperties` entry validates its key, and a schema-valued `additionalProperties` applies only to keys no property or pattern claims.
5
+Keep the content of free-form object arguments, and apply dynamic key rules only where they belong.
6
+
7
+An object schema with no named properties, written as `{ "type": "object" }` or `{ "properties": {} }`, used to become a strict empty object. The only value that passed was `{}`. Any real payload was rejected. Such an object is now open, so arbitrary content is accepted and preserved. This works at the root, nested inside another object, and inside array items.
8
+
9
+Dynamic keys are now routed to the schemas that actually claim them. Every matching `patternProperties` entry validates its key. A schema-valued `additionalProperties` applies only to keys that no declared property and no pattern matches. Before this change a key could pass by satisfying an unrelated pattern instead of its own.
10
+
11
+**What no longer works**
12
+
13
+Converting a property-less object no longer gives you a schema that rejects everything.
14
+
15
+```ts
16
+const schema = jsonSchemaToZod({ type: 'object' });
17
+
18
+schema.parse({ anything: 1 });
19
+// before: threw, because the result was z.object({}).strict()
20
+// now: returns { anything: 1 }
21
+```
22
+
23
+**What to do instead**
24
+
25
+If you want a property-less object to stay closed, say so in the JSON Schema:
26
+
27
+```ts
28
+const schema = jsonSchemaToZod({ type: 'object', additionalProperties: false });
29
+
30
+schema.parse({ anything: 1 }); // throws, as before
31
+```
32
+
33
+Objects that name at least one property are unchanged. They still reject unknown keys when `additionalProperties` is omitted.
.changeset/preserve-root-dynamic-key-constraints.md
+32
-1
@@ -2,4 +2,35 @@
2
'@composio/core': minor
3
---
4
5
-Preserve root `patternProperties` and boolean- or schema-valued `additionalProperties` when parsing tool parameters. `ToolSchema.parse` previously stripped `patternProperties` as an unknown key and rejected a schema-valued `additionalProperties` outright, so both dynamic-key constraints were lost before any converter could see them.
5
+Keep root `patternProperties` and `additionalProperties` when parsing a tool schema.
6
+
7
+`ToolSchema.parse` used to drop root `patternProperties` as an unknown key, and it rejected a root `additionalProperties` written as a schema instead of a boolean. Both constraints were lost before any converter or provider could read them. They now survive parsing exactly as written.
8
+
9
+This matters downstream. Every provider reads `inputParameters` after parsing, so a tool that declares dynamic keys had those rules stripped before the model ever saw them.
10
+
11
+An omitted `additionalProperties` still stays omitted. The parser does not invent a value, because each converter decides its own default.
12
+
13
+**What no longer works**
14
+
15
+Parsing no longer fails on a schema-valued root `additionalProperties`.
16
+
17
+```ts
18
+const tool = ToolSchema.parse({
19
+ slug: 'MY_TOOL',
20
+ inputParameters: {
21
+ type: 'object',
22
+ properties: { name: { type: 'string' } },
23
+ additionalProperties: { type: 'number' },
24
+ },
25
+ // ...
26
+});
27
+
28
+// before: parsing failed, because only a boolean was accepted
29
+// now: tool.inputParameters.additionalProperties is { type: 'number' }
30
+```
31
+
32
+**What to do instead**
33
+
34
+Nothing, if you only ever passed boolean values. That case is unchanged.
35
+
36
+If your code assumed `inputParameters` never carries `patternProperties`, or that `additionalProperties` is always a boolean, widen that assumption. Both keywords can now appear, and `additionalProperties` can be a boolean or a schema object.