@lamplitisles/dsh-nanocodex 0.1.0-beta.0

package/vendor/nanocodex/browser/InlineAgent.mjs

@@ -0,0 +1,266 @@
+import { applyBrowserPatch, Nanocodex } from "../pkg-web/nanocodex.js";
+
+import { agentActions } from "../actions/index.mjs";
+import {
+  activateHost,
+  activateCloudflareAgentSession,
+  bindHostSession,
+  CLOUDFLARE_SESSION_RESERVATION,
+  createAgentClient,
+  createEventChannel,
+  createSessionId,
+  defineRuntime,
+  loadDurabilityRuntime,
+  loadSubscriptionRuntime,
+  reportError,
+  registerDefinitionHost,
+  releaseDefinitionHost,
+  releaseHostSession,
+  toWasmConfig,
+} from "../internal.mjs";
+import { createBrowserHost } from "./host.mjs";
+import { initializeBrowserEngine } from "./engine.mjs";
+import { resolveResponsesTransport } from "../runtime/responses-transport.mjs";
+import {
+  createManagedAgent,
+  managedTransportOptions,
+} from "../runtime/managed-transport.mjs";
+import { resolveTools } from "../runtime/tool-configuration.mjs";
+import {
+  hostManaged as defaultHostManagedTransport,
+} from "./Transport.mjs";
+
+/** Creates the Rust/WASM Agent in the current Web API host isolate. */
+export async function create(options = {}) {
+  if (managedTransportOptions(options?.transport)) return createManagedAgent(options);
+  const internalRuntime = options[Symbol.for("nanocodex.browser.internalRuntime")];
+  if (internalRuntime !== undefined
+    && (!internalRuntime || typeof internalRuntime !== "object" || Array.isArray(internalRuntime))) {
+    throw new TypeError("browser Agent internal runtime options must be an object");
+  }
+  const {
+    transport,
+    module,
+    model,
+    thinking,
+    reasoningMode,
+    fastMode,
+    instructions,
+    additionalInstructions,
+    companionCompactionInstruction,
+    resolveCompactionInstruction,
+    historySeed,
+    sessionId,
+    workspace,
+    resume,
+    durability,
+    durabilityId,
+    terminalReceiptRetention,
+    filesystem,
+    filesystemTools,
+    tools,
+    toolMode,
+    mcp,
+    executionEnvironment,
+    codeEvaluator,
+  } = options;
+  const toolProviders = internalRuntime?.toolProviders;
+  const subagentSessions = internalRuntime?.subagentSessions;
+  const cloudflareReservation = internalRuntime?.[CLOUDFLARE_SESSION_RESERVATION];
+  const stableSessionId = sessionId ?? createSessionId();
+  const {
+    apiKey,
+    hostAuth,
+    hostManagedProtocol,
+    subscription,
+    mpp,
+    websocketUrl,
+    websocketPreconnect,
+    apiBaseUrl,
+    websocketWarmup,
+    WebSocketImpl,
+    createWebSocket,
+  } = resolveResponsesTransport(transport ?? defaultHostManagedTransport());
+  const { tools: hostTools, subagents: configuredSubagents } = resolveTools(tools);
+  const subagentMaxConcurrency = internalRuntime?.subagentMaxConcurrency;
+  if (subagentMaxConcurrency !== undefined
+    && (!Number.isSafeInteger(subagentMaxConcurrency) || subagentMaxConcurrency < 1)) {
+    throw new TypeError("host subagentMaxConcurrency must be a positive safe integer");
+  }
+  // Hosted runtimes own the resource ceiling, including when their tools are
+  // a prepared router rather than a named-tool array. A caller's lower cap wins.
+  const subagentConfig = configuredSubagents === undefined || subagentMaxConcurrency === undefined
+    ? configuredSubagents
+    : {
+      ...configuredSubagents,
+      max_concurrency: Math.min(configuredSubagents.max_concurrency ?? subagentMaxConcurrency, subagentMaxConcurrency),
+    };
+  if (filesystem && workspace !== undefined && workspace !== filesystem.root) {
+    throw new TypeError("workspace must match filesystem.root when both are provided");
+  }
+  const events = createEventChannel();
+  const tempoMcp = mpp?.[Symbol.for("nanocodex.tempo.mcp")];
+  let hostDefinitionId;
+  const host = createBrowserHost({
+    WebSocketImpl,
+    createWebSocket,
+    hostAuth: hostAuth === true
+      || (apiKey === undefined && mpp === undefined && subscription === undefined),
+    hostManagedProtocol,
+    mpp,
+    onEvent: events.emit,
+    filesystem,
+    filesystemTools,
+    tools: hostTools,
+    toolProviders,
+    subagentSessions,
+    toolMode,
+    mcp: mcp === false
+      ? undefined
+      : tempoMcp ? { ...tempoMcp, ...mcp } : mcp,
+    codeEvaluator,
+    resolveCompactionInstruction,
+    applyPatch: applyBrowserPatch,
+    websocketPreconnect,
+    websocketUrl,
+    onDispose: () => releaseDefinitionHost(hostDefinitionId),
+  });
+  let durabilityOwner;
+  let creationStarted = false;
+  hostDefinitionId = registerDefinitionHost(host, cloudflareReservation);
+  activateHost(host);
+  const runtime = defineRuntime({
+    key: "browser-wasm",
+    name: "Nanocodex Browser WASM",
+    type: "browser",
+    async create(config) {
+      creationStarted = true;
+      let raw;
+      try {
+        if (durability !== undefined || durabilityId !== undefined) {
+          durabilityOwner = (await loadDurabilityRuntime()).own(
+            host,
+            durability,
+            durabilityId,
+          );
+        }
+        activateHost(host);
+        await host.ready();
+        await initializeBrowserEngine({ module });
+        activateHost(host);
+        const configJson = JSON.stringify(toWasmConfig({
+          apiKey: apiKey ?? (mpp === undefined
+            ? subscription === undefined ? "host-managed" : "subscription-managed"
+            : "mpp-managed"),
+          websocketUrl: websocketUrl ?? (mpp === undefined
+            ? undefined
+            : "wss://openai.mpp.tempo.xyz/v1/responses"),
+          apiBaseUrl,
+          websocketWarmup,
+          subagents: subagentConfig,
+          hostDefinitionId,
+          ...config,
+          durabilityHostId: durabilityOwner?.id,
+        }));
+        raw = subscription === undefined
+          ? await Nanocodex.create(configJson)
+          : await Nanocodex.createWithChatGpt(
+              configJson,
+              (await loadSubscriptionRuntime()).rawSubscription(subscription),
+            );
+        if (cloudflareReservation !== undefined) {
+          activateCloudflareAgentSession(cloudflareReservation);
+          const restoredSubagents = subagentSessions?.restore?.() ?? [];
+          if (restoredSubagents.length > 0) {
+            const restoredHostContextRefs = Object.fromEntries(
+              restoredSubagents.map((descriptor) => {
+                const hostContextRef = subagentSessions?.hostContextRef?.(descriptor.sessionId);
+                return [descriptor.sessionId, hostContextRef ?? null];
+              }),
+            );
+            await raw.restoreSubagents(
+              JSON.stringify(restoredSubagents),
+              JSON.stringify(restoredHostContextRefs),
+            );
+          }
+        }
+        return raw;
+      } catch (error) {
+        const cleanupErrors = [];
+        if (raw !== undefined) {
+          try { await raw.shutdown(); }
+          catch (cleanupError) { cleanupErrors.push(cleanupError); }
+          try { raw.free(); }
+          catch (cleanupError) { cleanupErrors.push(cleanupError); }
+        }
+        try { durabilityOwner?.abandon(); }
+        catch (cleanupError) { cleanupErrors.push(cleanupError); }
+        try { await host.dispose(); }
+        catch (cleanupError) { cleanupErrors.push(cleanupError); }
+        if (cleanupErrors.length > 0) {
+          throw new AggregateError(
+            [error, ...cleanupErrors],
+            "browser Agent creation and cleanup both failed",
+          );
+        }
+        throw error;
+      }
+    },
+    subscribe: events.subscribe,
+    adopt(raw) {
+      host.retain();
+      try {
+        durabilityOwner?.retain();
+        bindHostSession(host, raw.sessionId, cloudflareReservation);
+        events.addSource(raw);
+      } catch (error) {
+        events.removeSource(raw);
+        durabilityOwner?.release();
+        releaseHost(host);
+        throw error;
+      }
+    },
+    release(raw) {
+      events.removeSource(raw);
+      host.releaseSession(raw.sessionId);
+      releaseHostSession(host, raw.sessionId);
+      durabilityOwner?.release();
+      releaseHost(host);
+    },
+    decorate: (agent) => agent.extend(agentActions()),
+  });
+  let agent;
+  try {
+    agent = await createAgentClient(runtime, {
+      model,
+      thinking,
+      reasoningMode,
+      fastMode,
+      instructions,
+      additionalInstructions,
+      companionCompactionInstruction,
+      resolveCompactionInstruction,
+      historySeed,
+      sessionId: stableSessionId,
+      workspace: workspace ?? filesystem?.root,
+      executionEnvironment,
+      resume,
+      durabilityId,
+      terminalReceiptRetention,
+    }, cloudflareReservation);
+  } catch (error) {
+    if (!creationStarted) await host.dispose();
+    throw error;
+  }
+  if (websocketPreconnect && websocketUrl) {
+    // Preconnect is speculative. A normal turn reconnects through the owned
+    // transport path, while adapters that require startup validation (such as
+    // Cloudflare) observe the same attempt at their createWebSocket boundary.
+    void host.preconnect(websocketUrl, agent.sessionId).catch(() => {});
+  }
+  return agent;
+}
+
+function releaseHost(host) {
+  void host.release().catch(reportError);
+}

