eve 0.33.2 → 0.34.0

package/dist/src/public/definitions/approval.d.ts

@@ -1,17 +1,14 @@
+import type { SessionAuthContext } from "#channel/types.js";
+import type { SessionParent, SessionTurn } from "#context/keys.js";
+import type { ToolAuthOptions, ToolAuthProvider } from "#public/definitions/tool.js";
 import type { SessionContext } from "#public/definitions/callback-context.js";
+import type { TokenResult } from "#runtime/connections/types.js";
 type ApprovalToolInput<TInput> = TInput extends object ? Readonly<TInput> : TInput;
 /**
- * Context passed to an {@link Approval} function.
+ * Context passed to an {@link ApprovalPolicy} function.
  *
  * Extends {@link SessionContext} so approval policies can make decisions from
  * the active session, current caller, and turn.
- *
- * `approvedTools` is the set of tool names (or compound approval keys)
- * already approved at least once in the current session. `toolName` is the
- * runtime name of the tool being evaluated. `toolInput` is the raw input the
- * model passed, available for input-aware decisions. `callId` is the id of
- * the call being evaluated — the same `callId` carried by the call's stream
- * events and its `execute` context.
  */
 export interface ApprovalContext<TInput = Record<string, unknown>> extends SessionContext {
     readonly approvedTools: ReadonlySet<string>;
@@ -19,12 +16,7 @@ export interface ApprovalContext<TInput = Record<string, unknown>> extends Sessi
     readonly toolInput?: ApprovalToolInput<TInput>;
     readonly toolName: string;
 }
-/**
- * Approval decision returned by an {@link Approval} function.
- *
- * AI SDK 7 statuses are accepted directly. For compatibility, `true` maps to
- * `"user-approval"` and `false` maps to `"not-applicable"`.
- */
+/** Request-time approval decision returned by an {@link ApprovalPolicy}. */
 export type ApprovalStatus = undefined | boolean | "not-applicable" | "approved" | "denied" | "user-approval" | {
     readonly type: "not-applicable";
     readonly reason?: never;
@@ -38,6 +30,55 @@ export type ApprovalStatus = undefined | boolean | "not-applicable" | "approved"
     readonly type: "user-approval";
     readonly reason?: never;
 };
-/** Shared approval policy used by authored tools and connections. */
-export type Approval<TInput = Record<string, unknown>> = (ctx: ApprovalContext<TInput>) => ApprovalStatus | Promise<ApprovalStatus>;
+/** Request-time approval policy shared by authored tools and connections. */
+export type ApprovalPolicy<TInput = Record<string, unknown>> = (ctx: ApprovalContext<TInput>) => ApprovalStatus | Promise<ApprovalStatus>;
+/** Stable tool request passed to a response authorizer. */
+export interface ApprovalRequest<TInput = Record<string, unknown>> {
+    readonly callId: string;
+    readonly requestId: string;
+    readonly toolInput?: ApprovalToolInput<TInput>;
+    readonly toolName: string;
+}
+/** Read-only session identity and lineage available to a response authorizer. */
+export interface ApprovalResponseSession {
+    readonly id: string;
+    readonly initiator: SessionAuthContext | null;
+    readonly parent?: SessionParent;
+    readonly turn: SessionTurn;
+}
+/** Narrow authorization capability available while validating a responder. */
+export interface ApprovalResponseAuth {
+    getToken(provider: ToolAuthProvider, options?: ToolAuthOptions): Promise<TokenResult>;
+    requireAuth(provider: ToolAuthProvider, options?: ToolAuthOptions): never;
+}
+/** Submitted decision passed to an approval response policy. */
+export interface ApprovalResponse {
+    readonly decision: "approve";
+}
+/** Context passed to an approval response policy. */
+export interface ApprovalResponseContext<TInput = Record<string, unknown>> {
+    readonly auth: ApprovalResponseAuth;
+    readonly request: ApprovalRequest<TInput>;
+    readonly response: ApprovalResponse;
+    readonly responder: SessionAuthContext;
+    readonly session: ApprovalResponseSession;
+}
+/** Response policy decision. Rejection keeps the shared request pending. */
+export type ApprovalResponseDecision = {
+    readonly status: "allowed";
+} | {
+    readonly reason: string;
+    readonly status: "rejected";
+};
+/** Decides whether an authenticated responder may approve one request. */
+export type ApprovalResponsePolicy<TInput = Record<string, unknown>> = (ctx: ApprovalResponseContext<TInput>) => ApprovalResponseDecision | Promise<ApprovalResponseDecision>;
+/** Approval definition with request- and response-time policy. */
+export interface ApprovalConfiguration<TInput = Record<string, unknown>> {
+    readonly request: ApprovalPolicy<TInput>;
+    readonly response?: ApprovalResponsePolicy<TInput>;
+}
+/** Shared approval definition used by authored tools and connections. */
+export type Approval<TInput = Record<string, unknown>> = ApprovalPolicy<TInput> | ApprovalConfiguration<TInput>;
+/** Returns the request-time policy from either approval authoring shape. */
+export declare function resolveApprovalPolicy<TInput>(approval: Approval<TInput>): ApprovalPolicy<TInput>;
 export {};

package/dist/src/public/definitions/approval.js

@@ -1 +1 @@
-export{};
+function resolveApprovalPolicy(e){return typeof e==`function`?e:e.request}export{resolveApprovalPolicy};

package/dist/src/public/definitions/channel.d.ts

@@ -3,7 +3,6 @@ import { type ChannelCorsOptions } from "#channel/cors.js";
 import type { ChannelFrom, ChannelReceiveContext, ChannelResolveSession, ChannelRespondOptions, ChannelSendOptions, ChannelSource } from "#channel/channel-operations.js";
 import type { RouteDefinition } from "#channel/routes.js";
 import type { Session } from "#channel/session.js";
-import type { TurnPolicy } from "#channel/types.js";
 import type { UnstampedMessageStreamEvent } from "#protocol/message.js";
 import type { SessionContext } from "#public/definitions/callback-context.js";
 import type { GenericChannelDefinition, GenericReceiveInput } from "#shared/channel-definition.js";
