eve 0.65.0 → 0.66.0

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

package/dist/src/tools/schema.js

@@ -1 +1 @@
-import{asSchema}from"ai";import{z}from"#compiled/zod/index.js";import{toErrorMessage}from"#shared/errors.js";import{parseJsonObject}from"#shared/json.js";const rehydratedSchemas={input:new WeakMap,output:new WeakMap};function toInputSchema(e){return toSchema(e,`input`)}function toOutputSchema(e){return toSchema(e,`output`)}function serializeInputSchema(e){return serializeSchema(e,`input`)}function serializeOutputSchema(e){return serializeSchema(e,`output`)}function isToolSchema(e){let t=getStandardSchemaProperties(e);if(t===void 0)return!1;let n=t.jsonSchema;return typeof t.validate==`function`&&typeof n==`object`&&!!n&&typeof n.input==`function`&&typeof n.output==`function`}const UNSPECIFIED_INPUT_SCHEMA=z.fromJSONSchema({});function toSchema(e,t){if(e==null||isToolSchema(e))return e;let n=rehydratedSchemas[t],r=n.get(e);return r===void 0&&(r=rehydrateJsonSchema(toJsonObject(e,t)),n.set(e,r)),r}function rehydrateJsonSchema(e){try{return z.fromJSONSchema(e,{defaultTarget:`draft-7`})}catch{}try{return z.fromJSONSchema(e,{defaultTarget:`draft-2020-12`})}catch(t){return console.warn(`[eve] Tool schema uses JSON Schema features outside local validation support; passing input through unvalidated: ${toErrorMessage(t)}`),toPassthroughSchema(e)}}function toPassthroughSchema(e){let emit=()=>structuredClone(e);return{"~standard":{version:1,vendor:`eve`,validate:e=>({value:e}),jsonSchema:{input:emit,output:emit}}}}function serializeSchema(e,t){return e==null?e:toJsonObject(e,t)}function toJsonObject(e,t){let n=getStandardSchemaProperties(e),r=n?.jsonSchema,i=typeof r==`object`&&r?r[t]:void 0,a=typeof n?.vendor==`string`?n.vendor:`unknown`;if(n!==void 0&&typeof i!=`function`&&a===`zod`){if(t===`input`){let t=asSchema(e),{$schema:n,...r}=parseJsonObject(t.jsonSchema);return r}throw Error(`Zod 3 cannot emit an output JSON Schema. Upgrade to Zod 4 or provide a plain JSON Schema object.`)}if(n!==void 0&&typeof i!=`function`)throw Error(`Standard Schema vendor "${a}" does not support JSON Schema conversion. Provide a Standard Schema implementation with JSON Schema conversion or a plain JSON Schema object.`);let{$schema:o,...s}=parseJsonObject(n===void 0?e:i({target:`draft-07`}));return s}function getStandardSchemaProperties(e){if(typeof e!=`object`||!e||!(`~standard`in e))return;let t=e[`~standard`];return typeof t==`object`&&t?t:void 0}export{UNSPECIFIED_INPUT_SCHEMA,isToolSchema,serializeInputSchema,serializeOutputSchema,toInputSchema,toOutputSchema};
+import{TypeValidationError,asSchema,jsonSchema}from"ai";import{isObject}from"#shared/guards.js";import{toErrorMessage}from"#shared/errors.js";import{parseJsonObject}from"#shared/json.js";import{Validator}from"#compiled/@cfworker/json-schema/index.js";function toInputSchema(e){return toSchema(e,`input`)}function toOutputSchema(e){return toSchema(e,`output`)}function serializeInputSchema(e){return serializeSchema(e,`input`)}function serializeOutputSchema(e){return serializeSchema(e,`output`)}function isToolSchema(e){let t=getStandardSchemaProperties(e);if(t===void 0)return!1;let n=t.jsonSchema;return typeof t.validate==`function`&&typeof n==`object`&&!!n&&typeof n.input==`function`&&typeof n.output==`function`}function defineJsonSchema(e,t){let emit=()=>structuredClone(e),n={"~standard":{version:1,vendor:`eve`,validate:createJsonSchemaValidator(e,t),jsonSchema:{input:emit,output:emit}}};return plainJsonSchemas.add(n),n}const plainJsonSchemas=new WeakSet,UNSPECIFIED_INPUT_SCHEMA=defineJsonSchema({});function toModelSchema(e,t){if(e===void 0||typeof e==`function`||!(`~standard`in e))return e;let n=e,r=plainJsonSchemas.has(n);return jsonSchema(()=>{let e=serializeSchema(n,t);return r?e:closeObjectSchemas(e)},{validate:async e=>{let t=await n[`~standard`].validate(e);return t.issues===void 0?{success:!0,value:t.value}:{success:!1,error:new TypeValidationError({value:e,cause:t.issues})}}})}function closeObjectSchemas(e){if(!isObject(e))return e;let t={...e},{type:n}=t;(n===`object`||Array.isArray(n)&&n.includes(`object`))&&(t.additionalProperties=isObject(t.additionalProperties)?closeObjectSchemas(t.additionalProperties):!1,isObject(t.properties)&&(t.properties=mapValues(t.properties,closeObjectSchemas))),Array.isArray(t.items)?t.items=t.items.map(closeObjectSchemas):isObject(t.items)&&(t.items=closeObjectSchemas(t.items));for(let e of[`allOf`,`anyOf`,`oneOf`]){let n=t[e];Array.isArray(n)&&(t[e]=n.map(closeObjectSchemas))}return isObject(t.definitions)&&(t.definitions=mapValues(t.definitions,closeObjectSchemas)),t}function mapValues(e,t){return Object.fromEntries(Object.entries(e).map(([e,n])=>[e,t(n)]))}function toSchema(e,t){return e==null||isToolSchema(e)?e:defineJsonSchema(toJsonObject(e,t))}function serializeSchema(e,t){return e==null?e:toJsonObject(e,t)}function toJsonObject(e,t){let n=getStandardSchemaProperties(e),r=n?.jsonSchema,i=typeof r==`object`&&r?r[t]:void 0,a=typeof n?.vendor==`string`?n.vendor:`unknown`;if(n!==void 0&&typeof i!=`function`&&a===`zod`){if(t===`input`){let t=asSchema(e),{$schema:n,...r}=parseJsonObject(t.jsonSchema);return r}throw Error(`Zod 3 cannot emit an output JSON Schema. Upgrade to Zod 4 or provide a plain JSON Schema object.`)}if(n!==void 0&&typeof i!=`function`)throw Error(`Standard Schema vendor "${a}" does not support JSON Schema conversion. Provide a Standard Schema implementation with JSON Schema conversion or a plain JSON Schema object.`);let{$schema:o,...s}=parseJsonObject(n===void 0?e:i({target:`draft-07`}));return s}function getStandardSchemaProperties(e){if(typeof e!=`object`||!e||!(`~standard`in e))return;let t=e[`~standard`];return typeof t==`object`&&t?t:void 0}function createJsonSchemaValidator(e,t){let n,r=!1,passThrough=(e,t)=>(r||(r=!0,console.warn(`[eve] Tool schema cannot validate values locally; passing them through unvalidated: ${t}`)),{value:e});return r=>{if(n===void 0){let t=buildValidator(e);if(typeof t==`string`)return n=null,passThrough(r,t);n=t}if(n===null)return{value:r};let i;try{i=n.validate(r)}catch(e){return r===void 0?{issues:[{message:`Expected a JSON value.`}]}:passThrough(r,toErrorMessage(e))}if(!i.valid)return{issues:toIssues(i.errors)};let a=applyDefaults(e,e,r),o=t?.(a);return o===void 0?{value:a}:{issues:[{message:o}]}}}function applyDefaults(e,t,n){let r=n;for(let n of followRefs(e,t)){let{items:t,properties:i}=n;if(isObject(r)&&isObject(i))r=fillProperties(e,i,r);else if(Array.isArray(r)&&isObject(t)){let n=r,i=n.map(n=>applyDefaults(e,t,n));i.some((e,t)=>e!==n[t])&&(r=i)}}return r}function fillProperties(e,t,n){let r=n;for(let[i,a]of Object.entries(t)){let t=Object.hasOwn(n,i)?n[i]:void 0,o=t===void 0?findDefault(e,a):applyDefaults(e,a,t);o!==t&&(r===n&&(r={...n}),r[i]=o)}return r}function findDefault(e,t){for(let n of followRefs(e,t))if(`default`in n)return structuredClone(n.default)}function*followRefs(e,t){let n=new Set,r=t;for(;isObject(r)&&!n.has(r);)n.add(r),yield r,r=resolveLocalRef(e,r.$ref)}function resolveLocalRef(e,t){if(typeof t!=`string`||t!==`#`&&!t.startsWith(`#/`))return;let n=e;for(let e of decodePointer(t)){if(typeof n!=`object`||!n||!Object.hasOwn(n,e))return;n=n[e]}return n}function buildValidator(e){try{let t=structuredClone(e);return prepareForValidation(t)??new Validator(t,`2020-12`,!1)}catch(e){return toErrorMessage(e)}}const JSON_TYPES=new Set([`array`,`boolean`,`integer`,`null`,`number`,`object`,`string`]),EXCLUSIVE_BOUNDS=[[`exclusiveMinimum`,`minimum`],[`exclusiveMaximum`,`maximum`]],SUBSCHEMA_KEYWORDS=[`additionalItems`,`additionalProperties`,`contains`,`else`,`if`,`not`,`propertyNames`,`then`,`unevaluatedItems`,`unevaluatedProperties`],SUBSCHEMA_LIST_KEYWORDS=[`allOf`,`anyOf`,`oneOf`,`prefixItems`],SUBSCHEMA_MAP_KEYWORDS=[`$defs`,`definitions`,`dependencies`,`dependentSchemas`,`patternProperties`,`properties`];function prepareForValidation(e){if(typeof e==`boolean`)return;if(typeof e!=`object`||!e||Array.isArray(e))return`a subschema is neither an object nor a boolean`;let t=e;delete t.format;for(let[e,n]of EXCLUSIVE_BOUNDS)typeof t[e]==`boolean`&&(t[e]&&typeof t[n]==`number`?(t[e]=t[n],delete t[n]):delete t[e]);let{enum:n,pattern:r,required:i,type:a}=t;if(a!==void 0&&!(Array.isArray(a)?a.every(isJsonType):isJsonType(a)))return`unsupported type ${JSON.stringify(a)}`;if(n!==void 0&&!Array.isArray(n))return"`enum` is not an array";if(i!==void 0&&!(Array.isArray(i)&&i.every(e=>typeof e==`string`)))return"`required` is not an array of strings";if(r!==void 0&&!isRegExpSource(r))return`invalid pattern ${JSON.stringify(r)}`;for(let e of SUBSCHEMA_KEYWORDS)if(e in t){let n=prepareForValidation(t[e]);if(n!==void 0)return n}let o=t.items;for(let e of Array.isArray(o)?o:o===void 0?[]:[o]){let t=prepareForValidation(e);if(t!==void 0)return t}for(let e of SUBSCHEMA_LIST_KEYWORDS){let n=t[e];if(n!==void 0){if(!Array.isArray(n))return`\`${e}\` is not an array`;for(let e of n){let t=prepareForValidation(e);if(t!==void 0)return t}}}for(let e of SUBSCHEMA_MAP_KEYWORDS){let n=t[e];if(n!==void 0){if(typeof n!=`object`||!n||Array.isArray(n))return`\`${e}\` is not an object`;for(let[t,r]of Object.entries(n)){if(e===`patternProperties`&&!isRegExpSource(t))return`invalid pattern ${JSON.stringify(t)}`;if(e===`dependencies`&&Array.isArray(r))continue;let n=prepareForValidation(r);if(n!==void 0)return n}}}}function isJsonType(e){return typeof e==`string`&&JSON_TYPES.has(e)}function isRegExpSource(e){if(typeof e!=`string`)return!1;try{return new RegExp(e,`u`),!0}catch{return!1}}const CLOSED_OBJECT_KEYWORD=/\/(?:additional|unevaluated)Properties$/;function toIssues(e){let t=[];for(let n=0;n<e.length;n++){let r=e[n],i=e[n+1];if(CLOSED_OBJECT_KEYWORD.test(r.keywordLocation)&&i?.keyword===`false`){let e=decodePointer(i.instanceLocation).at(-1);t.push({keyword:`false`,location:i.instanceLocation,message:`Unrecognized key: ${JSON.stringify(e)}`,object:r.instanceLocation}),n++}else t.push({keyword:r.keyword,location:r.instanceLocation,message:r.error})}let n=t.filter(e=>e.object===void 0||!t.some(t=>t.object===void 0&&(t.location===e.location||t.location.startsWith(`${e.location}/`))));return n.filter((e,t)=>{let r=n[t+1];return r===void 0?!0:r.location.startsWith(`${e.location}/`)?!1:e.keyword!==`$ref`||r.location!==e.location}).map(({location:e,message:t,object:n})=>{let r=decodePointer(n??e);return r.length===0?{message:t}:{message:t,path:r}})}function decodePointer(e){return e.split(`/`).slice(1).map(e=>{let t=e;try{t=decodeURIComponent(e)}catch{}return t.replaceAll(`~1`,`/`).replaceAll(`~0`,`~`)})}export{UNSPECIFIED_INPUT_SCHEMA,defineJsonSchema,isToolSchema,serializeInputSchema,serializeOutputSchema,toInputSchema,toModelSchema,toOutputSchema};