package/vendor/nanocodex/browser/Transport.d.mts

@@ -0,0 +1,74 @@
+import type {
+  ChatGptSubscriptionHandle,
+  MppSession,
+} from "../types.mjs";
+import type { Options as ManagedClientOptions } from "../managed/Agent.mjs";
+import type {
+  BrowserWebSocketConnection,
+  BrowserWebSocketRequest,
+} from "./host.mjs";
+
+declare const responsesTransport: unique symbol;
+declare const workerTransport: unique symbol;
+declare const managedTransport: unique symbol;
+
+export type ResponsesTransport = Readonly<{
+  [responsesTransport]: true;
+}>;
+export type ManagedTransport = Readonly<{ [managedTransport]: true }>;
+export type Transport = ResponsesTransport | ManagedTransport;
+
+/** A Responses transport whose complete descriptor can cross a module Worker boundary. */
+export type WorkerTransport = ResponsesTransport & Readonly<{
+  [workerTransport]: true;
+}>;
+
+type SharedEndpointOptions = Readonly<{
+  apiBaseUrl?: string | undefined;
+  websocketUrl?: string | undefined;
+  /** Open the persistent socket as soon as Agent.create returns. Defaults to true for hostManaged. */
+  websocketPreconnect?: boolean | undefined;
+  websocketWarmup?: boolean | undefined;
+}>;
+
+type WorkerEndpointOptions = SharedEndpointOptions & Readonly<{
+  WebSocketImpl?: never;
+  createWebSocket?: never;
+}>;
+
+type EndpointOptions = SharedEndpointOptions & Readonly<{
+  WebSocketImpl?: typeof WebSocket | undefined;
+  createWebSocket?(
+    endpoint: string,
+    sessionId: string,
+    request: BrowserWebSocketRequest,
+  ): WebSocket | BrowserWebSocketConnection | Promise<WebSocket | BrowserWebSocketConnection>;
+}>;
+
+export function openAi(options: WorkerEndpointOptions & Readonly<{
+  apiKey: string;
+}>): WorkerTransport;
+export function openAi(options: EndpointOptions & Readonly<{
+  apiKey: string;
+}>): ResponsesTransport;
+
+export function chatGpt(options: EndpointOptions & Readonly<{
+  subscription: ChatGptSubscriptionHandle;
+}>): ResponsesTransport;
+
+/** Same-origin Nanocodex Responses proxy; defaults to `/api/responses`. */
+export function hostManaged(options?: WorkerEndpointOptions): WorkerTransport;
+export function hostManaged(options?: EndpointOptions): ResponsesTransport;
+
+export function mpp(options: EndpointOptions & Readonly<{
+  session: MppSession;
+}>): ResponsesTransport;
+
+export type ManagedIdentity =
+  | Readonly<{ create: true; id?: never }>
+  | Readonly<{ id: string; create?: never }>;
+
+/** Account-authenticated durable Agent transport with explicit create/open identity. */
+export function managed(options: ManagedClientOptions & Readonly<{
+  agent: ManagedIdentity;
+}>): ManagedTransport;

