eve 0.63.0 → 0.64.1

package/dist/src/shared/default-agent-model.d.ts

@@ -2,4 +2,4 @@
  * Model used when an agent does not declare one, baked in by `eve init`, and
  * pre-selected in the setup model picker.
  */
-export declare const DEFAULT_AGENT_MODEL_ID = "openai/gpt-5.6-luna-fast";
+export declare const DEFAULT_AGENT_MODEL_ID = "spacexai/grok-4.7";

package/dist/src/shared/default-agent-model.js

@@ -1 +1 @@
-const DEFAULT_AGENT_MODEL_ID=`openai/gpt-5.6-luna-fast`;export{DEFAULT_AGENT_MODEL_ID};
+const DEFAULT_AGENT_MODEL_ID=`spacexai/grok-4.7`;export{DEFAULT_AGENT_MODEL_ID};

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

@@ -0,0 +1,45 @@
+import type { SessionAuth, SessionParent, SessionTurn } from "#context/keys.js";
+import type { SandboxProviderRuntime } from "#shared/sandbox-provider.js";
+import type { RuntimeSandboxSession, RuntimeSandboxSessionFor, SandboxSession } from "#shared/sandbox-session.js";
+declare const ENVIRONMENT: unique symbol;
+declare const PROVIDER_RUNTIME: unique symbol;
+declare const CONFIGURATION_HASH: unique symbol;
+export interface SandboxSelectorContext {
+    readonly session: {
+        readonly auth: SessionAuth;
+        readonly id: string;
+        readonly parent?: SessionParent;
+        readonly turn: SessionTurn;
+    };
+}
+export type SandboxSelector = (context: SandboxSelectorContext) => Promise<RuntimeSandboxSession> | RuntimeSandboxSession;
+export type SandboxOpenArguments<Options> = Options extends undefined ? [] : Record<never, never> extends Options ? [options?: Options] : [options: Options];
+export interface SandboxEnvironmentIdentity {
+    readonly [CONFIGURATION_HASH]: string;
+    readonly [ENVIRONMENT]: true;
+    readonly [PROVIDER_RUNTIME]: SandboxProviderRuntime;
+    readonly provider: string;
+}
+export interface SandboxEnvironment<Options extends object | undefined = object, Session extends SandboxSession = SandboxSession> extends SandboxEnvironmentIdentity {
+    open(...args: SandboxOpenArguments<Options>): Promise<RuntimeSandboxSessionFor<Session>>;
+}
+interface ConstructorRuntime {
+    open(input: {
+        readonly configurationHash: string;
+        readonly environment: object;
+        readonly environmentConfigurationHash: string;
+        readonly options: object | undefined;
+        readonly provider: SandboxProviderRuntime;
+    }): Promise<RuntimeSandboxSession>;
+}
+export declare function createSandboxEnvironment<Options extends object | undefined = object, Session extends SandboxSession = SandboxSession>(input: {
+    readonly configuration?: unknown;
+    readonly runtime: SandboxProviderRuntime;
+}): SandboxEnvironment<Options, Session>;
+export declare function getSandboxEnvironmentConfigurationHash(environment: SandboxEnvironmentIdentity): string;
+export declare function getSandboxEnvironmentRuntime(environment: SandboxEnvironmentIdentity): SandboxProviderRuntime;
+export declare function bindSandboxEnvironment(selector: SandboxSelector, environment: SandboxEnvironmentIdentity): SandboxSelector;
+export declare function getBoundSandboxEnvironment(value: unknown): SandboxEnvironmentIdentity | undefined;
+export declare function isSandboxEnvironment(value: unknown): value is SandboxEnvironmentIdentity;
+export declare function runWithSandboxConstructorRuntime<T>(runtime: ConstructorRuntime, callback: () => Promise<T> | T): Promise<T>;
+export {};

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

