eve 0.83.3 → 0.84.0

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

@@ -1,23 +1,31 @@
-import type { UserContent } from "ai";
-import { type EveAgentStoreCallbacks, type EveAgentStoreSnapshot, type EveAgentStoreStatus, type PrepareSend } from "#client/eve-agent-store.js";
-import type { ConversationState } from "#client/conversation-state.js";
-import type { EveAgentReducer } from "#client/reducer.js";
+import type { Delivery } from "#shared/delivery.js";
+import type { SessionStreamEvent } from "#protocol/session-event.js";
+import type { MessageContent } from "#shared/message-content.js";
+import { type SessionStoreCallbacks, type SessionStoreInit, type SessionStoreSnapshot, type SessionStoreStatus, type PrepareSend } from "#client/session-store.js";
 import type { ClientSession } from "#client/session.js";
-import type { CancelSessionResult, ClientAuth, HeadersValue, RespondTurnOptions, SendTurnOptions, ClientSessionState } from "#client/types.js";
-import type { MessageStreamEvent } from "#protocol/message.js";
+import type { ClientAuth, HeadersValue, RespondTurnOptions, SendTurnOptions, ClientSessionState } from "#client/types.js";
 export type { PrepareSend };
 /**
- * Session lifecycle phase: `"ready"` (idle), `"resuming"` (checking an
- * attached session), `"submitted"` (request sent, awaiting the first stream
- * event), `"streaming"` (events arriving), or `"error"`.
+ * Outstanding work this binding has observed or still owes. Failures are reported separately in
+ * `error`.
+ *
+ * - `"idle"`: no command, answer, or followed receipt is pending, and the last observed view is
+ *   idle. A turn waiting only on a person can still be open; read `activeTurn(view)`.
+ * - `"resuming"`: catching up on an attached session; submission is disabled.
+ * - `"busy"`: a send, answer, or control command is pending, a followed receipt has not settled,
+ *   or the session has running or queued work.
+ *
+ * After `followWhile` closes the stream, `status` reflects the last observed view, not the
+ * current server state.
  */
-export type UseEveAgentStatus = EveAgentStoreStatus;
+export type UseEveAgentStatus = SessionStoreStatus;
 /**
- * Immutable point-in-time view of an eve agent session: projected `data`, the
- * last `error`, the raw `events` stream, the `session` cursor, and `status`.
+ * Immutable point-in-time view of an eve agent session: the conversation (`messages`,
+ * `agents`, `view`), the last `error`, the raw `events` stream, the
+ * `session` cursor, and `status`.
  * `useEveAgent` passes this snapshot to the `onFinish` callback.
  */
-export type UseEveAgentSnapshot<TData> = EveAgentStoreSnapshot<TData>;
+export type UseEveAgentSnapshot = SessionStoreSnapshot;
 /**
  * Reactive return value from `useEveAgent`.
  *
@@ -25,33 +33,40 @@ export type UseEveAgentSnapshot<TData> = EveAgentStoreSnapshot<TData>;
  * template, `$derived`, or `$effect` and Svelte will update when eve streams
  * new events.
  */
