@deepstrike/sdk 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 Node.js SDK
 
 Runtime framework built on a Rust kernel. The kernel owns loop control, context compression, governance, signal routing, and memory paging — the SDK owns all I/O (LLM calls, tool execution, disk, long-term memory).

package/dist/providers/anthropic.js

@@ -182,6 +182,9 @@ export class AnthropicProvider {
                     // cache-heavy turn look tiny and suppress compaction until a 413.
                     const inputTokens = uncachedInput + cacheReadTokens + cacheCreationTokens;
                     const bySlot = estimateCacheReadBySlot(cacheReadTokens, slotBp);
+                    // stop_reason is only present on message_delta (the closing frame). `max_tokens` drives
+                    // the kernel's output-cap recovery; other reasons (end_turn/tool_use) are informational.
+                    const stopReason = evt.delta?.stop_reason;
                     yield {
                         type: "usage",
                         totalTokens: inputTokens + outputTokens,
@@ -190,6 +193,7 @@ export class AnthropicProvider {
                         cacheReadInputTokens: cacheReadTokens,
                         cacheCreationInputTokens: cacheCreationTokens,
                         ...(bySlot ? { cacheReadInputTokensBySlot: bySlot } : {}),
+                        ...(stopReason ? { stopReason } : {}),
                     };
                 }
             }

package/dist/providers/openai.js

@@ -250,6 +250,11 @@ export class OpenAIChatProvider {
         let inputTokens = 0;
         let outputTokens = 0;
         let cacheReadTokens = 0;
+        // Phase 4: OpenAI signals an output-cap truncation via finish_reason="length", which arrives on
+        // a `choices` frame separate from the trailing `usage` frame — so capture it and attach it to the
+        // usage event the runner reads. The kernel treats "length" as a truncation (== Anthropic
+        // "max_tokens"); other reasons ("stop"/"tool_calls") pass through harmlessly.
+        let finishReason;
         for await (const chunk of stream) {
             if (chunk.usage) {
                 totalTokens = chunk.usage.total_tokens;
@@ -261,6 +266,8 @@ export class OpenAIChatProvider {
             const choice = chunk.choices[0];
             if (!choice)
                 continue;
+            if (choice.finish_reason)
+                finishReason = choice.finish_reason;
             const delta = choice.delta;
             if (!delta)
                 continue;
@@ -317,7 +324,7 @@ export class OpenAIChatProvider {
         rememberStream();
         yield* emitPendingToolCalls();
         if (totalTokens > 0)
-            yield { type: "usage", totalTokens, inputTokens, outputTokens, ...(cacheReadTokens > 0 ? { cacheReadInputTokens: cacheReadTokens } : {}) };
+            yield { type: "usage", totalTokens, inputTokens, outputTokens, ...(cacheReadTokens > 0 ? { cacheReadInputTokens: cacheReadTokens } : {}), ...(finishReason ? { stopReason: finishReason } : {}) };
     }
     /**
      * Default `prompt_cache_key` derived from the cacheable prefix (system prompt +

package/dist/runtime/runner.js

@@ -5,7 +5,7 @@ import { peekProviderReplay, seedProviderReplayFromEvents } from "./provider-rep
 import { sanitizeReplayText } from "./replay-sanitize.js";
 import { buildLlmCompletedEvent, buildRunTerminalEvent, buildWorkflowNodeCompletedEvent, buildWorkflowNodesSubmittedEvent, recoverCompletedWorkflowNodes, recoverSubmittedWorkflowNodes, repairEventsForRecovery, } from "./session-repair.js";
 import { KernelPrimitivesDashboard } from "./kernel-primitives-dashboard.js";
-import { capabilityMarker, capabilitySkill, capabilityTool, capabilityCommandMount, capabilityCommandUnmount, kernelAction, kernelApply, kernelMaybeAction, forceCompact, messageToKernelMessage, skillMetadataToKernel, taskUpdateToKernel, toolResultToKernel, toolSchemaToKernel, } from "./kernel-step.js";
+import { capabilityMarker, capabilitySkill, capabilityTool, capabilityCommandMount, capabilityCommandUnmount, kernelAction, kernelApply, kernelMaybeAction, messageToKernelMessage, skillMetadataToKernel, taskUpdateToKernel, 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";
@@ -1077,7 +1077,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 (updated when the model's
         // `skill` tool call resolves). Drives the per-turn `activeSkill` metric → dwell measurement.
         let activeSkill;
@@ -1158,7 +1157,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)) {
@@ -1178,6 +1177,10 @@ export class RuntimeRunner {
                                 // I1: per-slot attribution forwarded into TurnMetrics. Undefined when the provider
                                 // doesn't honor cache_control (OpenAI-family auto-cache).
                                 turnCacheReadBySlot = usageEvt.cacheReadInputTokensBySlot;
+                                // Phase 4: stop_reason drives the kernel's max-output-tokens recovery. The closing
+                                // usage frame carries it; keep the last non-empty value seen this turn.
+                                if (usageEvt.stopReason)
+                                    turnStopReason = usageEvt.stopReason;
                                 continue;
                             }
                             yield evt;
@@ -1190,24 +1193,32 @@ export class RuntimeRunner {
                         }
                     }
                     catch (err) {
-                        // #2-B-ii: an aborted in-flight request surfaces as an AbortError — treat it as an interrupt
-                        // (the loop-top `interrupted` check converts it to a clean `timeout`/UserAbort), not a crash.
                         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. `continue` re-enters the loop: a recovered
+                            // turn persists its compaction archive via the loop-top appendObservations, and a
+                            // terminal `done` exits through `isTerminal()` into the run_terminal emit below.
+                            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, so embedders that terminate on `error` events don't see a
+                            // phantom failure mid-recovery.
+                            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 (provider yielded no error) —
@@ -1217,14 +1228,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,
@@ -1237,6 +1240,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);
                     if (!nextAction && this.pendingObservations.some(o => o.kind === "suspended")) {

package/dist/types.d.ts

@@ -93,6 +93,10 @@ export interface UsageEvent extends StreamEvent {
         tools?: number;
         messages?: number;
     };
+    /** Provider stop reason for the response — `max_tokens` (Anthropic) / `length` (OpenAI) flag an
+     *  output-cap truncation, which drives the kernel's max-output-tokens recovery. Absent when the
+     *  provider doesn't report one. */
+    stopReason?: string;
 }
 export type ToolChunk = string | {
     type: "text";

package/package.json

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