llm-cli-gateway 2.13.2 → 2.14.0

package/dist/acp/types.js

@@ -57,10 +57,60 @@ export const InitializeRequestSchema = z
     _meta: MetaSchema,
 })
     .passthrough();
+const SessionSubCapabilitySchema = z.object({ _meta: MetaSchema }).passthrough().nullish();
+export const PromptCapabilitiesSchema = z
+    .object({
+    image: z.boolean().optional(),
+    audio: z.boolean().optional(),
+    embeddedContext: z.boolean().optional(),
+    _meta: MetaSchema,
+})
+    .passthrough();
+export const McpCapabilitiesSchema = z
+    .object({
+    http: z.boolean().optional(),
+    sse: z.boolean().optional(),
+    _meta: MetaSchema,
+})
+    .passthrough();
+export const SessionCapabilitiesSchema = z
+    .object({
+    resume: SessionSubCapabilitySchema,
+    list: SessionSubCapabilitySchema,
+    close: SessionSubCapabilitySchema,
+    delete: SessionSubCapabilitySchema,
+    additionalDirectories: SessionSubCapabilitySchema,
+    _meta: MetaSchema,
+})
+    .passthrough();
+export const AgentAuthCapabilitiesSchema = z
+    .object({
+    logout: z.object({ _meta: MetaSchema }).passthrough().nullish(),
+    _meta: MetaSchema,
+})
+    .passthrough();
+export const AgentCapabilitiesSchema = z
+    .object({
+    loadSession: z.boolean().optional(),
+    promptCapabilities: PromptCapabilitiesSchema.optional(),
+    mcpCapabilities: McpCapabilitiesSchema.optional(),
+    sessionCapabilities: SessionCapabilitiesSchema.optional(),
+    auth: AgentAuthCapabilitiesSchema.optional(),
+    _meta: MetaSchema,
+})
+    .passthrough();
+export const AuthMethodSchema = z
+    .object({
+    id: z.string().optional(),
+    name: z.string().optional(),
+    description: z.string().nullish(),
+    _meta: MetaSchema,
+})
+    .passthrough();
 export const InitializeResponseSchema = z
     .object({
     protocolVersion: ProtocolVersionSchema,
-    agentCapabilities: z.record(z.unknown()).optional(),
+    agentCapabilities: AgentCapabilitiesSchema.optional(),
     agentInfo: z
         .object({
         name: z.string().optional(),
@@ -68,10 +118,51 @@ export const InitializeResponseSchema = z
     })
         .passthrough()
         .optional(),
-    authMethods: z.array(z.record(z.unknown())).optional(),
+    authMethods: z.array(AuthMethodSchema).optional(),
     _meta: MetaSchema,
 })
     .passthrough();
