mirror of
https://github.com/getpaseo/paseo.git
synced 2026-11-17 05:45:07 +00:00
Compare commits
1
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
eabbd3d97c |
@@ -20,6 +20,10 @@ import {
|
||||
type ManagedAgent,
|
||||
} from "./agent-manager.js";
|
||||
import { AgentStorage, parseStoredAgentRecord } from "./agent-storage.js";
|
||||
import { AgentTurnStartCanceledError } from "./agent-sdk-types.js";
|
||||
import { ForegroundPromptStart } from "./agent-run-state.js";
|
||||
import { CodexAppServerAgentSession } from "./providers/codex-app-server-agent.js";
|
||||
import { createFakeCodexAppServer } from "./providers/codex/test-utils/fake-app-server.js";
|
||||
import { InMemoryAgentTimelineStore } from "./agent-timeline-store.js";
|
||||
import { limitAgentTimelineItemContent } from "./agent-timeline-content.js";
|
||||
import { buildStoredAgentPayload, toAgentPayload } from "./agent-projections.js";
|
||||
@@ -1210,7 +1214,7 @@ test("starts its own turn when the previous turn fails to start under a steer se
|
||||
);
|
||||
|
||||
startHeld.resolve();
|
||||
await expect(second).resolves.toEqual({ disposition: "turn_started" });
|
||||
await expect(second).resolves.toMatchObject({ disposition: "turn_started" });
|
||||
await vi.waitFor(() => expect(session.startPrompts).toEqual(["FIRST", "SECOND"]));
|
||||
expect(session.interruptCount).toBe(0);
|
||||
} finally {
|
||||
@@ -9749,6 +9753,464 @@ test("streamAgent clears pending run when startTurn fails before a turn id exist
|
||||
);
|
||||
});
|
||||
|
||||
test("canceling a pending Codex start settles as canceled without accepting its prompt", async () => {
|
||||
const workdir = mkdtempSync(join(tmpdir(), "agent-manager-codex-cold-cancel-"));
|
||||
const threadLoaded = deferred<{ data: string[] }>();
|
||||
const appServer = createFakeCodexAppServer({ "thread/loaded/list": () => threadLoaded.promise });
|
||||
class ColdStartClient extends TestAgentClient {
|
||||
override async createSession(config: AgentSessionConfig): Promise<AgentSession> {
|
||||
return new CodexAppServerAgentSession(config, null, logger, async () => appServer.child);
|
||||
}
|
||||
}
|
||||
const manager = new AgentManager({
|
||||
clients: { codex: new ColdStartClient() },
|
||||
registry: new AgentStorage(join(workdir, "agents"), logger),
|
||||
logger,
|
||||
});
|
||||
const events: AgentStreamEvent[] = [];
|
||||
manager.subscribe((event) => {
|
||||
if (event.type === "agent_stream") events.push(event.event);
|
||||
});
|
||||
try {
|
||||
const agent = await manager.createAgent({ provider: "codex", cwd: workdir }, undefined, {
|
||||
workspaceId: undefined,
|
||||
});
|
||||
// Drain the stream: a fresh Codex agent has no session handle for runAgent before its first turn.
|
||||
const senderStart = new ForegroundPromptStart(agent.id);
|
||||
const firstRun = drainAsyncGenerator(
|
||||
manager.streamAgent(
|
||||
agent.id,
|
||||
"Canceled prompt",
|
||||
{ clientMessageId: "canceled-prompt" },
|
||||
senderStart,
|
||||
),
|
||||
);
|
||||
void firstRun.catch(() => undefined);
|
||||
await appServer.waitForRequest("thread/loaded/list");
|
||||
const senderRejection = expect(senderStart.started).rejects.toThrow(
|
||||
"its prompt was not delivered",
|
||||
);
|
||||
const cancel = manager.cancelAgentRun(agent.id);
|
||||
await new Promise((resolve) => setTimeout(resolve, 0));
|
||||
threadLoaded.resolve({ data: ["thread-1"] });
|
||||
await expect(cancel).resolves.toEqual({ status: "settled" });
|
||||
await expect(firstRun).resolves.toBeUndefined();
|
||||
await senderRejection;
|
||||
expect(manager.getAgent(agent.id)).toMatchObject({ lifecycle: "idle", lastError: undefined });
|
||||
expect(manager.hasInFlightRun(agent.id)).toBe(false);
|
||||
expect(events.map((event) => event.type)).toEqual(["timeline", "turn_canceled"]);
|
||||
// The canceled attempt stays in history like a rejected one, without being delivered.
|
||||
expect(manager.getTimeline(agent.id)).toEqual([
|
||||
{
|
||||
type: "user_message",
|
||||
text: "Canceled prompt",
|
||||
clientMessageId: "canceled-prompt",
|
||||
messageId: "canceled-prompt",
|
||||
},
|
||||
]);
|
||||
expect(appServer.requests().some((request) => request.method === "turn/start")).toBe(false);
|
||||
|
||||
const nextRun = manager.runAgent(agent.id, "Next prompt", { clientMessageId: "next-prompt" });
|
||||
await appServer.waitForRequest("turn/start");
|
||||
appServer.startsTurn({ threadId: "thread-1", turnId: "next-turn" });
|
||||
appServer.completeTurn();
|
||||
await expect(nextRun).resolves.toMatchObject({ canceled: false });
|
||||
appServer.assertNoErrors();
|
||||
} finally {
|
||||
threadLoaded.resolve({ data: ["thread-1"] });
|
||||
manager.prepareForShutdown();
|
||||
await Promise.all(manager.listAgents().map((agent) => manager.closeAgent(agent.id)));
|
||||
await manager.flushForShutdown();
|
||||
rmSync(workdir, { recursive: true, force: true });
|
||||
}
|
||||
});
|
||||
|
||||
test("stopping a Codex replacement of a stalled start clears replacement activity", async () => {
|
||||
const workdir = mkdtempSync(join(tmpdir(), "agent-manager-codex-replacement-cancel-"));
|
||||
const firstLoaded = deferred<{ data: string[] }>();
|
||||
const firstInterruptRequested = deferred<void>();
|
||||
const replacementLoaded = deferred<{ data: string[] }>();
|
||||
const replacementEntered = deferred<void>();
|
||||
let loadCount = 0;
|
||||
const appServer = createFakeCodexAppServer({
|
||||
"thread/loaded/list": () => {
|
||||
loadCount += 1;
|
||||
if (loadCount === 1) return firstLoaded.promise;
|
||||
replacementEntered.resolve();
|
||||
return replacementLoaded.promise;
|
||||
},
|
||||
});
|
||||
class ColdStartSession extends CodexAppServerAgentSession {
|
||||
override async interrupt(): Promise<void> {
|
||||
const interruption = super.interrupt();
|
||||
firstInterruptRequested.resolve();
|
||||
await interruption;
|
||||
}
|
||||
}
|
||||
class ColdStartClient extends TestAgentClient {
|
||||
override async createSession(config: AgentSessionConfig): Promise<AgentSession> {
|
||||
return new ColdStartSession(config, null, logger, async () => appServer.child);
|
||||
}
|
||||
}
|
||||
const manager = new AgentManager({
|
||||
clients: { codex: new ColdStartClient() },
|
||||
registry: new AgentStorage(join(workdir, "agents"), logger),
|
||||
logger,
|
||||
rescueTimeouts: { interruptSessionMs: 10 },
|
||||
});
|
||||
try {
|
||||
const agent = await manager.createAgent({ provider: "codex", cwd: workdir }, undefined, {
|
||||
workspaceId: undefined,
|
||||
});
|
||||
const firstRun = drainAsyncGenerator(manager.streamAgent(agent.id, "Original prompt"));
|
||||
await appServer.waitForRequest("thread/loaded/list");
|
||||
const replacement = manager.replaceAgentRun(agent.id, "Replacement prompt");
|
||||
await firstInterruptRequested.promise;
|
||||
firstLoaded.resolve({ data: ["thread-1"] });
|
||||
const replacementStream = await replacement;
|
||||
await expect(firstRun).resolves.toBeUndefined();
|
||||
expect(manager.getAgent(agent.id)?.lifecycle).toBe("running");
|
||||
const replacementEvent = replacementStream.next();
|
||||
await replacementEntered.promise;
|
||||
const cancel = manager.cancelAgentRun(agent.id);
|
||||
await new Promise((resolve) => setTimeout(resolve, 0));
|
||||
replacementLoaded.resolve({ data: ["thread-1"] });
|
||||
await expect(cancel).resolves.toEqual({ status: "settled" });
|
||||
await expect(replacementEvent).resolves.toMatchObject({
|
||||
value: { type: "turn_canceled" },
|
||||
});
|
||||
await expect(replacementStream.next()).resolves.toMatchObject({ done: true });
|
||||
expect(manager.hasInFlightRun(agent.id)).toBe(false);
|
||||
expect(manager.getAgent(agent.id)?.lifecycle).toBe("idle");
|
||||
expect(appServer.requests().some((request) => request.method === "turn/start")).toBe(false);
|
||||
appServer.assertNoErrors();
|
||||
} finally {
|
||||
firstLoaded.resolve({ data: ["thread-1"] });
|
||||
replacementLoaded.resolve({ data: ["thread-1"] });
|
||||
manager.prepareForShutdown();
|
||||
await Promise.all(manager.listAgents().map((agent) => manager.closeAgent(agent.id)));
|
||||
await manager.flushForShutdown();
|
||||
rmSync(workdir, { recursive: true, force: true });
|
||||
}
|
||||
});
|
||||
|
||||
test("a stalled Codex start canceled by its replacement rejects its sender's start wait", async () => {
|
||||
const workdir = mkdtempSync(join(tmpdir(), "agent-manager-codex-replaced-start-wait-"));
|
||||
const firstLoaded = deferred<{ data: string[] }>();
|
||||
const firstInterruptRequested = deferred<void>();
|
||||
let loadCount = 0;
|
||||
const appServer = createFakeCodexAppServer({
|
||||
"thread/loaded/list": () => {
|
||||
loadCount += 1;
|
||||
return loadCount === 1 ? firstLoaded.promise : { data: ["thread-1"] };
|
||||
},
|
||||
});
|
||||
class ColdStartSession extends CodexAppServerAgentSession {
|
||||
override async interrupt(): Promise<void> {
|
||||
const interruption = super.interrupt();
|
||||
firstInterruptRequested.resolve();
|
||||
await interruption;
|
||||
}
|
||||
}
|
||||
class ColdStartClient extends TestAgentClient {
|
||||
override async createSession(config: AgentSessionConfig): Promise<AgentSession> {
|
||||
return new ColdStartSession(config, null, logger, async () => appServer.child);
|
||||
}
|
||||
}
|
||||
const manager = new AgentManager({
|
||||
clients: { codex: new ColdStartClient() },
|
||||
registry: new AgentStorage(join(workdir, "agents"), logger),
|
||||
logger,
|
||||
rescueTimeouts: { interruptSessionMs: 10 },
|
||||
});
|
||||
try {
|
||||
const agent = await manager.createAgent({ provider: "codex", cwd: workdir }, undefined, {
|
||||
workspaceId: undefined,
|
||||
});
|
||||
const firstStart = new ForegroundPromptStart(agent.id);
|
||||
const secondStart = new ForegroundPromptStart(agent.id);
|
||||
const firstRun = drainAsyncGenerator(
|
||||
manager.streamAgent(agent.id, "First prompt", undefined, firstStart),
|
||||
);
|
||||
await appServer.waitForRequest("thread/loaded/list");
|
||||
const firstWait = firstStart.started;
|
||||
const replacement = manager.replaceAgentRun(agent.id, "Second prompt", undefined, secondStart);
|
||||
await firstInterruptRequested.promise;
|
||||
firstLoaded.resolve({ data: ["thread-1"] });
|
||||
const replacementStream = await replacement;
|
||||
await expect(firstRun).resolves.toBeUndefined();
|
||||
|
||||
const secondWait = secondStart.started;
|
||||
const replacementDrained = drainAsyncGenerator(replacementStream);
|
||||
await appServer.waitForRequest("turn/start");
|
||||
appServer.startsTurn({ threadId: "thread-1", turnId: "second-turn" });
|
||||
await expect(secondWait).resolves.toBeUndefined();
|
||||
await expect(firstWait).rejects.toThrow("its prompt was not delivered");
|
||||
appServer.completeTurn();
|
||||
await replacementDrained;
|
||||
expect(appServer.requests().filter((request) => request.method === "turn/start")).toEqual([
|
||||
expect.objectContaining({
|
||||
params: expect.objectContaining({
|
||||
input: [expect.objectContaining({ text: "Second prompt" })],
|
||||
}),
|
||||
}),
|
||||
]);
|
||||
appServer.assertNoErrors();
|
||||
} finally {
|
||||
firstLoaded.resolve({ data: ["thread-1"] });
|
||||
manager.prepareForShutdown();
|
||||
await Promise.all(manager.listAgents().map((agent) => manager.closeAgent(agent.id)));
|
||||
await manager.flushForShutdown();
|
||||
rmSync(workdir, { recursive: true, force: true });
|
||||
}
|
||||
});
|
||||
|
||||
test("a sender's start wait follows its prompt across a stale-session retry", async () => {
|
||||
const workdir = mkdtempSync(join(tmpdir(), "agent-manager-stale-start-wait-"));
|
||||
const releaseStart = deferred<void>();
|
||||
class StaleStartSession extends TestAgentSession {
|
||||
override async startTurn(): Promise<{ turnId: string }> {
|
||||
await releaseStart.promise;
|
||||
throw new StaleProviderSessionError("stale-bridge");
|
||||
}
|
||||
}
|
||||
class StaleStartClient extends ResumeTrackingTestAgentClient {
|
||||
override async createSession(config: AgentSessionConfig): Promise<AgentSession> {
|
||||
return new StaleStartSession(config);
|
||||
}
|
||||
}
|
||||
const client = new StaleStartClient();
|
||||
const storage = new AgentStorage(join(workdir, "agents"), logger);
|
||||
const manager = new AgentManager({ clients: { codex: client }, registry: storage, logger });
|
||||
const startedTurns: AgentStreamEvent[] = [];
|
||||
manager.subscribe((event) => {
|
||||
if (event.type === "agent_stream" && event.event.type === "turn_started") {
|
||||
startedTurns.push(event.event);
|
||||
}
|
||||
});
|
||||
try {
|
||||
const agent = await manager.createAgent({ provider: "codex", cwd: workdir }, undefined, {
|
||||
workspaceId: undefined,
|
||||
});
|
||||
const senderWait = dispatchStarted(
|
||||
await startAgentRun(manager, agent.id, "Retry this prompt", logger, {
|
||||
runOptions: { clientMessageId: "stale-start-wait" },
|
||||
}),
|
||||
);
|
||||
releaseStart.resolve();
|
||||
await client.waitForRetryStart();
|
||||
await manager.waitForAgentEvent(agent.id);
|
||||
expect(client.resumeOverrides).toHaveLength(1);
|
||||
expect(startedTurns).toHaveLength(1);
|
||||
expect(manager.getTimeline(agent.id).filter((item) => item.type === "user_message")).toEqual([
|
||||
expect.objectContaining({ text: "Retry this prompt", clientMessageId: "stale-start-wait" }),
|
||||
]);
|
||||
await expect(senderWait).resolves.toBeUndefined();
|
||||
} finally {
|
||||
releaseStart.resolve();
|
||||
manager.prepareForShutdown();
|
||||
await Promise.all(manager.listAgents().map((agent) => manager.closeAgent(agent.id)));
|
||||
await manager.flushForShutdown();
|
||||
rmSync(workdir, { recursive: true, force: true });
|
||||
}
|
||||
});
|
||||
|
||||
test("a sender's start wait follows its prompt when the session is stale before the wait begins", async () => {
|
||||
const workdir = mkdtempSync(join(tmpdir(), "agent-manager-immediate-stale-start-"));
|
||||
class StaleStartSession extends TestAgentSession {
|
||||
override async startTurn(): Promise<{ turnId: string }> {
|
||||
throw new StaleProviderSessionError("stale-bridge");
|
||||
}
|
||||
}
|
||||
class StaleStartClient extends ResumeTrackingTestAgentClient {
|
||||
override async createSession(config: AgentSessionConfig): Promise<AgentSession> {
|
||||
return new StaleStartSession(config);
|
||||
}
|
||||
}
|
||||
const client = new StaleStartClient();
|
||||
const storage = new AgentStorage(join(workdir, "agents"), logger);
|
||||
const manager = new AgentManager({ clients: { codex: client }, registry: storage, logger });
|
||||
try {
|
||||
const agent = await manager.createAgent({ provider: "codex", cwd: workdir }, undefined, {
|
||||
workspaceId: undefined,
|
||||
});
|
||||
const dispatch = await startAgentRun(manager, agent.id, "Retry this prompt", logger, {
|
||||
runOptions: { clientMessageId: "immediate-stale-start" },
|
||||
});
|
||||
// The stale start has failed and been cleared before the sender begins waiting.
|
||||
await new Promise((resolve) => setTimeout(resolve, 0));
|
||||
expect(manager.hasInFlightRun(agent.id)).toBe(false);
|
||||
await expect(dispatchStarted(dispatch)).resolves.toBeUndefined();
|
||||
await client.waitForRetryStart();
|
||||
expect(manager.getTimeline(agent.id).filter((item) => item.type === "user_message")).toEqual([
|
||||
expect.objectContaining({
|
||||
text: "Retry this prompt",
|
||||
clientMessageId: "immediate-stale-start",
|
||||
}),
|
||||
]);
|
||||
} finally {
|
||||
manager.prepareForShutdown();
|
||||
await Promise.all(manager.listAgents().map((agent) => manager.closeAgent(agent.id)));
|
||||
await manager.flushForShutdown();
|
||||
rmSync(workdir, { recursive: true, force: true });
|
||||
}
|
||||
});
|
||||
|
||||
test.each(["reload", "retry", "stale retry"])(
|
||||
"a sender's start wait rejects when its stale-session %s fails",
|
||||
async (failure) => {
|
||||
const workdir = mkdtempSync(join(tmpdir(), "agent-manager-stale-start-failure-"));
|
||||
const releaseStart = deferred<void>();
|
||||
class StaleStartSession extends TestAgentSession {
|
||||
override async startTurn(): Promise<{ turnId: string }> {
|
||||
await releaseStart.promise;
|
||||
throw new StaleProviderSessionError("stale-bridge");
|
||||
}
|
||||
}
|
||||
class FailedRetrySession extends TestAgentSession {
|
||||
override async startTurn(): Promise<{ turnId: string }> {
|
||||
if (failure === "stale retry") throw new StaleProviderSessionError("retry-bridge");
|
||||
throw new Error("retry failed");
|
||||
}
|
||||
}
|
||||
class FailedRetryClient extends TestAgentClient {
|
||||
override async createSession(config: AgentSessionConfig): Promise<AgentSession> {
|
||||
return new StaleStartSession(config);
|
||||
}
|
||||
override async resumeSession(): Promise<AgentSession> {
|
||||
if (failure === "reload") throw new Error("reload failed");
|
||||
return new FailedRetrySession({ provider: "codex", cwd: workdir });
|
||||
}
|
||||
}
|
||||
const manager = new AgentManager({ clients: { codex: new FailedRetryClient() }, logger });
|
||||
try {
|
||||
const agent = await manager.createAgent({ provider: "codex", cwd: workdir }, undefined, {
|
||||
workspaceId: undefined,
|
||||
});
|
||||
const senderWait = dispatchStarted(
|
||||
await startAgentRun(manager, agent.id, "Retry this prompt", logger),
|
||||
);
|
||||
const rejection = expect(senderWait).rejects.toThrow(
|
||||
failure === "retry" ? "retry failed" : "is stale after its plugin reloaded",
|
||||
);
|
||||
releaseStart.resolve();
|
||||
await rejection;
|
||||
} finally {
|
||||
releaseStart.resolve();
|
||||
manager.prepareForShutdown();
|
||||
await Promise.all(manager.listAgents().map((agent) => manager.closeAgent(agent.id)));
|
||||
await manager.flushForShutdown();
|
||||
rmSync(workdir, { recursive: true, force: true });
|
||||
}
|
||||
},
|
||||
);
|
||||
|
||||
test("a sender's start wait rejects when Stop cancels its pending stale-session retry", async () => {
|
||||
const workdir = mkdtempSync(join(tmpdir(), "agent-manager-stale-retry-stop-"));
|
||||
const releaseStart = deferred<void>();
|
||||
const retryEntered = deferred<void>();
|
||||
const retryCanceled = deferred<void>();
|
||||
class StaleStartSession extends TestAgentSession {
|
||||
override async startTurn(): Promise<{ turnId: string }> {
|
||||
await releaseStart.promise;
|
||||
throw new StaleProviderSessionError("stale-bridge");
|
||||
}
|
||||
}
|
||||
class CanceledRetrySession extends TestAgentSession {
|
||||
override async startTurn(): Promise<{ turnId: string }> {
|
||||
retryEntered.resolve();
|
||||
await retryCanceled.promise;
|
||||
throw new AgentTurnStartCanceledError();
|
||||
}
|
||||
override async interrupt(): Promise<void> {
|
||||
retryCanceled.resolve();
|
||||
}
|
||||
}
|
||||
class RetryClient extends TestAgentClient {
|
||||
override async createSession(config: AgentSessionConfig): Promise<AgentSession> {
|
||||
return new StaleStartSession(config);
|
||||
}
|
||||
override async resumeSession(): Promise<AgentSession> {
|
||||
return new CanceledRetrySession({ provider: "codex", cwd: workdir });
|
||||
}
|
||||
}
|
||||
const manager = new AgentManager({ clients: { codex: new RetryClient() }, logger });
|
||||
try {
|
||||
const agent = await manager.createAgent({ provider: "codex", cwd: workdir }, undefined, {
|
||||
workspaceId: undefined,
|
||||
});
|
||||
const senderWait = dispatchStarted(
|
||||
await startAgentRun(manager, agent.id, "Retry this prompt", logger),
|
||||
);
|
||||
const rejection = expect(senderWait).rejects.toThrow("its prompt was not delivered");
|
||||
releaseStart.resolve();
|
||||
await retryEntered.promise;
|
||||
await expect(manager.cancelAgentRun(agent.id)).resolves.toEqual({ status: "settled" });
|
||||
await rejection;
|
||||
expect(manager.getAgent(agent.id)?.lifecycle).toBe("idle");
|
||||
expect(manager.getTimeline(agent.id)).toEqual([]);
|
||||
} finally {
|
||||
releaseStart.resolve();
|
||||
retryCanceled.resolve();
|
||||
manager.prepareForShutdown();
|
||||
await Promise.all(manager.listAgents().map((agent) => manager.closeAgent(agent.id)));
|
||||
await manager.flushForShutdown();
|
||||
rmSync(workdir, { recursive: true, force: true });
|
||||
}
|
||||
});
|
||||
|
||||
test("a sender's start wait never adopts an unlinked run after a stale start", async () => {
|
||||
const workdir = mkdtempSync(join(tmpdir(), "agent-manager-unlinked-start-"));
|
||||
const releaseStart = deferred<void>();
|
||||
const staleError = new StaleProviderSessionError("stale-bridge");
|
||||
class StaleStartSession extends TestAgentSession {
|
||||
override async startTurn(): Promise<{ turnId: string }> {
|
||||
await releaseStart.promise;
|
||||
throw staleError;
|
||||
}
|
||||
}
|
||||
class RetryClient extends TestAgentClient {
|
||||
override async createSession(config: AgentSessionConfig): Promise<AgentSession> {
|
||||
return new StaleStartSession(config);
|
||||
}
|
||||
}
|
||||
const manager = new AgentManager({ clients: { codex: new RetryClient() }, logger });
|
||||
try {
|
||||
const agent = await manager.createAgent({ provider: "codex", cwd: workdir }, undefined, {
|
||||
workspaceId: undefined,
|
||||
});
|
||||
const senderStart = new ForegroundPromptStart(agent.id);
|
||||
const firstRun = drainAsyncGenerator(
|
||||
manager.streamAgent(agent.id, "First prompt", undefined, senderStart),
|
||||
);
|
||||
const firstFailure = expect(firstRun).rejects.toBe(staleError);
|
||||
const rejection = expect(senderStart.started).rejects.toThrow(staleError.message);
|
||||
releaseStart.resolve();
|
||||
await firstFailure;
|
||||
try {
|
||||
await manager.reloadAgentSession(agent.id);
|
||||
const otherStart = new ForegroundPromptStart(agent.id);
|
||||
const otherRun = drainAsyncGenerator(
|
||||
manager.streamAgent(agent.id, "Another sender", undefined, otherStart),
|
||||
);
|
||||
await expect(otherStart.started).resolves.toBeUndefined();
|
||||
await otherRun;
|
||||
} finally {
|
||||
senderStart.end();
|
||||
}
|
||||
await rejection;
|
||||
expect(manager.getTimeline(agent.id).filter((item) => item.type === "user_message")).toEqual(
|
||||
[],
|
||||
);
|
||||
} finally {
|
||||
releaseStart.resolve();
|
||||
manager.prepareForShutdown();
|
||||
await Promise.all(manager.listAgents().map((agent) => manager.closeAgent(agent.id)));
|
||||
await manager.flushForShutdown();
|
||||
rmSync(workdir, { recursive: true, force: true });
|
||||
}
|
||||
});
|
||||
|
||||
test("acknowledged cancellation settles a pending run before it has a turn id", async () => {
|
||||
const workdir = mkdtempSync(join(tmpdir(), "agent-manager-cancel-pending-start-"));
|
||||
const startEntered = deferred<void>();
|
||||
@@ -15071,3 +15533,11 @@ test("plugin instructions are recomputed for each launch without changing saved
|
||||
expect(client.resumeOverrides.at(-1)?.daemonAppendSystemPrompt).toBe("Daemon");
|
||||
expect((await storage.get(snapshot.id))?.config?.systemPrompt).toBe("Saved");
|
||||
});
|
||||
|
||||
function dispatchStarted(dispatch: Awaited<ReturnType<typeof startAgentRun>>): Promise<void> {
|
||||
if (dispatch.disposition !== "turn_started") {
|
||||
throw new Error(`Expected a started turn, got ${dispatch.disposition}`);
|
||||
}
|
||||
void dispatch.started.catch(() => undefined);
|
||||
return dispatch.started;
|
||||
}
|
||||
|
||||
@@ -29,6 +29,7 @@ import { z } from "zod";
|
||||
import type { TerminalManager } from "../../terminal/terminal-manager.js";
|
||||
|
||||
import {
|
||||
AgentTurnStartCanceledError,
|
||||
getAgentStreamEventTurnId,
|
||||
type AgentCapabilityFlags,
|
||||
type AgentClient,
|
||||
@@ -92,6 +93,7 @@ import {
|
||||
import { limitAgentTimelineItemContent } from "./agent-timeline-content.js";
|
||||
import {
|
||||
AgentRunState,
|
||||
type ForegroundPromptStart,
|
||||
type ForegroundTurnWaiter,
|
||||
type PendingForegroundRun,
|
||||
} from "./agent-run-state.js";
|
||||
@@ -3143,7 +3145,7 @@ export class AgentManager {
|
||||
pendingRun: PendingForegroundRun;
|
||||
prompt: AgentPromptInput;
|
||||
options?: AgentRunOptions;
|
||||
}): Promise<string> {
|
||||
}): Promise<string | null> {
|
||||
const { agent, agentId, pendingRun, prompt, options } = params;
|
||||
try {
|
||||
const result = await agent.session.startTurn(prompt, options);
|
||||
@@ -3152,11 +3154,32 @@ export class AgentManager {
|
||||
}
|
||||
return result.turnId;
|
||||
} catch (error) {
|
||||
if (error instanceof AgentTurnStartCanceledError) {
|
||||
if (!pendingRun.settled) {
|
||||
if (options?.clientMessageId) {
|
||||
this.recordSubmittedPrompt(agent, prompt, options.clientMessageId, "rejected", {
|
||||
messageId: options.clientMessageId,
|
||||
});
|
||||
}
|
||||
await this.handleStreamEvent(agent, {
|
||||
type: "turn_canceled",
|
||||
provider: agent.provider,
|
||||
reason: "interrupted",
|
||||
});
|
||||
this.finalizeForegroundTurn(agent);
|
||||
this.runs.settleForegroundRun(agentId, pendingRun.token);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
if (pendingRun.settled) {
|
||||
throw error;
|
||||
}
|
||||
if (isStaleProviderSessionError(error)) {
|
||||
this.runs.settleForegroundStart(pendingRun, { status: "failed", error: error.message });
|
||||
this.runs.settleForegroundStart(pendingRun, {
|
||||
status: "failed",
|
||||
error: error.message,
|
||||
stale: true,
|
||||
});
|
||||
agent.pendingReplacement = false;
|
||||
if (!agent.activeForegroundTurnId) agent.lifecycle = "idle";
|
||||
this.runs.settleForegroundRun(agentId, pendingRun.token);
|
||||
@@ -3212,15 +3235,17 @@ export class AgentManager {
|
||||
agentId: string,
|
||||
prompt: AgentPromptInput,
|
||||
options?: AgentRunOptions,
|
||||
promptStart?: ForegroundPromptStart,
|
||||
): AsyncGenerator<AgentStreamEvent> {
|
||||
await this.ensureInteractiveSession(agentId);
|
||||
yield* this.streamAgent(agentId, prompt, options);
|
||||
yield* this.streamAgent(agentId, prompt, options, promptStart);
|
||||
}
|
||||
|
||||
private async *streamAfterRuntimeCollection(
|
||||
agentId: string,
|
||||
prompt: AgentPromptInput,
|
||||
options?: AgentRunOptions,
|
||||
promptStart?: ForegroundPromptStart,
|
||||
): AsyncGenerator<AgentStreamEvent> {
|
||||
await this.waitForAgentClose(agentId);
|
||||
await ensureAgentLoaded(agentId, {
|
||||
@@ -3228,19 +3253,20 @@ export class AgentManager {
|
||||
agentStorage: this.requireRegistry(),
|
||||
logger: this.logger,
|
||||
});
|
||||
yield* this.streamAgent(agentId, prompt, options);
|
||||
yield* this.streamAgent(agentId, prompt, options, promptStart);
|
||||
}
|
||||
|
||||
streamAgent(
|
||||
agentId: string,
|
||||
prompt: AgentPromptInput,
|
||||
options?: AgentRunOptions,
|
||||
promptStart?: ForegroundPromptStart,
|
||||
): AsyncGenerator<AgentStreamEvent> {
|
||||
if (this.collectingRuntimes.has(agentId) || (!this.agents.has(agentId) && this.registry))
|
||||
return this.streamAfterRuntimeCollection(agentId, prompt, options);
|
||||
return this.streamAfterRuntimeCollection(agentId, prompt, options, promptStart);
|
||||
const existingAgent = this.requireSessionAgent(agentId);
|
||||
if (this.historySessions.has(existingAgent.session))
|
||||
return this.streamAfterHistoryLoad(agentId, prompt, options);
|
||||
return this.streamAfterHistoryLoad(agentId, prompt, options, promptStart);
|
||||
this.logger.trace(
|
||||
{
|
||||
agentId,
|
||||
@@ -3275,9 +3301,10 @@ export class AgentManager {
|
||||
agent.lastError = undefined;
|
||||
|
||||
const pendingRun = this.runs.createPendingRun(agentId);
|
||||
promptStart?.bind(pendingRun);
|
||||
|
||||
const streamForwarder = async function* streamForwarder(this: AgentManager) {
|
||||
let turnId: string;
|
||||
let turnId: string | null;
|
||||
let turnStream: ReturnType<AgentRunState["createTurnStream"]> | null = null;
|
||||
turnId = await this.startPendingForegroundTurn({
|
||||
agent,
|
||||
@@ -3286,6 +3313,15 @@ export class AgentManager {
|
||||
prompt,
|
||||
options,
|
||||
});
|
||||
if (turnId === null) {
|
||||
const canceledEvent: AgentStreamEvent = {
|
||||
type: "turn_canceled",
|
||||
provider: agent.provider,
|
||||
reason: "interrupted",
|
||||
};
|
||||
yield canceledEvent;
|
||||
return;
|
||||
}
|
||||
|
||||
if (isReplacement) {
|
||||
agent.pendingReplacement = false;
|
||||
@@ -3440,9 +3476,10 @@ export class AgentManager {
|
||||
agentId: string,
|
||||
prompt: AgentPromptInput,
|
||||
options?: AgentRunOptions,
|
||||
promptStart?: ForegroundPromptStart,
|
||||
): Promise<AsyncGenerator<AgentStreamEvent>> {
|
||||
this.requireSessionAgent(agentId);
|
||||
return this.replaceRunInForegroundLane(agentId, prompt, options);
|
||||
return this.replaceRunInForegroundLane(agentId, prompt, options, promptStart);
|
||||
}
|
||||
|
||||
async steerAgentRun(
|
||||
@@ -3483,6 +3520,7 @@ export class AgentManager {
|
||||
agentId: string,
|
||||
prompt: AgentPromptInput,
|
||||
options?: AgentSteerOptions,
|
||||
promptStart?: ForegroundPromptStart,
|
||||
): Promise<ActiveTurnSteerDispatchResult> {
|
||||
// A turn that is still starting has no id to steer yet. Replacing it would drop its
|
||||
// prompt, so wait until it is accepted (or fails) and steer the turn it became.
|
||||
@@ -3530,6 +3568,7 @@ export class AgentManager {
|
||||
expectedTurnId,
|
||||
prompt,
|
||||
stripSteerOptions(options),
|
||||
promptStart,
|
||||
),
|
||||
};
|
||||
}
|
||||
@@ -3595,9 +3634,10 @@ export class AgentManager {
|
||||
expectedTurnId: string,
|
||||
prompt: AgentPromptInput,
|
||||
options?: AgentRunOptions,
|
||||
promptStart?: ForegroundPromptStart,
|
||||
): Promise<AsyncGenerator<AgentStreamEvent>> {
|
||||
this.assertSteerAdmissionOwnsTurn(agent, expectedTurnId);
|
||||
return this.replaceRunInForegroundLane(agent.id, prompt, options, (live) =>
|
||||
return this.replaceRunInForegroundLane(agent.id, prompt, options, promptStart, (live) =>
|
||||
this.assertSteerAdmissionOwnsTurn(live, expectedTurnId),
|
||||
);
|
||||
}
|
||||
@@ -3610,12 +3650,13 @@ export class AgentManager {
|
||||
agentId: string,
|
||||
prompt: AgentPromptInput,
|
||||
options: AgentRunOptions | undefined,
|
||||
promptStart?: ForegroundPromptStart,
|
||||
assertAdmission?: (agent: ActiveManagedAgent) => void,
|
||||
): Promise<AsyncGenerator<AgentStreamEvent>> {
|
||||
// Replacements queue in arrival order; each one holds the foreground lane only while
|
||||
// it cancels and reserves, so Stop is never stuck behind a replacement that is waiting.
|
||||
return this.runQueuedMutation(this.replacementMutationTails, agentId, () =>
|
||||
this.replaceRunWhenAdmitted(agentId, prompt, options, assertAdmission),
|
||||
this.replaceRunWhenAdmitted(agentId, prompt, options, promptStart, assertAdmission),
|
||||
);
|
||||
}
|
||||
|
||||
@@ -3623,6 +3664,7 @@ export class AgentManager {
|
||||
agentId: string,
|
||||
prompt: AgentPromptInput,
|
||||
options: AgentRunOptions | undefined,
|
||||
promptStart?: ForegroundPromptStart,
|
||||
assertAdmission?: (agent: ActiveManagedAgent) => void,
|
||||
): Promise<AsyncGenerator<AgentStreamEvent>> {
|
||||
let stalledStart: PendingForegroundRun | null = null;
|
||||
@@ -3641,7 +3683,7 @@ export class AgentManager {
|
||||
if (!this.hasInFlightRun(agent.id)) {
|
||||
return {
|
||||
status: "reserved" as const,
|
||||
iterator: this.streamAgent(agent.id, prompt, options),
|
||||
iterator: this.streamAgent(agent.id, prompt, options, promptStart),
|
||||
};
|
||||
}
|
||||
agent.pendingReplacement = true;
|
||||
@@ -3655,7 +3697,7 @@ export class AgentManager {
|
||||
}
|
||||
return {
|
||||
status: "reserved" as const,
|
||||
iterator: this.streamAgent(agent.id, prompt, options),
|
||||
iterator: this.streamAgent(agent.id, prompt, options, promptStart),
|
||||
};
|
||||
} catch (error) {
|
||||
agent.pendingReplacement = false;
|
||||
@@ -3846,7 +3888,10 @@ export class AgentManager {
|
||||
}
|
||||
|
||||
async cancelAgentRun(agentId: string): Promise<AgentRunCancellationResult> {
|
||||
return this.runForegroundMutation(agentId, () => this.cancelAgentRunNow(agentId));
|
||||
return this.runForegroundMutation(agentId, () => {
|
||||
this.requireSessionAgent(agentId).pendingReplacement = false;
|
||||
return this.cancelAgentRunNow(agentId);
|
||||
});
|
||||
}
|
||||
|
||||
private async cancelAgentRunNow(agentId: string): Promise<AgentRunCancellationResult> {
|
||||
|
||||
@@ -15,6 +15,7 @@ import { join } from "node:path";
|
||||
import { createTestLogger } from "../../test-utils/test-logger.js";
|
||||
import { AgentManager } from "./agent-manager.js";
|
||||
import { waitForAgentRunStartWithTimeout } from "./agent-prompt.js";
|
||||
import { ForegroundPromptStart } from "./agent-run-state.js";
|
||||
import type {
|
||||
AgentClient,
|
||||
AgentRunResult,
|
||||
@@ -161,7 +162,7 @@ class SlowStartAgentClient implements AgentClient {
|
||||
async function createRunStartScenario(startDelayMs: number | null): Promise<{
|
||||
agentManager: AgentManager;
|
||||
agentId: string;
|
||||
startRun: () => Promise<void>;
|
||||
startRun: () => Promise<{ started: Promise<void> }>;
|
||||
cleanup: () => Promise<void>;
|
||||
}> {
|
||||
const workdir = mkdtempSync(join(tmpdir(), "agent-run-start-budget-"));
|
||||
@@ -178,14 +179,16 @@ async function createRunStartScenario(startDelayMs: number | null): Promise<{
|
||||
return {
|
||||
agentManager,
|
||||
agentId: snapshot.id,
|
||||
// streamAgent registers the pending run synchronously, so the wait always observes it.
|
||||
// Returns the sender's start, bound to the run streamAgent registers.
|
||||
startRun: async () => {
|
||||
const run = agentManager.streamAgent(snapshot.id, "start the run");
|
||||
const start = new ForegroundPromptStart(snapshot.id);
|
||||
const run = agentManager.streamAgent(snapshot.id, "start the run", undefined, start);
|
||||
drained = (async () => {
|
||||
for await (const _event of run) {
|
||||
// Drain whatever the turn produces.
|
||||
}
|
||||
})().catch(() => undefined);
|
||||
return { started: start.started };
|
||||
},
|
||||
cleanup: async () => {
|
||||
// Release any turn still held open, then close. The drain is deliberately not
|
||||
@@ -207,8 +210,8 @@ test("waiting for a run start outlasts the slowest provider startup budget", asy
|
||||
vi.useFakeTimers();
|
||||
|
||||
try {
|
||||
await scenario.startRun();
|
||||
const wait = waitForAgentRunStartWithTimeout(scenario.agentManager, scenario.agentId);
|
||||
const { started } = await scenario.startRun();
|
||||
const wait = waitForAgentRunStartWithTimeout(scenario.agentManager, scenario.agentId, started);
|
||||
let settled = false;
|
||||
const markSettled = () => {
|
||||
settled = true;
|
||||
@@ -233,8 +236,8 @@ test("waiting for a run start still gives up at the run start budget", async ()
|
||||
vi.useFakeTimers();
|
||||
|
||||
try {
|
||||
await scenario.startRun();
|
||||
const wait = waitForAgentRunStartWithTimeout(scenario.agentManager, scenario.agentId);
|
||||
const { started } = await scenario.startRun();
|
||||
const wait = waitForAgentRunStartWithTimeout(scenario.agentManager, scenario.agentId, started);
|
||||
const rejection = expect(wait).rejects.toThrow(
|
||||
"codex run did not start within 60 seconds (phase: run start)",
|
||||
);
|
||||
|
||||
@@ -3,6 +3,7 @@ import type { Logger } from "pino";
|
||||
|
||||
import type { AgentPromptInput, AgentRunOptions } from "./agent-sdk-types.js";
|
||||
import type { AgentManager, ManagedAgent } from "./agent-manager.js";
|
||||
import { ForegroundPromptStart } from "./agent-run-state.js";
|
||||
import type { AgentStorage } from "./agent-storage.js";
|
||||
import { ensureAgentLoaded } from "./agent-loading.js";
|
||||
import { isStaleProviderSessionError } from "./stale-provider-session-error.js";
|
||||
@@ -38,11 +39,17 @@ export interface StartAgentRunOptions {
|
||||
|
||||
export type PromptDispatchDisposition = "out_of_band" | "steered" | "turn_started";
|
||||
|
||||
/** A dispatched prompt. A started turn carries its sender's start outcome. */
|
||||
export type PromptDispatchResult =
|
||||
| { disposition: "turn_started"; started: Promise<void> }
|
||||
| { disposition: Exclude<PromptDispatchDisposition, "turn_started"> };
|
||||
|
||||
async function steerOrReplaceActiveRun(
|
||||
agentManager: AgentRunController,
|
||||
agentId: string,
|
||||
prompt: AgentPromptInput,
|
||||
options: StartAgentRunOptions | undefined,
|
||||
promptStart: ForegroundPromptStart,
|
||||
): Promise<
|
||||
| { disposition: "steered" }
|
||||
| {
|
||||
@@ -57,7 +64,12 @@ async function steerOrReplaceActiveRun(
|
||||
const steerOptions = options.clearPendingPermissions
|
||||
? { ...options.runOptions, clearPendingPermissions: true }
|
||||
: options.runOptions;
|
||||
const result = await agentManager.steerOrReplaceActiveTurn(agentId, prompt, steerOptions);
|
||||
const result = await agentManager.steerOrReplaceActiveTurn(
|
||||
agentId,
|
||||
prompt,
|
||||
steerOptions,
|
||||
promptStart,
|
||||
);
|
||||
if (result.status === "steered") {
|
||||
return { disposition: "steered" };
|
||||
}
|
||||
@@ -72,14 +84,15 @@ async function startOrReplaceRun(
|
||||
agentId: string,
|
||||
prompt: AgentPromptInput,
|
||||
options: StartAgentRunOptions | undefined,
|
||||
promptStart: ForegroundPromptStart,
|
||||
): Promise<{
|
||||
iterator: AsyncGenerator<import("./agent-sdk-types.js").AgentStreamEvent>;
|
||||
replaced: boolean;
|
||||
}> {
|
||||
const replaced = Boolean(options?.replaceRunning && agentManager.hasInFlightRun(agentId));
|
||||
const iterator = replaced
|
||||
? await agentManager.replaceAgentRun(agentId, prompt, options?.runOptions)
|
||||
: agentManager.streamAgent(agentId, prompt, options?.runOptions);
|
||||
? await agentManager.replaceAgentRun(agentId, prompt, options?.runOptions, promptStart)
|
||||
: agentManager.streamAgent(agentId, prompt, options?.runOptions, promptStart);
|
||||
return { iterator, replaced };
|
||||
}
|
||||
|
||||
@@ -97,7 +110,7 @@ export async function startAgentRun(
|
||||
prompt: AgentPromptInput,
|
||||
logger: Logger,
|
||||
options?: StartAgentRunOptions,
|
||||
): Promise<{ disposition: PromptDispatchDisposition }> {
|
||||
): Promise<PromptDispatchResult> {
|
||||
const snapshot = agentManager.getAgent(agentId);
|
||||
logger.trace(
|
||||
{
|
||||
@@ -118,16 +131,25 @@ export async function startAgentRun(
|
||||
options?.onDispatch?.("out_of_band");
|
||||
return { disposition: "out_of_band" };
|
||||
}
|
||||
const promptStart = new ForegroundPromptStart(agentId);
|
||||
try {
|
||||
await agentManager.reloadStalePluginSession(agentId);
|
||||
return await startAgentRunInner(agentManager, agentId, prompt, logger, options);
|
||||
try {
|
||||
await agentManager.reloadStalePluginSession(agentId);
|
||||
return await startAgentRunInner(agentManager, agentId, prompt, logger, options, promptStart);
|
||||
} catch (error) {
|
||||
if (!isStaleProviderSessionError(error)) throw error;
|
||||
logger.info(
|
||||
{ agentId, err: error },
|
||||
"Provider session went stale; reopening from persistence",
|
||||
);
|
||||
// The live session belongs to a retired plugin runtime. Reload swaps in a
|
||||
// fresh session on the current runtime while preserving history and labels.
|
||||
await agentManager.reloadAgentSession(agentId);
|
||||
return await startAgentRunInner(agentManager, agentId, prompt, logger, options, promptStart);
|
||||
}
|
||||
} catch (error) {
|
||||
if (!isStaleProviderSessionError(error)) throw error;
|
||||
logger.info({ agentId, err: error }, "Provider session went stale; reopening from persistence");
|
||||
// The live session belongs to a retired plugin runtime. Reload swaps in a
|
||||
// fresh session on the current runtime while preserving history and labels.
|
||||
await agentManager.reloadAgentSession(agentId);
|
||||
return await startAgentRunInner(agentManager, agentId, prompt, logger, options);
|
||||
promptStart.end();
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -136,12 +158,13 @@ async function startAgentRunInner(
|
||||
agentId: string,
|
||||
prompt: AgentPromptInput,
|
||||
logger: Logger,
|
||||
options?: StartAgentRunOptions,
|
||||
): Promise<{ disposition: PromptDispatchDisposition }> {
|
||||
options: StartAgentRunOptions | undefined,
|
||||
promptStart: ForegroundPromptStart,
|
||||
): Promise<PromptDispatchResult> {
|
||||
const snapshot = agentManager.getAgent(agentId);
|
||||
const steered = options?.idleOnly
|
||||
? null
|
||||
: await steerOrReplaceActiveRun(agentManager, agentId, prompt, options);
|
||||
: await steerOrReplaceActiveRun(agentManager, agentId, prompt, options, promptStart);
|
||||
if (options?.idleOnly && agentManager.hasInFlightRun(agentId)) {
|
||||
throw new AgentTurnBusyError(`Agent ${agentId} is running`);
|
||||
}
|
||||
@@ -151,7 +174,7 @@ async function startAgentRunInner(
|
||||
}
|
||||
const { iterator, replaced } = steered
|
||||
? { iterator: steered.iterator, replaced: true }
|
||||
: await startOrReplaceRun(agentManager, agentId, prompt, options);
|
||||
: await startOrReplaceRun(agentManager, agentId, prompt, options, promptStart);
|
||||
logger.trace(
|
||||
{
|
||||
agentId,
|
||||
@@ -173,7 +196,7 @@ async function startAgentRunInner(
|
||||
"Provider session went stale; reopening from persistence",
|
||||
);
|
||||
await agentManager.reloadAgentSession(agentId);
|
||||
const retry = await startOrReplaceRun(agentManager, agentId, prompt, options);
|
||||
const retry = await startOrReplaceRun(agentManager, agentId, prompt, options, promptStart);
|
||||
await drainAgentRunIterator(retry.iterator);
|
||||
}
|
||||
logger.trace(
|
||||
@@ -195,9 +218,11 @@ async function startAgentRunInner(
|
||||
"agent.session.iterator.error",
|
||||
);
|
||||
logger.error({ err: error, agentId }, "Agent stream failed");
|
||||
} finally {
|
||||
promptStart.end();
|
||||
}
|
||||
})();
|
||||
return { disposition: "turn_started" };
|
||||
return { disposition: "turn_started", started: promptStart.started };
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -270,8 +295,9 @@ export interface StartCreatedAgentInitialPromptParams {
|
||||
const AGENT_RUN_START_TIMEOUT_MS = 60_000;
|
||||
|
||||
export async function waitForAgentRunStartWithTimeout(
|
||||
agentManager: AgentManager,
|
||||
agentManager: Pick<AgentManager, "getAgent">,
|
||||
agentId: string,
|
||||
started: Promise<void>,
|
||||
signal?: AbortSignal,
|
||||
): Promise<void> {
|
||||
const provider = agentManager.getAgent(agentId)?.provider ?? "provider";
|
||||
@@ -286,15 +312,28 @@ export async function waitForAgentRunStartWithTimeout(
|
||||
AGENT_RUN_START_TIMEOUT_MS,
|
||||
);
|
||||
|
||||
const abortSignal = signal ? AbortSignal.any([startAbort.signal, signal]) : startAbort.signal;
|
||||
let onAbort: (() => void) | null = null;
|
||||
const aborted = new Promise<never>((_, reject) => {
|
||||
onAbort = () => reject(createStartAbortError(abortSignal.reason));
|
||||
if (abortSignal.aborted) onAbort();
|
||||
else abortSignal.addEventListener("abort", onAbort, { once: true });
|
||||
});
|
||||
try {
|
||||
await agentManager.waitForAgentRunStart(agentId, {
|
||||
signal: signal ? AbortSignal.any([startAbort.signal, signal]) : startAbort.signal,
|
||||
});
|
||||
await Promise.race([started, aborted]);
|
||||
} finally {
|
||||
clearTimeout(startTimeout);
|
||||
if (onAbort) abortSignal.removeEventListener("abort", onAbort);
|
||||
}
|
||||
}
|
||||
|
||||
function createStartAbortError(reason: unknown): Error {
|
||||
let message = "wait_for_agent_start aborted";
|
||||
if (typeof reason === "string") message = reason;
|
||||
else if (reason instanceof Error) message = reason.message;
|
||||
return Object.assign(new Error(message), { name: "AbortError" });
|
||||
}
|
||||
|
||||
async function resolvePromptSource(
|
||||
source: AgentPromptSource | undefined,
|
||||
manager: Pick<AgentManager, "getAgent">,
|
||||
@@ -320,7 +359,7 @@ async function resolvePromptSource(
|
||||
*/
|
||||
export async function sendPromptToAgent(
|
||||
params: SendPromptToAgentParams,
|
||||
): Promise<{ disposition: PromptDispatchDisposition }> {
|
||||
): Promise<PromptDispatchResult> {
|
||||
const source = await resolvePromptSource(params.source, params.agentManager, params.agentStorage);
|
||||
const delivery = prepareAgentMessage(params.prompt, source, params.messageId);
|
||||
return sendPreparedPromptToAgent({
|
||||
@@ -335,14 +374,14 @@ export async function sendPromptToAgent(
|
||||
/** Dispatch daemon-prepared context without reclassifying it as human input. */
|
||||
export async function sendPreparedPromptToAgent(
|
||||
params: Omit<SendPromptToAgentParams, "source" | "messageId">,
|
||||
): Promise<{ disposition: PromptDispatchDisposition }> {
|
||||
): Promise<PromptDispatchResult> {
|
||||
const unarchive = params.unarchive ?? true;
|
||||
|
||||
const record = await params.agentStorage.get(params.agentId);
|
||||
let archivedAtToRestore: string | null = null;
|
||||
if (record?.archivedAt) {
|
||||
if (!unarchive) {
|
||||
return { disposition: "turn_started" };
|
||||
return { disposition: "turn_started", started: Promise.resolve() };
|
||||
}
|
||||
if (await unarchiveAgentState(params.agentStorage, params.agentManager, params.agentId)) {
|
||||
archivedAtToRestore = record.archivedAt;
|
||||
@@ -408,7 +447,11 @@ export async function startCreatedAgentInitialPrompt(
|
||||
);
|
||||
|
||||
if (dispatchResult.disposition === "turn_started") {
|
||||
await waitForAgentRunStartWithTimeout(params.agentManager, params.agentId);
|
||||
await waitForAgentRunStartWithTimeout(
|
||||
params.agentManager,
|
||||
params.agentId,
|
||||
dispatchResult.started,
|
||||
);
|
||||
}
|
||||
|
||||
const refreshedSnapshot = params.agentManager.getAgent(params.agentId) ?? params.snapshot ?? null;
|
||||
|
||||
@@ -13,7 +13,7 @@ export interface ForegroundTurnWaiter {
|
||||
type ForegroundRunStart =
|
||||
| { status: "pending" }
|
||||
| { status: "started"; turnId: string }
|
||||
| { status: "failed"; error: string };
|
||||
| { status: "failed"; error: string; stale?: true };
|
||||
|
||||
export interface PendingForegroundRun {
|
||||
token: string;
|
||||
@@ -343,3 +343,59 @@ function settleTrackedRun(run: TrackedAgentRun): void {
|
||||
run.settled = true;
|
||||
run.resolveSettled();
|
||||
}
|
||||
|
||||
/**
|
||||
* Follows one sender's prompt to the foreground run that starts it. Each run created for the
|
||||
* prompt, including a stale-session retry, is bound here, so `started` settles for this
|
||||
* sender's prompt and never for another run the agent tracks.
|
||||
*/
|
||||
export class ForegroundPromptStart {
|
||||
readonly started: Promise<void>;
|
||||
private resolveStarted!: () => void;
|
||||
private rejectStarted!: (error: Error) => void;
|
||||
private run: PendingForegroundRun | null = null;
|
||||
private done = false;
|
||||
|
||||
constructor(private readonly agentId: string) {
|
||||
this.started = new Promise<void>((resolve, reject) => {
|
||||
this.resolveStarted = resolve;
|
||||
this.rejectStarted = reject;
|
||||
});
|
||||
// Steered and fire-and-forget dispatches never wait on the start.
|
||||
this.started.catch(() => undefined);
|
||||
}
|
||||
|
||||
/** A run was created for this prompt. */
|
||||
bind(run: PendingForegroundRun): void {
|
||||
this.run = run;
|
||||
void Promise.race([run.turnStartedPromise, run.settledPromise]).then(() =>
|
||||
this.settle(run, { ended: false }),
|
||||
);
|
||||
}
|
||||
|
||||
/** The prompt's dispatch is over; no further run will be created for it. */
|
||||
end(): void {
|
||||
this.settle(this.run, { ended: true });
|
||||
}
|
||||
|
||||
private settle(run: PendingForegroundRun | null, { ended }: { ended: boolean }): void {
|
||||
if (this.done || run !== this.run) return;
|
||||
if (run?.start.status === "started") {
|
||||
this.done = true;
|
||||
this.resolveStarted();
|
||||
return;
|
||||
}
|
||||
// A stale-session failure is retried with a new run; wait for it unless dispatch ended.
|
||||
if (run?.start.status === "failed" && run.start.stale && !ended) return;
|
||||
this.done = true;
|
||||
this.rejectStarted(new Error(this.describeUnstarted(run)));
|
||||
}
|
||||
|
||||
private describeUnstarted(run: PendingForegroundRun | null): string {
|
||||
if (run?.start.status === "failed") return run.start.error;
|
||||
if (run?.settled) {
|
||||
return `Agent ${this.agentId} run was canceled before its turn started; its prompt was not delivered`;
|
||||
}
|
||||
return `Agent ${this.agentId} run finished before starting`;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -528,6 +528,14 @@ export type AgentPermissionResponse =
|
||||
interrupt?: boolean;
|
||||
};
|
||||
|
||||
/** A requested turn was canceled before the provider accepted it. */
|
||||
export class AgentTurnStartCanceledError extends Error {
|
||||
constructor() {
|
||||
super("Turn was canceled before starting");
|
||||
this.name = "AgentTurnStartCanceledError";
|
||||
}
|
||||
}
|
||||
|
||||
export interface AgentRunResult {
|
||||
sessionId: string;
|
||||
finalText: string;
|
||||
|
||||
@@ -10,6 +10,7 @@ import { AgentManager } from "../agent-manager.js";
|
||||
import { AgentStorage } from "../agent-storage.js";
|
||||
import type { CreatePaseoWorktreeWorkflowResult } from "../../worktree-session.js";
|
||||
import { createAgentCommand } from "./create.js";
|
||||
import { ForegroundPromptStart } from "../agent-run-state.js";
|
||||
import type { ManagedAgent } from "../agent-manager.js";
|
||||
|
||||
const logger = createTestLogger();
|
||||
@@ -89,9 +90,12 @@ test("session create forwards clientMessageId to the initial prompt run options"
|
||||
firstAgentContext: { attachments: [] },
|
||||
});
|
||||
|
||||
expect(streamAgent).toHaveBeenCalledWith("agent-1", "hello from create", {
|
||||
clientMessageId: "msg-create-1",
|
||||
});
|
||||
expect(streamAgent).toHaveBeenCalledWith(
|
||||
"agent-1",
|
||||
"hello from create",
|
||||
{ clientMessageId: "msg-create-1" },
|
||||
expect.any(ForegroundPromptStart),
|
||||
);
|
||||
});
|
||||
|
||||
test("session create validates the requested mode against the provider's modes", async () => {
|
||||
|
||||
@@ -1,3 +1,4 @@
|
||||
import { AgentRunState, ForegroundPromptStart } from "./agent-run-state.js";
|
||||
import {
|
||||
createFinishSubscriptions,
|
||||
createFinishObservation,
|
||||
@@ -279,8 +280,15 @@ function buildAgentManagerSpies() {
|
||||
steerOrReplaceActiveTurn: async () => ({ status: "inactive" as const }),
|
||||
tryRunOutOfBand: vi.fn().mockReturnValue(false),
|
||||
subscribe: vi.fn().mockReturnValue(() => {}),
|
||||
streamAgent: vi.fn(() => (async function* noop() {})()),
|
||||
waitForAgentRunStart: vi.fn().mockResolvedValue(undefined),
|
||||
streamAgent: vi.fn(
|
||||
(agentId: string, _prompt: unknown, _options: unknown, start?: ForegroundPromptStart) => {
|
||||
const runs = new AgentRunState();
|
||||
const run = runs.createPendingRun(agentId);
|
||||
runs.settleForegroundStart(run, { status: "started", turnId: `${agentId}-turn` });
|
||||
start?.bind(run);
|
||||
return (async function* noop() {})();
|
||||
},
|
||||
),
|
||||
respondToPermission: vi.fn(),
|
||||
cancelAgentRun: vi.fn(),
|
||||
getPendingPermissions: vi.fn(),
|
||||
|
||||
@@ -5428,7 +5428,7 @@ describe("Codex app-server provider", () => {
|
||||
|
||||
threadStart.resolve({ thread: { id: "thread-1" } });
|
||||
await expect(interruptPromise).resolves.toBeUndefined();
|
||||
await expect(resultPromise).rejects.toThrow("interrupted before reaching Codex");
|
||||
await expect(resultPromise).resolves.toMatchObject({ canceled: true, timeline: [] });
|
||||
expect(appServer.requests()).not.toContainEqual(
|
||||
expect.objectContaining({ method: "turn/start" }),
|
||||
);
|
||||
|
||||
@@ -3,6 +3,7 @@ import { applyProviderOptionsPatch } from "../option-controls.js";
|
||||
import { assertChangesAreLive, validateProviderOptions } from "../provider-options.js";
|
||||
import { CodexBackgroundInventory } from "./codex/background-inventory.js";
|
||||
import {
|
||||
AgentTurnStartCanceledError,
|
||||
getAgentStreamEventTurnId,
|
||||
type AgentPermissionAction,
|
||||
type AgentCapabilityFlags,
|
||||
@@ -4696,7 +4697,7 @@ export class CodexAppServerAgentSession implements AgentSession {
|
||||
// outlives it into the new turn.
|
||||
await this.waitForInterruptedTurnCleanup();
|
||||
if (pendingStart.cancelRequested) {
|
||||
throw new Error("Codex turn start was interrupted before reaching Codex");
|
||||
throw new AgentTurnStartCanceledError();
|
||||
}
|
||||
await this.client.request("turn/start", turnStart.params, TURN_START_TIMEOUT_MS);
|
||||
return { turnId };
|
||||
|
||||
@@ -1,4 +1,5 @@
|
||||
import {
|
||||
AgentTurnStartCanceledError,
|
||||
getAgentStreamEventTurnId,
|
||||
type AgentPromptInput,
|
||||
type AgentRunOptions,
|
||||
@@ -90,6 +91,9 @@ export async function runProviderTurn({
|
||||
processEvent(event);
|
||||
}
|
||||
await completion;
|
||||
} catch (error) {
|
||||
if (!(error instanceof AgentTurnStartCanceledError)) throw error;
|
||||
return { sessionId: await getSessionId(), finalText: "", timeline: [], canceled: true };
|
||||
} finally {
|
||||
unsubscribe();
|
||||
}
|
||||
|
||||
@@ -2051,7 +2051,7 @@ function createToolCatalog(
|
||||
};
|
||||
}
|
||||
|
||||
const { disposition } = await sendPromptToAgent({
|
||||
const dispatch = await sendPromptToAgent({
|
||||
agentManager,
|
||||
agentStorage,
|
||||
agentId,
|
||||
@@ -2070,11 +2070,14 @@ function createToolCatalog(
|
||||
});
|
||||
|
||||
// Return once the provider has accepted the turn, so the status reports it running.
|
||||
if (disposition === "turn_started") {
|
||||
await waitForAgentRunStartWithTimeout(agentManager, agentId).catch((error) => {
|
||||
rejectNotification();
|
||||
throw error;
|
||||
});
|
||||
const { disposition } = dispatch;
|
||||
if (dispatch.disposition === "turn_started") {
|
||||
await waitForAgentRunStartWithTimeout(agentManager, agentId, dispatch.started).catch(
|
||||
(error) => {
|
||||
rejectNotification();
|
||||
throw error;
|
||||
},
|
||||
);
|
||||
}
|
||||
const currentSnapshot = agentManager.getAgent(agentId);
|
||||
|
||||
|
||||
@@ -38,6 +38,7 @@ import {
|
||||
type ScheduleServiceOptions,
|
||||
} from "./service.js";
|
||||
import { ScheduleStore } from "./store.js";
|
||||
import { ForegroundPromptStart } from "../agent/agent-run-state.js";
|
||||
import type { ScheduleExecutionResult, StoredSchedule } from "@getpaseo/protocol/schedule/types";
|
||||
|
||||
interface ScheduleServiceInternals {
|
||||
@@ -754,6 +755,7 @@ describe("ScheduleService", () => {
|
||||
agent.id,
|
||||
expect.stringContaining(`Schedule fired (id=${schedule.id}, run=`),
|
||||
undefined,
|
||||
expect.any(ForegroundPromptStart),
|
||||
]);
|
||||
});
|
||||
|
||||
|
||||
@@ -8993,6 +8993,7 @@ export class Session {
|
||||
await waitForAgentRunStartWithTimeout(
|
||||
this.agentManager,
|
||||
agentId,
|
||||
result.started,
|
||||
this.delivery.requestSignal,
|
||||
);
|
||||
}
|
||||
|
||||
@@ -50,7 +50,11 @@ export function createTestAgentMessages(params: {
|
||||
runOptions: { clientMessageId: request.messageIds[0] },
|
||||
});
|
||||
if (result.disposition === "turn_started")
|
||||
await waitForAgentRunStartWithTimeout(params.agentManager, request.recipientId);
|
||||
await waitForAgentRunStartWithTimeout(
|
||||
params.agentManager,
|
||||
request.recipientId,
|
||||
result.started,
|
||||
);
|
||||
return result.disposition;
|
||||
},
|
||||
onError: (error, request) =>
|
||||
|
||||
@@ -745,7 +745,7 @@ export class VoiceAssistantWebSocketServer {
|
||||
{ replayState: false },
|
||||
),
|
||||
dispatch: async (batch) => {
|
||||
const { disposition } = await sendPreparedPromptToAgent({
|
||||
const dispatch = await sendPreparedPromptToAgent({
|
||||
agentManager,
|
||||
agentStorage,
|
||||
agentId: batch.recipientId,
|
||||
@@ -758,9 +758,9 @@ export class VoiceAssistantWebSocketServer {
|
||||
runOptions: { clientMessageId: batch.messageIds[0] },
|
||||
logger: this.logger,
|
||||
});
|
||||
if (disposition === "turn_started")
|
||||
await waitForAgentRunStartWithTimeout(agentManager, batch.recipientId);
|
||||
return disposition;
|
||||
if (dispatch.disposition === "turn_started")
|
||||
await waitForAgentRunStartWithTimeout(agentManager, batch.recipientId, dispatch.started);
|
||||
return dispatch.disposition;
|
||||
},
|
||||
onError: (err, batch) =>
|
||||
this.logger.error(
|
||||
|
||||
Reference in New Issue
Block a user