eve 0.82.0 → 0.83.0

package/dist/src/shared/sandbox-network-policy.d.ts

@@ -1,11 +1,9 @@
-import type * as Vercel from "#compiled/@vercel/sandbox/index.js";
 /**
  * Firewall network policy applied to a live sandbox session.
  *
- * eve-owned alias of the provider network-policy shape. Use it to restrict
- * egress (`"deny-all"`, an allow-list) or to broker credentials onto
- * outgoing requests. A per-domain `transform` injects headers at the
- * firewall so secrets never enter the sandbox process:
+ * Use it to restrict egress (`"deny-all"`, an allow-list) or to broker
+ * credentials onto outgoing requests. A per-domain `transform` injects
+ * headers at the firewall so secrets never enter the sandbox process:
  *
  * ```ts
  * import { environment } from "../sandbox";
@@ -19,11 +17,49 @@ import type * as Vercel from "#compiled/@vercel/sandbox/index.js";
  * });
  * ```
  *
- * The Docker provider honors only the coarse `"allow-all"` and
- * `"deny-all"` policies. just-bash environments do not expose
- * `setNetworkPolicy` because their network policy is fixed at sandbox creation.
+ * A provider rejects any part of a policy it cannot enforce instead of
+ * weakening it. The Docker provider honors only `"allow-all"` and
+ * `"deny-all"`.
  */
