eve 0.62.0 → 0.64.0

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

@@ -1,176 +0,0 @@
-import type { SandboxBootstrapContext, SandboxSessionUseFn } from "#shared/sandbox-definition.js";
-import type { SandboxSession } from "#shared/sandbox-session.js";
-/**
- * Live sandbox handle returned by a {@link SandboxBackend}.
- *
- * Wraps the public {@link SandboxSession} with lifecycle methods so the
- * runtime orchestrator can persist reconnect metadata and release
- * resources.
- */
-export interface SandboxBackendHandle<SO = Record<string, never>> {
-    readonly session: SandboxSession;
-    readonly useSessionFn: SandboxSessionUseFn<SO>;
-    captureState(): Promise<SandboxBackendSessionState>;
-    /**
-     * Permanently deletes this sandbox and its disposable backend state.
-     * Reusable or shared template state must not be deleted.
-     */
-    delete(options?: SandboxDeleteOptions): Promise<void>;
-    /**
-     * Stops the underlying compute at an authored runtime boundary while
-     * preserving any backend state needed to reopen the durable session.
-     * Provider errors must reject this call.
-     */
-    stop(): Promise<void>;
-    /**
-     * Stops the underlying compute because the eve server is shutting
-     * down; nothing may be left running afterwards. The session must
-     * remain reattachable from persisted state on the next server start
-     * when the backend supports durable sessions.
-     */
-    shutdown(): Promise<void>;
-}
-/** Options for permanently deleting one sandbox. */
-export interface SandboxDeleteOptions {
-    readonly abortSignal?: AbortSignal;
-}
-/**
- * Serializable per-sandbox reconnect record stored on the harness session.
- *
- * `backendName` matches the {@link SandboxBackend.name} of the backend
- * that produced this state. The runtime reads it to decide whether a
- * previously persisted handle is still compatible with the current
- * backend.
- */
-export interface SandboxBackendSessionState {
-    readonly backendName: string;
-    readonly metadata: Record<string, unknown>;
-    readonly sessionKey: string;
-}
-/**
- * One file written into a sandbox template before template state capture.
- */
-export interface SandboxSeedFile {
-    readonly path: string;
-    readonly content: string | Buffer;
-}
-/**
- * Diagnostic tags attached to provider-owned sandbox resources.
- *
- * Built-in backends may forward these into their hosting platform's
- * native tagging system. eve supplies stable tags such as the active
- * agent, channel, and session id so sandboxes can be found and
- * attributed in provider dashboards.
- */
-export type SandboxBackendTags = Readonly<Record<string, string>>;
-/**
- * Framework-owned runtime context handed to a backend on every
- * {@link SandboxBackend.create} call.
- *
- * Backends use this to derive any per-call state that depends on the
- * surrounding application. For example, the local backend computes its
- * cache directory from `appRoot`. Backends that don't need anything
- * here may ignore the field entirely.
- */
-export interface SandboxBackendRuntimeContext {
-    readonly appRoot: string;
-}
-/**
- * Input passed to {@link SandboxBackend.create} when the runtime needs a
- * live sandbox session.
- */
-export interface SandboxBackendCreateInput {
-    /**
-     * Reusable template key to open this session from. `null` means eve
-     * intentionally skipped template prewarm because the sandbox has no
-     * `bootstrap()` and no seed files, so the backend should create a
-     * fresh session from its default base runtime.
-     */
-    readonly templateKey: string | null;
-    readonly sessionKey: string;
-    readonly existingMetadata?: Record<string, unknown>;
-    /**
-     * Runtime tags the backend should attach to sandbox resources when
-     * the underlying provider supports tags.
-     */
-    readonly tags?: SandboxBackendTags;
-    readonly runtimeContext: SandboxBackendRuntimeContext;
-}
-/**
- * Input passed to {@link SandboxBackend.prewarm} when the build pipeline
- * is preparing reusable templates.
- *
- * Every authored sandbox in the compiled graph receives exactly one
- * `prewarm(...)` call before runtime opens its first session. The
- * backend captures reusable template state from the supplied
- * `bootstrap` hook and `seedFiles`, then `backend.create(...)` opens
- * durable sessions from that state.
- */
-export interface SandboxBackendPrewarmInput<BO = Record<string, never>> {
-    readonly templateKey: string;
-    readonly bootstrap?: (input: SandboxBootstrapContext<BO>) => void | Promise<void>;
-    /**
-     * Optional progress logger for backend-specific prewarm phases.
-     */
-    readonly log?: (message: string) => void;
-    readonly runtimeContext: SandboxBackendRuntimeContext;
-    readonly seedFiles: ReadonlyArray<SandboxSeedFile>;
-}
-/**
- * Outcome of one {@link SandboxBackend.prewarm} call.
- *
- * The build pipeline uses this to report in the build logs whether a
- * template state was reused from a prior deploy or captured fresh, so
- * a cache hit is distinguishable from an expensive rebuild.
- */
-export interface SandboxBackendPrewarmResult {
-    /**
-     * `true` when existing template state was reused without rebuilding it;
-     * `false` when the backend captured fresh template state.
-     */
-    readonly reused: boolean;
-}
-/**
- * Pluggable sandbox backend.
- *
- * A `SandboxBackend` is a value an author attaches to a
- * {@link SandboxDefinition} to choose which underlying runtime hosts the
- * sandbox. eve ships built-in backends (`docker()`,
- * `justbash()`, `microsandbox()`,
- * `vercel()`, and the availability-aware
- * `defaultSandbox()`), but the interface is public so authors can write
- * their own.
- *
- * A backend implements the full two-phase lifecycle:
- * {@link SandboxBackend.prewarm} captures reusable template state at
- * build time, and {@link SandboxBackend.create} starts or reattaches a
- * live session from that template at runtime.
- */
-export interface SandboxBackend<BO = Record<string, never>, SO = Record<string, never>> {
-    /**
-     * Stable identifier for this backend implementation.
-     *
-     * Participates in cache-key derivation and the persisted reconnect
-     * state, so two backends that should not share template state
-     * must use distinct names. Built-in backends use `"vercel"` and
-     * `"local"`. Custom backends pick a unique string.
-     */
-    readonly name: string;
-    /**
-     * Creates or reattaches one live sandbox session from a template
-     * previously captured by {@link SandboxBackend.prewarm}. Throws
-     * {@link SandboxTemplateNotProvisionedError} when the requested
-     * template is missing.
-     */
-    create(input: SandboxBackendCreateInput): Promise<SandboxBackendHandle<SO>>;
-    /**
-     * Build-time prewarm hook. eve invokes this for every authored
-     * sandbox in the compiled graph before serving traffic so the backend
-     * can capture reusable template state. Idempotent against existing state
-     * keyed by `templateKey`.
-     *
-     * Returns whether the state was reused from a prior run or captured
-     * fresh so the build pipeline can surface that in its logs.
-     */
-    prewarm(input: SandboxBackendPrewarmInput<BO>): Promise<SandboxBackendPrewarmResult>;
-}

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

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

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

