eve 0.5.4 → 0.6.0-beta.3

package/dist/src/runtime/framework-tools/file-state.d.ts

@@ -0,0 +1,62 @@
+import { type AlsContext } from "#context/container.js";
+import { ContextKey } from "#context/key.js";
+/**
+ * Per-file fingerprint stored after a successful `read_file` call. Used by
+ * `write_file` to detect stale overwrites and enforce read-before-write.
+ */
+export interface ReadFileStamp {
+    readonly byteLength: number;
+    readonly contentHash: string;
+    readonly filePath: string;
+}
+/**
+ * Durable session state holding read-file stamps keyed by normalized
+ * absolute path.
+ */
+export interface ReadFileState {
+    readonly byTarget: Readonly<Record<string, ReadFileStamp>>;
+}
+/**
+ * Durable context key for read-file stamps.
+ */
+export declare const ReadFileStateKey: ContextKey<ReadFileState>;
+/**
+ * Normalizes an absolute model-facing path by collapsing dot segments and
+ * normalizing separators. The path must already be absolute — call
+ * {@link normalizeModelPath} only after validating that the input starts
+ * with `/`.
+ *
+ * Examples:
+ * - `/workspace/./foo.ts`  → `/workspace/foo.ts`
+ * - `/tmp/project/../project/foo.ts` → `/tmp/project/foo.ts`
+ */
+export declare function normalizeModelPath(path: string): string;
+/**
+ * Builds the durable state key used to index a read-file stamp.
+ *
+ * Callers are expected to pass an already-normalized path from
+ * {@link normalizeModelPath}. This function does not re-normalize.
+ */
+export declare function buildReadFileTargetKey(normalizedPath: string): string;
+/**
+ * Creates a read-file stamp from file content. The stamp records a SHA-256
+ * hash and UTF-8 byte length so `write_file` can detect external
+ * modifications without filesystem metadata.
+ */
+export declare function createReadFileStamp(input: {
+    content: string;
+    filePath: string;
+}): ReadFileStamp;
+/**
+ * Persists one read-file stamp into the durable context state.
+ *
+ * Centralizes the context read-update-write so callers in `read-file-tool`
+ * and `write-file-tool` do not duplicate the state mutation pattern.
+ */
+export declare function setReadFileStamp(ctx: AlsContext, targetKey: string, stamp: ReadFileStamp): void;
+/**
+ * Clears all read-file stamps from the context. Used by the `read_file`
+ * tool's `onCompact` hook and by authored `defineReadFileTool()` replacements
+ * that keep the default compaction behavior.
+ */
+export declare function clearReadFileState(): void;

package/dist/src/runtime/framework-tools/file-state.js

@@ -0,0 +1 @@
+import{posix}from"node:path";import{createHash}from"node:crypto";import{loadContext}from"#context/container.js";import{ContextKey}from"#context/key.js";const ReadFileStateKey=new ContextKey(`eve.readFile`);function normalizeModelPath(t){return posix.normalize(t)}function buildReadFileTargetKey(e){return e}function createReadFileStamp(e){let n=createHash(`sha256`).update(e.content,`utf8`).digest(`hex`);return{byteLength:Buffer.byteLength(e.content,`utf8`),contentHash:n,filePath:e.filePath}}function setReadFileStamp(e,t,n){let r=e.ensure(ReadFileStateKey,()=>({byTarget:{}}));e.set(ReadFileStateKey,{byTarget:{...r.byTarget,[t]:n}})}function clearReadFileState(){loadContext().set(ReadFileStateKey,{byTarget:{}})}export{ReadFileStateKey,buildReadFileTargetKey,clearReadFileState,createReadFileStamp,normalizeModelPath,setReadFileStamp};

package/dist/src/runtime/framework-tools/final-output.d.ts

@@ -0,0 +1,14 @@
+import { type Tool } from "ai";
+import type { JsonObject } from "#shared/json.js";
+/**
+ * Stable model-visible name for the framework structured-output tool.
+ */
+export declare const FINAL_OUTPUT_TOOL_NAME = "final_output";
+/**
+ * Builds the model-facing `final_output` tool from a lowered output schema.
+ *
+ * The tool has no `execute`: calling it is the terminal signal the harness
+ * intercepts to surface the structured result. Its input is provider-constrained
+ * to the schema during generation, exactly like every other Eve tool input.
+ */
+export declare function buildFinalOutputTool(schema: JsonObject): Tool;

package/dist/src/runtime/framework-tools/final-output.js

@@ -0,0 +1 @@
+import{jsonSchema}from"ai";const FINAL_OUTPUT_TOOL_NAME=`final_output`;function buildFinalOutputTool(e){return{description:`Deliver your final answer in the required structure by calling this tool. Call it exactly once, when you are done; do not answer in prose.`,inputSchema:jsonSchema(e),outputSchema:jsonSchema(e)}}export{FINAL_OUTPUT_TOOL_NAME,buildFinalOutputTool};

package/dist/src/runtime/framework-tools/glob.d.ts

@@ -0,0 +1,17 @@
+import type { JsonObject } from "#shared/json.js";
+import type { ResolvedToolDefinition } from "#runtime/types.js";
+/**
+ * Shared input schema used by the framework `glob` tool and any author tool
+ * constructed via {@link defineGlobTool}.
+ *
+ * Exported so the public `defineGlobTool` factory and the framework
+ * `GLOB_TOOL_DEFINITION` use the exact same schema object — keeping model
+ * input contracts in sync without duplication.
+ */
+export declare const GLOB_INPUT_SCHEMA: JsonObject;
+/**
+ * Shared output schema used by the framework `glob` tool and any author tool
+ * constructed via {@link defineGlobTool}.
+ */
+export declare const GLOB_OUTPUT_SCHEMA: JsonObject;
+export declare const GLOB_TOOL_DEFINITION: ResolvedToolDefinition;

package/dist/src/runtime/framework-tools/glob.js

