eve 0.44.4 → 0.45.1

package/dist/src/public/connections/errors.d.ts

@@ -1,125 +1 @@
-/**
- * Typed error classes for the connection authorization lifecycle.
- */
-/**
- * User-facing authorization challenge payload.
- */
-export interface ConnectionAuthorizationChallenge {
-    /**
-     * Optional URL the user should visit to complete authorization.
-     * Serves as the redirect target, the verification URL in device
-     * code flow, or the source for a QR code.
-     */
-    readonly url?: string;
-    /**
-     * Optional short code to display alongside `url` (device code flow).
-     */
-    readonly userCode?: string;
-    /**
-     * Optional ISO timestamp at which the authorization opportunity
-     * expires. When provided, the runtime clamps the authorization deadline to
-     * `min(configured_timeout, expiresAt)` so the turn cannot outlive
-     * the challenge.
-     */
-    readonly expiresAt?: string;
-    /**
-     * Optional human-readable call to action. When no `url` is
-     * available (e.g. CIBA, push-to-approve), this is what the channel
-     * should show as the primary affordance.
-     */
-    readonly instructions?: string;
-    /**
-     * Optional human-readable provider name for sign-in UI (e.g.
-     * `"Salesforce"`). Presentation-only: identity (the authorization
-     * scope, token cache keys, callback URLs) stays the path-derived
-     * name. Channels fall back to title-casing the scope name when
-     * absent.
-     */
-    readonly displayName?: string;
-}
-/**
- * Options accepted by {@link ConnectionAuthorizationRequiredError}.
- */
-export interface ConnectionAuthorizationRequiredErrorOptions {
-    /**
-     * Override for the default `Error.message`. Defaults to
-     * `Connection "{name}" requires authorization.` when omitted.
-     */
-    readonly message?: string;
-}
-/**
- * Options accepted by {@link ConnectionAuthorizationFailedError}.
- */
-export interface ConnectionAuthorizationFailedErrorOptions {
-    /**
-     * Override for the default `Error.message`. Defaults to
-     * `Connection "{name}" authorization failed.` when omitted.
-     */
-    readonly message?: string;
-    /**
-     * Stable machine-readable code describing why authorization failed.
-     *
-     * The runtime surfaces this code on the `authorization.completed`
-     * stream event and on the failed tool result the model sees. Use a
-     * short kebab- or snake-cased string (e.g. `"access_denied"`,
-     * `"invalid_grant"`).
-     *
-     * The runtime also emits a few reason codes itself, independently
-     * of authored throws:
-     *
-     * - `"principal_required"`: a `principalType: "user"` connection
-     *   was invoked without an authenticated user principal. Terminal.
-     * - `"app_not_installed"`: an authored `getToken` for a
-     *   `principalType: "app"` connection signalled the agent's own
-     *   credentials are missing. Terminal.
-     */
-    readonly reason?: string;
-    /**
-     * Controls whether the runtime re-prompts the user after this
-     * failure.
-     *
-     * Defaults to `true`; set `false` for terminal cases such as user
-     * denial (`reason: "access_denied"`).
-     */
-    readonly retryable?: boolean;
-}
-/**
- * Thrown from a connection's `getToken` when no valid credential is
- * available and authorization must be completed before the connection
- * can be used. Covers both interactive OAuth (the runtime emits
- * `authorization.required` and suspends the turn on a webhook) and
- * non-interactive / out-of-band flows such as static API keys (the
- * runtime emits `authorization.required` without suspending).
- */
-export declare class ConnectionAuthorizationRequiredError extends Error {
-    readonly connectionName: string;
-    constructor(connectionName: string, options?: ConnectionAuthorizationRequiredErrorOptions);
-}
-/**
- * Thrown when a connection's authorization fails.
- *
- * Retryable by default; pass `retryable: false` for terminal failures
- * where starting a fresh authorization flow would be wrong.
- */
-export declare class ConnectionAuthorizationFailedError extends Error {
-    readonly connectionName: string;
-    readonly reason?: string;
-    readonly retryable: boolean;
-    constructor(connectionName: string, options?: ConnectionAuthorizationFailedErrorOptions);
-}
-/**
- * Type guard for {@link ConnectionAuthorizationRequiredError}.
- *
- * Uses `err.name` rather than `instanceof` because user code and
- * framework internals can end up with different class identities
- * after bundling (dual-instance hazard in Nitro output).
- */
-export declare function isConnectionAuthorizationRequiredError(err: unknown): err is ConnectionAuthorizationRequiredError;
-/**
- * Type guard for {@link ConnectionAuthorizationFailedError}.
- *
- * Uses `err.name` rather than `instanceof` because user code and
- * framework internals can end up with different class identities
- * after bundling (dual-instance hazard in Nitro output).
- */
-export declare function isConnectionAuthorizationFailedError(err: unknown): err is ConnectionAuthorizationFailedError;
+export { ConnectionAuthorizationFailedError, ConnectionAuthorizationRequiredError, isConnectionAuthorizationFailedError, isConnectionAuthorizationRequiredError, type ConnectionAuthorizationChallenge, type ConnectionAuthorizationFailedErrorOptions, type ConnectionAuthorizationRequiredErrorOptions, } from "#connections/errors.js";