package/vendor/nanocodex/browser/Transport.mjs

@@ -0,0 +1,61 @@
+import {
+  createResponsesTransport,
+  nonEmpty,
+} from "../runtime/responses-transport.mjs";
+import { createManagedTransport } from "../runtime/managed-transport.mjs";
+import { defaultHostManagedWebSocketUrl } from "./hostManagedWebSocket.mjs";
+
+export function openAi(options) {
+  const apiKey = nonEmpty(options?.apiKey, "OpenAI API key");
+  return createResponsesTransport({
+    apiKey,
+    ...connection(options),
+  });
+}
+
+export function chatGpt(options) {
+  if (!options?.subscription || typeof options.subscription !== "object") {
+    throw new TypeError("ChatGPT transport requires a subscription handle");
+  }
+  return createResponsesTransport({
+    subscription: options.subscription,
+    ...connection(options),
+  });
+}
+
+export function hostManaged(options = {}) {
+  const websocketUrl = options.websocketUrl
+    ?? (options.createWebSocket ? undefined : defaultHostManagedWebSocketUrl());
+  return createResponsesTransport({
+    hostAuth: true,
+    hostManagedProtocol: true,
+    ...connection({ ...options, websocketUrl }),
+    websocketPreconnect: options.websocketPreconnect ?? true,
+  });
+}
+
+export function mpp(options) {
+  if (!options?.session || typeof options.session.ws !== "function") {
+    throw new TypeError("MPP transport requires a session with ws(endpoint)");
+  }
+  return createResponsesTransport({
+    mpp: options.session,
+    ...connection(options),
+  });
+}
+
+/** Account-authenticated durable Agent transport with explicit create/open identity. */
+export function managed(options) {
+  return createManagedTransport(options);
+}
+
+function connection(options = {}) {
+  return {
+    WebSocketImpl: options.WebSocketImpl,
+    apiBaseUrl: options.apiBaseUrl,
+    createWebSocket: options.createWebSocket,
+    websocketUrl: options.websocketUrl,
+    websocketPreconnect: options.websocketPreconnect,
+    websocketWarmup: options.websocketWarmup,
+  };
+}

