eve 0.72.1 → 0.74.0

package/CHANGELOG.md

@@ -1,5 +1,49 @@
 # eve
 
+## 0.74.0
+
+### Minor Changes
+
+- bc101b5: Add experimental `defineDynamicSchedules` with direct operation tools, optional `preparePayload` creation preparation, top-level per-operation approval, and creator-bound execution. Create approval receives prepared data and rejects changed results before writing; `ctx.session.schedule` exposes scheduled-turn provenance without auth attributes.
+
+### Patch Changes
+
+- 51648e3: Manual compaction now resolves step-scoped dynamic models before summarizing a session.
+- 880dd8b: Record offered tool definitions on GenAI chat spans and expose them to lifecycle handlers when input capture is enabled.
+- f528669: Settle tool calls when a model call is retried and remove unresolved tool parts when a turn ends.
+- 8751775: The experimental Vercel schedule provider includes Schedules SDK alpha.11 in the published package without adding a runtime dependency. Provider requests receive the operation's abort signal, and failed disable calls after inactive creation report that the schedule may remain active.
+- b9470fe: `Shift+Enter` now inserts a newline in the `eve dev` prompt in Warp, which sends a bare line feed for it. `Ctrl+J` inserts a newline too, instead of sending the message.
+- 8751775: Schedule subscriptions default to Vercel Schedules in production and process-local storage under `eve dev`, so an explicit `provider` is no longer required. Pass a provider to override the backend, or use `vercelScheduleProvider` from `eve/experimental/schedules/vercel` to customize the Vercel endpoint.
+- 0b5bb5b: Workflow tools in an `agents/<name>/` workspace member now compile with the workflow ID that the deployment registers, so calls no longer fail with "is not registered as a workflow in this deployment". Members can also import workflow and step modules from the shared root package, such as `lib/`, and `eve dev` rebuilds when shared modules imported from outside the agent directory change.
+
+## 0.73.0
+
+### Minor Changes
+
+- 9de88f7: Split self-modification into separate `eve/self-modification/local` and `eve/self-modification/remote` mounts, so `eve dev` no longer loads deployed sandbox dependencies. `eve/self-modification` remains an alias for the local mount and now rejects the `deployed` option; move that configuration to its own mount, for example `agent/extensions/self-modification-remote/extension.ts`, with the former `deployed` fields at the top level.
+
+### Patch Changes
+
+- a549cb6: Enable Workflow stream-writer WebSockets for eve's Vercel world. The upgraded SDK disposes released and aborted writer sessions, and falls back to HTTP when the server declines a WebSocket upgrade.
+- 83b97e6: Chat SDK channels now send a sign-in started in a shared thread to the person signing in, as an ephemeral message or a direct message, and show a link-free status in the thread. Adapters that support neither still post the existing "continue in a direct message" notice.
+- 7c60065: Discord button presses, selects, and modal submissions now answer as the Discord user who made them instead of anonymously, so requester-only and other approval response policies work on Discord. The new `onInputResponse` option on `discordChannel` chooses an answer's auth or drops it, and its context carries the presser's `defaultAuth`. Apps with a custom `onCommand` must also set `onInputResponse`; until they do, eve drops presses and logs a warning.
+- 90972b6: Start the first model call without waiting for session-title metadata persistence, while still completing the title write before the durable turn step finishes.
+- 933996c: `invokeTool` now accepts a `key`: calls from the same caller with the same key share one session id and keep their sandbox between calls, on Vercel Sandbox and just-bash. `mcpChannel({ tools: true })` advertises the `dev.eve/tool-sessions` extension, so MCP clients that declare it can join a tool session with `_meta["dev.eve/tool-session"]`. A forwarded caller's session also covers the verified forwarder, passed as `invokeTool`'s `forwardedBy` (`mcpChannel` passes the router its `auth` verified), so one user reached through two routers gets two sessions. Tool sessions need an authenticated caller: a keyed call from the anonymous principal `none()` gives is denied. On Vercel Sandbox, a tool session's saved filesystem expires a day after its last use, so the next call with the key starts a fresh sandbox; a deploy that changes the agent's sandbox definition also starts a fresh sandbox for each key.
+- 279e2b6: `mcpChannel({ skills: true })` serves the agent's skills as SEP-2640 skills under `skill://`, with each file's size and SHA-256 digest. Files are served byte for byte, except that a `SKILL.md` without conforming `name` and `description` frontmatter is served with generated frontmatter. Channel routes also get `listSkillFiles(skill)`, which lists a skill's files with their sizes, and `readSkill(skill, path?)`, which returns one skill file's bytes; `describe()` lists each skill's name and description.
+  
+  Production builds now ship skill files as eve-owned server assets and drop Nitro's default `server` asset entry, which bundled the app's `assets/` directory. An app that read `assets:server` storage in production finds it empty; eve reads only its own asset bases.
+- 866cb41: Tools published with `mcpChannel({ tools: true })` can now run as the user a trusted caller forwards. Set `trustedForwarders` on the channel to accept the `eve-forwarded-principal` header, and `forwardPrincipal: true` on a `defineMcpClientConnection` to send the turn's user to another eve agent. A channel without `trustedForwarders` refuses requests carrying the header with `403`. `invokeTool` also accepts an `initiator` option.
+- 282802a: Reduce new-session startup latency by overlapping session creation with timeout startup and first-turn cancellation and steering hook registration after inbox ownership is ready.
+- 64301d1: Remote evals now resolve Vercel deployments using the owner and project from the environment or local project link, allowing protected deployments owned by a different team than the CLI's current team. Ambient credentials are withheld when the deployment does not match the expected project.
+- f8bf204: Add the Sanity MCP integration to the registry. Use `eve add connection/sanity` to connect an existing Sanity account through Vercel Connect OAuth.
+- 0d6e2e2: `eve add` and `eve registry` now use `@shadcn/registry` instead of the full `shadcn` CLI package. The vendored registry bundle shrinks from 9.7 MB to 3.8 MB, and registry items install the same files, env vars, and dependencies as before.
+- 3c8919a: Slack `onInteraction` actions now include `triggerId`, so a button on a message can open a modal with `views.open`.
+- 17d5b11: When a turn waits on several questions or approvals, a typed reply now answers the first open one instead of none, so people can answer them one message at a time. Twilio, GitHub, Linear, and Chat SDK channels (including Linq and Photon) show one prompt at a time and post the next once it is answered. An approval raised alongside a workflow tool call such as `ask_question` is now requested after that call finishes, since it can't take effect before then.
+  
+  On Twilio, GitHub, and Linear, the built-in prompt queue spans the `input.requested`, `input.resolved`, and `approval.settled` handlers. If you override any one of them, override all three, or the built-in handlers will post prompts twice or stop posting later ones. If you render prompts yourself from `input.requested`, make `input.resolved` and `approval.settled` no-ops.
+- 7f559ac: The TUI now prints a connection sign-in URL on its own line and makes every wrapped row an OSC 8 hyperlink to the full URL, so Cmd-clicking the link opens the whole URL in a narrow terminal.
+- 17d5b11: Typing `approve` or `cancel` now answers a tool approval that has an `approval.response` policy. The policy checks the person who typed the reply, just as it checks someone who presses a button. Before, the reply reached the model as an ordinary message and the approval stayed pending.
+
 ## 0.72.1
 
 ### Patch Changes

