@demicodes/agent 0.10.3 → 0.12.0

package/dist/stdio-transport.d.mts

@@ -1,6 +1,5 @@
-import { n as AgentServerTransport, t as AgentClientTransport } from "./transport-Bhf0h9FY.mjs";
+import { n as AgentServerTransport, t as AgentClientTransport } from "./transport-Diegnou1.mjs";
 import { Readable, Writable } from "node:stream";
-
 //#region src/stdio-transport.d.ts
 declare function createStdioClientTransport(readable: Readable, writable: Writable): AgentClientTransport;
 declare function createStdioServerTransport(readable: Readable, writable: Writable): AgentServerTransport;

package/dist/{transport-Bhf0h9FY.d.mts → transport-Diegnou1.d.mts}

@@ -1,7 +1,7 @@
-import { BashAuditEvent, Command, Host, ShellCommandSnapshot } from "@demicodes/shell";
+import { PortableJsonValue } from "@demicodes/utils";
+import { BashAuditEvent, Command, Host, ShellCommandStatus } from "@demicodes/shell";
 import { AgentProvider, InferenceItem, ProviderEvent, ProviderSelection, ToolDefinition } from "@demicodes/provider";
-import { Block, ModelSelection, QueuedMessage, SessionPhase, ToolResultContentBlock, Transcript, UserContentBlock } from "@demicodes/core";
-
+import { Block, ModelSelection, ProviderErrorDiagnostics, QueuedMessage, SessionPhase, ToolResultContentBlock, Transcript, UserContentBlock } from "@demicodes/core";
 //#region src/retry-policy.d.ts
 /**
  * Retry policy for provider requests, applied by the agent runtime (turn loop
@@ -49,7 +49,7 @@ interface DrainedTranscriptPatches {
   revision: number;
   patches: TranscriptPatch[];
 }
-declare class Transcript$1 implements Transcript {
+declare class TranscriptLog implements Transcript {
   readonly blocks: Block[];
   private readonly idFactory;
   private readonly now;
@@ -58,7 +58,7 @@ declare class Transcript$1 implements Transcript {
   private readonly replayHeadChars;
   private readonly replayTailChars;
   constructor(blocks?: Block[], options?: TranscriptOptions);
-  snapshot(): Transcript;
+  toJSON(): Transcript;
   /** Monotonic revision, advanced once per drained patch batch. */
   get revision(): number;
   /**
@@ -83,8 +83,13 @@ declare class Transcript$1 implements Transcript {
   rewindToLastUserTurn(): Extract<Block, {
     type: 'user';
   }> | null;
+  /**
+   * Drops the blocks from `index` onward, returning true when anything went.
+   * Used to unwind a turn to its resume point before re-inferring.
+   */
+  truncateFrom(index: number): boolean;
   applyProviderEvent(model: ModelSelection, event: ProviderEvent): Block | null;