@@ -0,0 +1 @@
+import{createHash}from"node:crypto";import{ContextContainer,contextStorage}from"#context/container.js";const ENVIRONMENT=Symbol.for(`eve.sandbox-environment`),PROVIDER_RUNTIME=Symbol.for(`eve.sandbox-provider-runtime`),CONFIGURATION_HASH=Symbol.for(`eve.sandbox-environment-configuration-hash`),SELECTOR_ENVIRONMENT=Symbol.for(`eve.sandbox-selector-environment`),RUNTIMES=Symbol.for(`eve.sandbox-constructor-runtimes`),globals=globalThis,runtimes=globals[RUNTIMES]??=new WeakMap;function createSandboxEnvironment(e){let t;return t={[CONFIGURATION_HASH]:hashConstructorOptions({environment:e.configuration,sandbox:{}}),[ENVIRONMENT]:!0,[PROVIDER_RUNTIME]:e.runtime,provider:e.runtime.providerName,async open(...n){let r=n[0],i=contextStorage.getStore(),a=i===void 0?void 0:runtimes.get(i);if(a===void 0)throw Error(`Sandbox environments can only open sandboxes inside defineSandbox().`);return await a.open({configurationHash:hashConstructorOptions({environment:e.configuration,sandbox:r}),environment:t,environmentConfigurationHash:t[CONFIGURATION_HASH],options:r,provider:e.runtime})}},t}function hashConstructorOptions(e){return createHash(`sha256`).update(stableSerialize(e)).digest(`hex`)}function stableSerialize(e,t=new WeakSet){if(e===null||typeof e==`boolean`||typeof e==`number`||typeof e==`string`)return JSON.stringify(e);if(typeof e==`function`)return`function:${e.toString()}`;if(Array.isArray(e))return`[${e.map(e=>stableSerialize(e,t)).join(`,`)}]`;if(typeof e==`object`){if(t.has(e))return`[circular]`;t.add(e);let n=e.constructor?.name??`Object`,r=`{${Object.entries(e).sort(([e],[t])=>e.localeCompare(t)).map(([e,n])=>`${JSON.stringify(e)}:${stableSerialize(n,t)}`).join(`,`)}}`;return t.delete(e),`${n}:${r}`}return typeof e}function getSandboxEnvironmentConfigurationHash(e){return e[CONFIGURATION_HASH]}function getSandboxEnvironmentRuntime(e){return e[PROVIDER_RUNTIME]}function bindSandboxEnvironment(e,t){return Object.defineProperty(e,SELECTOR_ENVIRONMENT,{value:t}),e}function getBoundSandboxEnvironment(e){let t=typeof e==`function`?Reflect.get(e,SELECTOR_ENVIRONMENT):void 0;return isSandboxEnvironment(t)?t:void 0}function isSandboxEnvironment(e){return typeof e==`object`&&!!e&&Reflect.get(e,ENVIRONMENT)===!0&&typeof Reflect.get(e,`provider`)==`string`&&typeof Reflect.get(e,`open`)==`function`}async function runWithSandboxConstructorRuntime(e,t){let n=contextStorage.getStore(),r=n??new ContextContainer,i=runtimes.get(r);runtimes.set(r,e);try{return n===void 0?await contextStorage.run(r,t):await t()}finally{i===void 0?runtimes.delete(r):runtimes.set(r,i)}}export{bindSandboxEnvironment,createSandboxEnvironment,getBoundSandboxEnvironment,getSandboxEnvironmentConfigurationHash,getSandboxEnvironmentRuntime,isSandboxEnvironment,runWithSandboxConstructorRuntime};

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

@@ -2,7 +2,7 @@ import type * as Vercel from "#compiled/@vercel/sandbox/index.js";
 /**
  * Firewall network policy applied to a live sandbox session.
  *
- * eve-owned alias of the backend network-policy shape. Use it to restrict
+ * 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:
@@ -17,9 +17,14 @@ import type * as Vercel from "#compiled/@vercel/sandbox/index.js";
  * });
  * ```
  *
- * The Docker backend honors only the coarse `"allow-all"` and
- * `"deny-all"` policies; the just-bash backend rejects `setNetworkPolicy`
+ * The Docker provider honors only the coarse `"allow-all"` and
+ * `"deny-all"` policies; the just-bash provider rejects `setNetworkPolicy`
  * entirely (its network policy is fixed at sandbox creation and it runs
  * no binaries to govern).
  */
 export type SandboxNetworkPolicy = Vercel.NetworkPolicy;
+/** Initial network configuration shared by network-capable sandbox providers. */
+export interface SandboxNetworkOptions {
+    readonly networkPolicy?: SandboxNetworkPolicy;
+}
+export declare function isSandboxNetworkPolicy(value: unknown): value is SandboxNetworkPolicy;

package/dist/src/shared/sandbox-network-policy.js

@@ -1 +1 @@
-export{};
+function isSandboxNetworkPolicy(e){return e===`allow-all`||e===`deny-all`?!0:!isRecord(e)||!hasOnlyKeys(e,[`allow`,`subnets`])||e.allow!==void 0&&!isNetworkAllowList(e.allow)?!1:e.subnets===void 0||isSubnetPolicy(e.subnets)}function isNetworkAllowList(e){return isStringArray(e)?!0:isRecord(e)?Object.values(e).every(e=>Array.isArray(e)&&e.every(isNetworkPolicyRule)):!1}function isNetworkPolicyRule(e){if(!isRecord(e)||!hasOnlyKeys(e,[`forwardURL`,`match`,`transform`])||e.match!==void 0&&!isNetworkPolicyMatch(e.match))return!1;let t=e.transform!==void 0,n=e.forwardURL!==void 0;return t===n?!1:n?typeof e.forwardURL==`string`:Array.isArray(e.transform)&&e.transform.every(e=>isRecord(e)&&hasOnlyKeys(e,[`headers`])&&(e.headers===void 0||isStringRecord(e.headers)))}function isNetworkPolicyMatch(e){return!isRecord(e)||!hasOnlyKeys(e,[`headers`,`method`,`path`,`queryString`])?!1:(e.path===void 0||isNetworkPolicyMatcher(e.path))&&(e.method===void 0||isStringArray(e.method))&&(e.queryString===void 0||isKeyValueMatcherArray(e.queryString))&&(e.headers===void 0||isKeyValueMatcherArray(e.headers))}function isKeyValueMatcherArray(e){return Array.isArray(e)&&e.every(e=>isRecord(e)&&hasOnlyKeys(e,[`key`,`value`])&&(e.key===void 0||isNetworkPolicyMatcher(e.key))&&(e.value===void 0||isNetworkPolicyMatcher(e.value)))}function isNetworkPolicyMatcher(e){if(!isRecord(e)||!hasOnlyKeys(e,[`exact`,`regex`,`startsWith`]))return!1;let t=[e.exact,e.startsWith,e.regex];return t.filter(e=>e!==void 0).length===1&&t.every(e=>e===void 0||typeof e==`string`)}function isSubnetPolicy(e){return isRecord(e)&&hasOnlyKeys(e,[`allow`,`deny`])&&(e.allow===void 0||isStringArray(e.allow))&&(e.deny===void 0||isStringArray(e.deny))}function isStringArray(e){return Array.isArray(e)&&e.every(e=>typeof e==`string`)}function isStringRecord(e){return isRecord(e)&&Object.values(e).every(e=>typeof e==`string`)}function hasOnlyKeys(e,t){return Object.keys(e).every(e=>t.includes(e))}function isRecord(e){return typeof e==`object`&&!!e&&!Array.isArray(e)}export{isSandboxNetworkPolicy};

