nanocodex 0.2.0 → 0.3.0

package/pkg-node/nanocodex.d.ts

@@ -2,13 +2,21 @@
 /* eslint-disable */
 
 /**
- * Persistent WASM agent handle hosted by Node.js or a browser Worker.
+ * JavaScript binding over the shared Rust agent lifecycle.
  */
 export class Nanocodex {
     free(): void;
     [Symbol.dispose](): void;
     /**
-     * Fork the latest safe committed model boundary.
+     * Compacts retained history immediately without fabricating a user prompt.
+     *
+     * # Errors
+     *
+     * Throws when compaction or the agent driver fails.
+     */
+    compact(): Promise<void>;
+    /**
+     * Forks the latest safe committed model boundary.
      *
      * # Errors
      *
@@ -16,57 +24,63 @@ export class Nanocodex {
      */
     fork(): Promise<Nanocodex>;
     /**
-     * Fork from the exact checkpoint retained by a completed historical turn.
+     * Forks from an exact completed historical turn.
      *
      * # Errors
      *
-     * Rejects if the turn is incomplete, belongs to another lineage, or the
-     * driver stops.
+     * Rejects if the result belongs to another agent or the driver stopped.
      */
-    forkFrom(turn: Turn): Promise<Nanocodex>;
+    forkFrom(result: TurnResult): Promise<Nanocodex>;
     /**
-     * Build a persistent agent from a JSON configuration object.
+     * Builds an agent from its JavaScript JSON configuration.
      *
      * # Errors
      *
-     * Throws when the JSON or required configuration is invalid.
+     * Throws when the JSON or agent policy is invalid.
      */
     constructor(config_json: string);
     /**
-     * Accept a prompt immediately and return its independently awaitable turn.
+     * Accepts a text prompt and returns its independently awaitable turn.
      *
      * # Errors
      *
-     * Throws when the prompt is empty or the agent driver has stopped.
+     * Throws when the prompt is empty.
      */
     prompt(instruction: string): Turn;
     /**
-     * Accept ordered browser-safe text, image, or audio input encoded as JSON.
+     * Accepts browser-safe multimodal input encoded as JSON.
      *
      * # Errors
      *
-     * Throws for malformed or empty content, local filesystem inputs, or a
-     * stopped driver.
+     * Throws for malformed, empty, or local-filesystem input.
      */
     promptContent(content_json: string): Turn;
     /**
-     * Enable or disable priority processing for subsequently accepted turns.
+     * Enables or disables priority processing for subsequently accepted turns.
      *
      * # Errors
      *
-     * Rejects after the agent driver stops.
+     * Rejects after the driver stops.
      */
     setFastMode(enabled: boolean): Promise<void>;
     /**
-     * Change the reasoning effort for subsequently accepted turns.
+     * Changes the reasoning effort for subsequently accepted turns.
      *
      * # Errors
      *
-     * Rejects an unsupported effort or a stopped agent driver.
+     * Rejects an invalid effort or a stopped driver.
      */
     setThinking(thinking: string): Promise<void>;
     /**
-     * Start a clean sibling with the same configuration and tools.
+     * 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>;
+    /**
+     * Starts a clean sibling with the same private agent policy.
      *
      * # Errors
      *
@@ -74,60 +88,77 @@ export class Nanocodex {
      */
     spawn(): Promise<Nanocodex>;
     /**
-     * Stable session identifier used to route this agent's event stream.
+     * Returns the stable `UUIDv7` session identity.
      */
     readonly sessionId: string;
 }
 
 /**
- * Completion and control handle for one accepted WASM turn.
+ * JavaScript binding over one shared Rust turn.
  */
 export class Turn {
     private constructor();
     free(): void;
     [Symbol.dispose](): void;
     /**
-     * Cancel this exact active or queued turn.
+     * Cancels this exact active or queued turn.
      *
      * # Errors
      *
-     * Rejects if the turn is already terminal or the driver stops.
+     * Rejects if the turn is already terminal or its driver stopped.
      */
     cancel(): Promise<void>;
     /**
-     * Wait for the turn and return its final assistant message.
+     * Waits for the final assistant message.
      *
      * # Errors
      *
-     * Rejects when the model run fails, the driver stops, or two consumers
-     * await the same pending turn concurrently.
+     * Rejects when the model run or driver fails.
      */
-    result(): Promise<string>;
+    result(): Promise<TurnResult>;
     /**
-     * Serialize this completed turn's resumable session snapshot.
+     * Injects text input at the active turn's next safe model boundary.
      *
      * # Errors
      *
-     * Throws until the turn has completed or if serialization fails.
+     * Rejects if the turn is not active or its driver stopped.
      */
-    snapshot(): string;
+    steer(instruction: string): Promise<void>;
     /**
-     * Inject input at this active turn's next safe model boundary.
+     * Injects browser-safe multimodal input at the active turn's next boundary.
      *
      * # Errors
      *
-     * Rejects for empty input, a queued or terminal turn, a full steer queue,
-     * or a stopped driver.
+     * Rejects malformed input or a turn that is no longer active.
      */
-    steer(instruction: string): Promise<void>;
+    steerContent(content_json: string): Promise<void>;
+}
+
+/**
+ * JavaScript binding over one completed Rust turn result.
+ */
+export class TurnResult {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
     /**
-     * Inject ordered browser-safe text, image, or audio input at this active
-     * turn's next safe model boundary.
+     * Serializes this completed boundary's resumable session snapshot.
      *
      * # Errors
      *
-     * Rejects for malformed or empty content, local filesystem inputs, a
-     * queued or terminal turn, a full steer queue, or a stopped driver.
+     * Throws when serialization fails.
      */
-    steerContent(content_json: string): Promise<void>;
+    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;
 }