@deepstrike/sdk 0.2.42 → 0.2.44

package/dist/harness/harness.d.ts

@@ -1,5 +1,6 @@
 import type { RuntimeRunner } from "../runtime/runner.js";
 import type { SessionEvent } from "../runtime/session-log.js";
+import type { ContentPart } from "../types.js";
 import type { WorkflowNodeSpec } from "../types/agent.js";
 import type { Criterion, Verdict } from "../runtime/eval.js";
 import type { AttemptJudge, JudgeResult } from "./judge.js";
@@ -8,6 +9,12 @@ export interface AttemptRequest {
     sessionId?: string;
     goal: string;
     criteria?: Criterion[];
+    /**
+     * Multimodal inputs (images / audio) attached to the task. Forwarded to every attempt
+     * unconditionally; the runner seeds them per session idempotently, so fresh-session carries
+     * re-seed while same-session carries do not double.
+     */
+    attachments?: ContentPart[];
     extensions?: Record<string, unknown>;
     /** Parent transcript inherited by the first attempt only. */
     inheritEvents?: Array<{

package/dist/harness/harness.js

@@ -14,6 +14,7 @@ export class RuntimeAttemptBody {
             sessionId: context.sessionId,
             goal: context.goal,
             criteria: (context.criteria ?? []).map(criterion => criterion.text),
+            ...(context.attachments?.length ? { attachments: context.attachments } : {}),
             extensions: context.extensions,
             ...(context.attempt === 1 && context.inheritEvents
                 ? { inheritEvents: context.inheritEvents }

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

@@ -1208,6 +1208,12 @@ export class RuntimeRunner {
         const runId = midRun && resumedStart?.event.kind === "run_started"
             ? resumedStart.event.run_id
             : crypto.randomUUID();
+        // Idempotent per session: an earlier run's `run_started` already carries these attachments
+        // (same-session retry attempt), so replay reconstructs them — recording and seeding again
+        // would double them in history. Deduping at the append keeps live and replay in agreement.
+        const attachments = req.attachments?.length && !attachmentsAlreadySeeded(prior, req.attachments)
+            ? req.attachments
+            : undefined;
         if (!midRun) {
             await this.opts.sessionLog.append(req.sessionId, {
                 kind: "run_started",
@@ -1216,10 +1222,10 @@ export class RuntimeRunner {
                 criteria: req.criteria ?? [],
                 agent_id: this.opts.agentId,
                 system_prompt: this.opts.systemPrompt,
-                ...(req.attachments?.length ? { attachments: req.attachments } : {}),
+                ...(attachments ? { attachments } : {}),
             });
         }
-        yield* this.execute(req.sessionId, req.goal, req.criteria ?? [], req.extensions, prior.length > 0 ? prior : undefined, midRun, req.attachments, runId);
+        yield* this.execute(req.sessionId, req.goal, req.criteria ?? [], req.extensions, prior.length > 0 ? prior : undefined, midRun, attachments, runId);
     }
     async *wake(sessionId, extensions) {
         const events = await this.opts.sessionLog.read(sessionId);
@@ -1334,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;
@@ -1850,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);
@@ -2467,6 +2473,15 @@ function isMidRun(events) {
     }
     return lastStarted >= 0 && lastStarted > lastTerminal;
 }
+/**
+ * True when an earlier run in this session already seeded the same attachments. Replay
+ * reconstructs the attachment message from that run's `run_started`, so recording and
+ * live-seeding them again (a same-session retry attempt) would double them in history.
+ */
+function attachmentsAlreadySeeded(prior, attachments) {
+    const wanted = JSON.stringify(attachments);
+    return prior.some(({ event }) => event.kind === "run_started" && JSON.stringify(event.attachments ?? []) === wanted);
+}
 /**
  * Build a kernel `add_history_message` payload from user attachments: a `user`
  * message whose content is the multimodal parts in the kernel's serde shape

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deepstrike/sdk",
-  "version": "0.2.42",
+  "version": "0.2.44",
   "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.42",
+    "@deepstrike/core": "0.2.44",
     "@google/generative-ai": "^0.24.1",
     "openai": "^5.23.2"
   },