Skip to content

armgit / eve

Public Imported from GitHub
0

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