eve 0.44.4 → 0.45.1

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

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

@@ -1 +0,0 @@
-import{isInputRequest}from"#runtime/input/types.js";import{z}from"#compiled/zod/index.js";import{EVE_CALLBACK_ROUTE_PATTERN}from"#protocol/routes.js";import{jsonValueSchema}from"#shared/json-schemas.js";import{REMOTE_AGENT_FAILED}from"#harness/agent-handle-errors.js";import{readTaskIdFromInboxToken}from"#tasks/task-id.js";import{resumeHook}from"#internal/workflow/runtime.js";import{tokenUsageSchema}from"#shared/token-usage.js";import{agentTurnOutcomeSchema}from"#shared/agent-turn-outcome.js";const HTTP_SESSION_CALLBACK_CHANNEL_NAME_PREFIX=`eve/v1/callback`,HANDLED_METHODS=[`POST`],ZERO_TOKEN_USAGE={cacheReadTokens:0,cacheWriteTokens:0,inputTokens:0,outputTokens:0},eventCoordinateSchema=z.number().int().nonnegative(),authorizationChallengeSchema=z.looseObject({displayName:z.string().optional(),expiresAt:z.string().optional(),instructions:z.string().optional(),url:z.string().optional(),userCode:z.string().optional()}),taskInputEventSchema=z.looseObject({requests:z.array(jsonValueSchema.refine(isInputRequest)).min(1),sequence:eventCoordinateSchema,stepIndex:eventCoordinateSchema,turnId:z.string()}),taskAuthorizationEventSchema=z.discriminatedUnion(`type`,[z.looseObject({data:z.looseObject({attemptId:z.string().optional(),authorization:authorizationChallengeSchema.optional(),description:z.string(),name:z.string(),sequence:eventCoordinateSchema,stepIndex:eventCoordinateSchema,turnId:z.string(),webhookUrl:z.string().optional()}),type:z.literal(`authorization.required`)}),z.looseObject({data:z.looseObject({attemptId:z.string().optional(),authorization:authorizationChallengeSchema.optional(),name:z.string(),outcome:z.enum([`authorized`,`declined`,`failed`,`timed-out`]),reason:z.string().optional(),sequence:eventCoordinateSchema,stepIndex:eventCoordinateSchema,turnId:z.string()}),type:z.literal(`authorization.completed`)})]),taskEventCallbackSchema=z.discriminatedUnion(`kind`,[z.object({callId:z.string(),childContinuationToken:z.string(),childSessionId:z.string(),event:taskInputEventSchema,kind:z.literal(`task.input-requested`),subagentName:z.string(),taskId:z.string()}),z.object({callId:z.string(),childContinuationToken:z.string(),childSessionId:z.string(),event:taskAuthorizationEventSchema,kind:z.literal(`task.authorization`),subagentName:z.string(),taskId:z.string()})]),taskTurnStartedCallbackSchema=z.object({kind:z.literal(`turn.started`),sessionId:z.string().min(1),taskId:z.string().min(1),turnId:z.string().min(1)}),taskUpdateCallbackSchema=z.object({callId:z.string().min(1),kind:z.literal(`task.update`),message:z.string().min(1),taskId:z.string().min(1),updateEpoch:z.string().min(1),updateIndex:eventCoordinateSchema}),sessionResultCallbackSchema=z.discriminatedUnion(`kind`,[z.object({callId:z.string().min(1),kind:z.literal(`session.completed`),output:jsonValueSchema.optional(),subagentName:z.string().min(1),usage:z.unknown().optional()}),z.object({callId:z.string().min(1),error:jsonValueSchema.optional(),kind:z.literal(`session.failed`),subagentName:z.string().min(1),usage:z.unknown().optional()}),z.object({callId:z.string().min(1),kind:z.literal(`turn.completed`),outcome:agentTurnOutcomeSchema,output:jsonValueSchema.optional(),subagentName:z.string().min(1)}),z.object({callId:z.string().min(1),error:jsonValueSchema,kind:z.literal(`turn.failed`),outcome:agentTurnOutcomeSchema,subagentName:z.string().min(1)})]);function getSessionCallbackChannelDefinitions(){return HANDLED_METHODS.map(e=>buildCallbackChannelDefinition(e))}function getSessionCallbackChannelNames(){return new Set(HANDLED_METHODS.map(channelNameForMethod))}function buildCallbackChannelDefinition(e){let t=channelNameForMethod(e);return{name:t,method:e,urlPath:EVE_CALLBACK_ROUTE_PATTERN,fetch:handleSessionCallbackRequest,logicalPath:`framework://channels/${t}`,sourceId:`eve:framework:session-callback-${e.toLowerCase()}`,sourceKind:`module`}}function channelNameForMethod(e){return`${HTTP_SESSION_CALLBACK_CHANNEL_NAME_PREFIX}/${e.toLowerCase()}`}async function handleSessionCallbackRequest(e,t){let n=t.params.token;if(typeof n!=`string`||n.length===0)return Response.json({error:`Missing callback token.`,ok:!1},{status:400});let r;try{r=await e.json()}catch{return Response.json({error:`Invalid JSON body.`,ok:!1},{status:400})}let i=projectTaskEvent(r,n);if(i instanceof Response)return i;if(i!==void 0){try{await resumeHook(n,i)}catch{return Response.json({error:`Session callback not pending.`,ok:!1},{status:404})}return Response.json({ok:!0},{status:202})}let a=projectTaskUpdate(r,n);if(a instanceof Response)return a;if(a!==void 0){try{await resumeHook(n,a)}catch{return Response.json({error:`Session callback not pending.`,ok:!1},{status:404})}return Response.json({ok:!0},{status:202})}let o=projectTaskTurnStarted(r,n);if(o instanceof Response)return o;if(o!==void 0){try{await resumeHook(n,o)}catch{return Response.json({error:`Session callback not pending.`,ok:!1},{status:404})}return Response.json({ok:!0},{status:202})}let s=projectSessionCallbackResult(r);if(s instanceof Response)return s;try{await resumeHook(n,{kind:`runtime-action-result`,results:[s]})}catch{return Response.json({error:`Session callback not pending.`,ok:!1},{status:404})}return Response.json({ok:!0},{status:202})}function callbackKind(e){if(!(typeof e!=`object`||!e))return Reflect.get(e,`kind`)}function projectTaskEvent(e,t){let n=callbackKind(e);if(n!==`task.input-requested`&&n!==`task.authorization`)return;let r=taskEventCallbackSchema.safeParse(e);if(!r.success)return Response.json({error:`Invalid task event callback.`,ok:!1},{status:400});let i=r.data,a=rejectMismatchedTaskToken(t,i.taskId);return a===void 0?i.kind===`task.input-requested`?{callId:i.callId,childContinuationToken:i.childContinuationToken,childSessionId:i.childSessionId,event:i.event,kind:`subagent-input-request`,subagentName:i.subagentName}:{callId:i.callId,childSessionId:i.childSessionId,event:i.event,kind:`authorization-event`,subagentName:i.subagentName}:a}function projectTaskTurnStarted(e,t){if(callbackKind(e)!==`turn.started`)return;let n=taskTurnStartedCallbackSchema.safeParse(e);if(!n.success)return Response.json({error:`Invalid task turn-start callback.`,ok:!1},{status:400});let r=rejectMismatchedTaskToken(t,n.data.taskId);return r===void 0?{childSessionId:n.data.sessionId,childTurnId:n.data.turnId,kind:`turn-started`,taskId:n.data.taskId}:r}function projectTaskUpdate(e,t){if(callbackKind(e)!==`task.update`)return;let n=taskUpdateCallbackSchema.safeParse(e);if(!n.success)return Response.json({error:`Invalid task update callback.`,ok:!1},{status:400});let r=rejectMismatchedTaskToken(t,n.data.taskId);return r===void 0?{callId:n.data.callId,kind:`task-update`,message:n.data.message,updateEpoch:n.data.updateEpoch,updateIndex:n.data.updateIndex}:r}function rejectMismatchedTaskToken(e,t){return readTaskIdFromInboxToken(e)===t?void 0:Response.json({error:`Task callback token mismatch.`,ok:!1},{status:403})}function projectSessionCallbackResult(e){if(typeof e!=`object`||!e)return Response.json({error:`Expected a JSON object.`,ok:!1},{status:400});let t=callbackKind(e);if(t!==`session.completed`&&t!==`session.failed`&&t!==`turn.completed`&&t!==`turn.failed`)return Response.json({error:`Unsupported callback kind.`,ok:!1},{status:400});let n=sessionResultCallbackSchema.safeParse(e);if(!n.success)return Response.json({error:`Invalid session result callback.`,ok:!1},{status:400});let r=n.data;if(r.kind===`session.completed`){let e=r.output??``,t=parseCallbackUsage(r.usage),n={callId:r.callId,kind:`subagent-result`,origin:`child`,outcome:{kind:`terminal`,result:{kind:`succeeded`,output:e},usageDelta:t??ZERO_TOKEN_USAGE},output:e,subagentName:r.subagentName};return t===void 0?n:{...n,usage:t}}if(r.kind===`session.failed`){let e=r.error===void 0?{code:REMOTE_AGENT_FAILED,message:`Remote agent failed.`}:r.error,t=parseCallbackUsage(r.usage);return{callId:r.callId,isError:!0,kind:`subagent-result`,origin:`child`,outcome:{kind:`terminal`,result:{error:e,kind:`failed`},usageDelta:t??ZERO_TOKEN_USAGE},output:e,subagentName:r.subagentName}}return r.kind===`turn.completed`?{callId:r.callId,kind:`subagent-result`,origin:`child`,outcome:r.outcome,output:r.output??``,subagentName:r.subagentName,usage:r.outcome.usageDelta}:{callId:r.callId,isError:!0,kind:`subagent-result`,origin:`child`,outcome:r.outcome,output:r.error,subagentName:r.subagentName}}function parseCallbackUsage(e){if(e===void 0)return;let t=tokenUsageSchema.safeParse(e);return t.success?t.data:void 0}export{HTTP_SESSION_CALLBACK_CHANNEL_NAME_PREFIX,getSessionCallbackChannelDefinitions,getSessionCallbackChannelNames,handleSessionCallbackRequest};