@@ -0,0 +1,2 @@
+import{requireSandboxSession}from"#execution/sandbox/require-sandbox.js";import{executeGlobOnSandbox}from"#execution/sandbox/glob-tool.js";const GLOB_INPUT_SCHEMA={additionalProperties:!1,properties:{limit:{description:`Maximum number of results to return. Defaults to 100.`,maximum:1e3,minimum:1,type:`integer`},path:{description:`The directory to search in. Defaults to /workspace. Must be an absolute path. Omit to use the default.`,type:`string`},pattern:{description:`The glob pattern to match files against (e.g. "**/*.ts", "src/**/*.js").`,type:`string`}},required:[`pattern`],type:`object`},GLOB_OUTPUT_SCHEMA={additionalProperties:!1,properties:{content:{type:`string`},count:{type:`integer`},path:{type:`string`},truncated:{type:`boolean`}},required:[`content`,`count`,`path`,`truncated`],type:`object`};async function executeGlob(e){return executeGlobOnSandbox(await requireSandboxSession(),e)}const GLOB_TOOL_DEFINITION={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.`,`- Use this tool when you need to find files by name patterns.`,`- If you are unsure of the correct file path, use the glob tool to look up filenames by glob pattern.`,`- Use the grep tool instead if you need to search file contents.`,`- Call this tool in parallel when you know there are multiple patterns to search for.`].join(`
+`),execute:executeGlob,inputSchema:GLOB_INPUT_SCHEMA,logicalPath:`eve:framework/glob`,name:`glob`,outputSchema:GLOB_OUTPUT_SCHEMA,sourceId:`eve:glob-tool`,sourceKind:`module`};export{GLOB_INPUT_SCHEMA,GLOB_OUTPUT_SCHEMA,GLOB_TOOL_DEFINITION};

package/dist/src/runtime/framework-tools/grep.d.ts

@@ -0,0 +1,17 @@
+import type { JsonObject } from "#shared/json.js";
+import type { ResolvedToolDefinition } from "#runtime/types.js";
+/**
+ * Shared input schema used by the framework `grep` tool and any author tool
+ * constructed via {@link defineGrepTool}.
+ *
+ * Exported so the public `defineGrepTool` factory and the framework
+ * `GREP_TOOL_DEFINITION` use the exact same schema object — keeping model
+ * input contracts in sync without duplication.
+ */
+export declare const GREP_INPUT_SCHEMA: JsonObject;
+/**
+ * Shared output schema used by the framework `grep` tool and any author tool
+ * constructed via {@link defineGrepTool}.
+ */
+export declare const GREP_OUTPUT_SCHEMA: JsonObject;
+export declare const GREP_TOOL_DEFINITION: ResolvedToolDefinition;

package/dist/src/runtime/framework-tools/grep.js

@@ -0,0 +1,2 @@
+import{requireSandboxSession}from"#execution/sandbox/require-sandbox.js";import{executeGrepOnSandbox}from"#execution/sandbox/grep-tool.js";const GREP_INPUT_SCHEMA={additionalProperties:!1,properties:{context:{description:`Number of surrounding context lines to include before and after each match. Defaults to 0.`,minimum:0,type:`integer`},glob:{description:`Filter files by glob pattern (e.g. "*.ts", "*.{ts,tsx}").`,type:`string`},ignoreCase:{description:`Perform case-insensitive search. Defaults to false.`,type:`boolean`},limit:{description:`Maximum number of matches to return per file. Defaults to 100.`,maximum:1e3,minimum:1,type:`integer`},literal:{description:`Treat the pattern as a literal string instead of a regular expression. Defaults to false.`,type:`boolean`},path:{description:`The directory or file to search in. Defaults to /workspace. Must be an absolute path. Omit to use the default.`,type:`string`},pattern:{description:`The regex pattern to search for in file contents (e.g. "log.*Error", "function\\s+\\w+").`,type:`string`}},required:[`pattern`],type:`object`},GREP_OUTPUT_SCHEMA={additionalProperties:!1,properties:{content:{type:`string`},matchCount:{type:`integer`},path:{type:`string`},truncated:{type:`boolean`}},required:[`content`,`matchCount`,`path`,`truncated`],type:`object`};async function executeGrep(e){return executeGrepOnSandbox(await requireSandboxSession(),e)}const GREP_TOOL_DEFINITION={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.`,`- Use this tool when you need to find files containing specific patterns.`,`- Use the glob tool instead if you only need to find files by name.`,`- Call this tool in parallel when you have multiple independent searches.`,`- Any line longer than 2000 characters is truncated.`].join(`
+`),execute:executeGrep,inputSchema:GREP_INPUT_SCHEMA,logicalPath:`eve:framework/grep`,name:`grep`,outputSchema:GREP_OUTPUT_SCHEMA,sourceId:`eve:grep-tool`,sourceKind:`module`};export{GREP_INPUT_SCHEMA,GREP_OUTPUT_SCHEMA,GREP_TOOL_DEFINITION};

package/dist/src/runtime/framework-tools/index.d.ts

@@ -0,0 +1,26 @@
+export { ConnectionRegistryKey } from "#context/providers/connection.js";
+export type { ReadFileStamp, ReadFileState } from "#runtime/framework-tools/file-state.js";
+export { ReadFileStateKey } from "#runtime/framework-tools/file-state.js";
+export type { TodoItem, TodoState } from "#runtime/framework-tools/todo.js";
+export { TodoStateKey } from "#runtime/framework-tools/todo.js";
+import type { ResolvedToolDefinition } from "#runtime/types.js";
+/**
+ * Returns framework-owned tool definitions registered in the tool registry
+ * alongside authored tools during graph resolution.
+ *
+ * `connection_search` is no longer in this list — it is registered as a
+ * framework dynamic tool resolver in the graph resolution path.
+ */
+export declare function getFrameworkToolDefinitions(_config?: {
+    readonly hasConnections?: boolean;
+}): readonly ResolvedToolDefinition[];
+/**
+ * Returns the names of every framework-provided tool the framework knows
+ * about, regardless of whether the current agent gates any of them on
+ * runtime configuration.
+ *
+ * Used by the graph resolver to validate `disableTool(name)` arguments —
+ * disabling a name that does not match any known framework tool is treated
+ * as an authoring error rather than silently dropping the request.
+ */
+export declare function getAllFrameworkToolNames(): ReadonlySet<string>;

package/dist/src/runtime/framework-tools/index.js

@@ -0,0 +1 @@
+import{ConnectionRegistryKey}from"#context/providers/connection.js";import{ReadFileStateKey}from"#runtime/framework-tools/file-state.js";import{ASK_QUESTION_TOOL_DEFINITION}from"#runtime/framework-tools/ask-question.js";import{WEB_SEARCH_TOOL_DEFINITION}from"#runtime/framework-tools/web-search.js";import{BASH_TOOL_DEFINITION}from"#runtime/framework-tools/bash.js";import{GLOB_TOOL_DEFINITION}from"#runtime/framework-tools/glob.js";import{GREP_TOOL_DEFINITION}from"#runtime/framework-tools/grep.js";import{READ_FILE_TOOL_DEFINITION}from"#runtime/framework-tools/read-file.js";import{SKILL_TOOL_DEFINITION}from"#runtime/framework-tools/skill.js";import{TODO_TOOL_DEFINITION,TodoStateKey}from"#runtime/framework-tools/todo.js";import{WEB_FETCH_TOOL_DEFINITION}from"#runtime/framework-tools/web-fetch.js";import{WRITE_FILE_TOOL_DEFINITION}from"#runtime/framework-tools/write-file.js";const ALL_FRAMEWORK_TOOLS=[ASK_QUESTION_TOOL_DEFINITION,BASH_TOOL_DEFINITION,GLOB_TOOL_DEFINITION,GREP_TOOL_DEFINITION,READ_FILE_TOOL_DEFINITION,WRITE_FILE_TOOL_DEFINITION,TODO_TOOL_DEFINITION,WEB_FETCH_TOOL_DEFINITION,WEB_SEARCH_TOOL_DEFINITION,SKILL_TOOL_DEFINITION];function getFrameworkToolDefinitions(e){return ALL_FRAMEWORK_TOOLS}function getAllFrameworkToolNames(){return new Set(ALL_FRAMEWORK_TOOLS.map(e=>e.name))}export{ConnectionRegistryKey,ReadFileStateKey,TodoStateKey,getAllFrameworkToolNames,getFrameworkToolDefinitions};

package/dist/src/runtime/framework-tools/read-file.d.ts