package/dist/src/public/connections/errors.js

@@ -1 +1 @@
-var ConnectionAuthorizationRequiredError=class extends Error{connectionName;constructor(e,t){super(t?.message??`Connection "${e}" requires authorization.`),this.name=`ConnectionAuthorizationRequiredError`,this.connectionName=e}},ConnectionAuthorizationFailedError=class extends Error{connectionName;reason;retryable;constructor(e,t){super(t?.message??`Connection "${e}" authorization failed.`),this.name=`ConnectionAuthorizationFailedError`,this.connectionName=e,this.reason=t?.reason,this.retryable=t?.retryable??!0}};function isConnectionAuthorizationRequiredError(e){return e instanceof Error&&e.name===`ConnectionAuthorizationRequiredError`}function isConnectionAuthorizationFailedError(e){return e instanceof Error&&e.name===`ConnectionAuthorizationFailedError`}export{ConnectionAuthorizationFailedError,ConnectionAuthorizationRequiredError,isConnectionAuthorizationFailedError,isConnectionAuthorizationRequiredError};
+import{ConnectionAuthorizationFailedError,ConnectionAuthorizationRequiredError,isConnectionAuthorizationFailedError,isConnectionAuthorizationRequiredError}from"#connections/errors.js";export{ConnectionAuthorizationFailedError,ConnectionAuthorizationRequiredError,isConnectionAuthorizationFailedError,isConnectionAuthorizationRequiredError};

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

@@ -1,8 +1,8 @@
 /**
  * Connection authoring helpers for `agent/connections/*.ts` files.
  */
-export type { AuthorizationCallback, AuthorizationDefinition, ConnectionAuthDefinition, ConnectionAuthProvider, ConnectionAuthResolver, ConnectionPrincipal, HeadersDefinition, InteractiveAuthorizationDefinition, NonInteractiveAuthorizationDefinition, TokenResult, ToolFilterDefinition, } from "#runtime/connections/types.js";
-export { defineInteractiveAuthorization } from "#runtime/connections/types.js";
+export type { AuthorizationCallback, AuthorizationDefinition, ConnectionAuthDefinition, ConnectionAuthProvider, ConnectionAuthResolver, ConnectionPrincipal, HeadersDefinition, InteractiveAuthorizationDefinition, NonInteractiveAuthorizationDefinition, TokenResult, ToolFilterDefinition, } from "#shared/connection-types.js";
+export { defineInteractiveAuthorization } from "#shared/connection-types.js";
 export type { JsonValue } from "#public/types/json.js";
 export { defineMcpClientConnection, type McpClientConnectionDefinition, } from "#public/definitions/connections/mcp.js";
 export type { ConnectionToolCallDefinition, ProvidedArgumentContext, ProvidedArgumentsDefinition, ProvidedArgumentValue, } from "#public/definitions/connections/tool-call.js";

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