package/dist/src/runtime/task-input-response-route.d.ts

@@ -1,5 +0,0 @@
-import type { RouteContext } from "#public/definitions/channel.js";
-import type { ResolvedChannelDefinition } from "#runtime/types.js";
-export declare function getTaskInputResponseChannelDefinitions(): readonly ResolvedChannelDefinition[];
-export declare function getTaskInputResponseChannelNames(): ReadonlySet<string>;
-export declare function handleTaskInputResponseRequest(request: Request, ctx: RouteContext): Promise<Response>;

package/dist/src/runtime/task-input-response-route.js

@@ -1 +0,0 @@
-import{EVE_TASK_INPUT_ROUTE_PATTERN}from"#protocol/routes.js";import{resumeSessionInbox}from"#execution/wire/session-inbox-resume.js";import{readTaskInputTargetToken}from"#execution/task-input-capability.js";const NAME=`eve/v1/task-input/post`;function getTaskInputResponseChannelDefinitions(){return[{fetch:handleTaskInputResponseRequest,logicalPath:`framework://channels/${NAME}`,method:`POST`,name:NAME,sourceId:`eve:framework:task-input-post`,sourceKind:`module`,urlPath:EVE_TASK_INPUT_ROUTE_PATTERN}]}function getTaskInputResponseChannelNames(){return new Set([NAME])}async function handleTaskInputResponseRequest(e,r){let i=r.params.token;if(typeof i!=`string`||i.length===0)return Response.json({error:`Missing task input token.`,ok:!1},{status:400});let a=readTaskInputTargetToken(i);if(a===void 0)return Response.json({error:`Invalid task input token.`,ok:!1},{status:403});let o;try{o=await e.json()}catch{return Response.json({error:`Invalid JSON body.`,ok:!1},{status:400})}let s=readInputResponses(o);if(s===void 0||s.length===0)return Response.json({error:`Expected a non-empty inputResponses array.`,ok:!1},{status:400});try{await resumeSessionInbox(a,{kind:`send`,payload:{inputResponses:s}})}catch{return Response.json({error:`Task input target is not pending.`,ok:!1},{status:404})}return Response.json({ok:!0},{status:202})}function readInputResponses(e){if(typeof e!=`object`||!e||Array.isArray(e))return;let t=Reflect.get(e,`inputResponses`);if(!Array.isArray(t))return;let n=[];for(let e of t){if(typeof e!=`object`||!e||Array.isArray(e))return;let t=Reflect.get(e,`requestId`),r=Reflect.get(e,`optionId`),i=Reflect.get(e,`text`);if(typeof t!=`string`||r!==void 0&&typeof r!=`string`||i!==void 0&&typeof i!=`string`)return;let a={requestId:t};typeof r==`string`&&(a.optionId=r),typeof i==`string`&&(a.text=i),n.push(a)}return n}export{getTaskInputResponseChannelDefinitions,getTaskInputResponseChannelNames,handleTaskInputResponseRequest};

