eve 0.73.0 → 0.74.0

package/dist/src/public/schedules/provider-types.d.ts

@@ -0,0 +1,16 @@
+import type { ScheduleOccurrence } from "#public/schedules/subscription.js";
+export interface ScheduleDelivery<TPayload = unknown> {
+    readonly payload: TPayload;
+    readonly occurrence: ScheduleOccurrence;
+}
+export interface ScheduleDeliveryTarget {
+    readonly key: string;
+    readonly deliver?: (delivery: ScheduleDelivery<any>) => Promise<void>;
+}
+export interface ScheduleProviderContext {
+    readonly abortSignal: AbortSignal;
+    readonly collection: string;
+    readonly namespace: string;
+    readonly operationId: string;
+    readonly target: ScheduleDeliveryTarget;
+}

package/dist/src/public/schedules/provider-types.js

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

package/dist/src/public/schedules/providers/in-memory.d.ts

@@ -0,0 +1,5 @@
+import type { ScheduleProvider } from "#public/schedules/subscription.js";
+export interface InMemoryScheduleProviderOptions {
+    readonly now?: () => Date;
+}
+export declare function inMemoryScheduleProvider(options?: InMemoryScheduleProviderOptions): ScheduleProvider;

package/dist/src/public/schedules/providers/in-memory.js

@@ -0,0 +1 @@
+import{createHash,randomUUID}from"node:crypto";function inMemoryScheduleProvider(e={}){let t=new Map,n=new Map,r=new Map,i=new Set,a=new Set,o=e.now??(()=>new Date);return{kind:`in-memory`,async create(e,a){return withOperationResult(n,e.operationId,()=>{let n=scheduleKey(e,a.name);if(t.has(n))throw Error(`Schedule ${JSON.stringify(a.name)} already exists.`);let s=o().getTime(),c={createdAt:s,expression:normalizeExpression(a.expression),payload:a.payload,name:a.name,scheduleId:allocateScheduleId(e,a.name,r,i),state:a.expression.type===`single`&&Date.parse(a.expression.at)<=s?`completed`:a.state??`active`,target:e.target,updatedAt:s};return t.set(n,c),publicRecord(c)})},async list(e,n){let r=[...t.entries()].filter(([t])=>t.startsWith(collectionPrefix(e))).map(([,e])=>publicRecord(e)).sort((e,t)=>e.name.localeCompare(t.name)),i=decodeCursor(n.cursor),a=normalizeLimit(n.limit),o=r.slice(i,i+a),s=i+o.length;return{cursor:s<r.length?String(s):null,data:o}},async get(e,n){let r=t.get(scheduleKey(e,n));return r===void 0?null:publicRecord(r)},async enable(e,r){return setState(t,n,e,r,`active`,o)},async disable(e,r){return setState(t,n,e,r,`inactive`,o)},async invoke(e,r){let i=n.get(e.operationId);if(i!==void 0){e.target.deliver!==void 0&&await e.target.deliver(i);return}let s=requireSchedule(t,scheduleKey(e,r),r);if(s.state===`completed`)throw Error(`Completed schedule ${JSON.stringify(r)} cannot be invoked.`);let c=o().toISOString(),l={payload:s.payload,occurrence:{executionId:allocateOccurrenceId(e.operationId,a),name:s.name,scheduleId:s.scheduleId,scheduledAt:c}};n.set(e.operationId,l),s.target.deliver!==void 0&&await s.target.deliver(l)},async delete(e,i){return withOperationResult(n,e.operationId,()=>{let n=scheduleKey(e,i),a=t.delete(n);return a&&r.delete(n),a})}}}async function setState(e,t,n,r,i,a){return withOperationResult(t,n.operationId,()=>{let t=scheduleKey(n,r),o={...requireSchedule(e,t,r),state:i,updatedAt:a().getTime()};return e.set(t,o),publicRecord(o)})}function requireSchedule(e,t,n){let r=e.get(t);if(r===void 0)throw Error(`Schedule ${JSON.stringify(n)} was not found.`);return r}function withOperationResult(e,t,n){if(e.has(t))return e.get(t);let r=n();return e.set(t,r),r}function allocateOccurrenceId(e,t){let n=`manual_${createHash(`sha256`).update(e).digest(`base64url`)}`,r=n,i=0;for(;t.has(r);)r=`${n}_${++i}`;return t.add(r),r}function normalizeExpression(e){if(e.type===`cron`){let t={type:`cron`,cron:e.cron.trim().replace(/\s+/gu,` `)};return e.timezone!==void 0&&(t.timezone=e.timezone),e.jitter!==void 0&&(t.jitter=e.jitter),t}let t={type:`single`,at:e.at};return e.timezone!==void 0&&(t.timezone=e.timezone),t}function publicRecord(e){return{createdAt:e.createdAt,expression:e.expression,name:e.name,scheduleId:e.scheduleId,state:e.state,updatedAt:e.updatedAt}}function collectionPrefix(e){return`${e.collection}\0${e.namespace}\0`}function scheduleKey(e,t){return`${collectionPrefix(e)}${t}`}function allocateScheduleId(e,t,n,r){let i=scheduleKey(e,t),a=n.get(i);if(a!==void 0)return a;let o;do o=`mem_${createHash(`sha256`).update(`${i}:${randomUUID()}`).digest(`hex`)}`;while(r.has(o));return n.set(i,o),r.add(o),o}function normalizeLimit(e){if(e===void 0)return 20;if(!Number.isSafeInteger(e)||e<1||e>100)throw Error(`Schedule list limit must be an integer from 1 through 100.`);return e}function decodeCursor(e){if(e===void 0)return 0;let t=Number(e);if(!Number.isSafeInteger(t)||t<0)throw Error(`Invalid schedule cursor.`);return t}export{inMemoryScheduleProvider};

package/dist/src/public/schedules/providers/vercel.d.ts

@@ -0,0 +1,10 @@
+import type { ScheduleProvider } from "#public/schedules/subscription.js";
+/** Client options of a Vercel provider, so delivery verification talks to the same endpoint. */
+export declare function readVercelScheduleClientOptions(provider: ScheduleProvider): VercelScheduleProviderOptions | undefined;
+export interface VercelScheduleProviderOptions {
+    /** Overrides the public Vercel Schedules endpoint. */
+    readonly baseUrl?: string;
+    readonly fetch?: typeof fetch;
+}
+/** Uses ambient OIDC on Vercel and process-local storage under `eve dev`. */
+export declare function vercelScheduleProvider(options?: VercelScheduleProviderOptions): ScheduleProvider;

package/dist/src/public/schedules/providers/vercel.js

@@ -0,0 +1 @@
+import{isEveDevEnvironment}from"#internal/application/dev-environment.js";import{deriveEveScheduleQueueTopic}from"#runtime/schedules/queue-namespace.js";import{inMemoryScheduleProvider}from"#public/schedules/providers/in-memory.js";const DEVELOPMENT_PROVIDER=inMemoryScheduleProvider(),CLIENT_OPTIONS=new WeakMap;function readVercelScheduleClientOptions(e){return CLIENT_OPTIONS.get(e)}function vercelScheduleProvider(e={}){if(isEveDevEnvironment())return DEVELOPMENT_PROVIDER;let client=t=>createClient(e,t),t={kind:`vercel`,async create(e,t){let n=await client(e.abortSignal),r=await n.create({expression:toVercelExpression(t.expression),jitter:t.expression.type===`cron`?t.expression.jitter:void 0,name:t.name,namespace:e.namespace,payload:createDispatchPayload(e,t.payload),target:{topic:deriveEveScheduleQueueTopic(e.target.key)},timezone:t.expression.timezone});if(t.state===`inactive`)try{r=await n.disable({name:t.name,namespace:e.namespace})}catch(e){throw Error(`Schedule ${JSON.stringify(t.name)} was created active, but disabling it failed; it may remain active.`,{cause:e})}return fromVercelSchedule(r)},async list(e,t){let n=t.cursor?.trim()||void 0,r={namespace:e.namespace};n!==void 0&&(r.cursor=n),t.limit!==void 0&&(r.limit=t.limit);let i=await(await client(e.abortSignal)).list(r);return{cursor:i.cursor,data:i.data.map(fromVercelSchedule)}},async get(e,t){let n=await getScheduleOrNull(await client(e.abortSignal),t,e.namespace);return n===null?null:fromVercelSchedule(n)},async enable(e,t){return fromVercelSchedule(await(await client(e.abortSignal)).enable({name:t,namespace:e.namespace}))},async disable(e,t){return fromVercelSchedule(await(await client(e.abortSignal)).disable({name:t,namespace:e.namespace}))},async invoke(e,t){await(await client(e.abortSignal)).invoke({name:t,namespace:e.namespace})},async delete(e,t){try{return await(await client(e.abortSignal)).delete({name:t,namespace:e.namespace}),!0}catch(e){if(isNotFoundError(e))return!1;throw e}}};return CLIENT_OPTIONS.set(t,e),t}async function createClient(e,t){assertSupportedVercelEnvironment();let{SchedulesClient:n}=await import(`#compiled/@vercel/schedules/index.js`);t.throwIfAborted();let r=e.fetch??fetch;return new n({...e,fetch:(e,n)=>r(e,{...n,signal:t})})}function createDispatchPayload(e,t){return{eve:{application:e.target.key,collection:e.collection,version:1},payload:t}}function toVercelExpression(e){return e.type===`cron`?{type:`cron`,cron:e.cron}:{type:`single`,at:e.at}}function fromVercelSchedule(e){let t;if(e.expression.type===`cron`){let n={type:`cron`,cron:e.expression.cron,timezone:e.timezone};e.jitter!==void 0&&(n.jitter=e.jitter),t=n}else t={type:`single`,at:e.expression.at,timezone:e.timezone};return{createdAt:e.createdAt,expression:t,name:e.name,scheduleId:e.scheduleId,state:e.state,updatedAt:e.updatedAt}}async function getScheduleOrNull(e,t,n){try{return await e.get({name:t,namespace:n})}catch(e){if(isNotFoundError(e))return null;throw e}}function isNotFoundError(e){return typeof e==`object`&&!!e&&Reflect.get(e,`name`)===`SchedulesApiError`&&Reflect.get(e,`status`)===404}function assertSupportedVercelEnvironment(){if(!process.env.VERCEL?.trim())throw Error(`vercelScheduleProvider() requires a Vercel production deployment or eve dev.`);if(process.env.VERCEL_ENV!==`production`)throw Error("Vercel Schedules currently supports production deployments only. Deploy with `vercel --prod`.")}export{readVercelScheduleClientOptions,vercelScheduleProvider};

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

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

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