-  completeToolCall(toolUseId: string, output: ToolResultContentBlock[], isError?: boolean, metadata?: unknown | null): Block | null;
+  completeToolCall(toolUseId: string, output: ToolResultContentBlock[], isError?: boolean, view?: unknown | null): Block | null;
   findPendingToolUseId(): string | null;
   pendingToolCalls(): Extract<Block, {
     type: 'tool_call';
@@ -107,8 +112,13 @@ declare class Transcript$1 implements Transcript {
    * history), it anchors the estimate and only blocks streamed after it are
    * char-estimated; otherwise the whole replay window is estimated at ~4
    * chars/token with fixed weights for images and documents.
+   *
+   * When `contextWindow` is given, an anchor larger than the window is
+   * discarded: a single request's usage physically cannot exceed the window,
+   * so such a value is a provider violation of the response-usage contract
+   * (e.g. a turn-cumulative total) and would poison the estimate.
    */
-  estimateContextTokens(): number;
+  estimateContextTokens(contextWindow?: number): number;
   /**
    * The latest response block's usage, valid only when no compaction happened
    * after it (compaction shrinks the history the usage was measured against).
@@ -123,16 +133,19 @@ declare class Transcript$1 implements Transcript {
 declare function estimateTranscriptBlockTokens(block: Block): number;
 //#endregion
 //#region src/types.d.ts
+/** Caller-defined data carried with one agent action. Demi transports it without interpreting it. */
+type AgentMetadata = Readonly<Record<string, PortableJsonValue>>;
 interface AgentPromptContext<State> {
   agentSessionId: string;
   state: State;
   cwd: string;
-  transcript: Transcript$1;
+  transcript: TranscriptLog;
+  metadata: AgentMetadata | null;
 }
 interface AgentSystemPromptContext<State> extends AgentPromptContext<State> {
   /**
    * Rendered help for every registered command (summary, subcommands, parameters,
-   * stdin fields, examples), produced by the server from the session's actual
+   * stdin fields), produced by the server from the session's actual
    * CommandRegistry. Harnesses embed it wherever their system prompt wants the
    * command reference; empty string when no commands are registered.
    */
@@ -142,28 +155,36 @@ interface AgentToolContext<State> {
   agentSessionId: string;
   state: State;
   cwd: string;
+  metadata: AgentMetadata | null;
 }
 interface AgentDisposeContext<State> {
   agentSessionId: string;
   state: State;
   cwd: string;
-  transcript: Transcript$1;
+  transcript: TranscriptLog;
 }
 interface AgentReferenceResolveContext<State> {
   agentSessionId: string;
   state: State;
   cwd: string;
-  transcript: Transcript$1;
+  transcript: TranscriptLog;
   signal: AbortSignal;
+  metadata: AgentMetadata | null;
 }
 interface AgentHarnessContext<State> {
   state: State;
   cwd: string;
 }
+/** Context used when a shell operation resolves its action-specific Host. */
+interface AgentHostContext<State> extends AgentHarnessContext<State> {
+  agentSessionId: string;
+  metadata: AgentMetadata | null;
+}
 interface AgentHarness<State = unknown> {
   name: string;
   initialState(): State;
-  host(ctx: AgentHarnessContext<State>): Host;
+  /** Return the same Host object for calls that target the same execution environment. */
+  host(ctx: AgentHarnessContext<State> | AgentHostContext<State>): Host | Promise<Host>;
   commands?(ctx: AgentHarnessContext<State>): Command[];
   systemPrompt(ctx: AgentSystemPromptContext<State>): string;
   preamble?(ctx: AgentPromptContext<State>): string | null;
@@ -178,21 +199,16 @@ interface AgentToolInvokeContext<State> {
   model: ModelSelection;
   toolCallId: string;
   signal: AbortSignal;
+  metadata: AgentMetadata | null;
   emitProgress(progress: unknown): void;
 }
 interface AgentToolInvokeResult {
   output: ToolResultContentBlock[];
   isError?: boolean;
-  metadata?: unknown | null;
-  continuation?: ToolContinuation;
+  /** Bounded UI-facing view data stored on the tool_call block; see the core Block contract. */
+  view?: unknown | null;
   stopAfterToolResult?: boolean;
 }
-interface ToolContinuation {
-  toolCallId: string;
-  shellId: string;
-  commandId: string;
-  status: 'running';
-}
 type AbortTarget = 'active_provider_stream' | 'active_tool' | 'active_compaction' | 'active_turn' | 'queued_action' | 'queued_message' | 'pending_yield_wakeup';
 interface AbortResult {
   aborted: boolean;
@@ -206,22 +222,25 @@ type AgentLifecycleEvent<State> = {
   type: 'before_round_start';
   agentSessionId: string;
   state: State;
-  transcript: Transcript$1;
+  transcript: TranscriptLog;
   content: UserContentBlock[];
+  metadata: AgentMetadata | null;
 } | {
   type: 'after_tool_call';
   agentSessionId: string;
   state: State;
-  transcript: Transcript$1;
+  transcript: TranscriptLog;
   toolCallId: string;
   toolName: string;
   result: AgentToolInvokeResult;
+  metadata: AgentMetadata | null;
 } | {
   type: 'after_transcript_rewrite';
   agentSessionId: string;
   state: State;
-  transcript: Transcript$1;
+  transcript: TranscriptLog;
   reason: 'retry';
+  metadata: AgentMetadata | null;
 };
 interface AgentHarnessRuntime<State> {
   harnessName: string;
@@ -238,10 +257,31 @@ interface AgentSessionParams<State> {
   model: ModelSelection;
   cwd: string;
   runtime: AgentHarnessRuntime<State>;
-  transcript?: Transcript | Transcript$1;
+  transcript?: Transcript | TranscriptLog;
+  state?: State;
+}
+/**
+ * Overrides for `AgentSession.clone()`.
+ *
+ * Omitted fields keep the clone defaults: an independent `provider.clone()`,
+ * structured copies of model/transcript/state, and the same cwd/runtime.
+ */
+interface AgentSessionCloneParams<State = unknown> {
+  transcript?: Transcript;
+  /** Use this runtime instead of `this.provider.clone()`. */
+  provider?: AgentProvider;
+  model?: ModelSelection;
+  cwd?: string;
+  runtime?: AgentHarnessRuntime<State>;
+  /**
+   * Replace state. When omitted, state is `structuredClone`d for isolation.
+   * When provided, ownership transfers by reference (same as the constructor).
+   */
   state?: State;
+  /** Options for the clone. Parent store is never inherited. */
+  options?: AgentSessionOptions<State>;
 }
-interface AgentSessionSnapshot<State> {
+interface AgentSessionCheckpoint<State> {
   transcript: Transcript;
   state: State;
   phase: SessionPhase;
@@ -251,14 +291,14 @@ interface AgentSessionSnapshot<State> {
   harnessName: string;
 }
 interface AgentSessionStore<State = unknown> {
-  saveSnapshot(snapshot: AgentSessionSnapshot<State>): Promise<void> | void;
-  /** Load a previously saved snapshot for this session, or null if none exists. */
-  loadSnapshot(): Promise<AgentSessionSnapshot<State> | null>;
+  saveCheckpoint(checkpoint: AgentSessionCheckpoint<State>): Promise<void> | void;
+  /** Load a previously saved checkpoint for this session, or null if none exists. */
+  loadCheckpoint(): Promise<AgentSessionCheckpoint<State> | null>;
 }
 interface AgentSessionRestoreParams<State> {
   provider: AgentProvider;
   runtime: AgentHarnessRuntime<State>;
-  snapshot: AgentSessionSnapshot<State>;
+  checkpoint: AgentSessionCheckpoint<State>;
 }
 interface AgentSessionOptions<State = unknown> {
   agentSessionId?: string;
@@ -270,7 +310,7 @@ interface AgentSessionOptions<State = unknown> {
     preflightThresholdRatio?: number;
   };
   /**
-   * Maximum interval between snapshot writes while a turn is streaming. Writes
+   * Maximum interval between checkpoint writes while a turn is streaming. Writes
    * always flush at action boundaries (turn end, abort, dispose); this only
    * bounds staleness during streaming. Default 1000ms.
    */
@@ -298,6 +338,7 @@ type SessionEvent = {
   attempt: number;
   delayMs: number;
   code: string | null;
+  diagnostics?: ProviderErrorDiagnostics;
 } | {
   type: 'error';
   error: Error;
@@ -324,6 +365,7 @@ type ClientFrame = {
   type: 'send';
   messageId: string;
   content: UserContentBlock[];
+  metadata?: AgentMetadata;
 } | {
   type: 'dequeue_message';
   messageId: string;
@@ -350,14 +392,18 @@ type ClientFrame = {
   type: 'abort';
 } | {
   type: 'retry';
+  metadata?: AgentMetadata;
 } | {
   type: 'resume';
+  metadata?: AgentMetadata;
 } | {
   type: 'compact';
+  metadata?: AgentMetadata;
 } | {
   type: 'shell_write';
   commandId: string;
   stdin: string;
+  metadata?: AgentMetadata;
 } | {
   type: 'list_conversations';
   cwd: string;
@@ -373,7 +419,7 @@ type ServerFrame = {
   command: string;
   reason: string;
 } | {
-  type: 'transcript_snapshot';
+  type: 'transcript_reset';
   blocks: Block[];
   revision: number;
 } | {
@@ -406,7 +452,7 @@ type ServerFrame = {
   type: 'shell_output';
   shellId: string;
   commandId: string;
-  snapshot: ShellCommandSnapshotLike;
+  status: ShellCommandStatusLike;
 } | {
   type: 'shell_write_result';
   commandId: string;
@@ -422,15 +468,17 @@ type ServerFrame = {
   attempt: number;
   delayMs: number;
   code: string | null;
+  diagnostics?: ProviderErrorDiagnostics;
 } | {
   type: 'error';
   message: string;
   code?: string;
+  diagnostics?: ProviderErrorDiagnostics;
 } | {
   type: 'closed';
 };
 /**
- * Wire patches for transcript replication. Produced directly by the Transcript's
+ * Wire patches for transcript replication. Produced directly by the TranscriptLog's
  * mutation journal (never diff-derived). `append_text` carries streaming deltas
  * for the `text` field of the block at the index (text/thinking blocks), keeping
  * per-delta cost O(delta) instead of O(block) or O(transcript).
@@ -455,9 +503,9 @@ type TranscriptPatch = {
   path: ['blocks'];
   value: Block[];
 };
-type ShellCommandSnapshotLike = ShellCommandSnapshot;
+type ShellCommandStatusLike = ShellCommandStatus;
 type ClientSessionEvent = {
-  type: 'transcript_snapshot';
+  type: 'transcript_reset';
   blocks: Block[];
 } | {
   type: 'transcript_patch';
@@ -489,7 +537,7 @@ type ClientSessionEvent = {
   type: 'shell_output';
   shellId: string;
   commandId: string;
-  snapshot: ShellCommandSnapshotLike;
+  status: ShellCommandStatusLike;
 } | {
   type: 'shell_write_result';
   commandId: string;
@@ -502,6 +550,7 @@ type ClientSessionEvent = {
   attempt: number;
   delayMs: number;
   code: string | null;
+  diagnostics?: ProviderErrorDiagnostics;
 } | {
   type: 'rejected';
   command: string;
@@ -510,6 +559,7 @@ type ClientSessionEvent = {
   type: 'error';
   message: string;
   code?: string;
+  diagnostics?: ProviderErrorDiagnostics;
 } | {
   type: 'opened';
 } | {
@@ -530,4 +580,4 @@ interface InProcessTransportPair {
 }
 declare function createInProcessTransportPair(): InProcessTransportPair;
 //#endregion
-export { AgentToolInvokeResult as A, DEFAULT_TURN_RETRY_POLICY as B, AgentSessionRestoreParams as C, AgentTool as D, AgentSystemPromptContext as E, CompactionWindow as F, isRetryableCode as H, DrainedTranscriptPatches as I, Transcript$1 as L, SessionEvent as M, SessionEventListener as N, AgentToolContext as O, ToolContinuation as P, TranscriptOptions as R, AgentSessionParams as S, AgentSessionStore as T, resolveRetryPolicy as U, TurnRetryPolicy as V, retryDelayMs as W, AgentHarnessRuntime as _, createInProcessTransportPair as a, AgentReferenceResolveContext as b, ConversationSummary as c, TranscriptPatch as d, AbortResult as f, AgentHarnessContext as g, AgentHarness as h, InProcessTransportPair as i, ExternalMutationReservation as j, AgentToolInvokeContext as k, ServerFrame as l, AgentDisposeContext as m, AgentServerTransport as n, ClientFrame as o, AbortTarget as p, AgentTransport as r, ClientSessionEvent as s, AgentClientTransport as t, ShellCommandSnapshotLike as u, AgentLifecycleEvent as v, AgentSessionSnapshot as w, AgentSessionOptions as x, AgentPromptContext as y, estimateTranscriptBlockTokens as z };
+export { AgentTool as A, TranscriptOptions as B, AgentSessionCheckpoint as C, AgentSessionRestoreParams as D, AgentSessionParams as E, SessionEvent as F, resolveRetryPolicy as G, DEFAULT_TURN_RETRY_POLICY as H, SessionEventListener as I, retryDelayMs as K, CompactionWindow as L, AgentToolInvokeContext as M, AgentToolInvokeResult as N, AgentSessionStore as O, ExternalMutationReservation as P, DrainedTranscriptPatches as R, AgentReferenceResolveContext as S, AgentSessionOptions as T, TurnRetryPolicy as U, estimateTranscriptBlockTokens as V, isRetryableCode as W, AgentHarnessRuntime as _, createInProcessTransportPair as a, AgentMetadata as b, ConversationSummary as c, TranscriptPatch as d, AbortResult as f, AgentHarnessContext as g, AgentHarness as h, InProcessTransportPair as i, AgentToolContext as j, AgentSystemPromptContext as k, ServerFrame as l, AgentDisposeContext as m, AgentServerTransport as n, ClientFrame as o, AbortTarget as p, AgentTransport as r, ClientSessionEvent as s, AgentClientTransport as t, ShellCommandStatusLike as u, AgentHostContext as v, AgentSessionCloneParams as w, AgentPromptContext as x, AgentLifecycleEvent as y, TranscriptLog as z };

package/dist/{websocket-transport-Bod0puog.mjs → websocket-transport-BjSj3U0I.mjs}

@@ -1,4 +1,21 @@
 import { parsePortableJson, stringifyPortableJson } from "@demicodes/utils";
+//#region src/provider-stream-error.ts
+/** Error carrying a provider stream's normalized code and bounded diagnostics. */
+var ProviderStreamError = class extends Error {
+	code;
+	diagnostics;
+	constructor(message, code, diagnostics) {
+		super(message);
+		this.name = "ProviderStreamError";
+		this.code = code;
+		this.diagnostics = diagnostics;
+	}
+};
+/** Whether an error is a provider stream error reporting the context window was exceeded. */
+function isContextLengthExceeded(error) {
+	return error instanceof ProviderStreamError && error.code === "context_length_exceeded";
+}
+//#endregion
 //#region src/patch.ts
 /**
 * Applies journal-produced transcript patches to a block list, returning a new
@@ -73,18 +90,19 @@ var AgentClient = class {
 			});
 		});
 	}
-	sendMessage(content) {
+	sendMessage(content, options = {}) {
 		const messageId = globalThis.crypto.randomUUID();
 		const wait = this.waitForAction("send", messageId);
 		this.sendFrame({
 			type: "send",
 			messageId,
-			content
+			content,
+			metadata: options.metadata
 		});
 		return wait;
 	}
-	send(content) {
-		return this.sendMessage(content);
+	send(content, options = {}) {
+		return this.sendMessage(content, options);
 	}
 	dequeueMessage(messageId) {
 		this.sendFrame({
@@ -147,19 +165,39 @@ var AgentClient = class {
 			provider
 		});
 	}
-	retry() {
+	/**
+	* Discards the whole latest turn and runs it again from the user's input —
+	* "regenerate". NOT a recovery path: it drops text the turn already emitted and
+	* tool calls it already ran while their effects remain. Use `resume` to finish a
+	* turn that failed.
+	*/
+	retry(options = {}) {
 		const wait = this.waitForAction("retry");
-		this.sendFrame({ type: "retry" });
+		this.sendFrame({
+			type: "retry",
+			metadata: options.metadata
+		});
 		return wait;
 	}
-	resume() {
+	/**
+	* Finishes a turn that did not finish, after an abort or a terminal provider
+	* error. Unwinds only as far as is safe and re-infers from there; the caller
+	* does not choose the granularity.
+	*/
+	resume(options = {}) {
 		const wait = this.waitForAction("resume");
-		this.sendFrame({ type: "resume" });
+		this.sendFrame({
+			type: "resume",
+			metadata: options.metadata
+		});
 		return wait;
 	}
-	compact() {
+	compact(options = {}) {
 		const wait = this.waitForAction("compact");
-		this.sendFrame({ type: "compact" });
+		this.sendFrame({
+			type: "compact",
+			metadata: options.metadata
+		});
 		return wait;
 	}
 	abort() {
@@ -167,12 +205,13 @@ var AgentClient = class {
 		this.sendFrame({ type: "abort" });
 		return wait;
 	}
-	shellWrite(commandId, stdin) {
+	shellWrite(commandId, stdin, options = {}) {
 		const wait = this.waitForShellWrite(commandId);
 		this.sendFrame({
 			type: "shell_write",
 			commandId,
-			stdin
+			stdin,
+			metadata: options.metadata
 		});
 		return wait;
 	}
@@ -198,12 +237,12 @@ var AgentClient = class {
 	}
 	handleServerFrame(frame) {
 		switch (frame.type) {
-			case "transcript_snapshot":
+			case "transcript_reset":
 				this.blocks = [...frame.blocks];
 				this.revision = frame.revision;
 				this.awaitingResync = false;
 				this.emit({
-					type: "transcript_snapshot",
+					type: "transcript_reset",
 					blocks: this.blocks
 				});
 				return;
@@ -273,9 +312,12 @@ var AgentClient = class {
 				return;
 			case "error":
 				this.emit(frame);
-				this.rejectErroredAction(new Error(frame.message));
-				this.rejectAllSteerWaiters(new Error(frame.message));
-				this.rejectAllAbortWaiters(new Error(frame.message));
+				{
+					const error = frame.code ? new ProviderStreamError(frame.message, frame.code, frame.diagnostics) : new Error(frame.message);
+					this.rejectErroredAction(error);
+					this.rejectAllSteerWaiters(error);
+					this.rejectAllAbortWaiters(error);
+				}
 				return;
 		}
 	}
@@ -447,7 +489,8 @@ var WebSocketJsonTransport = class {
 	socket;
 	handlers = /* @__PURE__ */ new Set();
 	onMessage = (event) => {
-		const frame = parsePortableJson(typeof event.data === "string" ? event.data : String(event.data));
+		const text = typeof event.data === "string" ? event.data : String(event.data);
+		const frame = parsePortableJson(text);
 		for (const handler of this.handlers) handler(frame);
 	};
 	constructor(socket) {
@@ -470,4 +513,4 @@ var WebSocketJsonTransport = class {
 	}
 };
 //#endregion
-export { cloneBlocks as a, applyTranscriptPatches as i, createWebSocketServerTransport as n, AgentClient as r, createWebSocketClientTransport as t };
+export { cloneBlocks as a, applyTranscriptPatches as i, createWebSocketServerTransport as n, ProviderStreamError as o, AgentClient as r, isContextLengthExceeded as s, createWebSocketClientTransport as t };

package/dist/{websocket-transport-D_Awo7zN.d.mts → websocket-transport-c4hu2c0X.d.mts}

@@ -1,9 +1,11 @@
-import { c as ConversationSummary, f as AbortResult, n as AgentServerTransport, s as ClientSessionEvent, t as AgentClientTransport } from "./transport-Bhf0h9FY.mjs";
+import { b as AgentMetadata, c as ConversationSummary, f as AbortResult, n as AgentServerTransport, s as ClientSessionEvent, t as AgentClientTransport } from "./transport-Diegnou1.mjs";
 import { ProviderSelection } from "@demicodes/provider";
 import { Block, UserContentBlock } from "@demicodes/core";
-
 //#region src/client.d.ts
 type AgentClientListener = (event: ClientSessionEvent) => void;
+interface AgentActionOptions {
+  metadata?: AgentMetadata;
+}
 declare class AgentClient {
   private readonly transport;
   private readonly listeners;
@@ -20,8 +22,8 @@ declare class AgentClient {
   constructor(transport: AgentClientTransport);
   open(provider: ProviderSelection, cwd: string, sessionId: string): Promise<void>;
   listConversations(cwd: string): Promise<ConversationSummary[]>;
-  sendMessage(content: UserContentBlock[]): Promise<void>;
-  send(content: UserContentBlock[]): Promise<void>;
+  sendMessage(content: UserContentBlock[], options?: AgentActionOptions): Promise<void>;
+  send(content: UserContentBlock[], options?: AgentActionOptions): Promise<void>;
   dequeueMessage(messageId: string): void;
   sendQueuedMessage(messageId: string): void;
   steerQueuedMessage(messageId: string, options?: {
@@ -37,11 +39,22 @@ declare class AgentClient {
    * turn (the server applies it at a turn boundary), so this is fire-and-forget.
    */
   setProvider(provider: ProviderSelection): void;
-  retry(): Promise<void>;
-  resume(): Promise<void>;
-  compact(): Promise<void>;
+  /**
+   * Discards the whole latest turn and runs it again from the user's input —
+   * "regenerate". NOT a recovery path: it drops text the turn already emitted and
+   * tool calls it already ran while their effects remain. Use `resume` to finish a
+   * turn that failed.
+   */
+  retry(options?: AgentActionOptions): Promise<void>;
+  /**
+   * Finishes a turn that did not finish, after an abort or a terminal provider
+   * error. Unwinds only as far as is safe and re-infers from there; the caller
+   * does not choose the granularity.
+   */
+  resume(options?: AgentActionOptions): Promise<void>;
+  compact(options?: AgentActionOptions): Promise<void>;
   abort(): Promise<AbortResult>;
-  shellWrite(commandId: string, stdin: string): Promise<void>;
+  shellWrite(commandId: string, stdin: string, options?: AgentActionOptions): Promise<void>;
   close(): Promise<void>;
   subscribe(listener: AgentClientListener): () => void;
   transcript(): {
@@ -85,4 +98,4 @@ interface JsonWebSocket {
 declare function createWebSocketClientTransport(socket: JsonWebSocket): AgentClientTransport;
 declare function createWebSocketServerTransport(socket: JsonWebSocket): AgentServerTransport;
 //#endregion
-export { AgentClientListener as a, AgentClient as i, createWebSocketClientTransport as n, createWebSocketServerTransport as r, JsonWebSocket as t };
+export { AgentClient as a, AgentActionOptions as i, createWebSocketClientTransport as n, AgentClientListener as o, createWebSocketServerTransport as r, JsonWebSocket as t };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@demicodes/agent",
   "description": "Session runtime and transport-neutral client and server protocol for Demi.",
-  "version": "0.10.3",
+  "version": "0.12.0",
   "private": false,
   "type": "module",
   "exports": {
@@ -19,10 +19,10 @@
     }
   },
   "dependencies": {
-    "@demicodes/core": "^0.10.3",
-    "@demicodes/provider": "^0.10.3",
-    "@demicodes/shell": "^0.10.3",
-    "@demicodes/utils": "^0.10.3"
+    "@demicodes/core": "^0.12.0",
+    "@demicodes/provider": "^0.12.0",
+    "@demicodes/shell": "^0.12.0",
+    "@demicodes/utils": "^0.12.0"
   },
   "license": "Apache-2.0",
   "main": "./dist/index.mjs",