package/dist/src/shared/durable-dynamic-tool-callbacks.js

@@ -1 +0,0 @@
-import{resolveApprovalPolicy}from"#public/definitions/approval.js";const STAMPED_CALLBACK=Symbol.for(`eve:durable-dynamic-callback`),DURABLE_DYNAMIC_TOOL_CALLBACKS=Symbol.for(`eve:durable-dynamic-tool-callbacks`),REGISTRY=Symbol.for(`eve:dynamic-tool-callbacks`);function getRegistry(){let e=globalThis,t=e[REGISTRY];if(t!==void 0)return t;let n=new Map;return e[REGISTRY]=n,n}function registerDurableDynamicCallback(e){let t=getRegistry(),n=t.get(e.toolName);n===void 0&&(n=new Map,t.set(e.toolName,n)),n.set(e.phase,e.callback)}function lookupDurableDynamicCallback(e,t){return getRegistry().get(e)?.get(t)}function callDurableDynamicCallback(e,t,...n){return e(t,...n)}function hasUnregisteredDurableDynamicCallbacks(e){return e.some(e=>Object.keys(e.callbacks).some(t=>lookupDurableDynamicCallback(e.name,t)===void 0))}function stampDurableDynamicCallback(e,n){return Object.defineProperty(e,STAMPED_CALLBACK,{configurable:!0,value:n}),e}function readDurableDynamicCallback(e){if(typeof e==`function`)return Reflect.get(e,STAMPED_CALLBACK)}function stampDurableDynamicToolCallbacks(e,t){Object.defineProperty(e,DURABLE_DYNAMIC_TOOL_CALLBACKS,{configurable:!0,value:t})}function collectDurableDynamicToolCallbacks(t){let n=t.approval===void 0?void 0:readDurableDynamicCallback(resolveApprovalPolicy(t.approval)),r=t.approval===void 0||typeof t.approval==`function`?void 0:readDurableDynamicCallback(t.approval.response),i=readDurableDynamicCallback(t.execute),a=readDurableDynamicCallback(t.toModelOutput),o={};return i!==void 0&&(o.execute=i),n!==void 0&&(o.approvalRequest=n),r!==void 0&&(o.approvalResponse=r),a!==void 0&&(o.toModelOutput=a),o}function readDurableDynamicToolCallbacks(e){return e[DURABLE_DYNAMIC_TOOL_CALLBACKS]}export{DURABLE_DYNAMIC_TOOL_CALLBACKS,callDurableDynamicCallback,collectDurableDynamicToolCallbacks,hasUnregisteredDurableDynamicCallbacks,lookupDurableDynamicCallback,readDurableDynamicCallback,readDurableDynamicToolCallbacks,registerDurableDynamicCallback,stampDurableDynamicCallback,stampDurableDynamicToolCallbacks};

