fix(runtime,elevenlabs): make the two red CI legs green

Both predate this PR; fixing them here so the branch can go green.

Browser E2E (all 10 specs timed out on `workflowRunnerReady`)
------------------------------------------------------------
Three runtime modules read bare `process.env` at MODULE scope, so importing
them threw `ReferenceError: process is not defined` in the browser bundle and
took the whole harness down at import time -- not at the call that wanted the
variable. `python-bridge-base`, `python-websocket-bridge` and
`python-stdio-bridge` now read env through a shared `safeProcessEnv()`,
promoted from `ProcessingContext` (where it already existed for exactly this
reason) into `@nodetool-ai/config` next to `IS_NODE`.

The harness config says it deliberately does not shim `process`, because the
real web app does not either -- so the guard belongs in the modules, not in a
bundler define.

elevenlabs-nodes (vi.mock hoisting)
-----------------------------------
`vi.mock("ws")` is hoisted above the module body, and the factory fires while
the runtime's python-websocket-bridge -- a static `ws` importer -- is
evaluated, before this file's own `class MockWebSocket` initializes. Hence
`Cannot access 'MockWebSocket' before initialization`. The mock class and the
state it records now live in `vi.hoisted`, which runs first by construction.

Also from review
----------------
- `BoundedHandle` no longer calls the handle at all once the run is cancelled.
  Decisions are serialized, so a cancel mid-decision leaves a queue behind it;
  waking the agent for each would spend money deciding the fate of a run that
  is already over. Cancel is free, not merely fast.
- A non-finite provider cost is recorded as spending rather than dropped.
  "Cannot add this up" must not read as "this was free", or the invocation
  would look cost-free and re-earn a retry after a real charge.
- `end_stream` now emits `generation_complete`. The invocation committed early,
  but it did commit, and skipping the marker would hide the kept outputs from
  replay and asset autosave -- the silent data loss the PRD forbids.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_011yMUYSSrceG3dTcX3XmsGJ

Author: claude

packages/config/src/index.ts

