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.mdnew file mode 100644index 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.mdindex 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.mdxindex 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 tThe 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 activitydiff --git a/e2e/fixtures/agent-tools/agent/agent.ts b/e2e/fixtures/agent-tools/agent/agent.tsindex 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.tsnew file mode 100644index 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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 subagentdiff --git a/packages/eve/src/internal/workflow-bundle/dynamic-tool-transform.test.ts b/packages/eve/src/internal/workflow-bundle/dynamic-tool-transform.test.tsindex 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.tsindex 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[]): { cconst 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.tsindex 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.tsindex 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.tsindex 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 = anreadonly 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>;