@@ -0,0 +1 @@
+import{principalScope}from"#shared/principal-scope.js";function byPrincipal(e){return principalScope(e.session.auth)}export{byPrincipal};

package/dist/src/public/schedules/subscription.d.ts

@@ -0,0 +1,259 @@
+import type { StandardSchemaV1 } from "#compiled/@standard-schema/spec/index.js";
+import type { SessionSchedule } from "#context/session-schedule.js";
+import type { SessionAuth } from "#context/keys.js";
+import type { SessionAuthContext } from "#channel/types.js";
+import type { ScheduleHandlerArgs } from "#public/definitions/schedule.js";
+import type { ExactDefinition } from "#public/definitions/exact.js";
+import type { Approval, ApprovalContext, ApprovalStatus, ApprovalResponseContext, ApprovalResponseDecision } from "#approval/definition.js";
+import type { UserContent } from "ai";
+import type { ChannelReference } from "#channel/compiled-channel.js";
+import type { InferReceiveTarget } from "#channel/receive-target.js";
+import type { Session } from "#channel/session.js";
+import { SCHEDULE_COLLECTION_DEFINITION_BRAND } from "#shared/schedule-collection-definition.js";
+import type { ScheduleProviderContext } from "#runtime/schedules/provider-types.js";
+/** A provider namespace scope, represented by one key or a hierarchical key path. */
+export type ScheduleScopeValue = string | readonly string[];
+/** Return `null` to deny the current schedule operation. */
+export type ScheduleScopeResolverResult = ScheduleScopeValue | null;
+export type ScheduleOperation = "create" | "get" | "list" | "enable" | "disable" | "invoke" | "delete";
+/** Trusted caller context used to authorize each management operation. */
+export interface ScheduleScopeContext {
+    readonly abortSignal: AbortSignal;
+    readonly operation?: ScheduleOperation;
+    readonly name?: string;
+    readonly session: {
+        readonly id: string;
+        readonly auth: SessionAuth;
+        readonly schedule?: SessionSchedule;
+    };
+    readonly channel: {
+        readonly kind?: string;
+        readonly continuationToken?: string;
+        readonly metadata?: Readonly<Record<string, unknown>>;
+    };
+}
+/** Stable creator reference; never a snapshot of credentials or permissions. */
+export interface SchedulePrincipalReference {
+    readonly type: string;
+    readonly authenticator: string;
+    readonly issuer?: string;
+    readonly principalId: string;
+    readonly subject?: string;
+}
+/** Framework-owned envelope stored alongside timing with the provider. */
+export interface ScheduleEnvelope<TPayload = unknown> {
+    readonly version: 3;
+    readonly payload: TPayload;
+    readonly scope: ScheduleScopeValue;
+    readonly principal: SchedulePrincipalReference;
+}
+export interface ScheduleOccurrenceIdentity {
+    /** Readable schedule label; name remains the unique management identifier. */
+    readonly displayName?: string;
+    readonly collection: string;
+    readonly scheduleId: string;
+    readonly name: string;
+    readonly executionId: string;
+    readonly scheduledAt: string;
+}
+/** Callback completion is distinct from completion of the agent sessions it starts. */
+export interface ScheduleOccurrenceEvent<TPayload = unknown> {
+    readonly type: "occurrence.dispatched" | "occurrence.failed";
+    readonly collection: string;
+    readonly executionId: string;
+    readonly name: string;
+    readonly scheduleId: string;
+    readonly scheduledAt: string;
+    readonly occurrence: ScheduleOccurrenceIdentity;
+    readonly sessionIds?: readonly string[];
+    readonly reason?: string;
+    readonly schedule?: ScheduleEnvelope<TPayload>;
+}
+export type ScheduleOccurrenceEventHandler<TPayload = unknown> = (event: ScheduleOccurrenceEvent<TPayload>) => void | Promise<void>;
+export type ScheduleExpression = {
+    readonly type: "cron";
+    readonly cron: string;
+    readonly timezone?: string;
+    readonly jitter?: number;
+} | {
+    readonly type: "single";
+    readonly at: string;
+    readonly timezone?: string;
+};
+/** Relative delays are resolved once at the client call boundary using eve's clock. */
+export type ScheduleTiming = ScheduleExpression | {
+    readonly type: "delay";
+    readonly minutes: number;
+};
+export type ScheduleState = "active" | "inactive" | "completed";
+/** Provider projection; payload and creator data are not read back. */
+export interface ScheduleRecord {
+    /** Human-readable label; multiple schedules may share it. */
+    readonly displayName?: string;
+    readonly createdAt: number;
+    readonly expression: ScheduleExpression;
+    readonly name: string;
+    readonly scheduleId: string;
+    readonly state: ScheduleState;
+    readonly updatedAt: number;
+}
+export interface SchedulePage {
+    readonly cursor: string | null;
+    readonly data: readonly ScheduleRecord[];
+}
+export interface ScheduleCreate<TPayload> {
+    readonly expression: ScheduleExpression;
+    readonly payload: TPayload;
+    readonly name: string;
+    readonly state?: ScheduleState;
+}
+export interface ScheduleList {
+    readonly cursor?: string;
+    readonly limit?: number;
+}
+export interface ScheduleOccurrence {
+    readonly executionId: string;
+    readonly name: string;
+    readonly scheduleId: string;
+    readonly scheduledAt: string;
+}
+/** Storage and occurrence transport supplied by a schedule backend. */
+export interface ScheduleProvider {
+    readonly kind: string;
+    create<TPayload>(context: ScheduleProviderContext, schedule: ScheduleCreate<TPayload>): Promise<ScheduleRecord>;
+    list(context: ScheduleProviderContext, query: ScheduleList): Promise<SchedulePage>;
+    get(context: ScheduleProviderContext, name: string): Promise<ScheduleRecord | null>;
+    enable(context: ScheduleProviderContext, name: string): Promise<ScheduleRecord>;
+    disable(context: ScheduleProviderContext, name: string): Promise<ScheduleRecord>;
+    invoke(context: ScheduleProviderContext, name: string): Promise<void>;
+    delete(context: ScheduleProviderContext, name: string): Promise<boolean>;
+}
+export interface ScheduleClientCreate<TPayload> {
+    readonly expression: ScheduleTiming;
+    /** Display label. Creation allocates a unique management name returned in the receipt. */
+    readonly name: string;
+    readonly payload: TPayload;
+}
+export interface SchedulePageResult {
+    readonly cursor: string | null;
+    readonly data: readonly ScheduleRecord[];
+}
+/** Authenticated client; payload and creator identity are immutable after creation. */
+export interface ScheduleClient<TPayload> {
+    create(input: ScheduleClientCreate<TPayload>): Promise<ScheduleRecord>;
+    delete(name: string): Promise<boolean>;
+    disable(name: string): Promise<ScheduleRecord>;
+    enable(name: string): Promise<ScheduleRecord>;
+    get(name: string): Promise<ScheduleRecord | null>;
+    invoke(name: string): Promise<void>;
+    list(input?: ScheduleList): Promise<SchedulePageResult>;
+}
+/** Starts fresh unattended work bound to the resolved creator; callers cannot choose another identity. */
+export type DynamicSchedulesToFn = <TChannel extends ChannelReference<unknown>>(channel: TChannel, target: InferReceiveTarget<TChannel>) => {
+    send(message: string | UserContent): Promise<Session>;
+};
+export type ScheduleCreateApproval<TPrepared> = ((context: ApprovalContext & {
+    readonly payload: TPrepared;
+}) => ApprovalStatus | Promise<ApprovalStatus>) | {
+    readonly request: (context: ApprovalContext & {
+        readonly payload: TPrepared;
+    }) => ApprovalStatus | Promise<ApprovalStatus>;
+    readonly response?: (context: ApprovalResponseContext & {
+        readonly payload: TPrepared;
+    }) => ApprovalResponseDecision | Promise<ApprovalResponseDecision>;
+};
+export type ScheduleApprovals<TPrepared> = Partial<Record<Exclude<ScheduleOperation, "create">, Approval>> & {
+    readonly create?: ScheduleCreateApproval<TPrepared>;
+};
+/** Execution context; `to` starts fresh, unattended sessions as the resolved creator. */
+export interface DynamicSchedulesRunArgs<TPayload> extends Pick<ScheduleHandlerArgs, "waitUntil"> {
+    readonly to: DynamicSchedulesToFn;
+    readonly payload: TPayload;
+    readonly occurrence: ScheduleOccurrenceIdentity;
+    readonly auth: SessionAuthContext;
+}
+/** Defines dynamically created schedules whose occurrences invoke authored code. */
+export interface DynamicSchedulesDefinition<TPayload = unknown, TSchema extends StandardSchemaV1<unknown, TPayload> = StandardSchemaV1<unknown, TPayload>, TPrepared = TPayload> {
+    readonly description?: string;
+    /** Model-facing payload schema. Destination intent may be resolved by `run`. */
+    readonly inputSchema: TSchema;
+    /** Resolved backend. defineDynamicSchedules defaults omitted providers to Vercel Schedules. */
+    readonly provider: ScheduleProvider;
+    /**
+     * Validates application policy and enriches a creation payload before the provider write.
+     * The caller constructs input; eve validates it with `inputSchema`, authorizes creation
+     * through `scope`, then calls `preparePayload` with trusted creation context. eve checks that the
+     * result is bounded JSON and persists it; `inputSchema` describes caller input, not stored prepared output.
+     * Throw an actionable error to reject creation without writing a schedule.
+     *
+     * A common use is capturing the current channel destination: derive channel/workspace
+     * references from verified caller context, replace any model-supplied references, and
+     * return them with the task. Keep captured fields out of the input schema.
+     * Channel-less or delegated callers may lack that context; reject those cases explicitly.
+     *
+     * Runs only on creation. Model calls invoke preparePayload before approval and again before
+     * writing; execution fails if the prepared result differs from the approved snapshot.
+     * Authenticated clients invoke preparePayload once before writing without model approval. Reads, enable/disable operations, and occurrence execution do not call it. Omission
+     * stores validated input unchanged. Creation retries may call it again, so avoid
+     * irreversible side effects; state changes never recapture a different destination.
+     * `auth`, `run`, and occurrence events receive the inferred return type. Declare `preparePayload`
+     * before those callbacks for contextual inference, or annotate its return type explicitly.
+     * Prepared application data is not revalidated against the input schema at execution;
+     * validate the application's persisted contract in authored code when necessary.
+     */
+    readonly preparePayload?: (payload: TPayload, context: ScheduleScopeContext & {
+        readonly operation: "create";
+        readonly name: string;
+    }) => TPrepared | Promise<TPrepared>;
+    /** Authorizes every management operation. Defaults to `byPrincipal`. */
+    readonly scope?: (context: ScheduleScopeContext & {
+        readonly operation: ScheduleOperation;
+    }) => ScheduleScopeResolverResult | Promise<ScheduleScopeResolverResult>;
+    /** Resolves the captured creator to current execution auth; return `null` to deny. */
+    readonly auth: (context: {
+        readonly principal: SchedulePrincipalReference;
+        readonly payload: NoInfer<TPrepared>;
+        readonly occurrence: ScheduleOccurrenceIdentity;
+    }) => SessionAuthContext | null | Promise<SessionAuthContext | null>;
+    /** May repeat on provider retries. Key external effects on the occurrence identity. */
+    readonly run: (args: DynamicSchedulesRunArgs<NoInfer<TPrepared>>) => void | Promise<void>;
+    readonly events?: {
+        /** After `run` and registered `waitUntil` work succeed; may repeat on retries. */
+        readonly "occurrence.dispatched"?: ScheduleOccurrenceEventHandler<NoInfer<TPrepared>>;
+        /** On a permanent provider failure or after its retry budget is exhausted. */
+        readonly "occurrence.failed"?: ScheduleOccurrenceEventHandler<NoInfer<TPrepared>>;
+    };
+    /** Expose operation tools directly (default true), or false for code-only scheduling. */
+    readonly tool?: boolean;
+    /** Model-call policies keyed by operation. Create receives the validated prepared payload. */
+    readonly approval?: ScheduleApprovals<NoInfer<TPrepared>>;
+}
+export type DefinedDynamicSchedules<TPayload = unknown, TSchema extends StandardSchemaV1<unknown, TPayload> = StandardSchemaV1<unknown, TPayload>, TPrepared = TPayload> = DynamicSchedulesDefinition<TPayload, TSchema, TPrepared> & {
+    readonly [SCHEDULE_COLLECTION_DEFINITION_BRAND]: true;
+};
+type DynamicSchedulesOptions<TInput, TSchema extends StandardSchemaV1<unknown, TInput>, TPrepared = TInput> = Omit<DynamicSchedulesDefinition<TInput, TSchema, TPrepared>, "provider" | "tool" | "approval"> & {
+    /** Defaults to vercelScheduleProvider(): hosted production scheduling, process-local storage in eve dev. */
+    readonly provider?: ScheduleProvider;
+} & ({
+    readonly tool: false;
+    readonly approval?: never;
+} | {
+    readonly tool?: true;
+    readonly approval?: ScheduleApprovals<NoInfer<TPrepared>>;
+});
+/**
+ * Defines a dynamic schedule subscription. Export it from `agent/schedules/`;
+ * identity comes from the module path. inputSchema validates caller input,
+ * while eve captures creator identity separately and re-resolves it on every attempt.
+ * `run` chooses destinations and starts work; no creation conversation is implicitly captured.
+ * Provider defaults to vercelScheduleProvider(); pass provider explicitly to select another backend.
+ * The default supports Vercel production and eve dev, not preview or self-hosted scheduling.
+ */
+export declare function defineDynamicSchedules<TInput, TPrepared>(definition: Omit<DynamicSchedulesOptions<TInput, StandardSchemaV1<unknown, TInput>, TPrepared>, "preparePayload"> & {
+    readonly preparePayload: (payload: TInput, context: ScheduleScopeContext & {
+        readonly operation: "create";
+        readonly name: string;
+    }) => TPrepared | Promise<TPrepared>;
+}): DefinedDynamicSchedules<TInput, StandardSchemaV1<unknown, TInput>, TPrepared>;
+export declare function defineDynamicSchedules<TSchema extends StandardSchemaV1<unknown, unknown>>(definition: ExactDefinition<DynamicSchedulesOptions<StandardSchemaV1.InferOutput<TSchema>, TSchema>, DynamicSchedulesOptions<StandardSchemaV1.InferOutput<TSchema>, TSchema>>): DefinedDynamicSchedules<StandardSchemaV1.InferOutput<TSchema>, TSchema>;
+export {};