@@ -1,112 +0,0 @@
-import type { SandboxSession } from "#shared/sandbox-session.js";
-import type { SandboxBackend } from "#shared/sandbox-backend.js";
-import type { SessionContext } from "#context/session-context.js";
-/**
- * Opens the template session inside a `bootstrap` hook. Optional `options`
- * (typed by the backend's bootstrap-use options `BO`) are applied to the
- * template before the snapshot is captured. Resolves to the
- * {@link SandboxSession} to operate on.
- */
-export type SandboxBootstrapUseFn<O = Record<string, never>> = (options?: O) => Promise<SandboxSession>;
-/**
- * Opens the live sandbox session inside an `onSession` hook. Optional
- * `options` (typed by the backend's session-use options `SO`) are applied
- * to the live session. Resolves to the {@link SandboxSession} for the
- * current turn.
- */
-export type SandboxSessionUseFn<O = Record<string, never>> = (options?: O) => Promise<SandboxSession>;
-/**
- * Argument passed to a sandbox `bootstrap` hook. `use(options?)` opens the
- * template session that the snapshot is captured from; backend-specific
- * `options` (typed by the backend's bootstrap-use options `BO`) are applied
- * to that template.
- */
-export interface SandboxBootstrapContext<O = Record<string, never>> {
-    readonly use: SandboxBootstrapUseFn<O>;
-}
-/**
- * Argument passed to a sandbox `onSession` hook, invoked once per live
- * session. `ctx` contains the active session metadata; sandbox access during
- * initialization goes through `use(options?)`, which opens the live session
- * and applies backend-specific `options` (typed by the backend's session-use
- * options `SO`).
- */
-export interface SandboxSessionContext<O = Record<string, never>> {
-    readonly ctx: Pick<SessionContext, "session">;
-    readonly use: SandboxSessionUseFn<O>;
-}
-/**
- * Resolves a build-time revalidation key for a bootstrap snapshot. eve
- * evaluates it during compile/build and freezes the result into compiled
- * artifacts. Supply one only for external inputs that affect bootstrap
- * output; authored source and managed seeds are tracked automatically.
- */
-export type SandboxRevalidationKeyFn = () => Promise<string> | string;
-/**
- * Public sandbox definition authored in `agent/sandbox.ts` (shorthand)
- * or `agent/sandbox/sandbox.ts` (folder layout, when paired with an
- * authored `sandbox/workspace/` subtree).
- *
- * Each agent (and each subagent) owns exactly one sandbox. When the
- * module file is absent the framework auto-provides a default sandbox
- * via `defaultSandbox()`. Authors override lifecycle and backend by
- * creating `agent/sandbox.ts` (or `agent/sandbox/sandbox.ts` when they
- * also want a workspace folder); subagents override independently via
- * `subagents/<name>/sandbox.ts` (or the folder form) and do not inherit
- * their parent's sandbox (skill seeds differ per agent).
- */
-interface SandboxDefinitionBase<BO = Record<string, never>, SO = Record<string, never>> {
-    /**
-     * Backend that runs this sandbox.
-     *
-     * Accepts either a {@link SandboxBackend} value or a zero-arg factory
-     * function that returns one. The factory form is invoked lazily on
-     * first framework access and the result is memoized for the lifetime
-     * of the process, so backend-internal state (such as the Vercel
-     * backend's prewarmed-template cache) is preserved across every call.
-     * Use the factory form to defer evaluation, for example when create
-     * options depend on environment variables that aren't set at module
-     * load time:
-     *
-     * ```ts
-     * defineSandbox({
-     *   backend: () => vercel({ env: { TOKEN: process.env.TOKEN ?? "" } }),
-     * });
-     * ```
-     *
-     * When this field is omitted, eve substitutes `defaultSandbox()` at
-     * runtime, which picks the best available backend: `vercel()`
-     * on hosted Vercel (where `process.env.VERCEL` is set), then Docker,
-     * microsandbox, or just-bash
-     * everywhere else. Set `backend` explicitly to pin the sandbox to a
-     * specific backend regardless of environment.
-     */
-    readonly backend: SandboxBackend<BO, SO> | (() => SandboxBackend<BO, SO>);
-    /** Human-readable description of this sandbox, surfaced in tooling. */
-    readonly description?: string;
-    /**
-     * Runs once per live session before authored steps use the sandbox.
-     * Call `input.use(options?)` to open the session and apply per-session
-     * backend options (typed by `SO`).
-     */
-    onSession?(input: SandboxSessionContext<SO>): Promise<void> | void;
-}
-export interface SandboxDefinitionWithBootstrap<BO = Record<string, never>, SO = Record<string, never>> extends SandboxDefinitionBase<BO, SO> {
-    bootstrap(input: SandboxBootstrapContext<BO>): Promise<void> | void;
-    /**
-     * Optional build-time revalidation key for the reusable sandbox
-     * snapshot produced by {@link bootstrap}. eve evaluates this
-     * function during compile/build, stores the resolved string in
-     * compiled artifacts, and uses that frozen value for both prewarm and
-     * runtime session create. Authored sandbox source and
-     * framework-managed seed contents are included automatically; provide
-     * this key only for external inputs that affect bootstrap output.
-     */
-    readonly revalidationKey?: SandboxRevalidationKeyFn;
-}
-export interface SandboxDefinitionWithoutBootstrap<BO = Record<string, never>, SO = Record<string, never>> extends SandboxDefinitionBase<BO, SO> {
-    bootstrap?: undefined;
-    readonly revalidationKey?: never;
-}
-export type SandboxDefinition<BO = Record<string, never>, SO = Record<string, never>> = SandboxDefinitionWithBootstrap<BO, SO> | SandboxDefinitionWithoutBootstrap<BO, SO>;
-export {};

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

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