package/vendor/nanocodex/browser/Voice.d.mts

@@ -0,0 +1,71 @@
+import type { DefaultAgent } from "../types.mjs";
+import type { Agent as ManagedAgent } from "../managed/Agent.mjs";
+import type { ConnectAgent } from "../cloud/types.mjs";
+
+export const voices: readonly ["juniper", "maple", "spruce", "ember", "vale", "breeze", "arbor", "sol", "cove"];
+export const defaultVoice: "cove";
+export type VoiceName = (typeof voices)[number];
+export type VoiceErrorCode =
+  | "ice_gathering_timeout"
+  | "microphone_capture_cancelled"
+  | "microphone_capture_timeout"
+  | "microphone_not_found"
+  | "microphone_permission_blocked"
+  | "microphone_unavailable"
+  | "realtime_call_timeout"
+  | "sideband_open_timeout";
+export declare class VoiceError extends Error {
+  readonly code: VoiceErrorCode;
+  constructor(code: VoiceErrorCode, message: string, options?: { cause?: unknown });
+}
+export type Transcript = Readonly<{
+  speaker: "user" | "assistant";
+  text: string;
+  id?: string;
+  isPartial?: boolean;
+}>;
+export type Snapshot = Readonly<{
+  error: Error | undefined;
+  status: "idle" | "connecting" | "active" | "error";
+  statusText: string | undefined;
+  transcripts: readonly Transcript[];
+  voice: VoiceName | undefined;
+}>;
+export type Event =
+  | Readonly<{ type: "connecting"; voice: VoiceName }>
+  | Readonly<{ type: "started"; voice: VoiceName }>
+  | Readonly<{ type: "transcript"; speaker: "user" | "assistant"; text: string; id?: string; isPartial?: false }>
+  | Readonly<{ type: "transcript.delta"; speaker: "user" | "assistant"; text: string; id: string; isPartial: true }>
+  | Readonly<{ type: "error"; error: Error }>
+  | Readonly<{ type: "stopped" }>;
+export type Settings = Readonly<{
+  voice?: VoiceName | undefined;
+  /** Additional speaking preferences; base assistant instructions are retained. */
+  instructions?: string | undefined;
+  pace?: "slow" | "natural" | "fast" | undefined;
+  updates?: "auto" | "results" | "silent" | undefined;
+  handoffMode?: "thinking" | "commentary" | "bem_tags" | undefined;
+  acknowledgements?: boolean | undefined;
+}>;
+export type Options = Settings & Readonly<{
+  callUrl?: string | URL | undefined;
+  sidebandUrl?(callId: string, sessionId: string): string | URL | Promise<string | URL>;
+  captureMicrophone?(): Promise<MediaStream>;
+  beforeAgentTurn?(): Promise<void>;
+}>;
+export type Voice = Readonly<{
+  cancel(): Promise<boolean>;
+  /** Speak explicitly during an active call, independent of background update preferences. */
+  speak(text: string): Promise<void>;
+  /** Codex subscription voice treats every API role as context text. */
+  appendText(text: string, options?: { role?: "user" | "developer" | "assistant" }): Promise<void>;
+  appendContext(text: string): Promise<void>;
+  destroy(): Promise<void>;
+  getSnapshot(): Snapshot;
+  onEvent(listener: (event: Event) => void): () => void;
+  start(options?: Settings): Promise<void>;
+  stop(): Promise<void>;
+  subscribe(listener: () => void): () => void;
+  toggle(options?: Settings): Promise<void>;
+}>;
+export function create(agent: DefaultAgent | ManagedAgent | ConnectAgent, options?: Options): Voice;