package/dist/src/_virtual/_rolldown/runtime.js

@@ -1 +1 @@
-import"node:module";export{};
+import"node:module";var __create=Object.create,__defProp=Object.defineProperty,__getOwnPropDesc=Object.getOwnPropertyDescriptor,__getOwnPropNames=Object.getOwnPropertyNames,__getProtoOf=Object.getPrototypeOf,__hasOwnProp=Object.prototype.hasOwnProperty,__commonJSMin=(e,t)=>()=>(t||(e((t={exports:{}}).exports,t),e=null),t.exports),__copyProps=(e,t,n,r)=>{if(t&&typeof t==`object`||typeof t==`function`)for(var i=__getOwnPropNames(t),a=0,o=i.length,s;a<o;a++)s=i[a],!__hasOwnProp.call(e,s)&&s!==n&&__defProp(e,s,{get:(e=>t[e]).bind(null,s),enumerable:!(r=__getOwnPropDesc(t,s))||r.enumerable});return e},__toESM=(e,t,n)=>(n=e==null?{}:__create(__getProtoOf(e)),__copyProps(t||!e||!e.__esModule||!__hasOwnProp.call(e,`default`)?__defProp(n,`default`,{value:e,enumerable:!0}):n,e));export{__commonJSMin,__toESM};

package/dist/src/channel/agent-description.d.ts

@@ -1,5 +1,6 @@
 import type { CompiledAgentManifest } from "#compiler/manifest.js";
