eve 0.44.4 → 0.45.0

package/dist/src/public/tools/define-write-file-tool.d.ts

@@ -1,22 +0,0 @@
-import type { ToolDefinition } from "#public/definitions/tool.js";
-/**
- * Input shape accepted by {@link defineWriteFileTool}.
- */
-export interface DefineWriteFileToolInput {
-    /**
-     * Optional model-facing description. Defaults to a generic
-     * "Write a file to the workspace sandbox." line.
-     */
-    readonly description?: string;
-}
-/**
- * Defines a model-visible file-writer tool that writes files to the
- * agent's sandbox. Uses the same executor core as the framework
- * `write_file` tool, so input schema, error messages, and result shape
- * are identical.
- *
- * The tool's runtime name comes from the authored file's slug (for
- * example `agent/tools/write_file.ts` becomes a tool named
- * `write_file`).
- */
-export declare function defineWriteFileTool(input?: DefineWriteFileToolInput): ToolDefinition;

package/dist/src/public/tools/define-write-file-tool.js

@@ -1 +0,0 @@
-import{WRITE_FILE_INPUT_SCHEMA,WRITE_FILE_OUTPUT_SCHEMA}from"#runtime/framework-tools/write-file.js";import{executeWriteFileOnSandbox}from"#execution/sandbox/write-file-tool.js";function defineWriteFileTool(n={}){return{description:n.description??`Write a file to the workspace sandbox.`,async execute(e,t){return executeWriteFileOnSandbox(await t.getSandbox(),e)},inputSchema:WRITE_FILE_INPUT_SCHEMA,outputSchema:WRITE_FILE_OUTPUT_SCHEMA}}export{defineWriteFileTool};

package/dist/src/public/tools/internal.d.ts

@@ -1,13 +0,0 @@
-import type { ResolvedToolDefinition } from "#runtime/types.js";
-import type { ToolDefinition } from "#public/definitions/tool.js";
-/**
- * Converter that strips internal identity fields from a framework
- * {@link ResolvedToolDefinition} so it can be re-exported as a public
- * {@link ToolDefinition}.
- *
- * Framework tools have the internal `(input, options) => output` signature.
- * The public {@link ToolDefinition.execute} expects `(input, ctx)`.
- * This wrapper bridges the gap — the public `ctx` is mapped back onto the
- * internal execute options.
- */
-export declare function toPublicToolDefinition(definition: ResolvedToolDefinition): ToolDefinition;

package/dist/src/public/tools/internal.js

@@ -1 +0,0 @@
-function toPublicToolDefinition(e){if(!e.execute)throw Error(`Tool "${e.name}" is client-side and cannot be re-exported publicly.`);let t=e.execute,n={description:e.description,execute:(e,n)=>t(e,{abortSignal:n.abortSignal,messages:[],toolCallId:n.callId}),inputSchema:e.inputSchema??{},outputSchema:e.outputSchema};return e.approval!==void 0&&(n.approval=e.approval),n}export{toPublicToolDefinition};

package/dist/src/public/tools/sleep/index.js

@@ -1 +0,0 @@
-import{defineTool}from"#public/definitions/tool.js";import{SLEEP_INPUT_SCHEMA,SLEEP_OUTPUT_SCHEMA,SLEEP_TOOL_DESCRIPTION,executeSleepTool}from"#runtime/framework-tools/sleep.js";function sleep(){return defineTool({description:SLEEP_TOOL_DESCRIPTION,execute:executeSleepTool,inputSchema:SLEEP_INPUT_SCHEMA,outputSchema:SLEEP_OUTPUT_SCHEMA})}export{sleep};

package/dist/src/runtime/connections/callback-route.js

@@ -1 +0,0 @@
-import{EVE_CONNECTION_CALLBACK_ROUTE_PATTERN,EVE_LEGACY_CONNECTION_CALLBACK_ROUTE_PATTERN}from"#protocol/routes.js";import{resumeHook}from"#internal/workflow/runtime.js";import{buildAuthorizationCompletePage}from"#runtime/connections/authorization-complete-page.js";const HTTP_CONNECTION_CALLBACK_CHANNEL_NAME_PREFIX=`eve/v1/connections/callback`,HANDLED_METHODS=[`GET`,`POST`],ROUTE_KINDS=[`attempt`,`legacy`];function getConnectionCallbackChannelDefinitions(){return ROUTE_KINDS.flatMap(e=>HANDLED_METHODS.map(t=>buildCallbackChannelDefinition(t,e)))}function getConnectionCallbackChannelNames(){return new Set(getConnectionCallbackChannelDefinitions().map(e=>e.name))}function buildCallbackChannelDefinition(n,r){let i=channelNameForMethod(n,r);return{name:i,method:n,urlPath:r===`attempt`?EVE_CONNECTION_CALLBACK_ROUTE_PATTERN:EVE_LEGACY_CONNECTION_CALLBACK_ROUTE_PATTERN,fetch:r===`attempt`?handleConnectionCallbackRequest:handleLegacyConnectionCallbackRequest,logicalPath:`framework://channels/${i}`,sourceId:`eve:framework:connection-callback-${r}-${n.toLowerCase()}`,sourceKind:`module`}}function channelNameForMethod(e,t){let n=e.toLowerCase();return t===`attempt`?`${HTTP_CONNECTION_CALLBACK_CHANNEL_NAME_PREFIX}/${n}`:`${HTTP_CONNECTION_CALLBACK_CHANNEL_NAME_PREFIX}/legacy/${n}`}async function handleConnectionCallbackRequest(e,t){return handleCallbackRequest(e,t,!1)}async function handleLegacyConnectionCallbackRequest(e,t){return handleCallbackRequest(e,t,!0)}async function handleCallbackRequest(e,t,i){let a=t.params.name,o=t.params.attemptId,s=t.params.token;if(typeof a!=`string`||a.length===0)return Response.json({error:`Missing connection name.`,ok:!1},{status:400});if(typeof s!=`string`||s.length===0)return Response.json({error:`Missing callback token.`,ok:!1},{status:400});if(!i&&(typeof o!=`string`||o.length===0))return Response.json({error:`Missing authorization attempt ID.`,ok:!1},{status:400});let c=await projectAuthorizationCallback(e);try{await resumeHook(s,{kind:`deliver`,payloads:[{authorizationCallback:i?{callback:c,connectionName:a,legacy:!0}:{attemptId:o,callback:c,connectionName:a}}]})}catch{return Response.json({error:`Connection callback not pending.`,ok:!1},{status:404})}return buildAuthorizationCompletePage()}async function projectAuthorizationCallback(e){let t={};for(let[n,r]of new URL(e.url).searchParams)t[n]=r;let n;if(e.method!==`GET`&&e.method!==`HEAD`){try{n=await e.text()}catch{n=void 0}let r=e.headers.get(`content-type`)??``;if(n&&r.includes(`application/x-www-form-urlencoded`))for(let[e,r]of new URLSearchParams(n))t[e]=r}return n===void 0?{params:t,method:e.method}:{params:t,method:e.method,body:n}}export{HTTP_CONNECTION_CALLBACK_CHANNEL_NAME_PREFIX,getConnectionCallbackChannelDefinitions,getConnectionCallbackChannelNames,handleConnectionCallbackRequest};

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

@@ -1,6 +0,0 @@
-import type { ResolvedChannelDefinition } from "#runtime/types.js";
-/**
- * Framework default for the eve channel.
- */
-export declare function getFrameworkChannelDefinitions(): readonly ResolvedChannelDefinition[];
-export declare function getAllFrameworkChannelNames(): ReadonlySet<string>;

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

@@ -1 +0,0 @@
-import{localDev,placeholderAuth,vercelOidc}from"#public/channels/auth.js";import{isHttpRouteDefinition}from"#channel/routes.js";import{eveChannel}from"#public/channels/eve.js";import{getConnectionCallbackChannelDefinitions,getConnectionCallbackChannelNames}from"#runtime/connections/callback-route.js";import{getSessionCallbackChannelDefinitions,getSessionCallbackChannelNames}from"#runtime/session-callback-route.js";import{getTaskInputResponseChannelDefinitions,getTaskInputResponseChannelNames}from"#runtime/task-input-response-route.js";function getFrameworkChannelDefinitions(){let r=eveChannel({auth:[vercelOidc(),localDev(),placeholderAuth()]}),i=[];for(let e of r.routes)isHttpRouteDefinition(e)&&i.push({name:`eve`,method:e.method.toUpperCase(),urlPath:e.path,cors:r.cors,fetch:async(t,n)=>e.handler(t,n),handler:e.handler,adapter:r.adapter,turnPolicy:r.turnPolicy,logicalPath:`framework://channels/${e.path}`,sourceId:`eve:framework:${e.method.toLowerCase()}-${e.path}`,sourceKind:`module`});return i.push(...getConnectionCallbackChannelDefinitions(),...getSessionCallbackChannelDefinitions(),...getTaskInputResponseChannelDefinitions()),i}function getAllFrameworkChannelNames(){return new Set([`eve`,...getConnectionCallbackChannelNames(),...getSessionCallbackChannelNames(),...getTaskInputResponseChannelNames()])}export{getAllFrameworkChannelNames,getFrameworkChannelDefinitions};

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

