Skip to content

Commit 919bd72

Browse files
D3OXYcodex
authored andcommitted
Preserve pending startup lifecycle for PR #4101
Co-authored-by: codex <[email protected]>
1 parent 32c6012 commit 919bd72

7 files changed

Lines changed: 475 additions & 22 deletions

File tree

‎apps/server/src/orchestration/Layers/ProjectionPipeline.test.ts‎

Lines changed: 68 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -2464,6 +2464,74 @@ it.layer(BaseTestLayer)("OrchestrationProjectionPipeline", (it) => {
24642464
);
24652465
});
24662466

2467+
it.layer(makeProjectionPipelinePrefixedTestLayer("t3-pending-turn-terminal-test-"))(
2468+
"OrchestrationProjectionPipeline pending turn cleanup",
2469+
(it) => {
2470+
it.effect("clears pending turn starts when startup reaches a terminal session state", () =>
2471+
Effect.gen(function* () {
2472+
const projectionPipeline = yield* OrchestrationProjectionPipeline;
2473+
const eventStore = yield* OrchestrationEventStore;
2474+
const sql = yield* SqlClient.SqlClient;
2475+
2476+
for (const [index, status] of (["error", "interrupted", "stopped"] as const).entries()) {
2477+
const threadId = ThreadId.make(`thread-terminal-${status}`);
2478+
const requestedAt = `2026-02-26T14:00:0${index}.000Z`;
2479+
yield* eventStore.append({
2480+
type: "thread.turn-start-requested",
2481+
eventId: EventId.make(`evt-terminal-pending-${status}`),
2482+
aggregateKind: "thread",
2483+
aggregateId: threadId,
2484+
occurredAt: requestedAt,
2485+
commandId: CommandId.make(`cmd-terminal-pending-${status}`),
2486+
causationEventId: null,
2487+
correlationId: CorrelationId.make(`cmd-terminal-pending-${status}`),
2488+
metadata: {},
2489+
payload: {
2490+
threadId,
2491+
messageId: MessageId.make(`message-terminal-${status}`),
2492+
runtimeMode: "approval-required",
2493+
createdAt: requestedAt,
2494+
},
2495+
});
2496+
yield* eventStore.append({
2497+
type: "thread.session-set",
2498+
eventId: EventId.make(`evt-terminal-session-${status}`),
2499+
aggregateKind: "thread",
2500+
aggregateId: threadId,
2501+
occurredAt: requestedAt,
2502+
commandId: CommandId.make(`cmd-terminal-session-${status}`),
2503+
causationEventId: null,
2504+
correlationId: CorrelationId.make(`cmd-terminal-session-${status}`),
2505+
metadata: {},
2506+
payload: {
2507+
threadId,
2508+
session: {
2509+
threadId,
2510+
status,
2511+
providerName: "codex",
2512+
runtimeMode: "approval-required",
2513+
activeTurnId: null,
2514+
lastError: status === "error" ? "startup failed" : null,
2515+
updatedAt: requestedAt,
2516+
},
2517+
},
2518+
});
2519+
}
2520+
2521+
yield* projectionPipeline.bootstrap;
2522+
2523+
const pendingRows = yield* sql<{ readonly threadId: string }>`
2524+
SELECT thread_id AS "threadId"
2525+
FROM projection_turns
2526+
WHERE turn_id IS NULL
2527+
AND state = 'pending'
2528+
`;
2529+
assert.deepEqual(pendingRows, []);
2530+
}),
2531+
);
2532+
},
2533+
);
2534+
24672535
it.effect("restores pending turn-start metadata across projection pipeline restart", () =>
24682536
Effect.gen(function* () {
24692537
const { dbPath } = yield* ServerConfig;

‎apps/server/src/orchestration/Layers/ProjectionPipeline.ts‎

Lines changed: 9 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1059,6 +1059,15 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecti
10591059
case "thread.session-set": {
10601060
const turnId = event.payload.session.activeTurnId;
10611061
if (turnId === null || event.payload.session.status !== "running") {
1062+
if (
1063+
event.payload.session.status === "error" ||
1064+
event.payload.session.status === "stopped" ||
1065+
event.payload.session.status === "interrupted"
1066+
) {
1067+
yield* projectionTurnRepository.deletePendingTurnStartByThreadId({
1068+
threadId: event.payload.threadId,
1069+
});
1070+
}
10621071
// Leaving the "running" session status is the turn-end signal:
10631072
// settle still-running turns so their duration reflects the whole
10641073
// turn rather than the last assistant message.

‎apps/server/src/orchestration/Layers/ProviderCommandReactor.test.ts‎

Lines changed: 123 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -22,6 +22,7 @@ import {
2222
TurnId,
2323
} from "@t3tools/contracts";
2424
import * as Effect from "effect/Effect";
25+
import * as Deferred from "effect/Deferred";
2526
import * as Exit from "effect/Exit";
2627
import * as Layer from "effect/Layer";
2728
import * as ManagedRuntime from "effect/ManagedRuntime";
@@ -145,6 +146,9 @@ describe("ProviderCommandReactor", () => {
145146
readonly threadModelSelection?: ModelSelection;
146147
readonly sessionModelSwitch?: "unsupported" | "in-session";
147148
readonly requiresNewThreadForModelChange?: boolean;
149+
readonly startSessionEffect?: (
150+
session: ProviderSession,
151+
) => Effect.Effect<ProviderSession, ProviderAdapterRequestError>;
148152
}) {
149153
const now = "2026-01-01T00:00:00.000Z";
150154
const baseDir =
@@ -159,6 +163,7 @@ describe("ProviderCommandReactor", () => {
159163
instanceId: ProviderInstanceId.make("codex"),
160164
model: "gpt-5-codex",
161165
};
166+
const startSessionEffect = input?.startSessionEffect;
162167
const startSession = vi.fn((_: unknown, input: unknown) => {
163168
const sessionIndex = nextSessionIndex++;
164169
const resumeCursor =
@@ -212,8 +217,13 @@ describe("ProviderCommandReactor", () => {
212217
createdAt: now,
213218
updatedAt: now,
214219
};
215-
runtimeSessions.push(session);
216-
return Effect.succeed(session);
220+
return (startSessionEffect?.(session) ?? Effect.succeed(session)).pipe(
221+
Effect.tap((startedSession) =>
222+
Effect.sync(() => {
223+
runtimeSessions.push(startedSession);
224+
}),
225+
),
226+
);
217227
});
218228
const sendTurn = vi.fn((_: unknown) =>
219229
Effect.succeed({
@@ -463,9 +473,120 @@ describe("ProviderCommandReactor", () => {
463473
const readModel = await harness.readModel();
464474
const thread = readModel.threads.find((entry) => entry.id === ThreadId.make("thread-1"));
465475
expect(thread?.session?.threadId).toBe("thread-1");
476+
expect(thread?.session?.status).toBe("starting");
466477
expect(thread?.session?.runtimeMode).toBe("approval-required");
467478
});
468479

480+
effectIt.effect("projects starting before a slow provider session finishes", () =>
481+
Effect.gen(function* () {
482+
const releaseStart = yield* Deferred.make<void>();
483+
const harness = yield* Effect.promise(() =>
484+
createHarness({
485+
startSessionEffect: (session) => Deferred.await(releaseStart).pipe(Effect.as(session)),
486+
}),
487+
);
488+
const now = "2026-01-01T00:00:00.000Z";
489+
490+
yield* harness.engine.dispatch({
491+
type: "thread.turn.start",
492+
commandId: CommandId.make("cmd-turn-start-slow-provider"),
493+
threadId: ThreadId.make("thread-1"),
494+
message: {
495+
messageId: asMessageId("user-message-slow-provider"),
496+
role: "user",
497+
text: "start slowly",
498+
attachments: [],
499+
},
500+
interactionMode: DEFAULT_PROVIDER_INTERACTION_MODE,
501+
runtimeMode: "approval-required",
502+
createdAt: now,
503+
});
504+
505+
yield* Effect.promise(() => waitFor(() => harness.startSession.mock.calls.length === 1));
506+
const duringStartup = yield* Effect.promise(() => harness.readModel());
507+
expect(
508+
duringStartup.threads.find((entry) => entry.id === ThreadId.make("thread-1"))?.session
509+
?.status,
510+
).toBe("starting");
511+
expect(harness.sendTurn).not.toHaveBeenCalled();
512+
513+
yield* Deferred.succeed(releaseStart, undefined);
514+
yield* Effect.promise(() => waitFor(() => harness.sendTurn.mock.calls.length === 1));
515+
}),
516+
);
517+
518+
effectIt.effect("settles a failed provider startup and allows a clean retry", () =>
519+
Effect.gen(function* () {
520+
let failStartup = true;
521+
const harness = yield* Effect.promise(() =>
522+
createHarness({
523+
startSessionEffect: (session) =>
524+
failStartup
525+
? Effect.fail(
526+
new ProviderAdapterRequestError({
527+
provider: "codex",
528+
method: "thread.start",
529+
detail: "deterministic startup failure",
530+
}),
531+
)
532+
: Effect.succeed(session),
533+
}),
534+
);
535+
const now = "2026-01-01T00:00:00.000Z";
536+
537+
yield* harness.engine.dispatch({
538+
type: "thread.turn.start",
539+
commandId: CommandId.make("cmd-turn-start-provider-failure"),
540+
threadId: ThreadId.make("thread-1"),
541+
message: {
542+
messageId: asMessageId("user-message-provider-failure"),
543+
role: "user",
544+
text: "fail once",
545+
attachments: [],
546+
},
547+
interactionMode: DEFAULT_PROVIDER_INTERACTION_MODE,
548+
runtimeMode: "approval-required",
549+
createdAt: now,
550+
});
551+
552+
yield* Effect.promise(() =>
553+
waitFor(async () => {
554+
const readModel = await harness.readModel();
555+
return (
556+
readModel.threads.find((entry) => entry.id === ThreadId.make("thread-1"))?.session
557+
?.status === "error"
558+
);
559+
}),
560+
);
561+
let readModel = yield* Effect.promise(() => harness.readModel());
562+
let thread = readModel.threads.find((entry) => entry.id === ThreadId.make("thread-1"));
563+
expect(thread?.session?.lastError).toContain("deterministic startup failure");
564+
expect(harness.sendTurn).not.toHaveBeenCalled();
565+
566+
failStartup = false;
567+
yield* harness.engine.dispatch({
568+
type: "thread.turn.start",
569+
commandId: CommandId.make("cmd-turn-start-provider-retry"),
570+
threadId: ThreadId.make("thread-1"),
571+
message: {
572+
messageId: asMessageId("user-message-provider-retry"),
573+
role: "user",
574+
text: "retry",
575+
attachments: [],
576+
},
577+
interactionMode: DEFAULT_PROVIDER_INTERACTION_MODE,
578+
runtimeMode: "approval-required",
579+
createdAt: "2026-01-01T00:00:01.000Z",
580+
});
581+
582+
yield* Effect.promise(() => waitFor(() => harness.sendTurn.mock.calls.length === 1));
583+
readModel = yield* Effect.promise(() => harness.readModel());
584+
thread = readModel.threads.find((entry) => entry.id === ThreadId.make("thread-1"));
585+
expect(thread?.session?.status).toBe("starting");
586+
expect(thread?.session?.lastError).toBeNull();
587+
}),
588+
);
589+
469590
it("generates a thread title on the first turn", async () => {
470591
const harness = await createHarness();
471592
const now = "2026-01-01T00:00:00.000Z";

‎apps/server/src/orchestration/Layers/ProviderCommandReactor.ts‎

Lines changed: 34 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -288,15 +288,20 @@ const make = Effect.gen(function* () {
288288
readonly createdAt: string;
289289
}) {
290290
const thread = yield* resolveThread(input.threadId);
291-
const session = thread?.session;
292-
if (!session) {
291+
if (!thread) {
293292
return;
294293
}
294+
const session = thread.session;
295295
yield* setThreadSession({
296296
threadId: input.threadId,
297297
session: {
298-
...session,
299-
status: session.status === "stopped" ? "stopped" : "ready",
298+
...(session ?? {
299+
threadId: input.threadId,
300+
providerName: null,
301+
providerInstanceId: thread.modelSelection.instanceId,
302+
runtimeMode: thread.runtimeMode,
303+
}),
304+
status: session?.status === "stopped" ? "stopped" : "error",
300305
activeTurnId: null,
301306
lastError: input.detail,
302307
updatedAt: input.createdAt,
@@ -354,6 +359,7 @@ const make = Effect.gen(function* () {
354359
createdAt: string,
355360
options?: {
356361
readonly modelSelection?: ModelSelection;
362+
readonly pendingTurnStart?: boolean;
357363
},
358364
) {
359365
const thread = yield* resolveThread(threadId);
@@ -428,6 +434,22 @@ const make = Effect.gen(function* () {
428434
});
429435
}
430436
const preferredProvider: ProviderDriverKind = desiredDriverKind;
437+
if (options?.pendingTurnStart === true && thread.session?.status !== "running") {
438+
yield* setThreadSession({
439+
threadId,
440+
session: {
441+
threadId,
442+
status: "starting",
443+
providerName: activeSession?.provider ?? preferredProvider,
444+
providerInstanceId: activeSession?.providerInstanceId ?? desiredInstanceId,
445+
runtimeMode: desiredRuntimeMode,
446+
activeTurnId: null,
447+
lastError: null,
448+
updatedAt: createdAt,
449+
},
450+
createdAt,
451+
});
452+
}
431453
if (thread.session !== null) {
432454
yield* rejectStartedThreadModelChangeIfRequired({
433455
threadId,
@@ -498,7 +520,10 @@ const make = Effect.gen(function* () {
498520
threadId,
499521
session: {
500522
threadId,
501-
status: mapProviderSessionStatusToOrchestrationStatus(session.status),
523+
status:
524+
options?.pendingTurnStart === true && session.status === "ready"
525+
? "starting"
526+
: mapProviderSessionStatusToOrchestrationStatus(session.status),
502527
providerName: session.provider,
503528
providerInstanceId: session.providerInstanceId,
504529
runtimeMode: desiredRuntimeMode,
@@ -597,11 +622,10 @@ const make = Effect.gen(function* () {
597622
new Error(`Thread '${input.threadId}' was not found in read model.`),
598623
);
599624
}
600-
yield* ensureSessionForThread(
601-
input.threadId,
602-
input.createdAt,
603-
input.modelSelection !== undefined ? { modelSelection: input.modelSelection } : {},
604-
);
625+
yield* ensureSessionForThread(input.threadId, input.createdAt, {
626+
...(input.modelSelection !== undefined ? { modelSelection: input.modelSelection } : {}),
627+
pendingTurnStart: true,
628+
});
605629
if (input.modelSelection !== undefined) {
606630
threadModelSelections.set(input.threadId, input.modelSelection);
607631
}

0 commit comments

Comments
 (0)