Skip to content

armgit / eve

Public Imported from GitHub
0

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.md
new file mode 100644
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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[]>;