-import type { RuntimeCompiledArtifactsSource } from "#runtime/compiled-artifacts-source.js";
+import { type SkillFileSource } from "#channel/skill-files.js";
+import { type RuntimeCompiledArtifactsSource } from "#runtime/compiled-artifacts-source.js";
 import type { JsonObject } from "#shared/json.js";
 /** One compiled tool a caller can invoke outside a turn. */
 export interface AgentToolDescription {
@@ -10,24 +11,63 @@ export interface AgentToolDescription {
     /** The tool declares an approval policy. */
     readonly approval: boolean;
 }
+/** One file of a skill, as `listSkillFiles` returns it. `readSkill` rejects files over 512 KiB. */
+export interface AgentSkillFileDescription {
+    /** `/`-separated path under the skill root, e.g. `references/api.md`. */
+    readonly path: string;
+    /** Size in bytes. */
+    readonly size: number;
+}
+/** One compiled skill. `listSkillFiles` enumerates its files. */
+export interface AgentSkillDescription {
+    readonly name: string;
+    readonly description: string;
+}
 /**
- * The caller-facing view of an agent: its name, description, and the compiled
- * tools `invokeTool` can run, sorted by name. Unlike `GET /eve/v1/info`, it
- * carries no paths, config, diagnostics, or other inspection detail, so
- * channels can publish it as is. Tools added by dynamic resolvers and
- * subagents are not listed.
+ * The caller-facing view of an agent: its name, description, the compiled
+ * tools `invokeTool` can run, and its compiled skills, each sorted by name.
+ * Unlike `GET /eve/v1/info`, it carries no paths, config, diagnostics, or
+ * other inspection detail, so channels can publish it as is. Tools and
+ * skills added by dynamic resolvers and subagents are not listed.
  */
 export interface AgentDescription {
     readonly name: string;
     readonly description?: string;
     readonly tools: readonly AgentToolDescription[];
+    readonly skills: readonly AgentSkillDescription[];
+}
+/** The `describe`, `listSkillFiles`, and `readSkill` route handler args. */
+export interface AgentDescriptionRouteArgs {
+    describe(): Promise<AgentDescription>;
+    listSkillFiles(skill: string): Promise<readonly AgentSkillFileDescription[]>;
+    readSkill(skill: string, path?: string): Promise<Uint8Array>;
 }
 /**
- * The `describe` route handler arg for one compiled agent. The artifacts
- * source resolves on first use, so routes that never call it pay nothing.
+ * One compiled agent as its routes see it: the description projected from
+ * its manifest, and the source of its skill files. Loading it reads the
+ * manifest only; no skill file is touched until one is listed or read.
+ */
+export interface DescribedAgent {
+    readonly description: AgentDescription;
+    readonly files: SkillFileSource;
+}
+/**
+ * Loads the agent of a compiled artifacts source once per artifact version
+ * on the active runtime session, as `getCompiledRuntimeAgentBundle` does for
+ * the execution graph, without resolving that graph. A production build
+ * loads once per process; `eve dev` reloads after each recompile. A failed
+ * load is retried on the next call rather than cached.
+ */
+export declare function loadDescribedAgent(compiledArtifactsSource: RuntimeCompiledArtifactsSource): Promise<DescribedAgent>;
+/**
+ * The agent route handler args for one compiled artifacts source, which
+ * resolves on first use so routes that never call them pay nothing. Also
+ * returns the agent's skill files, so a channel that already holds listed
+ * paths reads them without the listing `readSkill` repeats per call.
  */
 export declare function createAgentDescriptionRouteArgs(resolveCompiledArtifactsSource: () => RuntimeCompiledArtifactsSource): {
-    describe(): Promise<AgentDescription>;
+    readonly args: AgentDescriptionRouteArgs;
+    readonly skillFiles: SkillFileSource;
 };
 /** Projects the root node of a compiled manifest onto {@link AgentDescription}. */
 export declare function describeCompiledAgent(manifest: CompiledAgentManifest): AgentDescription;

package/dist/src/channel/agent-description.js

@@ -1 +1 @@
-import{isInvocableCompiledTool}from"#channel/tool-eligibility.js";import{loadCompiledManifest}from"#runtime/loaders/manifest.js";function createAgentDescriptionRouteArgs(e){return{async describe(){let t=e();return describeCompiledAgent(await loadCompiledManifest({compiledArtifactsSource:t}))}}}function describeCompiledAgent(e){let t=e.tools.filter(t=>isInvocableCompiledTool(e,t)).sort((e,t)=>e.name<t.name?-1:+(e.name>t.name)).map(describeTool),n={name:e.config.name,tools:t};return e.config.description!==void 0&&(n.description=e.config.description),n}function describeTool(e){let t={name:e.name,description:e.description,inputSchema:e.inputSchema??{},approval:e.requiresApproval};return e.outputSchema!==void 0&&(t.outputSchema=e.outputSchema),t}export{createAgentDescriptionRouteArgs,describeCompiledAgent};
+import{SkillReadError,comparePaths,createCompiledSkillFileSource,readSkillFile}from"#channel/skill-files.js";import{isInvocableCompiledTool}from"#channel/tool-eligibility.js";import{resolveRuntimeCompiledArtifactsVersionedCacheKey}from"#runtime/cache-key.js";import{getRuntimeCompiledArtifactsCacheKey}from"#runtime/compiled-artifacts-source.js";import{loadCompiledManifest}from"#runtime/loaders/manifest.js";import{getActiveRuntimeSession}from"#runtime/sessions/runtime-session.js";async function loadDescribedAgent(e){let t=getActiveRuntimeSession(),n=getRuntimeCompiledArtifactsCacheKey(e),r=await resolveRuntimeCompiledArtifactsVersionedCacheKey(e),i=t.describedAgents.get(n);if(i?.version===r)return await i.agent;let a=loadCompiledManifest({compiledArtifactsSource:e}).then(t=>({description:describeCompiledAgent(t),files:createCompiledSkillFileSource({compiledArtifactsSource:e,workspaceResourceRoot:t.workspaceResourceRoot})}));return a.catch(()=>{t.describedAgents.get(n)?.agent===a&&t.describedAgents.delete(n)}),t.describedAgents.set(n,{agent:a,version:r}),await a}function createAgentDescriptionRouteArgs(e){let load=()=>loadDescribedAgent(e()),t={listFiles:async e=>await(await load()).files.listFiles(e),listDirectories:async e=>await(await load()).files.listDirectories(e),readFile:async(e,t)=>await(await load()).files.readFile(e,t)},assertSkill=async e=>{let{description:t}=await load();if(!t.skills.some(t=>t.name===e))throw new SkillReadError(`unknown-skill`,`Unknown skill "${e}".`)};return{args:{describe:async()=>(await load()).description,async listSkillFiles(e){return await assertSkill(e),await t.listFiles(e)},async readSkill(e,n){return await assertSkill(e),await readSkillFile({path:n,skill:e,source:t})}},skillFiles:t}}function describeCompiledAgent(e){let t=e.tools.filter(t=>isInvocableCompiledTool(e,t)).sort((e,t)=>comparePaths(e.name,t.name)).map(describeTool),n=[...e.skills].sort((e,t)=>comparePaths(e.name,t.name)).map(({name:e,description:t})=>({name:e,description:t})),r={name:e.config.name,tools:t,skills:n};return e.config.description!==void 0&&(r.description=e.config.description),r}function describeTool(e){let t={name:e.name,description:e.description,inputSchema:e.inputSchema??{},approval:e.requiresApproval};return e.outputSchema!==void 0&&(t.outputSchema=e.outputSchema),t}export{createAgentDescriptionRouteArgs,describeCompiledAgent,loadDescribedAgent};

package/dist/src/channel/invoke-tool.d.ts

@@ -1,9 +1,29 @@
 import type { SessionAuthContext } from "#channel/types.js";
 import type { ToolModelOutput } from "#tools/model-output.js";
+/** Longest {@link InvokeToolOptions.key} `invokeTool` accepts. */
+export declare const TOOL_SESSION_KEY_MAX_LENGTH = 512;
 /** Options for one {@link InvokeToolFn} call. */
 export interface InvokeToolOptions {
     /** The caller this request authenticated. Becomes `ctx.session.auth.current`. */
     readonly auth: SessionAuthContext;
+    /** Becomes `ctx.session.auth.initiator`. Defaults to `auth`. */
+    readonly initiator?: SessionAuthContext;
+    /**
+     * The verified caller that forwarded `auth`, when a trusted forwarder
+     * asserted it. A keyed session's identity includes it, so one user reached
+     * through two forwarders gets two sessions. Pass the principal the route
+     * authenticated, never one read from the request.
+     */
+    readonly forwardedBy?: SessionAuthContext;
+    /**
+     * Names a tool session the call joins: 1 to 512 characters, chosen by the
+     * caller. Calls from the same `auth` principal with the same key share one
+     * session id and one sandbox, which outlives the call. A different
+     * principal using the same key gets a different session. Without a key,
+     * the call runs in a one-off session. An anonymous `auth` (from `none()`)
+     * cannot send a key: the call is denied before anything runs.
+     */
+    readonly key?: string;
     readonly signal?: AbortSignal;
 }
 /** Outcome of one {@link InvokeToolFn} call. */
@@ -33,9 +53,11 @@ export type InvokeToolResult = {
 };
 /**
  * Runs one of the agent's tools outside a conversation. No model, turn, or
- * workflow step is involved, and the call never parks. Each call gets its own
- * session: `ctx.session.auth.current` is the caller, authored state starts from
- * its initial value and is not kept, and a sandbox the tool opens is deleted
- * when the call ends.
+ * workflow step is involved, and the call never parks. `ctx.session.auth.current`
+ * is the caller, and authored state starts from its initial value and is not
+ * kept, with or without a key. Without `key`, each call gets its own session,
+ * and a sandbox the tool opens is deleted when the call ends. With `key`, the
+ * session id is stable for that caller and key, and its sandbox is kept for
+ * the next call with the same key.
  */
 export type InvokeToolFn = (name: string, input: unknown, options: InvokeToolOptions) => Promise<InvokeToolResult>;

package/dist/src/channel/invoke-tool.js

@@ -1 +1 @@
-export{};
+const TOOL_SESSION_KEY_MAX_LENGTH=512;export{TOOL_SESSION_KEY_MAX_LENGTH};

package/dist/src/channel/principal-identity.d.ts

@@ -0,0 +1,9 @@
+import type { SessionAuthContext } from "#channel/types.js";
+/**
+ * The fields that identify a principal, in a fixed order, for hashing into
+ * invocation owner keys and tool session ids. Attributes describe a principal;
+ * they do not identify it. Adding a field changes every derived hash.
+ */
+export declare function principalIdentity(auth: SessionAuthContext): readonly string[];
+/** Whether `auth` is the shared principal `none()` gives every unauthenticated caller. */
+export declare function isAnonymousPrincipal(auth: SessionAuthContext): boolean;

package/dist/src/channel/principal-identity.js

@@ -0,0 +1 @@
+function principalIdentity(e){return[e.authenticator,e.issuer??``,e.principalType,e.principalId,e.subject??``]}function isAnonymousPrincipal(e){return e.principalType===`anonymous`}export{isAnonymousPrincipal,principalIdentity};

package/dist/src/channel/prompt-queue.d.ts

@@ -0,0 +1,31 @@
+import type { UnstampedMessageStreamEvent } from "#protocol/message.js";
+import type { InputRequest } from "#shared/input.js";
+/**
+ * Channel state for showing a session's open requests one at a time. A typed
+ * reply answers the first open request, so a channel that can only show text
+ * shows that one and holds the rest until it is answered.
+ */
+export interface PromptQueueState {
+    /** The request the channel last showed, which a typed reply answers. */
+    shownPromptId?: string;
+}
+/**
+ * Event handlers that call `show` with the request a typed reply answers now,
+ * each time that request changes. They read which requests are open from the
+ * session's own record of the events it published, so a request that closed
+ * never shows, and one the channel failed to show is tried again on the next
+ * event. `show` returns `false` when it could not show the request.
+ */
+export declare function promptQueueEvents<TChannel extends {
+    state: PromptQueueState;
+}>(show: (channel: TChannel, request: InputRequest) => Promise<boolean | void>): {
+    "input.requested"(data: Extract<UnstampedMessageStreamEvent, {
+        type: "input.requested";
+    }>["data"], channel: TChannel): Promise<void>;
+    "input.resolved"(data: Extract<UnstampedMessageStreamEvent, {
+        type: "input.resolved";
+    }>["data"], channel: TChannel): Promise<void>;
+    "approval.settled"(data: Extract<UnstampedMessageStreamEvent, {
+        type: "approval.settled";
+    }>["data"], channel: TChannel): Promise<void>;
+};

package/dist/src/channel/prompt-queue.js

@@ -0,0 +1 @@
+import{foldSession}from"#protocol/session-projection.js";import{contextStorage}from"#context/container.js";import{firstOpenInput}from"#harness/open-input-request.js";import{currentProjection}from"#harness/session-machine/current.js";function promptQueueEvents(e){async function refresh(t,n){let r=firstOpenInput(foldSession(publishedProjection(t),n))?.request;if(r===void 0){delete t.state.shownPromptId;return}r.requestId!==t.state.shownPromptId&&await e(t,r)!==!1&&(t.state.shownPromptId=r.requestId)}return{async"input.requested"(e,t){await refresh(t,{data:e,type:`input.requested`})},async"input.resolved"(e,t){await refresh(t,{data:e,type:`input.resolved`})},async"approval.settled"(e,t){await refresh(t,{data:e,type:`approval.settled`})}}}function publishedProjection(e){let t=e.ctx??contextStorage.getStore();return currentProjection(t)}export{promptQueueEvents};

package/dist/src/channel/routes.d.ts

@@ -6,7 +6,7 @@ import type { InputResponse } from "#shared/input.js";
 import type { Session } from "#channel/session.js";
 import type { JsonObject } from "#shared/json.js";
 import type { ChannelMethod } from "#public/definitions/channel.js";
-import type { AgentDescription } from "#channel/agent-description.js";
+import type { AgentDescription, AgentSkillFileDescription } from "#channel/agent-description.js";
 type WebSocketHeaders = Headers | readonly (readonly [string, string])[] | Record<string, string>;
 /**
  * Second argument passed to every route handler. `from` binds local operations,
@@ -32,11 +32,26 @@ export interface RouteHandlerArgs<TState = undefined> {
     /** Best-effort client IP reported by the host, or `null` when unavailable. */
     requestIp: string | null;
     /**
-     * Describes the agent for callers: its name, description, and the compiled
-     * tools that can run outside a turn, sorted by name. Carries none of the
-     * inspection detail of `GET /eve/v1/info`.
+     * Describes the agent for callers: its name, description, the compiled
+     * tools that can run outside a turn, and the name and description of each
+     * compiled skill, sorted by name. Reads the compiled manifest only, no
+     * skill file, and carries none of the inspection detail of `GET /eve/v1/info`.
      */
     describe(): Promise<AgentDescription>;
+    /**
+     * Lists the regular files of one compiled skill, each with its path under
+     * the skill root and its size in bytes, sorted by path. Rejects a skill
+     * the agent does not have.
+     */
+    listSkillFiles(skill: string): Promise<readonly AgentSkillFileDescription[]>;
+    /**
+     * Reads one file of a compiled skill as raw bytes. `path` is relative to
+     * the skill root and defaults to its `SKILL.md`. Rejects paths that are
+     * absolute or contain `.`, `..`, or empty segments, files the skill does
+     * not list, and files over 512 KiB. Production builds ship skill files as
+     * server assets, so they count toward the deployed function's size.
+     */
+    readSkill(skill: string, path?: string): Promise<Uint8Array>;
     /** Runs one of the agent's tools as `auth`, outside any conversation. */
     readonly invokeTool: InvokeToolFn;
 }