package/dist/src/public/schedules/subscription.js

@@ -0,0 +1 @@
+import{SCHEDULE_COLLECTION_DEFINITION_BRAND}from"#shared/schedule-collection-definition.js";import{vercelScheduleProvider}from"#public/schedules/providers/vercel.js";function defineDynamicSchedules(e){return Object.assign(e,{provider:e.provider??vercelScheduleProvider(),tool:e.tool??!0,[SCHEDULE_COLLECTION_DEFINITION_BRAND]:!0}),e}export{defineDynamicSchedules};

package/dist/src/public/schedules/testing.d.ts

@@ -0,0 +1 @@
+export { inMemoryScheduleProvider, type InMemoryScheduleProviderOptions, } from "#public/schedules/providers/in-memory.js";

package/dist/src/public/schedules/testing.js

@@ -0,0 +1 @@
+import{inMemoryScheduleProvider}from"#public/schedules/providers/in-memory.js";export{inMemoryScheduleProvider};

package/dist/src/runtime/schedules/collection-client.d.ts

@@ -0,0 +1,20 @@
+import type { StandardSchemaV1 } from "#compiled/@standard-schema/spec/index.js";
+import type { SessionSchedule } from "#context/session-schedule.js";
+import type { ScheduleClient, ScheduleClientCreate, DynamicSchedulesDefinition, ScheduleEnvelope, ScheduleScopeContext } from "#public/schedules/subscription.js";
+export interface ScheduleBoundCallContext extends ScheduleScopeContext {
+    readonly application: string;
+    readonly collection: string;
+    readonly operationId?: () => string;
+}
+export interface PreparedScheduleCreate<TPrepared = unknown> {
+    readonly displayName: string;
+    readonly expression: import("#public/schedules/subscription.js").ScheduleTiming;
+    readonly envelope: ScheduleEnvelope<TPrepared>;
+}
+/** Internal capabilities used by generated create approval; authored clients expose only create. */
+export interface ScheduleCollectionClient<TInput, TPrepared> extends ScheduleClient<TInput> {
+    prepareCreate(input: ScheduleClientCreate<TInput>): Promise<PreparedScheduleCreate<TInput | TPrepared>>;
+    create(input: ScheduleClientCreate<TInput>, approved?: PreparedScheduleCreate): Promise<import("#public/schedules/subscription.js").ScheduleRecord>;
+}
+export declare function createScheduleCollectionClient<TPayload, TPrepared = TPayload>(definition: DynamicSchedulesDefinition<TPayload, StandardSchemaV1<unknown, TPayload>, TPrepared>, callContext: ScheduleBoundCallContext): ScheduleCollectionClient<TPayload, TPrepared>;
+export declare function assertScheduleManagementAllowed(schedule?: SessionSchedule): void;