package/dist/src/vue/index.js

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

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

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

package/docs/README.md

@@ -97,7 +97,7 @@ eve then gives you:
 - a reconnectable session stream
 - durable session state across turns
 - a per-agent sandbox with a shared runtime workspace
-- typed runtime helpers accessed through `ctx` (`ctx.session`, `ctx.getSandbox()`, `ctx.getSkill()`)
+- typed runtime helpers accessed through `ctx` (`ctx.session`, `ctx.getSandbox()`)
 
 ## The runtime shape
 

package/docs/channels/slack.mdx

@@ -135,7 +135,7 @@ Check the delivery path in order so you can identify where a Slack event stops:
 | Mentions work but DMs or thread replies do not                        | Check the Slack app's Event Subscriptions and OAuth scopes. DMs require `message.im` and `im:history`; channel replies require the matching message event and history scope.           | Add the missing events or scopes, then reinstall the Slack app if Slack requires it.                                                                                 |
 | A long response cannot be uploaded as a snippet                       | Check whether the installed Slack app has the `files:write` bot scope.                                                                                                                 | Add `files:write`, then reinstall the Slack app so the new scope takes effect.                                                                                       |
 | A preview request receives an authentication page or protection error | Check whether the branch domain is exempt or the direct Slack request URL includes `x-vercel-protection-bypass`. Slack cannot complete an interactive Vercel Authentication challenge. | Add a Deployment Protection Exception for the branch domain, or add the automation bypass query parameter to a Slack app that uses environment-variable credentials. |