@@ -1,29 +0,0 @@
-import type { ResolvedToolDefinition } from "#runtime/types.js";
-/**
- * Stable model-visible name for the root-only agent delegation tool.
- */
-export declare const AGENT_TOOL_NAME = "agent";
-/**
- * Model-facing instructions for the root-only agent delegation tool.
- */
-export declare const AGENT_TOOL_DESCRIPTION: string;
-/**
- * Whether one node receives the implicit built-in `agent` tool.
- *
- * Single source of truth for the injection predicate: node-step uses it to
- * decide whether to add the tool, and prompt bootstrap uses it to decide
- * whether agent-messaging instructions may reference the tool. The
- * `hasAuthoredAgentTool` leg matters because an authored tool named "agent"
- * shadows the framework tool — instructions must not advertise a tool the
- * model cannot call.
- */
-export declare function isImplicitAgentToolAvailable(input: {
-    readonly disabledFrameworkTools: readonly string[];
-    readonly hasAuthoredAgentTool: boolean;
-    /** Undefined when the caller prepares a turn without a graph node (never root). */
-    readonly nodeId: string | undefined;
-}): boolean;
-/**
- * Shared metadata for the root-only agent delegation tool.
- */
-export declare const AGENT_TOOL_DEFINITION: ResolvedToolDefinition;

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

@@ -1 +0,0 @@
-import{SUBAGENT_TOOL_INPUT_SCHEMA}from"#runtime/subagents/registry.js";import{ROOT_RUNTIME_AGENT_NODE_ID}from"#runtime/graph.js";const AGENT_TOOL_NAME=`agent`,AGENT_TOOL_DESCRIPTION=[`Delegate a focused subtask to a fresh copy of yourself.`,`Use it to isolate complex work or split a large task into independent pieces.`,"Issue multiple `agent` calls in one response to run a small fixed set in parallel.","Each child has fresh history and state but shares your tools and sandbox, so include essential context in `message` and give parallel writers non-overlapping scopes."].join(` `);function isImplicitAgentToolAvailable(e){return e.nodeId===ROOT_RUNTIME_AGENT_NODE_ID&&!e.disabledFrameworkTools.includes(`agent`)&&!e.hasAuthoredAgentTool}const AGENT_TOOL_DEFINITION={description:AGENT_TOOL_DESCRIPTION,inputSchema:SUBAGENT_TOOL_INPUT_SCHEMA,logicalPath:`eve:framework/agent`,name:AGENT_TOOL_NAME,sourceId:`eve:agent-tool`,sourceKind:`module`};export{AGENT_TOOL_DEFINITION,AGENT_TOOL_DESCRIPTION,AGENT_TOOL_NAME,isImplicitAgentToolAvailable};

package/dist/src/runtime/framework-tools/ask-question.d.ts