+export const BASELINE_ACP_METHODS = [
+    "session/new",
+    "session/prompt",
+    "session/cancel",
+    "session/update",
+];
+function subCapabilityPresent(value) {
+    return value !== null && value !== undefined && typeof value === "object";
+}
+export function deriveAcpMethodAvailability(init) {
+    const methods = new Set(BASELINE_ACP_METHODS);
+    const caps = init.agentCapabilities;
+    if (caps?.loadSession === true) {
+        methods.add("session/load");
+    }
+    const sc = caps?.sessionCapabilities;
+    if (sc) {
+        if (subCapabilityPresent(sc.resume))
+            methods.add("session/resume");
+        if (subCapabilityPresent(sc.list))
+            methods.add("session/list");
+        if (subCapabilityPresent(sc.close))
+            methods.add("session/close");
+        if (subCapabilityPresent(sc.delete))
+            methods.add("session/delete");
+    }
+    if (Array.isArray(init.authMethods) && init.authMethods.length > 0) {
+        methods.add("authenticate");
+    }
+    return methods;
+}
+export function sessionResponseMethods(response) {
+    const methods = new Set();
+    if (response.modes !== null && response.modes !== undefined) {
+        methods.add("session/set_mode");
+    }
+    if (response.configOptions !== null && response.configOptions !== undefined) {
+        methods.add("session/set_config_option");
+    }
+    return methods;
+}
 export const McpServerSchema = z.record(z.unknown());
 export const SessionNewRequestSchema = z
     .object({
@@ -83,7 +174,8 @@ export const SessionNewRequestSchema = z
 export const SessionNewResponseSchema = z
     .object({
     sessionId: SessionIdSchema,
-    modes: z.record(z.unknown()).optional(),
+    modes: z.record(z.unknown()).nullish(),
+    configOptions: z.array(z.record(z.unknown())).nullish(),
     _meta: MetaSchema,
 })
     .passthrough();
@@ -97,7 +189,124 @@ export const SessionLoadRequestSchema = z
     .passthrough();
 export const SessionLoadResponseSchema = z
     .object({
-    modes: z.record(z.unknown()).optional(),
+    modes: z.record(z.unknown()).nullish(),
+    configOptions: z.array(z.record(z.unknown())).nullish(),
+    _meta: MetaSchema,
+})
+    .passthrough();
+export const SessionResumeRequestSchema = z
+    .object({
+    sessionId: SessionIdSchema,
+    cwd: z.string().min(1),
+    mcpServers: z.array(McpServerSchema).default([]),
+    _meta: MetaSchema,
+})
+    .passthrough();
+export const SessionResumeResponseSchema = z
+    .object({
+    modes: z.record(z.unknown()).nullish(),
+    configOptions: z.array(z.record(z.unknown())).nullish(),
+    _meta: MetaSchema,
+})
+    .passthrough();
+export const SessionModeSchema = z
+    .object({
+    id: z.string().min(1),
+    name: z.string().min(1),
+    description: z.string().nullish(),
+    _meta: MetaSchema,
+})
+    .passthrough();
+export const SessionModeStateSchema = z
+    .object({
+    currentModeId: z.string().min(1),
+    availableModes: z.array(SessionModeSchema),
+    _meta: MetaSchema,
+})
+    .passthrough();
+export const SessionConfigSelectValueSchema = z
+    .object({
+    value: z.string().min(1),
+    label: z.string().nullish(),
+    description: z.string().nullish(),
+    _meta: MetaSchema,
+})
+    .passthrough();
+export const SessionConfigOptionSchema = z.discriminatedUnion("type", [
+    z
+        .object({
+        type: z.literal("select"),
+        id: z.string().min(1),
+        name: z.string().min(1),
+        description: z.string().nullish(),
+        category: z.string().nullish(),
+        currentValue: z.string().min(1),
+        options: z.array(SessionConfigSelectValueSchema),
+        _meta: MetaSchema,
+    })
+        .passthrough(),
+    z
+        .object({
+        type: z.literal("boolean"),
+        id: z.string().min(1),
+        name: z.string().min(1),
+        description: z.string().nullish(),
+        category: z.string().nullish(),
+        currentValue: z.boolean(),
+        _meta: MetaSchema,
+    })
+        .passthrough(),
+]);
+export const SessionInfoSchema = z
+    .object({
+    sessionId: SessionIdSchema,
+    cwd: z.string().min(1),
+    additionalDirectories: z.array(z.string()).optional(),
+    title: z.string().nullish(),
+    updatedAt: z.string().nullish(),
+    _meta: MetaSchema,
+})
+    .passthrough();
+export const ListSessionsRequestSchema = z
+    .object({
+    cursor: z.string().nullish(),
+    _meta: MetaSchema,
+})
+    .passthrough();
+export const ListSessionsResponseSchema = z
+    .object({
+    sessions: z.array(SessionInfoSchema),
+    nextCursor: z.string().nullish(),
+    _meta: MetaSchema,
+})
+    .passthrough();
+export const CloseSessionRequestSchema = z
+    .object({ sessionId: SessionIdSchema, _meta: MetaSchema })
+    .passthrough();
+export const CloseSessionResponseSchema = z.object({ _meta: MetaSchema }).passthrough();
+export const DeleteSessionRequestSchema = z
+    .object({ sessionId: SessionIdSchema, _meta: MetaSchema })
+    .passthrough();
+export const DeleteSessionResponseSchema = z.object({ _meta: MetaSchema }).passthrough();
+export const SetSessionModeRequestSchema = z
+    .object({
+    sessionId: SessionIdSchema,
+    modeId: z.string().min(1),
+    _meta: MetaSchema,
+})
+    .passthrough();
+export const SetSessionModeResponseSchema = z.object({ _meta: MetaSchema }).passthrough();
+export const SetSessionConfigOptionRequestSchema = z
+    .object({
+    sessionId: SessionIdSchema,
+    configId: z.string().min(1),
+    value: z.string().min(1),
+    _meta: MetaSchema,
+})
+    .passthrough();
+export const SetSessionConfigOptionResponseSchema = z
+    .object({
+    configOptions: z.array(SessionConfigOptionSchema),
     _meta: MetaSchema,
 })
     .passthrough();
@@ -184,6 +393,13 @@ const UsageUpdate = z
     _meta: MetaSchema,
 })
     .passthrough();
