@wrongstack/acp 0.260.0 → 0.265.1

package/dist/{stdio-transport-DoKRVjHz.d.ts → stdio-transport-CsFr8JzC.d.ts}

@@ -167,6 +167,13 @@ interface ClientTransportOptions {
     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;
@@ -195,4 +202,4 @@ declare class ClientTransport {
     private dispatch;
 }
 
-export { type ACPCancelParams as A, ClientTransport as C, StdioTransport as S, type ACPCapabilities as a, type ACPChildProcess as b, type ACPError as c, type ACPImageContent as d, type ACPInitializeParams as e, type ACPInputSchema as f, type ACPMessage as g, type ACPNotification as h, type ACPPlanContent as i, type ACPPlanStep as j, type ACPProgressContent as k, type ACPRequest as l, type ACPResourceContent as m, type ACPResponse as n, type ACPSessionInfo as o, type ACPSessionMode as p, type ACPTextContent as q, type ACPToolCallRequest as r, type ACPToolCallResponse as s, type ACPToolDefinition as t, type ACPToolList as u, type ACPToolResult as v, type AgentServerTransport as w, type ClientTransportOptions as x, type ContentBlock as y };
+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/tools-registry-BCf8evEG.d.ts

@@ -0,0 +1,36 @@
+import { Tool } from '@wrongstack/core';
+import { a as ACPToolList, b as ACPToolResult } from './stdio-transport-CsFr8JzC.js';
+
+/**
+ * Tools registry for ACP agent-side.
+ *
+ * Translates WrongStack Tool definitions → ACP ACPToolDefinition format.
+ * Provides tool lookup and result assembly for the ACP protocol handler.
+ */
+
+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;
+    /**
+     * Replace the current tool set.
+     */
+    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;
+    /**
+     * Execute a tool by name and return ACP-formatted result.
+     * Returns null if the tool is not found.
+     */
+    execute(name: string, args: Record<string, unknown>, ctx: unknown, signal: AbortSignal): Promise<ACPToolResult | null>;
+}
+
+export { ACPToolsRegistry as A };

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

@@ -0,0 +1,310 @@
+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 };

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

@@ -0,0 +1,3 @@
+export { W as WrongStackACPServer, a as WrongStackACPServerOptions } from './wrongstack-acp-agent-Dv-A0bEm.js';
+import './stdio-transport-CsFr8JzC.js';
+import 'node:events';