-| The webhook reaches the deployment but the agent does not reply       | Open the project's Vercel runtime logs and locate the request for the inbound Slack event.                                                                                             | Use the first missing or failed stage to narrow the issue to channel dispatch, model or tool execution, or outbound Slack delivery.                                  |
+| The webhook reaches the deployment but the agent does not reply       | Open the project's Vercel runtime logs, then inspect the session in [**Agent Runs**](/docs/observability/agent-runs) when your team has access.                                        | Use the first missing or failed stage to narrow the issue to channel dispatch, the agent run, or outbound Slack delivery.                                            |
 
 ## Audience
 

package/docs/connections/overview.mdx

@@ -10,7 +10,7 @@ Connections live under `agent/connections/`. A static connection's runtime name
 
 ## MCP connections
 
-Use an MCP connection when the external service already exposes an MCP server. The server publishes its tools and schemas, and eve makes the matched tools callable by the model.
+Use an MCP connection when the external service already exposes an MCP server. The server publishes its tools and schemas, and eve makes the matched tools callable by the model. Each tool's JSON Schema reaches the model as published, minus any arguments you supply with `toolCall.providedArguments`, and eve checks the model's arguments against it before it calls the server.
 
 Read [MCP connections](/docs/connections/mcp) for `defineMcpClientConnection`, transport requirements, and MCP tool filters.
 