package/dist/src/runtime/schedules/collection-client.js

@@ -0,0 +1 @@
+import{createHash,randomUUID}from"node:crypto";import{contextStorage,loadContext}from"#context/container.js";import{projectScheduleRecord}from"#runtime/schedules/record.js";import{createScheduleCollectionPayload,validateSchedulePayload}from"#runtime/schedules/payload.js";import{isDeepStrictEqual}from"node:util";import{readSessionSchedule}from"#context/session-schedule.js";import{BundleKey}from"#runtime/sessions/runtime-context-keys.js";import{resolveScheduleTiming,validateScheduleListLimit,validateScheduleName}from"#runtime/schedules/validation.js";import{dispatchScheduledOccurrence}from"#runtime/schedules/dispatch-occurrence.js";import{byPrincipal}from"#public/schedules/scope.js";function createScheduleCollectionClient(e,t){let n=t.operationId??randomUUID,contextFor=(e,n)=>{let r={...t,operation:e};return n!==void 0&&(r.name=n),r},resolveNamespace=async(r,i)=>{assertScheduleManagementAllowed(t.session.schedule);let a=contextFor(r,i),o=e.scope===void 0?byPrincipal(a):await e.scope({...a,operation:r});if(o===null)throw Error(`Schedule ${r} is not available in this context.`);return validateScope(o),{scope:o,provider:{abortSignal:t.abortSignal,collection:t.collection,namespace:deriveScheduleNamespace(t.application,t.collection,o),operationId:n(),target:{key:t.application,deliver:async({payload:n,occurrence:r})=>{await dispatchScheduledOccurrence({bundle:loadContext().require(BundleKey),collection:t.collection,definition:e,occurrence:{...r,collection:t.collection},payload:n})}}}}},prepareCreation=async n=>{let r=validateScheduleName(n.name);resolveScheduleTiming(n.expression);let{scope:i,provider:a}=await resolveNamespace(`create`,r),o=principalReference(t.session.auth.current);if(o===null)throw Error(`Creating a schedule requires an authenticated principal.`);let s=await validateSchedulePayload(e.inputSchema,n.payload),c={version:3,payload:e.preparePayload===void 0?s:await e.preparePayload(s,{...contextFor(`create`,r),operation:`create`,name:r}),scope:i,principal:o},l=createScheduleCollectionPayload({application:t.application,collection:t.collection,envelope:c}),u={displayName:r,expression:JSON.parse(JSON.stringify(n.expression)),envelope:l.envelope};if(Buffer.byteLength(JSON.stringify(u))>65536)throw Error(`Prepared schedule creation exceeds the 64 KB limit, including timing and payload.`);return{prepared:u,provider:a}};return{async prepareCreate(e){return(await prepareCreation(e)).prepared},async create(n,r){let{prepared:i,provider:a}=await prepareCreation(n);if(r!==void 0&&!isDeepStrictEqual(i,r))throw Error(`Schedule creation changed after approval. Request a new creation approval; no schedule was written.`);let o=`${i.displayName.slice(0,218)}--${randomUUID()}`,s=resolveScheduleTiming(n.expression),c=createScheduleCollectionPayload({application:t.application,collection:t.collection,envelope:i.envelope});return projectScheduleRecord(await e.provider.create(a,{expression:s,name:o,payload:c}))},async delete(t){let n=validateScheduleName(t),{provider:r}=await resolveNamespace(`delete`,n);return await e.provider.delete(r,n)},async disable(t){let n=validateScheduleName(t),{provider:r}=await resolveNamespace(`disable`,n);return projectScheduleRecord(await e.provider.disable(r,n))},async enable(t){let n=validateScheduleName(t),{provider:r}=await resolveNamespace(`enable`,n);return projectScheduleRecord(await e.provider.enable(r,n))},async get(t){let n=validateScheduleName(t),{provider:r}=await resolveNamespace(`get`,n),i=await e.provider.get(r,n);return i===null?null:projectScheduleRecord(i)},async invoke(t){let n=validateScheduleName(t),{provider:r}=await resolveNamespace(`invoke`,n);await e.provider.invoke(r,n)},async list(t={}){let n=validateScheduleListLimit(t.limit),{provider:r}=await resolveNamespace(`list`),i={};t.cursor?.trim()&&(i.cursor=t.cursor.trim()),n!==void 0&&(i.limit=n);let a=await e.provider.list(r,i);return{...a,data:a.data.map(projectScheduleRecord)}}}}function assertScheduleManagementAllowed(e){let t=contextStorage.getStore();if(e!==void 0||t!==void 0&&readSessionSchedule(t)!==void 0)throw Error(`Schedule management is unavailable during scheduled execution.`)}function principalReference(e){if(e===null||e.principalType===`anonymous`||e.principalType===`runtime`)return null;let t={type:e.principalType,authenticator:e.authenticator,principalId:e.principalId};return e.issuer!==void 0&&(t.issuer=e.issuer),e.subject!==void 0&&(t.subject=e.subject),t}function validateScope(e){let t=typeof e==`string`?[e]:e;if(t.length===0||t.some(e=>typeof e!=`string`||e.trim().length===0))throw Error(`Schedule scope must be a non-empty string or tuple of non-empty strings.`)}function deriveScheduleNamespace(e,t,n){if(e.trim().length===0)throw Error(`Schedule application must not be empty.`);return`eve-${createHash(`sha256`).update(JSON.stringify([`eve-schedule-namespace-v2`,e,t,n])).digest(`base64url`)}`}export{assertScheduleManagementAllowed,createScheduleCollectionClient};

package/dist/src/runtime/schedules/dispatch-occurrence.d.ts

@@ -0,0 +1,12 @@
+import type { DynamicSchedulesDefinition, ScheduleOccurrenceIdentity } from "#public/schedules/subscription.js";
+import type { ScheduleCollectionPayload } from "#runtime/schedules/payload.js";
+import type { CompiledRuntimeAgentBundle } from "#runtime/sessions/compiled-agent-cache.js";
+/** Dispatches an at-least-once callback and reports the sessions it started, if any. */
+export declare function dispatchScheduledOccurrence(input: {
+    readonly bundle: Pick<CompiledRuntimeAgentBundle, "compiledArtifactsSource" | "graph">;
+    readonly collection: string;
+    readonly definition: DynamicSchedulesDefinition<any, any, any>;
+    readonly occurrence: ScheduleOccurrenceIdentity;
+    readonly payload: ScheduleCollectionPayload<unknown>;
+    readonly verifyDelivery?: () => Promise<void>;
+}): Promise<void>;

package/dist/src/runtime/schedules/dispatch-occurrence.js