package/dist/src/shared/dynamic-tool-definition.d.ts

@@ -1,154 +0,0 @@
-import type { ModelMessage } from "ai";
-import type { PublicToolInputSchema, PublicToolOutputSchema, ToolModelOutput } from "#shared/tool-definition.js";
-import type { Approval } from "#public/definitions/approval.js";
-import type { ToolContext } from "#public/definitions/tool.js";
-import type { SessionAuth } from "#context/keys.js";
-import type { UnstampedMessageStreamEvent } from "#protocol/message.js";
-/**
- * Stream event types allowed for dynamic tool resolvers. Dispatch
- * supports any event; this extract restricts the public surface until
- * more events are validated.
- */
-export type DynamicToolEventName = Extract<UnstampedMessageStreamEvent["type"], "session.started" | "turn.started" | "step.started">;
-export declare const ALLOWED_DYNAMIC_TOOL_EVENTS: ReadonlySet<string>;
-/**
- * Instructions and skills are restricted to session/turn boundaries.
- * Keeping their resolved context stable within a turn avoids changing the
- * model input between tool-loop steps.
- */
-export declare const ALLOWED_DYNAMIC_INSTRUCTION_EVENTS: ReadonlySet<string>;
-export declare const ALLOWED_DYNAMIC_SKILL_EVENTS: ReadonlySet<string>;
-/**
- * Context passed to a dynamic resolver's event handler.
- *
- * Exposes read-only session identity, auth, and channel metadata. State
- * is not exposed here; resolvers read it through `defineState` handles or
- * the session context inside tool `execute` functions.
- */
-export interface DynamicResolveContext {
-    readonly session: {
-        readonly id: string;
-        readonly auth: SessionAuth;
-    };
-    /** Channel metadata for the request that triggered this resolve. */
-    readonly channel: {
-        /** Channel type that produced the request (e.g. `"slack"`, `"http"`), when known. */
-        readonly kind?: string;
-        /** Channel-owned resume handle for the conversation, when the channel supplies one. */
-        readonly continuationToken?: string;
-        /** Free-form channel-specific metadata attached to the request. */
-        readonly metadata?: Readonly<Record<string, unknown>>;
-    };
-    /** Conversation history visible at this resolve point, oldest first. */
-    readonly messages: readonly ModelMessage[];
-}
-/**
- * A single tool entry within a resolved dynamic tool set.
- *
- * Identity comes from context: a single returned entry is named after
- * the file slug; entries in a returned `Record<string, DynamicToolEntry>`
- * are each named `slug__key`.
- *
- * `TInput` defaults to `Record<string, unknown>` but is inferred when
- * `inputSchema` is a Standard Schema (e.g. Zod) via the `defineTool`
- * wrapper. `TOutput` defaults to `any`; provide an `outputSchema`
- * (Standard Schema) to infer and check the executor return type.
- */
-export interface DynamicToolEntry<TInput = Record<string, unknown>, TOutput = any> {
-    readonly description: string;
-    readonly inputSchema: PublicToolInputSchema<TInput>;
-    readonly outputSchema?: PublicToolOutputSchema<TOutput>;
-    execute(input: TInput, ctx: ToolContext): TOutput | Promise<TOutput>;
-    readonly toModelOutput?: (output: TOutput) => ToolModelOutput | Promise<ToolModelOutput>;
-    /**
-     * Optional per-call approval gate, mirroring the authored-tool
-     * `approval` contract: return `"user-approval"` to require user approval
-     * before the call executes. Dynamic approval request and response callbacks
-     * use the same durable descriptor boundary as `execute` and `toModelOutput`.
-     */
-    readonly approval?: Approval;
-}
-/**
- * A resolved tool set: keys are entry identifiers, values are
- * {@link DynamicToolEntry} objects created via `defineTool` inside a
- * resolver. Entry type params are `any` so entries with differing
- * schemas stay assignable to one Record; `defineTool` captures each
- * entry's concrete types before this widened container.
- */
-export type DynamicToolSet = Readonly<Record<string, DynamicToolEntry<any, any>>>;
-/**
- * Return type for a `defineDynamic` event handler: a single tool entry
- * (named after the file slug), a map of entries (named `slug__key`), or
- * `null` for no tools.
- */
-export type DynamicToolResult = DynamicToolEntry<any, any> | DynamicToolSet | null;
-/**
- * Strongly-typed tool-handler map: each key is a supported event name,
- * each value a resolver that takes the stream event and resolve context
- * and returns a {@link DynamicToolResult}. `defineDynamic` accepts the
- * wider {@link DynamicEvents} (handlers return `unknown`) because the
- * slot directory (tools/ vs skills/) decides the expected return at
- * runtime. Reference `DynamicToolEvents` to check the tool-specific
- * return type at authoring time.
- */
-export type DynamicToolEvents = {
-    readonly [K in DynamicToolEventName]?: (event: unknown, ctx: DynamicResolveContext) => DynamicToolResult | Promise<DynamicToolResult>;
-};
-/**
- * Base event handler map accepted by `defineDynamic`. Intentionally
- * wide so it accepts both tool-returning and skill-returning handlers:
- * the slot directory (tools/ vs skills/) determines the required return,
- * validated at runtime by the respective resolver.
- */
-export type DynamicEvents<TResult = unknown> = {
-    readonly [K in DynamicToolEventName]?: (event: unknown, ctx: DynamicResolveContext) => TResult | Promise<TResult>;
-};
-/**
- * Marker discriminator for a `defineDynamic({ events })` export.
- */
-export declare const DYNAMIC_SENTINEL_KIND: "eve:dynamic";
-/**
- * Return value of `defineDynamic`: the runtime shape of a dynamic export,
- * stamped with a sentinel kind the compiler/normalizer detects.
- */
-export type DynamicSentinel<TResult = unknown> = {
-    readonly kind: typeof DYNAMIC_SENTINEL_KIND;
-    readonly events: DynamicEvents<TResult>;
-};
-export declare function assertResolverOnlyDynamicSentinel(sentinel: DynamicSentinel, message: string): void;
-export declare function isDynamicSentinel(value: unknown): value is DynamicSentinel;
-/**
- * Symbol-based brand stamped by `defineTool` on every entry. Invisible
- * in IntelliSense, checked at runtime to enforce the wrapper and to
- * distinguish a single entry from a map of entries.
- */
-export declare const TOOL_BRAND: unique symbol;
-/**
- * Returns true if `value` carries the `defineTool` brand symbol. Used
- * to detect single entry vs map of entries and to validate that entries
- * are properly wrapped.
- */
-export declare function isBrandedToolEntry(value: unknown): boolean;
-/**
- * Symbol-based brand stamped by `defineInstructions` on every entry.
- * Invisible in IntelliSense, checked at runtime to validate that dynamic
- * instruction resolver returns are properly wrapped.
- */
-export declare const INSTRUCTIONS_BRAND: unique symbol;
-/**
- * Returns true if `value` carries the `defineInstructions` brand symbol.
- * Used to validate that dynamic instruction entries are properly wrapped.
- */
-export declare function isBrandedInstructionsEntry(value: unknown): boolean;
-/**
- * Symbol-based brand stamped by `defineSkill` on every entry. Invisible
- * in IntelliSense, checked at runtime to detect single-entry vs
- * map-of-entries return shapes in dynamic skill resolvers.
- */
-export declare const SKILL_BRAND: unique symbol;
-/**
- * Returns true if `value` carries the `defineSkill` brand symbol. Used
- * to detect single entry vs map of entries and to validate that entries
- * are properly wrapped.
- */
-export declare function isBrandedSkillEntry(value: unknown): boolean;

