The Open Framework for Building Agents
[6/6] fix(telegram): answer held tool approvals from buttons (#4215)
Ben Pankow79c4379e2ebc
diff --git a/.changeset/telegram-held-approval-buttons.md b/.changeset/telegram-held-approval-buttons.mdnew file mode 100644index 000000000..04f0a1045--- /dev/null+++ b/.changeset/telegram-held-approval-buttons.md@@ -0,0 +1,5 @@+---+"eve": patch+---++Telegram's Approve and Cancel buttons answer a tool approval again. Since approvals started holding the turn, a button press never resumed it and the turn waited until the person typed a reply.diff --git a/packages/eve/src/execution/proxied-deliver-step.ts b/packages/eve/src/execution/proxied-deliver-step.tsindex d3260cc2e..6ec9bc2d0 100644--- a/packages/eve/src/execution/proxied-deliver-step.ts+++ b/packages/eve/src/execution/proxied-deliver-step.ts@@ -79,7 +79,11 @@ export async function routeProxiedDeliverStep(async function routeProxiedDeliver(input: SessionStepState & { readonly delivery: DeliverHookPayload },): Promise<RoutedDeliverResult> {- const { delivery: sourceDelivery, serializedContext } = await deliverChannelInputResponses(input);+ const requests = getProxyInputRequests(readDurableSession(input.sessionState).state);+ const { delivery: sourceDelivery, serializedContext } = await deliverChannelInputResponses({+ ...input,+ routable: (response) => requests.has(response.requestId),+ });let durableSession = readDurableSession(input.sessionState);const parentPayloads = new Map<number, DeliverPayload>();const children = new Map<string, ChildBucket>();@@ -220,21 +224,47 @@ async function routeProxiedDeliver(return { ...context, kind: "continue", remainder };}+/**+ * Maps a delivery's channel-specific answers to the requests a held turn waits+ * on, so the turn can tell they answer it. Returns the mapped delivery, or+ * `undefined` when the channel maps none of them to one of `requestIds`.+ */+export async function mapHeldInputResponsesStep(+ input: SessionStepState & {+ readonly delivery: DeliverHookPayload;+ readonly requestIds: readonly string[];+ },+): Promise<WithSessionStateDelta<{ readonly delivery: DeliverHookPayload | undefined }>> {+ "use step";+ return await withSessionStateDelta(input, async () => {+ const requestIds = new Set(input.requestIds);+ const mapped = await deliverChannelInputResponses({+ ...input,+ routable: (response) => requestIds.has(response.requestId),+ });+ return mapped.delivery === input.delivery+ ? { delivery: undefined }+ : { delivery: mapped.delivery, serializedContext: mapped.serializedContext };+ });+}+/*** Maps each input response this session cannot route as sent through the- * channel's `deliver` hook, and routes what it maps to a proxied request.+ * channel's `deliver` hook, and routes what it maps to a `routable` request.* Telegram buttons, for example, carry compact callback ids that only its hook* resolves against channel state. Every other response stays as sent for the* turn's own `deliver` call.*/async function deliverChannelInputResponses(- input: SessionStepState & { readonly delivery: DeliverHookPayload },+ input: SessionStepState & {+ readonly delivery: DeliverHookPayload;+ readonly routable: (response: InputResponse) => boolean;+ },): Promise<{readonly delivery: DeliverHookPayload;readonly serializedContext: Record<string, unknown>;}> {- const requests = getProxyInputRequests(readDurableSession(input.sessionState).state);- const routable = (response: InputResponse) => requests.has(response.requestId);+ const { routable } = input;const unrouted = input.delivery.payloads.some((payload) => payload.inputResponses?.some((response) => !routable(response)) === true,);@@ -245,7 +275,9 @@ async function deliverChannelInputResponses(// The hook sees this delivery's caller, as it does in the turn.if (input.delivery.auth !== undefined) ctx.set(AuthKey, input.delivery.auth ?? null);- const adapterCtx = buildAdapterContext(adapter, ctx);+ // Each hook call edits its own copy of channel state, kept only when it maps+ // to a routable request; a response put back as sent must stay resolvable.+ let state = adapter.state ?? {};let mapped = false;const payloads: DeliverPayload[] = [];for (const payload of input.delivery.payloads) {@@ -259,13 +291,19 @@ async function deliverChannelInputResponses(responses.push(response);continue;}+ const adapterCtx = buildAdapterContext({ ...adapter, state: structuredClone(state) }, ctx);const result = await adapter.deliver({ ...payload, inputResponses: [response], message: undefined },adapterCtx,);const routed = result?.inputResponses?.filter(routable) ?? [];- mapped ||= routed.length > 0;- responses.push(...(routed.length > 0 ? routed : [response]));+ if (routed.length === 0) {+ responses.push(response);+ continue;+ }+ mapped = true;+ state = adapterCtx.state;+ responses.push(...routed);}payloads.push({ ...payload, inputResponses: responses });}@@ -274,7 +312,7 @@ async function deliverChannelInputResponses(// Only the channel state the mapping consumed carries over; the turn applies// the rest of this delivery, such as its caller, itself.const session = await deserializeContext(input.serializedContext);- setChannelContext(session, { ...adapter, state: { ...adapterCtx.state } });+ setChannelContext(session, { ...adapter, state });return {delivery: { ...input.delivery, payloads },serializedContext: serializeContext(session),diff --git a/packages/eve/src/execution/session/active-turn.ts b/packages/eve/src/execution/session/active-turn.tsindex fac67fc3d..eff8cb144 100644--- a/packages/eve/src/execution/session/active-turn.ts+++ b/packages/eve/src/execution/session/active-turn.ts@@ -1,4 +1,5 @@import type { DeliverHookPayload, TurnCaller } from "#channel/types.js";+import { mapHeldInputResponsesStep } from "#execution/proxied-deliver-step.js";import { routeDeliverToChildren } from "#execution/route-child-delivery.js";import { admitSessionInboxPayload } from "#execution/session/admission.js";import {@@ -40,6 +41,7 @@ export type RuntimeEvent =export class ActiveTurn {private readonly admitted = new Set<number>();private readonly routedToChildren = new Set<number>();+ private readonly mappedForHeldRequest = new Set<number>();private readonly runtimeResults: RuntimeEvent[] = [];private readonly controller = new AbortController();private readonly expectedTurnId: string;@@ -177,14 +179,26 @@ export class ActiveTurn {* responder: an approver need not be the turn's own person. Returns* `undefined` when no admitted delivery answers one.*/- takeInputResponses(requestIds: ReadonlySet<string>): DeliverHookPayload | undefined {+ async takeInputResponses(+ requestIds: ReadonlySet<string>,+ ): Promise<DeliverHookPayload | undefined> {for (const sequence of this.admitted) {- const delivery = this.input.queue.delivery(sequence);+ let delivery = this.input.queue.delivery(sequence);if (delivery === undefined) continue;- const answers = delivery.payloads.some((payload) =>- payload.inputResponses?.some((response) => requestIds.has(response.requestId)),- );- if (!answers) continue;+ const responses = delivery.payloads.flatMap((payload) => payload.inputResponses ?? []);+ if (responses.length === 0) continue;+ if (!responses.some((response) => requestIds.has(response.requestId))) {+ // Some channels answer with ids only their `deliver` hook resolves,+ // such as Telegram's compact button callbacks.+ if (this.mappedForHeldRequest.has(sequence)) continue;+ this.mappedForHeldRequest.add(sequence);+ const target = delivery;+ const mapped = await this.input.cursor.advance((state) =>+ mapHeldInputResponsesStep({ delivery: target, requestIds: [...requestIds], ...state }),+ );+ if (mapped.delivery === undefined) continue;+ delivery = mapped.delivery;+ }this.admitted.delete(sequence);this.input.queue.replaceDelivery(sequence, undefined);return delivery;diff --git a/packages/eve/src/execution/session/turn-step.test.ts b/packages/eve/src/execution/session/turn-step.test.tsindex 3bd8ab54b..eb9e211f6 100644--- a/packages/eve/src/execution/session/turn-step.test.ts+++ b/packages/eve/src/execution/session/turn-step.test.ts@@ -96,7 +96,10 @@ function turnStep(}return runSessionStateStep({ history: [], ...input, input: payload }, runTurnStep);}-import { routeProxiedDeliverStep } from "#execution/proxied-deliver-step.js";+import {+ mapHeldInputResponsesStep,+ routeProxiedDeliverStep,+} from "#execution/proxied-deliver-step.js";import { captureLogRecords } from "#internal/testing/log-records.js";import { runSessionStateStep } from "#internal/testing/session-state-step.js";@@ -662,6 +665,75 @@ describe("routeProxiedDeliverStep", () => {});});+describe("mapHeldInputResponsesStep", () => {+ it("keeps the channel mapping of an answer the held turn does not wait on", async () => {+ // Resolves `button:N` ids against channel state and consumes the mapping,+ // as Telegram's compact callback buttons do.+ const buttonAdapter: ChannelAdapter = {+ kind: "buttons",+ deliver(payload: DeliverPayload, adapterCtx: ChannelAdapterContext) {+ const buttons = adapterCtx.state.buttons as Record<string, string>;+ return {+ inputResponses: (payload.inputResponses ?? []).flatMap((response) => {+ const button = response.requestId.slice("button:".length);+ const requestId = buttons[button];+ if (requestId === undefined) return [];+ delete buttons[button];+ return [{ optionId: "approve", requestId }];+ }),+ };+ },+ };+ const bundle = createStubBundle();+ vi.mocked(getCompiledRuntimeAgentBundle).mockResolvedValue({+ ...bundle,+ adapterRegistry: {+ adaptersByKind: new Map([+ [threadContextAdapter.kind, threadContextAdapter],+ [buttonAdapter.kind, buttonAdapter],+ ]),+ },+ } as never);+ const ctx = await deserializeContext(createSerializedContext());+ ctx.set(ChannelKey, {+ ...buttonAdapter,+ state: { buttons: { "1": "held-request", "2": "child-request" } },+ });++ const result = await runSessionStateStep(+ {+ delivery: {+ kind: "deliver",+ payloads: [+ {+ inputResponses: [+ { optionId: "approve", requestId: "button:1" },+ { optionId: "approve", requestId: "button:2" },+ ],+ },+ ],+ },+ requestIds: ["held-request"],+ serializedContext: serializeContext(ctx),+ sessionState: createStubSessionState(),+ sessionWritable: createTestWritable(),+ },+ mapHeldInputResponsesStep,+ );++ expect(result.delivery?.payloads).toEqual([+ {+ inputResponses: [+ { optionId: "approve", requestId: "held-request" },+ { optionId: "approve", requestId: "button:2" },+ ],+ },+ ]);+ const next = await deserializeContext(result.serializedContext);+ expect(next.require(ChannelKey).state).toEqual({ buttons: { "2": "child-request" } });+ });+});+function currentSessionHook(token: string) {return {metadata: { sessionId: "child-run" },diff --git a/packages/eve/src/execution/session/turn.ts b/packages/eve/src/execution/session/turn.tsindex 9b19f242f..91e1c42ba 100644--- a/packages/eve/src/execution/session/turn.ts+++ b/packages/eve/src/execution/session/turn.ts@@ -325,7 +325,7 @@ export class SessionExecution {while (true) {const callbacks = this.input.queue.takeAuthorizations(attemptIds);if (callbacks !== undefined) return { kind: "deliver", payloads: callbacks };- const answer = turn.takeInputResponses(requestIds);+ const answer = await turn.takeInputResponses(requestIds);if (answer !== undefined) return answer;const steering = await turn.takeSteering({ heldOnPerson: true });if (steering !== undefined) return steering;diff --git a/packages/eve/src/internal/testing/channel-conformance/conformance.ts b/packages/eve/src/internal/testing/channel-conformance/conformance.tsindex 7fedf9793..5faedef81 100644--- a/packages/eve/src/internal/testing/channel-conformance/conformance.ts+++ b/packages/eve/src/internal/testing/channel-conformance/conformance.ts@@ -48,23 +48,7 @@ const hitlConformance = {linq: [{ driver: linqDriver }],slack: [{ driver: slackDriver }],teams: [{ driver: teamsDriver }],- telegram: [- {- driver: telegramDriver,- broken: {- "pressing Approve runs the gated tool": {- reason:- "#4135: a held approval checks the button's callback id before Telegram maps it to the request",- symptom: /Timed out waiting for deploy_release to run or be denied on telegram/,- },- "pressing Cancel stops the gated tool without running it": {- reason:- "#4135: a held approval checks the button's callback id before Telegram maps it to the request",- symptom: /Timed out waiting for deploy_release to run or be denied on telegram/,- },- },- },- ],+ telegram: [{ driver: telegramDriver }],twilio: [{ driver: twilioDriver }],} satisfies Record<string, readonly ConformanceChannel[]>;