eve 0.67.2 → 0.69.0

package/dist/src/tools/behavior.d.ts

@@ -1,20 +1,21 @@
 import type { WebSearchProvider } from "#shared/web-search.js";
+import type { WorkflowToolEntryPoint } from "#tools/workflow-entry-point.js";
 /** Session facts that can hide a selected tool without changing source composition. */
-export type ToolAvailabilityCondition = "delegated-task-child" | "root-session";
+export type ToolAvailabilityCondition = "root-session";
 /** Native behavior declared by a selected compiled tool. */
 export type CompiledToolHandling = {
     readonly kind: "dispatch";
-    readonly action: "self-agent" | "task-cancel";
+    readonly action: "self-agent";
 } | {
     readonly kind: "provider-tool";
     readonly provider: WebSearchProvider;
 } | {
     readonly kind: "workflow-tool";
+    readonly entryPoint: WorkflowToolEntryPoint;
     readonly workflowId: string;
 };
 /** Closed, serializable behavior carried by one selected compiled tool. */
 export interface ToolExecutionShape {
-    readonly lifetime: "step" | "task";
     readonly suspend: "none" | "workflow";
 }
 export interface CompiledToolBehavior {
@@ -36,10 +37,9 @@ export type PreparedDispatchTarget = {
     readonly kind: "subagent-call";
     readonly nodeId: string;
     readonly subagentName: string;
-} | {
-    readonly kind: "task-cancel";
 } | {
     readonly kind: "workflow-tool-call";
+    readonly entryPoint: WorkflowToolEntryPoint;
     readonly workflowId: string;
 };
 /** Runtime-prepared handling consumed by the harness and execution boundary. */

package/dist/src/tools/definition.d.ts

@@ -1,4 +1,4 @@
-import type { ToolExecutionOptions } from "ai";
+import type { ModelMessage, ToolExecutionOptions } from "ai";
 import type { StandardJSONSchemaV1, StandardSchemaV1 } from "#compiled/@standard-schema/spec/index.js";
 import type { Approval } from "#approval/definition.js";
 import type { SessionContext } from "#context/session-context.js";
@@ -12,12 +12,10 @@ export type { ToolAuthDefinition, ToolAuthOptions, ToolAuthProvider } from "#too
 export type { ToolModelOutput, ToolModelOutputPart } from "#tools/model-output.js";
 export type ToolExecuteOptions = Omit<ToolExecutionOptions<unknown>, "context">;
 export type ToolExecuteFn<TInput = unknown, TOutput = unknown> = (input: TInput, options: ToolExecuteOptions) => Promise<TOutput> | TOutput | AsyncIterable<TOutput>;
-export type ToolExecution = "background";
 interface ToolDefinitionBase {
     /** Whether delegated agent sessions receive this tool. Defaults to `true`. */
     readonly availableInSubagents?: boolean;
     readonly description: string;
-    readonly execution?: ToolExecution;
 }
 export interface ToolLabelDefinition<TInput = unknown, TOutput = unknown> {
     /** Returns the presentation-safe label when one action invocation starts. */
@@ -40,6 +38,7 @@ export interface InternalToolLabelDefinition {
     readonly start?: (input: unknown) => string;
 }
 export interface InternalToolDefinition extends ToolDefinitionBase {
+    readonly endsTurn?: ToolDefinition["endsTurn"];
     label?: InternalToolLabelDefinition;
     name: string;
     inputSchema: JsonObject | null;
@@ -76,23 +75,25 @@ export interface ToolInputRequest {
      * {@link options}.
      */
     readonly allowFreeform?: boolean;
-    /**
-     * Whether the user's next message may skip the question. When `true`, a
-     * message that does not answer it resolves the request as `dismissed`, and
-     * the message reaches the agent as usual.
-     */
-    readonly dismissible?: boolean;
     /** Rendering hint: confirmation buttons, a selection list, or a text field. */
     readonly display?: "confirmation" | "select" | "text";
     /** Selectable answers. */
     readonly options?: readonly InputOption[];
     readonly prompt: string;
 }
+/** Public identity fields for the authenticated person who answered a question. */
+export interface ToolInputResponseResponder {
+    readonly authenticator: string;
+    readonly principalId: string;
+    readonly principalType: string;
+}
 /**
  * The outcome of a {@link ToolInputRequest}.
  *
- * - `answered`: the user picked an option or typed an answer.
- * - `dismissed`: the user moved on without answering a `dismissible` request.
+ * - `answered`: the user picked an option or typed an answer. An answer the
+ *   session accepted before a withdrawal wins, even after a signal aborted.
+ * - `cancelled`: the request was withdrawn before anyone answered it, because
+ *   the ask's `signal` or the call's `abortSignal` aborted.
  * - `unavailable`: the session cannot reach a human, such as a scheduled run,
  *   so the request resolved immediately without being shown.
  */
@@ -100,13 +101,25 @@ export type ToolInputResponse = {
     readonly status: "answered";
     /** The selected option's `id`, when the user picked one. */
     readonly optionId?: string;
+    /** Authenticated identity of the responder, without channel attributes. */
+    readonly responder?: ToolInputResponseResponder;
     /** Free text, when the user typed an answer. */
     readonly text?: string;
 } | {
-    readonly status: "dismissed";
+    readonly status: "cancelled";
 } | {
     readonly status: "unavailable";
 };
+/** Options for `ctx.ask` in a `defineWorkflowTool` executor. */
+export interface ToolInputRequestOptions {
+    /**
+     * Withdraws the request when it aborts: the channel stops offering the
+     * question and the ask resolves as `cancelled`, unless the session accepted
+     * an answer first, which the ask then resolves with. The call's
+     * `abortSignal` withdraws the request the same way without being passed.
+     */
+    readonly signal?: AbortSignal;
+}
 /**
  * Authored tool context. Passed as the last argument to
  * {@link ToolDefinition.execute}.
@@ -137,6 +150,15 @@ export type ToolContext = SessionContext & {
      * the tool's {@link ApprovalContext}.
      */
     readonly toolName: string;
+    /**
+     * Messages sent to the model for the step that requested this call, oldest
+     * first — the same model input a `step.started` dynamic resolver reads from
+     * `ctx.messages`. Excludes system instructions and the assistant response
+     * that contains this call. Includes eve-authored context messages, such as
+     * request context and recalled memory, and reflects history projection and
+     * compaction.
+     */
+    readonly messages: readonly ModelMessage[];
     /**
      * Resolves the bearer token for an inline provider. This accepts the same
      * auth shapes as a connection's `auth` field, including `connect("...")`
@@ -158,8 +180,26 @@ export type ToolContext = SessionContext & {
  * Authored definitions have no `name` field; identity is path-derived.
  */
 export interface ToolDefinition<TInput = unknown, TOutput = unknown> extends PublicToolDefinition<TInput, TOutput> {
-    readonly execution?: never;
     execute(input: TInput, ctx: ToolContext): Promise<TOutput> | TOutput | AsyncIterable<TOutput>;
+    /**
+     * Ends the turn after this tool succeeds, without another model call and
+     * without a final reply. Use it for a tool whose action is the whole
+     * answer, such as reacting to a message. The turn ends only when every
+     * tool call in the model's step ends the turn and succeeds; a failed call
+     * lets the model recover. Ignored in delegated sessions, which must return
+     * a reply to their caller, and on turns that request structured output.
+     * With `true`, eve appends a sentence to the description the model sees
+     * telling it the call ends its turn, so write `description` for what the
+     * tool does.
+     *
+     * Pass a function to decide from the result. eve calls it with the output
+     * of `execute` after each successful call, and the call ends the turn only
+     * when it returns `true`; if it throws, the turn continues as though it
+     * returned `false`. The model sees no appended sentence, so describe
+     * when the call ends the turn in `description` if the model needs to know.
+     * Defaults to `false`.
+     */
+    endsTurn?: boolean | ((output: TOutput) => boolean | Promise<boolean>);
     /**
      * Optional per-tool approval gate. The return value determines whether
      * user approval is required before executing this tool.
@@ -195,6 +235,7 @@ type ToolDefinitionWithExecuteReturn<TInput, TOutput, TReturn> = ToolDefinition<
  */
 export declare function defineTool<TInputSchema extends StandardSchemaV1<unknown, unknown> | StandardJSONSchemaV1<unknown, unknown>, TOutputSchema extends StandardJSONSchemaV1<unknown, unknown>, TReturn extends Promise<StandardJSONSchemaV1.InferOutput<TOutputSchema>> | StandardJSONSchemaV1.InferOutput<TOutputSchema> | AsyncIterable<StandardJSONSchemaV1.InferOutput<TOutputSchema>>>(definition: {
     description: ToolDefinition<unknown, unknown>["description"];
+    endsTurn?: ToolDefinition<unknown, StandardJSONSchemaV1.InferOutput<TOutputSchema>>["endsTurn"];
     inputSchema: TInputSchema;
     outputSchema: TOutputSchema;
     execute(input: StandardSchemaV1.InferOutput<TInputSchema>, ctx: ToolContext): TReturn;
@@ -205,6 +246,7 @@ export declare function defineTool<TInputSchema extends StandardSchemaV1<unknown
 }): ToolDefinitionWithExecuteReturn<StandardSchemaV1.InferOutput<TInputSchema>, StandardJSONSchemaV1.InferOutput<TOutputSchema>, TReturn>;
 export declare function defineTool<TSchema extends StandardSchemaV1<unknown, unknown> | StandardJSONSchemaV1<unknown, unknown>, TReturn>(definition: {
     description: ToolDefinition<unknown, unknown>["description"];
+    endsTurn?: ToolDefinition<unknown, ToolOutputFromExecuteReturn<TReturn>>["endsTurn"];
     inputSchema: TSchema;
     outputSchema?: JsonObject;
     execute(input: StandardSchemaV1.InferOutput<TSchema>, ctx: ToolContext): TReturn;
@@ -215,6 +257,7 @@ export declare function defineTool<TSchema extends StandardSchemaV1<unknown, unk
 }): ToolDefinitionWithExecuteReturn<StandardSchemaV1.InferOutput<TSchema>, ToolOutputFromExecuteReturn<TReturn>, TReturn>;
 export declare function defineTool<TOutputSchema extends StandardJSONSchemaV1<unknown, unknown>, TReturn extends Promise<StandardJSONSchemaV1.InferOutput<TOutputSchema>> | StandardJSONSchemaV1.InferOutput<TOutputSchema> | AsyncIterable<StandardJSONSchemaV1.InferOutput<TOutputSchema>>>(definition: {
     description: ToolDefinition<unknown, unknown>["description"];
+    endsTurn?: ToolDefinition<unknown, StandardJSONSchemaV1.InferOutput<TOutputSchema>>["endsTurn"];
     inputSchema: JsonObject;
     outputSchema: TOutputSchema;
     execute(input: Record<string, unknown>, ctx: ToolContext): TReturn;
@@ -225,6 +268,7 @@ export declare function defineTool<TOutputSchema extends StandardJSONSchemaV1<un
 }): ToolDefinitionWithExecuteReturn<Record<string, unknown>, StandardJSONSchemaV1.InferOutput<TOutputSchema>, TReturn>;
 export declare function defineTool<TReturn>(definition: {
     description: ToolDefinition<unknown, unknown>["description"];
+    endsTurn?: ToolDefinition<unknown, ToolOutputFromExecuteReturn<TReturn>>["endsTurn"];
     inputSchema: JsonObject;
     outputSchema?: JsonObject;
     execute(input: Record<string, unknown>, ctx: ToolContext): TReturn;
@@ -238,7 +282,7 @@ export declare function stampToolDefinition<T extends {
     readonly description: string;
     readonly inputSchema?: unknown;
     readonly outputSchema?: unknown;
-    readonly execute: (...args: never[]) => unknown;
+    readonly execute?: (...args: never[]) => unknown;
     readonly label?: ToolLabelDefinition;
     readonly approval?: Approval<never>;
     readonly approvalKey?: (...args: never[]) => unknown;

package/dist/src/tools/definition.js

@@ -1 +1 @@
-import{collectDurableDynamicToolCallbacks,stampDurableDynamicToolCallbacks}from"#tools/durable-callbacks.js";import{TOOL_BRAND}from"#tools/dynamic.js";import{stampDefinitionKey}from"#internal/authored-definition/source-identity.js";function defineTool(e){if(`execution`in e&&e.execution!==void 0)throw Error(`defineTool: "execution" is not supported. Use defineWorkflowTool for background work.`);return stampToolDefinition(e,`defineTool`)}function stampToolDefinition(e,t){if(e.auth!==void 0)throw Error(`${t}: The "auth" field is no longer supported. Pass auth providers inline to ctx.getToken(provider) or ctx.requireAuth(provider).`);return Object.assign(e,{[TOOL_BRAND]:!0}),stampDurableDynamicToolCallbacks(e,collectDurableDynamicToolCallbacks({inputSchema:e.inputSchema,outputSchema:e.outputSchema,label:e.label,approval:e.approval,approvalKey:e.approvalKey,execute:e.execute,toModelOutput:e.toModelOutput})),stampDefinitionKey(e,`tool:${e.description}`),e}const DISABLED_TOOL_SENTINEL_KIND=`eve:disabled-tool`;function disableTool(){return{kind:DISABLED_TOOL_SENTINEL_KIND}}function isDisabledToolSentinel(e){return typeof e==`object`&&!!e&&e.kind===DISABLED_TOOL_SENTINEL_KIND}export{defineTool,disableTool,isDisabledToolSentinel,stampToolDefinition};
+import{collectDurableDynamicToolCallbacks,stampDurableDynamicToolCallbacks}from"#tools/durable-callbacks.js";import{TOOL_BRAND}from"#tools/dynamic.js";import{stampDefinitionKey}from"#internal/authored-definition/source-identity.js";function defineTool(e){return stampToolDefinition(e,`defineTool`)}function stampToolDefinition(e,t){if(e.auth!==void 0)throw Error(`${t}: The "auth" field is no longer supported. Pass auth providers inline to ctx.getToken(provider) or ctx.requireAuth(provider).`);return Object.assign(e,{[TOOL_BRAND]:!0}),stampDurableDynamicToolCallbacks(e,collectDurableDynamicToolCallbacks({inputSchema:e.inputSchema,outputSchema:e.outputSchema,label:e.label,approval:e.approval,approvalKey:e.approvalKey,execute:e.execute,toModelOutput:e.toModelOutput})),stampDefinitionKey(e,`tool:${e.description}`),e}const DISABLED_TOOL_SENTINEL_KIND=`eve:disabled-tool`;function disableTool(){return{kind:DISABLED_TOOL_SENTINEL_KIND}}function isDisabledToolSentinel(e){return typeof e==`object`&&!!e&&e.kind===DISABLED_TOOL_SENTINEL_KIND}export{defineTool,disableTool,isDisabledToolSentinel,stampToolDefinition};

package/dist/src/tools/durable-callbacks.d.ts

@@ -105,7 +105,7 @@ export declare function collectDurableDynamicToolCallbacks(input: {
     };
     readonly approval?: Approval<never>;
     readonly approvalKey?: (...args: never[]) => unknown;
-    readonly execute: (...args: never[]) => unknown;
+    readonly execute?: (...args: never[]) => unknown;
     readonly toModelOutput?: (...args: never[]) => unknown;
 }): LiveDurableDynamicToolCallbacks;
 export declare function readDurableDynamicToolCallbacks(definition: object): LiveDurableDynamicToolCallbacks | undefined;

package/dist/src/tools/dynamic.d.ts

@@ -18,6 +18,12 @@ export interface DynamicToolEntry<TInput = Record<string, unknown>, TOutput = an
     readonly availableInSubagents?: boolean;
     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.
+     */
+    readonly endsTurn?: boolean | ((output: TOutput) => boolean | Promise<boolean>);
     readonly inputSchema: PublicToolInputSchema<TInput>;
     readonly outputSchema?: PublicToolOutputSchema<TOutput>;
     execute(input: TInput, ctx: ToolContext): TOutput | Promise<TOutput>;

package/dist/src/tools/framework/agent-contract.d.ts

@@ -1,7 +1,4 @@
+import type { AgentToolInput } from "#runtime/subagents/workflow.js";
 export declare const AGENT_TOOL_NAME = "agent";
 export declare const AGENT_TOOL_DESCRIPTION: string;
-export interface SubagentToolInput {
-    agentId?: string | null;
-    message: string;
-}
-export declare const SUBAGENT_TOOL_INPUT_SCHEMA: import("#tools/schema.js").ToolSchema<SubagentToolInput, SubagentToolInput>;
+export declare const SUBAGENT_TOOL_INPUT_SCHEMA: import("#tools/schema.js").ToolSchema<AgentToolInput, AgentToolInput>;

package/dist/src/tools/framework/agent-contract.js

@@ -1 +1 @@
-import{defineJsonSchema}from"#tools/schema.js";const AGENT_TOOL_NAME=`agent`,AGENT_TOOL_DESCRIPTION=["Delegate a focused subtask to a copy of yourself, or continue or steer a previous delegation with `agentId`.",`Use it to isolate complex work or split a large task into independent pieces.`,"Issue multiple `agent` calls in one response to run a small fixed set in parallel.","A new child has fresh history and state but reuses your tools and sandbox, so include essential context in `message` and give parallel writers non-overlapping scopes."].join(` `),SUBAGENT_TOOL_INPUT_SCHEMA=defineJsonSchema({type:`object`,properties:{agentId:{type:[`string`,`null`],description:`The id of an existing agent from the <agents> list or a task receipt. A message to a busy agent steers it: its previous task is cancelled and the updated work runs in the same child session. Omit this field (or pass null or an empty string) to start a new agent.`},message:{type:`string`,description:`The message to send to the subagent. Provide all context the subagent needs to complete the task; the subagent does not see the parent's history.`}},required:[`message`],additionalProperties:!1});export{AGENT_TOOL_DESCRIPTION,AGENT_TOOL_NAME,SUBAGENT_TOOL_INPUT_SCHEMA};
+import{defineJsonSchema}from"#tools/schema.js";const AGENT_TOOL_NAME=`agent`,AGENT_TOOL_DESCRIPTION=[`Delegate a focused subtask to a copy of yourself.`,`Use it to isolate complex work or split a large task into independent pieces.`,`Each call starts a task, so several agents can work at once: start every independent one before you wait.`,`A new child has fresh history and state but reuses your tools and sandbox, so give parallel writers non-overlapping scopes.`,`In message, state the goal, what to return, and whether it may change files.`].join(` `),SUBAGENT_TOOL_INPUT_SCHEMA=defineJsonSchema({type:`object`,properties:{message:{type:`string`,description:`The message to send to the agent, with everything it needs to do the work.`}},required:[`message`],additionalProperties:!1});export{AGENT_TOOL_DESCRIPTION,AGENT_TOOL_NAME,SUBAGENT_TOOL_INPUT_SCHEMA};

package/dist/src/tools/framework/agent.d.ts

@@ -1,9 +1,6 @@
-import { type SubagentTaskReceipt } from "#tools/framework/task-contract.js";
 export declare const agent: {
     description: string;
-    execution: string;
-    inputSchema: import("../schema.ts").ToolSchema<import("#tools/framework/agent-contract.js").SubagentToolInput, import("#tools/framework/agent-contract.js").SubagentToolInput>;
-    outputSchema: import("../schema.ts").ToolSchema<SubagentTaskReceipt, SubagentTaskReceipt>;
-    execute(): SubagentTaskReceipt;
+    inputSchema: import("../schema.ts").ToolSchema<import("../../runtime/subagents/workflow.ts").AgentToolInput, import("../../runtime/subagents/workflow.ts").AgentToolInput>;
+    execute(): never;
 };
 export default agent;

package/dist/src/tools/framework/agent.js

@@ -1 +1 @@
-import{SUBAGENT_TASK_RECEIPT_OUTPUT_SCHEMA}from"#tools/framework/task-contract.js";import{stampToolDefinition}from"#tools/definition.js";import{AGENT_TOOL_DESCRIPTION,SUBAGENT_TOOL_INPUT_SCHEMA}from"#tools/framework/agent-contract.js";import{attachToolBehavior}from"#tools/behavior.js";const agent=attachToolBehavior(stampToolDefinition({description:`${AGENT_TOOL_DESCRIPTION} This call starts a background task and returns a task receipt immediately.`,execution:`background`,inputSchema:SUBAGENT_TOOL_INPUT_SCHEMA,outputSchema:SUBAGENT_TASK_RECEIPT_OUTPUT_SCHEMA,execute(){throw Error(`The framework "agent" tool was executed directly. It must be resolved through the runtime tool registry, which dispatches it to the shared subagent workflow.`)}},`defineTool`),{availability:[`root-session`],handling:{action:`self-agent`,kind:`dispatch`}});export{agent,agent as default};
+import{AGENT_TOOL_DESCRIPTION,SUBAGENT_TOOL_INPUT_SCHEMA}from"#tools/framework/agent-contract.js";import{stampToolDefinition}from"#tools/definition.js";import{attachToolBehavior}from"#tools/behavior.js";const agent=attachToolBehavior(stampToolDefinition({description:AGENT_TOOL_DESCRIPTION,inputSchema:SUBAGENT_TOOL_INPUT_SCHEMA,execute(){throw Error(`The framework "agent" tool was executed directly. It must be resolved through the runtime tool registry, which dispatches it to the shared subagent workflow.`)}},`defineTool`),{availability:[`root-session`],handling:{action:`self-agent`,kind:`dispatch`}});export{agent,agent as default};

package/dist/src/tools/framework/connection-tools.d.ts

@@ -0,0 +1,3 @@
+/** Provides `connection_search` and `connection_execute` while the agent has connections. */
+export declare const connectionTools: import("#dynamic/definition.js").DynamicSentinel<Readonly<Record<string, import("../dynamic.ts").DynamicToolEntry<any, any>>> | null>;
+export default connectionTools;

package/dist/src/tools/framework/connection-tools.js

@@ -0,0 +1 @@
+import{defineDynamic}from"#dynamic/definition.js";import{resolveConnectionTools}from"#execution/tools/connection-tools.js";const connectionTools=defineDynamic({events:{"step.started":resolveConnectionTools}});export{connectionTools,connectionTools as default};

package/dist/src/tools/provided/agent-router.d.ts

@@ -1,7 +1,10 @@
 import type { JsonValue } from "#shared/json.js";
 import { type AgentRouterInput } from "#execution/tools/agent-router.js";
-import { type BlockingWorkflowToolDefinition } from "#tools/workflow-definition.js";
+import { type WorkflowTaskToolDefinition } from "#tools/workflow-definition.js";
 export type { AgentRouterInput };
-export type AgentRouterTool = BlockingWorkflowToolDefinition<AgentRouterInput, JsonValue>;
-/** Defines a workflow tool that uses JEV to route a task across all available agent targets. */
+export type AgentRouterTool = WorkflowTaskToolDefinition<AgentRouterInput, JsonValue>;
+/**
+ * Defines a workflow tool that uses JEV to route a task across all available
+ * agent targets. Each call runs as a task.
+ */
 export declare function agentRouter(): AgentRouterTool;

package/dist/src/tools/provided/agent-router.js

@@ -1 +1 @@
-import{defineWorkflowTool}from"#tools/workflow-definition.js";import{AGENT_ROUTER_INPUT_SCHEMA,AGENT_ROUTER_TOOL_DESCRIPTION,executeAgentRouterTool}from"#execution/tools/agent-router.js";function agentRouter(){return defineWorkflowTool({availableInSubagents:!1,description:AGENT_ROUTER_TOOL_DESCRIPTION,execute:executeAgentRouterTool,inputSchema:AGENT_ROUTER_INPUT_SCHEMA})}export{agentRouter};
+import{defineWorkflowTool}from"#tools/workflow-definition.js";import{AGENT_ROUTER_INPUT_SCHEMA,AGENT_ROUTER_TOOL_DESCRIPTION,runAgentRouterTask}from"#execution/tools/agent-router.js";function agentRouter(){return defineWorkflowTool({availableInSubagents:!1,description:AGENT_ROUTER_TOOL_DESCRIPTION,inputSchema:AGENT_ROUTER_INPUT_SCHEMA,task:runAgentRouterTask})}export{agentRouter};

package/dist/src/{execution/tools → tools/provided}/ask-question-workflow.d.ts

@@ -1,7 +1,6 @@
-import type { AskQuestionInput, AskQuestionOutput } from "#execution/tools/ask-question.js";
-import type { ToolInputRequest, ToolInputResponse } from "#tools/definition.js";
-import type { WorkflowToolContext } from "#tools/workflow-definition.js";
-/** Asks the session's user one question in a workflow dedicated to this tool call. */
+import type { ToolInputRequest, ToolInputResponse, WorkflowToolContext } from "#public/tools/index.js";
+import type { AskQuestionInput, AskQuestionOutput } from "#tools/provided/ask-question.js";
+/** Asks the session's user one question, and withdraws it when a new message arrives. */
 export declare function executeAskQuestionTool(input: AskQuestionInput, ctx: WorkflowToolContext): Promise<AskQuestionOutput>;
 /**
  * Free text is always allowed, so the model never needs an "Other" option.

package/dist/src/tools/provided/ask-question-workflow.js

@@ -0,0 +1 @@
+async function executeAskQuestionTool(e,t){"use workflow";return toAskQuestionOutput(await t.ask(toAskQuestionRequest(e)))}function toAskQuestionRequest(e){let t=e.options?.map(e=>({description:e.description,id:e.label,label:e.label}));return{allowFreeform:!0,display:t===void 0?`text`:`select`,prompt:e.question,...t!==void 0&&{options:t}}}function toAskQuestionOutput(e){switch(e.status){case`answered`:return{answer:e.optionId??e.text??``,status:`answered`};case`cancelled`:return{interrupted:!0};case`unavailable`:return{status:`unavailable`}}}executeAskQuestionTool.workflowId=`workflow//eve@0.69.0//executeAskQuestionTool`;export{executeAskQuestionTool,toAskQuestionOutput,toAskQuestionRequest};

package/dist/src/tools/provided/ask-question.d.ts

@@ -1,6 +1,20 @@
-import { type WorkflowToolDefinition } from "#tools/workflow-definition.js";
-import { type AskQuestionInput, type AskQuestionOutput } from "#execution/tools/ask-question.js";
-export type { AskQuestionInput, AskQuestionOutput };
+import { type WorkflowExecuteToolDefinition } from "#public/tools/index.js";
+import { type InterruptedOutput } from "#tools/provided/interrupted.js";
+export declare const ASK_QUESTION_TOOL_DESCRIPTION: string;
+export interface AskQuestionInput {
+    options?: {
+        description: string;
+        label: string;
+    }[];
+    question: string;
+}
+export type AskQuestionOutput = {
+    answer: string;
+    status: "answered";
+} | InterruptedOutput | {
+    status: "unavailable";
+};
+export declare const ASK_QUESTION_INPUT_SCHEMA: import("#tools/schema.js").ToolSchema<AskQuestionInput, AskQuestionInput>;
 /**
  * Defines the opt-in `ask_question` tool.
  *
@@ -13,6 +27,7 @@ export type { AskQuestionInput, AskQuestionOutput };
  * ```
  *
  * Each call runs as a durable workflow that asks through `ctx.ask()`, so the
- * turn waits for the answer without holding an application runtime open.
+ * turn waits for the answer without holding an application runtime open. A new
+ * message that does not answer the question withdraws it.
  */
-export declare function askQuestion(): WorkflowToolDefinition<AskQuestionInput, AskQuestionOutput>;
+export declare function askQuestion(): WorkflowExecuteToolDefinition<AskQuestionInput, AskQuestionOutput>;

package/dist/src/tools/provided/ask-question.js

@@ -1 +1,2 @@
-import{defineWorkflowTool}from"#tools/workflow-definition.js";import{ASK_QUESTION_INPUT_SCHEMA,ASK_QUESTION_OUTPUT_SCHEMA,ASK_QUESTION_TOOL_DESCRIPTION,executeAskQuestionTool}from"#execution/tools/ask-question.js";function askQuestion(){return defineWorkflowTool({description:ASK_QUESTION_TOOL_DESCRIPTION,execute:executeAskQuestionTool,inputSchema:ASK_QUESTION_INPUT_SCHEMA,outputSchema:ASK_QUESTION_OUTPUT_SCHEMA})}export{askQuestion};
+import{defineJsonSchema}from"#tools/schema.js";import{defineWorkflowTool}from"#public/tools/index.js";import{executeAskQuestionTool}from"#tools/provided/ask-question-workflow.js";import{INTERRUPTED_OUTPUT_SCHEMA,toInterruptibleModelOutput}from"#tools/provided/interrupted.js";const ASK_QUESTION_TOOL_DESCRIPTION=[`Ask the user a question and wait for the answer. Use this only when you cannot make good progress without the user's input: to choose between materially different approaches, fill in a missing requirement, or confirm something risky or irreversible. Do not ask for information you can find with your other tools, and do not ask the user to confirm routine steps.`,``,`Usage:`,`- Ask one focused question that includes the context needed to answer it.`,`- For a decision, offer 2-3 mutually exclusive options. Put the option you recommend first and end its label with "(Recommended)".`,`- Do not add an "Other" option; the user can always type their own answer.`,"- The result's `answer` is the chosen option's label or the user's own words.",`- If the question stopped early because a new message arrived, respond to that message instead.`,`- If the status is "unavailable", no one can answer in this session; continue with your best judgment and state the assumption you made.`].join(`
+`),ASK_QUESTION_INPUT_SCHEMA=defineJsonSchema({type:`object`,properties:{options:{type:`array`,minItems:2,maxItems:3,items:{type:`object`,properties:{description:{type:`string`,minLength:1,maxLength:200,description:`One short sentence on the impact or tradeoff of choosing this option.`},label:{type:`string`,minLength:1,maxLength:80,description:`User-facing label, 1-5 words.`}},required:[`description`,`label`],additionalProperties:!1},description:`Two or three mutually exclusive choices, recommended option first. Omit for an open-ended question. Never include an "Other" option.`},question:{type:`string`,minLength:1,maxLength:2e3,description:`The question to show the user, with the context needed to answer it.`}},required:[`question`],additionalProperties:!1},e=>e.options!==void 0&&new Set(e.options.map(e=>e.label)).size!==e.options.length?`Option labels must be unique.`:void 0),ASK_QUESTION_OUTPUT_SCHEMA=defineJsonSchema({oneOf:[{type:`object`,properties:{answer:{type:`string`,description:`The chosen option's label, or the user's own words.`},status:{type:`string`,const:`answered`}},required:[`answer`,`status`],additionalProperties:!1},INTERRUPTED_OUTPUT_SCHEMA,{type:`object`,properties:{status:{type:`string`,const:`unavailable`}},required:[`status`],additionalProperties:!1}]});function askQuestion(){return defineWorkflowTool({description:ASK_QUESTION_TOOL_DESCRIPTION,execute:executeAskQuestionTool,inputSchema:ASK_QUESTION_INPUT_SCHEMA,outputSchema:ASK_QUESTION_OUTPUT_SCHEMA,toModelOutput:toInterruptibleModelOutput})}export{ASK_QUESTION_INPUT_SCHEMA,ASK_QUESTION_TOOL_DESCRIPTION,askQuestion};

package/dist/src/tools/provided/interrupted.d.ts

@@ -0,0 +1,18 @@
+import { type ToolModelOutput } from "#public/tools/index.js";
+/** What a provided tool returns when a new message stops it early. */
+export interface InterruptedOutput {
+    readonly interrupted: true;
+}
+/** The model sees an interrupted call as text and every other output as JSON, as it would by default. */
+export declare function toInterruptibleModelOutput(output: object): ToolModelOutput;
+export declare const INTERRUPTED_OUTPUT_SCHEMA: {
+    readonly type: "object";
+    readonly properties: {
+        readonly interrupted: {
+            readonly type: "boolean";
+            readonly const: true;
+        };
+    };
+    readonly required: readonly ["interrupted"];
+    readonly additionalProperties: false;
+};

package/dist/src/tools/provided/interrupted.js

@@ -0,0 +1 @@
+import{toolOutput}from"#public/tools/index.js";function toInterruptibleModelOutput(e){return`interrupted`in e?toolOutput.text(`Stopped early because a new message arrived.`):toolOutput.json(e)}const INTERRUPTED_OUTPUT_SCHEMA={type:`object`,properties:{interrupted:{type:`boolean`,const:!0}},required:[`interrupted`],additionalProperties:!1};export{INTERRUPTED_OUTPUT_SCHEMA,toInterruptibleModelOutput};

package/dist/src/tools/provided/no-reply.d.ts

@@ -0,0 +1,19 @@
+import { type ToolDefinition } from "#public/tools/index.js";
+export interface NoReplyToolInput {
+    reason?: string;
+}
+/**
+ * Defines the opt-in `no_reply` tool, which ends the turn without a reply.
+ *
+ * Export it from `agent/tools/no_reply.ts`:
+ *
+ * ```ts
+ * import { noReply } from "eve/tools/no_reply";
+ *
+ * export default noReply();
+ * ```
+ *
+ * A turn that ends with `no_reply` completes without a final message, so
+ * channels and schedules post nothing. Only root sessions receive it.
+ */
+export declare function noReply(): ToolDefinition<NoReplyToolInput, string>;

package/dist/src/tools/provided/no-reply.js

@@ -0,0 +1 @@
+import{defineTool}from"#public/tools/index.js";function noReply(){return defineTool({availableInSubagents:!1,description:`End your turn without sending a reply. Use this when nothing needs to be said, such as when a scheduled check finds nothing to report or an action you already took is the whole answer.`,endsTurn:!0,execute:()=>`No reply was sent.`,inputSchema:{type:`object`,properties:{reason:{type:`string`,description:`Why no reply is needed. Kept in the session history and traces; never sent.`}},additionalProperties:!1}})}export{noReply};

package/dist/src/tools/provided/sleep-workflow.d.ts

@@ -0,0 +1,4 @@
+import type { WorkflowToolContext } from "#public/tools/index.js";
+import type { SleepToolInput, SleepToolOutput } from "#tools/provided/sleep.js";
+/** Waits durably, and stops early when a new message arrives. */
+export declare function executeSleepTool(input: SleepToolInput, ctx: WorkflowToolContext): Promise<SleepToolOutput>;

package/dist/src/tools/provided/sleep-workflow.js

@@ -0,0 +1 @@
+import{sleep}from"#compiled/@workflow/core/index.js";async function executeSleepTool(e,t){"use workflow";let n=new Promise(e=>t.abortSignal.addEventListener(`abort`,()=>e(`interrupted`),{once:!0})),r=sleep(Math.ceil(e.seconds*1e3)).then(()=>`elapsed`);return await Promise.race([r,n])===`elapsed`?{waitedSeconds:e.seconds}:{interrupted:!0}}executeSleepTool.workflowId=`workflow//eve@0.69.0//executeSleepTool`;export{executeSleepTool};

package/dist/src/tools/provided/sleep.d.ts

@@ -1,6 +1,12 @@
-import { type WorkflowToolDefinition } from "#tools/workflow-definition.js";
-import { type SleepToolInput, type SleepToolOutput } from "#execution/tools/sleep.js";
-export type { SleepToolInput, SleepToolOutput };
+import { type WorkflowExecuteToolDefinition } from "#public/tools/index.js";
+import { type InterruptedOutput } from "#tools/provided/interrupted.js";
+export interface SleepToolInput {
+    seconds: number;
+}
+export type SleepToolOutput = {
+    waitedSeconds: number;
+} | InterruptedOutput;
+export declare const SLEEP_INPUT_SCHEMA: import("#tools/schema.js").ToolSchema<SleepToolInput, SleepToolInput>;
 /**
  * Defines the opt-in durable `sleep` tool.
  *
@@ -13,6 +19,6 @@ export type { SleepToolInput, SleepToolOutput };
  * ```
  *
  * Each call runs as a durable workflow, so the wait does not hold an
- * application runtime open.
+ * application runtime open. A new message ends the wait early.
  */
-export declare function sleep(): WorkflowToolDefinition<SleepToolInput, SleepToolOutput>;
+export declare function sleep(): WorkflowExecuteToolDefinition<SleepToolInput, SleepToolOutput>;

package/dist/src/tools/provided/sleep.js

@@ -1 +1 @@
-import{defineWorkflowTool}from"#tools/workflow-definition.js";import{SLEEP_INPUT_SCHEMA,SLEEP_OUTPUT_SCHEMA,SLEEP_TOOL_DESCRIPTION,executeSleepTool}from"#execution/tools/sleep.js";function sleep(){return defineWorkflowTool({description:SLEEP_TOOL_DESCRIPTION,execute:executeSleepTool,inputSchema:SLEEP_INPUT_SCHEMA,outputSchema:SLEEP_OUTPUT_SCHEMA})}export{sleep};
+import{defineJsonSchema}from"#tools/schema.js";import{defineWorkflowTool}from"#public/tools/index.js";import{INTERRUPTED_OUTPUT_SCHEMA,toInterruptibleModelOutput}from"#tools/provided/interrupted.js";import{executeSleepTool}from"#tools/provided/sleep-workflow.js";const SLEEP_INPUT_SCHEMA=defineJsonSchema({type:`object`,properties:{seconds:{type:`number`,exclusiveMinimum:0,maximum:Math.floor((2**53-1)/1e3),description:`How long to wait, in seconds.`}},required:[`seconds`],additionalProperties:!1}),SLEEP_OUTPUT_SCHEMA=defineJsonSchema({oneOf:[{type:`object`,properties:{waitedSeconds:{type:`number`,exclusiveMinimum:0}},required:[`waitedSeconds`],additionalProperties:!1},INTERRUPTED_OUTPUT_SCHEMA]});function sleep(){return defineWorkflowTool({description:`Wait for a specified amount of time before continuing. Use this when a process or condition needs time to change before it is useful to check its progress or status again.`,execute:executeSleepTool,inputSchema:SLEEP_INPUT_SCHEMA,outputSchema:SLEEP_OUTPUT_SCHEMA,toModelOutput:toInterruptibleModelOutput})}export{SLEEP_INPUT_SCHEMA,sleep};

package/dist/src/tools/provided/task-cancel.d.ts

@@ -0,0 +1,6 @@
+import type { HarnessToolDefinition } from "#harness/execute-tool.js";
+export interface TaskCancelInput {
+    readonly taskId: string;
+}
+/** `task_cancel`, offered to agents that can start tasks; the session answers each call. */
+export declare const taskCancelTool: HarnessToolDefinition;

package/dist/src/tools/provided/task-cancel.js

@@ -0,0 +1 @@
+import{TASK_CANCEL_TOOL_NAME}from"#protocol/task-tools.js";import{defineJsonSchema}from"#tools/schema.js";import{TASK_CANCEL_DESCRIPTION,TASK_CANCEL_TASK_ID_DESCRIPTION}from"#execution/tasks/render.js";const taskCancelTool={description:TASK_CANCEL_DESCRIPTION,frameworkAction:`task-cancel`,inputSchema:defineJsonSchema({type:`object`,properties:{taskId:{type:`string`,minLength:1,description:TASK_CANCEL_TASK_ID_DESCRIPTION}},required:[`taskId`],additionalProperties:!1}),name:TASK_CANCEL_TOOL_NAME};export{taskCancelTool};

package/dist/src/tools/provided/task-wait.d.ts

@@ -0,0 +1,9 @@
+import type { HarnessToolDefinition } from "#harness/execute-tool.js";
+export interface TaskWaitInput {
+    readonly timeoutSeconds?: number;
+}
+/**
+ * `task_wait`, offered to agents that can start tasks. It is not a workflow tool: the
+ * call defers out of the model step and the session parks the turn itself.
+ */
+export declare const taskWaitTool: HarnessToolDefinition;

package/dist/src/tools/provided/task-wait.js

@@ -0,0 +1 @@
+import{TASK_WAIT_TOOL_NAME}from"#protocol/task-tools.js";import{defineJsonSchema}from"#tools/schema.js";import{TASK_WAIT_DESCRIPTION,TASK_WAIT_TIMEOUT_DESCRIPTION}from"#execution/tasks/render.js";const taskWaitTool={description:TASK_WAIT_DESCRIPTION,frameworkAction:`task-wait`,inputSchema:defineJsonSchema({type:`object`,properties:{timeoutSeconds:{type:`integer`,minimum:1,description:TASK_WAIT_TIMEOUT_DESCRIPTION}},additionalProperties:!1}),name:TASK_WAIT_TOOL_NAME};export{taskWaitTool};

package/dist/src/tools/provided/workflow.d.ts

@@ -1,5 +1,5 @@
 import type { JsonValue } from "#shared/json.js";
-import { type BlockingWorkflowToolDefinition } from "#tools/workflow-definition.js";
+import { type WorkflowTaskToolDefinition } from "#tools/workflow-definition.js";
 export interface WorkflowToolOptions {
     /** Maximum child-agent calls per program, from 1 to 128. Defaults to 100. */
     readonly maxSubagents?: number;
@@ -7,6 +7,6 @@ export interface WorkflowToolOptions {
 export interface WorkflowToolInput {
     readonly js: string;
 }
-export type WorkflowTool = BlockingWorkflowToolDefinition<WorkflowToolInput, JsonValue>;
+export type WorkflowTool = WorkflowTaskToolDefinition<WorkflowToolInput, JsonValue>;
 /** Defines a model-facing workflow tool backed by isolated runtime JavaScript. */
 export declare function workflow(options?: WorkflowToolOptions): WorkflowTool;

package/dist/src/tools/provided/workflow.js

@@ -1 +1 @@
-import{defineJsonSchema}from"#tools/schema.js";import{defineWorkflowTool}from"#tools/workflow-definition.js";import{DEFAULT_WORKFLOW_PROGRAM_MAX_SUBAGENTS,parseWorkflowProgramOptions}from"#execution/dynamic-workflow/schema.js";import{attachWorkflowProgramOptions}from"#tools/workflow-program-input.js";import{executeWorkflowProgram}from"#execution/dynamic-workflow/tool.js";const workflowProgramAgentContract=`Call ctx.agent(name, { message: string, agentId?: string, outputSchema?: object }). It resolves directly to the child's JSON-serializable output; when outputSchema is provided, the output matches that schema. It does not return an agent metadata wrapper. Use an agentId from the conversation's <agents> block to continue that child. The owning agent resolves the target and applies its existing availability and authorization checks.`,workflowInputSchema=defineJsonSchema({type:`object`,properties:{js:{type:`string`,description:`JavaScript statements executed inside an async function. Supply only the body, without a surrounding function declaration or arrow function. ${workflowProgramAgentContract} Return one JSON-serializable value.`}},required:[`js`],additionalProperties:!1});function workflow(e={}){let t=normalizeWorkflowToolOptions(e),n=[`Run an async JavaScript function body that invokes agents and returns one JSON-serializable value.`,workflowProgramAgentContract,`Supply the body directly, for example: return await ctx.agent("researcher", { message: "Describe the task" });`,`The program may invoke at most ${String(t.maxSubagents)} agents.`].join(` `);return attachWorkflowProgramOptions(defineWorkflowTool({description:n,execute:executeWorkflowProgram,inputSchema:workflowInputSchema}),t)}function normalizeWorkflowToolOptions(e){if(typeof e!=`object`||!e)throw TypeError(`workflow options must be an object.`);return parseWorkflowProgramOptions({maxSubagents:e.maxSubagents??DEFAULT_WORKFLOW_PROGRAM_MAX_SUBAGENTS})}export{workflow};
+import{defineJsonSchema}from"#tools/schema.js";import{defineWorkflowTool}from"#tools/workflow-definition.js";import{DEFAULT_WORKFLOW_PROGRAM_MAX_SUBAGENTS,parseWorkflowProgramOptions}from"#execution/dynamic-workflow/schema.js";import{attachWorkflowProgramOptions}from"#tools/workflow-program-input.js";import{runWorkflowProgramTask}from"#execution/dynamic-workflow/tool.js";const workflowProgramAgentContract=`Call ctx.agent(name, { message: string, outputSchema?: object }). Each call starts a new agent that does not see this conversation, so put everything it needs in message. It resolves directly to the agent's reply; when outputSchema is provided, the reply matches that schema. It does not return an agent metadata wrapper. The owning agent resolves the target and applies its existing availability and authorization checks.`,workflowInputSchema=defineJsonSchema({type:`object`,properties:{js:{type:`string`,description:`JavaScript statements executed inside an async function. Supply only the body, without a surrounding function declaration or arrow function. ${workflowProgramAgentContract} Return one JSON-serializable value.`}},required:[`js`],additionalProperties:!1});function workflow(e={}){let t=normalizeWorkflowToolOptions(e),n=[`Run an async JavaScript function body that invokes agents and returns one JSON-serializable value.`,workflowProgramAgentContract,`Supply the body directly, for example: return await ctx.agent("researcher", { message: "Describe the task" });`,`The program may invoke at most ${String(t.maxSubagents)} agents.`].join(` `);return attachWorkflowProgramOptions(defineWorkflowTool({description:n,inputSchema:workflowInputSchema,task:runWorkflowProgramTask}),t)}function normalizeWorkflowToolOptions(e){if(typeof e!=`object`||!e)throw TypeError(`workflow options must be an object.`);return parseWorkflowProgramOptions({maxSubagents:e.maxSubagents??DEFAULT_WORKFLOW_PROGRAM_MAX_SUBAGENTS})}export{workflow};

package/dist/src/tools/schema-emission.d.ts

@@ -0,0 +1,23 @@
+import type { StandardJSONSchemaV1 } from "#compiled/@standard-schema/spec/index.js";
+import { type JsonObject } from "#shared/json.js";
+import type { ToolSchemaSource } from "#tools/schema.js";
+export type SchemaDirection = "input" | "output";
+/** `null` and `undefined` pass through every conversion untouched. */
+export type SchemaResult<TSource, TResult> = TSource extends null | undefined ? TSource : TResult;
+type JsonSchemaEmitter = StandardJSONSchemaV1.Converter[SchemaDirection];
+/**
+ * Serializes an output schema source into canonical JSON Schema data (no
+ * `$schema` key) for compiled artifacts, durable state, and protocol
+ * responses. `null` and `undefined` pass through untouched.
+ */
+export declare function serializeOutputSchema<T extends ToolSchemaSource | null | undefined>(source: T): SchemaResult<T, JsonObject>;
+/**
+ * Normalizes one source into canonical JSON Schema data. Standard Schemas
+ * emit their requested direction; plain data passes through. The `$schema`
+ * version key is always stripped so every eve boundary carries one canonical
+ * wire form.
+ */
+export declare function emitJsonSchema(source: ToolSchemaSource, direction: SchemaDirection): JsonObject;
+export declare function readJsonSchemaEmitter(standard: Record<string, unknown>, direction: SchemaDirection): JsonSchemaEmitter | undefined;
+export declare function getStandardSchemaProperties(value: unknown): Record<string, unknown> | undefined;
+export {};

package/dist/src/tools/schema-emission.js

@@ -0,0 +1 @@
+import{parseJsonObject}from"#shared/json.js";function serializeOutputSchema(e){return e==null?e:emitJsonSchema(e,`output`)}function emitJsonSchema(e,t){let n=getStandardSchemaProperties(e);if(n===void 0)return withoutSchemaVersion(parseJsonObject(e));let r=readJsonSchemaEmitter(n,t);if(r===void 0)throw Error(describeMissingEmitter(n));return withoutSchemaVersion(parseJsonObject(r({target:`draft-07`})))}function readJsonSchemaEmitter(e,t){let n=e.jsonSchema;if(typeof n!=`object`||!n)return;let r=n[t];return typeof r==`function`?r:void 0}function getStandardSchemaProperties(e){if(typeof e!=`object`||!e||!(`~standard`in e))return;let t=e[`~standard`];return typeof t==`object`&&t?t:void 0}function describeMissingEmitter(e){let t=typeof e.vendor==`string`?e.vendor:`unknown`;return t===`zod`?`Zod 3 cannot emit an output JSON Schema. Upgrade to Zod 4 or provide a plain JSON Schema object.`:`Standard Schema vendor "${t}" does not support JSON Schema conversion. Provide a Standard Schema implementation with JSON Schema conversion or a plain JSON Schema object.`}function withoutSchemaVersion(e){let{$schema:t,...n}=e;return n}export{emitJsonSchema,getStandardSchemaProperties,readJsonSchemaEmitter,serializeOutputSchema};

package/dist/src/tools/schema.d.ts

@@ -1,6 +1,8 @@
 import { type FlexibleSchema } from "ai";
 import type { StandardJSONSchemaV1, StandardSchemaV1 } from "#compiled/@standard-schema/spec/index.js";
 import { type JsonObject } from "#shared/json.js";
+import { type SchemaDirection, type SchemaResult } from "#tools/schema-emission.js";
+export { serializeOutputSchema } from "#tools/schema-emission.js";
 /**
  * eve-owned schema contract for tool input and output schemas: a Standard
  * Schema validator that can also emit JSON Schema. Author schemas (Zod,
@@ -15,9 +17,6 @@ export type ToolSchema<Input = unknown, Output = Input> = StandardSchemaV1<Input
  * conversion.
  */
 export type ToolSchemaSource = StandardJSONSchemaV1 | StandardSchemaV1 | Record<string, unknown>;
-type SchemaDirection = "input" | "output";
-/** `null` and `undefined` pass through every conversion untouched. */
-type SchemaResult<TSource, TResult> = TSource extends null | undefined ? TSource : TResult;
 /**
  * Resolves a source into a live input {@link ToolSchema}. Live schemas pass
  * through unchanged; plain JSON Schema data becomes a {@link defineJsonSchema}
@@ -37,11 +36,15 @@ export declare function toOutputSchema<T extends ToolSchemaSource | null | undef
  */
 export declare function serializeInputSchema<T extends ToolSchemaSource | null | undefined>(source: T): SchemaResult<T, JsonObject>;
 /**
- * Serializes an output schema source into canonical JSON Schema data (no
- * `$schema` key) for compiled artifacts, durable state, and protocol
- * responses. `null` and `undefined` pass through untouched.
+ * Serializes an input schema into the JSON Schema eve sends a model for it.
+ * A schema from a validation library such as Zod, Valibot, or ArkType gets
+ * `additionalProperties: false` on every object that allows no other keys, as
+ * the AI SDK applies to library schemas. Plain JSON Schema is sent exactly as
+ * written. `null` and `undefined` pass through untouched.
+ *
+ * Providers can transform the schema further before the model reads it.
  */
-export declare function serializeOutputSchema<T extends ToolSchemaSource | null | undefined>(source: T): SchemaResult<T, JsonObject>;
+export declare function serializeModelInputSchema<T extends ToolSchemaSource | null | undefined>(source: T): SchemaResult<T, JsonObject>;
 /**
  * Returns whether a value implements the full {@link ToolSchema} contract:
  * Standard Schema validation plus JSON Schema emission.
@@ -63,6 +66,18 @@ export declare function isToolSchema(value: unknown): value is ToolSchema;
  * for constraints JSON Schema cannot express.
  */
 export declare function defineJsonSchema<T = unknown>(schema: JsonObject, check?: (value: T) => string | undefined): ToolSchema<T>;
+/** An optional string property added to an input schema. */
+export interface OptionalStringProperty {
+    readonly description: string;
+    readonly name: string;
+}
+/**
+ * Extends an object input schema with an optional string property that the
+ * schema itself never sees: validation splits the property off, validates the
+ * rest with `schema`, and returns the property alongside the result. A plain
+ * JSON Schema stays advertised as written.
+ */
+export declare function withOptionalStringProperty(schema: ToolSchema, property: OptionalStringProperty): ToolSchema;
 /**
  * Permissive schema lowered onto model-visible tools whose definitions
  * declare no input schema. Accepts any input — an absent schema declares no
@@ -84,4 +99,3 @@ export declare const UNSPECIFIED_INPUT_SCHEMA: ToolSchema;
  */
 export declare function toModelSchema(schema: FlexibleSchema, direction: SchemaDirection): FlexibleSchema;
 export declare function toModelSchema(schema: FlexibleSchema | undefined, direction: SchemaDirection): FlexibleSchema | undefined;
-export {};