package/dist/src/shared/dynamic-tool-definition.js

@@ -1 +0,0 @@
-const ALLOWED_DYNAMIC_TOOL_EVENTS=new Set([`session.started`,`turn.started`,`step.started`]),ALLOWED_DYNAMIC_INSTRUCTION_EVENTS=new Set([`session.started`,`turn.started`]),ALLOWED_DYNAMIC_SKILL_EVENTS=new Set([`session.started`,`turn.started`]),DYNAMIC_SENTINEL_KIND=`eve:dynamic`;function assertResolverOnlyDynamicSentinel(e,t){let n=Object.keys(e).filter(e=>e!==`events`&&e!==`kind`);if(n.length>0)throw Error(`${t} Unknown key(s): ${n.join(`, `)}.`)}function isDynamicSentinel(e){return typeof e==`object`&&!!e&&e.kind===`eve:dynamic`}const TOOL_BRAND=Symbol.for(`eve:tool-brand`);function isBrandedToolEntry(e){return typeof e==`object`&&!!e&&e[TOOL_BRAND]===!0}const INSTRUCTIONS_BRAND=Symbol.for(`eve:instructions-brand`);function isBrandedInstructionsEntry(e){return typeof e==`object`&&!!e&&e[INSTRUCTIONS_BRAND]===!0}const SKILL_BRAND=Symbol.for(`eve:skill-brand`);function isBrandedSkillEntry(e){return typeof e==`object`&&!!e&&e[SKILL_BRAND]===!0}export{ALLOWED_DYNAMIC_INSTRUCTION_EVENTS,ALLOWED_DYNAMIC_SKILL_EVENTS,ALLOWED_DYNAMIC_TOOL_EVENTS,DYNAMIC_SENTINEL_KIND,INSTRUCTIONS_BRAND,SKILL_BRAND,TOOL_BRAND,assertResolverOnlyDynamicSentinel,isBrandedInstructionsEntry,isBrandedSkillEntry,isBrandedToolEntry,isDynamicSentinel};

