Skip to content

armgit / eve

Public Imported from GitHub
0

The Open Framework for Building Agents

fix(eve): dynamic tools - refresh session scope after redeploy (#1133)

Andrew Barbad76f76b591b9
diff --git a/.changeset/quick-tools-redeploy.md b/.changeset/quick-tools-redeploy.md
new file mode 100644
index 000000000..332682f3b
--- /dev/null
+++ b/.changeset/quick-tools-redeploy.md
@@ -0,0 +1,5 @@
+---
+"eve": patch
+---
+
+Refresh session-scoped dynamic tools when an existing production session moves to a new Vercel deployment, so added, removed, and reordered tools use the current build.
diff --git a/packages/eve/src/context/dynamic-tool-lifecycle.test.ts b/packages/eve/src/context/dynamic-tool-lifecycle.test.ts
index 4f4b306dd..0f68218e5 100644
--- a/packages/eve/src/context/dynamic-tool-lifecycle.test.ts
+++ b/packages/eve/src/context/dynamic-tool-lifecycle.test.ts
@@ -14,18 +14,22 @@ vi.mock("#context/build-callback-context.js", () => ({
}));
// Import after mock so the module picks up the mock
-const { replayDynamicSessionTools, dispatchDynamicToolEvent } =
- await import("#context/dynamic-tool-lifecycle.js");
+const {
+ replayDynamicSessionTools,
+ dispatchDynamicToolEvent,
+ refreshDynamicSessionToolsForRuntimeRevision,
+} = await import("#context/dynamic-tool-lifecycle.js");
const { buildDynamicTools } = await import("#context/build-dynamic-tools.js");
import { ContextContainer } from "#context/container.js";
import {
SessionIdKey,
SessionDynamicToolMetadataKey,
+ SessionDynamicToolRuntimeRevisionKey,
TurnDynamicToolMetadataKey,
} from "#context/keys.js";
import type { ResolvedDynamicToolResolver } from "#runtime/types.js";
-import type { HandleMessageStreamEvent } from "#protocol/message.js";
+import { createSessionStartedEvent, type HandleMessageStreamEvent } from "#protocol/message.js";
// Re-implement the naming logic here to test it independently
// (the production function is unexported — testing via the public behavior)
@@ -499,6 +503,90 @@ function createReplayableTool(
}
describe("dispatchDynamicToolEvent", () => {
+ it("replaces session tools with the current deployment's resolver output", async () => {
+ const ctx = createCtx();
+ const oldResolver = createResolver("old", ["session.started"], () => ({
+ old_tool: createReplayableTool("old deployment"),
+ }));
+
+ await dispatchDynamicToolEvent({
+ ctx,
+ resolvers: [oldResolver],
+ messages: [],
+ event: makeEvent("session.started"),
+ });
+ ctx.set(SessionDynamicToolRuntimeRevisionKey, "deployment:dpl_old");
+
+ expect(buildDynamicTools(ctx).map((tool) => tool.name)).toEqual(["old_tool"]);
+
+ const newResolver = createResolver("new", ["session.started"], () => ({
+ new_tool: createReplayableTool("new deployment"),
+ }));
+
+ await refreshDynamicSessionToolsForRuntimeRevision({
+ ctx,
+ resolvers: [newResolver],
+ messages: [],
+ event: createSessionStartedEvent(),
+ runtimeRevision: "deployment:dpl_new",
+ });
+
+ expect(ctx.get(SessionDynamicToolRuntimeRevisionKey)).toBe("deployment:dpl_new");
+ expect(ctx.get(SessionDynamicToolMetadataKey)?.map((tool) => tool.name)).toEqual(["new_tool"]);
+ expect(buildDynamicTools(ctx).map((tool) => tool.name)).toEqual(["new_tool"]);
+ });
+
+ it("does not re-run session resolvers within the same deployment", async () => {
+ const ctx = createCtx();
+ const handler = vi.fn(() => ({
+ current_tool: createReplayableTool(),
+ }));
+ const resolver = createResolver("current", ["session.started"], handler);
+
+ await dispatchDynamicToolEvent({
+ ctx,
+ resolvers: [resolver],
+ messages: [],
+ event: makeEvent("session.started"),
+ });
+ ctx.set(SessionDynamicToolRuntimeRevisionKey, "deployment:dpl_current");
+
+ await refreshDynamicSessionToolsForRuntimeRevision({
+ ctx,
+ resolvers: [resolver],
+ messages: [],
+ event: createSessionStartedEvent(),
+ runtimeRevision: "deployment:dpl_current",
+ });
+
+ expect(handler).toHaveBeenCalledOnce();
+ });
+
+ it("clears removed session resolvers on a new runtime revision", async () => {
+ const ctx = createCtx();
+ const oldResolver = createResolver("old", ["session.started"], () => ({
+ old_tool: createReplayableTool(),
+ }));
+ await dispatchDynamicToolEvent({
+ ctx,
+ resolvers: [oldResolver],
+ messages: [],
+ event: makeEvent("session.started"),
+ });
+ ctx.set(SessionDynamicToolRuntimeRevisionKey, "deployment:dpl_old");
+
+ await refreshDynamicSessionToolsForRuntimeRevision({
+ ctx,
+ resolvers: [],
+ messages: [],
+ event: createSessionStartedEvent(),
+ runtimeRevision: "deployment:dpl_new",
+ });
+
+ expect(ctx.get(SessionDynamicToolMetadataKey)).toEqual([]);
+ expect(ctx.get(SessionDynamicToolRuntimeRevisionKey)).toBe("deployment:dpl_new");
+ });
+
it("leaves unsupported connection input schemas for the MCP server to validate", async () => {
const ctx = createCtx();
const inputSchema = {
diff --git a/packages/eve/src/context/dynamic-tool-lifecycle.ts b/packages/eve/src/context/dynamic-tool-lifecycle.ts
index 3f8d56140..8905064eb 100644
--- a/packages/eve/src/context/dynamic-tool-lifecycle.ts
+++ b/packages/eve/src/context/dynamic-tool-lifecycle.ts
@@ -3,7 +3,7 @@ import type { ModelMessage } from "ai";
import type { HarnessToolDefinition } from "#harness/execute-tool.js";
import type { ApprovalContext } from "#public/definitions/approval.js";
import type { DynamicToolEntry } from "#shared/dynamic-tool-definition.js";
-import type { HandleMessageStreamEvent } from "#protocol/message.js";
+import type { HandleMessageStreamEvent, SessionStartedStreamEvent } from "#protocol/message.js";
import {
ALLOWED_DYNAMIC_TOOL_EVENTS,
isBrandedToolEntry,
@@ -21,6 +21,7 @@ import type { ContextContainer } from "#context/container.js";
import type { ContextKey } from "#context/key.js";
import {
SessionDynamicToolMetadataKey,
+ SessionDynamicToolRuntimeRevisionKey,
TurnDynamicToolMetadataKey,
LiveStepToolsKey,
} from "#context/keys.js";
@@ -339,7 +340,12 @@ export async function dispatchDynamicToolEvent(input: {
if (!ALLOWED_DYNAMIC_TOOL_EVENTS.has(event.type)) return;
const matching = resolvers.filter((r) => r.eventNames.includes(event.type));
- if (matching.length === 0) return;
+ if (matching.length === 0) {
+ if (event.type === "session.started") {
+ ctx.set(SessionDynamicToolMetadataKey, []);
+ }
+ return;
+ }
const { metadata, liveTools } = await resolveToolsFromEvent(ctx, matching, event, messages);
@@ -356,8 +362,41 @@ export async function dispatchDynamicToolEvent(input: {
const durableKey = durableKeyForEvent(event.type);
if (durableKey === undefined) return;
+ if (event.type === "session.started") {
+ ctx.set(SessionDynamicToolMetadataKey, metadata);
+ return;
+ }
+
const slugs = new Set(matching.map((r) => r.slug));
const existing = ctx.get(durableKey) ?? [];
const kept = existing.filter((m) => !slugs.has(m.resolverSlug));
ctx.set(durableKey, [...kept, ...metadata]);
}
+
+/**
+ * Re-resolves session-scoped dynamic tools when a durable session reaches a
+ * different runtime revision. The refresh is internal: lifecycle consumers
+ * still observe exactly one `session.started` event for the session.
+ */
+export async function refreshDynamicSessionToolsForRuntimeRevision(input: {
+ readonly ctx: ContextContainer;
+ readonly resolvers: readonly ResolvedDynamicToolResolver[];
+ readonly event: SessionStartedStreamEvent;
+ readonly messages: readonly ModelMessage[];
+ readonly runtimeRevision: string;
+}): Promise<void> {
+ if (input.ctx.get(SessionDynamicToolRuntimeRevisionKey) === input.runtimeRevision) {
+ return;
+ }
+
+ const matching = input.resolvers.filter((resolver) =>
+ resolver.eventNames.includes("session.started"),
+ );
+ const { metadata } =
+ matching.length === 0
+ ? { metadata: [] }
+ : await resolveToolsFromEvent(input.ctx, matching, input.event, input.messages);
+
+ input.ctx.set(SessionDynamicToolMetadataKey, metadata);
+ input.ctx.set(SessionDynamicToolRuntimeRevisionKey, input.runtimeRevision);
+}
diff --git a/packages/eve/src/context/keys.ts b/packages/eve/src/context/keys.ts
index 05f07015a..a198e1db6 100644
--- a/packages/eve/src/context/keys.ts
+++ b/packages/eve/src/context/keys.ts
@@ -137,6 +137,14 @@ export const SessionDynamicToolMetadataKey = new ContextKey<readonly DurableDyna
"eve.sessionDynamicToolMetadata",
);
+/**
+ * Runtime revision that last resolved session-scoped dynamic tools.
+ * Used to refresh their durable metadata after a deploy or development rebuild.
+ */
+export const SessionDynamicToolRuntimeRevisionKey = new ContextKey<string>(
+ "eve.sessionDynamicToolRuntimeRevision",
+);
+
/**
* Turn-scoped dynamic tool metadata (from `turn.started`).
* Replaced each turn.
diff --git a/packages/eve/src/execution/node-step.ts b/packages/eve/src/execution/node-step.ts
index 1a9060851..4e0a7ddd8 100644
--- a/packages/eve/src/execution/node-step.ts
+++ b/packages/eve/src/execution/node-step.ts
@@ -100,7 +100,7 @@ export function createExecutionNodeStep(input: CreateExecutionNodeStepInput): St
* Builds a {@link RuntimeIdentity} from the resolved runtime agent node
* and the current eve package installation.
*/
-function buildRuntimeIdentity(node: ResolvedRuntimeAgentNode): RuntimeIdentity {
+export function buildRuntimeIdentity(node: ResolvedRuntimeAgentNode): RuntimeIdentity {
const packageInfo = resolveInstalledPackageInfo();
const identity: RuntimeIdentity = {
diff --git a/packages/eve/src/execution/workflow-steps.test.ts b/packages/eve/src/execution/workflow-steps.test.ts
index 87d833269..ed804a817 100644
--- a/packages/eve/src/execution/workflow-steps.test.ts
+++ b/packages/eve/src/execution/workflow-steps.test.ts
@@ -4,7 +4,14 @@ import type { ChannelAdapter, ChannelAdapterContext } from "#channel/adapter.js"
import type { DeliverPayload, SubagentInputRequestHookPayload } from "#channel/types.js";
import { ContextContainer } from "#context/container.js";
import { ContextKey } from "#context/key.js";
-import { AuthKey, ContinuationTokenKey, ModeKey, SessionIdKey } from "#context/keys.js";
+import {
+ AuthKey,
+ ContinuationTokenKey,
+ ModeKey,
+ SessionDynamicToolMetadataKey,
+ SessionDynamicToolRuntimeRevisionKey,
+ SessionIdKey,
+} from "#context/keys.js";
import { BundleKey, ChannelKey } from "#runtime/sessions/runtime-context-keys.js";
import { serializeContext } from "#context/serialize.js";
import {
@@ -25,6 +32,7 @@ import {
import { createTurnWorkflowInput } from "#execution/durable-session-migrations/turn-workflow.js";
import { projectToDurableSession } from "#execution/session.js";
import { createExecutionNodeStep } from "#execution/node-step.js";
+import { defineTool } from "#public/definitions/tool.js";
import { dispatchRuntimeActionsStep } from "#execution/dispatch-runtime-actions-step.js";
import { runProxySubagentEventStep } from "#execution/subagent-event-proxy-step.js";
import { emitTerminalSessionFailureStep } from "#execution/terminal-session-failure-step.js";
@@ -101,6 +109,11 @@ function createTestWritable(
}
vi.mock("./node-step.js", () => ({
+ buildRuntimeIdentity: vi.fn(() => ({
+ agentId: "test-agent",
+ eveVersion: "0.0.0-test",
+ modelId: "test-model",
+ })),
createExecutionNodeStep: vi.fn(),
}));
@@ -982,6 +995,115 @@ describe("turnStep", () => {
});
});
+ it("refreshes session-scoped dynamic tools from the current deployment", async () => {
+ vi.stubEnv("VERCEL_DEPLOYMENT_ID", "dpl_new");
+ const handler = vi.fn(() => ({
+ current_tool: defineTool({
+ description: "Current deployment tool",
+ inputSchema: { type: "object" },
+ execute: async () => ({ ok: true }),
+ }),
+ }));
+ const dynamicToolResolver = {
+ eventNames: ["session.started"],
+ events: { "session.started": handler },
+ logicalPath: "agent/tools/current.ts",
+ slug: "current",
+ sourceId: "test:current",
+ sourceKind: "module",
+ } as never;
+ const compiledArtifactsSource = { kind: "bundled" } as const;
+ const compiledBundle = {
+ adapterRegistry: {
+ adaptersByKind: new Map([[threadContextAdapter.kind, threadContextAdapter]]),
+ },
+ compiledArtifactsSource,
+ graph: {
+ nodesByNodeId: new Map(),
+ root: {
+ sandboxRegistry: { sandbox: null },
+ turnAgent: TestTurnAgent,
+ },
+ },
+ moduleMap: { nodes: {} },
+ hookRegistry: createEmptyHookRegistry(),
+ resolvedAgent: {
+ config: {},
+ dynamicToolResolvers: [dynamicToolResolver],
+ },
+ subagentRegistry: {},
+ toolRegistry: {},
+ turnAgent: TestTurnAgent,
+ } as never;
+ vi.mocked(getCompiledRuntimeAgentBundle).mockResolvedValue(compiledBundle);
+ vi.mocked(createExecutionNodeStep).mockImplementation(() => {
+ return async (session): Promise<StepResult> => ({
+ next: { done: true, output: "ok" },
+ session,
+ });
+ });
+
+ const session = createStubSession({
+ state: {
+ "eve.harness.emission": {
+ sequence: 1,
+ sessionStarted: true,
+ stepIndex: 0,
+ turnId: "",
+ },
+ },
+ });
+ installSessionStoreMocks([session]);
+
+ const ctx = new ContextContainer();
+ ctx.set(AuthKey, null);
+ ctx.set(BundleKey, compiledBundle);
+ ctx.set(ChannelKey, threadContextAdapter);
+ ctx.set(ContinuationTokenKey, "http:thread-context");
+ ctx.set(ModeKey, "conversation");
+ ctx.set(SessionIdKey, "session-1");
+ ctx.set(SessionDynamicToolRuntimeRevisionKey, "deployment:dpl_old");
+ ctx.set(SessionDynamicToolMetadataKey, [
+ {
+ closureVars: {},
+ description: "Stale deployment tool",
+ entryKey: "old_tool",
+ executeStepFnName: "eve:dynamic-tool//old",
+ inputSchema: { type: "object" },
+ name: "old_tool",
+ resolverSlug: "old",
+ },
+ ]);
+
+ const result = await turnStep({
+ input: {
+ kind: "deliver",
+ payloads: [{ message: "follow up" }],
+ },
+ parentWritable: createTestWritable(),
+ serializedContext: serializeContext(ctx),
+ sessionState: createStubSessionState({
+ emissionState: {
+ sequence: 1,
+ sessionStarted: true,
+ stepIndex: 0,
+ turnId: "",
+ },
+ }),
+ });
+
+ expect(handler).toHaveBeenCalledOnce();
+ expect(result.serializedContext[SessionDynamicToolRuntimeRevisionKey.name]).toBe(
+ "deployment:dpl_new",
+ );
+ expect(result.serializedContext[SessionDynamicToolMetadataKey.name]).toEqual([
+ expect.objectContaining({
+ name: "current_tool",
+ resolverSlug: "current",
+ }),
+ ]);
+ });
+
it("clears pending authorization after a matching callback resumes the turn", async () => {
const challenge = {
challenge: {
diff --git a/packages/eve/src/execution/workflow-steps.ts b/packages/eve/src/execution/workflow-steps.ts
index d8572458f..c4b98ff26 100644
--- a/packages/eve/src/execution/workflow-steps.ts
+++ b/packages/eve/src/execution/workflow-steps.ts
@@ -5,8 +5,16 @@ import { dispatchStreamEventHooks } from "#context/hook-lifecycle.js";
import { dispatchDynamicInstructionEvent } from "#context/dynamic-instruction-lifecycle.js";
import { dispatchDynamicModelEvent } from "#context/dynamic-model-lifecycle.js";
import { dispatchDynamicSkillEvent } from "#context/dynamic-skill-lifecycle.js";
-import { dispatchDynamicToolEvent } from "#context/dynamic-tool-lifecycle.js";
-import { AuthKey, CapabilitiesKey, ModeKey } from "#context/keys.js";
+import {
+ dispatchDynamicToolEvent,
+ refreshDynamicSessionToolsForRuntimeRevision,
+} from "#context/dynamic-tool-lifecycle.js";
+import {
+ AuthKey,
+ CapabilitiesKey,
+ ModeKey,
+ SessionDynamicToolRuntimeRevisionKey,
+} from "#context/keys.js";
import { BundleKey, ChannelKey } from "#runtime/sessions/runtime-context-keys.js";
import { runStep } from "#context/run-step.js";
import { deserializeContext, serializeContext } from "#context/serialize.js";
@@ -33,6 +41,7 @@ import type { RunMode } from "#shared/run-mode.js";
import { getRuntimeActionRequestKey } from "#runtime/actions/keys.js";
import {
createAuthorizationCompletedEvent,
+ createSessionStartedEvent,
encodeMessageStreamEvent,
type HandleMessageStreamEvent,
timestampHandleMessageStreamEvent,
@@ -57,13 +66,14 @@ import {
type TurnStepInput,
type TurnWorkflowDispatchInput,
} from "#execution/durable-session-migrations/turn-workflow.js";
-import { createExecutionNodeStep } from "#execution/node-step.js";
+import { buildRuntimeIdentity, createExecutionNodeStep } from "#execution/node-step.js";
import { routeDeliverPayload } from "#execution/subagent-hitl-proxy.js";
import { recordSubagentUsageSpans } from "#execution/subagent-usage-span.js";
import { reconcileSessionContinuationToken } from "#execution/reconcile-session-continuation-token.js";
import { hydrateDurableSession, refreshSessionFromTurnAgent } from "#execution/session.js";
import { buildTurnAttributes, readRootSessionId } from "#execution/eve-workflow-attributes.js";
import { normalizeEveAttributes } from "#runtime/attributes/normalize.js";
+import { resolveRuntimeCompiledArtifactsVersionedCacheKey } from "#runtime/cache-key.js";
import {
createWorkflowRuntime,
requestWorkflowTurnCancellation,
@@ -255,11 +265,30 @@ export async function turnStep(rawInput: TurnStepInput): Promise<DurableStepResu
};
}
- const writer = input.parentWritable.getWriter();
const hookRegistry = bundle.hookRegistry;
const dynamicInstructionsResolvers = bundle.resolvedAgent.dynamicInstructionsResolvers ?? [];
const dynamicSkillResolvers = bundle.resolvedAgent.dynamicSkillResolvers ?? [];
const dynamicToolResolvers = bundle.resolvedAgent.dynamicToolResolvers ?? [];
+ const runtimeIdentity = buildRuntimeIdentity(bundle.graph.root);
+ const deploymentId = process.env.VERCEL_DEPLOYMENT_ID?.trim();
+ const dynamicToolRuntimeRevision = deploymentId
+ ? `deployment:${deploymentId}`
+ : await resolveRuntimeCompiledArtifactsVersionedCacheKey(bundle.compiledArtifactsSource);
+ const sessionStarted = getHarnessEmissionState(initialSession.state).sessionStarted;
+
+ if (!sessionStarted) {
+ ctx.set(SessionDynamicToolRuntimeRevisionKey, dynamicToolRuntimeRevision);
+ } else {
+ await refreshDynamicSessionToolsForRuntimeRevision({
+ ctx,
+ resolvers: dynamicToolResolvers,
+ event: createSessionStartedEvent({ runtime: runtimeIdentity }),
+ messages: initialSession.history,
+ runtimeRevision: dynamicToolRuntimeRevision,
+ });
+ }
+
+ const writer = input.parentWritable.getWriter();
const emit = async (event: HandleMessageStreamEvent): Promise<HandleMessageStreamEvent> => {
const toEmit = await callAdapterEventHandler(adapter, event, adapterCtx);