package/dist/src/shared/sandbox-prepared-artifacts.d.ts

@@ -0,0 +1,16 @@
+import { z } from "#compiled/zod/index.js";
+import type { SandboxPreparedArtifact } from "#shared/sandbox-provider.js";
+export declare const SANDBOX_PREPARED_ARTIFACTS_KIND = "eve-sandbox-prepared-artifacts";
+export declare const SANDBOX_PREPARED_ARTIFACTS_VERSION = 2;
+export interface SandboxPreparedArtifactEntry {
+    readonly artifact: SandboxPreparedArtifact;
+    readonly nodeId: string;
+    readonly providerName: string;
+}
+export interface SandboxPreparedArtifactsManifest {
+    readonly entries: readonly SandboxPreparedArtifactEntry[];
+    readonly kind: typeof SANDBOX_PREPARED_ARTIFACTS_KIND;
+    readonly version: typeof SANDBOX_PREPARED_ARTIFACTS_VERSION;
+}
+export declare const sandboxPreparedArtifactsManifestSchema: z.ZodType<SandboxPreparedArtifactsManifest>;
+export declare function createSandboxPreparedArtifactsManifest(entries: readonly SandboxPreparedArtifactEntry[]): SandboxPreparedArtifactsManifest;

package/dist/src/shared/sandbox-prepared-artifacts.js

@@ -0,0 +1 @@
+import{z}from"#compiled/zod/index.js";const SANDBOX_PREPARED_ARTIFACTS_KIND=`eve-sandbox-prepared-artifacts`,SANDBOX_PREPARED_ARTIFACTS_VERSION=2,sandboxPreparedArtifactSchema=z.lazy(()=>z.union([z.null(),z.boolean(),z.number(),z.string(),z.array(sandboxPreparedArtifactSchema),z.record(z.string(),sandboxPreparedArtifactSchema)])),sandboxPreparedArtifactsManifestSchema=z.object({entries:z.array(z.object({artifact:sandboxPreparedArtifactSchema,nodeId:z.string().min(1),providerName:z.string().min(1)}).strict()),kind:z.literal(SANDBOX_PREPARED_ARTIFACTS_KIND),version:z.literal(2)}).strict();function createSandboxPreparedArtifactsManifest(e){return{entries:[...e].sort((e,t)=>e.nodeId.localeCompare(t.nodeId)),kind:SANDBOX_PREPARED_ARTIFACTS_KIND,version:2}}export{SANDBOX_PREPARED_ARTIFACTS_KIND,SANDBOX_PREPARED_ARTIFACTS_VERSION,createSandboxPreparedArtifactsManifest,sandboxPreparedArtifactsManifestSchema};

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

@@ -0,0 +1,112 @@
+import { type SandboxEnvironment, type SandboxSelectorContext } from "#shared/sandbox-environment.js";
+import type { SandboxSession } from "#shared/sandbox-session.js";
+export interface SandboxDeleteOptions {
+    readonly abortSignal?: AbortSignal;
+}
+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>;
+    onSessionDelete(options?: SandboxDeleteOptions): Promise<void>;
+    onSessionStop(): Promise<void>;
+}
+export interface SandboxProviderImplementation<OpenOptions extends object | undefined, PreparedArtifact extends SandboxPreparedArtifact, SessionState, Session extends SandboxSession = SandboxSession> {
+    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

@@ -0,0 +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};

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

@@ -1,5 +1,5 @@
 import type { Experimental_SandboxSession as AiSdkSandbox } from "ai";
