acpx/dist/client-BqZW_W14.d.ts

Headless CLI client for the Agent Client Protocol (ACP) — talk to coding agents from the command line

import { C as PermissionMode, D as PromptInput, S as NonInteractivePermissionPolicy, T as PermissionStats, a as AcpElicitationHandler, f as AcpPermissionHandler, r as AcpClientOptions } from "./session-options-D9KL7-d8.js";
import { AnyMessage, InitializeResponse, ListSessionsRequest, ListSessionsResponse, PromptResponse, SessionConfigOption, SetSessionConfigOptionResponse } from "@agentclientprotocol/sdk";
type AcpControlAuthority = {
  signal?: AbortSignal;
  assertActive?: () => void;
};
type SessionModelState = {
  configId?: string;
  currentModelId: string;
  availableModels: Array<{
    modelId: string;
    name: string;
  }>;
};
type LoadSessionOptions = {
  authority?: AcpControlAuthority;
  suppressReplayUpdates?: boolean;
  replayIdleMs?: number;
  replayDrainTimeoutMs?: number;
};
type SessionCreateResult = {
  sessionId: string;
  agentSessionId?: string;
  configOptions?: SessionConfigOption[];
  models?: SessionModelState;
  configOptionsPresent: boolean;
  legacyModelMetadataPresent: boolean;
};
type SessionLoadResult = {
  agentSessionId?: string;
  configOptions?: SessionConfigOption[];
  models?: SessionModelState;
  configOptionsPresent: boolean;
  legacyModelMetadataPresent: boolean;
};
type SessionResumeResult = SessionLoadResult;
type AgentDisconnectReason = "process_exit" | "process_close" | "pipe_close" | "connection_close";
type AgentExitInfo = {
  exitCode: number | null;
  signal: NodeJS.Signals | null;
  exitedAt: string;
  reason: AgentDisconnectReason;
  unexpectedDuringPrompt: boolean;
};
type AgentLifecycleSnapshot = {
  pid?: number;
  startedAt?: string;
  running: boolean;
  lastExit?: AgentExitInfo;
};
declare class AcpClient {
  private options;
  private connection?;
  private agent?;
  private readonly agentDescendants;
  private readonly agentCleanups;
  private readonly commandProbes;
  private initResult?;
  private loadedSessionId?;
  private eventHandlers;
  private readonly permissionStats;
  private readonly filesystem;
  private readonly terminalManager;
  private sessionUpdateChain;
  private observedSessionUpdates;
  private processedSessionUpdates;
  private suppressSessionUpdates;
  private activePrompt?;
  private readonly pendingPromptOwners;
  private readonly cancellingSessionIds;
  private readonly permissionAbortControllers;
  private closing;
  private closeTask?;
  private closeEpoch;
  private agentStartedAt?;
  private lastAgentExit?;
  private lastKnownPid?;
  private readonly promptPermissionFailures;
  private readonly pendingConnectionRequests;
  constructor(options: AcpClientOptions);
  get initializeResult(): InitializeResponse | undefined;
  getAgentPid(): number | undefined;
  getPermissionStats(): PermissionStats;
  getAgentLifecycleSnapshot(): AgentLifecycleSnapshot;
  supportsLoadSession(): boolean;
  supportsResumeSession(): boolean;
  supportsCloseSession(): boolean;
  supportsListSessions(): boolean;
  setEventHandlers(handlers: Pick<AcpClientOptions, "onAcpMessage" | "onAcpOutputMessage" | "onSessionUpdate" | "onClientOperation" | "onPermissionEscalation">): void;
  clearEventHandlers(): void;
  updateRuntimeOptions(options: {
    permissionMode?: PermissionMode;
    nonInteractivePermissions?: NonInteractivePermissionPolicy;
    permissionPolicy?: AcpClientOptions["permissionPolicy"];
    fs?: boolean;
    terminal?: boolean;
    suppressSdkConsoleErrors?: boolean;
    verbose?: boolean;
  }): void;
  private updateClientCapabilityPreferences;
  private refreshRuntimePermissionPolicy;
  private hasLiveConnection;
  hasReusableSession(sessionId: string): boolean;
  hasActivePrompt(sessionId?: string): boolean;
  hasUnresolvedPrompt(): boolean;
  private abortSessionRequests;
  start(authority?: AcpControlAuthority, options?: Pick<AcpClientOptions, "sessionOptions">): Promise<void>;
  private waitForPreviousClose;
  private resolveAgentLaunchPlan;
  private logAgentLaunch;
  private ensureLaunchSupport;
  private prepareProcessLaunch;
  private startedProcess;
  private spawnAgentProcess;
  private assertCommandProbeActive;
  private readAgentCommandOutput;
  private admitAndObserveSpawnedProcess;
  private admitSpawnedProcess;
  private createConnection;
  private initializeAgentConnection;
  private initializeProtocolConnection;
  private handleInitializeFailure;
  private createTappedStream;
  private sessionMeta;
  createSession(cwd?: string, authority?: AcpControlAuthority): Promise<SessionCreateResult>;
  loadSession(sessionId: string, cwd?: string): Promise<SessionLoadResult>;
  loadSessionWithOptions(sessionId: string, cwd?: string, options?: LoadSessionOptions): Promise<SessionLoadResult>;
  resumeSession(sessionId: string, cwd?: string, authority?: AcpControlAuthority): Promise<SessionResumeResult>;
  prompt(sessionId: string, prompt: PromptInput | string, onRequestWritten?: () => Promise<void> | void, onElicitation?: AcpElicitationHandler, onPermissionRequest?: AcpPermissionHandler, authority?: AcpControlAuthority): Promise<PromptResponse>;
  private beginActivePrompt;
  private bindPromptOwner;
  private assertPromptActive;
  private onPromptRequestWritten;
  private clearActivePrompt;
  private normalizePromptForAgent;
  private returnPromptResponseOrPermissionFailure;
  private throwPromptPermissionFailureIfPresent;
  setSessionMode(sessionId: string, modeId: string, authority?: AcpControlAuthority): Promise<void>;
  setSessionConfigOption(sessionId: string, configId: string, value: string, models: SessionModelState | undefined, authority?: AcpControlAuthority): Promise<SetSessionConfigOptionResponse>;
  setSessionModel(sessionId: string, modelId: string, models: SessionModelState | undefined, authority?: AcpControlAuthority): Promise<SetSessionConfigOptionResponse | undefined>;
  private resolveSessionModelId;
  private setSessionModelThroughConfig;
  private setSessionModelThroughLegacyMethod;
  private throwSessionModelError;
  cancel(sessionId: string): Promise<void>;
  closeSession(sessionId: string): Promise<void>;
  listSessions(params?: ListSessionsRequest): Promise<ListSessionsResponse>;
  requestCancelActivePrompt(): Promise<boolean>;
  cancelActivePrompt(waitMs?: number): Promise<PromptResponse | undefined>;
  close(): Promise<void>;
  private finishClose;
  private retireNativeResources;
  private stopIfClosedDuringLaunch;
  private abortActiveElicitation;
  private closeConnection;
  private captureAgentDescendants;
  private terminateAgentProcess;
  private cleanupAgentProcess;
  private endAgentStdin;
  private signalAgentAndDescendants;
  private detachAgentHandles;
  private getConnection;
  private log;
  private captureStartupStderr;
  private summarizeStartupStderr;
  private createStartupFailureWatcher;
  private normalizeInitializeError;
  private selectAuthMethod;
  private inheritedEnvPolicy;
  private readAgentSpecificEnvCredential;
  private selectAgentManagedAuthMethod;
  private isGrokBuildAcpCommand;
  private authenticateIfRequired;
  private handlePermissionRequest;
  private finishPermissionRequest;
  private hasPermissionOwner;
  private handleElicitationRequest;
  private resolveElicitationOwner;
  private resolveElicitationScope;
  private isElicitationSessionCancelling;
  private captureDelegatedRequestOwner;
  private isDelegatedRequestActive;
  private tryHandlePermissionRequestWithHost;
  private hostPermissionDecisionResponse;
  private hostPermissionErrorResponse;
  private resolvePermissionRequestFromMode;
  private explainPermissionRefusal;
  private emitPermissionEscalation;
  private handleModePermissionError;
  private attachAgentLifecycleObservers;
  private attachProcessExitObserver;
  private handleAgentDisconnect;
  private notifyProcessSpawnFailure;
  private notifyProcessExit;
  private logProcessLifecycleError;
  private recordAgentExit;
  private notePromptPermissionFailure;
  private consumePromptPermissionFailure;
  private runConnectionRequest;
  private rejectPendingConnectionRequests;
  private handleReadTextFile;
  private handleWriteTextFile;
  private handleCreateTerminal;
  private runDelegatedOperation;
  private cancellationSignalForSession;
  private takePermissionAbortController;
  private recordPermissionDecision;
  private recordPermissionError;
  private handleSessionUpdate;
  private waitForSessionUpdateDrain;
  waitForSessionUpdatesIdle(options?: {
    idleMs?: number;
    timeoutMs?: number;
  }): Promise<void>;
}
export { AcpControlAuthority as n, AcpClient as t };
//# sourceMappingURL=client-BqZW_W14.d.ts.map