The Open Framework for Building Agents
fix(eve): dynamic resolvers - include turn input and history (#3444)
Andrew Barba910bb45d299c
diff --git a/.changeset/fix-turn-resolver-messages.md b/.changeset/fix-turn-resolver-messages.mdnew file mode 100644index 000000000..0186b10d4--- /dev/null+++ b/.changeset/fix-turn-resolver-messages.md@@ -0,0 +1,5 @@+---+"eve": patch+---++Fix `turn.started` dynamic model, tool, skill, and subagent resolvers receiving an empty message snapshot. `ctx.messages` now includes visible conversation history and incoming input, including deferred session-limit turns and authorization resumes, with history projection preserved after memory recall.diff --git a/docs/guides/dynamic-capabilities.md b/docs/guides/dynamic-capabilities.mdindex 86016278e..4cfbe1a44 100644--- a/docs/guides/dynamic-capabilities.md+++ b/docs/guides/dynamic-capabilities.md@@ -333,6 +333,10 @@ A dynamic connection, tool, or skill whose name matches an **authored** one **ov¹ Workflow recovery can redeliver a resolver event, so keep resolvers idempotent. Replaying a parked callback does not depend on running the resolver again — except for the one-shot rebind described under [Identity and redeploys](#identity-and-redeploys).+At `turn.started`, model, tool, skill, and subagent resolvers receive the visible conversation history and incoming message in `ctx.messages`, oldest first. Request context is included, and history projection still applies. Read these messages from the handler's second argument; the event itself contains turn metadata. Instruction resolvers use the separate snapshot described under [Dynamic instructions](#dynamic-instructions).++This also applies while a session-limit prompt keeps the incoming message queued and when authorization completes. Authorization callbacks without new or queued input receive the visible history. When memory recall runs, its results appear in the projected snapshot before incoming input.+### Execution orderWhen a stream event fires, three things happen in order.diff --git a/e2e/fixtures/agent-model/agent/agent.ts b/e2e/fixtures/agent-model/agent/agent.tsindex 8309ed444..0a52c21d8 100644--- a/e2e/fixtures/agent-model/agent/agent.ts+++ b/e2e/fixtures/agent-model/agent/agent.ts@@ -12,6 +12,21 @@ const agent: AgentDefinition = defineAgent({experimental,model: defineDynamic({events: {+ "turn.started": (_event, ctx) => {+ const text = lastUserText(ctx.messages);+ if (text.length === 0) throw new Error("Turn resolver did not receive incoming input.");+ if (+ text.includes('"selected again"') &&+ !ctx.messages.some((message) => message.role === "assistant")+ ) {+ throw new Error("Turn resolver did not receive message history.");+ }+ // Turn selections are durable; the step resolver supplies the live mock.+ return {+ model: typeof model === "string" ? model : "openai/gpt-5.6-sol",+ modelContextWindowTokens: 1_000_000,+ };+ },"step.started": (_event, ctx) => {const text = lastUserText(ctx.messages);diff --git a/packages/eve/src/context/keys.ts b/packages/eve/src/context/keys.tsindex 32689b854..85816b2db 100644--- a/packages/eve/src/context/keys.ts+++ b/packages/eve/src/context/keys.ts@@ -31,6 +31,7 @@ import type { DynamicSubagentAgentConfig } from "#runtime/subagents/dynamic-agenimport type { DynamicRemoteAgentConfig } from "#runtime/subagents/dynamic-remote-agent-config.js";import type { SandboxAccess } from "#sandbox/state.js";import type { RunMode } from "#shared/run-mode.js";+import type { HistoryViewProjector } from "#shared/history-view.js";import type { RuntimeModelReference } from "#runtime/agent/bootstrap.js";import type { PreparedRuntimeDelegationTool } from "#runtime/sessions/turn.js";import type { MemoryScope, MemoryTurnContext } from "#public/memory/index.js";@@ -247,6 +248,7 @@ export const TurnMemoryLocksKey = new ContextKey<Readonly<Record<string, LockedM);export interface PreparedMemoryPreamble {+ readonly projector?: HistoryViewProjector;readonly history: readonly ModelMessage[];readonly input: readonly ModelMessage[];readonly state?: Readonly<Record<string, unknown>>;diff --git a/packages/eve/src/context/memory-lifecycle.ts b/packages/eve/src/context/memory-lifecycle.tsindex c3c758240..d26522ec2 100644--- a/packages/eve/src/context/memory-lifecycle.ts+++ b/packages/eve/src/context/memory-lifecycle.ts@@ -6,6 +6,7 @@ import {PreparedMemoryCompactionKey,PreparedMemoryPreambleKey,TurnMemoryLocksKey,+ type PreparedMemoryPreamble,} from "#context/keys.js";import { buildCallbackContext } from "#context/build-callback-context.js";import { buildResolveContext } from "#context/dynamic-resolve-context.js";@@ -41,19 +42,8 @@ import {const fallbackAbortSignal = new AbortController().signal;const log = createLogger("memory");-export function prepareMemoryPreamble(- ctx: AlsContext,- input: {- readonly history: readonly ModelMessage[];- readonly input: readonly ModelMessage[];- readonly state?: Readonly<Record<string, unknown>>;- },-): void {- ctx.setVirtualContext(PreparedMemoryPreambleKey, {- history: input.history,- input: input.input,- state: input.state,- });+export function prepareMemoryPreamble(ctx: AlsContext, input: PreparedMemoryPreamble): void {+ ctx.setVirtualContext(PreparedMemoryPreambleKey, input);}export async function dispatchMemoryTurnStarted(input: {@@ -150,10 +140,15 @@ export async function dispatchMemoryTurnStarted(input: {history: prepared.history,state: prepared.state,});- const projectedMessages = [+ const recalledMessages = [...projectMemoryHistory({ locks, messages: committed.history }),...prepared.input,];+ const projectedMessages =+ prepared.projector?.({+ messages: recalledMessages,+ state: committed.state,+ }) ?? recalledMessages;input.ctx.setVirtualContext(PendingMemoryCommitKey, {history: committed.history,projectedMessages,diff --git a/packages/eve/src/execution/session/turn-step.test.ts b/packages/eve/src/execution/session/turn-step.test.tsindex 7963d4df7..44fd4f4a4 100644--- a/packages/eve/src/execution/session/turn-step.test.ts+++ b/packages/eve/src/execution/session/turn-step.test.ts@@ -38,6 +38,7 @@ import { setHarnessEmissionState } from "#harness/emission-state.js";import { getPendingAuthorization, setPendingAuthorization } from "#harness/authorization.js";import { getProxyInputRequests, upsertProxyInputRequests } from "#harness/proxy-input-requests.js";import { appendPendingInputBatch } from "#harness/input-requests.js";+import { queueDeferredStepInput } from "#harness/pending-input-batches.js";import type { HarnessSession, StepFn, StepResult } from "#harness/types.js";import { createEmptyHookRegistry, createRuntimeHookRegistry } from "#runtime/hooks/registry.js";import {@@ -56,6 +57,7 @@ import {} from "#execution/durable-session-store.js";import { buildRuntimeIdentity, createExecutionNodeStep } from "#execution/node-step.js";import { defineTool } from "#tools/definition.js";+import { defineMemory } from "#public/memory/index.js";import { stampDurableDynamicCallback } from "#tools/durable-callbacks.js";import { dispatchCoordinationStep } from "#execution/coordination-dispatch-step.js";import { runProxySubagentEventStep } from "#subagents/event-proxy-step.js";@@ -3049,7 +3051,14 @@ describe("turnStep", () => {]);});- it("clears pending authorization after a matching callback resumes the turn", async () => {+ it.each([+ [false, "none"],+ [true, "none"],+ [false, "current"],+ [true, "current"],+ [false, "deferred"],+ [true, "deferred"],+ ] as const)("auth resume (%s, %s)", async (withMemory, inputKind) => {const challenge = {attemptId: "attempt-statuspage",challenge: {@@ -3072,11 +3081,39 @@ describe("turnStep", () => {const instructionHandler = vi.fn((_event: unknown, _context: { readonly messages: readonly ModelMessage[] }) => null,);+ const toolHandler = vi.fn(+ (_event: unknown, _context: { readonly messages: readonly ModelMessage[] }) => null,+ );+ const recall = vi.fn(async () => ({+ messages: [{ content: "Recalled context", id: "item" }],+ }));+ const memories = withMemory+ ? [+ {+ ...defineMemory({+ namespace: "test",+ scope: "alice",+ provider: { recall: { "turn.started": recall } },+ }),+ logicalPath: "memory/profile.ts",+ slot: "profile",+ sourceId: "memory/profile.ts",+ sourceKind: "module",+ visibility: "scope",+ },+ ]+ : [];const session = createStubSession({history: [{ content: "visible", kind: "user", role: "user" }, hidden],state: setPendingAuthorization({ retained: "yes" }, { challenges: [challenge] }),});- installSessionStoreMocks([session]);+ const turnInput = {+ context: ["Current context"],+ message: "Alice follows up after signing in.",+ };+ installSessionStoreMocks([+ inputKind === "deferred" ? queueDeferredStepInput(session, turnInput) : session,+ ]);vi.mocked(getCompiledRuntimeAgentBundle).mockResolvedValue({adapterRegistry: {adaptersByKind: new Map([[threadContextAdapter.kind, threadContextAdapter]]),@@ -3085,6 +3122,7 @@ describe("turnStep", () => {graph: {nodesByNodeId: new Map(),root: {+ agent: { memories, connections: [] },sandboxRegistry: { sandbox: null },turnAgent: TestTurnAgent,},@@ -3093,6 +3131,16 @@ describe("turnStep", () => {hookRegistry: createEmptyHookRegistry(),resolvedAgent: {config: {},+ dynamicToolResolvers: [+ {+ eventNames: ["turn.started"],+ events: { "turn.started": toolHandler },+ logicalPath: "tools/auth.ts",+ slug: "auth",+ sourceId: "tools/auth.ts",+ sourceKind: "module",+ },+ ],dynamicInstructionsResolvers: [{eventNames: ["session.started", "turn.started"],@@ -3126,6 +3174,7 @@ describe("turnStep", () => {input: {kind: "deliver",payloads: [+ ...(inputKind === "current" ? [turnInput] : []),{authorizationCallback: {attemptId: "attempt-statuspage",@@ -3141,7 +3190,9 @@ describe("turnStep", () => {});expect(observedPendingAuth).toBeUndefined();- expect(observedStepInput).toBeUndefined();+ expect(observedStepInput).toEqual(+ inputKind === "current" ? { message: `thread=unset; user=${turnInput.message}` } : undefined,+ );expect(result).toMatchObject({action: "park",hasPendingAuthorization: false,@@ -3159,6 +3210,31 @@ describe("turnStep", () => {});}expect(persistedSession?.history).toContain(hidden);+ const expectedInput =+ inputKind === "none"+ ? []+ : inputKind === "current"+ ? [{ content: `thread=unset; user=${turnInput.message}`, kind: "user", role: "user" }]+ : [+ { content: "Current context", kind: "context.instruction", role: "user" },+ { content: "Alice follows up after signing in.", kind: "user", role: "user" },+ ];+ expect(toolHandler).toHaveBeenCalledOnce();+ expect(toolHandler.mock.calls[0]?.[1].messages).toEqual([+ { content: "visible", kind: "user", role: "user" },+ ...(withMemory ? [{ content: "Recalled context", kind: "memory.load", role: "user" }] : []),+ ...expectedInput,+ ]);+ if (withMemory) {+ expect(recall).toHaveBeenCalledOnce();+ expect(recall).toHaveBeenCalledWith(+ expect.objectContaining({ turn: expect.objectContaining({ input: expectedInput }) }),+ );+ expect(+ persistedSession?.history.some((message) => message.content === "Recalled context"),+ ).toBe(true);+ expect(persistedSession?.state?.["eve.memory"]).toBeDefined();+ }});});diff --git a/packages/eve/src/execution/session/turn-step.ts b/packages/eve/src/execution/session/turn-step.tsindex 7f62bcab5..1b5b0da6c 100644--- a/packages/eve/src/execution/session/turn-step.ts+++ b/packages/eve/src/execution/session/turn-step.ts@@ -5,6 +5,7 @@ import {prepareDynamicInstructionPreamble,} from "#context/dynamic-instruction-lifecycle.js";import { refreshDynamicSessionSubagentsForRuntimeRevision } from "#context/dynamic-subagent-lifecycle.js";+import { drainMemoryCommit, prepareMemoryPreamble } from "#context/memory-lifecycle.js";import {rebindMissingCompiledDynamicToolCallbacks,refreshDynamicSessionToolsForRuntimeRevision,@@ -36,7 +37,13 @@ import { matchAuthorizationCallbacks } from "#execution/authorization-callback-mimport { isTurnCancellation, throwIfTurnAborted } from "#harness/turn-cancellation.js";import { setChannelContext } from "#execution/channel-context.js";import { activeTurnId } from "#harness/active-turn-id.js";-import { coalesceTurnInputs, type UserModelMessage } from "#harness/messages.js";+import {+ coalesceTurnInputs,+ createTurnInputMessages,+ validateHarnessModelMessages,+ type UserModelMessage,+} from "#harness/messages.js";+import { consumeDeferredStepInput } from "#harness/pending-input-batches.js";import type { HarnessSession, StepInput, StepResult } from "#harness/types.js";import type { DurableStepResult, TurnStepInput } from "#execution/session/turn-step-types.js";import { resolveSessionStepResult } from "#execution/session/turn-step-result.js";@@ -451,7 +458,16 @@ async function runSessionStep(input: TurnStepInput): Promise<DurableStepResult>if (firstCall && completedAuths) {let emissionState = getHarnessEmissionState(schemaSession.state);if (isHarnessBetweenTurns(schemaSession)) {+ const turnInput = createTurnInputMessages(+ consumeDeferredStepInput({ session: schemaSession, input: stepInput }).input,+ );prepareDynamicInstructionPreamble(ctx, history.messages(schemaSession));+ prepareMemoryPreamble(ctx, {+ history: schemaSession.history,+ input: turnInput,+ projector: history.projector,+ state: schemaSession.state,+ });let instructionMessages: readonly UserModelMessage[] = [];const traceContext = await prepareWorkflowPreambleTrace({emissionState,@@ -462,14 +478,23 @@ async function runSessionStep(input: TurnStepInput): Promise<DurableStepResult>handleEvent,{},emissionState,+ history.projector({+ messages: [...schemaSession.history, ...turnInput],+ state: schemaSession.state,+ }),runtimeIdentity,traceContext,);} finally {instructionMessages = drainDynamicInstructionUserMessages(ctx);+ const memoryCommit = drainMemoryCommit(ctx);schemaSession = {...schemaSession,- history: [...schemaSession.history, ...instructionMessages],+ history: validateHarnessModelMessages([+ ...(memoryCommit?.history ?? schemaSession.history),+ ...instructionMessages,+ ]),+ state: memoryCommit?.state ?? schemaSession.state,};}schemaSession = setHarnessEmissionState(schemaSession, emissionState);diff --git a/packages/eve/src/harness/emission.test.ts b/packages/eve/src/harness/emission.test.tsindex aca22ae4e..1b79208ab 100644--- a/packages/eve/src/harness/emission.test.ts+++ b/packages/eve/src/harness/emission.test.ts@@ -165,6 +165,7 @@ describe("emitTurnPreamble", () => {},{ message: "hello" },{ sequence: 0, sessionStarted: false, stepIndex: 0, turnId: "" },+ [{ role: "user", content: "hello" }],undefined,trace,);diff --git a/packages/eve/src/harness/emission.ts b/packages/eve/src/harness/emission.tsindex d8028208f..4435a881c 100644--- a/packages/eve/src/harness/emission.ts+++ b/packages/eve/src/harness/emission.ts@@ -79,6 +79,7 @@ export async function emitTurnPreamble(emitFn: HarnessEmitFn,input: StepInput,state: HarnessEmissionState,+ messages: readonly ModelMessage[],runtimeIdentity?: RuntimeIdentity,traceContext?: RuntimeTraceContext,): Promise<HarnessEmissionState> {@@ -92,7 +93,10 @@ export async function emitTurnPreamble(}if (!steering) {- await emitFn(createTurnStartedEvent({ sequence: state.sequence, trace: traceContext, turnId }));+ await emitFn(+ createTurnStartedEvent({ sequence: state.sequence, trace: traceContext, turnId }),+ messages,+ );}if (input.message !== undefined) {diff --git a/packages/eve/src/harness/messages.ts b/packages/eve/src/harness/messages.tsindex adc53600e..2c02080cb 100644--- a/packages/eve/src/harness/messages.ts+++ b/packages/eve/src/harness/messages.ts@@ -214,6 +214,21 @@ export function normalizeUserContent(return parts.length === content.length ? content : parts;}+export function createTurnInputMessages(input: StepInput | undefined): UserModelMessage[] {+ const messages = [...(readClientContext(input) ?? []), ...(input?.context ?? [])].map((content) =>+ createFrameworkUserMessage("context.instruction", content),+ );+ const content = normalizeUserContent(input?.message);+ if (content === undefined) return messages;+ const kind = frameworkMessageKindForStepInput(input);+ return [+ ...messages,+ kind === undefined+ ? createUserMessage("user", content)+ : createFrameworkUserMessage(kind, content),+ ];+}+/** Removes blank text blocks that some providers reject from model-bound history. */export function normalizeModelMessages(messages: readonly ModelMessage[]): ModelMessage[] {return messages.flatMap((message) => {diff --git a/packages/eve/src/harness/tool-loop.test.ts b/packages/eve/src/harness/tool-loop.test.tsindex 372c59c70..6a683e00b 100644--- a/packages/eve/src/harness/tool-loop.test.ts+++ b/packages/eve/src/harness/tool-loop.test.ts@@ -15,6 +15,9 @@ import { afterEach, describe, expect, it, vi } from "vitest";import { ContextContainer, contextStorage } from "#context/container.js";import { DynamicModelSelectionError } from "#context/dynamic-model-lifecycle.js";import { dispatchDynamicInstructionEvent } from "#context/dynamic-instruction-lifecycle.js";+import { dispatchDynamicSkillEvent } from "#context/dynamic-skill-lifecycle.js";+import { dispatchMemoryLifecycleEvent } from "#context/memory-event-lifecycle.js";+import { defineMemory } from "#public/memory/index.js";import {AuthKey,ChannelInstrumentationKey,@@ -1665,6 +1668,42 @@ describe("createToolLoopHarness", () => {).rejects.toThrow(/Dynamic model selection is required/);});+ it("passes projected history and incoming input to turn.started on every turn", async () => {+ setupMockAgent({+ finishReason: "stop",+ response: { messages: [{ content: "ok", role: "assistant" }] },+ text: "ok",+ toolCalls: [],+ toolResults: [],+ });+ const snapshots: (readonly ModelMessage[] | undefined)[] = [];+ const hidden = { content: "Hidden context", kind: "user" as const, role: "user" as const };+ const runStep = createToolLoopHarness(+ createTestConfig(+ "conversation",+ async (event, messages) => {+ if (event.type === "turn.started") snapshots.push(messages);+ },+ {+ historyProjector: ({ messages }) => messages.filter((message) => message !== hidden),+ },+ ),+ );++ const first = await runStep(createTestSession({ history: [hidden] }), { message: "Hello" });+ await runStep(first.session, { context: ["Current context"], message: "Follow up" });++ expect(snapshots).toEqual([+ [{ content: "Hello", kind: "user", role: "user" }],+ [+ { content: "Hello", kind: "user", role: "user" },+ { content: "ok", role: "assistant" },+ { content: "Current context", kind: "context.instruction", role: "user" },+ { content: "Follow up", kind: "user", role: "user" },+ ],+ ]);+ });+it("emits a terminal failure when no dynamic model selection is active", async () => {const { emit, events } = createEventCollector();const runStep = createToolLoopHarness(createTestConfig("conversation", emit));@@ -2186,6 +2225,120 @@ describe("createToolLoopHarness", () => {const LIMIT_REQUEST_ID = "test-session:limit:input:12";+ it.each([false, true])(+ "passes deferred input and history to turn resolvers while a session limit is open (memory: %s)",+ async (withMemory) => {+ const ctx = new ContextContainer();+ ctx.set(SandboxKey, mockSandbox().access);+ ctx.set(SessionIdKey, "test-session");+ ctx.set(SessionKey, {+ sessionId: "test-session",+ auth: { current: null, initiator: null },+ turn: { id: "turn_0", sequence: 0 },+ });+ const hidden = { content: "Hidden history", kind: "user" as const, role: "user" as const };+ const snapshots: (readonly ModelMessage[])[] = [];+ const recall = vi.fn(async () => ({+ messages: [{ content: "Remembered context", id: "item" }],+ }));+ const memories = withMemory+ ? [+ {+ ...defineMemory({+ namespace: "test",+ scope: "alice",+ provider: { recall: { "turn.started": recall } },+ }),+ logicalPath: "memory/profile.ts",+ slot: "profile",+ sourceId: "memory/profile.ts",+ sourceKind: "module" as const,+ visibility: "scope" as const,+ },+ ]+ : [];+ const runStep = createToolLoopHarness(+ createTestConfig(+ "conversation",+ async (event, messages) => {+ const lifecycleMessages = await dispatchMemoryLifecycleEvent({+ appRoot: "/app",+ ctx,+ event,+ memories,+ messages,+ nodeId: "__root__",+ });+ await dispatchDynamicSkillEvent({+ ctx,+ event,+ messages: lifecycleMessages,+ resolvers: [+ {+ eventNames: ["turn.started"],+ events: {+ "turn.started": (_event, context) => {+ snapshots.push((context as DynamicResolveContext).messages);+ return null;+ },+ },+ logicalPath: "skills/context.ts",+ slug: "context",+ sourceId: "skills/context.ts",+ sourceKind: "module",+ },+ ],+ });+ },+ { historyProjector: ({ messages }) => messages.filter((message) => message !== hidden) },+ ),+ );+ const first = await contextStorage.run(ctx, () =>+ runStep({ ...createLimitReachedSession(), history: [hidden] }, { message: "Hi again" }),+ );+ const second = await contextStorage.run(ctx, () =>+ runStep(+ first.session,+ attachClientContext(+ {+ context: ["Current context"],+ message: "Alice has a follow-up question.",+ },+ ["Current page"],+ ),+ ),+ );++ expect(snapshots).toHaveLength(2);+ expect(snapshots[1]).toContainEqual({ content: "Hi again", kind: "user", role: "user" });+ expect(snapshots[1]).not.toContain(hidden);+ expect(snapshots[1]?.slice(-3)).toEqual([+ { content: "Current page", kind: "context.instruction", role: "user" },+ { content: "Current context", kind: "context.instruction", role: "user" },+ { content: "Alice has a follow-up question.", kind: "user", role: "user" },+ ]);+ expect(+ second.session.history.some(+ (message) => message.content === "Alice has a follow-up question.",+ ),+ ).toBe(false);+ expect(second.next).toBeNull();+ expect(ToolLoopAgent).not.toHaveBeenCalled();+ if (withMemory) {+ expect(recall).toHaveBeenCalledTimes(2);+ expect(snapshots[1]).toContainEqual({+ content: "Remembered context",+ kind: "memory.load",+ role: "user",+ });+ expect(+ second.session.history.some((message) => message.content === "Remembered context"),+ ).toBe(true);+ expect(second.session.state?.["eve.memory"]).toBeDefined();+ }+ },+ );+it("parks on a deterministic continuation prompt when the session reaches its token limit", async () => {const { emit, events } = createEventCollector();const runStep = createToolLoopHarness(createTestConfig("conversation", emit));diff --git a/packages/eve/src/harness/tool-loop.ts b/packages/eve/src/harness/tool-loop.tsindex 2ab06927d..2d3d71df8 100644--- a/packages/eve/src/harness/tool-loop.ts+++ b/packages/eve/src/harness/tool-loop.ts@@ -150,6 +150,7 @@ import {frameworkMessageKindForStepInput,normalizeModelMessages,normalizeUserContent,+ createTurnInputMessages,resolveAssistantStepText,type HarnessModelMessage,type UserModelMessage,@@ -859,31 +860,42 @@ export function createToolLoopHarness(config: ToolLoopHarnessConfig): StepFn {pending.deferredMessage === true &&hasStepInput(input)) {+ const deferredInput = createTurnInputMessages(effectiveStepInput);if (store !== undefined) {prepareDynamicInstructionPreamble(store,projectHistory(parkedSession.history, parkedSession.state),);+ prepareMemoryPreamble(store, {+ history: parkedSession.history,+ input: deferredInput,+ projector: config.historyProjector,+ state: parkedSession.state,+ });}let instructionMessages: UserModelMessage[] = [];+ let memoryCommit: ReturnType<typeof drainMemoryCommit> = undefined;try {const traceContext = await preparePreambleTrace();emissionState = await emitTurnPreamble(emit,preambleStepInput ?? {},emissionState,+ projectHistory([...parkedSession.history, ...deferredInput], parkedSession.state),config.runtimeIdentity,traceContext,);} catch (error) {instructionMessages =store === undefined ? [] : drainDynamicInstructionUserMessages(store);+ memoryCommit = store === undefined ? undefined : drainMemoryCommit(store);parkedSession = {...parkedSession,history: validateHarnessModelMessages([- ...parkedSession.history,+ ...(memoryCommit?.history ?? parkedSession.history),...instructionMessages,]),+ state: memoryCommit?.state ?? parkedSession.state,};session = parkedSession;return failBoundaryEvent(error, {@@ -894,9 +906,14 @@ export function createToolLoopHarness(config: ToolLoopHarnessConfig): StepFn {});}instructionMessages = store === undefined ? [] : drainDynamicInstructionUserMessages(store);+ memoryCommit = store === undefined ? undefined : drainMemoryCommit(store);parkedSession = {...parkedSession,- history: validateHarnessModelMessages([...parkedSession.history, ...instructionMessages]),+ history: validateHarnessModelMessages([+ ...(memoryCommit?.history ?? parkedSession.history),+ ...instructionMessages,+ ]),+ state: memoryCommit?.state ?? parkedSession.state,};emissionState = await emitTurnEpilogue(emit, emissionState, config.mode);return {@@ -1005,6 +1022,7 @@ export function createToolLoopHarness(config: ToolLoopHarnessConfig): StepFn {prepareMemoryPreamble(store, {history: pending.messages,input: [...ephemeralContextMessages, ...preparedTurnInput],+ projector: config.historyProjector,state: pending.session.state,});}@@ -1014,6 +1032,10 @@ export function createToolLoopHarness(config: ToolLoopHarnessConfig): StepFn {emit,preambleStepInput ?? {},emissionState,+ projectHistory(+ [...pending.messages, ...ephemeralContextMessages, ...preparedTurnInput],+ pending.session.state,+ ),config.runtimeIdentity,traceContext,);