@wrongstack/acp 0.273.1 → 0.275.0

package/dist/index-BvPqJHhm.d.ts

@@ -1,119 +0,0 @@
-import { j as ACPMessage, v as ACPToolCallResponse } from './stdio-transport-CsFr8JzC.js';
-import { SubagentRunner } from '@wrongstack/core';
-
-/**
- * ToolTranslator — bidirectional translation between WrongStack tools and
- * ACP tool representations.
- *
- * Used by DIR-1 (WrongStack as ACP client) to:
- *   - Map WrongStack TaskSpec → ACP task payload
- *   - Map ACP tool responses → TaskResult
- *
- * Used by DIR-2 (WrongStack as ACP server) to:
- *   - Convert the WrongStack Tool.inputSchema → ACPToolDefinition.inputSchema
- *   - (handled by tools-registry.ts — same logic lives there)
- *
- * For DIR-1 async tool calls: ACP agents send progress notifications while
- * a tool is running, then send a final result. The translator handles this
- * by polling for the final [result] notification on the transport.
- */
-
-interface ToolTranslatorOptions {
-    /**
-     * If true (default), wrap tool calls in an async poll loop that waits
-     * for progress notifications until a final result arrives.
-     */
-    asyncTools?: boolean | undefined;
-    pollIntervalMs?: number | undefined;
-    totalTimeoutMs?: number | undefined;
-}
-/** ToolTranslator for DIR-1 — wraps ACP client transport, adds task semantics */
-declare class ToolTranslator {
-    private readonly opts;
-    private readonly pending;
-    constructor(opts?: ToolTranslatorOptions);
-    /**
-     * Start listening to a transport for tool responses and cancellations.
-     * Call this once after constructing the translator and before sending tasks.
-     */
-    attachToTransport(transport: {
-        onMessage: (h: (msg: ACPMessage) => void) => () => void;
-        send: (msg: ACPMessage) => Promise<void>;
-    }): void;
-    /**
-     * Send a tool call over the transport and wait for a response.
-     * If asyncTools is true, polls for progress and resolves when the final
-     * response arrives.
-     */
-    callTool(transport: {
-        send: (msg: ACPMessage) => Promise<void>;
-    }, name: string, args: Record<string, unknown>, callId?: string | number): Promise<ACPToolCallResponse>;
-    cancelAll(): void;
-}
-
-/**
- * ACPSubagentRunner — `SubagentRunner` implementation for DIR-1.
- *
- * Wraps an external ACP-supporting agent (Claude Code, Gemini CLI, Codex
- * CLI, Cline, Goose, OpenHands, etc.) as a WrongStack subagent. The
- * external agent runs its own agent loop; we send it a task via the ACP
- * v1 protocol and return the result.
- *
- * v1 spec: https://agentclientprotocol.com/protocol/v1/overview
- *
- * Connected to the Director / MultiAgentCoordinator via the
- * `SubagentRunner` interface (same shape as `AgentSubagentRunner`).
- */
-
-interface ACPSubagentRunnerOptions {
-    /** How to spawn the external agent. */
-    command: string;
-    args?: string[] | undefined;
-    env?: Record<string, string> | undefined;
-    cwd?: string | undefined;
-    /** Subagent role label — surfaced in errors and used for logging. */
-    role?: string | undefined;
-    /**
-     * Hard wall-clock cap for one prompt turn. Defaults to 5 minutes.
-     * Overrides `SubagentRunContext.budget.limits.timeoutMs` if both are set.
-     */
-    timeoutMs?: number | undefined;
-    /**
-     * Filesystem sandbox root. Defaults to `options.cwd` (when set) or
-     * the process's current working directory. All `fs/read_text_file` /
-     * `fs/write_text_file` calls are bounded to this root.
-     */
-    projectRoot?: string | undefined;
-}
-/**
- * Static catalog of agent ids → spawn options.
- *
- * The CLI and the host's `buildACPRunner` look up entries by id. The
- * canonical, multi-source catalog is `packages/acp/src/registry/agents.catalog.ts`
- * (the 12-entry static catalog introduced in commit 4ad287b4). This
- * map stays for backward compatibility with existing call sites that
- * import it directly; new code should prefer the registry.
- */
-declare const ACP_AGENT_COMMANDS: Record<string, ACPSubagentRunnerOptions>;
-/**
- * Build a one-shot `SubagentRunner` for a single agent invocation. Each
- * call to the returned function spawns a fresh child process, runs one
- * prompt turn, and tears everything down. The cost is ~1 second of
- * process-startup per call; for long-lived sessions (multi-turn
- * conversations), use `makeACPSubagentRunnerWithStop` and call `stop()`
- * explicitly.
- */
-declare function makeACPSubagentRunner(options: ACPSubagentRunnerOptions): Promise<SubagentRunner>;
-/**
- * Build a long-lived `SubagentRunner` plus an explicit `stop()` for
- * teardown. The caller is responsible for calling `stop()` when done
- * (or when the host's signal fires). Useful for the `wstack acp spawn`
- * CLI command, which holds the child open for the duration of a user
- * task and tears down on SIGINT.
- */
-declare function makeACPSubagentRunnerWithStop(options: ACPSubagentRunnerOptions): Promise<{
-    runner: SubagentRunner;
-    stop: () => void;
-}>;
-
-export { type ACPSubagentRunnerOptions as A, ToolTranslator as T, ACP_AGENT_COMMANDS as a, type ToolTranslatorOptions as b, makeACPSubagentRunnerWithStop as c, makeACPSubagentRunner as m };