@@ -1,35 +0,0 @@
-import { z } from "#compiled/zod/index.js";
-import type { ResolvedToolDefinition } from "#runtime/types.js";
-/**
- * Stable model-visible name for the framework question tool.
- */
-export declare const ASK_QUESTION_TOOL_NAME = "ask_question";
-export declare const ASK_QUESTION_INPUT_SCHEMA: z.ZodObject<{
-    allowFreeform: z.ZodOptional<z.ZodBoolean>;
-    options: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        description: z.ZodOptional<z.ZodString>;
-        id: z.ZodString;
-        label: z.ZodString;
-        style: z.ZodOptional<z.ZodEnum<{
-            danger: "danger";
-            default: "default";
-            primary: "primary";
-        }>>;
-    }, z.core.$strict>>>;
-    prompt: z.ZodString;
-}, z.core.$strict>;
-export declare const ASK_QUESTION_OUTPUT_SCHEMA: z.ZodObject<{
-    optionId: z.ZodOptional<z.ZodString>;
-    status: z.ZodEnum<{
-        answered: "answered";
-        ignored: "ignored";
-    }>;
-    text: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>;
-/**
- * Root-only framework tool that lets the agent request structured user input.
- *
- * This is a client-side tool (as indicated by it not having an `execute` method). It requires user input
- * and therefore cannot be autonomously executed by the runtime.
- */
-export declare const ASK_QUESTION_TOOL_DEFINITION: ResolvedToolDefinition;

package/dist/src/runtime/framework-tools/ask-question.js

@@ -1 +0,0 @@
-import{inputRequestSchema}from"#runtime/input/types.js";import{z}from"#compiled/zod/index.js";const ASK_QUESTION_TOOL_NAME=`ask_question`,ASK_QUESTION_INPUT_SCHEMA=inputRequestSchema.omit({action:!0,display:!0,kind:!0,requestId:!0}),ASK_QUESTION_OUTPUT_SCHEMA=z.object({optionId:z.string().optional(),status:z.enum([`answered`,`ignored`]),text:z.string().optional()}).strict(),ASK_QUESTION_TOOL_DEFINITION={description:`Ask the user a question and wait for their response before continuing. Use this when you need clarification or a choice from the user.`,inputSchema:ASK_QUESTION_INPUT_SCHEMA,logicalPath:`eve:framework/ask-question`,name:ASK_QUESTION_TOOL_NAME,outputSchema:ASK_QUESTION_OUTPUT_SCHEMA,sourceId:`eve:ask-question-tool`,sourceKind:`module`};export{ASK_QUESTION_INPUT_SCHEMA,ASK_QUESTION_OUTPUT_SCHEMA,ASK_QUESTION_TOOL_DEFINITION,ASK_QUESTION_TOOL_NAME};

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

@@ -1,24 +0,0 @@
-import { z } from "#compiled/zod/index.js";
-import type { ResolvedToolDefinition } from "#runtime/types.js";
-/**
- * Shared input schema used by the framework `bash` tool and any author tool
- * constructed via {@link defineBashTool}.
- *
- * Exported so the public `defineBashTool` factory and the framework
- * `BASH_TOOL_DEFINITION` use the exact same schema object — keeping model
- * input contracts in sync without duplication.
- */
-export declare const BASH_INPUT_SCHEMA: z.ZodObject<{
-    command: z.ZodString;
-}, z.core.$strict>;
-/**
- * Shared output schema used by the framework `bash` tool and any author tool
- * constructed via {@link defineBashTool}.
- */
-export declare const BASH_OUTPUT_SCHEMA: z.ZodObject<{
-    exitCode: z.ZodNumber;
-    stderr: z.ZodString;
-    stdout: z.ZodString;
-    truncated: z.ZodBoolean;
-}, z.core.$strict>;
-export declare const BASH_TOOL_DEFINITION: ResolvedToolDefinition;

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

@@ -1 +0,0 @@
-import{z}from"#compiled/zod/index.js";import{requireSandboxSession}from"#execution/sandbox/require-sandbox.js";import{executeBashOnSandbox}from"#execution/sandbox/bash-tool.js";const BASH_INPUT_SCHEMA=z.strictObject({command:z.string().describe(`The shell command to execute.`)}),BASH_OUTPUT_SCHEMA=z.strictObject({exitCode:z.number(),stderr:z.string(),stdout:z.string(),truncated:z.boolean()});async function executeBash(e,t){return executeBashOnSandbox(await requireSandboxSession(t?.abortSignal),e)}const BASH_TOOL_DEFINITION={description:`Execute a shell command in the shared workspace environment.`,execute:executeBash,inputSchema:BASH_INPUT_SCHEMA,logicalPath:`eve:framework/bash`,name:`bash`,outputSchema:BASH_OUTPUT_SCHEMA,sourceId:`eve:bash-tool`,sourceKind:`module`};export{BASH_INPUT_SCHEMA,BASH_OUTPUT_SCHEMA,BASH_TOOL_DEFINITION};

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

@@ -1,19 +0,0 @@
-import type { ModelMessage } from "ai";
-interface ConnectionSearchResultItem {
-    readonly connection: string;
-    readonly description: string;
-    readonly error?: string;
-    readonly inputSchema?: Record<string, unknown>;
-    readonly needsAuthorization?: boolean;
-    readonly outputSchema?: Record<string, unknown>;
-    readonly tool?: string;
-    readonly qualifiedName?: string;
-}
-/**
- * Extracts connection search results from conversation history.
- * Scans tool-result messages for `connection_search` results and
- * returns deduplicated tool metadata (latest result wins per qualifiedName).
- */
-export declare function extractDiscoveredTools(messages: readonly ModelMessage[]): ConnectionSearchResultItem[];
-declare const connectionSearchDynamicDefinition: import("../../index.ts").DynamicSentinel<Record<string, object> | null>;
-export default connectionSearchDynamicDefinition;

package/dist/src/runtime/framework-tools/connection-search-dynamic.js

@@ -1,2 +0,0 @@
-import{createLogger}from"#internal/logging.js";import{z}from"#compiled/zod/index.js";import{toError}from"#shared/errors.js";import{loadContext}from"#context/container.js";import{stampDurableDynamicToolCallbacks}from"#shared/durable-dynamic-tool-callbacks.js";import{ContextKey}from"#context/key.js";import{ConnectionRegistryKey}from"#context/providers/connection-key.js";import{consumeAuthorizationResult,createAuthorizationAttempt,requestAuthorization}from"#harness/authorization.js";import{ConnectionAuthorizationFailedError,isConnectionAuthorizationFailedError,isConnectionAuthorizationRequiredError}from"#public/connections/errors.js";import{supportsInteractiveAuthorization}from"#runtime/connections/types.js";import{resolveAuthorizationCallbackUrl,stampChallengeDisplayName}from"#runtime/connections/scoped-authorization.js";import{resolveApprovalPolicy}from"#public/definitions/approval.js";import{defineDynamic,defineTool}from"#public/definitions/tool.js";import{resolveConnectionAuthorization}from"#runtime/connections/resolve-authorization.js";import{writeCachedToken}from"#runtime/connections/authorization-tokens.js";import{principalKey,resolveConnectionPrincipal}from"#runtime/connections/principal.js";const logger=createLogger(`framework.connection-search-dynamic`),CONNECTION_SEARCH_INPUT_SCHEMA=z.strictObject({connection:z.string().describe(`Optional: limit search to a specific connection name.`).optional(),keywords:z.string().describe(`Search keywords and expanded aliases. Distill intent into keywords; avoid stop words like 'a', 'the', 'in'.`),limit:z.number().describe(`Max results to return. Default 10.`).optional()}),connectionSchema=z.looseObject({}),CONNECTION_SEARCH_RESULT_ITEM_SCHEMA=z.strictObject({connection:z.string(),description:z.string(),error:z.string().optional(),inputSchema:connectionSchema.optional(),needsAuthorization:z.boolean().optional(),outputSchema:connectionSchema.optional(),qualifiedName:z.string().optional(),tool:z.string().optional()}),CONNECTION_SEARCH_OUTPUT_SCHEMA=z.array(CONNECTION_SEARCH_RESULT_ITEM_SCHEMA),ConnectionSearchResultsKey=new ContextKey(`eve.connectionSearchResults`);function qualifiedConnectionToolName(e,t){return`${e}__${t}`}function tokenize(e){return e.toLowerCase().split(/[\s_\-./]+/).filter(e=>e.length>1)}function scoreMatch(e,t){let n=tokenize(t.name),r=tokenize(t.description),i=0;for(let t of e){for(let e of n)(e.includes(t)||t.includes(e))&&(i+=3);for(let e of r)(e.includes(t)||t.includes(e))&&(i+=1)}return i}async function resolveInteractiveAuth(e,t){let n=e.getConnections().find(e=>e.connectionName===t);if(n===void 0)return;let r=await resolveConnectionAuthorization(n);if(supportsInteractiveAuthorization(r))return r}async function completePendingAuthorizations(e,t){let n=loadContext(),i=new Set;for(let r of t){let t=consumeAuthorizationResult(r.connectionName);if(!t)continue;let a=await resolveInteractiveAuth(e,r.connectionName);if(!a)continue;let o=t.principal??resolveConnectionPrincipal(r.connectionName,a),c=await a.completeAuthorization({callbackUrl:t.hookUrl,connection:{url:r.url??``},principal:o,resume:t.resume,callback:t.callback});writeCachedToken(n,r.connectionName,principalKey(o),c),i.add(r.connectionName)}return i}async function executeConnectionSearch(e){let t=loadContext(),i=t.get(ConnectionRegistryKey);if(i===void 0)return[];let a=e.limit??10,s=tokenize(e.keywords),u=[],p=[],m=e.connection!==void 0&&e.connection!==``?i.getConnections().filter(t=>t.connectionName===e.connection):i.getConnections();if(e.connection&&m.length===0)throw Error(`Connection "${e.connection}" is not registered. Available connections: ${i.getConnectionNames().join(`, `)}.`);let h=await completePendingAuthorizations(i,m),g=[];for(let e of m){let t;try{t=await i.getClient(e.connectionName).getToolMetadata()}catch(t){if(isConnectionAuthorizationRequiredError(t)){if(h.has(e.connectionName)){logger.warn(`connection still unauthorized after authorization`,{connection:e.connectionName}),p.push({connection:e.connectionName,description:e.description,error:`Authorization for "${e.connectionName}" did not take effect; the token was rejected after sign-in.`});continue}let t=await resolveInteractiveAuth(i,e.connectionName);if(t){let r=createAuthorizationAttempt(e.connectionName);if(r){let i=resolveConnectionPrincipal(e.connectionName,t),a=resolveAuthorizationCallbackUrl({authorization:t,callbackUrl:r.hookUrl});try{let{challenge:n,resume:o}=await t.startAuthorization({callbackUrl:a,connection:{url:e.url??``},principal:i});g.push({attemptId:r.attemptId,name:e.connectionName,challenge:stampChallengeDisplayName(n,t),hookUrl:a,principal:i,resume:o})}catch(t){let r=toError(t);logger.warn(`startAuthorization failed`,{connection:e.connectionName,error:r}),p.push({connection:e.connectionName,description:e.description,error:`Failed to start authorization for "${e.connectionName}": ${r.message}`});continue}}}p.push({connection:e.connectionName,description:e.description,needsAuthorization:!0});continue}if(isConnectionAuthorizationFailedError(t)){logger.warn(`connection authorization failed`,{connection:e.connectionName,reason:t.reason,retryable:t.retryable,error:t}),p.push({connection:e.connectionName,description:e.description,error:`Authorization failed for ${e.connectionName}: ${t.message}`});continue}let r=toError(t);logger.warn(`failed to load connection tools`,{connection:e.connectionName,error:r}),p.push({connection:e.connectionName,description:e.description,error:`Failed to load tools for "${e.connectionName}": ${r.message}`});continue}for(let n of t){let t=scoreMatch(s,n);t>0&&u.push({item:{connection:e.connectionName,description:n.description,inputSchema:n.inputSchema,outputSchema:n.outputSchema,qualifiedName:qualifiedConnectionToolName(e.connectionName,n.name),tool:n.name},score:t})}}if(g.length>0)return requestAuthorization(g);let _=p.filter(e=>e.error!==void 0);if(m.length>0&&_.length===m.length)throw Error(_.map(e=>e.error).join(`
-`));u.sort((e,t)=>t.score-e.score);let v=u.slice(0,a).map(e=>e.item);if(v.length>0){let e=[...v,...p],n=t.get(ConnectionSearchResultsKey)??[],r=new Map(n.map(e=>[e.qualifiedName,e]));for(let e of v)e.qualifiedName&&r.set(e.qualifiedName,e);return t.set(ConnectionSearchResultsKey,[...r.values()]),e}return m.map(e=>p.find(t=>t.connection===e.connectionName)||{connection:e.connectionName,description:e.description})}function extractDiscoveredTools(e){let t=new Map;for(let n of e){if(n.role!==`tool`)continue;let e=n.content;for(let n of e){if(n.type!==`tool-result`||n.toolName!==`connection_search`)continue;let e=n.output;if(e==null)continue;let r=typeof e==`object`&&`type`in e&&`value`in e?e.value:e;if(Array.isArray(r))for(let e of r)e.tool&&e.qualifiedName&&t.set(e.qualifiedName,e)}}return[...t.values()]}function readDiscoveredToolClosure(e){let t=e.connectionName,n=e.toolName;if(typeof t!=`string`||typeof n!=`string`)throw Error(`Discovered connection tool callback metadata is invalid.`);return{connectionName:t,toolName:n}}async function executeDiscoveredConnectionTool(e,t,n){let{connectionName:i,toolName:a}=readDiscoveredToolClosure(e),d=loadContext().get(ConnectionRegistryKey);if(d===void 0)throw Error(`Connection registry is unavailable while replaying a discovered tool.`);let p=d.getConnections().find(e=>e.connectionName===i),m=await resolveInteractiveAuth(d,i),h=!1;if(m){let e=consumeAuthorizationResult(i);if(e){h=!0;let t=loadContext(),n=e.principal??resolveConnectionPrincipal(i,m),a=await m.completeAuthorization({callbackUrl:e.hookUrl,connection:{url:p?.url??``},principal:n,resume:e.resume,callback:e.callback});writeCachedToken(t,i,principalKey(n),a)}}try{return await d.getClient(i).executeTool(a,t,{abortSignal:n.abortSignal})}catch(e){if(!isConnectionAuthorizationRequiredError(e)||!m)throw e;if(h)throw new ConnectionAuthorizationFailedError(i,{retryable:!1,reason:`token_rejected_after_authorization`,message:`Connection "${i}" rejected the token immediately after authorization.`});let t=createAuthorizationAttempt(i);if(!t)throw e;let n=resolveConnectionPrincipal(i,m),r=resolveAuthorizationCallbackUrl({authorization:m,callbackUrl:t.hookUrl}),{challenge:a,resume:o}=await m.startAuthorization({callbackUrl:r,connection:{url:p?.url??``},principal:n});return requestAuthorization([{attemptId:t.attemptId,name:i,challenge:stampChallengeDisplayName(a,m),hookUrl:r,principal:n,resume:o}])}}async function requestDiscoveredConnectionToolApproval(e,t){let{connectionName:n}=readDiscoveredToolClosure(e),i=loadContext().get(ConnectionRegistryKey)?.getConnectionApproval(n);return i===void 0?`not-applicable`:await resolveApprovalPolicy(i)(t)}async function authorizeDiscoveredConnectionToolApproval(e,t){let{connectionName:n}=readDiscoveredToolClosure(e),i=loadContext().get(ConnectionRegistryKey)?.getConnectionApproval(n),a=i===void 0||typeof i==`function`?void 0:i.response;return a===void 0?{reason:`Approval response authorization is unavailable.`,status:`rejected`}:await a(t)}const connectionSearchDynamicDefinition=defineDynamic({events:{"step.started":async(e,t)=>{let n=loadContext().get(ConnectionRegistryKey);if(!n||n.getConnections().length===0)return null;let a=n.getConnections().map(e=>e.connectionName),s=extractDiscoveredTools(t.messages),c=loadContext().get(ConnectionSearchResultsKey)??[],l=new Map;for(let e of c)e.qualifiedName&&l.set(e.qualifiedName,e);for(let e of s)e.qualifiedName&&l.set(e.qualifiedName,e);let u=[...l.values()],d={},f=defineTool({description:`Search for tools across your connections. Discovered tools become directly callable by their qualified name (e.g. \`linear__list_issues\`) in your next response. Available connections: ${a.join(`, `)}.`,inputSchema:CONNECTION_SEARCH_INPUT_SCHEMA,async execute(e){return executeConnectionSearch(e)},outputSchema:CONNECTION_SEARCH_OUTPUT_SCHEMA});stampDurableDynamicToolCallbacks(f,{execute:{callback:(e,t)=>executeConnectionSearch(t),closure:{}}}),d.connection_search=f;for(let e of u){let t=e.connection,r=e.tool,a=n.getConnectionApproval(t),o={connectionName:t,toolName:r},s=defineTool({description:e.description,inputSchema:e.inputSchema??{type:`object`},approval:a,outputSchema:e.outputSchema,async execute(e,t){return await executeDiscoveredConnectionTool(o,e,t)}});stampDurableDynamicToolCallbacks(s,{execute:{callback:executeDiscoveredConnectionTool,closure:o},...a===void 0?{}:{approvalRequest:{callback:requestDiscoveredConnectionToolApproval,closure:o}},...a===void 0||typeof a==`function`||a.response===void 0?{}:{approvalResponse:{callback:authorizeDiscoveredConnectionToolApproval,closure:o}}}),d[qualifiedConnectionToolName(t,r)]=s}return d}}});export{connectionSearchDynamicDefinition as default,extractDiscoveredTools};

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

@@ -1 +0,0 @@
-import{toInputSchema}from"#shared/tool-schema.js";const FINAL_OUTPUT_TOOL_NAME=`final_output`;function buildFinalOutputTool(e){let t=toInputSchema(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:t,outputSchema:t}}export{FINAL_OUTPUT_TOOL_NAME,buildFinalOutputTool};

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

@@ -1,26 +0,0 @@
-import { z } from "#compiled/zod/index.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: z.ZodObject<{
-    limit: z.ZodOptional<z.ZodNumber>;
-    path: z.ZodOptional<z.ZodString>;
-    pattern: z.ZodString;
-}, z.core.$strict>;
-/**
- * Shared output schema used by the framework `glob` tool and any author tool
- * constructed via {@link defineGlobTool}.
- */
-export declare const GLOB_OUTPUT_SCHEMA: z.ZodObject<{
-    content: z.ZodString;
-    count: z.ZodNumber;
-    path: z.ZodString;
-    truncated: z.ZodBoolean;
-}, z.core.$strict>;
-export declare const GLOB_TOOL_DEFINITION: ResolvedToolDefinition;

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