+const ConfigOptionUpdate = z
+    .object({
+    sessionUpdate: z.literal("config_option_update"),
+    configOptions: z.array(SessionConfigOptionSchema),
+    _meta: MetaSchema,
+})
+    .passthrough();
 const KNOWN_UPDATE_SCHEMAS = {
     user_message_chunk: MessageChunkUpdate("user_message_chunk"),
     agent_message_chunk: MessageChunkUpdate("agent_message_chunk"),
@@ -193,6 +409,7 @@ const KNOWN_UPDATE_SCHEMAS = {
     plan: PlanUpdate,
     available_commands_update: AvailableCommandsUpdate,
     current_mode_update: CurrentModeUpdate,
+    config_option_update: ConfigOptionUpdate,
     usage_update: UsageUpdate,
 };
 export const SessionUpdateSchema = z
@@ -227,7 +444,6 @@ export const KNOWN_SESSION_UPDATE_VARIANTS = [
     "available_commands_update",
     "current_mode_update",
     "config_option_update",
-    "session_info_update",
     "usage_update",
 ];
 export function isUnknownSessionUpdate(update) {
@@ -333,3 +549,24 @@ export function parseWriteTextFileRequest(value, provider) {
         provider,
     });
 }
+export function parseSessionResumeResponse(value, provider) {
+    return parseAcp(SessionResumeResponseSchema, value, { method: "session/resume", provider });
+}
+export function parseListSessionsResponse(value, provider) {
+    return parseAcp(ListSessionsResponseSchema, value, { method: "session/list", provider });
+}
+export function parseCloseSessionResponse(value, provider) {
+    return parseAcp(CloseSessionResponseSchema, value, { method: "session/close", provider });
+}
+export function parseDeleteSessionResponse(value, provider) {
+    return parseAcp(DeleteSessionResponseSchema, value, { method: "session/delete", provider });
+}
+export function parseSetSessionModeResponse(value, provider) {
+    return parseAcp(SetSessionModeResponseSchema, value, { method: "session/set_mode", provider });
+}
+export function parseSetSessionConfigOptionResponse(value, provider) {
+    return parseAcp(SetSessionConfigOptionResponseSchema, value, {
+        method: "session/set_config_option",
+        provider,
+    });
+}

package/dist/async-job-manager.d.ts

@@ -5,6 +5,14 @@ import { type FlightRecorderLike } from "./flight-recorder.js";
 import type { ValidationRunStore } from "./job-store.js";
 import { type ApiProvider, type ApiRequest, type ApiUsage } from "./api-provider.js";
 import { type JobLimitsConfig } from "./config.js";
+export interface LeaseRuntimeConfig {
+    instanceHeartbeatMs: number;
+    instanceLeaseTtlMs: number;
+    httpJobGraceMs: number;
+    orphanSweepIntervalMs: number;
+    instanceGcMs: number;
+    role?: string;
+}
 export declare function extractApiHttpStatus(error: unknown): number | null;
 export declare function extractApiErrorBody(error: unknown): string | undefined;
 export type LlmCli = "claude" | "codex" | "gemini" | "grok" | "mistral" | "devin" | "cursor";
@@ -69,6 +77,8 @@ export interface AsyncJobResult extends AsyncJobSnapshot {
     responseId?: string | null;
     model?: string;
     errorBody?: string;
+    providerSessionId?: string;
+    stopReason?: string;
 }
 export interface StartJobOptions {
     cwd?: string;
@@ -100,7 +110,34 @@ export declare class AsyncJobManager {
     private readonly limiter;
     private readonly completedJobMemoryTtlMs;
     private readonly maxJobOutputBytes;
-    constructor(logger?: Logger, onJobComplete?: ((cli: JobProvider, durationMs: number, success: boolean) => void) | undefined, store?: JobStore | null, flightRecorder?: FlightRecorderLike, limits?: JobLimitsConfig);
+    private readonly instanceId;
+    private readonly hostname;
+    private readonly instancePid;
+    private readonly lease;
+    private heartbeatTimer;
+    private sweepTimer;
+    private durableAdmission;
+    private consecutiveHeartbeatFailures;
+    private skipSweepThisCycle;
+    private nextHeartbeatExpectedAt;
+    private disposed;
+    private readonly pendingWrites;
+    constructor(logger?: Logger, onJobComplete?: ((cli: JobProvider, durationMs: number, success: boolean) => void) | undefined, store?: JobStore | null, flightRecorder?: FlightRecorderLike, limits?: JobLimitsConfig, _deprecatedOwnsOrphanRecovery?: boolean, leaseConfig?: LeaseRuntimeConfig);
+    canAdmitDurableJobs(): boolean;
+    private assertDurableAdmission;
+    private trackPendingWrite;
+    dispose(opts?: {
+        timeoutMs?: number;
+    }): Promise<void>;
+    getInstanceId(): string;
+    private startHeartbeat;
+    private onHeartbeatTick;
+    runOrphanSweepNow(): void;
+    private startReaper;
+    private runOrphanSweep;
+    private confirmLiveProcessCandidates;
+    private recordStartOrFailClosed;
+    private markRunningDurable;
     private buildOrphanFlightResult;
     checkStalledJobs(now?: number): void;
     hasStore(): boolean;