@demicodes/agent 0.1.0

package/dist/websocket-transport-D6zJ4PLC.d.mts

@@ -0,0 +1,88 @@
+import { c as ConversationSummary, f as AbortResult, n as AgentServerTransport, s as ClientSessionEvent, t as AgentClientTransport } from "./transport-BkAbPvRc.mjs";
+import { ProviderSelection } from "@demicodes/provider";
+import { Block, UserContentBlock } from "@demicodes/core";
+
+//#region src/client.d.ts
+type AgentClientListener = (event: ClientSessionEvent) => void;
+declare class AgentClient {
+  private readonly transport;
+  private readonly listeners;
+  private readonly pendingActionWaiters;
+  private readonly pendingSteerWaiters;
+  private readonly pendingAbortWaiters;
+  private readonly pendingConversationWaiters;
+  private readonly queuedMessageIds;
+  private blocks;
+  private revision;
+  private awaitingResync;
+  private phase;
+  private unsubscribeTransport;
+  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>;
+  dequeueMessage(messageId: string): void;
+  sendQueuedMessage(messageId: string): void;
+  steerQueuedMessage(messageId: string, options?: {
+    steerId?: string;
+  }): Promise<void>;
+  clearMessageQueue(messageIds?: string[]): void;
+  steer(content: UserContentBlock[], options?: {
+    steerId?: string;
+  }): Promise<void>;
+  cancelPendingSteer(steerId: string): void;
+  /**
+   * Switches the provider/model for an open session. The change takes effect on the next
+   * 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>;
+  abort(): Promise<AbortResult>;
+  shellWrite(commandId: string, stdin: string): Promise<void>;
+  close(): Promise<void>;
+  subscribe(listener: AgentClientListener): () => void;
+  transcript(): {
+    blocks: Block[];
+  };
+  private sendFrame;
+  private handleServerFrame;
+  private waitForFrame;
+  private waitForAction;
+  private waitForSteer;
+  private handleSteerResult;
+  private handleActionPhase;
+  private markNextActionActive;
+  private resolveActiveAction;
+  private resolveQueuedSendWaiter;
+  private moveQueuedSendWaiterToFront;
+  private rejectPendingAction;
+  private rejectErroredAction;
+  private resolveAllActionWaiters;
+  private rejectAllActionWaiters;
+  private rejectAllSteerWaiters;
+  private settleActionWaiter;
+  private waitForAbort;
+  private waitForShellWrite;
+  private emit;
+  private resolveAbortWaiter;
+  private rejectAllAbortWaiters;
+}
+//#endregion
+//#region src/websocket-transport.d.ts
+interface JsonWebSocket {
+  send(data: string): void;
+  close(): void;
+  addEventListener(type: 'message', listener: (event: {
+    data: unknown;
+  }) => void): void;
+  removeEventListener(type: 'message', listener: (event: {
+    data: unknown;
+  }) => void): void;
+}
+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 };

package/dist/websocket-transport-o6r-jV5p.mjs

@@ -0,0 +1,473 @@
+import { n as stringifyAgentJson, t as parseAgentJson } from "./json-codec-BFLXlg3K.mjs";
+//#region src/patch.ts
+/**
+* Applies journal-produced transcript patches to a block list, returning a new
+* array. Touched blocks are replaced (never mutated in place), so callers can
+* safely share block objects between snapshots.
+*/
+function applyTranscriptPatches(blocks, patches) {
+	let next = [...blocks];
+	for (const patch of patches) switch (patch.op) {
+		case "replace":
+			next = [...patch.value];
+			break;
+		case "replace_block":
+			next[patch.path[1]] = patch.value;
+			break;
+		case "add":
+			next.splice(patch.path[1], 0, patch.value);
+			break;
+		case "remove":
+			next.splice(patch.path[1], 1);
+			break;
+		case "append_text": {
+			const index = patch.path[1];
+			const block = next[index];
+			if (block && (block.type === "text" || block.type === "thinking")) next[index] = {
+				...block,
+				text: block.text + patch.delta
+			};
+			break;
+		}
+	}
+	return next;
+}
+function cloneBlocks(blocks) {
+	return structuredClone(blocks);
+}
+//#endregion
+//#region src/client.ts
+var AgentClient = class {
+	transport;
+	listeners = /* @__PURE__ */ new Set();
+	pendingActionWaiters = [];
+	pendingSteerWaiters = /* @__PURE__ */ new Map();
+	pendingAbortWaiters = [];
+	pendingConversationWaiters = [];
+	queuedMessageIds = /* @__PURE__ */ new Set();
+	blocks = [];
+	revision = null;
+	awaitingResync = false;
+	phase = null;
+	unsubscribeTransport;
+	constructor(transport) {
+		this.transport = transport;
+		this.unsubscribeTransport = transport.onFrame((frame) => this.handleServerFrame(frame));
+	}
+	open(provider, cwd, sessionId) {
+		const wait = this.waitForFrame("opened");
+		this.sendFrame({
+			type: "open",
+			provider,
+			cwd,
+			sessionId
+		});
+		return wait;
+	}
+	listConversations(cwd) {
+		return new Promise((resolve) => {
+			this.pendingConversationWaiters.push(resolve);
+			this.sendFrame({
+				type: "list_conversations",
+				cwd
+			});
+		});
+	}
+	sendMessage(content) {
+		const messageId = globalThis.crypto.randomUUID();
+		const wait = this.waitForAction("send", messageId);
+		this.sendFrame({
+			type: "send",
+			messageId,
+			content
+		});
+		return wait;
+	}
+	send(content) {
+		return this.sendMessage(content);
+	}
+	dequeueMessage(messageId) {
+		this.sendFrame({
+			type: "dequeue_message",
+			messageId
+		});
+		this.resolveQueuedSendWaiter(messageId);
+		this.queuedMessageIds.delete(messageId);
+	}
+	sendQueuedMessage(messageId) {
+		this.moveQueuedSendWaiterToFront(messageId);
+		this.sendFrame({
+			type: "send_queued_message",
+			messageId
+		});
+	}
+	steerQueuedMessage(messageId, options = {}) {
+		const steerId = options.steerId ?? globalThis.crypto.randomUUID();
+		const wait = this.waitForSteer(steerId);
+		this.sendFrame({
+			type: "steer_queued_message",
+			messageId,
+			steerId
+		});
+		return wait.then(() => {
+			this.resolveQueuedSendWaiter(messageId);
+			this.queuedMessageIds.delete(messageId);
+		});
+	}
+	clearMessageQueue(messageIds = [...this.queuedMessageIds]) {
+		this.sendFrame({ type: "clear_message_queue" });
+		for (const messageId of messageIds) {
+			this.resolveQueuedSendWaiter(messageId);
+			this.queuedMessageIds.delete(messageId);
+		}
+	}
+	steer(content, options = {}) {
+		const steerId = options.steerId ?? globalThis.crypto.randomUUID();
+		const wait = this.waitForSteer(steerId);
+		this.sendFrame({
+			type: "steer",
+			steerId,
+			content
+		});
+		return wait;
+	}
+	cancelPendingSteer(steerId) {
+		this.sendFrame({
+			type: "cancel_pending_steer",
+			steerId
+		});
+	}
+	/**
+	* Switches the provider/model for an open session. The change takes effect on the next
+	* turn (the server applies it at a turn boundary), so this is fire-and-forget.
+	*/
+	setProvider(provider) {
+		this.sendFrame({
+			type: "set_provider",
+			provider
+		});
+	}
+	retry() {
+		const wait = this.waitForAction("retry");
+		this.sendFrame({ type: "retry" });
+		return wait;
+	}
+	resume() {
+		const wait = this.waitForAction("resume");
+		this.sendFrame({ type: "resume" });
+		return wait;
+	}
+	compact() {
+		const wait = this.waitForAction("compact");
+		this.sendFrame({ type: "compact" });
+		return wait;
+	}
+	abort() {
+		const wait = this.waitForAbort();
+		this.sendFrame({ type: "abort" });
+		return wait;
+	}
+	shellWrite(commandId, stdin) {
+		const wait = this.waitForShellWrite(commandId);
+		this.sendFrame({
+			type: "shell_write",
+			commandId,
+			stdin
+		});
+		return wait;
+	}
+	close() {
+		const wait = this.waitForFrame("closed");
+		this.sendFrame({ type: "close" });
+		return wait.finally(() => {
+			this.unsubscribeTransport();
+			this.transport.close();
+		});
+	}
+	subscribe(listener) {
+		this.listeners.add(listener);
+		return () => {
+			this.listeners.delete(listener);
+		};
+	}
+	transcript() {
+		return { blocks: [...this.blocks] };
+	}
+	sendFrame(frame) {
+		this.transport.send(frame);
+	}
+	handleServerFrame(frame) {
+		switch (frame.type) {
+			case "transcript_snapshot":
+				this.blocks = [...frame.blocks];
+				this.revision = frame.revision;
+				this.awaitingResync = false;
+				this.emit({
+					type: "transcript_snapshot",
+					blocks: this.blocks
+				});
+				return;
+			case "transcript_patch":
+				if (this.awaitingResync) return;
+				if (this.revision !== null && frame.revision !== this.revision + 1) {
+					this.awaitingResync = true;
+					this.sendFrame({ type: "sync_transcript" });
+					return;
+				}
+				this.revision = frame.revision;
+				this.blocks = applyTranscriptPatches(this.blocks, frame.patches);
+				this.emit({
+					type: "transcript_patch",
+					patches: frame.patches,
+					blocks: this.blocks
+				});
+				return;
+			case "closed":
+				this.blocks = [];
+				this.revision = null;
+				this.awaitingResync = false;
+				this.phase = null;
+				this.queuedMessageIds.clear();
+				this.emit(frame);
+				this.resolveAllActionWaiters();
+				this.rejectAllSteerWaiters(/* @__PURE__ */ new Error("Session closed"));
+				this.rejectAllAbortWaiters(/* @__PURE__ */ new Error("Session closed"));
+				return;
+			case "opened":
+				this.emit(frame);
+				return;
+			case "phase": {
+				const previousPhase = this.phase;
+				this.phase = frame.phase;
+				this.emit(frame);
+				this.handleActionPhase(previousPhase, frame.phase);
+				return;
+			}
+			case "queue":
+				this.queuedMessageIds.clear();
+				for (const message of frame.queue) this.queuedMessageIds.add(message.id);
+				this.emit(frame);
+				return;
+			case "steer_result":
+				this.emit(frame);
+				this.handleSteerResult(frame);
+				return;
+			case "abort_result":
+				this.emit(frame);
+				this.resolveAbortWaiter(frame.result);
+				return;
+			case "tool_progress":
+			case "shell_output":
+			case "shell_write_result":
+			case "audit":
+			case "retry_scheduled":
+				this.emit(frame);
+				return;
+			case "conversations":
+				this.pendingConversationWaiters.shift()?.(frame.conversations);
+				return;
+			case "rejected":
+				this.emit(frame);
+				this.rejectPendingAction(frame.command, new Error(frame.reason));
+				if (frame.command === "abort") this.rejectAllAbortWaiters(new Error(frame.reason));
+				return;
+			case "error":
+				this.emit(frame);
+				this.rejectErroredAction(new Error(frame.message));
+				this.rejectAllSteerWaiters(new Error(frame.message));
+				this.rejectAllAbortWaiters(new Error(frame.message));
+				return;
+		}
+	}
+	waitForFrame(type) {
+		return new Promise((resolve, reject) => {
+			const unsubscribe = this.subscribe((event) => {
+				if (event.type === type) {
+					unsubscribe();
+					resolve();
+				} else if (event.type === "error") {
+					unsubscribe();
+					reject(new Error(event.message));
+				} else if (event.type === "rejected") {
+					unsubscribe();
+					reject(new Error(event.reason));
+				}
+			});
+		});
+	}
+	waitForAction(command, messageId) {
+		return new Promise((resolve, reject) => {
+			this.pendingActionWaiters.push({
+				command,
+				messageId,
+				sawActivePhase: false,
+				resolve,
+				reject
+			});
+		});
+	}
+	waitForSteer(steerId) {
+		return new Promise((resolve, reject) => {
+			this.pendingSteerWaiters.set(steerId, {
+				resolve,
+				reject
+			});
+		});
+	}
+	handleSteerResult(frame) {
+		const waiter = this.pendingSteerWaiters.get(frame.steerId);
+		if (!waiter) return;
+		this.pendingSteerWaiters.delete(frame.steerId);
+		if (frame.status === "accepted") waiter.resolve();
+		else waiter.reject(new Error(frame.reason));
+	}
+	handleActionPhase(previousPhase, phase) {
+		if (phase !== "idle") {
+			if (previousPhase === "idle" || previousPhase === null) this.markNextActionActive();
+			return;
+		}
+		this.resolveActiveAction();
+	}
+	markNextActionActive() {
+		const waiter = this.pendingActionWaiters.find((candidate) => !candidate.sawActivePhase);
+		if (waiter) waiter.sawActivePhase = true;
+	}
+	resolveActiveAction() {
+		const waiter = this.pendingActionWaiters.find((candidate) => candidate.sawActivePhase);
+		if (!waiter) return;
+		this.settleActionWaiter(waiter, () => waiter.resolve());
+	}
+	resolveQueuedSendWaiter(messageId) {
+		const waiter = this.pendingActionWaiters.find((candidate) => candidate.command === "send" && candidate.messageId === messageId && !candidate.sawActivePhase);
+		if (!waiter) return;
+		this.settleActionWaiter(waiter, () => waiter.resolve());
+	}
+	moveQueuedSendWaiterToFront(messageId) {
+		const waiter = this.pendingActionWaiters.find((candidate) => candidate.command === "send" && candidate.messageId === messageId && !candidate.sawActivePhase);
+		if (!waiter) return;
+		const currentIndex = this.pendingActionWaiters.indexOf(waiter);
+		if (currentIndex === -1) return;
+		this.pendingActionWaiters.splice(currentIndex, 1);
+		const insertionIndex = this.pendingActionWaiters.findIndex((candidate) => candidate.command === "send" && !candidate.sawActivePhase);
+		if (insertionIndex === -1) this.pendingActionWaiters.push(waiter);
+		else this.pendingActionWaiters.splice(insertionIndex, 0, waiter);
+	}
+	rejectPendingAction(command, error) {
+		const waiter = this.pendingActionWaiters.find((candidate) => candidate.command === command && !candidate.sawActivePhase) ?? this.pendingActionWaiters.find((candidate) => candidate.command === command);
+		if (!waiter) return;
+		this.settleActionWaiter(waiter, () => waiter.reject(error));
+	}
+	rejectErroredAction(error) {
+		const waiter = this.pendingActionWaiters.find((candidate) => candidate.sawActivePhase);
+		if (waiter) {
+			this.settleActionWaiter(waiter, () => waiter.reject(error));
+			return;
+		}
+		this.rejectAllActionWaiters(error);
+	}
+	resolveAllActionWaiters() {
+		const waiters = this.pendingActionWaiters.splice(0);
+		for (const waiter of waiters) waiter.resolve();
+	}
+	rejectAllActionWaiters(error) {
+		const waiters = this.pendingActionWaiters.splice(0);
+		for (const waiter of waiters) waiter.reject(error);
+	}
+	rejectAllSteerWaiters(error) {
+		const waiters = [...this.pendingSteerWaiters.values()];
+		this.pendingSteerWaiters.clear();
+		for (const waiter of waiters) waiter.reject(error);
+	}
+	settleActionWaiter(waiter, settle) {
+		const index = this.pendingActionWaiters.indexOf(waiter);
+		if (index === -1) return;
+		this.pendingActionWaiters.splice(index, 1);
+		settle();
+	}
+	waitForAbort() {
+		return new Promise((resolve, reject) => {
+			this.pendingAbortWaiters.push({
+				resolve,
+				reject
+			});
+		});
+	}
+	waitForShellWrite(commandId) {
+		return new Promise((resolve, reject) => {
+			const unsubscribe = this.subscribe((event) => {
+				if (event.type === "shell_output" && event.commandId === commandId) {
+					unsubscribe();
+					resolve();
+					return;
+				}
+				if (event.type === "shell_write_result" && event.commandId === commandId) {
+					unsubscribe();
+					resolve();
+					return;
+				}
+				if (event.type === "error") {
+					unsubscribe();
+					reject(new Error(event.message));
+					return;
+				}
+				if (event.type === "rejected" && event.command === "shell_write") {
+					unsubscribe();
+					reject(new Error(event.reason));
+					return;
+				}
+				if (event.type === "closed") {
+					unsubscribe();
+					resolve();
+				}
+			});
+		});
+	}
+	emit(event) {
+		for (const listener of this.listeners) listener(event);
+	}
+	resolveAbortWaiter(result) {
+		const waiter = this.pendingAbortWaiters.shift();
+		if (!waiter) return;
+		waiter.resolve(result);
+	}
+	rejectAllAbortWaiters(error) {
+		const waiters = this.pendingAbortWaiters.splice(0);
+		for (const waiter of waiters) waiter.reject(error);
+	}
+};
+//#endregion
+//#region src/websocket-transport.ts
+function createWebSocketClientTransport(socket) {
+	return new WebSocketJsonTransport(socket);
+}
+function createWebSocketServerTransport(socket) {
+	return new WebSocketJsonTransport(socket);
+}
+var WebSocketJsonTransport = class {
+	socket;
+	handlers = /* @__PURE__ */ new Set();
+	onMessage = (event) => {
+		const frame = parseAgentJson(typeof event.data === "string" ? event.data : String(event.data));
+		for (const handler of this.handlers) handler(frame);
+	};
+	constructor(socket) {
+		this.socket = socket;
+		this.socket.addEventListener("message", this.onMessage);
+	}
+	send(frame) {
+		this.socket.send(stringifyAgentJson(frame));
+	}
+	onFrame(handler) {
+		this.handlers.add(handler);
+		return () => {
+			this.handlers.delete(handler);
+		};
+	}
+	close() {
+		this.handlers.clear();
+		this.socket.removeEventListener("message", this.onMessage);
+		this.socket.close();
+	}
+};
+//#endregion
+export { cloneBlocks as a, applyTranscriptPatches as i, createWebSocketServerTransport as n, AgentClient as r, createWebSocketClientTransport as t };

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@demicodes/agent",
+  "description": "Session runtime and transport-neutral client and server protocol for Demi.",
+  "version": "0.1.0",
+  "private": false,
+  "type": "module",
+  "exports": {
+    ".": {
+      "development": "./src/index.ts",
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs"
+    },
+    "./client": {
+      "development": "./src/client-entry.ts",
+      "types": "./dist/client-entry.d.mts",
+      "import": "./dist/client-entry.mjs"
+    },
+    "./stdio": {
+      "development": "./src/stdio-transport.ts",
+      "types": "./dist/stdio-transport.d.mts",
+      "import": "./dist/stdio-transport.mjs"
+    }
+  },
+  "dependencies": {
+    "@demicodes/core": "workspace:*",
+    "@demicodes/provider": "workspace:*",
+    "@demicodes/shell": "workspace:*",
+    "@demicodes/utils": "workspace:*"
+  },
+  "license": "Apache-2.0",
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsdown"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/wspl/demi.git",
+    "directory": "packages/agent"
+  },
+  "homepage": "https://github.com/wspl/demi/tree/main/packages/agent#readme",
+  "bugs": "https://github.com/wspl/demi/issues",
+  "devDependencies": {
+    "zod": "^4.0.0"
+  }
+}