package/dist/src/channel/schedule.d.ts

@@ -2,6 +2,8 @@ import type { ChannelAdapter } from "#channel/adapter.js";
 import { type Session } from "#channel/session.js";
 import type { Runtime } from "#channel/types.js";
 import type { ScheduleRunHandler } from "#public/definitions/schedule.js";
+import type { DynamicSchedulesDefinition, ScheduleOccurrenceIdentity } from "#public/schedules/subscription.js";
+import { type ScheduleCollectionPayload } from "#runtime/schedules/payload.js";
 import type { ResolvedChannelDefinition } from "#runtime/types.js";
 export { SCHEDULE_APP_AUTH } from "#channel/schedule-auth.js";
 /**
@@ -18,11 +20,23 @@ export declare const SCHEDULE_ADAPTER: ChannelAdapter;
  * Loaded shape of one schedule for the dispatcher. Either `run` is
  * defined (authored handler) or `markdown` is defined (fire-and-forget).
  */
-interface ScheduleDispatchInput {
+export interface ScheduleDispatchInput {
     readonly scheduleId: string;
     readonly run?: ScheduleRunHandler;
     readonly markdown?: string;
 }
+/** Sessions started by dispatch and background work registered by the handler. */
+export interface ScheduleDispatchResult {
+    readonly sessions: readonly Session[];
+    readonly waitUntilTasks: readonly Promise<unknown>[];
+}
+export interface ScheduleCollectionDispatchInput {
+    readonly collectionId: string;
+    readonly definition: DynamicSchedulesDefinition<any, any, any>;
+    readonly payload: ScheduleCollectionPayload<unknown>;
+    readonly occurrence: ScheduleOccurrenceIdentity;
+    readonly verifyDelivery?: () => Promise<void>;
+}
 /**
  * Dispatches scheduled task execution.
  *
@@ -38,12 +52,10 @@ interface ScheduleDispatchInput {
  *
  * Returns a {@link ScheduleDispatchResult} carrying any sessions the
  * handler started (for telemetry / task-result observability) and the
- * `waitUntil` promises the handler registered.
+ * `waitUntil` promises the handler registered. Subscription callbacks resolve
+ * creator auth and await their registered work before returning; their channel
+ * sends start fresh, unattended sessions rather than resume a conversation.
  */
-interface ScheduleDispatchResult {
-    readonly sessions: readonly Session[];
-    readonly waitUntilTasks: readonly Promise<unknown>[];
-}
 export declare class ScheduleDispatcher {
     private readonly runtime;
     private readonly channels;
@@ -52,7 +64,9 @@ export declare class ScheduleDispatcher {
         readonly channels: readonly ResolvedChannelDefinition[];
     });
     trigger(input: ScheduleDispatchInput): Promise<ScheduleDispatchResult>;
+    triggerCollection(input: ScheduleCollectionDispatchInput): Promise<ScheduleDispatchResult>;
     private triggerInScope;
+    private createHandlerContext;
     private runMarkdown;
 }
 /**

package/dist/src/channel/schedule.js

@@ -1 +1 @@
-import{createSession}from"#channel/session.js";import{SCHEDULE_APP_AUTH,SCHEDULE_APP_AUTH as SCHEDULE_APP_AUTH$1}from"#channel/schedule-auth.js";import{createCrossChannelToFn,toCrossChannelTargets}from"#channel/cross-channel-receive.js";import{ContextContainer,contextStorage}from"#context/container.js";import{ScheduleIdKey}from"#context/keys.js";import{expectFunction}from"#internal/authored-module.js";const SCHEDULE_ADAPTER_KIND=`schedule`,SCHEDULE_ADAPTER={kind:SCHEDULE_ADAPTER_KIND};var ScheduleDispatcher=class{runtime;channels;constructor(e){this.runtime=e.runtime,this.channels=e.channels}async trigger(e){let t=new ContextContainer;return t.set(ScheduleIdKey,e.scheduleId),await contextStorage.run(t,()=>this.triggerInScope(e))}async triggerInScope(e){let t=[],n=[],r=createCrossChannelToFn(this.runtime,toCrossChannelTargets(this.channels)),i={appAuth:SCHEDULE_APP_AUTH$1,to(e,n){let i=r(e,n);return{async send(e,n){let r=await i.send(e,n);return t.push(r),r}}},waitUntil(e){n.push(e)}};if(e.run)await e.run(i);else if(e.markdown!==void 0){let n=await this.runMarkdown(e.markdown);t.push(n)}else throw Error(`Schedule "${e.scheduleId}" has neither "run" nor "markdown" — at least one must be set.`);return{sessions:t,waitUntilTasks:n}}async runMarkdown(e){let t=await this.runtime.createSession({adapter:SCHEDULE_ADAPTER,auth:SCHEDULE_APP_AUTH$1,input:{message:e}});return createSession(t.sessionId,this.runtime)}};function expectScheduleRun(e,t,n){let r=e;if(typeof r!=`object`||!r)throw Error(`Schedule export "${n??`default`}" from "${t}" must be an object.`);return expectFunction(r.run,`Expected the schedule export "${n??`default`}" from "${t}" to export a \`run\` handler function.`)}export{SCHEDULE_ADAPTER,SCHEDULE_ADAPTER_KIND,SCHEDULE_APP_AUTH,ScheduleDispatcher,expectScheduleRun};
+import{randomUUID}from"node:crypto";import{createSession}from"#channel/session.js";import{ContextContainer,contextStorage}from"#context/container.js";import{scheduleDisplayName}from"#runtime/schedules/record.js";import{SCHEDULE_APP_AUTH,SCHEDULE_APP_AUTH as SCHEDULE_APP_AUTH$1}from"#channel/schedule-auth.js";import{createCrossChannelToFn,toCrossChannelTargets}from"#channel/cross-channel-receive.js";import{AuthKey,OccurrenceIdKey,ScheduleIdKey,ScheduleInstanceKey}from"#context/keys.js";import{expectFunction}from"#internal/authored-module.js";import{parseSchedulePayload,validateSchedulePayload}from"#runtime/schedules/payload.js";const SCHEDULE_ADAPTER_KIND=`schedule`,SCHEDULE_ADAPTER={kind:SCHEDULE_ADAPTER_KIND};var ScheduleDispatcher=class{runtime;channels;constructor(e){this.runtime=e.runtime,this.channels=e.channels}async trigger(e){let t=new ContextContainer;return t.set(ScheduleIdKey,e.scheduleId),await contextStorage.run(t,()=>this.triggerInScope(e))}async triggerCollection(e){let{envelope:t}=parseSchedulePayload(e.payload,{application:e.payload.eve.application,collection:e.collectionId}),{definition:n}=e,r={...e.occurrence,displayName:scheduleDisplayName(e.occurrence.name)},i=n.preparePayload===void 0?await validateSchedulePayload(n.inputSchema,t.payload):t.payload;await e.verifyDelivery?.();let a=await n.auth({principal:t.principal,payload:i,occurrence:r});if(a===null)throw Error(`Scheduled execution is no longer authorized.`);if(a.principalId!==t.principal.principalId||a.principalType!==t.principal.type||a.authenticator!==t.principal.authenticator||a.issuer!==t.principal.issuer||a.subject!==t.principal.subject)throw Error(`Scheduled execution auth must resolve the schedule creator.`);let o=a,s=new ContextContainer;return s.set(ScheduleIdKey,e.collectionId),s.set(AuthKey,o),s.set(OccurrenceIdKey,r.executionId),s.set(ScheduleInstanceKey,r.name),await contextStorage.run(s,async()=>{let e={...this.runtime,resolveContinuation:async()=>void 0,dispatchContinuation:async e=>{if(e.command.kind!==`send`)throw Error(`Scheduled channel receive can only start a fresh session.`);return{status:`session_not_active`}},createSession:async e=>await this.runtime.createSession({...e,auth:o,initiatorAuth:o,capabilities:{requestInput:!1},continuationToken:`eve-scheduled-send:${randomUUID()}`,continuationConflictCommand:void 0})},{args:t,sessions:a,waitUntilTasks:s}=this.createHandlerContext(e);return await n.run({payload:i,occurrence:r,auth:o,to:(e,n)=>({send:r=>t.to(e,n).send(r,{auth:o})}),waitUntil:t.waitUntil}),await Promise.all(s),{sessions:a,waitUntilTasks:s}})}async triggerInScope(e){let{args:t,sessions:n,waitUntilTasks:r}=this.createHandlerContext();if(e.run)await e.run(t);else if(e.markdown!==void 0)n.push(await this.runMarkdown(e.markdown));else throw Error(`Schedule "${e.scheduleId}" has neither "run" nor "markdown" — at least one must be set.`);return{sessions:n,waitUntilTasks:r}}createHandlerContext(e=this.runtime){let t=[],n=[],r=createCrossChannelToFn(e,toCrossChannelTargets(this.channels));return{args:{appAuth:SCHEDULE_APP_AUTH$1,to(e,n){let i=r(e,n);return{async send(e,n){let r=await i.send(e,n);return t.push(r),r}}},waitUntil(e){n.push(e)}},sessions:t,waitUntilTasks:n}}async runMarkdown(e){let t=await this.runtime.createSession({adapter:SCHEDULE_ADAPTER,auth:SCHEDULE_APP_AUTH$1,input:{message:e}});return createSession(t.sessionId,this.runtime)}};function expectScheduleRun(e,t,n){let r=e;if(typeof r!=`object`||!r)throw Error(`Schedule export "${n??`default`}" from "${t}" must be an object.`);return expectFunction(r.run,`Expected the schedule export "${n??`default`}" from "${t}" to export a \`run\` handler function.`)}export{SCHEDULE_ADAPTER,SCHEDULE_ADAPTER_KIND,SCHEDULE_APP_AUTH,ScheduleDispatcher,expectScheduleRun};

package/dist/src/channel/skill-files.d.ts

@@ -0,0 +1,114 @@
+import type { CompiledWorkspaceResourceRoot } from "#compiler/manifest.js";
+import type { RuntimeCompiledArtifactsSource } from "#runtime/compiled-artifacts-source.js";
+/** Largest skill file `readSkill` returns. */
+export declare const MAX_SKILL_FILE_BYTES: number;
+/** Canonical file name of a skill package's entry markdown. */
+export declare const SKILL_ENTRY_FILE_NAME = "SKILL.md";
+/**
+ * Whether a file name is a skill's entry markdown. Discovery accepts any case
+ * variant, such as `skill.md`, and materialization keeps the authored name.
+ */
+export declare function isSkillEntryFileName(name: string): boolean;
+export type SkillReadErrorCode = "invalid-path" | "too-large" | "unavailable" | "unknown-file" | "unknown-skill";
+/** Thrown by `readSkill`. `code` lets a channel map the failure onto its own protocol. */
+export declare class SkillReadError extends Error {
+    readonly code: SkillReadErrorCode;
+    constructor(code: SkillReadErrorCode, message: string);
+}
+/** One regular file of a skill: its `/`-separated path under the skill root and its size. */
+export interface SkillFileEntry {
+    readonly path: string;
+    readonly size: number;
+}
+/**
+ * Lookup into the compiled skill files of one agent. Paths are `/`-separated
+ * and relative to the skill root, e.g. `SKILL.md` or `references/api.md`.
+ */
+export interface SkillFileSource {
+    /** Regular files of one skill, sorted by path. Empty when the skill has no materialized files. */
+    listFiles(skill: string): Promise<readonly SkillFileEntry[]>;
+    /**
+     * Every directory of one skill below its root, sorted by path, including
+     * empty ones that no listed file implies.
+     */
+    listDirectories(skill: string): Promise<readonly string[]>;
+    readFile(skill: string, path: string): Promise<Uint8Array>;
+}
+/** Nitro `serverAssets` base that holds the root agent's shipped skill files. */
+export declare const SKILL_FILES_SERVER_ASSET_BASE = "eve-skills";
+/** Nitro `serverAssets` base that holds {@link SKILL_FILES_INDEX_KEY}. */
+export declare const SKILL_FILES_INDEX_SERVER_ASSET_BASE = "eve-skill-index";
+/** Key of the skill file index inside {@link SKILL_FILES_INDEX_SERVER_ASSET_BASE}. */
+export declare const SKILL_FILES_INDEX_KEY = "skills.json";
+/**
+ * One indexed file: `[path, size, sha256]`. `sha256` is `null` for files over
+ * {@link MAX_SKILL_FILE_BYTES}, which are listed but not shipped. A shipped
+ * file's storage key is {@link skillFileStorageKey} of its digest.
+ */
+export type SkillFilesIndexEntry = readonly [path: string, size: number, sha256: string | null];
+/**
+ * Index of the skill files a production build ships, written by `eve build`.
+ * eve owns the listing rather than deriving it from storage keys, so real
+ * paths never pass through unstorage key normalization. Entries are arrays,
+ * not object keys, so names such as `__proto__` stay plain data.
+ */
+export interface SkillFilesIndex {
+    readonly version: 1;
+    /** `[skill, files, directories]`, sorted by skill then path. */
+    readonly skills: readonly (readonly [
+        skill: string,
+        files: readonly SkillFilesIndexEntry[],
+        directories: readonly string[]
+    ])[];
+}
+/**
+ * Storage key of a shipped skill file: its SHA-256 with a `.bin` name. `.bin`
+ * makes Nitro inline the file as a `Uint8Array` whatever its real extension,
+ * and a hex name is left unchanged by unstorage key normalization.
+ */
+export declare function skillFileStorageKey(sha256: string): string;
+/** The subset of an unstorage `Storage` the server asset source reads with. */
+export interface SkillFileStorage {
+    getItemRaw(key: string): Promise<unknown>;
+}
+/** Opens a Nitro server asset storage, e.g. `useStorage("assets:eve-skills")`. */
+export type OpenSkillFileStorage = (base: string) => Promise<SkillFileStorage>;
+/**
+ * Selects the skill file source for the active compiled artifacts.
+ *
+ * Skill files are materialized under the node's workspace resource root by
+ * `compiler/workspace-resources.ts`. Disk artifacts (dev) read that tree with
+ * {@link createDiskSkillFileSource}; bundled artifacts (production builds)
+ * read the Nitro server assets `eve build` registers for the root agent.
+ */
+export declare function createCompiledSkillFileSource(input: {
+    readonly compiledArtifactsSource: RuntimeCompiledArtifactsSource;
+    readonly workspaceResourceRoot: CompiledWorkspaceResourceRoot;
+    readonly openStorage?: OpenSkillFileStorage;
+}): SkillFileSource;
+/**
+ * Reads skill files from a materialized `skills/<name>/` tree.
+ *
+ * Only regular files reached through real directories are served: a
+ * symlinked skill root lists nothing, listing skips symlinks, every path
+ * component is checked with `lstat` before opening, the leaf is opened with
+ * `O_NOFOLLOW` where the platform defines it, and the `realpath` of the
+ * target must stay under the `realpath` of the skill root. These checks are
+ * not atomic; the tree is the app's own compile output, so a writer that
+ * could race them can already change what is served.
+ */
+export declare function createDiskSkillFileSource(skillsRoot: string): SkillFileSource;
+/**
+ * Reads one file of one skill, byte for byte, given any caller-supplied path.
+ *
+ * With no `path`, reads the skill's entry markdown under whatever case variant
+ * of `SKILL.md` it was authored with. An explicit top-level `SKILL.md` matches
+ * the entry file case-insensitively too; every other path must match a listed
+ * file exactly. Files over {@link MAX_SKILL_FILE_BYTES} are `too-large`.
+ */
+export declare function readSkillFile(input: {
+    readonly path?: string;
+    readonly skill: string;
+    readonly source: SkillFileSource;
+}): Promise<Uint8Array>;
+export declare function comparePaths(left: string, right: string): number;

