@lamplitisles/dsh-nanocodex 0.1.0-beta.0

package/vendor/nanocodex/actions/events.d.mts

@@ -0,0 +1,10 @@
+import type { Agent, AgentEvent, EventWatcher, WatchEventsOptions } from "../types.mjs";
+
+/** Creates a lazy, terminal watcher for an Agent's ordered event stream. */
+export function watch(agent: Agent<object>, options?: watch.Options): watch.ReturnType;
+export declare namespace watch {
+  type OnEventFn = (event: AgentEvent) => void;
+  type Options = WatchEventsOptions;
+  type ReturnType = EventWatcher;
+  type Watcher = EventWatcher;
+}

package/vendor/nanocodex/actions/events.mjs

@@ -0,0 +1,163 @@
+import { reportError, subscribeAgentEvents } from "../internal.mjs";
+import { utf8ByteLength } from "../runtime/utf8.mjs";
+
+const MAX_BUFFERED_EVENTS = 4_096;
+const MAX_BUFFERED_EVENT_BYTES = 32 * 1024 * 1024;
+
+export function watch(agent, options = {}) {
+  const listeners = new Set();
+  const iterators = new Set();
+  let unsubscribe;
+  let closed = false;
+
+  const emit = (event, encodedLength, encodedEvent, agentId) => {
+    for (const listener of listeners) {
+      try {
+        listener(event, encodedLength, encodedEvent, agentId);
+      } catch (error) {
+        reportError(error);
+      }
+    }
+    for (const iterator of iterators) iterator.push(event, encodedLength);
+  };
+
+  const start = () => {
+    if (closed || unsubscribe) return;
+    unsubscribe = subscribeAgentEvents(agent, emit, options, () => watcher.off());
+  };
+
+  const stopIfIdle = () => {
+    if (listeners.size || iterators.size) return;
+    unsubscribe?.();
+    unsubscribe = undefined;
+  };
+
+  const watcher = {
+    onEvent(listener) {
+      if (typeof listener !== "function") throw new TypeError("events.watch.onEvent requires a listener");
+      if (closed) return () => {};
+      listeners.add(listener);
+      start();
+      return () => {
+        listeners.delete(listener);
+        stopIfIdle();
+      };
+    },
+    off() {
+      if (closed) return;
+      closed = true;
+      unsubscribe?.();
+      unsubscribe = undefined;
+      listeners.clear();
+      for (const iterator of [...iterators]) iterator.end();
+      iterators.clear();
+    },
+    [Symbol.asyncIterator]() {
+      if (closed) return emptyIterator();
+      const iterator = eventIterator(() => {
+        iterators.delete(iterator);
+        stopIfIdle();
+      });
+      iterators.add(iterator);
+      start();
+      return iterator;
+    },
+  };
+  return Object.freeze(watcher);
+}
+
+function eventIterator(onEnd) {
+  const queue = [];
+  let head = 0;
+  let bufferedBytes = 0;
+  const pending = [];
+  let pendingHead = 0;
+  let ended = false;
+  let failure;
+  let failureReported = false;
+  let detached = false;
+
+  const detach = () => {
+    if (detached) return;
+    detached = true;
+    onEnd();
+  };
+
+  const iterator = {
+    push(event, encodedLength) {
+      if (ended || failure) return;
+      if (pendingHead < pending.length) {
+        const resolve = pending[pendingHead++];
+        if (pendingHead === pending.length) {
+          pending.length = 0;
+          pendingHead = 0;
+        }
+        resolve({ done: false, value: event });
+      } else {
+        const bytes = encodedLength ?? utf8ByteLength(JSON.stringify(event));
+        if (
+          queue.length - head >= MAX_BUFFERED_EVENTS
+          || bufferedBytes + bytes > MAX_BUFFERED_EVENT_BYTES
+        ) {
+          failure = new RangeError(
+            `event iterator exceeded its private buffer of ${MAX_BUFFERED_EVENTS} events or `
+              + `${MAX_BUFFERED_EVENT_BYTES} encoded bytes`,
+          );
+          detach();
+          return;
+        }
+        queue.push({ bytes, event });
+        bufferedBytes += bytes;
+      }
+    },
+    end() {
+      if (ended) return;
+      ended = true;
+      detach();
+      while (pendingHead < pending.length) {
+        pending[pendingHead++]({ done: true, value: undefined });
+      }
+      pending.length = 0;
+      pendingHead = 0;
+      queue.length = 0;
+      head = 0;
+      bufferedBytes = 0;
+    },
+    next() {
+      if (head < queue.length) {
+        const entry = queue[head++];
+        bufferedBytes -= entry.bytes;
+        if (head === queue.length) {
+          queue.length = 0;
+          head = 0;
+        }
+        return Promise.resolve({ done: false, value: entry.event });
+      }
+      if (failure && !failureReported) {
+        failureReported = true;
+        return Promise.reject(failure);
+      }
+      if (ended || failure) return Promise.resolve({ done: true, value: undefined });
+      if (pending.length - pendingHead >= MAX_BUFFERED_EVENTS) {
+        return Promise.reject(new RangeError(
+          `event iterator exceeded its private buffer of ${MAX_BUFFERED_EVENTS} pending reads`,
+        ));
+      }
+      return new Promise((resolve) => { pending.push(resolve); });
+    },
+    return() {
+      iterator.end();
+      return Promise.resolve({ done: true, value: undefined });
+    },
+    [Symbol.asyncIterator]() { return this; },
+  };
+  return iterator;
+}
+
+function emptyIterator() {
+  return {
+    next: () => Promise.resolve({ done: true, value: undefined }),
+    return: () => Promise.resolve({ done: true, value: undefined }),
+    [Symbol.asyncIterator]() { return this; },
+  };
+}

