@wrongstack/acp 0.260.0 → 0.265.1

package/dist/agent.d.ts

@@ -1,100 +1,72 @@
-import { u as ACPToolList, v as ACPToolResult, w as AgentServerTransport, g as ACPMessage } from './stdio-transport-DoKRVjHz.js';
-export { S as StdioTransport } from './stdio-transport-DoKRVjHz.js';
-import { Tool } from '@wrongstack/core';
+export { A as AgentServerTransport, S as StdioTransport } from './stdio-transport-CsFr8JzC.js';
+export { A as ACPToolsRegistry } from './tools-registry-BCf8evEG.js';
+import { R as RunTurn } from './wrongstack-acp-agent-Dv-A0bEm.js';
+export { A as ACPProtocolHandler, W as WrongStackACPServer, a as WrongStackACPServerOptions } from './wrongstack-acp-agent-Dv-A0bEm.js';
+import { Agent } from '@wrongstack/core';
 import 'node:events';
 
 /**
- * Tools registry for ACP agent-side.
+ * ACPServerAgentTurn — `RunTurn` adapter for the v1 server side.
  *
- * Translates WrongStack Tool definitions → ACP ACPToolDefinition format.
- * Provides tool lookup and result assembly for the ACP protocol handler.
+ * Wires the ACP v1 server (`ACPProtocolHandler`) to a core `Agent`.
+ * Each session gets its own `Agent` instance (per spec: sessions are
+ * isolated; sharing agents across sessions would defeat isolation).
+ * The agent is created lazily on the first `session/prompt` and
+ * torn down when the server is closed or the session is removed.
+ *
+ * The adapter:
+ *  - converts the ACP `ContentBlock[]` prompt into a single string
+ *    (concatenating text blocks; non-text blocks are recorded as a
+ *    note in the prompt — future work can route images / audio to
+ *    the appropriate provider)
+ *  - calls `agent.run(prompt, {signal})` to drive the core loop
+ *  - captures the agent's text result and emits it as one or more
+ *    `agent_message_chunk` notifications
+ *  - maps the agent's stop semantics to a v1 `StopReason`
+ *
+ * Streaming: the core `Agent` API is not currently token-streamed
+ * through this surface (its `run()` returns a final `RunResult`).
+ * v1 clients expect text deltas, but most implementations batch
+ * them — a single chunk per turn is acceptable. A future
+ * enhancement can use the Agent's `Renderer` interface to capture
+ * deltas as they're written, then forward them as multiple chunks.
+ *
+ * Scope: the adapter is deliberately minimal. It does NOT:
+ *  - model the full conversation history across turns (the v1 spec
+ *    leaves this to the agent; on the next prompt we re-feed the
+ *    latest user message and the agent handles its own history)
+ *  - use the agent's tool registry, permission policy, or
+ *    extensions (this adapter is the lowest-fidelity integration;
+ *    a future PR can wire a richer session-aware agent)
+ *  - stream deltas token-by-token (see "Streaming" above)
+ *
+ * Cancellation: the parent `AbortSignal` propagates through
+ * `agent.run({signal})` and the underlying provider call observes
+ * it. On abort, the adapter maps the resulting `AbortError` to
+ * `{stopReason: 'cancelled'}`.
  */
 
-declare class ACPToolsRegistry {
-    private tools;
-    private readonly owner;
-    constructor(owner?: string);
-    /**
-     * Register one or more tools.
-     * Throws on duplicate name unless force=true.
-     */
-    register(tools: Tool[]): void;
+interface ACPServerAgentTurnOptions {
     /**
-     * Replace the current tool set.
+     * Factory that creates a fresh `Agent` for a given session.
+     * Called once per session on the first `session/prompt` turn.
+     * The factory must isolate each agent — sharing one agent
+     * across sessions would defeat v1's session-isolation model.
      */
-    setTools(tools: Tool[]): void;
-    get(name: string): Tool | undefined;
-    has(name: string): boolean;
-    list(): Tool[];
-    /** Build the ACP tools/list payload from registered tools. */
-    buildToolList(): ACPToolList;
+    agentFor: (sessionId: string, cwd: string) => Promise<Agent> | Agent;
     /**
-     * Execute a tool by name and return ACP-formatted result.
-     * Returns null if the tool is not found.
+     * Hard wall-clock cap for one turn. The agent's own provider
+     * timeout is layered under this; this cap is a safety belt.
+     * Default 5 minutes.
      */
-    execute(name: string, args: Record<string, unknown>, ctx: unknown, signal: AbortSignal): Promise<ACPToolResult | null>;
-}
-
-declare class ACPProtocolHandler {
-    private readonly transport;
-    private readonly registry;
-    private readonly context;
-    private initialized;
-    private readonly signal;
-    private pendingCalls;
-    constructor(transport: AgentServerTransport, registry: ACPToolsRegistry, context: unknown);
-    /** Wire an external abort signal from the ACP client */
-    wireAbortController(abortController: AbortController): void;
-    /** Process one inbound message. Returns true if this was a terminal message. */
-    handleMessage(msg: ACPMessage): Promise<boolean>;
-    private handleRequest;
-    private handleNotification;
-    private handleInitialize;
-    private handleToolsList;
-    private handleToolCall;
-    private handleCancel;
-    private handleCancelNotification;
-    private handleSessionList;
-    private sendError;
-}
-
-interface WrongStackACPServerOptions {
-    /**
-     * Initial tool set. Typically loaded from the WrongStack tool registry
-     * via `api.tools.list()` so the ACP server exposes exactly the tools the
-     * CLI has configured.
-     */
-    tools: Tool[];
-    /**
-     * Owner label for tool metadata. Passed to ACPToolsRegistry.
-     * @default 'wrongstack'
-     */
-    owner?: string | undefined;
-}
-declare class WrongStackACPServer {
-    private readonly transport;
-    private readonly registry;
-    private readonly handler;
-    private running;
-    constructor(opts: WrongStackACPServerOptions);
-    /**
-     * Start the server. Blocks until the client disconnects.
-     *
-     * 1. Send the startup marker `[wstack-acp]` so the client
-     *    knows which stdout line is the protocol boundary.
-     * 2. Loop: read messages, dispatch to handler, until EOF or error.
-     *
-     * Single dispatch path: every inbound message is read exactly once
-     * from the transport and passed to the protocol handler exactly once.
-     * An earlier version combined a `transport.onMessage` callback with
-     * this read loop, which caused every message to be processed twice
-     * (once by the callback, once by the loop) — duplicate tool calls
-     * and duplicate responses to the client. See the ACP double-dispatch
-     * fix in the security audit (P1-001).
-     */
-    start(): Promise<void>;
-    /** Stop the server. */
-    stop(): void;
+    timeoutMs?: number | undefined;
 }
+/**
+ * Build a `RunTurn` that owns per-session `Agent` instances and
+ * delegates each turn to the appropriate agent. The returned
+ * function is reusable across sessions — the agents are kept in a
+ * Map keyed by `sessionId`.
+ */
+declare function makeACPServerAgentTurn(opts: ACPServerAgentTurnOptions): RunTurn;
 
-export { ACPProtocolHandler, ACPToolsRegistry, AgentServerTransport, WrongStackACPServer, type WrongStackACPServerOptions };
+export { type ACPServerAgentTurnOptions, makeACPServerAgentTurn };