package/docs/extensions.md

@@ -334,6 +334,10 @@ export default defineHook({
 
 `toolResultFrom` recognizes the mounted `crm__search` result from the original definition, not the namespaced string. Publishers should keep tool descriptions distinct so eve can assign each definition an unambiguous identity.
 
+### Bundled development extensions
+
+Local `eve dev` also mounts bundled development extensions without creating a project mount. The self-modification extension is included by default when `eve dev` starts a local server. Bundled development extensions are not included in production builds. See [Self-Modification](./guides/self-modification) for the local workflow.
+
 ### Compatibility
 
 At build time, eve checks the extension's generated capability metadata. If the extension needs an unsupported capability contract, upgrade eve or install a compatible extension release.

package/docs/getting-started.mdx

@@ -57,7 +57,7 @@ cd my-agent
 npm run dev
 ```
 
-This starts an interactive session where you can send messages to your agent. Edit `agent/instructions.md` to change its behavior and `agent/agent.ts` to configure its model. eve reloads your changes as you work.
+This starts an interactive session where you can send messages to your agent. Edit `agent/instructions.md` to change its behavior and `agent/agent.ts` to configure its model. eve reloads your changes as you work. You can also ask the agent to update its own instructions, tools, or skills; see [Self-Modification](./guides/self-modification).
 
 <span id="project-layout" />
 <span id="agent-directory-layout" />

package/docs/guides/deployment/vercel.mdx

@@ -155,6 +155,12 @@ eve dev https://your_agent.vercel.app/eve/support
 
 Set `VERCEL_AUTOMATION_BYPASS_SECRET` locally before connecting if the deployment uses Deployment Protection.
 
+## Inspect agent runs
+
+Use the **Agent Runs** tab under **Observability** to browse sessions and
+inspect conversation traces. See [Agent Runs](../../observability/agent-runs)
+for beta access, pricing, retention, and tracing setup.
+
 ## Continue configuring production
 
 Use these guides to secure and observe the deployed agent:

package/docs/guides/dev-tui.md

@@ -3,7 +3,7 @@ title: "Terminal UI"
 description: "Use eve locally or connect to a deployed agent from an interactive terminal UI."
 ---
 
-`eve dev` starts a local development server and opens an interactive terminal UI. Use it to talk to your agent, approve tool calls, answer its questions, and configure local development.
+`eve dev` starts a local development server and opens an interactive terminal UI. Use it to talk to your agent, approve tool calls, answer its questions, and configure local development. When `eve dev` starts a local server, self-modification is available by default; see [Self-Modification](./self-modification).
 
 ```bash
 eve dev

package/docs/guides/dynamic-capabilities.md

@@ -422,6 +422,8 @@ The caller's team gets its own playbook advertised as a loadable skill; everyone
 
 Skills follow the same naming rule as tools: a single `defineSkill(...)` is named after the file slug, while a map names each entry by its bare key (namespace the key yourself if it might collide). A dynamic skill overrides a same-named authored one; two dynamic resolvers emitting the same name throws.
 
+A dynamic skill that returns only `markdown` never starts a sandbox: eve keeps its instructions in session state and serves them from `load_skill`. When the skill also returns `files`, eve writes the package to the sandbox skill root when the resolver first returns it, and again only when its contents change or the session gets a new sandbox. A changed package replaces the previous directory, so files omitted from the new result are removed.
+
 ## Dynamic instructions
 
 A dynamic instructions file returns `defineInstructions({ content, role? })` built from the principal, tenant, channel, or external data. Omit `role` for system context:

package/docs/guides/hooks.md

@@ -88,7 +88,8 @@ failed stop, follows the normal
 
 For `subagent.called` and `subagent.completed`, `ctx.session.id` identifies the
 parent session. Typed handlers and `*` handlers receive this context even when
-the subagent event arrives between parent turns.
+the subagent event arrives between parent turns. These hooks can use
+`ctx.getSandbox()` against the parent session.
 
 ### Narrowing tool results
 
@@ -174,13 +175,15 @@ When a stream event fires, three things happen in order:
 
 1. Emit. The channel adapter handler runs, the event is stamped with its `meta` envelope, then it is written to the durable stream.
 2. Hooks. Stream-event hooks fire (typed handlers first, then the `*` wildcard). Return values are ignored.
-3. Dynamic tool resolvers. Resolvers subscribed to the event type run and update the tool set.
+3. Model preparation, for model lifecycle events. Dynamic resolvers subscribed to those events update the model context. Subagent notifications do not run model preparation.
 
 Hooks always run after the event is durably recorded, so if a hook throws, the stream stays consistent. The persisted event and every hook observe the same `meta.id`.
 
 ## What happens when a hook throws
 
-A thrown handler propagates through the emit composer and surfaces as `turn.failed`. In a conversation session, this includes handlers for `turn.started` and the first `step.started` of a model call: the failed turn ends with `session.waiting`, and the next message can start another turn. Task-mode boundary failures remain terminal. If a hook subscribed to a failure-cascade event also throws, it escalates to `session.failed`. For belt-and-suspenders semantics inside a hook, wrap the body in `try`/`catch`. eve treats a thrown hook as a real failure.
+A thrown handler during a model turn propagates through turn execution and surfaces as `turn.failed`. In a conversation session, this includes handlers for `turn.started` and the first `step.started` of a model call: the failed turn ends with `session.waiting`, and the next message can start another turn. Task-mode boundary failures remain terminal. If a hook subscribed to a failure-cascade event also throws, it escalates to `session.failed`. For belt-and-suspenders semantics inside a hook, wrap the body in `try`/`catch`. eve treats a thrown hook as a real failure.
+
+For `subagent.called` and `subagent.completed`, a thrown handler fails the notification step and follows the workflow runtime's step retry policy. A retry can publish the event again before rerunning its hooks. Parent execution waits for the notification step to finish or exhaust its retries.
 
 ## Subagent isolation
 

package/docs/guides/instrumentation/agent-runs.mdx

@@ -0,0 +1,101 @@
+---
+title: "Agent Runs"
+description: "Inspect eve sessions in Vercel and configure the Agent Runs destination."
+url: "/observability/agent-runs"
+---
+
+<Callout type="info" icon={<Flag aria-hidden="true" className="size-5" />}>
+  Agent Runs are available in [**Beta**](https://vercel.com/docs/release-phases#beta) on
+  [**Enterprise**](https://vercel.com/docs/plans/enterprise),
+  [**Pro**](https://vercel.com/docs/plans/pro), and [**Hobby**](https://vercel.com/docs/plans/hobby)
+  plans.
+</Callout>
+
+Use Vercel Agent Runs to browse eve sessions and inspect conversation traces
+in the project's **Observability** view. The tab requires enablement for your
+Vercel team; contact your Vercel representative if it does not appear.
+
+Agent Runs usage is billed at
+[Always-on Tracing rates](https://vercel.com/docs/tracing/always-on-tracing#usage-and-pricing)
+during beta. All plans include 30-day Agent Runs retention during beta.
+
+## Configure Agent Runs
+
+Preview and production deployments export to Vercel Agent Runs by default.
+Omitting `agent/instrumentation/agent-runs.ts` preserves that default. Export
+`agentRuns(...)` from that file to reconfigure it, or export
+`disableInstrumentation()` to disable it.
+
+## Enable tracing on Vercel
+
+New eve deployments automatically sample 100% of requests. Existing eve
+deployments need a sampling rule configured for the Vercel project to collect
+traces. To enable tracing for an existing deployment, select your team and
+project, then open
+[**Settings → Tracing**](https://vercel.com/d?to=%2F%5Bteam%5D%2F%5Bproject%5D%2Fsettings%2Ftracing&title=Go+to+Tracing+settings):
+
+1. Select **Add Sampling Rule**.
+2. Choose **All Environments**, **Production**, or **Preview**.
+3. Set **Rate** to `100%`.
+4. Leave **Request Path Prefix** blank to sample requests on every path.
+5. Select **Save**.
+
+Vercel applies the first matching rule. If an existing rule matches these
+requests, update it to use a 100% rate; a later rule will not override it.
+
+Tracing starts as soon as you save the rule. You can also manage sampling
+rules with [`vercel traces config`](https://vercel.com/docs/cli/traces#manage-trace-sampling-rules).
+The CLI accepts rates from 1 to 100%; add a 0% rule from the dashboard.
+
+## Filter Agent Runs exports
+
+`agentRuns()` accepts one `exportPolicy` object or an array applied in order.
+Each policy filters spans and attributes before the Agent Runs destination
+receives them:
+
+```ts title="agent/instrumentation/agent-runs.ts"
+import { agentRuns } from "eve/instrumentation/otel";
+
+export default agentRuns({
+  exportPolicy: {
+    span: ({ name }) => ({ emit: name !== "internal.cache.refresh" }),
+    attribute: ({ key }) => (key === "customer.id" ? { emit: false } : { emit: true }),
+  },
+});
+```
+
+Return `{ emit: true }` from `span` to retain a span unchanged, or
+`{ emit: false }` to omit it from Agent Runs. To retain the span while redacting
+content, return `{ redact: true }` with `inputs: true`, `outputs: true`, or
+both. A redaction decision implies emission and requires at least one
+direction. A throwing `span` callback drops the span from Agent Runs. Return
+`{ emit: true }`, `{ emit: false }`, or `{ replace: true, value }` from
+`attribute` to retain, remove, or change one attribute.
+
+## Redact content
+
+The `exportPolicy` can further narrow what Agent Runs receives after the
+process-wide `otel({ tracePolicy })` has admitted a trace. For example, keep
+spans while redacting inputs and outputs unless the session is public:
+
+```ts title="agent/instrumentation/agent-runs.ts"
+import { agentRuns } from "eve/instrumentation/otel";
+
+export default agentRuns({
+  exportPolicy: {
+    span: ({ audience }) =>
+      audience === "public" ? { emit: true } : { redact: true, inputs: true, outputs: true },
+  },
+});
+```
+
+Input redaction removes eve's known prompt, instruction, document, and
+tool-argument attributes. Output redaction removes response, reasoning,
+tool-result, exception, and status attributes. Redaction narrows only Agent
+Runs; it does not mutate spans sent to another destination.
+
+## What to read next
+
+- [OpenTelemetry](./otel): configure process-wide settings and third-party destinations.
+- [Vercel deployment](/docs/guides/deployment/vercel): deploy an eve agent and inspect its runtime.
+- [Migrate instrumentation](/docs/observability/instrumentation-migration): replace `agent/instrumentation.ts`.

package/docs/guides/instrumentation/instrumentation.mdx

@@ -159,6 +159,7 @@ not depend on execution order. Use `flush` to drain buffered records and
 ## What to read next
 
 - [Migrate instrumentation](/docs/observability/instrumentation-migration): replace `agent/instrumentation.ts`.
-- [OpenTelemetry](/docs/observability/otel): configure OTel destinations and third-party exports.
+- [OpenTelemetry](/docs/observability/otel): configure process-wide settings and third-party destinations.
+- [Agent Runs](/docs/observability/agent-runs): configure Vercel's built-in trace destination.
 - [Local development](../guides/dev-tui): inspect local traces in the TUI
 - [Hooks](../guides/hooks): react to runtime events outside the instrumentation lifecycle

package/docs/guides/instrumentation/meta.json

@@ -1,5 +1,5 @@
 {
   "title": "Observability",
   "defaultOpen": false,
-  "pages": ["instrumentation", "otel", "migration"]
+  "pages": ["instrumentation", "otel", "agent-runs", "migration"]
 }

package/docs/guides/instrumentation/migration.md

@@ -89,4 +89,8 @@ see
 Run `eve build`. A remaining `agent/instrumentation.ts` fails the build with a
 message directing you to the instrumentation directory.
 
-Run the agent and verify each destination independently.
+New eve deployments automatically sample 100% of requests. Existing Vercel
+deployments need project sampling configured before you verify them. See
+[Enable tracing on Vercel](/docs/observability/agent-runs#enable-tracing-on-vercel).
+
+Then run the agent and verify each destination independently.

package/docs/guides/instrumentation/otel.mdx

@@ -4,8 +4,8 @@ description: "Configure OpenTelemetry destinations, content capture, and third-p
 url: "/observability/otel"
 ---
 
-`eve dev` records local traces automatically. You do not need `otel()` or
-`localTraces()` to use this default.
+`eve dev` records local traces by default. Use `otel()` for process-wide
+settings and `otelIntegration()` for third-party destinations.
 
 ## Configure OpenTelemetry
 
@@ -128,6 +128,11 @@ import { disableInstrumentation } from "eve/instrumentation";
 export default disableInstrumentation();
 ```
 
+## Enable tracing on Vercel
+
+For Agent Runs sampling defaults and existing-deployment setup, see
+[Enable tracing on Vercel](./agent-runs#enable-tracing-on-vercel).
+
 ## Filter a destination
 
 `otelIntegration()` and `localTraces()` accept one
@@ -156,33 +161,9 @@ A throwing `span` callback drops the span from this destination. Return
 `{ replace: true, value }` from `attribute` to retain, remove, or change
 one attribute.
 
-### Redact content from local traces
-
-Return a redaction decision to further narrow what the local trace destination
-receives after the process-wide `otel({ tracePolicy })` has admitted a trace.
-For example, keep spans in the local trace viewer while redacting their inputs
-and outputs unless the session is public:
-
-```ts title="agent/instrumentation/local.ts"
-import { localTraces } from "eve/instrumentation/otel";
-
-export default localTraces({
-  exportPolicy: {
-    span: ({ audience }) =>
-      audience === "public" ? { emit: true } : { redact: true, inputs: true, outputs: true },
-  },
-});
-```
-
-Input redaction removes eve's known prompt, instruction, document, and
-tool-argument attributes. Output redaction removes response, reasoning,
-tool-result, exception, and status attributes. Redaction narrows only this
-destination; it does not mutate spans sent to another destination. Policies run
-in array order, and each policy receives the facade produced by the policies
-before it.
-
 ## What to read next
 
 - [Instrumentation](/docs/observability/instrumentation): handle eve lifecycle events.
+- [Agent Runs](./agent-runs): configure Vercel's built-in trace destination.
 - [Migrate instrumentation](/docs/observability/instrumentation-migration): replace `agent/instrumentation.ts`.
 - [Local development](../guides/dev-tui): inspect local traces in the TUI.

package/docs/guides/self-modification.md

@@ -0,0 +1,37 @@
+---
+title: "Self-Modification"
+description: "Ask your agent to update its own instructions, tools, skills, and other authored files during local development."
+---
+
+When `eve dev` starts a local server, it mounts the bundled self-modification extension by default. Ask your agent to change its instructions, tools, skills, or other files under `agent/`; eve delegates the source work to the `self-modification__agent` subagent. Connecting to an existing server with `eve dev <url>` does not add the bundled extension to that server.
+
+The bundled extension is for local development and is not included in production builds.
+
+```bash
+eve dev
+```
+
+For example, ask the agent to add a reusable action:
+
+```text
+Add a tool that converts temperatures between Celsius and Fahrenheit.
+```
+
+The self-modification subagent changes the authored files in your project. Review the diff and test the new behavior as you would for any other source change. `eve dev` reloads changes while you work.
+
+## Run without self-modification
+
+Pass `--no-default-extensions` when you do not want `eve dev` to mount bundled development extensions:
+
+```bash
+eve dev --no-default-extensions
+```
+
+This disables the complete bundled default set for that server, including self-modification. It does not remove files from your project or disable extensions that you have explicitly mounted under `agent/extensions/`.
+
+## What to read next
+
+- [Terminal UI](./dev-tui): work with your agent locally.
+- [Instructions](../instructions): define the agent's behavior.
+- [Tools](../tools): add model-callable actions.
+- [Skills](../skills): give the agent reusable procedures.