package/dist/src/tasks/session-index.d.ts

@@ -1,65 +0,0 @@
-import type { HarnessSession, SessionStateMap } from "#harness/types.js";
-import { type ActivityWorkIdentityV1 } from "#protocol/activity.js";
-import type { TaskExecutorBinding } from "#tools/task.js";
-import { type TaskMetadata, type TaskView } from "#tasks/types.js";
-import { type DurableDynamicSubagentSelection, type SessionAuth } from "#context/keys.js";
-/**
- * Session-state key for the parent's live-task index.
- *
- * The parent session stores only this index; the mutable task record
- * lives in the dedicated durable task run. The PR #1190 spike found the
- * session-state boundary unworkable for task state itself: session state
- * threads through step results, while callback routes and child
- * executors must update tasks without holding the current snapshot.
- */
-export { SESSION_TASKS_STATE_KEY } from "#tasks/session-task-cohorts.js";
-/**
- * One task owned by this session. Immutable model-safe metadata keeps the
- * task-to-agent join available before the task run publishes its first view.
- *
- * `taskInboxToken` is the private routing credential for the task run's
- * inbound hook. It must never render into model context, history, task
- * views, or compaction summaries — the model addresses tasks by
- * `taskId` only, and lookup verifies ownership through this index.
- */
-export interface SessionTaskIndexEntry {
-    readonly activityWorkIdentity?: ActivityWorkIdentityV1;
-    readonly dispatchContext: SessionTaskDispatchContext;
-    readonly taskId: string;
-    readonly taskRunId: string;
-    /** Immutable fallback once the owning workflow run expires. */
-    readonly terminalView?: TaskView;
-    readonly taskInboxToken: string;
-    readonly createdByStepIndex?: number;
-    readonly createdByTurnId: string;
-    /** Immutable join target; absent on the task that starts a cohort. */
-    readonly cohortId?: string;
-    readonly executor?: TaskExecutorBinding;
-    readonly metadata: TaskMetadata;
-}
-export interface TaskAgentDispatchContext {
-    readonly auth: SessionAuth;
-    readonly sessionDynamicSubagentSelections?: Readonly<Record<string, DurableDynamicSubagentSelection>>;
-    readonly turnDynamicSubagentSelections?: Readonly<Record<string, DurableDynamicSubagentSelection>>;
-}
-export declare const LEGACY_TASK_AGENT_DISPATCH_CONTEXT: {
-    readonly legacy: true;
-};
-export type SessionTaskDispatchContext = TaskAgentDispatchContext | typeof LEGACY_TASK_AGENT_DISPATCH_CONTEXT;
-/**
- * Reads and validates the task index from session state.
- *
- * A present but invalid index throws: treating corruption as absence
- * would silently orphan every live task's routing credential.
- */
-export declare function getSessionTaskIndex(state: SessionStateMap | undefined): readonly SessionTaskIndexEntry[];
-/** Caches one terminal view beside its task-run address. */
-export declare function cacheTerminalTaskView(state: SessionStateMap | undefined, view: TaskView): SessionStateMap | undefined;
-/** Finds one owned task; `undefined` enforces parent-session ownership. */
-export declare function findSessionTaskEntry(state: SessionStateMap | undefined, taskId: string): SessionTaskIndexEntry | undefined;
-/**
- * Joins the indexed cohort that still has unreported/nonterminal work. Cached
- * terminal siblings remain members until the whole cohort settles. Membership
- * and creation provenance survive replay, even after that cohort has settled.
- */
-export declare function recordSessionTask(session: HarnessSession, entry: Omit<SessionTaskIndexEntry, "cohortId">): HarnessSession;