package/vendor/nanocodex/actions/index.d.mts

@@ -0,0 +1,13 @@
+import type { Agent, AgentActions } from "../types.mjs";
+
+export * as events from "./events.mjs";
+export * as session from "./session.mjs";
+export * as turn from "./turn.mjs";
+export * as voice from "./voice.mjs";
+
+/** Decorates a base Agent with the standard `turn`, `session`, and `events` domains. */
+export function agentActions(): agentActions.DecoratorFn;
+export declare namespace agentActions {
+  type Decorator = AgentActions;
+  type DecoratorFn = (agent: Agent<object>) => Decorator;
+}

package/vendor/nanocodex/actions/index.mjs

@@ -0,0 +1,35 @@
+import * as events from "./events.mjs";
+import * as session from "./session.mjs";
+import * as turn from "./turn.mjs";
+import * as voice from "./voice.mjs";
+
+export { events, session, turn, voice };
+
+export function agentActions() {
+  return (agent) => ({
+    events: {
+      watch: (options) => events.watch(agent, options),
+    },
+    session: {
+      appendDeveloperMessage: (text) => session.appendDeveloperMessage(agent, text),
+      compact: () => session.compact(agent),
+      context: () => session.context(agent),
+      fork: (options) => session.fork(agent, options),
+      snapshot: () => session.snapshot(agent),
+      setModel: (model) => session.setModel(agent, model),
+      setFastMode: (enabled) => session.setFastMode(agent, enabled),
+      setThinking: (thinking) => session.setThinking(agent, thinking),
+      shutdown: () => session.shutdown(agent),
+      spawn: () => session.spawn(agent),
+      realtime: {
+        start: () => session.startRealtimeConversation(agent),
+        end: () => session.endRealtimeConversation(agent),
+        delegation: (input, transcript) => session.realtimeDelegation(agent, input, transcript),
+        tailDelegation: (transcript) => session.realtimeTailDelegation(agent, transcript),
+      },
+    },
+    turn: {
+      prompt: (options) => turn.prompt(agent, options),
+    },
+  });
+}

package/vendor/nanocodex/actions/session.d.mts

