eve 0.44.3 → 0.45.0

package/dist/src/{public/definitions/tool.d.ts → tools/definition.d.ts}

@@ -1,52 +1,54 @@
+import type { ToolExecutionOptions } from "ai";
 import type { StandardJSONSchemaV1, StandardSchemaV1 } from "#compiled/@standard-schema/spec/index.js";
-import type { PublicToolDefinition, ToolModelOutput } from "#shared/tool-definition.js";
-import type { SessionContext } from "#public/definitions/callback-context.js";
-import type { Approval } from "#public/definitions/approval.js";
+import type { Approval } from "#approval/definition.js";
+import type { SessionContext } from "#context/session-context.js";
 import type { JsonObject } from "#shared/json.js";
-import type { TaskDelegated, TaskExec, TaskReceipt } from "#shared/tool-task.js";
-import type { AuthorizationDefinition, ConnectionAuthorizationContext, NonInteractiveAuthorizationDefinition, TokenResult } from "#runtime/connections/types.js";
-import { type DynamicEvents, type DynamicSentinel } from "#shared/dynamic-tool-definition.js";
+import type { TokenResult } from "#shared/connection-types.js";
+import type { ToolAuthOptions, ToolAuthProvider } from "#tools/auth.js";
+import type { ToolModelOutput } from "#tools/model-output.js";
+import type { TaskDelegated, TaskExec, TaskReceipt } from "#tools/task.js";
 type ApprovalContextInput<TInput> = unknown extends TInput ? Record<string, unknown> : TInput;
-type DynamicEventMapHandler<TEvents extends DynamicEvents> = Extract<NonNullable<TEvents[keyof TEvents]>, (...args: never[]) => unknown>;
-type DynamicEventMapResult<TEvents extends DynamicEvents> = Awaited<ReturnType<DynamicEventMapHandler<TEvents>>>;
-export type { ToolModelOutput, ToolModelOutputPart } from "#shared/tool-definition.js";
-export type { TaskBinding, TaskDelegated, TaskExec, TaskExecutorBinding, TaskReceipt, TaskSendCommand, } from "#shared/tool-task.js";
+export type { ToolAuthDefinition, ToolAuthOptions, ToolAuthProvider } from "#tools/auth.js";
+export type { ToolModelOutput, ToolModelOutputPart } from "#tools/model-output.js";
+export type { TaskBinding, TaskDelegated, TaskExec, TaskExecutorBinding, TaskReceipt, TaskSendCommand, } from "#tools/task.js";
+export type ToolExecuteOptions = Omit<ToolExecutionOptions<unknown>, "context">;
+export type ToolExecuteFn<TInput = unknown, TOutput = unknown> = (input: TInput, options: ToolExecuteOptions, task?: TaskExec) => Promise<TOutput> | TOutput | AsyncIterable<TOutput>;
+export type ToolExecution = "background";
+interface ToolDefinitionBase {
+    readonly description: string;
+    readonly execution?: ToolExecution;
+}
 /**
- * Authorization provider passed to {@link ToolContext.getToken} or
- * {@link ToolContext.requireAuth}. Accepts the same shapes as a connection's
- * `auth`:
- * - a `getToken`-only object (static API keys, pre-provisioned JWTs);
- *   `principalType` may be omitted and defaults to `"app"`.
- * - a full interactive OAuth definition (e.g. `connect("okta/myagent")` from
- *   `@vercel/connect/eve`, or {@link defineInteractiveAuthorization}).
+ * Internal/compiled tool definition shape. Carries `name` because the
+ * compiler stamps a path-derived identifier onto every tool entry.
+ *
+ * Authored public definitions (see {@link PublicToolDefinition}) do not
+ * carry `name`; identity comes from the file path.
  */
-export type ToolAuthDefinition = (Omit<NonInteractiveAuthorizationDefinition, "principalType"> & {
-    readonly principalType?: NonInteractiveAuthorizationDefinition["principalType"];
-}) | AuthorizationDefinition;
-export type ToolAuthProvider = ToolAuthDefinition;
+export interface InternalToolDefinition extends ToolDefinitionBase {
+    name: string;
+    inputSchema: JsonObject | null;
+    outputSchema?: JsonObject;
+}
+export type PublicToolInputSchema<TInput = unknown> = StandardSchemaV1<unknown, TInput> | StandardJSONSchemaV1<unknown, TInput> | JsonObject;
+export type PublicToolOutputSchema<TOutput = unknown> = StandardJSONSchemaV1<unknown, TOutput> | JsonObject;
 /**
- * Controls Eve runtime behavior for an inline tool auth provider.
+ * Authored public tool definition shape. Identity is derived from the
+ * file path at compile time, so `name` is intentionally absent here.
  */
