eve 0.5.4 → 0.6.0-beta.10

package/dist/src/runtime/agent/bootstrap.js

@@ -0,0 +1 @@
+import{composeRuntimeBasePrompt}from"#runtime/prompt/compose.js";const BOOTSTRAP_RUNTIME_MODEL_ID=`eve-bootstrap-model`,BOOTSTRAP_RUNTIME_SYSTEM_PROMPT=`You are the Eve bootstrap agent. Be concise, stay grounded in the current conversation, and do not assume tools are available unless the runtime provides them.`;function createResolvedRuntimeTurnAgent(e){let t=e.agent;return{id:t.config.name,instructions:composeRuntimeBasePrompt({connections:t.connections,instructions:t.instructions,skills:t.skills,toolsAvailable:e.tools.length>0,workspaceSpec:t.workspaceSpec}),compactionModel:t.config.compaction?.model,model:t.config.model,nodeId:e.nodeId,outputSchema:t.config.outputSchema,tools:[...e.tools],workspaceSpec:t.workspaceSpec}}export{BOOTSTRAP_RUNTIME_MODEL_ID,BOOTSTRAP_RUNTIME_SYSTEM_PROMPT,createResolvedRuntimeTurnAgent};

package/dist/src/runtime/agent/mock-model-adapter.d.ts

@@ -0,0 +1,21 @@
+import type { LanguageModel } from "ai";
+import { type RuntimeModelReference } from "#runtime/agent/bootstrap.js";
+/**
+ * Environment variable that forces authored runtime models onto the dedicated
+ * deterministic mock adapter.
+ */
+export declare const EVE_MOCK_AUTHORED_MODELS_ENV = "EVE_MOCK_AUTHORED_MODELS";
+/**
+ * Returns true when authored runtime models should resolve through the
+ * dedicated deterministic mock adapter.
+ */
+export declare function shouldMockAuthoredRuntimeModels(): boolean;
+/**
+ * Creates a deterministic authored-model mock for one runtime model reference.
+ */
+export declare function createMockAuthoredRuntimeModel(reference: RuntimeModelReference): LanguageModel;
+/**
+ * Resolves the current authored runtime model onto the deterministic mock
+ * adapter when the test seam is active.
+ */
+export declare function resolveMockAuthoredRuntimeModel(reference: RuntimeModelReference): LanguageModel | null;

package/dist/src/runtime/agent/mock-model-adapter.js

