@boardwalk-labs/runner 0.2.12 → 0.2.14

package/dist/runtime/direct_inference.d.ts

@@ -23,7 +23,7 @@ export interface DirectInferenceDeps {
 }
 /** One model turn, straight to the org's endpoint. Returns the ChatTurn + canonical model ref;
  *  BYO carries no platform cost (costMicros stays 0 — BYO is never metered). */
-export declare function streamDirectTurn(deps: DirectInferenceDeps, entry: ByoInferenceProvider, req: DirectTurnRequest, onDelta: ((text: string) => void) | undefined, 
+export declare function streamDirectTurn(deps: DirectInferenceDeps, entry: ByoInferenceProvider, req: DirectTurnRequest, onDelta: ((text: string) => void) | undefined, onReasoningDelta: ((text: string) => void) | undefined, 
 /** Register the resolved key with the CURRENT leaf's engine redactor, before the model call.
  *  The key resolves mid-leaf (after the leaf's redactor snapshot is seeded), so without this a
  *  provider that echoes the Authorization header in an error body would leak it into that

package/dist/runtime/direct_inference.js

@@ -53,7 +53,7 @@ export function directProviderFor(registry, provider) {
 }
 /** One model turn, straight to the org's endpoint. Returns the ChatTurn + canonical model ref;
  *  BYO carries no platform cost (costMicros stays 0 — BYO is never metered). */
-export async function streamDirectTurn(deps, entry, req, onDelta, 
+export async function streamDirectTurn(deps, entry, req, onDelta, onReasoningDelta, 
 /** Register the resolved key with the CURRENT leaf's engine redactor, before the model call.
  *  The key resolves mid-leaf (after the leaf's redactor snapshot is seeded), so without this a
  *  provider that echoes the Authorization header in an error body would leak it into that
@@ -77,6 +77,7 @@ registerSecret) {
     const io = {
         ...(deps.fetchImpl !== undefined ? { fetchImpl: deps.fetchImpl } : {}),
         ...(onDelta !== undefined ? { onDelta } : {}),
+        ...(onReasoningDelta !== undefined ? { onReasoningDelta } : {}),
     };
     log.debug("direct_turn", { provider: entry.name, source: entry.source, model: req.model });
     const turn = entry.source === "anthropic"

package/dist/runtime/leaf_executor.js

@@ -218,7 +218,7 @@ export class EngineLeafExecutor {
                 messages: req.messages,
                 tools: req.tools,
                 ...(req.reasoning !== undefined ? { reasoning: req.reasoning } : {}),
-            }, providerIo.onDelta, 
+            }, providerIo.onDelta, providerIo.onReasoningDelta, 
             // Register the org's key with THIS leaf's redactor before the model call, so an error
             // body echoing it is scrubbed from the leaf's run events (not just the terminal error).
             (value) => redactor.add("byo-key", value));
@@ -237,6 +237,9 @@ export class EngineLeafExecutor {
             if (frame.kind === "delta") {
                 providerIo.onDelta?.(frame.text);
             }
+            else if (frame.kind === "reasoning") {
+                providerIo.onReasoningDelta?.(frame.text);
+            }
             else if (frame.kind === "result") {
                 // contextTokens (when the broker knows the served model's window) lets the engine's loop
                 // size compaction against the real window instead of a conservative default.
@@ -331,6 +334,8 @@ export function toRunEventBody(body, identity) {
             return { kind: "text_delta", blockId: body.blockId, text: body.text };
         case "text_end":
             return { kind: "text_end", blockId: body.blockId };
+        case "reasoning_delta":
+            return { kind: "reasoning_delta", text: body.text };
         case "tool_call_start":
             return { kind: "tool_call_start", toolCallId: body.toolCallId, toolName: body.toolName };
         case "tool_call_input_complete":

package/dist/runtime/wire/inference_proxy.d.ts

@@ -36,6 +36,9 @@ export interface ProxyError {
 export type InferenceFrame = {
     kind: "delta";
     text: string;
+} | {
+    kind: "reasoning";
+    text: string;
 } | {
     kind: "result";
     turn: ChatTurn;
@@ -58,6 +61,9 @@ export declare function serializeInferenceRequest(req: InferenceProxyRequest): s
 export declare function parseInferenceRequest(body: string): InferenceProxyRequest;
 /** Serialize one streamed text delta as a single NDJSON line (trailing "\n" included). */
 export declare function serializeDeltaFrame(text: string): string;
+/** Serialize one streamed reasoning/thinking delta as a single NDJSON line. Separate from a `delta`
+ *  frame so the worker routes it to the thinking trace, never into the assistant answer. */
+export declare function serializeReasoningFrame(text: string): string;
 /** Serialize the single terminal turn result as one NDJSON line. `costMicros` is the turn's EXACT
  *  upstream cost (the managed provider's per-request cost × 1e6) on the managed lane — 0 for BYO or when unavailable.
  *  The worker feeds it to the budget guardrail so `max_usd` tracks real spend, not a token estimate. */

package/dist/runtime/wire/inference_proxy.js

@@ -78,6 +78,11 @@ export function parseInferenceRequest(body) {
 export function serializeDeltaFrame(text) {
     return `${JSON.stringify({ t: "delta", text })}\n`;
 }
+/** Serialize one streamed reasoning/thinking delta as a single NDJSON line. Separate from a `delta`
+ *  frame so the worker routes it to the thinking trace, never into the assistant answer. */
+export function serializeReasoningFrame(text) {
+    return `${JSON.stringify({ t: "reasoning", text })}\n`;
+}
 /** Serialize the single terminal turn result as one NDJSON line. `costMicros` is the turn's EXACT
  *  upstream cost (the managed provider's per-request cost × 1e6) on the managed lane — 0 for BYO or when unavailable.
  *  The worker feeds it to the budget guardrail so `max_usd` tracks real spend, not a token estimate. */
@@ -110,6 +115,8 @@ export function parseInferenceFrame(line) {
     switch (rec.t) {
         case "delta":
             return { kind: "delta", text: typeof rec.text === "string" ? rec.text : "" };
+        case "reasoning":
+            return { kind: "reasoning", text: typeof rec.text === "string" ? rec.text : "" };
         case "result":
             return {
                 kind: "result",
@@ -129,7 +136,11 @@ export function parseInferenceFrame(line) {
         case "ping":
             return { kind: "ping" };
         default:
-            throw new Error(`Unknown inference frame kind: ${String(rec.t)}`);
+            // Lenient consumer: a well-formed frame whose kind this runner predates must not crash the
+            // stream — a newer broker may emit frames an older runner can't name (this is how `reasoning`
+            // itself reaches a fleet mid-rollout). Treat it as a no-op heartbeat, which the leaf loop
+            // already ignores. Only a genuinely malformed line (caught above) is fatal.
+            return { kind: "ping" };
     }
 }
 /** Narrow a parsed `result` frame's turn back to the engine's `ChatTurn`, failing closed on shape —

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@boardwalk-labs/runner",
-  "version": "0.2.12",
+  "version": "0.2.14",
   "description": "Boardwalk self-hosted runner: execute cloud-scheduled runs on your own machines. Currently: the canonical runner contract types.",
   "license": "Apache-2.0",
   "repository": {
@@ -53,8 +53,8 @@
     "prebuild": "prebuildify --napi --strip -t 24.0.0"
   },
   "dependencies": {
-    "@boardwalk-labs/engine": "0.2.10",
-    "@boardwalk-labs/workflow": "0.2.2",
+    "@boardwalk-labs/engine": "0.2.12",
+    "@boardwalk-labs/workflow": "0.2.5",
     "@modelcontextprotocol/sdk": "^1.29.0",
     "node-gyp-build": "^4.8.4",
     "tar": "^7.5.16",