@@ -1 +1 @@
-import{ConnectionAuthorizationFailedError,ConnectionAuthorizationRequiredError,isConnectionAuthorizationFailedError,isConnectionAuthorizationRequiredError}from"#public/connections/errors.js";import{defineInteractiveAuthorization}from"#runtime/connections/types.js";import{defineMcpClientConnection}from"#public/definitions/connections/mcp.js";import{defineOpenAPIConnection}from"#public/definitions/connections/openapi.js";export{ConnectionAuthorizationFailedError,ConnectionAuthorizationRequiredError,defineInteractiveAuthorization,defineMcpClientConnection,defineOpenAPIConnection,isConnectionAuthorizationFailedError,isConnectionAuthorizationRequiredError};
+import{defineInteractiveAuthorization}from"#shared/connection-types.js";import{defineMcpClientConnection}from"#public/definitions/connections/mcp.js";import{defineOpenAPIConnection}from"#public/definitions/connections/openapi.js";import{ConnectionAuthorizationFailedError,ConnectionAuthorizationRequiredError,isConnectionAuthorizationFailedError,isConnectionAuthorizationRequiredError}from"#public/connections/errors.js";export{ConnectionAuthorizationFailedError,ConnectionAuthorizationRequiredError,defineInteractiveAuthorization,defineMcpClientConnection,defineOpenAPIConnection,isConnectionAuthorizationFailedError,isConnectionAuthorizationRequiredError};

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

@@ -1,7 +1,7 @@
 import type { AgentBuildDefinition, PublicAgentDefinition, PublicAgentStaticModelDefinition } from "#shared/agent-definition.js";
 import type { ExactDefinition } from "#public/definitions/exact.js";
 import type { RemoteAgentDefinition } from "#public/definitions/remote-agent.js";
-import type { DynamicEvents, DynamicSentinel } from "#shared/dynamic-tool-definition.js";
+import type { DynamicEvents, DynamicSentinel } from "#dynamic/definition.js";
 declare const DEFINED_AGENT: unique symbol;
 export type { AgentModelResolveContext, AgentModelOptionsDefinition, AgentModelResolver, AgentReasoningDefinition, AgentBuildDefinition, PublicAgentDynamicModelDefinition as AgentDynamicModelDefinition, PublicAgentDynamicModelResult as AgentDynamicModelResult, AgentExperimentalDefinition, AgentLimitsDefinition, PublicAgentModelSelectionDefinition as AgentModelSelectionDefinition, AgentWorkflowDefinition, AgentWorkflowWorldDefinition, PublicAgentModelDefinition as AgentModelDefinition, PublicAgentStaticModelDefinition as AgentStaticModelDefinition, PublicAgentCompactionDefinition as AgentCompactionDefinition, } from "#shared/agent-definition.js";
 /**

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

@@ -1 +1 @@
-import{defineDynamic as defineDynamic$1}from"#public/definitions/tool.js";const defineDynamic=(t=>{let n=defineDynamic$1({events:t.events});return t.build===void 0?n:{...n,build:t.build}});function defineAgent(e){return e}export{defineAgent,defineDynamic};
+import{defineDynamic as defineDynamic$1}from"#dynamic/definition.js";const defineDynamic=(t=>{let n=defineDynamic$1({events:t.events});return t.build===void 0?n:{...n,build:t.build}});function defineAgent(e){return e}export{defineAgent,defineDynamic};

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

@@ -1,84 +1,2 @@
-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 ApprovalPolicy} function.
- *
- * Extends {@link SessionContext} so approval policies can make decisions from
- * the active session, current caller, and turn.
- */
-export interface ApprovalContext<TInput = Record<string, unknown>> extends SessionContext {
-    readonly approvedTools: ReadonlySet<string>;
-    readonly callId: string;
-    readonly toolInput?: ApprovalToolInput<TInput>;
-    readonly toolName: string;
-}
-/** 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;
-} | {
-    readonly type: "approved";
-    readonly reason?: string;
-} | {
-    readonly type: "denied";
-    readonly reason?: string;
-} | {
-    readonly type: "user-approval";
-    readonly reason?: never;
-};
-/** 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 {};
+export type { Approval, ApprovalConfiguration, ApprovalContext, ApprovalPolicy, ApprovalRequest, ApprovalResponse, ApprovalResponseAuth, ApprovalResponseContext, ApprovalResponseDecision, ApprovalResponsePolicy, ApprovalResponseSession, ApprovalStatus, } from "#approval/definition.js";
+export { resolveApprovalPolicy } from "#approval/definition.js";

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

@@ -1 +1 @@
-function resolveApprovalPolicy(e){return typeof e==`function`?e:e.request}export{resolveApprovalPolicy};
+import{resolveApprovalPolicy}from"#approval/definition.js";export{resolveApprovalPolicy};

package/dist/src/public/definitions/callback-context.d.ts

@@ -1,32 +1 @@
-import type { SkillHandle } from "#execution/skills/types.js";
-import type { RuntimeSandboxSession } from "#shared/sandbox-session.js";
-import type { SessionAuth, SessionParent, SessionTurn } from "#context/keys.js";
-export type { SessionAuth, SessionParent, SessionTurn };
-/**
- * Shared runtime context available to all authored callbacks that run
- * inside the ALS-scoped harness step (tools, hooks, channel events).
- *
- * Non-ALS callbacks (schedule `run`, sandbox `bootstrap`/`onSession`,
- * instrumentation `setup`) do not receive this context. They get
- * domain-specific arguments instead.
- */
-export interface SessionContext {
-    /**
-     * Active session metadata for the callback's exact durable session.
-     */
-    readonly session: {
-        readonly id: string;
-        readonly auth: SessionAuth;
-        readonly turn: SessionTurn;
-        readonly parent?: SessionParent;
-    };
-    /**
-     * Resolves the session's sandbox. Throws when no sandbox is available
-     * in the current authored runtime context.
-     */
-    getSandbox(): Promise<RuntimeSandboxSession>;
-    /**
-     * Returns a {@link SkillHandle} for the named authored skill.
-     */
-    getSkill(identifier: string): SkillHandle;
-}
+export type { SessionAuth, SessionContext, SessionParent, SessionTurn, } from "#context/session-context.js";

