eve 0.65.0 → 0.66.0

package/dist/src/shared/sandbox-network-policy.d.ts

@@ -8,7 +8,9 @@ import type * as Vercel from "#compiled/@vercel/sandbox/index.js";
  * firewall so secrets never enter the sandbox process:
  *
  * ```ts
- * const sandbox = await ctx.getSandbox();
+ * import { environment } from "../sandbox";
+ *
+ * const sandbox = await ctx.getSandbox(environment);
  * await sandbox.setNetworkPolicy({
  *   allow: {
  *     "github.com": [{ transform: [{ headers: { authorization: "Basic ..." } }] }],
@@ -18,9 +20,8 @@ import type * as Vercel from "#compiled/@vercel/sandbox/index.js";
  * ```
  *
  * The Docker provider honors only the coarse `"allow-all"` and
- * `"deny-all"` policies; the just-bash provider rejects `setNetworkPolicy`
- * entirely (its network policy is fixed at sandbox creation and it runs
- * no binaries to govern).
+ * `"deny-all"` policies. just-bash environments do not expose
+ * `setNetworkPolicy` because their network policy is fixed at sandbox creation.
  */
 export type SandboxNetworkPolicy = Vercel.NetworkPolicy;
 /** Initial network configuration shared by network-capable sandbox providers. */

package/dist/src/shared/sandbox-session.d.ts

@@ -1,6 +1,5 @@
 import type { Experimental_SandboxSession as AiSdkSandbox } from "ai";
 import type { SandboxDeleteOptions } from "#shared/sandbox-provider.js";
-import type { SandboxNetworkPolicy } from "#shared/sandbox-network-policy.js";
 /**
  * Options for running one command in a sandbox. Shape mirrors the AI
  * SDK {@link AiSdkSandbox} `run` argument so authored code that targets
@@ -86,8 +85,6 @@ export interface SandboxSession extends Pick<AiSdkSandbox, "run" | "spawn" | "re
      * The read and write methods already apply this internally.
      */
     resolvePath(path: string): string;
-    /** Applies a firewall policy when the selected provider supports mutable networking. */
-    setNetworkPolicy?(policy: SandboxNetworkPolicy): Promise<void>;
     /**
      * Removes one file or directory from the sandbox filesystem.
      *
@@ -95,18 +92,6 @@ export interface SandboxSession extends Pick<AiSdkSandbox, "run" | "spawn" | "re
      */
     removePath(options: SandboxRemovePathOptions): Promise<void>;
 }