@@ -0,0 +1,5 @@
+import{z}from"#compiled/zod/index.js";import{CODE_MODE_TOOL_NAME}from"#shared/code-mode.js";import{LOAD_SKILL_TOOL_NAME}from"#runtime/skills/fragment-context.js";import{FINAL_OUTPUT_TOOL_NAME}from"#runtime/framework-tools/final-output.js";import{MockLanguageModelV3}from"ai/test";import{BOOTSTRAP_RUNTIME_MODEL_ID,BOOTSTRAP_RUNTIME_SYSTEM_PROMPT}from"#runtime/agent/bootstrap.js";import{createBootstrapGenerateResult,createBootstrapStreamResult,estimateTokenCount,getLastUserPromptText,getPromptContentText,getPromptText}from"#runtime/agent/bootstrap-model-utils.js";import{createMockAuthoredToolInput,formatToolOutput,resolveMockFixtureToken,resolveWeatherCity}from"#runtime/agent/mock-model-fixtures.js";import{findRelevantSkill,getActivatedSkillIds,getAvailableSkills}from"#runtime/agent/mock-model-skill-selection.js";import{createJsonSchemaSample}from"#runtime/agent/mock-structured-output.js";const authoredRuntimeModelMocks=new Map,bootstrapWeatherPayloadSchema=z.object({city:z.string(),condition:z.string(),summary:z.string(),temperatureF:z.number().finite()}).strict(),EVE_MOCK_AUTHORED_MODELS_ENV=`EVE_MOCK_AUTHORED_MODELS`;function shouldMockAuthoredRuntimeModels(){return process.env.EVE_MOCK_AUTHORED_MODELS===`1`||process.env.NODE_ENV===`test`}function createMockAuthoredRuntimeModel(e){let t=authoredRuntimeModelMocks.get(e.id);if(t!==void 0)return t;let n=new MockLanguageModelV3({modelId:e.id,provider:`eve-runtime-mock`,doGenerate:async t=>createMockModelResult(t,e.id),doStream:async t=>createBootstrapStreamResult(createMockModelResult(t,e.id))});return authoredRuntimeModelMocks.set(e.id,n),n}function createMockModelResult(e,t){let n=getLastAuthoredToolResult(e.prompt);if(n!==null){let r=createFollowUpToolCallResult({modelId:t,options:e,result:n});if(r!==null)return r}else{let n=createSkillLoadResult(e.prompt,t)??createAuthoredToolCallResult(e,t);if(n!==null)return n}let r=createFinalOutputResult(e,t);if(r!==null)return r;let i=n===null?createAssistantMessage(e.prompt):formatToolResultReply(n,e.prompt);return createBootstrapGenerateResult({inputTokens:estimateTokenCount(getPromptText(e.prompt)),modelId:t,outputTokens:estimateTokenCount(i),text:i})}function createFinalOutputResult(e,t){let n=getAvailableTools(e).find(e=>e.name===FINAL_OUTPUT_TOOL_NAME);if(n===void 0)return null;let i=createJsonSchemaSample(n.inputSchema);return createToolCallGenerateResult({input:i,inputTokens:estimateTokenCount(getPromptText(e.prompt)),modelId:t,outputTokens:estimateTokenCount(JSON.stringify(i)),toolCallId:createToolCallId(FINAL_OUTPUT_TOOL_NAME),toolName:FINAL_OUTPUT_TOOL_NAME})}function resolveMockAuthoredRuntimeModel(e){return!shouldMockAuthoredRuntimeModels()||e.id===BOOTSTRAP_RUNTIME_MODEL_ID?null:createMockAuthoredRuntimeModel(e)}function createSkillLoadResult(e,t){let r=getLastUserPromptText(e);if(r===null||getActivatedSkillIds(e).length>0)return null;let i=findRelevantSkill(getAvailableSkills(e),r);return i===null?null:createToolCallGenerateResult({input:{skill:i.name},inputTokens:estimateTokenCount(getPromptText(e)),modelId:t,outputTokens:estimateTokenCount(i.name),toolCallId:`call_load_skill`,toolName:LOAD_SKILL_TOOL_NAME})}function createAuthoredToolCallResult(e,n){let r=getLastUserPromptText(e.prompt);if(r===null)return null;let i=findRelevantTool(getAvailableTools(e),r);if(i===null)return null;let a=resolveWeatherCity(r),o=createMockAuthoredToolInput(i,r,a);if(i.name===CODE_MODE_TOOL_NAME){let t=findRelevantCodeModeHostTool(i.description,r);if(t===null)return null;let o=`return await tools${formatCodeModeToolAccess(t)}({ city: ${JSON.stringify(a)} });`;return createToolCallGenerateResult({input:{js:o},inputTokens:estimateTokenCount(getPromptText(e.prompt)),modelId:n,outputTokens:estimateTokenCount(o),toolCallId:createToolCallId(i.name),toolName:i.name})}return createToolCallGenerateResult({input:o,inputTokens:estimateTokenCount(getPromptText(e.prompt)),modelId:n,outputTokens:estimateTokenCount(Object.values(o).join(` `)),toolCallId:createToolCallId(i.name),toolName:i.name})}function createFollowUpToolCallResult(e){let t=findNextExplicitToolAfterResult({previousToolName:e.result.toolName,prompt:e.options.prompt,tools:getAvailableTools(e.options)});if(t===null)return null;let n=createFollowUpToolInput(e.result.output);return n===null?null:createToolCallGenerateResult({input:n,inputTokens:estimateTokenCount(getPromptText(e.options.prompt)),modelId:e.modelId,outputTokens:estimateTokenCount(Object.values(n).join(` `)),toolCallId:createToolCallId(t.name),toolName:t.name})}function createAssistantMessage(e){let t=getLastUserPromptText(e)??`Hello from Eve`,n=getSystemPromptLabels(e),r=resolveSystemProbe(e),i=resolveMockFixtureToken(e);return i===null?n.length>0?r===null?`Bootstrap reply [${n.join(`, `)}]: ${t}`:`Bootstrap reply [${n.join(`, `)}; probe=${r}]: ${t}`:r===null?`Bootstrap reply: ${t}`:`Bootstrap reply [probe=${r}]: ${t}`:i}function formatToolResultReply(e,t){if(e.isError)return`Local weather tool failed: ${formatToolOutput(e.output)}`;if(isWeatherPayload(e.output))return`Used local weather tool for ${e.output.city}: ${e.output.condition}, ${e.output.temperatureF}F. ${e.output.summary}`;let n=getLastUserPromptText(t)??`Hello from Eve`;return`Used ${e.toolName} for "${n}": ${formatToolOutput(e.output)}`}function createToolCallGenerateResult(e){return{content:[{input:JSON.stringify(e.input),toolCallId:e.toolCallId,toolName:e.toolName,type:`tool-call`}],finishReason:{raw:void 0,unified:`tool-calls`},response:{id:`bootstrap-response`,modelId:e.modelId,timestamp:new Date(`2026-03-16T00:00:00.000Z`)},usage:{inputTokens:{cacheRead:0,cacheWrite:0,noCache:e.inputTokens,total:e.inputTokens},outputTokens:{reasoning:0,text:e.outputTokens,total:e.outputTokens}},warnings:[]}}function getAvailableTools(e){return(e.tools??[]).flatMap(e=>e.type===`function`?[{description:e.description,inputSchema:`inputSchema`in e?e.inputSchema:void 0,name:e.name,outputSchema:`outputSchema`in e?e.outputSchema:void 0}]:[])}function getLastAuthoredToolResult(e){for(let t of[...e].reverse()){if(t.role===`user`)return null;if(!(t.role!==`tool`&&t.role!==`assistant`)){for(let e of[...t.content].reverse())if(!(typeof e==`string`||e.type!==`tool-result`)&&e.toolName!==LOAD_SKILL_TOOL_NAME)return{isError:e.output.type===`error-json`||e.output.type===`error-text`||e.output.type===`execution-denied`,output:e.output.type===`execution-denied`?{reason:e.output.reason??null,type:e.output.type}:e.output.value,toolCallId:e.toolCallId,toolName:e.toolName}}}return null}function findNextExplicitToolAfterResult(e){let t=getLastUserPromptText(e.prompt);if(t===null)return null;let n=normalizeText(t),r=n.indexOf(normalizeText(e.previousToolName));return r<0?null:e.tools.filter(t=>t.name!==e.previousToolName).flatMap(e=>{let t=n.indexOf(normalizeText(e.name),r+1);return t<0?[]:[{index:t,tool:e}]}).sort((e,t)=>e.index-t.index)[0]?.tool??null}function createFollowUpToolInput(e){return isRecord(e)&&typeof e.stepKey==`string`?{stepKey:e.stepKey}:null}function getSystemPromptLabels(e){let t=e.filter(e=>e.role===`system`);if(t.length===0)return[];let n=t.flatMap(e=>{let t=getPromptContentText(e.content);if(t.startsWith(`Available skills
+`))return[];let n=t.split(`
+`).map(e=>e.trim()).filter(e=>e.length>0),r=[];for(let e of n){if(e===BOOTSTRAP_RUNTIME_SYSTEM_PROMPT||e===`Available skills`)continue;let t=/^System \((.+)\)$/.exec(e);if(t?.[1]){r.push(t[1]);continue}let n=/^Skill \((.+)\)$/.exec(e);n?.[1]&&r.push(n[1])}if(r.length>0)return r;let i=n.find(e=>e!==BOOTSTRAP_RUNTIME_SYSTEM_PROMPT&&e!==`Available skills`);return i===void 0?[]:[i]});return[...new Set(n)]}function findRelevantTool(e,t){let n=normalizeText(t),r=e.find(e=>e.name!==`agent`&&n.includes(normalizeText(e.name)));return r===void 0?/\b(forecast|temperature|weather|wind|rain|snow)\b/u.test(n)?e.find(e=>/\b(forecast|temperature|weather|wind|rain|snow)\b/u.test(normalizeText(`${e.name} ${e.description??``}`)))??null:null:r}function findRelevantCodeModeHostTool(e,t){return e===void 0?null:findRelevantTool(parseCodeModeHostTools(e),t)?.name??null}function parseCodeModeHostTools(e){let t=[],n;for(let r of e.split(`
+`)){let e=/^\s*\/\*\*\s*(.*?)\s*\*\/\s*$/u.exec(r);if(e?.[1]!==void 0){n=e[1];continue}let i=/^\s*(?:([$A-Z_a-z][$\w]*)|(["'])(.*?)\2)\s*:\s*\(input:/u.exec(r),a=i?.[1]??i?.[3];a!==void 0&&(t.push({description:n,name:a}),n=void 0)}return t}function formatCodeModeToolAccess(e){return/^[$A-Z_a-z][$\w]*$/u.test(e)?`.${e}`:`[${JSON.stringify(e)}]`}function normalizeText(e){return e.toLowerCase().replace(/[^a-z0-9]+/gu,` `).trim()}function createToolCallId(e){return`call_${e.toLowerCase().replace(/[^a-z0-9]+/gu,`_`).replace(/^_+|_+$/gu,``)||`tool`}`}function resolveSystemProbe(e){let t=e.filter(e=>e.role===`system`).map(e=>getPromptContentText(e.content)).join(`
+`);return/hmr-probe:\s*([^\n]+)/iu.exec(t)?.[1]?.trim()||null}function isWeatherPayload(e){return bootstrapWeatherPayloadSchema.safeParse(e).success}function isRecord(e){return typeof e==`object`&&!!e&&!Array.isArray(e)}export{EVE_MOCK_AUTHORED_MODELS_ENV,createMockAuthoredRuntimeModel,resolveMockAuthoredRuntimeModel,shouldMockAuthoredRuntimeModels};

package/dist/src/runtime/agent/mock-model-fixtures.d.ts

@@ -0,0 +1,11 @@
+import type { BootstrapPrompt } from "#runtime/agent/bootstrap-model-utils.js";
+export interface AvailableBootstrapTool {
+    readonly description?: string;
+    readonly inputSchema?: unknown;
+    readonly name: string;
+    readonly outputSchema?: unknown;
+}
+export declare function createMockAuthoredToolInput(tool: AvailableBootstrapTool, message: string, city: string): Record<string, unknown>;
+export declare function resolveMockFixtureToken(prompt: BootstrapPrompt): string | null;
+export declare function resolveWeatherCity(message: string): string;
+export declare function formatToolOutput(output: unknown): string;

package/dist/src/runtime/agent/mock-model-fixtures.js

@@ -0,0 +1,2 @@
+import{LOAD_SKILL_TOOL_NAME}from"#runtime/skills/fragment-context.js";import{getPromptContentText}from"#runtime/agent/bootstrap-model-utils.js";function createMockAuthoredToolInput(e,t,n){let r=getToolInputPropertyNames(e.inputSchema);return e.name===`ask_question`||hasProperties(r,[`prompt`,`options`])?createAskQuestionInput(t):r.includes(`command`)?{command:resolveShellCommand(t)}:r.includes(`topic`)||/\btopic\b/u.test(normalizeText(t))?{topic:resolveLookupTopic(t)}:r.length===1&&r[0]===`message`?{message:t}:{city:n}}function resolveMockFixtureToken(e){let n=e.filter(e=>e.role===`system`).map(e=>getPromptContentText(e.content)).join(`
+`),r=[...getLoadedSkillResultTexts(e),n];for(let e of r){let t=resolveExactFixtureReply(e);if(t!==null)return t}return null}function resolveWeatherCity(e){let t=/"city"\s*:\s*"([^"]+)"/u.exec(e);return t?.[1]?t[1].trim():(/\b(?:in|for)\s+([A-Za-z][A-Za-z\s.-]*?)(?:[?.!,]|$)/u.exec(e)??/\b([A-Z][a-z]+(?:\s+[A-Z][a-z]+)*)\b/u.exec(e))?.[1]?.trim()||`Brooklyn`}function formatToolOutput(e){if(typeof e==`string`)return e;try{return JSON.stringify(e)}catch{return String(e)}}function getLoadedSkillResultTexts(t){return t.flatMap(t=>t.role!==`tool`&&t.role!==`assistant`?[]:(typeof t.content==`string`?[t.content]:t.content).flatMap(t=>typeof t==`string`||t.type!==`tool-result`||t.toolName!==LOAD_SKILL_TOOL_NAME||t.output.type===`execution-denied`?[]:[formatToolOutput(t.output.value)]))}function resolveExactFixtureReply(e){let t=matchExactValue(/\breply\s+with\s+the\s+exact\s+string\s+(`([^`]+)`|"([^"]+)"|'([^']+)'|([^\s.]+))\s+and\s+nothing\s+else\b/iu,e);if(t!==null)return t;let n=e.split(/\r?\n/u);for(let e=0;e<n.length;e+=1){let t=n[e]?.trim()??``,r=/\breply\s+with\s+exactly(?:\s+the\s+following\s+text\s+and\s+nothing\s+else)?:\s*(.+)$/iu.exec(t);if(r?.[1])return cleanExactValue(r[1]);if(/\breply\s+with\s+exactly\s+the\s+following\s+text\s+and\s+nothing\s+else:\s*$/iu.test(t)||/\breply\s+with\s+exactly:\s*$/iu.test(t)){let t=n.slice(e+1).map(e=>e.trim()).find(e=>e.length>0);if(t!==void 0)return cleanExactValue(t)}}return matchExactValue(/\binclude\s+the\s+exact\s+token\s+(`([^`]+)`|"([^"]+)"|'([^']+)'|([^\s.]+))\s+verbatim\b/iu,e)}function matchExactValue(e,t){let n=e.exec(t);return n===null?null:cleanExactValue(n[2]??n[3]??n[4]??n[5]??n[1]??``)}function cleanExactValue(e){return e.trim()}function getToolInputPropertyNames(e){return!isRecord(e)||!isRecord(e.properties)?[]:Object.keys(e.properties)}function hasProperties(e,t){return t.every(t=>e.includes(t))}function createAskQuestionInput(e){let t=parseInputOptions(e),n={prompt:resolveQuestionPrompt(e)};return t.length>0&&(n.options=t),/\ballow\s*freeform\s+(?:to\s+)?true\b|\ballowfreeform\s+(?:to\s+)?true\b/iu.test(e)&&(n.allowFreeform=!0),n}function parseInputOptions(e){return[...e.matchAll(/\bid\b\s*:?\s*"([^"]+)"\s*,\s*label\b\s*:?\s*"([^"]+)"/giu)].map(e=>({id:e[1]??``,label:e[2]??``}))}function resolveQuestionPrompt(e){let t=/\b(?:set\s+)?prompt\s+to:\s*'([^']+)'/iu.exec(e)??/\b(?:set\s+)?prompt\s+to:\s*"([^"]+)"/iu.exec(e);return t?.[1]?t[1].trim():/\bask(?:\s+me)?\s+(?:to\s+)?(.+?)(?:\.|$)/iu.exec(e)?.[1]?.trim()||`Please choose an option.`}function resolveShellCommand(e){let t=/`([^`]+)`/u.exec(e);return t?.[1]?t[1].trim():(/\b(?:run|command)\s+["']([^"']+)["']/iu.exec(e)??/\bcommand\s+(.+?)(?:\.|$)/iu.exec(e))?.[1]?.trim()||`pwd`}function resolveLookupTopic(e){return/\btopic\s+['"]?([A-Za-z0-9_.-]+)['"]?/u.exec(e)?.[1]??`demo`}function normalizeText(e){return e.toLowerCase().replace(/[^a-z0-9]+/gu,` `).trim()}function isRecord(e){return typeof e==`object`&&!!e&&!Array.isArray(e)}export{createMockAuthoredToolInput,formatToolOutput,resolveMockFixtureToken,resolveWeatherCity};

package/dist/src/runtime/agent/mock-model-skill-selection.d.ts

@@ -0,0 +1,9 @@
+import type { BootstrapPrompt } from "#runtime/agent/bootstrap-model-utils.js";
+interface AvailableBootstrapSkill {
+    readonly description: string;
+    readonly name: string;
+}
+export declare function getAvailableSkills(prompt: BootstrapPrompt): AvailableBootstrapSkill[];
+export declare function findRelevantSkill(skills: readonly AvailableBootstrapSkill[], message: string): AvailableBootstrapSkill | null;
+export declare function getActivatedSkillIds(prompt: BootstrapPrompt): string[];
+export {};

package/dist/src/runtime/agent/mock-model-skill-selection.js

@@ -0,0 +1,4 @@
+import{getPromptContentText}from"#runtime/agent/bootstrap-model-utils.js";function getAvailableSkills(t){let n=new Map;for(let r of t){if(r.role!==`system`)continue;let t=getPromptContentText(r.content);if(t.startsWith(`Available skills
+`))for(let e of t.split(`
+`).slice(1)){let t=parseAvailableSkill(e);t!==null&&n.set(t.name,t)}}return[...n.values()]}function findRelevantSkill(e,t){let n=normalizeText(t);for(let t of e)if(n.includes(normalizeText(t.name)))return t;return/\b(forecast|temperature|weather|wind|rain|snow)\b/u.test(n)?e.find(e=>/\b(forecast|temperature|weather|wind|rain|snow)\b/u.test(normalizeText(`${e.name} ${e.description}`)))??null:null}function getActivatedSkillIds(t){return t.filter(e=>e.role===`system`).flatMap(t=>getPromptContentText(t.content).split(`
+`).map(e=>e.trim()).flatMap(e=>{let t=/^Skill \((.+)\)$/.exec(e);return t?.[1]===void 0?[]:[t[1]]}))}function parseAvailableSkill(e){let t=/^- (.+?): (.+?)(?: \(path: (.+)\))?$/.exec(e.trim());return t?.[1]&&t[2]?{description:t[2],name:t[1]}:null}function normalizeText(e){return e.toLowerCase().replace(/[^a-z0-9]+/gu,` `).trim()}export{findRelevantSkill,getActivatedSkillIds,getAvailableSkills};

package/dist/src/runtime/agent/mock-structured-output.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Builds a deterministic sample value satisfying a JSON Schema, used by the
+ * mock model to populate a `final_output` tool call in tests.
+ */
+export declare function createJsonSchemaSample(schema: unknown): unknown;

package/dist/src/runtime/agent/mock-structured-output.js

@@ -0,0 +1 @@
+function createJsonSchemaSample(e){if(!isRecord(e))return{};if(`const`in e)return e.const;if(Array.isArray(e.enum)&&e.enum.length>0)return e.enum[0];let t=getFirstSchema(e.oneOf)??getFirstSchema(e.anyOf);if(t!==void 0)return createJsonSchemaSample(t);switch(getJsonSchemaType(e)){case`array`:return[createJsonSchemaSample(getFirstSchema(e.items)??e.items)];case`boolean`:return!0;case`integer`:case`number`:return 1;case`null`:return null;case`object`:return createJsonSchemaObjectSample(e);case`string`:return createJsonSchemaStringSample(e);default:return isRecord(e.properties)?createJsonSchemaObjectSample(e):e.items===void 0?{}:[createJsonSchemaSample(getFirstSchema(e.items)??e.items)]}}function createJsonSchemaObjectSample(e){let t=isRecord(e.properties)?e.properties:{},n=Array.isArray(e.required)?e.required.filter(e=>typeof e==`string`):[],r=new Set([...n,...Object.keys(t)]),i={};for(let e of r)i[e]=createJsonSchemaSample(t[e]);return i}function createJsonSchemaStringSample(e){switch(e.format){case`date`:return`2026-01-01`;case`date-time`:return`2026-01-01T00:00:00.000Z`;case`email`:return`eve@example.com`;case`uri`:return`https://example.com`;default:return`structured-output`}}function getJsonSchemaType(e){if(typeof e.type==`string`)return e.type;if(Array.isArray(e.type))return e.type.find(e=>typeof e==`string`&&e!==`null`)}function getFirstSchema(e){return Array.isArray(e)?e[0]:e}function isRecord(e){return typeof e==`object`&&!!e&&!Array.isArray(e)}export{createJsonSchemaSample};

package/dist/src/runtime/agent/resolve-model.d.ts

@@ -0,0 +1,11 @@
+import type { LanguageModel } from "ai";
+import type { RuntimeCompiledArtifactsSource } from "#runtime/compiled-artifacts-source.js";
+import type { RuntimeModelReference } from "#runtime/agent/bootstrap.js";
+import { EVE_MOCK_AUTHORED_MODELS_ENV, shouldMockAuthoredRuntimeModels } from "#runtime/agent/mock-model-adapter.js";
+export { EVE_MOCK_AUTHORED_MODELS_ENV, shouldMockAuthoredRuntimeModels };
+/**
+ * Resolves one runtime model reference into the active language model.
+ */
+export declare function resolveRuntimeModelReference(reference: RuntimeModelReference, input?: {
+    readonly compiledArtifactsSource?: RuntimeCompiledArtifactsSource;
+}): Promise<LanguageModel>;

package/dist/src/runtime/agent/resolve-model.js

@@ -0,0 +1 @@
+import{expectObjectRecord,getAuthoredModuleExport,materializeAuthoredModuleExport}from"#internal/authored-module.js";import{ROOT_COMPILED_AGENT_NODE_ID}from"#compiler/manifest.js";import{normalizeAgentDefinition}from"#internal/authored-definition/core.js";import{loadCompiledModuleMap}from"#runtime/loaders/module-map.js";import{resolveBootstrapRuntimeModel}from"#runtime/agent/bootstrap-model.js";import{EVE_MOCK_AUTHORED_MODELS_ENV,resolveMockAuthoredRuntimeModel,shouldMockAuthoredRuntimeModels}from"#runtime/agent/mock-model-adapter.js";async function resolveRuntimeModelReference(e,t={}){let n=resolveBootstrapRuntimeModel(e);if(n!==null)return n;let r=resolveMockAuthoredRuntimeModel(e);return r===null?isSourceBackedRuntimeModelReference(e)?await loadSourceBackedRuntimeModelReference(e,t):e.id:r}async function loadSourceBackedRuntimeModelReference(i,a){if(a.compiledArtifactsSource===void 0)throw Error(`Expected an explicit compiled artifact source to resolve the authored runtime model "${i.id}".`);let o=(await loadCompiledModuleMap({compiledArtifactsSource:a.compiledArtifactsSource})).nodes[ROOT_COMPILED_AGENT_NODE_ID]?.modules[i.source.sourceId],s=normalizeAgentDefinition(await materializeAuthoredModuleExport(getAuthoredModuleExport(expectObjectRecord(o,`Missing compiled agent config module for runtime model "${i.id}" at "${i.source.logicalPath}".`),i.source)),`Expected the authored agent config export "${i.source.exportName??`default`}" from "${i.source.logicalPath}" to match the public Eve shape.`).model;if(s===void 0)throw Error(`Expected the authored agent config export "${i.source.exportName??`default`}" from "${i.source.logicalPath}" to provide a runtime model.`);return s}function isSourceBackedRuntimeModelReference(e){return e.source!==void 0}export{EVE_MOCK_AUTHORED_MODELS_ENV,resolveRuntimeModelReference,shouldMockAuthoredRuntimeModels};

package/dist/src/runtime/attributes/emit.d.ts

@@ -0,0 +1,73 @@
+import "#internal/workflow/builtins.js";
+/**
+ * Maximum byte size for an attribute value on a workflow run.
+ *
+ * Local mirror of `ATTRIBUTE_VALUE_MAX_BYTES` from `@workflow/world`
+ * (source of truth: `packages/world/src/attributes.ts` in the workflow
+ * repo). The value is duplicated rather than imported because
+ * `@workflow/core` — the only workflow surface bundled into the
+ * workflow body — does not re-export it, and pulling `@workflow/world`
+ * into the body bundle would drag in the full zod attribute validator
+ * (the same reason `workflow-core-shim.ts` skips runtime validation in
+ * its `experimental_setAttributes`).
+ *
+ * Strings emitted through {@link setEveAttributes} are truncated to this
+ * byte count before they reach the runtime so the validator never
+ * rejects a tag for length alone.
+ *
+ * Drift is conservative-by-construction: if workflow LOWERS the limit,
+ * over-long values are rejected and `setEveAttributes` swallows the
+ * failure (warn-once-per-process) — dashboards see a missing tag, never
+ * a broken agent; if workflow RAISES it, titles are merely shorter than
+ * necessary. `emit.drift.test.ts` asserts equality against the real
+ * `@workflow/world` export (a devDependency) so CI fails loudly the day
+ * the constants diverge.
+ */
+export declare const EVE_ATTRIBUTE_VALUE_MAX_BYTES = 256;
+/**
+ * Attribute value the caller wants to write. `undefined` values are
+ * stripped before the runtime call; numbers are stringified; strings
+ * are truncated to {@link EVE_ATTRIBUTE_VALUE_MAX_BYTES}.
+ */
+export type EveAttributeValue = string | number | undefined;
+/**
+ * Truncates a string so its UTF-8 byte length is at most `maxBytes`
+ * without splitting a multi-byte character.
+ *
+ * The workflow runtime measures attribute values in UTF-8 bytes, not
+ * code units, so `value.slice(0, maxBytes)` is not safe — a JS string
+ * with two-byte characters (e.g. emoji surrogate pairs) can serialize
+ * to twice as many bytes as code units. We re-encode the truncated
+ * candidate after each drop and shrink one code unit at a time when
+ * the candidate's last character straddles the byte budget.
+ */
+export declare function truncateForTag(value: string, maxBytes?: number): string;
+/**
+ * Writes a batch of Eve-owned attributes to the active workflow run.
+ *
+ * Reserved-namespace contract:
+ * - All keys must use the `$eve.` prefix (the workflow runtime would
+ *   otherwise reject them as user-space writes into the reserved `$`
+ *   namespace).
+ * - The call always opts in via `{ allowReservedAttributes: true }`
+ *   on behalf of the framework — authored code never calls this helper
+ *   directly.
+ *
+ * Value normalization:
+ * - `undefined` entries are dropped so callers can build attribute
+ *   maps with optional fields (`$eve.subagent` is only present on
+ *   subagent roots, for example).
+ * - Numbers are stringified (the runtime stores all values as strings).
+ * - Strings are truncated to {@link EVE_ATTRIBUTE_VALUE_MAX_BYTES} via
+ *   {@link truncateForTag} so a long free-form value (e.g. `$eve.title`)
+ *   can never trip the runtime's per-value byte budget.
+ *
+ * Failure policy: tag writes are observability metadata, not load-bearing
+ * state. A failure inside the runtime (transient network, schema bug,
+ * missing world adapter) is logged once per process and then swallowed
+ * so the Eve session it tagged is unaffected.
+ *
+ * Must be called from inside a `"use workflow"` or `"use step"` body —
+ * the runtime throws a `FatalError` outside those contexts.
+ */
+export declare function setEveAttributes(attrs: Record<string, EveAttributeValue>): Promise<void>;

package/dist/src/runtime/attributes/emit.js

@@ -0,0 +1 @@
+import"#internal/workflow/builtins.js";const EVE_ATTRIBUTE_VALUE_MAX_BYTES=256;let WARNED_ABOUT_TAG_FAILURE=!1;function truncateForTag(e,t=256){if(t<=0)return``;let n=new TextEncoder;if(n.encode(e).length<=t)return e;let r=e.length;for(;r>0;){let i=e.charCodeAt(r-1);if(i>=55296&&i<=56319){--r;continue}let a=e.slice(0,r);if(n.encode(a).length<=t)return a;--r}return``}async function setEveAttributes(e){let n={};for(let[t,r]of Object.entries(e))r!==void 0&&(n[t]=truncateForTag(typeof r==`number`?String(r):r));if(Object.keys(n).length!==0)try{let{experimental_setAttributes:e}=await import(`#compiled/@workflow/core/index.js`);await e(n,{allowReservedAttributes:!0})}catch(e){WARNED_ABOUT_TAG_FAILURE||(WARNED_ABOUT_TAG_FAILURE=!0,console.warn(`[eve] setEveAttributes failed; suppressing further warnings this process.`,{keys:Object.keys(n),error:e.message}))}}export{EVE_ATTRIBUTE_VALUE_MAX_BYTES,setEveAttributes,truncateForTag};

package/dist/src/runtime/cache-key.d.ts

@@ -0,0 +1,9 @@
+import { type RuntimeCompiledArtifactsSource } from "#runtime/compiled-artifacts-source.js";
+/**
+ * Resolves a cache key for one compiled-artifact source that also fingerprints
+ * the current compiled source graph when metadata is available.
+ *
+ * This lets long-lived processes keep cache hits across turns while still
+ * invalidating naturally after recompilation under the same app root.
+ */
+export declare function resolveRuntimeCompiledArtifactsVersionedCacheKey(source: RuntimeCompiledArtifactsSource): Promise<string>;

package/dist/src/runtime/cache-key.js

@@ -0,0 +1 @@
+import{getRuntimeCompiledArtifactsCacheKey}from"#runtime/compiled-artifacts-source.js";import{loadCompileMetadata}from"#runtime/loaders/compile-metadata.js";import{resolveRuntimeCompilerArtifactPaths}from"#runtime/loaders/artifact-paths.js";async function resolveRuntimeCompiledArtifactsVersionedCacheKey(n){let r=getRuntimeCompiledArtifactsCacheKey(n),i=await resolveCompileMetadataMtimeMs(n);try{let e=(await loadCompileMetadata({compiledArtifactsSource:n}))?.discovery.sourceGraphHash;return e===void 0||e.length===0?i===void 0?r:`${r}:mtime-${formatMtimeMsForCacheKey(i)}`:i===void 0?`${r}:${e}`:`${r}:${e}:mtime-${formatMtimeMsForCacheKey(i)}`}catch{return i===void 0?r:`${r}:mtime-${formatMtimeMsForCacheKey(i)}`}}async function resolveCompileMetadataMtimeMs(e){if(e.kind!==`disk`)return;let{stat:t}=await import(`node:fs/promises`),{compileMetadataPath:r}=resolveRuntimeCompilerArtifactPaths(e.appRoot);try{return(await t(r)).mtimeMs}catch{return}}function formatMtimeMsForCacheKey(e){return Math.floor(e).toString(36)}export{resolveRuntimeCompiledArtifactsVersionedCacheKey};

package/dist/src/runtime/channels/registry.d.ts

@@ -0,0 +1,27 @@
+import type { ChannelAdapter } from "#channel/adapter.js";
+import type { ResolvedChannelDefinition } from "#runtime/types.js";
+/**
+ * Runtime-owned registry of adapter configs keyed by adapter kind.
+ * Used to rebuild adapter instances (with behavior functions) after
+ * workflow step boundaries.
+ */
+export interface RuntimeAdapterRegistry {
+    readonly adaptersByKind: ReadonlyMap<string, ChannelAdapter>;
+}
+/**
+ * Builds the runtime-owned adapter registry from framework adapters plus any
+ * custom adapters declared on resolved route definitions.
+ *
+ * Route-declared adapters may share framework kinds only as pass-throughs.
+ */
+export declare function createRuntimeAdapterRegistry(input: {
+    readonly channels: readonly ResolvedChannelDefinition[];
+}): RuntimeAdapterRegistry;
+/**
+ * Rehydrates one serialized adapter from the runtime-owned registry.
+ *
+ * Looks up the adapter config by `kind`, then merges the serialized state
+ * onto it. The result is a full adapter with behavior functions and
+ * restored state.
+ */
+export declare function deserializeRuntimeAdapter(registry: RuntimeAdapterRegistry, data: unknown): ChannelAdapter;

package/dist/src/runtime/channels/registry.js

@@ -0,0 +1 @@
+import{getAdapterKind}from"#channel/adapter.js";import{SUBAGENT_ADAPTER}from"#execution/subagent-adapter.js";import{SCHEDULE_ADAPTER}from"#channel/schedule.js";import{HTTP_ADAPTER}from"#channel/http.js";import{RuntimeRegistryError}from"#internal/runtime-registry.js";const FRAMEWORK_ADAPTERS=[HTTP_ADAPTER,SUBAGENT_ADAPTER,SCHEDULE_ADAPTER],ADAPTER_NON_EVENT_FIELDS=new Set([`kind`,`state`,`deliver`,`createAdapterContext`,`fetchFile`,`instrumentation`]);function createRuntimeAdapterRegistry(e){let t=new Map,n=new Set;for(let e of FRAMEWORK_ADAPTERS){let r=requireAdapterKind(e);n.add(r),t.set(r,e)}for(let r of e.channels){if(r.adapter===void 0)continue;let e={logicalPath:r.logicalPath,sourceId:r.sourceId},i=r.adapter,a=requireAdapterKind(i,e);if(n.has(a)){if(carriesAdapterBehavior(i))throw new RuntimeRegistryError(`adapter`,`Channel adapter kind "${a}" is reserved by the framework. A route-declared adapter may share a framework kind only as a pass-through with no \`deliver\` hook, event handlers, \`attachments\` resolver, or \`createAdapterContext\` factory. Use a custom \`kind\` to add channel-specific behavior.`,{...e,entryName:a});continue}t.set(a,i)}return{adaptersByKind:t}}function deserializeRuntimeAdapter(e,t){let n=t,r=e.adaptersByKind.get(n.kind);if(r===void 0)throw Error(`Unknown adapter kind: "${n.kind}". Declare the adapter on the route that starts this session so the runtime can rehydrate it.`);return{...r,state:n.state}}function requireAdapterKind(t,n){let r=getAdapterKind(t);if(typeof r!=`string`||r.length===0)throw new RuntimeRegistryError(`adapter`,"Adapters must declare a non-empty `kind` field.",{entryName:`unknown`,logicalPath:n?.logicalPath,sourceId:n?.sourceId});return r}function carriesAdapterBehavior(e){if(e.deliver!==void 0||e.fetchFile!==void 0||e.createAdapterContext!==void 0)return!0;for(let[t,n]of Object.entries(e))if(!ADAPTER_NON_EVENT_FIELDS.has(t)&&typeof n==`function`)return!0;return!1}export{createRuntimeAdapterRegistry,deserializeRuntimeAdapter};

package/dist/src/runtime/compiled-artifacts-source.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Runtime-owned compiled-artifact source for one resolved agent graph.
+ */
+export type RuntimeCompiledArtifactsSource = RuntimeBundledCompiledArtifactsSource | RuntimeDiskCompiledArtifactsSource;
+/**
+ * Bundled compiled artifacts installed in-process beside runtime workflow
+ * entrypoints.
+ */
+export interface RuntimeBundledCompiledArtifactsSource {
+    readonly kind: "bundled";
+}
+/**
+ * Disk-backed compiled artifacts rooted at one authored application.
+ */
+export interface RuntimeDiskCompiledArtifactsSource {
+    readonly appRoot: string;
+    readonly kind: "disk";
+    /**
+     * Native filesystem path to the package-owned authored-source module map
+     * loader. When set, the runtime loads modules directly from authored
+     * source instead of the bundled-compiled module map. Omitted in deployed
+     * runtimes, where the module map must come from the compiled artifact
+     * emitted by the build.
+     */
+    readonly moduleMapLoaderPath?: string;
+}
+/**
+ * Creates the bundled compiled-artifact source.
+ */
+export declare function createBundledRuntimeCompiledArtifactsSource(): RuntimeBundledCompiledArtifactsSource;
+/**
+ * Creates the disk-backed compiled-artifact source for one authored app root.
+ */
+export declare function createDiskRuntimeCompiledArtifactsSource(appRoot: string, options?: {
+    readonly moduleMapLoaderPath?: string;
+}): RuntimeDiskCompiledArtifactsSource;
+/**
+ * Returns the disk-backed app root when one exists for the artifact source.
+ */
+export declare function getRuntimeCompiledArtifactsAppRoot(source: RuntimeCompiledArtifactsSource): string | undefined;
+/**
+ * Returns the stable cache key for one runtime artifact source.
+ */
+export declare function getRuntimeCompiledArtifactsCacheKey(source: RuntimeCompiledArtifactsSource): string;

package/dist/src/runtime/compiled-artifacts-source.js

@@ -0,0 +1 @@
+function createBundledRuntimeCompiledArtifactsSource(){return{kind:`bundled`}}function createDiskRuntimeCompiledArtifactsSource(e,t={}){return t.moduleMapLoaderPath===void 0?{appRoot:e,kind:`disk`}:{appRoot:e,kind:`disk`,moduleMapLoaderPath:t.moduleMapLoaderPath}}function getRuntimeCompiledArtifactsAppRoot(e){return e.kind===`disk`?e.appRoot:void 0}function getRuntimeCompiledArtifactsCacheKey(e){return e.kind===`disk`?e.moduleMapLoaderPath===void 0?`disk:${e.appRoot}`:`disk:${e.appRoot}:authored-source:${e.moduleMapLoaderPath}`:`bundled`}export{createBundledRuntimeCompiledArtifactsSource,createDiskRuntimeCompiledArtifactsSource,getRuntimeCompiledArtifactsAppRoot,getRuntimeCompiledArtifactsCacheKey};

package/dist/src/runtime/connections/authorization-complete-page.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Renders the static HTML landing page that the user's browser sees
+ * after an OAuth IdP redirects back to the framework's connection
+ * callback route.
+ *
+ * The framework would otherwise respond with an empty `202 Accepted`
+ * body, which looks broken. This helper is intentionally self-contained:
+ * no external assets, no script, so it renders identically regardless
+ * of where the runtime serves the callback from.
+ */
+export declare function buildAuthorizationCompletePage(): Response;

package/dist/src/runtime/connections/authorization-complete-page.js

@@ -0,0 +1,53 @@
+function buildAuthorizationCompletePage(){return new Response(`<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>Authorization complete</title>
+    <style>
+      :root {
+        color-scheme: light dark;
+        --bg: #fafafa;
+        --fg: #111111;
+        --muted: #525252;
+        --card-bg: #ffffff;
+        --card-border: #e5e5e5;
+      }
+      @media (prefers-color-scheme: dark) {
+        :root {
+          --bg: #0a0a0a;
+          --fg: #fafafa;
+          --muted: #a3a3a3;
+          --card-bg: #171717;
+          --card-border: #262626;
+        }
+      }
+      body {
+        margin: 0;
+        min-height: 100vh;
+        display: grid;
+        place-items: center;
+        font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif;
+        background: var(--bg);
+        color: var(--fg);
+      }
+      .card {
+        max-width: 28rem;
+        padding: 2rem 2.25rem;
+        border: 1px solid var(--card-border);
+        border-radius: 12px;
+        background: var(--card-bg);
+        color: var(--fg);
+        text-align: center;
+      }
+      h1 { font-size: 1.25rem; margin: 0 0 0.5rem; color: var(--fg); }
+      p { margin: 0; color: var(--muted); line-height: 1.5; }
+    </style>
+  </head>
+  <body>
+    <main class="card">
+      <h1>Authorization complete</h1>
+      <p>You can close this tab and return to your app.</p>
+    </main>
+  </body>
+</html>`,{headers:{"cache-control":`no-store`,"content-type":`text/html; charset=utf-8`},status:200})}export{buildAuthorizationCompletePage};

package/dist/src/runtime/connections/authorization-tokens.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Per-step cache of resolved connection authorization tokens.
+ *
+ * Keyed by `(connectionName, principalKey)` so two users on the same
+ * session never share a user-scoped token. Stored as a virtual
+ * context value and wiped between workflow steps, so bearer tokens
+ * are never serialized into the durable step payload. Cross-step
+ * reuse is delegated to the upstream authorization provider (for
+ * example Connect's server-side cache), which owns the refresh grant.
+ *
+ * TODO(eve): once a server-derivable session key is available, promote
+ * this back to durable context via an AEAD codec so cross-step reuse
+ * is possible without exposing plaintext bearers in the WDK payload.
+ */
+import type { AlsContext } from "#context/container.js";
+import { ContextKey } from "#context/key.js";
+import type { TokenResult } from "#runtime/connections/types.js";
+/**
+ * Virtual context key mapping connection name to a per-principal
+ * {@link TokenResult} cache.
+ *
+ * The principal sub-key is produced by
+ * {@link principalKey} so identical string keys (for example
+ * `"user:${issuer}:${id}"`) collide only when the resolved principal
+ * genuinely matches.
+ */
+export declare const ConnectionAuthorizationTokensKey: ContextKey<Readonly<Record<string, Readonly<Record<string, TokenResult>>>>>;
+/**
+ * Returns the cached {@link TokenResult} for
+ * `(connectionName, principalKey)` when the entry is still valid
+ * (not expired). Expired entries are treated as a cache miss so
+ * callers re-run the authorization flow.
+ */
+export declare function readCachedToken(ctx: AlsContext, connectionName: string, principalKey: string): TokenResult | undefined;
+/**
+ * Persists a freshly resolved {@link TokenResult} on the cache under
+ * `(connectionName, principalKey)`. Existing entries for other
+ * principals on the same connection are left in place.
+ *
+ * Writes to the virtual context slot so the bearer is never serialized
+ * into the durable step payload. See the module docblock.
+ */
+export declare function writeCachedToken(ctx: AlsContext, connectionName: string, principalKey: string, token: TokenResult): void;
+/**
+ * Drops the cached {@link TokenResult} for `(connectionName, principalKey)`,
+ * if present. Used when the remote server rejects an already-resolved
+ * bearer (HTTP 401) so the subsequent re-authorization attempt does not
+ * re-read the stale token from the per-step cache. No-op when nothing is
+ * cached for the principal.
+ */
+export declare function evictCachedToken(ctx: AlsContext, connectionName: string, principalKey: string): void;

package/dist/src/runtime/connections/authorization-tokens.js

@@ -0,0 +1 @@
+import{ContextKey}from"#context/key.js";const ConnectionAuthorizationTokensKey=new ContextKey(`eve.connectionAuthorizationTokens`);function readCachedToken(e,t,n){let r=e.get(ConnectionAuthorizationTokensKey)?.[t]?.[n];if(r!==void 0&&!(r.expiresAt!==void 0&&r.expiresAt<=Date.now()))return r}function writeCachedToken(e,t,n,r){let i=e.get(ConnectionAuthorizationTokensKey)??{},a=i[t]??{};asContainer(e).setVirtualContext(ConnectionAuthorizationTokensKey,{...i,[t]:{...a,[n]:r}})}function evictCachedToken(e,t,n){let r=e.get(ConnectionAuthorizationTokensKey),i=r?.[t];if(r===void 0||i===void 0||i[n]===void 0)return;let{[n]:a,...o}=i;asContainer(e).setVirtualContext(ConnectionAuthorizationTokensKey,{...r,[t]:o})}function asContainer(e){return e}export{ConnectionAuthorizationTokensKey,evictCachedToken,readCachedToken,writeCachedToken};

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

@@ -0,0 +1,55 @@
+/**
+ * Framework-shipped callback route used by in-turn interactive
+ * connection authorization.
+ *
+ * The route at {@link EVE_CONNECTION_CALLBACK_ROUTE_PATTERN} is the
+ * redirect target the workflow body hands to the IdP via
+ * `startAuthorization`. When the IdP redirects the user's browser back
+ * with the OAuth `code`/`state` (or whatever payload the protocol
+ * carries), this handler:
+ *
+ * 1. Parses the inbound request into a JSON-serializable
+ *    {@link AuthorizationCallback} (params only — never request headers).
+ * 2. Calls `resumeHook(token, payload)` to wake the suspended workflow.
+ * 3. Renders the standard "Authorization complete" landing page so the
+ *    user sees a friendly UI instead of an empty `202 Accepted`.
+ *
+ * Owning this route in the framework - instead of routing the IdP at the
+ * workflow runtime's raw `/.well-known/workflow/v1/webhook/:token` -
+ * keeps the public surface namespaced under Eve and lets the framework
+ * decide delivery policy (auth, throttling, logging) for connection
+ * callbacks without leaking generic workflow primitives to the public
+ * internet.
+ */
+import type { RouteContext } from "#public/definitions/channel.js";
+import type { ResolvedChannelDefinition } from "#runtime/types.js";
+/**
+ * Logical name prefix of the framework-shipped connection callback
+ * channel. The trailing method segment (`get` or `post`) keeps each
+ * `(method, urlPath)` pair distinct in the channel registry.
+ */
+export declare const HTTP_CONNECTION_CALLBACK_CHANNEL_NAME_PREFIX = "eve/v1/connections/callback";
+/**
+ * Returns the framework-shipped channel definitions that mount the
+ * connection callback route at {@link EVE_CONNECTION_CALLBACK_ROUTE_PATTERN}.
+ *
+ * Returns one definition per accepted HTTP method (see
+ * {@link HANDLED_METHODS}). The framework channel resolver mounts each
+ * `(method, urlPath)` pair as a separate Nitro route; sharing one URL
+ * pattern across multiple methods is not supported by the channel
+ * model.
+ */
+export declare function getConnectionCallbackChannelDefinitions(): readonly ResolvedChannelDefinition[];
+/**
+ * Returns the set of logical channel names registered by the connection
+ * callback route. Used by `getAllFrameworkChannelNames` so authors who
+ * `disableRoute()` one of these names get a useful diagnostic instead
+ * of a silent no-op.
+ */
+export declare function getConnectionCallbackChannelNames(): ReadonlySet<string>;
+/**
+ * Inbound handler for the connection callback route. Exported for test
+ * coverage; the framework channel resolver wires it into Nitro via
+ * {@link getConnectionCallbackChannelDefinitions}.
+ */
+export declare function handleConnectionCallbackRequest(request: Request, ctx: RouteContext): Promise<Response>;

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

@@ -0,0 +1 @@
+import{EVE_CONNECTION_CALLBACK_ROUTE_PATTERN}from"#protocol/routes.js";import{resumeHook}from"#compiled/@workflow/core/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`];function getConnectionCallbackChannelDefinitions(){return HANDLED_METHODS.map(e=>buildCallbackChannelDefinition(e))}function getConnectionCallbackChannelNames(){return new Set(HANDLED_METHODS.map(channelNameForMethod))}function buildCallbackChannelDefinition(t){let n=channelNameForMethod(t);return{name:n,method:t,urlPath:EVE_CONNECTION_CALLBACK_ROUTE_PATTERN,fetch:handleConnectionCallbackRequest,logicalPath:`framework://channels/${n}`,sourceId:`eve:framework:connection-callback-${t.toLowerCase()}`,sourceKind:`module`}}function channelNameForMethod(e){return`${HTTP_CONNECTION_CALLBACK_CHANNEL_NAME_PREFIX}/${e.toLowerCase()}`}async function handleConnectionCallbackRequest(e,r){let i=r.params.name,a=r.params.token;if(typeof i!=`string`||i.length===0)return Response.json({error:`Missing connection name.`,ok:!1},{status:400});if(typeof a!=`string`||a.length===0)return Response.json({error:`Missing callback token.`,ok:!1},{status:400});let o=await projectAuthorizationCallback(e);try{await resumeHook(a,{kind:`deliver`,payloads:[{authorizationCallback:{connectionName:i,callback:o}}]})}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/connections/mcp-client.d.ts

@@ -0,0 +1,74 @@
+import { type MCPClient } from "#compiled/@ai-sdk/mcp/index.js";
+import type { ToolSet } from "ai";
+import type { ResolvedConnectionDefinition } from "#runtime/types.js";
+import type { ConnectionClient, ConnectionToolMetadata, ToolFilterDefinition } from "#runtime/connections/types.js";
+/**
+ * Wraps one `MCPClient` from `@ai-sdk/mcp` for a single connection.
+ *
+ * Created lazily per-connection per-session. Caches tool metadata after
+ * the first `getToolMetadata()` call.
+ */
+export declare class McpConnectionClient implements ConnectionClient {
+    #private;
+    constructor(connection: ResolvedConnectionDefinition);
+    /**
+     * Connects to the MCP server, trying Streamable HTTP first and
+     * falling back to SSE for transport-compatibility failures.
+     *
+     * Concurrent callers share the same connection promise to avoid
+     * duplicate connections.
+     */
+    connect(): Promise<MCPClient>;
+    /**
+     * Returns cached tool metadata for all tools this connection exposes,
+     * after applying any configured tool filter.
+     *
+     * The first call fetches tools from the server via `listTools()` and
+     * creates the AI SDK tool set in parallel. Subsequent calls return
+     * the cached result. Concurrent callers share the same in-flight
+     * promise.
+     */
+    getToolMetadata(): Promise<readonly ConnectionToolMetadata[]>;
+    /**
+     * Returns the AI SDK `ToolSet` produced by `@ai-sdk/mcp`'s
+     * `toolsFromDefinitions()`. Each entry is a full SDK `Tool` with
+     * `inputSchema`, `description`, and `execute` already set.
+     */
+    getTools(): Promise<ToolSet>;
+    /**
+     * Executes a named tool through the AI SDK's tool executor, which
+     * handles the JSON-RPC `tools/call` internally.
+     *
+     * A `401`/`invalid_token` from the remote server is translated into
+     * {@link ConnectionAuthorizationRequiredError} via {@link #rethrowClassified}
+     * so callers re-enter the authorization flow instead of surfacing an
+     * opaque transport error.
+     */
+    executeTool(toolName: string, args: unknown): Promise<unknown>;
+    close(): Promise<void>;
+}
+/**
+ * Returns `true` when an error from the MCP transport indicates the
+ * bearer was rejected by the remote server — an HTTP `401`. Per
+ * RFC 6750 a `401` means the access token is missing, expired, or
+ * revoked, all of which are recoverable by re-authorizing. (A `403`
+ * is an insufficient-scope / permission problem and is intentionally
+ * left to propagate, since re-running the same grant would not help.)
+ */
+export declare function isMcpAuthRequiredError(error: unknown): boolean;
+/**
+ * Returns `true` when a tool name passes the configured filter.
+ */
+export declare function passesToolFilter(toolName: string, filter: Readonly<ToolFilterDefinition> | undefined): boolean;
+/**
+ * Merges `authorization` (Bearer token) and `headers` into one
+ * flat `Record<string, string>` for the transport layer.
+ *
+ * Resolves the {@link ConnectionPrincipal} from the active session
+ * and invokes
+ * `authorization.getToken({ principal })` to produce the bearer.
+ * `getToken` may throw {@link ConnectionAuthorizationRequiredError};
+ * callers (`connection_search`, wrapped connection tools) catch it
+ * and it propagates as-is from here.
+ */
+export declare function resolveHeaders(connection: ResolvedConnectionDefinition): Promise<Record<string, string>>;

package/dist/src/runtime/connections/mcp-client.js

@@ -0,0 +1 @@
+import{isObject}from"#shared/guards.js";import{contextStorage}from"#context/container.js";import{ConnectionAuthorizationRequiredError}from"#public/connections/errors.js";import{resolveScopedToken}from"#runtime/connections/scoped-authorization.js";import{createMCPClient}from"#compiled/@ai-sdk/mcp/index.js";import{evictCachedToken}from"#runtime/connections/authorization-tokens.js";import{principalKey,resolveConnectionPrincipal}from"#runtime/connections/principal.js";var McpConnectionClient=class{#e;#t;#n;#r;#i;constructor(e){this.#i=e}async connect(){if(this.#t!==void 0)return this.#t;if(this.#e!==void 0)return this.#e;this.#e=this.#a();try{return this.#t=await this.#e,this.#t}catch(e){throw this.#e=void 0,e}}async#a(){let e=await resolveHeaders(this.#i),t=this.#i.url;try{return await createMCPClient({transport:{type:`http`,url:t,headers:e}})}catch(n){if(!isMcpHttpFallbackRetryableError(n))throw n;return await createMCPClient({transport:{type:`sse`,url:t,headers:e}})}}async getToolMetadata(){return(await this.#o()).metadata}async getTools(){return(await this.#o()).tools}async executeTool(e,t){try{let{tools:n}=await this.#o(),r=n[e];if(r?.execute===void 0)throw Error(`Tool "${e}" not found in connection "${this.#i.connectionName}".`);return await r.execute(t,{})}catch(e){return await this.#l(e)}}async#o(){if(this.#r!==void 0)return this.#r;if(this.#n!==void 0)return this.#n;this.#n=this.#s();try{return this.#r=await this.#n,this.#r}catch(e){throw this.#n=void 0,e}}async#s(){try{return await this.#c()}catch(e){return await this.#l(e)}}async#c(){let e=await this.connect(),t=await e.listTools(),n=this.#i.tools,r=n===void 0?t.tools:t.tools.filter(e=>passesToolFilter(e.name,n)),i=e.toolsFromDefinitions({tools:r});return{metadata:r.map(e=>({annotations:e.annotations,description:e.description??``,inputSchema:e.inputSchema??{},name:e.name,outputSchema:`outputSchema`in e&&e.outputSchema!==void 0?e.outputSchema:void 0})),tools:i}}async close(){this.#t!==void 0&&(await this.#t.close(),this.#t=void 0),this.#e=void 0,this.#n=void 0,this.#r=void 0}async#l(e){throw isMcpAuthRequiredError(e)?(this.#u(),await this.close(),new ConnectionAuthorizationRequiredError(this.#i.connectionName,{message:`Connection "${this.#i.connectionName}" requires authorization (the server rejected the token).`})):e}#u(){let e=this.#i.authorization;if(e===void 0)return;let n=contextStorage.getStore();if(n!==void 0)try{let t=resolveConnectionPrincipal(this.#i.connectionName,e,n);evictCachedToken(n,this.#i.connectionName,principalKey(t))}catch{}}};function isMcpAuthRequiredError(e){return readHttpStatus(e)===401}function isMcpHttpFallbackRetryableError(e){let t=readHttpStatus(e);return t===400||t===404||t===405}function readHttpStatus(t){for(let n of walkErrorChain(t)){if(!isObject(n))continue;let t=readStatusField(n);if(t!==void 0)return t;let r=n.response;if(isObject(r)){let e=readStatusField(r);if(e!==void 0)return e}if(typeof n.message==`string`){let e=/\bHTTP\s+(\d{3})\b/u.exec(n.message);if(e?.[1]!==void 0)return Number(e[1])}}}function readStatusField(e){if(typeof e.status==`number`)return e.status;if(typeof e.statusCode==`number`)return e.statusCode}function*walkErrorChain(t){let n=t,r=new Set;for(;n!=null&&!r.has(n);){if(r.add(n),yield n,!isObject(n)||!(`cause`in n))return;n=n.cause}}function passesToolFilter(e,t){return t===void 0?!0:`allow`in t?t.allow.includes(e):!t.block.includes(e)}async function resolveHeaders(e){let t={};if(e.authorization!==void 0&&(t.Authorization=`Bearer ${(await resolveToken(e)).token}`),e.headers!==void 0){let n=await resolveHeadersDefinition(e.headers);for(let[r,i]of Object.entries(n)){if(e.authorization!==void 0&&r.toLowerCase()===`authorization`)throw Error(`Connection "${e.connectionName}" headers must not include an "Authorization" key when "authorization" is also provided.`);t[r]=i}}return t}async function resolveToken(e){if(e.authorization===void 0)throw Error(`Connection "${e.connectionName}" does not define authorization.`);return await resolveScopedToken({authorization:e.authorization,connection:{url:e.url},scope:e.connectionName})}async function resolveHeadersDefinition(e){if(typeof e==`function`)return await e();let t={},n=Object.entries(e);for(let[e,r]of n)t[e]=await resolveHeaderValue(r);return t}async function resolveHeaderValue(e){return typeof e==`function`?await e():await e}export{McpConnectionClient,isMcpAuthRequiredError,passesToolFilter,resolveHeaders};

package/dist/src/runtime/connections/openapi-client.d.ts

@@ -0,0 +1,43 @@
+import { type ToolSet } from "ai";
+import type { ResolvedConnectionDefinition } from "#runtime/types.js";
+import { type OpenApiOperation } from "#runtime/connections/openapi-operations.js";
+import type { ConnectionClient, ConnectionToolMetadata } from "#runtime/connections/types.js";
+interface OpenApiToolCache {
+    readonly metadata: readonly ConnectionToolMetadata[];
+    readonly operations: ReadonlyMap<string, OpenApiOperation>;
+    readonly tools: ToolSet;
+    readonly baseUrl: string;
+}
+/**
+ * Result of executing an OpenAPI operation. Returned to the model as the
+ * tool result so it can react to the status and body of any response,
+ * including non-2xx responses.
+ */
+export interface OpenApiToolResult {
+    readonly status: number;
+    readonly statusText: string;
+    readonly body: unknown;
+}
+/**
+ * A {@link ConnectionClient} that turns an OpenAPI 3.x document into
+ * connection tools.
+ *
+ * Created lazily per-connection per-session. On first use it loads the
+ * document (fetching it when `spec` is a URL), dereferences local
+ * `$ref` pointers, and maps each operation to a tool whose name is the
+ * operation's `operationId`. Tool calls reconstruct the HTTP request —
+ * substituting path parameters, appending query parameters, attaching
+ * resolved auth and headers — and return the response as a serializable
+ * `{ status, statusText, body }`.
+ */
+export declare class OpenApiConnectionClient implements ConnectionClient {
+    #private;
+    constructor(connection: ResolvedConnectionDefinition);
+    /** Loads and parses the OpenAPI document, sharing one in-flight load. */
+    connect(): Promise<OpenApiToolCache>;
+    getToolMetadata(): Promise<readonly ConnectionToolMetadata[]>;
+    getTools(): Promise<ToolSet>;
+    executeTool(toolName: string, args: unknown): Promise<OpenApiToolResult>;
+    close(): Promise<void>;
+}
+export {};