-export type SandboxNetworkPolicy = Vercel.NetworkPolicy;
+export type SandboxNetworkPolicy = "allow-all" | "deny-all" | {
+    /** Allowed domains, or a map from domain to the rules applied to its requests. */
+    readonly allow?: readonly string[] | Readonly<Record<string, readonly SandboxNetworkRule[]>>;
+    readonly subnets?: {
+        readonly allow?: readonly string[];
+        readonly deny?: readonly string[];
+    };
+};
+/** Exactly one of `transform` (inject headers) or `forwardURL` (proxy the request). */
+export type SandboxNetworkRule = {
+    readonly match?: SandboxNetworkMatch;
+} & ({
+    readonly transform: readonly {
+        readonly headers?: Readonly<Record<string, string>>;
+    }[];
+} | {
+    readonly forwardURL: string;
+});
+/** Which requests a {@link SandboxNetworkRule} applies to. */
+export interface SandboxNetworkMatch {
+    readonly headers?: readonly {
+        readonly key?: SandboxNetworkMatcher;
+        readonly value?: SandboxNetworkMatcher;
+    }[];
+    readonly method?: readonly string[];
+    readonly path?: SandboxNetworkMatcher;
+    readonly queryString?: readonly {
+        readonly key?: SandboxNetworkMatcher;
+        readonly value?: SandboxNetworkMatcher;
+    }[];
+}
+/** Sets exactly one of `exact`, `startsWith`, or `regex`. */
+export type SandboxNetworkMatcher = {
+    readonly exact: string;
+} | {
+    readonly startsWith: string;
+} | {
+    readonly regex: string;
+};
 /** Initial network configuration shared by network-capable sandbox providers. */
 export interface SandboxNetworkOptions {
     readonly networkPolicy?: SandboxNetworkPolicy;

package/dist/src/shared/sandbox-provider.d.ts

@@ -1,5 +1,3 @@
-import { type SandboxEnvironment, type SandboxSelectorContext } from "#shared/sandbox-environment.js";
-import type { SandboxSession } from "#shared/sandbox-session.js";
 export interface SandboxDeleteOptions {
     readonly abortSignal?: AbortSignal;
 }
@@ -7,113 +5,12 @@ export interface SandboxProviderResourceFile {
     readonly content: string | Uint8Array;
     readonly relativePath: string;
 }
-export interface SandboxProviderResourceTree {
-    readonly files: readonly SandboxProviderResourceFile[];
-    readonly key: string;
-    readonly mountPath: string;
-    readonly targetPath: string;
-}
-export type SandboxProviderResourceSource = {
-    readonly kind: "none";
-} | {
-    readonly key: string;
-    readonly kind: "inline";
-} | {
-    readonly key: string;
-    readonly kind: "materialized";
-    readonly path: string;
-};
-export interface SandboxProviderResources {
-    readonly skills?: SandboxProviderResourceTree;
-    readonly source: SandboxProviderResourceSource;
-    readonly workspace?: SandboxProviderResourceTree;
-}
-export declare function sandboxProviderResourceIdentity(resources: SandboxProviderResources): object;
-export interface SandboxProviderTargetFile {
-    readonly content: string | Uint8Array;
-    readonly path: string;
-}
-export declare function providerResourceTargetFiles(resources: SandboxProviderResources): SandboxProviderTargetFile[];
 export type SandboxPreparedArtifact = null | boolean | number | string | readonly SandboxPreparedArtifact[] | {
     readonly [key: string]: SandboxPreparedArtifact;
 };
 export declare function isSandboxPreparedArtifact(value: unknown): value is SandboxPreparedArtifact;
-export declare function isSandboxPreparedArtifactRecord(artifact: unknown): artifact is {
-    readonly [key: string]: SandboxPreparedArtifact;
-};
 export interface SandboxProviderFiles {
     list(): Promise<readonly string[]>;
     read(path: string): Promise<Uint8Array>;
     readText(path: string): Promise<string>;
 }
-export interface SandboxProviderHost {
-    loadOptionalPackage<T>(input: {
-        readonly autoInstall: boolean;
-        readonly importModule: () => Promise<T>;
-        readonly installPackageName?: string;
-        readonly ignoredOptionalDependencies?: readonly string[];
-        readonly missingMessage: string;
-        readonly packageName: string;
-    }): Promise<T>;
-    resolveProjectPath(path: string): string;
-}
-export interface SandboxProviderPrepareContext {
-    readonly files: SandboxProviderFiles;
-    readonly host: SandboxProviderHost;
-    readonly log?: (message: string) => void;
-    readonly resources: SandboxProviderResources;
-    readonly sourceRevision: string;
-    readonly storagePath: string;
-}
-export interface SandboxProviderSessionContext {
-    readonly host: SandboxProviderHost;
-    readonly session: SandboxSelectorContext["session"];
-    readonly storagePath: string;
-}
-export interface SandboxProviderHandle<Session extends SandboxSession = SandboxSession> {
-    readonly sandbox: Session;
-    onRuntimeShutdown(): Promise<void>;
-    onSandboxDelete(options?: SandboxDeleteOptions): Promise<void>;
-    onSandboxStop(): Promise<void>;
-}
-export interface SandboxProviderImplementation<OpenOptions extends object | undefined, PreparedArtifact extends SandboxPreparedArtifact, SessionState, Session extends SandboxSession = SandboxSession> {
-    /**
-     * Permanently releases resources owned by a durable session after its terminal outcome.
-     * Implementations must be idempotent because the cleanup step may retry.
-     */
-    onSessionEnd?(context: SandboxProviderSessionContext, artifact: Readonly<PreparedArtifact>, state: Readonly<SessionState>, options: {
-        readonly reason: "completed" | "expired" | "failed";
-    }): Promise<void>;
-    prepare(context: SandboxProviderPrepareContext): Promise<PreparedArtifact>;
-    resume(context: SandboxProviderSessionContext, artifact: Readonly<PreparedArtifact>, state: Readonly<SessionState>): Promise<SandboxProviderHandle<Session>>;
-    start(context: SandboxProviderSessionContext, options: Readonly<OpenOptions> | undefined, artifact: Readonly<PreparedArtifact>): Promise<{
-        readonly handle: SandboxProviderHandle<Session>;
-        readonly state: SessionState;
-    }>;
-}
-type SandboxOptionArguments<Options extends object | undefined> = Options extends undefined ? [options?: undefined] : Record<never, never> extends Options ? [options?: Readonly<Options>] : [options: Readonly<Options>];
-export type SandboxProviderDefinition<EnvironmentOptions extends object | undefined, OpenOptions extends object | undefined, PreparedArtifact extends SandboxPreparedArtifact, SessionState, Session extends SandboxSession> = {
-    readonly name: string;
-    readonly stateProtocolVersion?: number;
-    environment(...args: SandboxOptionArguments<EnvironmentOptions>): SandboxProviderImplementation<OpenOptions, PreparedArtifact, SessionState, Session>;
-};
-export interface SandboxProvider<EnvironmentOptions extends object | undefined, OpenOptions extends object | undefined, Session extends SandboxSession> {
-    readonly name: string;
-    environment(...args: SandboxOptionArguments<EnvironmentOptions>): SandboxEnvironment<OpenOptions, Session>;
-}
-type ErasedSandboxProviderImplementation = SandboxProviderImplementation<object | undefined, SandboxPreparedArtifact, SandboxPreparedArtifact, SandboxSession>;
-export interface SandboxProviderRuntime {
-    readonly implementation: ErasedSandboxProviderImplementation;
-    readonly providerName: string;
-    readonly stateProtocolVersion: number;
-}
-export declare function defineSandboxProvider<EnvironmentOptions extends object | undefined = undefined, OpenOptions extends object | undefined = undefined, PreparedArtifact extends SandboxPreparedArtifact = SandboxPreparedArtifact, SessionState = SandboxPreparedArtifact, Session extends SandboxSession = SandboxSession>(definition: SandboxProviderDefinition<EnvironmentOptions, OpenOptions, PreparedArtifact, SessionState, Session>): SandboxProvider<EnvironmentOptions, OpenOptions, Session>;
-export declare function createSandboxProviderResources(input: {
-    readonly resourcesKey?: string;
-    readonly resourcesPath?: string;
-    readonly seedFiles?: readonly {
-        readonly content: string | Uint8Array;
-        readonly path: string;
-    }[];
-}): SandboxProviderResources;
-export {};

package/dist/src/shared/sandbox-provider.js

@@ -1 +1 @@
-import{createSandboxEnvironment}from"#shared/sandbox-environment.js";function sandboxProviderResourceIdentity(e){return{skills:e.skills?.key,workspace:e.workspace?.key}}function providerResourceTargetFiles(e){return[e.workspace,e.skills].flatMap(e=>e===void 0?[]:e.files.map(t=>({content:t.content,path:`${e.targetPath}/${t.relativePath}`})))}function isSandboxPreparedArtifact(e){return e===null||typeof e==`boolean`||typeof e==`number`||typeof e==`string`?!0:Array.isArray(e)?e.every(isSandboxPreparedArtifact):typeof e==`object`&&!!e&&Object.values(e).every(isSandboxPreparedArtifact)}function isSandboxPreparedArtifactRecord(e){return typeof e==`object`&&!!e&&!Array.isArray(e)}function defineSandboxProvider(e){let t=e.stateProtocolVersion??1;return{name:e.name,environment(...n){return createSandboxEnvironment({configuration:n[0],runtime:{implementation:eraseSandboxProviderImplementation(e.environment(...n)),providerName:e.name,stateProtocolVersion:t}})}}}function eraseSandboxProviderImplementation(e){return e}function createSandboxProviderResources(e){if(e.resourcesKey===void 0)return{source:{kind:`none`}};let t=e.seedFiles??[],n=e.resourcesPath===void 0?{key:e.resourcesKey,kind:`inline`}:{key:e.resourcesKey,kind:`materialized`,path:e.resourcesPath};return{skills:createResourceTree({files:t.filter(e=>e.path.startsWith(`$HOME/.agents/skills/`)),key:`${e.resourcesKey}:skills`,mountPath:`/eve/resources/skills`,prefix:`$HOME/.agents/skills/`,targetPath:`$HOME/.agents/skills`}),source:n,workspace:createResourceTree({files:t.filter(e=>!e.path.startsWith(`$HOME/.agents/skills/`)),key:`${e.resourcesKey}:workspace`,mountPath:`/eve/resources/workspace`,prefix:`/workspace/`,targetPath:`/workspace`})}}function createResourceTree(e){return{files:e.files.map(t=>({content:t.content,relativePath:t.path.startsWith(e.prefix)?t.path.slice(e.prefix.length):t.path})),key:e.key,mountPath:e.mountPath,targetPath:e.targetPath}}export{createSandboxProviderResources,defineSandboxProvider,isSandboxPreparedArtifact,isSandboxPreparedArtifactRecord,providerResourceTargetFiles,sandboxProviderResourceIdentity};
+function isSandboxPreparedArtifact(e){return e===null||typeof e==`boolean`||typeof e==`number`||typeof e==`string`?!0:Array.isArray(e)?e.every(isSandboxPreparedArtifact):typeof e==`object`&&!!e&&Object.values(e).every(isSandboxPreparedArtifact)}export{isSandboxPreparedArtifact};

package/dist/src/shared/sandbox-recorded-data-error.d.ts

@@ -0,0 +1,4 @@
+/** A provider's recorded session state does not match the shape this eve version writes. */
+export declare function invalidSandboxSessionStateError(label: string): Error;
+/** A provider's prepared artifact from `eve build` does not match the shape this eve version writes. */
+export declare function invalidPreparedSandboxArtifactError(label: string): Error;

package/dist/src/shared/sandbox-recorded-data-error.js

@@ -0,0 +1 @@
+function invalidSandboxSessionStateError(e){return Error(`Invalid ${e} session state. This session's recorded sandbox state does not match the format this eve version expects, usually because the session started under a different eve version. Start a new session to get a fresh sandbox.`)}function invalidPreparedSandboxArtifactError(e){return Error(`Invalid prepared ${e} artifact. The artifact recorded by \`eve build\` does not match the format this eve version expects, usually because the build used a different eve version. Run \`eve build\` with the eve version this runtime uses, then redeploy.`)}export{invalidPreparedSandboxArtifactError,invalidSandboxSessionStateError};

package/dist/src/shared/sandbox-session-gone-error.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Thrown by a provider's `resume()` when the session's native sandbox no
+ * longer exists. eve then clears the session's sandbox state and reruns the
+ * sandbox selector, which starts a fresh sandbox, as it would after
+ * `sandbox.delete()`. Throw it only for a sandbox that is gone; other
+ * failures must surface unchanged.
+ */
+export declare class SandboxSessionGoneError extends Error {
+    constructor(message: string);
+    /** Also matches an error from another copy of this class, such as one a provider bundles. */
+    static is(error: unknown): error is SandboxSessionGoneError;
+}

package/dist/src/shared/sandbox-session-gone-error.js

@@ -0,0 +1 @@
+var SandboxSessionGoneError=class SandboxSessionGoneError extends Error{constructor(e){super(e),this.name=`SandboxSessionGoneError`}static is(e){return e instanceof SandboxSessionGoneError||e instanceof Error&&e.name===`SandboxSessionGoneError`}};export{SandboxSessionGoneError};

package/dist/src/shared/sandbox-session.d.ts

@@ -1,59 +1,88 @@
-import type { Experimental_SandboxSession as AiSdkSandbox } from "ai";
 import type { SandboxDeleteOptions } from "#shared/sandbox-provider.js";
 /**
- * Options for running one command in a sandbox. Shape mirrors the AI
- * SDK {@link AiSdkSandbox} `run` argument so authored code that targets
- * either surface uses the same call shape.
+ * Options for running one command, or spawning one process, in a sandbox.
+ * `env` holds per-call variables, merged over the sandbox's environment.
+ * Aborting kills the process.
  */
-export type SandboxRunOptions = Parameters<AiSdkSandbox["run"]>[0];
-/**
- * Serializable result returned after running one sandbox command.
- */
-export type SandboxCommandResult = Awaited<ReturnType<AiSdkSandbox["run"]>>;
-/**
- * Options for spawning one long-running process in a sandbox. Shape
- * mirrors the AI SDK {@link AiSdkSandbox} `spawn` argument.
- */
-export type SandboxSpawnOptions = Parameters<AiSdkSandbox["spawn"]>[0];
-/**
- * Handle to a long-running process spawned via {@link SandboxSession.spawn}.
- * Mirrors the AI SDK `Experimental_SandboxProcess` type.
- */
-export type SandboxProcess = Awaited<ReturnType<AiSdkSandbox["spawn"]>>;
-/**
- * Options for reading one file as a stream of bytes.
- */
-export type SandboxReadFileOptions = Parameters<AiSdkSandbox["readFile"]>[0];
-/**
- * Options for reading one file as raw bytes.
- */
-export type SandboxReadBinaryFileOptions = Parameters<AiSdkSandbox["readBinaryFile"]>[0];
+export interface SandboxRunOptions {
+    readonly abortSignal?: AbortSignal;
+    readonly command: string;
+    readonly env?: Readonly<Record<string, string>>;
+    /** Relative directories resolve from the workspace root, which is also the default. */
+    readonly workingDirectory?: string;
+}
+/** Options for spawning one long-running process in a sandbox. */
+export type SandboxSpawnOptions = SandboxRunOptions;
+/** Result of one finished sandbox command. A nonzero `exitCode` does not throw. */
+export interface SandboxCommandResult {
+    readonly exitCode: number;
+    readonly stderr: string;
+    readonly stdout: string;
+}
+/** Handle to a long-running process spawned via {@link SandboxSession.spawn}. */
+export interface SandboxProcess {
+    readonly pid?: number;
+    readonly stderr: ReadableStream<Uint8Array>;
+    readonly stdout: ReadableStream<Uint8Array>;
+    /** Terminates the process. Idempotent. */
+    kill(): Promise<void>;
+    wait(): Promise<{
+        readonly exitCode: number;
+    }>;
+}
+/** Options for reading one file as a stream of bytes. */
+export interface SandboxReadFileOptions {
+    readonly abortSignal?: AbortSignal;
+    readonly path: string;
+}
+/** Options for reading one file as raw bytes. */
+export type SandboxReadBinaryFileOptions = SandboxReadFileOptions;
 /**
  * Options for reading one text file from a sandbox.
  *
- * `encoding`, `startLine`, and `endLine` are passed through to the
- * public-surface decoder. `"utf-8"` decodes with `TextDecoder` in fatal
- * mode; other encodings fall back to Node's `Buffer.toString(encoding)`.
- * Line ranges are 1-based and inclusive; `endLine` past the file's line
- * count returns through EOF without error.
+ * `"utf-8"` decodes with `TextDecoder` in fatal mode; other encodings fall
+ * back to Node's `Buffer.toString(encoding)`. Line ranges are 1-based and
+ * inclusive; `endLine` past the file's line count returns through EOF
+ * without error.
  */
-export type SandboxReadTextFileOptions = Parameters<AiSdkSandbox["readTextFile"]>[0];
-/**
- * Options for writing one file from a stream of bytes.
- */
-export type SandboxWriteFileOptions = Parameters<AiSdkSandbox["writeFile"]>[0];
-/**
- * Options for writing one file from raw bytes.
- */
-export type SandboxWriteBinaryFileOptions = Parameters<AiSdkSandbox["writeBinaryFile"]>[0];
+export interface SandboxReadTextFileOptions extends SandboxReadFileOptions {
+    readonly encoding?: string;
+    readonly endLine?: number;
+    readonly startLine?: number;
+}
+/** Options for writing one file from a stream of bytes. */
+export interface SandboxWriteFileOptions {
+    readonly abortSignal?: AbortSignal;
+    readonly content: ReadableStream<Uint8Array>;
+    readonly path: string;
+}
+/** Options for writing one file from raw bytes. */
+export interface SandboxWriteBinaryFileOptions {
+    readonly abortSignal?: AbortSignal;
+    readonly content: Uint8Array;
+    readonly path: string;
+}
+/** Options for writing one text file to a sandbox. Encodes as UTF-8 unless `encoding` is set. */
+export interface SandboxWriteTextFileOptions {
+    readonly abortSignal?: AbortSignal;
+    readonly content: string;
+    readonly encoding?: string;
+    readonly path: string;
+}
 /**
- * Options for writing one text file to a sandbox.
+ * Options for writing several files from raw bytes in one batch.
  */
-export type SandboxWriteTextFileOptions = Parameters<AiSdkSandbox["writeTextFile"]>[0];
+export interface SandboxWriteFilesOptions {
+    readonly abortSignal?: AbortSignal;
+    readonly files: readonly {
+        readonly content: Uint8Array;
+        readonly path: string;
+    }[];
+}
 /**
  * Options for removing a path from a sandbox.
  *
- * Relative paths resolve from `/workspace`; absolute paths pass through.
+ * Relative paths resolve from the workspace root; absolute paths pass through.
  * `force` ignores missing paths. `recursive` permits removing non-empty
  * directories.
  */
@@ -64,32 +93,37 @@ export interface SandboxRemovePathOptions {
     readonly recursive?: boolean;
 }
 /**
- * Public eve-owned sandbox session exposed to authored lifecycle hooks.
+ * The sandbox session that authored tools, hooks, and `prepare` receive.
  *
- * The eight I/O methods (`run`, `spawn`, `readFile`, `readBinaryFile`,
- * `readTextFile`, `writeFile`, `writeBinaryFile`, `writeTextFile`) are
- * pulled directly from the AI SDK {@link AiSdkSandbox} type, so authored
- * code that targets either surface uses identical signatures. `resolvePath`
- * is an eve-specific extension for `/workspace` path anchoring.
- *
- * Relative paths resolve from `/workspace`, the live working directory
- * for every provider. Absolute paths pass through unchanged.
+ * Relative paths resolve from the workspace root, where commands start by
+ * default: `/workspace` on every built-in provider. Absolute paths pass
+ * through unchanged. Writes create missing parent directories and overwrite
+ * existing files. Reads resolve to `null` only when the path does not exist.
  *
+ * The method set stays assignable to the AI SDK's
+ * `Experimental_SandboxSession`, apart from its `description`.
  */
-export interface SandboxSession extends Pick<AiSdkSandbox, "run" | "spawn" | "readFile" | "readBinaryFile" | "readTextFile" | "writeFile" | "writeBinaryFile" | "writeTextFile"> {
+export interface SandboxSession {
+    run(options: SandboxRunOptions): Promise<SandboxCommandResult>;
+    spawn(options: SandboxSpawnOptions): Promise<SandboxProcess>;
+    readFile(options: SandboxReadFileOptions): Promise<ReadableStream<Uint8Array> | null>;
+    readBinaryFile(options: SandboxReadBinaryFileOptions): Promise<Uint8Array | null>;
+    readTextFile(options: SandboxReadTextFileOptions): Promise<string | null>;
+    writeFile(options: SandboxWriteFileOptions): Promise<void>;
+    writeBinaryFile(options: SandboxWriteBinaryFileOptions): Promise<void>;
+    writeTextFile(options: SandboxWriteTextFileOptions): Promise<void>;
     /**
-     * Anchors a sandbox-relative path to `/workspace` and returns the
-     * resulting absolute path.
-     *
-     * Relative paths resolve from `/workspace`; absolute paths pass through.
-     * The read and write methods already apply this internally.
+     * Writes several files in as few provider calls as the provider allows. A
+     * batch is not atomic: a rejected batch may leave earlier files written.
      */
-    resolvePath(path: string): string;
+    writeFiles(options: SandboxWriteFilesOptions): Promise<void>;
     /**
-     * Removes one file or directory from the sandbox filesystem.
-     *
-     * Relative paths resolve from `/workspace`; absolute paths pass through.
+     * Anchors a sandbox-relative path to the workspace root and returns the
+     * resulting absolute path, so `resolvePath(".")` is the root itself. The
+     * read and write methods already apply it.
      */
+    resolvePath(path: string): string;
+    /** Removes one file or directory from the sandbox filesystem. */
     removePath(options: SandboxRemovePathOptions): Promise<void>;
 }
 export interface RuntimeSandboxSession extends SandboxSession {
@@ -103,23 +137,3 @@ export interface RuntimeSandboxSession extends SandboxSession {
     stop(): Promise<void>;
 }
 export type RuntimeSandboxSessionFor<Session extends SandboxSession> = Session & Pick<RuntimeSandboxSession, "delete" | "stop">;
-/**
- * Internal sandbox session, used to construct the public {@link SandboxSession}.
- *
- * Provider implementations only need to provide byte-oriented file I/O and
- * a `spawn` primitive; the public surface (binary and text variants,
- * line-range slicing, encoding handling, the `run` wrapper) is built on
- * top of these primitives by `buildSandboxSession`.
- *
- * Each method's signature mirrors its public counterpart (and the AI
- * SDK {@link AiSdkSandbox} surface) so providers look symmetric with
- * what authored code sees. The `path` field on `readFile`/`writeFile`
- * here is the **already-resolved** path: the public-surface builder
- * calls `resolvePath` before delegating.
- */
-export interface InternalSandboxSession extends Pick<AiSdkSandbox, "spawn" | "readFile" | "writeFile"> {
-    /** Removes an already-resolved path from the provider filesystem. */
-    removePath(options: SandboxRemovePathOptions): Promise<void>;
-    /** Translates a user-facing path to the provider's native path. */
-    resolvePath(path: string): string;
-}

package/dist/src/shared/sandbox-template-error.d.ts

@@ -1,9 +1,24 @@
+type SandboxTemplateNotProvisionedInput = 
+/** The build recorded no prepared artifact for this agent node. */
+{
+    readonly nodeId: string;
+    readonly providerName: string;
+}
+/**
+ * The provider cannot use the recorded template. Callers that know why pass
+ * `reason`; the default message names no cause, because callers raise this for
+ * several different ones.
+ */
+ | {
+    readonly providerName: string;
+    readonly reason?: string;
+    readonly templateKey: string;
+};
 export declare class SandboxTemplateNotProvisionedError extends Error {
     readonly providerName: string;
+    /** The provider's template identifier, or the agent node id when the build recorded no artifact. */
     readonly templateKey: string;
-    constructor(input: {
-        readonly providerName: string;
-        readonly templateKey: string;
-    });
+    constructor(input: SandboxTemplateNotProvisionedInput);
     static is(error: unknown): error is SandboxTemplateNotProvisionedError;
 }
+export {};

package/dist/src/shared/sandbox-template-error.js

@@ -1 +1 @@
-var SandboxTemplateNotProvisionedError=class SandboxTemplateNotProvisionedError extends Error{providerName;templateKey;constructor(e){super(`Sandbox template "${e.templateKey}" is not provisioned for provider "${e.providerName}". Run \`eve build\` before serving traffic.`),this.name=`SandboxTemplateNotProvisionedError`,this.providerName=e.providerName,this.templateKey=e.templateKey}static is(e){return e instanceof SandboxTemplateNotProvisionedError||typeof e==`object`&&!!e&&Reflect.get(e,`name`)===`SandboxTemplateNotProvisionedError`&&typeof Reflect.get(e,`providerName`)==`string`&&typeof Reflect.get(e,`templateKey`)==`string`}};export{SandboxTemplateNotProvisionedError};
+var SandboxTemplateNotProvisionedError=class SandboxTemplateNotProvisionedError extends Error{providerName;templateKey;constructor(e){super(`nodeId`in e?`No prepared "${e.providerName}" sandbox environment is recorded for agent node "${e.nodeId}". eve prepares sandbox environments during \`eve build\` and never prepares them in production. Run \`eve build\` without \`--skip-sandbox-prewarm\` and deploy that output with this runtime.`:`Sandbox template "${e.templateKey}" for provider "${e.providerName}" is not available to this runtime. `+(e.reason===void 0?``:`${e.reason} `)+"The runtime only uses templates that `eve build` prepared and never recreates them. Run `eve build` again and deploy its output."),this.name=`SandboxTemplateNotProvisionedError`,this.providerName=e.providerName,this.templateKey=`nodeId`in e?e.nodeId:e.templateKey}static is(e){return e instanceof SandboxTemplateNotProvisionedError||typeof e==`object`&&!!e&&Reflect.get(e,`name`)===`SandboxTemplateNotProvisionedError`&&typeof Reflect.get(e,`providerName`)==`string`&&typeof Reflect.get(e,`templateKey`)==`string`}};export{SandboxTemplateNotProvisionedError};

package/dist/src/shared/sandbox-tool-session-error.d.ts

@@ -0,0 +1,4 @@
+/** Raised when a keyed tool session opens a sandbox on a provider that cannot keep it. */
+export declare class ToolSessionSandboxUnsupportedError extends Error {
+    constructor(providerName: string);
+}

package/dist/src/shared/sandbox-tool-session-error.js

@@ -0,0 +1 @@
+var ToolSessionSandboxUnsupportedError=class extends Error{constructor(e){super(`Sandbox provider "${e}" cannot keep a sandbox between invokeTool calls, so a call with a key cannot open one. Call without a key for a sandbox that lasts one call, or use Vercel Sandbox, just-bash, or a custom provider that sets \`toolSessions: true\`.`),this.name=`ToolSessionSandboxUnsupportedError`}};export{ToolSessionSandboxUnsupportedError};

package/dist/src/shared/skill-package.js

@@ -1 +1 @@
-import{createHash}from"node:crypto";import{mkdir,writeFile}from"node:fs/promises";import{dirname,join}from"node:path";import{resolveSandboxSkillRoot,resolveSandboxSkillWritePath}from"#shared/skill-paths.js";import{mapWithConcurrency}from"#shared/map-with-concurrency.js";import{Buffer}from"node:buffer";function stripSkillFrontmatter(e){return e.replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n?/,``)}function skillPackageRevision(e){let t=createHash(`sha256`);for(let n of e.files)t.update(`${n.relativePath}\0${n.content.byteLength}\0`).update(n.content);return t.digest(`hex`)}function normalizeSkillPackage(e){assertSafeSkillPackageName(e.name);let t=[{content:Buffer.from(e.markdown,`utf8`),relativePath:`SKILL.md`}];for(let[n,r]of Object.entries(e.files??{}))assertSafeSkillPackageFilePath(n),t.push({content:contentToBuffer(r),relativePath:n});return t.sort((e,t)=>comparePaths(e.relativePath,t.relativePath)),{deferred:e.deferred,description:e.description,files:t,license:e.license,markdown:e.markdown,metadata:e.metadata===void 0?void 0:{...e.metadata},name:e.name}}async function writeSkillPackageDirectory(e){for(let t of e.skill.files){let n=join(e.rootPath,`skills`,e.skill.name,t.relativePath);await mkdir(dirname(n),{recursive:!0}),await writeFile(n,t.content)}}async function writeSkillPackageToSandbox(e){await mapWithConcurrency(e.skill.files,16,async t=>{await e.sandbox.writeBinaryFile({content:t.content,path:await resolveSandboxSkillWritePath({name:e.skill.name,relativePath:t.relativePath,sandbox:e.sandbox})})})}async function removeSkillPackageFromSandbox(e){assertSafeSkillPackageName(e.name);let t=await resolveSandboxSkillRoot({sandbox:e.sandbox});await e.sandbox.removePath({force:!0,path:`${t}/${e.name}`,recursive:!0})}function assertSafeSkillPackageName(e){if(e.length===0||e.startsWith(`.`)||e.includes(`/`)||e.includes(`\\`)||e.includes(`..`)||!/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(e)||/^[A-Za-z]:/.test(e))throw Error(`Expected skill name to be a non-empty shell-safe path segment starting with an alphanumeric character and containing only alphanumerics, ".", "_", or "-".`)}function assertSafeSkillPackageFilePath(e){if(e===`SKILL.md`)throw Error(`Skill package files must not include "SKILL.md"; eve generates it.`);if(e.length===0||e.startsWith(`/`)||e.includes(`\\`)||/^[A-Za-z]:/.test(e)||e.split(`/`).some(e=>e.length===0||e===`.`||e===`..`))throw Error(`Expected skill package file paths to be relative POSIX paths.`)}function contentToBuffer(e){return typeof e==`string`?Buffer.from(e,`utf8`):Buffer.from(e)}function comparePaths(e,t){return e<t?-1:+(e>t)}export{normalizeSkillPackage,removeSkillPackageFromSandbox,skillPackageRevision,stripSkillFrontmatter,writeSkillPackageDirectory,writeSkillPackageToSandbox};
+import{createHash}from"node:crypto";import{mkdir,writeFile}from"node:fs/promises";import{dirname,join}from"node:path";import{resolveSandboxSkillRoot,resolveSandboxSkillWritePath}from"#shared/skill-paths.js";import{Buffer}from"node:buffer";function stripSkillFrontmatter(e){return e.replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n?/,``)}function skillPackageRevision(e){let t=createHash(`sha256`);for(let n of e.files)t.update(`${n.relativePath}\0${n.content.byteLength}\0`).update(n.content);return t.digest(`hex`)}function normalizeSkillPackage(e){assertSafeSkillPackageName(e.name);let t=[{content:Buffer.from(e.markdown,`utf8`),relativePath:`SKILL.md`}];for(let[n,r]of Object.entries(e.files??{}))assertSafeSkillPackageFilePath(n),t.push({content:contentToBuffer(r),relativePath:n});return t.sort((e,t)=>comparePaths(e.relativePath,t.relativePath)),{deferred:e.deferred,description:e.description,files:t,license:e.license,markdown:e.markdown,metadata:e.metadata===void 0?void 0:{...e.metadata},name:e.name}}async function writeSkillPackageDirectory(e){for(let t of e.skill.files){let n=join(e.rootPath,`skills`,e.skill.name,t.relativePath);await mkdir(dirname(n),{recursive:!0}),await writeFile(n,t.content)}}async function writeSkillPackageToSandbox(e){let t=await Promise.all(e.skill.files.map(async t=>({content:t.content,path:await resolveSandboxSkillWritePath({name:e.skill.name,relativePath:t.relativePath,sandbox:e.sandbox})})));await e.sandbox.writeFiles({files:t})}async function removeSkillPackageFromSandbox(e){assertSafeSkillPackageName(e.name);let t=await resolveSandboxSkillRoot({sandbox:e.sandbox});await e.sandbox.removePath({force:!0,path:`${t}/${e.name}`,recursive:!0})}function assertSafeSkillPackageName(e){if(e.length===0||e.startsWith(`.`)||e.includes(`/`)||e.includes(`\\`)||e.includes(`..`)||!/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(e)||/^[A-Za-z]:/.test(e))throw Error(`Expected skill name to be a non-empty shell-safe path segment starting with an alphanumeric character and containing only alphanumerics, ".", "_", or "-".`)}function assertSafeSkillPackageFilePath(e){if(e===`SKILL.md`)throw Error(`Skill package files must not include "SKILL.md"; eve generates it.`);if(e.length===0||e.startsWith(`/`)||e.includes(`\\`)||/^[A-Za-z]:/.test(e)||e.split(`/`).some(e=>e.length===0||e===`.`||e===`..`))throw Error(`Expected skill package file paths to be relative POSIX paths.`)}function contentToBuffer(e){return typeof e==`string`?Buffer.from(e,`utf8`):Buffer.from(e)}function comparePaths(e,t){return e<t?-1:+(e>t)}export{normalizeSkillPackage,removeSkillPackageFromSandbox,skillPackageRevision,stripSkillFrontmatter,writeSkillPackageDirectory,writeSkillPackageToSandbox};

package/dist/src/shared/skill-paths.d.ts

@@ -1,18 +1,17 @@
 import type { SandboxSession } from "#shared/sandbox-session.js";
 export declare const MODEL_SKILL_ROOT = "$HOME/.agents/skills";
-export declare const FALLBACK_SKILL_ROOT = "/workspace/skills";
 /**
  * Resolves where skills live in the sandbox: under the probed home when it has
- * one, and under {@link FALLBACK_SKILL_ROOT} when it does not.
+ * one, and under `skills/` in the workspace root when it does not.
  */
 export declare function resolveSandboxSkillRoot(input: {
     readonly sandbox: SandboxSession;
 }): Promise<string>;
 /**
  * Resolves a leading `$HOME` in a model-supplied sandbox path without
- * evaluating any other shell syntax. Skill paths retain their documented
- * `/workspace/skills` fallback when the sandbox does not expose a usable
- * home directory.
+ * evaluating any other shell syntax. Skill paths fall back to `skills/` in
+ * the workspace root when the sandbox does not expose a usable home
+ * directory.
  */
 export declare function resolveSandboxModelPath(input: {
     readonly path: string;

package/dist/src/shared/skill-paths.js

@@ -1,2 +1,2 @@
-const MODEL_HOME_ROOT=`$HOME`,MODEL_SKILL_ROOT=`${MODEL_HOME_ROOT}/.agents/skills`,FALLBACK_SKILL_ROOT=`/workspace/skills`,sandboxHomeCache=new WeakMap;async function resolveSandboxSkillRoot(e){return await resolveSandboxModelPath({path:MODEL_SKILL_ROOT,sandbox:e.sandbox})}async function resolveSandboxModelPath(e){if(!isModelHomePath(e.path))return e.path;let t=await resolveSandboxHome(e.sandbox);if(t!==null){let n=e.path.slice(5);return n.length===0?t:`${t===`/`?``:t}${n}`}return isModelSkillPath(e.path)?`${FALLBACK_SKILL_ROOT}${e.path.slice(MODEL_SKILL_ROOT.length)}`:e.path}async function resolveSandboxSkillWritePath(e){return formatSkillPath({name:e.name,relativePath:e.relativePath,root:await resolveSandboxSkillRoot({sandbox:e.sandbox})})}function formatSkillPath(e){return`${e.root}/${e.name}/${e.relativePath}`}async function resolveSandboxHome(e){let t=sandboxHomeCache.get(e);if(t!==void 0)return await t;let n=probeSandboxHome(e);return sandboxHomeCache.set(e,n),await n}async function probeSandboxHome(e){try{let t=await e.run({command:`printf '%s\\n' "$HOME"`});if(t.exitCode!==0)return null;let n=t.stdout.trim();return isUsableSandboxHome(n)?normalizeSandboxHome(n):null}catch{return null}}function isModelHomePath(e){return e===MODEL_HOME_ROOT||e.startsWith(`${MODEL_HOME_ROOT}/`)}function isModelSkillPath(e){return e===MODEL_SKILL_ROOT||e.startsWith(`${MODEL_SKILL_ROOT}/`)}function isUsableSandboxHome(e){return e.length>0&&e.startsWith(`/`)&&!e.includes(`\0`)&&!e.includes(`
-`)&&!e.includes(`\r`)}function normalizeSandboxHome(e){return e===`/`?e:e.replace(/\/+$/,``)}export{FALLBACK_SKILL_ROOT,MODEL_SKILL_ROOT,resolveSandboxModelPath,resolveSandboxSkillRoot,resolveSandboxSkillWritePath};
+const MODEL_HOME_ROOT=`$HOME`,MODEL_SKILL_ROOT=`${MODEL_HOME_ROOT}/.agents/skills`,sandboxHomeCache=new WeakMap;async function resolveSandboxSkillRoot(e){return await resolveSandboxModelPath({path:MODEL_SKILL_ROOT,sandbox:e.sandbox})}async function resolveSandboxModelPath(e){if(!isModelHomePath(e.path))return e.path;let t=await resolveSandboxHome(e.sandbox);if(t!==null){let n=e.path.slice(5);return n.length===0?t:`${t===`/`?``:t}${n}`}return isModelSkillPath(e.path)?e.sandbox.resolvePath(`skills${e.path.slice(MODEL_SKILL_ROOT.length)}`):e.path}async function resolveSandboxSkillWritePath(e){return formatSkillPath({name:e.name,relativePath:e.relativePath,root:await resolveSandboxSkillRoot({sandbox:e.sandbox})})}function formatSkillPath(e){return`${e.root}/${e.name}/${e.relativePath}`}async function resolveSandboxHome(e){let t=sandboxHomeCache.get(e);if(t!==void 0)return await t;let n=probeSandboxHome(e);return sandboxHomeCache.set(e,n),await n}async function probeSandboxHome(e){try{let t=await e.run({command:`printf '%s\\n' "$HOME"`});if(t.exitCode!==0)return null;let n=t.stdout.trim();return isUsableSandboxHome(n)?normalizeSandboxHome(n):null}catch{return null}}function isModelHomePath(e){return e===MODEL_HOME_ROOT||e.startsWith(`${MODEL_HOME_ROOT}/`)}function isModelSkillPath(e){return e===MODEL_SKILL_ROOT||e.startsWith(`${MODEL_SKILL_ROOT}/`)}function isUsableSandboxHome(e){return e.length>0&&e.startsWith(`/`)&&!e.includes(`\0`)&&!e.includes(`
+`)&&!e.includes(`\r`)}function normalizeSandboxHome(e){return e===`/`?e:e.replace(/\/+$/,``)}export{MODEL_SKILL_ROOT,resolveSandboxModelPath,resolveSandboxSkillRoot,resolveSandboxSkillWritePath};

package/dist/src/shared/workflow-sandbox.d.ts

@@ -1,43 +1,6 @@
-import type { FlexibleSchema, ToolSet } from "ai";
-import type * as CodeModeModule from "#compiled/@ai-sdk/code-mode/index.js";
-type WorkflowSandboxModule = {
-    readonly CodeModeToolError: typeof CodeModeModule.CodeModeToolError;
-    readonly continueCodeModeInterrupt: typeof CodeModeModule.experimental_continueCodeModeInterrupt;
-    readonly createCodeModeTool: typeof CodeModeModule.experimental_createCodeModeTool;
-    readonly requestCodeModeInterrupt: typeof CodeModeModule.experimental_requestCodeModeInterrupt;
-    readonly unwrapCodeModeResult: typeof CodeModeModule.experimental_unwrapCodeModeResult;
-};
-export type WorkflowSandboxInterrupt = CodeModeModule.CodeModeInterrupt;
-export type WorkflowSandboxContinuationSecurity = CodeModeModule.CodeModeContinuationSecurityOptions;
+import type * as RunModule from "#compiled/run/index.js";
+type WorkflowSandboxModule = Pick<typeof RunModule, "createRunner" | "createSignedContinuationCodec" | "getHostFunctionContext" | "RunError">;
 export declare function installWorkflowSandboxModule(module: WorkflowSandboxModule): void;
-export declare function createWorkflowSandboxTool(input: {
-    readonly bridgeRequestLimit: number;
-    readonly continuationSecurity: WorkflowSandboxContinuationSecurity;
-    readonly hostTools: ToolSet;
-}): Promise<ToolSet[string]>;
-export declare function continueWorkflowSandboxInterrupt(input: {
-    readonly bridgeRequestLimit: number;
-    readonly continuationSecurity: WorkflowSandboxContinuationSecurity;
-    readonly interrupt: WorkflowSandboxInterrupt;
-    readonly resolution: unknown;
-    readonly tools: ToolSet;
-}): Promise<unknown>;
-export declare function unwrapWorkflowSandboxResult(value: unknown, continuationSecurity: WorkflowSandboxContinuationSecurity): Promise<{
-    readonly output: unknown;
-    readonly status: "completed";
-} | {
-    readonly interrupt: WorkflowSandboxInterrupt;
-    readonly status: "interrupted";
-}>;
-/** A host tool that parks on first call and consumes its resolution on replay. */
-export declare function createParkingHostTool(input: {
-    readonly description: string;
-    readonly inputSchema: FlexibleSchema;
-    readonly outputSchema?: FlexibleSchema | null;
-    readonly interrupt: (toolInput: unknown) => {
-        readonly kind: string;
-    } & Record<string, unknown>;
-}): ToolSet[string];
-/** Reconstructs every unresolved interruption from the authenticated continuation. */
-export declare function getWorkflowSandboxPendingInterrupts(interrupt: WorkflowSandboxInterrupt): WorkflowSandboxInterrupt[];
+/** Returns the vendored `run` runtime that executes generated workflow programs. */
+export declare function loadWorkflowSandboxModule(): Promise<WorkflowSandboxModule>;
 export {};

package/dist/src/shared/workflow-sandbox.js

@@ -1 +1 @@
-const WORKFLOW_SANDBOX_MODULE_KEY=Symbol.for(`eve.workflowSandbox.module`),WORKFLOW_SANDBOX_MODULE_SPECIFIER=[`#compiled`,`@ai-sdk`,`code-mode`,`index.js`].join(`/`);let workflowSandboxModulePromise;function installWorkflowSandboxModule(e){globalThis[WORKFLOW_SANDBOX_MODULE_KEY]=e}async function createWorkflowSandboxTool(e){let{createCodeModeTool:t}=await loadWorkflowSandboxModule();return t(e.hostTools,createWorkflowSandboxOptions(e.bridgeRequestLimit,e.continuationSecurity))}async function continueWorkflowSandboxInterrupt(e){let{continueCodeModeInterrupt:t}=await loadWorkflowSandboxModule();return t({interrupt:e.interrupt,options:createWorkflowSandboxOptions(e.bridgeRequestLimit,e.continuationSecurity),resolution:e.resolution,tools:e.tools})}async function unwrapWorkflowSandboxResult(e,t){let{unwrapCodeModeResult:n}=await loadWorkflowSandboxModule();return n(e,t)}function createParkingHostTool(e){return{description:e.description,inputSchema:e.inputSchema,outputSchema:e.outputSchema??void 0,execute:async(t,n)=>{let r=await loadWorkflowSandboxModule(),i=readWorkflowProgramResolution(n);if(i?.status===`failed`)throw new r.CodeModeToolError(i.error);return i?.status===`completed`?i.output:r.requestCodeModeInterrupt(e.interrupt(t))}}}function readWorkflowProgramResolution(e){if(typeof e!=`object`||!e)return;let t=e.codeModeInterrupt;if(typeof t!=`object`||!t)return;let n=t.resolution;if(typeof n!=`object`||!n)return;let r=n.status;return r===`completed`||r===`failed`?n:void 0}function getWorkflowSandboxPendingInterrupts(e){let t=e.continuation,n=new Set(t.resolutions.map(e=>e.runInterruptionId));return t.pendingInterruptions.flatMap(e=>n.has(e.runInterruptionId)?[]:[{continuation:t,input:e.input,interruptId:e.interruptId,outerToolCallId:t.outerToolCallId,payload:e.payload,toolCallId:e.toolCallId,toolName:e.toolName,type:`code-mode-interrupt`}])}function createWorkflowSandboxOptions(e,t){return{continuationSecurity:t,executionPolicy:{maxBridgeRequests:e,maxInFlightBridgeRequests:e}}}async function loadWorkflowSandboxModule(){let e=globalThis[WORKFLOW_SANDBOX_MODULE_KEY];return e===void 0?(workflowSandboxModulePromise??=importWorkflowSandboxModule(WORKFLOW_SANDBOX_MODULE_SPECIFIER),await workflowSandboxModulePromise):e}async function importWorkflowSandboxModule(e){let t=await import(e);return{CodeModeToolError:t.CodeModeToolError,continueCodeModeInterrupt:t.experimental_continueCodeModeInterrupt,createCodeModeTool:t.experimental_createCodeModeTool,requestCodeModeInterrupt:t.experimental_requestCodeModeInterrupt,unwrapCodeModeResult:t.experimental_unwrapCodeModeResult}}export{continueWorkflowSandboxInterrupt,createParkingHostTool,createWorkflowSandboxTool,getWorkflowSandboxPendingInterrupts,installWorkflowSandboxModule,unwrapWorkflowSandboxResult};
+const WORKFLOW_SANDBOX_MODULE_KEY=Symbol.for(`eve.workflowSandbox.module`),WORKFLOW_SANDBOX_MODULE_SPECIFIER=[`#compiled`,`run`,`index.js`].join(`/`);let workflowSandboxModulePromise;function installWorkflowSandboxModule(e){globalThis[WORKFLOW_SANDBOX_MODULE_KEY]=e}async function loadWorkflowSandboxModule(){let e=globalThis[WORKFLOW_SANDBOX_MODULE_KEY];return e===void 0?(workflowSandboxModulePromise??=import(WORKFLOW_SANDBOX_MODULE_SPECIFIER),await workflowSandboxModulePromise):e}export{installWorkflowSandboxModule,loadWorkflowSandboxModule};

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-DlznYwQk.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-3-WRmJkd.js";
 
 //#region src/client/tool-call-state.ts
 function toolCallState(conversation, callId, options = {}) {

package/dist/src/svelte/use-eve-agent.d.ts

@@ -110,7 +110,7 @@ export interface UseEveAgentOptions<TData> extends EveAgentStoreCallbacks<TData>
      * on the next send, answer, or resume. @default true
      */
     readonly followIdle?: boolean;
-    /** Prewarm an owned session on mount and after reset. @default false */
+    /** Create a session or prepare its existing idle owner on mount and after reset. @default false */
     readonly prewarm?: boolean;
     /**
      * Projects stream events into `TData`. Defaults to the conversation reducer.

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

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