package/dist/src/tasks/session-index.js

@@ -1 +0,0 @@
-import{z}from"#compiled/zod/index.js";import"#context/keys.js";import{parseActivityWorkIdentityV1}from"#protocol/activity.js";import{SESSION_TASKS_STATE_KEY,SESSION_TASKS_STATE_KEY as SESSION_TASKS_STATE_KEY$1,SESSION_TASKS_STATE_VERSION,getTaskCohortId}from"#tasks/session-task-cohorts.js";import{sameTaskMetadata}from"#tasks/types.js";const taskMetadataSchema=z.looseObject({kind:z.string().min(1),name:z.string().min(1)}),LEGACY_TASK_AGENT_DISPATCH_CONTEXT={legacy:!0},sessionAuthContextSchema=z.strictObject({attributes:z.record(z.string(),z.union([z.string(),z.array(z.string()).readonly()])),authenticator:z.string(),issuer:z.string().optional(),principalId:z.string(),principalType:z.string(),subject:z.string().optional()}),dynamicSubagentSelectionsSchema=z.record(z.string(),z.custom()),taskAgentDispatchContextSchema=z.strictObject({auth:z.strictObject({current:sessionAuthContextSchema.nullable(),initiator:sessionAuthContextSchema.nullable()}),sessionDynamicSubagentSelections:dynamicSubagentSelectionsSchema.optional(),turnDynamicSubagentSelections:dynamicSubagentSelectionsSchema.optional()}),sessionTaskDispatchContextSchema=z.union([taskAgentDispatchContextSchema,z.strictObject({legacy:z.literal(!0)})]),taskViewBaseShape={inputRequests:z.never().optional(),executor:z.looseObject({binding:z.looseObject({data:z.record(z.string(),z.custom()),kind:z.string().min(1)}).optional()}).optional(),metadata:taskMetadataSchema,taskId:z.string().min(1),usage:z.looseObject({cacheReadTokens:z.number().nonnegative(),cacheWriteTokens:z.number().nonnegative(),costUsd:z.number().finite().nonnegative().optional(),inputTokens:z.number().nonnegative(),outputTokens:z.number().nonnegative()}).optional()},taskViewSchema=z.discriminatedUnion(`status`,[z.looseObject({...taskViewBaseShape,lastOutput:z.looseObject({data:z.custom(),type:z.literal(`result`)}),status:z.literal(`completed`)}),z.looseObject({...taskViewBaseShape,lastOutput:z.looseObject({data:z.custom(),type:z.literal(`error`)}),status:z.literal(`failed`)}),z.looseObject({...taskViewBaseShape,lastOutput:z.never().optional(),status:z.literal(`cancelled`)})]),storedSessionTaskIndexEntrySchema=z.looseObject({activityWorkIdentity:z.custom(e=>parseActivityWorkIdentityV1(e)!==void 0).optional(),taskInboxToken:z.string().min(1),createdByStepIndex:z.number().int().nonnegative().optional(),createdByTurnId:z.string().min(1),cohortId:z.string().min(1).optional(),dispatchContext:sessionTaskDispatchContextSchema.optional(),executor:z.looseObject({data:z.record(z.string(),z.custom()),kind:z.string().min(1)}).optional(),metadata:taskMetadataSchema,taskId:z.string().min(1),taskRunId:z.string().min(1),terminalView:taskViewSchema.optional()}),sessionTaskIndexSchema=z.looseObject({tasks:z.array(storedSessionTaskIndexEntrySchema),version:z.literal(SESSION_TASKS_STATE_VERSION)}).refine(e=>new Set(e.tasks.map(e=>e.taskId)).size===e.tasks.length,{message:`Task ids must be unique.`}).refine(e=>e.tasks.every(e=>e.terminalView===void 0||e.terminalView.taskId===e.taskId&&sameTaskMetadata(e.terminalView.metadata,e.metadata)),{message:`Cached terminal views must match their task index entry.`});function getSessionTaskIndex(e){return readSessionTaskIndex(e).tasks}function readSessionTaskIndex(e){let t=e?.[SESSION_TASKS_STATE_KEY$1];if(t===void 0)return{tasks:[],version:SESSION_TASKS_STATE_VERSION};let n=typeof t==`object`&&t?Reflect.get(t,`version`):void 0;if(n!==SESSION_TASKS_STATE_VERSION)throw Error(`Unsupported task index version ${JSON.stringify(n)} under session state key "${SESSION_TASKS_STATE_KEY$1}"; expected version ${SESSION_TASKS_STATE_VERSION}.`);let r=sessionTaskIndexSchema.safeParse(t);if(!r.success)throw Error(`Corrupt task index under session state key "${SESSION_TASKS_STATE_KEY$1}": ${r.error.message}`);return{...r.data,tasks:r.data.tasks.map(e=>({...e,dispatchContext:e.dispatchContext??LEGACY_TASK_AGENT_DISPATCH_CONTEXT}))}}function cacheTerminalTaskView(e,t){if(!isValidTerminalView(t))throw Error(`Cannot cache invalid terminal task "${t.taskId}".`);let n=readSessionTaskIndex(e),r=n.tasks,i=r.findIndex(e=>e.taskId===t.taskId);if(i<0)return e;if(!sameTaskMetadata(r[i].metadata,t.metadata))throw Error(`Task view metadata does not match index entry "${t.taskId}".`);let a=[...r],o=a[i].terminalView;return a[i]={...a[i],terminalView:taskViewSchema.parse({...o,...t,metadata:{...o?.metadata,...t.metadata},lastOutput:t.lastOutput===void 0?void 0:{...o?.lastOutput,...t.lastOutput},usage:t.usage===void 0?void 0:{...o?.usage,...t.usage},executor:t.executor===void 0?void 0:{...o?.executor,...t.executor,binding:t.executor.binding===void 0?void 0:{...o?.executor?.binding,...t.executor.binding}}})},{...e,[SESSION_TASKS_STATE_KEY$1]:{...n,tasks:a}}}function isValidTerminalView(e){if(e.inputRequests!==void 0)return!1;switch(e.status){case`completed`:return e.lastOutput?.type===`result`;case`failed`:return e.lastOutput?.type===`error`;case`cancelled`:return e.lastOutput===void 0;case`working`:return!1}}function findSessionTaskEntry(e,t){return getSessionTaskIndex(e).find(e=>e.taskId===t)}function recordSessionTask(e,t){let n=readSessionTaskIndex(e.state),r=[...n.tasks],i=r.findIndex(e=>e.taskId===t.taskId),a=r[i];if(a!==void 0)r[i]={...a,...t,metadata:{...a.metadata,...t.metadata},activityWorkIdentity:t.activityWorkIdentity===void 0?a.activityWorkIdentity:{...a.activityWorkIdentity,...t.activityWorkIdentity},executor:t.executor===void 0?a.executor:{...a.executor,...t.executor},cohortId:a.cohortId,createdByStepIndex:a.createdByStepIndex,createdByTurnId:a.createdByTurnId,dispatchContext:a.dispatchContext,terminalView:a.terminalView??t.terminalView};else{let e=r.find(e=>e.terminalView===void 0);r.push({...t,cohortId:e===void 0?void 0:getTaskCohortId(e)})}return{...e,state:{...e.state,[SESSION_TASKS_STATE_KEY$1]:{...n,tasks:r,version:SESSION_TASKS_STATE_VERSION}}}}export{LEGACY_TASK_AGENT_DISPATCH_CONTEXT,SESSION_TASKS_STATE_KEY,cacheTerminalTaskView,findSessionTaskEntry,getSessionTaskIndex,recordSessionTask};