package/dist/src/channel/skill-files.js

@@ -0,0 +1 @@
+import{createHash}from"node:crypto";import{lstat,open,readdir,realpath}from"node:fs/promises";import{constants}from"node:fs";import nodePath from"node:path";import{resolveRuntimeCompilerArtifactPaths}from"#runtime/loaders/artifact-paths.js";const MAX_SKILL_FILE_BYTES=524288,SKILL_ENTRY_FILE_NAME=`SKILL.md`;function isSkillEntryFileName(e){return e.toLowerCase()===`skill.md`}var SkillReadError=class extends Error{code;constructor(e,t){super(t),this.name=`SkillReadError`,this.code=e}};const SKILL_FILES_SERVER_ASSET_BASE=`eve-skills`,SKILL_FILES_INDEX_SERVER_ASSET_BASE=`eve-skill-index`,SKILL_FILES_INDEX_KEY=`skills.json`;function skillFileStorageKey(e){return`${e}.bin`}const openNitroStorage=async e=>{let{useStorage:t}=await import(`nitro/storage`);return t(`assets:${e}`)};function createCompiledSkillFileSource(e){if(e.compiledArtifactsSource.kind!==`disk`)return createServerAssetSkillFileSource(e.openStorage??openNitroStorage);let{compileDirectoryPath:t}=resolveRuntimeCompilerArtifactPaths(e.compiledArtifactsSource.appRoot);return createDiskSkillFileSource(`${t}/${e.workspaceResourceRoot.logicalPath}/skills`)}function createServerAssetSkillFileSource(e){let t,loadIndex=()=>(t??=e(SKILL_FILES_INDEX_SERVER_ASSET_BASE).then(e=>e.getItemRaw(SKILL_FILES_INDEX_KEY)).then(parseSkillFilesIndex),t.catch(()=>{t=void 0}),t);return{async listFiles(e){return((await loadIndex()).get(e)?.files??[]).map(([e,t])=>({path:e,size:t}))},async listDirectories(e){return(await loadIndex()).get(e)?.directories??[]},async readFile(t,n){let r=(await loadIndex()).get(t)?.files.find(([e])=>e===n);if(r===void 0)throw unknownFile(t,n);let[,i,a]=r;if(a===null)throw tooLarge(t,n,i);let o=await(await e(SKILL_FILES_SERVER_ASSET_BASE)).getItemRaw(skillFileStorageKey(a));if(!(o instanceof Uint8Array)||o.byteLength!==i||createHash(`sha256`).update(o).digest(`hex`)!==a)throw new SkillReadError(`unavailable`,`Skill "${t}" file "${n}" does not match its build index; this build did not ship it byte for byte.`);return o}}}function parseSkillFilesIndex(e){let t=typeof e==`string`?e:e instanceof Uint8Array?new TextDecoder().decode(e):``,n;try{n=t===``?void 0:JSON.parse(t)}catch{n=void 0}if(!isSkillFilesIndex(n))throw new SkillReadError(`unavailable`,"Skill files are not available: this server was not built by `eve build`, so it carries no skill files.");return new Map(n.skills.map(([e,t,n])=>[e,{directories:n,files:t}]))}function isSkillFilesIndex(e){if(typeof e!=`object`||!e)return!1;let{skills:t,version:n}=e;return n===1&&Array.isArray(t)&&t.every(e=>Array.isArray(e)&&typeof e[0]==`string`&&Array.isArray(e[1])&&e[1].every(e=>Array.isArray(e)&&e.length===3&&typeof e[0]==`string`&&Number.isSafeInteger(e[1])&&(typeof e[2]==`string`||e[2]===null))&&Array.isArray(e[2])&&e[2].every(e=>typeof e==`string`))}function createDiskSkillFileSource(e){return{async listFiles(t){let n=`${e}/${t}`;if(!await isRealDirectory(n))return[];let{files:r}=await walkSkill(n);return r.sort((e,t)=>comparePaths(e.path,t.path))},async listDirectories(t){let n=`${e}/${t}`;if(!await isRealDirectory(n))return[];let{directories:r}=await walkSkill(n);return r.sort(comparePaths)},async readFile(t,n){let r=`${e}/${t}`;if(!await isRealDirectory(r))throw unknownFile(t,n);let i=n.split(`/`),a=r;for(let[e,r]of i.entries()){a=`${a}/${r}`;let o=await lstatOrUndefined(a),s=e===i.length-1;if(o===void 0||(s?!o.isFile():!o.isDirectory()))throw unknownFile(t,n)}let[o,s]=await Promise.all([realpath(r),realpath(a)]),c=nodePath.relative(o,s);if(c===``||nodePath.isAbsolute(c)||c.split(nodePath.sep)[0]===`..`)throw unknownFile(t,n);let l=await open(a,constants.O_RDONLY|(constants.O_NOFOLLOW??0));try{let e=await l.stat();if(!e.isFile())throw unknownFile(t,n);if(e.size>524288)throw tooLarge(t,n,e.size);return new Uint8Array(await l.readFile())}finally{await l.close()}}}}async function lstatOrUndefined(e){try{return await lstat(e)}catch(e){if(e instanceof Error&&`code`in e&&(e.code===`ENOENT`||e.code===`ENOTDIR`))return;throw e}}async function isRealDirectory(e){return(await lstatOrUndefined(e))?.isDirectory()===!0}async function walkSkill(e){let t=[],n=[],walk=async(e,r)=>{for(let i of await readdir(e,{withFileTypes:!0})){let a=r===``?i.name:`${r}/${i.name}`;if(i.isDirectory())n.push(a),await walk(`${e}/${i.name}`,a);else if(i.isFile()){let n=await lstatOrUndefined(`${e}/${i.name}`);n?.isFile()===!0&&t.push({path:a,size:n.size})}}};return await walk(e,``),{directories:n,files:t}}function unknownFile(e,t){return new SkillReadError(`unknown-file`,`Skill "${e}" has no file "${t}".`)}function tooLarge(e,t,n){return new SkillReadError(`too-large`,`Skill "${e}" file "${t}" is ${n} bytes, over the ${MAX_SKILL_FILE_BYTES}-byte limit.`)}async function readSkillFile(e){let t=e.path??`SKILL.md`;assertRelativeSkillPath(t);let n=await e.source.listFiles(e.skill),r=n.find(e=>e.path===t)??(isSkillEntryFileName(t)?n.find(e=>isSkillEntryFileName(e.path)):void 0);if(r===void 0)throw unknownFile(e.skill,t);if(r.size>524288)throw tooLarge(e.skill,r.path,r.size);let i=await e.source.readFile(e.skill,r.path);if(i.byteLength>524288)throw tooLarge(e.skill,r.path,i.byteLength);return i}function assertRelativeSkillPath(e){let invalid=t=>new SkillReadError(`invalid-path`,`Skill file path "${e}" ${t}.`);if(e.length===0)throw invalid(`must not be empty`);if(e.startsWith(`/`)||/^[A-Za-z]:/.test(e))throw invalid(`must be relative to the skill root`);if(e.includes(`\\`)||e.includes(`\0`))throw invalid(`must use "/" separators and contain no NUL bytes`);if(e.split(`/`).some(e=>e===``||e===`.`||e===`..`))throw invalid(`must not contain empty, ".", or ".." segments`)}function comparePaths(e,t){return e<t?-1:+(e>t)}export{MAX_SKILL_FILE_BYTES,SKILL_ENTRY_FILE_NAME,SKILL_FILES_INDEX_KEY,SKILL_FILES_INDEX_SERVER_ASSET_BASE,SKILL_FILES_SERVER_ASSET_BASE,SkillReadError,comparePaths,createCompiledSkillFileSource,createDiskSkillFileSource,isSkillEntryFileName,readSkillFile,skillFileStorageKey};

