Skip to content

armgit / eve

Public Imported from GitHub
0

The Open Framework for Building Agents

test(e2e): cover authorized approval responses (#1824)

Ben Pankowee8943b65368
diff --git a/.changeset/recover-cancelled-approval-settlements.md b/.changeset/recover-cancelled-approval-settlements.md
new file mode 100644
index 000000000..6bfeb6e7c
--- /dev/null
+++ b/.changeset/recover-cancelled-approval-settlements.md
@@ -0,0 +1,5 @@
+---
+"eve": patch
+---
+
+Recover cancelled responder-authorized approvals after replay so the pending tool call remains cancelled and cannot hang while waiting for a consumed response.
diff --git a/docs/concepts/sessions-runs-and-streaming.md b/docs/concepts/sessions-runs-and-streaming.md
index 6915401e3..f25fea304 100644
--- a/docs/concepts/sessions-runs-and-streaming.md
+++ b/docs/concepts/sessions-runs-and-streaming.md
@@ -160,7 +160,7 @@ curl -X POST http://127.0.0.1:2000/eve/v1/session/<sessionId> \
Message sends default to cancellation-backed `"steer"`; if a turn is active, eve buffers the follow-up, cancels that turn, and starts the message under a new turn ID. Channels and TypeScript `Session.send(...)` calls can select `turnPolicy: "queue"` when active work should finish first. Structured `inputResponses` never steer.
-If one pending batch is waiting on a human-in-the-loop approval, a matching text reply such as `approve` or `cancel` answers it. Unrelated text starts an ordinary turn immediately without denying the tool call; the approval stays pending and answerable. A later structured `inputResponses` answer keyed by its `requestId` still resumes the original tool call, even after intervening turns.
+If the session is waiting on a human-in-the-loop approval, respond with the channel’s Approve or Cancel controls. Text messages do not decide an approval; unrelated text starts an ordinary turn while the approval stays pending and answerable. A later structured `inputResponses` answer keyed by its `requestId` still resumes the original tool call, even after intervening turns.
With one question-only batch, an exact option match or permitted freeform response answers `ask_question`. Any other follow-up marks the question unanswered and starts the new turn. With several approval or question batches pending, eve does not guess which batch plain text addresses: the message starts an ordinary turn and the batches stay open. Use structured responses to target requests unambiguously.
diff --git a/e2e/fixtures/agent-tools-hitl/agent/channels/eve.ts b/e2e/fixtures/agent-tools-hitl/agent/channels/eve.ts
index 389c206f2..dd6784991 100644
--- a/e2e/fixtures/agent-tools-hitl/agent/channels/eve.ts
+++ b/e2e/fixtures/agent-tools-hitl/agent/channels/eve.ts
@@ -1,23 +1,16 @@
-import type { AuthFn } from "eve/channels/auth";
import { eveChannel } from "eve/channels/eve";
-import type { SessionAuthContext } from "eve/context";
-
-/**
- * Authored eve channel for the interactive-authorization evals. Interactive
- * authorizations are always `principalType: "user"`, and the eval driver is
- * otherwise anonymous (`local-dev` on the local world), which fails principal
- * resolution before a challenge can open. Every caller maps to one fixed end
- * user (fixture-only; do not pattern production channels off this).
- */
-const authenticateDefaultUser: AuthFn<Request> = (): SessionAuthContext => ({
- attributes: {},
- authenticator: "e2e-fixture",
- issuer: "e2e",
- principalId: "e2e-user",
- principalType: "user",
- subject: "e2e-user",
-});
+/** Fixture-only authentication for interactive authorization evals. */
export default eveChannel({
- auth: [authenticateDefaultUser],
+ auth: (request) => {
+ const principalId = request.headers.get("x-eve-fixture-user") ?? "e2e-approval-responder";
+ return {
+ attributes: { fixture: "authorized-response" },
+ authenticator: "e2e-fixture",
+ issuer: "e2e",
+ principalId,
+ principalType: "user",
+ subject: principalId,
+ };
+ },
});
diff --git a/e2e/fixtures/agent-tools-hitl/agent/tools/authorized-gate.ts b/e2e/fixtures/agent-tools-hitl/agent/tools/authorized-gate.ts
new file mode 100644
index 000000000..2efc23913
--- /dev/null
+++ b/e2e/fixtures/agent-tools-hitl/agent/tools/authorized-gate.ts
@@ -0,0 +1,18 @@
+import { defineTool } from "eve/tools";
+import { always } from "eve/tools/approval";
+import { z } from "zod";
+
+export default defineTool({
+ description: "PROOF-ONLY: executes after an authenticated response policy allows approval.",
+ inputSchema: z.object({ marker: z.string() }),
+ approval: {
+ request: always(),
+ response: ({ response, responder }) =>
+ response.decision === "approve" && responder.principalId === "e2e-approval-responder"
+ ? ({ status: "allowed" } as const)
+ : ({ status: "rejected", reason: "Unexpected eval responder." } as const),
+ },
+ async execute({ marker }) {
+ return { executed: true, marker };
+ },
+});
diff --git a/e2e/fixtures/agent-tools-hitl/agent/tools/oauth-authorized-gate.ts b/e2e/fixtures/agent-tools-hitl/agent/tools/oauth-authorized-gate.ts
new file mode 100644
index 000000000..e7ddd1e4d
--- /dev/null
+++ b/e2e/fixtures/agent-tools-hitl/agent/tools/oauth-authorized-gate.ts
@@ -0,0 +1,51 @@
+import {
+ ConnectionAuthorizationRequiredError,
+ defineInteractiveAuthorization,
+} from "eve/connections";
+import { defineTool } from "eve/tools";
+import { always } from "eve/tools/approval";
+import { z } from "zod";
+
+const tokens = new Map<string, string>();
+const fakeOAuth = defineInteractiveAuthorization<{ principalId: string }>({
+ displayName: "Fixture OAuth",
+ async getToken({ principal }) {
+ if (principal.type !== "user") throw new Error("Expected a user principal.");
+ const token = tokens.get(principal.id);
+ if (token === undefined) throw new ConnectionAuthorizationRequiredError("fixture-oauth");
+ return { providerSubject: principal.id, token };
+ },
+ async startAuthorization({ callbackUrl, principal }) {
+ if (principal.type !== "user") throw new Error("Expected a user principal.");
+ const url = new URL(callbackUrl);
+ url.searchParams.set("code", "fake-oauth-code");
+ return {
+ challenge: { instructions: "Complete fixture OAuth.", url: url.href },
+ resume: { principalId: principal.id },
+ };
+ },
+ async completeAuthorization({ callback, resume }) {
+ if (callback.params.code !== "fake-oauth-code" || resume === undefined) {
+ throw new Error("Unexpected fixture OAuth callback.");
+ }
+ tokens.set(resume.principalId, "fake-oauth-token");
+ return { providerSubject: resume.principalId, token: "fake-oauth-token" };
+ },
+});
+
+export default defineTool({
+ description: "PROOF-ONLY: executes after a fake responder OAuth flow.",
+ inputSchema: z.object({ marker: z.string() }),
+ approval: {
+ request: always(),
+ async response({ auth, responder }) {
+ const credential = await auth.getToken(fakeOAuth, { authKey: "fixture-oauth" });
+ return credential.providerSubject === responder.principalId
+ ? { status: "allowed" }
+ : { status: "rejected", reason: "Fixture OAuth identity mismatch." };
+ },
+ },
+ async execute({ marker }) {
+ return { executed: true, marker };
+ },
+});
diff --git a/e2e/fixtures/agent-tools-hitl/agent/tools/responder-gate.ts b/e2e/fixtures/agent-tools-hitl/agent/tools/responder-gate.ts
new file mode 100644
index 000000000..3f54546e8
--- /dev/null
+++ b/e2e/fixtures/agent-tools-hitl/agent/tools/responder-gate.ts
@@ -0,0 +1,18 @@
+import { defineTool } from "eve/tools";
+import { always } from "eve/tools/approval";
+import { z } from "zod";
+
+export default defineTool({
+ description: "PROOF-ONLY: only the authorized fixture responder may approve.",
+ inputSchema: z.object({ marker: z.string() }),
+ approval: {
+ request: always(),
+ response: ({ responder }) =>
+ responder.principalId === "e2e-approval-responder"
+ ? { status: "allowed" }
+ : { status: "rejected", reason: "This responder is not authorized." },
+ },
+ async execute({ marker }) {
+ return { executed: true, marker };
+ },
+});
diff --git a/e2e/fixtures/agent-tools-hitl/evals/hitl/authorized-response-oauth-cancel.eval.ts b/e2e/fixtures/agent-tools-hitl/evals/hitl/authorized-response-oauth-cancel.eval.ts
new file mode 100644
index 000000000..41ff36c23
--- /dev/null
+++ b/e2e/fixtures/agent-tools-hitl/evals/hitl/authorized-response-oauth-cancel.eval.ts
@@ -0,0 +1,51 @@
+import { defineEval } from "eve/evals";
+
+const MARKER = "authorized-response-oauth-cancel-P6W2";
+const TOOL_NAME = "oauth-authorized-gate";
+
+export default defineEval({
+ tags: ["real-model"],
+ description: "Cancel beats a candidate parked on OAuth and a late callback cannot execute.",
+ async test(t) {
+ const parked = await t.send(`Call the \`${TOOL_NAME}\` tool with marker "${MARKER}".`);
+ const approval = t.requireInputRequest({ display: "confirmation", toolName: TOOL_NAME });
+ const approvalTurn = await t.startRespond(
+ [{ optionId: "approve", requestId: approval.requestId }],
+ { headers: { "x-eve-fixture-user": "oauth-cancel-responder" } },
+ );
+ const required = await approvalTurn.waitForEvent("authorization.required");
+
+ const cancelTurn = await approvalTurn.session.startRespond([
+ { optionId: "cancel", requestId: approval.requestId },
+ ]);
+ await cancelTurn.waitForEvent("approval.settled", {
+ data: { outcome: "cancelled", requestId: approval.requestId },
+ });
+ const cancelled = await cancelTurn.result();
+ cancelled.event("approval.settled", {
+ count: 1,
+ data: { outcome: "cancelled", requestId: approval.requestId },
+ });
+ cancelled.notEvent("action.result", {
+ data: { result: { kind: "tool-result", toolName: TOOL_NAME }, status: "completed" },
+ });
+
+ if (
+ required.type !== "authorization.required" ||
+ required.data.authorization?.url === undefined
+ ) {
+ throw new Error("Expected candidate OAuth URL.");
+ }
+ const callbackUrl = new URL(required.data.authorization.url);
+ const callback = await fetch(callbackUrl);
+ if (!callback.ok)
+ throw new Error(`Late fixture OAuth callback failed (${String(callback.status)}).`);
+
+ const late = await cancelTurn.session.send("Confirm the cancelled action did not execute.");
+ late.notEvent("approval.settled", { data: { outcome: "approved" } });
+ late.notEvent("action.result", {
+ data: { result: { kind: "tool-result", toolName: TOOL_NAME }, status: "completed" },
+ });
+ t.succeeded();
+ },
+});
diff --git a/e2e/fixtures/agent-tools-hitl/evals/hitl/authorized-response-oauth-nonblocking.eval.ts b/e2e/fixtures/agent-tools-hitl/evals/hitl/authorized-response-oauth-nonblocking.eval.ts
new file mode 100644
index 000000000..702244470
--- /dev/null
+++ b/e2e/fixtures/agent-tools-hitl/evals/hitl/authorized-response-oauth-nonblocking.eval.ts
@@ -0,0 +1,57 @@
+import { defineEval } from "eve/evals";
+
+const MARKER = "authorized-response-oauth-nonblocking-K3T9";
+const TOOL_NAME = "oauth-authorized-gate";
+
+export default defineEval({
+ tags: ["real-model"],
+ description: "A message runs while candidate OAuth stays open, then OAuth settles the approval.",
+ async test(t) {
+ const parked = await t.send(`Call the \`${TOOL_NAME}\` tool with marker "${MARKER}".`);
+ const approval = t.requireInputRequest({ display: "confirmation", toolName: TOOL_NAME });
+ const approvalTurn = await t.startRespond(
+ [{ optionId: "approve", requestId: approval.requestId }],
+ { headers: { "x-eve-fixture-user": "oauth-nonblocking-responder" } },
+ );
+ const required = await approvalTurn.waitForEvent("authorization.required");
+
+ const message = await approvalTurn.session.send(
+ "Do not call tools. Reply with exactly CANDIDATE-OAUTH-OPEN-OK.",
+ );
+ message.expectOk();
+ message.messageIncludes("CANDIDATE-OAUTH-OPEN-OK");
+ message.notEvent("approval.settled");
+ message.notEvent("action.result", {
+ data: { result: { kind: "tool-result", toolName: TOOL_NAME }, status: "completed" },
+ });
+
+ if (
+ required.type !== "authorization.required" ||
+ required.data.authorization?.url === undefined
+ ) {
+ throw new Error("Expected candidate OAuth URL.");
+ }
+ const callbackUrl = new URL(required.data.authorization.url);
+ const callbackTurn = t.target.watchTurn(approvalTurn.sessionId, {
+ startIndex: t.state?.streamIndex,
+ });
+ await new Promise((resolve) => setTimeout(resolve, 250));
+ const callback = await fetch(callbackUrl);
+ if (!callback.ok)
+ throw new Error(`Fixture OAuth callback failed (${String(callback.status)}).`);
+ const resumed = await callbackTurn.result();
+ resumed.event("authorization.completed", { count: 1, data: { outcome: "authorized" } });
+ resumed.event("approval.settled", {
+ count: 1,
+ data: { outcome: "approved", requestId: approval.requestId },
+ });
+ resumed.event("action.result", {
+ count: 1,
+ data: {
+ result: { kind: "tool-result", output: new RegExp(MARKER), toolName: TOOL_NAME },
+ status: "completed",
+ },
+ });
+ t.succeeded();
+ },
+});
diff --git a/e2e/fixtures/agent-tools-hitl/evals/hitl/authorized-response-oauth.eval.ts b/e2e/fixtures/agent-tools-hitl/evals/hitl/authorized-response-oauth.eval.ts
new file mode 100644
index 000000000..23fd79eff
--- /dev/null
+++ b/e2e/fixtures/agent-tools-hitl/evals/hitl/authorized-response-oauth.eval.ts
@@ -0,0 +1,65 @@
+import { defineEval } from "eve/evals";
+
+const MARKER = "authorized-response-oauth-e2e-R8N5";
+const TOOL_NAME = "oauth-authorized-gate";
+
+export default defineEval({
+ tags: ["real-model"],
+ description: "Approval response policy parks for fake OAuth, resumes, and settles.",
+ async test(t) {
+ const parked = await t.send(`Call the \`${TOOL_NAME}\` tool with marker "${MARKER}".`);
+ const approval = t.requireInputRequest({ display: "confirmation", toolName: TOOL_NAME });
+ const approvalTurn = await t.startRespond([
+ {
+ optionId: "approve",
+ requestId: approval.requestId,
+ },
+ ]);
+
+ const required = await approvalTurn.waitForEvent("authorization.required");
+ if (
+ required?.type !== "authorization.required" ||
+ required.data.authorization?.url === undefined
+ ) {
+ throw new Error("Expected a fake OAuth authorization URL.");
+ }
+ const callbackUrl = new URL(required.data.authorization.url);
+ if (callbackUrl.origin !== new URL(t.target.url).origin) {
+ throw new Error("Fixture OAuth callback targeted an unexpected origin.");
+ }
+ const callback = await fetch(callbackUrl);
+ if (!callback.ok) {
+ throw new Error(
+ `Fixture OAuth callback failed (${String(callback.status)}): ${await callback.text()}`,
+ );
+ }
+
+ const resumed = await approvalTurn.result();
+ resumed.event("approval.candidate", {
+ data: { outcome: "pending", requestId: approval.requestId },
+ count: 1,
+ });
+ resumed.event("authorization.required", { count: 1 });
+ resumed.expectOk();
+ resumed.event("authorization.completed", {
+ data: { candidateId: required.data.candidateId, outcome: "authorized" },
+ count: 1,
+ });
+ resumed.event("approval.settled", {
+ data: { outcome: "approved", requestId: approval.requestId },
+ count: 1,
+ });
+ resumed.event("action.result", {
+ data: {
+ result: {
+ kind: "tool-result",
+ output: new RegExp(MARKER),
+ toolName: TOOL_NAME,
+ },
+ status: "completed",
+ },
+ count: 1,
+ });
+ t.succeeded();
+ },
+});
diff --git a/e2e/fixtures/agent-tools-hitl/evals/hitl/authorized-response.eval.ts b/e2e/fixtures/agent-tools-hitl/evals/hitl/authorized-response.eval.ts
new file mode 100644
index 000000000..a7cc3ae2d
--- /dev/null
+++ b/e2e/fixtures/agent-tools-hitl/evals/hitl/authorized-response.eval.ts
@@ -0,0 +1,43 @@
+import { defineEval } from "eve/evals";
+
+const MARKER = "authorized-response-e2e-Q7M4";
+const TOOL_NAME = "authorized-gate";
+
+export default defineEval({
+ tags: ["real-model"],
+ description: "Authenticated response policy emits candidate and settlement before execution.",
+ async test(t) {
+ const parked = await t.send(`Call the \`${TOOL_NAME}\` tool with marker "${MARKER}".`);
+ const approval = t.requireInputRequest({ display: "confirmation", toolName: TOOL_NAME });
+ parked.calledTool(TOOL_NAME, { status: "pending", count: 1 });
+
+ const approved = await t.respond([
+ {
+ optionId: "approve",
+ requestId: approval.requestId,
+ },
+ ]);
+
+ approved.expectOk();
+ approved.event("approval.candidate", {
+ data: { outcome: "pending", requestId: approval.requestId },
+ count: 1,
+ });
+ approved.event("approval.settled", {
+ data: { outcome: "approved", requestId: approval.requestId },
+ count: 1,
+ });
+ approved.event("action.result", {
+ data: {
+ result: {
+ kind: "tool-result",
+ output: new RegExp(MARKER),
+ toolName: TOOL_NAME,
+ },
+ status: "completed",
+ },
+ count: 1,
+ });
+ t.succeeded();
+ },
+});
diff --git a/e2e/fixtures/agent-tools-hitl/evals/hitl/text-approve.eval.ts b/e2e/fixtures/agent-tools-hitl/evals/hitl/text-approve.eval.ts
index 0fb2f025c..00134b285 100644
--- a/e2e/fixtures/agent-tools-hitl/evals/hitl/text-approve.eval.ts
+++ b/e2e/fixtures/agent-tools-hitl/evals/hitl/text-approve.eval.ts
@@ -1,14 +1,39 @@
import { defineEval } from "eve/evals";
+const MARKER = "authorized-response-retry-e2e-N4J8";
+const TOOL_NAME = "responder-gate";
+
export default defineEval({
tags: ["real-model"],
- description: "HITL smoke: approval decisions use structured controls.",
+ description: "A rejected responder leaves the approval open for an authorized retry.",
async test(t) {
- const parked = await t.send('Call the guarded-echo tool with note "button-only".');
- parked.calledTool("guarded-echo", { status: "pending", count: 1 });
- const request = t.requireInputRequest({ display: "confirmation", toolName: "guarded-echo" });
- const cancelled = await t.respond([{ optionId: "cancel", requestId: request.requestId }]);
- cancelled.expectOk();
+ const parked = await t.send(`Call the \`${TOOL_NAME}\` tool with marker "${MARKER}".`);
+ const approval = t.requireInputRequest({ display: "confirmation", toolName: TOOL_NAME });
+ parked.calledTool(TOOL_NAME, { status: "pending", count: 1 });
+
+ const rejectedTurn = await t.startRespond(
+ [{ optionId: "approve", requestId: approval.requestId }],
+ { headers: { "x-eve-fixture-user": "unauthorized-responder" } },
+ );
+ await rejectedTurn.waitForEvent("approval.candidate", {
+ data: { outcome: "rejected", requestId: approval.requestId },
+ });
+
+ const approved = await rejectedTurn.session.respond([
+ { optionId: "approve", requestId: approval.requestId },
+ ]);
+ approved.expectOk();
+ approved.event("approval.settled", {
+ count: 1,
+ data: { outcome: "approved", requestId: approval.requestId },
+ });
+ approved.event("action.result", {
+ count: 1,
+ data: {
+ result: { kind: "tool-result", output: new RegExp(MARKER), toolName: TOOL_NAME },
+ status: "completed",
+ },
+ });
t.succeeded();
},
});
diff --git a/packages/eve/src/evals/context.ts b/packages/eve/src/evals/context.ts
index a44b5bf2a..39d47fae8 100644
--- a/packages/eve/src/evals/context.ts
+++ b/packages/eve/src/evals/context.ts
@@ -56,6 +56,7 @@ export function createEvalContext(deps: {
cancel: () => primary().cancel(),
requireInputRequest: (filter) => primary().requireInputRequest(filter),
respond: (responses, options) => primary().respond(responses, options),
+ startRespond: (responses, options) => primary().startRespond(responses, options),
respondAll: (optionId) => primary().respondAll(optionId),
send: (message, options) => {
lastPrompt = typeof message === "string" ? message : "";
diff --git a/packages/eve/src/evals/session.ts b/packages/eve/src/evals/session.ts
index a468e2a00..67a6fccbe 100644
--- a/packages/eve/src/evals/session.ts
+++ b/packages/eve/src/evals/session.ts
@@ -169,6 +169,14 @@ export class EvalSessionDriver implements EveEvalSession {
return await (await this.#start({ ...options, inputResponses: responses })).result();
}
+ async startRespond(
+ responses: readonly InputResponse[],
+ options: SendTurnOptions = {},
+ ): Promise<EveEvalLiveTurn> {
+ if (responses.length === 0) throw new Error("startRespond() requires input responses.");
+ return await this.#start({ ...options, inputResponses: responses });
+ }
+
async respondAll(optionId: string): Promise<EveEvalTurn> {
const requests = this.#pendingInputRequests;
if (requests.length === 0) {
diff --git a/packages/eve/src/evals/types.ts b/packages/eve/src/evals/types.ts
index 80117c241..36e9dd9da 100644
--- a/packages/eve/src/evals/types.ts
+++ b/packages/eve/src/evals/types.ts
@@ -303,6 +303,11 @@ export interface EveEvalSessionDriver {
requireInputRequest(filter?: EveEvalInputRequestMatchOptions): InputRequest;
/** Resolve specific pending requests and run the resumed turn. */
respond(responses: readonly InputResponse[], options?: SendTurnOptions): Promise<EveEvalTurn>;
+ /** Start a response turn without waiting for its boundary. */
+ startRespond(
+ responses: readonly InputResponse[],
+ options?: SendTurnOptions,
+ ): Promise<EveEvalLiveTurn>;
/** Resolve every pending request with the same option id. */
respondAll(optionId: string): Promise<EveEvalTurn>;
/** Send one turn through this session. */
diff --git a/packages/eve/src/harness/approval-delivery-coordinator.test.ts b/packages/eve/src/harness/approval-delivery-coordinator.test.ts
index f6ba09389..1a84c46ad 100644
--- a/packages/eve/src/harness/approval-delivery-coordinator.test.ts
+++ b/packages/eve/src/harness/approval-delivery-coordinator.test.ts
@@ -62,4 +62,24 @@ describe("coordinateApprovalDelivery", () => {
{ optionId: "approve", requestId: request.requestId },
]);
});
+
+ it("recovers a cancelled settlement before its synthetic response is consumed", async () => {
+ const parked = parkedSession();
+ const settled = settleDirectApprovalResponse({
+ actor: responder,
+ outcome: "cancelled",
+ requestId: request.requestId,
+ settledAt: 100,
+ state: parked.state,
+ });
+ const result = await coordinateApprovalDelivery({
+ now: 101,
+ session: { ...parked, state: settled.state },
+ tools: new Map(),
+ });
+ expect(result.kind).toBe("continue");
+ expect(result.stepInput?.inputResponses).toEqual([
+ { optionId: "cancel", requestId: request.requestId },
+ ]);
+ });
});
diff --git a/packages/eve/src/harness/approval-delivery-coordinator.ts b/packages/eve/src/harness/approval-delivery-coordinator.ts
index ae988e69c..15fb6ba56 100644
--- a/packages/eve/src/harness/approval-delivery-coordinator.ts
+++ b/packages/eve/src/harness/approval-delivery-coordinator.ts
@@ -16,6 +16,7 @@ import {
settleAllowedCandidate,
settleDirectApprovalResponse,
type ActiveApprovalCandidate,
+ type ApprovalSettlementAuditRecord,
} from "#harness/approval-candidates.js";
import {
clearPendingAuthorization,
@@ -118,13 +119,8 @@ export async function coordinateApprovalDelivery(input: {
const pendingRequestIds = new Set(
batches.flatMap((batch) => batch.requests.map((request) => request.requestId)),
);
- const allowedRequestIds = new Set(
- audit.settlements
- .filter(
- (settlement) =>
- settlement.outcome === "allowed" && pendingRequestIds.has(settlement.requestId),
- )
- .map((settlement) => settlement.requestId),
+ const pendingSettlements = audit.settlements.filter((settlement) =>
+ pendingRequestIds.has(settlement.requestId),
);
const settledRequestIds = new Set(audit.settlements.map((settlement) => settlement.requestId));
const discardedDuplicate = hasResponseForRequest(input.stepInput, settledRequestIds);
@@ -133,7 +129,7 @@ export async function coordinateApprovalDelivery(input: {
: input.stepInput;
if (
discardedDuplicate &&
- allowedRequestIds.size === 0 &&
+ pendingSettlements.length === 0 &&
!hasMeaningfulInput(deduplicatedInput)
) {
return deliveryResult(session, deduplicatedInput, "park");
@@ -297,11 +293,11 @@ export async function coordinateApprovalDelivery(input: {
const settlement = getApprovalAuditState(session.state).settlements.find(
(entry) => entry.requestId === candidate.requestId,
);
- if (settlement?.outcome === "allowed") allowedRequestIds.add(candidate.requestId);
+ if (settlement !== undefined) pendingSettlements.push(settlement);
}
- const resumedStepInput = appendAllowedResponses(remainingStepInput, allowedRequestIds);
- if (allowedRequestIds.size > 0) {
+ const resumedStepInput = appendSettledResponses(remainingStepInput, pendingSettlements);
+ if (pendingSettlements.length > 0) {
return deliveryResult(session, resumedStepInput, "continue");
}
return didCommit
@@ -478,16 +474,19 @@ function hasMeaningfulInput(stepInput: StepInput | undefined): boolean {
);
}
-function appendAllowedResponses(
+function appendSettledResponses(
stepInput: StepInput | undefined,
- requestIds: ReadonlySet<string>,
+ settlements: readonly ApprovalSettlementAuditRecord[],
): StepInput | undefined {
- if (requestIds.size === 0) return stepInput;
+ if (settlements.length === 0) return stepInput;
return {
...stepInput,
inputResponses: [
...(stepInput?.inputResponses ?? []),
- ...[...requestIds].map((requestId) => ({ optionId: "approve", requestId })),
+ ...settlements.map((settlement) => ({
+ optionId: settlement.outcome === "allowed" ? "approve" : "cancel",
+ requestId: settlement.requestId,
+ })),
],
};
}