package/dist/src/shared/eve-server-health.d.ts

@@ -1,5 +0,0 @@
-/** Returns whether an Eve server answers its health route successfully. */
-export declare function isEveServerHealthy(serverUrl: string, options?: {
-    readonly signal?: AbortSignal;
-    readonly timeoutMs?: number;
-}): Promise<boolean>;

package/dist/src/shared/eve-server-health.js

@@ -1 +0,0 @@
-import{EVE_HEALTH_ROUTE_PATH}from"#protocol/routes.js";async function isEveServerHealthy(e,t={}){let n=AbortSignal.timeout(t.timeoutMs??1e3),r=t.signal===void 0?n:AbortSignal.any([t.signal,n]);try{let t=new URL(EVE_HEALTH_ROUTE_PATH,e).toString();return(await fetch(t,{redirect:`error`,signal:r})).ok}catch{return!1}}export{isEveServerHealthy};

package/dist/src/shared/tool-definition.d.ts

@@ -1,89 +0,0 @@
-import type { ToolExecutionOptions } from "ai";
-import type { StandardJSONSchemaV1, StandardSchemaV1 } from "#compiled/@standard-schema/spec/index.js";
-import type { JsonObject } from "#shared/json.js";
-import type { TaskExec } from "#shared/tool-task.js";
-/**
- * Options forwarded from the AI SDK to the tool's {@link ToolDefinition.execute}
- * function. These are the same options the SDK passes to every tool call.
- */
-export type ToolExecuteOptions = Omit<ToolExecutionOptions<unknown>, "context">;
-export type ToolExecuteFn<TInput = unknown, TOutput = unknown> = (input: TInput, options: ToolExecuteOptions, task?: TaskExec) => Promise<TOutput> | TOutput | AsyncIterable<TOutput>;
-export type ToolExecution = "background";
-interface ToolDefinitionBase {
-    readonly description: string;
-    readonly execution?: ToolExecution;
-}
-/**
- * Internal/compiled tool definition shape. Carries `name` because the
- * compiler stamps a path-derived identifier onto every tool entry.
- *
- * Authored public definitions (see {@link PublicToolDefinition}) do not
- * carry `name`; identity comes from the file path.
- */
-export interface InternalToolDefinition extends ToolDefinitionBase {
-    name: string;
-    inputSchema: JsonObject | null;
-    outputSchema?: JsonObject;
-}
-export type PublicToolInputSchema<TInput = unknown> = StandardSchemaV1<unknown, TInput> | StandardJSONSchemaV1<unknown, TInput> | JsonObject;
-export type PublicToolOutputSchema<TOutput = unknown> = StandardJSONSchemaV1<unknown, TOutput> | JsonObject;
-/**
- * Authored public tool definition shape. Identity is derived from the
- * file path at compile time, so `name` is intentionally absent here.
- */
-export interface PublicToolDefinition<TInput = unknown, TOutput = unknown> extends ToolDefinitionBase {
-    inputSchema: PublicToolInputSchema<TInput>;
-    /**
-     * Optional schema describing the value returned by the tool executor.
-     * The AI SDK can use this for tool result typing.
-     */
-    outputSchema?: PublicToolOutputSchema<TOutput>;
-}
-export interface InternalToolDefinitionWithExecuteFn<TInput = unknown, TOutput = unknown> extends InternalToolDefinition {
-    execute: ToolExecuteFn<TInput, TOutput>;
-}
-export interface PublicToolDefinitionWithExecuteFn<TInput = unknown, TOutput = unknown> extends PublicToolDefinition<TInput, TOutput> {
-    execute: ToolExecuteFn<TInput, TOutput>;
-}
-/**
- * eve-owned shape for the model-facing tool result produced by
- * `toModelOutput`. Structurally compatible with the AI SDK's
- * `ToolResultOutput` so the harness can forward it without conversion.
- *
- * The `content` variant carries an ordered list of
- * {@link ToolModelOutputPart} entries, letting a tool hand the model
- * text alongside inline files (e.g. a screenshot as vision input).
- */
-export type ToolModelOutput = {
-    readonly type: "text";
-    readonly value: string;
-} | {
-    readonly type: "json";
-    readonly value: unknown;
-} | {
-    readonly type: "content";
-    readonly value: readonly ToolModelOutputPart[];
-};
-/**
- * One part of a `content` {@link ToolModelOutput}. Mirrors the AI SDK's
- * `ToolResultOutput` content parts narrowed to the JSON-safe subset:
- * file data is the SDK's tagged `FileData` union restricted to
- * `{ type: "data" }` with a base64 string, so persisted tool results
- * survive the durable JSON boundary. Use the `toolOutputPart` builders
- * from `eve/tools` to construct parts without hand-writing the nesting.
- */
-export type ToolModelOutputPart = {
-    readonly type: "text";
-    readonly text: string;
-} | {
-    readonly type: "file";
-    /** Tagged file data; only JSON-safe base64 payloads are accepted. */
-    readonly data: {
-        readonly type: "data";
-        readonly data: string;
-    };
-    /** IANA media type, e.g. `image/png`. */
-    readonly mediaType: string;
-    readonly filename?: string;
-};
-export {};