nanocodex 0.6.5 → 0.6.7

package/browser/VoiceSession.mjs

@@ -90,6 +90,7 @@ export class BrowserVoiceSession {
   #elevenLabs;
   #muted = false;
   #inputGeneration = 0;
+  #playbackRevision = 0;
   #meterTimer;
   #backendReady;
   #resolveBackendReady;
@@ -267,7 +268,7 @@ export class BrowserVoiceSession {
     const channel = this.#channel;
     channel.addEventListener("message", (event) => {
       if (this.#directControl && !this.#closed && this.#channel === channel) {
-        this.#receiveControl(event.data, () => this.#channel === channel);
+        this.#receiveControl(event.data, () => this.#channel === channel && channel.readyState === "open");
       }
     });
     channel.addEventListener("close", () => {
@@ -311,6 +312,7 @@ export class BrowserVoiceSession {
   }
 
   noteTypedInput() {
+    this.#playbackRevision++;
     this.#playbackEnabled = false;
     this.#elevenLabs?.interrupt();
     this.#speaker?.setEnabled(false);
@@ -429,14 +431,19 @@ export class BrowserVoiceSession {
     for (const text of effects.undelivered_answers ?? []) this.#options.onUndeliveredAnswer?.(text);
     if (effects.input_generation !== undefined) {
       if (effects.input_generation < this.#inputGeneration) return;
-      if (effects.input_generation > this.#inputGeneration) this.#elevenLabs?.interrupt();
+      if (effects.input_generation > this.#inputGeneration) {
+        this.#playbackRevision++;
+        this.#elevenLabs?.interrupt();
+      }
       this.#inputGeneration = effects.input_generation;
     }
     if (effects.playback_enabled === false) {
+      this.#playbackRevision++;
       this.#playbackEnabled = false;
       this.#elevenLabs?.interrupt();
       this.#speaker?.setEnabled(false);
     }
+    const playbackRevision = this.#playbackRevision;
     let sent = 0;
     for (const frame of effects.frames ?? []) {
       if (this.#directControl && this.#channel?.readyState === "open") {
@@ -448,12 +455,15 @@ export class BrowserVoiceSession {
       }
     }
     if (effects.acknowledge_frames && sent > 0) await this.#core?.framesSent(sent);
-    if (!this.#closed && effects.playback_enabled === true && sent === (effects.frames?.length ?? 0)) {
+    // A live interruption can overtake asynchronous frame acknowledgement.
+    // Keep its speaker gate authoritative while retaining accepted captions.
+    const currentPlayback = playbackRevision === this.#playbackRevision;
+    if (currentPlayback && !this.#closed && effects.playback_enabled === true && sent === (effects.frames?.length ?? 0)) {
       this.#playbackEnabled = true;
       this.#speaker?.setEnabled(!this.#elevenLabs);
     }
     for (const entry of effects.transcripts ?? []) {
-      if (this.#playbackEnabled && !this.#closed) this.#elevenLabs?.transcript(entry);
+      if (currentPlayback && this.#playbackEnabled && !this.#closed) this.#elevenLabs?.transcript(entry);
       this.#options.onTranscript(entry.speaker, entry.text, entry);
     }
     if (effects.status) this.#status(effects.status);
@@ -490,7 +500,7 @@ export class BrowserVoiceSession {
     let opened = false;
     sideband.addEventListener("message", (event) => {
       if (!this.#closed && generation === this.#sidebandGeneration) {
-        this.#receiveControl(event.data, () => generation === this.#sidebandGeneration);
+        this.#receiveControl(event.data, () => generation === this.#sidebandGeneration && sideband.readyState === WebSocket.OPEN);
       }
     });
     sideband.addEventListener("close", () => {
@@ -516,7 +526,11 @@ export class BrowserVoiceSession {
     this.#applyLive(async () => {
       if (!this.#directControl) await this.#admission;
       if (this.#closed || !isCurrent()) return;
-      if (await this.#core.requiresAgentAdmission(payload)) {
+      const requiresAdmission = await this.#core.requiresAgentAdmission(payload);
+      // Classification can yield while this transport closes or is replaced.
+      // Only requests accepted on the current connection may enter the queue.
+      if (this.#closed || !isCurrent()) return;
+      if (requiresAdmission) {
         // Retain accepted requests on close, but keep captions and interruptions
         // independent of the durable route and its ordered task queue.
         void this.#enqueue(async () => {

package/browser/host.d.mts

@@ -1,5 +1,6 @@
 import type {
   CodeEvaluator,
+  CodeEffectJournal,
   McpServers,
   MppSession,
   SubagentToolContext,
@@ -51,12 +52,60 @@ export type BrowserWebSocketConnection = {
   socket: WebSocket;
   status?: number | undefined;
   requestId?: string | undefined;
+  /** @internal Correlation with the separately deployed credential egress. */
+  egressRequestId?: string | undefined;
   serverModel?: string | undefined;
   reasoningIncluded?: boolean | undefined;
   turnState?: string | undefined;
 };
 
+/** @internal Passive lifecycle metadata; never provider frames or request content. */
+export type BrowserSocketObservation = {
+  event: "socket.connecting" | "socket.connect_waiting" | "socket.opened" | "socket.closed" | "socket.error"
+    | "request.send_started" | "request.send_waiting" | "request.sent" | "request.waiting" | "request.first_message"
+    | "request.first_output" | "request.first_reasoning_delta" | "request.first_answer_delta" | "request.first_tool_delta" | "request.finished" | "provider.timing";
+  socket_id: string;
+  request_id: string;
+  egress_request_id?: string;
+  provider_request_id?: string;
+  response_id?: string;
+  socket_request_index?: number;
+  model_call_index?: number;
+  phase?: "generation" | "compaction" | "warmup";
+  outcome?: "completed" | "failed" | "send_failed" | "superseded";
+  elapsed_ms?: number;
+  send_wait_ms?: number;
+  first_message_ms?: number;
+  first_output_ms?: number;
+  first_reasoning_delta_ms?: number;
+  first_answer_delta_ms?: number;
+  first_tool_delta_ms?: number;
+  /** Fixed protocol name, or unclassified for oversized/unknown envelopes. */
+  provider_event_type?: string;
+  output_kind?: "item" | "reasoning" | "answer" | "tool";
+  last_message_age_ms?: number;
+  received_message_count?: number;
+  queued_message_count?: number;
+  socket_delivered_message_count?: number;
+  socket_queue_residence_max_ms?: number;
+  buffered_send_bytes?: number;
+  close_code?: number;
+  close_clean?: boolean;
+  intentional?: boolean;
+  pre_inference_ms?: number;
+  engine_queue_max_ms?: number;
+  engine_service_ttft_total_ms?: number;
+};
+
 export function createBrowserHost(options?: {
+  /** @internal Trusted runtime configuration carried by nanocodex.browser.internalRuntime. */
+  [key: symbol]: {
+    traceTool?: <T>(
+      name: string,
+      context: { sessionId: string; callId: string; parentCallId?: string; turnId?: string },
+      run: () => Promise<T>,
+    ) => Promise<T>;
+  } | undefined;
   WebSocketImpl?: typeof WebSocket;
   hostAuth?: boolean;
   hostManagedProtocol?: boolean;
@@ -74,7 +123,9 @@ export function createBrowserHost(options?: {
   /** Remote MCP servers exposed through native and Code Mode tool_search plus deferred tools. */
   mcp?: McpServers;
   codeEvaluator?: CodeEvaluator;
-  toolMode?: "code" | "direct";
+  /** @internal Trusted durable effect receipts, not available inside guest code. */
+  codeEffectJournal?: CodeEffectJournal;
+  toolMode?: "code" | "code-only" | "direct";
   /** @internal Live host lifecycle for ephemeral Rust-owned subagents. */
   subagentRouting?: Pick<import('../runtime/subagent-routing.mjs').SubagentRouting, 'resolve' | 'bind'>;
   subagentSessions?: {
@@ -97,6 +148,8 @@ export function createBrowserHost(options?: {
       engine_service_ttft_total_ms?: number;
     }>;
   }) => void;
+  /** @internal Live observations while an owned request waits; does not cancel it. */
+  onSocketEvent?: (event: BrowserSocketObservation) => void;
   maxQueuedMessages?: number;
   maxQueuedBytes?: number;
   maxBufferedSendBytes?: number;

package/browser/host.mjs

@@ -1,6 +1,7 @@
+import { createCodeEffectIdentity } from "../runtime/code-effect-identity.mjs";
 import { createBeforeCompaction } from "../runtime/before-compaction.mjs";
 import { createResponsesHttp, responsesHttpHeaders } from "../runtime/responses-http.mjs";
-import { createCodeRuntime, toolResult } from "../runtime/code-runtime.mjs";
+import { createCodeRuntime, toolResult, traceToolInvocation } from "../runtime/code-runtime.mjs";
 import {
   toolRouterBrand,
   toolRouterRuntime,
@@ -9,6 +10,7 @@ import {
 import { utf8ByteLength } from "../runtime/utf8.mjs";
 import { createWorkerEvaluator } from "../runtime/worker-evaluator.mjs";
 import { openHostManagedWebSocket } from "./hostManagedWebSocket.mjs";
+import { createSocketObservations } from "./socket-observations.mjs";
 
 const DEFAULT_MAX_QUEUED_MESSAGES = 4_096;
 const DEFAULT_MAX_QUEUED_BYTES = 32 * 1024 * 1024;
@@ -19,14 +21,24 @@ const MPP_CLIENT_PROTOCOL_ERROR_CLOSE_CODE = 3008;
 const WEBSOCKET_OPEN = 1;
 
 export function createBrowserHost(options = {}) {
+  const internalRuntime = options[Symbol.for("nanocodex.browser.internalRuntime")];
+  if (internalRuntime !== undefined
+    && (!internalRuntime || typeof internalRuntime !== "object" || Array.isArray(internalRuntime))) {
+    throw new TypeError("browser host internal runtime options must be an object");
+  }
+  const traceTool = internalRuntime?.traceTool;
+  if (traceTool !== undefined && typeof traceTool !== "function") {
+    throw new TypeError("browser host tool tracing hook must be a function");
+  }
   const onSocketTiming = options.onSocketTiming;
   if (onSocketTiming !== undefined && typeof onSocketTiming !== "function") {
     throw new TypeError("host socket timing hook must be a function");
   }
+  const socketObservations = createSocketObservations(options.onSocketEvent);
   const preservation = createBeforeCompaction(options.beforeCompaction);
   const toolMode = options.toolMode ?? "code";
-  if (toolMode !== "code" && toolMode !== "direct") {
-    throw new TypeError("toolMode must be code or direct");
+  if (toolMode !== "code" && toolMode !== "code-only" && toolMode !== "direct") {
+    throw new TypeError("toolMode must be code, code-only or direct");
   }
   const toolsRouter = options.tools?.[toolRouterBrand]
     ? options.tools[toolRouterRuntime]
@@ -38,7 +50,7 @@ export function createBrowserHost(options = {}) {
   if (toolsMcp && options.mcp) {
     throw new TypeError("MCP is already configured in Tools");
   }
-  if ((toolsMcp || options.mcp) && toolMode !== "code") {
+  if ((toolsMcp || options.mcp) && toolMode === "direct") {
     throw new TypeError("remote MCP requires Code Mode");
   }
   const toolsLifecycle = options.tools?.[toolRuntimeLifecycle];
@@ -76,8 +88,12 @@ export function createBrowserHost(options = {}) {
       : () => Promise.reject(new Error(
           "browser Code Mode requires a child Worker or an explicit codeEvaluator",
         )));
+  const effectIdentity = createCodeEffectIdentity(options.codeEffectJournal);
   const code = createCodeRuntime(options.tools, {
+    traceTool,
     evaluate: codeEvaluator,
+    effectJournal: options.codeEffectJournal,
+    effectIdentity: options.codeEffectJournal ? effectIdentity.resolve : undefined,
     subagentSessions: options.subagentSessions,
   });
   const toolProviders = options.toolProviders ?? [];
@@ -192,12 +208,22 @@ export function createBrowserHost(options = {}) {
       if (preconnected !== undefined) await closePreconnected();
       ownership = openOwned(() => createWebSocket(endpoint, sessionId, request));
     }
-    const opened = await ownership.promise;
-    const { socket, ...handshake } = normalizeWebSocketConnection(opened);
+    let connection;
+    const observation = socketObservations?.connect(sessionId, () => ({
+      queued_message_count: connection?.queue.length ?? 0,
+      socket_delivered_message_count: connection?.timing?.metrics.delivered_message_count ?? 0,
+      socket_queue_residence_max_ms: connection?.timing?.metrics.queue_residence_max_ms ?? 0,
+      buffered_send_bytes: connection?.socket.bufferedAmount ?? 0,
+    }));
+    let normalized;
+    try { normalized = normalizeWebSocketConnection(await ownership.promise); }
+    catch (error) { observation?.error(); observation?.close(undefined, false); throw error; }
+    const { socket, ...handshake } = normalized;
     return new Promise((resolve, reject) => {
       let settled = false;
-      const connection = {
+      connection = {
         socket,
+        observation,
         timing: socketTiming(),
         queue: [],
         queuedBytes: 0,
@@ -209,6 +235,7 @@ export function createBrowserHost(options = {}) {
         if (settled) return;
         settled = true;
         connectingConnections.delete(connection);
+        observation?.close(undefined, false);
         finishSocketTiming(connection);
         reject(error);
       };
@@ -228,6 +255,7 @@ export function createBrowserHost(options = {}) {
         delete connection.reject;
         const handle = nextHandle++;
         connections.set(handle, connection);
+        observation?.connected(handshake);
         resolve(JSON.stringify({
           handle,
           status: handshake.status ?? 101,
@@ -244,6 +272,7 @@ export function createBrowserHost(options = {}) {
           : { kind: "binary" });
       });
       socket.addEventListener("close", (event) => {
+        observation?.close(event, connection.intentionallyClosed);
         connection.wakeSend?.();
         if (!settled) {
           rejectConnection(new Error(`WebSocket closed during connection with code ${event.code}`));
@@ -252,6 +281,7 @@ export function createBrowserHost(options = {}) {
         }
       });
       socket.addEventListener("error", () => {
+        observation?.error();
         if (!settled) {
           rejectConnection(new Error("WebSocket connection failed"));
         } else {
@@ -329,6 +359,8 @@ export function createBrowserHost(options = {}) {
         error: "concurrent WebSocket sends are unsupported" });
     }
     connection.sending = true;
+    let sent = false;
+    connection.observation?.sendStarted();
     try {
       if (connection.managed) {
         connection.socket.send(JSON.stringify({ mpp: "message", data: message }));
@@ -363,6 +395,8 @@ export function createBrowserHost(options = {}) {
       }
       if (closed()) return closedResult();
       connection.socket.send(message);
+      sent = true;
+      connection.observation?.sent();
       return JSON.stringify({ ok: true });
     } catch (error) {
       return JSON.stringify({
@@ -371,6 +405,8 @@ export function createBrowserHost(options = {}) {
         error: error instanceof Error ? error.message : String(error),
       });
     } finally {
+      // A send that did not reach socket.send must not leave a waiting timer.
+      if (!sent) connection.observation?.sendFailed();
       connection.sending = false;
     }
   }
@@ -406,6 +442,7 @@ export function createBrowserHost(options = {}) {
     if (!connection) return;
     connections.delete(handle);
     connection.intentionallyClosed = true;
+    connection.observation?.close(undefined, true);
     connection.wakeSend?.();
     connection.waiter?.({ kind: "closed", detail: "by the WASM runtime" });
     finishSocketTiming(connection);
@@ -422,11 +459,13 @@ export function createBrowserHost(options = {}) {
     if (timing && dataMessage) {
       timing.metrics.message_count += 1;
       // Only the exact metadata event can produce diagnostics; deltas stay opaque.
-      if (message.kind === "text" && timing.provider.size < 32) {
+      connection.observation?.message(message.kind === "text" ? message.text : undefined);
+      if (message.kind === "text" && (timing.provider.size < 32 || connection.observation)) {
         const metadata = providerSocketTiming(message.text);
         if (metadata) {
+          connection.observation?.provider(metadata);
           const key = metadata.response_id ?? timing.provider.size;
-          if (!timing.provider.has(key)) timing.provider.set(key, metadata);
+          if (timing.provider.size < 32 && !timing.provider.has(key)) timing.provider.set(key, metadata);
         }
       }
     }
@@ -461,7 +500,7 @@ export function createBrowserHost(options = {}) {
 
   // No counters, timestamps, metadata parsing or observations without the internal hook.
   function socketTiming() {
-    return onSocketTiming === undefined ? undefined : {
+    return onSocketTiming === undefined && socketObservations === undefined ? undefined : {
       metrics: {
         message_count: 0,
         delivered_message_count: 0,
@@ -479,6 +518,7 @@ export function createBrowserHost(options = {}) {
     // Finalize owned consumption, not the remote close event: buffered frames may
     // still be drained after that event. Clear first for reentrant close/dispose.
     connection.timing = undefined;
+    if (onSocketTiming === undefined) return;
     const metrics = timing.metrics;
     try {
       const result = onSocketTiming({
@@ -513,7 +553,7 @@ export function createBrowserHost(options = {}) {
       }
       for (const handle of [...connections.keys()]) cleanup(() => close(handle));
       cleanup(() => closePreconnected(disposalError));
-      cleanup(() => code.reset());
+      cleanup(() => { effectIdentity.reset(); return code.reset(); });
       cleanup(() => mcpInstalled?.then(() => {}));
       cleanup(() => toolsLifecycle?.close());
       cleanup(() => options.onDispose?.());
@@ -612,10 +652,19 @@ export function createBrowserHost(options = {}) {
     next,
     close,
     sleep: (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds)),
-    executeCode: code.executeCodeObserved,
-    waitCode: code.waitCodeObserved,
+    executeCode: traceTool === undefined ? code.executeCodeObserved
+      : (source, sessionId = "default", callId = "exec", model = "unknown", turnId, localDefinitions, executeLocalTool) =>
+        traceToolInvocation(traceTool, "exec", {
+          sessionId, callId, ...(turnId == null ? {} : { turnId }),
+        }, () => code.executeCodeObserved(source, sessionId, callId, model, turnId, localDefinitions, executeLocalTool)),
+    waitCode: traceTool === undefined ? code.waitCodeObserved
+      : (input, sessionId = "default", callId = "wait") =>
+        traceToolInvocation(traceTool, "wait", { sessionId, callId },
+          () => code.waitCodeObserved(input, sessionId, callId)),
     beginCodeTurn: code.beginTurn,
     cancelCodeTurn: code.cancelTurn,
+    preemptCode: code.preempt,
+    preemptCodeTurn: code.preemptTurn,
     nextCodeUpdate: code.nextCodeUpdate,
     executeTool: code.executeTool,
     routeSubagent: (request) => {
@@ -653,9 +702,9 @@ export function createBrowserHost(options = {}) {
     },
     toolMode: () => toolMode,
     toolDefinitions: code.toolDefinitions,
-    releaseSession: code.releaseSession,
-    emitEvent: onEvent,
-    reset: code.reset,
+    releaseSession: (sessionId) => { effectIdentity.release(sessionId); socketObservations?.release(sessionId); return code.releaseSession(sessionId); },
+    emitEvent: (event, ...args) => { code.observeEvent(event); effectIdentity.observe(event); socketObservations?.runtime(event); return onEvent(event, ...args); },
+    reset: () => { effectIdentity.reset(); return code.reset(); },
     dispose,
   });
 }

package/browser/hostManagedWebSocket.mjs

@@ -1,3 +1,5 @@
+import { retryAfterAdvice } from "../runtime/retry-after.mjs";
+
 const DEFAULT_TIMEOUT_MS = 10_000;
 
 /** Open Nanocodex's same-origin Responses proxy and consume its setup frame. */
@@ -74,13 +76,20 @@ function waitForProxyHandshake(socket, timeoutMs) {
         && message.status <= 599) {
         const status = message.status;
         const body = typeof message.error === "string" ? message.error : `HTTP ${status}`;
-        const retryAfter = Number(message.retryAfter);
+        const advice = retryAfterAdvice(
+          typeof message.retryAfter === "number" ? String(message.retryAfter) : message.retryAfter,
+        );
+        // The proxy may already have captured advice before draining its rejection body.
+        if (Number.isSafeInteger(message.retry_after_deadline_ms) && message.retry_after_deadline_ms >= 0) {
+          advice.retry_after_deadline_ms = message.retry_after_deadline_ms;
+        }
         fail(Object.assign(
           new Error(`Agent connection rejected with HTTP ${status}: ${body}`),
           {
             status,
             body,
-            ...(Number.isFinite(retryAfter) && retryAfter >= 0 ? { retryAfter } : {}),
+            ...advice,
+            ...(advice.retry_after !== undefined ? { retryAfter: advice.retry_after } : {}),
           },
         ));
         return;

package/browser/index.d.mts

@@ -4,16 +4,6 @@ export {
   subscriptionRevision,
 } from "../runtime/subscription-store.mjs";
 export { createQuickJsEvaluator } from "../runtime/quickjs-evaluator.mjs";
-export {
-  createTempoProvider,
-  createTempoProviderFromAccounts,
-  DEFAULT_MERCATOR_MCP_URL,
-} from "../runtime/tempo-provider.mjs";
-export type {
-  AccountsTempoProviderOptions,
-  AccountsWallet,
-  TempoProvider,
-} from "../runtime/tempo-provider.mjs";
 export type {
   AgentEvent,
   AgentLifecycle,
@@ -46,6 +36,7 @@ export type {
   TurnResult,
   TurnUsage,
   McpPayment,
+  PaidMcpPayment,
   McpServer,
   McpServers,
   MemoryChatGptSubscriptionStore,
@@ -79,3 +70,5 @@ export type {
   BrowserWebSocketConnection,
   BrowserWebSocketRequest,
 } from "./host.mjs";
+
+export * as Claude from "./Claude.mjs";

package/browser/index.mjs

@@ -4,11 +4,6 @@ export {
   subscriptionRevision,
 } from "../runtime/subscription-store.mjs";
 export { createQuickJsEvaluator } from "../runtime/quickjs-evaluator.mjs";
-export {
-  createTempoProvider,
-  createTempoProviderFromAccounts,
-  DEFAULT_MERCATOR_MCP_URL,
-} from "../runtime/tempo-provider.mjs";
 export * as Agent from "./Agent.mjs";
 export * as ChatGptSubscription from "./ChatGptSubscription.mjs";
 export * as Subagents from "../runtime/subagents.mjs";
@@ -21,3 +16,5 @@ export {
   defaultHostManagedWebSocketUrl,
   openHostManagedWebSocket,
 } from "./hostManagedWebSocket.mjs";
+
+export * as Claude from "./Claude.mjs";