package/dist/src/tools/task.d.ts

@@ -1,55 +0,0 @@
-import type { BackgroundTask } from "#execution/tasks/parent/delegate.js";
-import type { HarnessSession } from "#harness/types.js";
-import type { JsonObject, JsonValue } from "#shared/json.js";
-declare const TASK_MESSAGE_KIND: "eve:task-message";
-export type TaskMessage = JsonObject & {
-    readonly kind: typeof TASK_MESSAGE_KIND;
-    readonly message: string;
-};
-export declare function createTaskMessage(message: string): TaskMessage;
-export declare function isTaskMessage(value: unknown): value is TaskMessage;
-/** Opaque, framework-private address used to control a task executor. */
-export interface TaskExecutorBinding {
-    readonly kind: string;
-    readonly data: JsonObject;
-}
-/** @deprecated Use workflow-backed background tools with yield descriptors. */
-export interface TaskBinding {
-    readonly taskId: string;
-    readonly token: string;
-    readonly url?: string;
-}
-/** @deprecated Use workflow-backed background tools with yield descriptors. */
-export type TaskSendCommand = {
-    readonly kind: "update";
-    readonly message: string;
-} | {
-    readonly kind: "complete";
-    readonly data: JsonValue;
-} | {
-    readonly kind: "fail";
-    readonly data: JsonValue;
-} | {
-    readonly kind: "cancel";
-};
-/** Fixed acknowledgement returned when a background task is admitted. */
-export interface TaskReceipt {
-    readonly status: "working";
-    readonly taskId: string;
-}
-/** Capability passed only to tools declared with `execution: "background"`. */
-export interface TaskExec {
-    /** Model-facing durable task identity. */
-    readonly taskId: string;
-    /** Returns a descriptor which sends one message to the parent when yielded. */
-    postMessage(message: string): TaskMessage;
-    /** @deprecated Use yields from a workflow-backed background tool. */
-    readonly binding: TaskBinding;
-    /** @deprecated Use yields from a workflow-backed background tool. */
-    readonly send: (command: TaskSendCommand) => Promise<void>;
-    /** @deprecated Use ctx.session. */
-    readonly session: HarnessSession;
-    /** @deprecated Framework-owned task internals are not part of the authoring API. */
-    readonly task: BackgroundTask;
-}
-export {};

package/dist/src/tools/task.js

@@ -1 +0,0 @@
-const TASK_MESSAGE_KIND=`eve:task-message`;function createTaskMessage(e){if(e.trim()===``)throw TypeError(`Task messages must not be empty.`);return{kind:TASK_MESSAGE_KIND,message:e}}function isTaskMessage(e){return typeof e==`object`&&!!e&&Reflect.get(e,`kind`)===TASK_MESSAGE_KIND}export{createTaskMessage,isTaskMessage};