libfx 0.0.10-dev.1213.g4c99a4b2ea67 → 0.0.10-dev.1217.g707afac508e1

package/README.md

@@ -1,8 +1,8 @@
 # libfx
 
 `libfx` is the small fx agent kernel for JavaScript hosts. One agent is one
-in-memory conversation with three operations: `prompt`, `checkpoint`, and
-`close`.
+in-memory conversation with `prompt`, `checkpoint`, and `close` operations,
+plus mid-turn steering on each running turn.
 
 ```sh
 npm install libfx
@@ -63,7 +63,12 @@ can resolve model capabilities and context capacity through the supplied
 
 `onEvent` receives runtime diagnostics separately from model output. Transport
 events report request start, response status and elapsed time, safe Gateway
-request metadata, and failures. Credentials and raw headers are never included.
+request metadata, failures, and throttled `transport.activity` liveness while a
+response body is streaming. Activity events include the attempt, current chunk
+bytes, and cumulative response bytes. They call the host directly at most once
+per 250 ms rather than entering the normalized turn queue, so an unread turn
+cannot accumulate heartbeat events. Credentials and raw headers are never
+included.
 
 libfx makes at most one automatic retry after a retryable transport failure and
 only before model output or tool effects escape. Cancellation prevents a retry.
@@ -77,6 +82,7 @@ blocks. It returns an async iterable of normalized events:
   64 KiB of JSON arrive as an `inputPreview` string prefix plus
   `inputTruncated: true` instead; the tool still receives complete arguments.
 - `tool_end`
+- `user_message` with `text` when accepted mid-turn steering enters the turn
 
 Consume the turn while it runs, then await `turn.result`. Streamed text and
 tool results are lossless and backpressured: a slow reader pauses production
@@ -121,9 +127,29 @@ leave the process. Prompt images are retained in checkpoints within the
 existing 4 MiB checkpoint bound, so a restored agent can refer to earlier
 images on either backend.
 
-Only one prompt may run at a time. `checkpoint()` is idle-only and returns
-opaque, bounded, versioned bytes. Restore them only when creating a fresh
-agent:
+Only one top-level prompt may run at a time. While it runs,
+`await turn.steer(text)` appends guidance at the next safe model boundary
+without discarding the in-flight response or completed tool work. Steering also
+accepts an array of text blocks; image and resource steering blocks are rejected.
+Each message is limited to 64 KiB, with at most 64 queued messages and 1 MiB of
+queued steering text. Accepted steering appears as a `user_message` event before
+the model's continued output. Calling `steer()` after the turn settles rejects
+with `no prompt is running`.
+
+```js
+const turn = agent.prompt("Build the feature.");
+for await (const event of turn) {
+  if (event.type === "tool_end" && event.name === "read_file") {
+    await turn.steer("Keep the public API backward compatible.");
+  }
+}
+```
+
+Cancelling a steered turn drops any guidance that has not reached a safe
+boundary and releases its queue. Applied guidance is part of the same history
+turn, so an idle `checkpoint()` includes the full steered conversation.
+`checkpoint()` returns opaque, bounded, versioned bytes. Restore them only when
+creating a fresh agent:
 
 ```js
 const restored = await createFxAgent({ apiKey, model, checkpoint });
