The Open Framework for Building Agents
Reproduce #3899: approval skipped after user instruction (#3902)
e0-gh-vercel-connect[bot]66f295eb68a9
diff --git a/.changeset/approved-tools-resume-order.md b/.changeset/approved-tools-resume-order.mdnew file mode 100644index 000000000..24ca380f0--- /dev/null+++ b/.changeset/approved-tools-resume-order.md@@ -0,0 +1,5 @@+---+"eve": patch+---++Approved tools now execute correctly when memory recall and dynamic user instructions run during approval resume.diff --git a/packages/eve/src/context/keys.ts b/packages/eve/src/context/keys.tsindex e84e788a6..a6e84d145 100644--- a/packages/eve/src/context/keys.ts+++ b/packages/eve/src/context/keys.ts@@ -256,8 +256,8 @@ export interface PreparedMemoryPreamble {}export interface PendingMemoryCommit {- readonly history: readonly ModelMessage[];- readonly projectedMessages: readonly ModelMessage[];+ /** Records recalled by this operation, to append after the prepared history. */+ readonly recalledMessages: readonly ModelMessage[];readonly state: Readonly<Record<string, unknown>>;}diff --git a/packages/eve/src/context/memory-lifecycle.test.ts b/packages/eve/src/context/memory-lifecycle.test.tsindex 7c526a4c4..ed86a6c01 100644--- a/packages/eve/src/context/memory-lifecycle.test.ts+++ b/packages/eve/src/context/memory-lifecycle.test.ts@@ -144,7 +144,8 @@ describe("memory lifecycle", () => {{ content: "bravo memory", kind: "memory.load", role: "user" },input[0],]);- expect(JSON.stringify(commit.history)).toContain("eve.memory");+ expect(commit.recalledMessages).toHaveLength(2);+ expect(JSON.stringify(commit.recalledMessages)).toContain("eve.memory");});it("commits no slot when one turn-wide recall batch is invalid", async () => {@@ -207,7 +208,7 @@ describe("memory lifecycle", () => {expect(namespace).not.toHaveBeenCalled();expect(recall).not.toHaveBeenCalled();- expect(drainMemoryCommit(ctx)?.history).toEqual([]);+ expect(drainMemoryCommit(ctx)?.recalledMessages).toEqual([]);});it("instruments recalls as memory searches with validated result records", async () => {@@ -295,7 +296,7 @@ describe("memory lifecycle", () => {);const commit = drainMemoryCommit(ctx)!;const settled = [- ...commit.history,+ ...commit.recalledMessages,{ content: "hello", role: "user" as const },{ content: "hi", role: "assistant" as const },];@@ -521,7 +522,7 @@ describe("memory lifecycle", () => {{ content: "ordinary", role: "user" },{ content: "new profile", kind: "memory.load", role: "user" },]);- expect(drainMemoryCommit(ctx)?.history).toHaveLength(3);+ expect(drainMemoryCommit(ctx)?.recalledMessages).toHaveLength(1);});it("gives each completed compaction within one turn a distinct recall operation id", async () => {@@ -575,7 +576,7 @@ describe("memory lifecycle", () => {}),);const commit = drainMemoryCommit(ctx)!;- history = [...commit.history];+ history = [...history, ...commit.recalledMessages];state = commit.state;return projected;};diff --git a/packages/eve/src/context/memory-lifecycle.ts b/packages/eve/src/context/memory-lifecycle.tsindex 5727027ff..cb85daf9c 100644--- a/packages/eve/src/context/memory-lifecycle.ts+++ b/packages/eve/src/context/memory-lifecycle.ts@@ -150,8 +150,7 @@ export async function dispatchMemoryTurnStarted(input: {state: committed.state,}) ?? recalledMessages;input.ctx.setVirtualContext(PendingMemoryCommitKey, {- history: committed.history,- projectedMessages,+ recalledMessages: committed.recalledMessages,state: committed.state,});return projectedMessages;@@ -312,8 +311,7 @@ export async function dispatchMemoryCompactionCompleted(input: {messages: committed.history,});input.ctx.setVirtualContext(PendingMemoryCommitKey, {- history: committed.history,- projectedMessages,+ recalledMessages: committed.recalledMessages,state: committed.state,});input.ctx.delete(PreparedMemoryCompactionKey);diff --git a/packages/eve/src/execution/session/turn-step.ts b/packages/eve/src/execution/session/turn-step.tsindex 8086c05b1..dedb8189f 100644--- a/packages/eve/src/execution/session/turn-step.ts+++ b/packages/eve/src/execution/session/turn-step.ts@@ -498,7 +498,8 @@ async function runSessionStep(input: TurnStepInput): Promise<DurableStepResult>schemaSession = {...schemaSession,history: validateHarnessModelMessages([- ...(memoryCommit?.history ?? schemaSession.history),+ ...schemaSession.history,+ ...(memoryCommit?.recalledMessages ?? []),...instructionMessages,]),state: memoryCommit?.state ?? schemaSession.state,diff --git a/packages/eve/src/harness/tool-loop-generate-approval-resume.integration.test.ts b/packages/eve/src/harness/tool-loop-generate-approval-resume.integration.test.tsindex 66a2dee30..45a60072f 100644--- a/packages/eve/src/harness/tool-loop-generate-approval-resume.integration.test.ts+++ b/packages/eve/src/harness/tool-loop-generate-approval-resume.integration.test.ts@@ -1,4 +1,9 @@import { setTurnClientContextState } from "#harness/turn-client-context.js";+import { DynamicModelSelectionError } from "#context/dynamic-model-lifecycle.js";+import { dispatchDynamicInstructionEvent } from "#context/dynamic-instruction-lifecycle.js";+import { dispatchMemoryLifecycleEvent } from "#context/memory-event-lifecycle.js";+import { defineInstructions } from "#public/definitions/instructions.js";+import { defineMemory } from "#public/memory/index.js";import { jsonSchema, type LanguageModel, type ModelMessage, simulateReadableStream } from "ai";import { MockLanguageModelV4 } from "ai/test";import { describe, expect, it, vi } from "vitest";@@ -207,6 +212,64 @@ function createTwoPendingApprovalSession(): HarnessSession {});}+/** Runs a `turn.started` memory recall and a user-role dynamic instruction, as in #3899. */+function createMemoryInstructionPreamble(+ ctx: ContextContainer,+ recalledMessages: readonly { readonly content: string; readonly id: string }[],+) {+ const recall = vi.fn(async () => ({ messages: [...recalledMessages] }));+ const instruction = vi.fn(() =>+ defineInstructions({+ content: "Current date and time: 2026-09-28T00:00:00.000Z (UTC).",+ role: "user",+ }),+ );+ const memories = [+ {+ ...defineMemory({+ namespace: "issue-3899",+ provider: { recall: { "turn.started": recall } },+ scope: "user-1",+ }),+ logicalPath: "memory/profile.ts",+ slot: "profile",+ sourceId: "memory/profile.ts",+ sourceKind: "module" as const,+ visibility: "scope" as const,+ },+ ];+ const resolvers = [+ {+ eventNames: ["turn.started"],+ events: { "turn.started": instruction },+ logicalPath: "instructions/timestamp.ts",+ slug: "timestamp",+ sourceId: "instructions/timestamp.ts",+ sourceKind: "module" as const,+ },+ ];+ const handleEvent: NonNullable<ToolLoopHarnessConfig["handleEvent"]> = async (+ event,+ messages,+ ) => {+ const lifecycleMessages = await dispatchMemoryLifecycleEvent({+ appRoot: "/app",+ ctx,+ event,+ memories: memories as never,+ messages,+ nodeId: "__root__",+ });+ await dispatchDynamicInstructionEvent({+ ctx,+ event,+ messages: lifecycleMessages,+ resolvers: resolvers as never,+ });+ };+ return { handleEvent, instruction, recall };+}+function createApprovalContext(): ContextContainer {const responder = {attributes: {},@@ -996,4 +1059,145 @@ describe("tool loop generate approval resume (real AI SDK)", () => {role: "assistant",});});++ it("keeps the approval response out of session history when the preamble fails", async () => {+ const ctx = createApprovalContext();+ const execute = vi.fn(async () => "/workspace");+ const preamble = createMemoryInstructionPreamble(ctx, [+ { content: "Remembered context", id: "memory-1" },+ ]);+ const model = new MockLanguageModelV4({+ doStream: textStreamResult("The command completed."),+ modelId: "generate-approval-resume-model",+ provider: "eve-integration-mock",+ });+ const runStep = createToolLoopHarness({+ ...createConfig(model, execute, {+ request: () => "user-approval",+ response: () => ({ status: "allowed" as const }),+ }),+ handleEvent: async (event, messages) => {+ await preamble.handleEvent(event, messages);+ if (event.type === "turn.started") {+ throw new DynamicModelSelectionError(new Error("model selection failed"));+ }+ },+ });+ let session = createPendingApprovalSession(undefined, true);+ let result = await contextStorage.run(ctx, () =>+ runStep(session, {+ attributedInputResponses: [+ {+ auth: ctx.require(AuthKey),+ response: { optionId: "approve", requestId: approvalRequest.approvalId },+ },+ ],+ }),+ );+ // The response-authorized approval runs its preamble on the continuation step.+ for (let index = 0; index < 3 && typeof result.next === "function"; index += 1) {+ const next = result.next;+ session = result.session;+ result = await contextStorage.run(ctx, () => next(session));+ }++ expect(preamble.recall).toHaveBeenCalledOnce();+ expect(preamble.instruction).toHaveBeenCalledOnce();+ expect(result.next).toEqual({ done: true, output: "" });+ expect(execute).not.toHaveBeenCalled();+ expect(model.doStreamCalls).toHaveLength(0);+ expect(result.session.history.slice(0, session.history.length)).toEqual(session.history);+ const preambleHistory = result.session.history.slice(session.history.length);+ expect(preambleHistory.map((message) => message.role)).toEqual(["user", "user"]);+ expect(JSON.stringify(preambleHistory[0]?.content)).toContain("Remembered context");+ expect(JSON.stringify(preambleHistory[1]?.content)).toContain("Current date and time");+ });++ it.each([+ { decision: "approve" as const, label: "empty recall", recalledMessages: [] },+ {+ decision: "approve" as const,+ label: "a recalled message",+ recalledMessages: [{ content: "Remembered context", id: "memory-1" }],+ },+ { decision: "cancel" as const, label: "empty recall", recalledMessages: [] },+ ])(+ "handles $decision after $label and a user instruction",+ async ({ decision, recalledMessages }) => {+ const ctx = createApprovalContext();+ const execute = vi.fn(async () => "/workspace");+ const { handleEvent, instruction, recall } = createMemoryInstructionPreamble(+ ctx,+ recalledMessages,+ );+ const model = new MockLanguageModelV4({+ doStream: textStreamResult("The command completed."),+ modelId: "generate-approval-resume-model",+ provider: "eve-integration-mock",+ });+ const runStep = createToolLoopHarness({+ ...createConfig(model, execute, {+ request: () => "user-approval",+ response: () => ({ status: "allowed" as const }),+ }),+ handleEvent,+ });++ let result = await contextStorage.run(ctx, () =>+ runStep(createPendingApprovalSession(undefined, true), {+ attributedInputResponses: [+ {+ auth: ctx.require(AuthKey),+ response: { optionId: decision, requestId: approvalRequest.approvalId },+ },+ ],+ }),+ );+ for (let index = 0; index < 3 && typeof result.next === "function"; index += 1) {+ const next = result.next;+ result = await contextStorage.run(ctx, () => next(result.session));+ }++ expect(recall).toHaveBeenCalledOnce();+ expect(instruction).toHaveBeenCalledOnce();+ if (decision === "approve") {+ expect(execute).toHaveBeenCalledExactlyOnceWith(+ toolCall.input,+ expect.objectContaining({ toolCallId: toolCall.toolCallId }),+ );+ } else {+ expect(execute).not.toHaveBeenCalled();+ }+ const providerPrompt = model.doStreamCalls[0]?.prompt ?? [];+ expect(providerPrompt).toContainEqual(+ expect.objectContaining({+ content: [+ expect.objectContaining({+ text: "Current date and time: 2026-09-28T00:00:00.000Z (UTC).",+ }),+ ],+ role: "user",+ }),+ );+ expect(+ providerPrompt.some((message) =>+ JSON.stringify(message.content).includes("Remembered context"),+ ),+ ).toBe(recalledMessages.length > 0);+ expect(+ result.session.history.some(+ (message) =>+ message.role === "user" &&+ JSON.stringify(message.content).includes("Current date and time"),+ ),+ ).toBe(true);+ if (decision === "approve") {+ expect(findPart(providerPrompt, "tool-result")).toMatchObject({+ output: { type: "text", value: "canonical:/workspace" },+ toolCallId: toolCall.toolCallId,+ toolName: toolCall.toolName,+ });+ }+ },+ );});diff --git a/packages/eve/src/harness/tool-loop.ts b/packages/eve/src/harness/tool-loop.tsindex aae3880fd..674ec7355 100644--- a/packages/eve/src/harness/tool-loop.ts+++ b/packages/eve/src/harness/tool-loop.ts@@ -907,7 +907,8 @@ export function createToolLoopHarness(config: ToolLoopHarnessConfig): StepFn {parkedSession = {...parkedSession,history: validateHarnessModelMessages([- ...(memoryCommit?.history ?? parkedSession.history),+ ...parkedSession.history,+ ...(memoryCommit?.recalledMessages ?? []),...instructionMessages,]),state: memoryCommit?.state ?? parkedSession.state,@@ -925,7 +926,8 @@ export function createToolLoopHarness(config: ToolLoopHarnessConfig): StepFn {parkedSession = {...parkedSession,history: validateHarnessModelMessages([- ...(memoryCommit?.history ?? parkedSession.history),+ ...parkedSession.history,+ ...(memoryCommit?.recalledMessages ?? []),...instructionMessages,]),state: memoryCommit?.state ?? parkedSession.state,@@ -1067,7 +1069,8 @@ export function createToolLoopHarness(config: ToolLoopHarnessConfig): StepFn {session = {...pending.session,history: validateHarnessModelMessages([- ...(memoryCommit?.history ?? pending.session.history),+ ...pending.session.history,+ ...(memoryCommit?.recalledMessages ?? []),...instructionMessages,]),state: memoryCommit?.state ?? pending.session.state,@@ -1085,20 +1088,22 @@ export function createToolLoopHarness(config: ToolLoopHarnessConfig): StepFn {stepInstrumentation?.setTurnId(emissionState.turnId);}- const committedHistory = memoryCommit?.history ?? pending.session.history;const historyLength = pending.session.history.length;+ const preambleMessages = [...(memoryCommit?.recalledMessages ?? []), ...instructionMessages];session = setHarnessEmissionState({...pending.session,- history: validateHarnessModelMessages([...committedHistory, ...instructionMessages]),+ history: validateHarnessModelMessages([...pending.session.history, ...preambleMessages]),state: memoryCommit?.state ?? pending.session.state,},emissionState,);+ // Preamble messages go before the pending transcript so an approval+ // response stays in the final tool message, where the AI SDK reads it.let messages: HarnessModelMessage[] = validateHarnessModelMessages([- ...(memoryCommit?.history ?? pending.messages.slice(0, historyLength)),- ...instructionMessages,- ...(memoryCommit === undefined ? pending.messages.slice(historyLength) : []),+ ...pending.messages.slice(0, historyLength),+ ...preambleMessages,+ ...pending.messages.slice(historyLength),]);// A resolved session-limit continuation prompt grants a fresh token@@ -3208,7 +3213,7 @@ async function maybeCompact(input: {if (ctx !== undefined) {const commit = drainMemoryCommit(ctx);if (commit !== undefined) {- messages = validateHarnessModelMessages(commit.history);+ messages = validateHarnessModelMessages([...messages, ...commit.recalledMessages]);session = { ...session, state: commit.state };}}diff --git a/packages/eve/src/shared/memory-state.ts b/packages/eve/src/shared/memory-state.tsindex 43cf330b3..1adaade73 100644--- a/packages/eve/src/shared/memory-state.ts+++ b/packages/eve/src/shared/memory-state.ts@@ -150,7 +150,11 @@ export function applyMemoryRecallBatches(input: {readonly batches: readonly MemoryRecallBatch[];readonly history: readonly ModelMessage[];readonly state: SessionStateMap | undefined;-}): { readonly history: ModelMessage[]; readonly state: SessionStateMap } {+}): {+ readonly history: ModelMessage[];+ readonly recalledMessages: ModelMessage[];+ readonly state: SessionStateMap;+} {const prior = readMemorySessionState(input.state);const operationDigests: Record<string, string> = { ...prior.operationDigests };const latest = latestKeyedRecords(input.history);@@ -193,6 +197,7 @@ export function applyMemoryRecallBatches(input: {);return {history: [...input.history, ...appended],+ recalledMessages: appended,state: writeMemorySessionState(input.state, {locks: Object.fromEntries(input.batches.map((batch) => [batch.lock.slot, batch.lock])),operationDigests: trimmedDigests,