package/dist/src/channel/types.d.ts

@@ -165,6 +165,7 @@ export type SessionCommand = {
     /** Initial workflow title when delivering to a prewarmed session. */
     readonly title?: string;
     readonly kind: "send";
+    readonly schedule?: import("#context/session-schedule.js").SessionSchedule;
     readonly payload: DeliverPayload;
     readonly delivery?: ChannelDeliveryMetadata;
     readonly requestId?: string;
@@ -220,6 +221,7 @@ export interface DispatchSessionInput<TCommand extends SessionCommand = SessionC
  * metadata so both cross the durable hook boundary outside adapter-owned data.
  */
 export interface DeliverHookPayload {
+    readonly schedule?: import("#context/session-schedule.js").SessionSchedule;
     /** Initial workflow title; ignored once session initialization has run. */
     readonly title?: string;
     readonly auth?: SessionAuthContext | null;
@@ -357,6 +359,8 @@ export interface SessionCapabilities {
  * subagent tool wrapper).
  */
 export interface RunInput {
+    /** Server-supplied provenance inherited by locally delegated scheduled work. */
+    readonly schedule?: import("#context/session-schedule.js").SessionSchedule;
     readonly adapter: ChannelAdapter<any>;
     /**
      * Registered channel name for root sessions started from an authored

package/dist/src/chunks/{use-eve-agent-C1GYGCtb.js → use-eve-agent-DOOXadF0.js}

@@ -3469,6 +3469,10 @@ function reduceContent(data, event) {
 		}
 		case "action.result": {
 			if (conversationProjection(data).calls[event.data.result.callId]?.taskId !== void 0) return data;
+			if (event.data.error?.code === "MODEL_CALL_ATTEMPT_RETRIED") return updateAssistantMessage(data, event.data.turnId, (message) => ({
+				...message,
+				parts: message.parts.filter((part) => part.type !== "dynamic-tool" || part.toolCallId !== event.data.result.callId)
+			}));
 			const existing = findToolPart(data, event.data.result.callId);
 			const descriptor = normalizeActionResult(event.data.result);
 			const succeeded = event.data.status === void 0 || event.data.status === "completed" ? event.data.result.isError !== true && event.data.error === void 0 : false;
@@ -3570,7 +3574,7 @@ function reduceContent(data, event) {
 					...message.metadata,
 					status: "complete"
 				},
-				parts: removeStreamingToolParts(closeStreamingRuns(message.parts))
+				parts: removeUnsettledToolParts(closeStreamingRuns(message.parts), conversationProjection(data))
 			}));
 		default: return data;
 	}
@@ -3605,8 +3609,14 @@ function closeStreamingRuns(parts, stepIndex) {
 		state: "done"
 	} : part);
 }
-function removeStreamingToolParts(parts) {
-	return parts.filter((part) => part.type !== "dynamic-tool" || part.state !== "input-streaming");
+function removeUnsettledToolParts(parts, projection) {
+	return parts.filter((part) => {
+		if (part.type !== "dynamic-tool") return true;
+		if (part.state === "input-streaming") return false;
+		if (part.state !== "input-available") return true;
+		const call = projection.calls[part.toolCallId];
+		return call === void 0 || call.taskId !== void 0 || reportedCallStatus(projection, call) !== "running";
+	});
 }
 function updateAssistantMessage(data, turnId, update) {
 	const message = data.messages.find((message) => message.role === "assistant" && message.metadata?.turnId === turnId) ?? createAssistantMessage(turnId);

package/dist/src/chunks/{use-eve-agent-hZJ7CB8t.js → use-eve-agent-mP0M7SrL.js}

@@ -3470,6 +3470,10 @@ function reduceContent(data, event) {
 		}
 		case "action.result": {
 			if (conversationProjection(data).calls[event.data.result.callId]?.taskId !== void 0) return data;
+			if (event.data.error?.code === "MODEL_CALL_ATTEMPT_RETRIED") return updateAssistantMessage(data, event.data.turnId, (message) => ({
+				...message,
+				parts: message.parts.filter((part) => part.type !== "dynamic-tool" || part.toolCallId !== event.data.result.callId)
+			}));
 			const existing = findToolPart(data, event.data.result.callId);
 			const descriptor = normalizeActionResult(event.data.result);
 			const succeeded = event.data.status === void 0 || event.data.status === "completed" ? event.data.result.isError !== true && event.data.error === void 0 : false;
@@ -3571,7 +3575,7 @@ function reduceContent(data, event) {
 					...message.metadata,
 					status: "complete"
 				},
-				parts: removeStreamingToolParts(closeStreamingRuns(message.parts))
+				parts: removeUnsettledToolParts(closeStreamingRuns(message.parts), conversationProjection(data))
 			}));
 		default: return data;
 	}
@@ -3606,8 +3610,14 @@ function closeStreamingRuns(parts, stepIndex) {
 		state: "done"
 	} : part);
 }
-function removeStreamingToolParts(parts) {
-	return parts.filter((part) => part.type !== "dynamic-tool" || part.state !== "input-streaming");
+function removeUnsettledToolParts(parts, projection) {
+	return parts.filter((part) => {
+		if (part.type !== "dynamic-tool") return true;
+		if (part.state === "input-streaming") return false;
+		if (part.state !== "input-available") return true;
+		const call = projection.calls[part.toolCallId];
+		return call === void 0 || call.taskId !== void 0 || reportedCallStatus(projection, call) !== "running";
+	});
 }
 function updateAssistantMessage(data, turnId, update) {
 	const message = data.messages.find((message) => message.role === "assistant" && message.metadata?.turnId === turnId) ?? createAssistantMessage(turnId);

package/dist/src/cli/commands/agent-instructions.js

@@ -1,4 +1,4 @@
-import pc from"#compiled/picocolors/index.js";import{readFileSync}from"node:fs";import{join}from"node:path";import{DEFAULT_AGENT_MODEL_ID}from"#shared/default-agent-model.js";const SETUP_SECTIONS=[`intro-setup.md`,`collect-intent.md`,`vercel-connect.md`,`scaffold.md`,`build-and-verify.md`],HANDOFF_SECTIONS=[`intro-handoff.md`,`collect-intent.md`,`vercel-connect.md`,`build-and-verify.md`];function compose(e,t){let n=e.map(e=>readFileSync(new URL(`./agent-prompt/${e}`,import.meta.url),`utf8`).trim()).join(`
+import{readFileSync}from"node:fs";import{join}from"node:path";import pc from"#compiled/picocolors/index.js";import{DEFAULT_AGENT_MODEL_ID}from"#shared/default-agent-model.js";const SETUP_SECTIONS=[`intro-setup.md`,`collect-intent.md`,`vercel-connect.md`,`scaffold.md`,`build-and-verify.md`],HANDOFF_SECTIONS=[`intro-handoff.md`,`collect-intent.md`,`vercel-connect.md`,`build-and-verify.md`];function compose(e,t){let n=e.map(e=>readFileSync(new URL(`./agent-prompt/${e}`,import.meta.url),`utf8`).trim()).join(`
 
 `).replaceAll(`{{devCommand}}`,()=>t.devCommand),{workingDirectory:r}=t;return r===void 0?n:n.replaceAll(`{{workingDirectory}}`,()=>r)}function initAgentInstructions(){return compose(SETUP_SECTIONS,{devCommand:`npx eve dev`})}function initAgentReadySummary(e,t,n={}){let r=e??DEFAULT_AGENT_MODEL_ID,i=e===void 0?pc.dim(` (eve default)`):``,a=n.workspace?`${pc.green(`✓`)} Agents ${pc.bold(join(t,`agents`))}`:`${pc.green(`✓`)} Instructions ${pc.bold(join(t,`agent/instructions.md`))}`;return[`${pc.green(`✓`)} Model ${pc.bold(r)}${i}`,a].join(`
 `)}function initAgentDevHandoff(e){return compose(HANDOFF_SECTIONS,{devCommand:e.devCommand,workingDirectory:e.projectPath})}function initExtensionInstructions(){return[`You are scaffolding an eve extension package (a reusable package of tools,`,`connections, skills, and hooks that a consuming agent mounts under`,`agent/extensions/).`,``,`Ask the user for a package directory name, then run:`,``,`    npx eve@latest extension init <name>`,``,`That creates the package, installs dependencies, and initializes Git. It`,`prints what was set up and how to author, build, and mount the extension —`,`it does not start eve dev (extensions are not standalone agents).`,``,"Build with `eve extension build` (or the package `build` script)."].join(`