package/dist/stdio-transport-CsFr8JzC.d.ts

@@ -1,205 +0,0 @@
-import { EventEmitter } from 'node:events';
-
-/**
- * ACP message types — transport-agnostic JSON-RPC 2.0 envelope.
- * Reuses MCP types where possible; custom types for agentic UX (diffs, plans).
- */
-interface ACPMessage {
-    method: string;
-    id?: string | number | undefined;
-    params?: unknown | undefined;
-    result?: unknown | undefined;
-    error?: ACPError | undefined;
-}
-interface ACPError {
-    code: number;
-    message: string;
-    data?: unknown | undefined;
-}
-type ACPRequest = RequiredPick<ACPMessage, 'id' | 'params' | 'method'>;
-type ACPResponse = RequiredPick<ACPMessage, 'id' | 'result' | 'method'>;
-type ACPNotification = Omit<ACPMessage, 'id'> & {
-    method: string;
-};
-interface ACPInitializeParams {
-    capabilities?: string[] | undefined;
-    protocolVersion?: string | undefined;
-    sessionId?: string | undefined;
-    authToken?: string | undefined;
-    sessionPath?: string | undefined;
-    workspaceRoots?: string[] | undefined;
-    mcpServers?: unknown[] | undefined;
-    [key: string]: unknown;
-}
-interface ACPCapabilities {
-    capabilities: string[];
-    agentName: string;
-    agentVersion: string;
-    tools?: ACPToolList | undefined;
-    protocolVersion: string;
-}
-interface ACPToolList {
-    tools: ACPToolDefinition[];
-}
-interface ACPToolDefinition {
-    name: string;
-    description?: string | undefined;
-    inputSchema: ACPInputSchema;
-    annotations?: {
-        title?: string | undefined;
-        description?: string | undefined;
-        priority?: 'high' | 'medium' | 'low' | undefined;
-        alwaysAccept?: boolean | undefined;
-    };
-}
-type ACPInputSchema = {
-    type?: string | undefined;
-    properties?: Record<string, ACPInputSchema>;
-    required?: string[] | undefined;
-    items?: ACPInputSchema | undefined;
-    enum?: unknown[] | undefined;
-    description?: string | undefined;
-    default?: unknown | undefined;
-    minimum?: number | undefined;
-    maximum?: number | undefined;
-    [key: string]: unknown;
-};
-type ContentBlock = ACPTextContent | ACPResourceContent | ACPImageContent | ACPProgressContent;
-interface ACPTextContent {
-    type: 'text';
-    text: string;
-}
-interface ACPResourceContent {
-    type: 'resource';
-    resource: {
-        type: string;
-        uri: string;
-        data?: string | undefined;
-        mimeType?: string | undefined;
-    };
-}
-interface ACPImageContent {
-    type: 'image';
-    data: string;
-    mimeType?: string | undefined;
-}
-interface ACPProgressContent {
-    type: 'progress';
-    id: string;
-    label?: string | undefined;
-    message?: string | undefined;
-    messages?: string[] | undefined;
-}
-interface ACPToolCallRequest {
-    method: 'tools/call';
-    id: string | number;
-    params: {
-        name: string;
-        arguments: Record<string, unknown>;
-    };
-}
-interface ACPToolResult {
-    content: ContentBlock[];
-    isError?: boolean | undefined;
-}
-type ACPToolCallResponse = {
-    method: 'tools/call';
-    id: string | number;
-    result: ACPToolResult;
-};
-interface ACPSessionInfo {
-    sessionId: string;
-    path: string;
-    title?: string | undefined;
-    modelId?: string | undefined;
-    createdAt: string;
-    lastActiveAt: string;
-}
-interface ACPPlanStep {
-    id: string;
-    description: string;
-    status?: 'pending' | 'running' | 'completed' | 'skipped' | undefined;
-}
-interface ACPPlanContent {
-    type: 'plan';
-    plan: {
-        steps: ACPPlanStep[];
-    };
-}
-type ACPSessionMode = 'agent' | 'chat' | 'edit' | 'preview';
-interface ACPCancelParams {
-    reason?: string | undefined;
-}
-type RequiredPick<T, K extends keyof T> = Pick<T, K> & Partial<Omit<T, K>>;
-
-interface AgentServerTransport {
-    send(msg: ACPMessage): Promise<void>;
-    sendRaw(chunk: string): void;
-    read(): Promise<ACPMessage | null>;
-    close(): void;
-    onMessage(handler: (msg: ACPMessage) => void): () => void;
-}
-declare class StdioTransport implements AgentServerTransport {
-    private readonly stdin;
-    private readonly stdout;
-    private readonly stderr;
-    private buffer;
-    private readonly handlers;
-    private closed;
-    private resolveRead;
-    private messageQueue;
-    constructor();
-    sendStartupMarker(): void;
-    send(msg: ACPMessage): Promise<void>;
-    sendRaw(chunk: string): void;
-    read(): Promise<ACPMessage | null>;
-    onMessage(handler: (msg: ACPMessage) => void): () => void;
-    close(): void;
-    private onData;
-    private dispatch;
-    private handleClose;
-    private failAll;
-}
-
-interface ClientTransportOptions {
-    command: string;
-    args?: string[] | undefined;
-    env?: Record<string, string>;
-    cwd?: string | undefined;
-    handshakeTimeoutMs?: number | undefined;
-    /**
-     * Set to true when the child is an external ACP agent (Claude Code,
-     * Gemini CLI, Codex CLI, …) that does NOT emit a `[wstack-acp]\n`
-     * marker on startup. The v1 client (`ACPSession`) sets this; the
-     * server-side transport (the default) keeps the marker check.
-     */
-    skipHandshakeMarker?: boolean | undefined;
-}
-interface ACPChildProcess extends EventEmitter {
-    stdout: NodeJS.ReadableStream;
-    stdin: NodeJS.WritableStream;
-    stderr: NodeJS.ReadableStream;
-    pid: number | undefined;
-    kill(): void;
-}
-declare class ClientTransport {
-    private child;
-    private buffer;
-    private readonly handlers;
-    private closed;
-    private resolveRead;
-    private messageQueue;
-    private readonly opts;
-    constructor(options: ClientTransportOptions);
-    start(): Promise<void>;
-    send(msg: ACPMessage): Promise<void>;
-    read(): Promise<ACPMessage | null>;
-    onMessage(handler: (msg: ACPMessage) => void): () => void;
-    stop(): void;
-    private onChildData;
-    private onChildError;
-    private onChildClose;
-    private dispatch;
-}
-
-export { type AgentServerTransport as A, ClientTransport as C, StdioTransport as S, type ACPToolList as a, type ACPToolResult as b, type ACPCancelParams as c, type ACPCapabilities as d, type ACPChildProcess as e, type ACPError as f, type ACPImageContent as g, type ACPInitializeParams as h, type ACPInputSchema as i, type ACPMessage as j, type ACPNotification as k, type ACPPlanContent as l, type ACPPlanStep as m, type ACPProgressContent as n, type ACPRequest as o, type ACPResourceContent as p, type ACPResponse as q, type ACPSessionInfo as r, type ACPSessionMode as s, type ACPTextContent as t, type ACPToolCallRequest as u, type ACPToolCallResponse as v, type ACPToolDefinition as w, type ClientTransportOptions as x, type ContentBlock as y };

