fix(anthropic): normalize tool input schemas (cherry-pick PR #76)

Cherry-pick of dae62a9 from ingw/fix-anthropic-tool-schema with review fixes:
- Translate Korean Decision Log comment to English
- Add known-limitation comment for oneOf/anyOf property collision

Co-authored-by: Ingwannu <186453546+Ingwannu@users.noreply.github.com>

Author: lidge-jun

src/adapters/anthropic.ts

@@ -482,11 +482,72 @@ function toolsToAnthropicFormat(parsed: OcxParsedRequest, toolNames: { toWire: (
   const converted = tools.map(t => ({
     name: toolNames.toWire(namespacedToolName(t.namespace, t.name)),
     description: t.description,
-    input_schema: t.parameters,
+    input_schema: normalizeAnthropicInputSchema(t.parameters),
   }));
   return converted;
 }
 
+function normalizeAnthropicInputSchema(schema: unknown): Record<string, unknown> {
+  const obj = schema && typeof schema === "object" && !Array.isArray(schema)
+    ? schema as Record<string, unknown>
+    : {};
+  // Anthropic rejects root-level missing type and oneOf/anyOf/allOf in input_schema.
+  // Normalize the root only: ensure type:"object" + properties, flatten root composition
+  // while preserving nested schemas. Mirrors kiro-tools.ts ensureRootObjectType.
+  // Known limitation: Object.assign on branch properties means later branches overwrite
+  // earlier ones when the same property name appears with different schemas.
+  const compositionKeys = ["oneOf", "anyOf", "allOf"] as const;
+  const hasRootComposition = compositionKeys.some(key => Array.isArray(obj[key]));
+  const type = obj.type;
+  const rootObjectType = type === "object" || (Array.isArray(type) && type.includes("object"));
+
+  if (!hasRootComposition) {
+    const normalized: Record<string, unknown> = rootObjectType && type === "object"
+      ? { ...obj }
+      : { ...obj, type: "object" };
+    if (normalized.properties === undefined || normalized.properties === null) {
+      normalized.properties = {};
+    }
+    return normalized;
+  }
+
+  const properties: Record<string, unknown> = {};
+  const required = new Set<string>();
+  if (obj.properties && typeof obj.properties === "object" && !Array.isArray(obj.properties)) {
+    Object.assign(properties, obj.properties as Record<string, unknown>);
+  }
+  if (Array.isArray(obj.required)) {
+    for (const item of obj.required) if (typeof item === "string") required.add(item);
+  }
+
+  for (const key of compositionKeys) {
+    const variants = obj[key];
+    if (!Array.isArray(variants)) continue;
+    const mergeRequired = key === "allOf";
+    for (const variant of variants) {
+      if (!variant || typeof variant !== "object" || Array.isArray(variant)) continue;
+      const v = variant as Record<string, unknown>;
+      if (v.properties && typeof v.properties === "object" && !Array.isArray(v.properties)) {
+        Object.assign(properties, v.properties as Record<string, unknown>);
+      }
+      if (mergeRequired && Array.isArray(v.required)) {
+        for (const item of v.required) if (typeof item === "string") required.add(item);
+      }
+    }
+  }
+
+  const normalized: Record<string, unknown> = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (key === "oneOf" || key === "anyOf" || key === "allOf") continue;
+    if (key === "type" || key === "properties" || key === "required") continue;
+    normalized[key] = value;
+  }
+  normalized.type = "object";
+  normalized.properties = properties;
+  if (required.size > 0) normalized.required = [...required];
+  return normalized;
+}
+
 export function createAnthropicAdapter(provider: OcxProviderConfig, cacheRetention?: "none" | "short" | "long"): ProviderAdapter {
   const isOAuth = provider.authMode === "oauth";
   const toolNames = buildToolNameTransforms(provider);

tests/anthropic-tool-schema.test.ts

@@ -0,0 +1,96 @@
+import { describe, expect, test } from "bun:test";
+import { createAnthropicAdapter } from "../src/adapters/anthropic";
+import type { OcxParsedRequest, OcxProviderConfig } from "../src/types";
+
+const provider = { adapter: "anthropic", baseUrl: "https://api.anthropic.com", apiKey: "sk-x", authMode: "apiKey" } as unknown as OcxProviderConfig;
+
+function toolSchema(parameters: unknown): Record<string, unknown> {
+  const { body } = createAnthropicAdapter(provider).buildRequest({
+    modelId: "anthropic/claude-opus-4.1",
+    stream: false,
+    options: {},
+    context: {
+      messages: [{ role: "user", content: "use the tool", timestamp: 0 }],
+      tools: [{ name: "sample_tool", description: "Sample", parameters }],
+    },
+  } as unknown as OcxParsedRequest);
+  const parsed = JSON.parse(body as string) as { tools: Array<{ input_schema: Record<string, unknown> }> };
+  return parsed.tools[0].input_schema;
+}
+
+describe("anthropic tool input_schema normalization", () => {
+  test("missing root type becomes an object schema with properties", () => {
+    expect(toolSchema({ properties: { query: { type: "string" } }, required: ["query"] })).toEqual({
+      type: "object",
+      properties: { query: { type: "string" } },
+      required: ["query"],
+    });
+    expect(toolSchema({})).toEqual({ type: "object", properties: {} });
+  });
+
+  test("root oneOf and anyOf are flattened without promoting branch required fields", () => {
+    const anyOf = toolSchema({
+      anyOf: [
+        { type: "object", properties: { a: { type: "string" } }, required: ["a"] },
+        { type: "object", properties: { b: { type: "number" } }, required: ["b"] },
+      ],
+    });
+    expect(anyOf.anyOf).toBeUndefined();
+    expect(anyOf.oneOf).toBeUndefined();
+    expect(anyOf.allOf).toBeUndefined();
+    expect(anyOf).toEqual({
+      type: "object",
+      properties: { a: { type: "string" }, b: { type: "number" } },
+    });
+
+    const oneOf = toolSchema({
+      oneOf: [
+        { type: "object", properties: { path: { type: "string" } }, required: ["path"] },
+      ],
+    });
+    expect(oneOf).toEqual({
+      type: "object",
+      properties: { path: { type: "string" } },
+    });
+  });
+
+  test("root allOf merges required fields and preserves sibling schema metadata", () => {
+    expect(toolSchema({
+      title: "Search options",
+      additionalProperties: false,
+      properties: { existing: { type: "string" } },
+      required: ["existing"],
+      allOf: [
+        { type: "object", properties: { limit: { type: "number" } }, required: ["limit"] },
+        { type: "object", properties: { sort: { type: "string" } } },
+      ],
+    })).toEqual({
+      title: "Search options",
+      additionalProperties: false,
+      type: "object",
+      properties: {
+        existing: { type: "string" },
+        limit: { type: "number" },
+        sort: { type: "string" },
+      },
+      required: ["existing", "limit"],
+    });
+  });
+
+  test("nested composition under properties is preserved", () => {
+    expect(toolSchema({
+      properties: {
+        value: {
+          anyOf: [{ type: "string" }, { type: "number" }],
+        },
+      },
+    })).toEqual({
+      type: "object",
+      properties: {
+        value: {
+          anyOf: [{ type: "string" }, { type: "number" }],
+        },
+      },
+    });
+  });
+});