-export interface ToolAuthOptions {
+export interface PublicToolDefinition<TInput = unknown, TOutput = unknown> extends ToolDefinitionBase {
+    inputSchema: PublicToolInputSchema<TInput>;
     /**
-     * Connection metadata passed through to provider callbacks. Tool-only
-     * providers usually leave this unset; connection-backed helpers can use it
-     * to receive the upstream server URL.
+     * Optional schema describing the value returned by the tool executor.
+     * The AI SDK can use this for tool result typing.
      */
-    readonly connection?: ConnectionAuthorizationContext;
-    /**
-     * Optional human-readable provider name shown in sign-in UI. Presentation
-     * only; it does not affect OAuth scopes, token cache keys, or callback URLs.
-     */
-    readonly displayName?: string;
-    /**
-     * Optional Eve auth-flow key for token caches, callback URLs, pending
-     * authorization state, and authorization completion. This is not an OAuth
-     * scope. For Vercel Connect OAuth targeting such as `scopes`, `resources`,
-     * or `authorizationDetails`, configure the provider with
-     * `connect({ connector, tokenParams })`.
-     */
-    readonly authKey?: string;
+    outputSchema?: PublicToolOutputSchema<TOutput>;
+}
+export interface InternalToolDefinitionWithExecuteFn<TInput = unknown, TOutput = unknown> extends InternalToolDefinition {
+    execute: ToolExecuteFn<TInput, TOutput>;
+}
+export interface PublicToolDefinitionWithExecuteFn<TInput = unknown, TOutput = unknown> extends PublicToolDefinition<TInput, TOutput> {
+    execute: ToolExecuteFn<TInput, TOutput>;
 }
 /**
  * Authored tool context. Passed as the last argument to
@@ -178,57 +180,6 @@ export declare function defineTool<TReturn>(definition: {
     toModelOutput?: ToolDefinition<unknown, ToolOutputFromExecuteReturn<TReturn>>["toModelOutput"];
 }): ToolDefinitionWithExecuteReturn<Record<string, unknown>, ToolOutputFromExecuteReturn<TReturn>, TReturn>;
 export declare function defineTool<TInput = unknown, TOutput = unknown>(definition: ToolDefinition<TInput, TOutput>): ToolDefinition<TInput, TOutput>;
-/**
- * Defines a dynamic resolver evaluated at runtime from stream-event
- * handlers. It is shared across tools, skills, and agent definitions;
- * the directory it is
- * authored in (not this function) decides what each handler must return
- * and which events are honored. The file's path-derived slug names the
- * single-entry case; a `Record<string, ...>` return names entries
- * `slug__key`. Return `null` to contribute nothing for that event.
- *
- * Per-slot return shape:
- * - `agent/tools/`: return a single `defineTool(...)`, a
- *   `Record<string, defineTool(...)>`, or `null`.
- * - `agent/skills/`: return a single `defineSkill(...)`, a
- *   `Record<string, defineSkill(...)>`, or `null`.
- * - `agent/subagents/<name>/agent.ts`: return `defineAgent(...)` to configure
- *   and expose the subagent, or `null` to omit it.
- *
- * Per-slot events: tools resolvers run at `session.started`,
- * `turn.started`, and `step.started`. Skills resolvers run only at
- * `session.started` and `turn.started`; the runtime never invokes a
- * handler keyed on `step.started` in that slot.
- * Dynamic subagents run at `session.started` and `turn.started` only.
- *
- * ```ts
- * import { defineDynamic, defineTool } from "eve/tools";
- * import { z } from "zod";
- *
- * export default defineDynamic({
- *   events: {
- *     "session.started": async (event, ctx) => ({
- *       export: defineTool({
- *         description: "Export data",
- *         inputSchema: z.object({ format: z.string() }),
- *         async execute(input) {
- *           return doExport(input.format);
- *         },
- *       }),
- *     }),
- *   },
- * });
- * ```
- *
- * A single return is named after the file slug. A map names each entry by its
- * bare key — there is no automatic slug prefix, so namespace keys yourself
- * (e.g. `team__playbook`) when a bare name might collide. A dynamic tool/skill
- * whose name matches an authored one overrides it; two dynamic resolvers
- * emitting the same name is an error.
- */
-export declare function defineDynamic<const TEvents extends DynamicEvents>(definition: {
-    readonly events: TEvents;
-}): DynamicSentinel<DynamicEventMapResult<TEvents>>;
 /**
  * Marker discriminator written into every {@link DisabledToolSentinel}.
  */
@@ -251,50 +202,3 @@ export declare function disableTool(): DisabledToolSentinel;
  * produced by {@link disableTool}.
  */
 export declare function isDisabledToolSentinel(value: unknown): value is DisabledToolSentinel;
-/**
- * Discriminator written into definitions returned by
- * {@link experimental_workflow}.
- */
-declare const EXPERIMENTAL_WORKFLOW_TOOL_KIND = "eve:enable-workflow-tool";
-/**
- * Configuration accepted by {@link experimental_workflow}.
- */
-export interface ExperimentalWorkflowToolInput {
-    /**
-     * Maximum number of subagent or remote-agent calls one `Workflow` program
-     * may dispatch, counted across sequential and parallel calls alike.
-     *
-     * Calls beyond the limit fail with a `WORKFLOW_SUBAGENT_LIMIT_REACHED`
-     * result instead of starting a child session.
-     *
-     * @default 100
-     */
-    readonly maxSubagents?: number;
-}
-/**
- * Framework `Workflow` tool definition returned by
- * {@link experimental_workflow}.
- */
-export interface ExperimentalWorkflowToolDefinition extends ExperimentalWorkflowToolInput {
-    readonly kind: typeof EXPERIMENTAL_WORKFLOW_TOOL_KIND;
-}
-/**
- * Enables and configures the experimental framework `Workflow` tool, an
- * isolated JavaScript sandbox whose only callable operations are this agent's
- * subagents and remote agents. Export the result from
- * `agent/tools/workflow.ts`:
- *
- * ```ts
- * import { experimental_workflow } from "eve/tools";
- *
- * export default experimental_workflow({ maxSubagents: 25 });
- * ```
- *
- * Only the root session sees the tool. The resulting model-facing tool is
- * still called `Workflow`.
- */
-export declare function experimental_workflow(input?: ExperimentalWorkflowToolInput): ExperimentalWorkflowToolDefinition;
-/**
- * Type guard for a definition returned by {@link experimental_workflow}.
- */
-export declare function isExperimentalWorkflowToolDefinition(value: unknown): value is ExperimentalWorkflowToolDefinition;

package/dist/src/tools/definition.js

@@ -0,0 +1 @@
+import{collectDurableDynamicToolCallbacks,stampDurableDynamicToolCallbacks}from"#tools/durable-callbacks.js";import{TOOL_BRAND}from"#tools/dynamic.js";import{stampDefinitionKey}from"#internal/authored-definition/source-identity.js";function defineTool(t){if(t.auth!==void 0)throw Error(`defineTool: The "auth" field is no longer supported. Pass auth providers inline to ctx.getToken(provider) or ctx.requireAuth(provider).`);return Object.assign(t,{[TOOL_BRAND]:!0}),stampDurableDynamicToolCallbacks(t,collectDurableDynamicToolCallbacks({approval:t.approval,execute:t.execute,toModelOutput:t.toModelOutput})),stampDefinitionKey(t,`tool:${t.description}`),t}const DISABLED_TOOL_SENTINEL_KIND=`eve:disabled-tool`;function disableTool(){return{kind:DISABLED_TOOL_SENTINEL_KIND}}function isDisabledToolSentinel(e){return typeof e==`object`&&!!e&&e.kind===DISABLED_TOOL_SENTINEL_KIND}export{defineTool,disableTool,isDisabledToolSentinel};

package/dist/src/{shared/durable-dynamic-tool-callbacks.d.ts → tools/durable-callbacks.d.ts}

@@ -1,4 +1,4 @@
-import type { Approval } from "#public/definitions/approval.js";
+import type { Approval } from "#approval/definition.js";
 import type { JsonObject } from "#shared/json.js";
 export type DurableDynamicCallbackPhase = "approvalRequest" | "approvalResponse" | "execute" | "toModelOutput";
 export type DurableDynamicCallbackFn = (closure: JsonObject, ...args: never[]) => unknown;

package/dist/src/tools/durable-callbacks.js

@@ -0,0 +1 @@
+import{resolveApprovalPolicy}from"#approval/definition.js";const STAMPED_CALLBACK=Symbol.for(`eve:durable-dynamic-callback`),DURABLE_DYNAMIC_TOOL_CALLBACKS=Symbol.for(`eve:durable-dynamic-tool-callbacks`),REGISTRY=Symbol.for(`eve:dynamic-tool-callbacks`);function getRegistry(){let e=globalThis,t=e[REGISTRY];if(t!==void 0)return t;let n=new Map;return e[REGISTRY]=n,n}function registerDurableDynamicCallback(e){let t=getRegistry(),n=t.get(e.toolName);n===void 0&&(n=new Map,t.set(e.toolName,n)),n.set(e.phase,e.callback)}function lookupDurableDynamicCallback(e,t){return getRegistry().get(e)?.get(t)}function callDurableDynamicCallback(e,t,...n){return e(t,...n)}function hasUnregisteredDurableDynamicCallbacks(e){return e.some(e=>Object.keys(e.callbacks).some(t=>lookupDurableDynamicCallback(e.name,t)===void 0))}function stampDurableDynamicCallback(e,n){return Object.defineProperty(e,STAMPED_CALLBACK,{configurable:!0,value:n}),e}function readDurableDynamicCallback(e){if(typeof e==`function`)return Reflect.get(e,STAMPED_CALLBACK)}function stampDurableDynamicToolCallbacks(e,t){Object.defineProperty(e,DURABLE_DYNAMIC_TOOL_CALLBACKS,{configurable:!0,value:t})}function collectDurableDynamicToolCallbacks(t){let n=t.approval===void 0?void 0:readDurableDynamicCallback(resolveApprovalPolicy(t.approval)),r=t.approval===void 0||typeof t.approval==`function`?void 0:readDurableDynamicCallback(t.approval.response),i=readDurableDynamicCallback(t.execute),a=readDurableDynamicCallback(t.toModelOutput),o={};return i!==void 0&&(o.execute=i),n!==void 0&&(o.approvalRequest=n),r!==void 0&&(o.approvalResponse=r),a!==void 0&&(o.toModelOutput=a),o}function readDurableDynamicToolCallbacks(e){return e[DURABLE_DYNAMIC_TOOL_CALLBACKS]}export{DURABLE_DYNAMIC_TOOL_CALLBACKS,callDurableDynamicCallback,collectDurableDynamicToolCallbacks,hasUnregisteredDurableDynamicCallbacks,lookupDurableDynamicCallback,readDurableDynamicCallback,readDurableDynamicToolCallbacks,registerDurableDynamicCallback,stampDurableDynamicCallback,stampDurableDynamicToolCallbacks};

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

@@ -0,0 +1,68 @@
+import type { Approval } from "#approval/definition.js";
+import type { DynamicResolveContext, DynamicToolEventName } from "#dynamic/definition.js";
+import type { PublicToolInputSchema, PublicToolOutputSchema, ToolContext } from "#tools/definition.js";
+import type { ToolModelOutput } from "#tools/model-output.js";
+/**
+ * A single tool entry within a resolved dynamic tool set.
+ *
+ * Identity comes from context: a single returned entry is named after
+ * the file slug; entries in a returned `Record<string, DynamicToolEntry>`
+ * are each named `slug__key`.
+ *
+ * `TInput` defaults to `Record<string, unknown>` but is inferred when
+ * `inputSchema` is a Standard Schema (e.g. Zod) via the `defineTool`
+ * wrapper. `TOutput` defaults to `any`; provide an `outputSchema`
+ * (Standard Schema) to infer and check the executor return type.
+ */
+export interface DynamicToolEntry<TInput = Record<string, unknown>, TOutput = any> {
+    readonly description: string;
+    readonly inputSchema: PublicToolInputSchema<TInput>;
+    readonly outputSchema?: PublicToolOutputSchema<TOutput>;
+    execute(input: TInput, ctx: ToolContext): TOutput | Promise<TOutput>;
+    readonly toModelOutput?: (output: TOutput) => ToolModelOutput | Promise<ToolModelOutput>;
+    /**
+     * Optional per-call approval gate, mirroring the authored-tool
+     * `approval` contract: return `"user-approval"` to require user approval
+     * before the call executes. Dynamic approval request and response callbacks
+     * use the same durable descriptor boundary as `execute` and `toModelOutput`.
+     */
+    readonly approval?: Approval;
+}
+/**
+ * A resolved tool set: keys are entry identifiers, values are
+ * {@link DynamicToolEntry} objects created via `defineTool` inside a
+ * resolver. Entry type params are `any` so entries with differing
+ * schemas stay assignable to one Record; `defineTool` captures each
+ * entry's concrete types before this widened container.
+ */
+export type DynamicToolSet = Readonly<Record<string, DynamicToolEntry<any, any>>>;
+/**
+ * Return type for a `defineDynamic` event handler: a single tool entry
+ * (named after the file slug), a map of entries (named `slug__key`), or
+ * `null` for no tools.
+ */
+export type DynamicToolResult = DynamicToolEntry<any, any> | DynamicToolSet | null;
+/**
+ * Strongly-typed tool-handler map: each key is a supported event name,
+ * each value a resolver that takes the stream event and resolve context
+ * and returns a {@link DynamicToolResult}. `defineDynamic` accepts the
+ * wider {@link DynamicEvents} (handlers return `unknown`) because the
+ * slot directory (tools/ vs skills/) decides the expected return at
+ * runtime. Reference `DynamicToolEvents` to check the tool-specific
+ * return type at authoring time.
+ */
+export type DynamicToolEvents = {
+    readonly [K in DynamicToolEventName]?: (event: unknown, ctx: DynamicResolveContext) => DynamicToolResult | Promise<DynamicToolResult>;
+};
+/**
+ * Symbol-based brand stamped by `defineTool` on every entry. Invisible
+ * in IntelliSense, checked at runtime to enforce the wrapper and to
+ * distinguish a single entry from a map of entries.
+ */
+export declare const TOOL_BRAND: unique symbol;
+/**
+ * Returns true if `value` carries the `defineTool` brand symbol. Used
+ * to detect single entry vs map of entries and to validate that entries
+ * are properly wrapped.
+ */
+export declare function isBrandedToolEntry(value: unknown): boolean;

package/dist/src/tools/dynamic.js

@@ -0,0 +1 @@
+const TOOL_BRAND=Symbol.for(`eve:tool-brand`);function isBrandedToolEntry(e){return typeof e==`object`&&!!e&&e[TOOL_BRAND]===!0}export{TOOL_BRAND,isBrandedToolEntry};

package/dist/src/tools/framework/agent-contract.d.ts

@@ -0,0 +1,8 @@
+import { z } from "#compiled/zod/index.js";
+export declare const AGENT_TOOL_NAME = "agent";
+export declare const AGENT_TOOL_DESCRIPTION: string;
+export declare const SUBAGENT_TOOL_INPUT_SCHEMA: z.ZodObject<{
+    agentId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    message: z.ZodString;
+    outputSchema: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
+}, z.core.$strict>;

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

@@ -0,0 +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 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(`Only pass this to continue a previous delegation: the id of an agent from the <agents> list. To start a new agent — the common case — omit this field entirely (or pass null or an empty string).`).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/tools/framework/agent.d.ts

@@ -0,0 +1,17 @@
+/** The harness intercepts this tool before its durable dispatch step executes. */
+export declare const agent: import("#tools/definition.js").ToolDefinition<{
+    agentId?: string | null | undefined;
+    message: string;
+    outputSchema?: {
+        [x: string]: unknown;
+    } | undefined;
+}, never> & {
+    execute(input: {
+        agentId?: string | null | undefined;
+        message: string;
+        outputSchema?: {
+            [x: string]: unknown;
+        } | undefined;
+    }, ctx: import("#tools/definition.js").ToolContext): never;
+};
+export default agent;

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

@@ -0,0 +1 @@
+import{defineTool}from"#tools/definition.js";import{AGENT_TOOL_DESCRIPTION,SUBAGENT_TOOL_INPUT_SCHEMA}from"#tools/framework/agent-contract.js";const agent=defineTool({description:AGENT_TOOL_DESCRIPTION,inputSchema:SUBAGENT_TOOL_INPUT_SCHEMA,execute(){throw Error(`agent is handled by eve's durable dispatch step.`)}});export{agent,agent as default};

package/dist/src/tools/framework/ask-question.d.ts

@@ -0,0 +1,50 @@
+import { z } from "#compiled/zod/index.js";
+export declare const ASK_QUESTION_INPUT_SCHEMA: z.ZodObject<{
+    allowFreeform: z.ZodOptional<z.ZodBoolean>;
+    options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        description: z.ZodOptional<z.ZodString>;
+        id: z.ZodString;
+        label: z.ZodString;
+        style: z.ZodOptional<z.ZodEnum<{
+            danger: "danger";
+            default: "default";
+            primary: "primary";
+        }>>;
+    }, z.core.$strict>>>;
+    prompt: z.ZodString;
+}, z.core.$strict>;
+export declare const ASK_QUESTION_OUTPUT_SCHEMA: z.ZodObject<{
+    optionId: z.ZodOptional<z.ZodString>;
+    status: z.ZodEnum<{
+        answered: "answered";
+        ignored: "ignored";
+    }>;
+    text: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+/** The harness intercepts this tool before its durable input step executes. */
+export declare const askQuestion: import("#tools/definition.js").ToolDefinition<{
+    allowFreeform?: boolean | undefined;
+    options?: {
+        description?: string | undefined;
+        id: string;
+        label: string;
+        style?: "danger" | "default" | "primary" | undefined;
+    }[] | undefined;
+    prompt: string;
+}, {
+    optionId?: string | undefined;
+    status: "answered" | "ignored";
+    text?: string | undefined;
+}> & {
+    execute(input: {
+        allowFreeform?: boolean | undefined;
+        options?: {
+            description?: string | undefined;
+            id: string;
+            label: string;
+            style?: "danger" | "default" | "primary" | undefined;
+        }[] | undefined;
+        prompt: string;
+    }, ctx: import("#tools/definition.js").ToolContext): never;
+};
+export default askQuestion;

package/dist/src/tools/framework/ask-question.js

@@ -0,0 +1 @@
+import{z}from"#compiled/zod/index.js";import{inputRequestSchema}from"#shared/input.js";import{defineTool}from"#tools/definition.js";const ASK_QUESTION_INPUT_SCHEMA=inputRequestSchema.omit({action:!0,display:!0,kind:!0,requestId:!0}),ASK_QUESTION_OUTPUT_SCHEMA=z.object({optionId:z.string().optional(),status:z.enum([`answered`,`ignored`]),text:z.string().optional()}).strict(),askQuestion=defineTool({description:`Ask the user a question and wait for their response before continuing. Use this when you need clarification or a choice from the user.`,inputSchema:ASK_QUESTION_INPUT_SCHEMA,outputSchema:ASK_QUESTION_OUTPUT_SCHEMA,execute(){throw Error(`ask_question is handled by eve's durable input dispatcher.`)}});export{ASK_QUESTION_INPUT_SCHEMA,ASK_QUESTION_OUTPUT_SCHEMA,askQuestion,askQuestion as default};

package/dist/src/tools/framework/connection-search.d.ts

@@ -0,0 +1,3 @@
+/** Canonical definition for dynamic connection tool discovery. */
+export declare const connectionSearch: import("#dynamic/definition.js").DynamicSentinel<Record<string, object> | null>;
+export default connectionSearch;

package/dist/src/tools/framework/connection-search.js

@@ -0,0 +1 @@
+import{defineDynamic}from"#dynamic/definition.js";import{resolveConnectionSearchDynamicTools}from"#execution/tools/connection-search.js";const connectionSearch=defineDynamic({events:{"step.started":resolveConnectionSearchDynamicTools}});export{connectionSearch,connectionSearch as default};

package/dist/src/tools/framework/task-cancel.d.ts

@@ -0,0 +1,29 @@
+/** The harness intercepts this tool before its durable dispatch step executes. */
+export declare const taskCancel: import("#tools/definition.js").ToolDefinition<{
+    taskIds: string[];
+}, {
+    tasks: {
+        inputRequests?: unknown[] | undefined;
+        lastOutput?: {
+            data: unknown;
+            type: "error" | "result";
+        } | undefined;
+        metadata: {
+            agentId: string;
+            kind: "subagent";
+            mode: "local" | "remote";
+            name: string;
+        } | {
+            data?: Record<string, unknown> | undefined;
+            kind: string;
+            name: string;
+        };
+        status: "cancelled" | "completed" | "failed" | "input_required" | "working";
+        taskId: string;
+    }[];
+}> & {
+    execute(input: {
+        taskIds: string[];
+    }, ctx: import("#tools/definition.js").ToolContext): never;
+};
+export default taskCancel;

package/dist/src/tools/framework/task-cancel.js

@@ -0,0 +1 @@
+import{defineTool}from"#tools/definition.js";import{TASK_CANCEL_INPUT_SCHEMA,TASK_VIEWS_OUTPUT_SCHEMA}from"#tools/framework/task-contract.js";const taskCancel=defineTool({description:`Request cooperative cancellation of one or more background tasks. Cancellation is final: a task that finishes after you cancel it stays cancelled. Cancelling an already-finished task changes nothing.`,inputSchema:TASK_CANCEL_INPUT_SCHEMA,outputSchema:TASK_VIEWS_OUTPUT_SCHEMA,execute(){throw Error(`task_cancel is handled by eve's durable dispatch step.`)}});export{taskCancel as default,taskCancel};

package/dist/src/tools/framework/task-contract.d.ts

@@ -0,0 +1,167 @@
+import { z } from "#compiled/zod/index.js";
+export declare const TASK_CANCEL_TOOL_NAME = "task_cancel";
+export declare const TASK_UPDATE_TOOL_NAME = "task_update";
+/** Transitional PR 1 task-tool names used by the existing dispatch mechanics. */
+export declare const TASK_TOOL_NAMES: ReadonlySet<string>;
+export declare const TASK_CANCEL_INPUT_SCHEMA: z.ZodObject<{
+    taskIds: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export declare const TASK_UPDATE_INPUT_SCHEMA: z.ZodObject<{
+    message: z.ZodString;
+}, z.core.$strict>;
+/** Strict model-visible task projection. */
+export declare const TASK_VIEW_JSON_SCHEMA: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    metadata: z.ZodUnion<readonly [z.ZodObject<{
+        agentId: z.ZodString;
+        kind: z.ZodLiteral<"subagent">;
+        mode: z.ZodEnum<{
+            local: "local";
+            remote: "remote";
+        }>;
+        name: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodString;
+        name: z.ZodString;
+    }, z.core.$strip>]>;
+    taskId: z.ZodString;
+    status: z.ZodLiteral<"working">;
+}, z.core.$strip>, z.ZodObject<{
+    metadata: z.ZodUnion<readonly [z.ZodObject<{
+        agentId: z.ZodString;
+        kind: z.ZodLiteral<"subagent">;
+        mode: z.ZodEnum<{
+            local: "local";
+            remote: "remote";
+        }>;
+        name: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodString;
+        name: z.ZodString;
+    }, z.core.$strip>]>;
+    taskId: z.ZodString;
+    inputRequests: z.ZodReadonly<z.ZodArray<z.ZodType<import("../../shared/json.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("../../shared/json.ts").JsonValue, unknown>>>>;
+    status: z.ZodLiteral<"input_required">;
+}, z.core.$strip>, z.ZodObject<{
+    metadata: z.ZodUnion<readonly [z.ZodObject<{
+        agentId: z.ZodString;
+        kind: z.ZodLiteral<"subagent">;
+        mode: z.ZodEnum<{
+            local: "local";
+            remote: "remote";
+        }>;
+        name: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodString;
+        name: z.ZodString;
+    }, z.core.$strip>]>;
+    taskId: z.ZodString;
+    lastOutput: z.ZodObject<{
+        data: z.ZodType<import("../../shared/json.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("../../shared/json.ts").JsonValue, unknown>>;
+        type: z.ZodLiteral<"result">;
+    }, z.core.$strip>;
+    status: z.ZodLiteral<"completed">;
+}, z.core.$strip>, z.ZodObject<{
+    metadata: z.ZodUnion<readonly [z.ZodObject<{
+        agentId: z.ZodString;
+        kind: z.ZodLiteral<"subagent">;
+        mode: z.ZodEnum<{
+            local: "local";
+            remote: "remote";
+        }>;
+        name: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodString;
+        name: z.ZodString;
+    }, z.core.$strip>]>;
+    taskId: z.ZodString;
+    lastOutput: z.ZodObject<{
+        data: z.ZodType<import("../../shared/json.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("../../shared/json.ts").JsonValue, unknown>>;
+        type: z.ZodLiteral<"error">;
+    }, z.core.$strip>;
+    status: z.ZodLiteral<"failed">;
+}, z.core.$strip>, z.ZodObject<{
+    metadata: z.ZodUnion<readonly [z.ZodObject<{
+        agentId: z.ZodString;
+        kind: z.ZodLiteral<"subagent">;
+        mode: z.ZodEnum<{
+            local: "local";
+            remote: "remote";
+        }>;
+        name: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodString;
+        name: z.ZodString;
+    }, z.core.$strip>]>;
+    taskId: z.ZodString;
+    status: z.ZodLiteral<"cancelled">;
+}, z.core.$strip>], "status">;
+/** Broad schema advertised by task-control tool outputs. */
+export declare const TASK_VIEW_OUTPUT_SCHEMA: z.ZodObject<{
+    inputRequests: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+    lastOutput: z.ZodOptional<z.ZodObject<{
+        data: z.ZodUnknown;
+        type: z.ZodEnum<{
+            error: "error";
+            result: "result";
+        }>;
+    }, z.core.$strip>>;
+    metadata: z.ZodUnion<readonly [z.ZodObject<{
+        agentId: z.ZodString;
+        kind: z.ZodLiteral<"subagent">;
+        mode: z.ZodEnum<{
+            local: "local";
+            remote: "remote";
+        }>;
+        name: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        kind: z.ZodString;
+        name: z.ZodString;
+    }, z.core.$strip>]>;
+    status: z.ZodEnum<{
+        cancelled: "cancelled";
+        completed: "completed";
+        failed: "failed";
+        input_required: "input_required";
+        working: "working";
+    }>;
+    taskId: z.ZodString;
+}, z.core.$strip>;
+export declare const TASK_VIEWS_OUTPUT_SCHEMA: z.ZodObject<{
+    tasks: z.ZodArray<z.ZodObject<{
+        inputRequests: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+        lastOutput: z.ZodOptional<z.ZodObject<{
+            data: z.ZodUnknown;
+            type: z.ZodEnum<{
+                error: "error";
+                result: "result";
+            }>;
+        }, z.core.$strip>>;
+        metadata: z.ZodUnion<readonly [z.ZodObject<{
+            agentId: z.ZodString;
+            kind: z.ZodLiteral<"subagent">;
+            mode: z.ZodEnum<{
+                local: "local";
+                remote: "remote";
+            }>;
+            name: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            kind: z.ZodString;
+            name: z.ZodString;
+        }, z.core.$strip>]>;
+        status: z.ZodEnum<{
+            cancelled: "cancelled";
+            completed: "completed";
+            failed: "failed";
+            input_required: "input_required";
+            working: "working";
+        }>;
+        taskId: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const SUBAGENT_TASK_RECEIPT_OUTPUT_SCHEMA: z.ZodObject<{
+    agentId: z.ZodString;
+    status: z.ZodLiteral<"working">;
+    taskId: z.ZodString;
+}, z.core.$strict>;

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

@@ -0,0 +1 @@
+import{z}from"#compiled/zod/index.js";import{jsonValueSchema}from"#shared/json-schemas.js";const TASK_CANCEL_TOOL_NAME=`task_cancel`,TASK_UPDATE_TOOL_NAME=`task_update`,TASK_TOOL_NAMES=new Set([TASK_CANCEL_TOOL_NAME,TASK_UPDATE_TOOL_NAME]),TASK_IDS_SCHEMA=z.array(z.string().min(1)).min(1).describe(`Task ids from earlier subagent task receipts.`),TASK_CANCEL_INPUT_SCHEMA=z.strictObject({taskIds:TASK_IDS_SCHEMA}),TASK_UPDATE_INPUT_SCHEMA=z.strictObject({message:z.string().min(1).describe(`Brief description of what this task is currently doing.`)}),taskMetadataJsonSchema=z.union([z.object({agentId:z.string(),kind:z.literal(`subagent`),mode:z.enum([`local`,`remote`]),name:z.string()}),z.object({kind:z.string(),name:z.string()})]),taskOutputJsonSchema=z.object({data:jsonValueSchema,type:z.enum([`result`,`error`])}),taskViewJsonBaseShape={metadata:taskMetadataJsonSchema,taskId:z.string()},TASK_VIEW_JSON_SCHEMA=z.discriminatedUnion(`status`,[z.object({...taskViewJsonBaseShape,status:z.literal(`working`)}),z.object({...taskViewJsonBaseShape,inputRequests:z.array(jsonValueSchema).readonly(),status:z.literal(`input_required`)}),z.object({...taskViewJsonBaseShape,lastOutput:taskOutputJsonSchema.extend({type:z.literal(`result`)}),status:z.literal(`completed`)}),z.object({...taskViewJsonBaseShape,lastOutput:taskOutputJsonSchema.extend({type:z.literal(`error`)}),status:z.literal(`failed`)}),z.object({...taskViewJsonBaseShape,status:z.literal(`cancelled`)})]),TASK_VIEW_OUTPUT_SCHEMA=z.object({inputRequests:z.array(z.unknown()).optional(),lastOutput:z.object({data:z.unknown(),type:z.enum([`result`,`error`])}).optional(),metadata:z.union([z.object({agentId:z.string(),kind:z.literal(`subagent`),mode:z.enum([`local`,`remote`]),name:z.string()}),z.object({data:z.record(z.string(),z.unknown()).optional(),kind:z.string(),name:z.string()})]),status:z.enum([`working`,`input_required`,`completed`,`failed`,`cancelled`]),taskId:z.string()}),TASK_VIEWS_OUTPUT_SCHEMA=z.object({tasks:z.array(TASK_VIEW_OUTPUT_SCHEMA)}),SUBAGENT_TASK_RECEIPT_OUTPUT_SCHEMA=z.strictObject({agentId:z.string(),status:z.literal(`working`),taskId:z.string()});export{SUBAGENT_TASK_RECEIPT_OUTPUT_SCHEMA,TASK_CANCEL_INPUT_SCHEMA,TASK_CANCEL_TOOL_NAME,TASK_TOOL_NAMES,TASK_UPDATE_INPUT_SCHEMA,TASK_UPDATE_TOOL_NAME,TASK_VIEWS_OUTPUT_SCHEMA,TASK_VIEW_JSON_SCHEMA,TASK_VIEW_OUTPUT_SCHEMA};

package/dist/src/tools/framework/task-update.d.ts

@@ -0,0 +1,9 @@
+/** The harness intercepts this tool before its durable dispatch step executes. */
+export declare const taskUpdate: import("#tools/definition.js").ToolDefinition<{
+    message: string;
+}, never> & {
+    execute(input: {
+        message: string;
+    }, ctx: import("#tools/definition.js").ToolContext): never;
+};
+export default taskUpdate;

package/dist/src/tools/framework/task-update.js

@@ -0,0 +1 @@
+import{defineTool}from"#tools/definition.js";import{TASK_UPDATE_INPUT_SCHEMA}from"#tools/framework/task-contract.js";const taskUpdate=defineTool({description:`Briefly tell the parent agent what this background task is currently doing. Report activity, not preliminary findings or results.`,inputSchema:TASK_UPDATE_INPUT_SCHEMA,execute(){throw Error(`task_update is handled by eve's durable dispatch step.`)}});export{taskUpdate as default,taskUpdate};