@@ -0,0 +1 @@
+import{scheduleDisplayName}from"#runtime/schedules/record.js";import{createWorkflowRuntime}from"#execution/workflow-runtime.js";import{ScheduleDispatcher}from"#channel/schedule.js";async function dispatchScheduledOccurrence(e){let t={...e.occurrence,displayName:scheduleDisplayName(e.occurrence.name)},n=await new ScheduleDispatcher({runtime:createWorkflowRuntime({compiledArtifactsSource:e.bundle.compiledArtifactsSource}),channels:e.bundle.graph.root.channels}).triggerCollection({collectionId:e.collection,definition:e.definition,occurrence:t,payload:e.payload,verifyDelivery:e.verifyDelivery});await e.definition.events?.[`occurrence.dispatched`]?.({collection:e.collection,executionId:e.occurrence.executionId,name:t.name,occurrence:t,scheduledAt:e.occurrence.scheduledAt,scheduleId:e.occurrence.scheduleId,sessionIds:n.sessions.map(e=>e.id),schedule:e.payload.envelope,type:`occurrence.dispatched`})}export{dispatchScheduledOccurrence};

package/dist/src/runtime/schedules/load-collection.d.ts

@@ -0,0 +1,14 @@
+import type { CompiledAgentManifest } from "#compiler/manifest.js";
+import type { DynamicSchedulesDefinition } from "#public/schedules/subscription.js";
+import type { CompiledRuntimeAgentBundle } from "#runtime/sessions/compiled-agent-cache.js";
+/** The agent does not deploy the named collection, or not with the expected provider. */
+export declare class ScheduleCollectionNotDeployedError extends Error {
+}
+/**
+ * Reloads a collection's authored definition inside a durable step or queue
+ * callback, where the closure that created the occurrence no longer exists.
+ */
+export declare function loadScheduleCollectionDefinition(bundle: Pick<CompiledRuntimeAgentBundle, "compiledArtifactsSource" | "moduleMap" | "nodeId">, collection: string, options?: {
+    readonly manifest?: CompiledAgentManifest;
+    readonly providerKind?: string;
+}): Promise<DynamicSchedulesDefinition<unknown>>;

package/dist/src/runtime/schedules/load-collection.js

@@ -0,0 +1 @@
+import{loadCompiledManifest}from"#runtime/loaders/manifest.js";import{normalizeScheduleCollectionDefinition}from"#internal/authored-definition/schedule-collection.js";import{loadResolvedModuleExport}from"#runtime/resolve-helpers.js";var ScheduleCollectionNotDeployedError=class extends Error{};async function loadScheduleCollectionDefinition(e,t,n={}){let r=(n.manifest??await loadCompiledManifest({compiledArtifactsSource:e.compiledArtifactsSource})).scheduleCollections.find(e=>e.name===t&&(n.providerKind===void 0||e.providerKind===n.providerKind));if(r===void 0)throw new ScheduleCollectionNotDeployedError(`Schedule collection "${t}" is not deployed by this agent.`);let i=await loadResolvedModuleExport({definition:r,kindLabel:`schedule collection`,moduleMap:e.moduleMap,nodeId:e.nodeId});return normalizeScheduleCollectionDefinition(i,`Invalid schedule collection ${t}.`)}export{ScheduleCollectionNotDeployedError,loadScheduleCollectionDefinition};

package/dist/src/runtime/schedules/payload.d.ts

@@ -0,0 +1,24 @@
+import type { ScheduleEnvelope } from "#public/schedules/subscription.js";
+export interface ScheduleCollectionPayload<TPayload = unknown> {
+    readonly eve: {
+        readonly application: string;
+        readonly collection: string;
+        readonly version: 3;
+    };
+    readonly envelope: ScheduleEnvelope<TPayload>;
+}
+export declare function createScheduleCollectionPayload<TPayload>(input: {
+    readonly application: string;
+    readonly collection: string;
+    readonly envelope: ScheduleEnvelope<TPayload>;
+}): ScheduleCollectionPayload<TPayload>;
+export declare function parseSchedulePayload<TPayload = unknown>(value: unknown, expected?: {
+    readonly application: string;
+    readonly collection: string;
+}): ScheduleCollectionPayload<TPayload>;
+/** Shared validation for client writes and delivered occurrences. */
+export declare function validateSchedulePayload<T>(schema: {
+    readonly "~standard": {
+        validate(value: unknown): unknown;
+    };
+}, value: unknown): Promise<T>;

package/dist/src/runtime/schedules/payload.js

@@ -0,0 +1 @@
+import{z}from"#compiled/zod/index.js";const referenceSchema=z.string().min(1).max(2048),principalReferenceSchema=z.object({type:referenceSchema,authenticator:referenceSchema,issuer:referenceSchema.optional(),principalId:referenceSchema,subject:referenceSchema.optional()}).strict(),payloadSchema=z.object({eve:z.object({application:referenceSchema,collection:referenceSchema,version:z.literal(3)}).strict(),envelope:z.object({version:z.literal(3),payload:z.json(),scope:z.union([z.string().min(1),z.array(z.string().min(1)).min(1)]),principal:principalReferenceSchema}).strict()}).strict();function createScheduleCollectionPayload(e){return parseSchedulePayload({eve:{application:e.application,collection:e.collection,version:3},envelope:e.envelope})}function parseSchedulePayload(e,t){let n;try{let t=JSON.stringify(e);if(t===void 0||Buffer.byteLength(t)>65536)throw Error();n=JSON.parse(t)}catch{throw Error(`Invalid scheduled collection payload; recreate the schedule.`)}let r=payloadSchema.safeParse(n);if(!r.success)throw Error(`Invalid scheduled collection payload; recreate the schedule.`);if(t!==void 0&&(r.data.eve.application!==t.application||r.data.eve.collection!==t.collection))throw Error(`Schedule identity changed; recreate the schedule.`);return r.data}async function validateSchedulePayload(e,t){let n=await e[`~standard`].validate(t);if(n.issues!==void 0||!(`value`in n))throw Error(`Invalid schedule payload: ${n.issues?.map(e=>e.message).join(`; `)??`schema validation failed`}.`);return n.value}export{createScheduleCollectionPayload,parseSchedulePayload,validateSchedulePayload};

package/dist/src/runtime/schedules/provider-types.d.ts

@@ -0,0 +1 @@
+export type { ScheduleDelivery, ScheduleDeliveryTarget, ScheduleProviderContext, } from "#public/schedules/provider-types.js";

package/dist/src/runtime/schedules/provider-types.js

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

package/dist/src/runtime/schedules/queue-namespace.d.ts

@@ -0,0 +1,2 @@
+/** Derives the private Vercel Queues topic used by one eve agent's schedule collections. */
+export declare function deriveEveScheduleQueueTopic(application: string): string;

package/dist/src/runtime/schedules/queue-namespace.js

@@ -0,0 +1 @@
+import{createHash}from"node:crypto";function deriveEveScheduleQueueTopic(e){let t=e.trim();if(t.length===0)throw Error(`Schedule application must not be empty.`);return`__eve_schedule_${createHash(`sha256`).update(t).digest(`hex`).slice(0,32)}`}export{deriveEveScheduleQueueTopic};

package/dist/src/runtime/schedules/record.d.ts

@@ -0,0 +1,4 @@
+import type { ScheduleRecord } from "#public/schedules/subscription.js";
+/** Provider names retain the readable label so get/list need no payload read-back. */
+export declare function scheduleDisplayName(name: string): string;
+export declare function projectScheduleRecord(record: ScheduleRecord): ScheduleRecord;

package/dist/src/runtime/schedules/record.js

