@lamplitisles/dsh-nanocodex 0.1.0-beta.0

package/vendor/nanocodex/pkg-node/nanocodex.d.ts

@@ -0,0 +1,675 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/**
+ * Rust-owned Codex browser voice protocol and Agent bridge.
+ */
+export class BrowserVoice {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Applies one typed Agent event to the Rust-owned handoff stream.
+     *
+     * # Errors
+     *
+     * Rejects only when effects cannot be serialized.
+     */
+    agentEvent(envelope: string): string;
+    /**
+     * Adds background context without requesting speech or consuming a delegation.
+     *
+     * # Errors
+     * Rejects an inactive session or invalid text.
+     */
+    appendContext(text: string): string;
+    /**
+     * Queues explicitly speakable text in the current conversation.
+     *
+     * # Errors
+     * Rejects inactive sessions, invalid text, or a full output queue.
+     */
+    appendSpeech(text: string): string;
+    /**
+     * Appends text through Codex's subscription context adapter.
+     *
+     * # Errors
+     * Rejects inactive sessions, invalid roles/text, or a full output queue.
+     */
+    appendText(role: string, text: string): string;
+    /**
+     * Encodes the complete same-origin call request after the browser creates its SDP offer.
+     *
+     * # Errors
+     *
+     * Rejects calls made before [`Self::start`] or an empty SDP offer.
+     */
+    callBody(sdp: string): string;
+    /**
+     * Cancels only the active coding turn, never merely the voice transport.
+     *
+     * # Errors
+     *
+     * Rejects when the active turn cannot be cancelled.
+     */
+    cancel(): Promise<boolean>;
+    /**
+     * Decodes Codex's provider response body and Location header in Rust.
+     *
+     * # Errors
+     *
+     * Rejects an empty SDP answer or a Location without a Codex call identity.
+     */
+    completeCall(response_body: string, location: string): string;
+    /**
+     * Sets subscription voice preferences before starting a call.
+     *
+     * # Errors
+     * Rejects invalid settings or changes to an active call.
+     */
+    configure(settings_json: string): void;
+    /**
+     * Drains one Codex-paced streamed or final Agent handoff chunk.
+     *
+     * # Errors
+     *
+     * Rejects only when effects cannot be serialized.
+     */
+    flush(final_chunk: boolean): string;
+    /**
+     * Acknowledges frames written by the browser WebSocket effect executor.
+     */
+    framesSent(count: number): void;
+    /**
+     * Selects Codex's preferred physical input from browser device labels.
+     *
+     * # Errors
+     *
+     * Rejects malformed label JSON.
+     */
+    preferredPhysicalInput(current_label: string, labels_json: string): number | undefined;
+    /**
+     * Applies one Frameless sideband event and routes any delegation through the Rust Agent.
+     *
+     * # Errors
+     *
+     * Rejects when delegated Agent work cannot be accepted or steered.
+     */
+    realtimeMessage(payload: string): Promise<string>;
+    /**
+     * Reports whether one Rust-decoded sideband event can admit Agent work.
+     */
+    requiresAgentAdmission(payload: string): boolean;
+    /**
+     * Applies Codex's Rust-owned Frameless reconnect policy after transport loss.
+     *
+     * # Errors
+     *
+     * Rejects only when effects cannot be serialized.
+     */
+    sidebandClosed(connected_ms: number): string;
+    /**
+     * Replays Rust-retained outbound frames after a sideband connects.
+     *
+     * # Errors
+     *
+     * Rejects only when effects cannot be serialized.
+     */
+    sidebandOpened(): string;
+    /**
+     * Builds the same-origin sideband URL with Codex's Rust-owned request identity.
+     *
+     * # Errors
+     *
+     * Rejects a malformed provider call identity.
+     */
+    sidebandUrl(call_id: string): string;
+    /**
+     * Begins Codex's Realtime lifecycle and builds bounded browser startup context in Rust.
+     *
+     * # Errors
+     *
+     * Rejects when the Agent driver has stopped.
+     */
+    start(): Promise<void>;
+    /**
+     * Flushes any final transcript tail and ends Codex's Realtime lifecycle.
+     *
+     * # Errors
+     *
+     * Rejects when the Agent driver stops.
+     */
+    stop(): Promise<string>;
+}
+
+/**
+ * JavaScript binding over the Rust-owned hosted ChatGPT credential lifecycle.
+ */
+export class ChatGptSubscription {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Resolves one credential generation for a host-owned outbound request.
+     */
+    credential(): Promise<string>;
+    /**
+     * Clears the persisted credential and pending login.
+     */
+    logout(): Promise<void>;
+    /**
+     * Opens a subscription over the currently registered generic host capabilities.
+     */
+    static open(config_json: string): Promise<ChatGptSubscription>;
+    /**
+     * Refreshes a rejected generation and returns the credential now current.
+     */
+    recover(rejected_revision: string): Promise<string>;
+    /**
+     * Starts a ChatGPT device login and returns public pending state as JSON.
+     */
+    startLogin(): Promise<string>;
+    /**
+     * Polls device login and returns public state as JSON.
+     */
+    status(): Promise<string>;
+}
+
+/**
+ * Standalone Rust-owned browser voice protocol for a remote managed Agent.
+ *
+ * This core owns only Realtime protocol state. The caller owns media,
+ * transports, the managed Agent lifecycle, and routing returned delegations.
+ */
+export class ManagedBrowserVoice {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Applies one canonical raw `AgentEvent` JSON value to the handoff stream.
+     *
+     * # Errors
+     *
+     * Rejects only when effects cannot be serialized.
+     */
+    agentEvent(event_json: string): string;
+    /**
+     * Adds background context without requesting speech or consuming a delegation.
+     *
+     * # Errors
+     * Rejects an inactive session or invalid text.
+     */
+    appendContext(text: string): string;
+    /**
+     * Queues explicitly speakable text in the current conversation.
+     *
+     * # Errors
+     * Rejects inactive sessions, invalid text, or a full output queue.
+     */
+    appendSpeech(text: string): string;
+    /**
+     * Appends text through Codex's subscription context adapter.
+     *
+     * # Errors
+     * Rejects inactive sessions, invalid roles/text, or a full output queue.
+     */
+    appendText(role: string, text: string): string;
+    /**
+     * Encodes the managed same-origin call request after the browser creates its SDP offer.
+     *
+     * # Errors
+     *
+     * Rejects invalid session IDs or empty SDP offers. Admission can complete
+     * after this request; its context is then sent over the control channel.
+     */
+    callBody(sdp: string, managed_session_id: string): string;
+    /**
+     * Decodes Codex's provider response body and Location header in Rust.
+     *
+     * # Errors
+     *
+     * Rejects an empty SDP answer or a Location without a Codex call identity.
+     */
+    completeCall(response_body: string, location: string): string;
+    /**
+     * Sets subscription voice preferences before starting a call.
+     *
+     * # Errors
+     * Rejects invalid settings or changes to an active call.
+     */
+    configure(settings_json: string): void;
+    /**
+     * Drains one Codex-paced streamed or final managed Agent handoff chunk.
+     *
+     * # Errors
+     *
+     * Rejects only when effects cannot be serialized.
+     */
+    flush(final_chunk: boolean): string;
+    /**
+     * Acknowledges frames written by the caller's WebSocket effect executor.
+     */
+    framesSent(count: number): void;
+    /**
+     * Applies a scoped managed context envelope using the shared Rust queue.
+     *
+     * # Errors
+     * Rejects malformed JSON or effects that cannot be serialized.
+     */
+    managedEvent(envelope_json: string): string;
+    /**
+     * Creates an idle managed browser voice protocol core.
+     *
+     * # Errors
+     *
+     * Rejects voices outside Codex's ChatGPT V3 catalog.
+     */
+    constructor(voice: string);
+    /**
+     * Selects Codex's preferred physical input from browser device labels.
+     *
+     * # Errors
+     *
+     * Rejects malformed label JSON.
+     */
+    preferredPhysicalInput(current_label: string, labels_json: string): number | undefined;
+    /**
+     * Applies one sideband event and returns effects plus canonical delegation text.
+     *
+     * The caller must route returned delegation text through its remote managed Agent.
+     *
+     * # Errors
+     *
+     * Rejects only when the update cannot be serialized.
+     */
+    realtimeMessage(payload: string): string;
+    /**
+     * Reports whether one sideband event may produce a managed Agent delegation.
+     */
+    requiresAgentAdmission(payload: string): boolean;
+    /**
+     * Applies Codex's bounded reconnect policy after sideband transport loss.
+     *
+     * # Errors
+     *
+     * Rejects only when effects cannot be serialized.
+     */
+    sidebandClosed(connected_ms: number): string;
+    /**
+     * Replays Rust-retained outbound frames after a sideband connects.
+     *
+     * # Errors
+     *
+     * Rejects only when effects cannot be serialized.
+     */
+    sidebandOpened(): string;
+    /**
+     * Builds the managed same-origin sideband URL for a provider call identity.
+     *
+     * # Errors
+     *
+     * Rejects malformed provider call or managed session identities.
+     */
+    sidebandUrl(call_id: string, managed_session_id: string): string;
+    /**
+     * Starts the protocol from the managed Agent's authoritative serialized context.
+     *
+     * # Errors
+     *
+     * Rejects malformed `AgentSessionContext` JSON.
+     */
+    start(context_json: string): void;
+    /**
+     * Stops the protocol and returns final transcript delegation plus close effects.
+     *
+     * # Errors
+     *
+     * Rejects only when the update cannot be serialized.
+     */
+    stop(): string;
+}
+
+/**
+ * JavaScript binding over the shared Rust agent lifecycle.
+ */
+export class Nanocodex {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Appends adapter-owned developer context at the next safe model boundary.
+     *
+     * Returns the complete read-only session context captured at that boundary.
+     *
+     * # Errors
+     *
+     * Rejects empty text or a stopped driver.
+     */
+    appendDeveloperMessage(text: string): Promise<string>;
+    /**
+     * Creates the Rust-owned Codex browser voice controller for this agent.
+     *
+     * # Errors
+     *
+     * Rejects voices outside Codex's ChatGPT V3 catalog.
+     */
+    browserVoice(voice: string): BrowserVoice;
+    /**
+     * Closes one canonical task-tree child and its descendants.
+     */
+    closeSubagent(task: string): Promise<string>;
+    /**
+     * Compacts retained history immediately without fabricating a user prompt.
+     *
+     * # Errors
+     *
+     * Throws when compaction or the agent driver fails.
+     */
+    compact(): Promise<void>;
+    /**
+     * Compacts retained history and returns the private replacement mapping.
+     *
+     * The serialized result includes the generated summary, the replaced
+     * pre-compaction range, retained tail identities, and the complete
+     * post-compaction session context for custom host compaction. It is
+     * `null` when provider-default compaction is active.
+     */
+    compactOutcome(): Promise<string>;
+    /**
+     * Returns complete read-only session context at the latest safe boundary.
+     *
+     * # Errors
+     *
+     * Rejects after the driver stops or when context serialization fails.
+     */
+    context(): Promise<string>;
+    /**
+     * Builds an agent from its JavaScript JSON configuration.
+     *
+     * # Errors
+     *
+     * Throws when the JSON or agent policy is invalid.
+     */
+    static create(config_json: string): Promise<Nanocodex>;
+    /**
+     * Builds an agent whose ChatGPT credential lifecycle is owned by Rust.
+     */
+    static createWithChatGpt(config_json: string, subscription: ChatGptSubscription): Promise<Nanocodex>;
+    /**
+     * Ends the canonical Codex Realtime adapter lifecycle.
+     *
+     * # Errors
+     *
+     * Rejects when the agent driver has stopped or context serialization fails.
+     */
+    endRealtimeConversation(): Promise<string>;
+    /**
+     * Forks the latest safe committed model boundary.
+     *
+     * # Errors
+     *
+     * Rejects before the first safe boundary or after the driver stops.
+     */
+    fork(): Promise<Nanocodex>;
+    /**
+     * Forks from an exact completed historical turn.
+     *
+     * # Errors
+     *
+     * Rejects if the result belongs to another agent or the driver stopped.
+     */
+    forkFrom(result: TurnResult): Promise<Nanocodex>;
+    /**
+     * Interrupts one canonical task-tree child while keeping it reusable.
+     */
+    interruptSubagent(task: string): Promise<string>;
+    /**
+     * Lists the canonical task-tree directory visible to the owning root.
+     */
+    listSubagents(task: string): Promise<string>;
+    /**
+     * Accepts a text prompt and returns its independently awaitable turn.
+     *
+     * # Errors
+     *
+     * Throws when the prompt is empty.
+     */
+    prompt(instruction: string, operation_id?: string | null, cancel_on_admission?: boolean | null, supplementary_context?: string | null): Turn;
+    /**
+     * Accepts browser-safe multimodal input encoded as JSON.
+     *
+     * # Errors
+     *
+     * Throws for malformed, empty, or local-filesystem input.
+     */
+    promptContent(content_json: string, operation_id?: string | null, cancel_on_admission?: boolean | null, supplementary_context?: string | null): Turn;
+    /**
+     * Formats one structured Realtime delegation using canonical Codex markers.
+     *
+     * # Errors
+     *
+     * Rejects malformed transcript JSON.
+     */
+    realtimeDelegation(input: string, transcript: string): string;
+    /**
+     * Formats an unconsumed Realtime transcript tail using canonical Codex markers.
+     *
+     * # Errors
+     *
+     * Rejects malformed transcript JSON.
+     */
+    realtimeTailDelegation(transcript: string): string | undefined;
+    /**
+     * Restores persisted logical children after the JavaScript owner acquires
+     * its durability generation and activates the replacement host.
+     *
+     * # Errors
+     *
+     * Rejects malformed descriptors, disabled subagents, duplicate restoration,
+     * or an invalid persisted topology.
+     */
+    restoreSubagents(descriptors_json: string, host_contexts_json?: string | null): Promise<void>;
+    /**
+     * Atomically steers the active turn or starts a new independently awaitable turn.
+     *
+     * Returns `undefined` when the input was steered into an active turn.
+     *
+     * # Errors
+     *
+     * Rejects empty input, a full steering queue, or a stopped driver.
+     */
+    routePrompt(instruction: string): Promise<Turn | undefined>;
+    /**
+     * Sends one canonical directed task-tree message from the owning root.
+     */
+    sendSubagentMessage(task: string): Promise<string>;
+    /**
+     * Enables or disables the optional JavaScript event crossing for this handle.
+     */
+    setEventForwarding(enabled: boolean): void;
+    /**
+     * Enables or disables priority processing for subsequently accepted turns.
+     *
+     * # Errors
+     *
+     * Rejects after the driver stops.
+     */
+    setFastMode(enabled: boolean): Promise<void>;
+    /**
+     * Changes the model before the first turn is accepted.
+     *
+     * # Errors
+     *
+     * Rejects an invalid model, an incompatible thinking level, conversation
+     * activity, or a stopped driver.
+     */
+    setModel(model: string): Promise<void>;
+    /**
+     * Changes the reasoning effort for subsequently accepted turns.
+     *
+     * # Errors
+     *
+     * Rejects an invalid effort or a stopped driver.
+     */
+    setThinking(thinking: string): Promise<void>;
+    /**
+     * Gracefully stops the driver and joins every resource owned by this agent.
+     *
+     * # Errors
+     *
+     * Rejects when the driver had already stopped or cleanup fails.
+     */
+    shutdown(): Promise<void>;
+    /**
+     * Serializes the latest committed, resumable session snapshot.
+     *
+     * This is the engine-owned checkpoint at the latest completed safe
+     * boundary. After manual compaction, it therefore captures the exact
+     * post-install history that can be supplied to a fresh Agent instance.
+     *
+     * # Errors
+     *
+     * Rejects before the first committed boundary, after the driver stops,
+     * or when serialization fails.
+     */
+    snapshot(): Promise<string>;
+    /**
+     * Starts a clean sibling with the same private agent policy.
+     *
+     * # Errors
+     *
+     * Rejects after the driver stops.
+     */
+    spawn(): Promise<Nanocodex>;
+    /**
+     * Starts one canonical Rust task-tree child and returns its descriptor.
+     */
+    spawnSubagent(task: string): Promise<string>;
+    /**
+     * Starts an ordered batch of canonical subagents in the same task tree.
+     *
+     * # Errors
+     *
+     * Rejects malformed tasks, agents without subagent tools, a stopped
+     * parent, or a batch that cannot be reserved in full.
+     */
+    spawnSubagents(tasks_json: string): Promise<string>;
+    /**
+     * Starts the canonical Codex Realtime adapter lifecycle.
+     *
+     * # Errors
+     *
+     * Rejects when the agent driver has stopped or context serialization fails.
+     */
+    startRealtimeConversation(): Promise<string>;
+    /**
+     * Waits for any selected canonical task-tree child to become terminal.
+     */
+    waitSubagents(task: string): Promise<string>;
+    /**
+     * Returns the stable Agent identity.
+     */
+    readonly agentId: string;
+    /**
+     * Returns the stable UUID session identity (`UUIDv7` by default).
+     */
+    readonly sessionId: string;
+}
+
+/**
+ * JavaScript binding over one shared Rust turn.
+ */
+export class Turn {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Waits until the Rust driver has durably admitted this turn.
+     *
+     * Returns the durable request identity selected during admission, or
+     * `undefined` when the agent has no execution policy.
+     *
+     * # Errors
+     *
+     * Rejects with a stable `code` describing an admission failure.
+     */
+    accepted(): Promise<string | undefined>;
+    /**
+     * Cancels this exact active or queued turn.
+     *
+     * # Errors
+     *
+     * Rejects if the turn is already terminal or its driver stopped.
+     */
+    cancel(): Promise<void>;
+    /**
+     * Waits for the final assistant message.
+     *
+     * # Errors
+     *
+     * Rejects with a stable `code` when the model run or driver fails.
+     */
+    result(): Promise<TurnResult>;
+    /**
+     * Injects text input at the active turn's next safe model boundary.
+     *
+     * # Errors
+     *
+     * Rejects if the turn is not active or its driver stopped.
+     */
+    steer(instruction: string): Promise<void>;
+    /**
+     * Injects browser-safe multimodal input at the active turn's next boundary.
+     *
+     * # Errors
+     *
+     * Rejects malformed input or a turn that is no longer active.
+     */
+    steerContent(content_json: string): Promise<void>;
+}
+
+/**
+ * JavaScript binding over one completed Rust turn result.
+ */
+export class TurnResult {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Serializes this completed boundary's resumable session snapshot.
+     *
+     * # Errors
+     *
+     * Throws when serialization fails.
+     */
+    snapshot(): string;
+    /**
+     * Serializes exact aggregate usage for this completed logical turn.
+     *
+     * # Errors
+     *
+     * Throws when serialization fails.
+     */
+    usage(): string;
+    /**
+     * Returns the final assistant message.
+     */
+    readonly finalMessage: string;
+}
+
+/**
+ * Applies a browser-workspace patch through the canonical Rust planner.
+ *
+ * The browser host uses this internal binding for nested Code Mode calls so
+ * they share the direct `apply_patch` tool's verification and mutation path.
+ */
+export function applyBrowserPatch(patch: string, session_id: string): Promise<string>;
+
+/**
+ * Returns the shared bounded first-prompt retrieval plan for a managed host.
+ */
+export function managedBootstrapPlan(input: string): string;
+
+/**
+ * Prunes old replay receipts before the full Agent runtime is constructed.
+ */
+export function pruneDurableReceipts(durability_host_id: string, durability_id: string, terminal_receipt_limit: number): Promise<void>;