nanocodex 0.1.1 → 0.2.0

package/README.md

@@ -17,6 +17,9 @@ const agent = await Agent.create({
 const turn = agent.turn.prompt({ input: "Build the thing." });
 console.log(await turn.result());
 
+await agent.session.setThinking("high");
+await agent.session.setFastMode(true);
+
 const branch = await agent.session.fork({ at: turn });
 console.log(await branch.turn.prompt({ input: "Try another approach." }).result());
 
@@ -24,11 +27,113 @@ const followOn = Actions.turn.prompt(agent, { input: "Now explain it." });
 console.log(await Actions.turn.getResult(followOn));
 ```
 
+Node and browser applications can instead pay through MPP without an OpenAI
+API key. Pass an MPP session with a `ws(endpoint)` method; an `mppx` Tempo
+session manager has this shape. Nanocodex defaults the socket to
+`wss://openai.mpp.tempo.xyz/v1/responses` when `mpp` is present.
+
+```js
+import { Agent } from "nanocodex/node";
+import { Expiry } from "accounts";
+import { Provider } from "accounts/cli";
+import { tempo } from "mppx/client";
+import { parseUnits } from "viem";
+import { connect } from "viem/experimental/erc7846";
+import WebSocket from "ws";
+
+const pathUsd = "0x20c0000000000000000000000000000000000000";
+const provider = Provider.create({ mpp: false });
+if (!provider.store.persist.hasHydrated()) {
+  await new Promise((resolve) => provider.store.persist.onFinishHydration(resolve));
+}
+const status = await provider.getAccessKeyStatus();
+if (status === "missing" || status === "expired") {
+  await connect(provider.getClient(), {
+    capabilities: { authorizeAccessKey: {
+      expiry: Expiry.days(1),
+      limits: [{ token: pathUsd, limit: parseUnits("25", 6) }],
+    } },
+  });
+}
+const root = provider.getAccount();
+const account = await provider.store.accessKeys.select({
+  account: root.address,
+  chainId: provider.getClient().chain.id,
+});
+if (!account) throw new Error("Tempo account has no usable access key");
+console.error(`Tempo access-key signer: ${account.accessKeyAddress}`);
+const mpp = tempo.session.manager({
+  account,
+  autoSwap: { tokenIn: [pathUsd], slippage: 1 },
+  bootstrap: true,
+  client: provider.getClient(),
+  webSocket: WebSocket,
+  maxDeposit: "0.05",
+  topUpAmount: "0.05",
+});
+
+const agent = await Agent.create({ mpp, thinking: "none", fastMode: true, tools });
+const events = agent.events.watch();
+const unwatch = events.onEvent((event) => {
+  process.stdout.write(`${JSON.stringify(event)}\n`);
+});
+try {
+  console.error(await agent.turn.prompt({ input: "Build the thing." }).result());
+} finally {
+  await mpp.close();
+  unwatch();
+  events.off();
+  agent.dispose();
+}
+```
+
+The application still owns its wallet, deposit policy, persisted payment
+channel store, and final settlement. Keep the manager alive to reuse its channel
+across agents, and supply mppx `channelStore` for reuse after a process or page
+restart. Nanocodex never closes a caller-owned MPP session. `apiKey` and `mpp`
+are mutually exclusive.
+
+Completed turns can be persisted and resumed by a fresh Node or browser agent:
+
+```js
+const snapshot = turn.snapshot();
+agent.dispose();
+
+const resumed = await Agent.create({
+  apiKey: process.env.OPENAI_API_KEY,
+  resume: snapshot,
+  tools,
+});
+```
+
+The snapshot contains authoritative typed history but no provider response ID,
+so the first resumed request safely replays the committed conversation. Resume
+with the same instructions and tool definitions, and release the original
+agent before handing its snapshot to another writer.
+
+Node embedders whose bundler relocates package assets may compile and pass the
+web-target artifact explicitly. The runtime still uses the Node host for
+WebSockets and Code Mode:
+
+```js
+const module = await WebAssembly.compile(await readFile(wasmAssetPath));
+const agent = await Agent.create({ apiKey, module });
+```
+
+A Codex-compatible rollout can also be resumed by materializing its committed
+`response_item` history into a snapshot with no `request_prefix`. Nanocodex
+rebuilds the current prefix from the supplied instructions and JavaScript tools
+while preserving the rollout's workspace, lineage, cache key, canonical user
+context, and typed history.
+
 `Agent` and `Actions` are module namespaces, not classes. `Agent.create` returns
 an owned client decorated with matching domain actions:
 
 - `agent.turn.prompt(...)` / `Actions.turn.prompt(agent, ...)`
+- `turn.snapshot()` / `Actions.turn.getSnapshot(turn)`
 - `agent.session.fork(...)` / `Actions.session.fork(agent, ...)`
+- `agent.session.setThinking(...)` / `Actions.session.setThinking(agent, ...)`
+- `agent.session.setFastMode(...)` / `Actions.session.setFastMode(agent, ...)`
 - `agent.session.spawn()` / `Actions.session.spawn(agent)`
 - `agent.events.watch(...)` / `Actions.events.watch(agent, ...)`
 

package/actions/index.mjs

@@ -11,6 +11,8 @@ export function agentActions() {
     },
     session: {
       fork: (options) => session.fork(agent, options),
+      setFastMode: (enabled) => session.setFastMode(agent, enabled),
+      setThinking: (thinking) => session.setThinking(agent, thinking),
       spawn: () => session.spawn(agent),
     },
     turn: {

package/actions/session.d.mts

@@ -1,4 +1,4 @@
-import type { Agent, DefaultAgent, ForkOptions } from "../types.mjs";
+import type { Agent, DefaultAgent, ForkOptions, Thinking } from "../types.mjs";
 
 /** Forks the latest checkpoint, or the exact completed Turn supplied in `options.at`. */
 export function fork(agent: Agent<object>, options?: fork.Options): Promise<fork.ReturnType>;
@@ -12,3 +12,9 @@ export function spawn(agent: Agent<object>): Promise<spawn.ReturnType>;
 export declare namespace spawn {
   type ReturnType = DefaultAgent;
 }
+
+/** Changes the reasoning effort for subsequently accepted turns. */
+export function setThinking(agent: Agent<object>, thinking: Thinking): Promise<void>;
+
+/** Enables or disables priority processing for subsequently accepted turns. */
+export function setFastMode(agent: Agent<object>, enabled: boolean): Promise<void>;

package/actions/session.mjs

@@ -1,4 +1,9 @@
-import { fork as forkAgent, spawn as spawnAgent } from "../internal.mjs";
+import {
+  fork as forkAgent,
+  setFastMode as setAgentFastMode,
+  setThinking as setAgentThinking,
+  spawn as spawnAgent,
+} from "../internal.mjs";
 
 export function fork(agent, options = {}) {
   return forkAgent(agent, options);
@@ -7,3 +12,11 @@ export function fork(agent, options = {}) {
 export function spawn(agent) {
   return spawnAgent(agent);
 }
+
+export function setThinking(agent, thinking) {
+  return setAgentThinking(agent, thinking);
+}
+
+export function setFastMode(agent, enabled) {
+  return setAgentFastMode(agent, enabled);
+}

package/actions/turn.d.mts

@@ -1,4 +1,4 @@
-import type { Agent, PromptInput, Turn } from "../types.mjs";
+import type { Agent, PromptInput, SessionSnapshot, Turn } from "../types.mjs";
 
 /** Accepts a prompt on an owned Agent and returns its independently awaitable Turn. */
 export function prompt<const agent extends Agent<object>>(
@@ -16,6 +16,12 @@ export declare namespace getResult {
   type ReturnType = string;
 }
 
+/** Copies a completed Turn into a serializable session snapshot. */
+export function getSnapshot(turn: Turn): getSnapshot.ReturnType;
+export declare namespace getSnapshot {
+  type ReturnType = SessionSnapshot;
+}
+
 /** Adds input to an active Turn. */
 export function steer(turn: Turn, options: steer.Options): Promise<void>;
 export declare namespace steer {

package/actions/turn.mjs

@@ -1,6 +1,7 @@
 import {
   cancel as cancelTurn,
   getTurnResult,
+  getTurnSnapshot,
   prompt as promptTurn,
   steer as steerTurn,
 } from "../internal.mjs";
@@ -13,6 +14,10 @@ export function getResult(turn) {
   return getTurnResult(turn);
 }
 
+export function getSnapshot(turn) {
+  return getTurnSnapshot(turn);
+}
+
 export function steer(turn, options) {
   return steerTurn(turn, options);
 }

package/browser/Agent.d.mts

@@ -1,6 +1,7 @@
 import type {
   AgentOptions,
   DefaultAgent,
+  MppSession,
   ToolMap,
 } from "../types.mjs";
 
@@ -9,10 +10,12 @@ export type Agent = DefaultAgent;
 /** Creates a browser- or Worker-hosted Rust/WASM Agent. */
 export function create(options?: create.Options): Promise<create.ReturnType>;
 export declare namespace create {
-  type Options = AgentOptions & {
+  type Options = AgentOptions & (
+    | { apiKey?: string | undefined; mpp?: never }
+    | { apiKey?: never; mpp: MppSession }
+  ) & {
     WebSocketImpl?: typeof WebSocket | undefined;
     apiBaseUrl?: string | undefined;
-    apiKey?: string | undefined;
     createWebSocket?(endpoint: string, sessionId: string): WebSocket;
     maxBufferedSendBytes?: number | undefined;
     maxQueuedBytes?: number | undefined;

package/browser/Agent.mjs

@@ -16,18 +16,24 @@ let initialized;
 
 export function create(options = {}) {
   const {
-    apiKey = "host-managed",
+    apiKey,
+    mpp,
     websocketUrl,
     apiBaseUrl,
     module,
     thinking,
     reasoningMode,
+    fastMode,
     instructions,
     sessionId,
+    resume,
     ...hostOptions
   } = options;
+  if (mpp !== undefined && apiKey !== undefined) {
+    throw new TypeError("apiKey and mpp are mutually exclusive");
+  }
   const events = createEventChannel();
-  const host = createBrowserHost({ ...hostOptions, onEvent: events.emit });
+  const host = createBrowserHost({ ...hostOptions, mpp, onEvent: events.emit });
   activateHost(host);
   const runtime = defineRuntime({
     key: "browser-wasm",
@@ -39,8 +45,10 @@ export function create(options = {}) {
       await initialized;
       activateHost(host);
       return new Nanocodex(JSON.stringify(toWasmConfig({
-        apiKey,
-        websocketUrl,
+        apiKey: apiKey ?? (mpp === undefined ? "host-managed" : "mpp-managed"),
+        websocketUrl: websocketUrl ?? (mpp === undefined
+          ? undefined
+          : "wss://openai.mpp.tempo.xyz/v1/responses"),
         apiBaseUrl,
         ...config,
       })));
@@ -50,5 +58,12 @@ export function create(options = {}) {
     release: (raw) => releaseHostSession(host, raw.sessionId),
     decorate: (agent) => agent.extend(agentActions()),
   });
-  return createAgentClient(runtime, { thinking, reasoningMode, instructions, sessionId });
+  return createAgentClient(runtime, {
+    thinking,
+    reasoningMode,
+    fastMode,
+    instructions,
+    sessionId,
+    resume,
+  });
 }

package/browser/host.mjs

@@ -18,6 +18,7 @@ export function createBrowserHost(options = {}) {
   let nextHandle = 1;
 
   function connect(endpoint, _apiKey, sessionId) {
+    if (options.mpp) return connectMpp(endpoint);
     return new Promise((resolve, reject) => {
       let settled = false;
       const handle = nextHandle++;
@@ -59,6 +60,41 @@ export function createBrowserHost(options = {}) {
     });
   }
 
+  async function connectMpp(endpoint) {
+    if (typeof options.mpp.ws !== "function") {
+      throw new TypeError("mpp must provide ws(endpoint)");
+    }
+    const socket = await options.mpp.ws(endpoint);
+    if (!socket || typeof socket.addEventListener !== "function") {
+      throw new TypeError("mpp.ws(endpoint) must return a WebSocket");
+    }
+    const handle = nextHandle++;
+    const connection = {
+      socket,
+      queue: [],
+      queuedBytes: 0,
+      waiter: undefined,
+      intentionallyClosed: false,
+      overflowed: false,
+      managed: true,
+    };
+    connections.set(handle, connection);
+    socket.addEventListener("message", (event) => {
+      enqueue(connection, typeof event.data === "string"
+        ? { kind: "text", text: event.data }
+        : { kind: "binary" });
+    });
+    socket.addEventListener("close", (event) => {
+      if (!connection.intentionallyClosed && !connection.overflowed) {
+        enqueue(connection, { kind: "closed", detail: `with code ${event.code ?? 1000}` });
+      }
+    });
+    socket.addEventListener("error", () => {
+      enqueue(connection, { kind: "error", detail: "MPP WebSocket connection failed" });
+    });
+    return JSON.stringify({ handle, status: 101, reasoning_included: false });
+  }
+
   function send(handle, message) {
     const connection = connections.get(handle);
     if (!connection || connection.socket.readyState !== WebSocketImpl.OPEN) {
@@ -69,6 +105,10 @@ export function createBrowserHost(options = {}) {
       }));
     }
     try {
+      if (connection.managed) {
+        connection.socket.send(JSON.stringify({ mpp: "message", data: message }));
+        return Promise.resolve(JSON.stringify({ ok: true }));
+      }
       const frameBytes = encoder.encode(message).byteLength;
       if (frameBytes > maxBufferedSendBytes
         || connection.socket.bufferedAmount + frameBytes > maxBufferedSendBytes) {

package/browser/index.d.mts

@@ -4,6 +4,7 @@ export type {
   PromptInput,
   PromptItem,
   ReasoningMode,
+  SessionSnapshot,
   Thinking,
   Tool,
   ToolContext,

package/index.d.mts

@@ -10,6 +10,7 @@ export type {
   PromptInput,
   PromptItem,
   ReasoningMode,
+  SessionSnapshot,
   Thinking,
   Tool,
   ToolContext,

package/internal.mjs

@@ -45,6 +45,10 @@ export function getTurnResult(turn) {
   return state.result;
 }
 
+export function getTurnSnapshot(turn) {
+  return JSON.parse(turnState(turn).raw.snapshot());
+}
+
 export function steer(turn, options) {
   const state = turnState(turn);
   const input = actionInput(options);
@@ -71,6 +75,14 @@ export async function spawn(agent) {
   return createAgent(await state.raw.spawn(), state.runtime);
 }
 
+export function setThinking(agent, thinking) {
+  return agentState(agent).raw.setThinking(thinking);
+}
+
+export function setFastMode(agent, enabled) {
+  return agentState(agent).raw.setFastMode(enabled);
+}
+
 export function subscribeAgentEvents(agent, listener, options = {}) {
   const state = agentState(agent);
   if (typeof state.runtime.subscribe !== "function") {
@@ -94,10 +106,12 @@ export function toWasmConfig(options = {}) {
   const config = { api_key: apiKey };
   copy(config, "thinking", options.thinking);
   copy(config, "reasoning_mode", options.reasoningMode);
+  copy(config, "fast_mode", options.fastMode);
   copy(config, "websocket_url", options.websocketUrl);
   copy(config, "api_base_url", options.apiBaseUrl);
   copy(config, "instructions", options.instructions);
   copy(config, "session_id", options.sessionId);
+  copy(config, "resume", options.resume);
   return config;
 }
 
@@ -250,6 +264,7 @@ function createTurn(raw, agent) {
   const turn = {
     get agent() { return state.agent; },
     result: () => getTurnResult(turn),
+    snapshot: () => getTurnSnapshot(turn),
     steer: (input) => steer(turn, input),
     cancel: () => cancel(turn),
     dispose() {

package/node/Agent.d.mts

@@ -1,6 +1,7 @@
 import type {
   AgentOptions,
   DefaultAgent,
+  MppSession,
   ToolMap,
 } from "../types.mjs";
 
@@ -9,13 +10,13 @@ export type Agent = DefaultAgent;
 /** Creates a Node-hosted Rust/WASM Agent. */
 export function create(options: create.Options): Promise<create.ReturnType>;
 export declare namespace create {
-  type Options = AgentOptions & {
+  type Options = AgentOptions & ({ apiKey: string; mpp?: never } | { apiKey?: never; mpp: MppSession }) & {
     apiBaseUrl?: string | undefined;
-    apiKey: string;
     connectTimeoutMs?: number | undefined;
     maxFrameBytes?: number | undefined;
     maxQueuedBytes?: number | undefined;
     maxQueuedMessages?: number | undefined;
+    module?: unknown;
     sendTimeoutMs?: number | undefined;
     tools?: ToolMap | undefined;
     websocketUrl?: string | undefined;

package/node/Agent.mjs

@@ -1,4 +1,5 @@
 import { createRequire } from "node:module";
+import initWeb, { Nanocodex as WebNanocodex } from "../pkg-web/nanocodex.js";
 
 import { agentActions } from "../actions/index.mjs";
 import {
@@ -12,32 +13,45 @@ import {
 } from "../internal.mjs";
 import { createNodeHost } from "./host.mjs";
 
-const require = createRequire(import.meta.url);
-const { Nanocodex } = require("../pkg-node/nanocodex.js");
+let initializedWeb;
+let NodeNanocodex;
 
 export function create(options = {}) {
   const {
     thinking,
     reasoningMode,
+    fastMode,
     instructions,
     sessionId,
+    resume,
     apiKey,
+    mpp,
     websocketUrl,
     apiBaseUrl,
+    module,
     ...hostOptions
   } = options;
   const events = createEventChannel();
-  const host = createNodeHost({ ...hostOptions, onEvent: events.emit });
+  if (mpp !== undefined && apiKey !== undefined) {
+    throw new TypeError("apiKey and mpp are mutually exclusive");
+  }
+  const host = createNodeHost({ ...hostOptions, mpp, onEvent: events.emit });
   activateHost(host);
   const runtime = defineRuntime({
     key: "node-wasm",
     name: "Nanocodex Node WASM",
     type: "node",
-    create(config) {
+    async create(config) {
+      activateHost(host);
+      const Nanocodex = module === undefined
+        ? loadNodeNanocodex()
+        : await loadWebNanocodex(module);
       activateHost(host);
       return new Nanocodex(JSON.stringify(toWasmConfig({
-        apiKey,
-        websocketUrl,
+        apiKey: apiKey ?? (mpp === undefined ? undefined : "mpp-managed"),
+        websocketUrl: websocketUrl ?? (mpp === undefined
+          ? undefined
+          : "wss://openai.mpp.tempo.xyz/v1/responses"),
         apiBaseUrl,
         ...config,
       })));
@@ -47,5 +61,24 @@ export function create(options = {}) {
     release: (raw) => releaseHostSession(host, raw.sessionId),
     decorate: (agent) => agent.extend(agentActions()),
   });
-  return createAgentClient(runtime, { thinking, reasoningMode, instructions, sessionId });
+  return createAgentClient(runtime, {
+    thinking,
+    reasoningMode,
+    fastMode,
+    instructions,
+    sessionId,
+    resume,
+  });
+}
+
+function loadNodeNanocodex() {
+  const require = createRequire(import.meta.url);
+  NodeNanocodex ||= require("../pkg-node/nanocodex.js").Nanocodex;
+  return NodeNanocodex;
+}
+
+async function loadWebNanocodex(module) {
+  initializedWeb ||= initWeb({ module_or_path: module });
+  await initializedWeb;
+  return WebNanocodex;
 }

package/node/host.mjs

@@ -24,6 +24,7 @@ export function createNodeHost(options = {}) {
   let nextHandle = 1;
 
   function connect(endpoint, apiKey, sessionId) {
+    if (options.mpp) return connectMpp(endpoint);
     return new Promise((resolve, reject) => {
       let settled = false;
       let upgradeResponse;
@@ -80,6 +81,35 @@ export function createNodeHost(options = {}) {
     });
   }
 
+  async function connectMpp(endpoint) {
+    if (typeof options.mpp.ws !== "function") {
+      throw new TypeError("mpp must provide ws(endpoint)");
+    }
+    const socket = await options.mpp.ws(endpoint);
+    if (!socket || typeof socket.addEventListener !== "function") {
+      throw new TypeError("mpp.ws(endpoint) must return a WebSocket");
+    }
+    const handle = nextHandle++;
+    const connection = queueState(socket);
+    connection.managed = true;
+    connections.set(handle, connection);
+    socket.addEventListener("message", (event) => {
+      enqueue(connection, typeof event.data === "string"
+        ? { kind: "text", text: event.data }
+        : { kind: "binary" });
+    });
+    socket.addEventListener("close", (event) => {
+      if (!connection.intentionallyClosed && !connection.overflowed) {
+        const suffix = event.reason ? `: ${event.reason}` : "";
+        enqueue(connection, { kind: "closed", detail: `with code ${event.code ?? 1000}${suffix}` });
+      }
+    });
+    socket.addEventListener("error", () => {
+      enqueue(connection, { kind: "error", detail: "MPP WebSocket connection failed" });
+    });
+    return JSON.stringify({ handle, status: 101, reasoning_included: false });
+  }
+
   function send(handle, message) {
     const connection = connections.get(handle);
     if (!connection || connection.socket.readyState !== WebSocket.OPEN) {
@@ -89,6 +119,18 @@ export function createNodeHost(options = {}) {
         error: "WebSocket is no longer open",
       }));
     }
+    if (connection.managed) {
+      try {
+        connection.socket.send(JSON.stringify({ mpp: "message", data: message }));
+        return Promise.resolve(JSON.stringify({ ok: true }));
+      } catch (error) {
+        return Promise.resolve(JSON.stringify({
+          ok: false,
+          reconnectable: connection.socket.readyState !== WebSocket.OPEN,
+          error: errorMessage(error),
+        }));
+      }
+    }
     return new Promise((resolve) => {
       let completed = false;
       const timer = setTimeout(() => finish({
@@ -159,7 +201,8 @@ export function createNodeHost(options = {}) {
         detail: `receive queue exceeded ${maxQueuedMessages} messages or ${maxQueuedBytes} bytes`,
       };
       connection.queue.push({ message: error, bytes: messageBytes(error) });
-      connection.socket.terminate();
+      if (typeof connection.socket.terminate === "function") connection.socket.terminate();
+      else connection.socket.close(1009, "receive queue exceeded configured bounds");
       return;
     }
     connection.queue.push({ message, bytes });
@@ -187,6 +230,7 @@ function queueState(socket) {
     waiter: undefined,
     intentionallyClosed: false,
     overflowed: false,
+    managed: false,
   };
 }
 

package/node/index.d.mts

@@ -4,6 +4,7 @@ export type {
   PromptInput,
   PromptItem,
   ReasoningMode,
+  SessionSnapshot,
   Thinking,
   Tool,
   ToolContext,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nanocodex",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "Viem-style Node and browser bindings for the Nanocodex WASM agent",
   "type": "module",
   "sideEffects": false,

package/pkg-node/nanocodex.d.ts

@@ -49,6 +49,22 @@ export class Nanocodex {
      * stopped driver.
      */
     promptContent(content_json: string): Turn;
+    /**
+     * Enable or disable priority processing for subsequently accepted turns.
+     *
+     * # Errors
+     *
+     * Rejects after the agent driver stops.
+     */
+    setFastMode(enabled: boolean): Promise<void>;
+    /**
+     * Change the reasoning effort for subsequently accepted turns.
+     *
+     * # Errors
+     *
+     * Rejects an unsupported effort or a stopped agent driver.
+     */
+    setThinking(thinking: string): Promise<void>;
     /**
      * Start a clean sibling with the same configuration and tools.
      *
@@ -87,6 +103,14 @@ export class Turn {
      * await the same pending turn concurrently.
      */
     result(): Promise<string>;
+    /**
+     * Serialize this completed turn's resumable session snapshot.
+     *
+     * # Errors
+     *
+     * Throws until the turn has completed or if serialization fails.
+     */
+    snapshot(): string;
     /**
      * Inject input at this active turn's next safe model boundary.
      *

package/pkg-node/nanocodex.js

@@ -119,6 +119,34 @@ class Nanocodex {
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
+    /**
+     * Enable or disable priority processing for subsequently accepted turns.
+     *
+     * # Errors
+     *
+     * Rejects after the agent driver stops.
+     * @param {boolean} enabled
+     * @returns {Promise<void>}
+     */
+    setFastMode(enabled) {
+        const ret = wasm.nanocodex_setFastMode(this.__wbg_ptr, enabled);
+        return ret;
+    }
+    /**
+     * Change the reasoning effort for subsequently accepted turns.
+     *
+     * # Errors
+     *
+     * Rejects an unsupported effort or a stopped agent driver.
+     * @param {string} thinking
+     * @returns {Promise<void>}
+     */
+    setThinking(thinking) {
+        const ptr0 = passStringToWasm0(thinking, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.nanocodex_setThinking(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
     /**
      * Start a clean sibling with the same configuration and tools.
      *
@@ -180,6 +208,32 @@ class Turn {
         const ret = wasm.turn_result(this.__wbg_ptr);
         return ret;
     }
+    /**
+     * Serialize this completed turn's resumable session snapshot.
+     *
+     * # Errors
+     *
+     * Throws until the turn has completed or if serialization fails.
+     * @returns {string}
+     */
+    snapshot() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.turn_snapshot(this.__wbg_ptr);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
     /**
      * Inject input at this active turn's next safe model boundary.
      *
@@ -252,17 +306,17 @@ function __wbg_get_imports() {
             const ret = arg0.call(arg1, arg2);
             return ret;
         }, arguments); },
-        __wbg_close_b36455f162d504cf: function(arg0) {
+        __wbg_close_fc18ac046d437740: function(arg0) {
             globalThis.nanocodexHost.close(arg0 >>> 0);
         },
-        __wbg_connect_82a82e999c6dad2f: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5) {
+        __wbg_connect_703930fc33e0b1fe: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5) {
             const ret = globalThis.nanocodexHost.connect(getStringFromWasm0(arg0, arg1), getStringFromWasm0(arg2, arg3), getStringFromWasm0(arg4, arg5));
             return ret;
         }, arguments); },
-        __wbg_emitEvent_fe69df479c60b4dc: function(arg0, arg1) {
+        __wbg_emitEvent_6aeed1b6a9321c6d: function(arg0, arg1) {
             globalThis.nanocodexHost.emitEvent(getStringFromWasm0(arg0, arg1));
         },
-        __wbg_executeCode_1b0871b5adb65342: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5) {
+        __wbg_executeCode_9b60ca31e4917172: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5) {
             const ret = globalThis.nanocodexHost.executeCode(getStringFromWasm0(arg0, arg1), getStringFromWasm0(arg2, arg3), getStringFromWasm0(arg4, arg5));
             return ret;
         }, arguments); },
@@ -313,7 +367,7 @@ function __wbg_get_imports() {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return wasm_bindgen__convert__closures_____invoke__h179cb8eb2e8755ae(a, state0.b, arg0, arg1);
+                        return wasm_bindgen_6c97e59ea7837008___convert__closures_____invoke___js_sys_ec93bd22bf926fce___Function_fn_wasm_bindgen_6c97e59ea7837008___JsValue_____wasm_bindgen_6c97e59ea7837008___sys__Undefined___js_sys_ec93bd22bf926fce___Function_fn_wasm_bindgen_6c97e59ea7837008___JsValue_____wasm_bindgen_6c97e59ea7837008___sys__Undefined_______true_(a, state0.b, arg0, arg1);
                     } finally {
                         state0.a = a;
                     }
@@ -324,7 +378,7 @@ function __wbg_get_imports() {
                 state0.a = 0;
             }
         },
-        __wbg_next_9da746b48109347a: function() { return handleError(function (arg0, arg1) {
+        __wbg_next_49b0de35982cd4f1: function() { return handleError(function (arg0, arg1) {
             const ret = globalThis.nanocodexHost.next(arg0 >>> 0, arg1 >>> 0);
             return ret;
         }, arguments); },
@@ -355,11 +409,11 @@ function __wbg_get_imports() {
             const ret = arg0.resolvedOptions();
             return ret;
         },
-        __wbg_send_211e498fb0677de2: function() { return handleError(function (arg0, arg1, arg2) {
+        __wbg_send_dcb152f7d2b1f786: function() { return handleError(function (arg0, arg1, arg2) {
             const ret = globalThis.nanocodexHost.send(arg0 >>> 0, getStringFromWasm0(arg1, arg2));
             return ret;
         }, arguments); },
-        __wbg_sleep_03cdb40ace612b9f: function(arg0) {
+        __wbg_sleep_f4e409e87a98636b: function(arg0) {
             const ret = globalThis.nanocodexHost.sleep(arg0 >>> 0);
             return ret;
         },
@@ -387,7 +441,7 @@ function __wbg_get_imports() {
             const ret = arg0.then(arg1);
             return ret;
         },
-        __wbg_toolDefinitions_976a998d8a17c04c: function(arg0, arg1, arg2) {
+        __wbg_toolDefinitions_7280a1e99f843af9: function(arg0, arg1, arg2) {
             const ret = globalThis.nanocodexHost.toolDefinitions(getStringFromWasm0(arg1, arg2));
             const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
             const len1 = WASM_VECTOR_LEN;
@@ -395,8 +449,8 @@ function __wbg_get_imports() {
             getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
         },
         __wbindgen_cast_0000000000000001: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 57, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h02eb5eea4c10a535);
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 58, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm_bindgen_6c97e59ea7837008___convert__closures_____invoke___wasm_bindgen_6c97e59ea7837008___JsValue__core_9b3796e30d99ddb7___result__Result_____wasm_bindgen_6c97e59ea7837008___JsError___true_);
             return ret;
         },
         __wbindgen_cast_0000000000000002: function(arg0, arg1) {
@@ -420,15 +474,15 @@ function __wbg_get_imports() {
     };
 }
 
-function wasm_bindgen__convert__closures_____invoke__h02eb5eea4c10a535(arg0, arg1, arg2) {
-    const ret = wasm.wasm_bindgen__convert__closures_____invoke__h02eb5eea4c10a535(arg0, arg1, arg2);
+function wasm_bindgen_6c97e59ea7837008___convert__closures_____invoke___wasm_bindgen_6c97e59ea7837008___JsValue__core_9b3796e30d99ddb7___result__Result_____wasm_bindgen_6c97e59ea7837008___JsError___true_(arg0, arg1, arg2) {
+    const ret = wasm.wasm_bindgen_6c97e59ea7837008___convert__closures_____invoke___wasm_bindgen_6c97e59ea7837008___JsValue__core_9b3796e30d99ddb7___result__Result_____wasm_bindgen_6c97e59ea7837008___JsError___true_(arg0, arg1, arg2);
     if (ret[1]) {
         throw takeFromExternrefTable0(ret[0]);
     }
 }
 
-function wasm_bindgen__convert__closures_____invoke__h179cb8eb2e8755ae(arg0, arg1, arg2, arg3) {
-    wasm.wasm_bindgen__convert__closures_____invoke__h179cb8eb2e8755ae(arg0, arg1, arg2, arg3);
+function wasm_bindgen_6c97e59ea7837008___convert__closures_____invoke___js_sys_ec93bd22bf926fce___Function_fn_wasm_bindgen_6c97e59ea7837008___JsValue_____wasm_bindgen_6c97e59ea7837008___sys__Undefined___js_sys_ec93bd22bf926fce___Function_fn_wasm_bindgen_6c97e59ea7837008___JsValue_____wasm_bindgen_6c97e59ea7837008___sys__Undefined_______true_(arg0, arg1, arg2, arg3) {
+    wasm.wasm_bindgen_6c97e59ea7837008___convert__closures_____invoke___js_sys_ec93bd22bf926fce___Function_fn_wasm_bindgen_6c97e59ea7837008___JsValue_____wasm_bindgen_6c97e59ea7837008___sys__Undefined___js_sys_ec93bd22bf926fce___Function_fn_wasm_bindgen_6c97e59ea7837008___JsValue_____wasm_bindgen_6c97e59ea7837008___sys__Undefined_______true_(arg0, arg1, arg2, arg3);
 }
 
 const NanocodexFinalization = (typeof FinalizationRegistry === 'undefined')

package/pkg-node/nanocodex_bg.wasm.d.ts

@@ -9,13 +9,16 @@ export const nanocodex_new: (a: number, b: number) => [number, number, number];
 export const nanocodex_prompt: (a: number, b: number, c: number) => [number, number, number];
 export const nanocodex_promptContent: (a: number, b: number, c: number) => [number, number, number];
 export const nanocodex_sessionId: (a: number) => [number, number];
+export const nanocodex_setFastMode: (a: number, b: number) => any;
+export const nanocodex_setThinking: (a: number, b: number, c: number) => any;
 export const nanocodex_spawn: (a: number) => any;
 export const turn_cancel: (a: number) => any;
 export const turn_result: (a: number) => any;
+export const turn_snapshot: (a: number) => [number, number, number, number];
 export const turn_steer: (a: number, b: number, c: number) => any;
 export const turn_steerContent: (a: number, b: number, c: number) => any;
-export const wasm_bindgen__convert__closures_____invoke__h02eb5eea4c10a535: (a: number, b: number, c: any) => [number, number];
-export const wasm_bindgen__convert__closures_____invoke__h179cb8eb2e8755ae: (a: number, b: number, c: any, d: any) => void;
+export const wasm_bindgen_6c97e59ea7837008___convert__closures_____invoke___wasm_bindgen_6c97e59ea7837008___JsValue__core_9b3796e30d99ddb7___result__Result_____wasm_bindgen_6c97e59ea7837008___JsError___true_: (a: number, b: number, c: any) => [number, number];
+export const wasm_bindgen_6c97e59ea7837008___convert__closures_____invoke___js_sys_ec93bd22bf926fce___Function_fn_wasm_bindgen_6c97e59ea7837008___JsValue_____wasm_bindgen_6c97e59ea7837008___sys__Undefined___js_sys_ec93bd22bf926fce___Function_fn_wasm_bindgen_6c97e59ea7837008___JsValue_____wasm_bindgen_6c97e59ea7837008___sys__Undefined_______true_: (a: number, b: number, c: any, d: any) => void;
 export const __wbindgen_malloc: (a: number, b: number) => number;
 export const __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
 export const __wbindgen_exn_store: (a: number) => void;

package/pkg-web/nanocodex.d.ts

@@ -49,6 +49,22 @@ export class Nanocodex {
      * stopped driver.
      */
     promptContent(content_json: string): Turn;
+    /**
+     * Enable or disable priority processing for subsequently accepted turns.
+     *
+     * # Errors
+     *
+     * Rejects after the agent driver stops.
+     */
+    setFastMode(enabled: boolean): Promise<void>;
+    /**
+     * Change the reasoning effort for subsequently accepted turns.
+     *
+     * # Errors
+     *
+     * Rejects an unsupported effort or a stopped agent driver.
+     */
+    setThinking(thinking: string): Promise<void>;
     /**
      * Start a clean sibling with the same configuration and tools.
      *
@@ -87,6 +103,14 @@ export class Turn {
      * await the same pending turn concurrently.
      */
     result(): Promise<string>;
+    /**
+     * Serialize this completed turn's resumable session snapshot.
+     *
+     * # Errors
+     *
+     * Throws until the turn has completed or if serialization fails.
+     */
+    snapshot(): string;
     /**
      * Inject input at this active turn's next safe model boundary.
      *
@@ -120,13 +144,16 @@ export interface InitOutput {
     readonly nanocodex_prompt: (a: number, b: number, c: number) => [number, number, number];
     readonly nanocodex_promptContent: (a: number, b: number, c: number) => [number, number, number];
     readonly nanocodex_sessionId: (a: number) => [number, number];
+    readonly nanocodex_setFastMode: (a: number, b: number) => any;
+    readonly nanocodex_setThinking: (a: number, b: number, c: number) => any;
     readonly nanocodex_spawn: (a: number) => any;
     readonly turn_cancel: (a: number) => any;
     readonly turn_result: (a: number) => any;
+    readonly turn_snapshot: (a: number) => [number, number, number, number];
     readonly turn_steer: (a: number, b: number, c: number) => any;
     readonly turn_steerContent: (a: number, b: number, c: number) => any;
-    readonly wasm_bindgen__convert__closures_____invoke__h02eb5eea4c10a535: (a: number, b: number, c: any) => [number, number];
-    readonly wasm_bindgen__convert__closures_____invoke__h179cb8eb2e8755ae: (a: number, b: number, c: any, d: any) => void;
+    readonly wasm_bindgen_6c97e59ea7837008___convert__closures_____invoke___wasm_bindgen_6c97e59ea7837008___JsValue__core_9b3796e30d99ddb7___result__Result_____wasm_bindgen_6c97e59ea7837008___JsError___true_: (a: number, b: number, c: any) => [number, number];
+    readonly wasm_bindgen_6c97e59ea7837008___convert__closures_____invoke___js_sys_ec93bd22bf926fce___Function_fn_wasm_bindgen_6c97e59ea7837008___JsValue_____wasm_bindgen_6c97e59ea7837008___sys__Undefined___js_sys_ec93bd22bf926fce___Function_fn_wasm_bindgen_6c97e59ea7837008___JsValue_____wasm_bindgen_6c97e59ea7837008___sys__Undefined_______true_: (a: number, b: number, c: any, d: any) => void;
     readonly __wbindgen_malloc: (a: number, b: number) => number;
     readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
     readonly __wbindgen_exn_store: (a: number) => void;

package/pkg-web/nanocodex.js

@@ -119,6 +119,34 @@ export class Nanocodex {
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
+    /**
+     * Enable or disable priority processing for subsequently accepted turns.
+     *
+     * # Errors
+     *
+     * Rejects after the agent driver stops.
+     * @param {boolean} enabled
+     * @returns {Promise<void>}
+     */
+    setFastMode(enabled) {
+        const ret = wasm.nanocodex_setFastMode(this.__wbg_ptr, enabled);
+        return ret;
+    }
+    /**
+     * Change the reasoning effort for subsequently accepted turns.
+     *
+     * # Errors
+     *
+     * Rejects an unsupported effort or a stopped agent driver.
+     * @param {string} thinking
+     * @returns {Promise<void>}
+     */
+    setThinking(thinking) {
+        const ptr0 = passStringToWasm0(thinking, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.nanocodex_setThinking(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
     /**
      * Start a clean sibling with the same configuration and tools.
      *
@@ -179,6 +207,32 @@ export class Turn {
         const ret = wasm.turn_result(this.__wbg_ptr);
         return ret;
     }
+    /**
+     * Serialize this completed turn's resumable session snapshot.
+     *
+     * # Errors
+     *
+     * Throws until the turn has completed or if serialization fails.
+     * @returns {string}
+     */
+    snapshot() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.turn_snapshot(this.__wbg_ptr);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
     /**
      * Inject input at this active turn's next safe model boundary.
      *
@@ -250,17 +304,17 @@ function __wbg_get_imports() {
             const ret = arg0.call(arg1, arg2);
             return ret;
         }, arguments); },
-        __wbg_close_b36455f162d504cf: function(arg0) {
+        __wbg_close_fc18ac046d437740: function(arg0) {
             globalThis.nanocodexHost.close(arg0 >>> 0);
         },
-        __wbg_connect_82a82e999c6dad2f: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5) {
+        __wbg_connect_703930fc33e0b1fe: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5) {
             const ret = globalThis.nanocodexHost.connect(getStringFromWasm0(arg0, arg1), getStringFromWasm0(arg2, arg3), getStringFromWasm0(arg4, arg5));
             return ret;
         }, arguments); },
-        __wbg_emitEvent_fe69df479c60b4dc: function(arg0, arg1) {
+        __wbg_emitEvent_6aeed1b6a9321c6d: function(arg0, arg1) {
             globalThis.nanocodexHost.emitEvent(getStringFromWasm0(arg0, arg1));
         },
-        __wbg_executeCode_1b0871b5adb65342: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5) {
+        __wbg_executeCode_9b60ca31e4917172: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5) {
             const ret = globalThis.nanocodexHost.executeCode(getStringFromWasm0(arg0, arg1), getStringFromWasm0(arg2, arg3), getStringFromWasm0(arg4, arg5));
             return ret;
         }, arguments); },
@@ -311,7 +365,7 @@ function __wbg_get_imports() {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return wasm_bindgen__convert__closures_____invoke__h179cb8eb2e8755ae(a, state0.b, arg0, arg1);
+                        return wasm_bindgen_6c97e59ea7837008___convert__closures_____invoke___js_sys_ec93bd22bf926fce___Function_fn_wasm_bindgen_6c97e59ea7837008___JsValue_____wasm_bindgen_6c97e59ea7837008___sys__Undefined___js_sys_ec93bd22bf926fce___Function_fn_wasm_bindgen_6c97e59ea7837008___JsValue_____wasm_bindgen_6c97e59ea7837008___sys__Undefined_______true_(a, state0.b, arg0, arg1);
                     } finally {
                         state0.a = a;
                     }
@@ -322,7 +376,7 @@ function __wbg_get_imports() {
                 state0.a = 0;
             }
         },
-        __wbg_next_9da746b48109347a: function() { return handleError(function (arg0, arg1) {
+        __wbg_next_49b0de35982cd4f1: function() { return handleError(function (arg0, arg1) {
             const ret = globalThis.nanocodexHost.next(arg0 >>> 0, arg1 >>> 0);
             return ret;
         }, arguments); },
@@ -353,11 +407,11 @@ function __wbg_get_imports() {
             const ret = arg0.resolvedOptions();
             return ret;
         },
-        __wbg_send_211e498fb0677de2: function() { return handleError(function (arg0, arg1, arg2) {
+        __wbg_send_dcb152f7d2b1f786: function() { return handleError(function (arg0, arg1, arg2) {
             const ret = globalThis.nanocodexHost.send(arg0 >>> 0, getStringFromWasm0(arg1, arg2));
             return ret;
         }, arguments); },
-        __wbg_sleep_03cdb40ace612b9f: function(arg0) {
+        __wbg_sleep_f4e409e87a98636b: function(arg0) {
             const ret = globalThis.nanocodexHost.sleep(arg0 >>> 0);
             return ret;
         },
@@ -385,7 +439,7 @@ function __wbg_get_imports() {
             const ret = arg0.then(arg1);
             return ret;
         },
-        __wbg_toolDefinitions_976a998d8a17c04c: function(arg0, arg1, arg2) {
+        __wbg_toolDefinitions_7280a1e99f843af9: function(arg0, arg1, arg2) {
             const ret = globalThis.nanocodexHost.toolDefinitions(getStringFromWasm0(arg1, arg2));
             const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
             const len1 = WASM_VECTOR_LEN;
@@ -393,8 +447,8 @@ function __wbg_get_imports() {
             getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
         },
         __wbindgen_cast_0000000000000001: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 57, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h02eb5eea4c10a535);
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 58, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm_bindgen_6c97e59ea7837008___convert__closures_____invoke___wasm_bindgen_6c97e59ea7837008___JsValue__core_9b3796e30d99ddb7___result__Result_____wasm_bindgen_6c97e59ea7837008___JsError___true_);
             return ret;
         },
         __wbindgen_cast_0000000000000002: function(arg0, arg1) {
@@ -418,15 +472,15 @@ function __wbg_get_imports() {
     };
 }
 
-function wasm_bindgen__convert__closures_____invoke__h02eb5eea4c10a535(arg0, arg1, arg2) {
-    const ret = wasm.wasm_bindgen__convert__closures_____invoke__h02eb5eea4c10a535(arg0, arg1, arg2);
+function wasm_bindgen_6c97e59ea7837008___convert__closures_____invoke___wasm_bindgen_6c97e59ea7837008___JsValue__core_9b3796e30d99ddb7___result__Result_____wasm_bindgen_6c97e59ea7837008___JsError___true_(arg0, arg1, arg2) {
+    const ret = wasm.wasm_bindgen_6c97e59ea7837008___convert__closures_____invoke___wasm_bindgen_6c97e59ea7837008___JsValue__core_9b3796e30d99ddb7___result__Result_____wasm_bindgen_6c97e59ea7837008___JsError___true_(arg0, arg1, arg2);
     if (ret[1]) {
         throw takeFromExternrefTable0(ret[0]);
     }
 }
 
-function wasm_bindgen__convert__closures_____invoke__h179cb8eb2e8755ae(arg0, arg1, arg2, arg3) {
-    wasm.wasm_bindgen__convert__closures_____invoke__h179cb8eb2e8755ae(arg0, arg1, arg2, arg3);
+function wasm_bindgen_6c97e59ea7837008___convert__closures_____invoke___js_sys_ec93bd22bf926fce___Function_fn_wasm_bindgen_6c97e59ea7837008___JsValue_____wasm_bindgen_6c97e59ea7837008___sys__Undefined___js_sys_ec93bd22bf926fce___Function_fn_wasm_bindgen_6c97e59ea7837008___JsValue_____wasm_bindgen_6c97e59ea7837008___sys__Undefined_______true_(arg0, arg1, arg2, arg3) {
+    wasm.wasm_bindgen_6c97e59ea7837008___convert__closures_____invoke___js_sys_ec93bd22bf926fce___Function_fn_wasm_bindgen_6c97e59ea7837008___JsValue_____wasm_bindgen_6c97e59ea7837008___sys__Undefined___js_sys_ec93bd22bf926fce___Function_fn_wasm_bindgen_6c97e59ea7837008___JsValue_____wasm_bindgen_6c97e59ea7837008___sys__Undefined_______true_(arg0, arg1, arg2, arg3);
 }
 
 const NanocodexFinalization = (typeof FinalizationRegistry === 'undefined')

package/pkg-web/nanocodex_bg.wasm.d.ts

@@ -9,13 +9,16 @@ export const nanocodex_new: (a: number, b: number) => [number, number, number];
 export const nanocodex_prompt: (a: number, b: number, c: number) => [number, number, number];
 export const nanocodex_promptContent: (a: number, b: number, c: number) => [number, number, number];
 export const nanocodex_sessionId: (a: number) => [number, number];
+export const nanocodex_setFastMode: (a: number, b: number) => any;
+export const nanocodex_setThinking: (a: number, b: number, c: number) => any;
 export const nanocodex_spawn: (a: number) => any;
 export const turn_cancel: (a: number) => any;
 export const turn_result: (a: number) => any;
+export const turn_snapshot: (a: number) => [number, number, number, number];
 export const turn_steer: (a: number, b: number, c: number) => any;
 export const turn_steerContent: (a: number, b: number, c: number) => any;
-export const wasm_bindgen__convert__closures_____invoke__h02eb5eea4c10a535: (a: number, b: number, c: any) => [number, number];
-export const wasm_bindgen__convert__closures_____invoke__h179cb8eb2e8755ae: (a: number, b: number, c: any, d: any) => void;
+export const wasm_bindgen_6c97e59ea7837008___convert__closures_____invoke___wasm_bindgen_6c97e59ea7837008___JsValue__core_9b3796e30d99ddb7___result__Result_____wasm_bindgen_6c97e59ea7837008___JsError___true_: (a: number, b: number, c: any) => [number, number];
+export const wasm_bindgen_6c97e59ea7837008___convert__closures_____invoke___js_sys_ec93bd22bf926fce___Function_fn_wasm_bindgen_6c97e59ea7837008___JsValue_____wasm_bindgen_6c97e59ea7837008___sys__Undefined___js_sys_ec93bd22bf926fce___Function_fn_wasm_bindgen_6c97e59ea7837008___JsValue_____wasm_bindgen_6c97e59ea7837008___sys__Undefined_______true_: (a: number, b: number, c: any, d: any) => void;
 export const __wbindgen_malloc: (a: number, b: number) => number;
 export const __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
 export const __wbindgen_exn_store: (a: number) => void;

package/runtime/code-runtime.mjs

@@ -31,6 +31,10 @@ export function createCodeRuntime(toolConfiguration = {}, extras = {}) {
       tools[name] = async (input) => {
         const callId = `${parentCallId}/code-${nextCallId++}`;
         const toolStartedAt = performance.now();
+        const startedAfterNs = Math.max(
+          0,
+          Math.round((toolStartedAt - startedAt) * 1_000_000),
+        );
         try {
           const result = await tool.handler(input, { sessionId, parentCallId, callId });
           nestedCalls.push({
@@ -41,6 +45,7 @@ export function createCodeRuntime(toolConfiguration = {}, extras = {}) {
             input: clone(input) ?? null,
             output: outputBody(result),
             success: true,
+            started_after_ns: startedAfterNs,
             duration_ns: elapsedNs(toolStartedAt),
           });
           return result;
@@ -51,6 +56,7 @@ export function createCodeRuntime(toolConfiguration = {}, extras = {}) {
             input: clone(input) ?? null,
             output: errorMessage(error),
             success: false,
+            started_after_ns: startedAfterNs,
             duration_ns: elapsedNs(toolStartedAt),
           });
           throw error;

package/types.d.mts

@@ -19,10 +19,23 @@ export type AgentEvent = {
 export type AgentOptions = {
   instructions?: string | undefined;
   reasoningMode?: ReasoningMode | undefined;
+  fastMode?: boolean | undefined;
   sessionId?: string | undefined;
   thinking?: Thinking | undefined;
+  resume?: SessionSnapshot | undefined;
 };
 
+export type SessionSnapshot = Readonly<{
+  version: number;
+  model: string;
+  lineage_id: string;
+  prompt_cache_key: string;
+  workspace: string;
+  request_prefix?: readonly Record<string, unknown>[] | undefined;
+  canonical_context: Record<string, unknown>;
+  history: readonly Record<string, unknown>[];
+}>;
+
 export type ForkOptions = { at?: Turn | undefined };
 export type WatchEventsOptions = { includeAllSessions?: boolean | undefined };
 
@@ -38,6 +51,8 @@ export type AgentActions = {
   };
   session: {
     fork(options?: ForkOptions): Promise<DefaultAgent>;
+    setFastMode(enabled: boolean): Promise<void>;
+    setThinking(thinking: Thinking): Promise<void>;
     spawn(): Promise<DefaultAgent>;
   };
   turn: {
@@ -62,6 +77,7 @@ export type DefaultAgent = Agent<AgentActions>;
 export type Turn<agent extends Agent<object> = Agent<object>> = Readonly<{
   readonly agent: agent;
   result(): Promise<string>;
+  snapshot(): SessionSnapshot;
   steer(options: { input: PromptInput }): Promise<void>;
   cancel(): Promise<void>;
   dispose(): void;
@@ -80,3 +96,17 @@ export type Tool = {
 };
 
 export type ToolMap = Record<string, Tool>;
+
+/** A paid WebSocket session, such as an mppx Tempo session manager. */
+export type MppSession = {
+  ws(endpoint: string | URL): Promise<MppWebSocket>;
+  close?(): unknown | Promise<unknown>;
+};
+
+export type MppWebSocket = {
+  readonly readyState: number;
+  readonly bufferedAmount?: number | undefined;
+  addEventListener(type: string, listener: (event: any) => void, options?: unknown): void;
+  send(message: string): void;
+  close(code?: number, reason?: string): void;
+};