@@ -0,0 +1,66 @@
+import type {
+  Agent,
+  AgentSessionContext,
+  CompactionOutcome,
+  DefaultAgent,
+  ForkOptions,
+  RealtimeTranscriptEntry,
+  SessionSnapshot,
+  Thinking,
+} from "../types.mjs";
+
+/** Appends adapter-owned developer context and returns the latest safe session context. */
+export function appendDeveloperMessage(
+  agent: Agent<object>,
+  text: string,
+): Promise<AgentSessionContext>;
+
+/** Starts the canonical Codex Realtime adapter lifecycle at a safe boundary. */
+export function startRealtimeConversation(agent: Agent<object>): Promise<AgentSessionContext>;
+
+/** Ends the canonical Codex Realtime adapter lifecycle at a safe boundary. */
+export function endRealtimeConversation(agent: Agent<object>): Promise<AgentSessionContext>;
+
+/** Formats structured Realtime input using canonical Codex delegation markers. */
+export function realtimeDelegation(
+  agent: Agent<object>,
+  input: string,
+  transcript?: readonly RealtimeTranscriptEntry[],
+): Promise<string>;
+
+/** Formats an unconsumed transcript tail, or returns undefined for an empty tail. */
+export function realtimeTailDelegation(
+  agent: Agent<object>,
+  transcript: readonly RealtimeTranscriptEntry[],
+): Promise<string | undefined>;
+
+/** Compacts retained history; provider-default compaction returns null. */
+export function compact(agent: Agent<object>): Promise<CompactionOutcome | null>;
+
+/** Returns complete read-only model context at the latest safe boundary. */
+export function context(agent: Agent<object>): Promise<AgentSessionContext>;
+
+/** Returns the latest committed, resumable engine-owned session snapshot. */
+export function snapshot(agent: Agent<object>): Promise<SessionSnapshot>;
+
+/** Forks the latest checkpoint, or the exact completed result supplied in `options.at`. */
+export function fork(agent: Agent<object>, options?: fork.Options): Promise<fork.ReturnType>;
+export declare namespace fork {
+  type Options = ForkOptions;
+  type ReturnType = DefaultAgent;
+}
+
+/** Creates a clean sibling with the Agent's configuration and tools. */
+export function spawn(agent: Agent<object>): Promise<spawn.ReturnType>;
+export declare namespace spawn {
+  type ReturnType = DefaultAgent;
+}
+
+/** Changes the reasoning effort for subsequently accepted turns. */
+export function setThinking(agent: Agent<object>, thinking: Thinking): Promise<void>;
+
+/** Enables or disables priority processing for subsequently accepted turns. */
+export function setFastMode(agent: Agent<object>, enabled: boolean): Promise<void>;
+
+/** Stops the driver and joins every resource owned by this Agent. */
+export function shutdown(agent: Agent<object>): Promise<void>;

package/vendor/nanocodex/actions/session.mjs

@@ -0,0 +1,59 @@
+import {
+  appendDeveloperMessage as appendAgentDeveloperMessage,
+  compact as compactAgent,
+  context as agentContext,
+  fork as forkAgent,
+  snapshot as snapshotAgent,
+  setFastMode as setAgentFastMode,
+  setModel as setAgentModel,
+  setThinking as setAgentThinking,
+  shutdown as shutdownAgent,
+  spawn as spawnAgent,
+} from "../internal.mjs";
+
+export {
+  endRealtimeConversation,
+  realtimeDelegation,
+  realtimeTailDelegation,
+  startRealtimeConversation,
+} from "../internal.mjs";
+
+export function appendDeveloperMessage(agent, text) {
+  return appendAgentDeveloperMessage(agent, text);
+}
+
+export function compact(agent) {
+  return compactAgent(agent);
+}
+
+export function context(agent) {
+  return agentContext(agent);
+}
+
+export function snapshot(agent) {
+  return snapshotAgent(agent);
+}
+
+export function fork(agent, options = {}) {
+  return forkAgent(agent, options);
+}
+
+export function spawn(agent) {
+  return spawnAgent(agent);
+}
+
+export function setThinking(agent, thinking) {
+  return setAgentThinking(agent, thinking);
+}
+
+export function setModel(agent, model) {
+  return setAgentModel(agent, model);
+}
+
+export function setFastMode(agent, enabled) {
+  return setAgentFastMode(agent, enabled);
+}
+
+export function shutdown(agent) {
+  return shutdownAgent(agent);
+}

package/vendor/nanocodex/actions/turn.d.mts

