fix(kimi): add missing required arrays to tool schemas

.changeset/fix-kimi-required-arrays.md

@@ -0,0 +1,5 @@
+---
+"@moonshot-ai/kimi-code": patch
+---
+
+Fix Kimi-compatible APIs rejecting tool schemas whose object nodes omit required arrays.

packages/agent-core-v2/src/kosong/provider/providers/kimi/kimi-schema.ts

@@ -2,8 +2,9 @@
  * `kosong/provider` domain (L2) — Kimi tool-schema dialect normalization.
  *
  * Pure functions: dereference local `$ref` pointers by inlining definitions,
- * then complete missing `type` fields from enum/const values or structural
- * keys — the schema dialect the Kimi tool endpoint accepts.
+ * complete missing `type` fields from enum/const values or structural keys,
+ * and add missing `required` arrays to object nodes — the schema dialect the
+ * Kimi tool endpoint accepts.
  *
  * Circular references are detected and left as `$ref` to avoid infinite
  * recursion; in that case the referenced definition bucket is preserved so the
@@ -227,6 +228,10 @@ function recurseSchema(node: unknown): void {
     return;
   }
 
+  if (node['type'] === 'object' && !hasOwn(node, 'required')) {
+    node['required'] = [];
+  }
+
   visitChildSchemas(node, normalizeProperty);
 }
 

packages/agent-core-v2/test/kosong/provider/kimi.test.ts

@@ -69,6 +69,44 @@ describe('kimiOpenAITrait.convertTool', () => {
       },
     });
   });
+
+  it('adds required arrays to root and nested object schemas', () => {
+    const tool: Tool = {
+      name: 'read_file',
+      description: 'read',
+      parameters: {
+        type: 'object',
+        properties: {
+          options: {
+            type: 'object',
+            properties: { encoding: { type: 'string' } },
+          },
+          path: { type: 'string' },
+        },
+        required: ['path'],
+      },
+    };
+
+    expect(convertKimiTool(tool)).toEqual({
+      type: 'function',
+      function: {
+        name: 'read_file',
+        description: 'read',
+        parameters: {
+          type: 'object',
+          properties: {
+            options: {
+              type: 'object',
+              properties: { encoding: { type: 'string' } },
+              required: [],
+            },
+            path: { type: 'string' },
+          },
+          required: ['path'],
+        },
+      },
+    });
+  });
 });
 
 describe('kimiOpenAITrait.convertMessage', () => {

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

@@ -108,16 +108,16 @@ const NUMERIC_STRUCTURE_KEYS = new Set([
 ]);
 
 /**
- * Return a deep-cloned JSON Schema with missing `type` fields filled in for
- * Kimi tool compatibility.
+ * Return a deep-cloned JSON Schema with missing `type` fields and object
+ * `required` arrays filled in for Kimi tool compatibility.
  *
  * Moonshot's tool validator rejects some valid JSON Schema shapes when nested
  * property schemas omit `type` (for example enum-only MCP properties). This is
  * a provider-compatibility normalizer, not a complete JSON Schema compiler:
  * 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.
+ * typeless property schemas. The root schema is not type-inferred, but an
+ * explicitly typed root object receives the same `required` normalization.
  */
 export function normalizeKimiToolSchema(schema: Record<string, unknown>): Record<string, unknown> {
   return ensureKimiPropertyTypes(derefJsonSchema(schema));
@@ -252,6 +252,10 @@ function recurseSchema(node: unknown): void {
     return;
   }
 
+  if (node['type'] === 'object' && !hasOwn(node, 'required')) {
+    node['required'] = [];
+  }
+
   visitChildSchemas(node, normalizeProperty);
 }
 

packages/kosong/test/kimi.test.ts

@@ -359,6 +359,7 @@ describe('KimiChatProvider', () => {
                   prefixItems: [{ enum: ['left', 'right'], type: 'string' }],
                 },
               },
+              required: [],
             },
           },
         },