Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
Original file line number Diff line number Diff line change
Expand Up @@ -3229,6 +3229,93 @@ it.effect("reports a restart that stops the running turn as restarted", () =>
}),
);

it.effect("replays an accepted steer after its target turn completes", () =>
Effect.gen(function* () {
const name = "steer-retry-after-completion";
const { events, started, steered, layer, startFirstTurn } =
yield* nextTurnSelectionHarness(name);
yield* Effect.gen(function* () {
const orchestrator = yield* Orchestrator.OrchestratorV2;
const worker = yield* EffectWorker.OrchestrationEffectWorkerV2;
const threadManagement = yield* ThreadManagementService.ThreadManagementService;
const threadId = yield* startFirstTurn;
const input = {
projectId: ProjectId.make(`project:${name}`),
commandId: CommandId.make("steer"),
threadId,
messageId: MessageId.make("message:steer"),
text: "Please report the test result",
attachments: [],
mode: "steer",
createdBy: "agent",
creationSource: "mcp",
} as const;
const accepted = yield* threadManagement.sendToThread(input);
assert.equal(accepted.delivery, "steered");
yield* worker.drain();

const waiting = yield* orchestrator.streamDomainEvents.pipe(
Stream.filter(
(event) =>
event.type === "run.updated" &&
event.payload.id === accepted.run.id &&
event.payload.status === "waiting",
),
Stream.take(1),
Stream.runDrain,
Effect.forkScoped({ startImmediately: true }),
);
const turn = (yield* orchestrator.getThreadProjection(threadId)).providerTurns[0]!;
yield* Queue.offer(events, {
type: "provider_turn.updated",
driver,
providerTurn: { ...turn, status: "completed", completedAt: yield* DateTime.now },
});
yield* Queue.offer(events, {
type: "turn.terminal",
driver,
providerThreadId: turn.providerThreadId,
providerTurnId: turn.id,
runOrdinal: accepted.run.ordinal,
status: "completed",
failure: null,
threadDisposition: "reusable",
});
yield* Fiber.join(waiting);
yield* worker.drain();

const replayed = yield* threadManagement.sendToThread(input);
assert.equal(replayed.dispatch.replayed, true);
assert.equal(replayed.delivery, accepted.delivery);
assert.equal(replayed.message.id, accepted.message.id);
assert.equal(replayed.run.id, accepted.run.id);
assert.equal(replayed.run.status, "completed");

const fresh = yield* threadManagement
.sendToThread({
...input,
commandId: CommandId.make("fresh-steer"),
messageId: MessageId.make("message:fresh-steer"),
})
.pipe(Effect.flip);
assert.equal(fresh._tag, "ThreadManagementNoSteerableRunError");
yield* worker.drain();
assert.deepEqual(steered, [input.text]);
assert.lengthOf(started, 1);
}).pipe(
Effect.provide(
ThreadManagementService.layer.pipe(
Layer.provideMerge(layer),
Layer.provide(ServerSettings.layerTest()),
Layer.provide(
CommandReceiptStore.layer.pipe(Layer.provide(SqlitePersistence.layerMemory)),
),
),
),
);
}),
);

it.effect("queues a goal clear without stopping work when no goal drives it", () =>
Effect.gen(function* () {
const { steered, layer, startFirstTurn, send, read } = yield* goalHarness("goal-clear");
Expand Down
26 changes: 14 additions & 12 deletions apps/server/src/orchestration-v2/ThreadManagementService.ts
Original file line number Diff line number Diff line change
Expand Up @@ -880,32 +880,34 @@ const make = Effect.gen(function* () {
input.freshContext && (input.mode === "steer" || input.mode === "restart")
? "queue"
: input.mode;
const explicitSteer = mode === "steer" || mode === "restart";
const missingSteeringTarget = explicitSteer && steerableRun === undefined;
// A command receipt outlives its target turn. Dispatch validates and replays it.
if (missingSteeringTarget && !(yield* hasReceipt(input.commandId))) {
return yield* new ThreadManagementNoSteerableRunError({
threadId: input.threadId,
mode,
});
}

let dispatchMode: Extract<
OrchestrationV2Command,
{ readonly type: "message.dispatch" }
>["dispatchMode"];
if (mode === "steer" || mode === "restart") {
if (steerableRun === undefined) {
return yield* new ThreadManagementNoSteerableRunError({
threadId: input.threadId,
mode,
});
}
if ((explicitSteer || mode === "auto") && steerableRun !== undefined) {
dispatchMode = {
type: mode === "steer" ? "steer_active" : "restart_active",
type: mode === "restart" ? "restart_active" : "steer_active",
targetRunId: steerableRun.id,
};
} else if (mode === "auto" && steerableRun !== undefined) {
dispatchMode = { type: "steer_active", targetRunId: steerableRun.id };
} else {
dispatchMode = {
type: mode === "queue" ? "queue_after_active" : "start_immediately",
};
}

// Turn start would fail on its own after the send reported success; a replay keeps its answer.
// A live steer starts no turn, so it needs no workspace.
if (dispatchMode.type !== "steer_active") {
// A live steer and a receipt replay without a target turn need no workspace.
if (!missingSteeringTarget && dispatchMode.type !== "steer_active") {
yield* worktreeRestore
.restore(target.thread)
.pipe(
Expand Down
Loading