eve 0.83.2 → 0.84.0

package/dist/src/setup/verified-remote-agent.js

@@ -1 +1 @@
-import{Client,ClientError}from"#client/index.js";import{WizardCancelledError}from"#setup/step.js";import{resolveVerifiedRemoteDevelopmentClient}from"#setup/verified-remote-client.js";import{runRemoteAuthFlow}from"#cli/dev/tui/remote-auth.js";const defaultDeps={createClient:e=>new Client(e),resolveVerifiedRemoteDevelopmentClient,runRemoteAuthFlow};async function inspectVerifiedRemoteAgent(e){let t={...defaultDeps,...e.deps},n=await t.resolveVerifiedRemoteDevelopmentClient({headers:e.headers,serverUrl:e.serverUrl,signal:e.signal,workspaceRoot:e.workspaceRoot});try{return inspection(await t.createClient(n.options).info(),verifiedScope(n))}catch(t){if(e.prompter===void 0||!isAuthenticationFailure(t)||!canAuthenticateInteractively(t,n))throw t}let r=await t.runRemoteAuthFlow({configureTrustedSources:!0,prompter:e.prompter,serverUrl:e.serverUrl,signal:e.signal,workspaceRoot:e.workspaceRoot});if(r.kind===`cancelled`)throw new WizardCancelledError;if(r.kind===`failed`)throw Error(r.message);let i={...n.options,auth:{vercelOidc:{token:r.resolveToken}},headers:e.headers,host:e.serverUrl,redirect:`manual`};return inspection(await t.createClient(i).info(),r.target.deployment.ownerId)}function inspection(e,t){return t===void 0?{info:e}:{info:e,vercelScope:t}}function verifiedScope(e){let t=e.deploymentResolution;return t?.kind===`resolved`?t.target.deployment.ownerId:void 0}function isAuthenticationFailure(e){return e instanceof ClientError&&(e.status>=300&&e.status<400||e.status===401||e.status===403)}function canAuthenticateInteractively(e,t){return e.status>=300&&e.status<400&&(e.headers.location??``).includes(`vercel.com/sso-api`)?!0:t.deploymentResolution?.kind===`resolved`||t.deploymentResolution?.kind===`forbidden`}export{inspectVerifiedRemoteAgent};
+import{Client,ClientError}from"#client/index.js";import{WizardCancelledError}from"#setup/step.js";import{resolveVerifiedRemoteDevelopmentClient}from"#setup/verified-remote-client.js";import{runRemoteAuthFlow}from"#cli/dev/tui/remote-auth.js";const defaultDeps={createClient:e=>new Client(e),resolveVerifiedRemoteDevelopmentClient,runRemoteAuthFlow};async function inspectVerifiedRemoteAgent(e){let t={...defaultDeps,...e.deps},n=await t.resolveVerifiedRemoteDevelopmentClient({headers:e.headers,serverUrl:e.serverUrl,signal:e.signal,workspaceRoot:e.workspaceRoot});try{return inspection(await t.createClient(n.options).info(),verifiedScope(n))}catch(t){if(e.prompter===void 0||!isAuthenticationFailure(t)||!canAuthenticateInteractively(t,n))throw t}let r=await t.runRemoteAuthFlow({configureTrustedSources:!0,prompter:e.prompter,serverUrl:e.serverUrl,signal:e.signal,workspaceRoot:e.workspaceRoot});if(r.kind===`cancelled`)throw new WizardCancelledError;if(r.kind===`failed`)throw Error(r.message);let i={...n.options,auth:{vercelOidc:{token:r.resolveToken}},headers:e.headers,baseUrl:e.serverUrl,redirect:`manual`};return inspection(await t.createClient(i).info(),r.target.deployment.ownerId)}function inspection(e,t){return t===void 0?{info:e}:{info:e,vercelScope:t}}function verifiedScope(e){let t=e.deploymentResolution;return t?.kind===`resolved`?t.target.deployment.ownerId:void 0}function isAuthenticationFailure(e){return e instanceof ClientError&&(e.status>=300&&e.status<400||e.status===401||e.status===403)}function canAuthenticateInteractively(e,t){return e.status>=300&&e.status<400&&(e.headers.location??``).includes(`vercel.com/sso-api`)?!0:t.deploymentResolution?.kind===`resolved`||t.deploymentResolution?.kind===`forbidden`}export{inspectVerifiedRemoteAgent};

package/dist/src/shared/action-label.d.ts

@@ -1,4 +1,3 @@
-import type { ActionPresentationByCallId } from "#protocol/message.js";
 import type { RuntimeActionRequest } from "#shared/action-types.js";
 /**
  * How a call reads to people on every surface: the label its entry's definition
@@ -6,5 +5,8 @@ import type { RuntimeActionRequest } from "#shared/action-types.js";
  * `eve__skill` arrives as the call to its entry, so it reads like a direct call.
  */
 export declare function actionLabel(action: RuntimeActionRequest, presentation: ActionPresentationByCallId | undefined): string;
-/** The calls people see: the model waiting on or stopping its own tasks stays out of view. */
-export declare function visibleActions<T extends RuntimeActionRequest>(actions: readonly T[]): T[];
+/** A tool's authored label for a call or output snapshot. */
+export interface ActionPresentation {
+    readonly label?: string;
+}
+export type ActionPresentationByCallId = Readonly<Record<string, ActionPresentation>>;

