@wrongstack/acp 1.1.1 → 1.1.4

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

@@ -139,6 +139,8 @@ export interface ACPChildProcess extends EventEmitter {
 export declare class ClientTransport implements ACPClientTransport {
     private child;
     private buffer;
+    private stderrTail;
+    private stopRequested;
     private readonly handlers;
     private readonly claimHandlers;
     private readonly closeHandlers;

package/dist/client/acp-request-state.d.ts

@@ -4,7 +4,11 @@ export interface PendingRequest {
     reject: (e: Error) => void;
     timeoutMs: number;
     timeoutHandle: ReturnType<typeof setTimeout>;
+    /** Set on a request timed by inactivity: restarts its clock. */
+    rearm?: (() => void) | undefined;
 }
+/** The agent was heard from: restart the clock of every inactivity-timed request. */
+export declare function touchIdleRequests(pending: Map<string | number, PendingRequest>): void;
 export type State = 'init' | 'ready' | 'authenticated' | 'sessioning' | 'prompting' | 'done' | 'closed';
 /**
  * Fail and forget every in-flight request. Without a `reason` the session was

package/dist/client/acp-session-ops.d.ts

@@ -29,4 +29,23 @@ export declare function executeSetProvider(ctx: ACPSessionOpContext, providerId:
 export declare function executeDisableProvider(ctx: ACPSessionOpContext): Promise<void>;
 export declare function executeMcpMessage(ctx: ACPSessionOpContext, connectionId: string, message: Record<string, unknown>): Promise<unknown>;
 export declare function executeCreateSession(ctx: ACPSessionOpContext): Promise<SessionId>;
+/**
+ * Create the session now rather than at the first prompt. `resumed` is true
+ * when it continues `opts.resumeSessionId` (the agent remembers it), false for
+ * a new session.
+ */
+export declare function executeOpenSession(ctx: ACPSessionOpContext, create: () => Promise<SessionId>): Promise<{
+    sessionId: SessionId;
+    resumed: boolean;
+}>;
+/** What a steer did: joined the running turn, found none, or cannot steer. */
+export type AcpSteerOutcome = 'injected' | 'promptRequired' | 'startedNewTurn' | 'unsupported';
+/**
+ * Inject `text` into the turn the agent is running, through the
+ * `_session/steering` extension (Claude's ACP adapter advertises it as
+ * `InitializeResponse._meta.steering.supported`). With no turn running the
+ * agent hands the text back (`promptRequired`) instead of starting a turn
+ * nobody awaits.
+ */
+export declare function executeSteer(ctx: ACPSessionOpContext, supported: boolean, text: string): Promise<AcpSteerOutcome>;
 //# sourceMappingURL=acp-session-ops.d.ts.map

package/dist/client/acp-session-prompt.d.ts

@@ -15,8 +15,8 @@ export interface AcpSessionPromptHost {
     resetScratch(): void;
     progressHandler: ACPProgressHandler | null;
     allocId(): number;
-    sendRequest(id: number, method: string, params: unknown, timeoutMs?: number): Promise<unknown>;
-    timeoutMs: number;
+    sendRequest(id: number, method: string, params: unknown, timeoutMs?: number, idle?: boolean): Promise<unknown>;
+    promptIdleTimeoutMs: number;
     scratch: ACPSessionScratch;
 }
 export declare function prompt(host: AcpSessionPromptHost, blocks: ContentBlock[], signal: AbortSignal, onProgress?: ACPProgressHandler): Promise<ACPSessionRunResult>;

package/dist/client/acp-session-types.d.ts

@@ -8,7 +8,15 @@ export interface ACPSessionOptions {
     cwd?: string | undefined;
     role?: string | undefined;
     projectRoot: string;
+    /** Cap for each request to the agent other than a prompt turn. Default 5 minutes. */
     timeoutMs?: number | undefined;
+    /**
+     * How long a prompt turn may go without hearing from the agent (an update,
+     * a permission request, a file or terminal call) before it counts as
+     * stalled and is cancelled. Default 10 minutes. A turn that keeps reporting
+     * runs until it ends: a coding agent's turn routinely outlasts any fixed cap.
+     */
+    promptIdleTimeoutMs?: number | undefined;
     permissionPolicy?: PermissionPolicy | undefined;
     trustBoundary?: TrustBoundary | undefined;
     trustActor?: TrustActor | undefined;
@@ -19,6 +27,30 @@ export interface ACPSessionOptions {
     terminalOutputByteLimit?: number | undefined;
     terminalMaxCount?: number | undefined;
     mcpServers?: McpServer[] | undefined;
+    /**
+     * Opaque `_meta` sent with `session/new`. ACP reserves `_meta` for
+     * agent-specific extensions; e.g. the Claude adapter reads
+     * `systemPrompt: { append }` from it. Agents that know no key ignore it.
+     */
+    sessionMeta?: Record<string, unknown> | undefined;
+    /**
+     * Session mode to switch to right after `session/new`, when the agent
+     * offers it (e.g. Claude's `default`, so it asks before edits and
+     * commands instead of following the user's own Claude permission mode).
+     */
+    initialModeId?: string | undefined;
+    /**
+     * Refuse the session when the agent does not offer `initialModeId`: the
+     * host depends on that mode (an agent left in its own mode may never ask).
+     */
+    requireInitialMode?: boolean | undefined;
+    /**
+     * An earlier session of this agent to continue instead of starting one
+     * (`session/resume`, with this session's MCP servers, `_meta` and mode).
+     * Used when the agent advertises resume; when it does not, or no longer has
+     * the session, a new session starts. `openSession()` says which happened.
+     */
+    resumeSessionId?: string | undefined;
 }
 export interface ACPCapturedDiff {
     path: string;
@@ -32,6 +64,12 @@ export interface ACPCapturedToolCall {
     status: ToolCallStatus;
     rawOutput?: Record<string, unknown> | undefined;
     rawInput?: Record<string, unknown> | undefined;
+    /**
+     * What the call returned, as text: its `content` text blocks, else a
+     * string or text-block `rawOutput`. Claude's adapter sends the result in
+     * those shapes, which `rawOutput` (an object only) never held.
+     */
+    output?: string | undefined;
 }
 export interface ACPSessionRunResult {
     text: string;
@@ -42,11 +80,23 @@ export interface ACPSessionRunResult {
         size: number;
         cost?: UsageCost | undefined;
     } | undefined;
+    /**
+     * Token counts for the turn, from the `session/prompt` response
+     * (`PromptResponse.usage`). `usage.cost`, by contrast, is the session's
+     * running total.
+     */
+    tokens?: ACPTokenUsage | undefined;
     plan?: PlanEntry[] | undefined;
     toolCalls: ACPCapturedToolCall[];
     diffs: ACPCapturedDiff[];
     thoughts: string;
 }
+export interface ACPTokenUsage {
+    input: number;
+    output: number;
+    cacheRead: number;
+    cacheWrite: number;
+}
 export type ACPProgressHandler = (event: ACPProgressEvent) => void;
 export type ACPProgressEvent = {
     type: 'message';
@@ -73,9 +123,25 @@ export type ACPProgressEvent = {
         size: number;
         cost?: UsageCost | undefined;
     };
+}
+/**
+ * The agent's account rate-limit reading, as it sent it (Claude's adapter:
+ * `usage_update._meta["_claude/rateLimit"]` — status, resetsAt, windows).
+ */
+ | {
+    type: 'rate_limit';
+    info: Record<string, unknown>;
+}
+/** Emitted by the subagent runner once a turn ends: what the turn consumed. */
+ | {
+    type: 'turn_usage';
+    tokens?: ACPTokenUsage | undefined;
+    costUsd: number;
 } | {
     type: 'raw';
     update: AnySessionUpdate;
 };
-export type ACPSessionErrorKind = 'spawn_failed' | 'init_failed' | 'protocol_error' | 'session_create_failed' | 'prompt_failed' | 'auth_failed' | 'logout_failed' | 'aborted' | 'closed' | 'agent_died' | 'unsupported_capability';
+export type ACPSessionErrorKind = 'spawn_failed' | 'init_failed' | 'protocol_error' | 'session_create_failed' | 'prompt_failed' | 'auth_failed' | 'logout_failed' | 'aborted' | 'closed' | 'agent_died'
+/** A prompt turn heard nothing from the agent for `promptIdleTimeoutMs`. */
+ | 'stalled' | 'unsupported_capability';
 //# sourceMappingURL=acp-session-types.d.ts.map

package/dist/client/acp-session-updates.d.ts

@@ -12,6 +12,15 @@ export interface ACPSessionScratch {
     };
     toolCalls: Map<string, ACPCapturedToolCall>;
     diffs: ACPCapturedDiff[];
+    /**
+     * Set when a tool call ran after the last message text: the next text
+     * chunk starts a new assistant message, not a continuation.
+     */
+    messageBreak?: boolean;
+    /** Diffs already captured, keyed by tool call; agents resend them on update. */
+    seenDiffs?: Set<string>;
+    /** Tool calls already reported as started (see captureToolCall). */
+    announced?: Set<string>;
 }
 export declare function createSessionScratch(): ACPSessionScratch;
 export declare function handleAcpSessionUpdate(msg: ACPMessage, scratch: ACPSessionScratch, emitProgress: (event: ACPProgressEvent) => void): void;

package/dist/client/acp-session.d.ts

@@ -10,6 +10,7 @@
  */
 import { type ACPClientTransport } from '../agent/stdio-transport.js';
 import { type AgentCapabilities, type AuthMethod, type ContentBlock, type McpServer, type SessionId, type SessionInfo } from '../types/acp-v1.js';
+import { type AcpSteerOutcome } from './acp-session-ops.js';
 import type { ACPProgressHandler, ACPSessionOptions, ACPSessionRunResult } from './acp-session-types.js';
 import { type WebSocketClientTransportOptions } from './websocket-transport.js';
 export { audioContent, imageContent, textContent } from './acp-session-content.js';
@@ -21,6 +22,7 @@ export declare class ACPSession {
     private readonly terminalServer;
     private readonly permissionPolicy;
     private readonly timeoutMs;
+    private readonly promptIdleTimeoutMs;
     private readonly opts;
     private transportOff;
     private readonly callbackAbort;
@@ -35,6 +37,8 @@ export declare class ACPSession {
     private agentCapabilities;
     private agentInfo;
     private authMethods;
+    /** The agent accepts `_session/steering` (see executeSteer). */
+    private steeringSupported;
     /** Protocol version negotiated with the agent during initialize. */
     private negotiatedVersion;
     private constructor();
@@ -85,6 +89,11 @@ export declare class ACPSession {
      */
     logout(): Promise<void>;
     private opContext;
+    /** Start (or, with `resumeSessionId`, resume) the agent session now, not at the first prompt. */
+    openSession(): Promise<{
+        sessionId: SessionId;
+        resumed: boolean;
+    }>;
     loadSession(sessionId: SessionId, mcpServers?: McpServer[], cwd?: string): Promise<void>;
     resumeSession(sessionId: SessionId, mcpServers?: McpServer[], cwd?: string): Promise<void>;
     listSessions(cursor?: string, cwd?: string): Promise<{
@@ -102,6 +111,10 @@ export declare class ACPSession {
     mcpMessage(connectionId: string, message: Record<string, unknown>): Promise<unknown>;
     setProvider(providerId: string, config?: Record<string, unknown>): Promise<void>;
     disableProvider(): Promise<void>;
+    /** Whether {@link steer} can reach the agent. */
+    canSteer(): boolean;
+    /** Inject a message into the agent's running turn. */
+    steer(text: string): Promise<AcpSteerOutcome>;
     prompt(blocks: ContentBlock[], signal: AbortSignal, onProgress?: ACPProgressHandler): Promise<ACPSessionRunResult>;
     /**
      * Best-effort cancel for a session the server confirmed after we already
@@ -114,7 +127,14 @@ export declare class ACPSession {
      */
     private cancelLateSession;
     private closeSession;
-    close(): Promise<void>;
+    /**
+     * Close the session and stop the agent. `graceMs` bounds how long the
+     * agent may take to answer `session/close` before it is stopped anyway —
+     * shutdown passes a short one so a slow answer cannot outlive the process.
+     */
+    close(opts?: {
+        graceMs?: number;
+    }): Promise<void>;
     private allocId;
     private sendRequest;
     /**