@@ -0,0 +1,59 @@
+import type {
+  Agent,
+  PromptInput,
+  SessionSnapshot,
+  Turn,
+  TurnResult,
+  TurnUsage,
+} from "../types.mjs";
+
+/** Accepts a prompt on an owned Agent and returns its independently awaitable Turn. */
+export function prompt<const agent extends Agent<object>>(
+  agent: agent,
+  options: prompt.Options,
+): prompt.ReturnType<agent>;
+export declare namespace prompt {
+  type Options = {
+    input: PromptInput;
+    id?: string | undefined;
+    supplementaryContext?: string | undefined;
+  };
+  type ReturnType<agent extends Agent<object> = Agent<object>> = Turn<agent>;
+}
+
+/** Waits for durable admission and returns its request ID when one was assigned. */
+export function accepted(turn: Turn): Promise<accepted.ReturnType>;
+export declare namespace accepted {
+  type ReturnType = string | undefined;
+}
+
+/** Waits for a Turn's typed completed result. */
+export function getResult(turn: Turn): Promise<getResult.ReturnType>;
+export declare namespace getResult {
+  type ReturnType = TurnResult;
+}
+
+/** Materializes a completed result's serializable session snapshot. */
+export function getSnapshot(result: TurnResult): Promise<getSnapshot.ReturnType>;
+export declare namespace getSnapshot {
+  type ReturnType = SessionSnapshot;
+}
+
+/** Materializes exact aggregate token usage from a completed result. */
+export function getUsage(result: TurnResult): Promise<getUsage.ReturnType>;
+export declare namespace getUsage {
+  type ReturnType = TurnUsage;
+}
+
+/** Adds input to an active Turn. */
+export function steer(turn: Turn, options: steer.Options): Promise<void>;
+export declare namespace steer {
+  type Options = { input: PromptInput };
+  type ReturnType = void;
+}
+
+/** Cancels an active or queued Turn. */
+export function cancel(turn: Turn): Promise<void>;
+export declare namespace cancel {
+  type ReturnType = void;
+}

package/vendor/nanocodex/actions/turn.mjs

@@ -0,0 +1,37 @@
+import {
+  awaitTurnAcceptance,
+  cancel as cancelTurn,
+  getTurnResult,
+  getTurnSnapshot,
+  getTurnUsage,
+  prompt as promptTurn,
+  steer as steerTurn,
+} from "../internal.mjs";
+
+export function prompt(agent, options) {
+  return promptTurn(agent, options);
+}
+
+export function getResult(turn) {
+  return getTurnResult(turn);
+}
+
+export function accepted(turn) {
+  return awaitTurnAcceptance(turn);
+}
+
+export function getSnapshot(result) {
+  return getTurnSnapshot(result);
+}
+
+export function getUsage(result) {
+  return getTurnUsage(result);
+}
+
+export function steer(turn, options) {
+  return steerTurn(turn, options);
+}
+
+export function cancel(turn) {
+  return cancelTurn(turn);
+}

package/vendor/nanocodex/actions/voice.d.mts

@@ -0,0 +1,22 @@
+import type {
+  create as createResource,
+  Event,
+  Options,
+  Snapshot,
+  Settings,
+  Voice,
+} from "../browser/Voice.mjs";
+
+export function create(agent: Parameters<typeof createResource>[0], options?: Options): Voice;
+export function start(voice: Voice, options?: Settings): Promise<void>;
+export function stop(voice: Voice): Promise<void>;
+export function toggle(voice: Voice, options?: Settings): Promise<void>;
+export function cancel(voice: Voice): Promise<boolean>;
+export function destroy(voice: Voice): Promise<void>;
+export function getSnapshot(voice: Voice): Snapshot;
+export function subscribe(voice: Voice, listener: () => void): () => void;
+export function onEvent(voice: Voice, listener: (event: Event) => void): () => void;
+
+export function speak(voice: Voice, text: string): Promise<void>;
+export function appendText(voice: Voice, text: string, options?: { role?: "user" | "developer" | "assistant" }): Promise<void>;
+export function appendContext(voice: Voice, text: string): Promise<void>;

package/vendor/nanocodex/actions/voice.mjs

@@ -0,0 +1,50 @@
+import { create as createResource } from "../browser/Voice.mjs";
+
+/** Creates one browser voice resource backed by the Agent's Rust/WASM controller. */
+export function create(agent, options) {
+  return createResource(agent, options);
+}
+
+export function start(voice, options) {
+  return voice.start(options);
+}
+
+export function stop(voice) {
+  return voice.stop();
+}
+
+export function toggle(voice, options) {
+  return voice.toggle(options);
+}
+
+export function cancel(voice) {
+  return voice.cancel();
+}
+
+export function destroy(voice) {
+  return voice.destroy();
+}
+
+export function getSnapshot(voice) {
+  return voice.getSnapshot();
+}
+
+export function subscribe(voice, listener) {
+  return voice.subscribe(listener);
+}
+
+export function onEvent(voice, listener) {
+  return voice.onEvent(listener);
+}
+
+export function speak(voice, text) {
+  return voice.speak(text);
+}
+
+export function appendText(voice, text, options) {
+  return voice.appendText(text, options);
+}
+
+export function appendContext(voice, text) {
+  return voice.appendContext(text);
+}

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