-export interface UseEveAgentReturn<TData> {
-    /** Request durable cancellation of the active turn while continuing to receive its events. */
-    readonly cancel: () => Promise<CancelSessionResult>;
-    /** Projected state built by reducing every stream event through the reducer. */
-    readonly data: TData;
-    /** Canonical session state, regardless of the chosen data reducer. */
-    readonly conversation: ConversationState;
+export interface UseEveAgentReturn {
+    /**
+     * Request durable cancellation of the active turn while continuing to receive its events.
+     * Offer it while `activeTurn(view)` returns a turn, including one waiting on a person.
+     */
+    readonly cancel: () => Promise<Delivery>;
+    /** Rendered messages, local answers, native lifecycle tables, and followed agents. */
+    readonly messages: SessionStoreSnapshot["messages"];
+    readonly agents: SessionStoreSnapshot["agents"];
     /** Last transport-level error, or `undefined` when healthy. */
     readonly error: Error | undefined;
+    readonly view: SessionStoreSnapshot["view"];
     /** Raw server events received during this session (authoritative stream). */
-    readonly events: readonly MessageStreamEvent[];
-    /** Replay the attached durable session and follow its in-flight turn, if any. */
+    readonly events: readonly SessionStreamEvent[];
+    /** Follow a same-session delivery receipt until settlement. */
+    readonly follow: (receipt: Pick<Delivery, "sessionId" | "deliveryId">) => void;
+    /** Resolves at the durable tail; subsequent following obeys `followWhile`. */
     readonly resume: () => Promise<void>;
     /** Create the session without starting its first turn. */
     readonly prewarm: () => Promise<void>;
     /** Clear all state and start a new session. */
-    readonly reset: () => void;
-    /** Send a message with optional turn settings. */
-    readonly send: <TOutput = unknown>(message: string | UserContent, options?: SendTurnOptions<TOutput>) => Promise<void>;
-    /** Answer pending HITL input requests. */
-    readonly respond: <TOutput = unknown>(inputResponses: Parameters<ClientSession["respond"]>[0], options?: RespondTurnOptions<TOutput>) => Promise<void>;
+    readonly newSession: () => void;
+    readonly reset: () => Promise<Delivery>;
+    readonly clear: () => Promise<Delivery>;
+    readonly compact: () => Promise<Delivery>;
+    /** Submits a message and resolves on acceptance, not execution. */
+    readonly send: <TOutput = unknown>(message: MessageContent, options?: SendTurnOptions<TOutput>) => Promise<Delivery<TOutput>>;
+    /** Submits answers and resolves on acceptance, not execution. */
+    readonly respond: <TOutput = unknown>(answers: Parameters<ClientSession["respond"]>[0], options?: RespondTurnOptions<TOutput>) => Promise<Delivery<TOutput>>;
     /** Current session identity and stream cursor. */
     readonly session: ClientSessionState | undefined;
     /**
-     * Lifecycle phase: `"ready"` (idle), `"resuming"` (checking an attached
-     * session), `"submitted"` (request sent, awaiting first event), `"streaming"`
-     * (events arriving), or `"error"`.
+     * Outstanding work: `"idle"`, `"resuming"` (catching up on an attached session), or `"busy"`.
+     * Read `activeTurn(view)` for turn openness. Failures are reported separately in `error`.
      */
     readonly status: UseEveAgentStatus;
 }
@@ -59,16 +74,16 @@ export interface UseEveAgentReturn<TData> {
  * Configuration for a Svelte eve agent session.
  *
  * Read once when `useEveAgent` creates its store; create a new binding to
- * change host, reducer, or session. To rotate credentials or headers without
+ * change base URL or session. To rotate credentials or headers without
  * recreating the binding, pass function values to `auth` or `headers`, which
  * the client resolves before each HTTP request.
  */
-export interface UseEveAgentOptions<TData> extends EveAgentStoreCallbacks<TData> {
+export interface UseEveAgentOptions extends SessionStoreCallbacks {
     /**
      * Named agent mounted by a framework integration such as `withEve({ agents })`.
      *
      * `agent: "support"` targets same-origin routes under
-     * `/eve/support/v1/...`. Do not combine with `host`.
+     * `/eve/support/v1/...`. Do not combine with `baseUrl`.
      */
     readonly agent?: string;
     /**
@@ -88,43 +103,39 @@ export interface UseEveAgentOptions<TData> extends EveAgentStoreCallbacks<TData>
      *
      * @default ""
      */
-    readonly host?: string;
+    readonly baseUrl?: string;
     /** Ordered prefix of the session stream used to rehydrate projected state. */
-    readonly initialEvents?: readonly MessageStreamEvent[];
+    readonly initialEvents?: readonly SessionStreamEvent[];
     /** Seed session identity and stream cursor for resuming a prior conversation. */
     readonly initialSession?: ClientSessionState;
     /**
      * Project submitted user messages before eve confirms them with a
-     * `message.received` stream event. Optimistic events are reducer-facing
-     * projection only and never appear in `events`, which stays the
-     * authoritative eve stream.
+     * `delivery.consumed` fact. Such a message shows in `messages` only;
+     * `events` stays the authoritative eve stream.
      *
      * @default true
      */
     readonly optimistic?: boolean;
-    /** Follow each subagent call's session into `conversation.agents` while mounted. @default false */
-    readonly followSubagents?: boolean;
-    /**
-     * Keep the session stream open between turns to show events that arrive from schedules,
-     * channels, or other clients. Set to false to close it once the session is idle and reopen it
-     * on the next send, answer, or resume. @default true
-     */
-    readonly followIdle?: boolean;
-    /** Create a session or prepare its existing idle owner on mount and after reset. @default false */
+    /** Recursively observe recorded children, or select relationships with a predicate, within store safety limits. @default false */
+    readonly followAgents?: SessionStoreInit["followAgents"];
+    /** Keep following while the committed view matches; local obligations take priority. @default () => true */
+    readonly followWhile?: (view: SessionStoreSnapshot["view"]) => boolean;
+    /** Create a session or prepare its existing idle owner on mount and after `newSession()`. @default false */
     readonly prewarm?: boolean;
-    /**
-     * Projects stream events into `TData`. Defaults to the conversation reducer.
-     */
-    readonly reducer?: EveAgentReducer<TData>;
     /** Replay the attached durable session after mount. Requires `initialSession` or `session`. */
     readonly resume?: boolean;
     /**
      * Pre-built client session to bind to. When omitted, the binding creates its
-     * own session from `auth`, `headers`, and `host`.
+     * own session from `auth`, `headers`, and `baseUrl`.
      */
     readonly session?: ClientSession;
 }
-export declare function useEveAgent(options?: UseEveAgentOptions<ConversationState>): UseEveAgentReturn<ConversationState>;
-export declare function useEveAgent<TData>(options: UseEveAgentOptions<TData> & {
-    readonly reducer: EveAgentReducer<TData>;
-}): UseEveAgentReturn<TData>;
+/**
+ * Svelte 5 binding that drives an eve session and projects its events into
+ * rune-friendly reactive data.
+ *
+ * The conversation's `messages`, `agents`, and `view` are exposed
+ * directly; derive anything else from `events`.
+ * Configuration is read once; create a new binding to change base URL or session.
+ */
+export declare function useEveAgent(options?: UseEveAgentOptions): UseEveAgentReturn;

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

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

package/dist/src/tool-stubs/rules.js

@@ -1 +1 @@
-import{z}from"#compiled/zod/index.js";import{CALL_TOOL_NAME,SEARCH_TOOL_NAME,SKILL_TOOL_NAME}from"#protocol/catalog-tools.js";import{parseJsonValue}from"#shared/json.js";import{createStubValidator,validateStubConstraint}from"#tool-stubs/schema.js";const ruleSchema=z.strictObject({id:z.string().min(1),tool:z.string().min(1),match:z.record(z.string(),z.union([z.boolean(),z.record(z.string(),z.json())])).optional()}),outcomeSchema=z.union([z.strictObject({response:z.json()}),z.strictObject({throw:z.strictObject({message:z.string(),name:z.string().min(1).optional()})})]),toolStubsSchema=z.array(z.union([ruleSchema.extend({outcome:outcomeSchema}),ruleSchema.extend({outcomes:z.tuple([outcomeSchema]).rest(outcomeSchema)})])).max(100);function parseToolStubs(e){boundStubConfiguration(e);let t=toolStubsSchema.parse(parseJsonValue(e)),n=new Set;for(let e of t){if(n.has(e.id))throw Error(`Duplicate tool stub id "${e.id}".`);if(n.add(e.id),[SEARCH_TOOL_NAME,CALL_TOOL_NAME,SKILL_TOOL_NAME].includes(e.tool.split(`/`).at(-1)))throw Error(`Cannot stub ${SEARCH_TOOL_NAME}, ${CALL_TOOL_NAME}, or ${SKILL_TOOL_NAME}. Stub the tool an ${CALL_TOOL_NAME} call reaches, such as linear__list_issues.`);for(let[t,n]of Object.entries(e.match??{})){validateStubConstraint(n,e.id,t);try{createStubValidator(n)}catch(n){throw Error(`Could not create matcher "${t}" in tool stub "${e.id}".`,{cause:n})}}}return t}function boundStubConfiguration(e){let t=[{value:e,depth:0}],n=0,r=0;for(;t.length>0;){let e=t.pop();if(++n>2e4||e.depth>32)throw Error(`Tool stubs exceed the size or nesting limit.`);if(typeof e.value==`string`&&(r+=e.value.length),e.value!==null&&typeof e.value==`object`)for(let[n,i]of Object.entries(e.value)){if(n===`__proto__`)throw Error(`Tool stubs cannot contain prototype keys.`);r+=n.length,t.push({value:i,depth:e.depth+1})}if(r>1e6)throw Error(`Tool stubs exceed the size or nesting limit.`)}}export{parseToolStubs};
+import{z}from"#compiled/zod/index.js";import{parseJsonValue}from"#shared/json.js";import{CALL_TOOL_NAME,SEARCH_TOOL_NAME,SKILL_TOOL_NAME}from"#protocol/catalog-tools.js";import{createStubValidator,validateStubConstraint}from"#tool-stubs/schema.js";const ruleSchema=z.strictObject({id:z.string().min(1),tool:z.string().min(1),match:z.record(z.string(),z.union([z.boolean(),z.record(z.string(),z.json())])).optional()}),outcomeSchema=z.union([z.strictObject({response:z.json()}),z.strictObject({throw:z.strictObject({message:z.string(),name:z.string().min(1).optional()})})]),toolStubsSchema=z.array(z.union([ruleSchema.extend({outcome:outcomeSchema}),ruleSchema.extend({outcomes:z.tuple([outcomeSchema]).rest(outcomeSchema)})])).max(100);function parseToolStubs(e){boundStubConfiguration(e);let t=toolStubsSchema.parse(parseJsonValue(e)),n=new Set;for(let e of t){if(n.has(e.id))throw Error(`Duplicate tool stub id "${e.id}".`);if(n.add(e.id),[SEARCH_TOOL_NAME,CALL_TOOL_NAME,SKILL_TOOL_NAME].includes(e.tool.split(`/`).at(-1)))throw Error(`Cannot stub ${SEARCH_TOOL_NAME}, ${CALL_TOOL_NAME}, or ${SKILL_TOOL_NAME}. Stub the tool an ${CALL_TOOL_NAME} call reaches, such as linear__list_issues.`);for(let[t,n]of Object.entries(e.match??{})){validateStubConstraint(n,e.id,t);try{createStubValidator(n)}catch(n){throw Error(`Could not create matcher "${t}" in tool stub "${e.id}".`,{cause:n})}}}return t}function boundStubConfiguration(e){let t=[{value:e,depth:0}],n=0,r=0;for(;t.length>0;){let e=t.pop();if(++n>2e4||e.depth>32)throw Error(`Tool stubs exceed the size or nesting limit.`);if(typeof e.value==`string`&&(r+=e.value.length),e.value!==null&&typeof e.value==`object`)for(let[n,i]of Object.entries(e.value)){if(n===`__proto__`)throw Error(`Tool stubs cannot contain prototype keys.`);r+=n.length,t.push({value:i,depth:e.depth+1})}if(r>1e6)throw Error(`Tool stubs exceed the size or nesting limit.`)}}export{parseToolStubs};

package/dist/src/tools/approval/policies.d.ts

@@ -1,4 +1,4 @@
-import type { Experimental_DecisionModel as DecisionModel } from "ai";
+import type { DecisionModel } from "#ai/decision-types.js";
 import type { ApprovalPolicy } from "#approval/definition.js";
 export interface AutoApprovalOptions {
     /** Decision model instance or ID. Defaults to TypeSafe Jev. */
@@ -17,21 +17,9 @@ export interface AutoApprovalOptions {
  * Unavailable or invalid decisions require user approval.
  */
 export declare function auto<TInput = unknown>(options?: AutoApprovalOptions): ApprovalPolicy<TInput>;
-/**
- * Returns an `approval` callback that always requires user approval before
- * the tool executes.
- */
+/** Returns an `approval` callback that always requires user approval. */
 export declare function always<TInput = unknown>(): ApprovalPolicy<TInput>;
-/**
- * Returns an `approval` callback that never requires user approval before
- * the tool executes.
- */
+/** Returns an `approval` callback that never requires user approval. */
 export declare function never<TInput = unknown>(): ApprovalPolicy<TInput>;
-/**
- * Returns an `approval` callback that requires approval until the user
- * approves this tool once in the current session. A tool is recorded as
- * approved only on an explicit approval; a denial (or continuing without
- * responding) leaves it unrecorded, so the next call prompts again. Keys off
- * the bare tool name, so it ignores compound approval keys.
- */
+/** Remembers a person's approval for this tool for the rest of the session. */
 export declare function once<TInput = unknown>(): ApprovalPolicy<TInput>;

package/dist/src/tools/approval/policies.js

@@ -1 +1 @@
-import{parseJsonValue}from"#shared/json.js";import{stampDurableDynamicCallback}from"#tools/durable-callbacks.js";import{decide}from"#ai/decide.js";async function autoApproval(e,t,n){try{let r=parseJsonValue(n.toolInput??null),i=JSON.stringify(r);if(new TextEncoder().encode(i).byteLength>65536)return`user-approval`;let a=AbortSignal.any([n.abortSignal,AbortSignal.timeout(3e4)]);return(await decide({model:e,state:{action:{input:r,tool:n.toolName}},questions:{permission:{type:`choice`,instructions:t.instructions??`Review the exact tool action for dangerous effects. Return caution when it could cause meaningful harm, including destructive data loss, credential exposure, financial transactions, deployments or public changes, external communication, privilege or system changes, or concealed execution. Return clear for routine, low-impact actions. Judge the action's actual effects from its name and input. If important effects are unclear, return caution.`,criteria:{clear:t.criteria?.clear??`The action is routine and low impact.`,caution:t.criteria?.caution??`The action is dangerous or its important effects are unclear.`}}},abortSignal:a,maxRetries:0})).answers.permission.choice===`clear`?`approved`:`user-approval`}catch{return n.abortSignal.throwIfAborted(),`user-approval`}}function alwaysApproval(e){return`user-approval`}function neverApproval(e){return`not-applicable`}function onceApproval(e,t){return t.approvedTools.has(t.toolName)?`not-applicable`:`user-approval`}function auto(e={}){let t=e.model??`typesafe-ai/jev`;return stampDurableDynamicCallback(n=>autoApproval(t,e,n),{callback:(n,r)=>autoApproval(t,e,r),closure:{}})}function always(){return stampDurableDynamicCallback(()=>`user-approval`,{callback:alwaysApproval,closure:{}})}function never(){return stampDurableDynamicCallback(()=>`not-applicable`,{callback:neverApproval,closure:{}})}function once(){return stampDurableDynamicCallback(({approvedTools:e,toolName:t})=>e.has(t)?`not-applicable`:`user-approval`,{callback:onceApproval,closure:{}})}export{always,auto,never,once};
+import{parseJsonValue}from"#shared/json.js";import{approvalEvaluation}from"#approval/evaluation.js";import{decide}from"#ai/decide.js";async function autoApproval(e,t,n){try{let r=parseJsonValue(n.toolInput??null),i=JSON.stringify(r);if(new TextEncoder().encode(i).byteLength>65536)return`user-approval`;let a=AbortSignal.any([n.abortSignal,AbortSignal.timeout(3e4)]);return(await decide({model:e,state:{action:{input:r,tool:n.toolName}},questions:{permission:{type:`choice`,instructions:t.instructions??`Review the exact tool action for dangerous effects. Return caution when it could cause meaningful harm, including destructive data loss, credential exposure, financial transactions, deployments or public changes, external communication, privilege or system changes, or concealed execution. Return clear for routine, low-impact actions. Judge the action's actual effects from its name and input. If important effects are unclear, return caution.`,criteria:{clear:t.criteria?.clear??`The action is routine and low impact.`,caution:t.criteria?.caution??`The action is dangerous or its important effects are unclear.`}}},signal:a,maxRetries:0})).answers.permission.choice===`clear`?`approved`:`user-approval`}catch{return n.abortSignal.throwIfAborted(),`user-approval`}}function auto(e={}){let t=e.model??`typesafe-ai/jev`;return n=>autoApproval(t,e,n)}function always(){return()=>`user-approval`}function never(){return()=>`not-applicable`}function once(){if(arguments.length!==0)throw TypeError(`once() does not accept options. Use a custom approval policy for input-dependent decisions.`);return e=>{let t=approvalEvaluation(e);if(t===void 0)return`user-approval`;let{entry:n,pending:r}=t.read(`once`);return n?.outcome===`accepted`&&!r?`approved`:t.ask({key:`once`})}}export{always,auto,never,once};

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

@@ -1,14 +1,14 @@
-import type { ConnectionAuthorizationContext, ConnectionAuthProvider } from "#shared/connection-types.js";
+import type { ConnectionAuthorizationContext, AuthorizationDefinition } from "#shared/connection-types.js";
 /**
  * Authorization provider passed to the tool context's `getToken` or
  * `requireAuth` method. Accepts the same shapes as a connection's `auth`:
  * - a `getToken`-only object (static API keys, pre-provisioned JWTs);
- *   `credentialOwner` may be omitted and defaults to `"app"`.
+ *   `principalType` may be omitted and defaults to `"app"`.
  * - a full interactive OAuth definition (e.g. `connect("okta/myagent")` from
  *   `@vercel/connect/eve`, or `defineInteractiveAuthorization`), which keeps
  *   `principalType: "user"`.
  */
-export type ToolAuthDefinition = ConnectionAuthProvider;
+export type ToolAuthDefinition = AuthorizationDefinition;
 export type ToolAuthProvider = ToolAuthDefinition;
 /** Controls eve runtime behavior for an inline tool auth provider. */
 export interface ToolAuthOptions {

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

@@ -1,12 +1,14 @@
-import type { ModelMessage, ToolExecutionOptions } from "ai";
+import type { Principal } from "#protocol/session-events/envelope.js";
+import type { ToolExecutionOptions } from "ai";
+import type { HistoryMessage as ModelMessage } from "#shared/history-message.js";
 import type { StandardJSONSchemaV1, StandardSchemaV1 } from "#compiled/@standard-schema/spec/index.js";
-import type { ToolApproval } from "#approval/definition.js";
+import type { Approval } from "#approval/definition.js";
 import type { SessionAuthContext } from "#channel/types.js";
 import type { SessionContext } from "#context/session-context.js";
 import type { JsonObject } from "#shared/json.js";
 import type { TokenResult } from "#shared/connection-types.js";
 import type { ToolAuthOptions, ToolAuthProvider } from "#tools/auth.js";
-import type { InputOption } from "#shared/input.js";
+import type { InteractionRequest } from "#protocol/session-events/families/interaction.js";
 import type { ToolModelOutput } from "#tools/model-output.js";
 type ApprovalContextInput<TInput> = unknown extends TInput ? Record<string, unknown> : TInput;
 export type { ToolAuthDefinition, ToolAuthOptions, ToolAuthProvider } from "#tools/auth.js";
@@ -69,8 +71,6 @@ export interface PublicToolDefinition<TInput = unknown, TOutput = unknown> exten
      * The AI SDK can use this for tool result typing.
      */
     outputSchema?: PublicToolOutputSchema<TOutput>;
-    /** Derives the input-scoped key recorded when this tool is approved. */
-    approvalKey?: (input: Readonly<ApprovalContextInput<TInput>>) => string;
 }
 export interface InternalToolDefinitionWithExecuteFn<TInput = unknown, TOutput = unknown> extends InternalToolDefinition {
     execute: ToolExecuteFn<TInput, TOutput>;
@@ -80,26 +80,9 @@ export interface InternalToolDefinitionWithExecuteFn<TInput = unknown, TOutput =
  * with `ctx.ask` from a `defineWorkflowTool` executor. Channels render it the
  * way they render tool approvals.
  */
-export interface ToolInputRequest {
-    /**
-     * Whether the user may answer with free text instead of one of the
-     * {@link options}.
-     */
-    readonly allowFreeform?: boolean;
-    /** Rendering hint: confirmation buttons, a selection list, or a text field. */
-    readonly display?: "confirmation" | "select" | "text";
-    /** Selectable answers. */
-    readonly options?: readonly InputOption[];
-    readonly prompt: string;
-}
-/** Public identity fields for the authenticated person who answered a question. */
-export interface ToolInputResponseResponder {
-    readonly authenticator: string;
-    readonly principalId: string;
-    readonly principalType: string;
-}
+export type ToolQuestion = Pick<InteractionRequest, "prompt" | "title" | "options" | "allowFreeform" | "display">;
 /**
- * The outcome of a {@link ToolInputRequest}.
+ * The outcome of a {@link ToolQuestion}.
  *
  * - `answered`: the user picked an option or typed an answer. An answer the
  *   session accepted before a withdrawal wins, even after a signal aborted.
@@ -108,12 +91,12 @@ export interface ToolInputResponseResponder {
  * - `unavailable`: the session cannot reach a human, such as a scheduled run,
  *   so the request resolved immediately without being shown.
  */
-export type ToolInputResponse = {
+export type ToolAnswer = {
     readonly status: "answered";
     /** The selected option's `id`, when the user picked one. */
     readonly optionId?: string;
     /** Authenticated identity of the responder, without channel attributes. */
-    readonly responder?: ToolInputResponseResponder;
+    readonly responder?: Principal;
     /** Free text, when the user typed an answer. */
     readonly text?: string;
 } | {
@@ -122,7 +105,7 @@ export type ToolInputResponse = {
     readonly status: "unavailable";
 };
 /** Options for `ctx.ask` in a `defineWorkflowTool` executor. */
-export interface ToolInputRequestOptions {
+export interface ToolAskOptions {
     /**
      * Withdraws the request when it aborts: the channel stops offering the
      * question and the ask resolves as `cancelled`, unless the session accepted
@@ -251,7 +234,7 @@ export interface ToolDefinition<TInput = unknown, TOutput = unknown> extends Pub
      * - {@link never}: never require approval
      * - {@link once}: require approval only the first time per session
      */
-    approval?: ToolApproval<ApprovalContextInput<TInput>>;
+    approval?: Approval<ApprovalContextInput<TInput>>;
     /**
      * Optional projection controlling what the model sees as the tool result.
      * Receives the full `TOutput` from {@link execute} and returns the
@@ -259,7 +242,7 @@ export interface ToolDefinition<TInput = unknown, TOutput = unknown> extends Pub
      *
      * When omitted, the model sees the full `execute` return value
      * (default AI SDK serialization). Channel event handlers
-     * (`action.result`) always receive the full output regardless.
+     * (`call.settled`) always receive the full output regardless.
      */
     toModelOutput?: (output: TOutput) => ToolModelOutput | Promise<ToolModelOutput>;
 }
@@ -283,7 +266,6 @@ export declare function defineTool<TInputSchema extends StandardSchemaV1<unknown
     execute(input: StandardSchemaV1.InferOutput<TInputSchema>, ctx: ToolContext): TReturn;
     label?: ToolDefinition<StandardSchemaV1.InferOutput<TInputSchema>, StandardJSONSchemaV1.InferOutput<TOutputSchema>>["label"];
     approval?: ToolDefinition<StandardSchemaV1.InferOutput<TInputSchema>, unknown>["approval"];
-    approvalKey?: ToolDefinition<StandardSchemaV1.InferOutput<TInputSchema>, unknown>["approvalKey"];
     toModelOutput?: ToolDefinition<unknown, StandardJSONSchemaV1.InferOutput<TOutputSchema>>["toModelOutput"];
 }): ToolDefinitionWithExecuteReturn<StandardSchemaV1.InferOutput<TInputSchema>, StandardJSONSchemaV1.InferOutput<TOutputSchema>, TReturn>;
 export declare function defineTool<TSchema extends StandardSchemaV1<unknown, unknown> | StandardJSONSchemaV1<unknown, unknown>, TReturn>(definition: {
@@ -294,7 +276,6 @@ export declare function defineTool<TSchema extends StandardSchemaV1<unknown, unk
     execute(input: StandardSchemaV1.InferOutput<TSchema>, ctx: ToolContext): TReturn;
     label?: ToolDefinition<StandardSchemaV1.InferOutput<TSchema>, ToolOutputFromExecuteReturn<TReturn>>["label"];
     approval?: ToolDefinition<StandardSchemaV1.InferOutput<TSchema>, unknown>["approval"];
-    approvalKey?: ToolDefinition<StandardSchemaV1.InferOutput<TSchema>, unknown>["approvalKey"];
     toModelOutput?: ToolDefinition<unknown, ToolOutputFromExecuteReturn<TReturn>>["toModelOutput"];
 }): ToolDefinitionWithExecuteReturn<StandardSchemaV1.InferOutput<TSchema>, ToolOutputFromExecuteReturn<TReturn>, TReturn>;
 export declare function defineTool<TOutputSchema extends StandardJSONSchemaV1<unknown, unknown>, TReturn extends Promise<StandardJSONSchemaV1.InferOutput<TOutputSchema>> | StandardJSONSchemaV1.InferOutput<TOutputSchema> | AsyncIterable<StandardJSONSchemaV1.InferOutput<TOutputSchema>>>(definition: {
@@ -305,7 +286,6 @@ export declare function defineTool<TOutputSchema extends StandardJSONSchemaV1<un
     execute(input: Record<string, unknown>, ctx: ToolContext): TReturn;
     label?: ToolDefinition<Record<string, unknown>, StandardJSONSchemaV1.InferOutput<TOutputSchema>>["label"];
     approval?: ToolDefinition<Record<string, unknown>, unknown>["approval"];
-    approvalKey?: ToolDefinition<Record<string, unknown>, unknown>["approvalKey"];
     toModelOutput?: ToolDefinition<unknown, StandardJSONSchemaV1.InferOutput<TOutputSchema>>["toModelOutput"];
 }): ToolDefinitionWithExecuteReturn<Record<string, unknown>, StandardJSONSchemaV1.InferOutput<TOutputSchema>, TReturn>;
 export declare function defineTool<TReturn>(definition: {
@@ -316,7 +296,6 @@ export declare function defineTool<TReturn>(definition: {
     execute(input: Record<string, unknown>, ctx: ToolContext): TReturn;
     label?: ToolDefinition<Record<string, unknown>, ToolOutputFromExecuteReturn<TReturn>>["label"];
     approval?: ToolDefinition<Record<string, unknown>, unknown>["approval"];
-    approvalKey?: ToolDefinition<Record<string, unknown>, unknown>["approvalKey"];
     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>;
@@ -326,8 +305,7 @@ export declare function stampToolDefinition<T extends {
     readonly outputSchema?: unknown;
     readonly execute?: (...args: never[]) => unknown;
     readonly label?: ToolLabelDefinition;
-    readonly approval?: ToolApproval<never>;
-    readonly approvalKey?: (...args: never[]) => unknown;
+    readonly approval?: Approval<never>;
     readonly toModelOutput?: (...args: never[]) => unknown;
 }>(definition: T, definer: "defineTool" | "defineWorkflowTool"): T;
 /**

package/dist/src/tools/definition.js

@@ -1 +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(e){return stampToolDefinition(e,`defineTool`)}function stampToolDefinition(e,t){if(e.auth!==void 0)throw Error(`${t}: The "auth" field is no longer supported. Pass auth providers inline to ctx.getToken(provider) or ctx.requireAuth(provider).`);return Object.assign(e,{[TOOL_BRAND]:!0}),stampDurableDynamicToolCallbacks(e,collectDurableDynamicToolCallbacks({inputSchema:e.inputSchema,outputSchema:e.outputSchema,label:e.label,approval:e.approval,approvalKey:e.approvalKey,endsTurn:e.endsTurn,execute:e.execute,toModelOutput:e.toModelOutput})),stampDefinitionKey(e,`tool:${e.description}`),e}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,stampToolDefinition};
+import{TOOL_BRAND}from"#tools/dynamic.js";import{stampDefinitionKey}from"#internal/authored-definition/source-identity.js";function defineTool(e){return stampToolDefinition(e,`defineTool`)}function stampToolDefinition(e,t){if(e.auth!==void 0)throw Error(`${t}: The "auth" field is no longer supported. Pass auth providers inline to ctx.getToken(provider) or ctx.requireAuth(provider).`);if(`approvalKey`in e)throw Error(`${t}: approvalKey is no longer supported. Use an approval policy for input-dependent decisions.`);return Object.assign(e,{[TOOL_BRAND]:!0}),stampDefinitionKey(e,`tool:${e.description}`),e}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,stampToolDefinition};

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

@@ -1,81 +1,22 @@
-import type { ToolApproval } from "#approval/definition.js";
-import type { DynamicResolveContext, DynamicToolEventName } from "#dynamic/definition.js";
-import type { PublicToolInputSchema, PublicToolOutputSchema, ToolLabelDefinition, ToolContext } from "#tools/definition.js";
-import type { ToolModelOutput } from "#tools/model-output.js";
+import { type DefineDynamic } from "#dynamic/definition.js";
+import type { ToolDefinition } from "#tools/definition.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 by their bare key, prefixed with the mount namespace for an
- * extension's resolver.
- *
- * `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.
+ * One tool a dynamic resolver returns, created with `defineTool()`. A single returned entry is
+ * named after the file; entries of a returned map are named by their keys, prefixed with the
+ * mount namespace for an extension's resolver.
  */
-export interface DynamicToolEntry<TInput = Record<string, unknown>, TOutput = any> {
-    readonly availableInSubagents?: boolean;
-    /** Keeps this entry out of the model's tool list, as `deferred` on `defineTool`. */
-    readonly deferred?: boolean;
-    readonly label?: ToolLabelDefinition<TInput, TOutput>;
-    readonly description: string;
-    /**
-     * Ends the turn after a successful call, as `endsTurn` on a static
-     * `defineTool`. A function is replayed from its durable descriptor, like
-     * `execute`.
-     */
-    readonly endsTurn?: boolean | ((output: TOutput) => boolean | Promise<boolean>);
-    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?: ToolApproval<TInput>;
-    /** Derives the input-scoped key recorded when this tool is approved. */
-    readonly approvalKey?: (toolInput: Readonly<Record<string, unknown>>) => string;
-}
-/**
- * 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 by their keys), 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>;
-};
+export type DynamicToolEntry = Pick<ToolDefinition, "description" | "inputSchema">;
+/** A map of dynamic tools, named by key. */
+export type DynamicToolSet = Readonly<Record<string, DynamicToolEntry>>;
+/** What a dynamic tool resolver returns: one tool, a map of them, or `null`. */
+export type DynamicToolResult = DynamicToolEntry | DynamicToolSet | null;
+/** `defineDynamic()` for `agent/tools/`: returns one tool, a map of them, or `null`. */
+export declare const defineDynamic: DefineDynamic<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.
- */
+/** True when `value` carries the `defineTool` brand. */
 export declare function isBrandedToolEntry(value: unknown): boolean;

package/dist/src/tools/dynamic.js

@@ -1 +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};
+import{defineDynamic as defineDynamic$1}from"#dynamic/definition.js";const defineDynamic=defineDynamic$1,TOOL_BRAND=Symbol.for(`eve:tool-brand`);function isBrandedToolEntry(e){return typeof e==`object`&&!!e&&e[TOOL_BRAND]===!0}export{TOOL_BRAND,defineDynamic,isBrandedToolEntry};

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

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

package/dist/src/tools/provided/ask-question-workflow.d.ts

@@ -1,4 +1,4 @@
-import type { ToolInputRequest, ToolInputResponse, WorkflowToolContext } from "#public/tools/index.js";
+import type { ToolQuestion, ToolAnswer, WorkflowToolContext } from "#public/tools/index.js";
 import type { AskQuestionInput, AskQuestionOutput } from "#tools/provided/ask-question.js";
 /** Asks the session's user one question, and withdraws it when a new message arrives. */
 export declare function executeAskQuestionTool(input: AskQuestionInput, ctx: WorkflowToolContext): Promise<AskQuestionOutput>;
@@ -6,5 +6,5 @@ export declare function executeAskQuestionTool(input: AskQuestionInput, ctx: Wor
  * Free text is always allowed, so the model never needs an "Other" option.
  * Labels double as option ids so a late answer still reads as the label.
  */
-export declare function toAskQuestionRequest(input: AskQuestionInput): ToolInputRequest;
-export declare function toAskQuestionOutput(answer: ToolInputResponse): AskQuestionOutput;
+export declare function toAskQuestionRequest(input: AskQuestionInput): ToolQuestion;
+export declare function toAskQuestionOutput(answer: ToolAnswer): AskQuestionOutput;

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

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

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

@@ -23,11 +23,11 @@ export declare const ASK_QUESTION_INPUT_SCHEMA: import("#tools/schema.js").ToolS
  * ```ts
  * import { askQuestion } from "eve/tools/ask_question";
  *
- * export default askQuestion();
+ * export default askQuestion;
  * ```
  *
  * Each call runs as a durable workflow that asks through `ctx.ask()`, so the
  * turn waits for the answer without holding an application runtime open. A new
  * message that does not answer the question withdraws it.
  */
-export declare function askQuestion(): WorkflowExecuteToolDefinition<AskQuestionInput, AskQuestionOutput>;
+export declare const askQuestion: WorkflowExecuteToolDefinition<AskQuestionInput, AskQuestionOutput>;

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

@@ -1,2 +1,2 @@
 import{frameworkTool}from"./framework-tool.js";import{defineJsonSchema}from"#tools/schema.js";import{defineWorkflowTool}from"#public/tools/index.js";import{executeAskQuestionTool}from"#tools/provided/ask-question-workflow.js";import{INTERRUPTED_OUTPUT_SCHEMA,toInterruptibleModelOutput}from"#tools/provided/interrupted.js";const ASK_QUESTION_TOOL_DESCRIPTION=[`Ask the user a question and wait for the answer. Use this only when you cannot make good progress without the user's input: to choose between materially different approaches, fill in a missing requirement, or confirm something risky or irreversible. Do not ask for information you can find with your other tools, and do not ask the user to confirm routine steps.`,``,`Usage:`,`- Ask one focused question that includes the context needed to answer it.`,`- For a decision, offer 2-3 mutually exclusive options. Put the option you recommend first and end its label with "(Recommended)".`,`- Do not add an "Other" option; the user can always type their own answer.`,"- The result's `answer` is the chosen option's label or the user's own words.",`- If the question stopped early because a new message arrived, respond to that message instead.`,`- If the status is "unavailable", no one can answer in this session; continue with your best judgment and state the assumption you made.`].join(`
-`),ASK_QUESTION_INPUT_SCHEMA=defineJsonSchema({type:`object`,properties:{options:{type:`array`,minItems:2,maxItems:3,items:{type:`object`,properties:{description:{type:`string`,minLength:1,maxLength:200,description:`One short sentence on the impact or tradeoff of choosing this option.`},label:{type:`string`,minLength:1,maxLength:80,description:`User-facing label, 1-5 words.`}},required:[`description`,`label`],additionalProperties:!1},description:`Two or three mutually exclusive choices, recommended option first. Omit for an open-ended question. Never include an "Other" option.`},question:{type:`string`,minLength:1,maxLength:2e3,description:`The question to show the user, with the context needed to answer it.`}},required:[`question`],additionalProperties:!1},e=>e.options!==void 0&&new Set(e.options.map(e=>e.label)).size!==e.options.length?`Option labels must be unique.`:void 0),ASK_QUESTION_OUTPUT_SCHEMA=defineJsonSchema({oneOf:[{type:`object`,properties:{answer:{type:`string`,description:`The chosen option's label, or the user's own words.`},status:{type:`string`,const:`answered`}},required:[`answer`,`status`],additionalProperties:!1},INTERRUPTED_OUTPUT_SCHEMA,{type:`object`,properties:{status:{type:`string`,const:`unavailable`}},required:[`status`],additionalProperties:!1}]});function askQuestion(){return frameworkTool(defineWorkflowTool({description:ASK_QUESTION_TOOL_DESCRIPTION,execute:executeAskQuestionTool,inputSchema:ASK_QUESTION_INPUT_SCHEMA,outputSchema:ASK_QUESTION_OUTPUT_SCHEMA,toModelOutput:toInterruptibleModelOutput}))}export{ASK_QUESTION_INPUT_SCHEMA,ASK_QUESTION_TOOL_DESCRIPTION,askQuestion};
+`),ASK_QUESTION_INPUT_SCHEMA=defineJsonSchema({type:`object`,properties:{options:{type:`array`,minItems:2,maxItems:3,items:{type:`object`,properties:{description:{type:`string`,minLength:1,maxLength:200,description:`One short sentence on the impact or tradeoff of choosing this option.`},label:{type:`string`,minLength:1,maxLength:80,description:`User-facing label, 1-5 words.`}},required:[`description`,`label`],additionalProperties:!1},description:`Two or three mutually exclusive choices, recommended option first. Omit for an open-ended question. Never include an "Other" option.`},question:{type:`string`,minLength:1,maxLength:2e3,description:`The question to show the user, with the context needed to answer it.`}},required:[`question`],additionalProperties:!1},e=>e.options!==void 0&&new Set(e.options.map(e=>e.label)).size!==e.options.length?`Option labels must be unique.`:void 0),ASK_QUESTION_OUTPUT_SCHEMA=defineJsonSchema({oneOf:[{type:`object`,properties:{answer:{type:`string`,description:`The chosen option's label, or the user's own words.`},status:{type:`string`,const:`answered`}},required:[`answer`,`status`],additionalProperties:!1},INTERRUPTED_OUTPUT_SCHEMA,{type:`object`,properties:{status:{type:`string`,const:`unavailable`}},required:[`status`],additionalProperties:!1}]}),askQuestion=frameworkTool(defineWorkflowTool({description:ASK_QUESTION_TOOL_DESCRIPTION,execute:executeAskQuestionTool,inputSchema:ASK_QUESTION_INPUT_SCHEMA,outputSchema:ASK_QUESTION_OUTPUT_SCHEMA,toModelOutput:toInterruptibleModelOutput}));export{ASK_QUESTION_INPUT_SCHEMA,ASK_QUESTION_TOOL_DESCRIPTION,askQuestion};

package/dist/src/tools/provided/grep.d.ts

@@ -1,19 +1,6 @@
+import { type GrepToolInput, type GrepSearchResult as GrepToolOutput } from "#execution/sandbox/grep-search.js";
 import { type ToolDefinition } from "#tools/definition.js";
-export interface GrepToolInput {
-    context?: number;
-    glob?: string;
-    ignoreCase?: boolean;
-    limit?: number;
-    literal?: boolean;
-    path?: string;
-    pattern: string;
-}
-export interface GrepToolOutput {
-    content: string;
-    matchCount: number;
-    path: string;
-    truncated: boolean;
-}
+export type { GrepToolInput, GrepToolOutput };
 /**
  * Input schema for the provided `grep` tool.
  */

package/dist/src/tools/provided/grep.js

@@ -1,2 +1 @@
-import{frameworkTool}from"./framework-tool.js";import{defineJsonSchema}from"#tools/schema.js";import{defineTool}from"#tools/definition.js";import{toolLabel}from"#tools/tool-label.js";import{executeGrepOnSandbox}from"#execution/sandbox/grep-tool.js";const GREP_INPUT_SCHEMA=defineJsonSchema({type:`object`,properties:{context:{type:`integer`,minimum:0,description:`Number of surrounding context lines to include before and after each match. Defaults to 0.`},glob:{type:`string`,description:`Filter files by glob pattern (e.g. "*.ts", "*.{ts,tsx}").`},ignoreCase:{type:`boolean`,description:`Perform case-insensitive search. Defaults to false.`},limit:{type:`integer`,minimum:1,maximum:1e3,description:`Maximum number of matches to return per file. Defaults to 100.`},literal:{type:`boolean`,description:`Treat the pattern as a literal string instead of a regular expression. Defaults to false.`},path:{type:`string`,description:`The directory or file to search in: absolute, relative to the workspace root, or beginning with $HOME/. Omit to search the workspace root.`},pattern:{type:`string`,description:`The regex pattern to search for in file contents (e.g. "log.*Error", "function\\s+\\w+").`}},required:[`pattern`],additionalProperties:!1}),GREP_OUTPUT_SCHEMA=defineJsonSchema({type:`object`,properties:{content:{type:`string`},matchCount:{type:`integer`},path:{type:`string`},truncated:{type:`boolean`}},required:[`content`,`matchCount`,`path`,`truncated`],additionalProperties:!1}),grep=frameworkTool(defineTool({label:{start:e=>toolLabel(`Search`,e.pattern)},description:[`Fast content search tool that works with any codebase size.`,``,`Usage:`,`- Searches file contents using regular expressions.`,`- Supports full regex syntax (e.g. "log.*Error", "function\\s+\\w+").`,`- Filter files by pattern with the glob parameter (e.g. "*.js", "*.{ts,tsx}").`,`- Returns matching lines with file paths and line numbers.`,`- Call this tool in parallel when you have multiple independent searches.`,`- Any line longer than 2000 characters is truncated.`].join(`
-`),async execute(e,t){return await executeGrepOnSandbox(await t.getSandbox(),e)},inputSchema:GREP_INPUT_SCHEMA,outputSchema:GREP_OUTPUT_SCHEMA}));export{GREP_INPUT_SCHEMA,GREP_OUTPUT_SCHEMA,grep as default,grep};
+import{frameworkTool}from"./framework-tool.js";import{defineJsonSchema}from"#tools/schema.js";import{defineTool}from"#tools/definition.js";import{toolLabel}from"#tools/tool-label.js";import{GREP_OUTPUT_MODES,executeGrepSearch}from"#execution/sandbox/grep-search.js";const GREP_INPUT_SCHEMA=defineJsonSchema({type:`object`,properties:{context:{type:`integer`,minimum:0,description:`Number of surrounding context lines to include before and after each match. Defaults to 0.`},glob:{type:`string`,description:`Filter files by glob pattern (e.g. "*.ts", "*.{ts,tsx}").`},ignoreCase:{type:`boolean`,description:`Perform case-insensitive search. Defaults to false.`},limit:{type:`integer`,minimum:1,maximum:200,description:`Maximum rows to return. Defaults to 50; capped at 200.`},literal:{type:`boolean`,description:`Use a literal match. Defaults to true for identifier-like patterns, false for regex syntax.`},path:{type:`string`,description:`Directory or file inside the workspace. Defaults to the workspace root. Relative paths resolve within the workspace.`},outputMode:{type:`string`,enum:GREP_OUTPUT_MODES,description:`files_with_matches (default) lists paths; content returns matching lines; count returns per-file totals.`},pattern:{type:`string`,description:`The regex pattern to search for in file contents (e.g. "log.*Error", "function\\s+\\w+").`}},required:[`pattern`],additionalProperties:!1}),GREP_OUTPUT_SCHEMA=defineJsonSchema({type:`object`,properties:{content:{type:`string`},matchCount:{type:`integer`},outputMode:{type:`string`,enum:GREP_OUTPUT_MODES},path:{type:`string`},truncated:{type:`boolean`}},required:[`content`,`matchCount`,`outputMode`,`path`,`truncated`],additionalProperties:!1}),grep=frameworkTool(defineTool({label:{start:e=>toolLabel(`Search`,e.pattern)},description:`Search sandbox files with ripgrep (or a POSIX fallback). Start with files_with_matches and a narrow path or glob; use content for matching lines or count for totals. Includes hidden files, excludes .git; ripgrep respects .gitignore. The POSIX fallback does not read .gitignore. Output is bounded by rows and bytes.`,async execute(e,t){return await executeGrepSearch(e,await t.getSandbox(),t.abortSignal)},inputSchema:GREP_INPUT_SCHEMA,outputSchema:GREP_OUTPUT_SCHEMA}));export{GREP_INPUT_SCHEMA,GREP_OUTPUT_SCHEMA,grep as default,grep};