@@ -178,8 +204,27 @@ const agent = await createFxAgent({
 });
 ```
 
-The JavaScript host is the authority for tool effects. The same descriptors,
-schemas, cancellation, results, and events are used by N-API and WebAssembly.
+Gateway web search can run at the provider instead of in the JavaScript host.
+Mark its canonical tool name with `providerExecuted: true` and omit `execute`:
+
+```js
+const agent = await createFxAgent({
+  apiKey,
+  tools: [{ name: "web_search", providerExecuted: true }],
+});
+```
+
+The kernel supplies the canonical schema and Gateway advertisement. Currently
+`web_search` is the supported provider-executed descriptor; unknown or local
+names reject agent creation. Provider-executed tools do not
+call host code or require a separate provider key; their `tool_start` and
+`tool_end` events, results, and checkpoint history use the same turn contract.
+Their built-in permission policy is enforced when the request is projected, as
+there is no local call-time effect to approve.
+
+For ordinary tools, the JavaScript host is the authority for effects. The same
+descriptors, schemas, cancellation, results, and events are used by N-API and
+WebAssembly.
 Cancelling a prompt aborts its tools' signals and stops waiting for their
 callbacks. Late results and rejections are ignored. Tools remain responsible
 for stopping their own work when their signal is aborted.

package/fx-sdk.js

@@ -16,6 +16,7 @@ const maxUrlBytes = 16 * 1024;
 const maxModelCatalogBytes = 4 * 1024 * 1024;
 const maxModelCatalogEntries = 10_000;
 const streamReadsPerTaskYield = 32;
+const transportActivityIntervalMs = 250;
 const maxUnreadEventBytes = 1024 * 1024;
 const maxUnreadEvents = 256;
 // Prompt image limits mirror the host tool result image contract: the kernel
@@ -28,6 +29,9 @@ const maxPromptImagesBytes = 8 * 1024 * 1024;
 // envelope allowance covers the method key and request id.
 const maxPromptFrameBytes = 8 * 1024 * 1024;
 const promptFrameEnvelopeBytes = 128;
+const maxSteeringMessageBytes = 64 * 1024;
+const maxSteeringMessages = 64;
+const maxSteeringQueueBytes = 1024 * 1024;
 // tool_start events carry a bounded preview of the tool input; larger inputs
 // are marked truncated instead of dropped or sent whole.
 const maxToolStartInputBytes = 64 * 1024;
@@ -444,6 +448,9 @@ function createRuntime(options) {
   const stdin = new ByteQueue();
   const streams = new Map();
   const httpRequests = new Set();
+  const steering = [];
+  let steeringBytes = 0;
+  let steeringOpen = false;
   const workspaceExecs = new Set();
   const workspace = prepareWorkspaceAdapter(options.workspace);
   const args = ["fx", ...(options.args || [])];
@@ -656,6 +663,7 @@ function createRuntime(options) {
       state.readResult = null;
       if (done) return 0;
       if (!value?.length) return null;
+      options.onTransportChunk?.(value.length);
       return copy(value);
     };
     const immediate = consume();
@@ -709,6 +717,36 @@ function createRuntime(options) {
     });
   }
 
+  function clearSteering() {
+    steering.length = 0;
+    steeringBytes = 0;
+  }
+
+  function queueSteering(text) {
+    if (!steeringOpen) throw new Error("no prompt is running");
+    const value = encoder.encode(text);
+    if (value.length === 0) throw new TypeError("steering text cannot be empty");
+    if (value.length > maxSteeringMessageBytes) {
+      throw new RangeError(`steering text exceeds the ${maxSteeringMessageBytes} byte libfx limit`);
+    }
+    if (steering.length >= maxSteeringMessages || value.length > maxSteeringQueueBytes - steeringBytes) {
+      throw new Error("steering queue is full");
+    }
+    steering.push(value);
+    steeringBytes += value.length;
+  }
+
+  function steeringTake(outputPtr, outputCap) {
+    const value = steering[0];
+    if (!value) return 0;
+    const output = checkedBytes(outputPtr, outputCap);
+    if (!output || value.length > output.length) return -1;
+    output.subarray(0, value.length).set(value);
+    steering.shift();
+    steeringBytes -= value.length;
+    return value.length;
+  }
+
   let pendingHostToolResult = null;
   function hostToolCall(namePtr, nameLen, argumentsPtr, argumentsLen, outputPtr, outputCap, statusPtr) {
     pendingHostToolResult = null;
@@ -1078,6 +1116,8 @@ function createRuntime(options) {
       return chunk.length;
     },
     fx_host_tool_result_release() { pendingHostToolResult = null; },
+    fx_steering_take: steeringTake,
+    fx_steering_close() { steeringOpen = false; clearSteering(); },
     fx_open_url: new WebAssembly.Suspending(openUrl),
     fx_oauth_session_load: new WebAssembly.Suspending(oauthSessionLoad),
     fx_oauth_session_commit: new WebAssembly.Suspending(oauthSessionCommit),
@@ -1105,7 +1145,10 @@ function createRuntime(options) {
     setInstance(value) { instance = value; },
     write(data) { stdin.push(typeof data === "string" ? encoder.encode(data) : data); },
     wake() { stdin.wake(); },
-    closeStdin() { stdin.close(); },
+    closeStdin() { steeringOpen = false; clearSteering(); stdin.close(); },
+    openSteering() { clearSteering(); steeringOpen = true; },
+    steer: queueSteering,
+    closeSteering() { steeringOpen = false; clearSteering(); },
     abortHostEffects,
     abort(error) {
       aborted = true;
@@ -1274,19 +1317,42 @@ function normalizePromptInput(input) {
   });
 }
 
+function normalizeSteeringInput(input) {
+  const blocks = normalizePromptInput(input);
+  if (blocks.some((block) => block.type !== "text")) {
+    throw new TypeError("steering accepts only text blocks");
+  }
+  const text = blocks.map((block) => block.text).join("\n");
+  if (text.length === 0) throw new TypeError("steering text cannot be empty");
+  if (encoder.encode(text).length > maxSteeringMessageBytes) {
+    throw new RangeError(`steering text exceeds the ${maxSteeringMessageBytes} byte libfx limit`);
+  }
+  return text;
+}
+
 function normalizeHostTools(value) {
   if (value === undefined) return { descriptors: [], executors: new Map() };
   if (!Array.isArray(value)) throw new TypeError("tools must be an array");
   if (value.length > 64) throw new RangeError("tools cannot contain more than 64 entries");
   const descriptors = [];
   const executors = new Map();
+  const names = new Set();
   for (const [index, tool] of value.entries()) {
     if (!tool || typeof tool !== "object") throw new TypeError(`tool ${index} must be an object`);
-    const { name, description, inputSchema, execute } = tool;
+    const { name, description, inputSchema, execute, providerExecuted } = tool;
     if (typeof name !== "string" || !/^[A-Za-z0-9_-]{1,64}$/.test(name)) {
       throw new TypeError(`tool ${index} has an invalid name`);
     }
-    if (executors.has(name)) throw new TypeError(`duplicate tool name: ${name}`);
+    if (names.has(name)) throw new TypeError(`duplicate tool name: ${name}`);
+    names.add(name);
+    if (providerExecuted !== undefined && typeof providerExecuted !== "boolean") {
+      throw new TypeError(`tool ${name} providerExecuted must be a boolean`);
+    }
+    if (providerExecuted === true) {
+      if (execute !== undefined) throw new TypeError(`provider-executed tool ${name} must not define execute()`);
+      descriptors.push({ name, providerExecuted: true });
+      continue;
+    }
     if (typeof description !== "string") throw new TypeError(`tool ${name} requires a description`);
     if (typeof execute !== "function") throw new TypeError(`tool ${name} requires execute()`);
     if (!inputSchema || typeof inputSchema !== "object" || Array.isArray(inputSchema)) {
@@ -1392,6 +1458,10 @@ export async function createFxAgent(options = {}) {
     for (let attemptIndex = 0; attemptIndex < 2; attemptIndex++) {
       const startedAt = performance.now();
       const attempt = activeTurn ? ++activeTurn.transportAttempts : attemptIndex + 1;
+      if (activeTurn) {
+        activeTurn.transportBytes = 0;
+        activeTurn.lastTransportActivityAt = null;
+      }
       emit("transport.start", { attempt, method, endpoint, model: options.model });
       try {
         if (activeTurn?.cancelled) {
@@ -1481,6 +1551,19 @@ export async function createFxAgent(options = {}) {
     args: ["acp"],
     env: agentEnvironment(options),
     hostToolExecutor: executeHostTool,
+    onTransportChunk(byteLength) {
+      const turn = activeTurn;
+      if (!isCurrentTurn(turn) || !Number.isSafeInteger(byteLength) || byteLength <= 0) return;
+      turn.transportBytes += byteLength;
+      const now = performance.now();
+      if (turn.lastTransportActivityAt !== null && now - turn.lastTransportActivityAt < transportActivityIntervalMs) return;
+      turn.lastTransportActivityAt = now;
+      emit("transport.activity", {
+        attempt: turn.transportAttempts,
+        chunkBytes: byteLength,
+        totalBytes: turn.transportBytes,
+      });
+    },
   };
   const runtime = options.runtimeFactory
     ? await options.runtimeFactory(runtimeOptions)
@@ -1606,6 +1689,9 @@ export async function createFxAgent(options = {}) {
         const delta = update.content?.text;
         return delta ? { type: "reasoning_delta", delta } : null;
       }
+      if (update.sessionUpdate === "user_message_chunk" && update.content?.type === "text") {
+        return { type: "user_message", text: update.content.text };
+      }
       if (update.sessionUpdate === "tool_call") {
         toolNames.set(update.toolCallId, update.name || update.toolName || update.title || "tool");
         if (started.has(update.toolCallId)) return null;
@@ -1637,6 +1723,7 @@ export async function createFxAgent(options = {}) {
     void result.catch(() => {});
     return {
       cancel() { rawTurn.cancel(); },
+      steer(input) { return rawTurn.steer(normalizeSteeringInput(input)); },
       [Symbol.asyncIterator]() {
         const iterator = (async function* () {
           for await (const update of rawTurn) {
@@ -1712,10 +1799,34 @@ export async function createFxAgent(options = {}) {
       },
       toolControllers,
       transportAttempts: 0,
+      transportBytes: 0,
+      lastTransportActivityAt: null,
       get cancelled() { return cancelled; },
+      steer(text) {
+        if (finished || cancelled || activeTurn !== turn) {
+          return Promise.reject(new Error("no prompt is running"));
+        }
+        let accepted;
+        try {
+          if (typeof runtime.steer === "function") {
+            runtime.steer(text);
+            void turn.push({
+              sessionUpdate: "user_message_chunk",
+              content: { type: "text", text },
+            });
+            accepted = Promise.resolve();
+          } else {
+            accepted = request("libfx/steer", { sessionId, text });
+          }
+        } catch (error) {
+          return Promise.reject(error);
+        }
+        return accepted;
+      },
       cancel() {
         if (finished || cancelled) return;
         cancelled = true;
+        runtime.closeSteering?.();
         resumeOutput?.();
         resumeOutput = null;
         send({ jsonrpc: "2.0", method: "session/cancel", params: { sessionId } });
@@ -1748,6 +1859,7 @@ export async function createFxAgent(options = {}) {
       return turn;
     }
     activeTurn = turn;
+    runtime.openSteering?.();
     const abort = () => turn.cancel();
     signal?.addEventListener("abort", abort, { once: true });
     turn.result = request("session/prompt", { sessionId, prompt })
@@ -1763,6 +1875,7 @@ export async function createFxAgent(options = {}) {
         resumeOutput = null;
         signal?.removeEventListener("abort", abort);
         if (activeTurn === turn) activeTurn = null;
+        runtime.closeSteering?.();
         toolControllers.clear();
         if (discardedBytes) emit("output.discarded", { reason: "cancelled", bytes: discardedBytes });
         for (const waiter of waiters.splice(0)) {

package/node.cjs

@@ -193,6 +193,7 @@ var maxUrlBytes = 16 * 1024;
 var maxModelCatalogBytes = 4 * 1024 * 1024;
 var maxModelCatalogEntries = 1e4;
 var streamReadsPerTaskYield = 32;
+var transportActivityIntervalMs = 250;
 var maxUnreadEventBytes = 1024 * 1024;
 var maxUnreadEvents = 256;
 var maxPromptImages = 8;
@@ -200,6 +201,9 @@ var maxPromptImageDataBytes = 5 * 1024 * 1024;
 var maxPromptImagesBytes = 8 * 1024 * 1024;
 var maxPromptFrameBytes = 8 * 1024 * 1024;
 var promptFrameEnvelopeBytes = 128;
+var maxSteeringMessageBytes = 64 * 1024;
+var maxSteeringMessages = 64;
+var maxSteeringQueueBytes = 1024 * 1024;
 var maxToolStartInputBytes = 64 * 1024;
 function boundedString(value, name, maxBytes, required) {
   if (value === undefined && !required)
@@ -637,6 +641,9 @@ function createRuntime(options) {
   const stdin = new ByteQueue;
   const streams = new Map;
   const httpRequests = new Set;
+  const steering = [];
+  let steeringBytes = 0;
+  let steeringOpen = false;
   const workspaceExecs = new Set;
   const workspace = prepareWorkspaceAdapter(options.workspace);
   const args = ["fx", ...options.args || []];
@@ -872,6 +879,7 @@ function createRuntime(options) {
         return 0;
       if (!value?.length)
         return null;
+      options.onTransportChunk?.(value.length);
       return copy(value);
     };
     const immediate = consume();
@@ -928,6 +936,37 @@ function createRuntime(options) {
       httpRequests.delete(controller);
     });
   }
+  function clearSteering() {
+    steering.length = 0;
+    steeringBytes = 0;
+  }
+  function queueSteering(text) {
+    if (!steeringOpen)
+      throw new Error("no prompt is running");
+    const value = encoder.encode(text);
+    if (value.length === 0)
+      throw new TypeError("steering text cannot be empty");
+    if (value.length > maxSteeringMessageBytes) {
+      throw new RangeError(`steering text exceeds the ${maxSteeringMessageBytes} byte libfx limit`);
+    }
+    if (steering.length >= maxSteeringMessages || value.length > maxSteeringQueueBytes - steeringBytes) {
+      throw new Error("steering queue is full");
+    }
+    steering.push(value);
+    steeringBytes += value.length;
+  }
+  function steeringTake(outputPtr, outputCap) {
+    const value = steering[0];
+    if (!value)
+      return 0;
+    const output = checkedBytes(outputPtr, outputCap);
+    if (!output || value.length > output.length)
+      return -1;
+    output.subarray(0, value.length).set(value);
+    steering.shift();
+    steeringBytes -= value.length;
+    return value.length;
+  }
   let pendingHostToolResult = null;
   function hostToolCall(namePtr, nameLen, argumentsPtr, argumentsLen, outputPtr, outputCap, statusPtr) {
     pendingHostToolResult = null;
@@ -1386,6 +1425,11 @@ function createRuntime(options) {
     fx_host_tool_result_release() {
       pendingHostToolResult = null;
     },
+    fx_steering_take: steeringTake,
+    fx_steering_close() {
+      steeringOpen = false;
+      clearSteering();
+    },
     fx_open_url: new WebAssembly.Suspending(openUrl),
     fx_oauth_session_load: new WebAssembly.Suspending(oauthSessionLoad),
     fx_oauth_session_commit: new WebAssembly.Suspending(oauthSessionCommit),
@@ -1420,8 +1464,19 @@ function createRuntime(options) {
       stdin.wake();
     },
     closeStdin() {
+      steeringOpen = false;
+      clearSteering();
       stdin.close();
     },
+    openSteering() {
+      clearSteering();
+      steeringOpen = true;
+    },
+    steer: queueSteering,
+    closeSteering() {
+      steeringOpen = false;
+      clearSteering();
+    },
     abortHostEffects,
     abort(error) {
       aborted = true;
@@ -1625,6 +1680,20 @@ function normalizePromptInput(input) {
     throw new TypeError(`unsupported prompt block type: ${String(block.type)}`);
   });
 }
+function normalizeSteeringInput(input) {
+  const blocks = normalizePromptInput(input);
+  if (blocks.some((block) => block.type !== "text")) {
+    throw new TypeError("steering accepts only text blocks");
+  }
+  const text = blocks.map((block) => block.text).join(`
+`);
+  if (text.length === 0)
+    throw new TypeError("steering text cannot be empty");
+  if (encoder.encode(text).length > maxSteeringMessageBytes) {
+    throw new RangeError(`steering text exceeds the ${maxSteeringMessageBytes} byte libfx limit`);
+  }
+  return text;
+}
 function normalizeHostTools(value) {
   if (value === undefined)
     return { descriptors: [], executors: new Map };
@@ -1634,15 +1703,26 @@ function normalizeHostTools(value) {
     throw new RangeError("tools cannot contain more than 64 entries");
   const descriptors = [];
   const executors = new Map;
+  const names = new Set;
   for (const [index, tool] of value.entries()) {
     if (!tool || typeof tool !== "object")
       throw new TypeError(`tool ${index} must be an object`);
-    const { name, description, inputSchema, execute } = tool;
+    const { name, description, inputSchema, execute, providerExecuted } = tool;
     if (typeof name !== "string" || !/^[A-Za-z0-9_-]{1,64}$/.test(name)) {
       throw new TypeError(`tool ${index} has an invalid name`);
     }
-    if (executors.has(name))
+    if (names.has(name))
       throw new TypeError(`duplicate tool name: ${name}`);
+    names.add(name);
+    if (providerExecuted !== undefined && typeof providerExecuted !== "boolean") {
+      throw new TypeError(`tool ${name} providerExecuted must be a boolean`);
+    }
+    if (providerExecuted === true) {
+      if (execute !== undefined)
+        throw new TypeError(`provider-executed tool ${name} must not define execute()`);
+      descriptors.push({ name, providerExecuted: true });
+      continue;
+    }
     if (typeof description !== "string")
       throw new TypeError(`tool ${name} requires a description`);
     if (typeof execute !== "function")
@@ -1760,6 +1840,10 @@ async function createFxAgent(options = {}) {
     for (let attemptIndex = 0;attemptIndex < 2; attemptIndex++) {
       const startedAt = performance.now();
       const attempt = activeTurn ? ++activeTurn.transportAttempts : attemptIndex + 1;
+      if (activeTurn) {
+        activeTurn.transportBytes = 0;
+        activeTurn.lastTransportActivityAt = null;
+      }
       emit("transport.start", { attempt, method, endpoint, model: options.model });
       try {
         if (activeTurn?.cancelled) {
@@ -1855,7 +1939,22 @@ async function createFxAgent(options = {}) {
     fetch: transportFetch,
     args: ["acp"],
     env: agentEnvironment(options),
-    hostToolExecutor: executeHostTool
+    hostToolExecutor: executeHostTool,
+    onTransportChunk(byteLength) {
+      const turn = activeTurn;
+      if (!isCurrentTurn(turn) || !Number.isSafeInteger(byteLength) || byteLength <= 0)
+        return;
+      turn.transportBytes += byteLength;
+      const now = performance.now();
+      if (turn.lastTransportActivityAt !== null && now - turn.lastTransportActivityAt < transportActivityIntervalMs)
+        return;
+      turn.lastTransportActivityAt = now;
+      emit("transport.activity", {
+        attempt: turn.transportAttempts,
+        chunkBytes: byteLength,
+        totalBytes: turn.transportBytes
+      });
+    }
   };
   const runtime = options.runtimeFactory ? await options.runtimeFactory(runtimeOptions) : await instantiate(runtimeOptions);
   emit("runtime.ready");
@@ -2008,6 +2107,9 @@ async function createFxAgent(options = {}) {
         const delta = update.content?.text;
         return delta ? { type: "reasoning_delta", delta } : null;
       }
+      if (update.sessionUpdate === "user_message_chunk" && update.content?.type === "text") {
+        return { type: "user_message", text: update.content.text };
+      }
       if (update.sessionUpdate === "tool_call") {
         toolNames.set(update.toolCallId, update.name || update.toolName || update.title || "tool");
         if (started.has(update.toolCallId))
@@ -2041,6 +2143,9 @@ async function createFxAgent(options = {}) {
       cancel() {
         rawTurn.cancel();
       },
+      steer(input) {
+        return rawTurn.steer(normalizeSteeringInput(input));
+      },
       [Symbol.asyncIterator]() {
         const iterator = async function* () {
           for await (const update of rawTurn) {
@@ -2141,13 +2246,37 @@ async function createFxAgent(options = {}) {
       },
       toolControllers,
       transportAttempts: 0,
+      transportBytes: 0,
+      lastTransportActivityAt: null,
       get cancelled() {
         return cancelled;
       },
+      steer(text) {
+        if (finished || cancelled || activeTurn !== turn) {
+          return Promise.reject(new Error("no prompt is running"));
+        }
+        let accepted;
+        try {
+          if (typeof runtime.steer === "function") {
+            runtime.steer(text);
+            turn.push({
+              sessionUpdate: "user_message_chunk",
+              content: { type: "text", text }
+            });
+            accepted = Promise.resolve();
+          } else {
+            accepted = request("libfx/steer", { sessionId, text });
+          }
+        } catch (error) {
+          return Promise.reject(error);
+        }
+        return accepted;
+      },
       cancel() {
         if (finished || cancelled)
           return;
         cancelled = true;
+        runtime.closeSteering?.();
         resumeOutput?.();
         resumeOutput = null;
         send({ jsonrpc: "2.0", method: "session/cancel", params: { sessionId } });
@@ -2187,6 +2316,7 @@ async function createFxAgent(options = {}) {
       return turn;
     }
     activeTurn = turn;
+    runtime.openSteering?.();
     const abort = () => turn.cancel();
     signal?.addEventListener("abort", abort, { once: true });
     turn.result = request("session/prompt", { sessionId, prompt }).then((response) => ({ stopReason: cancelled ? "cancelled" : response.stopReason, usage: response.usage })).catch((error) => {
@@ -2201,6 +2331,7 @@ async function createFxAgent(options = {}) {
       signal?.removeEventListener("abort", abort);
       if (activeTurn === turn)
         activeTurn = null;
+      runtime.closeSteering?.();
       toolControllers.clear();
       if (discardedBytes)
         emit("output.discarded", { reason: "cancelled", bytes: discardedBytes });
@@ -2584,6 +2715,7 @@ function createNativeCoreRuntime(addon, options) {
       if (response.body) {
         for await (const chunk of response.body) {
           const buffer = Buffer.from(chunk);
+          options.onTransportChunk?.(buffer.length);
           let offset = 0;
           while (offset < buffer.length) {
             const end = Math.min(offset + 65536, buffer.length);

package/node.js

@@ -407,6 +407,7 @@ function createNativeCoreRuntime(addon, options) {
       if (response.body) {
         for await (const chunk of response.body) {
           const buffer = Buffer.from(chunk);
+          options.onTransportChunk?.(buffer.length);
           let offset = 0;
           while (offset < buffer.length) {
             const end = Math.min(offset + 64 * 1024, buffer.length);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "libfx",
-  "version": "0.0.10-dev.1213.g4c99a4b2ea67",
+  "version": "0.0.10-dev.1217.g707afac508e1",
   "description": "Embed fx agents and terminals in JavaScript hosts",
   "type": "module",
   "repository": {