nanocodex 0.6.5 → 0.6.7

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;

package/cloud/Dialog.mjs

@@ -2,6 +2,9 @@ import { DialogBusyError, UserRejectedRequestError } from "./Errors.mjs";
 
 export const DEFAULT_HOST = "https://nanocodex.gakonst.workers.dev/connect-dialog/";
 
+const APPEARANCE_PARAMETER = "nanocodex_appearance";
+const MAX_APPEARANCE_LENGTH = 1024;
+
 const iframeInstances = new Map();
 const popupInstances = new Map();
 
@@ -22,6 +25,7 @@ export function from(parameters) {
 
 export function iframe(options = {}) {
   const host = new URL(options.host ?? DEFAULT_HOST).toString();
+  const appearance = serializeAppearance(options.appearance);
   return from({
     key: options.key ?? "nanocodex-iframe",
     name: options.name ?? "Nanocodex Connect",
@@ -35,7 +39,7 @@ export function iframe(options = {}) {
           },
         };
       }
-      const source = dialogUrl(host, "iframe", appId);
+      const source = dialogUrl(host, "iframe", appId, appearance);
       let instance = iframeInstances.get(source);
       if (!instance) {
         instance = createIframeInstance(source);
@@ -48,6 +52,7 @@ export function iframe(options = {}) {
 
 export function popup(options = {}) {
   const host = new URL(options.host ?? DEFAULT_HOST).toString();
+  const appearance = serializeAppearance(options.appearance);
   return from({
     key: options.key ?? "nanocodex-popup",
     name: options.name ?? "Nanocodex Connect",
@@ -61,7 +66,7 @@ export function popup(options = {}) {
           },
         };
       }
-      const source = dialogUrl(host, "popup", appId);
+      const source = dialogUrl(host, "popup", appId, appearance);
       let instance = popupInstances.get(source);
       if (!instance) {
         instance = createPopupInstance(source, options);
@@ -141,7 +146,7 @@ function createIframeInstance(host) {
     if (frame && modal) return;
     modal = document.createElement("dialog");
     modal.setAttribute("aria-label", "Nanocodex Connect permissions");
-    modal.style.cssText = "border:0;padding:0;background:transparent;max-width:none;max-height:none";
+    modal.style.cssText = "border:0;outline:0;padding:0;margin:0;background:transparent;max-width:none;max-height:none;width:100vw;height:100dvh";
     modal.addEventListener("cancel", (event) => {
       event.preventDefault();
       rejectActive(new UserRejectedRequestError());
@@ -161,7 +166,7 @@ function createIframeInstance(host) {
       `publickey-credentials-create ${dialogOrigin}`,
       "payment",
     ].join("; ");
-    frame.style.cssText = "border:0;width:min(440px,calc(100vw - 24px));height:min(720px,calc(100vh - 24px));background:#161616";
+    frame.style.cssText = "border:0;width:100vw;height:100dvh;background:transparent";
     frame.style.display = "none";
     modal.append(frame);
     document.body.append(modal);
@@ -202,6 +207,8 @@ function createIframeInstance(host) {
     const url = new URL(nextHost ?? host);
     if (!url.searchParams.has("origin")) url.searchParams.set("origin", window.location.origin);
     url.searchParams.set("mode", "iframe");
+    // Accounts may supply a fresh host URL; retain this dialog's visual options.
+    setAppearance(url, new URL(host).searchParams.get(APPEARANCE_PARAMETER));
     const source = url.toString();
     if (walletFrame && walletModal && walletHost === source) return;
     walletModal?.remove();
@@ -319,7 +326,7 @@ function createIframeInstance(host) {
 function createPopupInstance(host, options) {
   const source = host;
   const targetName = options.target ?? "nanocodex-connect";
-  const features = options.features ?? "popup=yes,width=440,height=720,resizable=yes,scrollbars=yes";
+  const features = options.features ?? "popup=yes,width=808,height=780,resizable=yes,scrollbars=yes";
   let walletWindow;
 
   function showWallet() {
@@ -350,11 +357,12 @@ function createPopupInstance(host, options) {
   };
 }
 
-function dialogUrl(host, mode, appId) {
+function dialogUrl(host, mode, appId, appearance) {
   const url = new URL(host);
   url.searchParams.set("app_id", appId);
   url.searchParams.set("origin", window.location.origin);
   url.searchParams.set("mode", mode);
+  setAppearance(url, appearance);
   return url.toString();
 }
 
@@ -364,3 +372,41 @@ function requiredString(value, label) {
   }
   return value;
 }
+
+function setAppearance(url, appearance) {
+  // Explicit SDK options own this parameter, including clearing stale host values.
+  url.searchParams.delete(APPEARANCE_PARAMETER);
+  if (appearance) url.searchParams.set(APPEARANCE_PARAMETER, appearance);
+}
+
+function serializeAppearance(appearance) {
+  if (appearance === undefined) return undefined;
+  if (!appearance || typeof appearance !== "object" || Array.isArray(appearance)) {
+    throw new TypeError("Dialog appearance must be an object");
+  }
+  const keys = ["theme", "accentColor", "fontFamily", "borderRadius"];
+  if (Object.keys(appearance).some((key) => !keys.includes(key))) {
+    throw new TypeError("Dialog appearance contains an unsupported option");
+  }
+  const { theme, accentColor, fontFamily, borderRadius } = appearance;
+  if (theme !== undefined && !["light", "dark", "system"].includes(theme)) {
+    throw new TypeError("Dialog appearance theme must be light, dark, or system");
+  }
+  if (accentColor !== undefined && (typeof accentColor !== "string" || !/^#[\da-f]{6}$/i.test(accentColor))) {
+    throw new TypeError("Dialog appearance accentColor must be a six-digit hex color");
+  }
+  if (fontFamily !== undefined && (typeof fontFamily !== "string" || fontFamily.length > 160
+    || !/^[a-zA-Z0-9 ,"'_-]+$/.test(fontFamily) || !fontFamily.trim())) {
+    throw new TypeError("Dialog appearance fontFamily must be a font list of at most 160 characters");
+  }
+  if (borderRadius !== undefined && (typeof borderRadius !== "number" || !Number.isFinite(borderRadius)
+    || borderRadius < 0 || borderRadius > 24)) {
+    throw new TypeError("Dialog appearance borderRadius must be between 0 and 24 pixels");
+  }
+  // Pick known scalar fields, never invoking a caller's toJSON or carrying CSS.
+  const serialized = JSON.stringify({ theme, accentColor, fontFamily, borderRadius });
+  if (serialized.length > MAX_APPEARANCE_LENGTH) {
+    throw new TypeError("Dialog appearance is too large");
+  }
+  return serialized;
+}

package/cloud/Transport.d.mts

@@ -1,6 +1,4 @@
 export const DEFAULT_API_URL: "https://api.nanocodex.xyz";
-export const MOCK_ACCOUNT_ADDRESS: `0x${string}`;
-export const MOCK_MACHINE_USD_ADDRESS: `0x${string}`;
 
 export type Request = Readonly<{
   path: string;
@@ -36,12 +34,3 @@ export function http(url?: string | undefined, options?: Readonly<{
   key?: string | undefined;
   name?: string | undefined;
 }>): Transport<"http">;
-
-export function mock(options?: Readonly<{
-  accountAddress?: `0x${string}` | undefined;
-  appName?: string | undefined;
-  appOrigin?: string | undefined;
-  key?: string | undefined;
-  machineUsdAddress?: `0x${string}` | undefined;
-  name?: string | undefined;
-}>): Transport<"mock">;