@@ -0,0 +1,17 @@
+import type { JsonObject } from "#shared/json.js";
+import type { ResolvedToolDefinition } from "#runtime/types.js";
+/**
+ * Shared input schema used by the framework `read_file` tool and any author
+ * tool constructed via {@link defineReadFileTool}.
+ *
+ * Exported so the public `defineReadFileTool` factory and the framework
+ * `READ_FILE_TOOL_DEFINITION` use the exact same schema object — keeping
+ * model input contracts in sync without duplication.
+ */
+export declare const READ_FILE_INPUT_SCHEMA: JsonObject;
+/**
+ * Shared output schema used by the framework `read_file` tool and any author
+ * tool constructed via {@link defineReadFileTool}.
+ */
+export declare const READ_FILE_OUTPUT_SCHEMA: JsonObject;
+export declare const READ_FILE_TOOL_DEFINITION: ResolvedToolDefinition;

package/dist/src/runtime/framework-tools/read-file.js

@@ -0,0 +1,2 @@
+import{clearReadFileState}from"#runtime/framework-tools/file-state.js";import{requireSandboxSession}from"#execution/sandbox/require-sandbox.js";import{executeReadFileOnSandbox}from"#execution/sandbox/read-file-tool.js";const READ_FILE_INPUT_SCHEMA={additionalProperties:!1,properties:{filePath:{description:`The absolute path to the file to read.`,type:`string`},limit:{description:`Maximum number of lines to return. Defaults to 2000.`,minimum:1,type:`integer`},offset:{description:`1-based line number to start from. Defaults to 1.`,minimum:1,type:`integer`}},required:[`filePath`],type:`object`},READ_FILE_OUTPUT_SCHEMA={additionalProperties:!1,properties:{content:{type:`string`},nextOffset:{minimum:1,type:`integer`},path:{type:`string`},totalLines:{minimum:0,type:`integer`},truncated:{type:`boolean`}},required:[`content`,`path`,`totalLines`,`truncated`],type:`object`};async function executeReadFile(e){return executeReadFileOnSandbox(await requireSandboxSession(),e)}const READ_FILE_TOOL_DEFINITION={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.`,`- 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.`,`- Use the grep tool to find specific content in large files or files with long lines.`,`- If you are unsure of the correct file path, use the glob tool to look up filenames by glob pattern.`,'- 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(`
+`),execute:executeReadFile,inputSchema:READ_FILE_INPUT_SCHEMA,logicalPath:`eve:framework/read-file`,name:`read_file`,onCompact(){return clearReadFileState(),{}},outputSchema:READ_FILE_OUTPUT_SCHEMA,sourceId:`eve:read-file-tool`,sourceKind:`module`};export{READ_FILE_INPUT_SCHEMA,READ_FILE_OUTPUT_SCHEMA,READ_FILE_TOOL_DEFINITION};

package/dist/src/runtime/framework-tools/skill.d.ts

@@ -0,0 +1,4 @@
+import type { ResolvedToolDefinition } from "#runtime/types.js";
+import type { JsonObject } from "#shared/json.js";
+export declare const SKILL_OUTPUT_SCHEMA: JsonObject;
+export declare const SKILL_TOOL_DEFINITION: ResolvedToolDefinition;

package/dist/src/runtime/framework-tools/skill.js

@@ -0,0 +1 @@
+import{SandboxKey}from"#context/keys.js";import{loadContext}from"#context/container.js";import{loadSkillFromSandbox}from"#runtime/skills/sandbox-access.js";async function executeLoadSkillTool(t){let n=loadContext().get(SandboxKey);if(n===void 0)throw Error(`The load_skill tool requires sandbox access on the runtime context. Ensure the step is running inside a managed runtime context with sandbox support.`);let{skill:r}=t;return await loadSkillFromSandbox(n,r)}const SKILL_OUTPUT_SCHEMA={type:`string`},SKILL_TOOL_DEFINITION={description:[`Load the full instructions for one available skill by name or id.`,`Use this tool when the request clearly matches a listed skill description or when the user explicitly asks for that skill.`,`Loading adds the skill instructions to the current turn.`,`Choose the "skill" value from the Available skills block.`].join(` `),execute:e=>executeLoadSkillTool(e),inputSchema:{additionalProperties:!1,properties:{skill:{description:`Available skill name or id.`,type:`string`}},required:[`skill`],type:`object`},logicalPath:`eve:framework/load-skill`,name:`load_skill`,outputSchema:SKILL_OUTPUT_SCHEMA,sourceId:`eve:load-skill-tool`,sourceKind:`module`};export{SKILL_OUTPUT_SCHEMA,SKILL_TOOL_DEFINITION};

package/dist/src/runtime/framework-tools/todo.d.ts

@@ -0,0 +1,39 @@
+import { ContextKey } from "#context/key.js";
+import type { ResolvedToolDefinition } from "#runtime/types.js";
+import type { JsonObject } from "#shared/json.js";
+/**
+ * Single item in the todo list.
+ */
+export interface TodoItem {
+    readonly content: string;
+    readonly priority: "high" | "medium" | "low";
+    readonly status: "pending" | "in_progress" | "completed" | "cancelled";
+}
+/**
+ * Durable state for the framework todo tool.
+ */
+export interface TodoState {
+    readonly items: readonly TodoItem[];
+}
+export declare const TodoStateKey: ContextKey<TodoState>;
+/**
+ * Typed input accepted by {@link executeTodoTool}.
+ *
+ * When `todos` is provided, the list is replaced (full replacement write).
+ * When `todos` is omitted, the current list is returned without modification.
+ */
+export interface TodoToolInput {
+    readonly todos?: readonly TodoItem[];
+}
+/**
+ * Executes the framework todo tool.
+ *
+ * - Read: omit `todos` → returns the current list.
+ * - Write: provide `todos` → replaces the entire list, returns the new list.
+ *
+ * Both paths return the same formatted output so the model always sees
+ * the full current state.
+ */
+export declare function executeTodoTool(input: TodoToolInput): unknown;
+export declare const TODO_OUTPUT_SCHEMA: JsonObject;
+export declare const TODO_TOOL_DEFINITION: ResolvedToolDefinition;

package/dist/src/runtime/framework-tools/todo.js

@@ -0,0 +1,3 @@
+import{loadContext}from"#context/container.js";import{ContextKey}from"#context/key.js";const TodoStateKey=new ContextKey(`eve.todo`);function formatTodoSummary(e){return e.items.length===0?void 0:`[Your task list was preserved across context compaction]\n${e.items.map(e=>`- [${e.status===`completed`?`x`:e.status===`cancelled`?`-`:` `}] [${e.priority}] ${e.content}`).join(`
+`)}`}function formatTodoResult(e){let{items:t}=e,n={cancelled:0,completed:0,in_progress:0,pending:0,total:t.length};for(let e of t)n[e.status]++;return{counts:n,todos:t}}function executeTodoTool(t){let r=loadContext(),{todos:i}=t??{};if(i!==void 0){let e={items:[...i]};return r.set(TodoStateKey,e),formatTodoResult(e)}return formatTodoResult(r.ensure(TodoStateKey,()=>({items:[]})))}const TODO_ITEM_SCHEMA={additionalProperties:!1,properties:{content:{description:`Brief description of the task.`,type:`string`},priority:{description:`Priority level of the task.`,enum:[`high`,`medium`,`low`],type:`string`},status:{description:`Current status of the task.`,enum:[`pending`,`in_progress`,`completed`,`cancelled`],type:`string`}},required:[`content`,`status`,`priority`],type:`object`},TODO_OUTPUT_SCHEMA={additionalProperties:!1,properties:{counts:{additionalProperties:!1,properties:{cancelled:{minimum:0,type:`integer`},completed:{minimum:0,type:`integer`},in_progress:{minimum:0,type:`integer`},pending:{minimum:0,type:`integer`},total:{minimum:0,type:`integer`}},required:[`cancelled`,`completed`,`in_progress`,`pending`,`total`],type:`object`},todos:{items:TODO_ITEM_SCHEMA,type:`array`}},required:[`counts`,`todos`],type:`object`},TODO_TOOL_DEFINITION={description:[`Use this tool to create and manage a structured task list for the current session.`,`This helps you track progress, organize complex tasks, and demonstrate thoroughness.`,``,`When to use:`,`- Complex multistep tasks requiring 3 or more distinct steps`,`- When the user provides multiple tasks or a numbered list`,`- After receiving new instructions, to capture requirements`,`- After completing a task, to mark it complete and add follow-ups`,``,`When NOT to use:`,`- Single, straightforward tasks that need no tracking`,`- Purely conversational or informational requests`,``,`Usage:`,"- Call with `todos` to replace the entire list (full replacement write)","- Call without `todos` to read the current list",`- Both return the full current list with status counts`,`- Mark tasks in_progress when you start, completed when done`,`- Only have ONE task in_progress at a time`].join(`
+`),execute:async e=>executeTodoTool(e??{}),inputSchema:{additionalProperties:!1,properties:{todos:{description:`The updated todo list. Omit to read the current list without modifying it.`,items:TODO_ITEM_SCHEMA,type:`array`}},type:`object`},logicalPath:`eve:framework/todo`,name:`todo`,onCompact(){let t=loadContext().get(TodoStateKey);if(t===void 0||t.items.length===0)return{};let r=formatTodoSummary(t);return r===void 0?{}:{messages:[{content:r,role:`user`}]}},outputSchema:TODO_OUTPUT_SCHEMA,sourceId:`eve:todo-tool`,sourceKind:`module`};export{TODO_OUTPUT_SCHEMA,TODO_TOOL_DEFINITION,TodoStateKey,executeTodoTool};

package/dist/src/runtime/framework-tools/web-fetch.d.ts

@@ -0,0 +1,5 @@
+import type { ResolvedToolDefinition } from "#runtime/types.js";
+import type { JsonObject } from "#shared/json.js";
+export declare const WEB_FETCH_INPUT_SCHEMA: JsonObject;
+export declare const WEB_FETCH_OUTPUT_SCHEMA: JsonObject;
+export declare const WEB_FETCH_TOOL_DEFINITION: ResolvedToolDefinition;

package/dist/src/runtime/framework-tools/web-fetch.js

@@ -0,0 +1,2 @@
+import{executeWebFetchTool}from"#execution/web-fetch/tool.js";async function executeWebFetch(e){return executeWebFetchTool(e)}const WEB_FETCH_INPUT_SCHEMA={additionalProperties:!1,properties:{format:{description:`The format to return the content in (text, markdown, or html). HTML responses are automatically converted to the requested format. Defaults to "markdown".`,enum:[`markdown`,`text`,`html`],type:`string`},timeout:{description:`Optional timeout in seconds. Defaults to 30, max 120.`,type:`number`},url:{description:`The fully-formed URL to fetch content from. Must start with http:// or https://.`,type:`string`}},required:[`url`],type:`object`},WEB_FETCH_OUTPUT_SCHEMA={additionalProperties:!1,properties:{content:{type:`string`},contentType:{type:`string`},truncated:{type:`boolean`},url:{type:`string`}},required:[`content`,`contentType`,`url`,`truncated`],type:`object`},WEB_FETCH_TOOL_DEFINITION={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 http:// or 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(`
+`),execute:executeWebFetch,inputSchema:WEB_FETCH_INPUT_SCHEMA,logicalPath:`eve:framework/web-fetch`,name:`web_fetch`,outputSchema:WEB_FETCH_OUTPUT_SCHEMA,sourceId:`eve:web-fetch-tool`,sourceKind:`module`};export{WEB_FETCH_INPUT_SCHEMA,WEB_FETCH_OUTPUT_SCHEMA,WEB_FETCH_TOOL_DEFINITION};

package/dist/src/runtime/framework-tools/web-search.d.ts

@@ -0,0 +1,26 @@
+import type { ResolvedToolDefinition } from "#runtime/types.js";
+import type { JsonObject } from "#shared/json.js";
+/**
+ * Output schema for OpenAI's provider-managed `webSearch` tool.
+ */
+export declare const WEB_SEARCH_OPENAI_OUTPUT_SCHEMA: JsonObject;
+/**
+ * Output schema for Anthropic's stable provider-managed `webSearch_20250305` tool.
+ */
+export declare const WEB_SEARCH_ANTHROPIC_OUTPUT_SCHEMA: JsonObject;
+/**
+ * Output schema for Google's provider-managed `googleSearch` grounding tool.
+ */
+export declare const WEB_SEARCH_GOOGLE_OUTPUT_SCHEMA: JsonObject;
+/**
+ * Output schema for AI Gateway's provider-managed `perplexitySearch` tool.
+ */
+export declare const WEB_SEARCH_GATEWAY_OUTPUT_SCHEMA: JsonObject;
+/**
+ * Framework-provided web search tool definition.
+ *
+ * Omits `execute` — the execution layer skips executor creation for tools
+ * without it, and the harness injects the real provider-managed tool at
+ * step time.
+ */
+export declare const WEB_SEARCH_TOOL_DEFINITION: ResolvedToolDefinition;

package/dist/src/runtime/framework-tools/web-search.js

@@ -0,0 +1 @@
+const WEB_SEARCH_OPENAI_OUTPUT_SCHEMA={$schema:`http://json-schema.org/draft-07/schema#`,additionalProperties:!1,properties:{action:{oneOf:[{additionalProperties:!1,properties:{queries:{items:{type:`string`},type:`array`},query:{type:`string`},type:{const:`search`,type:`string`}},required:[`type`],type:`object`},{additionalProperties:!1,properties:{type:{const:`openPage`,type:`string`},url:{anyOf:[{type:`string`},{type:`null`}]}},required:[`type`],type:`object`},{additionalProperties:!1,properties:{pattern:{anyOf:[{type:`string`},{type:`null`}]},type:{const:`findInPage`,type:`string`},url:{anyOf:[{type:`string`},{type:`null`}]}},required:[`type`],type:`object`}]},sources:{items:{oneOf:[{additionalProperties:!1,properties:{type:{const:`url`,type:`string`},url:{type:`string`}},required:[`type`,`url`],type:`object`},{additionalProperties:!1,properties:{name:{type:`string`},type:{const:`api`,type:`string`}},required:[`type`,`name`],type:`object`}]},type:`array`}},type:`object`},WEB_SEARCH_ANTHROPIC_OUTPUT_SCHEMA={$schema:`http://json-schema.org/draft-07/schema#`,items:{additionalProperties:!1,properties:{encryptedContent:{type:`string`},pageAge:{anyOf:[{type:`string`},{type:`null`}]},title:{anyOf:[{type:`string`},{type:`null`}]},type:{const:`web_search_result`,type:`string`},url:{type:`string`}},required:[`url`,`title`,`pageAge`,`encryptedContent`,`type`],type:`object`},type:`array`},WEB_SEARCH_GOOGLE_OUTPUT_SCHEMA={$schema:`http://json-schema.org/draft-07/schema#`,additionalProperties:!1,properties:{},type:`object`},WEB_SEARCH_GATEWAY_OUTPUT_SCHEMA={$schema:`http://json-schema.org/draft-07/schema#`,anyOf:[{additionalProperties:!1,properties:{id:{type:`string`},results:{items:{additionalProperties:!1,properties:{date:{type:`string`},lastUpdated:{type:`string`},snippet:{type:`string`},title:{type:`string`},url:{type:`string`}},required:[`title`,`url`,`snippet`],type:`object`},type:`array`}},required:[`results`,`id`],type:`object`},{additionalProperties:!1,properties:{error:{enum:[`api_error`,`rate_limit`,`timeout`,`invalid_input`,`unknown`],type:`string`},message:{type:`string`},statusCode:{type:`number`}},required:[`error`,`message`],type:`object`}]},WEB_SEARCH_TOOL_DEFINITION={description:`Search the web for real-time information. Use this to find up-to-date information about current events, recent developments, or topics that may have changed since the knowledge cutoff.`,inputSchema:null,logicalPath:`eve:framework/web-search`,name:`web_search`,sourceId:`eve:web-search-tool`,sourceKind:`module`};export{WEB_SEARCH_ANTHROPIC_OUTPUT_SCHEMA,WEB_SEARCH_GATEWAY_OUTPUT_SCHEMA,WEB_SEARCH_GOOGLE_OUTPUT_SCHEMA,WEB_SEARCH_OPENAI_OUTPUT_SCHEMA,WEB_SEARCH_TOOL_DEFINITION};

package/dist/src/runtime/framework-tools/write-file.d.ts

@@ -0,0 +1,17 @@
+import type { JsonObject } from "#shared/json.js";
+import type { ResolvedToolDefinition } from "#runtime/types.js";
+/**
+ * Shared input schema used by the framework `write_file` tool and any author
+ * tool constructed via {@link defineWriteFileTool}.
+ *
+ * Exported so the public `defineWriteFileTool` factory and the framework
+ * `WRITE_FILE_TOOL_DEFINITION` use the exact same schema object — keeping
+ * model input contracts in sync without duplication.
+ */
+export declare const WRITE_FILE_INPUT_SCHEMA: JsonObject;
+/**
+ * Shared output schema used by the framework `write_file` tool and any author
+ * tool constructed via {@link defineWriteFileTool}.
+ */
+export declare const WRITE_FILE_OUTPUT_SCHEMA: JsonObject;
+export declare const WRITE_FILE_TOOL_DEFINITION: ResolvedToolDefinition;

package/dist/src/runtime/framework-tools/write-file.js

@@ -0,0 +1,2 @@
+import{requireSandboxSession}from"#execution/sandbox/require-sandbox.js";import{executeWriteFileOnSandbox}from"#execution/sandbox/write-file-tool.js";const WRITE_FILE_INPUT_SCHEMA={additionalProperties:!1,properties:{content:{description:`Complete replacement file contents.`,type:`string`},filePath:{description:`The absolute path to the file to write (must be absolute, not relative).`,type:`string`}},required:[`filePath`,`content`],type:`object`},WRITE_FILE_OUTPUT_SCHEMA={additionalProperties:!1,properties:{existed:{type:`boolean`},path:{type:`string`}},required:[`existed`,`path`],type:`object`};async function executeWriteFile(e){return executeWriteFileOnSandbox(await requireSandboxSession(),e)}const WRITE_FILE_TOOL_DEFINITION={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(`
+`),execute:executeWriteFile,inputSchema:WRITE_FILE_INPUT_SCHEMA,logicalPath:`eve:framework/write-file`,name:`write_file`,outputSchema:WRITE_FILE_OUTPUT_SCHEMA,sourceId:`eve:write-file-tool`,sourceKind:`module`};export{WRITE_FILE_INPUT_SCHEMA,WRITE_FILE_OUTPUT_SCHEMA,WRITE_FILE_TOOL_DEFINITION};

package/dist/src/runtime/governance/auth/http-basic.d.ts

@@ -0,0 +1,8 @@
+import type { ResolvedHttpBasicAuthStrategy, RouteStrategyAuthenticationResult } from "#runtime/governance/auth/types.js";
+/**
+ * Verifies one HTTP Basic credential against a resolved Eve strategy.
+ */
+export declare function authenticateHttpBasicStrategy(input: {
+    readonly authorization: string;
+    readonly strategy: ResolvedHttpBasicAuthStrategy;
+}): RouteStrategyAuthenticationResult;

package/dist/src/runtime/governance/auth/http-basic.js

@@ -0,0 +1 @@
+import{createHash,timingSafeEqual}from"node:crypto";function authenticateHttpBasicStrategy(e){let t=parseBasicAuthorizationHeader(e.authorization);return t===null||t.username!==e.strategy.username||!timingSafeStringEquals(t.password,e.strategy.password)?{kind:`not-authenticated`}:{kind:`authenticated`,principal:{attributes:Object.freeze({}),authenticator:`http-basic`,claims:Object.freeze({}),principalId:e.strategy.username,principalType:`user`}}}function parseBasicAuthorizationHeader(e){let t=/^Basic\s+(.+)$/i.exec(e);if(t===null)return null;let n=t[1];if(n===void 0)return null;let r;try{r=Buffer.from(n,`base64`).toString(`utf8`)}catch{return null}let i=r.indexOf(`:`);return i===-1?null:{password:r.slice(i+1),username:r.slice(0,i)}}function timingSafeStringEquals(e,n){return timingSafeEqual(heveString(e),heveString(n))}function heveString(t){return createHash(`sha256`).update(t,`utf8`).digest()}export{authenticateHttpBasicStrategy};

package/dist/src/runtime/governance/auth/jwt-ecdsa.d.ts

@@ -0,0 +1,8 @@
+import type { ResolvedJwtEcdsaAuthStrategy, RouteStrategyAuthenticationResult } from "#runtime/governance/auth/types.js";
+/**
+ * Verifies one bearer token against a resolved ECDSA JWT strategy.
+ */
+export declare function authenticateJwtEcdsaStrategy(input: {
+    readonly token: string;
+    readonly strategy: ResolvedJwtEcdsaAuthStrategy;
+}): Promise<RouteStrategyAuthenticationResult>;

package/dist/src/runtime/governance/auth/jwt-ecdsa.js

@@ -0,0 +1 @@
+import{importJWK,importSPKI,jwtVerify}from"#compiled/jose/index.js";import{areTokenClaimMatchersSatisfied,createJwtAuthenticatedCallerPrincipal}from"#runtime/governance/auth/token-claims.js";const importedJwtPublicKeyCache=new Map;async function authenticateJwtEcdsaStrategy(e){let t;try{t=await getImportedJwtPublicKey(e.strategy)}catch(e){return{kind:`misconfigured`,message:`Failed to import JWT ECDSA public key. ${e instanceof Error?e.message:`Unknown key import failure.`}`}}try{let a=await jwtVerify(e.token,t,{algorithms:[e.strategy.algorithm],audience:[...e.strategy.audiences],clockTolerance:e.strategy.clockSkewSeconds,issuer:e.strategy.issuer});return typeof a.payload.sub!=`string`||a.payload.sub.length===0?{kind:`not-authenticated`}:areTokenClaimMatchersSatisfied(a.payload,e.strategy)?{kind:`authenticated`,principal:createJwtAuthenticatedCallerPrincipal({authenticator:`jwt-ecdsa`,payload:a.payload,principalType:`service`})}:{kind:`caller-not-allowed`}}catch{return{kind:`not-authenticated`}}}async function getImportedJwtPublicKey(e){let t=`${e.algorithm}:${e.publicKey}`,n=importedJwtPublicKeyCache.get(t);if(n!==void 0)return await n;let r=importJwtPublicKey(e.publicKey,e.algorithm).catch(e=>{throw importedJwtPublicKeyCache.delete(t),e});return importedJwtPublicKeyCache.set(t,r),await r}async function importJwtPublicKey(n,r){let i=n.trim();return i.startsWith(`{`)?await importJWK(JSON.parse(i),r):await importSPKI(i,r)}export{authenticateJwtEcdsaStrategy};

package/dist/src/runtime/governance/auth/jwt-hmac.d.ts

@@ -0,0 +1,8 @@
+import type { ResolvedJwtHmacAuthStrategy, RouteStrategyAuthenticationResult } from "#runtime/governance/auth/types.js";
+/**
+ * Verifies one bearer token against a resolved HMAC JWT strategy.
+ */
+export declare function authenticateJwtHmacStrategy(input: {
+    readonly token: string;
+    readonly strategy: ResolvedJwtHmacAuthStrategy;
+}): Promise<RouteStrategyAuthenticationResult>;

package/dist/src/runtime/governance/auth/jwt-hmac.js

@@ -0,0 +1 @@
+import{createSecretKey}from"node:crypto";import{jwtVerify}from"#compiled/jose/index.js";import{areTokenClaimMatchersSatisfied,createJwtAuthenticatedCallerPrincipal}from"#runtime/governance/auth/token-claims.js";async function authenticateJwtHmacStrategy(e){try{let t=await jwtVerify(e.token,createSecretKey(Buffer.from(e.strategy.secret,`utf8`)),{algorithms:[e.strategy.algorithm],audience:[...e.strategy.audiences],clockTolerance:e.strategy.clockSkewSeconds,issuer:e.strategy.issuer});return typeof t.payload.sub!=`string`||t.payload.sub.length===0?{kind:`not-authenticated`}:areTokenClaimMatchersSatisfied(t.payload,e.strategy)?{kind:`authenticated`,principal:createJwtAuthenticatedCallerPrincipal({authenticator:`jwt-hmac`,payload:t.payload,principalType:`service`})}:{kind:`caller-not-allowed`}}catch{return{kind:`not-authenticated`}}}export{authenticateJwtHmacStrategy};

package/dist/src/runtime/governance/auth/oidc.d.ts

@@ -0,0 +1,8 @@
+import type { ResolvedOidcAuthStrategy, RouteStrategyAuthenticationResult } from "#runtime/governance/auth/types.js";
+/**
+ * Verifies one bearer token against a resolved OIDC strategy.
+ */
+export declare function authenticateOidcStrategy(input: {
+    readonly token: string;
+    readonly strategy: ResolvedOidcAuthStrategy;
+}): Promise<RouteStrategyAuthenticationResult>;

package/dist/src/runtime/governance/auth/oidc.js

@@ -0,0 +1 @@
+import{z}from"#compiled/zod/index.js";import{createRemoteJWKSet,jwtVerify}from"#compiled/jose/index.js";import{areTokenClaimMatchersSatisfied,createJwtAuthenticatedCallerPrincipal}from"#runtime/governance/auth/token-claims.js";const oidcDiscoveryDocumentSchema=z.object({issuer:z.string().optional(),jwks_uri:z.string().url()}).passthrough(),oidcDiscoveryDocumentCache=new Map,oidcJwksCache=new Map;async function authenticateOidcStrategy(e){let t;try{t=await getOidcRemoteJwks(e.strategy)}catch(e){return{kind:`misconfigured`,message:`Failed to load OIDC discovery metadata. ${e instanceof Error?e.message:`Unknown discovery failure.`}`}}try{let a=await jwtVerify(e.token,t,{audience:[...e.strategy.audiences],clockTolerance:e.strategy.clockSkewSeconds,issuer:e.strategy.issuer});if(e.strategy.acceptCurrentVercelProject&&e.strategy.issuer.startsWith(`https://oidc.vercel.com/`)&&a.payload.external_sub!==void 0)return typeof a.payload.external_sub!=`string`||a.payload.external_sub.length===0||!currentVercelProjectMatches({payload:a.payload})||!currentVercelEnvironmentMatches({payload:a.payload})?{kind:`caller-not-allowed`}:{kind:`authenticated`,principal:createJwtAuthenticatedCallerPrincipal({authenticator:`oidc`,issuerClaims:[`external_iss`,`connector_id`],payload:a.payload,principalType:`user`,subjectClaim:`external_sub`})};if(typeof a.payload.sub!=`string`||a.payload.sub.length===0)return{kind:`not-authenticated`};let o=e.strategy.acceptCurrentVercelProject&&isCurrentVercelProjectToken({issuer:e.strategy.issuer,payload:a.payload}),s=o&&isCurrentVercelEnvironmentToken({payload:a.payload});return!o&&!areTokenClaimMatchersSatisfied(a.payload,e.strategy)?{kind:`caller-not-allowed`}:{kind:`authenticated`,principal:createJwtAuthenticatedCallerPrincipal({authenticator:`oidc`,payload:a.payload,principalType:s?`runtime`:`service`})}}catch{return{kind:`not-authenticated`}}}async function getOidcRemoteJwks(e){let n=await getOidcDiscoveryDocument(e.discoveryUrl),r=oidcJwksCache.get(n.jwks_uri);if(r!==void 0)return r;let i=createRemoteJWKSet(new URL(n.jwks_uri));return oidcJwksCache.set(n.jwks_uri,i),i}async function getOidcDiscoveryDocument(e){let t=oidcDiscoveryDocumentCache.get(e);if(t!==void 0)return await t;let n=fetch(e,{headers:{accept:`application/json`}}).then(async e=>{if(!e.ok)throw Error(`Discovery route returned HTTP ${e.status}.`);return oidcDiscoveryDocumentSchema.parse(await e.json())}).catch(t=>{throw oidcDiscoveryDocumentCache.delete(e),t});return oidcDiscoveryDocumentCache.set(e,n),await n}function isCurrentVercelProjectToken(e){if(!e.issuer.startsWith(`https://oidc.vercel.com`))return!1;let t=process.env.VERCEL_PROJECT_ID?.trim();return t===void 0||t.length===0?!1:typeof e.payload.project_id==`string`&&e.payload.project_id===t}function currentVercelProjectMatches(e){let t=process.env.VERCEL_PROJECT_ID?.trim();return t===void 0||t.length===0?!1:typeof e.payload.project_id==`string`&&e.payload.project_id===t}function isCurrentVercelEnvironmentToken(e){let t=getCurrentVercelEnvironment();return t===void 0||t.length===0?!1:typeof e.payload.environment==`string`&&e.payload.environment===t}function currentVercelEnvironmentMatches(e){let t=getCurrentVercelEnvironment();return t===void 0||t.length===0?!1:typeof e.payload.environment==`string`&&e.payload.environment===t}function getCurrentVercelEnvironment(){return process.env.VERCEL_TARGET_ENV?.trim()||process.env.VERCEL_ENV?.trim()||void 0}export{authenticateOidcStrategy};

package/dist/src/runtime/governance/auth/token-claims.d.ts

@@ -0,0 +1,17 @@
+import type { JWTPayload } from "#compiled/jose/index.js";
+import type { AuthenticatedCallerPrincipal, ResolvedTokenClaimMatchers } from "#runtime/governance/auth/types.js";
+/**
+ * Returns whether the verified JWT payload satisfies the authored subject and
+ * claim selectors.
+ */
+export declare function areTokenClaimMatchersSatisfied(payload: JWTPayload, matchers: ResolvedTokenClaimMatchers): boolean;
+/**
+ * Creates a normalized JWT-backed Eve principal from a verified payload.
+ */
+export declare function createJwtAuthenticatedCallerPrincipal(input: {
+    readonly authenticator: AuthenticatedCallerPrincipal["authenticator"];
+    readonly issuerClaims?: readonly string[];
+    readonly payload: JWTPayload;
+    readonly principalType: AuthenticatedCallerPrincipal["principalType"];
+    readonly subjectClaim?: string;
+}): AuthenticatedCallerPrincipal;

package/dist/src/runtime/governance/auth/token-claims.js

@@ -0,0 +1 @@
+const STANDARD_PROJECTED_CLAIM_KEYS=new Set([`aud`,`exp`,`iat`,`iss`,`jti`,`nbf`,`sub`]);function normalizeJwtClaims(e){let t={};for(let[n,r]of Object.entries(e)){if(typeof r==`string`){t[n]=r;continue}Array.isArray(r)&&r.every(e=>typeof e==`string`)&&(t[n]=Object.freeze([...r]))}return Object.freeze(t)}function createJwtAttributeProjection(t){let n=normalizeJwtClaims(t);return Object.freeze(Object.fromEntries(Object.entries(n).filter(([t])=>!STANDARD_PROJECTED_CLAIM_KEYS.has(t))))}function areTokenClaimMatchersSatisfied(e,t){let n=normalizeJwtClaims(e);if(t.subjects!==void 0){let n=typeof e.sub==`string`?e.sub:null;if(n===null||!t.subjects.some(e=>matchesWildcardPattern(e,n)))return!1}return t.claims===void 0?!0:Object.entries(t.claims).every(([e,t])=>{let r=n[e];return r===void 0?!1:typeof r==`string`?t.includes(r):r.some(e=>t.includes(e))})}function createJwtAuthenticatedCallerPrincipal(e){let t=readFirstStringClaim(e.payload,[...e.issuerClaims??[],`iss`]),n=e.subjectClaim??`sub`,r=readFirstStringClaim(e.payload,[n]);if(t===void 0||r===void 0)throw Error(`Expected verified JWT payloads to include string iss and ${n} claims.`);let i=normalizeJwtClaims(e.payload);return{attributes:createJwtAttributeProjection(e.payload),authenticator:e.authenticator,claims:i,issuer:t,principalId:`${t}:${r}`,principalType:e.principalType,subject:r}}function readFirstStringClaim(e,t){for(let n of t){let t=e[n];if(typeof t==`string`&&t.length>0)return t}}function matchesWildcardPattern(e,t){if(!e.includes(`*`))return e===t;let n=e.replaceAll(/[.+?^${}()|[\]\\]/g,`\\$&`).replaceAll(`*`,`.*`);return RegExp(`^${n}$`).test(t)}export{areTokenClaimMatchersSatisfied,createJwtAuthenticatedCallerPrincipal};

package/dist/src/runtime/governance/auth/types.d.ts

@@ -0,0 +1,104 @@
+import type { RuntimeSessionAuthAttributes, RuntimeSessionAuthContext, RuntimeSessionAuthenticator, RuntimeSessionPrincipalType } from "#runtime/sessions/auth.js";
+/**
+ * Shared serializable token-claim projection used by auth verifiers.
+ */
+export type RouteAuthAttributes = RuntimeSessionAuthAttributes;
+/**
+ * One authenticated caller normalized into Eve-owned runtime metadata.
+ */
+export interface AuthenticatedCallerPrincipal {
+    readonly attributes: RouteAuthAttributes;
+    readonly authenticator: RuntimeSessionAuthenticator;
+    readonly claims: RouteAuthAttributes;
+    readonly issuer?: string;
+    readonly principalId: string;
+    readonly principalType: RuntimeSessionPrincipalType;
+    readonly subject?: string;
+}
+/**
+ * Shared resolved token claim matchers.
+ */
+export interface ResolvedTokenClaimMatchers {
+    readonly claims?: Readonly<Record<string, readonly string[]>>;
+    readonly subjects?: readonly string[];
+}
+/**
+ * Resolved HTTP Basic auth strategy.
+ */
+export interface ResolvedHttpBasicAuthStrategy {
+    readonly kind: "http-basic";
+    readonly password: string;
+    readonly username: string;
+}
+/**
+ * Resolved HMAC JWT auth strategy.
+ */
+export interface ResolvedJwtHmacAuthStrategy extends ResolvedTokenClaimMatchers {
+    readonly algorithm: "HS256" | "HS384" | "HS512";
+    readonly audiences: readonly string[];
+    readonly clockSkewSeconds: number;
+    readonly issuer: string;
+    readonly kind: "jwt-hmac";
+    readonly secret: string;
+}
+/**
+ * Resolved ECDSA JWT auth strategy.
+ */
+export interface ResolvedJwtEcdsaAuthStrategy extends ResolvedTokenClaimMatchers {
+    readonly algorithm: "ES256" | "ES384" | "ES512";
+    readonly audiences: readonly string[];
+    readonly clockSkewSeconds: number;
+    readonly issuer: string;
+    readonly kind: "jwt-ecdsa";
+    readonly publicKey: string;
+}
+/**
+ * Resolved OIDC auth strategy.
+ */
+export interface ResolvedOidcAuthStrategy extends ResolvedTokenClaimMatchers {
+    /**
+     * Vercel-platform extension. When `true` and the token's issuer is
+     * a Vercel OIDC issuer, tokens minted for the current
+     * `VERCEL_PROJECT_ID` are accepted unconditionally — in addition to
+     * the author-supplied `subjects`/`claims` matchers — so the
+     * deployment's own runtime callers (subagent, internal fetches)
+     * always authenticate. Tokens that additionally match the current
+     * `VERCEL_TARGET_ENV` / `VERCEL_ENV` are tagged
+     * `principalType: "runtime"`; other current-project tokens are
+     * tagged `"service"`.
+     *
+     * Vercel OIDC tokens with an `external_sub` claim are user tokens.
+     * They must satisfy the current project/environment constraints when
+     * those environment variables are configured, and then authenticate as
+     * `principalType: "user"` with `external_sub` as their subject and
+     * `external_iss` / `connector_id` as their issuer when present.
+     *
+     * Set exclusively by `verifyVercelOidc`. The generic public
+     * `verifyOidc` always passes `false`.
+     */
+    readonly acceptCurrentVercelProject: boolean;
+    readonly audiences: readonly string[];
+    readonly clockSkewSeconds: number;
+    readonly discoveryUrl: string;
+    readonly issuer: string;
+    readonly kind: "oidc";
+}
+/**
+ * Internal strategy verification outcomes used by the route-auth orchestrator.
+ */
+export type RouteStrategyAuthenticationResult = {
+    readonly kind: "authenticated";
+    readonly principal: AuthenticatedCallerPrincipal;
+} | {
+    readonly kind: "caller-not-allowed";
+} | {
+    readonly kind: "misconfigured";
+    readonly message: string;
+} | {
+    readonly kind: "not-authenticated";
+};
+/**
+ * Creates the session-auth projection persisted on runtime state and exposed to
+ * authored code via `ctx.session.auth`.
+ */
+export declare function createRuntimeSessionAuthContext(principal: AuthenticatedCallerPrincipal): RuntimeSessionAuthContext;

package/dist/src/runtime/governance/auth/types.js

@@ -0,0 +1 @@
+function createRuntimeSessionAuthContext(e){return{attributes:e.attributes,authenticator:e.authenticator,issuer:e.issuer,principalId:e.principalId,principalType:e.principalType,subject:e.subject}}export{createRuntimeSessionAuthContext};

package/dist/src/runtime/governance/network/ip-allow-list.d.ts

@@ -0,0 +1,17 @@
+import { BlockList } from "node:net";
+/**
+ * Parsed runtime-owned IP allowlist.
+ */
+export interface RuntimeIpAllowList {
+    readonly blockList: BlockList;
+    readonly entries: readonly string[];
+}
+/**
+ * Parses exact IP and CIDR entries into a reusable runtime-owned allowlist.
+ */
+export declare function createRuntimeIpAllowList(entries: readonly string[]): RuntimeIpAllowList;
+/**
+ * Returns whether the normalized request IP matches at least one allowlist
+ * entry.
+ */
+export declare function isRuntimeIpAllowed(address: string, allowList: RuntimeIpAllowList): boolean;

package/dist/src/runtime/governance/network/ip-allow-list.js

@@ -0,0 +1 @@
+import{BlockList,isIP}from"node:net";function createRuntimeIpAllowList(t){let n=new BlockList;for(let e of t){let t=e.trim();if(t.length===0)throw Error(`Expected every network.ipAllowList entry to be non-empty.`);if(t.includes(`*`))throw Error(`Expected "${t}" to use exact IP or CIDR syntax instead of "*".`);let r=t.indexOf(`/`);if(r===-1){let e=normalizeIpAddress(t),r=getIpFamily(e);n.addAddress(e,r);continue}let i=normalizeIpAddress(t.slice(0,r)),a=Number.parseInt(t.slice(r+1),10),o=getIpFamily(i),s=o===`ipv4`?32:128;if(!Number.isInteger(a)||a<0||a>s)throw Error(`Expected "${t}" to use a valid ${o} CIDR prefix length.`);n.addSubnet(i,a,o)}return{blockList:n,entries:[...t]}}function isRuntimeIpAllowed(e,t){let n=normalizeIpAddress(e),r=getIpFamily(n);return t.blockList.check(n,r)}function normalizeIpAddress(e){let n=e.trim().replace(/^\[(.*)\]$/,`$1`),r=n.indexOf(`%`),i=r===-1?n:n.slice(0,r);if(i.startsWith(`::ffff:`)){let e=i.slice(7);if(isIP(e)===4)return e}return i}function getIpFamily(e){switch(isIP(e)){case 4:return`ipv4`;case 6:return`ipv6`;default:throw Error(`Expected "${e}" to be a valid IP address.`)}}export{createRuntimeIpAllowList,isRuntimeIpAllowed};

package/dist/src/runtime/graph.d.ts

@@ -0,0 +1,46 @@
+import type { RuntimeTurnAgent } from "#runtime/agent/bootstrap.js";
+import type { RuntimeHookRegistry } from "#runtime/hooks/registry.js";
+import type { RuntimeSandboxRegistry } from "#runtime/sandbox/registry.js";
+import type { RuntimeSubagentRegistry } from "#runtime/subagents/registry.js";
+import type { RuntimeToolRegistry } from "#runtime/tools/registry.js";
+import type { ResolvedAgent, ResolvedChannelDefinition } from "#runtime/types.js";
+/**
+ * Stable node id used by the runtime-owned graph bundle for the root agent.
+ */
+export declare const ROOT_RUNTIME_AGENT_NODE_ID = "__root__";
+/**
+ * One resolved runtime-owned agent node in the recursive compiled graph.
+ */
+export interface ResolvedRuntimeAgentNode {
+    readonly agent: ResolvedAgent;
+    /**
+     * The merged set of channels (framework defaults + authored overrides
+     * minus authored disables) that the Nitro mounting loop should mount.
+     * Computed by `resolve-agent-graph.ts` so the host plumbing never has to
+     * combine framework defaults with the resolved-agent's authored channels.
+     */
+    readonly channels: readonly ResolvedChannelDefinition[];
+    /**
+     * Per-node hook registry. Stream-event subscribers fan out alongside
+     * channel adapter event handlers.
+     */
+    readonly hookRegistry: RuntimeHookRegistry;
+    readonly nodeId: string;
+    readonly sandboxRegistry: RuntimeSandboxRegistry;
+    readonly sourceId?: string;
+    readonly subagentRegistry: RuntimeSubagentRegistry;
+    readonly toolRegistry: RuntimeToolRegistry;
+    readonly turnAgent: RuntimeTurnAgent;
+}
+/**
+ * Recursive runtime-owned compiled graph bundle shared across root and child
+ * subagent execution.
+ */
+export interface ResolvedAgentGraphBundle {
+    readonly nodesByNodeId: ReadonlyMap<string, ResolvedRuntimeAgentNode>;
+    readonly root: ResolvedRuntimeAgentNode;
+}
+/**
+ * Resolves one runtime-owned agent node from the compiled recursive graph.
+ */
+export declare function getResolvedRuntimeAgentNode(bundle: ResolvedAgentGraphBundle, nodeId: string | undefined): ResolvedRuntimeAgentNode;

package/dist/src/runtime/graph.js

@@ -0,0 +1 @@
+const ROOT_RUNTIME_AGENT_NODE_ID=`__root__`;function getResolvedRuntimeAgentNode(e,t){if(t===void 0||t===`__root__`)return e.root;let n=e.nodesByNodeId.get(t);if(n===void 0)throw Error(`Missing runtime agent node for node id "${t}".`);return n}export{ROOT_RUNTIME_AGENT_NODE_ID,getResolvedRuntimeAgentNode};