fix: repair anyOf tool schemas rejected by the Kimi wire

Kimi rejects a tool whose parameters declare `anyOf` next to `type`, and
also rejects a validation keyword appearing on both a node and its `anyOf`
branches. TaskStop hits both: it adds a hand-written root `anyOf` to an
object schema, so every request carrying it failed with a 400 before the
model ever ran.

Repair the shape where all tools converge instead of at the one call site,
so MCP- and plugin-contributed schemas are covered too:

- Nested nodes distribute their own constraints into each branch, which
  accepts exactly the same instances as before.
- The root instead drops its `anyOf`. A tool's parameters must be an
  object, and the wire demands `type: "object"` there, so the branch form
  is unsatisfiable at that position; branch properties are merged up first
  so a tool cannot lose its arguments.

Verified by replaying every builtin and connected MCP tool schema through
the provider's own validator.

Author: elkaix

.changeset/kimi-anyof-tool-schema.md

@@ -0,0 +1,5 @@
+---
+"@pythoughts/pythinker-code": patch
+---
+
+Fix Kimi and Moonshot models rejecting every request with an invalid tool schema error when a tool declares `anyOf` alongside its own type or properties.

packages/kosong/src/providers/pythinker-schema.ts

@@ -117,7 +117,8 @@ const NUMERIC_STRUCTURE_KEYS = new Set([
  * it resolves local refs, preserves combinator nodes, infers obvious
  * scalar/object/array types, and falls back to `string` only for nested
  * typeless property schemas. The root schema object is treated as a container
- * and is not itself normalized.
+ * and is not itself type-normalized, with one exception: an `anyOf` at the root
+ * is folded away, because a tool's parameters must be a plain object.
  */
 export function normalizePythinkerToolSchema(schema: Record<string, unknown>): Record<string, unknown> {
   return ensurePythinkerPropertyTypes(derefJsonSchema(schema));
@@ -128,10 +129,52 @@ function ensurePythinkerPropertyTypes(schema: Record<string, unknown>): Record<s
   if (!isRecord(normalized)) {
     throw new Error('JSON Schema root must normalize to an object.');
   }
+  // Fold the root's `anyOf` away before recursing; once it is gone the generic
+  // per-node distribution below sees nothing to do at the root.
+  foldRootAnyOf(normalized);
   recurseSchema(normalized);
   return normalized;
 }
 
+/**
+ * Remove an `anyOf` sitting at the root of a tool's parameter schema.
+ *
+ * A tool's parameters must be an object, so the root cannot use the branch form
+ * that {@link distributeAnyOfParentKeywords} produces for every other node: the
+ * wire requires `type: "object"` there, and rejects `type` next to `anyOf`. The
+ * two constraints are jointly unsatisfiable, so the root's `anyOf` is dropped.
+ *
+ * Dropping only ever widens what the schema accepts — a root `anyOf` is almost
+ * always a "one of these fields is required" hint, which the tool re-checks when
+ * it runs. Branch properties are folded into the root first, so a schema that
+ * kept its arguments inside the branches does not lose them.
+ */
+function foldRootAnyOf(root: Record<string, unknown>): void {
+  const branches = root['anyOf'];
+  if (!Array.isArray(branches) || !branches.every(isRecord)) {
+    return;
+  }
+  delete root['anyOf'];
+
+  const rootProperties = root['properties'];
+  const merged: Record<string, unknown> = isRecord(rootProperties)
+    ? rootProperties
+    : {};
+  for (const branch of branches) {
+    const branchProperties = branch['properties'];
+    if (!isRecord(branchProperties)) continue;
+    for (const [name, property] of Object.entries(branchProperties)) {
+      if (!hasOwn(merged, name)) {
+        merged[name] = cloneJsonValue(property);
+      }
+    }
+  }
+  if (Object.keys(merged).length > 0) {
+    root['properties'] = merged;
+  }
+  root['type'] = 'object';
+}
+
 function hasUnresolvedDefinitionRef(node: unknown, bucketKey: string): boolean {
   if (Array.isArray(node)) {
     return node.some((child) => hasUnresolvedDefinitionRef(child, bucketKey));
@@ -252,9 +295,74 @@ function recurseSchema(node: unknown): void {
     return;
   }
 
+  distributeAnyOfParentKeywords(node);
   visitChildSchemas(node, normalizeProperty);
 }
 
+/**
+ * Keywords that may stay on a schema node that also carries `anyOf`.
+ *
+ * Everything else is a validation keyword the wire validator refuses to see on
+ * both sides of an `anyOf`. Sibling combinators are left alone because the
+ * validator does not read them at all, so relocating them would only churn the
+ * schema. `$defs` / `definitions` stay put because cyclic `$ref` pointers
+ * resolve against the root, and `$ref` stays because duplicating a cyclic
+ * reference into every branch changes its meaning.
+ */
+const ANYOF_PARENT_KEEP_KEYS = new Set([
+  '$comment',
+  '$defs',
+  '$ref',
+  '$schema',
+  'allOf',
+  'anyOf',
+  'default',
+  'definitions',
+  'description',
+  'else',
+  'if',
+  'not',
+  'oneOf',
+  'then',
+  'title',
+]);
+
+/**
+ * Push a node's own constraints down into its `anyOf` branches.
+ *
+ * Pythoughts's tool validator rejects `anyOf` used as a refinement of its parent:
+ * `type` must be declared inside the branches rather than beside them, and no
+ * other validation keyword (`properties`, `items`, `additionalProperties`, …)
+ * may appear on both the parent and a branch. Standard JSON Schema allows both,
+ * so schemas that are perfectly valid elsewhere are rejected on this wire.
+ *
+ * Distributing is lossless: `P ∧ (B₁ ∨ B₂)` and `(P ∧ B₁) ∨ (P ∧ B₂)` accept
+ * exactly the same instances. A branch that already declares a keyword keeps
+ * its own, which is the narrower of the two.
+ */
+function distributeAnyOfParentKeywords(node: Record<string, unknown>): void {
+  const branches = node['anyOf'];
+  if (!Array.isArray(branches) || branches.length === 0 || !branches.every(isRecord)) {
+    return;
+  }
+
+  const inherited = Object.keys(node).filter((key) => !ANYOF_PARENT_KEEP_KEYS.has(key));
+  if (inherited.length === 0) {
+    return;
+  }
+
+  for (const branch of branches) {
+    for (const key of inherited) {
+      if (!hasOwn(branch, key)) {
+        branch[key] = cloneJsonValue(node[key]);
+      }
+    }
+  }
+  for (const key of inherited) {
+    delete node[key];
+  }
+}
+
 function visitChildSchemas(node: Record<string, unknown>, visit: (schema: unknown) => void): void {
   for (const { key, kind } of CHILD_SCHEMA_SLOTS) {
     const value = node[key];

packages/kosong/test/providers/pythinker-schema.test.ts

@@ -570,6 +570,106 @@ describe('normalizePythinkerToolSchema', () => {
     expect(normalizePythinkerToolSchema({})).toEqual({});
   });
 
+  it('drops a root anyOf that refines the root itself', () => {
+    // The TaskStop shape: `anyOf` says "one of these two fields is required".
+    // A tool's parameters must stay an object, so the branch form is unusable
+    // here and the requirement falls back to the tool's own runtime check.
+    const properties = {
+      task_id: { type: 'string' },
+      shell_id: { type: 'string' },
+    };
+
+    const result = normalizePythinkerToolSchema({
+      type: 'object',
+      description: 'Root doc.',
+      properties,
+      additionalProperties: false,
+      anyOf: [{ required: ['task_id'] }, { required: ['shell_id'] }],
+    });
+
+    expect(result).toEqual({
+      type: 'object',
+      description: 'Root doc.',
+      properties,
+      additionalProperties: false,
+    });
+  });
+
+  it('keeps the arguments of a root anyOf whose branches hold the properties', () => {
+    const result = normalizePythinkerToolSchema({
+      anyOf: [
+        { type: 'object', properties: { task_id: { type: 'string' } }, required: ['task_id'] },
+        { type: 'object', properties: { shell_id: { type: 'string' } }, required: ['shell_id'] },
+      ],
+    });
+
+    expect(result).toEqual({
+      type: 'object',
+      properties: {
+        task_id: { type: 'string' },
+        shell_id: { type: 'string' },
+      },
+    });
+  });
+
+  it('distributes into nested anyOf nodes and keeps narrower branch keywords', () => {
+    const result = normalizePythinkerToolSchema({
+      type: 'object',
+      properties: {
+        target: {
+          type: 'array',
+          items: { type: 'string' },
+          anyOf: [{ minItems: 1 }, { items: { type: 'integer' } }],
+        },
+      },
+    });
+
+    expect(result).toEqual({
+      type: 'object',
+      properties: {
+        target: {
+          anyOf: [
+            { type: 'array', items: { type: 'string' }, minItems: 1 },
+            { type: 'array', items: { type: 'integer' } },
+          ],
+        },
+      },
+    });
+  });
+
+  it('leaves anyOf nodes alone when the parent only carries metadata', () => {
+    const schema = {
+      type: 'object',
+      properties: {
+        qs: {
+          description: 'A query, or a list of them.',
+          anyOf: [{ type: 'string' }, { type: 'array', items: { type: 'string' } }],
+        },
+      },
+    };
+
+    expect(normalizePythinkerToolSchema(schema)).toEqual(schema);
+  });
+
+  it('keeps cyclic $ref and definition buckets on the parent of an anyOf', () => {
+    const result = normalizePythinkerToolSchema({
+      type: 'object',
+      properties: {
+        node: {
+          anyOf: [{ $ref: '#/$defs/Node' }, { type: 'null' }],
+        },
+      },
+      $defs: {
+        Node: {
+          type: 'object',
+          properties: { next: { $ref: '#/$defs/Node' } },
+        },
+      },
+    });
+
+    expect(result['$defs']).toBeDefined();
+  });
+
   it('dereferences and normalizes local definition buckets', () => {
     const schema = {
       type: 'object',
@@ -755,42 +855,48 @@ describe('normalizePythinkerToolSchema', () => {
 
   it('preserves combinators while normalizing their schema branches', () => {
     const schema = {
-      anyOf: [{ enum: ['auto', 'manual'] }, { const: false }],
-      oneOf: [
-        {
-          properties: {
-            strategy: { enum: ['replace', 'insert'] },
-          },
-        },
-      ],
-      allOf: [
-        {
-          items: { const: 1 },
+      properties: {
+        combined: {
+          anyOf: [{ enum: ['auto', 'manual'] }, { const: false }],
+          oneOf: [
+            {
+              properties: {
+                strategy: { enum: ['replace', 'insert'] },
+              },
+            },
+          ],
+          allOf: [
+            {
+              items: { const: 1 },
+            },
+          ],
         },
-      ],
+      },
     };
 
     const result = normalizePythinkerToolSchema(schema);
 
-    expect(result).toEqual({
-      anyOf: [
-        { enum: ['auto', 'manual'], type: 'string' },
-        { const: false, type: 'boolean' },
-      ],
-      oneOf: [
-        {
-          type: 'object',
-          properties: {
-            strategy: { enum: ['replace', 'insert'], type: 'string' },
+    expect(result['properties']).toEqual({
+      combined: {
+        anyOf: [
+          { enum: ['auto', 'manual'], type: 'string' },
+          { const: false, type: 'boolean' },
+        ],
+        oneOf: [
+          {
+            type: 'object',
+            properties: {
+              strategy: { enum: ['replace', 'insert'], type: 'string' },
+            },
           },
-        },
-      ],
-      allOf: [
-        {
-          type: 'array',
-          items: { const: 1, type: 'integer' },
-        },
-      ],
+        ],
+        allOf: [
+          {
+            type: 'array',
+            items: { const: 1, type: 'integer' },
+          },
+        ],
+      },
     });
     expect(result).not.toHaveProperty('type');
   });