-import type { SandboxDeleteOptions } from "#shared/sandbox-backend.js";
+import type { SandboxDeleteOptions } from "#shared/sandbox-provider.js";
 import type { SandboxNetworkPolicy } from "#shared/sandbox-network-policy.js";
 /**
  * Options for running one command in a sandbox. Shape mirrors the AI
@@ -70,26 +70,14 @@ export interface SandboxRemovePathOptions {
  * 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. `id` and
- * `resolvePath` are eve-specific extensions that the runtime relies on
- * for caching and `/workspace` path anchoring.
+ * 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 backend. Absolute paths pass through unchanged.
+ * for every provider. Absolute paths pass through unchanged.
  *
  */
 export interface SandboxSession extends Pick<AiSdkSandbox, "run" | "spawn" | "readFile" | "readBinaryFile" | "readTextFile" | "writeFile" | "writeBinaryFile" | "writeTextFile"> {
-    /**
-     * Stable identifier for the backend session this handle wraps.
-     *
-     * Persists across reconnects to the same logical session: two calls
-     * that resume the same underlying backend sandbox observe the same
-     * `id`. Template sessions constructed during bootstrap expose the
-     * template key; live sessions expose the session key assigned by the
-     * runtime. Useful as a cache key for per-session state that must
-     * outlive individual step executions.
-     */
-    readonly id: string;
     /**
      * Anchors a sandbox-relative path to `/workspace` and returns the
      * resulting absolute path.
@@ -98,21 +86,8 @@ export interface SandboxSession extends Pick<AiSdkSandbox, "run" | "spawn" | "re
      * The read and write methods already apply this internally.
      */
     resolvePath(path: string): string;
-    /**
-     * Applies a firewall network policy to this live sandbox at run time,
-     * for changing the policy *during* a turn (e.g. brokering a credential
-     * resolved mid-turn, or tightening egress after fetching data). A
-     * per-domain `transform` injects headers at the firewall so secrets
-     * never enter the sandbox process. The policy takes effect from the time
-     * the call resolves, so await it before the egress you want governed.
-     *
-     * When the policy is known at session start, prefer configuring it up
-     * front in the sandbox backend factory or `onSession`'s `use()`. The
-     * Docker backend honors only `"allow-all"` and `"deny-all"`;
-     * the just-bash backend rejects this call entirely (its network policy
-     * is fixed at sandbox creation and it runs no binaries to govern).
-     */
-    setNetworkPolicy(policy: SandboxNetworkPolicy): Promise<void>;
+    /** Applies a firewall policy when the selected provider supports mutable networking. */
+    setNetworkPolicy?(policy: SandboxNetworkPolicy): Promise<void>;
     /**
      * Removes one file or directory from the sandbox filesystem.
      *
@@ -127,37 +102,39 @@ export interface SandboxSession extends Pick<AiSdkSandbox, "run" | "spawn" | "re
  * Unlike the I/O-only session used during sandbox initialization, this handle
  * exposes provider-backed lifecycle operations.
  */
+export interface MutableNetworkSandboxSession extends SandboxSession {
+    /** Applies a firewall policy to the live sandbox. */
+    setNetworkPolicy(policy: SandboxNetworkPolicy): Promise<void>;
+}
+export type FixedNetworkSandboxSession = Omit<SandboxSession, "setNetworkPolicy">;
 export interface RuntimeSandboxSession extends SandboxSession {
-    /** Permanently deletes this sandbox and its disposable backend state. */
+    /** Permanently deletes this sandbox and its disposable provider state. */
     delete(options?: SandboxDeleteOptions): Promise<void>;
     /**
      * Stops the backing sandbox compute while preserving the durable session.
      * A later runtime callback reopens the session through its configured
-     * backend. Providers may also support resuming the same handle.
+     * provider. Providers may also support resuming the same handle.
      */
     stop(): Promise<void>;
 }
+export type RuntimeSandboxSessionFor<Session extends SandboxSession> = Session & Pick<RuntimeSandboxSession, "delete" | "stop">;
 /**
  * Internal sandbox session, used to construct the public {@link SandboxSession}.
  *
- * Backend implementers only need to provide byte-oriented file I/O and
+ * 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 backends look symmetric with
+ * 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"> {
-    /**
-     * Stable identifier surfaced on the public {@link SandboxSession}.
-     */
-    readonly id: string;
-    /** Removes an already-resolved path from the backend filesystem. */
+    /** Removes an already-resolved path from the provider filesystem. */
     removePath(options: SandboxRemovePathOptions): Promise<void>;
-    /** Translates a user-facing path to the backend's native path. */
+    /** Translates a user-facing path to the provider's native path. */
     resolvePath(path: string): string;
 }

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

@@ -0,0 +1,9 @@
+export declare class SandboxTemplateNotProvisionedError extends Error {
+    readonly providerName: string;
+    readonly templateKey: string;
+    constructor(input: {
+        readonly providerName: string;
+        readonly templateKey: string;
+    });
+    static is(error: unknown): error is SandboxTemplateNotProvisionedError;
+}

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

@@ -0,0 +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};

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