package/dist/src/shared/action-label.js

@@ -1 +1 @@
-import{actionRequestName}from"#shared/action-request-name.js";import{displayTitle}from"#shared/display-name.js";import{isTaskControlTool}from"#protocol/task-tools.js";function actionLabel(e,t){return t?.[e.callId]?.label??displayTitle(actionRequestName(e))}function visibleActions(e){return e.filter(e=>!(e.kind===`tool-call`&&isTaskControlTool(e.toolName)))}export{actionLabel,visibleActions};
+import{displayTitle}from"#protocol/session-projection/display-name.js";import{actionRequestName}from"#shared/action-request-name.js";function actionLabel(e,t){return t?.[e.callId]?.label??displayTitle(actionRequestName(e))}export{actionLabel};

package/dist/src/shared/action-types.d.ts

@@ -115,6 +115,11 @@ declare const workflowToolCallEntrySchema: z.ZodDiscriminatedUnion<[z.ZodObject<
 export type RuntimeWorkflowTaskRequest = z.infer<typeof runtimeWorkflowTaskRequestSchema>;
 export declare const runtimeWorkflowTaskRequestSchema: z.ZodObject<{
     callId: z.ZodString;
+    clearedBy: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        policy: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        interactionId: z.ZodString;
+    }, z.core.$strip>]>>;
     entry: z.ZodDiscriminatedUnion<[z.ZodObject<{
         entryPoint: z.ZodLiteral<"execute">;
     }, z.core.$strict>, z.ZodObject<{

package/dist/src/shared/action-types.js

@@ -1 +1 @@
-import{z}from"#compiled/zod/index.js";import{jsonObjectSchema,jsonValueSchema}from"#shared/json-schemas.js";const runtimeToolCallActionRequestSchema=z.object({callId:z.string(),input:jsonObjectSchema,kind:z.literal(`tool-call`),toolName:z.string()}).strict();z.object({callId:z.string(),description:z.string(),input:jsonObjectSchema,kind:z.literal(`subagent-call`),name:z.string(),nodeId:z.string(),subagentName:z.string()}).strict(),z.object({callId:z.string(),description:z.string(),input:jsonObjectSchema,kind:z.literal(`remote-agent-call`),name:z.string(),nodeId:z.string(),remoteAgentName:z.string()}).strict(),z.object({callId:z.string(),input:jsonObjectSchema,kind:z.literal(`workflow-tool-call`),toolName:z.string(),workflowId:z.string()}).strict(),z.object({callId:z.string(),description:z.string(),input:jsonObjectSchema,kind:z.literal(`subagent-call`),name:z.string(),nodeId:z.string(),subagentName:z.string()}).strict();const runtimeRemoteAgentDispatchRequestSchema=z.object({callId:z.string(),description:z.string(),input:jsonObjectSchema,kind:z.literal(`remote-agent-call`),name:z.string(),nodeId:z.string(),remoteAgentName:z.string()}).strict(),workflowToolCallEntrySchema=z.discriminatedUnion(`entryPoint`,[z.object({entryPoint:z.literal(`execute`)}).strict(),z.object({entryPoint:z.literal(`task`),taskId:z.string()}).strict(),z.object({entryPoint:z.literal(`serve`),taskId:z.string()}).strict(),z.object({entryPoint:z.literal(`receive`),taskId:z.string()}).strict()]),runtimeWorkflowTaskRequestSchema=z.object({callId:z.string(),entry:workflowToolCallEntrySchema,executeInput:jsonValueSchema.optional(),input:jsonObjectSchema,kind:z.literal(`workflow-task`),toolName:z.string(),workflowId:z.string()}).strict();z.object({callId:z.string(),input:jsonObjectSchema,kind:z.literal(`load-skill`),name:z.string()}).strict();const RUNTIME_WORKFLOW_TOOL_ACTION=Symbol.for(`eve:runtime-workflow-tool-action`);function markRuntimeWorkflowToolAction(e){return Object.defineProperty(e,RUNTIME_WORKFLOW_TOOL_ACTION,{value:!0}),e}function isRuntimeWorkflowToolAction(e){return e.kind===`workflow-tool-call`||e.kind===`tool-call`&&Reflect.get(e,RUNTIME_WORKFLOW_TOOL_ACTION)===!0}z.object({callId:z.string(),errorName:z.string().optional(),isError:z.boolean().optional(),kind:z.literal(`tool-result`),output:jsonValueSchema,toolName:z.string()}).strict(),z.object({callId:z.string(),isError:z.literal(!0),kind:z.literal(`subagent-result`),origin:z.literal(`dispatch`),output:jsonValueSchema,subagentName:z.string()}).strict(),z.object({callId:z.string(),isError:z.boolean().optional(),kind:z.literal(`load-skill-result`),name:z.string(),output:jsonValueSchema}).strict();export{isRuntimeWorkflowToolAction,markRuntimeWorkflowToolAction,runtimeRemoteAgentDispatchRequestSchema,runtimeToolCallActionRequestSchema,runtimeWorkflowTaskRequestSchema};
+import{z}from"#compiled/zod/index.js";import{jsonObjectSchema,jsonValueSchema}from"#shared/json-schemas.js";import{clearedBySchema}from"#protocol/session-events/families/call.js";const runtimeToolCallActionRequestSchema=z.object({callId:z.string(),input:jsonObjectSchema,kind:z.literal(`tool-call`),toolName:z.string()}).strict();z.object({callId:z.string(),description:z.string(),input:jsonObjectSchema,kind:z.literal(`subagent-call`),name:z.string(),nodeId:z.string(),subagentName:z.string()}).strict(),z.object({callId:z.string(),description:z.string(),input:jsonObjectSchema,kind:z.literal(`remote-agent-call`),name:z.string(),nodeId:z.string(),remoteAgentName:z.string()}).strict(),z.object({callId:z.string(),input:jsonObjectSchema,kind:z.literal(`workflow-tool-call`),toolName:z.string(),workflowId:z.string()}).strict(),z.object({callId:z.string(),description:z.string(),input:jsonObjectSchema,kind:z.literal(`subagent-call`),name:z.string(),nodeId:z.string(),subagentName:z.string()}).strict();const runtimeRemoteAgentDispatchRequestSchema=z.object({callId:z.string(),description:z.string(),input:jsonObjectSchema,kind:z.literal(`remote-agent-call`),name:z.string(),nodeId:z.string(),remoteAgentName:z.string()}).strict(),workflowToolCallEntrySchema=z.discriminatedUnion(`entryPoint`,[z.object({entryPoint:z.literal(`execute`)}).strict(),z.object({entryPoint:z.literal(`task`),taskId:z.string()}).strict(),z.object({entryPoint:z.literal(`serve`),taskId:z.string()}).strict(),z.object({entryPoint:z.literal(`receive`),taskId:z.string()}).strict()]),runtimeWorkflowTaskRequestSchema=z.object({callId:z.string(),clearedBy:clearedBySchema.optional(),entry:workflowToolCallEntrySchema,executeInput:jsonValueSchema.optional(),input:jsonObjectSchema,kind:z.literal(`workflow-task`),toolName:z.string(),workflowId:z.string()}).strict();z.object({callId:z.string(),input:jsonObjectSchema,kind:z.literal(`load-skill`),name:z.string()}).strict();const RUNTIME_WORKFLOW_TOOL_ACTION=Symbol.for(`eve:runtime-workflow-tool-action`);function markRuntimeWorkflowToolAction(e){return Object.defineProperty(e,RUNTIME_WORKFLOW_TOOL_ACTION,{value:!0}),e}function isRuntimeWorkflowToolAction(e){return e.kind===`workflow-tool-call`||e.kind===`tool-call`&&Reflect.get(e,RUNTIME_WORKFLOW_TOOL_ACTION)===!0}z.object({callId:z.string(),errorName:z.string().optional(),isError:z.boolean().optional(),kind:z.literal(`tool-result`),output:jsonValueSchema,toolName:z.string()}).strict(),z.object({callId:z.string(),isError:z.literal(!0),kind:z.literal(`subagent-result`),origin:z.literal(`dispatch`),output:jsonValueSchema,subagentName:z.string()}).strict(),z.object({callId:z.string(),isError:z.boolean().optional(),kind:z.literal(`load-skill-result`),name:z.string(),output:jsonValueSchema}).strict();export{isRuntimeWorkflowToolAction,markRuntimeWorkflowToolAction,runtimeRemoteAgentDispatchRequestSchema,runtimeToolCallActionRequestSchema,runtimeWorkflowTaskRequestSchema};

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

@@ -1,8 +1,8 @@
-import type { CallSettings, LanguageModel } from "ai";
+import type { LanguageModel } from "ai";
 import type { JsonObject } from "#shared/json.js";
 import type { ModuleSourceRef } from "#shared/source-ref.js";
 import type { TokenUsage } from "#shared/token-usage.js";
-import { type DynamicResolveContext, type DynamicSentinel } from "#dynamic/definition.js";
+import { type DynamicModelContext, type DynamicSentinel } from "#dynamic/definition.js";
 /**
  * Optional overrides that eve forwards to the AI SDK model runtime call for
  * this model.
@@ -38,7 +38,7 @@ export declare const ANTHROPIC_PROMPT_CACHE_TTLS: readonly AnthropicPromptCacheT
  * Provider-agnostic reasoning effort forwarded to the AI SDK model call.
  * The AI SDK's `max` level is not supported yet: eve's manifest and agent info list the levels.
  */
-export type AgentReasoningDefinition = Exclude<NonNullable<CallSettings["reasoning"]>, "max">;
+export type AgentReasoningDefinition = "provider-default" | "none" | "minimal" | "low" | "medium" | "high" | "xhigh";
 /**
  * How an agent's model is reached at runtime, decided at compile time from the
  * authored model value.
@@ -80,8 +80,6 @@ export type InternalAgentModelDefinition = {
  * `LanguageModel` instance.
  */
 export type PublicAgentStaticModelDefinition = string | LanguageModel;
-/** Context passed to dynamic model event handlers; the shared dynamic resolver context. */
-export type AgentModelResolveContext = DynamicResolveContext;
 export interface PublicAgentModelSelectionDefinition {
     readonly model: PublicAgentStaticModelDefinition;
     /** Override the agent reasoning effort for this selection; omitted values inherit it. */
@@ -92,11 +90,15 @@ export interface PublicAgentModelSelectionDefinition {
     readonly modelOptions?: AgentModelOptionsDefinition;
 }
 export type PublicAgentDynamicModelResult = PublicAgentStaticModelDefinition | PublicAgentModelSelectionDefinition;
-export type AgentModelResolver = (event: unknown, ctx: AgentModelResolveContext) => PublicAgentDynamicModelResult | Promise<PublicAgentDynamicModelResult>;
-export type PublicAgentDynamicModelDefinition = DynamicSentinel<PublicAgentDynamicModelResult>;
+/**
+ * A `model` chosen per model call: `defineDynamic()` from `eve` or `eve/models`, or `auto()`. Its
+ * function runs before the model is chosen, so its context has no `model`.
+ */
+export type PublicAgentDynamicModelDefinition = DynamicSentinel<PublicAgentDynamicModelResult, DynamicModelContext>;
 export declare function isDynamicModelDefinition(value: unknown): value is PublicAgentDynamicModelDefinition;
 /**
- * The model handle you assign to an agent's `model` field.
+ * The model handle you assign to an agent's `model` field: a static model, or one chosen per
+ * session with `defineDynamic()` from `eve/models` or `auto()`.
  */
 export type PublicAgentModelDefinition = PublicAgentStaticModelDefinition | PublicAgentDynamicModelDefinition;
 export interface InternalAgentCompactionDefinition {
@@ -369,7 +371,10 @@ export type PublicAgentDefinition = PublicAgentDefinitionBase & ({
     readonly modelContextWindowTokens?: number;
     readonly modelOptions?: AgentModelOptionsDefinition;
 } | {
-    /** Resolver that must select a concrete model before model-dependent work. */
+    /**
+     * The model chosen per session. `render` returns the model with its context window,
+     * options, and reasoning, so those fields don't sit beside it.
+     */
     readonly model: PublicAgentDynamicModelDefinition;
     readonly modelContextWindowTokens?: never;
     readonly modelOptions?: never;

package/dist/src/shared/answers-delivery-id.d.ts

@@ -0,0 +1 @@
+export declare function answersDeliveryId(deliveryId: string): string;

package/dist/src/shared/answers-delivery-id.js

@@ -0,0 +1 @@
+function answersDeliveryId(e){return`answers_${e}`}export{answersDeliveryId};

package/dist/src/shared/channel-context.d.ts

@@ -0,0 +1,12 @@
+import type { SessionInfo } from "#context/session-context.js";
+/** Channel routing authority; changing an address does not send input or control a session. */
+export interface ChannelContinuationOps {
+    readonly continuation?: {
+        readonly token: string;
+        alias(token: string): void;
+    };
+}
+/** Live inputs to a channel's context factory, separate from operable session handles. */
+export interface ChannelContext extends ChannelContinuationOps {
+    readonly session: Pick<SessionInfo, "id" | "auth">;
+}

package/dist/src/shared/channel-context.js

@@ -0,0 +1 @@
+export{};

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

@@ -1,10 +1,11 @@
 import { type ChannelCors } from "#channel/cors.js";
-import type { UserContent } from "ai";
+import type { MessageContent } from "#shared/message-content.js";
 import type { ChannelReceiveContext } from "#channel/channel-operations.js";
 import type { RouteDefinition } from "#channel/routes.js";
-import type { Session, SessionHandle } from "#channel/session.js";
-import type { DeliverPayload, SessionAuthContext, TurnPolicy } from "#channel/types.js";
-import type { StepInput } from "#harness/types.js";
+import type { ChannelContext } from "#shared/channel-context.js";
+import type { Delivery } from "#shared/delivery.js";
+import type { SessionAuthContext, TurnPolicy } from "#channel/types.js";
+import type { ChannelDelivery, ChannelDeliveryReplacement } from "#shared/channel-delivery.js";
 import type { UploadPolicyInput } from "#public/channels/upload-policy.js";
 import type { AudienceContext } from "#shared/conversation-context.js";
 import type { ChannelAudience } from "#shared/channel-audience.js";
@@ -26,7 +27,7 @@ export interface FetchFileResult {
 export interface FetchFileContext {
     readonly state: Readonly<Record<string, unknown>>;
     /** The session the attachment arrived in, for checking it against the session's caller. */
-    readonly session: SessionHandle;
+    readonly session: ChannelContext["session"];
 }
 export type FetchFileFunction = (url: string, context?: FetchFileContext) => Promise<Buffer | FetchFileResult | null>;
 /**
@@ -34,13 +35,13 @@ export type FetchFileFunction = (url: string, context?: FetchFileContext) => Pro
  * schedule proactively routes a message to it.
  */
 export interface GenericReceiveInput<TReceiveTarget = Record<string, unknown>> {
-    readonly message: string | UserContent;
+    readonly message: MessageContent;
     readonly target: Readonly<TReceiveTarget>;
     readonly auth: SessionAuthContext | null;
 }
 /**
  * The object passed to {@link defineChannel}. `routes` is required; `state`
- * seeds durable adapter state, `context` builds the per-step `channel` argument
+ * seeds durable adapter state, `context` builds the per-step `ctx.channel`
  * for `events` and `deliver`, `events` handle session lifecycle, `receive`
  * accepts cross-channel handoffs, `fetchFile` stages remote file URLs,
  * `audience` classifies conversation visibility, and `metadata` projects
@@ -53,7 +54,11 @@ export interface GenericReceiveInput<TReceiveTarget = Record<string, unknown>> {
 export interface GenericChannelDefinition<TEvents, TState = undefined, TCtx = void, TReceiveTarget = Record<string, unknown>, TMetadata extends Record<string, unknown> = Record<string, unknown>> {
     /** Policy used by message sends that do not provide an explicit override. */
     readonly turnPolicy?: TurnPolicy;
-    deliver?(payload: DeliverPayload, ctx: TCtx): StepInput | void | Promise<StepInput | void>;
+    /**
+     * Return a replacement delivery, or void to deliver the original payload unchanged. A
+     * replacement carries no `state`; change durable channel state through `ctx.state`.
+     */
+    deliver?(payload: ChannelDelivery<TState>, ctx: TCtx & ChannelContext): ChannelDeliveryReplacement | void | Promise<ChannelDeliveryReplacement | void>;
     readonly state?: TState;
     /**
      * CORS policy for this channel's HTTP routes. `true` enables H3/Nitro's
@@ -64,18 +69,17 @@ export interface GenericChannelDefinition<TEvents, TState = undefined, TCtx = vo
     readonly cors?: ChannelCors;
     /**
      * Builds the per-step channel context handed to `events` and `deliver`.
-     * Receives the live {@link SessionHandle}, so a factory can close over it to
+     * Receives live session information and channel continuation routing, so a factory can
      * register late-bound callbacks. eve writes state mutations made inside the
      * returned context back through `adapter.state`.
      *
-     * Return the channel-owned context (thread handles, API clients, etc.). The
-     * framework passes it as the `channel` argument to event handlers (with
-     * {@link ChannelContinuationOps} injected) and passes {@link SessionContext}
-     * as a separate `ctx` argument.
+     * Return the channel-owned context (thread handles, API clients, etc.). An
+     * event handler reads it as `ctx.channel`, with continuation routing added,
+     * beside the session's context.
      */
-    context?(state: NonNullable<TState>, session: SessionHandle): TCtx;
+    context?(state: NonNullable<TState>, channel: ChannelContext): TCtx;
     readonly routes: readonly RouteDefinition<TState>[];
-    receive?(input: GenericReceiveInput<TReceiveTarget>, ctx: ChannelReceiveContext<TState>): Promise<Session>;
+    receive?(input: GenericReceiveInput<TReceiveTarget>, ctx: ChannelReceiveContext<TState>): Promise<Delivery>;
     readonly events?: TEvents;
     /**
      * Fetches bytes for a link encountered on a `FilePart.data` by the staging
@@ -108,15 +112,4 @@ export interface GenericChannelDefinition<TEvents, TState = undefined, TCtx = vo
      * confident; consumers treat it as non-public.
      */
     readonly audience?: (input: AudienceContext<TState>) => ChannelAudience;
-    /**
-     * Identifier of the adapter family this channel belongs to. Set by
-     * higher-level wrappers (e.g. `slackChannel` passes `"slack"`) so downstream
-     * consumers can render typed channel chips instead of bucketing everything
-     * under "unknown".
-     *
-     * Authors calling `defineChannel` directly do not need to set this; the
-     * framework defaults to `"http"` for stateless channels and `"defineChannel"`
-     * for stateful ones.
-     */
-    readonly kindHint?: string;
 }

package/dist/src/shared/channel-delivery.d.ts

@@ -0,0 +1,16 @@
+import type { Answer } from "#shared/input.js";
+import type { JsonObject } from "#shared/json.js";
+import type { MessageContent } from "#shared/message-content.js";
+/** One inbound delivery passed to a channel's `deliver` hook. */
+export interface ChannelDelivery<TState = undefined> {
+    readonly message?: MessageContent;
+    readonly answers?: readonly Answer[];
+    /** Context persisted in history before this delivery's message. */
+    readonly context?: readonly string[];
+    /** JSON schema the turn's result must match. */
+    readonly outputSchema?: JsonObject;
+    /** Per-delivery state; the hook chooses what to merge into durable channel state. */
+    readonly state?: Partial<TState>;
+}
+/** What a `deliver` hook may return. Channel state changes go through `channel.state`. */
+export type ChannelDeliveryReplacement = Omit<ChannelDelivery, "state">;

package/dist/src/shared/channel-delivery.js

@@ -0,0 +1 @@
+export{};

package/dist/src/shared/connection-events.d.ts

@@ -1,5 +1,5 @@
 import type { ConnectionPrincipal } from "#shared/connection-types.js";
-import type { Experimental_ConnectionEvent } from "#public/definitions/connections/events.js";
+import type { ConnectionEvent } from "#public/definitions/connections/events.js";
 export type EventJson = string | number | boolean | null | readonly EventJson[] | EventJsonObject;
 export type EventJsonObject = {
     [key: string]: EventJson | undefined;
@@ -50,7 +50,7 @@ export type ConnectionEventDelivery = {
     };
     context: Record<string, unknown>;
 } & ({
-    event: Experimental_ConnectionEvent;
+    event: ConnectionEvent;
 } | {
     control: {
         type: "gap";

package/dist/src/shared/connection-types.d.ts

@@ -127,7 +127,7 @@ export interface ConnectionAuthorizationContext {
  * 1. **`getToken`-only**: the runtime probes {@link getToken} per
  *    tool invocation. Throwing
  *    {@link ConnectionAuthorizationRequiredError} emits a
- *    `authorization.required` event; the workflow does
+ *    sign-in `interaction.opened` event; the workflow does
  *    not suspend on a webhook. Works for both `"app"` and `"user"`
  *    principal types.
  * 2. **Full interactive OAuth**: all three methods provided. The
@@ -147,31 +147,6 @@ export interface ConnectionAuthorizationContext {
  * guaranteed JSON-serializable.
  */
 export type AuthorizationDefinition<Resume extends JsonValue = JsonValue> = NonInteractiveAuthorizationDefinition | InteractiveAuthorizationDefinition<Resume>;
-/** Declares whether a connection credential belongs to the agent or end user. */
-export type CredentialOwner = "app" | "user";
-type NonInteractiveCredentialOwner = {
-    readonly credentialOwner?: CredentialOwner;
-    readonly principalType?: never;
-} | {
-    readonly credentialOwner?: never;
-    /**
-     * @deprecated Use `credentialOwner` for connection credential ownership.
-     * Session auth continues to use `principalType`.
-     */
-    readonly principalType?: CredentialOwner;
-};
-/**
- * Auth provider returned directly from or resolved by a connection's `auth`
- * field.
- *
- * Identical to {@link AuthorizationDefinition} except the
- * non-interactive form may omit `credentialOwner`; normalization
- * defaults it to `"app"`. Its legacy `principalType` remains supported
- * and deprecated for compatibility. Interactive definitions continue to
- * use `principalType: "user"`. The resolved token is sent as
- * `Authorization: Bearer <token>`.
- */
-export type ConnectionAuthProvider = (Omit<NonInteractiveAuthorizationDefinition, "principalType"> & NonInteractiveCredentialOwner) | AuthorizationDefinition;
 /**
  * Resolves a connection auth provider from the active turn.
  *
@@ -179,13 +154,13 @@ export type ConnectionAuthProvider = (Omit<NonInteractiveAuthorizationDefinition
  * `ctx.session`, such as selecting a tenant-specific Vercel Connect client.
  * The returned provider is validated and normalized before use.
  */
-export type ConnectionAuthResolver = (ctx: SessionContext) => ConnectionAuthProvider | Promise<ConnectionAuthProvider>;
+export type ConnectionAuthResolver = (ctx: SessionContext) => AuthorizationDefinition | Promise<AuthorizationDefinition>;
 /**
  * Protocol-agnostic `auth` shape accepted by every connection `define*`
  * factory. Pass a provider directly for static configuration, or a resolver
  * to select the provider from the current caller's session context.
  */
-export type ConnectionAuthDefinition = ConnectionAuthProvider | ConnectionAuthResolver;
+export type ConnectionAuthDefinition = AuthorizationDefinition | ConnectionAuthResolver;
 /**
  * Fields shared by every {@link AuthorizationDefinition} shape.
  */
@@ -206,7 +181,7 @@ interface AuthorizationDefinitionBase {
      *   no authenticated user. The token cache keys on a JSON tuple of
      *   the issuer and id so concurrent users never share tokens.
      */
-    readonly principalType: "app" | "user";
+    readonly principalType?: "app" | "user";
     /**
      * Optional metadata marker attached by `connect()` from
      * `@vercel/connect/eve` so downstream tooling can detect Vercel
@@ -275,7 +250,7 @@ export interface NonInteractiveAuthorizationDefinition extends AuthorizationDefi
      * tool invocation. Throw
      * {@link ConnectionAuthorizationRequiredError} to signal that the
      * user must complete authorization out of band; the runtime emits
-     * `authorization.required` and does not suspend on a
+     * sign-in `interaction.opened` and does not suspend on a
      * webhook.
      */
     getToken(opts: {
@@ -304,7 +279,7 @@ export interface InteractiveAuthorizationDefinition<Resume = JsonValue> extends
      * a {@link TokenResult} lets the tool run. Throwing
      * {@link ConnectionAuthorizationRequiredError} signals that the
      * user must complete an authorization flow; the runtime emits a
-     * `authorization.required` event and suspends the turn
+     * sign-in `interaction.opened` event and suspends the turn
      * on a framework-owned webhook while it runs
      * {@link startAuthorization}.
      */
@@ -315,7 +290,7 @@ export interface InteractiveAuthorizationDefinition<Resume = JsonValue> extends
     /**
      * Start an authorization flow. Invoked inside a durable step after the
      * runtime mints a framework-owned callback URL. Returns the user-facing
-     * `challenge` (forwarded verbatim on `authorization.required`) and an
+     * `challenge` (forwarded verbatim on sign-in `interaction.opened`) and an
      * optional serializable `resume` value (e.g. a PKCE verifier) that the
      * runtime journals and hands back to {@link completeAuthorization} when
      * the callback URL receives the provider redirect. Omit `resume` when
@@ -396,6 +371,11 @@ export interface ConnectionToolMetadata {
     readonly description: string;
     readonly inputSchema: Record<string, unknown>;
     readonly name: string;
+    /**
+     * The OpenAPI `operationId` the tool was generated from. The tool name is a
+     * sanitized form of it, so connection filters match both.
+     */
+    readonly operationId?: string;
     readonly outputSchema?: Record<string, unknown>;
 }
 /** Per-call options for {@link ConnectionClient.executeTool}. */

package/dist/src/shared/conversation-context.d.ts

@@ -1,4 +1,4 @@
-import type { InstrumentationChannelKind } from "#public/channels/index.js";
+import type { InstrumentationChannelKind } from "#shared/instrumentation-channel.js";
 import { ContextKey } from "#context/key.js";
 import { type ChannelAudience } from "#shared/channel-audience.js";
 import type { ForwardedTraceAssertion } from "#shared/forwarded-trace-policy.js";
@@ -12,11 +12,6 @@ export interface ConversationContext {
     readonly environment: ConversationEnvironment;
     readonly principalType: string;
 }
-export interface AudiencePrincipal {
-    readonly principalType: string;
-    readonly authenticator: string;
-    readonly attributes: Readonly<Record<string, string | readonly string[]>>;
-}
 export type AudienceCaller = {
     readonly type: "anonymous";
 } | {
@@ -27,17 +22,13 @@ export type AudienceCaller = {
         readonly attributes: Readonly<Record<string, string | readonly string[]>>;
     };
 };
-export interface AudienceInput<TState> {
+/** Privacy-limited input for conversation audience classification. */
+export interface AudienceContext<TState> {
     readonly state: TState;
-    /** @deprecated Use `caller`; it excludes `principalId`, `issuer`, and `subject`. */
-    readonly auth: AudiencePrincipal | null;
+    readonly caller: AudienceCaller;
     readonly channel: ConversationContext["channel"];
     readonly environment: ConversationEnvironment;
 }
-/** Preferred input type for new audience callback annotations. */
-export interface AudienceContext<TState> extends AudienceInput<TState> {
-    readonly caller: AudienceCaller;
-}
 /** Safe projection for durable sessions created before `eve.conversation` existed. */
 export declare const UNKNOWN_CONVERSATION_CONTEXT: ConversationContext;
 interface ConversationContextFallback {

package/dist/src/shared/delivery.d.ts

@@ -0,0 +1,38 @@
+import type { SessionStreamEvent } from "#protocol/session-event.js";
+import type { Interaction } from "#protocol/session-projection/reader.js";
+import type { RequestStatus } from "#protocol/session-projection/request-status.js";
+import type { DeliveryOutcome } from "#protocol/session-events/families/delivery.js";
+import type { ErrorInfo } from "#protocol/session-events/envelope.js";
+/** Options for one observation, independent of the accepted work and other reads. */
+export interface DeliveryReadOptions {
+    /** Aborts this read, not the accepted command. Use session.cancel() to cancel work. */
+    readonly signal?: AbortSignal;
+}
+/** An accepted command: its session and delivery ids form a receipt you can pass to `store.follow()`, alongside reusable, independent reads. */
+export interface Delivery<TOutput = unknown> {
+    readonly sessionId: string;
+    readonly deliveryId: string;
+    /** Reads the admitting commit through the settlement's complete commit. */
+    stream(options?: DeliveryReadOptions): AsyncIterable<SessionStreamEvent>;
+    /** Waits for this delivery's settlement, not the end of its session. */
+    result(options?: DeliveryReadOptions): Promise<DeliveryResult<TOutput>>;
+}
+/** A settled request. Human input finishes this delivery; its answer is a new delivery. */
+export type DeliveryResult<TOutput = unknown> = {
+    readonly deliveryId: string;
+    readonly sessionId: string;
+    readonly outcome: DeliveryOutcome;
+    /** Whether the session ended in the response's final commit. */
+    readonly sessionEnded: boolean;
+    /** The reply's text, when the request produced one. */
+    readonly reply: string | undefined;
+    /** Structured output inferred from the supplied Standard Schema, when available. */
+    readonly data: TOutput | undefined;
+    readonly interactions: readonly Interaction[];
+} & ({
+    readonly status: Exclude<RequestStatus, "failed">;
+    readonly error?: never;
+} | {
+    readonly status: "failed";
+    readonly error: ErrorInfo;
+});

package/dist/src/shared/delivery.js

@@ -0,0 +1 @@
+export{};

package/dist/src/shared/history-message.d.ts

@@ -0,0 +1,190 @@
+type JSONValue = null | boolean | number | string | readonly JSONValue[] | {
+    readonly [key: string]: JSONValue | undefined;
+};
+type ProviderOptions = Record<string, {
+    [key: string]: JSONValue | undefined;
+}>;
+type DataContent = string | Uint8Array | ArrayBuffer;
+type ProviderReference = Record<string, string> & {
+    type?: never;
+};
+type FileDataData = {
+    type: "data";
+    data: DataContent;
+};
+type FileDataUrl = {
+    type: "url";
+    url: URL;
+    originalUrl?: string;
+};
+type FileData = FileDataData | FileDataUrl | {
+    type: "reference";
+    reference: ProviderReference;
+} | {
+    type: "text";
+    text: string;
+};
+interface TextPart {
+    type: "text";
+    text: string;
+    providerOptions?: ProviderOptions;
+}
+interface ImagePart {
+    type: "image";
+    image: DataContent | URL | ProviderReference;
+    mediaType?: string;
+    providerOptions?: ProviderOptions;
+}
+interface FilePart {
+    type: "file";
+    data: FileData | DataContent | URL | ProviderReference;
+    filename?: string;
+    mediaType: string;
+    providerOptions?: ProviderOptions;
+}
+interface ReasoningPart {
+    type: "reasoning";
+    text: string;
+    providerOptions?: ProviderOptions;
+}
+interface CustomPart {
+    type: "custom";
+    kind: `${string}.${string}`;
+    providerOptions?: ProviderOptions;
+}
+interface ReasoningFilePart {
+    type: "reasoning-file";
+    data: FileDataData | FileDataUrl | DataContent | URL;
+    mediaType: string;
+    providerOptions?: ProviderOptions;
+}
+interface ToolCallPart {
+    type: "tool-call";
+    toolCallId: string;
+    toolName: string;
+    input: unknown;
+    providerOptions?: ProviderOptions;
+    providerExecuted?: boolean;
+}
+interface ToolResultPart {
+    type: "tool-result";
+    toolCallId: string;
+    toolName: string;
+    output: ToolResultOutput;
+    providerOptions?: ProviderOptions;
+}
+type ToolResultOutput = {
+    type: "text";
+    value: string;
+    providerOptions?: ProviderOptions;
+} | {
+    type: "json";
+    value: JSONValue;
+    providerOptions?: ProviderOptions;
+} | {
+    type: "execution-denied";
+    reason?: string;
+    providerOptions?: ProviderOptions;
+} | {
+    type: "error-text";
+    value: string;
+    providerOptions?: ProviderOptions;
+} | {
+    type: "error-json";
+    value: JSONValue;
+    providerOptions?: ProviderOptions;
+} | {
+    type: "content";
+    value: Array<{
+        type: "text";
+        text: string;
+        providerOptions?: ProviderOptions;
+    } | {
+        type: "file";
+        data: FileData;
+        mediaType: string;
+        filename?: string;
+        providerOptions?: ProviderOptions;
+    } | {
+        type: "file-data";
+        data: string;
+        mediaType: string;
+        filename?: string;
+        providerOptions?: ProviderOptions;
+    } | {
+        type: "file-url";
+        url: string;
+        mediaType?: string;
+        providerOptions?: ProviderOptions;
+    } | {
+        type: "file-id";
+        fileId: string | Record<string, string>;
+        providerOptions?: ProviderOptions;
+    } | {
+        type: "file-reference";
+        providerReference: ProviderReference;
+        providerOptions?: ProviderOptions;
+    } | {
+        type: "image-data";
+        data: string;
+        mediaType: string;
+        providerOptions?: ProviderOptions;
+    } | {
+        type: "image-url";
+        url: string;
+        providerOptions?: ProviderOptions;
+    } | {
+        type: "image-file-id";
+        fileId: string | Record<string, string>;
+        providerOptions?: ProviderOptions;
+    } | {
+        type: "image-file-reference";
+        providerReference: ProviderReference;
+        providerOptions?: ProviderOptions;
+    } | {
+        type: "custom";
+        providerOptions?: ProviderOptions;
+    }>;
+};
+type ToolApprovalRequest = {
+    type: "tool-approval-request";
+    approvalId: string;
+    toolCallId: string;
+    reason?: string;
+    isAutomatic?: boolean;
+    signature?: string;
+    inputSchemaInput?: unknown;
+};
+type ToolApprovalResponse = {
+    type: "tool-approval-response";
+    approvalId: string;
+    approved: boolean;
+    reason?: string;
+    providerExecuted?: boolean;
+};
+type SystemModelMessage = {
+    role: "system";
+    content: string;
+    providerOptions?: ProviderOptions;
+};
+type UserModelMessage = {
+    role: "user";
+    content: UserContent;
+    providerOptions?: ProviderOptions;
+};
+type UserContent = string | Array<TextPart | ImagePart | FilePart>;
+type AssistantModelMessage = {
+    role: "assistant";
+    content: AssistantContent;
+    providerOptions?: ProviderOptions;
+};
+type AssistantContent = string | Array<TextPart | CustomPart | FilePart | ReasoningPart | ReasoningFilePart | ToolCallPart | ToolResultPart | ToolApprovalRequest>;
+type ToolModelMessage = {
+    role: "tool";
+    content: ToolContent;
+    providerOptions?: ProviderOptions;
+};
+type ToolContent = Array<ToolResultPart | ToolApprovalResponse>;
+/** One system, user, assistant, or tool message in an agent's history. */
+export type HistoryMessage = SystemModelMessage | UserModelMessage | AssistantModelMessage | ToolModelMessage;
+export {};

package/dist/src/shared/history-message.js

@@ -0,0 +1 @@
+export{};