eve 0.75.1 → 0.76.2

package/dist/src/execution/session-inbox/owner.d.ts

@@ -0,0 +1,48 @@
+import { type OwnerRun } from "#execution/session-inbox/runnable-owner.js";
+import { resumeHook, type Hook } from "#internal/workflow/runtime.js";
+/**
+ * The session's owner was built by another eve version, so this build cannot
+ * execute it and ingress refused the command before committing it. Internal:
+ * carries the owner run, which never reaches a client.
+ */
+export declare class StrandedSessionOwnerError extends Error {
+    /** The owner's hook, when ingress looked it up; its metadata names the session. */
+    readonly hook: Hook | undefined;
+    readonly ownerRun: OwnerRun;
+    constructor(ownerRun: OwnerRun, hook?: Hook);
+    get ownerRunId(): string;
+    /** eve version that built the owner, when it recorded one. */
+    get eveVersion(): string | undefined;
+}
+/**
+ * The single ingress path into a hook: refuses a session inbox whose owner
+ * cannot execute before anything is committed, then resumes by token. Any
+ * other hook resumes unchecked. Resuming by token rather than by the looked-up
+ * hook keeps Workflow's delivery dedup, which a caller-supplied hook disables.
+ */
+export declare function resumeRunnableHook(token: string, payload: unknown): Promise<Awaited<ReturnType<typeof resumeHook>>>;
+/**
+ * Throws {@link StrandedSessionOwnerError} when the run holding a physical
+ * session inbox token cannot execute. An unheld token passes: resuming it
+ * reports the absence. Where the World replays each run on its own
+ * deployment, every owner can execute, so nothing is looked up.
+ */
+export declare function assertRunnableSessionInbox(token: string): Promise<void>;
+/** {@link assertRunnableSessionInbox} for a hook the caller already looked up. */
+export declare function assertRunnableSessionOwner(hook: Hook): Promise<void>;
+/**
+ * The run holding a session hook token, or `undefined` when none does. The
+ * `eve dev` World refuses to expose the hooks of a run it will not execute
+ * (a dormant or ineligible generation) and names only the run, so `hook` is
+ * then absent. This is the only place that refusal is interpreted.
+ */
+export declare function findSessionHookHolder(token: string): Promise<{
+    readonly runId: string;
+    readonly hook?: Hook;
+} | undefined>;
+/**
+ * Looks up a session hook. A run the `eve dev` World refuses to expose is
+ * stranded only when another eve version built it; otherwise a restart with
+ * `--resume` may run it, so the refusal propagates and nothing is ended.
+ */
+export declare function lookupSessionOwnerHook(token: string): Promise<Hook>;

package/dist/src/execution/session-inbox/owner.js

@@ -0,0 +1 @@
+import{isSessionInboxHookToken}from"#execution/session-inbox/address.js";import{getHookByToken,getWorld,resumeHook}from"#internal/workflow/runtime.js";import{HookNotFoundError}from"#compiled/@workflow/errors/index.js";import{EVE_VERSION_ATTRIBUTE}from"#execution/eve-workflow-attributes.js";import{findRetiredOwnerRun,routesToOwnerDeployment}from"#execution/session-inbox/runnable-owner.js";import{DevelopmentRunUnavailableError}from"#internal/workflow/development-run-unavailable-error.js";var StrandedSessionOwnerError=class extends Error{hook;ownerRun;constructor(e,t){super(`Session owner run "${e.runId}" is stranded.`),this.name=`StrandedSessionOwnerError`,this.hook=t,this.ownerRun=e}get ownerRunId(){return this.ownerRun.runId}get eveVersion(){return this.ownerRun.attributes[EVE_VERSION_ATTRIBUTE]}};async function resumeRunnableHook(e,t){return isSessionInboxHookToken(e)&&await assertRunnableSessionInbox(e),await resumeHook(e,t)}async function assertRunnableSessionInbox(e){let t=await getWorld();if(routesToOwnerDeployment(t))return;let n=await findSessionHookHolder(e);n!==void 0&&await assertRunnableOwner(t,n.runId,n.hook)}async function assertRunnableSessionOwner(e){let t=await getWorld();routesToOwnerDeployment(t)||await assertRunnableOwner(t,e.runId,e)}async function findSessionHookHolder(e){try{let t=await getHookByToken(e);return{hook:t,runId:t.runId}}catch(e){if(HookNotFoundError.is(e))return;if(DevelopmentRunUnavailableError.is(e))return{runId:e.runId};throw e}}async function lookupSessionOwnerHook(e){try{return await getHookByToken(e)}catch(e){throw DevelopmentRunUnavailableError.is(e)&&await assertRunnableOwner(await getWorld(),e.runId),e}}async function assertRunnableOwner(e,t,n){let r=await findRetiredOwnerRun(e,t);if(r!==void 0)throw new StrandedSessionOwnerError(r,n)}export{StrandedSessionOwnerError,assertRunnableSessionInbox,assertRunnableSessionOwner,findSessionHookHolder,lookupSessionOwnerHook,resumeRunnableHook};

package/dist/src/execution/session-inbox/resume.d.ts

