@ai-sdk/harness-claude-code 1.0.36 → 1.0.38

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @ai-sdk/harness-claude-code
 
+## 1.0.38
+
+### Patch Changes
+
+- 6c3e639: fix(harness-claude-code): classify the Skill tool as readonly so `allow-reads` permission mode no longer requires approval for skill activations
+- 0534507: fix(harness-claude-code): preserve nested user tool JSON schemas when exposing tools through the MCP bridge
+- Updated dependencies [b460541]
+- Updated dependencies [079591e]
+  - @ai-sdk/harness@1.0.37
+
+## 1.0.37
+
+### Patch Changes
+
+- Updated dependencies [cd06458]
+  - @ai-sdk/provider-utils@5.0.11
+  - @ai-sdk/harness@1.0.36
+
 ## 1.0.36
 
 ### Patch Changes

package/dist/bridge/index.mjs

@@ -510,13 +510,103 @@ import { randomUUID } from "crypto";
 import { argv, stdout as stdout2 } from "process";
 import * as claudeAgentSdk from "@anthropic-ai/claude-agent-sdk";
 import * as mcpServerModule from "@modelcontextprotocol/sdk/server/mcp.js";
-import { z } from "zod/v4";
 
 // src/bridge/claude-skills-option.ts
 function toClaudeSkillsOption(skills) {
   return skills && skills.length > 0 ? "all" : void 0;
 }
 
+// src/bridge/json-schema-to-zod.ts
+import { z } from "zod/v4";
+function jsonSchemaToZodShape(input) {
+  const schema = isJsonSchemaObject(input) ? input : {};
+  return toZodShape(schema);
+}
+function toZodShape(schema) {
+  if (!schema?.properties) return {};
+  const required = new Set(schema.required ?? []);
+  const shape = {};
+  for (const [key, propSchema] of Object.entries(schema.properties)) {
+    const propType = toZodType(propSchema);
+    let propertyType = required.has(key) ? propType : propType.optional();
+    if (propSchema.description) {
+      propertyType = propertyType.describe(propSchema.description);
+    }
+    shape[key] = propertyType;
+  }
+  return shape;
+}
+function toZodType(schema) {
+  if (!schema) return z.any();
+  let zType = zodForConst(schema) ?? zodForEnum(schema) ?? zodForNullableUnion(schema) ?? zodForType(schema);
+  if (isNullable(schema)) zType = zType.nullable();
+  if (schema.description) zType = zType.describe(schema.description);
+  return zType;
+}
+function zodForType(schema) {
+  const types = getNonNullTypes(schema);
+  if (types.length > 1) return z.any();
+  if (Array.isArray(schema.type) && types.length === 0) return z.null();
+  const type = types[0] ?? (schema.properties ? "object" : void 0);
+  switch (type) {
+    case "string":
+      return z.string();
+    case "number":
+      return z.number();
+    case "integer":
+      return z.number().int();
+    case "boolean":
+      return z.boolean();
+    case "array":
+      return z.array(
+        Array.isArray(schema.items) ? z.any() : toZodType(schema.items)
+      );
+    case "object":
+      return z.object(toZodShape(schema));
+    case "null":
+      return z.null();
+    default:
+      return z.any();
+  }
+}
+function zodForConst(schema) {
+  if (!("const" in schema)) return void 0;
+  return isJsonLiteral(schema.const) ? z.literal(schema.const) : z.any();
+}
+function zodForEnum(schema) {
+  if (!Array.isArray(schema.enum)) return void 0;
+  if (!schema.enum.every(isJsonLiteral)) return z.any();
+  return zodForLiterals(schema.enum);
+}
+function zodForNullableUnion(schema) {
+  const unionSchemas = schema.anyOf ?? schema.oneOf;
+  if (!unionSchemas || unionSchemas.length < 2) return void 0;
+  const nonNullSchemas = unionSchemas.filter((item) => !isNullOnlySchema(item));
+  if (nonNullSchemas.length !== 1) return void 0;
+  return toZodType(nonNullSchemas[0]).nullable();
+}
+function zodForLiterals(values) {
+  if (values.length === 0) return z.any();
+  if (values.length === 1) return z.literal(values[0]);
+  const literals = values.map((value) => z.literal(value));
+  return z.union(literals);
+}
+function getNonNullTypes(schema) {
+  return Array.isArray(schema.type) ? schema.type.filter((type) => type !== "null") : [schema.type].filter(Boolean);
+}
+function isNullable(schema) {
+  return schema.nullable === true || Array.isArray(schema.type) && schema.type.includes("null");
+}
+function isNullOnlySchema(schema) {
+  return schema.type === "null" || Array.isArray(schema.type) && schema.type.length === 1 && schema.type[0] === "null" || schema.const === null || Array.isArray(schema.enum) && schema.enum.length === 1 && schema.enum[0] === null;
+}
+function isJsonSchemaObject(input) {
+  return input != null && typeof input === "object" && !Array.isArray(input);
+}
+function isJsonLiteral(value) {
+  return value === null || typeof value === "string" || typeof value === "boolean" || typeof value === "number" && Number.isFinite(value);
+}
+
 // src/bridge/index.ts
 var NATIVE_TO_COMMON = {
   Read: "read",
@@ -578,7 +668,7 @@ var NATIVE_TOOL_KINDS = {
   EnterWorktree: "edit",
   ExitWorktree: "edit",
   ExitPlanMode: "edit",
-  Skill: "edit",
+  Skill: "readonly",
   AskUserQuestion: "readonly",
   ToolSearch: "readonly",
   Bash: "bash",
@@ -739,7 +829,7 @@ async function runTurn(start, turn) {
       version: "1.0.0"
     });
     for (const tool of start.tools) {
-      const shape = jsonSchemaToZodShape(tool.inputSchema, z);
+      const shape = jsonSchemaToZodShape(tool.inputSchema);
       server.tool(
         tool.name,
         tool.description ?? "",
@@ -1145,38 +1235,6 @@ function defaultUsage() {
     outputTokens: { total: 0, text: 0 }
   };
 }
-function jsonSchemaToZodShape(schema, z2) {
-  if (!schema || typeof schema !== "object") return {};
-  const s = schema;
-  const shape = {};
-  const required = new Set(s.required ?? []);
-  for (const [key, val] of Object.entries(s.properties ?? {})) {
-    let z_;
-    switch (val.type) {
-      case "string":
-        z_ = z2.string();
-        break;
-      case "number":
-      case "integer":
-        z_ = z2.number();
-        break;
-      case "boolean":
-        z_ = z2.boolean();
-        break;
-      case "array":
-        z_ = z2.array(z2.any());
-        break;
-      default:
-        z_ = z2.any();
-    }
-    if (val.description)
-      z_ = z_.describe(
-        val.description
-      );
-    shape[key] = required.has(key) ? z_ : z_.optional();
-  }
-  return shape;
-}
 function parseArgs(args2) {
   const out = {};
   for (let i = 0; i < args2.length; i++) {