import { setTimeout as scheduleNativeTimeout } from "node:timers"; import { setTimeout as sleep } from "node:timers/promises"; import { afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest"; import type { OpenClawConfig } from "../../config/config.js"; import type { AcpSessionRuntimeOptions, SessionAcpMeta } from "../../config/sessions/types.js"; import { resetHeartbeatWakeStateForTests } from "../../infra/heartbeat-wake.js"; import { resetSystemEventsForTest } from "../../infra/system-events.js"; import { withTempDir } from "../../test-helpers/temp-dir.js"; import type { AcpRuntime, AcpRuntimeCapabilities } from "../runtime/types.js"; const hoisted = vi.hoisted(() => { const listAcpSessionEntriesMock = vi.fn(); const readAcpSessionEntryMock = vi.fn(); const upsertAcpSessionMetaMock = vi.fn(); const getAcpRuntimeBackendMock = vi.fn(); const requireAcpRuntimeBackendMock = vi.fn(); return { listAcpSessionEntriesMock, readAcpSessionEntryMock, upsertAcpSessionMetaMock, getAcpRuntimeBackendMock, requireAcpRuntimeBackendMock, }; }); vi.mock("../runtime/session-meta.js", () => ({ listAcpSessionEntries: (params: unknown) => hoisted.listAcpSessionEntriesMock(params), readAcpSessionEntry: (params: unknown) => hoisted.readAcpSessionEntryMock(params), upsertAcpSessionMeta: (params: unknown) => hoisted.upsertAcpSessionMetaMock(params), })); vi.mock("../runtime/registry.js", () => ({ getAcpRuntimeBackend: (backendId?: string) => hoisted.getAcpRuntimeBackendMock(backendId), requireAcpRuntimeBackend: (backendId?: string) => hoisted.requireAcpRuntimeBackendMock(backendId), })); let AcpSessionManager: typeof import("./manager.js").AcpSessionManager; let AcpRuntimeError: typeof import("../runtime/errors.js").AcpRuntimeError; let resetAcpSessionManagerForTests: typeof import("./manager.js").__testing.resetAcpSessionManagerForTests; let findTaskByRunId: typeof import("../../tasks/task-registry.js").findTaskByRunId; let resetTaskRegistryForTests: typeof import("../../tasks/task-registry.js").resetTaskRegistryForTests; let resetTaskFlowRegistryForTests: typeof import("../../tasks/task-flow-registry.js").resetTaskFlowRegistryForTests; let installInMemoryTaskRegistryRuntime: typeof import("../../test-utils/task-registry-runtime.js").installInMemoryTaskRegistryRuntime; let configureTaskFlowRegistryRuntime: typeof import("../../tasks/task-flow-registry.store.js").configureTaskFlowRegistryRuntime; const baseCfg = { acp: { enabled: true, backend: "acpx", dispatch: { enabled: true }, }, } as const; const ORIGINAL_STATE_DIR = process.env.OPENCLAW_STATE_DIR; async function withAcpManagerTaskStateDir(run: (root: string) => Promise): Promise { await withTempDir({ prefix: "openclaw-acp-manager-task-" }, async (root) => { process.env.OPENCLAW_STATE_DIR = root; resetTaskRegistryForTests({ persist: false }); resetTaskFlowRegistryForTests({ persist: false }); installInMemoryTaskRegistryRuntime(); configureTaskFlowRegistryRuntime({ store: { loadSnapshot: () => ({ flows: new Map(), }), saveSnapshot: () => {}, upsertFlow: () => {}, deleteFlow: () => {}, close: () => {}, }, }); try { await run(root); } finally { resetTaskRegistryForTests({ persist: false }); resetTaskFlowRegistryForTests({ persist: false }); } }); } async function flushMicrotasks(rounds = 3): Promise { for (let index = 0; index < rounds; index += 1) { await Promise.resolve(); } } function createDeferred(): { promise: Promise; resolve: () => void } { let resolve!: () => void; const promise = new Promise((next) => { resolve = next; }); return { promise, resolve }; } function createRuntime(): { runtime: AcpRuntime; ensureSession: ReturnType; runTurn: ReturnType; prepareFreshSession: ReturnType; cancel: ReturnType; close: ReturnType; getCapabilities: ReturnType; getStatus: ReturnType; setMode: ReturnType; setConfigOption: ReturnType; } { const ensureSession = vi.fn( async (input: { sessionKey: string; agent: string; mode: "persistent" | "oneshot" }) => ({ sessionKey: input.sessionKey, backend: "acpx", runtimeSessionName: `${input.sessionKey}:${input.mode}:runtime`, }), ); const runTurn = vi.fn(async function* () { yield { type: "done" as const }; }); const prepareFreshSession = vi.fn(async () => {}); const cancel = vi.fn(async () => {}); const close = vi.fn(async () => {}); const getCapabilities = vi.fn( async (): Promise => ({ controls: ["session/set_mode", "session/set_config_option", "session/status"], }), ); const getStatus = vi.fn(async () => ({ summary: "status=alive", details: { status: "alive" }, })); const setMode = vi.fn(async () => {}); const setConfigOption = vi.fn(async () => {}); return { runtime: { ensureSession, runTurn, getCapabilities, getStatus, setMode, setConfigOption, prepareFreshSession, cancel, close, }, ensureSession, runTurn, prepareFreshSession, cancel, close, getCapabilities, getStatus, setMode, setConfigOption, }; } function readySessionMeta(overrides: Partial = {}): SessionAcpMeta { return { backend: "acpx", agent: "codex", runtimeSessionName: "runtime-1", mode: "persistent" as const, state: "idle" as const, lastActivityAt: Date.now(), ...overrides, }; } function extractStatesFromUpserts(): SessionAcpMeta["state"][] { const states: SessionAcpMeta["state"][] = []; for (const [firstArg] of hoisted.upsertAcpSessionMetaMock.mock.calls) { const payload = firstArg as { mutate: ( current: SessionAcpMeta | undefined, entry: { acp?: SessionAcpMeta } | undefined, ) => SessionAcpMeta | null | undefined; }; const current = readySessionMeta(); const next = payload.mutate(current, { acp: current }); if (next?.state) { states.push(next.state); } } return states; } function extractRuntimeOptionsFromUpserts(): Array { const options: Array = []; for (const [firstArg] of hoisted.upsertAcpSessionMetaMock.mock.calls) { const payload = firstArg as { mutate: ( current: SessionAcpMeta | undefined, entry: { acp?: SessionAcpMeta } | undefined, ) => SessionAcpMeta | null | undefined; }; const current = readySessionMeta(); const next = payload.mutate(current, { acp: current }); if (next) { options.push(next.runtimeOptions); } } return options; } describe("AcpSessionManager", () => { beforeAll(async () => { ({ AcpSessionManager, __testing: { resetAcpSessionManagerForTests }, } = await import("./manager.js")); ({ AcpRuntimeError } = await import("../runtime/errors.js")); ({ findTaskByRunId, resetTaskRegistryForTests } = await import("../../tasks/task-registry.js")); ({ resetTaskFlowRegistryForTests } = await import("../../tasks/task-flow-registry.js")); ({ configureTaskFlowRegistryRuntime } = await import("../../tasks/task-flow-registry.store.js")); ({ installInMemoryTaskRegistryRuntime } = await import("../../test-utils/task-registry-runtime.js")); }); beforeEach(() => { resetAcpSessionManagerForTests(); vi.useRealTimers(); hoisted.listAcpSessionEntriesMock.mockReset().mockResolvedValue([]); hoisted.readAcpSessionEntryMock.mockReset(); hoisted.upsertAcpSessionMetaMock.mockReset().mockResolvedValue(null); hoisted.requireAcpRuntimeBackendMock.mockReset(); hoisted.getAcpRuntimeBackendMock.mockReset().mockImplementation((backendId?: string) => { try { return hoisted.requireAcpRuntimeBackendMock(backendId); } catch { return null; } }); }); afterEach(() => { if (ORIGINAL_STATE_DIR === undefined) { delete process.env.OPENCLAW_STATE_DIR; } else { process.env.OPENCLAW_STATE_DIR = ORIGINAL_STATE_DIR; } resetSystemEventsForTest(); resetHeartbeatWakeStateForTests(); resetTaskRegistryForTests({ persist: false }); resetTaskFlowRegistryForTests({ persist: false }); }); it("marks ACP-shaped sessions without metadata as stale", () => { hoisted.readAcpSessionEntryMock.mockReturnValue(null); const manager = new AcpSessionManager(); const resolved = manager.resolveSession({ cfg: baseCfg, sessionKey: "agent:codex:acp:session-1", }); expect(resolved.kind).toBe("stale"); if (resolved.kind !== "stale") { return; } expect(resolved.error.code).toBe("ACP_SESSION_INIT_FAILED"); expect(resolved.error.message).toContain("ACP metadata is missing"); }); it("canonicalizes the main alias before ACP rehydrate after restart", async () => { const runtimeState = createRuntime(); hoisted.requireAcpRuntimeBackendMock.mockReturnValue({ id: "acpx", runtime: runtimeState.runtime, }); hoisted.readAcpSessionEntryMock.mockImplementation((paramsUnknown: unknown) => { const sessionKey = (paramsUnknown as { sessionKey?: string }).sessionKey; if (sessionKey !== "agent:main:main") { return null; } return { sessionKey, storeSessionKey: sessionKey, acp: { ...readySessionMeta(), agent: "main", runtimeSessionName: sessionKey, }, }; }); const manager = new AcpSessionManager(); const cfg = { ...baseCfg, session: { mainKey: "main" }, agents: { list: [{ id: "main", default: true }] }, } as OpenClawConfig; await manager.runTurn({ cfg, sessionKey: "main", text: "after restart", mode: "prompt", requestId: "r-main", }); expect(hoisted.readAcpSessionEntryMock).toHaveBeenCalledWith( expect.objectContaining({ cfg, sessionKey: "agent:main:main", }), ); expect(runtimeState.ensureSession).toHaveBeenCalledWith( expect.objectContaining({ agent: "main", sessionKey: "agent:main:main", }), ); }); it("tracks parented direct ACP turns in the task registry", async () => { await withAcpManagerTaskStateDir(async () => { const runtimeState = createRuntime(); runtimeState.runTurn.mockImplementation(async function* () { yield { type: "text_delta" as const, stream: "output" as const, text: "Write failed: permission denied for /root/oc-acp-write-should-fail.txt.", }; yield { type: "done" as const }; }); hoisted.requireAcpRuntimeBackendMock.mockReturnValue({ id: "acpx", runtime: runtimeState.runtime, }); hoisted.readAcpSessionEntryMock.mockImplementation((paramsUnknown: unknown) => { const sessionKey = (paramsUnknown as { sessionKey?: string }).sessionKey; if (sessionKey === "agent:codex:acp:child-1") { return { sessionKey, storeSessionKey: sessionKey, entry: { sessionId: "child-1", updatedAt: Date.now(), spawnedBy: "agent:quant:telegram:quant:direct:822430204", label: "Quant patch", }, acp: readySessionMeta(), }; } if (sessionKey === "agent:quant:telegram:quant:direct:822430204") { return { sessionKey, storeSessionKey: sessionKey, entry: { sessionId: "parent-1", updatedAt: Date.now(), }, }; } return null; }); const manager = new AcpSessionManager(); await manager.runTurn({ cfg: baseCfg, sessionKey: "agent:codex:acp:child-1", text: "Implement the feature and report back", mode: "prompt", requestId: "direct-parented-run", }); await flushMicrotasks(); expect(findTaskByRunId("direct-parented-run")).toMatchObject({ runtime: "acp", ownerKey: "agent:quant:telegram:quant:direct:822430204", scopeKind: "session", childSessionKey: "agent:codex:acp:child-1", label: "Quant patch", task: "Implement the feature and report back", status: "succeeded", progressSummary: "Write failed: permission denied for /root/oc-acp-write-should-fail.txt.", terminalOutcome: "blocked", terminalSummary: "Permission denied for /root/oc-acp-write-should-fail.txt.", }); }); }, 300_000); it("serializes concurrent turns for the same ACP session", async () => { const runtimeState = createRuntime(); hoisted.requireAcpRuntimeBackendMock.mockReturnValue({ id: "acpx", runtime: runtimeState.runtime, }); hoisted.readAcpSessionEntryMock.mockReturnValue({ sessionKey: "agent:codex:acp:session-1", storeSessionKey: "agent:codex:acp:session-1", acp: readySessionMeta(), }); let inFlight = 0; let maxInFlight = 0; const releaseFirstTurn = createDeferred(); runtimeState.runTurn.mockImplementation(async function* (_input: { requestId: string }) { inFlight += 1; maxInFlight = Math.max(maxInFlight, inFlight); try { if (_input.requestId === "r1") { await releaseFirstTurn.promise; } yield { type: "done" }; } finally { inFlight -= 1; } }); const manager = new AcpSessionManager(); const first = manager.runTurn({ cfg: baseCfg, sessionKey: "agent:codex:acp:session-1", text: "first", mode: "prompt", requestId: "r1", }); await vi.waitFor( () => { expect(runtimeState.runTurn).toHaveBeenCalledTimes(1); }, { interval: 1 }, ); const second = manager.runTurn({ cfg: baseCfg, sessionKey: "agent:codex:acp:session-1", text: "second", mode: "prompt", requestId: "r2", }); await flushMicrotasks(); expect(runtimeState.runTurn).toHaveBeenCalledTimes(1); releaseFirstTurn.resolve(); await Promise.all([first, second]); expect(maxInFlight).toBe(1); expect(runtimeState.runTurn).toHaveBeenCalledTimes(2); }); it("rejects a queued turn promptly when its caller aborts before the actor is free", async () => { const runtimeState = createRuntime(); hoisted.requireAcpRuntimeBackendMock.mockReturnValue({ id: "acpx", runtime: runtimeState.runtime, }); hoisted.readAcpSessionEntryMock.mockReturnValue({ sessionKey: "agent:codex:acp:session-1", storeSessionKey: "agent:codex:acp:session-1", acp: readySessionMeta(), }); let firstTurnStarted = false; let releaseFirstTurn: (() => void) | undefined; runtimeState.runTurn.mockImplementation(async function* (input: { requestId: string }) { if (input.requestId === "r1") { firstTurnStarted = true; await new Promise((resolve) => { releaseFirstTurn = resolve; }); } yield { type: "done" as const }; }); const manager = new AcpSessionManager(); const first = manager.runTurn({ cfg: baseCfg, sessionKey: "agent:codex:acp:session-1", text: "first", mode: "prompt", requestId: "r1", }); await vi.waitFor( () => { expect(firstTurnStarted).toBe(true); }, { interval: 1 }, ); const abortController = new AbortController(); const second = manager.runTurn({ cfg: baseCfg, sessionKey: "agent:codex:acp:session-1", text: "second", mode: "prompt", requestId: "r2", signal: abortController.signal, }); abortController.abort(); const secondOutcome = await Promise.race([ second.then( () => ({ status: "resolved" as const }), (error) => ({ status: "rejected" as const, error }), ), new Promise<{ status: "pending" }>((resolve) => { scheduleNativeTimeout(() => resolve({ status: "pending" }), 100); }), ]); releaseFirstTurn?.(); await first; await vi.waitFor( () => { expect(manager.getObservabilitySnapshot(baseCfg).turns.queueDepth).toBe(0); }, { interval: 1 }, ); expect(secondOutcome.status).toBe("rejected"); if (secondOutcome.status !== "rejected") { return; } expect(secondOutcome.error).toBeInstanceOf(AcpRuntimeError); expect(secondOutcome.error).toMatchObject({ code: "ACP_TURN_FAILED", message: "ACP operation aborted.", }); expect(runtimeState.runTurn).toHaveBeenCalledTimes(1); }); it("times out a hung persistent turn without closing the session and lets queued work continue", async () => { vi.useFakeTimers(); try { const runtimeState = createRuntime(); hoisted.requireAcpRuntimeBackendMock.mockReturnValue({ id: "acpx", runtime: runtimeState.runtime, }); hoisted.readAcpSessionEntryMock.mockReturnValue({ sessionKey: "agent:codex:acp:session-1", storeSessionKey: "agent:codex:acp:session-1", acp: readySessionMeta(), }); let firstTurnStarted = false; runtimeState.runTurn.mockImplementation(async function* (input: { requestId: string }) { if (input.requestId === "r1") { firstTurnStarted = true; await new Promise(() => {}); } yield { type: "done" as const }; }); const manager = new AcpSessionManager(); const cfg = { ...baseCfg, agents: { defaults: { timeoutSeconds: 1, }, }, } as OpenClawConfig; const first = manager.runTurn({ cfg, sessionKey: "agent:codex:acp:session-1", text: "first", mode: "prompt", requestId: "r1", }); void first.catch(() => undefined); await vi.waitFor( () => { expect(firstTurnStarted).toBe(true); }, { interval: 1 }, ); const second = manager.runTurn({ cfg, sessionKey: "agent:codex:acp:session-1", text: "second", mode: "prompt", requestId: "r2", }); await vi.advanceTimersByTimeAsync(3_500); await expect(first).rejects.toMatchObject({ code: "ACP_TURN_FAILED", message: "ACP turn timed out after 1s.", }); await expect(second).resolves.toBeUndefined(); expect(runtimeState.ensureSession).toHaveBeenCalledTimes(1); expect(runtimeState.runTurn).toHaveBeenCalledTimes(2); expect(runtimeState.cancel).toHaveBeenCalledWith( expect.objectContaining({ reason: "turn-timeout", }), ); expect(runtimeState.close).not.toHaveBeenCalled(); expect(manager.getObservabilitySnapshot(cfg)).toMatchObject({ runtimeCache: { activeSessions: 1, }, turns: { active: 0, queueDepth: 0, completed: 1, failed: 1, }, }); const states = extractStatesFromUpserts(); expect(states).toContain("error"); expect(states.at(-1)).toBe("idle"); } finally { vi.useRealTimers(); } }); it("keeps timed-out runtime handles counted until timeout cleanup finishes", async () => { vi.useFakeTimers(); try { const runtimeState = createRuntime(); runtimeState.cancel.mockImplementation(() => new Promise(() => {})); hoisted.requireAcpRuntimeBackendMock.mockReturnValue({ id: "acpx", runtime: runtimeState.runtime, }); hoisted.readAcpSessionEntryMock.mockImplementation((paramsUnknown: unknown) => { const sessionKey = (paramsUnknown as { sessionKey?: string }).sessionKey ?? ""; return { sessionKey, storeSessionKey: sessionKey, acp: { ...readySessionMeta(), runtimeSessionName: `runtime:${sessionKey}`, }, }; }); let firstTurnStarted = false; runtimeState.runTurn.mockImplementation(async function* (input: { requestId: string }) { if (input.requestId === "r1") { firstTurnStarted = true; await new Promise(() => {}); } yield { type: "done" as const }; }); const manager = new AcpSessionManager(); const cfg = { ...baseCfg, acp: { ...baseCfg.acp, maxConcurrentSessions: 1, }, agents: { defaults: { timeoutSeconds: 1, }, }, } as OpenClawConfig; const first = manager.runTurn({ cfg, sessionKey: "agent:codex:acp:session-a", text: "first", mode: "prompt", requestId: "r1", }); void first.catch(() => undefined); await vi.waitFor( () => { expect(firstTurnStarted).toBe(true); }, { interval: 1 }, ); await vi.advanceTimersByTimeAsync(4_500); await expect(first).rejects.toMatchObject({ code: "ACP_TURN_FAILED", message: "ACP turn timed out after 1s.", }); expect(manager.getObservabilitySnapshot(cfg).runtimeCache.activeSessions).toBe(1); await expect( manager.runTurn({ cfg, sessionKey: "agent:codex:acp:session-b", text: "second", mode: "prompt", requestId: "r2", }), ).rejects.toMatchObject({ code: "ACP_SESSION_INIT_FAILED", message: expect.stringContaining("max concurrent sessions"), }); expect(runtimeState.ensureSession).toHaveBeenCalledTimes(1); } finally { vi.useRealTimers(); } }); it("runs turns for different ACP sessions in parallel", async () => { const runtimeState = createRuntime(); hoisted.requireAcpRuntimeBackendMock.mockReturnValue({ id: "acpx", runtime: runtimeState.runtime, }); hoisted.readAcpSessionEntryMock.mockImplementation((paramsUnknown: unknown) => { const sessionKey = (paramsUnknown as { sessionKey?: string }).sessionKey ?? ""; return { sessionKey, storeSessionKey: sessionKey, acp: { ...readySessionMeta(), runtimeSessionName: `runtime:${sessionKey}`, }, }; }); let inFlight = 0; let maxInFlight = 0; const bothTurnsEntered = createDeferred(); runtimeState.runTurn.mockImplementation(async function* () { inFlight += 1; maxInFlight = Math.max(maxInFlight, inFlight); if (inFlight === 2) { bothTurnsEntered.resolve(); } try { await bothTurnsEntered.promise; yield { type: "done" as const }; } finally { inFlight -= 1; } }); const manager = new AcpSessionManager(); await Promise.race([ Promise.all([ manager.runTurn({ cfg: baseCfg, sessionKey: "agent:codex:acp:session-a", text: "first", mode: "prompt", requestId: "r1", }), manager.runTurn({ cfg: baseCfg, sessionKey: "agent:codex:acp:session-b", text: "second", mode: "prompt", requestId: "r2", }), ]), sleep(100).then(() => { throw new Error("ACP sessions did not run in parallel"); }), ]); expect(maxInFlight).toBe(2); }); it("reuses runtime session handles for repeat turns in the same manager process", async () => { const runtimeState = createRuntime(); hoisted.requireAcpRuntimeBackendMock.mockReturnValue({ id: "acpx", runtime: runtimeState.runtime, }); hoisted.readAcpSessionEntryMock.mockReturnValue({ sessionKey: "agent:codex:acp:session-1", storeSessionKey: "agent:codex:acp:session-1", acp: readySessionMeta(), }); const manager = new AcpSessionManager(); await manager.runTurn({ cfg: baseCfg, sessionKey: "agent:codex:acp:session-1", text: "first", mode: "prompt", requestId: "r1", }); await manager.runTurn({ cfg: baseCfg, sessionKey: "agent:codex:acp:session-1", text: "second", mode: "prompt", requestId: "r2", }); expect(runtimeState.ensureSession).toHaveBeenCalledTimes(1); expect(runtimeState.runTurn).toHaveBeenCalledTimes(2); }); it("re-ensures cached runtime handles when the backend reports the session is dead", async () => { const runtimeState = createRuntime(); runtimeState.getStatus .mockResolvedValueOnce({ summary: "status=alive", details: { status: "alive" }, }) .mockResolvedValueOnce({ summary: "status=dead", details: { status: "dead" }, }) .mockResolvedValueOnce({ summary: "status=alive", details: { status: "alive" }, }); hoisted.requireAcpRuntimeBackendMock.mockReturnValue({ id: "acpx", runtime: runtimeState.runtime, }); hoisted.readAcpSessionEntryMock.mockReturnValue({ sessionKey: "agent:codex:acp:session-1", storeSessionKey: "agent:codex:acp:session-1", acp: readySessionMeta(), }); const manager = new AcpSessionManager(); await manager.runTurn({ cfg: baseCfg, sessionKey: "agent:codex:acp:session-1", text: "first", mode: "prompt", requestId: "r1", }); await manager.runTurn({ cfg: baseCfg, sessionKey: "agent:codex:acp:session-1", text: "second", mode: "prompt", requestId: "r2", }); expect(runtimeState.ensureSession).toHaveBeenCalledTimes(2); expect(runtimeState.getStatus).toHaveBeenCalledTimes(3); expect(runtimeState.runTurn).toHaveBeenCalledTimes(2); }); it("re-ensures cached runtime handles when persisted ACP session identity changes", async () => { const runtimeState = createRuntime(); runtimeState.ensureSession .mockResolvedValueOnce({ sessionKey: "agent:codex:acp:session-1", backend: "acpx", runtimeSessionName: "runtime-1", acpxRecordId: "record-1", backendSessionId: "acpx-session-1", agentSessionId: "agent-session-1", }) .mockResolvedValueOnce({ sessionKey: "agent:codex:acp:session-1", backend: "acpx", runtimeSessionName: "runtime-2", acpxRecordId: "record-1", backendSessionId: "acpx-session-2", agentSessionId: "agent-session-2", }); hoisted.requireAcpRuntimeBackendMock.mockReturnValue({ id: "acpx", runtime: runtimeState.runtime, }); let currentMeta = readySessionMeta({ runtimeSessionName: "runtime-1", identity: { state: "resolved", acpxRecordId: "record-1", acpxSessionId: "acpx-session-1", agentSessionId: "agent-session-1", source: "status", lastUpdatedAt: Date.now(), }, }); hoisted.readAcpSessionEntryMock.mockImplementation(() => ({ sessionKey: "agent:codex:acp:session-1", storeSessionKey: "agent:codex:acp:session-1", acp: currentMeta, })); const manager = new AcpSessionManager(); await manager.runTurn({ cfg: baseCfg, sessionKey: "agent:codex:acp:session-1", text: "first", mode: "prompt", requestId: "r1", }); currentMeta = readySessionMeta({ runtimeSessionName: "runtime-2", identity: { state: "resolved", acpxRecordId: "record-1", acpxSessionId: "acpx-session-2", agentSessionId: "agent-session-2", source: "status", lastUpdatedAt: Date.now(), }, }); await manager.runTurn({ cfg: baseCfg, sessionKey: "agent:codex:acp:session-1", text: "second", mode: "prompt", requestId: "r2", }); expect(runtimeState.ensureSession).toHaveBeenCalledTimes(2); expect(runtimeState.runTurn).toHaveBeenCalledTimes(2); }); it("rehydrates runtime handles after a manager restart", async () => { const runtimeState = createRuntime(); hoisted.requireAcpRuntimeBackendMock.mockReturnValue({ id: "acpx", runtime: runtimeState.runtime, }); hoisted.readAcpSessionEntryMock.mockReturnValue({ sessionKey: "agent:codex:acp:session-1", storeSessionKey: "agent:codex:acp:session-1", acp: readySessionMeta(), }); const managerA = new AcpSessionManager(); await managerA.runTurn({ cfg: baseCfg, sessionKey: "agent:codex:acp:session-1", text: "before restart", mode: "prompt", requestId: "r1", }); const managerB = new AcpSessionManager(); await managerB.runTurn({ cfg: baseCfg, sessionKey: "agent:codex:acp:session-1", text: "after restart", mode: "prompt", requestId: "r2", }); expect(runtimeState.ensureSession).toHaveBeenCalledTimes(2); }); it("passes persisted ACP backend session identity back into ensureSession for configured bindings after restart", async () => { const runtimeState = createRuntime(); hoisted.requireAcpRuntimeBackendMock.mockReturnValue({ id: "acpx", runtime: runtimeState.runtime, }); const sessionKey = "agent:codex:acp:binding:demo-binding:default:deadbeef"; hoisted.readAcpSessionEntryMock.mockImplementation((paramsUnknown: unknown) => { const key = (paramsUnknown as { sessionKey?: string }).sessionKey ?? sessionKey; return { sessionKey: key, storeSessionKey: key, acp: { ...readySessionMeta(), runtimeSessionName: key, identity: { state: "resolved", source: "status", acpxSessionId: "acpx-sid-1", lastUpdatedAt: Date.now(), }, }, }; }); const manager = new AcpSessionManager(); await manager.runTurn({ cfg: baseCfg, sessionKey, text: "after restart", mode: "prompt", requestId: "r-binding-restart", }); expect(runtimeState.ensureSession).toHaveBeenCalledWith( expect.objectContaining({ sessionKey, agent: "codex", resumeSessionId: "acpx-sid-1", }), ); }); it("prefers the persisted agent session id when reopening an ACP runtime after restart", async () => { const runtimeState = createRuntime(); hoisted.requireAcpRuntimeBackendMock.mockReturnValue({ id: "acpx", runtime: runtimeState.runtime, }); const sessionKey = "agent:gemini:acp:binding:discord:default:restart"; hoisted.readAcpSessionEntryMock.mockImplementation((paramsUnknown: unknown) => { const key = (paramsUnknown as { sessionKey?: string }).sessionKey ?? sessionKey; return { sessionKey: key, storeSessionKey: key, acp: { ...readySessionMeta(), agent: "gemini", runtimeSessionName: key, identity: { state: "resolved", source: "status", acpxSessionId: "acpx-sid-1", agentSessionId: "gemini-sid-1", lastUpdatedAt: Date.now(), }, }, }; }); const manager = new AcpSessionManager(); await manager.runTurn({ cfg: baseCfg, sessionKey, text: "after restart", mode: "prompt", requestId: "r-binding-restart-gemini", }); expect(runtimeState.ensureSession).toHaveBeenCalledWith( expect.objectContaining({ sessionKey, agent: "gemini", resumeSessionId: "gemini-sid-1", }), ); }); it("passes persisted cwd runtime options into ensureSession after restart", async () => { const runtimeState = createRuntime(); hoisted.requireAcpRuntimeBackendMock.mockReturnValue({ id: "acpx", runtime: runtimeState.runtime, }); const sessionKey = "agent:codex:acp:binding:demo-binding:default:cwd-restart"; hoisted.readAcpSessionEntryMock.mockImplementation((paramsUnknown: unknown) => { const key = (paramsUnknown as { sessionKey?: string }).sessionKey ?? sessionKey; return { sessionKey: key, storeSessionKey: key, acp: { ...readySessionMeta(), cwd: "/workspace/stale", runtimeOptions: { cwd: "/workspace/project", }, }, }; }); const manager = new AcpSessionManager(); await manager.runTurn({ cfg: baseCfg, sessionKey, text: "after restart", mode: "prompt", requestId: "r-binding-restart-cwd", }); expect(runtimeState.ensureSession).toHaveBeenCalledWith( expect.objectContaining({ sessionKey, cwd: "/workspace/project", }), ); }); it("does not resume persisted ACP identity for oneshot sessions after restart", async () => { const runtimeState = createRuntime(); hoisted.requireAcpRuntimeBackendMock.mockReturnValue({ id: "acpx", runtime: runtimeState.runtime, }); const sessionKey = "agent:codex:acp:binding:demo-binding:default:oneshot"; hoisted.readAcpSessionEntryMock.mockImplementation((paramsUnknown: unknown) => { const key = (paramsUnknown as { sessionKey?: string }).sessionKey ?? sessionKey; return { sessionKey: key, storeSessionKey: key, acp: { ...readySessionMeta(), runtimeSessionName: key, mode: "oneshot", identity: { state: "resolved", source: "status", acpxSessionId: "acpx-sid-oneshot", lastUpdatedAt: Date.now(), }, }, }; }); const manager = new AcpSessionManager(); await manager.runTurn({ cfg: baseCfg, sessionKey, text: "after restart", mode: "prompt", requestId: "r-binding-oneshot", }); expect(runtimeState.ensureSession).toHaveBeenCalledTimes(1); const ensureInput = runtimeState.ensureSession.mock.calls[0]?.[0] as | { resumeSessionId?: string; mode?: string } | undefined; expect(ensureInput).toMatchObject({ sessionKey, agent: "codex", mode: "oneshot", }); expect(ensureInput?.resumeSessionId).toBeUndefined(); }); it("falls back to a fresh ensure without reusing stale agent session ids", async () => { const runtimeState = createRuntime(); runtimeState.ensureSession.mockImplementation(async (inputUnknown: unknown) => { const input = inputUnknown as { sessionKey: string; agent: string; mode: "persistent" | "oneshot"; resumeSessionId?: string; }; if (input.resumeSessionId) { throw new AcpRuntimeError( "ACP_SESSION_INIT_FAILED", "failed to resume persisted ACP session", ); } return { sessionKey: input.sessionKey, backend: "acpx", runtimeSessionName: `${input.sessionKey}:${input.mode}:runtime`, backendSessionId: "acpx-sid-fresh", }; }); runtimeState.getStatus.mockResolvedValue({ summary: "status=alive", backendSessionId: "acpx-sid-fresh", details: { status: "alive" }, }); hoisted.requireAcpRuntimeBackendMock.mockReturnValue({ id: "acpx", runtime: runtimeState.runtime, }); const sessionKey = "agent:codex:acp:binding:demo-binding:default:retry-fresh"; let currentMeta: SessionAcpMeta = { ...readySessionMeta(), runtimeSessionName: sessionKey, identity: { state: "resolved", source: "status", acpxSessionId: "acpx-sid-stale", agentSessionId: "agent-sid-stale", lastUpdatedAt: Date.now(), }, }; hoisted.readAcpSessionEntryMock.mockImplementation((paramsUnknown: unknown) => { const key = (paramsUnknown as { sessionKey?: string }).sessionKey ?? sessionKey; return { sessionKey: key, storeSessionKey: key, acp: currentMeta, }; }); hoisted.upsertAcpSessionMetaMock.mockImplementation(async (paramsUnknown: unknown) => { const params = paramsUnknown as { mutate: ( current: SessionAcpMeta | undefined, entry: { acp?: SessionAcpMeta } | undefined, ) => SessionAcpMeta | null | undefined; }; const next = params.mutate(currentMeta, { acp: currentMeta }); if (next) { currentMeta = next; } return { sessionId: "session-1", updatedAt: Date.now(), acp: currentMeta, }; }); const manager = new AcpSessionManager(); await manager.runTurn({ cfg: baseCfg, sessionKey, text: "after restart", mode: "prompt", requestId: "r-binding-retry-fresh", }); expect(runtimeState.ensureSession).toHaveBeenCalledTimes(2); expect(runtimeState.ensureSession.mock.calls[0]?.[0]).toMatchObject({ sessionKey, agent: "codex", resumeSessionId: "agent-sid-stale", }); const retryInput = runtimeState.ensureSession.mock.calls[1]?.[0] as | { resumeSessionId?: string } | undefined; expect(retryInput?.resumeSessionId).toBeUndefined(); const runTurnInput = runtimeState.runTurn.mock.calls[0]?.[0] as | { handle?: { agentSessionId?: string; backendSessionId?: string } } | undefined; expect(runTurnInput?.handle?.backendSessionId).toBe("acpx-sid-fresh"); expect(runTurnInput?.handle?.agentSessionId).toBeUndefined(); expect(currentMeta.identity?.acpxSessionId).toBe("acpx-sid-fresh"); expect(currentMeta.identity?.agentSessionId).toBeUndefined(); }); it("enforces acp.maxConcurrentSessions when opening new runtime handles", async () => { const runtimeState = createRuntime(); hoisted.requireAcpRuntimeBackendMock.mockReturnValue({ id: "acpx", runtime: runtimeState.runtime, }); hoisted.readAcpSessionEntryMock.mockImplementation((paramsUnknown: unknown) => { const sessionKey = (paramsUnknown as { sessionKey?: string }).sessionKey ?? ""; return { sessionKey, storeSessionKey: sessionKey, acp: { ...readySessionMeta(), runtimeSessionName: `runtime:${sessionKey}`, }, }; }); const limitedCfg = { acp: { ...baseCfg.acp, maxConcurrentSessions: 1, }, } as OpenClawConfig; const manager = new AcpSessionManager(); await manager.runTurn({ cfg: limitedCfg, sessionKey: "agent:codex:acp:session-a", text: "first", mode: "prompt", requestId: "r1", }); await expect( manager.runTurn({ cfg: limitedCfg, sessionKey: "agent:codex:acp:session-b", text: "second", mode: "prompt", requestId: "r2", }), ).rejects.toMatchObject({ code: "ACP_SESSION_INIT_FAILED", message: expect.stringContaining("max concurrent sessions"), }); expect(runtimeState.ensureSession).toHaveBeenCalledTimes(1); }); it("enforces acp.maxConcurrentSessions during initializeSession", async () => { const runtimeState = createRuntime(); hoisted.requireAcpRuntimeBackendMock.mockReturnValue({ id: "acpx", runtime: runtimeState.runtime, }); hoisted.upsertAcpSessionMetaMock.mockResolvedValue({ sessionKey: "agent:codex:acp:session-a", storeSessionKey: "agent:codex:acp:session-a", acp: readySessionMeta(), }); const limitedCfg = { acp: { ...baseCfg.acp, maxConcurrentSessions: 1, }, } as OpenClawConfig; const manager = new AcpSessionManager(); await manager.initializeSession({ cfg: limitedCfg, sessionKey: "agent:codex:acp:session-a", agent: "codex", mode: "persistent", }); await expect( manager.initializeSession({ cfg: limitedCfg, sessionKey: "agent:codex:acp:session-b", agent: "codex", mode: "persistent", }), ).rejects.toMatchObject({ code: "ACP_SESSION_INIT_FAILED", message: expect.stringContaining("max concurrent sessions"), }); expect(runtimeState.ensureSession).toHaveBeenCalledTimes(1); }); it("drops cached runtime handles when close tolerates backend-unavailable errors", async () => { const runtimeState = createRuntime(); runtimeState.close.mockRejectedValueOnce( new AcpRuntimeError("ACP_BACKEND_UNAVAILABLE", "runtime temporarily unavailable"), ); hoisted.requireAcpRuntimeBackendMock.mockReturnValue({ id: "acpx", runtime: runtimeState.runtime, }); hoisted.readAcpSessionEntryMock.mockImplementation((paramsUnknown: unknown) => { const sessionKey = (paramsUnknown as { sessionKey?: string }).sessionKey ?? ""; return { sessionKey, storeSessionKey: sessionKey, acp: { ...readySessionMeta(), runtimeSessionName: `runtime:${sessionKey}`, }, }; }); const limitedCfg = { acp: { ...baseCfg.acp, maxConcurrentSessions: 1, }, } as OpenClawConfig; const manager = new AcpSessionManager(); await manager.runTurn({ cfg: limitedCfg, sessionKey: "agent:codex:acp:session-a", text: "first", mode: "prompt", requestId: "r1", }); const closeResult = await manager.closeSession({ cfg: limitedCfg, sessionKey: "agent:codex:acp:session-a", reason: "manual-close", allowBackendUnavailable: true, }); expect(closeResult.runtimeClosed).toBe(false); expect(closeResult.runtimeNotice).toContain("temporarily unavailable"); await expect( manager.runTurn({ cfg: limitedCfg, sessionKey: "agent:codex:acp:session-b", text: "second", mode: "prompt", requestId: "r2", }), ).resolves.toBeUndefined(); expect(runtimeState.ensureSession).toHaveBeenCalledTimes(2); }); it("drops cached runtime handles when close sees a stale acpx process-exit error", async () => { const runtimeState = createRuntime(); runtimeState.close.mockRejectedValueOnce(new Error("acpx exited with code 1")); hoisted.requireAcpRuntimeBackendMock.mockReturnValue({ id: "acpx", runtime: runtimeState.runtime, }); hoisted.readAcpSessionEntryMock.mockImplementation((paramsUnknown: unknown) => { const sessionKey = (paramsUnknown as { sessionKey?: string }).sessionKey ?? ""; return { sessionKey, storeSessionKey: sessionKey, acp: { ...readySessionMeta(), runtimeSessionName: `runtime:${sessionKey}`, }, }; }); const limitedCfg = { acp: { ...baseCfg.acp, maxConcurrentSessions: 1, }, } as OpenClawConfig; const manager = new AcpSessionManager(); await manager.runTurn({ cfg: limitedCfg, sessionKey: "agent:codex:acp:session-a", text: "first", mode: "prompt", requestId: "r1", }); const closeResult = await manager.closeSession({ cfg: limitedCfg, sessionKey: "agent:codex:acp:session-a", reason: "manual-close", allowBackendUnavailable: true, }); expect(closeResult.runtimeClosed).toBe(false); expect(closeResult.runtimeNotice).toBe("acpx exited with code 1"); await expect( manager.runTurn({ cfg: limitedCfg, sessionKey: "agent:codex:acp:session-b", text: "second", mode: "prompt", requestId: "r2", }), ).resolves.toBeUndefined(); expect(runtimeState.ensureSession).toHaveBeenCalledTimes(2); }); it("treats stale session init failures as recoverable during discard resets", async () => { const runtimeState = createRuntime(); runtimeState.ensureSession.mockRejectedValueOnce( new AcpRuntimeError("ACP_SESSION_INIT_FAILED", "Could not initialize ACP session runtime."), ); hoisted.requireAcpRuntimeBackendMock.mockReturnValue({ id: "acpx", runtime: runtimeState.runtime, }); hoisted.readAcpSessionEntryMock.mockReturnValue({ sessionKey: "agent:claude:acp:session-1", storeSessionKey: "agent:claude:acp:session-1", acp: readySessionMeta({ agent: "claude", }), }); const manager = new AcpSessionManager(); const closeResult = await manager.closeSession({ cfg: baseCfg, sessionKey: "agent:claude:acp:session-1", reason: "new-in-place-reset", allowBackendUnavailable: true, discardPersistentState: true, }); expect(closeResult.runtimeClosed).toBe(false); expect(closeResult.runtimeNotice).toBe("Could not initialize ACP session runtime."); expect(runtimeState.prepareFreshSession).toHaveBeenCalledWith({ sessionKey: "agent:claude:acp:session-1", }); }); it("clears persisted resume identity when close discards persistent state", async () => { const runtimeState = createRuntime(); const sessionKey = "agent:claude:acp:binding:discord:default:9373ab192b2317f4"; const entry = { sessionKey, storeSessionKey: sessionKey, acp: readySessionMeta({ agent: "claude", state: "running", lastError: "stale failure", identity: { state: "resolved", acpxRecordId: sessionKey, acpxSessionId: "acpx-session-1", agentSessionId: "agent-session-1", source: "status", lastUpdatedAt: 1, }, }), }; hoisted.requireAcpRuntimeBackendMock.mockReturnValue({ id: "acpx", runtime: runtimeState.runtime, }); hoisted.readAcpSessionEntryMock.mockImplementation(() => entry); hoisted.upsertAcpSessionMetaMock.mockImplementation(async (paramsUnknown: unknown) => { const params = paramsUnknown as { mutate: ( current: SessionAcpMeta | undefined, entry: { acp?: SessionAcpMeta } | undefined, ) => SessionAcpMeta | null | undefined; }; const next = params.mutate(entry.acp, entry); if (next === null) { return null; } if (next) { entry.acp = next; } return entry; }); const manager = new AcpSessionManager(); const result = await manager.closeSession({ cfg: baseCfg, sessionKey, reason: "new-in-place-reset", discardPersistentState: true, clearMeta: false, allowBackendUnavailable: true, }); expect(result.runtimeClosed).toBe(true); expect(entry.acp?.state).toBe("idle"); expect(entry.acp?.lastError).toBeUndefined(); expect(entry.acp?.identity).toMatchObject({ state: "pending", acpxRecordId: sessionKey, source: "status", }); expect(entry.acp?.identity).not.toHaveProperty("acpxSessionId"); expect(entry.acp?.identity).not.toHaveProperty("agentSessionId"); }); it("prepares a fresh persistent session before ensure when metadata has no stable session id", async () => { const runtimeState = createRuntime(); const sessionKey = "agent:claude:acp:binding:discord:default:9373ab192b2317f4"; runtimeState.ensureSession.mockResolvedValue({ sessionKey, backend: "acpx", runtimeSessionName: "runtime-fresh", acpxRecordId: sessionKey, backendSessionId: "acpx-session-fresh", }); hoisted.requireAcpRuntimeBackendMock.mockReturnValue({ id: "acpx", runtime: runtimeState.runtime, }); let currentMeta: SessionAcpMeta = readySessionMeta({ agent: "claude", identity: { state: "pending", acpxRecordId: sessionKey, source: "status", lastUpdatedAt: Date.now(), }, }); hoisted.readAcpSessionEntryMock.mockImplementation((paramsUnknown: unknown) => { const key = (paramsUnknown as { sessionKey?: string }).sessionKey ?? sessionKey; return { sessionKey: key, storeSessionKey: key, acp: currentMeta, }; }); hoisted.upsertAcpSessionMetaMock.mockImplementation(async (paramsUnknown: unknown) => { const params = paramsUnknown as { mutate: ( current: SessionAcpMeta | undefined, entry: { acp?: SessionAcpMeta } | undefined, ) => SessionAcpMeta | null | undefined; }; const next = params.mutate(currentMeta, { acp: currentMeta }); if (next) { currentMeta = next; } return { sessionId: "session-1", updatedAt: Date.now(), acp: currentMeta, }; }); const manager = new AcpSessionManager(); await expect( manager.runTurn({ cfg: baseCfg, sessionKey, text: "who are you?", mode: "prompt", requestId: "r-fresh", }), ).resolves.toBeUndefined(); expect(runtimeState.prepareFreshSession).toHaveBeenCalledWith({ sessionKey, }); expect(runtimeState.ensureSession).toHaveBeenCalledWith( expect.objectContaining({ sessionKey, }), ); expect(runtimeState.prepareFreshSession.mock.invocationCallOrder[0]).toBeLessThan( runtimeState.ensureSession.mock.invocationCallOrder[0], ); }); it("skips runtime re-ensure when discarding a pending persistent session", async () => { const runtimeState = createRuntime(); const sessionKey = "agent:claude:acp:binding:discord:default:9373ab192b2317f4"; hoisted.getAcpRuntimeBackendMock.mockReturnValue({ id: "acpx", runtime: runtimeState.runtime, }); const entry = { sessionKey, storeSessionKey: sessionKey, acp: readySessionMeta({ agent: "claude", identity: { state: "pending", acpxRecordId: sessionKey, source: "ensure", lastUpdatedAt: Date.now(), }, }), }; hoisted.readAcpSessionEntryMock.mockImplementation(() => entry); hoisted.upsertAcpSessionMetaMock.mockImplementation(async (paramsUnknown: unknown) => { const params = paramsUnknown as { mutate: ( current: SessionAcpMeta | undefined, entry: { acp?: SessionAcpMeta } | undefined, ) => SessionAcpMeta | null | undefined; }; const next = params.mutate(entry.acp, entry); if (next === null) { return null; } if (next) { entry.acp = next; } return entry; }); const manager = new AcpSessionManager(); const result = await manager.closeSession({ cfg: baseCfg, sessionKey, reason: "new-in-place-reset", discardPersistentState: true, clearMeta: false, allowBackendUnavailable: true, }); expect(result.runtimeClosed).toBe(false); expect(runtimeState.prepareFreshSession).toHaveBeenCalledWith({ sessionKey, }); expect(runtimeState.ensureSession).not.toHaveBeenCalled(); expect(runtimeState.close).not.toHaveBeenCalled(); expect(entry.acp?.identity).toMatchObject({ state: "pending", acpxRecordId: sessionKey, source: "ensure", }); expect(entry.acp?.identity).not.toHaveProperty("acpxSessionId"); expect(entry.acp?.identity).not.toHaveProperty("agentSessionId"); }); it("evicts idle cached runtimes before enforcing max concurrent limits", async () => { vi.useFakeTimers(); try { vi.setSystemTime(new Date("2026-02-23T00:00:00.000Z")); const runtimeState = createRuntime(); hoisted.requireAcpRuntimeBackendMock.mockReturnValue({ id: "acpx", runtime: runtimeState.runtime, }); hoisted.readAcpSessionEntryMock.mockImplementation((paramsUnknown: unknown) => { const sessionKey = (paramsUnknown as { sessionKey?: string }).sessionKey ?? ""; return { sessionKey, storeSessionKey: sessionKey, acp: { ...readySessionMeta(), runtimeSessionName: `runtime:${sessionKey}`, }, }; }); const cfg = { acp: { ...baseCfg.acp, maxConcurrentSessions: 1, runtime: { ttlMinutes: 0.01, }, }, } as OpenClawConfig; const manager = new AcpSessionManager(); await manager.runTurn({ cfg, sessionKey: "agent:codex:acp:session-a", text: "first", mode: "prompt", requestId: "r1", }); vi.advanceTimersByTime(2_000); await manager.runTurn({ cfg, sessionKey: "agent:codex:acp:session-b", text: "second", mode: "prompt", requestId: "r2", }); expect(runtimeState.ensureSession).toHaveBeenCalledTimes(2); expect(runtimeState.close).toHaveBeenCalledWith( expect.objectContaining({ reason: "idle-evicted", handle: expect.objectContaining({ sessionKey: "agent:codex:acp:session-a", }), }), ); } finally { vi.useRealTimers(); } }); it("tracks ACP turn latency and error-code observability", async () => { const runtimeState = createRuntime(); runtimeState.runTurn.mockImplementation(async function* (input: { requestId: string }) { if (input.requestId === "fail") { throw new Error("runtime exploded"); } yield { type: "done" as const }; }); hoisted.requireAcpRuntimeBackendMock.mockReturnValue({ id: "acpx", runtime: runtimeState.runtime, }); hoisted.readAcpSessionEntryMock.mockImplementation((paramsUnknown: unknown) => { const sessionKey = (paramsUnknown as { sessionKey?: string }).sessionKey ?? ""; return { sessionKey, storeSessionKey: sessionKey, acp: { ...readySessionMeta(), runtimeSessionName: `runtime:${sessionKey}`, }, }; }); const manager = new AcpSessionManager(); await manager.runTurn({ cfg: baseCfg, sessionKey: "agent:codex:acp:session-1", text: "ok", mode: "prompt", requestId: "ok", }); await expect( manager.runTurn({ cfg: baseCfg, sessionKey: "agent:codex:acp:session-1", text: "boom", mode: "prompt", requestId: "fail", }), ).rejects.toMatchObject({ code: "ACP_TURN_FAILED", }); const snapshot = manager.getObservabilitySnapshot(baseCfg); expect(snapshot.turns.completed).toBe(1); expect(snapshot.turns.failed).toBe(1); expect(snapshot.turns.active).toBe(0); expect(snapshot.turns.queueDepth).toBe(0); expect(snapshot.errorsByCode.ACP_TURN_FAILED).toBe(1); }); it("rolls back ensured runtime sessions when metadata persistence fails", async () => { const runtimeState = createRuntime(); hoisted.requireAcpRuntimeBackendMock.mockReturnValue({ id: "acpx", runtime: runtimeState.runtime, }); hoisted.upsertAcpSessionMetaMock.mockRejectedValueOnce(new Error("disk full")); const manager = new AcpSessionManager(); await expect( manager.initializeSession({ cfg: baseCfg, sessionKey: "agent:codex:acp:session-1", agent: "codex", mode: "persistent", }), ).rejects.toThrow("disk full"); expect(runtimeState.close).toHaveBeenCalledWith( expect.objectContaining({ reason: "init-meta-failed", handle: expect.objectContaining({ sessionKey: "agent:codex:acp:session-1", }), }), ); }); it("preempts an active turn on cancel and returns to idle state", async () => { const runtimeState = createRuntime(); hoisted.requireAcpRuntimeBackendMock.mockReturnValue({ id: "acpx", runtime: runtimeState.runtime, }); hoisted.readAcpSessionEntryMock.mockReturnValue({ sessionKey: "agent:codex:acp:session-1", storeSessionKey: "agent:codex:acp:session-1", acp: readySessionMeta(), }); let enteredRun = false; runtimeState.runTurn.mockImplementation(async function* (input: { signal?: AbortSignal }) { enteredRun = true; await new Promise((resolve) => { if (input.signal?.aborted) { resolve(); return; } input.signal?.addEventListener("abort", () => resolve(), { once: true }); }); yield { type: "done" as const, stopReason: "cancel" }; }); const manager = new AcpSessionManager(); const runPromise = manager.runTurn({ cfg: baseCfg, sessionKey: "agent:codex:acp:session-1", text: "long task", mode: "prompt", requestId: "run-1", }); await vi.waitFor( () => { expect(enteredRun).toBe(true); }, { interval: 1 }, ); await manager.cancelSession({ cfg: baseCfg, sessionKey: "agent:codex:acp:session-1", reason: "manual-cancel", }); await runPromise; expect(runtimeState.cancel).toHaveBeenCalledTimes(1); expect(runtimeState.cancel).toHaveBeenCalledWith( expect.objectContaining({ reason: "manual-cancel", }), ); const states = extractStatesFromUpserts(); expect(states).toContain("running"); expect(states).toContain("idle"); expect(states).not.toContain("error"); }); it("cleans actor-tail bookkeeping after session turns complete", async () => { const runtimeState = createRuntime(); hoisted.requireAcpRuntimeBackendMock.mockReturnValue({ id: "acpx", runtime: runtimeState.runtime, }); hoisted.readAcpSessionEntryMock.mockImplementation((paramsUnknown: unknown) => { const sessionKey = (paramsUnknown as { sessionKey?: string }).sessionKey ?? ""; return { sessionKey, storeSessionKey: sessionKey, acp: { ...readySessionMeta(), runtimeSessionName: `runtime:${sessionKey}`, }, }; }); runtimeState.runTurn.mockImplementation(async function* () { yield { type: "done" as const }; }); const manager = new AcpSessionManager(); await manager.runTurn({ cfg: baseCfg, sessionKey: "agent:codex:acp:session-a", text: "first", mode: "prompt", requestId: "r1", }); await manager.runTurn({ cfg: baseCfg, sessionKey: "agent:codex:acp:session-b", text: "second", mode: "prompt", requestId: "r2", }); const internals = manager as unknown as { actorTailBySession: Map>; }; expect(internals.actorTailBySession.size).toBe(0); }); it("surfaces backend failures raised after a done event", async () => { const runtimeState = createRuntime(); hoisted.requireAcpRuntimeBackendMock.mockReturnValue({ id: "acpx", runtime: runtimeState.runtime, }); hoisted.readAcpSessionEntryMock.mockReturnValue({ sessionKey: "agent:codex:acp:session-1", storeSessionKey: "agent:codex:acp:session-1", acp: readySessionMeta(), }); runtimeState.runTurn.mockImplementation(async function* () { yield { type: "done" as const }; throw new Error("acpx exited with code 1"); }); const manager = new AcpSessionManager(); await expect( manager.runTurn({ cfg: baseCfg, sessionKey: "agent:codex:acp:session-1", text: "do work", mode: "prompt", requestId: "run-1", }), ).rejects.toMatchObject({ code: "ACP_TURN_FAILED", message: "acpx exited with code 1", }); const states = extractStatesFromUpserts(); expect(states).toContain("running"); expect(states).toContain("error"); expect(states.at(-1)).toBe("error"); }); it("marks the session as errored when runtime ensure fails before turn start", async () => { const runtimeState = createRuntime(); runtimeState.ensureSession.mockRejectedValue(new Error("acpx exited with code 1")); hoisted.requireAcpRuntimeBackendMock.mockReturnValue({ id: "acpx", runtime: runtimeState.runtime, }); hoisted.readAcpSessionEntryMock.mockReturnValue({ sessionKey: "agent:codex:acp:session-1", storeSessionKey: "agent:codex:acp:session-1", acp: { ...readySessionMeta(), state: "running", }, }); const manager = new AcpSessionManager(); await expect( manager.runTurn({ cfg: baseCfg, sessionKey: "agent:codex:acp:session-1", text: "do work", mode: "prompt", requestId: "run-1", }), ).rejects.toMatchObject({ code: "ACP_SESSION_INIT_FAILED", message: "acpx exited with code 1", }); const states = extractStatesFromUpserts(); expect(states).not.toContain("running"); expect(states.at(-1)).toBe("error"); }); it("retries once with a fresh runtime handle after an early acpx exit", async () => { const runtimeState = createRuntime(); hoisted.requireAcpRuntimeBackendMock.mockReturnValue({ id: "acpx", runtime: runtimeState.runtime, }); hoisted.readAcpSessionEntryMock.mockReturnValue({ sessionKey: "agent:codex:acp:session-1", storeSessionKey: "agent:codex:acp:session-1", acp: readySessionMeta(), }); runtimeState.runTurn .mockImplementationOnce(async function* () { yield { type: "error" as const, message: "acpx exited with code 1", }; }) .mockImplementationOnce(async function* () { yield { type: "done" as const }; }); const manager = new AcpSessionManager(); await expect( manager.runTurn({ cfg: baseCfg, sessionKey: "agent:codex:acp:session-1", text: "do work", mode: "prompt", requestId: "run-1", }), ).resolves.toBeUndefined(); expect(runtimeState.ensureSession).toHaveBeenCalledTimes(2); expect(runtimeState.runTurn).toHaveBeenCalledTimes(2); const states = extractStatesFromUpserts(); expect(states).toContain("running"); expect(states).toContain("idle"); expect(states).not.toContain("error"); }); it("retries once with a fresh runtime handle after an early acpx signal exit", async () => { const runtimeState = createRuntime(); hoisted.requireAcpRuntimeBackendMock.mockReturnValue({ id: "acpx", runtime: runtimeState.runtime, }); hoisted.readAcpSessionEntryMock.mockReturnValue({ sessionKey: "agent:codex:acp:session-1", storeSessionKey: "agent:codex:acp:session-1", acp: readySessionMeta(), }); runtimeState.runTurn .mockImplementationOnce(async function* () { yield { type: "error" as const, message: "acpx exited with signal SIGTERM", }; }) .mockImplementationOnce(async function* () { yield { type: "done" as const }; }); const manager = new AcpSessionManager(); await expect( manager.runTurn({ cfg: baseCfg, sessionKey: "agent:codex:acp:session-1", text: "do work", mode: "prompt", requestId: "run-1", }), ).resolves.toBeUndefined(); expect(runtimeState.ensureSession).toHaveBeenCalledTimes(2); expect(runtimeState.runTurn).toHaveBeenCalledTimes(2); const states = extractStatesFromUpserts(); expect(states).toContain("running"); expect(states).toContain("idle"); expect(states).not.toContain("error"); }); it("retries once with a fresh persistent session after an early missing-session turn failure", async () => { const runtimeState = createRuntime(); hoisted.requireAcpRuntimeBackendMock.mockReturnValue({ id: "acpx", runtime: runtimeState.runtime, }); const sessionKey = "agent:claude:acp:binding:discord:default:retry-no-session"; let currentMeta: SessionAcpMeta = { ...readySessionMeta({ agent: "claude", }), runtimeSessionName: sessionKey, identity: { state: "resolved", source: "status", acpxSessionId: "acpx-sid-stale", lastUpdatedAt: Date.now(), }, }; hoisted.readAcpSessionEntryMock.mockImplementation((paramsUnknown: unknown) => { const key = (paramsUnknown as { sessionKey?: string }).sessionKey ?? sessionKey; return { sessionKey: key, storeSessionKey: key, acp: currentMeta, }; }); hoisted.upsertAcpSessionMetaMock.mockImplementation(async (paramsUnknown: unknown) => { const params = paramsUnknown as { mutate: ( current: SessionAcpMeta | undefined, entry: { acp?: SessionAcpMeta } | undefined, ) => SessionAcpMeta | null | undefined; }; const next = params.mutate(currentMeta, { acp: currentMeta }); if (next) { currentMeta = next; } return { sessionId: "session-1", updatedAt: Date.now(), acp: currentMeta, }; }); runtimeState.ensureSession.mockImplementation(async (inputUnknown: unknown) => { const input = inputUnknown as { sessionKey: string; mode: "persistent" | "oneshot"; resumeSessionId?: string; }; return { sessionKey: input.sessionKey, backend: "acpx", runtimeSessionName: `${input.sessionKey}:${input.mode}:runtime`, backendSessionId: input.resumeSessionId ? "acpx-sid-stale" : "acpx-sid-fresh", }; }); runtimeState.getStatus.mockResolvedValue({ summary: "status=alive", backendSessionId: "acpx-sid-fresh", details: { status: "alive" }, }); runtimeState.runTurn .mockImplementationOnce(async function* () { yield { type: "error" as const, code: "NO_SESSION", message: "Persistent ACP session acpx-sid-stale could not be resumed: Resource not found: acpx-sid-stale", }; }) .mockImplementationOnce(async function* () { yield { type: "done" as const }; }); const manager = new AcpSessionManager(); await expect( manager.runTurn({ cfg: baseCfg, sessionKey, text: "do work", mode: "prompt", requestId: "run-no-session", }), ).resolves.toBeUndefined(); expect(runtimeState.prepareFreshSession).toHaveBeenCalledWith({ sessionKey, }); expect(runtimeState.ensureSession).toHaveBeenCalledTimes(2); expect(runtimeState.ensureSession.mock.calls[0]?.[0]).toMatchObject({ sessionKey, resumeSessionId: "acpx-sid-stale", }); const retryInput = runtimeState.ensureSession.mock.calls[1]?.[0] as | { resumeSessionId?: string } | undefined; expect(retryInput?.resumeSessionId).toBeUndefined(); expect(currentMeta.identity?.acpxSessionId).toBe("acpx-sid-fresh"); expect(currentMeta.identity?.state).toBe("resolved"); const states = extractStatesFromUpserts(); expect(states).toContain("running"); expect(states).toContain("idle"); expect(states).not.toContain("error"); }); it("persists runtime mode changes through setSessionRuntimeMode", async () => { const runtimeState = createRuntime(); hoisted.requireAcpRuntimeBackendMock.mockReturnValue({ id: "acpx", runtime: runtimeState.runtime, }); hoisted.readAcpSessionEntryMock.mockReturnValue({ sessionKey: "agent:codex:acp:session-1", storeSessionKey: "agent:codex:acp:session-1", acp: readySessionMeta(), }); const manager = new AcpSessionManager(); const options = await manager.setSessionRuntimeMode({ cfg: baseCfg, sessionKey: "agent:codex:acp:session-1", runtimeMode: "plan", }); expect(runtimeState.setMode).toHaveBeenCalledWith( expect.objectContaining({ mode: "plan", }), ); expect(options.runtimeMode).toBe("plan"); expect(extractRuntimeOptionsFromUpserts().some((entry) => entry?.runtimeMode === "plan")).toBe( true, ); }); it("reapplies persisted controls on next turn after runtime option updates", async () => { const runtimeState = createRuntime(); hoisted.requireAcpRuntimeBackendMock.mockReturnValue({ id: "acpx", runtime: runtimeState.runtime, }); let currentMeta: SessionAcpMeta = { ...readySessionMeta(), runtimeOptions: { runtimeMode: "plan", }, }; hoisted.readAcpSessionEntryMock.mockImplementation((paramsUnknown: unknown) => { const sessionKey = (paramsUnknown as { sessionKey?: string }).sessionKey ?? "agent:codex:acp:session-1"; return { sessionKey, storeSessionKey: sessionKey, acp: currentMeta, }; }); hoisted.upsertAcpSessionMetaMock.mockImplementation(async (paramsUnknown: unknown) => { const params = paramsUnknown as { mutate: ( current: SessionAcpMeta | undefined, entry: { acp?: SessionAcpMeta } | undefined, ) => SessionAcpMeta | null | undefined; }; const next = params.mutate(currentMeta, { acp: currentMeta }); if (next) { currentMeta = next; } return { sessionId: "session-1", updatedAt: Date.now(), acp: currentMeta, }; }); const manager = new AcpSessionManager(); await manager.setSessionConfigOption({ cfg: baseCfg, sessionKey: "agent:codex:acp:session-1", key: "model", value: "openai-codex/gpt-5.4", }); expect(runtimeState.setMode).not.toHaveBeenCalled(); await manager.runTurn({ cfg: baseCfg, sessionKey: "agent:codex:acp:session-1", text: "do work", mode: "prompt", requestId: "run-1", }); expect(runtimeState.setMode).toHaveBeenCalledWith( expect.objectContaining({ mode: "plan", }), ); }); it("reconciles persisted ACP session identifiers from runtime status after a turn", async () => { const runtimeState = createRuntime(); runtimeState.ensureSession.mockResolvedValue({ sessionKey: "agent:codex:acp:session-1", backend: "acpx", runtimeSessionName: "runtime-1", backendSessionId: "acpx-stale", agentSessionId: "agent-stale", }); runtimeState.getStatus.mockResolvedValue({ summary: "status=alive", backendSessionId: "acpx-fresh", agentSessionId: "agent-fresh", details: { status: "alive" }, }); hoisted.requireAcpRuntimeBackendMock.mockReturnValue({ id: "acpx", runtime: runtimeState.runtime, }); let currentMeta: SessionAcpMeta = { ...readySessionMeta(), identity: { state: "resolved", source: "status", acpxSessionId: "acpx-stale", agentSessionId: "agent-stale", lastUpdatedAt: Date.now(), }, }; hoisted.readAcpSessionEntryMock.mockImplementation((paramsUnknown: unknown) => { const sessionKey = (paramsUnknown as { sessionKey?: string }).sessionKey ?? "agent:codex:acp:session-1"; return { sessionKey, storeSessionKey: sessionKey, acp: currentMeta, }; }); hoisted.upsertAcpSessionMetaMock.mockImplementation(async (paramsUnknown: unknown) => { const params = paramsUnknown as { mutate: ( current: SessionAcpMeta | undefined, entry: { acp?: SessionAcpMeta } | undefined, ) => SessionAcpMeta | null | undefined; }; const next = params.mutate(currentMeta, { acp: currentMeta }); if (next) { currentMeta = next; } return { sessionId: "session-1", updatedAt: Date.now(), acp: currentMeta, }; }); const manager = new AcpSessionManager(); await manager.runTurn({ cfg: baseCfg, sessionKey: "agent:codex:acp:session-1", text: "do work", mode: "prompt", requestId: "run-1", }); expect(runtimeState.getStatus).toHaveBeenCalledTimes(1); expect(currentMeta.identity?.acpxSessionId).toBe("acpx-fresh"); expect(currentMeta.identity?.agentSessionId).toBe("agent-fresh"); }); it("reconciles pending ACP identities during startup scan", async () => { const runtimeState = createRuntime(); runtimeState.getStatus.mockResolvedValue({ summary: "status=alive", acpxRecordId: "acpx-record-1", backendSessionId: "acpx-session-1", agentSessionId: "agent-session-1", details: { status: "alive" }, }); hoisted.requireAcpRuntimeBackendMock.mockReturnValue({ id: "acpx", runtime: runtimeState.runtime, }); let currentMeta: SessionAcpMeta = { ...readySessionMeta(), identity: { state: "pending", source: "ensure", acpxSessionId: "acpx-stale", lastUpdatedAt: Date.now(), }, }; const sessionKey = "agent:codex:acp:session-1"; hoisted.listAcpSessionEntriesMock.mockResolvedValue([ { cfg: baseCfg, storePath: "/tmp/sessions-acp.json", sessionKey, storeSessionKey: sessionKey, entry: { sessionId: "session-1", updatedAt: Date.now(), acp: currentMeta, }, acp: currentMeta, }, ]); hoisted.readAcpSessionEntryMock.mockImplementation((paramsUnknown: unknown) => { const key = (paramsUnknown as { sessionKey?: string }).sessionKey ?? sessionKey; return { sessionKey: key, storeSessionKey: key, acp: currentMeta, }; }); hoisted.upsertAcpSessionMetaMock.mockImplementation(async (paramsUnknown: unknown) => { const params = paramsUnknown as { mutate: ( current: SessionAcpMeta | undefined, entry: { acp?: SessionAcpMeta } | undefined, ) => SessionAcpMeta | null | undefined; }; const next = params.mutate(currentMeta, { acp: currentMeta }); if (next) { currentMeta = next; } return { sessionId: "session-1", updatedAt: Date.now(), acp: currentMeta, }; }); const manager = new AcpSessionManager(); const result = await manager.reconcilePendingSessionIdentities({ cfg: baseCfg }); expect(result).toEqual({ checked: 1, resolved: 1, failed: 0 }); expect(currentMeta.identity?.state).toBe("resolved"); expect(currentMeta.identity?.acpxRecordId).toBe("acpx-record-1"); expect(currentMeta.identity?.acpxSessionId).toBe("acpx-session-1"); expect(currentMeta.identity?.agentSessionId).toBe("agent-session-1"); }); it("skips startup reconcile for pending identities without stable runtime ids", async () => { const runtimeState = createRuntime(); hoisted.requireAcpRuntimeBackendMock.mockReturnValue({ id: "acpx", runtime: runtimeState.runtime, }); const sessionKey = "agent:claude:acp:binding:discord:default:9373ab192b2317f4"; hoisted.listAcpSessionEntriesMock.mockResolvedValue([ { cfg: baseCfg, storePath: "/tmp/sessions-acp.json", sessionKey, storeSessionKey: sessionKey, entry: { sessionId: "session-1", updatedAt: Date.now(), acp: { ...readySessionMeta({ agent: "claude", }), identity: { state: "pending", acpxRecordId: sessionKey, source: "status", lastUpdatedAt: Date.now(), }, }, }, acp: { ...readySessionMeta({ agent: "claude", }), identity: { state: "pending", acpxRecordId: sessionKey, source: "status", lastUpdatedAt: Date.now(), }, }, }, ]); const manager = new AcpSessionManager(); const result = await manager.reconcilePendingSessionIdentities({ cfg: baseCfg }); expect(result).toEqual({ checked: 0, resolved: 0, failed: 0 }); expect(runtimeState.ensureSession).not.toHaveBeenCalled(); expect(runtimeState.getStatus).not.toHaveBeenCalled(); }); it("reconciles prompt-learned agent session IDs even when runtime status omits them", async () => { const runtimeState = createRuntime(); runtimeState.ensureSession.mockResolvedValue({ sessionKey: "agent:gemini:acp:session-1", backend: "acpx", runtimeSessionName: "runtime-3", backendSessionId: "acpx-stale", }); runtimeState.runTurn.mockImplementation(async function* (inputUnknown: unknown) { const input = inputUnknown as { handle: { agentSessionId?: string; }; }; input.handle.agentSessionId = "gemini-session-1"; yield { type: "done" as const }; }); runtimeState.getStatus.mockResolvedValue({ summary: "status=alive", details: { status: "alive" }, }); hoisted.requireAcpRuntimeBackendMock.mockReturnValue({ id: "acpx", runtime: runtimeState.runtime, }); let currentMeta: SessionAcpMeta = { ...readySessionMeta(), agent: "gemini", identity: { state: "pending", source: "ensure", acpxSessionId: "acpx-stale", lastUpdatedAt: Date.now(), }, }; const sessionKey = "agent:gemini:acp:session-1"; hoisted.readAcpSessionEntryMock.mockImplementation((paramsUnknown: unknown) => { const key = (paramsUnknown as { sessionKey?: string }).sessionKey ?? sessionKey; return { sessionKey: key, storeSessionKey: key, acp: currentMeta, }; }); hoisted.upsertAcpSessionMetaMock.mockImplementation(async (paramsUnknown: unknown) => { const params = paramsUnknown as { mutate: ( current: SessionAcpMeta | undefined, entry: { acp?: SessionAcpMeta } | undefined, ) => SessionAcpMeta | null | undefined; }; const next = params.mutate(currentMeta, { acp: currentMeta }); if (next) { currentMeta = next; } return { sessionId: "session-1", updatedAt: Date.now(), acp: currentMeta, }; }); const manager = new AcpSessionManager(); await manager.runTurn({ cfg: baseCfg, sessionKey, text: "learn prompt session", mode: "prompt", requestId: "run-prompt-learned-agent-id", }); expect(currentMeta.identity?.state).toBe("resolved"); expect(currentMeta.identity?.agentSessionId).toBe("gemini-session-1"); expect(currentMeta.identity?.acpxSessionId).toBe("acpx-stale"); }); it("skips startup identity reconciliation for already resolved sessions", async () => { const runtimeState = createRuntime(); hoisted.requireAcpRuntimeBackendMock.mockReturnValue({ id: "acpx", runtime: runtimeState.runtime, }); const sessionKey = "agent:codex:acp:session-1"; const resolvedMeta: SessionAcpMeta = { ...readySessionMeta(), identity: { state: "resolved", source: "status", acpxSessionId: "acpx-sid-1", agentSessionId: "agent-sid-1", lastUpdatedAt: Date.now(), }, }; hoisted.listAcpSessionEntriesMock.mockResolvedValue([ { cfg: baseCfg, storePath: "/tmp/sessions-acp.json", sessionKey, storeSessionKey: sessionKey, entry: { sessionId: "session-1", updatedAt: Date.now(), acp: resolvedMeta, }, acp: resolvedMeta, }, ]); const manager = new AcpSessionManager(); const result = await manager.reconcilePendingSessionIdentities({ cfg: baseCfg }); expect(result).toEqual({ checked: 0, resolved: 0, failed: 0 }); expect(runtimeState.getStatus).not.toHaveBeenCalled(); expect(runtimeState.ensureSession).not.toHaveBeenCalled(); }); it("preserves existing ACP session identifiers when ensure returns none", async () => { const runtimeState = createRuntime(); runtimeState.ensureSession.mockResolvedValue({ sessionKey: "agent:codex:acp:session-1", backend: "acpx", runtimeSessionName: "runtime-2", }); runtimeState.getStatus.mockResolvedValue({ summary: "status=alive", details: { status: "alive" }, }); hoisted.requireAcpRuntimeBackendMock.mockReturnValue({ id: "acpx", runtime: runtimeState.runtime, }); hoisted.readAcpSessionEntryMock.mockReturnValue({ sessionKey: "agent:codex:acp:session-1", storeSessionKey: "agent:codex:acp:session-1", acp: { ...readySessionMeta(), identity: { state: "resolved", source: "status", acpxSessionId: "acpx-stable", agentSessionId: "agent-stable", lastUpdatedAt: Date.now(), }, }, }); const manager = new AcpSessionManager(); const status = await manager.getSessionStatus({ cfg: baseCfg, sessionKey: "agent:codex:acp:session-1", }); expect(status.identity?.acpxSessionId).toBe("acpx-stable"); expect(status.identity?.agentSessionId).toBe("agent-stable"); }); it("applies persisted runtime options before running turns", async () => { const runtimeState = createRuntime(); hoisted.requireAcpRuntimeBackendMock.mockReturnValue({ id: "acpx", runtime: runtimeState.runtime, }); hoisted.readAcpSessionEntryMock.mockReturnValue({ sessionKey: "agent:codex:acp:session-1", storeSessionKey: "agent:codex:acp:session-1", acp: { ...readySessionMeta(), runtimeOptions: { runtimeMode: "plan", model: "openai-codex/gpt-5.4", permissionProfile: "strict", timeoutSeconds: 120, }, }, }); const manager = new AcpSessionManager(); await manager.runTurn({ cfg: baseCfg, sessionKey: "agent:codex:acp:session-1", text: "do work", mode: "prompt", requestId: "run-1", }); expect(runtimeState.setMode).toHaveBeenCalledWith( expect.objectContaining({ mode: "plan", }), ); expect(runtimeState.setConfigOption).toHaveBeenCalledWith( expect.objectContaining({ key: "model", value: "openai-codex/gpt-5.4", }), ); expect(runtimeState.setConfigOption).toHaveBeenCalledWith( expect.objectContaining({ key: "approval_policy", value: "strict", }), ); expect(runtimeState.setConfigOption).toHaveBeenCalledWith( expect.objectContaining({ key: "timeout", value: "120", }), ); }); it("re-ensures runtime handles after cwd runtime option updates", async () => { const runtimeState = createRuntime(); hoisted.requireAcpRuntimeBackendMock.mockReturnValue({ id: "acpx", runtime: runtimeState.runtime, }); const sessionKey = "agent:codex:acp:session-cwd-update"; let currentEntry = { sessionKey, storeSessionKey: sessionKey, acp: readySessionMeta(), }; hoisted.readAcpSessionEntryMock.mockImplementation(() => currentEntry); hoisted.upsertAcpSessionMetaMock.mockImplementation((paramsUnknown: unknown) => { const params = paramsUnknown as { mutate: ( current: SessionAcpMeta | undefined, entry: { acp?: SessionAcpMeta } | undefined, ) => SessionAcpMeta | null | undefined; }; const nextMeta = params.mutate(currentEntry.acp, currentEntry); if (nextMeta === null) { return null; } currentEntry = { ...currentEntry, acp: nextMeta ?? currentEntry.acp, }; return currentEntry; }); const manager = new AcpSessionManager(); await manager.runTurn({ cfg: baseCfg, sessionKey, text: "first", mode: "prompt", requestId: "r1", }); await expect( manager.updateSessionRuntimeOptions({ cfg: baseCfg, sessionKey, patch: { cwd: "/workspace/next" }, }), ).resolves.toEqual({ cwd: "/workspace/next", }); expect(currentEntry.acp.runtimeOptions).toEqual({ cwd: "/workspace/next", }); expect(currentEntry.acp.cwd).toBe("/workspace/next"); await manager.runTurn({ cfg: baseCfg, sessionKey, text: "second", mode: "prompt", requestId: "r2", }); expect(runtimeState.ensureSession).toHaveBeenCalledTimes(2); expect(runtimeState.ensureSession).toHaveBeenNthCalledWith( 2, expect.objectContaining({ sessionKey, cwd: "/workspace/next", }), ); }); it("returns unsupported-control error when backend does not support set_config_option", async () => { const runtimeState = createRuntime(); const unsupportedRuntime: AcpRuntime = { ensureSession: runtimeState.ensureSession as AcpRuntime["ensureSession"], runTurn: runtimeState.runTurn as AcpRuntime["runTurn"], getCapabilities: vi.fn(async () => ({ controls: [] })), cancel: runtimeState.cancel as AcpRuntime["cancel"], close: runtimeState.close as AcpRuntime["close"], }; hoisted.requireAcpRuntimeBackendMock.mockReturnValue({ id: "acpx", runtime: unsupportedRuntime, }); hoisted.readAcpSessionEntryMock.mockReturnValue({ sessionKey: "agent:codex:acp:session-1", storeSessionKey: "agent:codex:acp:session-1", acp: readySessionMeta(), }); const manager = new AcpSessionManager(); await expect( manager.setSessionConfigOption({ cfg: baseCfg, sessionKey: "agent:codex:acp:session-1", key: "model", value: "gpt-5.4", }), ).rejects.toMatchObject({ code: "ACP_BACKEND_UNSUPPORTED_CONTROL", }); }); it("rejects invalid runtime option values before backend controls run", async () => { const runtimeState = createRuntime(); hoisted.requireAcpRuntimeBackendMock.mockReturnValue({ id: "acpx", runtime: runtimeState.runtime, }); hoisted.readAcpSessionEntryMock.mockReturnValue({ sessionKey: "agent:codex:acp:session-1", storeSessionKey: "agent:codex:acp:session-1", acp: readySessionMeta(), }); const manager = new AcpSessionManager(); await expect( manager.setSessionConfigOption({ cfg: baseCfg, sessionKey: "agent:codex:acp:session-1", key: "timeout", value: "not-a-number", }), ).rejects.toMatchObject({ code: "ACP_INVALID_RUNTIME_OPTION", }); expect(runtimeState.setConfigOption).not.toHaveBeenCalled(); await expect( manager.updateSessionRuntimeOptions({ cfg: baseCfg, sessionKey: "agent:codex:acp:session-1", patch: { cwd: "relative/path" }, }), ).rejects.toMatchObject({ code: "ACP_INVALID_RUNTIME_OPTION", }); }); it("can close and clear metadata when backend is unavailable", async () => { hoisted.readAcpSessionEntryMock.mockReturnValue({ sessionKey: "agent:codex:acp:session-1", storeSessionKey: "agent:codex:acp:session-1", acp: readySessionMeta(), }); hoisted.requireAcpRuntimeBackendMock.mockImplementation(() => { throw new AcpRuntimeError( "ACP_BACKEND_MISSING", "ACP runtime backend is not configured. Install and enable the acpx runtime plugin.", ); }); const manager = new AcpSessionManager(); const result = await manager.closeSession({ cfg: baseCfg, sessionKey: "agent:codex:acp:session-1", reason: "manual-close", allowBackendUnavailable: true, clearMeta: true, }); expect(result.runtimeClosed).toBe(false); expect(result.runtimeNotice).toContain("not configured"); expect(result.metaCleared).toBe(true); expect(hoisted.upsertAcpSessionMetaMock).toHaveBeenCalled(); }); it("does not fail reset close recovery when backend lookup also throws", async () => { hoisted.readAcpSessionEntryMock.mockReturnValue({ sessionKey: "agent:codex:acp:session-1", storeSessionKey: "agent:codex:acp:session-1", acp: readySessionMeta(), }); hoisted.requireAcpRuntimeBackendMock.mockImplementation(() => { throw new AcpRuntimeError( "ACP_BACKEND_MISSING", "ACP runtime backend is not configured. Install and enable the acpx runtime plugin.", ); }); const manager = new AcpSessionManager(); const result = await manager.closeSession({ cfg: baseCfg, sessionKey: "agent:codex:acp:session-1", reason: "new-in-place-reset", discardPersistentState: true, allowBackendUnavailable: true, clearMeta: false, }); expect(result.runtimeClosed).toBe(false); expect(result.runtimeNotice).toContain("not configured"); expect(result.metaCleared).toBe(false); }); it("prepares a fresh session during reset recovery even when the backend is unhealthy", async () => { const runtimeState = createRuntime(); hoisted.readAcpSessionEntryMock.mockReturnValue({ sessionKey: "agent:claude:acp:session-1", storeSessionKey: "agent:claude:acp:session-1", acp: readySessionMeta({ agent: "claude", }), }); hoisted.requireAcpRuntimeBackendMock.mockImplementation(() => { throw new AcpRuntimeError( "ACP_BACKEND_UNAVAILABLE", "ACP runtime backend is currently unavailable. Try again in a moment.", ); }); hoisted.getAcpRuntimeBackendMock.mockReturnValue({ id: "acpx", runtime: runtimeState.runtime, }); const manager = new AcpSessionManager(); const result = await manager.closeSession({ cfg: baseCfg, sessionKey: "agent:claude:acp:session-1", reason: "new-in-place-reset", discardPersistentState: true, allowBackendUnavailable: true, clearMeta: false, }); expect(result.runtimeClosed).toBe(false); expect(result.runtimeNotice).toContain("currently unavailable"); expect(runtimeState.prepareFreshSession).toHaveBeenCalledWith({ sessionKey: "agent:claude:acp:session-1", }); }); it("surfaces metadata clear errors during closeSession", async () => { hoisted.readAcpSessionEntryMock.mockReturnValue({ sessionKey: "agent:codex:acp:session-1", storeSessionKey: "agent:codex:acp:session-1", acp: readySessionMeta(), }); hoisted.requireAcpRuntimeBackendMock.mockImplementation(() => { throw new AcpRuntimeError( "ACP_BACKEND_MISSING", "ACP runtime backend is not configured. Install and enable the acpx runtime plugin.", ); }); hoisted.upsertAcpSessionMetaMock.mockRejectedValueOnce(new Error("disk locked")); const manager = new AcpSessionManager(); await expect( manager.closeSession({ cfg: baseCfg, sessionKey: "agent:codex:acp:session-1", reason: "manual-close", allowBackendUnavailable: true, clearMeta: true, }), ).rejects.toThrow("disk locked"); }); });