package/dist/wrongstack-acp-agent-Dv-A0bEm.d.ts

@@ -1,310 +0,0 @@
-import { A as AgentServerTransport } from './stdio-transport-CsFr8JzC.js';
-
-type ToolCallId = string & {
-    readonly __acpToolCallId: unique symbol;
-};
-type TerminalId = string & {
-    readonly __acpTerminalId: unique symbol;
-};
-/**
- * Annotations attached to a content block. Optional, agent-supplied hint
- * about audience/priority. Spec leaves shape open; we mirror the fields
- * the spec shows in its examples.
- */
-interface ContentAnnotations {
-    audience?: ('user' | 'assistant')[] | undefined;
-    priority?: number | undefined;
-    [key: string]: unknown;
-}
-interface TextContent {
-    type: 'text';
-    text: string;
-    annotations?: ContentAnnotations | undefined;
-}
-interface ImageContent {
-    type: 'image';
-    mimeType: string;
-    /** Base64-encoded image data. */
-    data: string;
-    uri?: string | undefined;
-    annotations?: ContentAnnotations | undefined;
-}
-interface AudioContent {
-    type: 'audio';
-    mimeType: string;
-    /** Base64-encoded audio data. */
-    data: string;
-    annotations?: ContentAnnotations | undefined;
-}
-interface TextResourceContents {
-    uri: string;
-    mimeType?: string | undefined;
-    text: string;
-}
-interface BlobResourceContents {
-    uri: string;
-    mimeType?: string | undefined;
-    /** Base64-encoded binary. */
-    blob: string;
-}
-type EmbeddedResourceContents = TextResourceContents | BlobResourceContents;
-interface EmbeddedResourceContent {
-    type: 'resource';
-    resource: EmbeddedResourceContents;
-    annotations?: ContentAnnotations | undefined;
-}
-interface ResourceLinkContent {
-    type: 'resource_link';
-    uri: string;
-    name: string;
-    mimeType?: string | undefined;
-    title?: string | undefined;
-    description?: string | undefined;
-    size?: number | undefined;
-    annotations?: ContentAnnotations | undefined;
-}
-type ContentBlock = TextContent | ImageContent | AudioContent | EmbeddedResourceContent | ResourceLinkContent;
-type ToolKind = 'read' | 'edit' | 'delete' | 'move' | 'search' | 'execute' | 'think' | 'fetch' | 'switch_mode' | 'other';
-type ToolCallStatus = 'pending' | 'in_progress' | 'completed' | 'failed';
-/** A single concrete content payload attached to a tool call. */
-type ToolCallContent = {
-    type: 'content';
-    content: ContentBlock;
-} | {
-    type: 'diff';
-    path: string;
-    oldText: string | null;
-    newText: string;
-} | {
-    type: 'terminal';
-    terminalId: TerminalId;
-};
-interface ToolCallLocation {
-    path: string;
-    /** 1-based per the spec's argument requirements. */
-    line?: number | undefined;
-}
-type PlanEntryPriority = 'high' | 'medium' | 'low';
-type PlanEntryStatus = 'pending' | 'in_progress' | 'completed';
-interface PlanEntry {
-    /** Required by the spec for the array shape, but per-entry id is optional. */
-    content: string;
-    priority: PlanEntryPriority;
-    status: PlanEntryStatus;
-}
-interface UsageCost {
-    amount: number;
-    /** ISO 4217 currency code, e.g. "USD". */
-    currency: string;
-}
-type PermissionOptionKind = 'allow_once' | 'allow_always' | 'reject_once' | 'reject_always';
-interface PermissionOption {
-    optionId: string;
-    name: string;
-    kind: PermissionOptionKind;
-}
-type RequestPermissionOutcome = {
-    outcome: 'cancelled';
-} | {
-    outcome: 'selected';
-    optionId: string;
-};
-type StopReason = 'end_turn' | 'max_tokens' | 'max_turn_requests' | 'refusal' | 'cancelled' | string;
-/** Subsequent updates to a previously-emitted tool call. */
-interface ToolCallUpdateNotification {
-    sessionUpdate: 'tool_call_update';
-    toolCallId: ToolCallId;
-    status?: ToolCallStatus | undefined;
-    content?: ToolCallContent[] | undefined;
-    title?: string | undefined;
-    kind?: ToolKind | undefined;
-    locations?: ToolCallLocation[] | undefined;
-    rawInput?: Record<string, unknown> | undefined;
-    rawOutput?: Record<string, unknown> | undefined;
-}
-
-/**
- * ACP v1 server-side protocol handler.
- *
- * Receives JSON-RPC requests from an external ACP client (Zed, JetBrains
- * Junie, VS Code ACP extension, etc.) over stdio and answers them per the
- * v1 spec. See https://agentclientprotocol.com/protocol/v1/overview.
- *
- * Supported methods
- * ─────────────────
- *  - initialize                — handshake
- *  - authenticate              — optional, no-op when auth isn't required
- *  - session/new               — create a session
- *  - session/load              — restore a session by id
- *  - session/prompt            — run one turn, stream session/update
- *                               notifications, return stopReason
- *  - session/cancel            — notification (no response); cancels the
- *                               in-flight turn on the target session
- *  - session/set_mode          — change the active mode for a session
- *  - session/set_config_option — change a config option value
- *  - session/list              — list known sessions
- *
- * Method execution
- * ────────────────
- *  The handler is transport-agnostic; it sends responses via the
- *  `AgentServerTransport` injected at construction. The actual
- *  agent-loop work for a `session/prompt` turn is delegated to the
- *  caller-provided `runTurn` callback, which receives the prompt
- *  blocks and the per-turn AbortSignal and resolves with the final
- *  stopReason. Updates are streamed via the `emit` callback passed
- *  to `runTurn`; the handler wraps each as a `session/update`
- *  notification.
- *
- *  This separation keeps the handler unit-testable: tests can supply
- *  a fake `runTurn` that yields a canned sequence of updates, and
- *  assert on the JSON-RPC traffic the handler produces. A real
- *  production caller wires `runTurn` to a core `Agent` instance.
- *
- * Concurrency
- * ───────────
- *  Each session is single-threaded (one active turn at a time). The
- *  handler keeps a per-session AbortController so a `session/cancel`
- *  notification can stop the running turn mid-stream without tearing
- *  down the session. Multiple sessions can be active concurrently.
- */
-
-interface RunTurnInput {
-    sessionId: string;
-    /** Content blocks the client sent. */
-    prompt: readonly ContentBlock[];
-    /** Cancelled when the client sends `session/cancel` for this session. */
-    signal: AbortSignal;
-}
-interface RunTurnResult {
-    stopReason: StopReason;
-    /** Optional summary text the agent produced. */
-    text?: string;
-    plan?: PlanEntry[];
-    usage?: {
-        used: number;
-        size: number;
-        cost?: UsageCost | undefined;
-    };
-}
-/**
- * The agent's per-turn work. Streams `SessionUpdate` notifications to
- * `emit` and resolves with the final stopReason. Errors thrown from
- * this iterable are converted to a `prompt_failed` JSON-RPC error.
- */
-type RunTurn = (input: RunTurnInput, emit: (update: unknown) => void) => Promise<RunTurnResult>;
-interface SessionState {
-    id: string;
-    cwd: string;
-    /** Per-turn abort signal — aborted when the session is cancelled or closed. */
-    abort: AbortController;
-    /** Active mode, advertised to the client in current_mode_update. */
-    modeId: string;
-    /** Created at, for session/list ordering. */
-    createdAt: string;
-    /** Last activity timestamp, for session/info_update. */
-    updatedAt: string;
-    /** Optional human title. */
-    title?: string;
-}
-/** MCP-style session mode advertised in current_mode_update. */
-interface SessionMode {
-    id: string;
-    name: string;
-    description?: string | undefined;
-}
-interface SessionConfigOption {
-    id: string;
-    name: string;
-    type: 'select' | string;
-    currentValue: string;
-    options: {
-        value: string;
-        name: string;
-        description?: string | undefined;
-    }[];
-}
-interface ProtocolHandlerOptions {
-    transport: AgentServerTransport;
-    /** Where the server is running; used for new sessions' default cwd. */
-    defaultCwd: string;
-    /** Agent's per-turn implementation. */
-    runTurn: RunTurn;
-    /**
-     * Optional callbacks for the lifecycle events the server should
-     * surface to the client. All default to no-ops.
-     */
-    onSessionNew?: ((state: SessionState) => void) | undefined;
-    /** Static list of available modes (advertised to clients). */
-    modes?: readonly SessionMode[] | undefined;
-    /** Static list of config options. */
-    configOptions?: readonly SessionConfigOption[] | undefined;
-    /** Agent name advertised in initialize. */
-    agentName?: string | undefined;
-}
-declare class ACPProtocolHandler {
-    private readonly transport;
-    private readonly defaultCwd;
-    private readonly runTurn;
-    private readonly onSessionNew;
-    private readonly modes;
-    private readonly configOptions;
-    private readonly agentName;
-    private initialized;
-    private readonly sessions;
-    private nextId;
-    constructor(opts: ProtocolHandlerOptions);
-    /**
-     * Process one inbound message. Returns true if this was a terminal
-     * message (rare; reserved for future use by the server's own
-     * shutdown signal).
-     */
-    handleMessage(msg: unknown): Promise<boolean>;
-    /** Abort all active turns and drop session state. */
-    close(): void;
-    private handleRequest;
-    private handleInitialize;
-    private handleAuthenticate;
-    private handleSessionNew;
-    private handleSessionLoad;
-    private handleSessionPrompt;
-    private handleSetMode;
-    private handleSetConfigOption;
-    private handleSessionList;
-    private handleNotification;
-    private sendNotification;
-    private sendError;
-    private allocId;
-}
-
-interface WrongStackACPServerOptions {
-    /**
-     * Per-turn implementation. If omitted, the server runs a no-op turn
-     * that just resolves with `end_turn`. The real production usage
-     * passes the result of `makeACPServerAgentTurn({ agentFor: ... })`
-     * from `./server-agent-turn.js` so each session gets a real
-     * `Agent` instance.
-     */
-    runTurn?: RunTurn | undefined;
-    /** Default cwd for new sessions. Defaults to the current process cwd. */
-    defaultCwd?: string | undefined;
-    /** Agent name advertised in initialize. */
-    agentName?: string | undefined;
-}
-declare class WrongStackACPServer {
-    private readonly transport;
-    private readonly handler;
-    private running;
-    constructor(opts?: WrongStackACPServerOptions);
-    /**
-     * Start the server. Blocks until the client disconnects.
-     *
-     * 1. Print the legacy `[wstack-acp]\n` marker so the client knows the
-     *    process is the ACP server (the old `StdioTransport` handshake).
-     * 2. Loop: read messages, dispatch to the handler, until EOF / error.
-     */
-    start(): Promise<void>;
-    /** Stop the server. */
-    stop(): void;
-}
-
-export { ACPProtocolHandler as A, type PermissionOption as P, type RunTurn as R, type StopReason as S, type ToolCallUpdateNotification as T, type UsageCost as U, WrongStackACPServer as W, type WrongStackACPServerOptions as a, type RequestPermissionOutcome as b, type PlanEntry as c };