@@ -1,2 +0,0 @@
-import{z}from"#compiled/zod/index.js";import{requireSandboxSession}from"#execution/sandbox/require-sandbox.js";import{executeGlobOnSandbox}from"#execution/sandbox/glob-tool.js";const GLOB_INPUT_SCHEMA=z.strictObject({limit:z.number().int().min(1).max(1e3).describe(`Maximum number of results to return. Defaults to 100.`).optional(),path:z.string().describe(`The directory to search in. Defaults to /workspace. Must be an absolute path or begin with $HOME/. Omit to use the default.`).optional(),pattern:z.string().describe(`The glob pattern to match files against (e.g. "**/*.ts", "src/**/*.js").`)}),GLOB_OUTPUT_SCHEMA=z.strictObject({content:z.string(),count:z.number().int(),path:z.string(),truncated:z.boolean()});async function executeGlob(e,t){return executeGlobOnSandbox(await requireSandboxSession(t?.abortSignal),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.`,`- 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.js

@@ -1,2 +0,0 @@
-import{z}from"#compiled/zod/index.js";import{requireSandboxSession}from"#execution/sandbox/require-sandbox.js";import{executeGrepOnSandbox}from"#execution/sandbox/grep-tool.js";const GREP_INPUT_SCHEMA=z.strictObject({context:z.number().int().min(0).describe(`Number of surrounding context lines to include before and after each match. Defaults to 0.`).optional(),glob:z.string().describe(`Filter files by glob pattern (e.g. "*.ts", "*.{ts,tsx}").`).optional(),ignoreCase:z.boolean().describe(`Perform case-insensitive search. Defaults to false.`).optional(),limit:z.number().int().min(1).max(1e3).describe(`Maximum number of matches to return per file. Defaults to 100.`).optional(),literal:z.boolean().describe(`Treat the pattern as a literal string instead of a regular expression. Defaults to false.`).optional(),path:z.string().describe(`The directory or file to search in. Defaults to /workspace. Must be an absolute path or begin with $HOME/. Omit to use the default.`).optional(),pattern:z.string().describe(`The regex pattern to search for in file contents (e.g. "log.*Error", "function\\s+\\w+").`)}),GREP_OUTPUT_SCHEMA=z.strictObject({content:z.string(),matchCount:z.number().int(),path:z.string(),truncated:z.boolean()});async function executeGrep(e,t){return executeGrepOnSandbox(await requireSandboxSession(t?.abortSignal),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.`,`- 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

@@ -1,39 +0,0 @@
-export { ConnectionRegistryKey } from "#context/providers/connection-key.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 { ResolvedDynamicToolResolver, ResolvedSkillDefinition, 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. The graph resolution path
- * registers it as a framework dynamic tool resolver.
- */
-export declare function getFrameworkToolDefinitions(config?: {
-    readonly authoredSkills?: readonly ResolvedSkillDefinition[];
-}): readonly ResolvedToolDefinition[];
-/**
- * Returns framework-owned dynamic tool resolvers.
- * Framework definitions use the public `defineDynamic()` contract and enter
- * the same loaded-definition resolver path as authored dynamic tools.
- */
-export declare function getFrameworkDynamicToolResolvers(): readonly ResolvedDynamicToolResolver[];
-/**
- * Returns every static framework-owned tool definition, including tools such
- * as `agent` that the runtime does not register in the tool registry.
- */
-export declare function getAllFrameworkToolDefinitions(): readonly ResolvedToolDefinition[];
-/** Returns framework tools that authors must explicitly add to an agent. */
-export declare function getOptInFrameworkToolNames(): ReadonlySet<string>;
-/**
- * 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

@@ -1 +0,0 @@
-import{ConnectionRegistryKey}from"#context/providers/connection-key.js";import{ReadFileStateKey}from"#runtime/framework-tools/file-state.js";import{TODO_TOOL_DEFINITION,TodoStateKey}from"#runtime/framework-tools/todo.js";import{TASK_TOOL_DEFINITIONS}from"#runtime/framework-tools/tasks.js";import{AGENT_TOOL_DEFINITION}from"#runtime/framework-tools/agent.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,createSkillToolDefinition}from"#runtime/framework-tools/skill.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";import connectionSearchDynamicDefinition from"#runtime/framework-tools/connection-search-dynamic.js";import{resolveLoadedDynamicToolDefinition}from"#runtime/resolve-dynamic-tool.js";const REGISTERED_FRAMEWORK_DYNAMIC_TOOLS=[{definition:connectionSearchDynamicDefinition,logicalPath:`eve:framework/connection-search-dynamic`,slug:`connection`,sourceId:`eve:connection-search-dynamic`}],REGISTERED_FRAMEWORK_TOOLS=[ASK_QUESTION_TOOL_DEFINITION,BASH_TOOL_DEFINITION,READ_FILE_TOOL_DEFINITION,WRITE_FILE_TOOL_DEFINITION,TODO_TOOL_DEFINITION,WEB_FETCH_TOOL_DEFINITION,WEB_SEARCH_TOOL_DEFINITION,SKILL_TOOL_DEFINITION],OPT_IN_FRAMEWORK_TOOLS=[GLOB_TOOL_DEFINITION,GREP_TOOL_DEFINITION],ALL_FRAMEWORK_TOOLS=[...REGISTERED_FRAMEWORK_TOOLS,...OPT_IN_FRAMEWORK_TOOLS,AGENT_TOOL_DEFINITION,...TASK_TOOL_DEFINITIONS];function getFrameworkToolDefinitions(e){let t=e?.authoredSkills;return t===void 0?REGISTERED_FRAMEWORK_TOOLS:REGISTERED_FRAMEWORK_TOOLS.map(e=>e.name===SKILL_TOOL_DEFINITION.name?createSkillToolDefinition(t):e)}function getFrameworkDynamicToolResolvers(){return REGISTERED_FRAMEWORK_DYNAMIC_TOOLS.map(e=>resolveLoadedDynamicToolDefinition(e.definition,{logicalPath:e.logicalPath,slug:e.slug,sourceId:e.sourceId,sourceKind:`module`}))}function getAllFrameworkToolDefinitions(){return ALL_FRAMEWORK_TOOLS}function getOptInFrameworkToolNames(){return new Set(OPT_IN_FRAMEWORK_TOOLS.map(e=>e.name))}function getAllFrameworkToolNames(){return new Set(ALL_FRAMEWORK_TOOLS.map(e=>e.name))}export{ConnectionRegistryKey,ReadFileStateKey,TodoStateKey,getAllFrameworkToolDefinitions,getAllFrameworkToolNames,getFrameworkDynamicToolResolvers,getFrameworkToolDefinitions,getOptInFrameworkToolNames};

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

@@ -1,27 +0,0 @@
-import { z } from "#compiled/zod/index.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: z.ZodObject<{
-    filePath: z.ZodString;
-    limit: z.ZodOptional<z.ZodNumber>;
-    offset: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strict>;
-/**
- * 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: z.ZodObject<{
-    content: z.ZodString;
-    nextOffset: z.ZodOptional<z.ZodNumber>;
-    path: z.ZodString;
-    totalLines: z.ZodNumber;
-    truncated: z.ZodBoolean;
-}, z.core.$strict>;
-export declare const READ_FILE_TOOL_DEFINITION: ResolvedToolDefinition;

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

@@ -1,2 +0,0 @@
-import{z}from"#compiled/zod/index.js";import{requireSandboxSession}from"#execution/sandbox/require-sandbox.js";import{executeReadFileOnSandbox}from"#execution/sandbox/read-file-tool.js";const READ_FILE_INPUT_SCHEMA=z.strictObject({filePath:z.string().describe(`The absolute path to the file to read. A leading $HOME is supported.`),limit:z.number().int().min(1).describe(`Maximum number of lines to return. Defaults to 2000.`).optional(),offset:z.number().int().min(1).describe(`1-based line number to start from. Defaults to 1.`).optional()}),READ_FILE_OUTPUT_SCHEMA=z.strictObject({content:z.string(),nextOffset:z.number().int().min(1).optional(),path:z.string(),totalLines:z.number().int().min(0),truncated:z.boolean()});async function executeReadFile(e,t){return executeReadFileOnSandbox(await requireSandboxSession(t?.abortSignal),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 or begin with $HOME/.`,`- By default, this tool returns up to 2000 lines from the start of the file.`,`- The offset parameter is the line number to start from (1-indexed).`,`- To read later sections, call this tool again with a larger offset.`,'- Contents are returned with each line prefixed by its line number as `<line>: <content>`. For example, if a file has contents "foo\\n", you will receive "1: foo\\n".',`- Any line longer than 2000 characters is truncated.`,`- Call this tool in parallel when you know there are multiple files you want to read.`,`- Avoid tiny repeated slices (30 line chunks). If you need more context, read a larger window.`].join(`
-`),execute:executeReadFile,inputSchema:READ_FILE_INPUT_SCHEMA,logicalPath:`eve:framework/read-file`,name:`read_file`,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

@@ -1,12 +0,0 @@
-import { z } from "#compiled/zod/index.js";
-import type { ResolvedSkillDefinition, ResolvedToolDefinition } from "#runtime/types.js";
-export declare const SKILL_INPUT_SCHEMA: z.ZodObject<{
-    skill: z.ZodString;
-}, z.core.$strict>;
-export declare const SKILL_OUTPUT_SCHEMA: z.ZodString;
-/**
- * Creates a node-specific `load_skill` definition with authored skills bound
- * into its executor.
- */
-export declare function createSkillToolDefinition(authoredSkills: readonly ResolvedSkillDefinition[]): ResolvedToolDefinition;
-export declare const SKILL_TOOL_DEFINITION: ResolvedToolDefinition;

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

@@ -1 +0,0 @@
-import{z}from"#compiled/zod/index.js";import{DynamicSkillManifestKey,SandboxKey}from"#context/keys.js";import{loadContext}from"#context/container.js";import{loadSkillFromSandbox}from"#runtime/skills/sandbox-access.js";import{ConnectionRegistryKey}from"#context/providers/connection-key.js";async function executeLoadSkillTool(e,t){let r=loadContext(),{skill:i}=e,a=availableDynamicSkillNames(r),o=[...new Set([...t.map(e=>e.name),...a])].sort();try{if(a.includes(i)){let e=r.get(SandboxKey);if(e===void 0)throw Error(`The dynamic skill "${i}" requires sandbox access on the runtime context.`);return await loadSkillFromSandbox(e,i,o)}let e=t.find(e=>e.name===i);if(e!==void 0)return e.markdown;throw Error(formatSkillNotFoundError(i,o))}catch(e){let t=r.get(ConnectionRegistryKey)?.getConnectionNames().find(e=>e.toLowerCase()===i.toLowerCase());if(t===void 0||o.includes(i))throw e;let n=e instanceof Error?e.message:String(e);throw Error(`${n} "${t}" is an installed connection, not a skill. Use connection_search with connection "${t}" to find its tools.`,{cause:e})}}function availableDynamicSkillNames(e){let n=Object.values(e.get(DynamicSkillManifestKey)??{}).flat().map(e=>e.name);return[...new Set(n)].sort()}function formatSkillNotFoundError(e,t){return`No skill named "${e}".${t.length>0?` Available skills: ${t.join(`, `)}.`:``}`}const SKILL_INPUT_SCHEMA=z.strictObject({skill:z.string().describe(`Available skill name or id.`)}),SKILL_OUTPUT_SCHEMA=z.string(),SKILL_TOOL_METADATA={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(` `),inputSchema:SKILL_INPUT_SCHEMA,logicalPath:`eve:framework/load-skill`,name:`load_skill`,outputSchema:SKILL_OUTPUT_SCHEMA,sourceId:`eve:load-skill-tool`,sourceKind:`module`};function createSkillToolDefinition(e){return{...SKILL_TOOL_METADATA,execute:t=>executeLoadSkillTool(t,e)}}const SKILL_TOOL_DEFINITION=createSkillToolDefinition([]);export{SKILL_INPUT_SCHEMA,SKILL_OUTPUT_SCHEMA,SKILL_TOOL_DEFINITION,createSkillToolDefinition};

package/dist/src/runtime/framework-tools/subagent/local.js

@@ -1 +0,0 @@
-import{createLogger,logError}from"#internal/logging.js";import{HandleEventKey}from"#context/keys.js";import{createSubagentCalledEvent}from"#protocol/message.js";import{parseJsonObject}from"#shared/json.js";import{loadContext}from"#context/container.js";import{PERSISTENT_SUBAGENT_TOOL_INPUT_SCHEMA}from"#runtime/subagents/registry.js";import{getHarnessEmissionState}from"#harness/emission.js";import{workflowEntryReference}from"#execution/workflow-runtime.js";import{serializeContext}from"#context/serialize.js";import{createDurableSessionState}from"#execution/durable-session-store.js";import{SUBAGENT_TASK_RECEIPT_OUTPUT_SCHEMA}from"#runtime/framework-tools/tasks.js";import{dispatchToTaskAgentAddress}from"#execution/agent-handle-dispatch.js";import{createAgentContinuationBundle}from"#execution/agent-continuation-bundle.js";import{prepareAgentActionDispatch,startSubagent}from"#execution/dispatch-runtime-actions-shared.js";import{CallbackBaseUrlKey}from"#harness/authorization.js";import{activeTurnId}from"#harness/active-turn-id.js";import{createSubagentExecutorBinding}from"#tasks/types.js";import{findTaskAgentAddress}from"#execution/tasks/parent/control-shared.js";import{checkTaskContinuationAvailability,createTaskContinuationBusyResult,describeTaskDispatch}from"#execution/tasks/parent/continuation-dispatch.js";import{defineTool}from"#public/definitions/tool.js";const localSubagentExecutors=new WeakSet,batchAgentClaims=new WeakMap,log=createLogger(`runtime.framework-tools.subagent`);function defineSubagent(e){return defineTool({description:e.description,execution:`background`,inputSchema:PERSISTENT_SUBAGENT_TOOL_INPUT_SCHEMA,outputSchema:SUBAGENT_TASK_RECEIPT_OUTPUT_SCHEMA,execute:(t,n,r)=>executeSubagentTool({definition:e,kind:`local`,task:r,toolContext:n,toolInput:t})})}function registerLocalSubagentExecutor(e){localSubagentExecutors.add(e)}function countLocalSubagentCalls(e){return e.filter(e=>localSubagentExecutors.has(e.definition.execute)).length}async function executeSubagentTool(e){let t=loadContext(),{batch:n,session:r,task:o}=e.task,s=getHarnessEmissionState(r.state),c={callId:e.toolContext.callId,description:e.definition.description,input:parseJsonObject(PERSISTENT_SUBAGENT_TOOL_INPUT_SCHEMA.parse(e.toolInput)),name:e.definition.name,nodeId:e.definition.nodeId},l=await dispatchSubagent({action:e.kind===`remote`?{...c,kind:`remote-agent-call`,remoteAgentName:e.definition.name}:{...c,kind:`subagent-call`,subagentName:e.definition.name},batch:n,callbackBaseUrl:t.get(CallbackBaseUrlKey),ctx:t,event:{...s,turnId:activeTurnId(s)},localFanoutSize:countLocalSubagentCalls(n),serializedContext:serializeContext(t),sessionState:createDurableSessionState({session:r}),task:o}),u=findTaskAgentAddress(l.session,l.agentId);if(u===void 0)throw Error(`Subagent dispatch for "${l.agentId}" recorded no task agent address.`);let d=createSubagentExecutorBinding({address:u.address,identity:u.identity});await emitSubagentCalled$1({callId:e.toolContext.callId,childSessionId:l.address.sessionId,event:{...s,turnId:activeTurnId(s)},name:l.name,remote:l.remote,sessionId:r.sessionId,toolName:e.definition.name});let f=e.task.delegated({executor:d,receipt:{agentId:l.agentId}});return await emitSubagentCompleted({callId:e.toolContext.callId,output:JSON.stringify(f.receipt),subagentName:l.name,taskId:f.receipt.taskId}),f}async function dispatchSubagent(e){let t=await prepareAgentActionDispatch({action:e.action,ctx:e.ctx,event:e.event,localFanoutSize:e.localFanoutSize,serializedContext:e.serializedContext,sessionState:e.sessionState}),n=t.plan[0];if(n===void 0||n.kind===`task-control`)throw Error(`Subagent tool dispatch produced no executable plan entry.`);if(n.kind===`reject`)throw Error(JSON.stringify(n.result.output));if(n.kind===`resume`){let r=await checkTaskContinuationAvailability({action:n.action,agentId:n.agentId,parentStepIndex:e.event.stepIndex,parentTurnId:e.event.turnId,session:t.session});if(r!==void 0)throw Error(JSON.stringify(r.output));let i=claimBatchAgent(e.batch,n.agentId,e.task.taskId);if(i!==void 0){let e=createTaskContinuationBusyResult({action:n.action,agentId:n.agentId,status:`working`,taskId:i});throw Error(JSON.stringify(e.output))}}let r=n.kind===`resume`?await dispatchToTaskAgentAddress({action:n.action,agentId:n.agentId,auth:t.auth,bundle:createAgentContinuationBundle({action:n.action,bundle:t.bundle,dynamicRemoteAgent:n.dynamicRemoteAgent}),currentSession:t.session,parentToken:e.task.taskInboxToken}):await startSubagent({auth:t.auth,batchEvent:e.event,bundle:t.bundle,callbackBaseUrl:e.callbackBaseUrl,capabilities:t.capabilities,channelMetadata:t.channelMetadata,currentSession:t.session,fanoutSize:t.fanoutSize,initiatorAuth:t.initiatorAuth,parentContinuationToken:e.task.taskInboxToken,parentTraceContext:t.parentTraceContext,persistentSessions:!0,sandboxSessionId:t.sandboxSessionId,serializedContext:t.serializedContext,session:t.session,taskOwned:!0,target:n.target});if(r.kind===`error`)throw Error(JSON.stringify(r.result.output));let i=describeTaskDispatch({action:e.action,agentId:n.kind===`resume`?n.agentId:void 0,parentSessionId:t.session.sessionId,parentTurnId:e.event.turnId,session:r.session}),a=n.kind===`resume`?n.dynamicRemoteAgent:n.target.kind===`remote`?n.target.dynamicRemoteAgent:void 0;return{address:r.address,agentId:i.agentId,mode:i.mode,name:i.name,...r.address.kind===`agent/remote`?{remote:{resolverId:a?.credentialsStepId??e.action.nodeId,url:r.address.url}}:{},session:r.session}}function claimBatchAgent(e,t,n){let r=batchAgentClaims.get(e);r===void 0&&(r=new Map,batchAgentClaims.set(e,r));let i=r.get(t);if(i!==void 0)return i;r.set(t,n)}async function emitSubagentCalled$1(e){let i=loadContext().get(HandleEventKey);if(i!==void 0)try{await i(createSubagentCalledEvent({callId:e.callId,childSessionId:e.childSessionId,name:e.name,remote:e.remote,sequence:e.event.sequence,sessionId:e.sessionId,toolName:e.toolName,turnId:e.event.turnId,workflowId:workflowEntryReference.workflowId}))}catch(n){logError(log,`subagent.called emission failed`,n,{callId:e.callId,childSessionId:e.childSessionId,toolName:e.toolName})}}async function emitSubagentCompleted(e){let r=loadContext().get(HandleEventKey);if(r!==void 0)try{await r({data:{backgroundTask:{status:`working`,taskId:e.taskId},callId:e.callId,output:e.output,subagentName:e.subagentName},type:`subagent.completed`})}catch(n){logError(log,`subagent.completed emission failed`,n,{callId:e.callId,taskId:e.taskId})}}export{countLocalSubagentCalls,defineSubagent,executeSubagentTool,registerLocalSubagentExecutor};

package/dist/src/runtime/framework-tools/subagent/remote.js

@@ -1 +0,0 @@
-import{PERSISTENT_SUBAGENT_TOOL_INPUT_SCHEMA}from"#runtime/subagents/registry.js";import{SUBAGENT_TASK_RECEIPT_OUTPUT_SCHEMA}from"#runtime/framework-tools/tasks.js";import{executeSubagentTool}from"#runtime/framework-tools/subagent/local.js";import{defineTool}from"#public/definitions/tool.js";function defineRemoteSubagent(r){return defineTool({description:r.description,execution:`background`,inputSchema:PERSISTENT_SUBAGENT_TOOL_INPUT_SCHEMA,outputSchema:SUBAGENT_TASK_RECEIPT_OUTPUT_SCHEMA,execute:(e,t,n)=>executeSubagentTool({definition:r,kind:`remote`,task:n,toolContext:t,toolInput:e})})}export{defineRemoteSubagent};

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

@@ -1,91 +0,0 @@
-import { z } from "#compiled/zod/index.js";
-import type { HarnessToolDefinition } from "#harness/execute-tool.js";
-import type { ResolvedToolDefinition } from "#runtime/types.js";
-/**
- * Framework task tools for `experimental.tasks`.
- *
- * With the flag on, subagent calls return a task receipt instead of
- * blocking the parent turn; these tools coordinate that delegated work.
- * `task_cancel` and `task_update` are execute-less runtime actions —
- * they need durable session state and world access, so the runtime-action
- * dispatch step executes them.
- */
-export declare const TASK_CANCEL_TOOL_NAME = "task_cancel";
-export declare const TASK_UPDATE_TOOL_NAME = "task_update";
-/** Every model-visible task tool name, for gating and dispatch matching. */
-export declare const TASK_TOOL_NAMES: ReadonlySet<string>;
-/** Task-control tools executed by the runtime-action dispatch step. */
-export declare const TASK_CONTROL_TOOL_NAMES: ReadonlySet<string>;
-export declare const TASK_CANCEL_INPUT_SCHEMA: z.ZodObject<{
-    taskIds: z.ZodArray<z.ZodString>;
-}, z.core.$strict>;
-export declare const TASK_UPDATE_INPUT_SCHEMA: z.ZodObject<{
-    message: z.ZodString;
-}, z.core.$strict>;
-export declare const TASK_VIEWS_OUTPUT_SCHEMA: z.ZodObject<{
-    tasks: z.ZodArray<z.ZodObject<{
-        inputRequests: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
-        lastOutput: z.ZodOptional<z.ZodObject<{
-            data: z.ZodUnknown;
-            type: z.ZodEnum<{
-                error: "error";
-                result: "result";
-            }>;
-        }, z.core.$strip>>;
-        metadata: z.ZodUnion<readonly [z.ZodObject<{
-            agentId: z.ZodString;
-            kind: z.ZodLiteral<"subagent">;
-            mode: z.ZodEnum<{
-                local: "local";
-                remote: "remote";
-            }>;
-            name: z.ZodString;
-        }, z.core.$strip>, z.ZodObject<{
-            data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-            kind: z.ZodString;
-            name: z.ZodString;
-        }, z.core.$strip>]>;
-        status: z.ZodEnum<{
-            cancelled: "cancelled";
-            completed: "completed";
-            failed: "failed";
-            input_required: "input_required";
-            working: "working";
-        }>;
-        taskId: z.ZodString;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-export declare const SUBAGENT_TASK_RECEIPT_OUTPUT_SCHEMA: z.ZodObject<{
-    agentId: z.ZodString;
-    status: z.ZodLiteral<"working">;
-    taskId: z.ZodString;
-}, z.core.$strict>;
-/**
- * Builds the harness definitions injected when the root agent enables
- * `experimental.tasks`. Follows the implicit `agent` tool pattern:
- * inline definitions, no registry entry, session-shape hiding in
- * advertised-tools, and re-validation at dispatch.
- */
-export declare function createTaskToolHarnessDefinitions(): readonly HarnessToolDefinition[];
-/**
- * Whether one node's sessions receive the task tools.
- *
- * Mirrors `isImplicitAgentToolAvailable`: the compile step already
- * rejects `experimental.tasks` on subagents, authored tools with the
- * same name shadow the framework tool, and `disableTool(name)` removes
- * individual tools. Root-node self-delegated children share this node's
- * config, so advertised-tools uses caller/session shape to expose only
- * `task_update` to delegated task children.
- */
-export declare function isTaskToolAvailable(input: {
-    readonly disabledFrameworkTools: readonly string[];
-    readonly hasAuthoredTool: boolean;
-    readonly tasksEnabled: boolean;
-    readonly toolName: string;
-}): boolean;
-/**
- * Registry-shaped metadata for the task tools. Not registered in the
- * tool registry (the harness injects the real definitions per node);
- * these entries exist so `disableTool(name)` validates the names.
- */
-export declare const TASK_TOOL_DEFINITIONS: readonly ResolvedToolDefinition[];

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

@@ -1 +0,0 @@
-import{z}from"#compiled/zod/index.js";const TASK_CANCEL_TOOL_NAME=`task_cancel`,TASK_UPDATE_TOOL_NAME=`task_update`,TASK_TOOL_NAMES=new Set([TASK_CANCEL_TOOL_NAME,TASK_UPDATE_TOOL_NAME]),TASK_CONTROL_TOOL_NAMES=new Set([TASK_CANCEL_TOOL_NAME,TASK_UPDATE_TOOL_NAME]),TASK_IDS_SCHEMA=z.array(z.string().min(1)).min(1).describe(`Task ids from earlier subagent task receipts.`),TASK_CANCEL_INPUT_SCHEMA=z.strictObject({taskIds:TASK_IDS_SCHEMA}),TASK_UPDATE_INPUT_SCHEMA=z.strictObject({message:z.string().min(1).describe(`Brief description of what this task is currently doing.`)}),TASK_VIEW_SCHEMA=z.object({inputRequests:z.array(z.unknown()).optional(),lastOutput:z.object({data:z.unknown(),type:z.enum([`result`,`error`])}).optional(),metadata:z.union([z.object({agentId:z.string(),kind:z.literal(`subagent`),mode:z.enum([`local`,`remote`]),name:z.string()}),z.object({data:z.record(z.string(),z.unknown()).optional(),kind:z.string(),name:z.string()})]),status:z.enum([`working`,`input_required`,`completed`,`failed`,`cancelled`]),taskId:z.string()}),TASK_VIEWS_OUTPUT_SCHEMA=z.object({tasks:z.array(TASK_VIEW_SCHEMA)}),SUBAGENT_TASK_RECEIPT_OUTPUT_SCHEMA=z.strictObject({agentId:z.string(),status:z.literal(`working`),taskId:z.string()}),TASK_CANCEL_DESCRIPTION=`Request cooperative cancellation of one or more background tasks. Cancellation is final: a task that finishes after you cancel it stays cancelled. Cancelling an already-finished task changes nothing.`,TASK_UPDATE_DESCRIPTION=`Briefly tell the parent agent what this background task is currently doing. Report activity, not preliminary findings or results.`;function createTaskToolHarnessDefinitions(){return[{description:TASK_CANCEL_DESCRIPTION,inputSchema:TASK_CANCEL_INPUT_SCHEMA,name:TASK_CANCEL_TOOL_NAME,outputSchema:TASK_VIEWS_OUTPUT_SCHEMA,runtimeAction:{kind:`task-control`}},{description:TASK_UPDATE_DESCRIPTION,inputSchema:TASK_UPDATE_INPUT_SCHEMA,name:TASK_UPDATE_TOOL_NAME,runtimeAction:{kind:`task-control`}}]}function isTaskToolAvailable(e){return e.tasksEnabled&&!e.disabledFrameworkTools.includes(e.toolName)&&!e.hasAuthoredTool}function createResolvedTaskToolStub(e){return{description:e.description,inputSchema:null,logicalPath:`eve:framework/${e.name}`,name:e.name,sourceId:`eve:${e.name}-tool`,sourceKind:`module`}}const TASK_TOOL_DEFINITIONS=[createResolvedTaskToolStub({description:TASK_CANCEL_DESCRIPTION,name:TASK_CANCEL_TOOL_NAME}),createResolvedTaskToolStub({description:TASK_UPDATE_DESCRIPTION,name:TASK_UPDATE_TOOL_NAME})];export{SUBAGENT_TASK_RECEIPT_OUTPUT_SCHEMA,TASK_CANCEL_INPUT_SCHEMA,TASK_CANCEL_TOOL_NAME,TASK_CONTROL_TOOL_NAMES,TASK_TOOL_DEFINITIONS,TASK_TOOL_NAMES,TASK_UPDATE_INPUT_SCHEMA,TASK_UPDATE_TOOL_NAME,TASK_VIEWS_OUTPUT_SCHEMA,createTaskToolHarnessDefinitions,isTaskToolAvailable};

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

@@ -1,2 +0,0 @@
-import{z}from"#compiled/zod/index.js";import{executeWebFetchTool}from"#execution/web-fetch/tool.js";async function executeWebFetch(e,t){return executeWebFetchTool(e,{abortSignal:t?.abortSignal})}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()}),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 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.js

@@ -1 +0,0 @@
-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_EXA_OUTPUT_SCHEMA={$schema:`http://json-schema.org/draft-07/schema#`,anyOf:[{properties:{costDollars:{additionalProperties:!1,properties:{search:{additionalProperties:{type:`number`},type:`object`},total:{type:`number`}},type:`object`},requestId:{type:`string`},resolvedSearchType:{type:`string`},results:{items:{properties:{author:{anyOf:[{type:`string`},{type:`null`}]},entities:{items:{properties:{id:{type:`string`},properties:{type:`object`},type:{type:`string`},version:{type:`number`}},required:[`id`,`type`,`version`,`properties`],type:`object`},type:`array`},extras:{additionalProperties:!1,properties:{imageLinks:{items:{type:`string`},type:`array`},links:{items:{type:`string`},type:`array`}},type:`object`},favicon:{anyOf:[{type:`string`},{type:`null`}]},highlightScores:{items:{type:`number`},type:`array`},highlights:{items:{type:`string`},type:`array`},id:{type:`string`},image:{anyOf:[{type:`string`},{type:`null`}]},publishedDate:{anyOf:[{type:`string`},{type:`null`}]},score:{anyOf:[{type:`number`},{type:`null`}]},subpages:{items:{},type:`array`},summary:{type:`string`},text:{type:`string`},title:{anyOf:[{type:`string`},{type:`null`}]},url:{type:`string`}},required:[`url`,`id`],type:`object`},type:`array`},searchTime:{type:`number`},searchType:{type:`string`}},required:[`requestId`,`results`],type:`object`},{additionalProperties:!1,properties:{error:{enum:[`api_error`,`rate_limit`,`timeout`,`invalid_input`,`configuration_error`,`execution_error`,`unknown`],type:`string`},message:{type:`string`},statusCode:{type:`number`}},required:[`error`,`message`],type:`object`}]},WEB_SEARCH_PARALLEL_OUTPUT_SCHEMA={$schema:`http://json-schema.org/draft-07/schema#`,anyOf:[{additionalProperties:!1,properties:{results:{items:{additionalProperties:!1,properties:{excerpt:{type:`string`},publishDate:{anyOf:[{type:`string`},{type:`null`}]},relevanceScore:{type:`number`},title:{type:`string`},url:{type:`string`}},required:[`url`,`title`,`excerpt`],type:`object`},type:`array`},searchId:{type:`string`}},required:[`searchId`,`results`],type:`object`},{additionalProperties:!1,properties:{error:{enum:[`api_error`,`rate_limit`,`timeout`,`invalid_input`,`configuration_error`,`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_EXA_OUTPUT_SCHEMA,WEB_SEARCH_GOOGLE_OUTPUT_SCHEMA,WEB_SEARCH_OPENAI_OUTPUT_SCHEMA,WEB_SEARCH_PARALLEL_OUTPUT_SCHEMA,WEB_SEARCH_TOOL_DEFINITION};

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

@@ -1,23 +0,0 @@
-import { z } from "#compiled/zod/index.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: z.ZodObject<{
-    content: z.ZodString;
-    filePath: z.ZodString;
-}, z.core.$strict>;
-/**
- * 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: z.ZodObject<{
-    existed: z.ZodBoolean;
-    path: z.ZodString;
-}, z.core.$strict>;
-export declare const WRITE_FILE_TOOL_DEFINITION: ResolvedToolDefinition;

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

@@ -1,2 +0,0 @@
-import{z}from"#compiled/zod/index.js";import{requireSandboxSession}from"#execution/sandbox/require-sandbox.js";import{executeWriteFileOnSandbox}from"#execution/sandbox/write-file-tool.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()});async function executeWriteFile(e,t){return executeWriteFileOnSandbox(await requireSandboxSession(t?.abortSignal),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/jwt-ecdsa.js

@@ -1 +0,0 @@
-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.js

@@ -1 +0,0 @@
-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.js

@@ -1 +0,0 @@
-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,strategy:e.strategy})||!currentVercelEnvironmentMatches({payload:a.payload,strategy:e.strategy})?{kind:`caller-not-allowed`}:{kind:`authenticated`,principal:createJwtAuthenticatedCallerPrincipal({authenticator:`oidc`,issuerClaims:[`external_iss`,`connector_id`],payload:a.payload,principalType:`user`,subjectClaim:`external_sub`})};if(e.strategy.acceptCurrentVercelProject&&e.strategy.issuer.startsWith(`https://oidc.vercel.com/`)&&a.payload.user_id!==void 0){if(typeof a.payload.user_id!=`string`||a.payload.user_id.length===0||a.payload.environment!==`development`||!currentVercelProjectMatches({payload:a.payload,strategy:e.strategy}))return{kind:`caller-not-allowed`};if(currentVercelEnvironmentMatches({payload:a.payload,strategy:e.strategy}))return{kind:`authenticated`,principal:createJwtAuthenticatedCallerPrincipal({authenticator:`oidc`,payload:a.payload,principalType:`user`,subjectClaim:`user_id`})}}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,strategy:e.strategy}),s=o&&isCurrentVercelEnvironmentToken({payload:a.payload,strategy:e.strategy});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=e.strategy.currentVercelProject;return t!==void 0&&typeof e.payload.project_id==`string`&&e.payload.project_id===t.projectId}function currentVercelProjectMatches(e){let t=e.strategy.currentVercelProject;return t!==void 0&&typeof e.payload.project_id==`string`&&e.payload.project_id===t.projectId}function isCurrentVercelEnvironmentToken(e){let t=e.strategy.currentVercelProject?.environment;return t===void 0||t.length===0?!1:typeof e.payload.environment==`string`&&e.payload.environment===t}function currentVercelEnvironmentMatches(e){let t=e.strategy.currentVercelProject?.environment;return t===void 0||t.length===0?!1:typeof e.payload.environment==`string`&&e.payload.environment===t}export{authenticateOidcStrategy};

package/dist/src/runtime/input/types.js

@@ -1 +0,0 @@
-import{z}from"#compiled/zod/index.js";import{runtimeToolCallActionRequestSchema}from"#runtime/actions/types.js";const inputOptionSchema=z.object({description:z.string().describe(`Optional additional context for this option.`).optional(),id:z.string().describe(`Stable identifier for the option.`),label:z.string().describe(`User-facing label for the option.`),style:z.enum([`primary`,`danger`,`default`]).describe(`Visual treatment hint for the option.`).optional()}).strict(),inputRequestKindSchema=z.enum([`question`,`session-limit`,`tool-approval`]),inputRequestSchema=z.object({action:runtimeToolCallActionRequestSchema,allowFreeform:z.boolean().describe(`Whether the user may answer with freeform text instead of selecting one of the provided options.`).optional(),display:z.enum([`confirmation`,`select`,`text`]).describe(`Rendering hint: the channel uses this to pick a UX treatment.`).optional(),kind:inputRequestKindSchema.describe(`Framework-owned request source used to resolve, route, and render the response.`),options:z.array(inputOptionSchema).describe(`Selectable answer options to present to the user.`).optional(),prompt:z.string().describe(`The prompt to present to the user.`),requestId:z.string().describe(`Stable identifier for this request.`)}).strict(),inputResponseSchema=z.object({optionId:z.string().optional(),requestId:z.string(),text:z.string().optional()}).strict();function parseInputResponse(e){return inputResponseSchema.parse(e)}function parseInputResponses(e){return inputResponseSchema.array().parse(e).map(e=>e)}function isInputRequest(e){return inputRequestSchema.safeParse(e).success}function isInputResponse(e){return inputResponseSchema.safeParse(e).success}export{inputOptionSchema,inputRequestKindSchema,inputRequestSchema,inputResponseSchema,isInputRequest,isInputResponse,parseInputResponse,parseInputResponses};

package/dist/src/runtime/session-callback-route.d.ts

@@ -1,6 +0,0 @@
-import type { RouteContext } from "#public/definitions/channel.js";
-import type { ResolvedChannelDefinition } from "#runtime/types.js";
-export declare const HTTP_SESSION_CALLBACK_CHANNEL_NAME_PREFIX = "eve/v1/callback";
-export declare function getSessionCallbackChannelDefinitions(): readonly ResolvedChannelDefinition[];
-export declare function getSessionCallbackChannelNames(): ReadonlySet<string>;
-export declare function handleSessionCallbackRequest(request: Request, ctx: RouteContext): Promise<Response>;