package/dist/src/public/definitions/connections/mcp.d.ts

@@ -1,4 +1,4 @@
-import type { ConnectionAuthDefinition, HeadersDefinition, ToolFilterDefinition } from "#runtime/connections/types.js";
+import type { ConnectionAuthDefinition, HeadersDefinition, ToolFilterDefinition } from "#shared/connection-types.js";
 import type { ConnectionToolCallDefinition } from "#public/definitions/connections/tool-call.js";
 import type { Approval } from "#public/definitions/approval.js";
 /**

package/dist/src/public/definitions/connections/mcp.js

@@ -1 +1 @@
-import{stampConnectionProtocol}from"#public/definitions/connections/protocol.js";import{normalizeAuthorizationSpec}from"#runtime/connections/validate-authorization.js";import{stampDefinitionKey}from"#public/tool-result-narrowing.js";function defineMcpClientConnection(e){return e.auth!==void 0&&typeof e.auth!=`function`&&(e.auth=normalizeAuthorizationSpec(e.auth,`defineMcpClientConnection:`)),stampDefinitionKey(e,`connection:${e.url}`),stampConnectionProtocol(e,`mcp`),e}export{defineMcpClientConnection};
+import{stampConnectionProtocol}from"#public/definitions/connections/protocol.js";import{stampDefinitionKey}from"#internal/authored-definition/source-identity.js";import{normalizeAuthorizationSpec}from"#shared/validate-authorization.js";function defineMcpClientConnection(e){return e.auth!==void 0&&typeof e.auth!=`function`&&(e.auth=normalizeAuthorizationSpec(e.auth,`defineMcpClientConnection:`)),stampDefinitionKey(e,`connection:${e.url}`),stampConnectionProtocol(e,`mcp`),e}export{defineMcpClientConnection};

package/dist/src/public/definitions/connections/openapi.d.ts

@@ -1,4 +1,4 @@
-import type { ConnectionAuthDefinition, HeadersDefinition, ToolFilterDefinition } from "#runtime/connections/types.js";
+import type { ConnectionAuthDefinition, HeadersDefinition, ToolFilterDefinition } from "#shared/connection-types.js";
 import type { Approval } from "#public/definitions/approval.js";
 import type { ConnectionToolCallDefinition } from "#public/definitions/connections/tool-call.js";
 /**

package/dist/src/public/definitions/connections/openapi.js

@@ -1 +1 @@
-import{stampConnectionProtocol}from"#public/definitions/connections/protocol.js";import{normalizeAuthorizationSpec}from"#runtime/connections/validate-authorization.js";import{stampDefinitionKey}from"#public/tool-result-narrowing.js";function defineOpenAPIConnection(e){return e.auth!==void 0&&typeof e.auth!=`function`&&(e.auth=normalizeAuthorizationSpec(e.auth,`defineOpenAPIConnection:`)),stampDefinitionKey(e,`connection:${e.baseUrl??(typeof e.spec==`string`?e.spec:e.description)}`),stampConnectionProtocol(e,`openapi`),e}export{defineOpenAPIConnection};
+import{stampConnectionProtocol}from"#public/definitions/connections/protocol.js";import{stampDefinitionKey}from"#internal/authored-definition/source-identity.js";import{normalizeAuthorizationSpec}from"#shared/validate-authorization.js";function defineOpenAPIConnection(e){return e.auth!==void 0&&typeof e.auth!=`function`&&(e.auth=normalizeAuthorizationSpec(e.auth,`defineOpenAPIConnection:`)),stampDefinitionKey(e,`connection:${e.baseUrl??(typeof e.spec==`string`?e.spec:e.description)}`),stampConnectionProtocol(e,`openapi`),e}export{defineOpenAPIConnection};

package/dist/src/public/definitions/connections/protocol.d.ts

@@ -1,4 +1,4 @@
-import type { ConnectionProtocol } from "#runtime/connections/types.js";
+import type { ConnectionProtocol } from "#shared/connection-types.js";
 /**
  * Stamps the wire protocol on a connection definition. Called by the
  * `define*` factory that produced it.

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

@@ -1,6 +1,6 @@
-import { type DynamicResolveContext, type DynamicSentinel } from "#shared/dynamic-tool-definition.js";
+import { type DynamicResolveContext, type DynamicSentinel } from "#dynamic/definition.js";
 import type { ExactDefinition } from "#public/definitions/exact.js";
-import type { PublicInstructionsDefinition } from "#shared/instructions-definition.js";
+import { type PublicInstructionsDefinition } from "#shared/instructions-definition.js";
 export type InstructionsDefinition = Readonly<PublicInstructionsDefinition>;
 /**
  * Defines instructions in TypeScript from a `{ content, role? }`

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

@@ -1 +1 @@
-import{DYNAMIC_SENTINEL_KIND,INSTRUCTIONS_BRAND}from"#shared/dynamic-tool-definition.js";import{stampDefinitionKey}from"#public/tool-result-narrowing.js";function defineInstructions(e){return Object.assign(e,{[INSTRUCTIONS_BRAND]:!0}),e}function defineDynamic(t){let n={kind:DYNAMIC_SENTINEL_KIND,events:t.events};return stampDefinitionKey(n,`dynamic-instructions:${Object.keys(t.events).join(`,`)}`),n}export{defineDynamic,defineInstructions};
+import{DYNAMIC_SENTINEL_KIND}from"#dynamic/definition.js";import{INSTRUCTIONS_BRAND}from"#shared/instructions-definition.js";import{stampDefinitionKey}from"#internal/authored-definition/source-identity.js";function defineInstructions(e){return Object.assign(e,{[INSTRUCTIONS_BRAND]:!0}),e}function defineDynamic(t){let n={kind:DYNAMIC_SENTINEL_KIND,events:t.events};return stampDefinitionKey(n,`dynamic-instructions:${Object.keys(t.events).join(`,`)}`),n}export{defineDynamic,defineInstructions};

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

@@ -1 +1 @@
-import{SKILL_BRAND}from"#shared/dynamic-tool-definition.js";function defineSkill(e){return Object.defineProperty(e,SKILL_BRAND,{value:!0}),e}export{defineSkill};
+import{SKILL_BRAND}from"#shared/skill-definition.js";function defineSkill(e){return Object.defineProperty(e,SKILL_BRAND,{value:!0}),e}export{defineSkill};

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

@@ -2,5 +2,5 @@
  * Core agent authoring helpers for `agent/agent.ts`.
  */
 export { type AgentCompactionDefinition, type AgentDefinition, type AgentExperimentalDefinition, type AgentLimitsDefinition, type AgentModelDefinition, type AgentModelOptionsDefinition, type AgentReasoningDefinition, type AgentStaticModelDefinition, type AgentWorkflowDefinition, type AgentWorkflowWorldDefinition, type DefinedAgent, type DynamicSubagentDefinition, type DynamicLocalSubagentDefinition, defineAgent, defineDynamic, } from "#public/definitions/agent.js";