@@ -11,8 +11,18 @@ export interface ResumedSessionInboxHook {
  * deployment handoff the address is briefly unowned; the releasing owner
  * leaves a marker for that interval, so delivery retries instead of
  * reporting the session gone and letting a channel start a replacement.
+ * The retry window bounds this request, not the handoff: a marker that
+ * outlives it throws {@link SessionHandoffPendingError}.
  */
 export declare function resumeSessionInbox(address: string | SessionInboxAddress, command: DeliverHookPayload | SessionCommand | SessionTimeoutHookPayload | SessionFailurePayload): Promise<ResumedSessionInboxHook>;
+/**
+ * The address's owner is still handing off after the request's retry window.
+ * Nothing was delivered. The address is not unowned, so callers must not start
+ * a session there; the request can be retried.
+ */
+export declare class SessionHandoffPendingError extends Error {
+    constructor(token: string);
+}
 export declare class AcceptedSessionIdentityError extends Error {
     constructor(cause: unknown);
 }
@@ -20,3 +30,5 @@ export declare function requireSessionId(metadata: unknown): string;
 export declare function resolveSessionInbox(token: string): Promise<{
     sessionId: string;
 }>;
+/** Logical token behind an address: the address itself, or the session's stable command token. */
+export declare function logicalSessionToken(address: string | SessionInboxAddress): string;

package/dist/src/execution/session-inbox/resume.js

@@ -1 +1 @@
-import{isObject}from"#shared/guards.js";import{SESSION_INBOX_SESSION_ID_METADATA_KEY,isSessionInboxAddress,sessionCommandHookToken,sessionHandoffMarkerToken,sessionInboxHookToken}from"#execution/session-inbox/address.js";import{getHookByToken,resumeHook}from"#internal/workflow/runtime.js";import{HookNotFoundError}from"#compiled/@workflow/errors/index.js";import{UnsupportedLegacySessionError,resolveLegacyInbox,resumeLegacyInbox}from"#execution/legacy-session/inbox.js";async function resumeSessionInbox(e,t){let n=logicalToken(e),r=Date.now()+5e3;for(;;){let i;try{i=await resumeHook(sessionInboxHookToken(n),t)}catch(e){if(!HookNotFoundError.is(e))throw e;if(await isHandoffInProgress(n,r))continue;if(t.kind===`session-failure`)throw e;return await resumeLegacyInbox(n,t).catch(rethrowUnsupportedAsNotFound)}let a;return{ownerRunId:i.runId,get sessionId(){return a??=(async()=>{try{return typeof e==`string`?requireSessionId(await i.metadata):e.sessionId}catch(e){throw new AcceptedSessionIdentityError(e)}})()}}}}var AcceptedSessionIdentityError=class extends Error{constructor(e){super(`Session command accepted, but its session identity could not be resolved.`,{cause:e}),this.name=`AcceptedSessionIdentityError`}};function requireSessionId(e){let t=isObject(e)?e[SESSION_INBOX_SESSION_ID_METADATA_KEY]:void 0;if(typeof t!=`string`||t.length===0)throw Error(`Session hook metadata is missing its session ID.`);return t}async function resolveSessionInbox(e){try{return{sessionId:requireSessionId(await(await getHookByToken(sessionInboxHookToken(e))).metadata)}}catch(t){if(!HookNotFoundError.is(t))throw t;return{sessionId:(await resolveLegacyInbox(e)).sessionId}}}function rethrowUnsupportedAsNotFound(e){throw e instanceof UnsupportedLegacySessionError?new HookNotFoundError(e.message):e}function logicalToken(e){if(typeof e==`string`)return e;if(!isSessionInboxAddress(e))throw Error(`Session inbox target has an invalid address.`);return sessionCommandHookToken(e.sessionId)}async function isHandoffInProgress(e,t){if(Date.now()>=t)return!1;try{await getHookByToken(sessionHandoffMarkerToken(e))}catch(e){if(HookNotFoundError.is(e))return!1;throw e}return await new Promise(e=>setTimeout(e,20)),!0}export{AcceptedSessionIdentityError,requireSessionId,resolveSessionInbox,resumeSessionInbox};
+import{isObject}from"#shared/guards.js";import{SESSION_INBOX_SESSION_ID_METADATA_KEY,isSessionInboxAddress,sessionCommandHookToken,sessionHandoffMarkerToken,sessionInboxHookToken}from"#execution/session-inbox/address.js";import{getHookByToken}from"#internal/workflow/runtime.js";import{HookNotFoundError}from"#compiled/@workflow/errors/index.js";import{assertRunnableSessionOwner,lookupSessionOwnerHook,resumeRunnableHook}from"#execution/session-inbox/owner.js";import{UnsupportedLegacySessionError,resolveLegacyInbox,resumeLegacyInbox}from"#execution/legacy-session/inbox.js";async function resumeSessionInbox(e,t){let n=logicalSessionToken(e),r=typeof e==`string`?void 0:e.sessionId,i=Date.now()+5e3;for(;;){let e;try{e=await resumeRunnableHook(sessionInboxHookToken(n),t)}catch(e){if(!HookNotFoundError.is(e))throw e;if(await waitWhileHandoffInProgress(n,i))continue;if(t.kind===`session-failure`)throw e;return await resumeLegacyInbox(n,t).catch(rethrowUnsupportedAsNotFound)}let a;return{ownerRunId:e.runId,get sessionId(){return a??=(async()=>{try{return r??requireSessionId(await e.metadata)}catch(e){throw new AcceptedSessionIdentityError(e)}})()}}}}var SessionHandoffPendingError=class extends Error{constructor(e){super(`Session address "${e}" is still changing owners. Nothing was delivered; retry the request.`),this.name=`SessionHandoffPendingError`}},AcceptedSessionIdentityError=class extends Error{constructor(e){super(`Session command accepted, but its session identity could not be resolved.`,{cause:e}),this.name=`AcceptedSessionIdentityError`}};function requireSessionId(e){let t=isObject(e)?e[SESSION_INBOX_SESSION_ID_METADATA_KEY]:void 0;if(typeof t!=`string`||t.length===0)throw Error(`Session hook metadata is missing its session ID.`);return t}async function resolveSessionInbox(e){try{return{sessionId:requireSessionId(await(await getHookByToken(sessionInboxHookToken(e))).metadata)}}catch(t){if(!HookNotFoundError.is(t))throw t;return{sessionId:(await resolveLegacyInbox(e)).sessionId}}}function rethrowUnsupportedAsNotFound(e){throw e instanceof UnsupportedLegacySessionError?new HookNotFoundError(e.message):e}function logicalSessionToken(e){if(typeof e==`string`)return e;if(!isSessionInboxAddress(e))throw Error(`Session inbox target has an invalid address.`);return sessionCommandHookToken(e.sessionId)}async function waitWhileHandoffInProgress(e,t){let n;try{n=await lookupSessionOwnerHook(sessionHandoffMarkerToken(e))}catch(e){if(HookNotFoundError.is(e))return!1;throw e}if(Date.now()>=t)throw await assertRunnableSessionOwner(n),new SessionHandoffPendingError(e);return await new Promise(e=>setTimeout(e,20)),!0}export{AcceptedSessionIdentityError,SessionHandoffPendingError,logicalSessionToken,requireSessionId,resolveSessionInbox,resumeSessionInbox};

package/dist/src/execution/session-inbox/runnable-owner.d.ts

@@ -0,0 +1,13 @@
+import type { World } from "#compiled/@workflow/world/index.js";
+export type OwnerRun = Awaited<ReturnType<World["runs"]["get"]>>;
+/**
+ * Whether the World replays every run on the deployment that started it
+ * (Vercel). There, an owner from another eve version is the normal handoff
+ * case, not a stranded one.
+ */
+export declare function routesToOwnerDeployment(world: Pick<World, "capabilities">): boolean;
+/**
+ * The owner run when it is retired, or `undefined` when this build can run it.
+ * Reads the run only when it is not already known to be runnable.
+ */
+export declare function findRetiredOwnerRun(world: Pick<World, "runs">, runId: string): Promise<OwnerRun | undefined>;

package/dist/src/execution/session-inbox/runnable-owner.js

@@ -0,0 +1 @@
+import{resolveInstalledPackageInfo}from"#internal/application/package.js";import{EVE_VERSION_ATTRIBUTE}from"#execution/eve-workflow-attributes.js";const runnableOwnerRunIds=new Set;function routesToOwnerDeployment(e){return e.capabilities?.deploymentAffinity===!0}function isRunnableOwnerRun(e){return e.attributes[EVE_VERSION_ATTRIBUTE]===resolveInstalledPackageInfo().version}async function findRetiredOwnerRun(e,t){if(runnableOwnerRunIds.has(t))return;let n=await e.runs.get(t,{resolveData:`none`});if(!isRunnableOwnerRun(n))return n;runnableOwnerRunIds.size>=1e4&&runnableOwnerRunIds.clear(),runnableOwnerRunIds.add(t)}export{findRetiredOwnerRun,routesToOwnerDeployment};

package/dist/src/execution/session-inbox/stranded-replay-guard.d.ts

@@ -0,0 +1,16 @@
+import type { World } from "#compiled/@workflow/world/index.js";
+/**
+ * Makes the World acknowledge, without replaying, queue deliveries for
+ * top-level eve session runs that another eve version started. Worlds that
+ * re-enqueue their active runs at startup (local, Postgres) would otherwise
+ * replay such a run on this build's code and fail it as `CORRUPTED_EVENT_LOG`.
+ * A top-level session stays active until ingress replaces it or its timeout
+ * ends it. Subagent sessions and workflow tool runs are cancelled instead:
+ * no later user message can replace their interrupted work. Ingress refuses
+ * the same owners by the same verdict, so preserved owners cannot admit work.
+ * Timeout workflows remain runnable so they can end preserved sessions.
+ *
+ * Mutates and returns `world`; only its `createQueueHandler` changes. Worlds
+ * that replay each run on its own deployment are returned untouched.
+ */
+export declare function guardStrandedSessionReplay<TWorld extends World>(world: TWorld): TWorld;

package/dist/src/execution/session-inbox/stranded-replay-guard.js

@@ -0,0 +1 @@
+import{createLogger}from"#internal/logging.js";import{resolveInstalledPackageInfo}from"#internal/application/package.js";import{cancelRun}from"#internal/workflow/runtime.js";import{isInactiveWorkflowRunError,isMissingWorkflowRunError}from"#internal/workflow/is-inactive-workflow-run-error.js";import{EVE_TYPE_ATTRIBUTE,EVE_VERSION_ATTRIBUTE}from"#execution/eve-workflow-attributes.js";import{findRetiredOwnerRun,routesToOwnerDeployment}from"#execution/session-inbox/runnable-owner.js";import{WORKFLOW_ENTRY_NAME,WORKFLOW_TOOL_RUN_WORKFLOW_NAME}from"#execution/stable-workflow-names.js";const log=createLogger(`execution.session-inbox.stranded-replay-guard`);function guardStrandedSessionReplay(e){if(routesToOwnerDeployment(e))return e;let{name:t}=resolveInstalledPackageInfo(),n=new Map([[`workflow//${t}//${WORKFLOW_ENTRY_NAME}`,`session`],[`workflow//${t}//${WORKFLOW_TOOL_RUN_WORKFLOW_NAME}`,`tool`]]),r=e.createQueueHandler.bind(e);return e.createQueueHandler=(t,i)=>r(t,async(r,a)=>{let o=n.get(a.queueName.slice(t.length)),s=readRunId(r);if(!(o!==void 0&&s!==void 0&&await skipRetiredRun(e,s,o)))return await i(r,a)}),e}async function skipRetiredRun(e,t,n){let r=await readRetiredRun(e,t);if(r===void 0)return!1;switch(strandedReplayAction(r,n)){case`replay`:return!1;case`retire`:return await retireRun(e,r),!0;case`park`:return logParkedSession(r),!0}}function strandedReplayAction(e,t){return e.status!==`pending`&&e.status!==`running`?`replay`:t===`tool`||e.attributes[EVE_TYPE_ATTRIBUTE]===`subagent`?`retire`:`park`}async function readRetiredRun(e,t){try{return await findRetiredOwnerRun(e,t)}catch(e){if(isMissingWorkflowRunError(e))return;throw e}}async function retireRun(e,t){try{await cancelRun(e,t.runId,{cancelReason:`Run retired: its eve deployment is no longer available`})}catch(e){if(!isInactiveWorkflowRunError(e))throw e}log.warn(`Retired stranded descendant run`,{runId:t.runId,previousEveVersion:t.attributes[EVE_VERSION_ATTRIBUTE]??`unknown`,currentEveVersion:resolveInstalledPackageInfo().version})}function logParkedSession(e){log.warn(`Skipping replay of stranded session run "${e.runId}" (owner eve ${e.attributes[EVE_VERSION_ATTRIBUTE]??`unknown`}, current ${resolveInstalledPackageInfo().version}). It remains active until an ordinary channel message, an explicit reset, or its session timeout ends it.`)}function readRunId(e){if(typeof e!=`object`||!e||`__healthCheck`in e)return;let t=e.runId;return typeof t==`string`&&t.length>0?t:void 0}export{guardStrandedSessionReplay};

package/dist/src/execution/session.js

@@ -1,3 +1,3 @@
-import{formatAvailableSkillsSection}from"#execution/skills/instructions.js";const DEFAULT_ROOT_MAX_INPUT_TOKENS_PER_SESSION=4e7;function createCompactionConfig(e={}){let t=e.thresholdPercent??.9,n={recentWindowSize:10,threshold:e.contextWindowTokens===void 0?1e5:Math.max(1,Math.floor(e.contextWindowTokens*t)),thresholdPercent:t};return e.lastKnownInputTokens===void 0?n:{...n,lastKnownInputTokens:e.lastKnownInputTokens,lastKnownPromptMessageCount:e.lastKnownPromptMessageCount}}function createSession(e){let{turnAgent:t}=e,n=createSessionToolDefinitions(t),r={agent:createSessionAgent(t,createSessionSystemPrompt(t),n),compaction:createCompactionConfig({contextWindowTokens:t.model?.contextWindowTokens,thresholdPercent:e.compactionOverrides?.thresholdPercent}),continuationToken:e.continuationToken,history:[...t.initialMessages??[]],sessionId:e.sessionId};return e.rootSessionId!==void 0&&(r.rootSessionId=e.rootSessionId),r.limits=resolveSessionLimits(e),e.outputSchema!==void 0&&(r.outputSchema=e.outputSchema),r}function createSessionAgent(e,t,n){let r={compactionModelReference:e.compactionModel,reasoning:e.reasoning,system:t,tools:n};if(e.model!==void 0)return{...r,modelReference:e.model};if(e.dynamicModel!==void 0)return{...r,dynamicModel:!0};throw Error(`Cannot create a session before dynamic subagent config is selected.`)}function refreshSessionFromTurnAgent(e){return{...e.session,agent:createSessionAgent(e.turnAgent,createSessionSystemPrompt(e.turnAgent),createSessionToolDefinitions(e.turnAgent)),compaction:createCompactionConfig({contextWindowTokens:e.turnAgent.model?.contextWindowTokens,lastKnownInputTokens:e.session.compaction.lastKnownInputTokens,lastKnownPromptMessageCount:e.session.compaction.lastKnownPromptMessageCount,thresholdPercent:e.compactionOverrides?.thresholdPercent})}}function createSessionSystemPrompt(e){let t=formatAvailableSkillsSection(e.availableSkills??[]);return(t===null?e.instructions:[...e.instructions,t]).join(`
+import{formatAvailableSkillsSection}from"#execution/skills/instructions.js";const DEFAULT_ROOT_MAX_INPUT_TOKENS_PER_SESSION=4e7;function createCompactionConfig(e={}){let t=e.thresholdPercent??.9,n={recentWindowSize:10,threshold:e.contextWindowTokens===void 0?1e5:Math.max(1,Math.floor(e.contextWindowTokens*t)),thresholdPercent:t};return e.lastKnownInputTokens===void 0?n:{...n,lastKnownInputTokens:e.lastKnownInputTokens,lastKnownPromptMessageCount:e.lastKnownPromptMessageCount}}function createSession(e){let{turnAgent:t}=e,n=createSessionToolDefinitions(t),r={agent:createSessionAgent(t,createSessionSystemPrompt(t),n),compaction:createCompactionConfig({contextWindowTokens:t.model?.contextWindowTokens,thresholdPercent:e.compactionOverrides?.thresholdPercent}),continuationToken:e.continuationToken,history:[...t.initialMessages??[]],sessionId:e.sessionId};return e.rootSessionId!==void 0&&(r.rootSessionId=e.rootSessionId),r.limits=resolveSessionLimits(e),e.outputSchema!==void 0&&(r.outputSchema=e.outputSchema),r}function createSessionAgent(e,t,n){let r={compactionModelReference:e.compactionModel,reasoning:e.reasoning,system:t,tools:n};if(e.model!==void 0)return{...r,modelReference:e.model};if(e.dynamicModel!==void 0)return{...r,dynamicModel:!0};throw Error(`Cannot create a session before dynamic subagent config is selected.`)}function refreshSessionFromTurnAgent(e){return{...e.session,agent:createSessionAgent(e.turnAgent,createSessionSystemPrompt(e.turnAgent),createSessionToolDefinitions(e.turnAgent)),compaction:createCompactionConfig({contextWindowTokens:e.turnAgent.model?.contextWindowTokens,lastKnownInputTokens:e.session.compaction.lastKnownInputTokens,lastKnownPromptMessageCount:e.session.compaction.lastKnownPromptMessageCount,thresholdPercent:e.compactionOverrides?.thresholdPercent})}}function createSessionSystemPrompt(e){let t=formatAvailableSkillsSection(e.listedSkills??[]);return(t===null?e.instructions:[...e.instructions,t]).join(`
 
 `)}function mintSubagentContinuationToken(e){return`subagent:${e??crypto.randomUUID()}`}function projectToDurableSession(e){let t={agent:{system:e.agent.system},continuationToken:e.continuationToken,sessionId:e.sessionId};return(e.compaction.lastKnownInputTokens!==void 0||e.compaction.lastKnownPromptMessageCount!==void 0)&&(t.compaction={lastKnownInputTokens:e.compaction.lastKnownInputTokens,lastKnownPromptMessageCount:e.compaction.lastKnownPromptMessageCount}),e.rootSessionId!==void 0&&(t.rootSessionId=e.rootSessionId),e.limits!==void 0&&(t.limits=e.limits),e.outputSchema!==void 0&&(t.outputSchema=e.outputSchema),e.sandboxState!==void 0&&(t.sandboxState=e.sandboxState),e.state!==void 0&&(t.state=e.state),t}function hydrateDurableSession(e){let{durable:t,turnAgent:n}=e,r=createSessionToolDefinitions(n),i={agent:createSessionAgent(n,t.agent.system,r),compaction:createCompactionConfig({contextWindowTokens:n.model?.contextWindowTokens,lastKnownInputTokens:t.compaction?.lastKnownInputTokens,lastKnownPromptMessageCount:t.compaction?.lastKnownPromptMessageCount,thresholdPercent:e.compactionOverrides?.thresholdPercent}),continuationToken:t.continuationToken,sessionId:t.sessionId};return t.rootSessionId!==void 0&&(i.rootSessionId=t.rootSessionId),t.limits!==void 0&&(i.limits=t.limits),t.outputSchema!==void 0&&(i.outputSchema=t.outputSchema),t.sandboxState!==void 0&&(i.sandboxState=t.sandboxState),t.state!==void 0&&(i.state=t.state),i}function createSessionToolDefinitions(e){return e.tools.map(e=>({description:e.description??``,inputSchema:e.inputSchema,name:e.name,outputSchema:e.outputSchema}))}function resolveSessionLimits(e){let t=resolveSessionTokenLimit({authored:e.limits?.maxInputTokensPerSession,fallback:DEFAULT_ROOT_MAX_INPUT_TOKENS_PER_SESSION}),n=resolveSessionTokenLimit({authored:e.limits?.maxOutputTokensPerSession,fallback:void 0}),r=resolveSessionTokenLimit({authored:e.limits?.maxTokenCostUsdPerSession,fallback:void 0}),i={};return t!==void 0&&(i.maxInputTokensPerSession=t),n!==void 0&&(i.maxOutputTokensPerSession=n),r!==void 0&&(i.maxTokenCostUsdPerSession=r),i}function resolveSessionTokenLimit(e){return e.authored===!1?void 0:e.authored??e.fallback}export{DEFAULT_ROOT_MAX_INPUT_TOKENS_PER_SESSION,createCompactionConfig,createSession,hydrateDurableSession,mintSubagentContinuationToken,projectToDurableSession,refreshSessionFromTurnAgent};

package/dist/src/execution/skills/instructions.d.ts

@@ -1,3 +1,5 @@
+import type { DynamicSkillManifest } from "#context/keys.js";
+import type { Announcement } from "#harness/announcements.js";
 export interface AvailableSkillDescription {
     readonly description: string;
     readonly name: string;
@@ -5,17 +7,25 @@ export interface AvailableSkillDescription {
     readonly hasFiles?: boolean;
 }
 /**
- * Formats the "Available skills" system prompt section.
+ * Formats the "Available skills" section: every skill that isn't deferred,
+ * with the instruction to load it. Deferred skills stay out of context until
+ * search finds them.
  *
- * All skills are always listed regardless of activation state. Active skill
- * instructions are never injected into the system prompt — the model already
- * has them from the `load_skill` tool result. The formatter uses the canonical
- * symbolic skill root so supporting files remain discoverable without
- * provisioning a sandbox.
+ * A loaded skill's instructions are never injected into the system prompt;
+ * the model has them from the result of loading it. The formatter uses the
+ * canonical symbolic skill root so supporting files remain discoverable
+ * without provisioning a sandbox.
  *
- * Authored skills call this at graph resolution time so the section is
- * part of the turn agent's static instructions. Dynamic skills
- * (`defineDynamic` in `agent/skills/`) reuse the same formatter for
- * durable context announcements.
+ * Authored skills call this at graph resolution time so the section is part of
+ * the turn agent's static instructions. Dynamic skills reuse it for their
+ * announcement.
  */
 export declare function formatAvailableSkillsSection(skills: readonly AvailableSkillDescription[]): string | null;
+/**
+ * Announces the dynamic skills that aren't deferred, in full whenever they
+ * change. Nothing is announced until the first one resolves. `announced` holds
+ * the values announced so far.
+ */
+export declare function dynamicSkillAnnouncements(manifest: DynamicSkillManifest | undefined, announced: Readonly<Record<string, string>> | undefined): Readonly<Record<string, Announcement>>;
+/** Where a skill's `SKILL.md` lives under the model's skill root. */
+export declare function skillFilePath(name: string): string;

package/dist/src/execution/skills/instructions.js

@@ -1,2 +1,2 @@
-import{FALLBACK_SKILL_ROOT,MODEL_SKILL_ROOT}from"#shared/skill-paths.js";function formatAvailableSkillsSection(e){return e.length===0?null:[`Available skills`,`Listed skills are available in this run. Do not claim a listed skill is inaccessible unless activation or workspace inspection actually fails.`,`Dynamic skill announcements replace earlier dynamic skills and override static skills with the same name. Static skills omitted from a dynamic announcement remain available.`,`If the user names a skill or the request clearly matches one of the descriptions below, call load_skill before proceeding.`,`If multiple skills match, activate the minimal set that covers the task. After activation, follow the returned instructions instead of improvising around them.`,`If activation fails, say so briefly and continue with the best available alternative.`,`Skill files live under \`${MODEL_SKILL_ROOT}/<skill>/\`, with \`${FALLBACK_SKILL_ROOT}/<skill>/\` as the fallback when \`$HOME\` is unavailable.`,"When a loaded SKILL.md mentions sibling files such as `references/foo.md`, resolve them relative to the directory containing that specific SKILL.md.",...e.map(formatAvailableSkillLine)].join(`
-`)}function formatAvailableSkillLine(e){let t=`- ${e.name}: ${e.description}`;return e.hasFiles===!1?t:`${t} (path: ${MODEL_SKILL_ROOT}/${e.name}/SKILL.md)`}export{formatAvailableSkillsSection};
+import{SKILL_TOOL_NAME}from"#protocol/catalog-tools.js";import{FALLBACK_SKILL_ROOT,MODEL_SKILL_ROOT}from"#shared/skill-paths.js";const ANNOUNCEMENT_KEY=`skills`;function formatAvailableSkillsSection(e){return e.length===0?null:[`Available skills`,`Listed skills are available in this run. Do not claim a listed skill is inaccessible unless activation or workspace inspection actually fails.`,`Dynamic skill announcements replace earlier dynamic skills and override static skills with the same name. Static skills omitted from a dynamic announcement remain available.`,`If the user names a skill or the request clearly matches one of the descriptions below, load it with ${SKILL_TOOL_NAME}({ name }) before proceeding.`,`If multiple skills match, activate the minimal set that covers the task. After activation, follow the returned instructions instead of improvising around them.`,`If activation fails, say so briefly and continue with the best available alternative.`,`Skill files live under \`${MODEL_SKILL_ROOT}/<skill>/\`, with \`${FALLBACK_SKILL_ROOT}/<skill>/\` as the fallback when \`$HOME\` is unavailable.`,"When a loaded SKILL.md mentions sibling files such as `references/foo.md`, resolve them relative to the directory containing that specific SKILL.md.",...e.map(formatAvailableSkillLine)].join(`
+`)}function dynamicSkillAnnouncements(e,t){let n=Object.values(e??{}).flat().filter(e=>e.deferred!==!0);if(n.length===0&&t?.[ANNOUNCEMENT_KEY]===void 0)return{};let r=formatAvailableSkillsSection(n.map(({description:e,name:t,revision:n})=>({description:e,hasFiles:n!==void 0,name:t})))??`Available skills: none`;return{[ANNOUNCEMENT_KEY]:{value:r,render:()=>r}}}function formatAvailableSkillLine(e){let t=`- ${e.name}: ${e.description}`;return e.hasFiles===!1?t:`${t} (path: ${skillFilePath(e.name)})`}function skillFilePath(e){return`${MODEL_SKILL_ROOT}/${e}/SKILL.md`}export{dynamicSkillAnnouncements,formatAvailableSkillsSection,skillFilePath};

package/dist/src/execution/tasks/calls.d.ts

@@ -1,27 +1,28 @@
 import type { ModelMessage } from "ai";
 import type { RuntimeToolResultActionResult } from "#shared/action-types.js";
 import type { JsonValue } from "#shared/json.js";
+import { TASK_CANCEL_TOOL_NAME, TASK_WAIT_TOOL_NAME } from "#protocol/task-tools.js";
 /**
  * Calls to the task tools. They defer out of the model step like
  * workflow tool calls; the session answers them instead of a workflow run.
  */
 export type TaskToolCall = {
     readonly callId: string;
-    readonly kind: "task_wait";
+    readonly kind: typeof TASK_WAIT_TOOL_NAME;
     readonly timeoutMs?: number;
 } | {
     readonly callId: string;
-    readonly kind: "task_cancel";
+    readonly kind: typeof TASK_CANCEL_TOOL_NAME;
     readonly taskId: string;
 };
 /**
  * The task tool calls a parked step's response still waits on. The response
  * is the one record of these calls: a call without a result is pending, and
- * a call with invalid input already carries its error result. The names are
- * reserved, so no authored tool's call matches.
+ * a call with invalid input already carries its error result. The `eve`
+ * namespace is reserved, so no authored tool's call matches.
  */
 export declare function pendingTaskToolCalls(messages: readonly ModelMessage[]): TaskToolCall[];
-/** Why a `task_wait` call, or a held turn, stopped waiting. */
+/** Why an `eve__task_wait` call, or a held turn, stopped waiting. */
 export type TaskWaitResult = {
     readonly status: "settled";
     /** Tasks whose results follow; both lists are empty when nothing was working. */

package/dist/src/execution/tasks/calls.js

@@ -1 +1 @@
-import{TASK_CANCEL_TOOL_NAME,TASK_WAIT_TOOL_NAME}from"#protocol/task-tools.js";function pendingTaskToolCalls(e){let t=new Set;for(let n of e)if(typeof n.content!=`string`)for(let e of n.content)e.type===`tool-result`&&t.add(e.toolCallId);let n=[];for(let r of e)if(r.role===`assistant`&&typeof r.content!=`string`)for(let e of r.content){if(e.type!==`tool-call`||t.has(e.toolCallId))continue;let r=typeof e.input==`object`&&e.input!==null?e.input:{};if(e.toolName===TASK_CANCEL_TOOL_NAME){let t=String(Reflect.get(r,`taskId`));n.push({callId:e.toolCallId,kind:`task_cancel`,taskId:t})}else if(e.toolName===TASK_WAIT_TOOL_NAME){let t=Reflect.get(r,`timeoutSeconds`);n.push(typeof t==`number`?{callId:e.toolCallId,kind:`task_wait`,timeoutMs:t*1e3}:{callId:e.toolCallId,kind:`task_wait`})}}return n}function taskToolResult(e,t,n){return{callId:e,kind:`tool-result`,output:n,toolName:t}}export{pendingTaskToolCalls,taskToolResult};
+import{TASK_CANCEL_TOOL_NAME,TASK_WAIT_TOOL_NAME}from"#protocol/task-tools.js";function pendingTaskToolCalls(e){let t=new Set;for(let n of e)if(typeof n.content!=`string`)for(let e of n.content)e.type===`tool-result`&&t.add(e.toolCallId);let n=[];for(let r of e)if(r.role===`assistant`&&typeof r.content!=`string`)for(let e of r.content){if(e.type!==`tool-call`||t.has(e.toolCallId))continue;let r=typeof e.input==`object`&&e.input!==null?e.input:{};if(e.toolName===TASK_CANCEL_TOOL_NAME){let t=String(Reflect.get(r,`taskId`));n.push({callId:e.toolCallId,kind:TASK_CANCEL_TOOL_NAME,taskId:t})}else if(e.toolName===TASK_WAIT_TOOL_NAME){let t=Reflect.get(r,`timeoutSeconds`);n.push(typeof t==`number`?{callId:e.toolCallId,kind:TASK_WAIT_TOOL_NAME,timeoutMs:t*1e3}:{callId:e.toolCallId,kind:TASK_WAIT_TOOL_NAME})}}return n}function taskToolResult(e,t,n){return{callId:e,kind:`tool-result`,output:n,toolName:t}}export{pendingTaskToolCalls,taskToolResult};

package/dist/src/execution/tasks/model-step.d.ts

@@ -5,20 +5,20 @@ import type { HarnessSession, HarnessToolMap } from "#harness/types.js";
 import type { WorkflowToolCallEntry } from "#shared/action-types.js";
 import type { JsonObject } from "#shared/json.js";
 export declare function isTaskTool(definition: HarnessToolDefinition | undefined): boolean;
-/** Whether the agent can start tasks, so the task tools and system block are offered. */
-export declare function offersTasks(tools: HarnessToolMap): boolean;
-/** Adds `task_wait` and `task_cancel` to a tool set that can start tasks. */
+/** Workflow tools, and the task tools that control them, run after the model step. */
+export declare function isWorkflowTool(definition: HarnessToolDefinition | undefined): boolean;
+/** Adds `eve__task_wait` and `eve__task_cancel` to the tools of a session that offers tasks. */
 export declare function withTaskTools(tools: HarnessToolMap): HarnessToolMap;
 /**
- * The task block, when the agent can start tasks. `finalReplyOnly` is set for a
+ * The task block, when the session offers tasks. `finalReplyOnly` is set for a
  * child or schedule session, which hides a held turn's text, so a reply before
  * a result would reach no one.
  */
-export declare function taskSystemMessages(tools: HarnessToolMap, options: {
+export declare function taskSystemMessages(offers: boolean, options: {
     readonly finalReplyOnly: boolean;
 }): SystemModelMessage[];
-/** A deferred call as the model made it, before the session knows what it enters. */
-export interface DeferredCall {
+/** A workflow tool call as the model made it, before the session knows what it enters. */
+export interface WorkflowCall {
     readonly callId: string;
     readonly definition: HarnessToolDefinition | undefined;
     /** The call's model input. */
@@ -26,19 +26,19 @@ export interface DeferredCall {
     readonly toolName: string;
     readonly turnId: string;
 }
-/** How a deferred call enters its workflow, with the tool's own input. */
+/** How a workflow tool call enters its workflow, with the tool's own input. */
 export interface CommittedCallEntry {
     readonly entry: WorkflowToolCallEntry;
     readonly input: JsonObject;
     readonly session: HarnessSession;
 }
 /**
- * How a deferred call enters its workflow. A call that starts a task commits
+ * How a workflow tool call enters its workflow. A call that starts a task commits
  * the task's record alongside the call, so the run starts with its id; a
  * `serve` tool's call with `taskId` goes to that task's `receive()`, which the
  * session checks when it sends the call.
  */
-export declare function commitCallEntry(session: HarnessSession, call: DeferredCall): CommittedCallEntry;
+export declare function commitCallEntry(session: HarnessSession, call: WorkflowCall): CommittedCallEntry;
 export declare function workingTaskIds(session: HarnessSession): readonly string[];
 /**
  * The messages a model step appends for tasks, before any new input: one

package/dist/src/execution/tasks/model-step.js

@@ -1 +1 @@
-import{TASK_CANCEL_TOOL_NAME,TASK_WAIT_TOOL_NAME}from"#protocol/task-tools.js";import{createFrameworkUserMessage}from"#harness/messages.js";import{FINAL_REPLY_TASK_SYSTEM_BLOCK,TASKS_NOTE_LABEL,TASK_SYSTEM_BLOCK,renderModelOutputText,renderTaskResults,renderTasksNote}from"#execution/tasks/render.js";import{createTask,idleTasks,readTaskTable,takeTaskResults,workingTasks,writeTaskTable}from"#execution/tasks/table.js";import{observeToolOutput}from"#tool-stubs/execute.js";import{splitTaskIdInput}from"#execution/tasks/task-id-input.js";import{entryPointOf,isAgentTool,startsTasks}from"#execution/tasks/tool-entry-point.js";import{taskCancelTool}from"#tools/provided/task-cancel.js";import{taskWaitTool}from"#tools/provided/task-wait.js";function isTaskTool(e){return e?.frameworkAction===`task-wait`||e?.frameworkAction===`task-cancel`}function offersTasks(e){for(let t of e.values())if(startsTasks(t))return!0;return!1}function withTaskTools(e){return offersTasks(e)?new Map([...e,[TASK_WAIT_TOOL_NAME,taskWaitTool],[TASK_CANCEL_TOOL_NAME,taskCancelTool]]):e}function taskSystemMessages(e,t){return offersTasks(e)?[{content:t.finalReplyOnly?FINAL_REPLY_TASK_SYSTEM_BLOCK:TASK_SYSTEM_BLOCK,role:`system`}]:[]}function commitCallEntry(e,t){let n=entryPointOf(t.definition);switch(n){case`execute`:return{entry:{entryPoint:n},input:t.input,session:e};case`task`:return commitTask(e,t,n,t.input);case`serve`:{let{input:r,taskId:i}=splitTaskIdInput(t.input);return i===void 0?commitTask(e,t,n,r):{entry:{entryPoint:`receive`,taskId:i},input:r,session:e}}}}function commitTask(e,t,n,r){let i=createTask(readTaskTable(e.state),{callId:t.callId,kind:isAgentTool(t.definition)?`agent`:`tool`,name:t.toolName,resumable:n===`serve`,turnId:t.turnId});return{entry:{entryPoint:n,taskId:i.taskId},input:r,session:writeTaskTable(e,i.table)}}function workingTaskIds(e){return workingTasks(readTaskTable(e.state)).map(e=>e.id)}async function appendTaskContext(e){let t=[],n=await deliverTaskResults(e);n.message!==void 0&&t.push(createFrameworkUserMessage(`task.result`,n.message));let r=resolveTasksNote({messages:e.projectHistory([...e.messages,...t],n.session.state),session:n.session});return r!==void 0&&t.push(createFrameworkUserMessage(`context.state`,r)),{messages:t,session:n.session}}async function deliverTaskResults(e){let{table:t,taken:n}=takeTaskResults(readTaskTable(e.session.state));if(n.length===0)return{session:e.session};let r=[];for(let t of n)for(let n of t.results)r.push(await toResultBlock(t,n,e.tools.get(t.name)));return{message:renderTaskResults(r),session:writeTaskTable(e.session,t)}}async function toResultBlock(e,t,n){let r={taskId:e.id,tool:e.name};return t.status===`failed`?{...r,body:t.error,status:`failed`}:{...r,body:await projectOutput(e.name,t,n),status:`completed`}}async function projectOutput(e,t,n){return n?.toModelOutput===void 0?renderModelOutputText(t.output):await observeToolOutput(e,t.calls??[],async()=>renderModelOutputText(await n.toModelOutput(t.output)),()=>renderModelOutputText(t.output))}function resolveTasksNote(e){let t=readTaskTable(e.session.state),n=workingTasks(t).map(toListedTask),r=idleTasks(t).map(toListedTask),i=e.messages.findLast(isTasksNote);if(i===void 0&&n.length===0&&r.length===0)return;let a=renderTasksNote({idle:r,working:n});return i?.content===a?void 0:a}function toListedTask(e){return{id:e.id,tool:e.name}}function isTasksNote(e){return e.role===`user`&&typeof e.content==`string`&&e.content.startsWith(TASKS_NOTE_LABEL)}export{appendTaskContext,commitCallEntry,isTaskTool,offersTasks,taskSystemMessages,withTaskTools,workingTaskIds};
+import{TASK_CANCEL_TOOL_NAME,TASK_WAIT_TOOL_NAME}from"#protocol/task-tools.js";import{createFrameworkUserMessage}from"#harness/messages.js";import{FINAL_REPLY_TASK_SYSTEM_BLOCK,TASKS_NOTE_LABEL,TASK_SYSTEM_BLOCK,renderModelOutputText,renderTaskResults,renderTasksNote}from"#execution/tasks/render.js";import{createTask,idleTasks,readTaskTable,takeTaskResults,workingTasks,writeTaskTable}from"#execution/tasks/table.js";import{entryPointOf,isAgentTool}from"#execution/tasks/tool-entry-point.js";import{observeToolOutput}from"#tool-stubs/execute.js";import{splitTaskIdInput}from"#execution/tasks/task-id-input.js";import{taskCancelTool}from"#tools/provided/task-cancel.js";import{taskWaitTool}from"#tools/provided/task-wait.js";function isTaskTool(e){return e?.frameworkAction===`task-wait`||e?.frameworkAction===`task-cancel`}function isWorkflowTool(e){return e?.workflowId!==void 0||isTaskTool(e)}function withTaskTools(e){return new Map([...e,[TASK_WAIT_TOOL_NAME,taskWaitTool],[TASK_CANCEL_TOOL_NAME,taskCancelTool]])}function taskSystemMessages(e,t){return e?[{content:t.finalReplyOnly?FINAL_REPLY_TASK_SYSTEM_BLOCK:TASK_SYSTEM_BLOCK,role:`system`}]:[]}function commitCallEntry(e,t){let n=entryPointOf(t.definition);switch(n){case`execute`:return{entry:{entryPoint:n},input:t.input,session:e};case`task`:return commitTask(e,t,n,t.input);case`serve`:{let{input:r,taskId:i}=splitTaskIdInput(t.input);return i===void 0?commitTask(e,t,n,r):{entry:{entryPoint:`receive`,taskId:i},input:r,session:e}}}}function commitTask(e,t,n,r){let i=createTask(readTaskTable(e.state),{callId:t.callId,kind:isAgentTool(t.definition)?`agent`:`tool`,name:t.toolName,resumable:n===`serve`,turnId:t.turnId});return{entry:{entryPoint:n,taskId:i.taskId},input:r,session:writeTaskTable(e,i.table)}}function workingTaskIds(e){return workingTasks(readTaskTable(e.state)).map(e=>e.id)}async function appendTaskContext(e){let t=[],n=await deliverTaskResults(e);n.message!==void 0&&t.push(createFrameworkUserMessage(`task.result`,n.message));let r=resolveTasksNote({messages:e.projectHistory([...e.messages,...t],n.session.state),session:n.session});return r!==void 0&&t.push(createFrameworkUserMessage(`context.state`,r)),{messages:t,session:n.session}}async function deliverTaskResults(e){let{table:t,taken:n}=takeTaskResults(readTaskTable(e.session.state));if(n.length===0)return{session:e.session};let r=[];for(let t of n)for(let n of t.results)r.push(await toResultBlock(t,n,e.tools.get(t.name)));return{message:renderTaskResults(r),session:writeTaskTable(e.session,t)}}async function toResultBlock(e,t,n){let r={taskId:e.id,tool:e.name};return t.status===`failed`?{...r,body:t.error,status:`failed`}:{...r,body:await projectOutput(e.name,t,n),status:`completed`}}async function projectOutput(e,t,n){return n?.toModelOutput===void 0?renderModelOutputText(t.output):await observeToolOutput(e,t.calls??[],async()=>renderModelOutputText(await n.toModelOutput(t.output)),()=>renderModelOutputText(t.output))}function resolveTasksNote(e){let t=readTaskTable(e.session.state),n=workingTasks(t).map(toListedTask),r=idleTasks(t).map(toListedTask),i=e.messages.findLast(isTasksNote);if(i===void 0&&n.length===0&&r.length===0)return;let a=renderTasksNote({idle:r,working:n});return i?.content===a?void 0:a}function toListedTask(e){return{id:e.id,tool:e.name}}function isTasksNote(e){return e.role===`user`&&typeof e.content==`string`&&e.content.startsWith(TASKS_NOTE_LABEL)}export{appendTaskContext,commitCallEntry,isTaskTool,isWorkflowTool,taskSystemMessages,withTaskTools,workingTaskIds};

package/dist/src/execution/tasks/render.d.ts

@@ -1,5 +1,5 @@
 import type { TaskCancelResult, TaskWaitResult } from "#execution/tasks/calls.js";
-export declare const TASK_WAIT_DESCRIPTION = "Call task_wait sparingly, only when you deliberately want to withhold a message from the user while waiting for a task result. Tasks keep running and their results reach you without calling task_wait. If the user should hear from you now, reply instead. Wait silently until any of your tasks has a result, a new message arrives, or timeoutSeconds pass. It returns after the first result, which follows in a <task_result> message; wait again only if you still want to withhold a reply until another result arrives. Waiting never stops a task.";
+export declare const TASK_WAIT_DESCRIPTION = "Call eve__task_wait sparingly, only when you deliberately want to withhold a message from the user while waiting for a task result. Tasks keep running and their results reach you without calling eve__task_wait. If the user should hear from you now, reply instead. Wait silently until any of your tasks has a result, a new message arrives, or timeoutSeconds pass. It returns after the first result, which follows in a <task_result> message; wait again only if you still want to withhold a reply until another result arrives. Waiting never stops a task.";
 export declare const TASK_WAIT_TIMEOUT_DESCRIPTION = "Optional. Seconds to wait before returning without a result. Omit it to wait for a result or a new message, which is almost always right. Don't use short timeouts to check on tasks: results reach you without checking.";
 export declare const TASK_CANCEL_DESCRIPTION = "Stop a task's current work. That work never reports back; if it already had a result, that result is still delivered. An agent, or any task that accepts more input, stays available: call its tool with its taskId to give it new work.";
 export declare const TASK_CANCEL_TASK_ID_DESCRIPTION = "The id of the task to stop, copied from its \"Started task\" receipt or the [Tasks] note.";
@@ -29,11 +29,11 @@ export declare function renderTaskReceipt(task: {
 export declare function renderTaskSentReceipt(taskId: string): string;
 export declare function renderUnknownTaskError(taskId: string, tool: string): string;
 export declare function renderUnknownCancelTaskError(taskId: string): string;
-/** What the model reads when `task_cancel` answers. */
+/** What the model reads when `eve__task_cancel` answers. */
 export declare function renderTaskCancelResult(taskId: string, result: TaskCancelResult): string;
 export declare function renderTooManyTasksError(max: number, workingIds: readonly string[]): string;
 export declare function renderFinalOutputWhileWorkingError(workingIds: readonly string[]): string;
-/** What the model reads when `task_wait` returns after waiting `waitedMs`. */
+/** What the model reads when `eve__task_wait` returns after waiting `waitedMs`. */
 export declare function renderTaskWaitResult(result: TaskWaitResult, waitedMs: number): string;
 /** One `<task_result>` block of a `task.result` message. */
 export interface TaskResultBlock {

package/dist/src/execution/tasks/render.js

@@ -1,6 +1,6 @@
-import{formatDuration}from"#shared/format-duration.js";const TASK_WAIT_DESCRIPTION=`Call task_wait sparingly, only when you deliberately want to withhold a message from the user while waiting for a task result. Tasks keep running and their results reach you without calling task_wait. If the user should hear from you now, reply instead. Wait silently until any of your tasks has a result, a new message arrives, or timeoutSeconds pass. It returns after the first result, which follows in a <task_result> message; wait again only if you still want to withhold a reply until another result arrives. Waiting never stops a task.`,TASK_WAIT_TIMEOUT_DESCRIPTION=`Optional. Seconds to wait before returning without a result. Omit it to wait for a result or a new message, which is almost always right. Don't use short timeouts to check on tasks: results reach you without checking.`,TASK_CANCEL_DESCRIPTION=`Stop a task's current work. That work never reports back; if it already had a result, that result is still delivered. An agent, or any task that accepts more input, stays available: call its tool with its taskId to give it new work.`,TASK_ID_SOURCE=`copied from its "Started task" receipt or the [Tasks] note`,TASK_CANCEL_TASK_ID_DESCRIPTION=`The id of the task to stop, ${TASK_ID_SOURCE}.`,TASK_SYSTEM_BLOCK_OPENING=[`Tasks`,`- A call that returns "Started task <id>" is a task: it keeps working while you continue. Every agent call is a task.`,`- Each result arrives once, in a <task_result> message. Until then you know nothing about it, so don't guess or report its result.`,`- Ending your reply doesn't end your turn. While tasks work, eve holds your turn and calls you again with each result.`],TASK_SYSTEM_BLOCK_CLOSING=[`- Don't redo work you delegated. Never use sleep or shell commands to wait for a task.`,`- To correct or continue an agent, or any task that accepts more input, call its tool again with its taskId. A new message never stops your tasks: answer it if it asks you something, decide whether it changes the work, then keep each task, correct an agent by taskId, or stop a task with task_cancel.`],TASK_SYSTEM_BLOCK=[...TASK_SYSTEM_BLOCK_OPENING,`- If you have nothing to tell the person until a result arrives, call task_wait. Start every independent task first, then wait.`,`- If the person should hear from you now, for example to confirm work is underway when they don't need the result yet, reply. When results arrive, report them without repeating yourself.`,...TASK_SYSTEM_BLOCK_CLOSING].join(`
-`),FINAL_REPLY_TASK_SYSTEM_BLOCK=[...TASK_SYSTEM_BLOCK_OPENING,`- Only your final reply reaches your caller. While tasks work, call task_wait instead of replying. Start every independent task first, then wait.`,...TASK_SYSTEM_BLOCK_CLOSING].join(`
-`),SERVE_TOOL_DESCRIPTION=`To send this task more input, call this tool again with its taskId; without taskId, each call starts a new task.`,AGENT_SERVE_TOOL_DESCRIPTION=`It does not see this conversation, so put everything it needs in message. To correct or continue an agent task, call this tool again with its taskId; without taskId, each call starts a new agent.`,TASK_ID_INPUT_DESCRIPTION=`The id of a task this tool started, ${TASK_ID_SOURCE}, to send it this input. Omit it to start a new task.`,TASKS_NOTE_LABEL=`[Tasks]`,TASK_RESULT_TAG=`<task_result`,UNREADABLE_TASK_ERROR=`The task's state could not be read.`;function renderTaskReceipt(e){let t=`Started task ${e.id}. Its result will arrive in a <task_result> message.`;return e.resumable?`${t} To send it another message, call ${e.tool} again with taskId ${e.id}.`:t}function renderTaskSentReceipt(e){return`Sent to task ${e}. Its reply will arrive in a <task_result> message.`}function renderUnknownTaskError(e,t){return`No task "${e}" is available to ${t}: it may have ended or belong to another tool. Start a new one by calling ${t} without taskId.`}function renderUnknownCancelTaskError(e){return`No task "${e}" is in this session. Copy an id from a "Started task" receipt or the [Tasks] note.`}function renderTaskCancelResult(e,t){return t.status===`already_finished`?`${e} had no work to stop.`:t.resumable?`Stopped ${e}'s current work; it won't report back. To give it new work, call ${t.tool} again with taskId ${e}.`:`Stopped ${e}; it won't report back.`}function renderTooManyTasksError(e,t){return`${String(e)} tasks are already working (${t.join(`, `)}). Wait with task_wait or stop one with task_cancel, then try again.`}function renderFinalOutputWhileWorkingError(e){return`You can't give your final output while tasks you started are working (${e.join(`, `)}). Wait for their results with task_wait, or stop a task with task_cancel, then call final_output.`}function renderTaskWaitResult(e,t){switch(e.status){case`settled`:return renderSettledWait(e.settled,e.working);case`timeout`:return`Stopped waiting after ${formatDuration(t)}; ${countWorking(e.working)}. ${resultsArriveLater(e.working.length)}`;case`interrupt`:return`A new message arrived, so the wait ended after ${formatDuration(t)}; ${countWorking(e.working)}. Read the message, answer it if it asks you something, and decide whether it changes this work: ${interruptChoices(e.working.length)}`}}function renderSettledWait(e,t){if(e.length===0&&t.length===0)return`No tasks are working.`;let n=[];if(e.length>0){let t=e.map(e=>`${e.id} ${e.status}`),r=e.length===1?`its result follows`:`their results follow`;n.push(`${joinList(t)}; ${r}.`)}return t.length>0&&n.push(`${capitalize(countWorking(t))}: ${t.join(`, `)}.`),n.join(` `)}function countWorking(e){return e.length===1?`1 task is still working`:`${String(e.length)} tasks are still working`}function resultsArriveLater(e){return e===1?`Its result arrives before your turn ends; wait again only if you need it now.`:`Their results arrive before your turn ends; wait again only if you need them now.`}function interruptChoices(e){return`${e===1?`keep the task`:`keep the tasks`}, call an agent again with its taskId to correct it, or stop a task with task_cancel.`}function renderTaskResults(e){let t={bytes:51200,lines:2e3};return e.map(e=>{let n=fitToBudget(escapeTaskResultBody(e.body),t),r=`id="${escapeAttribute(e.taskId)}" tool="${escapeAttribute(e.tool)}" status="${e.status}"`;return`${TASK_RESULT_TAG} ${r}>${n}</task_result>`}).join(`
+import{TASK_CANCEL_TOOL_NAME,TASK_WAIT_TOOL_NAME}from"#protocol/task-tools.js";import{REPLY_TOOL_NAME}from"#protocol/reply-tool.js";import{formatDuration}from"#shared/format-duration.js";const TASK_WAIT_DESCRIPTION=`Call ${TASK_WAIT_TOOL_NAME} sparingly, only when you deliberately want to withhold a message from the user while waiting for a task result. Tasks keep running and their results reach you without calling ${TASK_WAIT_TOOL_NAME}. If the user should hear from you now, reply instead. Wait silently until any of your tasks has a result, a new message arrives, or timeoutSeconds pass. It returns after the first result, which follows in a <task_result> message; wait again only if you still want to withhold a reply until another result arrives. Waiting never stops a task.`,TASK_WAIT_TIMEOUT_DESCRIPTION=`Optional. Seconds to wait before returning without a result. Omit it to wait for a result or a new message, which is almost always right. Don't use short timeouts to check on tasks: results reach you without checking.`,TASK_CANCEL_DESCRIPTION=`Stop a task's current work. That work never reports back; if it already had a result, that result is still delivered. An agent, or any task that accepts more input, stays available: call its tool with its taskId to give it new work.`,TASK_ID_SOURCE=`copied from its "Started task" receipt or the [Tasks] note`,TASK_CANCEL_TASK_ID_DESCRIPTION=`The id of the task to stop, ${TASK_ID_SOURCE}.`,TASK_SYSTEM_BLOCK_OPENING=[`Tasks`,`- A call that returns "Started task <id>" is a task: it keeps working while you continue. Every agent call is a task.`,`- Each result arrives once, in a <task_result> message. Until then you know nothing about it, so don't guess or report its result.`,`- Ending your reply doesn't end your turn. While tasks work, eve holds your turn and calls you again with each result.`],TASK_SYSTEM_BLOCK_CLOSING=[`- Don't redo work you delegated. Never use sleep or shell commands to wait for a task.`,`- To correct or continue an agent, or any task that accepts more input, call its tool again with its taskId. A new message never stops your tasks: answer it if it asks you something, decide whether it changes the work, then keep each task, correct an agent by taskId, or stop a task with ${TASK_CANCEL_TOOL_NAME}.`],TASK_SYSTEM_BLOCK=[...TASK_SYSTEM_BLOCK_OPENING,`- If you have nothing to tell the person until a result arrives, call ${TASK_WAIT_TOOL_NAME}. Start every independent task first, then wait.`,`- If the person should hear from you now, for example to confirm work is underway when they don't need the result yet, reply. When results arrive, report them without repeating yourself.`,...TASK_SYSTEM_BLOCK_CLOSING].join(`
+`),FINAL_REPLY_TASK_SYSTEM_BLOCK=[...TASK_SYSTEM_BLOCK_OPENING,`- Only your final reply reaches your caller. While tasks work, call ${TASK_WAIT_TOOL_NAME} instead of replying. Start every independent task first, then wait.`,...TASK_SYSTEM_BLOCK_CLOSING].join(`
+`),SERVE_TOOL_DESCRIPTION=`To send this task more input, call this tool again with its taskId; without taskId, each call starts a new task.`,AGENT_SERVE_TOOL_DESCRIPTION=`It does not see this conversation, so put everything it needs in message. To correct or continue an agent task, call this tool again with its taskId; without taskId, each call starts a new agent.`,TASK_ID_INPUT_DESCRIPTION=`The id of a task this tool started, ${TASK_ID_SOURCE}, to send it this input. Omit it to start a new task.`,TASKS_NOTE_LABEL=`[Tasks]`,TASK_RESULT_TAG=`<task_result`,UNREADABLE_TASK_ERROR=`The task's state could not be read.`;function renderTaskReceipt(e){let t=`Started task ${e.id}. Its result will arrive in a <task_result> message.`;return e.resumable?`${t} To send it another message, call ${e.tool} again with taskId ${e.id}.`:t}function renderTaskSentReceipt(e){return`Sent to task ${e}. Its reply will arrive in a <task_result> message.`}function renderUnknownTaskError(e,t){return`No task "${e}" is available to ${t}: it may have ended or belong to another tool. Start a new one by calling ${t} without taskId.`}function renderUnknownCancelTaskError(e){return`No task "${e}" is in this session. Copy an id from a "Started task" receipt or the [Tasks] note.`}function renderTaskCancelResult(e,t){return t.status===`already_finished`?`${e} had no work to stop.`:t.resumable?`Stopped ${e}'s current work; it won't report back. To give it new work, call ${t.tool} again with taskId ${e}.`:`Stopped ${e}; it won't report back.`}function renderTooManyTasksError(e,t){return`${String(e)} tasks are already working (${t.join(`, `)}). Wait with ${TASK_WAIT_TOOL_NAME} or stop one with ${TASK_CANCEL_TOOL_NAME}, then try again.`}function renderFinalOutputWhileWorkingError(e){return`You can't give your final reply while tasks you started are working (${e.join(`, `)}). Wait for their results with ${TASK_WAIT_TOOL_NAME}, or stop a task with ${TASK_CANCEL_TOOL_NAME}, then call ${REPLY_TOOL_NAME}.`}function renderTaskWaitResult(e,t){switch(e.status){case`settled`:return renderSettledWait(e.settled,e.working);case`timeout`:return`Stopped waiting after ${formatDuration(t)}; ${countWorking(e.working)}. ${resultsArriveLater(e.working.length)}`;case`interrupt`:return`A new message arrived, so the wait ended after ${formatDuration(t)}; ${countWorking(e.working)}. Read the message, answer it if it asks you something, and decide whether it changes this work: ${interruptChoices(e.working.length)}`}}function renderSettledWait(e,t){if(e.length===0&&t.length===0)return`No tasks are working.`;let n=[];if(e.length>0){let t=e.map(e=>`${e.id} ${e.status}`),r=e.length===1?`its result follows`:`their results follow`;n.push(`${joinList(t)}; ${r}.`)}return t.length>0&&n.push(`${capitalize(countWorking(t))}: ${t.join(`, `)}.`),n.join(` `)}function countWorking(e){return e.length===1?`1 task is still working`:`${String(e.length)} tasks are still working`}function resultsArriveLater(e){return e===1?`Its result arrives before your turn ends; wait again only if you need it now.`:`Their results arrive before your turn ends; wait again only if you need them now.`}function interruptChoices(e){return`${e===1?`keep the task`:`keep the tasks`}, call an agent again with its taskId to correct it, or stop a task with ${TASK_CANCEL_TOOL_NAME}.`}function renderTaskResults(e){let t={bytes:51200,lines:2e3};return e.map(e=>{let n=fitToBudget(escapeTaskResultBody(e.body),t),r=`id="${escapeAttribute(e.taskId)}" tool="${escapeAttribute(e.tool)}" status="${e.status}"`;return`${TASK_RESULT_TAG} ${r}>${n}</task_result>`}).join(`
 `)}const TASK_RESULT_BLOCK=RegExp(`${TASK_RESULT_TAG} id="([^"]*)" tool="([^"]*)" status="(completed|failed)">([\\s\\S]*?)</task_result>`,`g`);function readTaskResults(e){return[...e.matchAll(TASK_RESULT_BLOCK)].map(([,e,t,n,r])=>({body:r.replaceAll(`<\\/task_result`,`</task_result`),status:n,taskId:e,tool:t}))}function fitToBudget(e,t){let n=new TextEncoder,r=e.split(`
 `),i=[];for(let e of r){let r=n.encode(e).byteLength+1;if(t.lines===0||r>t.bytes){i.push(`[truncated]`),t.lines=0,t.bytes=0;break}i.push(e),--t.lines,t.bytes-=r}return i.join(`
 `)}function escapeTaskResultBody(e){return e.replaceAll(`</task_result`,`<\\/task_result`)}function renderModelOutputText(e){if(typeof e==`string`)return e;if(isModelOutput(e))switch(e.type){case`text`:return String(e.value);case`json`:return JSON.stringify(e.value);case`content`:return renderContentParts(e.value)}return JSON.stringify(e??null)}function renderContentParts(e){return Array.isArray(e)?e.map(e=>e.type===`text`?String(e.text):`[file: ${typeof e.filename==`string`?e.filename:String(e.mediaType)}]`).join(`

package/dist/src/execution/tasks/session.d.ts

@@ -4,6 +4,7 @@ import { type TaskRunMessage } from "#execution/tasks/steps.js";
 import { type TaskTable } from "#execution/tasks/table.js";
 import type { WorkflowToolRunMessage } from "#execution/tools/workflow/messages.js";
 import type { TaskCancelReason } from "#protocol/message.js";
+import { TASK_CANCEL_TOOL_NAME } from "#protocol/task-tools.js";
 import type { RuntimeActionResult } from "#shared/action-types.js";
 /** Whether a run's message changes a task record. */
 export declare function isTaskRunMessage(message: WorkflowToolRunMessage): message is TaskRunMessage;
@@ -15,5 +16,5 @@ export declare function sessionTaskTable(cursor: SessionStateCursor): TaskTable;
  */
 export declare function cancelWorkingTasks(cursor: SessionStateCursor, reason: Exclude<TaskCancelReason, "task_cancel">): Promise<void>;
 export declare function answerTaskCancel(cursor: SessionStateCursor, call: Extract<TaskToolCall, {
-    readonly kind: "task_cancel";
+    readonly kind: typeof TASK_CANCEL_TOOL_NAME;
 }>): Promise<RuntimeActionResult>;

package/dist/src/execution/tasks/table.d.ts

@@ -111,7 +111,7 @@ export declare function taskWaitResult(table: TaskTable, wake: {
     readonly timedOut: boolean;
 }): TaskWaitResult | undefined;
 /**
- * What `task_cancel` answers, or `undefined` for a task that doesn't exist.
+ * What `eve__task_cancel` answers, or `undefined` for a task that doesn't exist.
  * `cancelled` means the caller cancels the working task.
  */
 export declare function taskCancelResult(table: TaskTable, taskId: string): TaskCancelResult | undefined;

package/dist/src/execution/tasks/tool-entry-point.d.ts

@@ -1,7 +1,7 @@
 import type { HarnessToolDefinition } from "#harness/execute-tool.js";
 import type { WorkflowToolEntryPoint } from "#tools/workflow-entry-point.js";
 /**
- * The entry point a deferred tool's calls run through. Every agent tool is a
+ * The entry point a workflow tool's calls run through. Every agent tool is a
  * `serve` tool; tools that dispatch nowhere are called like `execute`.
  */
 export declare function entryPointOf(definition: HarnessToolDefinition | undefined): WorkflowToolEntryPoint;

package/dist/src/execution/tool-auth.js

@@ -1 +1 @@
-import{buildBaseToolContext}from"#context/build-base-tool-context.js";import{createAuthorizationContext}from"#runtime/authorization-context.js";import{handleAuthorizationError}from"#runtime/connections/scoped-authorization.js";function createToolExecuteWithAuth(e){return(t,n)=>{let r=createAuthorizationContext({scope:e.scope}),i={...buildBaseToolContext({options:n,toolName:e.scope}),messages:n.messages,getToken:r.getToken,requireAuth:r.requireAuth};return r.run(()=>e.execute(t,i))}}function buildApprovalResponseAuth(e){let t=createAuthorizationContext({scope:e.scope,boundResponder:e.responder});return{getToken:(n,r)=>t.getToken(n,namespaceApprovalAuthOptions(e.scope,r)),requireAuth:(n,r)=>t.requireAuth(n,namespaceApprovalAuthOptions(e.scope,r))}}function namespaceApprovalAuthOptions(e,t){return t?.authKey===void 0?t:{...t,authKey:`${e}:${t.authKey}`}}async function handleApprovalResponsePolicyError(e){return await handleAuthorizationError(e)}export{buildApprovalResponseAuth,createToolExecuteWithAuth,handleApprovalResponsePolicyError};
+import{handleAuthorizationError}from"#runtime/connections/scoped-authorization.js";import{buildBaseToolContext}from"#context/build-base-tool-context.js";import{createAuthorizationContext}from"#runtime/authorization-context.js";function createToolExecuteWithAuth(e){return(t,n)=>{let r=createAuthorizationContext({scope:e.scope}),i={...buildBaseToolContext({options:n,toolName:e.scope}),messages:n.messages,getToken:r.getToken,requireAuth:r.requireAuth};return r.run(()=>e.execute(t,i))}}function buildApprovalResponseAuth(e){let t=createAuthorizationContext({scope:e.scope,boundResponder:e.responder});return{getToken:(n,r)=>t.getToken(n,namespaceApprovalAuthOptions(e.scope,r)),requireAuth:(n,r)=>t.requireAuth(n,namespaceApprovalAuthOptions(e.scope,r))}}function namespaceApprovalAuthOptions(e,t){return t?.authKey===void 0?t:{...t,authKey:`${e}:${t.authKey}`}}async function handleApprovalResponsePolicyError(e){return await handleAuthorizationError(e)}export{buildApprovalResponseAuth,createToolExecuteWithAuth,handleApprovalResponsePolicyError};

package/dist/src/execution/tools/agent-router-workflow.js

@@ -1 +1 @@
-import{decide}from"#ai/decide.js";async function runAgentRouterTask(e,t){"use workflow";let n=await chooseTarget(e.message,descriptions(t),t.abortSignal),{message:r,status:i}=await(await t.agent(n).send(e.message,{signal:t.abortSignal})).result();if(i===`failed`)throw Error(`Agent "${n}" failed to handle the task.`);return r??null}async function chooseTarget(e,t,n){"use step";let r=Object.keys(t);if(r.length===0)throw Error(`agentRouter requires at least one available agent with a description.`);return r.length===1?r[0]:(await decide({abortSignal:n,state:{message:e},questions:{route:{type:`choice`,instructions:`Which subagent should handle this task?`,criteria:t}}})).answers.route.choice}function descriptions(e){return Object.fromEntries(Object.entries(e.agents).flatMap(([e,t])=>{let n=t.description.trim();return n.length===0?[]:[[e,n]]}))}runAgentRouterTask.workflowId=`workflow//eve@0.75.1//runAgentRouterTask`;export{runAgentRouterTask};
+import{decide}from"#ai/decide.js";async function runAgentRouterTask(e,t){"use workflow";let n=await chooseTarget(e.message,descriptions(t),t.abortSignal),{message:r,status:i}=await(await t.agent(n).send(e.message,{signal:t.abortSignal})).result();if(i===`failed`)throw Error(`Agent "${n}" failed to handle the task.`);return r??null}async function chooseTarget(e,t,n){"use step";let r=Object.keys(t);if(r.length===0)throw Error(`agentRouter requires at least one available agent with a description.`);return r.length===1?r[0]:(await decide({abortSignal:n,state:{message:e},questions:{route:{type:`choice`,instructions:`Which subagent should handle this task?`,criteria:t}}})).answers.route.choice}function descriptions(e){return Object.fromEntries(Object.entries(e.agents).flatMap(([e,t])=>{let n=t.description.trim();return n.length===0?[]:[[e,n]]}))}runAgentRouterTask.workflowId=`workflow//eve@0.76.2//runAgentRouterTask`;export{runAgentRouterTask};

package/dist/src/execution/tools/workflow/harness-definition.js

@@ -1 +1 @@
-import{UNSPECIFIED_INPUT_SCHEMA,toInputSchema,toOutputSchema}from"#tools/schema.js";import{workflowIdForHandling}from"#runtime/subagents/workflow-reference.js";import{withTaskIdInput}from"#execution/tasks/task-id-input.js";import{entryPointOf}from"#execution/tasks/tool-entry-point.js";function createWorkflowToolHarnessDefinition(e){return{...entryPointOf(e.definition)===`serve`?withTaskIdInput(e.definition):e.definition,execute:void 0,executeInput:e.executeInput,workflowId:e.workflowId}}function createPreparedWorkflowToolHarnessDefinition(e){let t=workflowIdForHandling(e.behavior?.handling);if(t===void 0)throw Error(`Prepared tool "${e.name}" is not backed by a workflow.`);return createWorkflowToolHarnessDefinition({definition:{frameworkTool:e.kind!==`authored-tool`||e.owner.kind===`framework`,behavior:e.behavior,description:e.description,inputSchema:toInputSchema(e.inputSchema)??UNSPECIFIED_INPUT_SCHEMA,name:e.name,outputSchema:toOutputSchema(e.outputSchema),rootOnly:e.rootOnly},workflowId:t})}export{createPreparedWorkflowToolHarnessDefinition,createWorkflowToolHarnessDefinition};
+import{UNSPECIFIED_INPUT_SCHEMA,toInputSchema,toOutputSchema}from"#tools/schema.js";import{workflowIdForHandling}from"#runtime/subagents/workflow-reference.js";import{entryPointOf}from"#execution/tasks/tool-entry-point.js";import{withTaskIdInput}from"#execution/tasks/task-id-input.js";function createWorkflowToolHarnessDefinition(e){return{...entryPointOf(e.definition)===`serve`?withTaskIdInput(e.definition):e.definition,execute:void 0,executeInput:e.executeInput,workflowId:e.workflowId}}function createPreparedWorkflowToolHarnessDefinition(e){let t=workflowIdForHandling(e.behavior?.handling);if(t===void 0)throw Error(`Prepared tool "${e.name}" is not backed by a workflow.`);return createWorkflowToolHarnessDefinition({definition:{frameworkTool:e.kind!==`authored-tool`||e.owner.kind===`framework`,behavior:e.behavior,deferred:e.deferred,description:e.description,inputSchema:toInputSchema(e.inputSchema)??UNSPECIFIED_INPUT_SCHEMA,name:e.name,outputSchema:toOutputSchema(e.outputSchema),rootOnly:e.rootOnly},workflowId:t})}export{createPreparedWorkflowToolHarnessDefinition,createWorkflowToolHarnessDefinition};

package/dist/src/execution/workflow-runtime.d.ts

@@ -42,7 +42,11 @@ export type SessionOwnerStartInput = SessionHandoffStart & {
 };
 /** Starts a successor owner and binds its output to the original session stream. */
 export declare function startSessionOwnerStep(input: SessionOwnerStartInput): Promise<void>;
-/** Sends one command to a session through its stable command inbox. */
+/**
+ * Sends one command to a session through its stable command inbox. A caller
+ * holding the session id asked for that exact session, so a send to a
+ * stranded one is refused rather than replaced.
+ */
 export declare function dispatchWorkflowSessionCommand<TCommand extends SessionCommand>(input: DispatchSessionInput<TCommand>): Promise<SessionCommandResult<TCommand>>;
 /** Requests cancellation through a session's stable command inbox. */
 export declare function requestWorkflowTurnCancellation(input: CancelTurnInput): Promise<CancelTurnResult>;

package/dist/src/execution/workflow-runtime.js

@@ -1 +1 @@
-import{createLogger,logError}from"#internal/logging.js";import{sessionCommandHookToken,sessionInboxHookToken}from"#execution/session-inbox/address.js";import{resolveInstalledPackageInfo}from"#internal/application/package.js";import{walkCauseChain}from"#shared/errors.js";import{validateToolStubTargets}from"#tool-stubs/validate-targets.js";import{getHookByToken,getRun,getWorld,start}from"#internal/workflow/runtime.js";import{getCompiledRuntimeAgentBundle}from"#runtime/sessions/compiled-agent-cache.js";import{ROOT_RUNTIME_AGENT_NODE_ID}from"#runtime/graph.js";import{serializeContext}from"#context/serialize.js";import{AcceptedSessionIdentityError,resolveSessionInbox,resumeSessionInbox}from"#execution/session-inbox/resume.js";import{resolveEffectiveAgentRuntime}from"#execution/effective-agent-config.js";import{context,trace}from"#compiled/@opentelemetry/api/index.js";import{EntityConflictError,HookNotFoundError,RunExpiredError,WorkflowRunNotFoundError}from"#compiled/@workflow/errors/index.js";import{initializeSessionInstrumentation}from"#instrumentation/runtime.js";import{buildSessionAttributes,buildSubagentRootAttributes,readParentLineage}from"#execution/eve-workflow-attributes.js";import{normalizeEveAttributes}from"#runtime/attributes/normalize.js";import{buildRunContext}from"#execution/runtime-context.js";import{readSessionEventStream,readSessionStreamTailIndex}from"#execution/session-event-stream.js";import{SESSION_HANDOFF_VERSION}from"#execution/session/entry-input.js";import{buildInvocationAttributes}from"#internal/invocation/metadata.js";import{isAgentTraceContext}from"#tracing/agent-trace-context.js";import{SESSION_TIMEOUT_WORKFLOW_NAME,WORKFLOW_ENTRY_NAME,WORKFLOW_TOOL_RUN_WORKFLOW_NAME}from"#execution/stable-workflow-names.js";const EVE_PACKAGE_INFO=resolveInstalledPackageInfo(),COMMAND_HOOK_READY_TIMEOUT_MS=3e4,STABLE_ID_BASE=EVE_PACKAGE_INFO.name,log=createLogger(`execution.workflow-runtime`),workflowEntryReference={workflowId:`workflow//${STABLE_ID_BASE}//${WORKFLOW_ENTRY_NAME}`},sessionTimeoutWorkflowReference={workflowId:`workflow//${STABLE_ID_BASE}//${SESSION_TIMEOUT_WORKFLOW_NAME}`},workflowToolRunWorkflowReference={workflowId:`workflow//${STABLE_ID_BASE}//${WORKFLOW_TOOL_RUN_WORKFLOW_NAME}`};function createWorkflowRuntime(e){return{async createSession(t){let n=await getCompiledRuntimeAgentBundle({compiledArtifactsSource:e.compiledArtifactsSource,nodeId:e.nodeId});t.toolStubs!==void 0&&t.toolStubs.rootSessionId===void 0&&validateToolStubTargets(t.toolStubs.rules,n.graph);let r=buildRunContext({bundle:n,dynamicSubagentAgentConfig:e.dynamicSubagentAgentConfig,run:t}),i=resolveEffectiveAgentRuntime(n,r);initializeSessionInstrumentation({agentName:i.turnAgent.id,ctx:r});let a=i.limits?.sessionTimeoutMs,o=n.resolvedAgent.config?.experimental?.workflow?.retention,s=serializeContext(r),c=readParentLineage(s),l={kind:`initial`,input:t.input,ownerDeploymentId:await resolveCurrentWorkflowDeploymentId(),serializedContext:s};t.limits!==void 0&&(l.limits=t.limits),t.continuationConflictCommand!==void 0&&(l.continuationConflictCommand=t.continuationConflictCommand),a!==void 0&&(l.sessionTimeoutMs=a),o!==void 0&&(l.retention=o);let u={...c.sessionId===void 0?buildSessionAttributes({serializedContext:s}):buildSubagentRootAttributes({identity:{nodeId:n.nodeId??ROOT_RUNTIME_AGENT_NODE_ID},parentCallId:c.callId,parentSessionId:c.sessionId,parentTurnId:c.turnId,rootSessionId:c.rootSessionId??c.sessionId,serializedContext:s}),...t.externalInvocation===void 0?{}:buildInvocationAttributes(t.externalInvocation)},d;try{let e={allowReservedAttributes:!0,attributes:normalizeEveAttributes(u)};o!==void 0&&(e.experimental_retention=o),d=await startWorkflowOnDeployment(workflowEntryReference,[l],l.ownerDeploymentId,e)}catch(e){throw logError(log,`failed to start workflow run`,e,{continuationToken:t.continuationToken}),e}let f,getEvents=()=>(f??=readSessionEventStream(d.runId),f);return{get events(){return getEvents()},sessionId:d.runId}},async dispatchContinuation(e){return await dispatchWorkflowCommand(e.continuationToken,e.command)},async dispatchSession(e){return await dispatchWorkflowSessionCommand(e)},async getEventStream(e,t){return readSessionEventStream(e,t?.startIndex)},async getStreamTailIndex(e){return await readSessionStreamTailIndex(e)},async resolveContinuation(e){try{return await resolveSessionInbox(e)}catch(t){if(HookNotFoundError.is(t))return;throw logError(log,`failed to resolve session by continuation token`,t,{continuationToken:e}),t}}}}async function startSessionOwnerStep(e){"use step";let{activationToken:t,anchorRunId:n,checkpoint:r,targetDeploymentId:i,...a}=e,o={...a,activationToken:t,checkpoint:r,handoffVersion:SESSION_HANDOFF_VERSION,kind:`handoff`,ownerDeploymentId:i,sessionWritable:getRun(n).getWritable(),sessionId:n};await startWorkflowOnDeployment(workflowEntryReference,[o],i,r.retention===void 0?void 0:{experimental_retention:r.retention})}async function dispatchWorkflowCommand(e,t){let n;try{let r=await resumeSessionInbox(e,t);n={runId:r.ownerRunId,sessionId:await r.sessionId}}catch(n){if(isInactiveCommandTarget(n)){if(t.kind===`send`&&typeof e!=`string`)try{let t=await getRun(e.sessionId).status;if(t===`pending`||t===`running`)return{status:`session_not_active`,retryable:!0}}catch(e){if(!isInactiveCommandTarget(e))throw e}return inactiveCommandResult(t)}throw logError(log,`failed to dispatch session command`,n,{command:t.kind,token:e}),n}if(t.kind===`reset`){let t=typeof e==`string`?e:sessionCommandHookToken(e.sessionId),r=new Set([sessionCommandHookToken(n.sessionId),t]);await Promise.all([...r].map(e=>waitForHookRelease(sessionInboxHookToken(e),n.runId)))}return activeCommandResult(t,n.sessionId)}function activeCommandResult(e,t){return e.kind===`reset`?{previousSessionId:t,status:`reset`}:e.kind===`send`&&e.delivery!==void 0?{sessionId:t,status:`accepted`,deliveryId:e.delivery.deliveryId}:{sessionId:t,status:`accepted`}}function inactiveCommandResult(e){return e.kind===`send`?{status:`session_not_active`}:e.kind===`cancel`?{status:`no_active_turn`}:{status:`no_active_session`}}async function dispatchWorkflowSessionCommand(e){return await dispatchWorkflowCommand({sessionId:e.sessionId},e.command)}async function requestWorkflowTurnCancellation(e){let t={kind:`cancel`};return e.turnId!==void 0&&(t.turnId=e.turnId),await dispatchWorkflowCommand({sessionId:e.sessionId},t)}function isInactiveCommandTarget(e){if(e instanceof AcceptedSessionIdentityError)return!1;if(HookNotFoundError.is(e))return!0;for(let t of walkCauseChain(e))if(WorkflowRunNotFoundError.is(t)||RunExpiredError.is(t)||EntityConflictError.is(t))return!0;return!1}async function waitForCommandHookOwner(e){let t=Date.now()+COMMAND_HOOK_READY_TIMEOUT_MS;for(;;)try{return normalizeWorkflowHook(await getHookByToken(e))}catch(e){if(!HookNotFoundError.is(e)||Date.now()>=t)throw e;await new Promise(e=>setTimeout(e,20))}}async function waitForHookRelease(e,t){let n=Date.now()+COMMAND_HOOK_READY_TIMEOUT_MS;for(;;){try{if(normalizeWorkflowHook(await getHookByToken(e)).runId!==t)return}catch(e){if(HookNotFoundError.is(e))return;throw e}if(Date.now()>=n)throw Error(`Timed out waiting for session "${t}" to release inbox "${e}".`);await new Promise(e=>setTimeout(e,20))}}async function startWorkflowOnCurrentDeployment(e,t,n){return await startWorkflowOnDeployment(e,t,await resolveCurrentWorkflowDeploymentId(),n)}async function startWorkflowOnDeployment(e,t,n,r){return await withWorkflowStartContext(async()=>{if(n.length===0||n===`latest`)throw Error(`Workflow starts require an exact deployment id.`);return await start(e,t,{...r,deploymentId:n})})}async function resolveCurrentWorkflowDeploymentId(){let e=process.env.VERCEL_DEPLOYMENT_ID?.trim()||await(await getWorld()).getDeploymentId();if(e.length===0||e===`latest`)throw Error(`Workflow runtime could not resolve an exact deployment id.`);return e}async function withWorkflowStartContext(e){let t=context.active(),n=isAgentTraceContext(t)?trace.deleteSpan(t):t;return await context.with(n,e)}function normalizeWorkflowHook(e){if(typeof e!=`object`||!e||!(`runId`in e))throw Error(`Workflow hook did not include a run id.`);let t=e.runId;if(typeof t!=`string`||t.length===0)throw Error(`Workflow hook did not include a run id.`);return{runId:t}}export{createWorkflowRuntime,dispatchWorkflowSessionCommand,requestWorkflowTurnCancellation,sessionTimeoutWorkflowReference,startSessionOwnerStep,startWorkflowOnCurrentDeployment,waitForCommandHookOwner,workflowEntryReference,workflowToolRunWorkflowReference};
+import{createLogger,logError}from"#internal/logging.js";import{sessionCommandHookToken,sessionInboxHookToken}from"#execution/session-inbox/address.js";import{SessionPredecessorKey}from"#context/keys.js";import{resolveInstalledPackageInfo}from"#internal/application/package.js";import{walkCauseChain}from"#shared/errors.js";import{validateToolStubTargets}from"#tool-stubs/validate-targets.js";import{getHookByToken,getRun,getWorld,start}from"#internal/workflow/runtime.js";import{SessionStrandedError,describeStrandedSession}from"#channel/session-stranded-error.js";import{getCompiledRuntimeAgentBundle}from"#runtime/sessions/compiled-agent-cache.js";import{ROOT_RUNTIME_AGENT_NODE_ID}from"#runtime/graph.js";import{serializeContext}from"#context/serialize.js";import{AcceptedSessionIdentityError,SessionHandoffPendingError,logicalSessionToken,resolveSessionInbox,resumeSessionInbox}from"#execution/session-inbox/resume.js";import{resolveEffectiveAgentRuntime}from"#execution/effective-agent-config.js";import{context,trace}from"#compiled/@opentelemetry/api/index.js";import{EntityConflictError,HookNotFoundError,RunExpiredError,WorkflowRunNotFoundError}from"#compiled/@workflow/errors/index.js";import{StrandedSessionOwnerError,assertRunnableSessionInbox}from"#execution/session-inbox/owner.js";import{initializeSessionInstrumentation}from"#instrumentation/runtime.js";import{EVE_VERSION_ATTRIBUTE,buildSessionAttributes,buildSubagentRootAttributes,readParentLineage}from"#execution/eve-workflow-attributes.js";import{endStrandedSession}from"#execution/session-inbox/end-stranded-session.js";import{SESSION_HOOK_HANDOVER_TIMEOUT_MS,waitForSessionHooksRelease}from"#execution/session-inbox/hook-release.js";import{SESSION_TIMEOUT_WORKFLOW_NAME,WORKFLOW_ENTRY_NAME,WORKFLOW_TOOL_RUN_WORKFLOW_NAME}from"#execution/stable-workflow-names.js";import{normalizeEveAttributes}from"#runtime/attributes/normalize.js";import{buildRunContext}from"#execution/runtime-context.js";import{readSessionEventHistory,readSessionEventStream,readSessionStreamTailIndex}from"#execution/session-event-stream.js";import{SESSION_HANDOFF_VERSION}from"#execution/session/entry-input.js";import{buildInvocationAttributes}from"#internal/invocation/metadata.js";import{isAgentTraceContext}from"#tracing/agent-trace-context.js";const EVE_PACKAGE_INFO=resolveInstalledPackageInfo(),STABLE_ID_BASE=EVE_PACKAGE_INFO.name,log=createLogger(`execution.workflow-runtime`),workflowEntryReference={workflowId:`workflow//${STABLE_ID_BASE}//${WORKFLOW_ENTRY_NAME}`},sessionTimeoutWorkflowReference={workflowId:`workflow//${STABLE_ID_BASE}//${SESSION_TIMEOUT_WORKFLOW_NAME}`},workflowToolRunWorkflowReference={workflowId:`workflow//${STABLE_ID_BASE}//${WORKFLOW_TOOL_RUN_WORKFLOW_NAME}`};function createWorkflowRuntime(e){let startSession=async(t,n)=>{let r=await getCompiledRuntimeAgentBundle({compiledArtifactsSource:e.compiledArtifactsSource,nodeId:e.nodeId});t.toolStubs!==void 0&&t.toolStubs.rootSessionId===void 0&&validateToolStubTargets(t.toolStubs.rules,r.graph);let i=buildRunContext({bundle:r,dynamicSubagentAgentConfig:e.dynamicSubagentAgentConfig,run:t});n!==void 0&&i.set(SessionPredecessorKey,n);let a=resolveEffectiveAgentRuntime(r,i);initializeSessionInstrumentation({agentName:a.turnAgent.id,ctx:i});let o=a.limits?.sessionTimeoutMs,s=r.resolvedAgent.config?.experimental?.workflow?.retention,c=serializeContext(i),l=readParentLineage(c),u={kind:`initial`,input:t.input,ownerDeploymentId:await resolveCurrentWorkflowDeploymentId(),serializedContext:c};t.limits!==void 0&&(u.limits=t.limits),t.continuationConflictCommand!==void 0&&(u.continuationConflictCommand=t.continuationConflictCommand),o!==void 0&&(u.sessionTimeoutMs=o),s!==void 0&&(u.retention=s);let d={...l.sessionId===void 0?buildSessionAttributes({serializedContext:c}):buildSubagentRootAttributes({identity:{nodeId:r.nodeId??ROOT_RUNTIME_AGENT_NODE_ID},parentCallId:l.callId,parentSessionId:l.sessionId,parentTurnId:l.turnId,rootSessionId:l.rootSessionId??l.sessionId,serializedContext:c}),...t.externalInvocation===void 0?{}:buildInvocationAttributes(t.externalInvocation)},f;try{let e={allowReservedAttributes:!0,attributes:normalizeEveAttributes(d)};s!==void 0&&(e.experimental_retention=s),f=await startWorkflowOnDeployment(workflowEntryReference,[u],u.ownerDeploymentId,e)}catch(e){throw logError(log,`failed to start workflow run`,e,{continuationToken:t.continuationToken}),e}let p,getEvents=()=>(p??=readSessionEventStream(f.runId),p);return{get events(){return getEvents()},sessionId:f.runId}};return{async createSession(e){return await startSession(e)},async dispatchContinuation(e){let{command:t,continuationToken:n,successor:r}=e;try{return await dispatchWorkflowCommand(n,t)}catch(e){if(!(e instanceof StrandedSessionOwnerError))throw e;if(t.kind!==`send`||r===void 0)return await settleStrandedCommand(n,t,e);if((t.payload.inputResponses?.length??0)>0)throw sessionStrandedError(e,`Its pending requests can no longer be answered; send a new message to start a fresh session.`);let i=await endStrandedSession(e,n,`message`);return{sessionId:(await startSession(r,{sessionId:i})).sessionId,status:`accepted`}}},async dispatchSession(e){return await dispatchWorkflowSessionCommand(e)},async getEventStream(e,t){if(t?.follow===!1)return readSessionEventHistory(e,t.startIndex);try{await assertRunnableSessionInbox(sessionInboxHookToken(sessionCommandHookToken(e)))}catch(e){throw e instanceof StrandedSessionOwnerError?sessionStrandedError(e):e}return readSessionEventStream(e,t?.startIndex)},async getStreamTailIndex(e){return await readSessionStreamTailIndex(e)},async resolveContinuation(e){try{return await resolveSessionInbox(e)}catch(t){if(HookNotFoundError.is(t))return;throw logError(log,`failed to resolve session by continuation token`,t,{continuationToken:e}),t}}}}async function startSessionOwnerStep(e){"use step";let{activationToken:t,anchorRunId:n,checkpoint:r,targetDeploymentId:i,...a}=e,o={...a,activationToken:t,checkpoint:r,handoffVersion:SESSION_HANDOFF_VERSION,kind:`handoff`,ownerDeploymentId:i,sessionWritable:getRun(n).getWritable(),sessionId:n};await startWorkflowOnDeployment(workflowEntryReference,[o],i,r.retention===void 0?void 0:{experimental_retention:r.retention})}async function dispatchWorkflowCommand(e,t){let n;try{let r=await resumeSessionInbox(e,t);n={runId:r.ownerRunId,sessionId:await r.sessionId}}catch(n){if(n instanceof StrandedSessionOwnerError)throw n;let r=t.kind===`send`&&typeof e!=`string`,i={status:`session_not_active`,retryable:!0};if(n instanceof SessionHandoffPendingError){if(r)return i;throw n}if(isInactiveCommandTarget(n))return r&&await isRunActive(e.sessionId)?i:inactiveCommandResult(t);throw logError(log,`failed to dispatch session command`,n,{command:t.kind,token:e}),n}return t.kind===`reset`&&await waitForSessionHooksRelease([sessionCommandHookToken(n.sessionId),logicalSessionToken(e)],n.runId),activeCommandResult(t,n.sessionId)}async function settleStrandedCommand(e,t,n){switch(t.kind){case`reset`:return{previousSessionId:await endStrandedSession(n,e,`reset`),status:`reset`};case`send`:case`clear`:throw sessionStrandedError(n);default:return inactiveCommandResult(t)}}function sessionStrandedError(e,t){let n=e.eveVersion===void 0?{}:{eveVersion:e.eveVersion};return new SessionStrandedError(n,describeStrandedSession(n,t))}function activeCommandResult(e,t){return e.kind===`reset`?{previousSessionId:t,status:`reset`}:e.kind===`send`&&e.delivery!==void 0?{sessionId:t,status:`accepted`,deliveryId:e.delivery.deliveryId}:{sessionId:t,status:`accepted`}}function inactiveCommandResult(e){return e.kind===`send`?{status:`session_not_active`}:e.kind===`cancel`?{status:`no_active_turn`}:{status:`no_active_session`}}async function dispatchWorkflowSessionCommand(e){let t={sessionId:e.sessionId};try{return await dispatchWorkflowCommand(t,e.command)}catch(n){if(!(n instanceof StrandedSessionOwnerError))throw n;return await settleStrandedCommand(t,e.command,n)}}async function requestWorkflowTurnCancellation(e){let t={kind:`cancel`};return e.turnId!==void 0&&(t.turnId=e.turnId),await dispatchWorkflowSessionCommand({command:t,sessionId:e.sessionId})}async function isRunActive(e){try{let t=await getRun(e).status;return t===`pending`||t===`running`}catch(e){if(isInactiveCommandTarget(e))return!1;throw e}}function isInactiveCommandTarget(e){if(e instanceof AcceptedSessionIdentityError)return!1;if(HookNotFoundError.is(e))return!0;for(let t of walkCauseChain(e))if(WorkflowRunNotFoundError.is(t)||RunExpiredError.is(t)||EntityConflictError.is(t))return!0;return!1}async function waitForCommandHookOwner(e){let t=Date.now()+SESSION_HOOK_HANDOVER_TIMEOUT_MS;for(;;)try{return normalizeWorkflowHook(await getHookByToken(e))}catch(e){if(!HookNotFoundError.is(e)||Date.now()>=t)throw e;await new Promise(e=>setTimeout(e,20))}}async function startWorkflowOnCurrentDeployment(e,t,n){return await startWorkflowOnDeployment(e,t,await resolveCurrentWorkflowDeploymentId(),n)}async function startWorkflowOnDeployment(e,t,n,r){return await withWorkflowStartContext(async()=>{if(n.length===0||n===`latest`)throw Error(`Workflow starts require an exact deployment id.`);return await start(e,t,{...r,allowReservedAttributes:!0,attributes:{...r?.attributes,[EVE_VERSION_ATTRIBUTE]:EVE_PACKAGE_INFO.version},deploymentId:n})})}async function resolveCurrentWorkflowDeploymentId(){let e=process.env.VERCEL_DEPLOYMENT_ID?.trim()||await(await getWorld()).getDeploymentId();if(e.length===0||e===`latest`)throw Error(`Workflow runtime could not resolve an exact deployment id.`);return e}async function withWorkflowStartContext(e){let t=context.active(),n=isAgentTraceContext(t)?trace.deleteSpan(t):t;return await context.with(n,e)}function normalizeWorkflowHook(e){if(typeof e!=`object`||!e||!(`runId`in e))throw Error(`Workflow hook did not include a run id.`);let t=e.runId;if(typeof t!=`string`||t.length===0)throw Error(`Workflow hook did not include a run id.`);return{runId:t}}export{createWorkflowRuntime,dispatchWorkflowSessionCommand,requestWorkflowTurnCancellation,sessionTimeoutWorkflowReference,startSessionOwnerStep,startWorkflowOnCurrentDeployment,waitForCommandHookOwner,workflowEntryReference,workflowToolRunWorkflowReference};

package/dist/src/extensions/code/extension/extension.d.ts

@@ -1,28 +1,14 @@
 import type { SandboxSession } from "eve/sandbox";
 import { z } from "zod";
+import type { GitHubConfig } from "eve/extensions/git/sandbox";
 export type CredentialPolicyBroker = (sandbox: SandboxSession, rules: Record<string, Record<string, string>>) => Promise<void>;
-export interface GitHubLeaseRule {
-    readonly match?: {
-        readonly headers?: readonly {
-            readonly key?: {
-                readonly exact: string;
-            };
-            readonly value?: {
-                readonly exact?: string;
-                readonly regex?: string;
-            };
-        }[];
-    };
-    readonly transform: readonly {
-        readonly headers: Readonly<Record<string, string>>;
-    }[];
-}
-export type GitHubLeaseBroker = (sandbox: SandboxSession, rules: Readonly<Record<string, readonly GitHubLeaseRule[]>> | null) => Promise<void>;
+export type { GitHubLeaseRule } from "eve/extensions/git/sandbox";
+export type GitHubLeaseBroker = GitHubConfig["broker"];
 declare const _default: import("eve/extension").ExtensionHandle<z.ZodObject<{
     github: z.ZodOptional<z.ZodObject<{
         connector: z.ZodString;
         org: z.ZodString;
-        broker: z.ZodCustom<GitHubLeaseBroker, GitHubLeaseBroker>;
+        broker: z.ZodCustom<(sandbox: SandboxSession, rules: Readonly<Record<string, readonly import("eve/extensions/git/sandbox").GitHubLeaseRule[]>> | null) => Promise<void>, (sandbox: SandboxSession, rules: Readonly<Record<string, readonly import("eve/extensions/git/sandbox").GitHubLeaseRule[]>> | null) => Promise<void>>;
     }, z.core.$strip>>;
     vercel: z.ZodOptional<z.ZodObject<{
         connector: z.ZodString;

package/dist/src/extensions/code/extension/instructions/github.d.ts

@@ -0,0 +1,3 @@
+/** @deprecated Mount `eve/extensions/git` with `github` config. */
+declare const _default: import("eve/instructions").DynamicSentinel<import("eve/instructions").DynamicInstructionsResult>;
+export default _default;

package/dist/src/extensions/code/extension/instructions/github.js

@@ -0,0 +1 @@
+import{deprecatedGitHubConfigured}from"../lib/github-compat.js";import{githubInstructions}from"eve/extensions/git/sandbox";import{defineDynamic,defineInstructions}from"eve/instructions";var github_default=defineDynamic({events:{"session.started":()=>deprecatedGitHubConfigured()?defineInstructions({content:githubInstructions(!0)}):null}});export{github_default as default};