@@ -32,7 +32,7 @@ export interface SubagentSandboxGraph {
         readonly sandboxRegistry: {
             readonly sandbox: {
                 readonly definition: {
-                    readonly inheritsParent?: boolean;
+                    readonly kind: "independent" | "parent";
                 };
             } | null;
         };

package/dist/src/subagents/tool.js

@@ -1 +1 @@
-import{mintSubagentContinuationToken}from"#execution/session.js";import{formatSubagentInput,normalizeRequestedOutputSchema}from"#subagents/invocation.js";import{SUBAGENT_ADAPTER_KIND}from"#subagents/adapter-state.js";import{resolveRemainingSessionTokenLimits}from"#subagents/token-budget.js";function buildSubagentRunInput(e){let{action:t,auth:n,capabilities:r,channelMetadata:i,inheritedConversation:a,initiatorAuth:o,session:s,source:c}=e,l=mintSubagentContinuationToken(`${s.sessionId}:${t.callId}`),u=resolveRemainingSessionTokenLimits(s,e.fanoutSize),d=normalizeRequestedOutputSchema(t.input.outputSchema),f={callId:t.callId,parentContinuationToken:e.parent.continuationToken??s.continuationToken,parentSessionId:s.sessionId,subagentName:t.subagentName};e.taskId!==void 0&&(f.taskId=e.taskId),(e.graph?.nodesByNodeId.get(t.nodeId)?.sandboxRegistry.sandbox?.definition.inheritsParent===!0||e.selfAgent)&&(s.sandboxState!==void 0&&(f.parentSandboxState=s.sandboxState),f.sandboxSessionId=e.sandboxSessionId??s.sessionId);let p={adapter:{kind:SUBAGENT_ADAPTER_KIND,state:f},auth:n,capabilities:r,channelMetadata:i,inheritedConversation:a,continuationToken:l,initiatorAuth:o,input:{message:formatSubagentCallInputMessage({action:t,source:c}),outputSchema:d??c.outputSchema},limits:u,mode:`conversation`,conversationId:e.parent.conversationId,parent:e.parent.lineage,parentTraceContext:e.parent.traceContext,activityObserver:e.activityObserver};return e.taskId!==void 0&&(p.taskId=e.taskId),{childContinuationToken:l,runInput:p}}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{mintSubagentContinuationToken}from"#execution/session.js";import{formatSubagentInput,normalizeRequestedOutputSchema}from"#subagents/invocation.js";import{SUBAGENT_ADAPTER_KIND}from"#subagents/adapter-state.js";import{resolveRemainingSessionTokenLimits}from"#subagents/token-budget.js";function buildSubagentRunInput(e){let{action:t,auth:n,capabilities:r,channelMetadata:i,inheritedConversation:a,initiatorAuth:o,session:s,source:c}=e,l=mintSubagentContinuationToken(`${s.sessionId}:${t.callId}`),u=resolveRemainingSessionTokenLimits(s,e.fanoutSize),d=normalizeRequestedOutputSchema(t.input.outputSchema),f={callId:t.callId,parentContinuationToken:e.parent.continuationToken??s.continuationToken,parentSessionId:s.sessionId,subagentName:t.subagentName};e.taskId!==void 0&&(f.taskId=e.taskId),(e.graph?.nodesByNodeId.get(t.nodeId)?.sandboxRegistry.sandbox?.definition.kind===`parent`||e.selfAgent)&&(s.sandboxState!==void 0&&(f.parentSandboxState=s.sandboxState),f.sandboxSessionId=e.sandboxSessionId??s.sessionId);let p={adapter:{kind:SUBAGENT_ADAPTER_KIND,state:f},auth:n,capabilities:r,channelMetadata:i,inheritedConversation:a,continuationToken:l,initiatorAuth:o,input:{message:formatSubagentCallInputMessage({action:t,source:c}),outputSchema:d??c.outputSchema},limits:u,mode:`conversation`,conversationId:e.parent.conversationId,parent:e.parent.lineage,parentTraceContext:e.parent.traceContext,activityObserver:e.activityObserver};return e.taskId!==void 0&&(p.taskId=e.taskId),{childContinuationToken:l,runInput:p}}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,3 +1,3 @@
-import { n as defaultMessageReducer, t as useEveAgent } from "../chunks/use-eve-agent-CVWk5KKy.js";
+import { n as defaultMessageReducer, t as useEveAgent } from "../chunks/use-eve-agent-IIuxkn6y.js";
 
 export { defaultMessageReducer, useEveAgent };

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

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

package/dist/src/tasks/delivery-context.d.ts

@@ -1,8 +1,9 @@
-import type { DeliverHookPayload } from "#channel/types.js";
+import type { TaskDeliveryPolicy, DeliverHookPayload } from "#channel/types.js";
 import type { SessionStateMap, StepInput } from "#harness/types.js";
 export declare const TASK_DELIVERY_CONTEXT_LABEL = "[Task state]";
 export declare const TASK_DELIVERY_INITIATING_INSTRUCTION = "Background task reporting: launch acknowledgement\nThe latest [Task state] message is runtime-authored and lists background tasks accepted so far from the current turn. They continue independently after this turn.\n\nContinue carrying out the user's request, including starting any remaining background work. When no further tool calls are needed in this turn, send one brief user-facing acknowledgement that the background work has started. Do not wait for results or report results that are not available yet. End the turn after the acknowledgement.";
-export declare const TASK_DELIVERY_SETTLED_INSTRUCTION = "Background task reporting\nThis turn was triggered by background task activity. The accompanying [Task state] message is runtime-authored and lists overlapping background tasks in the same cohort, potentially started across different user turns, all settled, with every available terminal output. Do not reply with <eve-empty-delivery/>. Send one user-facing response that combines their useful results.";
+export declare const TASK_DELIVERY_SETTLED_INSTRUCTION = "Background task reporting\nFor this background-task update, the accompanying [Task state] message is runtime-authored and lists the settled tasks in this cohort and their available terminal outputs. Report their useful results together in one user-facing response without repeating results already reported. Do not reply with <eve-empty-delivery/>.";
+export declare const TASK_DELIVERY_AUTO_INSTRUCTION = "Background task reporting\nFor this background-task update, the accompanying [Task state] message is runtime-authored and lists the whole cohort, including pending tasks and every available terminal output. A received result has not necessarily been reported to the user. Report new results only when they are useful independently of unfinished work. When that work settles, combine its results with any previously withheld results. If there is nothing new and useful to report, reply with exactly <eve-empty-delivery/>. Do not repeat results already reported or send an acknowledgement just to say you are waiting.";
 type BackgroundTaskDelivery = DeliverHookPayload & {
     readonly taskDeliveryId: string;
 };
@@ -10,10 +11,11 @@ type BackgroundTaskDelivery = DeliverHookPayload & {
 export declare function getBackgroundTaskDelivery(input: unknown): BackgroundTaskDelivery | undefined;
 /** Marks a task-produced user message before the harness coalesces delivery results. */
 export declare function markBackgroundTaskStepInput(input: StepInput): StepInput;
-/** Groups overlapping tasks without changing the delivered task's activity root. */
+/** Projects the report group without changing the delivered task's activity root. */
 export declare function resolveTaskDeliveryContext(input: {
     readonly state: SessionStateMap | undefined;
-    readonly taskDeliveryId: string;
+    readonly taskDeliveryIds: readonly string[];
+    readonly taskDeliveryPolicy: TaskDeliveryPolicy;
 }): {
     readonly context: string;
     readonly phase: "pending" | "settled";

package/dist/src/tasks/delivery-context.js

@@ -1,4 +1,4 @@
 import{markFrameworkStepInput}from"#harness/messages.js";import{getBackgroundWorkflowToolRuns,readWorkflowTaskView}from"#harness/workflow-tool-runs.js";import{getTaskCohortId}from"#tasks/session-task-cohorts.js";import{EMPTY_DELIVERY_SENTINEL}from"#shared/empty-delivery.js";const TASK_DELIVERY_CONTEXT_LABEL=`[Task state]`,TASK_DELIVERY_INITIATING_INSTRUCTION=`Background task reporting: launch acknowledgement
 The latest ${TASK_DELIVERY_CONTEXT_LABEL} message is runtime-authored and lists background tasks accepted so far from the current turn. They continue independently after this turn.
 
-Continue carrying out the user's request, including starting any remaining background work. When no further tool calls are needed in this turn, send one brief user-facing acknowledgement that the background work has started. Do not wait for results or report results that are not available yet. End the turn after the acknowledgement.`,TASK_DELIVERY_SETTLED_INSTRUCTION=`Background task reporting\nThis turn was triggered by background task activity. The accompanying ${TASK_DELIVERY_CONTEXT_LABEL} message is runtime-authored and lists overlapping background tasks in the same cohort, potentially started across different user turns, all settled, with every available terminal output. Do not reply with ${EMPTY_DELIVERY_SENTINEL}. Send one user-facing response that combines their useful results.`;function getBackgroundTaskDelivery(e){if(typeof e!=`object`||!e)return;let t=e;return t.kind===`deliver`&&typeof t.taskDeliveryId==`string`?e:void 0}function markBackgroundTaskStepInput(e){return e.message===void 0?e:markFrameworkStepInput(e,`execution.background_task`)}function resolveTaskDeliveryContext(e){let t=getBackgroundWorkflowToolRuns(e.state),n=t.find(t=>e.taskDeliveryId.startsWith(`${t.task.taskId}:`));return n===void 0?void 0:{...projectTaskCohort(t.filter(e=>getTaskCohortId(e.task)===getTaskCohortId(n.task))),rootTurnId:n.origin.turnId}}function resolveInitiatingTaskContext(e){let t=getBackgroundWorkflowToolRuns(e.state).filter(t=>t.origin.turnId===e.turnId);if(t.some(e=>e.task.outcome===void 0))return{...projectTaskCohort(t),phase:`initiating`}}function projectTaskCohort(e){let t=e.every(e=>e.task.outcome!==void 0),n=e.map(e=>{let n=readWorkflowTaskView(e.task);return{name:e.task.metadata.name,output:t?n?.lastOutput:void 0,status:n?.status??`pending`,taskId:e.task.taskId}});return{context:`${TASK_DELIVERY_CONTEXT_LABEL}\n${JSON.stringify({tasks:n})}`,phase:t?`settled`:`pending`}}export{TASK_DELIVERY_CONTEXT_LABEL,TASK_DELIVERY_INITIATING_INSTRUCTION,TASK_DELIVERY_SETTLED_INSTRUCTION,getBackgroundTaskDelivery,markBackgroundTaskStepInput,resolveInitiatingTaskContext,resolveTaskDeliveryContext};
+Continue carrying out the user's request, including starting any remaining background work. When no further tool calls are needed in this turn, send one brief user-facing acknowledgement that the background work has started. Do not wait for results or report results that are not available yet. End the turn after the acknowledgement.`,TASK_DELIVERY_SETTLED_INSTRUCTION=`Background task reporting\nFor this background-task update, the accompanying ${TASK_DELIVERY_CONTEXT_LABEL} message is runtime-authored and lists the settled tasks in this cohort and their available terminal outputs. Report their useful results together in one user-facing response without repeating results already reported. Do not reply with ${EMPTY_DELIVERY_SENTINEL}.`,TASK_DELIVERY_AUTO_INSTRUCTION=`Background task reporting\nFor this background-task update, the accompanying ${TASK_DELIVERY_CONTEXT_LABEL} message is runtime-authored and lists the whole cohort, including pending tasks and every available terminal output. A received result has not necessarily been reported to the user. Report new results only when they are useful independently of unfinished work. When that work settles, combine its results with any previously withheld results. If there is nothing new and useful to report, reply with exactly ${EMPTY_DELIVERY_SENTINEL}. Do not repeat results already reported or send an acknowledgement just to say you are waiting.`;function getBackgroundTaskDelivery(e){if(typeof e!=`object`||!e)return;let t=e;return t.kind===`deliver`&&typeof t.taskDeliveryId==`string`?e:void 0}function markBackgroundTaskStepInput(e){return e.message===void 0?e:markFrameworkStepInput(e,`execution.background_task`)}function resolveTaskDeliveryContext(e){let t=e.taskDeliveryIds[0];if(t===void 0)return;let n=getBackgroundWorkflowToolRuns(e.state),r=n.find(e=>t.startsWith(`${e.task.taskId}:`));return r===void 0?void 0:{...projectTaskCohort(n.filter(e=>getTaskCohortId(e.task)===getTaskCohortId(r.task)),e.taskDeliveryPolicy===`auto`),rootTurnId:r.origin.turnId}}function resolveInitiatingTaskContext(e){let t=getBackgroundWorkflowToolRuns(e.state).filter(t=>t.origin.turnId===e.turnId);if(t.some(e=>e.task.outcome===void 0))return{...projectTaskCohort(t,!1),phase:`initiating`}}function projectTaskCohort(e,t){let n=e.every(e=>e.task.outcome!==void 0),r=e.map(e=>{let r=readWorkflowTaskView(e.task);return{name:e.task.metadata.name,output:n||t?r?.lastOutput:void 0,status:r?.status??`pending`,taskId:e.task.taskId}});return{context:`${TASK_DELIVERY_CONTEXT_LABEL}\n${JSON.stringify({tasks:r})}`,phase:n?`settled`:`pending`}}export{TASK_DELIVERY_AUTO_INSTRUCTION,TASK_DELIVERY_CONTEXT_LABEL,TASK_DELIVERY_INITIATING_INSTRUCTION,TASK_DELIVERY_SETTLED_INSTRUCTION,getBackgroundTaskDelivery,markBackgroundTaskStepInput,resolveInitiatingTaskContext,resolveTaskDeliveryContext};

package/dist/src/tasks/delivery-policy.d.ts

@@ -1,3 +1,4 @@
+import type { TaskDeliveryPolicy } from "#channel/types.js";
 export interface DeliveryPolicy {
     readonly allowsEmptyDelivery: boolean;
     readonly instruction?: string;
@@ -8,5 +9,6 @@ export declare function resolveDeliveryPolicy(input: {
     readonly isChild: boolean;
     readonly isFirstTurn: boolean;
     readonly hasScheduleProvenance: boolean;
+    readonly taskDeliveryPolicy: TaskDeliveryPolicy | undefined;
     readonly taskDeliveryPhase: "none" | "initiating" | "pending" | "settled" | undefined;
 }): DeliveryPolicy;

package/dist/src/tasks/delivery-policy.js

@@ -1 +1 @@
-import{TASK_DELIVERY_INITIATING_INSTRUCTION,TASK_DELIVERY_SETTLED_INSTRUCTION}from"#tasks/delivery-context.js";import{CONDITIONAL_DELIVERY_INSTRUCTION}from"#shared/empty-delivery.js";const POLICIES={conditional:{allowsEmptyDelivery:!0,instruction:CONDITIONAL_DELIVERY_INSTRUCTION},initiating:{allowsEmptyDelivery:!1,instruction:TASK_DELIVERY_INITIATING_INSTRUCTION},normal:{allowsEmptyDelivery:!1},pending:{allowsEmptyDelivery:!0},settled:{allowsEmptyDelivery:!1,instruction:TASK_DELIVERY_SETTLED_INSTRUCTION}};function resolveDeliveryPolicy(e){return e.hasOutputSchema||e.isChild?POLICIES.normal:e.taskDeliveryPhase===`pending`?POLICIES.pending:e.taskDeliveryPhase===`settled`?POLICIES.settled:e.isFirstTurn&&e.hasScheduleProvenance?POLICIES.conditional:e.taskDeliveryPhase===`initiating`?POLICIES.initiating:POLICIES.normal}export{resolveDeliveryPolicy};
+import{TASK_DELIVERY_AUTO_INSTRUCTION,TASK_DELIVERY_INITIATING_INSTRUCTION,TASK_DELIVERY_SETTLED_INSTRUCTION}from"#tasks/delivery-context.js";import{CONDITIONAL_DELIVERY_INSTRUCTION}from"#shared/empty-delivery.js";const POLICIES={auto:{allowsEmptyDelivery:!0,instruction:TASK_DELIVERY_AUTO_INSTRUCTION},conditional:{allowsEmptyDelivery:!0,instruction:CONDITIONAL_DELIVERY_INSTRUCTION},initiating:{allowsEmptyDelivery:!1,instruction:TASK_DELIVERY_INITIATING_INSTRUCTION},normal:{allowsEmptyDelivery:!1},pending:{allowsEmptyDelivery:!0},settled:{allowsEmptyDelivery:!1,instruction:TASK_DELIVERY_SETTLED_INSTRUCTION}};function resolveDeliveryPolicy(e){return e.hasOutputSchema||e.isChild?POLICIES.normal:e.taskDeliveryPolicy===`auto`&&(e.taskDeliveryPhase===`pending`||e.taskDeliveryPhase===`settled`)?POLICIES.auto:e.taskDeliveryPhase===`pending`?POLICIES.pending:e.taskDeliveryPhase===`settled`?POLICIES.settled:e.isFirstTurn&&e.hasScheduleProvenance?POLICIES.conditional:e.taskDeliveryPhase===`initiating`?POLICIES.initiating:POLICIES.normal}export{resolveDeliveryPolicy};

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

@@ -1 +1 @@
-import{z}from"#compiled/zod/index.js";const AGENT_TOOL_NAME=`agent`,AGENT_TOOL_DESCRIPTION=["Delegate a focused subtask to a copy of yourself, or continue or steer a previous delegation with `agentId`.",`Use it to isolate complex work or split a large task into independent pieces.`,"Issue multiple `agent` calls in one response to run a small fixed set in parallel.","A new child has fresh history and state but shares your tools and sandbox, so include essential context in `message` and give parallel writers non-overlapping scopes."].join(` `),SUBAGENT_TOOL_INPUT_SCHEMA=z.strictObject({agentId:z.string().nullable().describe(`The id of an existing agent from the <agents> list or a task receipt. A message to a busy agent steers it: its previous task is cancelled and the updated work runs in the same child session. Omit this field (or pass null or an empty string) to start a new agent.`).optional(),message:z.string().describe(`The message to send to the subagent. Provide all context the subagent needs to complete the task; the subagent does not see the parent's history.`),outputSchema:z.looseObject({}).describe(`Only provide a non-empty JSON Schema when the caller explicitly requests structured output; otherwise omit this field. The subagent must match a provided schema, and that structured output becomes the tool result.`).optional()});export{AGENT_TOOL_DESCRIPTION,AGENT_TOOL_NAME,SUBAGENT_TOOL_INPUT_SCHEMA};
+import{z}from"#compiled/zod/index.js";const AGENT_TOOL_NAME=`agent`,AGENT_TOOL_DESCRIPTION=["Delegate a focused subtask to a copy of yourself, or continue or steer a previous delegation with `agentId`.",`Use it to isolate complex work or split a large task into independent pieces.`,"Issue multiple `agent` calls in one response to run a small fixed set in parallel.","A new child has fresh history and state but reuses your tools and sandbox, so include essential context in `message` and give parallel writers non-overlapping scopes."].join(` `),SUBAGENT_TOOL_INPUT_SCHEMA=z.strictObject({agentId:z.string().nullable().describe(`The id of an existing agent from the <agents> list or a task receipt. A message to a busy agent steers it: its previous task is cancelled and the updated work runs in the same child session. Omit this field (or pass null or an empty string) to start a new agent.`).optional(),message:z.string().describe(`The message to send to the subagent. Provide all context the subagent needs to complete the task; the subagent does not see the parent's history.`),outputSchema:z.looseObject({}).describe(`Only provide a non-empty JSON Schema when the caller explicitly requests structured output; otherwise omit this field. The subagent must match a provided schema, and that structured output becomes the tool result.`).optional()});export{AGENT_TOOL_DESCRIPTION,AGENT_TOOL_NAME,SUBAGENT_TOOL_INPUT_SCHEMA};

package/dist/src/vue/index.js

@@ -1,3 +1,3 @@
-import { n as defaultMessageReducer, t as useEveAgent } from "../chunks/use-eve-agent-C5-yqRuq.js";
+import { n as defaultMessageReducer, t as useEveAgent } from "../chunks/use-eve-agent-BdKlQF32.js";
 
 export { defaultMessageReducer, useEveAgent };

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

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