-/**
- * Sandbox session exposed to authored runtime callbacks through
- * `ctx.getSandbox()`.
- *
- * Unlike the I/O-only session used during sandbox initialization, this handle
- * exposes provider-backed lifecycle operations.
- */
-export interface MutableNetworkSandboxSession extends SandboxSession {
-    /** Applies a firewall policy to the live sandbox. */
-    setNetworkPolicy(policy: SandboxNetworkPolicy): Promise<void>;
-}
-export type FixedNetworkSandboxSession = Omit<SandboxSession, "setNetworkPolicy">;
 export interface RuntimeSandboxSession extends SandboxSession {
     /** Permanently deletes this sandbox and its disposable provider state. */
     delete(options?: SandboxDeleteOptions): Promise<void>;

package/dist/src/shared/skill-package.d.ts

@@ -13,6 +13,9 @@ export interface MaterializableSkillPackage {
     readonly metadata?: Readonly<Record<string, string>>;
     readonly name: string;
 }
+export declare function stripSkillFrontmatter(markdown: string): string;
+/** Content hash over every package file, including `SKILL.md`. */
+export declare function skillPackageRevision(skill: MaterializableSkillPackage): string;
 /**
  * Normalizes one named skill package into the concrete files eve writes to
  * workspace resources or the live sandbox.

package/dist/src/shared/skill-package.js

@@ -1 +1 @@
-import{mkdir,writeFile}from"node:fs/promises";import{dirname,join}from"node:path";import{resolveSandboxSkillRoot,resolveSandboxSkillWritePath}from"#shared/skill-paths.js";import{Buffer}from"node:buffer";function normalizeSkillPackage(e){assertSafeSkillPackageName(e.name);let t=[{content:Buffer.from(e.markdown,`utf8`),relativePath:`SKILL.md`}];for(let[n,r]of Object.entries(e.files??{}))assertSafeSkillPackageFilePath(n),t.push({content:contentToBuffer(r),relativePath:n});return t.sort((e,t)=>comparePaths(e.relativePath,t.relativePath)),{description:e.description,files:t,license:e.license,markdown:e.markdown,metadata:e.metadata===void 0?void 0:{...e.metadata},name:e.name}}async function writeSkillPackageDirectory(e){for(let t of e.skill.files){let n=join(e.rootPath,`skills`,e.skill.name,t.relativePath);await mkdir(dirname(n),{recursive:!0}),await writeFile(n,t.content)}}async function writeSkillPackageToSandbox(e){for(let t of e.skill.files)await e.sandbox.writeBinaryFile({content:t.content,path:await resolveSandboxSkillWritePath({name:e.skill.name,relativePath:t.relativePath,sandbox:e.sandbox})})}async function removeSkillPackageFromSandbox(e){assertSafeSkillPackageName(e.name);let t=await resolveSandboxSkillRoot({sandbox:e.sandbox});await e.sandbox.removePath({force:!0,path:`${t}/${e.name}`,recursive:!0})}function assertSafeSkillPackageName(e){if(e.length===0||e.startsWith(`.`)||e.includes(`/`)||e.includes(`\\`)||e.includes(`..`)||!/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(e)||/^[A-Za-z]:/.test(e))throw Error(`Expected skill name to be a non-empty shell-safe path segment starting with an alphanumeric character and containing only alphanumerics, ".", "_", or "-".`)}function assertSafeSkillPackageFilePath(e){if(e===`SKILL.md`)throw Error(`Skill package files must not include "SKILL.md"; eve generates it.`);if(e.length===0||e.startsWith(`/`)||e.includes(`\\`)||/^[A-Za-z]:/.test(e)||e.split(`/`).some(e=>e.length===0||e===`.`||e===`..`))throw Error(`Expected skill package file paths to be relative POSIX paths.`)}function contentToBuffer(e){return typeof e==`string`?Buffer.from(e,`utf8`):Buffer.from(e)}function comparePaths(e,t){return e<t?-1:+(e>t)}export{assertSafeSkillPackageName,normalizeSkillPackage,removeSkillPackageFromSandbox,writeSkillPackageDirectory,writeSkillPackageToSandbox};
+import{createHash}from"node:crypto";import{mkdir,writeFile}from"node:fs/promises";import{dirname,join}from"node:path";import{resolveSandboxSkillRoot,resolveSandboxSkillWritePath}from"#shared/skill-paths.js";import{Buffer}from"node:buffer";function stripSkillFrontmatter(e){return e.replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n?/,``)}function skillPackageRevision(e){let t=createHash(`sha256`);for(let n of e.files)t.update(`${n.relativePath}\0${n.content.byteLength}\0`).update(n.content);return t.digest(`hex`)}function normalizeSkillPackage(e){assertSafeSkillPackageName(e.name);let t=[{content:Buffer.from(e.markdown,`utf8`),relativePath:`SKILL.md`}];for(let[n,r]of Object.entries(e.files??{}))assertSafeSkillPackageFilePath(n),t.push({content:contentToBuffer(r),relativePath:n});return t.sort((e,t)=>comparePaths(e.relativePath,t.relativePath)),{description:e.description,files:t,license:e.license,markdown:e.markdown,metadata:e.metadata===void 0?void 0:{...e.metadata},name:e.name}}async function writeSkillPackageDirectory(e){for(let t of e.skill.files){let n=join(e.rootPath,`skills`,e.skill.name,t.relativePath);await mkdir(dirname(n),{recursive:!0}),await writeFile(n,t.content)}}async function writeSkillPackageToSandbox(e){for(let t of e.skill.files)await e.sandbox.writeBinaryFile({content:t.content,path:await resolveSandboxSkillWritePath({name:e.skill.name,relativePath:t.relativePath,sandbox:e.sandbox})})}async function removeSkillPackageFromSandbox(e){assertSafeSkillPackageName(e.name);let t=await resolveSandboxSkillRoot({sandbox:e.sandbox});await e.sandbox.removePath({force:!0,path:`${t}/${e.name}`,recursive:!0})}function assertSafeSkillPackageName(e){if(e.length===0||e.startsWith(`.`)||e.includes(`/`)||e.includes(`\\`)||e.includes(`..`)||!/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(e)||/^[A-Za-z]:/.test(e))throw Error(`Expected skill name to be a non-empty shell-safe path segment starting with an alphanumeric character and containing only alphanumerics, ".", "_", or "-".`)}function assertSafeSkillPackageFilePath(e){if(e===`SKILL.md`)throw Error(`Skill package files must not include "SKILL.md"; eve generates it.`);if(e.length===0||e.startsWith(`/`)||e.includes(`\\`)||/^[A-Za-z]:/.test(e)||e.split(`/`).some(e=>e.length===0||e===`.`||e===`..`))throw Error(`Expected skill package file paths to be relative POSIX paths.`)}function contentToBuffer(e){return typeof e==`string`?Buffer.from(e,`utf8`):Buffer.from(e)}function comparePaths(e,t){return e<t?-1:+(e>t)}export{assertSafeSkillPackageName,normalizeSkillPackage,removeSkillPackageFromSandbox,skillPackageRevision,stripSkillFrontmatter,writeSkillPackageDirectory,writeSkillPackageToSandbox};

package/dist/src/svelte/index.js

@@ -1,3 +1,3 @@
-import { n as defaultMessageReducer, t as useEveAgent } from "../chunks/use-eve-agent-BRvEh9sO.js";
+import { n as defaultMessageReducer, t as useEveAgent } from "../chunks/use-eve-agent-ydPlURM4.js";
 
 export { defaultMessageReducer, useEveAgent };

package/dist/src/svelte/use-eve-agent.js

@@ -1,3 +1,3 @@
-import { t as useEveAgent } from "../chunks/use-eve-agent-BRvEh9sO.js";
+import { t as useEveAgent } from "../chunks/use-eve-agent-ydPlURM4.js";
 
 export { useEveAgent };

package/dist/src/tasks/json.d.ts

@@ -1,7 +1,77 @@
-import type { z } from "#compiled/zod/index.js";
+import { z } from "#compiled/zod/index.js";
 import type { JsonValue } from "#shared/json.js";
-import { TASK_VIEW_JSON_SCHEMA } from "#tools/framework/task-contract.js";
 import type { TaskView } from "#tasks/types.js";
+/** Strict model-visible task projection. */
+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<JsonValue, unknown, z.core.$ZodTypeInternals<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<JsonValue, unknown, z.core.$ZodTypeInternals<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<JsonValue, unknown, z.core.$ZodTypeInternals<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">;
 /**
  * Model-visible task view, inferred from {@link TASK_VIEW_JSON_SCHEMA}.
  *

package/dist/src/tasks/json.js

@@ -1 +1 @@
-import{TASK_VIEW_JSON_SCHEMA}from"#tools/framework/task-contract.js";function taskViewToJson(e){return TASK_VIEW_JSON_SCHEMA.parse(e)}function taskViewsToJson(e){return{tasks:e.map(e=>taskViewToJson(e))}}export{taskViewToJson,taskViewsToJson};
+import{z}from"#compiled/zod/index.js";import{jsonValueSchema}from"#shared/json-schemas.js";const 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`)})]);function taskViewToJson(e){return TASK_VIEW_JSON_SCHEMA.parse(e)}function taskViewsToJson(e){return{tasks:e.map(e=>taskViewToJson(e))}}export{taskViewToJson,taskViewsToJson};

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

@@ -1,8 +1,9 @@
-import { z } from "#compiled/zod/index.js";
+import type { JsonObject } from "#shared/json.js";
 export declare const AGENT_TOOL_NAME = "agent";
 export declare const AGENT_TOOL_DESCRIPTION: string;
-export declare const SUBAGENT_TOOL_INPUT_SCHEMA: z.ZodObject<{
-    agentId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    message: z.ZodString;
-    outputSchema: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
-}, z.core.$strict>;
+export interface SubagentToolInput {
+    agentId?: string | null;
+    message: string;
+    outputSchema?: JsonObject;
+}
+export declare const SUBAGENT_TOOL_INPUT_SCHEMA: import("#tools/schema.js").ToolSchema<SubagentToolInput, SubagentToolInput>;

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

@@ -1 +1 @@
-import{z}from"#compiled/zod/index.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=z.strictObject({agentId:z.string().nullable().describe(`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.`).optional(),message:z.string().describe(`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.`),outputSchema:z.looseObject({}).describe(`Only provide a non-empty JSON Schema when the caller explicitly requests structured output; otherwise omit this field. The subagent must match a provided schema, and that structured output becomes the tool result.`).optional()});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, 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.`},outputSchema:{type:`object`,description:`Only provide a non-empty JSON Schema when the caller explicitly requests structured output; otherwise omit this field. The subagent must match a provided schema, and that structured output becomes the tool result.`}},required:[`message`],additionalProperties:!1});export{AGENT_TOOL_DESCRIPTION,AGENT_TOOL_NAME,SUBAGENT_TOOL_INPUT_SCHEMA};

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

@@ -1,18 +1,9 @@
-import type { z } from "#compiled/zod/index.js";
-import { SUBAGENT_TASK_RECEIPT_OUTPUT_SCHEMA } from "#tools/framework/task-contract.js";
+import { type SubagentTaskReceipt } from "#tools/framework/task-contract.js";
 export declare const agent: {
     description: string;
     execution: string;
-    inputSchema: z.ZodObject<{
-        agentId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        message: z.ZodString;
-        outputSchema: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
-    }, z.core.$strict>;
-    outputSchema: z.ZodObject<{
-        agentId: z.ZodString;
-        status: z.ZodLiteral<"working">;
-        taskId: z.ZodString;
-    }, z.core.$strict>;
-    execute(): z.infer<typeof SUBAGENT_TASK_RECEIPT_OUTPUT_SCHEMA>;
+    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;
 };
 export default agent;

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

@@ -1,20 +1,4 @@
 export declare const taskCancel: import("#tools/native-definition.js").NativeToolDefinition<{
     taskIds: string[];
-}, {
-    tasks: {
-        inputRequests?: unknown[] | undefined;
-        lastOutput?: {
-            data: unknown;
-            type: "error" | "result";
-        } | undefined;
-        metadata: {
-            agentId?: string | undefined;
-            kind: string;
-            mode?: "local" | "remote" | undefined;
-            name: string;
-        };
-        status: "cancelled" | "completed" | "failed" | "input_required" | "working";
-        taskId: string;
-    }[];
-}>;
+}, unknown>;
 export default taskCancel;

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/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};