@@ -111,6 +110,8 @@ type ChannelSessionFailedHandler<TCtx> = (data: EventData<"session.failed">, cha
  * and the channel context, with no `ctx`; its data includes `sessionId`.
  */
 export interface ChannelEvents<TCtx = void> {
+    readonly "approval.candidate"?: ChannelEventHandler<"approval.candidate", TCtx>;
+    readonly "approval.settled"?: ChannelEventHandler<"approval.settled", TCtx>;
     readonly "context.cleared"?: ChannelEventHandler<"context.cleared", TCtx>;
     readonly "compaction.requested"?: ChannelEventHandler<"compaction.requested", TCtx>;
     readonly "compaction.completed"?: ChannelEventHandler<"compaction.completed", TCtx>;
@@ -161,7 +162,6 @@ export interface Channel<TState = undefined, TReceiveTarget = Record<string, unk
     readonly routes: readonly RouteDefinition<TState>[];
     readonly cors?: ChannelCorsOptions;
     readonly receive?: (input: ReceiveInput<TReceiveTarget>, ctx: ChannelReceiveContext<TState>) => Promise<Session>;
-    readonly turnPolicy?: TurnPolicy;
 }
 /**
  * Extracts the metadata projection type (`TMetadata`) from a {@link Channel}.

package/dist/src/public/definitions/channel.js

@@ -1 +1 @@
-import{CHANNEL_SENTINEL}from"#channel/compiled-channel.js";import{defaultDeliverResult}from"#channel/adapter.js";import{buildCallbackContext}from"#context/build-callback-context.js";import{normalizeChannelCors}from"#channel/cors.js";import{HTTP_ADAPTER_KIND}from"#channel/http.js";import{DELETE,GET,PATCH,POST,PUT,WS}from"#channel/routes.js";const DISABLED_ROUTE_SENTINEL_KIND=`eve:disabled-channel`;function disableRoute(){return{kind:DISABLED_ROUTE_SENTINEL_KIND}}function isDisabledRouteSentinel(e){return typeof e==`object`&&!!e&&e.kind===DISABLED_ROUTE_SENTINEL_KIND}function defineChannel(t){let n=buildAdapter(t),i=normalizeChannelCors(t.cors);return{__kind:CHANNEL_SENTINEL,routes:t.routes,adapter:n,cors:i,receive:t.receive,turnPolicy:t.turnPolicy}}const eventTypes=Object.keys({"context.cleared":null,"compaction.requested":null,"compaction.completed":null,"turn.started":null,"actions.requested":null,"action.partial":null,"action.result":null,"message.completed":null,"message.appended":null,"reasoning.appended":null,"reasoning.completed":null,"input.requested":null,"turn.failed":null,"turn.completed":null,"turn.cancelled":null,"session.failed":null,"session.completed":null,"session.waiting":null,"authorization.required":null,"authorization.completed":null});function buildAdapter(e){let r=e.state!=null,a=e.context!=null,o=e.fetchFile!==void 0,s=e.metadata,c=r||a||s!==void 0,l={},u=!1,d=e.events;for(let e of eventTypes){let t=d?.[e];t&&(u=!0,l[e]=(r,i)=>{let{session:a,...o}=i,s={...o,continuation:a?.continuation===void 0?void 0:{token:a.continuation.token,rekey:e=>a.continuation?.rekey(e)}};if(e===`session.failed`)return t(r,s);let c=buildCallbackContext();return t(r,s,c)})}return!c&&!u&&!o?{kind:e.kindHint??HTTP_ADAPTER_KIND}:{kind:e.kindHint??`defineChannel`,state:r?{...e.state}:{},fetchFile:e.fetchFile,instrumentation:s===void 0?void 0:{metadata(e){return s(e)}},createAdapterContext(t){let n=t.state,r=t.session;return{...a?e.context(n,r):{},state:n,ctx:t.ctx,session:r}},deliver(e){return defaultDeliverResult(e)},...l}}export{DELETE,GET,PATCH,POST,PUT,WS,defineChannel,disableRoute,isDisabledRouteSentinel};
+import{CHANNEL_SENTINEL}from"#channel/compiled-channel.js";import{defaultDeliverResult}from"#channel/adapter.js";import{buildCallbackContext}from"#context/build-callback-context.js";import{normalizeChannelCors}from"#channel/cors.js";import{HTTP_ADAPTER_KIND}from"#channel/http.js";import{DELETE,GET,PATCH,POST,PUT,WS}from"#channel/routes.js";const DISABLED_ROUTE_SENTINEL_KIND=`eve:disabled-channel`;function disableRoute(){return{kind:DISABLED_ROUTE_SENTINEL_KIND}}function isDisabledRouteSentinel(e){return typeof e==`object`&&!!e&&e.kind===DISABLED_ROUTE_SENTINEL_KIND}function defineChannel(t){let n=buildAdapter(t),i=normalizeChannelCors(t.cors);return{__kind:CHANNEL_SENTINEL,routes:t.routes,adapter:n,cors:i,receive:t.receive}}const eventTypes=Object.keys({"approval.candidate":null,"approval.settled":null,"context.cleared":null,"compaction.requested":null,"compaction.completed":null,"turn.started":null,"actions.requested":null,"action.partial":null,"action.result":null,"message.completed":null,"message.appended":null,"reasoning.appended":null,"reasoning.completed":null,"input.requested":null,"turn.failed":null,"turn.completed":null,"turn.cancelled":null,"session.failed":null,"session.completed":null,"session.waiting":null,"authorization.required":null,"authorization.completed":null});function buildAdapter(e){let r=e.state!=null,a=e.context!=null,o=e.fetchFile!==void 0,s=e.metadata,c=r||a||s!==void 0,l={},u=!1,d=e.events;for(let e of eventTypes){let t=d?.[e];t&&(u=!0,l[e]=(r,i)=>{let{session:a,...o}=i,s={...o,continuation:a?.continuation===void 0?void 0:{token:a.continuation.token,rekey:e=>a.continuation?.rekey(e)}};if(e===`session.failed`)return t(r,s);let c=buildCallbackContext();return t(r,s,c)})}return!c&&!u&&!o?{kind:e.kindHint??HTTP_ADAPTER_KIND}:{kind:e.kindHint??`defineChannel`,state:r?{...e.state}:{},fetchFile:e.fetchFile,instrumentation:s===void 0?void 0:{metadata(e){return s(e)}},createAdapterContext(t){let n=t.state,r=t.session;return{...a?e.context(n,r):{},state:n,ctx:t.ctx,session:r}},deliver(n,r){return e.deliver===void 0?defaultDeliverResult(n):e.deliver(n,r)},...l}}export{DELETE,GET,PATCH,POST,PUT,WS,defineChannel,disableRoute,isDisabledRouteSentinel};

package/dist/src/public/definitions/hook.d.ts

@@ -1,7 +1,7 @@
-import type { MessageStreamEvent } from "../../protocol/message.js";
+import type { HandleMessageStreamEvent } from "../../protocol/message.js";
 import type { SessionContext } from "./callback-context.js";
 import type { ExactDefinition } from "./exact.js";
-type ProtocolEvent<TType extends MessageStreamEvent["type"]> = Extract<MessageStreamEvent, {
+type ProtocolEvent<TType extends HandleMessageStreamEvent["type"]> = Extract<HandleMessageStreamEvent, {
     type: TType;
 }>;
 /**
@@ -14,6 +14,8 @@ type ProtocolEvent<TType extends MessageStreamEvent["type"]> = Extract<MessageSt
 export interface HookEventMap {
     readonly "action.partial": ProtocolEvent<"action.partial">;
     readonly "action.result": ProtocolEvent<"action.result">;
+    readonly "approval.candidate": ProtocolEvent<"approval.candidate">;
+    readonly "approval.settled": ProtocolEvent<"approval.settled">;
     readonly "actions.requested": ProtocolEvent<"actions.requested">;
     readonly "authorization.completed": ProtocolEvent<"authorization.completed">;
     readonly "authorization.required": ProtocolEvent<"authorization.required">;

package/dist/src/public/instrumentation/index.d.ts

@@ -1,21 +1,23 @@
-import type { ExactDefinition } from "#public/definitions/exact.js";
 /**
- * Instrumentation authoring helpers for `agent/instrumentation.ts`.
+ * Instrumentation authoring helpers for `agent/instrumentation.ts` and, with
+ * `experimental.instrumentationProviders` on, `agent/instrumentation/`.
  */
 import type { ModelMessage, SystemModelMessage } from "ai";
 import type { SessionAuthContext, SessionParent } from "#channel/types.js";
 import type { InstrumentationChannel } from "#public/channels/index.js";
+import { PROVIDER, type ProviderDefinition, type ProviderSetupContext } from "#public/instrumentation/provider.js";
 import type { JsonObject } from "#shared/json.js";
+export * from "#public/instrumentation/provider.js";
 export { isChannel, type InstrumentationChannel, type InstrumentationChannelForChannel, type InstrumentationChannelForKind, type InstrumentationChannelKind, type InstrumentationChannelMetadata, } from "#public/channels/index.js";
 /**
  * Context passed to the {@link InstrumentationDefinition.setup} callback.
+ *
+ * The same context both layouts receive. Keeping one type is what gives
+ * {@link defineInstrumentation}'s union a contextual signature for `setup`;
+ * two divergent ones would leave every authored `setup(context)` parameter an
+ * implicit `any`.
  */
-export interface InstrumentationSetupContext {
-    /**
-     * The agent name declared by `defineAgent`. Use as the `serviceName` for
-     * `registerOTel` instead of a hard-coded string.
-     */
-    readonly agentName: string;
+export interface InstrumentationSetupContext extends ProviderSetupContext {
 }
 /**
  * User-authored runtime context values attached to AI SDK telemetry spans.
@@ -136,16 +138,29 @@ export interface InstrumentationDefinition {
      */
     readonly traceChannelRequests?: boolean;
     /**
-     * Setup callback invoked at server startup with the resolved agent name.
-     * Use it to call `registerOTel` or other OTel provider setup;
-     * `context.agentName` comes from `defineAgent`.
+     * Setup callback invoked at server startup, before the first request. Use it
+     * to call `registerOTel` or other OTel provider setup; `context.agentName`
+     * comes from `defineAgent`. A returned promise is awaited.
      */
-    readonly setup?: (context: InstrumentationSetupContext) => void;
+    readonly setup?: (context: InstrumentationSetupContext) => void | PromiseLike<void>;
 }
 /**
- * Export the result as the default export of `agent/instrumentation.ts`. eve
- * reads these settings at server startup and applies them to every AI SDK
- * model call. The `setup` callback runs later with the resolved agent name,
- * not during `defineInstrumentation` itself.
+ * Declares instrumentation, in either of eve's two layouts.
+ *
+ * Export the result as the default export of `agent/instrumentation.ts`, or —
+ * with `experimental.instrumentationProviders` on — of one file under
+ * `agent/instrumentation/`. The layout decides how eve reads the value; the two
+ * are mutually exclusive builds, so only one can apply. `setup` runs at server
+ * startup, not during this call.
+ *
+ * The parameter is a union because a provider and a legacy config overlap on
+ * `events` and `setup`, so no value-level check separates them. One consequence
+ * is that excess-property checking is weaker here than it was against the
+ * config shape alone, and a misspelled key can reach `eve build` rather than
+ * failing at `tsc`.
  */
-export declare function defineInstrumentation<T extends InstrumentationDefinition>(definition: ExactDefinition<T, InstrumentationDefinition>): T;
+export declare function defineInstrumentation<const TDefinition extends InstrumentationDefinition | ProviderDefinition>(definition: TDefinition): InstrumentationDeclaration<TDefinition>;
+/** The branded result of {@link defineInstrumentation}. */
+export type InstrumentationDeclaration<TDefinition extends InstrumentationDefinition | ProviderDefinition = InstrumentationDefinition | ProviderDefinition> = TDefinition & {
+    readonly [PROVIDER]: true;
+};

package/dist/src/public/instrumentation/index.js

@@ -1 +1 @@
-import{isChannel}from"#public/channels/index.js";function defineInstrumentation(e){return e}export{defineInstrumentation,isChannel};
+import{PROVIDER}from"#public/instrumentation/provider.js";import{isChannel}from"#public/channels/index.js";export*from"#public/instrumentation/provider.js";function defineInstrumentation(e){return{...e,[PROVIDER]:!0}}export{defineInstrumentation,isChannel};

package/dist/src/public/instrumentation/otel.d.ts

@@ -0,0 +1,31 @@
+/**
+ * The OpenTelemetry authoring surface for `agent/instrumentation/`.
+ *
+ * Two halves, because OpenTelemetry has two: `otel()` is the settings a process
+ * can only hold one of, and an integration is a destination, of which there may
+ * be as many as there are files.
+ *
+ * Reachable only with `experimental.instrumentationProviders` on. With the flag
+ * off nothing discovers that directory, so these compile but never run.
+ */
+import { type ContentOptions, type OtelIntegration } from "#tracing/otel-declaration.js";
+export { isOtelDeclaration, isOtelIntegration, otel, otelIntegration, type ContentOptions, type OtelDeclaration, type OtelIntegration, type OtelIntegrationOptions, type OtelOptions, } from "#tracing/otel-declaration.js";
+export type { SpanExporter, SpanProcessor } from "#compiled/@vercel/otel/index.js";
+/**
+ * Vercel Agent Runs, enabled by default in production.
+ *
+ * Export it from `agent/instrumentation/agent-runs.ts` to narrow content, or
+ * export `disableInstrumentation()` from that file to turn it off.
+ */
+export declare function agentRuns(options?: ContentOptions): OtelIntegration;
+/**
+ * The local trace spool `eve dev` reads, as a destination.
+ *
+ * Export it from `agent/instrumentation/local.ts` to keep it alongside a hosted
+ * backend, or export `disableInstrumentation()` from that file to turn it off.
+ * Omitting the file leaves eve's default in place.
+ *
+ * `EVE_TRACES_CONTENT=off` narrows this destination and no other, so declining
+ * content locally leaves what a hosted backend receives alone.
+ */
+export declare function localTraces(options?: ContentOptions): OtelIntegration;

package/dist/src/public/instrumentation/otel.js

@@ -0,0 +1 @@
+import{agentRunsIntegration,isOtelDeclaration,isOtelIntegration,otel,otelIntegration,otelIntegration as otelIntegration$1}from"#tracing/otel-declaration.js";import{createLocalTracesProcessor,resolveLocalTracesContent}from"#tracing/local-traces.js";function agentRuns(t={}){return agentRunsIntegration(t)}function localTraces(e={}){return otelIntegration$1({...resolveLocalTracesContent(e),spanProcessors:[createLocalTracesProcessor()]})}export{agentRuns,isOtelDeclaration,isOtelIntegration,localTraces,otel,otelIntegration};

package/dist/src/public/instrumentation/provider.d.ts

@@ -0,0 +1,117 @@
+/**
+ * The provider contract authored under `agent/instrumentation/`.
+ *
+ * Reachable only with `experimental.instrumentationProviders` on. With the flag
+ * off nothing discovers that directory, so these types compile but never run.
+ */
+import type { InstrumentationCapture, InstrumentationEvent } from "#harness/instrumentation-lifecycle.js";
+import type { JsonValue } from "#public/types/json.js";
+export type { JsonValue } from "#public/types/json.js";
+export type { InstrumentationActionCompletedEvent, InstrumentationActionFailedEvent, InstrumentationActionKind, InstrumentationActionOutcome, InstrumentationActionOutput, InstrumentationActionStartedEvent, InstrumentationAttemptScope, InstrumentationCapture, InstrumentationChannelDeliveryInput, InstrumentationChannelDeliveryOutcome, InstrumentationChannelDeliveryRef, InstrumentationChannelDeliveryStartedEvent, InstrumentationChannelDeliveryTerminalEvent, InstrumentationContentPart, InstrumentationEvent, InstrumentationInputKind, InstrumentationInputOption, InstrumentationInputOutcome, InstrumentationInputRequest, InstrumentationInputRequestedEvent, InstrumentationInputResolvedEvent, InstrumentationInputResponse, InstrumentationModelCallCompletedEvent, InstrumentationModelCallFailedEvent, InstrumentationModelCallStartedEvent, InstrumentationModelRef, InstrumentationOperationRef, InstrumentationParentLineage, InstrumentationSessionFailedEvent, InstrumentationSessionSettledEvent, InstrumentationSessionStartedEvent, InstrumentationSessionTransitionEvent, InstrumentationStepAttemptMetadataEvent, InstrumentationStepAttemptCompletedEvent, InstrumentationStepAttemptFailedEvent, InstrumentationStepAttemptStartedEvent, InstrumentationStepAttemptTerminalEvent, InstrumentationToolCallCompletedEvent, InstrumentationToolCallFailedEvent, InstrumentationToolCallStartedEvent, InstrumentationToolOutput, InstrumentationTraceContext, InstrumentationTurnFailedEvent, InstrumentationTurnSettledEvent, InstrumentationTurnStartedEvent, InstrumentationTurnTerminalEvent, InstrumentationUsage, } from "#harness/instrumentation-lifecycle.js";
+/**
+ * Marks a value as having come from `defineInstrumentation` or a built-in
+ * factory.
+ *
+ * It does not say which layout the value belongs to: a provider and a legacy
+ * config both carry `events` and `setup`, so no value-level check separates
+ * them. The layout decides — `agent/instrumentation.ts` is read as a config and
+ * `agent/instrumentation/*.ts` as providers, and the two are mutually exclusive
+ * builds. The brand's job is only to catch a default export that never went
+ * through eve at all.
+ */
+export declare const PROVIDER: unique symbol;
+/** Marks a slot the author turned off rather than configured. */
+export declare const DISABLED: unique symbol;
+/** Where the agent is running when `setup` fires. */
+export type InstrumentationEnvironment = "development" | "preview" | "production";
+/** The local eval run this server was started to serve. */
+export interface EvaluationRef {
+    readonly runId: string;
+}
+/**
+ * Passed to {@link InstrumentationProvider.setup} once at server startup,
+ * before any event is published.
+ */
+export interface ProviderSetupContext {
+    /** The agent name declared by `defineAgent`. */
+    readonly agentName: string;
+    /** Always supplied at runtime; optional for legacy setup-context compatibility. */
+    readonly environment?: InstrumentationEnvironment;
+    /** Present only when this server was started for a local `eve eval` run. */
+    readonly evaluation?: EvaluationRef;
+    /** The eve version running the agent. */
+    /** Always supplied at runtime; optional for legacy setup-context compatibility. */
+    readonly frameworkVersion?: string;
+}
+export interface ProviderState {
+    get(): JsonValue | undefined;
+    /** Stages a JSON value; `undefined` releases this operation's slot. */
+    set(value: JsonValue | undefined): void;
+}
+export interface ProviderContext {
+    readonly state: ProviderState;
+}
+/**
+ * One event handler.
+ *
+ * A handler can carry durable JSON state from a start to its terminal through
+ * `ctx.state`. eve scopes and releases that state by provider and operation.
+ */
+export type Handler<TEvent> = (event: TEvent, ctx: ProviderContext) => void | PromiseLike<void>;
+type EventForType<TEvent, TType> = TEvent extends {
+    readonly type: infer TEventType;
+} ? TType extends TEventType ? TEvent & {
+    readonly type: TType;
+} : never : never;
+/**
+ * The events a provider may handle, one optional handler per event type.
+ *
+ * Derived from the event union rather than written out, so a new event reaches
+ * providers the moment the bus can publish it.
+ */
+export type ProviderEvents = {
+    readonly [TType in InstrumentationEvent["type"]]?: Handler<EventForType<InstrumentationEvent, TType>>;
+};
+/**
+ * What an author writes for one file under `agent/instrumentation/`.
+ *
+ * Setup runs in slot order, but event handlers across authored providers run
+ * concurrently and are failure-isolated. Do not coordinate providers through
+ * completion order.
+ */
+export interface ProviderDefinition {
+    /**
+     * How much of each event this provider is handed. Defaults to `"metadata"`:
+     * structure, identity, usage, and timing, but not what was said.
+     *
+     * `"content"` adds the prompt, the response, tool arguments, and tool
+     * results. Asking is what makes eve build the projection at all, so a
+     * directory in which nobody asks never serializes a prompt.
+     */
+    readonly capture?: InstrumentationCapture;
+    readonly events?: ProviderEvents;
+    /** Runs once at server startup, before any event is published. */
+    readonly setup?: (context: ProviderSetupContext) => void | PromiseLike<void>;
+    /** Drains anything buffered. eve calls this before a session goes idle. */
+    readonly flush?: () => void | PromiseLike<void>;
+    /** Releases resources when the process is going away. */
+    readonly shutdown?: () => void | PromiseLike<void>;
+}
+/** A {@link ProviderDefinition} that has been through `defineInstrumentation`. */
+export type InstrumentationProvider = ProviderDefinition & {
+    readonly [PROVIDER]: true;
+};
+/** A slot the author turned off. eve registers nothing for it. */
+export interface InstrumentationDisabled {
+    readonly [DISABLED]: true;
+}
+/**
+ * Turns off the slot the file it is exported from names.
+ *
+ * Export it as the default of `agent/instrumentation/local.ts` to stop eve
+ * spooling local traces, for instance. Omitting the file entirely leaves eve's
+ * default in place, which is why turning one off takes a value.
+ */
+export declare function disableInstrumentation(): InstrumentationDisabled;
+export declare function isInstrumentationProvider(value: unknown): value is InstrumentationProvider;
+export declare function isInstrumentationDisabled(value: unknown): value is InstrumentationDisabled;

package/dist/src/public/instrumentation/provider.js

@@ -0,0 +1 @@
+const PROVIDER=Symbol.for(`eve.instrumentation.provider`),DISABLED=Symbol.for(`eve.instrumentation.disabled`);function disableInstrumentation(){return{[DISABLED]:!0}}function isInstrumentationProvider(t){return typeof t==`object`&&!!t&&t[PROVIDER]===!0}function isInstrumentationDisabled(e){return typeof e==`object`&&!!e&&e[DISABLED]===!0}export{DISABLED,PROVIDER,disableInstrumentation,isInstrumentationDisabled,isInstrumentationProvider};

package/dist/src/public/tools/approval/approval-helpers.d.ts

@@ -1,14 +1,14 @@
-import type { Approval } from "#public/definitions/approval.js";
+import type { ApprovalPolicy } from "#public/definitions/approval.js";
 /**
  * Returns an `approval` callback that always requires user approval before
  * the tool executes.
  */
-export declare function always<TInput = unknown>(): Approval<TInput>;
+export declare function always<TInput = unknown>(): ApprovalPolicy<TInput>;
 /**
  * Returns an `approval` callback that never requires user approval before
  * the tool executes.
  */
-export declare function never<TInput = unknown>(): Approval<TInput>;
+export declare function never<TInput = unknown>(): ApprovalPolicy<TInput>;
 /**
  * Returns an `approval` callback that requires approval until the user
  * approves this tool once in the current session. A tool is recorded as
@@ -16,4 +16,4 @@ export declare function never<TInput = unknown>(): Approval<TInput>;
  * responding) leaves it unrecorded, so the next call prompts again. Keys off
  * the bare tool name, so it ignores compound approval keys.
  */
-export declare function once<TInput = unknown>(): Approval<TInput>;
+export declare function once<TInput = unknown>(): ApprovalPolicy<TInput>;

package/dist/src/public/tools/index.d.ts

@@ -3,7 +3,7 @@
  */
 export { type DisabledToolSentinel, type ExperimentalWorkflowToolDefinition, type ExperimentalWorkflowToolInput, defineDynamic, defineTool, disableTool, experimental_workflow, isDisabledToolSentinel, isExperimentalWorkflowToolDefinition, type ToolAuthOptions, type ToolAuthProvider, type ToolDefinition, type ToolContext, type ToolModelOutput, type ToolModelOutputPart, } from "#public/definitions/tool.js";
 export { toolOutput, toolOutputPart } from "#public/tools/output-builders.js";
-export type { Approval, ApprovalContext, ApprovalStatus } from "#public/definitions/approval.js";
+export type { Approval, ApprovalConfiguration, ApprovalContext, ApprovalPolicy, ApprovalRequest, ApprovalResponse, ApprovalResponseAuth, ApprovalResponseContext, ApprovalResponseDecision, ApprovalResponsePolicy, ApprovalResponseSession, ApprovalStatus, } from "#public/definitions/approval.js";
 export type { DynamicToolEntry, DynamicEvents, DynamicToolEvents, DynamicResolveContext, DynamicSentinel, DynamicToolSet, DynamicToolResult, } from "#shared/dynamic-tool-definition.js";
 export { type SessionContext } from "#public/definitions/callback-context.js";
 export { toolResultFrom, type MatchedConnectionResult, type MatchedToolResult, type ToolResultFromFn, } from "#public/tool-result-narrowing.js";

package/dist/src/runtime/actions/results.d.ts

@@ -1,6 +1,6 @@
 import type { RuntimeActionResult } from "#runtime/actions/types.js";
 /** Returns results in pending-key order once every requested action has completed. */
-export declare function resolveRuntimeActionResultsForKeys(input: {
+export declare function resolveRuntimeActionResultsForKeys<TResult extends RuntimeActionResult>(input: {
     readonly pendingKeys: readonly string[];
-    readonly results: readonly RuntimeActionResult[];
-}): RuntimeActionResult[] | undefined;
+    readonly results: readonly TResult[];
+}): TResult[] | undefined;

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

@@ -1 +1 @@
-import{EVE_ATTRIBUTE_VALUE_MAX_BYTES,normalizeEveAttributes,truncateForTag}from"#runtime/attributes/normalize.js";import"#internal/workflow/builtins.js";let WARNED_ABOUT_TAG_FAILURE=!1;async function setEveAttributes(e){let t=normalizeEveAttributes(e);if(Object.keys(t).length!==0)try{let{setAttributes:e}=await import(`#compiled/@workflow/core/index.js`);await e(t,{allowReservedAttributes:!0})}catch(e){WARNED_ABOUT_TAG_FAILURE||(WARNED_ABOUT_TAG_FAILURE=!0,console.warn(`[eve] setEveAttributes failed; suppressing further warnings this process.`,{keys:Object.keys(t),error:e.message}))}}export{EVE_ATTRIBUTE_VALUE_MAX_BYTES,setEveAttributes,truncateForTag};
+import{EVE_ATTRIBUTE_VALUE_MAX_BYTES,normalizeEveAttributes,truncateForTag}from"#runtime/attributes/normalize.js";import"#internal/workflow/builtins.js";let WARNED_ABOUT_TAG_FAILURE=!1;async function setEveAttributes(e){let t=normalizeEveAttributes(e);if(Object.keys(t).length!==0)try{let{setAttributes:e}=await import(`#compiled/@workflow/core/index.js`);await e(t,{allowReservedAttributes:!0})}catch(e){if(isTerminalRunAttributeError(e))return;WARNED_ABOUT_TAG_FAILURE||(WARNED_ABOUT_TAG_FAILURE=!0,console.warn(`[eve] setEveAttributes failed; suppressing further warnings this process.`,{keys:Object.keys(t),error:e.message}))}}function isTerminalRunAttributeError(e){return e instanceof Error&&e.message.startsWith(`Cannot set attributes on run in terminal state`)}export{EVE_ATTRIBUTE_VALUE_MAX_BYTES,setEveAttributes,truncateForTag};

package/dist/src/runtime/connections/principal.d.ts

@@ -10,6 +10,7 @@
  * by principal routes through {@link principalKey}.
  */
 import { type AlsContext } from "#context/container.js";
+import { type SessionAuthContext } from "#context/keys.js";
 import type { AuthorizationDefinition, ConnectionPrincipal } from "#runtime/connections/types.js";
 /**
  * Stable string key identifying one principal within a connection's
@@ -66,3 +67,5 @@ export declare function principalKey(principal: ConnectionPrincipal): string;
  * the definition shape beyond reading `principalType`.
  */
 export declare function resolveConnectionPrincipal(connectionName: string, authorization: AuthorizationDefinition, ctx?: AlsContext | undefined): ConnectionPrincipal;
+/** Resolves a connection principal from an explicitly bound session identity. */
+export declare function resolveConnectionPrincipalFromAuth(connectionName: string, authorization: AuthorizationDefinition, current: SessionAuthContext | null | undefined, ctx?: AlsContext): ConnectionPrincipal;

package/dist/src/runtime/connections/principal.js

@@ -1 +1 @@
-import{AuthKey}from"#context/keys.js";import{contextStorage}from"#context/container.js";import{ConnectionAuthorizationFailedError}from"#public/connections/errors.js";function principalKey(e){return e.type===`app`?`app`:e.issuer===void 0?`user:${e.id}`:`user:${e.issuer}:${e.id}`}function resolveConnectionPrincipal(r,i,a=contextStorage.getStore()){if(i.principalType===`app`)return{type:`app`};let o=a?.get(AuthKey);if(o==null||o.principalType!==`user`)throw new ConnectionAuthorizationFailedError(r,{message:buildUserPrincipalRequiredMessage(r,i,a,o),reason:`principal_required`,retryable:!1});return i.vercelConnect!==void 0&&isVercelDevelopmentUser(o)?{attributes:o.attributes,id:o.subject??o.principalId,type:`user`}:{attributes:o.attributes,id:o.principalId,issuer:o.issuer??o.authenticator,type:`user`}}function isVercelDevelopmentUser(e){return e.authenticator===`oidc`&&e.issuer?.startsWith(`https://oidc.vercel.com/`)===!0&&e.attributes.environment===`development`&&e.subject===e.attributes.user_id}function buildUserPrincipalRequiredMessage(e,t,n,r){let i;return i=n===void 0?`it was invoked outside an eve context, so no authenticated user can be resolved.`:r==null?`the active session has no authenticated user.`:t.vercelConnect!==void 0&&r.authenticator===`local-dev`?`the local request fell back to local development access instead of authenticating a Vercel user. Ensure this directory is linked and the Vercel CLI can mint a Vercel OIDC token, then retry.`:`the active session is scoped to "${r.principalType}", not an authenticated user.`,`Connection "${e}" is user-scoped, but ${i} User-scoped connections require route auth that resolves an authenticated user. If this connection should use credentials shared by the agent instead, configure it as an app-scoped connection.`}export{principalKey,resolveConnectionPrincipal};
+import{AuthKey}from"#context/keys.js";import{contextStorage}from"#context/container.js";import{ConnectionAuthorizationFailedError}from"#public/connections/errors.js";function principalKey(e){return e.type===`app`?`app`:e.issuer===void 0?`user:${e.id}`:`user:${e.issuer}:${e.id}`}function resolveConnectionPrincipal(n,r,i=contextStorage.getStore()){return resolveConnectionPrincipalFromAuth(n,r,i?.get(AuthKey),i)}function resolveConnectionPrincipalFromAuth(e,t,r,i){if(t.principalType===`app`)return{type:`app`};if(r==null||r.principalType!==`user`)throw new ConnectionAuthorizationFailedError(e,{message:buildUserPrincipalRequiredMessage(e,t,i,r),reason:`principal_required`,retryable:!1});return t.vercelConnect!==void 0&&isVercelDevelopmentUser(r)?{attributes:r.attributes,id:r.subject??r.principalId,type:`user`}:{attributes:r.attributes,id:r.principalId,issuer:r.issuer??r.authenticator,type:`user`}}function isVercelDevelopmentUser(e){return e.authenticator===`oidc`&&e.issuer?.startsWith(`https://oidc.vercel.com/`)===!0&&e.attributes.environment===`development`&&e.subject===e.attributes.user_id}function buildUserPrincipalRequiredMessage(e,t,n,r){let i;return i=n===void 0?`it was invoked outside an eve context, so no authenticated user can be resolved.`:r==null?`the active session has no authenticated user.`:t.vercelConnect!==void 0&&r.authenticator===`local-dev`?`the local request fell back to local development access instead of authenticating a Vercel user. Ensure this directory is linked and the Vercel CLI can mint a Vercel OIDC token, then retry.`:`the active session is scoped to "${r.principalType}", not an authenticated user.`,`Connection "${e}" is user-scoped, but ${i} User-scoped connections require route auth that resolves an authenticated user. If this connection should use credentials shared by the agent instead, configure it as an app-scoped connection.`}export{principalKey,resolveConnectionPrincipal,resolveConnectionPrincipalFromAuth};

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

@@ -11,6 +11,7 @@
  */
 import type { ConnectionAuthorizationChallenge } from "#public/connections/errors.js";
 import { type AuthorizationSignal } from "#harness/authorization.js";
+import type { SessionAuthContext } from "#context/keys.js";
 import { type AuthorizationDefinition, type ConnectionAuthorizationContext, type TokenResult } from "#runtime/connections/types.js";
 /**
  * Everything the scoped authorization helpers need to drive one
@@ -19,6 +20,7 @@ import { type AuthorizationDefinition, type ConnectionAuthorizationContext, type
  * {@link ConnectionAuthorizationContext} handed to every callback.
  */
 export interface ScopedAuthorization {
+    readonly boundResponder?: SessionAuthContext;
     readonly scope: string;
     readonly authorization: Readonly<AuthorizationDefinition>;
     readonly connection: ConnectionAuthorizationContext;
@@ -78,11 +80,7 @@ export declare function completeScopedAuthorization(input: ScopedAuthorization):
  * callers can fall through to rethrowing the original `Required` error.
  */
 export declare function startScopedAuthorization(input: ScopedAuthorization): Promise<AuthorizationSignal | undefined>;
-/**
- * Vercel Connect accepts local HTTP callback URLs only when their hostname is
- * literally `localhost`. Other authorization providers keep the framework's
- * original callback URL so their registered redirect URI remains unchanged.
- */
+/** Normalizes callback URLs for providers with localhost requirements. */
 export declare function resolveAuthorizationCallbackUrl(input: {
     readonly authorization: Readonly<AuthorizationDefinition>;
     readonly callbackUrl: string;

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

@@ -1 +1 @@
-import{contextStorage,loadContext}from"#context/container.js";import{consumeAuthorizationResult,createAuthorizationAttempt,requestAuthorization}from"#harness/authorization.js";import{supportsInteractiveAuthorization}from"#runtime/connections/types.js";import{evictCachedToken,readCachedToken,writeCachedToken}from"#runtime/connections/authorization-tokens.js";import{principalKey,resolveConnectionPrincipal}from"#runtime/connections/principal.js";const LOCAL_HTTP_VERCEL_CONNECT_HOSTNAMES=new Set([`127.0.0.1`,`[::1]`]);async function resolveScopedToken(t){let{scope:n,authorization:r,connection:i}=t,a=contextStorage.getStore(),o=resolveConnectionPrincipal(n,r,a);if(a===void 0)return await r.getToken({connection:i,principal:o});let u=principalKey(o),d=readCachedToken(a,n,u);if(d!==void 0)return d;let f=await r.getToken({connection:i,principal:o});return writeCachedToken(a,n,u,f),f}async function evictScopedToken(t){let{scope:n,authorization:r,connection:i}=t,a=contextStorage.getStore();if(a===void 0)return;let s;try{s=resolveConnectionPrincipal(n,r,a),evictCachedToken(a,n,principalKey(s))}catch{return}try{await r.evict?.({connection:i,principal:s})}catch{}}async function completeScopedAuthorization(e){let{scope:r,authorization:i,connection:o}=e;if(!supportsInteractiveAuthorization(i))return!1;let s=consumeAuthorizationResult(r);if(s===void 0)return!1;let u=i,d=loadContext(),f=s.principal??resolveConnectionPrincipal(r,u,d),p=await u.completeAuthorization({callbackUrl:s.hookUrl,connection:o,principal:f,resume:s.resume,callback:s.callback});return writeCachedToken(d,r,principalKey(f),p),!0}async function startScopedAuthorization(e){let{scope:t,authorization:n,connection:o}=e;if(!supportsInteractiveAuthorization(n))return;let s=createAuthorizationAttempt(t);if(s===void 0)return;let c=n,l=resolveConnectionPrincipal(t,c),u=resolveAuthorizationCallbackUrl({authorization:n,callbackUrl:s.hookUrl}),{challenge:d,resume:f}=await c.startAuthorization({callbackUrl:u,connection:o,principal:l});return requestAuthorization([{attemptId:s.attemptId,challenge:stampChallengeDisplayName(d,n),hookUrl:u,name:t,principal:l,resume:f}])}function resolveAuthorizationCallbackUrl(e){if(e.authorization.vercelConnect===void 0)return e.callbackUrl;let t;try{t=new URL(e.callbackUrl)}catch{return e.callbackUrl}return t.protocol!==`http:`||!LOCAL_HTTP_VERCEL_CONNECT_HOSTNAMES.has(t.hostname)?e.callbackUrl:(t.hostname=`localhost`,t.toString())}function stampChallengeDisplayName(e,t){let n=t.displayName??e.displayName;return n===e.displayName?e:{...e,displayName:n}}export{completeScopedAuthorization,evictScopedToken,resolveAuthorizationCallbackUrl,resolveScopedToken,stampChallengeDisplayName,startScopedAuthorization};
+import{contextStorage,loadContext}from"#context/container.js";import{consumeAuthorizationResult,createAuthorizationAttempt,requestAuthorization}from"#harness/authorization.js";import{supportsInteractiveAuthorization}from"#runtime/connections/types.js";import{evictCachedToken,readCachedToken,writeCachedToken}from"#runtime/connections/authorization-tokens.js";import{principalKey,resolveConnectionPrincipal,resolveConnectionPrincipalFromAuth}from"#runtime/connections/principal.js";const LOCAL_HTTP_VERCEL_CONNECT_HOSTNAMES=new Set([`127.0.0.1`,`[::1]`]);async function resolveScopedToken(t){let{scope:n,authorization:r,connection:i}=t,a=contextStorage.getStore(),o=resolveScopedPrincipal(t,a);if(a===void 0)return await r.getToken({connection:i,principal:o});let u=principalKey(o),d=readCachedToken(a,n,u);if(d!==void 0)return d;let f=await r.getToken({connection:i,principal:o});return writeCachedToken(a,n,u,f),f}async function evictScopedToken(t){let{scope:n,authorization:r,connection:i}=t,a=contextStorage.getStore();if(a===void 0)return;let s;try{s=resolveScopedPrincipal(t,a),evictCachedToken(a,n,principalKey(s))}catch{return}try{await r.evict?.({connection:i,principal:s})}catch{}}async function completeScopedAuthorization(e){let{scope:r,authorization:i,connection:o}=e;if(!supportsInteractiveAuthorization(i))return!1;let s=consumeAuthorizationResult(r);if(s===void 0)return!1;let u=i,d=loadContext(),f=s.principal??resolveScopedPrincipal(e,d),p=await u.completeAuthorization({callbackUrl:s.hookUrl,connection:o,principal:f,resume:s.resume,callback:s.callback});return writeCachedToken(d,r,principalKey(f),p),!0}async function startScopedAuthorization(e){let{scope:t,authorization:n,connection:o}=e;if(!supportsInteractiveAuthorization(n))return;let s=createAuthorizationAttempt(t);if(s===void 0)return;let c=n,l=resolveScopedPrincipal(e),u=resolveAuthorizationCallbackUrl({authorization:n,callbackUrl:s.hookUrl}),{challenge:d,resume:f}=await c.startAuthorization({callbackUrl:u,connection:o,principal:l});return requestAuthorization([{attemptId:s.attemptId,challenge:stampChallengeDisplayName(d,n),hookUrl:u,name:t,principal:l,resume:f}])}function resolveScopedPrincipal(e,t){return e.boundResponder===void 0?resolveConnectionPrincipal(e.scope,e.authorization,t):resolveConnectionPrincipalFromAuth(e.scope,e.authorization,e.boundResponder,t)}function resolveAuthorizationCallbackUrl(e){if(e.authorization.vercelConnect===void 0)return e.callbackUrl;let t;try{t=new URL(e.callbackUrl)}catch{return e.callbackUrl}return t.protocol!==`http:`||!LOCAL_HTTP_VERCEL_CONNECT_HOSTNAMES.has(t.hostname)?e.callbackUrl:(t.hostname=`localhost`,t.toString())}function stampChallengeDisplayName(e,t){let n=t.displayName??e.displayName;return n===e.displayName?e:{...e,displayName:n}}export{completeScopedAuthorization,evictScopedToken,resolveAuthorizationCallbackUrl,resolveScopedToken,stampChallengeDisplayName,startScopedAuthorization};

package/dist/src/runtime/connections/types.d.ts

@@ -20,10 +20,15 @@ import type { ResolvedConnectionDefinition } from "#runtime/types.js";
  * `expiresAt` is an optional absolute expiration in **milliseconds since
  * the Unix epoch** ({@link Date.now}). Advisory: the runtime may refresh a
  * cached token before the next call based on it, but is not required to.
+ *
+ * `providerSubject` is the stable subject of the provider account represented
+ * by this credential. It is scoped to the provider and must not be compared
+ * across providers without provider context.
  */
 export interface TokenResult {
     readonly token: string;
     readonly expiresAt?: number;
+    readonly providerSubject?: string;
 }
 /**
  * Wire protocol a connection speaks.

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

@@ -1 +1 @@
-import{ResolveAgentError,createResolvedModuleSourceRef}from"#runtime/resolve-helpers.js";import{resolveDynamicToolDefinition}from"#runtime/resolve-dynamic-tool.js";import{resolveChannelDefinition}from"#runtime/resolve-channel.js";import{resolveConnectionDefinition}from"#runtime/resolve-connection.js";import{resolveHookDefinition}from"#runtime/resolve-hook.js";import{resolveSandboxDefinition}from"#runtime/resolve-sandbox.js";import{resolveDynamicInstructionsDefinition}from"#runtime/resolve-dynamic-instructions.js";import{resolveDynamicSkillDefinition}from"#runtime/resolve-dynamic-skill.js";import{resolveToolDefinition}from"#runtime/resolve-tool.js";async function resolveAgent(e){let t=e.manifest.skills.map(e=>({...e,metadata:e.metadata===void 0?void 0:{...e.metadata}})),i=[],a=[];for(let t of e.manifest.channels){if(t.kind===`disabled`){a.push(t.name);continue}i.push(await resolveChannelDefinition(t,e.moduleMap,e.nodeId))}let o=await Promise.all(e.manifest.tools.map(t=>resolveToolDefinition(t,e.moduleMap,e.nodeId))),s=await Promise.all((e.manifest.dynamicInstructions??[]).map(t=>resolveDynamicInstructionsDefinition(t,e.moduleMap,e.nodeId))),c=await Promise.all((e.manifest.dynamicSkills??[]).map(t=>resolveDynamicSkillDefinition(t,e.moduleMap,e.nodeId))),l=await Promise.all(e.manifest.dynamicTools.map(t=>resolveDynamicToolDefinition(t,e.moduleMap,e.nodeId))),u=await Promise.all(e.manifest.hooks.map(t=>resolveHookDefinition(t,e.moduleMap,e.nodeId))),d=await Promise.all(e.manifest.connections.map(t=>resolveConnectionDefinition(t,e.moduleMap,e.nodeId))),f=e.manifest.sandbox===null?null:await resolveSandboxDefinition(e.manifest.sandbox,e.moduleMap,e.nodeId),p=createResolvedInstructionsDefinition(e.manifest.instructions),m=e.manifest.workspaceResourceRoot,h={channels:i,connections:d,disabledFrameworkChannels:a,disabledFrameworkTools:[...e.manifest.disabledFrameworkTools],workflowTool:e.manifest.workflowTool===void 0?void 0:{maxSubagents:e.manifest.workflowTool.maxSubagents},webSearchProvider:e.manifest.webSearchProvider,dynamicInstructionsResolvers:s,dynamicSkillResolvers:c,dynamicToolResolvers:l,hooks:u,metadata:{agentRoot:e.manifest.agentRoot,appRoot:e.manifest.appRoot,diagnosticsSummary:e.manifest.diagnosticsSummary},sandbox:f,workspaceResourceRoot:m,skills:t,tools:o,workspaceSpec:{rootEntries:[...m.rootEntries]}},g=p===void 0?h:{...h,instructions:p};return`config`in e.manifest?{...g,config:createResolvedAgentConfig(e.manifest)}:g}function createResolvedInstructionsDefinition(e){if(e!==void 0)return{name:e.name,logicalPath:e.logicalPath,markdown:e.markdown,sourceId:e.sourceId,sourceKind:e.sourceKind}}function createResolvedAgentConfig(e){let n={name:e.config.name};if(e.config.compaction!==void 0){let t={};e.config.compaction.model!==void 0&&(t.model=e.config.compaction.model.source===void 0?{contextWindowTokens:e.config.compaction.model.contextWindowTokens,id:e.config.compaction.model.id,maxOutputTokens:e.config.compaction.model.maxOutputTokens,providerOptions:e.config.compaction.model.providerOptions}:{contextWindowTokens:e.config.compaction.model.contextWindowTokens,id:e.config.compaction.model.id,maxOutputTokens:e.config.compaction.model.maxOutputTokens,providerOptions:e.config.compaction.model.providerOptions,source:{exportName:e.config.compaction.model.source.exportName,sourceKind:`module`,logicalPath:e.config.compaction.model.source.logicalPath,sourceId:e.config.compaction.model.source.sourceId}}),e.config.compaction.thresholdPercent!==void 0&&(t.thresholdPercent=e.config.compaction.thresholdPercent),n.compaction=t}if(e.config.experimental!==void 0&&(n.experimental={subagentPersistentSessions:e.config.experimental.subagentPersistentSessions,workflow:e.config.experimental.workflow===void 0?void 0:{world:e.config.experimental.workflow.world}}),e.config.outputSchema!==void 0&&(n.outputSchema=e.config.outputSchema),e.config.reasoning!==void 0&&(n.reasoning=e.config.reasoning),e.config.source!==void 0&&(n.source=createResolvedModuleSourceRef(e.config.source)),e.config.limits!==void 0&&(n.limits={maxInputTokensPerSession:e.config.limits.maxInputTokensPerSession,maxOutputTokensPerSession:e.config.limits.maxOutputTokensPerSession,sessionTimeoutMs:e.config.limits.sessionTimeoutMs}),e.config.dynamicModel!==void 0)return{...n,dynamicModel:{...createResolvedModuleSourceRef(e.config.dynamicModel),eventNames:[...e.config.dynamicModel.eventNames]}};let r=e.config.model;return{...n,model:r.source===void 0?{id:r.id,contextWindowTokens:r.contextWindowTokens,maxOutputTokens:r.maxOutputTokens,providerOptions:r.providerOptions}:{contextWindowTokens:r.contextWindowTokens,id:r.id,maxOutputTokens:r.maxOutputTokens,providerOptions:r.providerOptions,source:{exportName:r.source.exportName,sourceKind:`module`,logicalPath:r.source.logicalPath,sourceId:r.source.sourceId}}}}export{ResolveAgentError,resolveAgent};
+import{ResolveAgentError,createResolvedModuleSourceRef}from"#runtime/resolve-helpers.js";import{resolveDynamicToolDefinition}from"#runtime/resolve-dynamic-tool.js";import{resolveChannelDefinition}from"#runtime/resolve-channel.js";import{resolveConnectionDefinition}from"#runtime/resolve-connection.js";import{resolveHookDefinition}from"#runtime/resolve-hook.js";import{resolveSandboxDefinition}from"#runtime/resolve-sandbox.js";import{resolveDynamicInstructionsDefinition}from"#runtime/resolve-dynamic-instructions.js";import{resolveDynamicSkillDefinition}from"#runtime/resolve-dynamic-skill.js";import{resolveToolDefinition}from"#runtime/resolve-tool.js";async function resolveAgent(e){let t=e.manifest.skills.map(e=>({...e,metadata:e.metadata===void 0?void 0:{...e.metadata}})),i=[],a=[];for(let t of e.manifest.channels){if(t.kind===`disabled`){a.push(t.name);continue}i.push(await resolveChannelDefinition(t,e.moduleMap,e.nodeId))}let o=await Promise.all(e.manifest.tools.map(t=>resolveToolDefinition(t,e.moduleMap,e.nodeId))),s=await Promise.all((e.manifest.dynamicInstructions??[]).map(t=>resolveDynamicInstructionsDefinition(t,e.moduleMap,e.nodeId))),c=await Promise.all((e.manifest.dynamicSkills??[]).map(t=>resolveDynamicSkillDefinition(t,e.moduleMap,e.nodeId))),l=await Promise.all(e.manifest.dynamicTools.map(t=>resolveDynamicToolDefinition(t,e.moduleMap,e.nodeId))),u=await Promise.all(e.manifest.hooks.map(t=>resolveHookDefinition(t,e.moduleMap,e.nodeId))),d=await Promise.all(e.manifest.connections.map(t=>resolveConnectionDefinition(t,e.moduleMap,e.nodeId))),f=e.manifest.sandbox===null?null:await resolveSandboxDefinition(e.manifest.sandbox,e.moduleMap,e.nodeId),p=createResolvedInstructionsDefinition(e.manifest.instructions),m=e.manifest.workspaceResourceRoot,h={channels:i,connections:d,disabledFrameworkChannels:a,disabledFrameworkTools:[...e.manifest.disabledFrameworkTools],workflowTool:e.manifest.workflowTool===void 0?void 0:{maxSubagents:e.manifest.workflowTool.maxSubagents},webSearchProvider:e.manifest.webSearchProvider,dynamicInstructionsResolvers:s,dynamicSkillResolvers:c,dynamicToolResolvers:l,hooks:u,metadata:{agentRoot:e.manifest.agentRoot,appRoot:e.manifest.appRoot,diagnosticsSummary:e.manifest.diagnosticsSummary},sandbox:f,workspaceResourceRoot:m,skills:t,tools:o,workspaceSpec:{rootEntries:[...m.rootEntries]}},g=p===void 0?h:{...h,instructions:p};return`config`in e.manifest?{...g,config:createResolvedAgentConfig(e.manifest)}:g}function createResolvedInstructionsDefinition(e){if(e!==void 0)return{name:e.name,logicalPath:e.logicalPath,markdown:e.markdown,sourceId:e.sourceId,sourceKind:e.sourceKind}}function createResolvedAgentConfig(e){let n={name:e.config.name};if(e.config.compaction!==void 0){let t={};e.config.compaction.model!==void 0&&(t.model=e.config.compaction.model.source===void 0?{contextWindowTokens:e.config.compaction.model.contextWindowTokens,id:e.config.compaction.model.id,maxOutputTokens:e.config.compaction.model.maxOutputTokens,providerOptions:e.config.compaction.model.providerOptions}:{contextWindowTokens:e.config.compaction.model.contextWindowTokens,id:e.config.compaction.model.id,maxOutputTokens:e.config.compaction.model.maxOutputTokens,providerOptions:e.config.compaction.model.providerOptions,source:{exportName:e.config.compaction.model.source.exportName,sourceKind:`module`,logicalPath:e.config.compaction.model.source.logicalPath,sourceId:e.config.compaction.model.source.sourceId}}),e.config.compaction.thresholdPercent!==void 0&&(t.thresholdPercent=e.config.compaction.thresholdPercent),n.compaction=t}if(e.config.experimental!==void 0&&(n.experimental={instrumentationProviders:e.config.experimental.instrumentationProviders,subagentPersistentSessions:e.config.experimental.subagentPersistentSessions,workflow:e.config.experimental.workflow===void 0?void 0:{world:e.config.experimental.workflow.world}}),e.config.outputSchema!==void 0&&(n.outputSchema=e.config.outputSchema),e.config.reasoning!==void 0&&(n.reasoning=e.config.reasoning),e.config.source!==void 0&&(n.source=createResolvedModuleSourceRef(e.config.source)),e.config.limits!==void 0&&(n.limits={maxInputTokensPerSession:e.config.limits.maxInputTokensPerSession,maxOutputTokensPerSession:e.config.limits.maxOutputTokensPerSession,sessionTimeoutMs:e.config.limits.sessionTimeoutMs}),e.config.dynamicModel!==void 0)return{...n,dynamicModel:{...createResolvedModuleSourceRef(e.config.dynamicModel),eventNames:[...e.config.dynamicModel.eventNames]}};let r=e.config.model;return{...n,model:r.source===void 0?{id:r.id,contextWindowTokens:r.contextWindowTokens,maxOutputTokens:r.maxOutputTokens,providerOptions:r.providerOptions}:{contextWindowTokens:r.contextWindowTokens,id:r.id,maxOutputTokens:r.maxOutputTokens,providerOptions:r.providerOptions,source:{exportName:r.source.exportName,sourceKind:`module`,logicalPath:r.source.logicalPath,sourceId:r.source.sourceId}}}}export{ResolveAgentError,resolveAgent};

package/dist/src/runtime/resolve-tool.js

@@ -1 +1 @@
-import{expectFunction,expectObjectRecord}from"#internal/authored-module.js";import{toErrorMessage}from"#shared/errors.js";import{isToolSchema,toInputSchema,toOutputSchema}from"#shared/tool-schema.js";import{ResolveAgentError,loadResolvedModuleExport}from"#runtime/resolve-helpers.js";import{registerDefinitionSource,stampDefinitionKey}from"#public/tool-result-narrowing.js";async function resolveToolDefinition(a,o,s){try{let n=expectObjectRecord(await loadResolvedModuleExport({definition:a,kindLabel:`tool`,moduleMap:o,nodeId:s}),describe(a,`to return an object`)),i={kind:`tool`,logicalPath:a.logicalPath,name:a.name},c=`tool-source:${a.sourceId}`;stampDefinitionKey(n,c),registerDefinitionSource(c,i),registerDefinitionSource(`tool:${n.description}`,i);let l=expectFunction(n.execute,describe(a,`to provide an execute function`)),u=isToolSchema(n.inputSchema)?n.inputSchema:toInputSchema(a.inputSchema),d=isToolSchema(n.outputSchema)?n.outputSchema:toOutputSchema(a.outputSchema);return{description:a.description,execute:l,exportName:a.exportName,inputSchema:u,logicalPath:a.logicalPath,name:a.name,outputSchema:d,sourceId:a.sourceId,sourceKind:`module`,...extractOptionalHooks(n,a)}}catch(e){throw e instanceof ResolveAgentError?e:new ResolveAgentError(`Failed to attach the tool execute function from "${a.logicalPath}": ${toErrorMessage(e)}`,{logicalPath:a.logicalPath,sourceId:a.sourceId})}}function extractOptionalHooks(t,n){let r={};return t.approval!==void 0&&(r.approval=expectFunction(t.approval,describe(n,`to provide an approval function`))),t.toModelOutput!==void 0&&(r.toModelOutput=expectFunction(t.toModelOutput,describe(n,`to provide a toModelOutput function`))),r}function describe(e,t){return`Expected the tool export "${e.exportName??`default`}" from "${e.logicalPath}" ${t}.`}export{resolveToolDefinition};
+import{expectFunction,expectObjectRecord}from"#internal/authored-module.js";import{toErrorMessage}from"#shared/errors.js";import{isToolSchema,toInputSchema,toOutputSchema}from"#shared/tool-schema.js";import{normalizeApproval}from"#internal/authored-definition/approval.js";import{ResolveAgentError,loadResolvedModuleExport}from"#runtime/resolve-helpers.js";import{registerDefinitionSource,stampDefinitionKey}from"#public/tool-result-narrowing.js";async function resolveToolDefinition(i,o,s){try{let n=expectObjectRecord(await loadResolvedModuleExport({definition:i,kindLabel:`tool`,moduleMap:o,nodeId:s}),describe(i,`to return an object`)),a={kind:`tool`,logicalPath:i.logicalPath,name:i.name},c=`tool-source:${i.sourceId}`;stampDefinitionKey(n,c),registerDefinitionSource(c,a),registerDefinitionSource(`tool:${n.description}`,a);let l=expectFunction(n.execute,describe(i,`to provide an execute function`)),u=isToolSchema(n.inputSchema)?n.inputSchema:toInputSchema(i.inputSchema),d=isToolSchema(n.outputSchema)?n.outputSchema:toOutputSchema(i.outputSchema);return{description:i.description,execute:l,exportName:i.exportName,inputSchema:u,logicalPath:i.logicalPath,name:i.name,outputSchema:d,sourceId:i.sourceId,sourceKind:`module`,...extractOptionalHooks(n,i)}}catch(e){throw e instanceof ResolveAgentError?e:new ResolveAgentError(`Failed to attach the tool execute function from "${i.logicalPath}": ${toErrorMessage(e)}`,{logicalPath:i.logicalPath,sourceId:i.sourceId})}}function extractOptionalHooks(t,n){let r={};return t.approval!==void 0&&(r.approval=normalizeApproval(t.approval,describe(n,`to provide a valid approval definition`))),t.toModelOutput!==void 0&&(r.toModelOutput=expectFunction(t.toModelOutput,describe(n,`to provide a toModelOutput function`))),r}function describe(e,t){return`Expected the tool export "${e.exportName??`default`}" from "${e.logicalPath}" ${t}.`}export{resolveToolDefinition};

package/dist/src/setup/index.d.ts

@@ -10,5 +10,6 @@ export { detectDeployment, detectProjectResolution, projectProductionUrlFromReso
 export { runVercelEnvPull } from "./run-vercel-link.js";
 export { provisionSlackbot, reconcileSlackUid, type ProvisionSlackbotResult } from "./slackbot.js";
 export { runRemoteAuthFlow } from "../cli/dev/tui/remote-auth.js";
+export { inspectVerifiedRemoteAgent, type InspectVerifiedRemoteAgentDeps, type VerifiedRemoteAgentInspection, } from "./verified-remote-agent.js";
 export { setupConnectionConnector, type SetupConnectionConnectorOptions, type SetupConnectionConnectorResult, } from "./connection-connector.js";
 export { linkProject, requireAuth, resolveProjectByNameOrId, resolveTeam, } from "./vercel-project.js";

package/dist/src/setup/index.js

@@ -1 +1 @@
-import{runRemoteAuthFlow}from"../cli/dev/tui/remote-auth.js";import{InteractionRequired}from"./ask-signals.js";import"./ask.js";import{runVercel}from"./primitives/run-vercel.js";import{detectDeployment,detectProjectResolution,projectProductionUrlFromResolution}from"./project-resolution.js";import{runVercelEnvPull}from"./run-vercel-link.js";import{createDefaultSetupState,requireProjectPath,snapshotSetupState}from"./state.js";import{getPackageManagerStrategy}from"./primitives/pm/index.js";import{linkProject,requireAuth,resolveProjectByNameOrId,resolveTeam}from"./vercel-project.js";import{createPromptCommandOutput}from"./cli/command-output.js";import"./cli/index.js";import{setupConnectionConnector}from"./connection-connector.js";import{WizardCancelledError}from"./step.js";import{runHeadless,runInteractive}from"./runner.js";import{HeadlessPromptError,createHeadlessPrompter,formatHeadlessEvent}from"./headless.js";import{createPrompter}from"./prompter.js";import{runPackageManagerInstall,runPnpmInstall,spawnPackageManager,spawnPnpm}from"./primitives/pm/run.js";import"./primitives/index.js";import{provisionSlackbot,reconcileSlackUid}from"./slackbot.js";export{HeadlessPromptError,InteractionRequired,WizardCancelledError,createDefaultSetupState,createHeadlessPrompter,createPromptCommandOutput,createPrompter,detectDeployment,detectProjectResolution,formatHeadlessEvent,getPackageManagerStrategy,linkProject,projectProductionUrlFromResolution,provisionSlackbot,reconcileSlackUid,requireAuth,requireProjectPath,resolveProjectByNameOrId,resolveTeam,runHeadless,runInteractive,runPackageManagerInstall,runPnpmInstall,runRemoteAuthFlow,runVercel,runVercelEnvPull,setupConnectionConnector,snapshotSetupState,spawnPackageManager,spawnPnpm};
+import{runRemoteAuthFlow}from"../cli/dev/tui/remote-auth.js";import{InteractionRequired}from"./ask-signals.js";import"./ask.js";import{runVercel}from"./primitives/run-vercel.js";import{detectDeployment,detectProjectResolution,projectProductionUrlFromResolution}from"./project-resolution.js";import{runVercelEnvPull}from"./run-vercel-link.js";import{createDefaultSetupState,requireProjectPath,snapshotSetupState}from"./state.js";import{getPackageManagerStrategy}from"./primitives/pm/index.js";import{linkProject,requireAuth,resolveProjectByNameOrId,resolveTeam}from"./vercel-project.js";import{createPromptCommandOutput}from"./cli/command-output.js";import"./cli/index.js";import{setupConnectionConnector}from"./connection-connector.js";import{WizardCancelledError}from"./step.js";import{runHeadless,runInteractive}from"./runner.js";import{HeadlessPromptError,createHeadlessPrompter,formatHeadlessEvent}from"./headless.js";import{createPrompter}from"./prompter.js";import{runPackageManagerInstall,runPnpmInstall,spawnPackageManager,spawnPnpm}from"./primitives/pm/run.js";import"./primitives/index.js";import{provisionSlackbot,reconcileSlackUid}from"./slackbot.js";import{inspectVerifiedRemoteAgent}from"./verified-remote-agent.js";export{HeadlessPromptError,InteractionRequired,WizardCancelledError,createDefaultSetupState,createHeadlessPrompter,createPromptCommandOutput,createPrompter,detectDeployment,detectProjectResolution,formatHeadlessEvent,getPackageManagerStrategy,inspectVerifiedRemoteAgent,linkProject,projectProductionUrlFromResolution,provisionSlackbot,reconcileSlackUid,requireAuth,requireProjectPath,resolveProjectByNameOrId,resolveTeam,runHeadless,runInteractive,runPackageManagerInstall,runPnpmInstall,runRemoteAuthFlow,runVercel,runVercelEnvPull,setupConnectionConnector,snapshotSetupState,spawnPackageManager,spawnPnpm};