nanocodex 0.3.0 → 0.4.0

package/README.md

@@ -9,6 +9,7 @@ import { Actions, Agent } from "nanocodex/node";
 
 const agent = await Agent.create({
   apiKey: process.env.OPENAI_API_KEY,
+  model: "gpt-5.6-luna",
   instructions: "You are a Rust coding agent. Preserve unrelated work and run relevant tests.",
   reasoningMode: "pro",
   thinking: "high",
@@ -242,12 +243,50 @@ const agent = await Agent.create({
 });
 ```
 
+Server-side Worker runtimes can await a `fetch()`-based WebSocket upgrade. The
+third callback argument is a discriminated authorization request plus connection
+metadata. With `apiKey`, `authorization` is `"bearer"` and `bearerToken` is
+present. With `hostAuth: true`, it is `"host_managed"`; the host must resolve
+credentials without exposing them to WASM. Do not retain or log bearer tokens.
+Return the socket alone or a descriptor containing response metadata:
+
+```js
+import { Agent } from "nanocodex/browser";
+import module from "nanocodex/wasm";
+
+const agent = await Agent.create({
+  apiKey,
+  module,
+  async createWebSocket(endpoint, sessionId, request) {
+    if (request.authorization !== "bearer") {
+      throw new Error("this host requires Nanocodex bearer authorization");
+    }
+    const response = await fetch(endpoint.replace("wss:", "https:"), {
+      headers: {
+        Authorization: `Bearer ${request.bearerToken}`,
+        Upgrade: "websocket",
+        "session-id": sessionId,
+      },
+    });
+    if (!response.webSocket) throw new Error(`upgrade failed: ${response.status}`);
+    response.webSocket.accept();
+    return { socket: response.webSocket, status: response.status };
+  },
+});
+```
+
+`hostAuth` is useful when the embedding runtime owns rotating credentials. The
+callback can acquire a fresh token, attempt the upgrade, and refresh-and-retry
+on 401. Bound and reject upgrade work in the callback: until it returns a
+socket, there is no connection handle for Nanocodex to close. `apiKey`,
+`hostAuth`, and `mpp` are mutually exclusive.
+
 After publication, a browser can load the same entrypoint without a package
 manager or build step:
 
 ```html
 <script type="module">
-  import { Agent } from "https://cdn.jsdelivr.net/npm/nanocodex@0.3.0/browser/index.mjs";
+  import { Agent } from "https://cdn.jsdelivr.net/npm/nanocodex@0.4.0/browser/index.mjs";
   const agent = await Agent.create({ websocketUrl: "/api/responses" });
   const turn = agent.turn.prompt({ input: "Hello." });
   try {

package/browser/Agent.d.mts

@@ -4,6 +4,10 @@ import type {
   MppSession,
   ToolMap,
 } from "../types.mjs";
+import type {
+  BrowserWebSocketConnection,
+  BrowserWebSocketRequest,
+} from "./host.mjs";
 
 export type Agent = DefaultAgent;
 
@@ -11,14 +15,21 @@ export type Agent = DefaultAgent;
 export function create(options?: create.Options): Promise<create.ReturnType>;
 export declare namespace create {
   type Options = AgentOptions & (
-    | { apiKey?: string | undefined; mpp?: never }
-    | { apiKey?: never; mpp: MppSession }
+    | { apiKey?: string | undefined; hostAuth?: never; mpp?: never }
+    | { apiKey?: never; hostAuth?: true; mpp?: never }
+    | { apiKey?: never; hostAuth?: never; mpp: MppSession }
   ) & {
     WebSocketImpl?: typeof WebSocket | undefined;
     apiBaseUrl?: string | undefined;
-    createWebSocket?(endpoint: string, sessionId: string): WebSocket;
+    createWebSocket?(
+      endpoint: string,
+      sessionId: string,
+      request: BrowserWebSocketRequest,
+    ): WebSocket | BrowserWebSocketConnection | Promise<WebSocket | BrowserWebSocketConnection>;
     module?: unknown;
     tools?: ToolMap | undefined;
+    /** Direct dispatch is CSP-safe; Code Mode requires dynamic JavaScript evaluation. */
+    toolMode?: "code" | "direct" | undefined;
     websocketUrl?: string | undefined;
   };
   type ReturnType = Agent;

package/browser/Agent.mjs

@@ -17,10 +17,12 @@ let initialized;
 export function create(options = {}) {
   const {
     apiKey,
+    hostAuth,
     mpp,
     websocketUrl,
     apiBaseUrl,
     module,
+    model,
     thinking,
     reasoningMode,
     fastMode,
@@ -31,17 +33,23 @@ export function create(options = {}) {
     WebSocketImpl,
     createWebSocket,
     tools,
+    toolMode,
   } = options;
   if (mpp !== undefined && apiKey !== undefined) {
     throw new TypeError("apiKey and mpp are mutually exclusive");
   }
+  if (hostAuth && (apiKey !== undefined || mpp !== undefined)) {
+    throw new TypeError("hostAuth is mutually exclusive with apiKey and mpp");
+  }
   const events = createEventChannel();
   const host = createBrowserHost({
     WebSocketImpl,
     createWebSocket,
+    hostAuth: hostAuth === true || (apiKey === undefined && mpp === undefined),
     mpp,
     onEvent: events.emit,
     tools,
+    toolMode,
   });
   activateHost(host);
   const runtime = defineRuntime({
@@ -68,6 +76,7 @@ export function create(options = {}) {
     decorate: (agent) => agent.extend(agentActions()),
   });
   return createAgentClient(runtime, {
+    model,
     thinking,
     reasoningMode,
     fastMode,

package/browser/host.d.mts

@@ -9,9 +9,41 @@ export type BrowserTool = {
 
 export type BrowserToolMap = Record<string, BrowserTool>;
 
+type BrowserWebSocketMetadata = {
+  accountId?: string | undefined;
+  fedramp?: boolean | undefined;
+  turnState?: string | undefined;
+};
+
+export type BrowserWebSocketRequest = BrowserWebSocketMetadata & (
+  | {
+    authorization: "bearer";
+    /** Resolved credential for this handshake. Do not retain or log it. */
+    bearerToken: string;
+  }
+  | {
+    authorization: "host_managed";
+    bearerToken?: never;
+  }
+);
+
+export type BrowserWebSocketConnection = {
+  socket: WebSocket;
+  status?: number | undefined;
+  requestId?: string | undefined;
+  serverModel?: string | undefined;
+  reasoningIncluded?: boolean | undefined;
+  turnState?: string | undefined;
+};
+
 export function createBrowserHost(options?: {
   WebSocketImpl?: typeof WebSocket;
-  createWebSocket?: (endpoint: string, sessionId: string) => WebSocket;
+  hostAuth?: boolean;
+  createWebSocket?: (
+    endpoint: string,
+    sessionId: string,
+    request: BrowserWebSocketRequest,
+  ) => WebSocket | BrowserWebSocketConnection | Promise<WebSocket | BrowserWebSocketConnection>;
   onEvent?: (eventJson: string) => void;
   tools?: BrowserToolMap;
   maxQueuedMessages?: number;

package/browser/host.mjs

@@ -14,6 +14,10 @@ export function createBrowserHost(options = {}) {
   }
   const connections = new Map();
   const code = createCodeRuntime(options.tools);
+  const toolMode = options.toolMode ?? "code";
+  if (toolMode !== "code" && toolMode !== "direct") {
+    throw new TypeError("toolMode must be code or direct");
+  }
   const onEvent = options.onEvent || (() => {});
   const maxQueuedMessages = options.maxQueuedMessages ?? DEFAULT_MAX_QUEUED_MESSAGES;
   const maxQueuedBytes = options.maxQueuedBytes ?? DEFAULT_MAX_QUEUED_BYTES;
@@ -21,12 +25,19 @@ export function createBrowserHost(options = {}) {
   const encoder = new TextEncoder();
   let nextHandle = 1;
 
-  function connect(endpoint, _apiKey, sessionId, metadata = {}) {
+  async function connect(endpoint, apiKey, sessionId, metadata = {}) {
     if (options.mpp) return connectMpp(endpoint);
+    const authorization = options.hostAuth
+      ? { authorization: "host_managed" }
+      : { authorization: "bearer", bearerToken: apiKey };
+    const request = { ...metadata };
+    delete request.authorization;
+    delete request.bearerToken;
+    Object.assign(request, authorization);
+    const opened = await createWebSocket(endpoint, sessionId, request);
+    const { socket, ...handshake } = normalizeWebSocketConnection(opened);
     return new Promise((resolve, reject) => {
       let settled = false;
-      const handle = nextHandle++;
-      const socket = createWebSocket(endpoint, sessionId, metadata);
       const connection = {
         socket,
         queue: [],
@@ -35,11 +46,21 @@ export function createBrowserHost(options = {}) {
         intentionallyClosed: false,
         overflowed: false,
       };
-      socket.addEventListener("open", () => {
+      const resolveOpen = () => {
+        if (settled) return;
         settled = true;
+        const handle = nextHandle++;
         connections.set(handle, connection);
-        resolve(JSON.stringify({ handle, status: 101, reasoning_included: false }));
-      }, { once: true });
+        resolve(JSON.stringify({
+          handle,
+          status: handshake.status ?? 101,
+          request_id: handshake.requestId,
+          server_model: handshake.serverModel,
+          reasoning_included: handshake.reasoningIncluded ?? false,
+          turn_state: handshake.turnState,
+        }));
+      };
+      socket.addEventListener("open", resolveOpen, { once: true });
       socket.addEventListener("message", (event) => {
         enqueue(connection, typeof event.data === "string"
           ? { kind: "text", text: event.data }
@@ -61,6 +82,11 @@ export function createBrowserHost(options = {}) {
           enqueue(connection, { kind: "error", detail: "WebSocket connection failed" });
         }
       });
+      if (socket.readyState === WEBSOCKET_OPEN) resolveOpen();
+      else if (socket.readyState > WEBSOCKET_OPEN) {
+        settled = true;
+        reject(new Error("WebSocket closed during connection"));
+      }
     });
   }
 
@@ -198,8 +224,20 @@ export function createBrowserHost(options = {}) {
     close,
     sleep: (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds)),
     executeCode: code.executeCode,
+    executeTool: code.executeTool,
+    toolMode: () => toolMode,
     toolDefinitions: code.toolDefinitions,
     emitEvent: onEvent,
     reset: code.reset,
   });
 }
+
+function normalizeWebSocketConnection(opened) {
+  if (opened?.socket && typeof opened.socket.addEventListener === "function") {
+    return opened;
+  }
+  if (!opened || typeof opened.addEventListener !== "function") {
+    throw new TypeError("createWebSocket must return a WebSocket or a connection descriptor");
+  }
+  return { socket: opened };
+}

package/internal.mjs

@@ -141,6 +141,7 @@ export function toWasmConfig(options = {}) {
     throw new TypeError("apiKey must be a non-empty string");
   }
   const config = { api_key: apiKey };
+  copy(config, "model", options.model);
   copy(config, "thinking", options.thinking);
   copy(config, "reasoning_mode", options.reasoningMode);
   copy(config, "fast_mode", options.fastMode);
@@ -235,6 +236,13 @@ const hostBridge = Object.freeze({
   executeCode(source, sessionId, callId) {
     return requiredSessionHost(sessionId).executeCode(source, sessionId, callId);
   },
+  executeTool(name, input, sessionId, callId) {
+    return requiredSessionHost(sessionId).executeTool(name, input, sessionId, callId);
+  },
+  toolMode(sessionId) {
+    // The WASM constructor asks before its session is adopted.
+    return (hostSessions.get(sessionId) ?? requiredActiveHost()).toolMode();
+  },
   toolDefinitions(sessionId) {
     // ModelRun builds its stable tool prefix inside the WASM constructor,
     // immediately before the returned session can be adopted. Runtime

package/node/Agent.d.mts

@@ -14,6 +14,7 @@ export declare namespace create {
     apiBaseUrl?: string | undefined;
     module?: unknown;
     tools?: ToolMap | undefined;
+    toolMode?: "code" | "direct" | undefined;
     websocketUrl?: string | undefined;
   };
   type ReturnType = Agent;

package/node/Agent.mjs

@@ -18,6 +18,7 @@ let NodeNanocodex;
 
 export function create(options = {}) {
   const {
+    model,
     thinking,
     reasoningMode,
     fastMode,
@@ -31,6 +32,7 @@ export function create(options = {}) {
     apiBaseUrl,
     module,
     tools,
+    toolMode,
   } = options;
   const events = createEventChannel();
   if (mpp !== undefined && apiKey !== undefined) {
@@ -40,6 +42,7 @@ export function create(options = {}) {
     mpp,
     onEvent: events.emit,
     tools,
+    toolMode,
     workspace: workspace ?? resume?.workspace,
   });
   activateHost(host);
@@ -68,6 +71,7 @@ export function create(options = {}) {
     decorate: (agent) => agent.extend(agentActions()),
   });
   return createAgentClient(runtime, {
+    model,
     thinking,
     reasoningMode,
     fastMode,

package/node/host.mjs

@@ -18,6 +18,10 @@ export function createNodeHost(options = {}) {
     require: createRequire(resolve(options.workspace ?? process.cwd(), ".nanocodex-code-mode.cjs")),
     console: new Console({ stdout: process.stderr, stderr: process.stderr }),
   });
+  const toolMode = options.toolMode ?? "code";
+  if (toolMode !== "code" && toolMode !== "direct") {
+    throw new TypeError("toolMode must be code or direct");
+  }
   const onEvent = options.onEvent || (() => {});
   const connectTimeoutMs = options.connectTimeoutMs ?? 30_000;
   const sendTimeoutMs = options.sendTimeoutMs ?? 30_000;
@@ -237,6 +241,8 @@ export function createNodeHost(options = {}) {
     close,
     sleep: (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds)),
     executeCode: code.executeCode,
+    executeTool: code.executeTool,
+    toolMode: () => toolMode,
     toolDefinitions: code.toolDefinitions,
     emitEvent: onEvent,
     reset: code.reset,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nanocodex",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Viem-style Node and browser bindings for the Nanocodex WASM agent",
   "type": "module",
   "sideEffects": false,
@@ -16,6 +16,10 @@
     "./browser": {
       "types": "./browser/index.d.mts",
       "import": "./browser/index.mjs"
+    },
+    "./wasm": {
+      "types": "./wasm.d.mts",
+      "import": "./pkg-web/nanocodex_bg.wasm"
     }
   },
   "files": [
@@ -28,6 +32,7 @@
     "internal.mjs",
     "index.d.mts",
     "index.mjs",
+    "wasm.d.mts",
     "types.d.mts",
     "README.md"
   ],

package/pkg-node/nanocodex.js

@@ -390,20 +390,24 @@ function __wbg_get_imports() {
             const ret = arg0.call(arg1, arg2);
             return ret;
         }, arguments); },
-        __wbg_close_84b985b15720666a: function(arg0) {
+        __wbg_close_01cad5fe38e81c86: function(arg0) {
             globalThis.nanocodexHost.close(arg0 >>> 0);
         },
-        __wbg_connect_fdf81494b56b3a0a: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10) {
+        __wbg_connect_5611ecc28eb874ce: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10) {
             const ret = globalThis.nanocodexHost.connect(getStringFromWasm0(arg0, arg1), getStringFromWasm0(arg2, arg3), arg4 === 0 ? undefined : getStringFromWasm0(arg4, arg5), arg6 !== 0, getStringFromWasm0(arg7, arg8), arg9 === 0 ? undefined : getStringFromWasm0(arg9, arg10));
             return ret;
         }, arguments); },
-        __wbg_emitEvent_52491cc5b9c996ad: function(arg0, arg1) {
+        __wbg_emitEvent_3feefd1f718bb4db: function(arg0, arg1) {
             globalThis.nanocodexHost.emitEvent(getStringFromWasm0(arg0, arg1));
         },
-        __wbg_executeCode_616baf56d3c8480c: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5) {
+        __wbg_executeCode_8137943d0e1986eb: 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); },
+        __wbg_executeTool_e4208b9be8ad5132: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
+            const ret = globalThis.nanocodexHost.executeTool(getStringFromWasm0(arg0, arg1), getStringFromWasm0(arg2, arg3), getStringFromWasm0(arg4, arg5), getStringFromWasm0(arg6, arg7));
+            return ret;
+        }, arguments); },
         __wbg_getRandomValues_ceb34d8ffce7e87f: function() { return handleError(function (arg0, arg1) {
             globalThis.crypto.getRandomValues(getArrayU8FromWasm0(arg0, arg1));
         }, arguments); },
@@ -465,7 +469,7 @@ function __wbg_get_imports() {
                 state0.a = 0;
             }
         },
-        __wbg_next_4acad3c8f1e88dfb: function() { return handleError(function (arg0, arg1) {
+        __wbg_next_ad2796bd351c174b: function() { return handleError(function (arg0, arg1) {
             const ret = globalThis.nanocodexHost.next(arg0 >>> 0, arg1 >>> 0);
             return ret;
         }, arguments); },
@@ -496,11 +500,11 @@ function __wbg_get_imports() {
             const ret = arg0.resolvedOptions();
             return ret;
         },
-        __wbg_send_bdd41ab8e18f6042: function() { return handleError(function (arg0, arg1, arg2) {
+        __wbg_send_864d9417bda59954: function() { return handleError(function (arg0, arg1, arg2) {
             const ret = globalThis.nanocodexHost.send(arg0 >>> 0, getStringFromWasm0(arg1, arg2));
             return ret;
         }, arguments); },
-        __wbg_sleep_c32f4fdaac627991: function() { return handleError(function (arg0, arg1, arg2) {
+        __wbg_sleep_926d4c81d29ad90a: function() { return handleError(function (arg0, arg1, arg2) {
             const ret = globalThis.nanocodexHost.sleep(getStringFromWasm0(arg0, arg1), arg2 >>> 0);
             return ret;
         }, arguments); },
@@ -528,19 +532,26 @@ function __wbg_get_imports() {
             const ret = arg0.then(arg1);
             return ret;
         },
-        __wbg_toolDefinitions_4f496f9fbb096753: function() { return handleError(function (arg0, arg1, arg2) {
+        __wbg_toolDefinitions_fc0bd1da5e037164: function() { return handleError(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;
             getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
             getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
         }, arguments); },
+        __wbg_toolMode_4ce2699746be96ac: function(arg0, arg1, arg2) {
+            const ret = globalThis.nanocodexHost.toolMode(getStringFromWasm0(arg1, arg2));
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
         __wbg_turnresult_new: function(arg0) {
             const ret = TurnResult.__wrap(arg0);
             return ret;
         },
         __wbindgen_cast_0000000000000001: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 446, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 455, 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;
         },

package/pkg-web/nanocodex.js

@@ -387,20 +387,24 @@ function __wbg_get_imports() {
             const ret = arg0.call(arg1, arg2);
             return ret;
         }, arguments); },
-        __wbg_close_84b985b15720666a: function(arg0) {
+        __wbg_close_01cad5fe38e81c86: function(arg0) {
             globalThis.nanocodexHost.close(arg0 >>> 0);
         },
-        __wbg_connect_fdf81494b56b3a0a: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10) {
+        __wbg_connect_5611ecc28eb874ce: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10) {
             const ret = globalThis.nanocodexHost.connect(getStringFromWasm0(arg0, arg1), getStringFromWasm0(arg2, arg3), arg4 === 0 ? undefined : getStringFromWasm0(arg4, arg5), arg6 !== 0, getStringFromWasm0(arg7, arg8), arg9 === 0 ? undefined : getStringFromWasm0(arg9, arg10));
             return ret;
         }, arguments); },
-        __wbg_emitEvent_52491cc5b9c996ad: function(arg0, arg1) {
+        __wbg_emitEvent_3feefd1f718bb4db: function(arg0, arg1) {
             globalThis.nanocodexHost.emitEvent(getStringFromWasm0(arg0, arg1));
         },
-        __wbg_executeCode_616baf56d3c8480c: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5) {
+        __wbg_executeCode_8137943d0e1986eb: 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); },
+        __wbg_executeTool_e4208b9be8ad5132: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
+            const ret = globalThis.nanocodexHost.executeTool(getStringFromWasm0(arg0, arg1), getStringFromWasm0(arg2, arg3), getStringFromWasm0(arg4, arg5), getStringFromWasm0(arg6, arg7));
+            return ret;
+        }, arguments); },
         __wbg_getRandomValues_ceb34d8ffce7e87f: function() { return handleError(function (arg0, arg1) {
             globalThis.crypto.getRandomValues(getArrayU8FromWasm0(arg0, arg1));
         }, arguments); },
@@ -462,7 +466,7 @@ function __wbg_get_imports() {
                 state0.a = 0;
             }
         },
-        __wbg_next_4acad3c8f1e88dfb: function() { return handleError(function (arg0, arg1) {
+        __wbg_next_ad2796bd351c174b: function() { return handleError(function (arg0, arg1) {
             const ret = globalThis.nanocodexHost.next(arg0 >>> 0, arg1 >>> 0);
             return ret;
         }, arguments); },
@@ -493,11 +497,11 @@ function __wbg_get_imports() {
             const ret = arg0.resolvedOptions();
             return ret;
         },
-        __wbg_send_bdd41ab8e18f6042: function() { return handleError(function (arg0, arg1, arg2) {
+        __wbg_send_864d9417bda59954: function() { return handleError(function (arg0, arg1, arg2) {
             const ret = globalThis.nanocodexHost.send(arg0 >>> 0, getStringFromWasm0(arg1, arg2));
             return ret;
         }, arguments); },
-        __wbg_sleep_c32f4fdaac627991: function() { return handleError(function (arg0, arg1, arg2) {
+        __wbg_sleep_926d4c81d29ad90a: function() { return handleError(function (arg0, arg1, arg2) {
             const ret = globalThis.nanocodexHost.sleep(getStringFromWasm0(arg0, arg1), arg2 >>> 0);
             return ret;
         }, arguments); },
@@ -525,19 +529,26 @@ function __wbg_get_imports() {
             const ret = arg0.then(arg1);
             return ret;
         },
-        __wbg_toolDefinitions_4f496f9fbb096753: function() { return handleError(function (arg0, arg1, arg2) {
+        __wbg_toolDefinitions_fc0bd1da5e037164: function() { return handleError(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;
             getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
             getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
         }, arguments); },
+        __wbg_toolMode_4ce2699746be96ac: function(arg0, arg1, arg2) {
+            const ret = globalThis.nanocodexHost.toolMode(getStringFromWasm0(arg1, arg2));
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
         __wbg_turnresult_new: function(arg0) {
             const ret = TurnResult.__wrap(arg0);
             return ret;
         },
         __wbindgen_cast_0000000000000001: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 446, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 455, 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;
         },

package/runtime/code-runtime.mjs

@@ -23,6 +23,24 @@ export function createCodeRuntime(toolConfiguration = {}, extras = {}) {
   Object.freeze(configuredTools);
   Object.freeze(definitions);
   const encodedDefinitions = JSON.stringify(definitions);
+  const toolByName = new Map(configuredTools.map((tool) => [tool.name, tool]));
+
+  async function executeTool(name, encodedInput, sessionId = "default", callId = "tool") {
+    const tool = toolByName.get(name);
+    if (!tool) return encodeToolOutput(`unknown application tool: ${name}`, false, null);
+    let input;
+    try {
+      input = JSON.parse(encodedInput);
+    } catch (error) {
+      return encodeToolOutput(`invalid tool input: ${errorMessage(error)}`, false, null);
+    }
+    try {
+      const result = await tool.handler(input, { sessionId, parentCallId: "", callId });
+      return encodeToolOutput(outputBody(result), true, clone(result) ?? null);
+    } catch (error) {
+      return encodeToolOutput(errorMessage(error), false, null);
+    }
+  }
 
   async function executeCode(source, sessionId = "default", parentCallId = "exec") {
     const startedAt = performance.now();
@@ -151,6 +169,7 @@ export function createCodeRuntime(toolConfiguration = {}, extras = {}) {
 
   return Object.freeze({
     executeCode,
+    executeTool,
     toolDefinitions: () => encodedDefinitions,
     reset() {
       stores.clear();
@@ -158,6 +177,16 @@ export function createCodeRuntime(toolConfiguration = {}, extras = {}) {
   });
 }
 
+function encodeToolOutput(output, success, codeModeValue) {
+  return JSON.stringify({
+    output,
+    success,
+    code_mode_value: codeModeValue,
+    metadata: null,
+    process_trace: null,
+  });
+}
+
 function outputBody(value) {
   if (Array.isArray(value) && value.every((item) => item?.type === "input_text" || item?.type === "input_image")) {
     return clone(value);

package/types.d.mts

@@ -1,5 +1,6 @@
 export type Thinking = "none" | "low" | "medium" | "high" | "xhigh" | "max";
 export type ReasoningMode = "standard" | "pro";
+export type Model = "gpt-5.6-sol" | "gpt-5.6-terra" | "gpt-5.6-luna";
 
 export type PromptItem =
   | { type: "text"; text: string }
@@ -18,6 +19,7 @@ export type AgentEvent = {
 
 export type AgentOptions = {
   instructions?: string | undefined;
+  model?: Model | undefined;
   reasoningMode?: ReasoningMode | undefined;
   fastMode?: boolean | undefined;
   sessionId?: string | undefined;

package/wasm.d.mts

@@ -0,0 +1,4 @@
+/** Precompiled web WASM module for runtimes that import binary modules. */
+declare const module: WebAssembly.Module;
+
+export default module;