Skip to content

armgit / eve

Public Imported from GitHub
0

The Open Framework for Building Agents

feat(eve): support an endsTurn function on dynamic tools (#5296)

Matan Kushner25c9fff80b79
diff --git a/.changeset/dynamic-tool-ends-turn-function.md b/.changeset/dynamic-tool-ends-turn-function.md
new file mode 100644
index 000000000..575160f5b
--- /dev/null
+++ b/.changeset/dynamic-tool-ends-turn-function.md
@@ -0,0 +1,5 @@
+---
+"eve": patch
+---
+
+Dynamic tools now accept an `endsTurn` function, as static tools do. eve replays it from a durable descriptor like `execute`, so a tool returned by a `defineDynamic` resolver can decide from its output whether the call ends the turn.
diff --git a/docs/guides/dynamic-capabilities.md b/docs/guides/dynamic-capabilities.md
index ace024e74..81f536103 100644
--- a/docs/guides/dynamic-capabilities.md
+++ b/docs/guides/dynamic-capabilities.md
@@ -248,7 +248,7 @@ the handler.
## Dynamic tools
-Pass `defineDynamic` an `events` object whose handlers return either a single `defineTool(...)`, a `Record<string, defineTool(...)>`, or `null` for no tools. Wrap every entry in `defineTool()`. eve records durable descriptors for `execute`, approval request and response policies, input-scoped `approvalKey` callbacks, and `toModelOutput`, so a parked call can reconstruct the same callbacks in a fresh process.
+Pass `defineDynamic` an `events` object whose handlers return either a single `defineTool(...)`, a `Record<string, defineTool(...)>`, or `null` for no tools. Wrap every entry in `defineTool()`. eve records durable descriptors for `execute`, approval request and response policies, input-scoped `approvalKey` callbacks, `toModelOutput`, and an `endsTurn` function, so a parked call can reconstruct the same callbacks in a fresh process.
Dynamic tool executors receive the same `ToolContext` as static authored tools, including inline provider auth through `ctx.getToken(provider)` and `ctx.requireAuth(provider)`.
diff --git a/docs/tools/overview.mdx b/docs/tools/overview.mdx
index 00d240759..191aaeb2c 100644
--- a/docs/tools/overview.mdx
+++ b/docs/tools/overview.mdx
@@ -123,7 +123,7 @@ eve does not append the sentence for a function, because whether the call ends t
The turn ends only when every tool call in the model's step can end the turn and succeeds, and every `endsTurn` function returns `true`. Otherwise the model receives the results and continues as usual. Text the model writes before the call is narration, so channels do not post it as the reply. While [tasks](/docs/tools/tasks) are still working, the turn waits for them and then calls the model again.
-eve ignores `endsTurn` in delegated sessions, which must return a reply to their caller, and on turns that request structured output; the model does not see the appended sentence there, and eve does not call an `endsTurn` function. `defineWorkflowTool` rejects `endsTurn` at build time. Dynamic tool entries accept `endsTurn: true` or `false`; eve rejects a function when the resolver returns the entry, because dynamic tool metadata is stored durably. To end a turn without taking any other action, add the opt-in [`no_reply`](/docs/concepts/built-in-tools#no_reply) tool.
+eve ignores `endsTurn` in delegated sessions, which must return a reply to their caller, and on turns that request structured output; the model does not see the appended sentence there, and eve does not call an `endsTurn` function. `defineWorkflowTool` rejects `endsTurn` at build time. Dynamic tool entries accept `endsTurn` too, including a function. eve replays the function from a durable descriptor, as it does `execute`. To end a turn without taking any other action, add the opt-in [`no_reply`](/docs/concepts/built-in-tools#no_reply) tool.
### Label tool activity
diff --git a/e2e/fixtures/agent-tools/agent/agent.ts b/e2e/fixtures/agent-tools/agent/agent.ts
index 59468dd25..4b2a322cf 100644
--- a/e2e/fixtures/agent-tools/agent/agent.ts
+++ b/e2e/fixtures/agent-tools/agent/agent.ts
@@ -63,11 +63,14 @@ const base = e2eAgentConfig({
// Reached only if `no_reply` failed to end the turn; the eval then sees a reply.
return "Replied after no_reply.";
}
- if (request.lastUserMessage?.includes("`react_to_note`")) {
+ const reactTool = ["dynamic_react_to_note", "react_to_note"].find((name) =>
+ request.lastUserMessage?.includes(`\`${name}\``),
+ );
+ if (reactTool !== undefined) {
const roles = request.messages.map((message) => message.role);
if (roles.lastIndexOf("tool") <= roles.lastIndexOf("user")) {
- const emoji = request.lastUserMessage.includes("rocket") ? "rocket" : "tada";
- return { toolCalls: [{ name: "react_to_note", input: { emoji } }] };
+ const emoji = request.lastUserMessage?.includes("rocket") ? "rocket" : "tada";
+ return { toolCalls: [{ name: reactTool, input: { emoji } }] };
}
return "The rocket reaction isn't allowed in the team channel, so nothing was posted.";
}
diff --git a/e2e/fixtures/agent-tools/agent/tools/dynamic-react.ts b/e2e/fixtures/agent-tools/agent/tools/dynamic-react.ts
new file mode 100644
index 000000000..31a9720c9
--- /dev/null
+++ b/e2e/fixtures/agent-tools/agent/tools/dynamic-react.ts
@@ -0,0 +1,22 @@
+import { defineDynamic, defineTool } from "eve/tools";
+import { z } from "zod";
+
+// The dynamic twin of `react_to_note` for `evals/static-tools/ends-turn-function.eval.ts`:
+// its `endsTurn` function replays from a durable descriptor.
+export default defineDynamic({
+ events: {
+ "session.started": () => ({
+ dynamic_react_to_note: defineTool({
+ description:
+ "Smoke-test fixture: reacts to a team note with an emoji. Only call when the user explicitly asks to use `dynamic_react_to_note`. When the reaction posts, your turn ends; when it doesn't, tell the user.",
+ inputSchema: z.object({
+ emoji: z.string().min(1).describe("The emoji name, such as tada."),
+ }),
+ async execute({ emoji }) {
+ return { emoji, posted: emoji === "tada" };
+ },
+ endsTurn: (output) => output.posted,
+ }),
+ }),
+ },
+});
diff --git a/e2e/fixtures/agent-tools/evals/static-tools/ends-turn-function.eval.ts b/e2e/fixtures/agent-tools/evals/static-tools/ends-turn-function.eval.ts
index 97095cc66..faf248834 100644
--- a/e2e/fixtures/agent-tools/evals/static-tools/ends-turn-function.eval.ts
+++ b/e2e/fixtures/agent-tools/evals/static-tools/ends-turn-function.eval.ts
@@ -1,33 +1,36 @@
import { defineEval } from "eve/evals";
import { satisfies } from "eve/evals/expect";
-// `endsTurn` as a function of the execute output: a posted reaction ends the
-// turn without a reply, and a reaction that doesn't post lets the model reply.
-export default defineEval({
- description: "An endsTurn function decides from the tool's output whether the turn ends.",
- async test(t) {
- const posted = await t.send(
- "Alice shared that the release shipped this morning. Celebrate it with the `react_to_note` tool using the tada emoji.",
- );
- posted.expectOk();
- posted.requireToolCall("react_to_note");
- t.check(
- posted.message,
- satisfies((message) => message === undefined, "a posted reaction sends no reply"),
- );
+// `endsTurn` as a function of the execute output, on a static tool and on a
+// dynamic one: a posted reaction ends the turn without a reply, and a reaction
+// that doesn't post lets the model reply.
+export default (["react_to_note", "dynamic_react_to_note"] as const).map((tool) =>
+ defineEval({
+ description: `An endsTurn function on ${tool} decides from the tool's output whether the turn ends.`,
+ async test(t) {
+ const posted = await t.send(
+ `Alice shared that the release shipped this morning. Celebrate it with the \`${tool}\` tool using the tada emoji.`,
+ );
+ posted.expectOk();
+ posted.requireToolCall(tool);
+ t.check(
+ posted.message,
+ satisfies((message) => message === undefined, "a posted reaction sends no reply"),
+ );
- const refused = await posted.session.send(
- "Bob would also like to add a rocket reaction to Alice's note with the `react_to_note` tool. Let him know how it went.",
- );
- refused.expectOk();
- refused.requireToolCall("react_to_note");
- t.check(
- refused.message,
- satisfies(
- (message) => typeof message === "string" && message.trim().length > 0,
- "a reaction that doesn't post gets a reply",
- ),
- );
- t.succeeded();
- },
-});
+ const refused = await posted.session.send(
+ `Bob would also like to add a rocket reaction to Alice's note with the \`${tool}\` tool. Let him know how it went.`,
+ );
+ refused.expectOk();
+ refused.requireToolCall(tool);
+ t.check(
+ refused.message,
+ satisfies(
+ (message) => typeof message === "string" && message.trim().length > 0,
+ "a reaction that doesn't post gets a reply",
+ ),
+ );
+ t.succeeded();
+ },
+ }),
+);
diff --git a/packages/eve/src/context/build-dynamic-tools.ts b/packages/eve/src/context/build-dynamic-tools.ts
index 3c9279f74..7f4336913 100644
--- a/packages/eve/src/context/build-dynamic-tools.ts
+++ b/packages/eve/src/context/build-dynamic-tools.ts
@@ -154,6 +154,8 @@ export function replayDynamicTools(
"toModelOutput",
entry.callbacks.toModelOutput,
);
+ const endsTurn =
+ entry.endsTurn ?? bindDynamicCallback(entry, owner, "endsTurn", entry.callbacks.endsTurn);
const replayed: {
-readonly [K in keyof HarnessToolDefinition]: HarnessToolDefinition[K];
@@ -162,7 +164,7 @@ export function replayDynamicTools(
deferred: entry.deferred,
frameworkTool: entry.frameworkTool,
description: entry.description,
- endsTurn: entry.endsTurn,
+ endsTurn,
execute: createToolExecuteWithAuth({
scope: entry.name,
execute: (input, context) => {
diff --git a/packages/eve/src/context/dynamic-tool-lifecycle.test.ts b/packages/eve/src/context/dynamic-tool-lifecycle.test.ts
index a86c9e5fc..2faf72fe8 100644
--- a/packages/eve/src/context/dynamic-tool-lifecycle.test.ts
+++ b/packages/eve/src/context/dynamic-tool-lifecycle.test.ts
@@ -49,6 +49,7 @@ import {
clearDurableDynamicCallbacks,
lookupDurableDynamicCallback,
registerDurableDynamicCallback,
+ readDurableDynamicToolCallbacks,
stampDurableDynamicToolCallbacks,
} from "#tools/durable-callbacks.js";
import type { ResolvedDynamicToolResolver } from "#runtime/types.js";
@@ -1547,7 +1548,33 @@ describe("dispatchDynamicToolEvent", () => {
expect(buildDynamicTools(ctx)[0]?.endsTurn).toBe(true);
});
- it("rejects an endsTurn function, which durable dynamic metadata cannot hold", async () => {
+ it("replays an endsTurn function from its durable descriptor", async () => {
+ const ctx = createCtx();
+ const resolver = createResolver("open_case", ["session.started"], () => {
+ const entry = Object.assign(createReplayableTool(), { endsTurn: () => false });
+ stampDurableDynamicToolCallbacks(entry, {
+ ...readDurableDynamicToolCallbacks(entry),
+ endsTurn: {
+ callback: (closure, output) => (output as { status: string }).status === closure.status,
+ closure: { status: "awaiting_confirmation" },
+ },
+ });
+ return entry;
+ });
+
+ await dispatchDynamicToolEvent({
+ ctx,
+ resolvers: [resolver],
+ messages: [],
+ event: makeEvent("session.started"),
+ });
+
+ const endsTurn = buildDynamicTools(ctx)[0]?.endsTurn as (output: unknown) => boolean;
+ expect(endsTurn({ status: "awaiting_confirmation" })).toBe(true);
+ expect(endsTurn({ status: "redirected" })).toBe(false);
+ });
+
+ it("rejects an endsTurn function without a durable descriptor", async () => {
const logs = captureLogRecords();
const ctx = createCtx();
const resolver = createResolver("react", ["session.started"], () =>
@@ -1563,7 +1590,7 @@ describe("dispatchDynamicToolEvent", () => {
expect(buildDynamicTools(ctx)).toHaveLength(0);
expect(JSON.stringify(logs.records)).toContain(
- 'Dynamic tool \\"react\\" sets endsTurn to a function, which dynamic tools do not support.',
+ 'Dynamic tool \\"react\\" callback \\"endsTurn\\" does not have a durable descriptor.',
);
});
diff --git a/packages/eve/src/context/dynamic-tool-lifecycle.ts b/packages/eve/src/context/dynamic-tool-lifecycle.ts
index 14be07717..21ec38bb3 100644
--- a/packages/eve/src/context/dynamic-tool-lifecycle.ts
+++ b/packages/eve/src/context/dynamic-tool-lifecycle.ts
@@ -200,6 +200,7 @@ export function validateDurableDynamicToolCallbacks(
const raw = readDurableDynamicToolCallbacks(entry) ?? {};
const unknownPhases = Object.keys(raw).filter(
(key) =>
+ key !== "endsTurn" &&
key !== "execute" &&
key !== "inputSchema" &&
key !== "outputSchema" &&
@@ -286,6 +287,13 @@ export function validateDurableDynamicToolCallbacks(
stamped: raw.toModelOutput,
required: entry.toModelOutput !== undefined,
});
+ const endsTurn = validateReference({
+ name,
+ owner,
+ phase: "endsTurn",
+ stamped: raw.endsTurn,
+ required: typeof entry.endsTurn === "function",
+ });
const inputSchema = validateReference({
name,
@@ -303,6 +311,7 @@ export function validateDurableDynamicToolCallbacks(
});
const callbacks: {
+ endsTurn?: DurableDynamicCallbackReference;
execute: DurableDynamicCallbackReference;
inputSchema?: DurableDynamicCallbackReference;
outputSchema?: DurableDynamicCallbackReference;
@@ -331,6 +340,7 @@ export function validateDurableDynamicToolCallbacks(
if (approvalRequest !== undefined) callbacks.approvalRequest = approvalRequest;
if (approvalResponse !== undefined) callbacks.approvalResponse = approvalResponse;
if (toModelOutput !== undefined) callbacks.toModelOutput = toModelOutput;
+ if (endsTurn !== undefined) callbacks.endsTurn = endsTurn;
return callbacks;
}
@@ -354,7 +364,8 @@ function createMetadata(input: {
}),
description: input.entry.description,
frameworkTool: isFrameworkTool(input.entry) || undefined,
- endsTurn: readDynamicEndsTurn(input.name, input.entry.endsTurn) || undefined,
+ // A function is replayed from its durable callback instead.
+ endsTurn: input.entry.endsTurn === true || undefined,
entryKey: input.entryKey,
inputSchema: serializeInputSchema(input.entry.inputSchema),
name: input.name,
@@ -363,16 +374,6 @@ function createMetadata(input: {
};
}
-/** Dynamic tool metadata is durable, so it can hold only a literal `endsTurn`. */
-function readDynamicEndsTurn(name: string, endsTurn: DynamicToolEntry["endsTurn"]): boolean {
- if (typeof endsTurn === "function") {
- throw new Error(
- `Dynamic tool "${name}" sets endsTurn to a function, which dynamic tools do not support. Set endsTurn to true or false; the resolver runs for each event, so it can decide then.`,
- );
- }
- return endsTurn === true;
-}
-
/**
* The agent's workflow tools and agents. They run after the model step, so a
* dynamic tool, which runs in it, cannot take their names. A static subagent
diff --git a/packages/eve/src/internal/workflow-bundle/dynamic-tool-transform.test.ts b/packages/eve/src/internal/workflow-bundle/dynamic-tool-transform.test.ts
index e36191dca..643a43ec6 100644
--- a/packages/eve/src/internal/workflow-bundle/dynamic-tool-transform.test.ts
+++ b/packages/eve/src/internal/workflow-bundle/dynamic-tool-transform.test.ts
@@ -60,6 +60,7 @@ async function transformAndEval(
label: entry.label as { complete?: never; delta?: never; start?: never } | undefined,
approval: entry.approval as never,
approvalKey: entry.approvalKey as never,
+ endsTurn: entry.endsTurn,
execute: entry.execute as never,
toModelOutput: entry.toModelOutput as never,
}),
@@ -127,6 +128,7 @@ export default defineDynamic({
const promptPrefix = "Review";
const allowedResponder = "user-123";
const projectionPrefix = "visible";
+ const doneStatus = "posted";
return {
guarded: defineTool({
description: "Guarded",
@@ -161,6 +163,7 @@ export default defineDynamic({
toModelOutput(output) {
return { type: "text", value: projectionPrefix + ":" + output };
},
+ endsTurn: (output) => output.status === doneStatus,
}),
};
},
@@ -174,6 +177,7 @@ export default defineDynamic({
const callbacks = durableCallbacks(guarded);
expect(Object.keys(callbacks)).toEqual([
+ "endsTurn",
"execute",
"label",
"approvalPrompt",
@@ -189,7 +193,9 @@ export default defineDynamic({
expect(callbacks.approvalPrompt!.closure).toEqual({ promptPrefix: "Review" });
expect(callbacks.approvalResponse!.closure).toEqual({ allowedResponder: "user-123" });
expect(callbacks.toModelOutput!.closure).toEqual({ projectionPrefix: "visible" });
+ expect(callbacks.endsTurn!.closure).toEqual({ doneStatus: "posted" });
const callbackValues = [
+ callbacks.endsTurn,
callbacks.execute,
callbacks.label?.start,
callbacks.label?.complete,
@@ -199,10 +205,50 @@ export default defineDynamic({
callbacks.approvalResponse,
callbacks.toModelOutput,
];
- expect(new Set(callbackValues.map((callback) => callback!.callback)).size).toBe(8);
+ expect(new Set(callbackValues.map((callback) => callback!.callback)).size).toBe(9);
for (const callback of callbackValues) expect(callback!.callback).toBeTypeOf("function");
});
+ it("stamps an endsTurn identifier only when it names a function", async () => {
+ const source = `
+import { defineDynamic, defineTool } from "eve/tools";
+
+const ENDS_TURN = true;
+function isAwaitingConfirmation(output) {
+ return output.status === "awaiting_confirmation";
+}
+
+export default defineDynamic({
+ events: {
+ "session.started": async () => ({
+ react: defineTool({
+ description: "React",
+ inputSchema: { type: "object" },
+ execute: () => ({ ok: true }),
+ endsTurn: ENDS_TURN,
+ }),
+ open_case: defineTool({
+ description: "Open a case",
+ inputSchema: { type: "object" },
+ execute: () => ({ status: "awaiting_confirmation" }),
+ endsTurn: isAwaitingConfirmation,
+ }),
+ }),
+ },
+});
+`;
+
+ const tools = await (await transformAndEval("tools/ends-turn.ts", source)).callHandler();
+ const react = tools.react as { endsTurn: unknown };
+ const openCase = tools.open_case as { endsTurn: (output: unknown) => boolean };
+
+ expect(react.endsTurn).toBe(true);
+ expect(durableCallbacks(react).endsTurn).toBeUndefined();
+ const { callback, closure } = durableCallbacks(openCase).endsTurn!;
+ expect(callback(closure, { status: "awaiting_confirmation" })).toBe(true);
+ expect(callback(closure, { status: "redirected" })).toBe(false);
+ });
+
it("preserves top-level function-form approval properties", async () => {
const source = `
import { defineDynamic, defineTool } from "eve/tools";
diff --git a/packages/eve/src/internal/workflow-bundle/dynamic-tool-transform.ts b/packages/eve/src/internal/workflow-bundle/dynamic-tool-transform.ts
index 7bb84dc84..6203b6b4a 100644
--- a/packages/eve/src/internal/workflow-bundle/dynamic-tool-transform.ts
+++ b/packages/eve/src/internal/workflow-bundle/dynamic-tool-transform.ts
@@ -27,6 +27,7 @@ type CallbackPhase =
| "approvalPrompt"
| "approvalRequest"
| "approvalResponse"
+ | "endsTurn"
| "execute"
| "toModelOutput"
| "inputSchema"
@@ -42,6 +43,7 @@ type CallbackPropertyName =
| "response"
| "complete"
| "delta"
+ | "endsTurn"
| "toModelOutput"
| "inputSchema"
| "outputSchema";
@@ -59,6 +61,8 @@ interface CallbackInfo {
readonly propertyName: CallbackPropertyName;
readonly propEnd: number;
readonly propStart: number;
+ /** The identifier a reference callback names, as written. */
+ readonly referenceName?: string;
}
interface ScopeEntry {
@@ -214,6 +218,14 @@ function collectToolCallbacks(
results,
nestedScopes,
);
+ collectCallbackProperty(
+ source,
+ findProperty(tool, "endsTurn"),
+ "endsTurn",
+ "endsTurn",
+ results,
+ nestedScopes,
+ );
for (const propertyName of ["inputSchema", "outputSchema"] as const) {
const property = findProperty(tool, propertyName);
@@ -325,6 +337,7 @@ function collectCallbackProperty(
propertyName,
propEnd: property.end,
propStart: property.start,
+ referenceName: source.slice(value.start, value.end),
});
}
}
@@ -365,7 +378,10 @@ function applyTransform(source: string, callbacks: readonly CallbackInfo[]): { c
const stamped =
callback.phase === "inputSchema" || callback.phase === "outputSchema"
? `__eveDefineDurableSchema({ schema: ${hoistedName}, closure: ${closure} })`
- : `__eveStampDynamicCallback(${wrapper}, ${hoistedName}, ${closure})`;
+ : callback.phase === "endsTurn" && callback.referenceName !== undefined
+ ? // `endsTurn` may name a boolean, which stays as written.
+ `typeof ${callback.referenceName} === "function" ? __eveStampDynamicCallback(${wrapper}, ${hoistedName}, ${closure}) : ${callback.referenceName}`
+ : `__eveStampDynamicCallback(${wrapper}, ${hoistedName}, ${closure})`;
replacements.push({
end: callback.propEnd,
start: callback.propStart,
diff --git a/packages/eve/src/tools/definition.ts b/packages/eve/src/tools/definition.ts
index 650e518e9..656324291 100644
--- a/packages/eve/src/tools/definition.ts
+++ b/packages/eve/src/tools/definition.ts
@@ -454,6 +454,7 @@ export function stampToolDefinition<
label: definition.label,
approval: definition.approval,
approvalKey: definition.approvalKey,
+ endsTurn: (definition as { readonly endsTurn?: unknown }).endsTurn,
execute: definition.execute,
toModelOutput: definition.toModelOutput,
}),
diff --git a/packages/eve/src/tools/durable-callbacks.ts b/packages/eve/src/tools/durable-callbacks.ts
index 4f0f43c30..c66425eed 100644
--- a/packages/eve/src/tools/durable-callbacks.ts
+++ b/packages/eve/src/tools/durable-callbacks.ts
@@ -11,6 +11,7 @@ export type DurableDynamicCallbackPhase =
| "approvalPrompt"
| "approvalRequest"
| "approvalResponse"
+ | "endsTurn"
| "execute"
| "toModelOutput"
| "inputSchema"
@@ -30,6 +31,7 @@ export interface DurableDynamicCallbackReference {
}
export interface DurableDynamicToolCallbacks {
+ readonly endsTurn?: DurableDynamicCallbackReference;
readonly execute: DurableDynamicCallbackReference;
readonly inputSchema?: DurableDynamicCallbackReference;
readonly outputSchema?: DurableDynamicCallbackReference;
@@ -52,6 +54,7 @@ export interface StampedDurableDynamicCallback {
}
type LiveDurableDynamicToolCallbacks = Partial<{
+ endsTurn: StampedDurableDynamicCallback;
execute: StampedDurableDynamicCallback;
inputSchema: StampedDurableDynamicCallback;
outputSchema: StampedDurableDynamicCallback;
@@ -178,6 +181,7 @@ function durableCallbackPhases(
DurableDynamicCallbackPhase,
DurableDynamicCallbackReference | undefined,
])[] = [
+ ["endsTurn", callbacks.endsTurn],
["execute", callbacks.execute],
["inputSchema", callbacks.inputSchema],
["outputSchema", callbacks.outputSchema],
@@ -277,6 +281,8 @@ export function collectDurableDynamicToolCallbacks(input: {
};
readonly approval?: ToolApproval<never>;
readonly approvalKey?: (...args: never[]) => unknown;
+ /** A boolean `endsTurn` is durable metadata already; only a function needs a descriptor. */
+ readonly endsTurn?: unknown;
readonly execute?: (...args: never[]) => unknown;
readonly toModelOutput?: (...args: never[]) => unknown;
}): LiveDurableDynamicToolCallbacks {
@@ -298,6 +304,7 @@ export function collectDurableDynamicToolCallbacks(input: {
? undefined
: input.approval.prompt,
);
+ const endsTurn = readDurableDynamicCallback(input.endsTurn);
const execute = readDurableDynamicCallback(input.execute);
const toModelOutput = readDurableDynamicCallback(input.toModelOutput);
const callbacks: LiveDurableDynamicToolCallbacks = {};
@@ -305,6 +312,7 @@ export function collectDurableDynamicToolCallbacks(input: {
const outputSchema = readDurableSchema(input.outputSchema);
if (inputSchema !== undefined) callbacks.inputSchema = inputSchema;
if (outputSchema !== undefined) callbacks.outputSchema = outputSchema;
+ if (endsTurn !== undefined) callbacks.endsTurn = endsTurn;
if (execute !== undefined) callbacks.execute = execute;
if (labelComplete !== undefined || labelDelta !== undefined || labelStart !== undefined) {
callbacks.label = {
diff --git a/packages/eve/src/tools/dynamic.ts b/packages/eve/src/tools/dynamic.ts
index 72e19e94f..8167056c7 100644
--- a/packages/eve/src/tools/dynamic.ts
+++ b/packages/eve/src/tools/dynamic.ts
@@ -29,9 +29,9 @@ export interface DynamicToolEntry<TInput = Record<string, unknown>, TOutput = an
readonly label?: ToolLabelDefinition<TInput, TOutput>;
readonly description: string;
/**
- * Ends the turn after a successful call, as `endsTurn: true` on
- * `defineTool`. Dynamic tools accept only `true` or `false`: eve rejects a
- * function when the resolver returns this entry.
+ * Ends the turn after a successful call, as `endsTurn` on a static
+ * `defineTool`. A function is replayed from its durable descriptor, like
+ * `execute`.
*/
readonly endsTurn?: boolean | ((output: TOutput) => boolean | Promise<boolean>);
readonly inputSchema: PublicToolInputSchema<TInput>;