@@ -0,0 +1 @@
+function scheduleDisplayName(e){return e.replace(/--[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/u,``)}function projectScheduleRecord(e){return{...e,displayName:scheduleDisplayName(e.name)}}export{projectScheduleRecord,scheduleDisplayName};

package/dist/src/runtime/schedules/validation.d.ts

@@ -0,0 +1,6 @@
+import type { ScheduleExpression, ScheduleTiming } from "#public/schedules/subscription.js";
+export declare function validateScheduleName(name: string): string;
+export declare const MAX_SCHEDULE_DELAY_MINUTES = 525600;
+export declare function resolveScheduleTiming(timing: ScheduleTiming, now?: number): ScheduleExpression;
+export declare function validateScheduleExpression(expression: ScheduleExpression): ScheduleExpression;
+export declare function validateScheduleListLimit(limit: number | undefined): number | undefined;

package/dist/src/runtime/schedules/validation.js

@@ -0,0 +1 @@
+const SCHEDULE_IDENTIFIER=/^[0-9A-Za-z][0-9A-Za-z._-]{0,255}$/u,LOCAL_DATE_TIME=/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(?::00)?$/u;function validateScheduleName(e){let t=e.trim();if(!SCHEDULE_IDENTIFIER.test(t))throw Error(`Schedule name must be 1–256 characters, start with an ASCII letter or digit, and contain only letters, digits, '.', '_', and '-'.`);return t}const MAX_SCHEDULE_DELAY_MINUTES=525600;function resolveScheduleTiming(e,t=Date.now()){if(e.type!==`delay`)return validateScheduleExpression(e);if(!Number.isSafeInteger(e.minutes)||e.minutes<1||e.minutes>525600)throw Error(`Schedule delay must be a whole number from 1 through ${MAX_SCHEDULE_DELAY_MINUTES} minutes.`);if(Object.keys(e).some(e=>e!==`type`&&e!==`minutes`))throw Error(`Relative schedule delays accept only type and minutes; no timezone is needed.`);return{type:`single`,at:new Date(Math.ceil((t+e.minutes*6e4)/6e4)*6e4).toISOString().slice(0,16),timezone:`UTC`}}function validateScheduleExpression(e){if(e.type===`cron`){let t=e.cron.trim().replace(/\s+/gu,` `);if(t.split(` `).length!==5)throw Error(`Schedule cron expressions must contain exactly five fields.`);let n={type:`cron`,cron:t};if(e.timezone!==void 0&&(n.timezone=validateTimezone(e.timezone)),e.jitter!==void 0){if(!Number.isSafeInteger(e.jitter)||e.jitter<1||e.jitter>15)throw Error(`Schedule jitter must be an integer from 1 through 15 minutes.`);n.jitter=e.jitter}return n}if(!LOCAL_DATE_TIME.test(e.at))throw Error(`One-time schedules require a minute-precision local datetime in "YYYY-MM-DDTHH:mm" or "YYYY-MM-DDTHH:mm:00" format without an offset or fractional seconds.`);let t={type:`single`,at:e.at};return e.timezone!==void 0&&(t.timezone=validateTimezone(e.timezone)),t}function validateScheduleListLimit(e){if(e!==void 0){if(!Number.isSafeInteger(e)||e<1||e>100)throw Error(`Schedule list limit must be an integer from 1 through 100.`);return e}}function validateTimezone(e){let t=e.trim();if(t.length===0||t.length>50)throw Error(`Schedule timezone must be a valid IANA timezone.`);try{new Intl.DateTimeFormat(`en-US`,{timeZone:t}).format(0)}catch{throw Error(`Invalid IANA timezone: ${t}`)}return t}export{MAX_SCHEDULE_DELAY_MINUTES,resolveScheduleTiming,validateScheduleExpression,validateScheduleListLimit,validateScheduleName};

package/dist/src/runtime/sessions/runtime-context-keys.js

@@ -1 +1 @@
-import{getAdapterKind}from"#channel/adapter.js";import{ContextKey}from"#context/key.js";import{CHANNEL_CONTEXT_KEY_NAME}from"#context/key-names.js";import{resolveDurableCompiledArtifactsSource,serializeDurableCompiledArtifactsSource}from"#runtime/durable-compiled-artifacts-source.js";import{getCompiledRuntimeAgentBundle}from"#runtime/sessions/compiled-agent-cache.js";import{deserializeRuntimeAdapter}from"#runtime/channels/registry.js";const ChannelKey=new ContextKey(CHANNEL_CONTEXT_KEY_NAME,{codec:{serialize(e){return{kind:getAdapterKind(e),state:e.state?{...e.state}:{}}},deserialize(e,t){let n=t.get(BundleKey);if(n===void 0)throw Error(`Cannot deserialize "eve.channel" before "eve.bundle". The runtime bundle must be present in context.`);return deserializeRuntimeAdapter(n.adapterRegistry,e)}}}),BundleKey=new ContextKey(`eve.bundle`,{codec:{serialize:e=>({nodeId:e.nodeId,source:serializeDurableCompiledArtifactsSource(e.compiledArtifactsSource)}),deserialize:e=>{let{source:t,nodeId:n}=e;return getCompiledRuntimeAgentBundle({compiledArtifactsSource:resolveDurableCompiledArtifactsSource(t),nodeId:n})}}});export{BundleKey,ChannelKey};
+import{getAdapterKind}from"#channel/adapter.js";import{ContextKey}from"#context/key.js";import{BUNDLE_CONTEXT_KEY_NAME,CHANNEL_CONTEXT_KEY_NAME}from"#context/key-names.js";import{resolveDurableCompiledArtifactsSource,serializeDurableCompiledArtifactsSource}from"#runtime/durable-compiled-artifacts-source.js";import{getCompiledRuntimeAgentBundle}from"#runtime/sessions/compiled-agent-cache.js";import{deserializeRuntimeAdapter}from"#runtime/channels/registry.js";const ChannelKey=new ContextKey(CHANNEL_CONTEXT_KEY_NAME,{codec:{serialize(e){return{kind:getAdapterKind(e),state:e.state?{...e.state}:{}}},deserialize(e,t){let n=t.get(BundleKey);if(n===void 0)throw Error(`Cannot deserialize "eve.channel" before "eve.bundle". The runtime bundle must be present in context.`);return deserializeRuntimeAdapter(n.adapterRegistry,e)}}}),BundleKey=new ContextKey(BUNDLE_CONTEXT_KEY_NAME,{codec:{serialize:e=>({nodeId:e.nodeId,source:serializeDurableCompiledArtifactsSource(e.compiledArtifactsSource)}),deserialize:e=>{let{source:t,nodeId:n}=e;return getCompiledRuntimeAgentBundle({compiledArtifactsSource:resolveDurableCompiledArtifactsSource(t),nodeId:n})}}});export{BundleKey,ChannelKey};

package/dist/src/setup/scaffold/create/project.js

@@ -1,4 +1,4 @@
-import{pinnedNodeEngineMajor}from"../../node-engine.js";import{parseChatGptModelSelection}from"../../../shared/chatgpt-model.js";import{SUPPORTED_AUTHORED_MODULE_FILE_EXTENSIONS}from"../update/module-files.js";import{pathExists,writeTextFile}from"../files.js";import{blockingCreateInPlaceEntries}from"../create-in-place.js";import{DEFAULT_CONNECT_PACKAGE_VERSION,resolveVersionToken}from"../version-tokens.js";import{applyPackageManagerWorkspaceConfiguration,isPackageManagerWorkspaceMember,patchWorkspaceRootPackageJson}from"../workspace-root.js";import{WEB_CHANNEL_TEMPLATES}from"./web-template.js";import{AGENT_INSTRUCTIONS_TEMPLATE}from"./instructions-template.js";import{SCAFFOLDED_AGENT_PATHS}from"./agent-paths.js";import{mkdir,readdir,stat}from"node:fs/promises";import{basename,join,resolve}from"node:path";const CURRENT_DIRECTORY_PROJECT_NAME=`.`,DEFAULT_AI_PACKAGE_VERSION=`^7.0.128`,DEFAULT_ZOD_PACKAGE_VERSION=`4.5.4`,DEFAULT_EVE_PACKAGE_CONTRACT={version:`0.73.0`,nodeEngine:`>=24`};function resolveEvePackageContract(e=DEFAULT_EVE_PACKAGE_CONTRACT){return{version:resolveVersionToken(`evePackage.version`,e.version),nodeEngine:resolveVersionToken(`evePackage.nodeEngine`,e.nodeEngine)}}function modelProviderSlug(e){let t=(e.split(`/`)[0]??``).replaceAll(/[^A-Za-z0-9._-]/gu,``);return t.length>0?t:`anthropic`}function byokProviderEnvVar(e){let t=modelProviderSlug(e).toUpperCase().replaceAll(/[^A-Z0-9]/gu,`_`);return`${/^[0-9]/.test(t)?`_`:``}${t}_API_KEY`}function agentTemplateFiles(e,t){return{[SCAFFOLDED_AGENT_PATHS.config]:renderAgentTemplate(e,t),[SCAFFOLDED_AGENT_PATHS.channel]:WEB_CHANNEL_TEMPLATES.default,[SCAFFOLDED_AGENT_PATHS.instructions]:AGENT_INSTRUCTIONS_TEMPLATE}}function renderAgentTemplate(e,t){let n=parseChatGptModelSelection(e);return n===void 0?BASE_AGENT_TEMPLATE.replaceAll(`__EVE_INIT_MODEL__`,e).replaceAll(`__EVE_INIT_REASONING__`,reasoningTemplateLine(t)):`import { defineAgent } from "eve";\nimport { chatgpt } from "eve/models/openai";\n\nexport default defineAgent({\n  model: chatgpt(${JSON.stringify(n)}),\n${reasoningTemplateLine(t)}});\n`}function reasoningTemplateLine(e){return e===void 0||e===`provider-default`?``:`  reasoning: "${e}",\n`}function renderTemplate(e,t){return e===BASE_AGENT_TEMPLATE&&parseChatGptModelSelection(t.model)!==void 0?renderAgentTemplate(t.model,t.reasoning):e.replaceAll(`__EVE_INIT_APP_NAME__`,t.appName).replaceAll(`__EVE_INIT_MODEL__`,t.model).replaceAll(`__EVE_INIT_REASONING__`,reasoningTemplateLine(t.reasoning)).replaceAll(`__EVE_INIT_BYOK_PROVIDER__`,modelProviderSlug(t.model)).replaceAll(`__EVE_INIT_BYOK_ENV_VAR__`,byokProviderEnvVar(t.model)).replaceAll(`__EVE_INIT_PACKAGE_VERSION__`,formatEveDependencySpecifier(t.eveVersion)).replaceAll(`__EVE_INIT_AI_SDK_VERSION__`,t.aiPackageVersion).replaceAll(`__EVE_INIT_CONNECT_VERSION__`,t.connectPackageVersion).replaceAll(`__EVE_INIT_ZOD_VERSION__`,t.zodPackageVersion).replaceAll(`__EVE_INIT_TYPESCRIPT_VERSION__`,t.typescriptPackageVersion).replaceAll(`__EVE_INIT_TYPES_NODE_VERSION__`,t.nodeTypesVersion).replaceAll(`__EVE_INIT_NODE_ENGINE__`,t.nodeEngine)}function formatEveDependencySpecifier(e){return/^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z-.]+)?$/.test(e)?`^${e}`:e}const BASE_AGENT_TEMPLATE=`import { defineAgent } from "eve";
+import{pinnedNodeEngineMajor}from"../../node-engine.js";import{parseChatGptModelSelection}from"../../../shared/chatgpt-model.js";import{SUPPORTED_AUTHORED_MODULE_FILE_EXTENSIONS}from"../update/module-files.js";import{pathExists,writeTextFile}from"../files.js";import{blockingCreateInPlaceEntries}from"../create-in-place.js";import{DEFAULT_CONNECT_PACKAGE_VERSION,resolveVersionToken}from"../version-tokens.js";import{applyPackageManagerWorkspaceConfiguration,isPackageManagerWorkspaceMember,patchWorkspaceRootPackageJson}from"../workspace-root.js";import{WEB_CHANNEL_TEMPLATES}from"./web-template.js";import{AGENT_INSTRUCTIONS_TEMPLATE}from"./instructions-template.js";import{SCAFFOLDED_AGENT_PATHS}from"./agent-paths.js";import{mkdir,readdir,stat}from"node:fs/promises";import{basename,join,resolve}from"node:path";const CURRENT_DIRECTORY_PROJECT_NAME=`.`,DEFAULT_AI_PACKAGE_VERSION=`^7.0.128`,DEFAULT_ZOD_PACKAGE_VERSION=`4.5.4`,DEFAULT_EVE_PACKAGE_CONTRACT={version:`0.74.0`,nodeEngine:`>=24`};function resolveEvePackageContract(e=DEFAULT_EVE_PACKAGE_CONTRACT){return{version:resolveVersionToken(`evePackage.version`,e.version),nodeEngine:resolveVersionToken(`evePackage.nodeEngine`,e.nodeEngine)}}function modelProviderSlug(e){let t=(e.split(`/`)[0]??``).replaceAll(/[^A-Za-z0-9._-]/gu,``);return t.length>0?t:`anthropic`}function byokProviderEnvVar(e){let t=modelProviderSlug(e).toUpperCase().replaceAll(/[^A-Z0-9]/gu,`_`);return`${/^[0-9]/.test(t)?`_`:``}${t}_API_KEY`}function agentTemplateFiles(e,t){return{[SCAFFOLDED_AGENT_PATHS.config]:renderAgentTemplate(e,t),[SCAFFOLDED_AGENT_PATHS.channel]:WEB_CHANNEL_TEMPLATES.default,[SCAFFOLDED_AGENT_PATHS.instructions]:AGENT_INSTRUCTIONS_TEMPLATE}}function renderAgentTemplate(e,t){let n=parseChatGptModelSelection(e);return n===void 0?BASE_AGENT_TEMPLATE.replaceAll(`__EVE_INIT_MODEL__`,e).replaceAll(`__EVE_INIT_REASONING__`,reasoningTemplateLine(t)):`import { defineAgent } from "eve";\nimport { chatgpt } from "eve/models/openai";\n\nexport default defineAgent({\n  model: chatgpt(${JSON.stringify(n)}),\n${reasoningTemplateLine(t)}});\n`}function reasoningTemplateLine(e){return e===void 0||e===`provider-default`?``:`  reasoning: "${e}",\n`}function renderTemplate(e,t){return e===BASE_AGENT_TEMPLATE&&parseChatGptModelSelection(t.model)!==void 0?renderAgentTemplate(t.model,t.reasoning):e.replaceAll(`__EVE_INIT_APP_NAME__`,t.appName).replaceAll(`__EVE_INIT_MODEL__`,t.model).replaceAll(`__EVE_INIT_REASONING__`,reasoningTemplateLine(t.reasoning)).replaceAll(`__EVE_INIT_BYOK_PROVIDER__`,modelProviderSlug(t.model)).replaceAll(`__EVE_INIT_BYOK_ENV_VAR__`,byokProviderEnvVar(t.model)).replaceAll(`__EVE_INIT_PACKAGE_VERSION__`,formatEveDependencySpecifier(t.eveVersion)).replaceAll(`__EVE_INIT_AI_SDK_VERSION__`,t.aiPackageVersion).replaceAll(`__EVE_INIT_CONNECT_VERSION__`,t.connectPackageVersion).replaceAll(`__EVE_INIT_ZOD_VERSION__`,t.zodPackageVersion).replaceAll(`__EVE_INIT_TYPESCRIPT_VERSION__`,t.typescriptPackageVersion).replaceAll(`__EVE_INIT_TYPES_NODE_VERSION__`,t.nodeTypesVersion).replaceAll(`__EVE_INIT_NODE_ENGINE__`,t.nodeEngine)}function formatEveDependencySpecifier(e){return/^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z-.]+)?$/.test(e)?`^${e}`:e}const BASE_AGENT_TEMPLATE=`import { defineAgent } from "eve";
 
 export default defineAgent({
   model: "__EVE_INIT_MODEL__",

package/dist/src/shared/principal-scope.d.ts

@@ -0,0 +1,2 @@
+import type { SessionAuth } from "#context/keys.js";
+export declare function principalScope(auth: SessionAuth): string | null;

package/dist/src/shared/principal-scope.js

@@ -0,0 +1 @@
+const DISABLED_PRINCIPAL_TYPES=new Set([`anonymous`,`runtime`]);function principalScope(e){let t=e.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{principalScope};

package/dist/src/shared/schedule-collection-definition.d.ts

@@ -0,0 +1,11 @@
+export declare const SCHEDULE_COLLECTION_DEFINITION_BRAND: unique symbol;
+export declare const SCHEDULE_COLLECTION_SOURCE: unique symbol;
+export interface ScheduleCollectionSourceIdentity {
+    readonly application: string;
+    readonly collection: string;
+    readonly logicalPath: string;
+    readonly sourceId: string;
+}
+export declare function stampScheduleCollectionSource(value: object, identity: ScheduleCollectionSourceIdentity): void;
+export declare function readScheduleCollectionSource(value: object): ScheduleCollectionSourceIdentity | undefined;
+export declare function isScheduleCollectionDefinition(value: unknown): boolean;

package/dist/src/shared/schedule-collection-definition.js

@@ -0,0 +1 @@
+const SCHEDULE_COLLECTION_DEFINITION_BRAND=Symbol.for(`eve:schedule-collection-definition`),SCHEDULE_COLLECTION_SOURCE=Symbol.for(`eve:schedule-collection-source`);function stampScheduleCollectionSource(e,t){let n=readScheduleCollectionSource(e);if(n!==void 0){if(n.application!==t.application||n.collection!==t.collection||n.logicalPath!==t.logicalPath||n.sourceId!==t.sourceId)throw Error(`Schedule collection source identity does not match its compiled module.`);return}Object.defineProperty(e,SCHEDULE_COLLECTION_SOURCE,{configurable:!1,enumerable:!1,value:Object.freeze({...t})})}function readScheduleCollectionSource(e){return Reflect.get(e,SCHEDULE_COLLECTION_SOURCE)}function isScheduleCollectionDefinition(e){return typeof e==`object`&&!!e&&Reflect.get(e,SCHEDULE_COLLECTION_DEFINITION_BRAND)===!0}export{SCHEDULE_COLLECTION_DEFINITION_BRAND,SCHEDULE_COLLECTION_SOURCE,isScheduleCollectionDefinition,readScheduleCollectionSource,stampScheduleCollectionSource};

package/dist/src/shared/schedule-collection-tools.d.ts

@@ -0,0 +1 @@
+export declare function scheduleCollectionToolPrefix(collection: string): string;

package/dist/src/shared/schedule-collection-tools.js

@@ -0,0 +1 @@
+function scheduleCollectionToolPrefix(e){return`schedule__${e.replaceAll(`/`,`-`)}`}export{scheduleCollectionToolPrefix};

package/dist/src/subagents/tool.d.ts

@@ -47,6 +47,7 @@ export declare function buildSubagentRunInput(input: {
      * parent capabilities produce an undefined child capability set.
      */
     readonly capabilities?: SessionCapabilities;
+    readonly schedule?: import("#context/session-schedule.js").SessionSchedule;
     readonly channelMetadata?: ChannelInstrumentationProjection;
     /** Replay-stable key the child's continuation token derives from. */
     readonly continuationKey: string;

package/dist/src/subagents/tool.js

@@ -1 +1 @@
-import{formatSubagentInput}from"#subagents/invocation.js";import{mintSubagentContinuationToken}from"#execution/session.js";import{SUBAGENT_ADAPTER_KIND}from"#subagents/adapter-state.js";function buildSubagentRunInput(e){let{action:t,auth:n,capabilities:r,channelMetadata:i,inheritedConversation:a,initiatorAuth:o,session:s,source:c}=e,l=mintSubagentContinuationToken(e.continuationKey),u={callId:t.callId,parentContinuationToken:e.parent.continuationToken??s.continuationToken,parentSessionId:s.sessionId,subagentName:t.subagentName};return(e.graph?.nodesByNodeId.get(t.nodeId)?.sandboxRegistry.sandbox?.definition.kind===`parent`||e.selfAgent)&&(s.sandboxState!==void 0&&(u.parentSandboxState=s.sandboxState),u.sandboxSessionId=e.sandboxSessionId??s.sessionId),{childContinuationToken:l,runInput:{adapter:{kind:SUBAGENT_ADAPTER_KIND,state:u},auth:n,capabilities:r,channelMetadata:i,inheritedConversation:a,continuationToken:l,initiatorAuth:o,input:{message:formatSubagentCallInputMessage({action:t,source:c}),outputSchema:t.input.outputSchema},limits:e.limits,conversationId:e.parent.conversationId,parent:e.parent.lineage,parentTraceContext:e.parent.traceContext,traceRoot:e.parent.traceRoot}}}function formatSubagentCallInputMessage(e){let{message:t}=e.action.input;switch(e.source.type){case`local`:return formatSubagentInput({description:e.source.description,message:t,name:e.action.subagentName,type:`local`}).message;case`runtime`:return formatSubagentInput({message:t,name:e.action.subagentName,type:`runtime`}).message;default:return e.source}}export{buildSubagentRunInput};
+import{formatSubagentInput}from"#subagents/invocation.js";import{mintSubagentContinuationToken}from"#execution/session.js";import{SUBAGENT_ADAPTER_KIND}from"#subagents/adapter-state.js";function buildSubagentRunInput(e){let{action:t,auth:n,capabilities:r,channelMetadata:i,inheritedConversation:a,initiatorAuth:o,session:s,source:c}=e,l=mintSubagentContinuationToken(e.continuationKey),u={callId:t.callId,parentContinuationToken:e.parent.continuationToken??s.continuationToken,parentSessionId:s.sessionId,subagentName:t.subagentName};return(e.graph?.nodesByNodeId.get(t.nodeId)?.sandboxRegistry.sandbox?.definition.kind===`parent`||e.selfAgent)&&(s.sandboxState!==void 0&&(u.parentSandboxState=s.sandboxState),u.sandboxSessionId=e.sandboxSessionId??s.sessionId),{childContinuationToken:l,runInput:{adapter:{kind:SUBAGENT_ADAPTER_KIND,state:u},auth:n,capabilities:r,schedule:e.schedule,channelMetadata:i,inheritedConversation:a,continuationToken:l,initiatorAuth:o,input:{message:formatSubagentCallInputMessage({action:t,source:c}),outputSchema:t.input.outputSchema},limits:e.limits,conversationId:e.parent.conversationId,parent:e.parent.lineage,parentTraceContext:e.parent.traceContext,traceRoot:e.parent.traceRoot}}}function formatSubagentCallInputMessage(e){let{message:t}=e.action.input;switch(e.source.type){case`local`:return formatSubagentInput({description:e.source.description,message:t,name:e.action.subagentName,type:`local`}).message;case`runtime`:return formatSubagentInput({message:t,name:e.action.subagentName,type:`runtime`}).message;default:return e.source}}export{buildSubagentRunInput};

package/dist/src/svelte/index.js

@@ -1,4 +1,4 @@
-import { a as conversationProjection, i as openConversationInputs, n as conversationReducer, o as callStatus, r as defaultMessageReducer, t as useEveAgent } from "../chunks/use-eve-agent-hZJ7CB8t.js";
+import { a as conversationProjection, i as openConversationInputs, n as conversationReducer, o as callStatus, r as defaultMessageReducer, t as useEveAgent } from "../chunks/use-eve-agent-mP0M7SrL.js";
 
 //#region src/client/tool-call-state.ts
 function toolCallState(conversation, callId, options = {}) {

package/dist/src/svelte/use-eve-agent.js

@@ -1,3 +1,3 @@
-import { t as useEveAgent } from "../chunks/use-eve-agent-hZJ7CB8t.js";
+import { t as useEveAgent } from "../chunks/use-eve-agent-mP0M7SrL.js";
 
 export { useEveAgent };

package/dist/src/tools/framework/agent.js

@@ -1 +1 @@
-import{frameworkTool}from"#tools/provided/framework-tool.js";import{AGENT_TOOL_DESCRIPTION,SUBAGENT_TOOL_INPUT_SCHEMA}from"#tools/framework/agent-contract.js";import{stampToolDefinition}from"#tools/definition.js";import{attachToolBehavior}from"#tools/behavior.js";const agent=attachToolBehavior(frameworkTool(stampToolDefinition({description:AGENT_TOOL_DESCRIPTION,inputSchema:SUBAGENT_TOOL_INPUT_SCHEMA,execute(){throw Error(`The framework "agent" tool was executed directly. It must be resolved through the runtime tool registry, which dispatches it to the shared subagent workflow.`)}},`defineTool`)),{availability:[`root-session`],handling:{action:`self-agent`,kind:`dispatch`}});export{agent,agent as default};
+import{frameworkTool}from"#tools/provided/framework-tool.js";import{stampToolDefinition}from"#tools/definition.js";import{AGENT_TOOL_DESCRIPTION,SUBAGENT_TOOL_INPUT_SCHEMA}from"#tools/framework/agent-contract.js";import{attachToolBehavior}from"#tools/behavior.js";const agent=attachToolBehavior(frameworkTool(stampToolDefinition({description:AGENT_TOOL_DESCRIPTION,inputSchema:SUBAGENT_TOOL_INPUT_SCHEMA,execute(){throw Error(`The framework "agent" tool was executed directly. It must be resolved through the runtime tool registry, which dispatches it to the shared subagent workflow.`)}},`defineTool`)),{availability:[`root-session`],handling:{action:`self-agent`,kind:`dispatch`}});export{agent,agent as default};

package/dist/src/tools/provided/ask-question-workflow.js

@@ -1 +1 @@
-async function executeAskQuestionTool(e,t){"use workflow";return toAskQuestionOutput(await t.ask(toAskQuestionRequest(e)))}function toAskQuestionRequest(e){let t=e.options?.map(e=>({description:e.description,id:e.label,label:e.label}));return{allowFreeform:!0,display:t===void 0?`text`:`select`,prompt:e.question,...t!==void 0&&{options:t}}}function toAskQuestionOutput(e){switch(e.status){case`answered`:return{answer:e.optionId??e.text??``,status:`answered`};case`cancelled`:return{interrupted:!0};case`unavailable`:return{status:`unavailable`}}}executeAskQuestionTool.workflowId=`workflow//eve@0.73.0//executeAskQuestionTool`;export{executeAskQuestionTool,toAskQuestionOutput,toAskQuestionRequest};
+async function executeAskQuestionTool(e,t){"use workflow";return toAskQuestionOutput(await t.ask(toAskQuestionRequest(e)))}function toAskQuestionRequest(e){let t=e.options?.map(e=>({description:e.description,id:e.label,label:e.label}));return{allowFreeform:!0,display:t===void 0?`text`:`select`,prompt:e.question,...t!==void 0&&{options:t}}}function toAskQuestionOutput(e){switch(e.status){case`answered`:return{answer:e.optionId??e.text??``,status:`answered`};case`cancelled`:return{interrupted:!0};case`unavailable`:return{status:`unavailable`}}}executeAskQuestionTool.workflowId=`workflow//eve@0.74.0//executeAskQuestionTool`;export{executeAskQuestionTool,toAskQuestionOutput,toAskQuestionRequest};