nanocodex 0.6.6 → 0.6.7

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";

package/browser/socket-observations.mjs

@@ -0,0 +1,203 @@
+// Passive, content-free observations. Timers report silence; they never cancel
+// inference. Each socket retains only one active request and 32 response links.
+export function createSocketObservations(observe) {
+  if (observe === undefined) return;
+  if (typeof observe !== "function") throw new TypeError("host socket event hook must be a function");
+  const turns = new Map();
+  const calls = new Map();
+  const sockets = new Set();
+  const emit = (value) => {
+    try {
+      const result = observe(value);
+      if (result?.then) void Promise.resolve(result).catch(() => {});
+    } catch { /* Observation cannot change transport behavior. */ }
+  };
+  const retain = (map, key, value, limit = 128) => {
+    if (!map.has(key) && map.size >= limit) map.delete(map.keys().next().value);
+    map.set(key, value);
+  };
+  return {
+    runtime(encoded) {
+      if (typeof encoded === "string" && !/"(?:input\.accepted|model\.(?:call|compaction|warmup)\.|run\.)/.test(encoded.slice(0, 512))) return;
+      let event;
+      try { event = typeof encoded === "string" ? JSON.parse(encoded) : encoded; } catch { return; }
+      const p = event?.payload;
+      if (!p) return;
+      if (event.type === "input.accepted" && typeof p.turn_id === "string" && typeof p.session_id === "string") {
+        retain(turns, p.turn_id, p.session_id);
+      }
+      const sessionId = turns.get(p.turn_id) ?? event.request_id;
+      if (event.type === "model.call.started" || event.type === "model.compaction.started" || event.type === "model.warmup.started") {
+        retain(calls, sessionId, { ...(Number.isSafeInteger(p.call_index ?? p.after_model_call_index)
+          ? { model_call_index: p.call_index ?? p.after_model_call_index } : {}),
+          phase: event.type.startsWith("model.compaction.") ? "compaction" : event.type.startsWith("model.warmup.") ? "warmup" : "generation" });
+      } else if (/^model\.(call|compaction|warmup)\.(completed|failed)$/.test(event.type)) {
+        for (const socket of sockets) {
+          if (socket.sessionId === sessionId) socket.finished(p.call_index ?? p.after_model_call_index, p.response_id, event.type.endsWith(".failed") ? "failed" : "completed");
+        }
+        calls.delete(sessionId);
+      }
+    },
+    release(sessionId) {
+      calls.delete(sessionId);
+      for (const [turn, session] of turns) if (session === sessionId) turns.delete(turn);
+    },
+    connect(sessionId, snapshot) {
+      const measure = () => { try { return snapshot(); } catch { return {}; } };
+      const socketId = crypto.randomUUID();
+      const began = performance.now();
+      const responses = new Map();
+      let handshake = {};
+      let active, last, timer, ordinal = 0, closed = false;
+      const record = (event, fields = {}, request = active ?? last) => emit({
+        event, socket_id: socketId, request_id: sessionId,
+        ...(uuid(handshake.egressRequestId) ? { egress_request_id: handshake.egressRequestId } : {}),
+        ...(identifier(handshake.requestId, "req_") || uuid(handshake.requestId) ? { provider_request_id: handshake.requestId } : {}),
+        ...(request ? { socket_request_index: request.index, ...request.context,
+          ...(request.responseId ? { response_id: request.responseId } : {}) } : {}),
+        ...fields,
+      });
+      const watch = (event, started) => {
+        clearTimeout(timer);
+        let after = 1_000;
+        const waiting = () => {
+          if (closed) return;
+          const now = performance.now();
+          record(event, { elapsed_ms: now - started,
+            ...(active ? { received_message_count: active.messages,
+              ...(active.firstMessage === undefined ? {} : { first_message_ms: active.firstMessage - active.started }),
+              ...milestones(active),
+              last_message_age_ms: now - (active.lastMessage ?? active.started), ...measure() } : {}) });
+          after = Math.min(after * 2, 5_000);
+          timer = setTimeout(waiting, after);
+        };
+        timer = setTimeout(waiting, after);
+      };
+      const responseLink = (request, id) => {
+        if (!request || !identifier(id, "resp_")) return;
+        request.responseId = id;
+        retain(responses, id, request, 32);
+      };
+      const finish = (outcome) => {
+        if (!active) return;
+        clearTimeout(timer);
+        record("request.finished", { outcome, elapsed_ms: performance.now() - active.started,
+          received_message_count: active.messages, ...milestones(active), ...measure() });
+        last = active;
+        active = undefined;
+      };
+      const socket = {
+        sessionId,
+        connected(value) {
+          handshake = value;
+          clearTimeout(timer);
+          record("socket.opened", { elapsed_ms: performance.now() - began });
+        },
+        sendStarted() {
+          finish("superseded");
+          active = { index: ++ordinal, context: calls.get(sessionId) ?? {}, started: performance.now(), messages: 0 };
+          record("request.send_started", measure());
+          watch("request.send_waiting", active.started);
+        },
+        sent() {
+          if (!active) return;
+          const now = performance.now();
+          record("request.sent", { send_wait_ms: now - active.started, ...measure() });
+          if (active.firstMessage === undefined) active.started = now;
+          active.sentAt = now;
+          watch("request.waiting", active.started);
+        },
+        sendFailed() { finish("send_failed"); },
+        message(text) {
+          const now = performance.now();
+          if (!active) return;
+          active.messages++;
+          active.lastMessage = now;
+          // Only parse bounded envelopes while a relevant milestone is missing.
+          // A large/unrecognized envelope remains unclassified, never copied to logs.
+          const candidates = typeof text === "string" && text.length <= 16_384
+            && (active.firstMessage === undefined || active.firstOutput === undefined
+              || DELTA_STAGES.some(([field, , types]) => active[field] === undefined
+                && types.some(type => text.includes(`"${type}"`))));
+          let frame;
+          if (candidates) {
+            try { frame = JSON.parse(text); } catch { /* Invalid frames remain the runtime's responsibility. */ }
+          }
+          const type = EVENT_TYPES.has(frame?.type) ? frame.type : "unclassified";
+          const classification = { provider_event_type: type };
+          if (type !== "unclassified") responseLink(active, frame?.response?.id);
+          // A new frame ends the current silence interval. Streaming calls
+          // produce no waiting records while frames keep arriving.
+          if (active.sentAt !== undefined) watch("request.waiting", active.started);
+          if (active.firstMessage === undefined) {
+            active.firstMessage = now;
+            record("request.first_message", { elapsed_ms: now - active.started, ...classification, ...measure() });
+          }
+          // Keep the historical output-item milestone, but identify what caused
+          // it. Empty item announcements are not evidence of generated text.
+          if (active.firstOutput === undefined && OUTPUT_EVENTS.has(type)) {
+            active.firstOutput = now;
+            record("request.first_output", { elapsed_ms: now - active.started, ...classification,
+              output_kind: OUTPUT_KINDS.get(type) ?? "item", ...measure() });
+          }
+          for (const [field, stage, types] of DELTA_STAGES) {
+            if (active[field] === undefined && types.includes(type) && typeof frame.delta === "string" && frame.delta.length > 0) {
+              active[field] = now;
+              record(stage, { elapsed_ms: now - active.started, ...classification, ...measure() });
+            }
+          }
+        },
+        provider(timing) {
+          const request = timing.response_id ? responses.get(timing.response_id) : active ?? last;
+          if (request?.timingReported) return;
+          if (request) request.timingReported = true;
+          record("provider.timing", timing, request ?? null);
+        },
+        finished(index, responseId, outcome) {
+          if (active?.context.model_call_index !== index) return;
+          responseLink(active, responseId);
+          finish(outcome);
+        },
+        close(event, intentional = false) {
+          if (closed) return;
+          closed = true;
+          clearTimeout(timer);
+          record("socket.closed", { elapsed_ms: performance.now() - began, intentional,
+            ...(Number.isInteger(event?.code) ? { close_code: event.code } : {}),
+            ...(typeof event?.wasClean === "boolean" ? { close_clean: event.wasClean } : {}),
+            ...(active ? { received_message_count: active.messages,
+              last_message_age_ms: performance.now() - (active.lastMessage ?? active.started) } : {}), ...measure() });
+          active = undefined;
+          sockets.delete(socket);
+        },
+        error() { record("socket.error", { elapsed_ms: performance.now() - began, ...measure() }); },
+      };
+      sockets.add(socket);
+      record("socket.connecting", {}, undefined);
+      watch("socket.connect_waiting", began);
+      return socket;
+    },
+  };
+}
+
+function uuid(value) { return typeof value === "string" && /^[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}$/i.test(value); }
+function identifier(value, prefix) { return typeof value === "string" && value.startsWith(prefix) && /^[A-Za-z0-9_-]{1,160}$/.test(value); }
+const OUTPUT_EVENTS = new Set(["response.output_text.delta", "response.reasoning_summary_text.delta",
+  "response.reasoning_summary.delta", "response.reasoning_content.delta", "response.output_item.added", "response.output_item.done"]);
+
+// These names are a fixed protocol allowlist, never provider-supplied log text.
+const DELTA_STAGES = [
+  ["firstReasoning", "request.first_reasoning_delta", ["response.reasoning_text.delta", "response.reasoning_summary_text.delta",
+    "response.reasoning_summary.delta", "response.reasoning_content.delta"]],
+  ["firstAnswer", "request.first_answer_delta", ["response.output_text.delta"]],
+  ["firstTool", "request.first_tool_delta", ["response.function_call_arguments.delta", "response.custom_tool_call_input.delta"]],
+];
+const OUTPUT_KINDS = new Map(DELTA_STAGES.flatMap(([, stage, types]) => types.map(type => [type,
+  stage === "request.first_reasoning_delta" ? "reasoning" : stage === "request.first_answer_delta" ? "answer" : "tool"])));
+const EVENT_TYPES = new Set([...OUTPUT_EVENTS, ...OUTPUT_KINDS.keys(), "response.created", "response.in_progress", "response.queued",
+  "response.completed", "response.failed", "response.incomplete", "error", "responsesapi.websocket_timing"]);
+function milestones(request) {
+  return Object.fromEntries([["firstOutput", "first_output_ms"], ["firstReasoning", "first_reasoning_delta_ms"],
+    ["firstAnswer", "first_answer_delta_ms"], ["firstTool", "first_tool_delta_ms"]]
+    .filter(([field]) => request[field] !== undefined).map(([field, key]) => [key, request[field] - request.started]));
+}

package/cloud/Decorator.d.mts

@@ -1,4 +1,4 @@
-import type { logout } from "./actions/account.mjs";
+import type { links, logout } from "./actions/account.mjs";
 import type { create as createAgent } from "./actions/agent.mjs";
 import type { request as connectorRequest } from "./actions/connector.mjs";
 import type { connect, disconnect, reconnect } from "./actions/connection.mjs";
@@ -10,7 +10,7 @@ import type { Client } from "./Client.mjs";
 import type { Connection, HostConnection } from "./types.mjs";
 
 export type ConnectActions<connection extends Connection | HostConnection = Connection> = {
-  account: { logout(): logout.ReturnType };
+  account: { links(options?: links.Options): links.ReturnType; logout(): logout.ReturnType };
   agent: { create(options: createAgent.Options): Promise<createAgent.ReturnType> };
   connector: { request(options: connectorRequest.Options): connectorRequest.ReturnType };
   connectors: {

package/cloud/Decorator.mjs

@@ -11,6 +11,7 @@ import * as mpp from "./actions/mpp.mjs";
 export function connectActions() {
   return (client) => ({
     account: {
+      links: (options) => account.links(client, options),
       logout: () => account.logout(client),
     },
     agent: {

package/cloud/Dialog.d.mts

@@ -1,5 +1,16 @@
 export const DEFAULT_HOST: "https://nanocodex.gakonst.workers.dev/connect-dialog/";
 
+/** Visual tokens for the hosted dialog. Arbitrary CSS is not supported. */
+export type Appearance = Readonly<{
+  theme?: "light" | "dark" | "system" | undefined;
+  /** Six-digit hex color, for example #635bff. */
+  accentColor?: `#${string}` | undefined;
+  /** Installed or self-hosted font list, at most 160 characters. No CSS functions. */
+  fontFamily?: string | undefined;
+  /** Control corner radius in pixels, from 0 to 24. */
+  borderRadius?: number | undefined;
+}>;
+
 export type Request = ConnectionRequest | FundingRequest;
 
 export type ConnectionRequest = Readonly<{
@@ -93,12 +104,14 @@ export function from<const type extends string>(parameters: Readonly<{
 }>): Dialog<type>;
 
 export function iframe(options?: Readonly<{
+  appearance?: Appearance | undefined;
   host?: string | undefined;
   key?: string | undefined;
   name?: string | undefined;
 }>): Dialog<"iframe">;
 
 export function popup(options?: Readonly<{
+  appearance?: Appearance | undefined;
   host?: string | undefined;
   key?: string | undefined;
   name?: string | undefined;