@deepstrike/sdk 0.2.44 → 0.2.45

package/dist/runtime/execution-plane.js

@@ -124,9 +124,11 @@ export class LocalExecutionPlane {
             },
         };
         try {
-            const args = JSON.parse(call.arguments || "{}");
-            const originalArgsStr = JSON.stringify(args);
-            const validation = validateToolArguments(registered.schema.parameters, args);
+            const rawArgs = JSON.parse(call.arguments || "{}");
+            const originalArgsStr = JSON.stringify(rawArgs);
+            // validation.args, not rawArgs, from here on: a oneOf/anyOf ROOT accepts a repaired probe
+            // CLONE — the original reference never sees those repairs (auto-casts, strips, defaults).
+            const validation = validateToolArguments(registered.schema.parameters, rawArgs);
             if (validation.error)
                 return { callId: call.id, output: `invalid arguments: ${validation.error}`, isError: true };
             if (validation.repaired) {
@@ -135,13 +137,13 @@ export class LocalExecutionPlane {
                     callId: call.id,
                     name: call.name,
                     originalArguments: originalArgsStr,
-                    repairedArguments: JSON.stringify(args),
+                    repairedArguments: JSON.stringify(validation.args),
                 };
             }
             // M3/G4: pass the run context (incl. `cwd`) so cwd-aware tools scope their work to the
             // sub-agent's worktree. `RunContext` is structurally assignable to the tool's `ToolExecContext`.
             // The per-call `audit` helper (above) layers best-effort side-effect handling on top.
-            const output = await registered.execute(args, callCtx);
+            const output = await registered.execute(validation.args, callCtx);
             if (isAsyncIterable(output)) {
                 let combined = "";
                 const iterator = output[Symbol.asyncIterator]();

package/dist/tools/index.d.ts

@@ -26,6 +26,7 @@ export declare function toolChunkText(chunk: ToolChunk): string;
 export declare function validateToolArguments(schemaJson: string, args: Record<string, unknown>): {
     error?: string;
     repaired: boolean;
+    args: Record<string, unknown>;
 };
 export declare function executeTools(calls: {
     id: string;

package/dist/tools/index.js

@@ -1,11 +1,24 @@
 import { formatToolError } from "./errors.js";
+/** Fail at registration, not as a vendor 400 at call time: every major provider (OpenAI-compat,
+ *  Anthropic, Gemini) rejects a tool whose parameters root is not `type: "object"` — the wire
+ *  error ("schema must be a JSON Schema of 'type: \"object\"'") surfaces far from the tool that
+ *  caused it. Union roots must be wrapped: object root + flattened properties + `oneOf` sibling. */
+function assertObjectRootSchema(name, parameters) {
+    if (!parameters || typeof parameters !== "object" || Array.isArray(parameters) || parameters.type !== "object") {
+        throw new Error(`tool "${name}": parameters must be a JSON Schema with root type "object" `
+            + `(got type: ${JSON.stringify(parameters?.type ?? null)}); `
+            + `providers reject any other root — wrap union variants as an object root with a oneOf sibling`);
+    }
+}
 export function tool(name, description, parameters, fn) {
+    assertObjectRootSchema(name, parameters);
     return {
         schema: { name, description, parameters: JSON.stringify(parameters) },
         async execute(args, ctx) { return fn(args, ctx); },
     };
 }
 export function streamingTool(name, description, parameters, fn) {
+    assertObjectRootSchema(name, parameters);
     return {
         schema: { name, description, parameters: JSON.stringify(parameters) },
         execute(args, ctx) { return fn(args, ctx); },
@@ -27,12 +40,14 @@ export function validateToolArguments(schemaJson, args) {
         schema = JSON.parse(schemaJson);
     }
     catch {
-        return { error: "invalid tool schema", repaired: false };
+        return { error: "invalid tool schema", repaired: false, args };
     }
     const state = { repaired: false };
     const wrapper = { root: args };
     const error = validateValue(schema, wrapper, "root", "$", state);
-    return { error, repaired: state.repaired };
+    // A oneOf/anyOf ROOT replaces the value with its accepted probe clone — in-place mutation of
+    // the caller's object only covers non-union roots. Callers must use the returned `args`.
+    return { error, repaired: state.repaired, args: wrapper.root };
 }
 function validateValue(schema, parent, key, path, state) {
     let value = parent[key];
@@ -188,12 +203,72 @@ function validateValue(schema, parent, key, path, state) {
             if (typeof value !== "boolean")
                 return `${path} must be boolean`;
         }
+        else if (expectedType === "null") {
+            if (value !== null)
+                return `${path} must be null`;
+        }
     }
     else if (path === "$" && (!value || typeof value !== "object" || Array.isArray(value))) {
         return `${path} must be object`;
     }
     if (Array.isArray(schema.enum) && !schema.enum.includes(value))
         return `${path} must be one of enum values`;
+    // `const` is THE discriminator convention for oneOf variants (kind: {const: "edit"}). Without
+    // it, union branches match on required+type alone and the WRONG branch can win — then its
+    // allow-list strips keys the right branch declared.
+    if ("const" in schema) {
+        const want = schema.const;
+        const matches = want !== null && typeof want === "object"
+            ? JSON.stringify(value) === JSON.stringify(want)
+            : value === want;
+        if (!matches)
+            return `${path} must equal the const value ${JSON.stringify(want)}`;
+    }
+    // Constraint keywords, checked per the value's actual type (JSON Schema semantics: string
+    // constraints ignore non-strings, etc.). Keywords outside this set (allOf, multipleOf,
+    // uniqueItems, format, if/then/else, …) are ignored, not rejected.
+    if (typeof value === "string") {
+        if (typeof schema.minLength === "number" && value.length < schema.minLength) {
+            return `${path} must be at least ${schema.minLength} characters`;
+        }
+        if (typeof schema.maxLength === "number" && value.length > schema.maxLength) {
+            return `${path} must be at most ${schema.maxLength} characters`;
+        }
+        if (typeof schema.pattern === "string") {
+            let re;
+            try {
+                re = new RegExp(schema.pattern);
+            }
+            catch {
+                re = undefined;
+            } // author-side bad regex: skip, never fail the call
+            if (re && !re.test(value))
+                return `${path} must match pattern ${schema.pattern}`;
+        }
+    }
+    else if (typeof value === "number") {
+        if (typeof schema.minimum === "number" && value < schema.minimum)
+            return `${path} must be >= ${schema.minimum}`;
+        if (typeof schema.maximum === "number" && value > schema.maximum)
+            return `${path} must be <= ${schema.maximum}`;
+        if (typeof schema.exclusiveMinimum === "number" && value <= schema.exclusiveMinimum)
+            return `${path} must be > ${schema.exclusiveMinimum}`;
+        if (typeof schema.exclusiveMaximum === "number" && value >= schema.exclusiveMaximum)
+            return `${path} must be < ${schema.exclusiveMaximum}`;
+    }
+    else if (Array.isArray(value)) {
+        if (typeof schema.minItems === "number" && value.length < schema.minItems)
+            return `${path} must have at least ${schema.minItems} items`;
+        if (typeof schema.maxItems === "number" && value.length > schema.maxItems)
+            return `${path} must have at most ${schema.maxItems} items`;
+    }
+    // `not`: probe on a clone so a matching (= rejected) subschema's repairs never leak out.
+    if (schema.not && typeof schema.not === "object" && !Array.isArray(schema.not)) {
+        const probe = { v: structuredClone(value) };
+        if (!validateValue(schema.not, probe, "v", path, { repaired: false })) {
+            return `${path} must not match the disallowed shape`;
+        }
+    }
     return undefined;
 }
 export async function executeTools(calls, registry) {
@@ -206,7 +281,9 @@ export async function executeTools(calls, registry) {
             const validation = validateToolArguments(t.schema.parameters, args);
             if (validation.error)
                 return { callId: c.id, output: `invalid arguments: ${validation.error}`, isError: true };
-            const output = await t.execute(args);
+            // validation.args, not args: a oneOf/anyOf ROOT accepts a repaired probe CLONE — the
+            // original reference never sees those repairs (auto-casts, strips, defaults).
+            const output = await t.execute(validation.args);
             if (isAsyncIterable(output)) {
                 let combined = "";
                 for await (const chunk of output)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deepstrike/sdk",
-  "version": "0.2.44",
+  "version": "0.2.45",
   "description": "DeepStrike Node.js SDK",
   "type": "module",
   "main": "dist/index.js",
@@ -72,7 +72,7 @@
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.99.0",
-    "@deepstrike/core": "0.2.44",
+    "@deepstrike/core": "0.2.45",
     "@google/generative-ai": "^0.24.1",
     "openai": "^5.23.2"
   },