@deepstrike/sdk 0.2.43 → 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/runtime/kernel-step.js

@@ -19,7 +19,6 @@ export function restoreKernelRuntime(runtime, snapshot) {
     }, 1);
     kernelWireStates.set(runtime, { operationId, nextEventSequence });
 }
-let nextOperationSequence = 1;
 const kernelWireStates = new WeakMap();
 function tryParseJson(s) {
     try {
@@ -370,8 +369,12 @@ function mapKernelAction(raw) {
 function stepInput(runtime, event) {
     let state = kernelWireStates.get(runtime);
     if (!state) {
+        // Globally unique, never a process-local counter: durable session logs key the kernel
+        // genesis/transaction chains by (sessionId, operationId) and outlive this process, so a
+        // counter that restarts at 1 collides with yesterday's chain on the same session (genesis
+        // digest conflict, or step_seq successor violation when the policy digest happens to match).
         state = {
-            operationId: `node-operation-${nextOperationSequence++}`,
+            operationId: `node-operation-${crypto.randomUUID()}`,
             nextEventSequence: 1,
         };
         kernelWireStates.set(runtime, state);

package/dist/runtime/large-result-spool.d.ts

@@ -74,7 +74,7 @@ export declare class LargeResultSpool {
     /**
      * Persist a kernel-spooled tool output to disk. Returns the on-disk path ref.
      */
-    persistOutput(callId: string, content: string): Promise<string>;
+    persistOutput(sessionId: string, callId: string, content: string): Promise<string>;
     /**
      * Read a spooled result back from disk.
      */
@@ -85,7 +85,7 @@ export declare class LargeResultSpool {
      * for the hashed call-key prefix; returns `undefined` if nothing was ever spooled
      * for that call (e.g. it never actually exceeded the threshold, or the spool dir was cleaned up).
      */
-    findByCallId(callId: string): Promise<string | undefined>;
+    findByCallId(sessionId: string, callId: string): Promise<string | undefined>;
     /**
      * Clean up old spool files (optional maintenance).
      */

package/dist/runtime/large-result-spool.js

@@ -46,8 +46,11 @@ export class LargeResultSpool {
     getSpoolPath(hash) {
         return path.join(this.spoolDir, `${hash}.txt`);
     }
-    callKey(callId) {
-        return this.hashContent(callId).slice(0, 32);
+    callKey(sessionId, callId) {
+        // Session-scoped: the spool dir is shared across sessions and outlives runs, while vendor
+        // call ids can be index-style ("call_0") and repeat — an unscoped key lets read_result in
+        // one session fetch another session's spooled output.
+        return this.hashContent(`${sessionId}\u0000${callId}`).slice(0, 32);
     }
     async atomicWrite(spoolPath, content) {
         const tempPath = `${spoolPath}.${process.pid}.${crypto.randomUUID()}.tmp`;
@@ -128,9 +131,9 @@ omitted: ${omitted} chars
     /**
      * Persist a kernel-spooled tool output to disk. Returns the on-disk path ref.
      */
-    async persistOutput(callId, content) {
+    async persistOutput(sessionId, callId, content) {
         const hash = this.hashContent(content);
-        const spoolPath = this.getSpoolPath(`${this.callKey(callId)}-${hash.slice(0, 16)}`);
+        const spoolPath = this.getSpoolPath(`${this.callKey(sessionId, callId)}-${hash.slice(0, 16)}`);
         let promise = this.activeWrites.get(spoolPath);
         if (!promise) {
             promise = (async () => {
@@ -165,7 +168,7 @@ omitted: ${omitted} chars
      * for the hashed call-key prefix; returns `undefined` if nothing was ever spooled
      * for that call (e.g. it never actually exceeded the threshold, or the spool dir was cleaned up).
      */
-    async findByCallId(callId) {
+    async findByCallId(sessionId, callId) {
         let files;
         try {
             files = await fs.readdir(this.spoolDir);
@@ -173,7 +176,7 @@ omitted: ${omitted} chars
         catch {
             return undefined;
         }
-        const prefix = `${this.callKey(callId)}-`;
+        const prefix = `${this.callKey(sessionId, callId)}-`;
         const match = files.find(f => f.startsWith(prefix) && f.endsWith('.txt'));
         if (!match)
             return undefined;

package/dist/runtime/runner.js

@@ -1340,7 +1340,7 @@ export class RuntimeRunner {
         let full;
         const spool = this.opts.resultSpool ?? new LargeResultSpool();
         try {
-            full = await spool.findByCallId(callId);
+            full = await spool.findByCallId(sessionId, callId);
         }
         catch {
             full = undefined;
@@ -1856,7 +1856,7 @@ export class RuntimeRunner {
                         let spoolRef;
                         let error;
                         try {
-                            spoolRef = await spool.persistOutput(action.callId, action.output);
+                            spoolRef = await spool.persistOutput(sessionId, action.callId, action.output);
                         }
                         catch (cause) {
                             error = formatToolError(cause);

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.43",
+  "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.43",
+    "@deepstrike/core": "0.2.45",
     "@google/generative-ai": "^0.24.1",
     "openai": "^5.23.2"
   },