@@ -0,0 +1,55 @@
+import type {
+  AgentLifecycle,
+  AgentOptions,
+  DefaultAgent,
+  ExecutionEnvironment,
+} from "../types.mjs";
+import type { ManagedTransport, WorkerTransport } from "./Transport.mjs";
+import type { Tools } from "../tools/Tools.mjs";
+
+export type Agent = DefaultAgent;
+/** Worker options exclude function-valued resolver callbacks. */
+type WorkerAgentOptions = Omit<AgentOptions, "resolveCompactionInstruction">;
+
+type WorkerMcpServer = Readonly<{
+  url?: string | URL | undefined;
+  description?: string | undefined;
+  headers?: Readonly<Record<string, string>> | readonly (readonly [string, string])[] | undefined;
+  enabledTools?: readonly string[] | undefined;
+  disabledTools?: readonly string[] | undefined;
+  supportsParallelToolCalls?: boolean | undefined;
+  parallelTools?: readonly string[] | undefined;
+  startupTimeoutMs?: number | undefined;
+  timeoutMs?: number | undefined;
+}>;
+type WorkerMcpServers = Readonly<Record<string, string | URL | WorkerMcpServer>>;
+type WorkerToolExposureOptions =
+  | { mcp?: false | undefined; toolMode?: "code" | "direct" | undefined }
+  | { mcp: WorkerMcpServers; toolMode?: "code" | undefined };
+
+/** Creates a Rust/WASM Agent in a package-owned browser module Worker. */
+export function create(options: create.ManagedOptions): Promise<AgentLifecycle>;
+export function create(options?: create.Options): Promise<create.ReturnType>;
+export declare namespace create {
+  type ManagedOptions = Readonly<{
+    transport: ManagedTransport;
+    tools?: Tools | undefined;
+  }>;
+  type Options = WorkerAgentOptions & WorkerToolExposureOptions & {
+    /** Precompiled browser module; WebAssembly modules are structured-clone-safe. */
+    module?: WebAssembly.Module | undefined;
+    /** Fixed browser workspace facts, including its AGENTS.md snapshot. */
+    executionEnvironment?: ExecutionEnvironment | undefined;
+    /** Defaults to the same-origin Nanocodex `/api/responses` proxy. */
+    transport?: WorkerTransport | undefined;
+    /** Stable OPFS/Git workspace identity for the default browser harness. */
+    threadId?: string | undefined;
+    /** Exposes provider authorization links in the default browser harness. */
+    accountConnectionRequests?: boolean | undefined;
+    /** Set false to keep this browser session out of the IndexedDB durability store. */
+    durability?: false | undefined;
+    /** Set false to omit the default OPFS, shell, web, image, plan, and artifact tools. */
+    harness?: false | undefined;
+  };
+  type ReturnType = Agent;
+}

package/vendor/nanocodex/browser/Agent.mjs

@@ -0,0 +1,11 @@
+import {
+  createManagedAgent,
+  managedTransportOptions,
+} from "../runtime/managed-transport.mjs";
+
+/** Create the browser Agent in its package-owned module Worker. */
+export function create(options = {}) {
+  if (managedTransportOptions(options?.transport)) return createManagedAgent(options);
+  return import("./WorkerAgent.mjs").then(({ createWorkerAgent }) =>
+    createWorkerAgent(options));
+}

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

@@ -0,0 +1,7 @@
+import type {
+  ChatGptSubscriptionHandle,
+  ChatGptSubscriptionOptions,
+} from "../types.mjs";
+
+/** Opens the Rust-owned ChatGPT device-login and credential lifecycle. */
+export function open(options: ChatGptSubscriptionOptions): Promise<ChatGptSubscriptionHandle>;

package/vendor/nanocodex/browser/ChatGptSubscription.mjs

@@ -0,0 +1,19 @@
+import init, { ChatGptSubscription as WasmChatGptSubscription } from "../pkg-web/nanocodex.js";
+
+import { installHostBridge } from "../internal.mjs";
+import { openSubscription } from "../runtime/chatgpt-subscription.mjs";
+
+let initialized;
+
+/** Opens a Rust-managed ChatGPT subscription over caller-owned storage and fetch. */
+export async function open(options) {
+  installHostBridge();
+  initialized ||= init(options?.module === undefined
+    ? undefined
+    : { module_or_path: options.module }).catch((error) => {
+      initialized = undefined;
+      throw error;
+    });
+  await initialized;
+  return openSubscription(options, (config) => WasmChatGptSubscription.open(config));
+}