@deepstrike/wasm 0.2.33 → 0.2.35

package/README.md

@@ -1,3 +1,9 @@
+<p align="center">
+  <a href="https://github.com/kongusen/deepstrike">
+    <img src="https://raw.githubusercontent.com/kongusen/deepstrike/main/docs/public/banner.png" alt="DeepStrike" width="420" />
+  </a>
+</p>
+
 # DeepStrike WASM SDK
 
 Runtime framework built on a Rust kernel compiled to WebAssembly. Runs in browsers, Cloudflare Workers, Deno Deploy, and Vercel Edge — anywhere that supports `fetch` and WASM.

package/dist/providers/anthropic.js

@@ -250,6 +250,8 @@ export class AnthropicProvider {
                             const inputTokens = uncachedInput + cacheReadTokens + cacheCreationTokens;
                             if (inputTokens > 0 || outputTokens > 0) {
                                 const bySlot = estimateCacheReadBySlot(cacheReadTokens, slotBp);
+                                // stop_reason rides on message_delta; "max_tokens" drives output-cap recovery.
+                                const stopReason = evt.delta?.stop_reason;
                                 yield {
                                     type: "usage",
                                     totalTokens: inputTokens + outputTokens,
@@ -258,6 +260,7 @@ export class AnthropicProvider {
                                     cacheReadInputTokens: cacheReadTokens,
                                     cacheCreationInputTokens: cacheCreationTokens,
                                     ...(bySlot ? { cacheReadInputTokensBySlot: bySlot } : {}),
+                                    ...(stopReason ? { stopReason } : {}),
                                 };
                             }
                         }

package/dist/providers/openai.js

@@ -37,6 +37,9 @@ export class OpenAIProvider {
         const reader = resp.body.getReader();
         const decoder = new TextDecoder();
         let buf = "";
+        // Phase 4: OpenAI signals an output-cap truncation via finish_reason="length"; the kernel
+        // treats it as a truncation (== Anthropic "max_tokens") and drives output-cap recovery.
+        let finishReason;
         while (true) {
             const { done, value } = await reader.read();
             if (done)
@@ -48,10 +51,17 @@ export class OpenAIProvider {
                 if (!line.startsWith("data: "))
                     continue;
                 const data = line.slice(6).trim();
-                if (data === "[DONE]")
+                if (data === "[DONE]") {
+                    // Surface an output-cap truncation (finish_reason="length") to the runner/kernel. Emitted
+                    // as a usage frame (the channel the runner reads stopReason from) before the early return.
+                    if (finishReason)
+                        yield { type: "usage", totalTokens: 0, stopReason: finishReason };
                     return;
+                }
                 try {
                     const chunk = JSON.parse(data);
+                    if (chunk.choices?.[0]?.finish_reason)
+                        finishReason = chunk.choices[0].finish_reason ?? undefined;
                     const delta = chunk.choices?.[0]?.delta;
                     if (!delta)
                         continue;

package/dist/runtime/runner.js

@@ -5,7 +5,7 @@ import { peekProviderReplay, seedProviderReplayFromEvents } from "./provider-rep
 import { sanitizeReplayText } from "./replay-sanitize.js";
 import { formatToolError } from "../tools/errors.js";
 import { buildLlmCompletedEvent, buildRunTerminalEvent, buildWorkflowNodeCompletedEvent, buildWorkflowNodesSubmittedEvent, recoverCompletedWorkflowNodes, recoverSubmittedWorkflowNodes, repairEventsForRecovery, } from "./session-repair.js";
-import { forceCompact, kernelAction, kernelApply, kernelMaybeAction, messageToKernelMessage, skillMetadataToKernel, toolResultToKernel, toolSchemaToKernel, } from "./kernel-step.js";
+import { kernelAction, kernelApply, kernelMaybeAction, messageToKernelMessage, skillMetadataToKernel, toolResultToKernel, toolSchemaToKernel, } from "./kernel-step.js";
 import { agentRunSpecToKernel, findSpawnProcessObservation, milestoneCheckPass, milestoneCheckResultToKernel, spawnObservationToManifest, subAgentResultToKernel, submitWorkflowNodesToKernel, submitWorkflowToKernel, workflowBudgetNote, workflowNodeToManifest, workflowNodeToSpec, workflowSpecToKernel, } from "./types/agent.js";
 import { defaultSubAgentOrchestrator } from "./sub-agent-orchestrator.js";
 import { extractJsonValue, schemaInstruction, schemaRetryInstruction, validateAgainstSchema, } from "./output-schema.js";
@@ -408,7 +408,6 @@ export class RuntimeRunner {
         let action = resumeMidRun
             ? kernelAction(runtime, this.pendingObservations, { kind: "resume" })
             : kernelAction(runtime, this.pendingObservations, startPayload);
-        let hasAttemptedReactiveCompact = false;
         // P0-C: the skill loaded and in effect going into the current turn → per-turn `activeSkill` metric.
         let activeSkill;
         // I0b: kernel-throw safety net — see Node runner for full rationale.
@@ -466,7 +465,7 @@ export class RuntimeRunner {
                     let turnCacheReadTokens = 0;
                     let turnCacheCreationTokens = 0;
                     let turnCacheReadBySlot;
-                    let shouldRetry = false;
+                    let turnStopReason;
                     const abortSignal = this.abortController?.signal;
                     try {
                         for await (const evt of this.opts.provider.stream(context, tools, Object.keys(ext).length ? ext : undefined, providerState, abortSignal)) {
@@ -483,6 +482,9 @@ export class RuntimeRunner {
                                 turnCacheCreationTokens = usageEvt.cacheCreationInputTokens ?? 0;
                                 // I1: per-slot attribution forwarded to TurnMetrics; undefined on non-Anthropic providers.
                                 turnCacheReadBySlot = usageEvt.cacheReadInputTokensBySlot;
+                                // Phase 4: stop_reason drives the kernel's max-output-tokens recovery.
+                                if (usageEvt.stopReason)
+                                    turnStopReason = usageEvt.stopReason;
                                 continue;
                             }
                             yield evt;
@@ -495,23 +497,31 @@ export class RuntimeRunner {
                         }
                     }
                     catch (err) {
-                        // #2-B-ii: an aborted in-flight request surfaces as an AbortError — treat as an interrupt.
                         if (abortSignal?.aborted) {
+                            // #2-B-ii: an aborted in-flight request surfaces as an AbortError — treat it as an
+                            // interrupt (the post-stream `aborted` check below converts it to a clean
+                            // timeout/UserAbort), not a crash or a provider error.
                             this.interrupted = true;
                         }
-                        const errMsg = formatToolError(err).toLowerCase();
-                        if ((errMsg.includes("413") || errMsg.includes("too long") || errMsg.includes("context length exceeded") || errMsg.includes("context_length_exceeded")) &&
-                            !hasAttemptedReactiveCompact) {
-                            hasAttemptedReactiveCompact = true;
-                            if (forceCompact(runtime, this.pendingObservations)) {
-                                nextCompressedArchiveStart = await this.appendObservations(sessionId, runtime, nextCompressedArchiveStart);
-                                shouldRetry = true;
+                        else {
+                            // Reactive recovery is now a kernel decision. Forward the raw provider error and
+                            // dispatch whatever the kernel returns: `call_provider` to retry with a freshly
+                            // compacted context, or `done` to terminate with an honest `ContextOverflow`. The
+                            // classify + compact + retry + give-up policy lives in the kernel (one place), not
+                            // duplicated across the four SDK runners.
+                            action = kernelAction(runtime, this.pendingObservations, {
+                                kind: "provider_error",
+                                message: formatToolError(err),
+                            });
+                            // Withholding (query.ts parity): surface the raw provider error only when the kernel
+                            // could NOT recover (it returned a terminal). On a recovered retry (`call_provider`)
+                            // the error stays hidden. `continue` re-enters the loop: a recovered turn persists its
+                            // compaction archive via the loop-top appendObservations, and a terminal `done` exits
+                            // through `isTerminal()`.
+                            if (action.kind === "done") {
+                                yield { type: "error", message: formatToolError(err) };
                             }
-                        }
-                        if (!shouldRetry) {
-                            yield { type: "error", message: formatToolError(err) };
-                            action = kernelAction(runtime, this.pendingObservations, { kind: "timeout" });
-                            break;
+                            continue;
                         }
                     }
                     // #2-B-ii: stream aborted (preempt/interrupt) via the break path — end the turn now.
@@ -519,14 +529,6 @@ export class RuntimeRunner {
                         action = kernelAction(runtime, this.pendingObservations, { kind: "timeout" });
                         break;
                     }
-                    if (shouldRetry) {
-                        action = {
-                            kind: "call_provider",
-                            context: runtime.render(),
-                            tools,
-                        };
-                        continue;
-                    }
                     const assistantMessage = {
                         role: "assistant",
                         content: finalText,
@@ -539,6 +541,7 @@ export class RuntimeRunner {
                         ...(turnInputTokens > 0 ? { observed_input_tokens: turnInputTokens } : {}),
                         ...(turnOutputTokens > 0 ? { observed_output_tokens: turnOutputTokens } : {}),
                         now_ms: Date.now(),
+                        ...(turnStopReason ? { stop_reason: turnStopReason } : {}),
                     };
                     let nextAction = kernelMaybeAction(runtime, this.pendingObservations, providerEvent);
                     const hasSuspended = this.pendingObservations.some(o => o.kind === "suspended");

package/dist/types.d.ts

@@ -73,7 +73,8 @@ export interface UsageEvent extends StreamEvent {
         system?: number;
         tools?: number;
         messages?: number;
-    };
+    }; /** Provider stop reason — `max_tokens` (Anthropic) / `length` (OpenAI) flag an output-cap truncation driving the kernel's max-output-tokens recovery. */
+    stopReason?: string;
 }
 export interface ThinkingDelta extends StreamEvent {
     type: "thinking_delta";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deepstrike/wasm",
-  "version": "0.2.33",
+  "version": "0.2.35",
   "description": "DeepStrike WASM SDK — browser, Cloudflare Workers, Deno Deploy",
   "type": "module",
   "main": "dist/index.js",
@@ -15,7 +15,7 @@
     "test": "node --experimental-vm-modules node_modules/.bin/jest"
   },
   "dependencies": {
-    "@deepstrike/wasm-kernel": "0.2.33"
+    "@deepstrike/wasm-kernel": "0.2.35"
   },
   "devDependencies": {
     "@types/jest": "^30.0.0",