-export type { DynamicResolveContext, DynamicSentinel } from "#shared/dynamic-tool-definition.js";
+export type { DynamicResolveContext, DynamicSentinel } from "#dynamic/definition.js";
 export { type RemoteAgentDefinition, type RemoteAgentDefinitionInput, type RemoteAgentUrl, defineRemoteAgent, } from "#public/definitions/remote-agent.js";

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

@@ -3,4 +3,4 @@
  * and `agent/instructions/*.ts` files.
  */
 export { defineDynamic, defineInstructions, type DynamicInstructionsEvents, type DynamicInstructionsResult, type InstructionsDefinition, } from "#public/definitions/instructions.js";
-export type { DynamicResolveContext, DynamicSentinel } from "#shared/dynamic-tool-definition.js";
+export type { DynamicResolveContext, DynamicSentinel } from "#dynamic/definition.js";

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

@@ -1,117 +1 @@
-/**
- * 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;
+export * from "#instrumentation/provider.js";

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

@@ -1 +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};
+export*from"#instrumentation/provider.js";export{};

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

@@ -0,0 +1,117 @@
+import type { ModelMessage } from "ai";
+import type { SessionAuth } from "#context/keys.js";
+import type { Approval } from "#public/definitions/approval.js";
+import type { SessionContext } from "#public/definitions/callback-context.js";
+import type { ExactDefinition } from "#public/definitions/exact.js";
+import type { DynamicResolveContext } from "#dynamic/definition.js";
+import { MEMORY_DEFINITION_BRAND } from "#shared/memory-definition.js";
+import type { ToolContext, ToolModelOutput } from "#tools/definition.js";
+export interface MemoryNamespaceContext {
+    readonly appRoot: string;
+    readonly node: string;
+    readonly slot: string;
+}
+export type MemoryNamespaceDefinition = string | null | ((context: MemoryNamespaceContext) => string | null | Promise<string | null>);
+export type MemoryScopeResolverResult = string | readonly string[] | null;
+export interface MemoryScopeContext {
+    readonly abortSignal: AbortSignal;
+    readonly session: {
+        readonly id: string;
+        readonly auth: SessionAuth;
+    };
+    readonly channel: {
+        readonly kind?: string;
+        readonly continuationToken?: string;
+        readonly metadata?: Readonly<Record<string, unknown>>;
+    };
+}
+export type MemoryScopeDefinition = string | null | ((context: MemoryScopeContext) => MemoryScopeResolverResult | Promise<MemoryScopeResolverResult>);
+export interface MemoryScope {
+    readonly key: string;
+    readonly namespace: string;
+    readonly value: string | readonly string[];
+}
+export interface MemoryRecallMessage {
+    readonly content: string;
+    readonly id?: string;
+}
+export type MemoryRecallResult = {
+    readonly messages: readonly MemoryRecallMessage[];
+} | null | undefined;
+export interface MemoryTurnContext {
+    readonly id: string;
+    readonly input: readonly ModelMessage[];
+    readonly sequence: number;
+}
+export interface MemoryOperationContext extends SessionContext {
+    readonly abortSignal: AbortSignal;
+    readonly messages: readonly ModelMessage[];
+    readonly operationId: string;
+    readonly memory: {
+        readonly scope: MemoryScope;
+        readonly slot: string;
+    };
+}
+export interface MemoryTurnStartedContext extends MemoryOperationContext {
+    readonly turn: MemoryTurnContext;
+}
+export interface MemoryCompactionCompletedContext extends MemoryOperationContext {
+    readonly turn: MemoryTurnContext | null;
+    readonly compaction: {
+        readonly modelId: string;
+    };
+}
+export interface MemoryCompactionRequestedContext extends MemoryOperationContext {
+    readonly turn: MemoryTurnContext | null;
+    readonly compaction: {
+        readonly modelId: string;
+        readonly usageInputTokens: number | null;
+    };
+}
+export interface MemoryTurnCompletedContext extends MemoryOperationContext {
+    readonly turn: MemoryTurnContext;
+}
+export type MemoryRecallHandler<TContext extends MemoryOperationContext> = (context: TContext) => MemoryRecallResult | Promise<MemoryRecallResult>;
+export type MemoryCaptureHandler<TContext extends MemoryOperationContext> = (context: TContext) => void | Promise<void>;
+export interface MemoryToolsContext extends DynamicResolveContext {
+    readonly memory: {
+        readonly scope: MemoryScope;
+        readonly slot: string;
+    };
+    readonly turn: MemoryTurnContext;
+}
+export interface MemoryToolDefinition {
+    readonly approval?: Approval<never>;
+    readonly description: string;
+    readonly execution?: never;
+    execute(input: never, context: ToolContext): unknown | Promise<unknown> | AsyncIterable<unknown>;
+    readonly inputSchema: unknown;
+    readonly outputSchema?: unknown;
+    readonly toModelOutput?: (output: never) => ToolModelOutput | Promise<ToolModelOutput>;
+}
+export type MemoryToolSet = Readonly<Record<string, MemoryToolDefinition>>;
+export interface MemoryProvider {
+    readonly recall: {
+        readonly "turn.started": MemoryRecallHandler<MemoryTurnStartedContext>;
+        readonly "compaction.completed"?: MemoryRecallHandler<MemoryCompactionCompletedContext>;
+    };
+    readonly capture?: {
+        readonly "compaction.requested"?: MemoryCaptureHandler<MemoryCompactionRequestedContext>;
+        readonly "turn.completed"?: MemoryCaptureHandler<MemoryTurnCompletedContext>;
+    };
+    readonly tools?: (context: MemoryToolsContext) => Promise<MemoryToolSet | null>;
+}
+export type MemoryVisibility = "scope" | "session";
+export interface MemoryDefinition {
+    readonly description?: string;
+    readonly namespace?: MemoryNamespaceDefinition;
+    readonly provider: MemoryProvider;
+    readonly scope: MemoryScopeDefinition;
+    readonly visibility?: MemoryVisibility;
+}
+export type DefinedMemory<T extends MemoryDefinition = MemoryDefinition> = T & {
+    readonly [MEMORY_DEFINITION_BRAND]: true;
+};
+export declare function defineMemoryProvider<const T extends MemoryProvider>(provider: ExactDefinition<T, MemoryProvider>): T;
+export declare function defineMemory<const T extends MemoryDefinition>(definition: ExactDefinition<T, MemoryDefinition>): DefinedMemory<T>;
+export declare function defaultNamespace(context: MemoryNamespaceContext): string;

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

@@ -0,0 +1 @@
+import{createHash}from"node:crypto";import{resolveVercelProjectIdFromEnvironment}from"#shared/vercel-project.js";import{MEMORY_DEFINITION_BRAND}from"#shared/memory-definition.js";function defineMemoryProvider(e){return e}function defineMemory(e){return Object.assign(e,{[MEMORY_DEFINITION_BRAND]:!0}),e}function defaultNamespace(t){let n=resolveVercelProjectIdFromEnvironment();if(n===void 0)return JSON.stringify([`eve-memory-default-namespace-v1`,`local`,createHash(`sha256`).update(t.appRoot).digest(`base64url`),t.node,t.slot]);let r=process.env.VERCEL_TARGET_ENV?.trim()||process.env.VERCEL_ENV?.trim()||`production`,i=r===`preview`?process.env.VERCEL_GIT_COMMIT_REF?.trim()||process.env.VERCEL_DEPLOYMENT_ID?.trim()||process.env.VERCEL_URL?.trim()||`unknown-preview`:null;return JSON.stringify([`eve-memory-default-namespace-v1`,`vercel`,n,r,i,t.node,t.slot])}export{defaultNamespace,defineMemory,defineMemoryProvider};

package/dist/src/public/memory/scope.d.ts

@@ -0,0 +1,2 @@
+import type { MemoryScopeContext } from "#public/memory/index.js";
+export declare function byPrincipal(context: MemoryScopeContext): string | null;

package/dist/src/public/memory/scope.js

@@ -0,0 +1 @@
+const DISABLED_PRINCIPAL_TYPES=new Set([`anonymous`,`runtime`]);function byPrincipal(e){let t=e.session.auth.current;return t===null||DISABLED_PRINCIPAL_TYPES.has(t.principalType)?null:t.principalType===`local-dev`?`local-dev`:JSON.stringify([t.principalType,t.authenticator,t.issuer??null,t.principalId])}export{byPrincipal};

package/dist/src/public/models/openai/chatgpt/auth.js

@@ -1 +1 @@
-import{isObject}from"#shared/guards.js";import{decodeJwt}from"#compiled/jose/index.js";function readCodexJwtExpirationMs(e){let t=parseCodexJwtClaims(e);if(!(t===void 0||typeof t.exp!=`number`))return t.exp*1e3}function extractCodexAccountIdFromToken(t){let n=parseCodexJwtClaims(t);if(n===void 0)return;let r=n[`https://api.openai.com/auth`],i=n.organizations;return readNonEmptyString$1(n.chatgpt_account_id)??readNonEmptyString$1(isObject(r)?r.chatgpt_account_id:void 0)??readNonEmptyString$1(Array.isArray(i)&&isObject(i[0])?i[0].id:void 0)}function extractCodexAccountLabelFromToken(t){let n=parseCodexJwtClaims(t);if(n===void 0)return;let r=n[`https://api.openai.com/auth`],i=readEmail(n.email)??readEmail(isObject(r)?r.email:void 0);if(i!==void 0)return i;let a=readNonEmptyString$1(n.sub);return a===void 0?void 0:readEmail(a.split(`|`).at(-1))}function readEmail(e){let t=readNonEmptyString$1(e);return t!==void 0&&/^[^@\s]+@[^@\s]+\.[^@\s]+$/u.test(t)?t:void 0}function readNonEmptyString$1(e){return typeof e==`string`&&e.trim()!==``?e:void 0}function parseCodexJwtClaims(e){if(e!==void 0)try{return decodeJwt(e)}catch{return}}export{extractCodexAccountIdFromToken,extractCodexAccountLabelFromToken,readCodexJwtExpirationMs};
+import{decodeJwt}from"#compiled/jose/index.js";import{isObject}from"#shared/guards.js";function readCodexJwtExpirationMs(e){let t=parseCodexJwtClaims(e);if(!(t===void 0||typeof t.exp!=`number`))return t.exp*1e3}function extractCodexAccountIdFromToken(e){let n=parseCodexJwtClaims(e);if(n===void 0)return;let r=n[`https://api.openai.com/auth`],i=n.organizations;return readNonEmptyString$1(n.chatgpt_account_id)??readNonEmptyString$1(isObject(r)?r.chatgpt_account_id:void 0)??readNonEmptyString$1(Array.isArray(i)&&isObject(i[0])?i[0].id:void 0)}function extractCodexAccountLabelFromToken(e){let n=parseCodexJwtClaims(e);if(n===void 0)return;let r=n[`https://api.openai.com/auth`],i=readEmail(n.email)??readEmail(isObject(r)?r.email:void 0);if(i!==void 0)return i;let a=readNonEmptyString$1(n.sub);return a===void 0?void 0:readEmail(a.split(`|`).at(-1))}function readEmail(e){let t=readNonEmptyString$1(e);return t!==void 0&&/^[^@\s]+@[^@\s]+\.[^@\s]+$/u.test(t)?t:void 0}function readNonEmptyString$1(e){return typeof e==`string`&&e.trim()!==``?e:void 0}function parseCodexJwtClaims(t){if(t!==void 0)try{return decodeJwt(t)}catch{return}}export{extractCodexAccountIdFromToken,extractCodexAccountLabelFromToken,readCodexJwtExpirationMs};