Skip to content

Commit 449ad5c

Browse files
fix(server): keep a user's approval answer when Pi, OpenCode or Muse confirm it
When a user answers an approval request, the orchestrator records the request as resolved with the decision, and marks the request's card and node cancelled for a decline. Only then does it hand the answer to the provider. Pi and OpenCode v1 then re-emitted the request record they had cached when it was asked, with no decision and the card completed, and Muse marked the card completed even for a decline. Provider events replace the projected records, so the thread lost the decision and showed a declined approval as completed. Pi no longer reports a request it just answered. OpenCode v1 remembers the requests T3 answered and, when OpenCode confirms one or its turn ends, only stops tracking it instead of reporting it again. Muse settles a declined or cancelled request's card and node as cancelled. Co-Authored-By: Claude Opus 5.5 <[email protected]>
1 parent 405ad19 commit 449ad5c

5 files changed

Lines changed: 200 additions & 52 deletions

File tree

‎apps/server/src/orchestration-v2/testkit/OrchestratorReplayFixtures.integration.test.ts‎

Lines changed: 153 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -457,8 +457,161 @@ describe("orchestrator replay fixtures", () => {
457457
}),
458458
);
459459
}
460+
461+
// Pi and OpenCode report a request answered after T3 sends its answer. The
462+
// orchestrator's record (decision, decline status) must survive that
463+
// acknowledgement.
464+
it.effect.each(
465+
(
466+
[
467+
["opencode", "opencode_child_approval", "accept"],
468+
["opencode", "opencode_child_approval", "decline"],
469+
["pi", "simple", "accept"],
470+
["pi", "simple", "decline"],
471+
] as const
472+
).flatMap(([driver, fixtureName, decision]) => {
473+
const fixture = ORCHESTRATOR_REPLAY_FIXTURES.find(
474+
(candidate) => candidate.name === fixtureName,
475+
);
476+
const provider = fixture?.providers.find((candidate) => candidate.driver === driver);
477+
return fixture === undefined || provider === undefined
478+
? []
479+
: [[driver, decision, fixture, provider] as const];
480+
}),
481+
)(
482+
"keeps the answer through %s's acknowledgement (%s)",
483+
([driver, decision, fixture, provider]) => {
484+
const prompt = fixture.buildInput().steps[0];
485+
return runFixtureProviderWithRegisteredHarness({
486+
fixtureName: fixture.name,
487+
buildInput: () => ({
488+
steps: [
489+
...(prompt === undefined ? [] : [prompt]),
490+
{ type: "approve_next_runtime_request", decision },
491+
],
492+
}),
493+
driver: {
494+
...provider,
495+
assertOutput: (result) => {
496+
const status = decision === "accept" ? "completed" : "cancelled";
497+
const projection = [...result.projections.values()].find(
498+
(candidate) => candidate.thread.lineage.parentThreadId === null,
499+
);
500+
const item = projection?.turnItems.find(
501+
(candidate) => candidate.type === "approval_request",
502+
);
503+
assert.deepInclude(item, { status });
504+
assert.deepInclude(projection?.runtimeRequests[0], { status: "resolved", decision });
505+
// The last word on the card and the request, as every client and a replay read them.
506+
const card = result.domainEvents.findLast(
507+
(event) => event.type === "turn-item.updated" && event.payload.id === item?.id,
508+
);
509+
assert.deepInclude(card?.payload, { status });
510+
const request = result.domainEvents.findLast(
511+
(event) => event.type === "runtime-request.updated",
512+
);
513+
assert.deepInclude(request?.payload, { status: "resolved", decision });
514+
},
515+
},
516+
transformTranscript: (transcript) =>
517+
driver === "pi"
518+
? withPiConfirm(transcript, decision)
519+
: withOpenCodeReply(transcript, decision),
520+
});
521+
},
522+
);
523+
524+
it.effect("keeps a decline through muse's acknowledgement", () => {
525+
const fixture = ORCHESTRATOR_REPLAY_FIXTURES.find(
526+
(candidate) => candidate.name === "muse_permission",
527+
);
528+
const provider = fixture?.providers.find((candidate) => candidate.driver === "muse");
529+
assert.isDefined(fixture);
530+
assert.isDefined(provider);
531+
return runFixtureProviderWithRegisteredHarness({
532+
fixtureName: fixture.name,
533+
buildInput: fixture.buildInput,
534+
driver: {
535+
...provider,
536+
assertOutput: (result) => {
537+
const projection = [...result.projections.values()].find(
538+
(candidate) => candidate.thread.lineage.parentThreadId === null,
539+
);
540+
// Each request's card ends as the orchestrator recorded its answer.
541+
assert.deepEqual(
542+
(projection?.runtimeRequests ?? [])
543+
.toSorted((left, right) => (left.createdAt < right.createdAt ? -1 : 1))
544+
.map((request) => [
545+
request.decision,
546+
projection?.turnItems.find(
547+
(item) => item.type === "approval_request" && item.nodeId === request.nodeId,
548+
)?.status,
549+
]),
550+
[
551+
["accept", "completed"],
552+
["decline", "cancelled"],
553+
],
554+
);
555+
},
556+
},
557+
});
558+
});
460559
});
461560

