eve 0.64.1 → 0.66.0

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

@@ -1,140 +1,19 @@
-import { z } from "#compiled/zod/index.js";
 export declare const TASK_CANCEL_TOOL_NAME = "task_cancel";
 /** Framework task-control tool names lowered by the runtime. */
 export declare const TASK_TOOL_NAMES: ReadonlySet<string>;
-export declare const TASK_CANCEL_INPUT_SCHEMA: z.ZodObject<{
-    taskIds: z.ZodArray<z.ZodString>;
-}, z.core.$strict>;
-/** Strict model-visible task projection. */
-export declare const TASK_VIEW_JSON_SCHEMA: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    metadata: z.ZodObject<{
-        agentId: z.ZodOptional<z.ZodString>;
-        kind: z.ZodString;
-        mode: z.ZodOptional<z.ZodEnum<{
-            local: "local";
-            remote: "remote";
-        }>>;
-        name: z.ZodString;
-    }, z.core.$strip>;
-    taskId: z.ZodString;
-    status: z.ZodLiteral<"working">;
-}, z.core.$strip>, z.ZodObject<{
-    metadata: z.ZodObject<{
-        agentId: z.ZodOptional<z.ZodString>;
-        kind: z.ZodString;
-        mode: z.ZodOptional<z.ZodEnum<{
-            local: "local";
-            remote: "remote";
-        }>>;
-        name: z.ZodString;
-    }, z.core.$strip>;
-    taskId: z.ZodString;
-    inputRequests: z.ZodReadonly<z.ZodArray<z.ZodType<import("../../shared/json.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("../../shared/json.ts").JsonValue, unknown>>>>;
-    status: z.ZodLiteral<"input_required">;
-}, z.core.$strip>, z.ZodObject<{
-    metadata: z.ZodObject<{
-        agentId: z.ZodOptional<z.ZodString>;
-        kind: z.ZodString;
-        mode: z.ZodOptional<z.ZodEnum<{
-            local: "local";
-            remote: "remote";
-        }>>;
-        name: z.ZodString;
-    }, z.core.$strip>;
-    taskId: z.ZodString;
-    lastOutput: z.ZodObject<{
-        data: z.ZodType<import("../../shared/json.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("../../shared/json.ts").JsonValue, unknown>>;
-        type: z.ZodLiteral<"result">;
-    }, z.core.$strip>;
-    status: z.ZodLiteral<"completed">;
-}, z.core.$strip>, z.ZodObject<{
-    metadata: z.ZodObject<{
-        agentId: z.ZodOptional<z.ZodString>;
-        kind: z.ZodString;
-        mode: z.ZodOptional<z.ZodEnum<{
-            local: "local";
-            remote: "remote";
-        }>>;
-        name: z.ZodString;
-    }, z.core.$strip>;
-    taskId: z.ZodString;
-    lastOutput: z.ZodObject<{
-        data: z.ZodType<import("../../shared/json.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("../../shared/json.ts").JsonValue, unknown>>;
-        type: z.ZodLiteral<"error">;
-    }, z.core.$strip>;
-    status: z.ZodLiteral<"failed">;
-}, z.core.$strip>, z.ZodObject<{
-    metadata: z.ZodObject<{
-        agentId: z.ZodOptional<z.ZodString>;
-        kind: z.ZodString;
-        mode: z.ZodOptional<z.ZodEnum<{
-            local: "local";
-            remote: "remote";
-        }>>;
-        name: z.ZodString;
-    }, z.core.$strip>;
-    taskId: z.ZodString;
-    status: z.ZodLiteral<"cancelled">;
-}, z.core.$strip>], "status">;
-/** Broad schema advertised by task-control tool outputs. */
-export declare const TASK_VIEW_OUTPUT_SCHEMA: z.ZodObject<{
-    inputRequests: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
-    lastOutput: z.ZodOptional<z.ZodObject<{
-        data: z.ZodUnknown;
-        type: z.ZodEnum<{
-            error: "error";
-            result: "result";
-        }>;
-    }, z.core.$strip>>;
-    metadata: z.ZodObject<{
-        agentId: z.ZodOptional<z.ZodString>;
-        kind: z.ZodString;
-        mode: z.ZodOptional<z.ZodEnum<{
-            local: "local";
-            remote: "remote";
-        }>>;
-        name: z.ZodString;
-    }, z.core.$strip>;
-    status: z.ZodEnum<{
-        cancelled: "cancelled";
-        completed: "completed";
-        failed: "failed";
-        input_required: "input_required";
-        working: "working";
-    }>;
-    taskId: z.ZodString;
-}, z.core.$strip>;
-export declare const TASK_VIEWS_OUTPUT_SCHEMA: z.ZodObject<{
-    tasks: z.ZodArray<z.ZodObject<{
-        inputRequests: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
-        lastOutput: z.ZodOptional<z.ZodObject<{
-            data: z.ZodUnknown;
-            type: z.ZodEnum<{
-                error: "error";
-                result: "result";
-            }>;
-        }, z.core.$strip>>;
-        metadata: z.ZodObject<{
-            agentId: z.ZodOptional<z.ZodString>;
-            kind: z.ZodString;
-            mode: z.ZodOptional<z.ZodEnum<{
-                local: "local";
-                remote: "remote";
-            }>>;
-            name: z.ZodString;
-        }, z.core.$strip>;
-        status: z.ZodEnum<{
-            cancelled: "cancelled";
-            completed: "completed";
-            failed: "failed";
-            input_required: "input_required";
-            working: "working";
-        }>;
-        taskId: z.ZodString;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-export declare const SUBAGENT_TASK_RECEIPT_OUTPUT_SCHEMA: z.ZodObject<{
-    agentId: z.ZodString;
-    status: z.ZodLiteral<"working">;
-    taskId: z.ZodString;
-}, z.core.$strict>;
+export declare const TASK_CANCEL_INPUT_SCHEMA: import("#tools/schema.js").ToolSchema<{
+    taskIds: string[];
+}, {
+    taskIds: string[];
+}>;
+/**
+ * Broad schema advertised by task-control tool outputs. Objects stay open so
+ * task metadata can grow without breaking consumers of the output contract.
+ */
+export declare const TASK_VIEWS_OUTPUT_SCHEMA: import("#tools/schema.js").ToolSchema<unknown, unknown>;
+export interface SubagentTaskReceipt {
+    agentId: string;
+    status: "working";
+    taskId: string;
+}
+export declare const SUBAGENT_TASK_RECEIPT_OUTPUT_SCHEMA: import("#tools/schema.js").ToolSchema<SubagentTaskReceipt, SubagentTaskReceipt>;

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

@@ -1 +1 @@
-import{z}from"#compiled/zod/index.js";import{jsonValueSchema}from"#shared/json-schemas.js";const TASK_CANCEL_TOOL_NAME=`task_cancel`,TASK_TOOL_NAMES=new Set([TASK_CANCEL_TOOL_NAME]),TASK_IDS_SCHEMA=z.array(z.string().min(1)).min(1).describe(`Task ids from earlier subagent task receipts.`),TASK_CANCEL_INPUT_SCHEMA=z.strictObject({taskIds:TASK_IDS_SCHEMA}),taskMetadataJsonSchema=z.object({agentId:z.string().optional(),kind:z.string(),mode:z.enum([`local`,`remote`]).optional(),name:z.string()}),taskOutputJsonSchema=z.object({data:jsonValueSchema,type:z.enum([`result`,`error`])}),taskViewJsonBaseShape={metadata:taskMetadataJsonSchema,taskId:z.string()},TASK_VIEW_JSON_SCHEMA=z.discriminatedUnion(`status`,[z.object({...taskViewJsonBaseShape,status:z.literal(`working`)}),z.object({...taskViewJsonBaseShape,inputRequests:z.array(jsonValueSchema).readonly(),status:z.literal(`input_required`)}),z.object({...taskViewJsonBaseShape,lastOutput:taskOutputJsonSchema.extend({type:z.literal(`result`)}),status:z.literal(`completed`)}),z.object({...taskViewJsonBaseShape,lastOutput:taskOutputJsonSchema.extend({type:z.literal(`error`)}),status:z.literal(`failed`)}),z.object({...taskViewJsonBaseShape,status:z.literal(`cancelled`)})]),TASK_VIEW_OUTPUT_SCHEMA=z.object({inputRequests:z.array(z.unknown()).optional(),lastOutput:z.object({data:z.unknown(),type:z.enum([`result`,`error`])}).optional(),metadata:z.object({agentId:z.string().optional(),kind:z.string(),mode:z.enum([`local`,`remote`]).optional(),name:z.string()}),status:z.enum([`working`,`input_required`,`completed`,`failed`,`cancelled`]),taskId:z.string()}),TASK_VIEWS_OUTPUT_SCHEMA=z.object({tasks:z.array(TASK_VIEW_OUTPUT_SCHEMA)}),SUBAGENT_TASK_RECEIPT_OUTPUT_SCHEMA=z.strictObject({agentId:z.string(),status:z.literal(`working`),taskId:z.string()});export{SUBAGENT_TASK_RECEIPT_OUTPUT_SCHEMA,TASK_CANCEL_INPUT_SCHEMA,TASK_CANCEL_TOOL_NAME,TASK_TOOL_NAMES,TASK_VIEWS_OUTPUT_SCHEMA,TASK_VIEW_JSON_SCHEMA,TASK_VIEW_OUTPUT_SCHEMA};
+import{defineJsonSchema}from"#tools/schema.js";const TASK_CANCEL_TOOL_NAME=`task_cancel`,TASK_TOOL_NAMES=new Set([TASK_CANCEL_TOOL_NAME]),TASK_CANCEL_INPUT_SCHEMA=defineJsonSchema({type:`object`,properties:{taskIds:{type:`array`,minItems:1,items:{type:`string`,minLength:1},description:`Task ids from earlier subagent task receipts.`}},required:[`taskIds`],additionalProperties:!1}),TASK_VIEWS_OUTPUT_SCHEMA=defineJsonSchema({type:`object`,properties:{tasks:{type:`array`,items:{type:`object`,properties:{inputRequests:{type:`array`,items:{}},lastOutput:{type:`object`,properties:{data:{},type:{type:`string`,enum:[`result`,`error`]}},required:[`data`,`type`]},metadata:{type:`object`,properties:{agentId:{type:`string`},kind:{type:`string`},mode:{type:`string`,enum:[`local`,`remote`]},name:{type:`string`}},required:[`kind`,`name`]},status:{type:`string`,enum:[`working`,`input_required`,`completed`,`failed`,`cancelled`]},taskId:{type:`string`}},required:[`metadata`,`status`,`taskId`]}}},required:[`tasks`]}),SUBAGENT_TASK_RECEIPT_OUTPUT_SCHEMA=defineJsonSchema({type:`object`,properties:{agentId:{type:`string`},status:{type:`string`,const:`working`},taskId:{type:`string`}},required:[`agentId`,`status`,`taskId`],additionalProperties:!1});export{SUBAGENT_TASK_RECEIPT_OUTPUT_SCHEMA,TASK_CANCEL_INPUT_SCHEMA,TASK_CANCEL_TOOL_NAME,TASK_TOOL_NAMES,TASK_VIEWS_OUTPUT_SCHEMA};

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

@@ -0,0 +1,18 @@
+import { type WorkflowToolDefinition } from "#tools/workflow-definition.js";
+import { type AskQuestionInput, type AskQuestionOutput } from "#execution/tools/ask-question.js";
+export type { AskQuestionInput, AskQuestionOutput };
+/**
+ * Defines the opt-in `ask_question` tool.
+ *
+ * Export it from `agent/tools/ask_question.ts`:
+ *
+ * ```ts
+ * import { askQuestion } from "eve/tools/ask_question";
+ *
+ * export default askQuestion();
+ * ```
+ *
+ * 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.
+ */
+export declare function askQuestion(): WorkflowToolDefinition<AskQuestionInput, AskQuestionOutput>;

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

@@ -0,0 +1 @@
+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};

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

@@ -1,22 +1,21 @@
-import { z } from "#compiled/zod/index.js";
 import { type ToolDefinition } from "#tools/definition.js";
+export interface BashToolInput {
+    command: string;
+}
+export interface BashToolOutput {
+    exitCode: number;
+    stderr: string;
+    stdout: string;
+    truncated: boolean;
+}
 /**
  * Input schema for the provided `bash` tool.
  */
-export declare const BASH_INPUT_SCHEMA: z.ZodObject<{
-    command: z.ZodString;
-}, z.core.$strict>;
+export declare const BASH_INPUT_SCHEMA: import("#tools/schema.js").ToolSchema<BashToolInput, BashToolInput>;
 /**
  * Output schema for the provided `bash` tool.
  */
-export declare const BASH_OUTPUT_SCHEMA: z.ZodObject<{
-    exitCode: z.ZodNumber;
-    stderr: z.ZodString;
-    stdout: z.ZodString;
-    truncated: z.ZodBoolean;
-}, z.core.$strict>;
-export type BashToolInput = z.infer<typeof BASH_INPUT_SCHEMA>;
-export type BashToolOutput = z.infer<typeof BASH_OUTPUT_SCHEMA>;
+export declare const BASH_OUTPUT_SCHEMA: import("#tools/schema.js").ToolSchema<BashToolOutput, BashToolOutput>;
 /**
  * Framework-owned executors stay statically imported so hosted server bundles
  * can trace and rewrite them into deployable output chunks.

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

@@ -1 +1 @@
-import{z}from"#compiled/zod/index.js";import{defineTool}from"#tools/definition.js";import{toolLabel}from"#tools/tool-label.js";import{executeBashOnSandbox}from"#execution/sandbox/bash.js";const BASH_INPUT_SCHEMA=z.strictObject({command:z.string().describe(`The shell command to execute.`)}),BASH_OUTPUT_SCHEMA=z.strictObject({exitCode:z.number(),stderr:z.string(),stdout:z.string(),truncated:z.boolean()}),bash=defineTool({label:{start:e=>toolLabel(`Run`,e.command)},description:`Execute a shell command in the shared workspace environment.`,async execute(e,t){return await executeBashOnSandbox(await t.getSandbox(),e)},inputSchema:BASH_INPUT_SCHEMA,outputSchema:BASH_OUTPUT_SCHEMA});export{BASH_INPUT_SCHEMA,BASH_OUTPUT_SCHEMA,bash,bash as default};
+import{defineJsonSchema}from"#tools/schema.js";import{defineTool}from"#tools/definition.js";import{toolLabel}from"#tools/tool-label.js";import{executeBashOnSandbox}from"#execution/sandbox/bash.js";const BASH_INPUT_SCHEMA=defineJsonSchema({type:`object`,properties:{command:{type:`string`,description:`The shell command to execute.`}},required:[`command`],additionalProperties:!1}),BASH_OUTPUT_SCHEMA=defineJsonSchema({type:`object`,properties:{exitCode:{type:`number`},stderr:{type:`string`},stdout:{type:`string`},truncated:{type:`boolean`}},required:[`exitCode`,`stderr`,`stdout`,`truncated`],additionalProperties:!1}),bash=defineTool({label:{start:e=>toolLabel(`Run`,e.command)},description:`Execute a shell command in the shared workspace environment.`,async execute(e,t){return await executeBashOnSandbox(await t.getSandbox(),e)},inputSchema:BASH_INPUT_SCHEMA,outputSchema:BASH_OUTPUT_SCHEMA});export{BASH_INPUT_SCHEMA,BASH_OUTPUT_SCHEMA,bash,bash as default};

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

@@ -1,24 +1,23 @@
-import { z } from "#compiled/zod/index.js";
 import { type ToolDefinition } from "#tools/definition.js";
+export interface GlobToolInput {
+    limit?: number;
+    path?: string;
+    pattern: string;
+}
+export interface GlobToolOutput {
+    content: string;
+    count: number;
+    path: string;
+    truncated: boolean;
+}
 /**
  * Input schema for the provided `glob` tool.
  */
-export declare const GLOB_INPUT_SCHEMA: z.ZodObject<{
-    limit: z.ZodOptional<z.ZodNumber>;
-    path: z.ZodOptional<z.ZodString>;
-    pattern: z.ZodString;
-}, z.core.$strict>;
+export declare const GLOB_INPUT_SCHEMA: import("#tools/schema.js").ToolSchema<GlobToolInput, GlobToolInput>;
 /**
  * Output schema for the provided `glob` tool.
  */
-export declare const GLOB_OUTPUT_SCHEMA: z.ZodObject<{
-    content: z.ZodString;
-    count: z.ZodNumber;
-    path: z.ZodString;
-    truncated: z.ZodBoolean;
-}, z.core.$strict>;
-export type GlobToolInput = z.infer<typeof GLOB_INPUT_SCHEMA>;
-export type GlobToolOutput = z.infer<typeof GLOB_OUTPUT_SCHEMA>;
+export declare const GLOB_OUTPUT_SCHEMA: import("#tools/schema.js").ToolSchema<GlobToolOutput, GlobToolOutput>;
 /**
  * Framework-owned executor that delegates to the default sandbox.
  */

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

@@ -1,2 +1,2 @@
-import{z}from"#compiled/zod/index.js";import{defineTool}from"#tools/definition.js";import{toolLabel}from"#tools/tool-label.js";import{executeGlobOnSandbox}from"#execution/sandbox/glob-tool.js";const GLOB_INPUT_SCHEMA=z.strictObject({limit:z.number().int().min(1).max(1e3).describe(`Maximum number of results to return. Defaults to 100.`).optional(),path:z.string().describe(`The directory to search in. Defaults to /workspace. Must be an absolute path or begin with $HOME/. Omit to use the default.`).optional(),pattern:z.string().describe(`The glob pattern to match files against (e.g. "**/*.ts", "src/**/*.js").`)}),GLOB_OUTPUT_SCHEMA=z.strictObject({content:z.string(),count:z.number().int(),path:z.string(),truncated:z.boolean()}),glob=defineTool({label:{start:e=>toolLabel(`Find`,e.pattern)},description:[`Fast file pattern matching tool that works with any codebase size.`,``,`Usage:`,`- Supports glob patterns like "**/*.js" or "src/**/*.ts".`,`- Returns matching file paths.`,`- Call this tool in parallel when you know there are multiple patterns to search for.`].join(`
+import{defineJsonSchema}from"#tools/schema.js";import{defineTool}from"#tools/definition.js";import{toolLabel}from"#tools/tool-label.js";import{executeGlobOnSandbox}from"#execution/sandbox/glob-tool.js";const GLOB_INPUT_SCHEMA=defineJsonSchema({type:`object`,properties:{limit:{type:`integer`,minimum:1,maximum:1e3,description:`Maximum number of results to return. Defaults to 100.`},path:{type:`string`,description:`The directory to search in. Defaults to /workspace. Must be an absolute path or begin with $HOME/. Omit to use the default.`},pattern:{type:`string`,description:`The glob pattern to match files against (e.g. "**/*.ts", "src/**/*.js").`}},required:[`pattern`],additionalProperties:!1}),GLOB_OUTPUT_SCHEMA=defineJsonSchema({type:`object`,properties:{content:{type:`string`},count:{type:`integer`},path:{type:`string`},truncated:{type:`boolean`}},required:[`content`,`count`,`path`,`truncated`],additionalProperties:!1}),glob=defineTool({label:{start:e=>toolLabel(`Find`,e.pattern)},description:[`Fast file pattern matching tool that works with any codebase size.`,``,`Usage:`,`- Supports glob patterns like "**/*.js" or "src/**/*.ts".`,`- Returns matching file paths.`,`- Call this tool in parallel when you know there are multiple patterns to search for.`].join(`
 `),async execute(e,t){return await executeGlobOnSandbox(await t.getSandbox(),e)},inputSchema:GLOB_INPUT_SCHEMA,outputSchema:GLOB_OUTPUT_SCHEMA});export{GLOB_INPUT_SCHEMA,GLOB_OUTPUT_SCHEMA,glob as default,glob};

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

@@ -1,28 +1,27 @@
-import { z } from "#compiled/zod/index.js";
 import { type ToolDefinition } from "#tools/definition.js";
+export interface GrepToolInput {
+    context?: number;
+    glob?: string;
+    ignoreCase?: boolean;
+    limit?: number;
+    literal?: boolean;
+    path?: string;
+    pattern: string;
+}
+export interface GrepToolOutput {
+    content: string;
+    matchCount: number;
+    path: string;
+    truncated: boolean;
+}
 /**
  * Input schema for the provided `grep` tool.
  */
-export declare const GREP_INPUT_SCHEMA: z.ZodObject<{
-    context: z.ZodOptional<z.ZodNumber>;
-    glob: z.ZodOptional<z.ZodString>;
-    ignoreCase: z.ZodOptional<z.ZodBoolean>;
-    limit: z.ZodOptional<z.ZodNumber>;
-    literal: z.ZodOptional<z.ZodBoolean>;
-    path: z.ZodOptional<z.ZodString>;
-    pattern: z.ZodString;
-}, z.core.$strict>;
+export declare const GREP_INPUT_SCHEMA: import("#tools/schema.js").ToolSchema<GrepToolInput, GrepToolInput>;
 /**
  * Output schema for the provided `grep` tool.
  */
-export declare const GREP_OUTPUT_SCHEMA: z.ZodObject<{
-    content: z.ZodString;
-    matchCount: z.ZodNumber;
-    path: z.ZodString;
-    truncated: z.ZodBoolean;
-}, z.core.$strict>;
-export type GrepToolInput = z.infer<typeof GREP_INPUT_SCHEMA>;
-export type GrepToolOutput = z.infer<typeof GREP_OUTPUT_SCHEMA>;
+export declare const GREP_OUTPUT_SCHEMA: import("#tools/schema.js").ToolSchema<GrepToolOutput, GrepToolOutput>;
 /**
  * Framework-owned executor that delegates to the default sandbox.
  */

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

@@ -1,2 +1,2 @@
-import{z}from"#compiled/zod/index.js";import{defineTool}from"#tools/definition.js";import{toolLabel}from"#tools/tool-label.js";import{executeGrepOnSandbox}from"#execution/sandbox/grep-tool.js";const GREP_INPUT_SCHEMA=z.strictObject({context:z.number().int().min(0).describe(`Number of surrounding context lines to include before and after each match. Defaults to 0.`).optional(),glob:z.string().describe(`Filter files by glob pattern (e.g. "*.ts", "*.{ts,tsx}").`).optional(),ignoreCase:z.boolean().describe(`Perform case-insensitive search. Defaults to false.`).optional(),limit:z.number().int().min(1).max(1e3).describe(`Maximum number of matches to return per file. Defaults to 100.`).optional(),literal:z.boolean().describe(`Treat the pattern as a literal string instead of a regular expression. Defaults to false.`).optional(),path:z.string().describe(`The directory or file to search in. Defaults to /workspace. Must be an absolute path or begin with $HOME/. Omit to use the default.`).optional(),pattern:z.string().describe(`The regex pattern to search for in file contents (e.g. "log.*Error", "function\\s+\\w+").`)}),GREP_OUTPUT_SCHEMA=z.strictObject({content:z.string(),matchCount:z.number().int(),path:z.string(),truncated:z.boolean()}),grep=defineTool({label:{start:e=>toolLabel(`Search`,e.pattern)},description:[`Fast content search tool that works with any codebase size.`,``,`Usage:`,`- Searches file contents using regular expressions.`,`- Supports full regex syntax (e.g. "log.*Error", "function\\s+\\w+").`,`- Filter files by pattern with the glob parameter (e.g. "*.js", "*.{ts,tsx}").`,`- Returns matching lines with file paths and line numbers.`,`- Call this tool in parallel when you have multiple independent searches.`,`- Any line longer than 2000 characters is truncated.`].join(`
+import{defineJsonSchema}from"#tools/schema.js";import{defineTool}from"#tools/definition.js";import{toolLabel}from"#tools/tool-label.js";import{executeGrepOnSandbox}from"#execution/sandbox/grep-tool.js";const GREP_INPUT_SCHEMA=defineJsonSchema({type:`object`,properties:{context:{type:`integer`,minimum:0,description:`Number of surrounding context lines to include before and after each match. Defaults to 0.`},glob:{type:`string`,description:`Filter files by glob pattern (e.g. "*.ts", "*.{ts,tsx}").`},ignoreCase:{type:`boolean`,description:`Perform case-insensitive search. Defaults to false.`},limit:{type:`integer`,minimum:1,maximum:1e3,description:`Maximum number of matches to return per file. Defaults to 100.`},literal:{type:`boolean`,description:`Treat the pattern as a literal string instead of a regular expression. Defaults to false.`},path:{type:`string`,description:`The directory or file to search in. Defaults to /workspace. Must be an absolute path or begin with $HOME/. Omit to use the default.`},pattern:{type:`string`,description:`The regex pattern to search for in file contents (e.g. "log.*Error", "function\\s+\\w+").`}},required:[`pattern`],additionalProperties:!1}),GREP_OUTPUT_SCHEMA=defineJsonSchema({type:`object`,properties:{content:{type:`string`},matchCount:{type:`integer`},path:{type:`string`},truncated:{type:`boolean`}},required:[`content`,`matchCount`,`path`,`truncated`],additionalProperties:!1}),grep=defineTool({label:{start:e=>toolLabel(`Search`,e.pattern)},description:[`Fast content search tool that works with any codebase size.`,``,`Usage:`,`- Searches file contents using regular expressions.`,`- Supports full regex syntax (e.g. "log.*Error", "function\\s+\\w+").`,`- Filter files by pattern with the glob parameter (e.g. "*.js", "*.{ts,tsx}").`,`- Returns matching lines with file paths and line numbers.`,`- Call this tool in parallel when you have multiple independent searches.`,`- Any line longer than 2000 characters is truncated.`].join(`
 `),async execute(e,t){return await executeGrepOnSandbox(await t.getSandbox(),e)},inputSchema:GREP_INPUT_SCHEMA,outputSchema:GREP_OUTPUT_SCHEMA});export{GREP_INPUT_SCHEMA,GREP_OUTPUT_SCHEMA,grep as default,grep};

package/dist/src/tools/provided/read-file.d.ts

@@ -1,25 +1,24 @@
-import { z } from "#compiled/zod/index.js";
 import { type ToolDefinition } from "#tools/definition.js";
+export interface ReadFileToolInput {
+    filePath: string;
+    limit?: number;
+    offset?: number;
+}
+export interface ReadFileToolOutput {
+    content: string;
+    nextOffset?: number;
+    path: string;
+    totalLines: number;
+    truncated: boolean;
+}
 /**
  * Input schema for the provided `read_file` tool.
  */
-export declare const READ_FILE_INPUT_SCHEMA: z.ZodObject<{
-    filePath: z.ZodString;
-    limit: z.ZodOptional<z.ZodNumber>;
-    offset: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strict>;
+export declare const READ_FILE_INPUT_SCHEMA: import("#tools/schema.js").ToolSchema<ReadFileToolInput, ReadFileToolInput>;
 /**
  * Output schema for the provided `read_file` tool.
  */
-export declare const READ_FILE_OUTPUT_SCHEMA: z.ZodObject<{
-    content: z.ZodString;
-    nextOffset: z.ZodOptional<z.ZodNumber>;
-    path: z.ZodString;
-    totalLines: z.ZodNumber;
-    truncated: z.ZodBoolean;
-}, z.core.$strict>;
-export type ReadFileToolInput = z.infer<typeof READ_FILE_INPUT_SCHEMA>;
-export type ReadFileToolOutput = z.infer<typeof READ_FILE_OUTPUT_SCHEMA>;
+export declare const READ_FILE_OUTPUT_SCHEMA: import("#tools/schema.js").ToolSchema<ReadFileToolOutput, ReadFileToolOutput>;
 /**
  * Framework-owned executor that delegates to the default sandbox.
  */

package/dist/src/tools/provided/read-file.js

@@ -1,2 +1,2 @@
-import{z}from"#compiled/zod/index.js";import{defineTool}from"#tools/definition.js";import{toolLabel}from"#tools/tool-label.js";import{executeReadFileOnSandbox}from"#execution/sandbox/read-file.js";const READ_FILE_INPUT_SCHEMA=z.strictObject({filePath:z.string().describe(`The absolute path to the file to read. A leading $HOME is supported.`),limit:z.number().int().min(1).describe(`Maximum number of lines to return. Defaults to 2000.`).optional(),offset:z.number().int().min(1).describe(`1-based line number to start from. Defaults to 1.`).optional()}),READ_FILE_OUTPUT_SCHEMA=z.strictObject({content:z.string(),nextOffset:z.number().int().min(1).optional(),path:z.string(),totalLines:z.number().int().min(0),truncated:z.boolean()}),readFile=defineTool({label:{start:e=>toolLabel(`Read`,e.filePath)},description:[`Read a file from the local filesystem. If the path does not exist, an error is returned.`,``,`Usage:`,`- The filePath parameter should be an absolute path or begin with $HOME/.`,`- By default, this tool returns up to 2000 lines from the start of the file.`,`- The offset parameter is the line number to start from (1-indexed).`,`- To read later sections, call this tool again with a larger offset.`,'- Contents are returned with each line prefixed by its line number as `<line>: <content>`. For example, if a file has contents "foo\\n", you will receive "1: foo\\n".',`- Any line longer than 2000 characters is truncated.`,`- Call this tool in parallel when you know there are multiple files you want to read.`,`- Avoid tiny repeated slices (30 line chunks). If you need more context, read a larger window.`].join(`
+import{defineJsonSchema}from"#tools/schema.js";import{defineTool}from"#tools/definition.js";import{toolLabel}from"#tools/tool-label.js";import{executeReadFileOnSandbox}from"#execution/sandbox/read-file.js";const READ_FILE_INPUT_SCHEMA=defineJsonSchema({type:`object`,properties:{filePath:{type:`string`,description:`The absolute path to the file to read. A leading $HOME is supported.`},limit:{type:`integer`,minimum:1,description:`Maximum number of lines to return. Defaults to 2000.`},offset:{type:`integer`,minimum:1,description:`1-based line number to start from. Defaults to 1.`}},required:[`filePath`],additionalProperties:!1}),READ_FILE_OUTPUT_SCHEMA=defineJsonSchema({type:`object`,properties:{content:{type:`string`},nextOffset:{type:`integer`,minimum:1},path:{type:`string`},totalLines:{type:`integer`,minimum:0},truncated:{type:`boolean`}},required:[`content`,`path`,`totalLines`,`truncated`],additionalProperties:!1}),readFile=defineTool({label:{start:e=>toolLabel(`Read`,e.filePath)},description:[`Read a file from the local filesystem. If the path does not exist, an error is returned.`,``,`Usage:`,`- The filePath parameter should be an absolute path or begin with $HOME/.`,`- By default, this tool returns up to 2000 lines from the start of the file.`,`- The offset parameter is the line number to start from (1-indexed).`,`- To read later sections, call this tool again with a larger offset.`,'- Contents are returned with each line prefixed by its line number as `<line>: <content>`. For example, if a file has contents "foo\\n", you will receive "1: foo\\n".',`- Any line longer than 2000 characters is truncated.`,`- Call this tool in parallel when you know there are multiple files you want to read.`,`- Avoid tiny repeated slices (30 line chunks). If you need more context, read a larger window.`].join(`
 `),async execute(e,t){return await executeReadFileOnSandbox(await t.getSandbox(),e)},inputSchema:READ_FILE_INPUT_SCHEMA,outputSchema:READ_FILE_OUTPUT_SCHEMA});export{READ_FILE_INPUT_SCHEMA,READ_FILE_OUTPUT_SCHEMA,readFile as default,readFile};

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

@@ -1,4 +1,4 @@
-import { type BlockingWorkflowToolDefinition } from "#tools/workflow-definition.js";
+import { type WorkflowToolDefinition } from "#tools/workflow-definition.js";
 import { type SleepToolInput, type SleepToolOutput } from "#execution/tools/sleep.js";
 export type { SleepToolInput, SleepToolOutput };
 /**
@@ -15,4 +15,4 @@ export type { SleepToolInput, SleepToolOutput };
  * Each call runs as a durable workflow, so the wait does not hold an
  * application runtime open.
  */
-export declare function sleep(): BlockingWorkflowToolDefinition<SleepToolInput, SleepToolOutput>;
+export declare function sleep(): WorkflowToolDefinition<SleepToolInput, SleepToolOutput>;

package/dist/src/tools/provided/web-fetch.d.ts

@@ -1,21 +1,16 @@
-import { z } from "#compiled/zod/index.js";
 import { type ToolDefinition } from "#tools/definition.js";
-export declare const WEB_FETCH_INPUT_SCHEMA: z.ZodObject<{
-    format: z.ZodOptional<z.ZodEnum<{
-        html: "html";
-        markdown: "markdown";
-        text: "text";
-    }>>;
-    timeout: z.ZodOptional<z.ZodNumber>;
-    url: z.ZodString;
-}, z.core.$strict>;
-export declare const WEB_FETCH_OUTPUT_SCHEMA: z.ZodObject<{
-    content: z.ZodString;
-    contentType: z.ZodString;
-    truncated: z.ZodBoolean;
-    url: z.ZodString;
-}, z.core.$strict>;
-export type WebFetchToolInput = z.infer<typeof WEB_FETCH_INPUT_SCHEMA>;
-export type WebFetchToolOutput = z.infer<typeof WEB_FETCH_OUTPUT_SCHEMA>;
+export interface WebFetchToolInput {
+    format?: "markdown" | "text" | "html";
+    timeout?: number;
+    url: string;
+}
+export interface WebFetchToolOutput {
+    content: string;
+    contentType: string;
+    truncated: boolean;
+    url: string;
+}
+export declare const WEB_FETCH_INPUT_SCHEMA: import("#tools/schema.js").ToolSchema<WebFetchToolInput, WebFetchToolInput>;
+export declare const WEB_FETCH_OUTPUT_SCHEMA: import("#tools/schema.js").ToolSchema<WebFetchToolOutput, WebFetchToolOutput>;
 export declare const webFetch: ToolDefinition<WebFetchToolInput, WebFetchToolOutput>;
 export default webFetch;

package/dist/src/tools/provided/web-fetch.js

@@ -1,2 +1,2 @@
-import{z}from"#compiled/zod/index.js";import{defineTool}from"#tools/definition.js";import{toolLabel}from"#tools/tool-label.js";import{executeWebFetchTool}from"#execution/web-fetch/execute.js";const WEB_FETCH_INPUT_SCHEMA=z.strictObject({format:z.enum([`markdown`,`text`,`html`]).describe(`The format to return the content in (text, markdown, or html). HTML responses are automatically converted to the requested format. Defaults to "markdown".`).optional(),timeout:z.number().describe(`Optional timeout in seconds. Defaults to 30, max 120.`).optional(),url:z.string().describe(`The fully-formed URL to fetch content from. Must start with https://.`)}),WEB_FETCH_OUTPUT_SCHEMA=z.strictObject({content:z.string(),contentType:z.string(),truncated:z.boolean(),url:z.string()}),webFetch=defineTool({label:{start:e=>toolLabel(`Fetch`,e.url)},description:[`Fetch a webpage and return its content in the requested format. Use this to retrieve and analyze content from URLs.`,``,`Usage notes:`,`- The URL must be a fully-formed valid URL starting with https://`,`- HTML responses are automatically converted to markdown or plain text based on the requested format`,`- Format options: "markdown" (default), "text", or "html"`,`- Default timeout is 30 seconds (max 120 seconds)`,`- Maximum response size is 5 MB; content is further capped at the shared tool-output budget (50 KB / 2000 lines)`,`- This tool is read-only and does not modify any files`].join(`
+import{defineJsonSchema}from"#tools/schema.js";import{defineTool}from"#tools/definition.js";import{toolLabel}from"#tools/tool-label.js";import{executeWebFetchTool}from"#execution/web-fetch/execute.js";const WEB_FETCH_INPUT_SCHEMA=defineJsonSchema({type:`object`,properties:{format:{type:`string`,enum:[`markdown`,`text`,`html`],description:`The format to return the content in (text, markdown, or html). HTML responses are automatically converted to the requested format. Defaults to "markdown".`},timeout:{type:`number`,description:`Optional timeout in seconds. Defaults to 30, max 120.`},url:{type:`string`,description:`The fully-formed URL to fetch content from. Must start with https://.`}},required:[`url`],additionalProperties:!1}),WEB_FETCH_OUTPUT_SCHEMA=defineJsonSchema({type:`object`,properties:{content:{type:`string`},contentType:{type:`string`},truncated:{type:`boolean`},url:{type:`string`}},required:[`content`,`contentType`,`truncated`,`url`],additionalProperties:!1}),webFetch=defineTool({label:{start:e=>toolLabel(`Fetch`,e.url)},description:[`Fetch a webpage and return its content in the requested format. Use this to retrieve and analyze content from URLs.`,``,`Usage notes:`,`- The URL must be a fully-formed valid URL starting with https://`,`- HTML responses are automatically converted to markdown or plain text based on the requested format`,`- Format options: "markdown" (default), "text", or "html"`,`- Default timeout is 30 seconds (max 120 seconds)`,`- Maximum response size is 5 MB; content is further capped at the shared tool-output budget (50 KB / 2000 lines)`,`- This tool is read-only and does not modify any files`].join(`
 `),async execute(e,t){return await executeWebFetchTool(e,{abortSignal:t.abortSignal})},inputSchema:WEB_FETCH_INPUT_SCHEMA,outputSchema:WEB_FETCH_OUTPUT_SCHEMA});export{WEB_FETCH_INPUT_SCHEMA,WEB_FETCH_OUTPUT_SCHEMA,webFetch as default,webFetch};

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

@@ -1 +1 @@
-import{z}from"#compiled/zod/index.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=z.strictObject({js:z.string().describe(`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.`)});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{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};

package/dist/src/tools/provided/write-file.d.ts

@@ -1,21 +1,20 @@
-import { z } from "#compiled/zod/index.js";
 import { type ToolDefinition } from "#tools/definition.js";
+export interface WriteFileToolInput {
+    content: string;
+    filePath: string;
+}
+export interface WriteFileToolOutput {
+    existed: boolean;
+    path: string;
+}
 /**
  * Input schema for the provided `write_file` tool.
  */
-export declare const WRITE_FILE_INPUT_SCHEMA: z.ZodObject<{
-    content: z.ZodString;
-    filePath: z.ZodString;
-}, z.core.$strict>;
+export declare const WRITE_FILE_INPUT_SCHEMA: import("#tools/schema.js").ToolSchema<WriteFileToolInput, WriteFileToolInput>;
 /**
  * Output schema for the provided `write_file` tool.
  */
-export declare const WRITE_FILE_OUTPUT_SCHEMA: z.ZodObject<{
-    existed: z.ZodBoolean;
-    path: z.ZodString;
-}, z.core.$strict>;
-export type WriteFileToolInput = z.infer<typeof WRITE_FILE_INPUT_SCHEMA>;
-export type WriteFileToolOutput = z.infer<typeof WRITE_FILE_OUTPUT_SCHEMA>;
+export declare const WRITE_FILE_OUTPUT_SCHEMA: import("#tools/schema.js").ToolSchema<WriteFileToolOutput, WriteFileToolOutput>;
 /**
  * Framework-owned executor that delegates to the default sandbox.
  */

package/dist/src/tools/provided/write-file.js

@@ -1,2 +1,2 @@
-import{z}from"#compiled/zod/index.js";import{defineTool}from"#tools/definition.js";import{toolLabel}from"#tools/tool-label.js";import{executeWriteFileOnSandbox}from"#execution/sandbox/write-file.js";const WRITE_FILE_INPUT_SCHEMA=z.strictObject({content:z.string().describe(`Complete replacement file contents.`),filePath:z.string().describe(`The absolute path to the file to write. A leading $HOME is supported.`)}),WRITE_FILE_OUTPUT_SCHEMA=z.strictObject({existed:z.boolean(),path:z.string()}),writeFile=defineTool({label:{start:e=>toolLabel(`Write`,e.filePath)},description:[`Writes a file to the local filesystem.`,``,`Usage:`,`- This tool will overwrite the existing file if there is one at the provided path.`,`- If this is an existing file, you MUST use the read_file tool first to read the file's contents. This tool will fail if you did not read the file first.`,`- ALWAYS prefer editing existing files in the codebase. NEVER write new files unless explicitly required.`,`- NEVER proactively create documentation files (*.md) or README files. Only create documentation files if explicitly requested by the User.`,`- Only use emojis if the user explicitly requests it. Avoid writing emojis to files unless asked.`].join(`
+import{defineJsonSchema}from"#tools/schema.js";import{defineTool}from"#tools/definition.js";import{toolLabel}from"#tools/tool-label.js";import{executeWriteFileOnSandbox}from"#execution/sandbox/write-file.js";const WRITE_FILE_INPUT_SCHEMA=defineJsonSchema({type:`object`,properties:{content:{type:`string`,description:`Complete replacement file contents.`},filePath:{type:`string`,description:`The absolute path to the file to write. A leading $HOME is supported.`}},required:[`content`,`filePath`],additionalProperties:!1}),WRITE_FILE_OUTPUT_SCHEMA=defineJsonSchema({type:`object`,properties:{existed:{type:`boolean`},path:{type:`string`}},required:[`existed`,`path`],additionalProperties:!1}),writeFile=defineTool({label:{start:e=>toolLabel(`Write`,e.filePath)},description:[`Writes a file to the local filesystem.`,``,`Usage:`,`- This tool will overwrite the existing file if there is one at the provided path.`,`- If this is an existing file, you MUST use the read_file tool first to read the file's contents. This tool will fail if you did not read the file first.`,`- ALWAYS prefer editing existing files in the codebase. NEVER write new files unless explicitly required.`,`- NEVER proactively create documentation files (*.md) or README files. Only create documentation files if explicitly requested by the User.`,`- Only use emojis if the user explicitly requests it. Avoid writing emojis to files unless asked.`].join(`
 `),async execute(e,t){return await executeWriteFileOnSandbox(await t.getSandbox(),e)},inputSchema:WRITE_FILE_INPUT_SCHEMA,outputSchema:WRITE_FILE_OUTPUT_SCHEMA});export{WRITE_FILE_INPUT_SCHEMA,WRITE_FILE_OUTPUT_SCHEMA,writeFile as default,writeFile};

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

@@ -1,9 +1,11 @@
+import { type FlexibleSchema } from "ai";
 import type { StandardJSONSchemaV1, StandardSchemaV1 } from "#compiled/@standard-schema/spec/index.js";
 import { type JsonObject } from "#shared/json.js";
 /**
  * eve-owned schema contract for tool input and output schemas: a Standard
- * Schema validator that can also emit JSON Schema. Zod implements both
- * constituent protocols without exposing Zod through runtime-owned types.
+ * Schema validator that can also emit JSON Schema. Author schemas (Zod,
+ * Valibot, ArkType) implement it directly; plain JSON Schema data is lowered
+ * onto it by {@link defineJsonSchema}.
  */
 export type ToolSchema<Input = unknown, Output = Input> = StandardSchemaV1<Input, Output> & StandardJSONSchemaV1<Input, Output>;
 /**
@@ -13,22 +15,19 @@ 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; serialized JSON Schemas are rehydrated into vendored Zod
- * validators. Serialized schemas outside Zod's conversion subset degrade to a
- * validation-free schema that still advertises the source JSON Schema. `null`
- * and `undefined` pass through untouched.
+ * through unchanged; plain JSON Schema data becomes a {@link defineJsonSchema}
+ * schema. `null` and `undefined` pass through untouched.
  */
 export declare function toInputSchema<T extends ToolSchemaSource | null | undefined>(source: T): SchemaResult<T, ToolSchema>;
 /**
  * Resolves a source into a live output {@link ToolSchema}. Live schemas pass
- * through unchanged; serialized JSON Schemas are rehydrated into vendored Zod
- * validators. Serialized schemas outside Zod's conversion subset degrade to a
- * validation-free schema that still advertises the source JSON Schema. `null`
- * and `undefined` pass through untouched.
+ * through unchanged; plain JSON Schema data becomes a {@link defineJsonSchema}
+ * schema. `null` and `undefined` pass through untouched.
  */
 export declare function toOutputSchema<T extends ToolSchemaSource | null | undefined>(source: T): SchemaResult<T, ToolSchema>;
 /**
@@ -48,10 +47,41 @@ export declare function serializeOutputSchema<T extends ToolSchemaSource | null
  * Standard Schema validation plus JSON Schema emission.
  */
 export declare function isToolSchema(value: unknown): value is ToolSchema;
+/**
+ * Builds a {@link ToolSchema} from plain JSON Schema data. The schema is
+ * advertised exactly as given, and values are validated against it with a
+ * JSON Schema 2020-12 validator that also accepts draft-07 constructs.
+ *
+ * `format` is treated as an annotation, as JSON Schema 2020-12 specifies by
+ * default. A valid value's omitted properties receive their `default` values.
+ * A schema the validator cannot evaluate faithfully (unknown `type`
+ * names, invalid `pattern` expressions, unresolvable `$ref`s) is still
+ * advertised, but its values pass through unvalidated; the tool's executor,
+ * such as a remote MCP server, remains the authority for its own contract.
+ *
+ * `check` runs after the JSON Schema accepts a value and reports a message
+ * for constraints JSON Schema cannot express.
+ */
+export declare function defineJsonSchema<T = unknown>(schema: JsonObject, check?: (value: T) => string | undefined): ToolSchema<T>;
 /**
  * Permissive schema lowered onto model-visible tools whose definitions
  * declare no input schema. Accepts any input — an absent schema declares no
  * contract, so rejecting stray properties would only force needless retries.
  */
 export declare const UNSPECIFIED_INPUT_SCHEMA: ToolSchema;
+/**
+ * Lowers a harness tool schema onto the AI SDK boundary.
+ *
+ * Every Standard Schema is wrapped in an AI SDK `jsonSchema()` schema whose
+ * JSON Schema and validation both come from the schema's own library. The
+ * AI SDK treats an existing `Schema` as final, so it never reaches for the
+ * app's `zod` copy to convert or parse a schema built by another copy — a
+ * mismatch that crashes JSON Schema conversion across Zod minor versions.
+ * AI SDK-native schemas (already wrapped, or lazy) pass through.
+ *
+ * Library schemas get the object closing the AI SDK applies to them itself;
+ * plain JSON Schema from {@link defineJsonSchema} is advertised as written.
+ */
+export declare function toModelSchema(schema: FlexibleSchema, direction: SchemaDirection): FlexibleSchema;
+export declare function toModelSchema(schema: FlexibleSchema | undefined, direction: SchemaDirection): FlexibleSchema | undefined;
 export {};