@@ -1,4 +1,9 @@
-export { IS_NODE, importNodeBuiltin, importHidden } from "./node-import.js";
+export {
+  IS_NODE,
+  safeProcessEnv,
+  importNodeBuiltin,
+  importHidden
+} from "./node-import.js";
 
 export {
   loadEnvironment,
@@ -14,7 +19,6 @@ export {
   GOOGLE_WORKSPACE_NAMESPACE
 } from "./google-workspace.js";
 
-
 export {
   registerSetting,
   getSettings,

packages/config/src/node-import.ts

@@ -16,6 +16,16 @@ export const IS_NODE =
   typeof (process as { versions?: { node?: string } }).versions?.node ===
     "string";
 
+/**
+ * `process` is undefined in browser/edge runtimes, where a bare `process.env`
+ * read throws `ReferenceError` — including at module scope, which takes the
+ * whole bundle down at import time rather than at the call that wanted the
+ * variable. Any module that can end up in a browser graph reads env through
+ * this instead.
+ */
+export const safeProcessEnv = (): Record<string, string | undefined> =>
+  typeof process !== "undefined" && process.env ? process.env : {};
+
 /**
  * Dynamic import that bundlers can't statically resolve.
  *

packages/elevenlabs-nodes/tests/realtime-stt.test.ts

@@ -1,57 +1,70 @@
-import { EventEmitter } from "node:events";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 
-const sentMessages: Array<Record<string, unknown>> = [];
-const lifecycleEvents: string[] = [];
+/**
+ * `vi.mock` factories are hoisted above the module body, and the `ws` mock
+ * is pulled in while the runtime's python-websocket-bridge is evaluated —
+ * before this file's own declarations initialize. So the mock and the state
+ * it records live in `vi.hoisted`, which runs first by construction.
+ */
+const { sentMessages, lifecycleEvents, MockWebSocket } = await vi.hoisted(
+  async () => {
+    const { EventEmitter } = await import("node:events");
 
-class MockWebSocket extends EventEmitter {
-  static readonly OPEN = 1;
-  static readonly CLOSED = 3;
+    const sentMessages: Array<Record<string, unknown>> = [];
+    const lifecycleEvents: string[] = [];
 
-  readyState = 0;
+    class MockWebSocket extends EventEmitter {
+      static readonly OPEN = 1;
+      static readonly CLOSED = 3;
 
-  constructor(_url: string, _opts?: Record<string, unknown>) {
-    super();
+      readyState = 0;
 
-    setTimeout(() => {
-      this.readyState = MockWebSocket.OPEN;
-      this.emit("open");
-      setTimeout(() => {
-        this.emit(
-          "message",
-          Buffer.from(JSON.stringify({ message_type: "session_started" }))
-        );
-      }, 0);
-    }, 0);
-  }
+      constructor(_url: string, _opts?: Record<string, unknown>) {
+        super();
+
+        setTimeout(() => {
+          this.readyState = MockWebSocket.OPEN;
+          this.emit("open");
+          setTimeout(() => {
+            this.emit(
+              "message",
+              Buffer.from(JSON.stringify({ message_type: "session_started" }))
+            );
+          }, 0);
+        }, 0);
+      }
+
+      send(payload: string): void {
+        const parsed = JSON.parse(payload) as Record<string, unknown>;
+        sentMessages.push(parsed);
+        if (parsed.commit === true) {
+          lifecycleEvents.push("commit");
+          setTimeout(() => {
+            this.emit(
+              "message",
+              Buffer.from(
+                JSON.stringify({
+                  message_type: "committed_transcript",
+                  text: "final transcript"
+                })
+              )
+            );
+          }, 0);
+        }
+      }
 
-  send(payload: string): void {
-    const parsed = JSON.parse(payload) as Record<string, unknown>;
-    sentMessages.push(parsed);
-    if (parsed.commit === true) {
-      lifecycleEvents.push("commit");
-      setTimeout(() => {
-        this.emit(
-          "message",
-          Buffer.from(
-            JSON.stringify({
-              message_type: "committed_transcript",
-              text: "final transcript"
-            })
-          )
-        );
-      }, 0);
+      close(): void {
+        lifecycleEvents.push("close");
+        this.readyState = MockWebSocket.CLOSED;
+        setTimeout(() => {
+          this.emit("close", 1000, Buffer.from(""));
+        }, 0);
+      }
     }
-  }
 
-  close(): void {
-    lifecycleEvents.push("close");
-    this.readyState = MockWebSocket.CLOSED;
-    setTimeout(() => {
-      this.emit("close", 1000, Buffer.from(""));
-    }, 0);
+    return { sentMessages, lifecycleEvents, MockWebSocket };
   }
-}
+);
 
 vi.mock("ws", () => ({
   WebSocket: MockWebSocket

packages/elevenlabs-nodes/tests/realtime-tts.test.ts

@@ -1,64 +1,79 @@
-import { EventEmitter } from "node:events";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 
-const sentMessages: Array<Record<string, unknown>> = [];
-const lifecycleEvents: string[] = [];
-const wsUrls: string[] = [];
-
-class MockWebSocket extends EventEmitter {
-  static readonly OPEN = 1;
-  static readonly CLOSED = 3;
-
-  readyState = 0;
-
-  constructor(url: string, _opts?: Record<string, unknown>) {
-    super();
-    wsUrls.push(url);
-
-    setTimeout(() => {
-      this.readyState = MockWebSocket.OPEN;
-      this.emit("open");
-    }, 0);
-  }
-
-  send(payload: string): void {
-    const parsed = JSON.parse(payload) as Record<string, unknown>;
-    sentMessages.push(parsed);
-
-    // Respond to EOS (empty text) with isFinal
-    if (parsed.text === "") {
-      lifecycleEvents.push("eos");
-      setTimeout(() => {
-        this.emit("message", Buffer.from(JSON.stringify({ isFinal: true })));
-      }, 0);
-      return;
-    }
+/**
+ * `vi.mock` factories are hoisted above the module body, and the `ws` mock
+ * is pulled in while the runtime's python-websocket-bridge is evaluated —
+ * before this file's own declarations initialize. So the mock and the state
+ * it records live in `vi.hoisted`, which runs first by construction.
+ */
+const { sentMessages, lifecycleEvents, wsUrls, MockWebSocket } =
+  await vi.hoisted(async () => {
+    const { EventEmitter } = await import("node:events");
+
+    const sentMessages: Array<Record<string, unknown>> = [];
+    const lifecycleEvents: string[] = [];
+    const wsUrls: string[] = [];
+
+    class MockWebSocket extends EventEmitter {
+      static readonly OPEN = 1;
+      static readonly CLOSED = 3;
+
+      readyState = 0;
+
+      constructor(url: string, _opts?: Record<string, unknown>) {
+        super();
+        wsUrls.push(url);
+
+        setTimeout(() => {
+          this.readyState = MockWebSocket.OPEN;
+          this.emit("open");
+        }, 0);
+      }
+
+      send(payload: string): void {
+        const parsed = JSON.parse(payload) as Record<string, unknown>;
+        sentMessages.push(parsed);
 
-    // Respond to non-init text with an audio chunk
-    const text = parsed.text as string | undefined;
-    if (text && text.trim() && text !== " ") {
-      setTimeout(() => {
-        this.emit(
-          "message",
-          Buffer.from(
-            JSON.stringify({
-              audio: "ZmFrZS1hdWRpbw==", // base64: "fake-audio"
-              isFinal: false
-            })
-          )
-        );
-      }, 0);
+        // Respond to EOS (empty text) with isFinal
+        if (parsed.text === "") {
+          lifecycleEvents.push("eos");
+          setTimeout(() => {
+            this.emit(
+              "message",
+              Buffer.from(JSON.stringify({ isFinal: true }))
+            );
+          }, 0);
+          return;
+        }
+
+        // Respond to non-init text with an audio chunk
+        const text = parsed.text as string | undefined;
+        if (text && text.trim() && text !== " ") {
+          setTimeout(() => {
+            this.emit(
+              "message",
+              Buffer.from(
+                JSON.stringify({
+                  audio: "ZmFrZS1hdWRpbw==", // base64: "fake-audio"
+                  isFinal: false
+                })
+              )
+            );
+          }, 0);
+        }
+      }
+
+      close(): void {
+        lifecycleEvents.push("close");
+        this.readyState = MockWebSocket.CLOSED;
+        setTimeout(() => {
+          this.emit("close", 1000, Buffer.from(""));
+        }, 0);
+      }
     }
-  }
-
-  close(): void {
-    lifecycleEvents.push("close");
-    this.readyState = MockWebSocket.CLOSED;
-    setTimeout(() => {
-      this.emit("close", 1000, Buffer.from(""));
-    }, 0);
-  }
-}
+
+    return { sentMessages, lifecycleEvents, wsUrls, MockWebSocket };
+  });
 
 vi.mock("ws", () => ({
   WebSocket: MockWebSocket

packages/kernel/src/actor.ts

@@ -1454,6 +1454,11 @@ export class NodeActor {
           case "end_stream":
             this._completeOutputSlots();
             this._latestResult = { ...(this._streamingCollectedOutputs ?? {}) };
+            // `end_stream` keeps what the stream produced, so the invocation
+            // committed — it just committed early. Skipping the commit marker
+            // would hide those outputs from replay and asset autosave, which
+            // is the "silent data loss dressed as success" the PRD forbids.
+            this._emitGenerationComplete(this._latestResult, inputs);
             return;
           default:
             throw err;

packages/kernel/src/supervisor.ts

@@ -292,11 +292,18 @@ export class BoundedHandle implements SupervisorHandle {
       return { verdict: { action: "fail" }, decidedBy: "bounds" };
     }
 
-    // The decision signal is the run signal plus a timeout, so `cancel()` is
-    // instant *and* free: a pending decision is killed, not un-awaited.
+    // Cancel is free, not merely fast. Decisions are serialized, so a cancel
+    // during a slow decision leaves a queue behind it; calling the handle for
+    // each of those would spend real money deciding the fate of a run that is
+    // already over.
+    if (runSignal.aborted) {
+      return { verdict: { action: "fail" }, decidedBy: "bounds" };
+    }
+
+    // The decision signal is the run signal plus a timeout, so an in-flight
+    // decision is killed rather than un-awaited.
     const timeout = new AbortController();
     const onRunAbort = () => timeout.abort();
-    if (runSignal.aborted) timeout.abort();
     runSignal.addEventListener("abort", onRunAbort, { once: true });
     const timer = setTimeout(
       () => timeout.abort(),

packages/kernel/tests/supervisor-handle.test.ts

@@ -124,20 +124,22 @@ describe("BoundedHandle — decisions and retries are capped", () => {
     }
   });
 
-  it("passes an already-aborted run signal straight through to the handle", async () => {
-    const seen: AbortSignal[] = [];
+  it("does not call the handle at all once the run is cancelled", async () => {
+    // Decisions are serialized, so a cancel mid-decision leaves a queue behind
+    // it. Waking the agent for each of those would spend money deciding the
+    // fate of a run that is already over.
+    let calls = 0;
     const bounded = new BoundedHandle({
-      async decide(_e, signal): Promise<DecisionOutcome> {
-        seen.push(signal);
+      async decide(): Promise<DecisionOutcome> {
+        calls++;
         return { verdict: { action: "skip" }, decidedBy: "agent" };
       },
       close() {}
     });
-    const cancelled = AbortSignal.abort();
-    const decision = await bounded.decide(escalation(), cancelled);
-    expect(seen[0].aborted).toBe(true);
-    // A verdict decided against a run that is already over is not applied.
+    const decision = await bounded.decide(escalation(), AbortSignal.abort());
+    expect(calls).toBe(0);
     expect(decision.verdict.action).toBe("fail");
+    expect(decision.decidedBy).toBe("bounds");
   });
 
   it("serializes decisions", async () => {

packages/kernel/tests/supervisor.test.ts

@@ -782,6 +782,13 @@ describe("supervisor — streaming", () => {
     // one the PRD reports as "kept the chunks it had finished".
     expect(result.status).toBe("completed");
     expect(received).toEqual(["chunk-0", "chunk-1"]);
+    // The invocation committed early, but it did commit: the marker replay and
+    // asset autosave key off must carry what the stream kept.
+    const committed = result.messages.filter(
+      (m) => m.type === "generation_complete" && m.node_id === "work"
+    );
+    expect(committed).toHaveLength(1);
+    expect(committed[0].outputs).toEqual({ value: "chunk-1" });
   });
 
   it("fails the node when routing a frame throws, without escalating", async () => {

packages/runtime/src/invocation-account.ts

@@ -45,11 +45,20 @@ export function inInvocationAccount<T>(
   return store.run(account, fn);
 }
 
-/** Charge the invocation currently on the async stack, if any. */
+/**
+ * Charge the invocation currently on the async stack, if any.
+ *
+ * A non-finite amount means a provider reported something we cannot add up —
+ * and "cannot add up" must not read as "free", or the invocation would look
+ * cost-free and re-earn a retry after a real charge. It is recorded as a
+ * nominal charge instead: the number is meaningless, the fact of spending is
+ * not. `costUsd` stays finite so the escalation record remains JSON-safe.
+ */
 export function recordInvocationCost(usd: number | undefined | null): void {
-  if (!usd) return;
+  if (usd === undefined || usd === null) return;
   const account = store.getStore();
-  if (account) account.costUsd += usd;
+  if (!account) return;
+  account.costUsd += Number.isFinite(usd) ? usd : Number.MIN_VALUE;
 }
 
 /** Mark the invocation currently on the async stack as having written an asset. */