561+
/** Adds an extension confirm dialog to the turn and the answer T3 sends for it. */
562+
function withPiConfirm(
563+
transcript: ProviderReplayTranscript,
564+
decision: "accept" | "decline",
565+
): ProviderReplayTranscript {
566+
const at = transcript.entries.findIndex(
567+
(entry) => entry.type === "emit_inbound" && entry.label === "turn_start",
568+
);
569+
const id = "ui-approval";
570+
return {
571+
...transcript,
572+
entries: [
573+
...transcript.entries.slice(0, at + 1),
574+
{
575+
type: "emit_inbound",
576+
label: "extension_ui_request.confirm",
577+
frame: { type: "extension_ui_request", id, method: "confirm", title: "Allow bash?" },
578+
},
579+
{
580+
type: "expect_outbound",
581+
label: "extension_ui_response",
582+
frame: { type: "extension_ui_response", id, confirmed: decision === "accept" },
583+
},
584+
...transcript.entries.slice(at + 1),
585+
],
586+
};
587+
}
588+
589+
/** The recorded permission reply and its echo, rejected instead when declining. */
590+
function withOpenCodeReply(
591+
transcript: ProviderReplayTranscript,
592+
decision: "accept" | "decline",
593+
): ProviderReplayTranscript {
594+
if (decision === "accept") return transcript;
595+
return {
596+
...transcript,
597+
entries: transcript.entries.map((entry) => {
598+
if (entry.type === "expect_outbound" && entry.label === "permission.reply") {
599+
const frame = entry.frame as { readonly input: object };
600+
return { ...entry, frame: { ...frame, input: { ...frame.input, reply: "reject" } } };
601+
}
602+
if (entry.type === "emit_inbound" && entry.label === "child.permission.replied") {
603+
const frame = entry.frame as { readonly event: { readonly properties: object } };
604+
const event = {
605+
...frame.event,
606+
properties: { ...frame.event.properties, reply: "reject" },
607+
};
608+
return { ...entry, frame: { ...frame, event } };
609+
}
610+
return entry;
611+
}),
612+
};
613+
}
614+
462615
/** The same event with an envelope this build cannot decode, as a newer OpenCode may send. */
463616
function undecodableEvent(entry: ProviderReplayEntry): ProviderReplayEntry {
464617
if (entry.type !== "emit_inbound") return entry;

‎packages/provider-muse/src/server/adapter.ts‎

Lines changed: 8 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -933,24 +933,21 @@ export const makeMuseAdapterV2 = Effect.fn("makeMuseAdapterV2")(function* (
933933
status: "resolved" | "cancelled",
934934
) {
935935
const time = yield* DateTime.now;
936+
const decision = entry.response?.decision;
937+
// A declined request ends cancelled, as the orchestrator records T3's own answer.
938+
const settled =
939+
status === "resolved" && decision !== "decline" && decision !== "cancel"
940+
? "completed"
941+
: "cancelled";
936942
entry.request = {
937943
...entry.request,
938944
...(status === "resolved" ? entry.response : undefined),
939945
status,
940946
resolvedAt: time,
941947
responseCapability: { type: "not_resumable", reason: "This Muse request has ended." },
942948
};
943-
entry.node = {
944-
...entry.node,
945-
status: status === "resolved" ? "completed" : "cancelled",
946-
completedAt: time,
947-
};
948-
entry.item = {
949-
...entry.item,
950-
status: status === "resolved" ? "completed" : "cancelled",
951-
completedAt: time,
952-
updatedAt: time,
953-
};
949+
entry.node = { ...entry.node, status: settled, completedAt: time };
950+
entry.item = { ...entry.item, status: settled, completedAt: time, updatedAt: time };
954951
pending.delete(entry.request.id);
955952
yield* emit({
956953
type: "runtime_request.updated",

‎packages/provider-opencode/src/server/adapter.ts‎

Lines changed: 34 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -427,6 +427,11 @@ interface PendingOpenCodeRequest {
427427
readonly createdAt: DateTime.Utc;
428428
readonly permission?: PermissionRequest;
429429
readonly question?: QuestionRequest;
430+
/**
431+
* T3 is sending, or sent, its own answer, which the orchestrator already
432+
* recorded. It stays set if delivery fails: a retry still finds the request.
433+
*/
434+
answering: boolean;
430435
}
431436

432437
export interface OpenCodeAdapterV2Options {
@@ -1853,6 +1858,7 @@ export const makeOpenCodeAdapterV2 = Effect.fn("makeOpenCodeAdapterV2")(function
18531858
turnItemId,
18541859
requestKind,
18551860
createdAt: now,
1861+
answering: false,
18561862
...(request.type === "permission"
18571863
? { permission: request.value }
18581864
: { question: request.value }),
@@ -1909,6 +1915,20 @@ export const makeOpenCodeAdapterV2 = Effect.fn("makeOpenCodeAdapterV2")(function
19091915
yield* updateProviderSession("waiting", null);
19101916
});
19111917

1918+
/**
1919+
* Stops tracking a request. Requests T3 answered are only forgotten when
1920+
* OpenCode confirms them or their turn ends: the orchestrator already
1921+
* recorded their resolution and decision.
1922+
*/
1923+
const forgetRuntimeRequest = Effect.fnUntraced(function* (pending: PendingOpenCodeRequest) {
1924+
pendingRequests.delete(String(pending.requestId));
1925+
pendingRequestsByNativeId.delete(pending.nativeRequestId);
1926+
const hasOtherPending = Array.from(pendingRequests.values()).some(
1927+
(candidate) => candidate.turn.isRoot,
1928+
);
1929+
if (!hasOtherPending) yield* updateProviderSession("running", null);
1930+
});
1931+
19121932
const resolveRuntimeRequest = Effect.fnUntraced(function* (
19131933
nativeRequestId: string,
19141934
status: "resolved" | "cancelled",
@@ -1917,6 +1937,17 @@ export const makeOpenCodeAdapterV2 = Effect.fn("makeOpenCodeAdapterV2")(function
19171937
if (pending === undefined) return;
19181938
const now = yield* DateTime.now;
19191939
const current = pending.state.runtimeRequests.get(String(pending.requestId));
1940+
if (pending.answering) {
1941+
// Only snapshots learn of it: an event would replace the orchestrator's record.
1942+
if (current !== undefined) {
1943+
pending.state.runtimeRequests.set(String(pending.requestId), {
1944+
...current,
1945+
status: "resolved",
1946+
resolvedAt: now,
1947+
});
1948+
}
1949+
return yield* forgetRuntimeRequest(pending);
1950+
}
19201951
if (current !== undefined) {
19211952
const resolved: OrchestrationV2RuntimeRequest = {
19221953
...current,
@@ -1962,12 +1993,7 @@ export const makeOpenCodeAdapterV2 = Effect.fn("makeOpenCodeAdapterV2")(function
19621993
now,
19631994
),
19641995
});
1965-
pendingRequests.delete(String(pending.requestId));
1966-
pendingRequestsByNativeId.delete(nativeRequestId);
1967-
const hasOtherPending = Array.from(pendingRequests.values()).some(
1968-
(candidate) => candidate.turn.isRoot,
1969-
);
1970-
if (!hasOtherPending) yield* updateProviderSession("running", null);
1996+
yield* forgetRuntimeRequest(pending);
19711997
});
19721998

19731999
/** Resolve the thread state a session belongs to: its own, or for a
@@ -3499,6 +3525,7 @@ export const makeOpenCodeAdapterV2 = Effect.fn("makeOpenCodeAdapterV2")(function
34993525
pending.question,
35003526
requestInput.answers,
35013527
);
3528+
pending.answering = true;
35023529
yield* sdkCall(
35033530
"question.reply",
35043531
{ requestID: pending.nativeRequestId, answers },
@@ -3519,6 +3546,7 @@ export const makeOpenCodeAdapterV2 = Effect.fn("makeOpenCodeAdapterV2")(function
35193546
);
35203547
}
35213548
const reply = OpenCodeRuntime.toOpenCodePermissionReply(requestInput.decision);
3549+
pending.answering = true;
35223550
yield* sdkCall(
35233551
"permission.reply",
35243552
{ requestID: pending.nativeRequestId, reply },

‎packages/provider-pi/src/server/adapter.test.ts‎

Lines changed: 2 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -921,14 +921,8 @@ describe("PiAdapterV2", () => {
921921
const prompt = yield* fake.takeRequest("prompt");
922922
assert.equal(prompt["message"], "Continue the review");
923923
assert.equal(prompt["streamingBehavior"], "steer");
924-
const resolved = yield* takeEvent(
925-
(event) =>
926-
event.type === "runtime_request.updated" && event.runtimeRequest.id === dialog!.id,
927-
);
928-
assert.isTrue(
929-
resolved.type === "runtime_request.updated" &&
930-
resolved.runtimeRequest.status === "resolved",
931-
);
924+
// The orchestrator records the answer before asking for this response, so the
925+
// adapter does not report the dialog resolved again.
932926
}).pipe(Effect.scoped, Effect.provide(layerTest)),
933927
);
934928

‎packages/provider-pi/src/server/adapter.ts‎

Lines changed: 3 additions & 27 deletions
Original file line numberDiff line numberDiff line change
@@ -2907,33 +2907,9 @@ export const makePiAdapterV2 = Effect.fn("makePiAdapterV2")(function* (
29072907
if (pending.method === "confirm" && requestInput.decision === "acceptForSession") {
29082908
sessionApprovals.add(pending.approvalKey);
29092909
}
2910-
const resolvedAt = yield* DateTime.now;
2911-
pending.runtimeRequest = {
2912-
...pending.runtimeRequest,
2913-
status: "resolved",
2914-
resolvedAt,
2915-
};
2916-
yield* emit({
2917-
type: "runtime_request.updated",
2918-
driver: PI_PROVIDER,
2919-
threadId: pending.node.threadId,
2920-
runtimeRequest: pending.runtimeRequest,
2921-
});
2922-
yield* emit({
2923-
type: "node.updated",
2924-
driver: PI_PROVIDER,
2925-
node: { ...pending.node, status: "completed", completedAt: resolvedAt },
2926-
});
2927-
yield* emit({
2928-
type: "turn_item.updated",
2929-
driver: PI_PROVIDER,
2930-
turnItem: {
2931-
...pending.turnItem,
2932-
status: "completed",
2933-
completedAt: resolvedAt,
2934-
updatedAt: resolvedAt,
2935-
},
2936-
});
2910+
// The orchestrator recorded the answer and its decision before
2911+
// asking for this response; re-emitting the cached card would
2912+
// overwrite that record.
29372913
}).pipe(
29382914
sessionEventPermit.withPermits(1),
29392915
Effect.mapError(

0 commit comments

Comments
 (0)