@zvada/agent-server 0.2.1 → 0.3.0

package/src/server/acp/translate.ts

@@ -7,30 +7,41 @@ import type { LifecycleEvent, McpServerConfig, PartInput, ToolPart } from "../..
  * (the vocabularies were aligned for this: ToolKind, tool status, and
  * permission shapes pass through unchanged).
  *
- * Deliberate v1 gaps: sub-agent parts (`parentToolUseId`) have no ACP slot
- * and are dropped (the parent tool's result carries the outcome);
- * `session.compacted` has no v1 equivalent; `usage_update` requires `size`,
- * so gauges without a window size are skipped.
+ * Deliberate v1 gaps: sub-agent parts (`parentToolCallId`) have no ACP slot
+ * and are dropped (the parent tool's result carries the outcome); the
+ * `session.compaction` entity has no v1 equivalent; `usage_update` requires
+ * `size`, so gauges without a window size are skipped. The user echo is
+ * skipped too — the ACP client authored the prompt and re-chunking it back
+ * would duplicate it.
  */
 export class AcpUpdateTranslator {
 	/** toolCallIds already announced via `tool_call`. */
 	private readonly openedTools = new Set<string>();
 	/** Text/reasoning characters already emitted per part (dedupe snapshots vs deltas). */
 	private readonly sentByPart = new Map<string, number>();
+	/** Message ids of the user echo (role "user") — skipped entirely. */
+	private readonly userMessageIds = new Set<string>();
+	/** Part ids that belong to a sub-agent (parented) — their deltas are skipped. */
+	private readonly parentedParts = new Set<string>();
 
 	translate(event: LifecycleEvent): SessionUpdate[] {
 		switch (event.type) {
+			case "message.started": {
+				if (event.role === "user") this.userMessageIds.add(event.messageId);
+				return [];
+			}
 			case "message.part.delta": {
-				if (event.parentToolUseId) return [];
+				if (this.parentedParts.has(event.partId)) return [];
+				if (this.userMessageIds.has(event.messageId)) return [];
 				const { delta } = event;
-				if (delta.type === "tool-input-delta") return []; // covered by part snapshots
+				if (delta.type === "tool_input") return []; // covered by part snapshots
 				this.sentByPart.set(
 					event.partId,
 					(this.sentByPart.get(event.partId) ?? 0) + delta.text.length,
 				);
 				return [
 					chunk(
-						delta.type === "text-delta" ? "agent_message_chunk" : "agent_thought_chunk",
+						delta.type === "text" ? "agent_message_chunk" : "agent_thought_chunk",
 						delta.text,
 						event.messageId,
 					),
@@ -38,8 +49,14 @@ export class AcpUpdateTranslator {
 			}
 			case "message.part": {
 				const part = event.part;
-				if (part.parentToolUseId) return [];
+				if (part.parentToolCallId) {
+					this.parentedParts.add(part.id);
+					return [];
+				}
+				if (this.userMessageIds.has(event.messageId)) return [];
 				if (part.type === "tool") return this.toolUpdate(part);
+				// Image/file parts have no v1 chunk slot (agent-side); dropped.
+				if (part.type !== "text" && part.type !== "reasoning") return [];
 				// While a part is still streaming, its snapshots mirror the deltas
 				// (adapters mutate in place, so an early snapshot can already carry
 				// delta text — emitting both doubles it). Only the final `done`
@@ -75,9 +92,29 @@ export class AcpUpdateTranslator {
 	}
 
 	private toolUpdate(part: ToolPart): SessionUpdate[] {
-		// Statuses and ToolKind are the SDK's own vocabulary (DESIGN D2) — no
-		// re-narrowing, no casts.
-		const status = part.state.status;
+		// Statuses and ToolKind are the SDK's own vocabulary (DESIGN D2), with
+		// two edge maps: `cancelled` (ACP v2 / schema 1.6+) predates our pinned
+		// SDK's ToolCallStatus and maps to `failed`; our open kind narrows via a
+		// membership check — `task` and extensions fall back to `other`.
+		const status = (part.state.status === "cancelled" ? "failed" : part.state.status) as Exclude<
+			typeof part.state.status,
+			"cancelled"
+		>;
+		const acpKinds = new Set([
+			"read",
+			"edit",
+			"delete",
+			"move",
+			"search",
+			"execute",
+			"think",
+			"fetch",
+			"switch_mode",
+			"other",
+		]);
+		const kind = part.kind
+			? ((acpKinds.has(part.kind) ? part.kind : "other") as "other")
+			: undefined;
 		if (!this.openedTools.has(part.toolCallId)) {
 			this.openedTools.add(part.toolCallId);
 			return [
@@ -86,10 +123,10 @@ export class AcpUpdateTranslator {
 					toolCallId: part.toolCallId,
 					title: part.title ?? part.toolName,
 					name: part.toolName,
-					...(part.kind && { kind: part.kind }),
+					...(kind && { kind }),
 					status,
 					...(part.locations?.length && { locations: part.locations }),
-					...(status !== "pending" && { rawInput: part.state.input }),
+					...("input" in part.state && { rawInput: part.state.input }),
 				},
 			];
 		}
@@ -126,7 +163,7 @@ export function fromPromptBlocks(prompt: ContentBlock[]): string | PartInput[] {
 	for (const block of prompt) {
 		if (block.type === "text" && block.text) parts.push({ type: "text", text: block.text });
 		else if (block.type === "image" && block.data) {
-			parts.push({ type: "image", data: block.data, mediaType: block.mimeType });
+			parts.push({ type: "image", data: block.data, mimeType: block.mimeType });
 		}
 	}
 	if (parts.length === 1 && parts[0]?.type === "text") return parts[0].text;

package/src/server/agent-server.ts

@@ -1,4 +1,4 @@
-import { type AgentRuntime, callbackSink } from "../core/index.ts";
+import { type AgentRuntime, TurnConflictError, callbackSink } from "../core/index.ts";
 import {
 	type AgentCapabilities,
 	type AgentHarness,
@@ -10,6 +10,7 @@ import {
 	type RunRequest,
 	SessionCloseParamsSchema,
 	TurnCancelParamsSchema,
+	type TurnCancelResult,
 	TurnStartParamsSchema,
 	WIRE_ERROR_CODES,
 	WIRE_METHODS,
@@ -17,6 +18,7 @@ import {
 	type WireEventEnvelope,
 	type WireImplementationInfo,
 	type WireTransport,
+	classifyError,
 	decodeWireMessage,
 	encodeErrorResponse,
 	encodeNotification,
@@ -57,6 +59,15 @@ export class AgentServer {
 	 * unbounded only across a server lifetime with unbounded distinct ids, the
 	 * same order of growth already accepted for `sessions`. */
 	private readonly retiredSeqs = new Map<string, number>();
+	private readonly observers = new Set<(envelope: WireEventEnvelope) => void>();
+	/**
+	 * One id per server PROCESS, handed out in `initialize`. Within a process,
+	 * session logs never restart (`retiredSeqs` keeps seq monotonic across
+	 * close/reopen of an id), so a client that sees this id change across a
+	 * reconnect knows — as a stated fact, not an inference — that every log it
+	 * tracked belongs to a dead process.
+	 */
+	private readonly instanceId = generateUUIDv7();
 	private shuttingDown = false;
 
 	constructor(
@@ -76,6 +87,25 @@ export class AgentServer {
 		return detach;
 	}
 
+	/**
+	 * Observe every broadcast envelope in-process; returns an unsubscribe.
+	 *
+	 * The same sequenced envelopes the transports receive, already appended to
+	 * the session log — a host that embeds the server (to keep its own session
+	 * bookkeeping, mirror events into a DB, trigger follow-up work) gets them
+	 * as decoded objects instead of attaching a fake transport and parsing its
+	 * own wire back out of NDJSON.
+	 *
+	 * Synchronous and isolated: an observer that throws is swallowed, exactly
+	 * like a faulty transport or a failing sink — an event is a fact that
+	 * already happened, and a consumer's bug must not unwind the broadcast for
+	 * everyone else. Do the slow part yourself (queue it, don't block here).
+	 */
+	onEvent(observer: (envelope: WireEventEnvelope) => void): () => void {
+		this.observers.add(observer);
+		return () => this.observers.delete(observer);
+	}
+
 	/** Cancel all turns, terminate harnesses, and close every transport. */
 	async shutdown(): Promise<void> {
 		if (this.shuttingDown) return;
@@ -131,6 +161,7 @@ export class AgentServer {
 				const result: InitializeResult = {
 					protocolVersion: WIRE_PROTOCOL_VERSION,
 					server: this.options.info ?? { name: "agent-server" },
+					instanceId: this.instanceId,
 					harnesses,
 				};
 				return transport.send(encodeResponse(id, result));
@@ -176,6 +207,23 @@ export class AgentServer {
 						),
 					);
 				}
+				// Idempotent admission, delegated to the runtime: a retried start
+				// (same turnId, identical input) converges — ack again, never run
+				// twice; `events/replay` serves anything the retryer missed. The
+				// same turnId with different input is a caller bug → turnConflict.
+				const request = { sessionId, turnId, input, config };
+				try {
+					if (this.runtime.admission(request).status !== "new") {
+						return transport.send(encodeResponse(id, { sessionId, turnId, deduplicated: true }));
+					}
+				} catch (err) {
+					if (err instanceof TurnConflictError) {
+						return transport.send(
+							encodeErrorResponse(id, WIRE_ERROR_CODES.turnConflict, err.message, { turnId }),
+						);
+					}
+					throw err;
+				}
 				if (this.activeTurns.has(sessionId)) {
 					return transport.send(
 						encodeErrorResponse(
@@ -207,9 +255,37 @@ export class AgentServer {
 				const parsed = TurnCancelParamsSchema.safeParse(params);
 				if (!parsed.success) return this.invalidParams(transport, id, parsed.error);
 				const active = this.activeTurns.get(parsed.data.sessionId);
-				if (!active) return transport.send(encodeResponse(id, { cancelled: false }));
-				await this.runtime.cancel(active.harness, parsed.data.sessionId);
-				return transport.send(encodeResponse(id, { cancelled: true }));
+				if (!active) {
+					return transport.send(
+						encodeResponse(id, { outcome: "no_active_turn" } satisfies TurnCancelResult),
+					);
+				}
+				if (parsed.data.turnId && parsed.data.turnId !== active.turnId) {
+					// Turn-stamped cancel for a turn that is no longer the active one —
+					// refuse to kill its successor; report who IS active instead.
+					return transport.send(
+						encodeResponse(id, {
+							outcome: "no_active_turn",
+							activeTurnId: active.turnId,
+						} satisfies TurnCancelResult),
+					);
+				}
+				const { confirmed, hadTurn } = await this.runtime.cancel(
+					active.harness,
+					parsed.data.sessionId,
+				);
+				// An unacknowledged interrupt is NOT a cancel: the agent may still be
+				// running and `turn.ended` stays the source of truth. `hadTurn: false`
+				// while the server tracks an active turn is the pre-first-yield window
+				// (between the turn/start quick-ack and the harness registering its
+				// abortable turn) — the abort landed on nothing and the turn may run
+				// to completion, so it must report `unconfirmed`, never a clean cancel.
+				return transport.send(
+					encodeResponse(id, {
+						outcome: confirmed && hadTurn ? "cancelled" : "unconfirmed",
+						turnId: active.turnId,
+					} satisfies TurnCancelResult),
+				);
 			}
 
 			case WIRE_METHODS.sessionClose: {
@@ -241,6 +317,21 @@ export class AgentServer {
 				this.closingSessions.add(sessionId);
 				try {
 					await this.runtime.closeSession(log.harness, sessionId);
+					// The terminal fact for CONNECTED subscribers (spec §6.1): they
+					// learn the session is over from the stream, not from the RPC
+					// result (which only the closer sees). It is deliberately NOT
+					// replayable — the log is retired on the next line, so a
+					// subscriber that was detached gets `unknownSession` from
+					// `events/replay`, and that answer IS its terminal signal (the
+					// session is gone; nothing more will ever be appended).
+					this.broadcast(
+						log.append({
+							type: "session.ended",
+							sessionId,
+							reason: "released",
+							timestamp: Date.now(),
+						}),
+					);
 					if (log.latestSeq !== null) this.retiredSeqs.set(sessionId, log.latestSeq);
 					if (this.sessions.get(sessionId) === log) this.sessions.delete(sessionId);
 					return transport.send(encodeResponse(id, { closed: true }));
@@ -323,7 +414,7 @@ export class AgentServer {
 					sessionId: request.sessionId,
 					turnId: request.turnId,
 					stopReason: "error",
-					error: { name: err instanceof Error ? err.name : "Error", message },
+					error: { category: classifyError(err), message },
 					timestamp: Date.now(),
 				}),
 			);
@@ -333,13 +424,25 @@ export class AgentServer {
 	}
 
 	private broadcast(envelope: WireEventEnvelope): void {
+		// In-process observers first: they see the same envelope, in the same
+		// order, whether or not any transport is attached.
+		for (const observer of [...this.observers]) {
+			try {
+				observer(envelope);
+			} catch {
+				// An observer's failure is its own; the event is already logged.
+			}
+		}
 		const line = encodeNotification(WIRE_METHODS.event, envelope);
 		for (const transport of this.transports) {
 			try {
 				transport.send(line);
 			} catch {
 				// One faulty transport must not starve the others; the event is
-				// already in the session log, so the client heals via replay.
+				// already in the session log, so the client heals via replay. The
+				// one exception is `session.ended` from `session/close`, whose log
+				// is retired in the same breath — a client that missed it learns the
+				// session is over from `unknownSession` on replay instead.
 			}
 		}
 	}