mirror of https://github.com/openclaw/openclaw.git
2070 lines
63 KiB
TypeScript
2070 lines
63 KiB
TypeScript
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 { 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 requireAcpRuntimeBackendMock = vi.fn();
|
|
return {
|
|
listAcpSessionEntriesMock,
|
|
readAcpSessionEntryMock,
|
|
upsertAcpSessionMetaMock,
|
|
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", async (importOriginal) => {
|
|
const actual = await importOriginal<typeof import("../runtime/registry.js")>();
|
|
return {
|
|
...actual,
|
|
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 resetFlowRegistryForTests: typeof import("../../tasks/flow-registry.js").resetFlowRegistryForTests;
|
|
let installInMemoryTaskAndFlowRegistryRuntime: typeof import("../../test-utils/task-flow-registry-runtime.js").installInMemoryTaskAndFlowRegistryRuntime;
|
|
|
|
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<void>): Promise<void> {
|
|
await withTempDir({ prefix: "openclaw-acp-manager-task-" }, async (root) => {
|
|
process.env.OPENCLAW_STATE_DIR = root;
|
|
resetTaskRegistryForTests({ persist: false });
|
|
resetFlowRegistryForTests({ persist: false });
|
|
installInMemoryTaskAndFlowRegistryRuntime();
|
|
try {
|
|
await run(root);
|
|
} finally {
|
|
resetTaskRegistryForTests({ persist: false });
|
|
resetFlowRegistryForTests({ persist: false });
|
|
}
|
|
});
|
|
}
|
|
|
|
async function flushMicrotasks(rounds = 3): Promise<void> {
|
|
for (let index = 0; index < rounds; index += 1) {
|
|
await Promise.resolve();
|
|
}
|
|
}
|
|
|
|
function createRuntime(): {
|
|
runtime: AcpRuntime;
|
|
ensureSession: ReturnType<typeof vi.fn>;
|
|
runTurn: ReturnType<typeof vi.fn>;
|
|
cancel: ReturnType<typeof vi.fn>;
|
|
close: ReturnType<typeof vi.fn>;
|
|
getCapabilities: ReturnType<typeof vi.fn>;
|
|
getStatus: ReturnType<typeof vi.fn>;
|
|
setMode: ReturnType<typeof vi.fn>;
|
|
setConfigOption: ReturnType<typeof vi.fn>;
|
|
} {
|
|
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 cancel = vi.fn(async () => {});
|
|
const close = vi.fn(async () => {});
|
|
const getCapabilities = vi.fn(
|
|
async (): Promise<AcpRuntimeCapabilities> => ({
|
|
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,
|
|
cancel,
|
|
close,
|
|
},
|
|
ensureSession,
|
|
runTurn,
|
|
cancel,
|
|
close,
|
|
getCapabilities,
|
|
getStatus,
|
|
setMode,
|
|
setConfigOption,
|
|
};
|
|
}
|
|
|
|
function readySessionMeta(overrides: Partial<SessionAcpMeta> = {}): 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<AcpSessionRuntimeOptions | undefined> {
|
|
const options: Array<AcpSessionRuntimeOptions | undefined> = [];
|
|
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 () => {
|
|
vi.resetModules();
|
|
({
|
|
AcpSessionManager,
|
|
__testing: { resetAcpSessionManagerForTests },
|
|
} = await import("./manager.js"));
|
|
({ AcpRuntimeError } = await import("../runtime/errors.js"));
|
|
({ findTaskByRunId, resetTaskRegistryForTests } = await import("../../tasks/task-registry.js"));
|
|
({ resetFlowRegistryForTests } = await import("../../tasks/flow-registry.js"));
|
|
({ installInMemoryTaskAndFlowRegistryRuntime } =
|
|
await import("../../test-utils/task-flow-registry-runtime.js"));
|
|
});
|
|
|
|
beforeEach(() => {
|
|
resetAcpSessionManagerForTests();
|
|
vi.useRealTimers();
|
|
hoisted.listAcpSessionEntriesMock.mockReset().mockResolvedValue([]);
|
|
hoisted.readAcpSessionEntryMock.mockReset();
|
|
hoisted.upsertAcpSessionMetaMock.mockReset().mockResolvedValue(null);
|
|
hoisted.requireAcpRuntimeBackendMock.mockReset();
|
|
});
|
|
|
|
afterEach(() => {
|
|
if (ORIGINAL_STATE_DIR === undefined) {
|
|
delete process.env.OPENCLAW_STATE_DIR;
|
|
} else {
|
|
process.env.OPENCLAW_STATE_DIR = ORIGINAL_STATE_DIR;
|
|
}
|
|
resetTaskRegistryForTests({ persist: false });
|
|
resetFlowRegistryForTests({ 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",
|
|
requesterSessionKey: "agent:quant:telegram:quant:direct:822430204",
|
|
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.",
|
|
});
|
|
});
|
|
});
|
|
|
|
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;
|
|
runtimeState.runTurn.mockImplementation(async function* (_input: { requestId: string }) {
|
|
inFlight += 1;
|
|
maxInFlight = Math.max(maxInFlight, inFlight);
|
|
try {
|
|
await sleep(10);
|
|
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",
|
|
});
|
|
const second = manager.runTurn({
|
|
cfg: baseCfg,
|
|
sessionKey: "agent:codex:acp:session-1",
|
|
text: "second",
|
|
mode: "prompt",
|
|
requestId: "r2",
|
|
});
|
|
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<void>((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);
|
|
});
|
|
|
|
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);
|
|
});
|
|
|
|
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);
|
|
});
|
|
|
|
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);
|
|
});
|
|
|
|
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;
|
|
runtimeState.runTurn.mockImplementation(async function* () {
|
|
inFlight += 1;
|
|
maxInFlight = Math.max(maxInFlight, inFlight);
|
|
try {
|
|
await sleep(15);
|
|
yield { type: "done" as const };
|
|
} finally {
|
|
inFlight -= 1;
|
|
}
|
|
});
|
|
|
|
const manager = new AcpSessionManager();
|
|
await 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",
|
|
}),
|
|
]);
|
|
|
|
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("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("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 when reopening a persisted ACP backend session id fails", 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",
|
|
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: "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");
|
|
});
|
|
|
|
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("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<void>((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);
|
|
});
|
|
|
|
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<string, Promise<void>>;
|
|
};
|
|
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("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 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("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("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");
|
|
});
|
|
});
|