eve 0.44.4 → 0.45.0

package/dist/src/runtime/session-callback-route.js

@@ -1 +0,0 @@
-import{isInputRequest}from"#runtime/input/types.js";import{z}from"#compiled/zod/index.js";import{EVE_CALLBACK_ROUTE_PATTERN}from"#protocol/routes.js";import{jsonValueSchema}from"#shared/json-schemas.js";import{REMOTE_AGENT_FAILED}from"#harness/agent-handle-errors.js";import{readTaskIdFromInboxToken}from"#tasks/task-id.js";import{resumeHook}from"#internal/workflow/runtime.js";import{tokenUsageSchema}from"#shared/token-usage.js";import{agentTurnOutcomeSchema}from"#shared/agent-turn-outcome.js";const HTTP_SESSION_CALLBACK_CHANNEL_NAME_PREFIX=`eve/v1/callback`,HANDLED_METHODS=[`POST`],ZERO_TOKEN_USAGE={cacheReadTokens:0,cacheWriteTokens:0,inputTokens:0,outputTokens:0},eventCoordinateSchema=z.number().int().nonnegative(),authorizationChallengeSchema=z.looseObject({displayName:z.string().optional(),expiresAt:z.string().optional(),instructions:z.string().optional(),url:z.string().optional(),userCode:z.string().optional()}),taskInputEventSchema=z.looseObject({requests:z.array(jsonValueSchema.refine(isInputRequest)).min(1),sequence:eventCoordinateSchema,stepIndex:eventCoordinateSchema,turnId:z.string()}),taskAuthorizationEventSchema=z.discriminatedUnion(`type`,[z.looseObject({data:z.looseObject({attemptId:z.string().optional(),authorization:authorizationChallengeSchema.optional(),description:z.string(),name:z.string(),sequence:eventCoordinateSchema,stepIndex:eventCoordinateSchema,turnId:z.string(),webhookUrl:z.string().optional()}),type:z.literal(`authorization.required`)}),z.looseObject({data:z.looseObject({attemptId:z.string().optional(),authorization:authorizationChallengeSchema.optional(),name:z.string(),outcome:z.enum([`authorized`,`declined`,`failed`,`timed-out`]),reason:z.string().optional(),sequence:eventCoordinateSchema,stepIndex:eventCoordinateSchema,turnId:z.string()}),type:z.literal(`authorization.completed`)})]),taskEventCallbackSchema=z.discriminatedUnion(`kind`,[z.object({callId:z.string(),childContinuationToken:z.string(),childSessionId:z.string(),event:taskInputEventSchema,kind:z.literal(`task.input-requested`),subagentName:z.string(),taskId:z.string()}),z.object({callId:z.string(),childContinuationToken:z.string(),childSessionId:z.string(),event:taskAuthorizationEventSchema,kind:z.literal(`task.authorization`),subagentName:z.string(),taskId:z.string()})]),taskTurnStartedCallbackSchema=z.object({kind:z.literal(`turn.started`),sessionId:z.string().min(1),taskId:z.string().min(1),turnId:z.string().min(1)}),taskUpdateCallbackSchema=z.object({callId:z.string().min(1),kind:z.literal(`task.update`),message:z.string().min(1),taskId:z.string().min(1),updateEpoch:z.string().min(1),updateIndex:eventCoordinateSchema}),sessionResultCallbackSchema=z.discriminatedUnion(`kind`,[z.object({callId:z.string().min(1),kind:z.literal(`session.completed`),output:jsonValueSchema.optional(),subagentName:z.string().min(1),usage:z.unknown().optional()}),z.object({callId:z.string().min(1),error:jsonValueSchema.optional(),kind:z.literal(`session.failed`),subagentName:z.string().min(1),usage:z.unknown().optional()}),z.object({callId:z.string().min(1),kind:z.literal(`turn.completed`),outcome:agentTurnOutcomeSchema,output:jsonValueSchema.optional(),subagentName:z.string().min(1)}),z.object({callId:z.string().min(1),error:jsonValueSchema,kind:z.literal(`turn.failed`),outcome:agentTurnOutcomeSchema,subagentName:z.string().min(1)})]);function getSessionCallbackChannelDefinitions(){return HANDLED_METHODS.map(e=>buildCallbackChannelDefinition(e))}function getSessionCallbackChannelNames(){return new Set(HANDLED_METHODS.map(channelNameForMethod))}function buildCallbackChannelDefinition(e){let t=channelNameForMethod(e);return{name:t,method:e,urlPath:EVE_CALLBACK_ROUTE_PATTERN,fetch:handleSessionCallbackRequest,logicalPath:`framework://channels/${t}`,sourceId:`eve:framework:session-callback-${e.toLowerCase()}`,sourceKind:`module`}}function channelNameForMethod(e){return`${HTTP_SESSION_CALLBACK_CHANNEL_NAME_PREFIX}/${e.toLowerCase()}`}async function handleSessionCallbackRequest(e,t){let n=t.params.token;if(typeof n!=`string`||n.length===0)return Response.json({error:`Missing callback token.`,ok:!1},{status:400});let r;try{r=await e.json()}catch{return Response.json({error:`Invalid JSON body.`,ok:!1},{status:400})}let i=projectTaskEvent(r,n);if(i instanceof Response)return i;if(i!==void 0){try{await resumeHook(n,i)}catch{return Response.json({error:`Session callback not pending.`,ok:!1},{status:404})}return Response.json({ok:!0},{status:202})}let a=projectTaskUpdate(r,n);if(a instanceof Response)return a;if(a!==void 0){try{await resumeHook(n,a)}catch{return Response.json({error:`Session callback not pending.`,ok:!1},{status:404})}return Response.json({ok:!0},{status:202})}let o=projectTaskTurnStarted(r,n);if(o instanceof Response)return o;if(o!==void 0){try{await resumeHook(n,o)}catch{return Response.json({error:`Session callback not pending.`,ok:!1},{status:404})}return Response.json({ok:!0},{status:202})}let s=projectSessionCallbackResult(r);if(s instanceof Response)return s;try{await resumeHook(n,{kind:`runtime-action-result`,results:[s]})}catch{return Response.json({error:`Session callback not pending.`,ok:!1},{status:404})}return Response.json({ok:!0},{status:202})}function callbackKind(e){if(!(typeof e!=`object`||!e))return Reflect.get(e,`kind`)}function projectTaskEvent(e,t){let n=callbackKind(e);if(n!==`task.input-requested`&&n!==`task.authorization`)return;let r=taskEventCallbackSchema.safeParse(e);if(!r.success)return Response.json({error:`Invalid task event callback.`,ok:!1},{status:400});let i=r.data,a=rejectMismatchedTaskToken(t,i.taskId);return a===void 0?i.kind===`task.input-requested`?{callId:i.callId,childContinuationToken:i.childContinuationToken,childSessionId:i.childSessionId,event:i.event,kind:`subagent-input-request`,subagentName:i.subagentName}:{callId:i.callId,childSessionId:i.childSessionId,event:i.event,kind:`authorization-event`,subagentName:i.subagentName}:a}function projectTaskTurnStarted(e,t){if(callbackKind(e)!==`turn.started`)return;let n=taskTurnStartedCallbackSchema.safeParse(e);if(!n.success)return Response.json({error:`Invalid task turn-start callback.`,ok:!1},{status:400});let r=rejectMismatchedTaskToken(t,n.data.taskId);return r===void 0?{childSessionId:n.data.sessionId,childTurnId:n.data.turnId,kind:`turn-started`,taskId:n.data.taskId}:r}function projectTaskUpdate(e,t){if(callbackKind(e)!==`task.update`)return;let n=taskUpdateCallbackSchema.safeParse(e);if(!n.success)return Response.json({error:`Invalid task update callback.`,ok:!1},{status:400});let r=rejectMismatchedTaskToken(t,n.data.taskId);return r===void 0?{callId:n.data.callId,kind:`task-update`,message:n.data.message,updateEpoch:n.data.updateEpoch,updateIndex:n.data.updateIndex}:r}function rejectMismatchedTaskToken(e,t){return readTaskIdFromInboxToken(e)===t?void 0:Response.json({error:`Task callback token mismatch.`,ok:!1},{status:403})}function projectSessionCallbackResult(e){if(typeof e!=`object`||!e)return Response.json({error:`Expected a JSON object.`,ok:!1},{status:400});let t=callbackKind(e);if(t!==`session.completed`&&t!==`session.failed`&&t!==`turn.completed`&&t!==`turn.failed`)return Response.json({error:`Unsupported callback kind.`,ok:!1},{status:400});let n=sessionResultCallbackSchema.safeParse(e);if(!n.success)return Response.json({error:`Invalid session result callback.`,ok:!1},{status:400});let r=n.data;if(r.kind===`session.completed`){let e=r.output??``,t=parseCallbackUsage(r.usage),n={callId:r.callId,kind:`subagent-result`,origin:`child`,outcome:{kind:`terminal`,result:{kind:`succeeded`,output:e},usageDelta:t??ZERO_TOKEN_USAGE},output:e,subagentName:r.subagentName};return t===void 0?n:{...n,usage:t}}if(r.kind===`session.failed`){let e=r.error===void 0?{code:REMOTE_AGENT_FAILED,message:`Remote agent failed.`}:r.error,t=parseCallbackUsage(r.usage);return{callId:r.callId,isError:!0,kind:`subagent-result`,origin:`child`,outcome:{kind:`terminal`,result:{error:e,kind:`failed`},usageDelta:t??ZERO_TOKEN_USAGE},output:e,subagentName:r.subagentName}}return r.kind===`turn.completed`?{callId:r.callId,kind:`subagent-result`,origin:`child`,outcome:r.outcome,output:r.output??``,subagentName:r.subagentName,usage:r.outcome.usageDelta}:{callId:r.callId,isError:!0,kind:`subagent-result`,origin:`child`,outcome:r.outcome,output:r.error,subagentName:r.subagentName}}function parseCallbackUsage(e){if(e===void 0)return;let t=tokenUsageSchema.safeParse(e);return t.success?t.data:void 0}export{HTTP_SESSION_CALLBACK_CHANNEL_NAME_PREFIX,getSessionCallbackChannelDefinitions,getSessionCallbackChannelNames,handleSessionCallbackRequest};

package/dist/src/runtime/task-input-response-route.d.ts

@@ -1,5 +0,0 @@
-import type { RouteContext } from "#public/definitions/channel.js";
-import type { ResolvedChannelDefinition } from "#runtime/types.js";
-export declare function getTaskInputResponseChannelDefinitions(): readonly ResolvedChannelDefinition[];
-export declare function getTaskInputResponseChannelNames(): ReadonlySet<string>;
-export declare function handleTaskInputResponseRequest(request: Request, ctx: RouteContext): Promise<Response>;

package/dist/src/runtime/task-input-response-route.js

@@ -1 +0,0 @@
-import{EVE_TASK_INPUT_ROUTE_PATTERN}from"#protocol/routes.js";import{resumeSessionInbox}from"#execution/wire/session-inbox-resume.js";import{readTaskInputTargetToken}from"#execution/task-input-capability.js";const NAME=`eve/v1/task-input/post`;function getTaskInputResponseChannelDefinitions(){return[{fetch:handleTaskInputResponseRequest,logicalPath:`framework://channels/${NAME}`,method:`POST`,name:NAME,sourceId:`eve:framework:task-input-post`,sourceKind:`module`,urlPath:EVE_TASK_INPUT_ROUTE_PATTERN}]}function getTaskInputResponseChannelNames(){return new Set([NAME])}async function handleTaskInputResponseRequest(e,r){let i=r.params.token;if(typeof i!=`string`||i.length===0)return Response.json({error:`Missing task input token.`,ok:!1},{status:400});let a=readTaskInputTargetToken(i);if(a===void 0)return Response.json({error:`Invalid task input token.`,ok:!1},{status:403});let o;try{o=await e.json()}catch{return Response.json({error:`Invalid JSON body.`,ok:!1},{status:400})}let s=readInputResponses(o);if(s===void 0||s.length===0)return Response.json({error:`Expected a non-empty inputResponses array.`,ok:!1},{status:400});try{await resumeSessionInbox(a,{kind:`send`,payload:{inputResponses:s}})}catch{return Response.json({error:`Task input target is not pending.`,ok:!1},{status:404})}return Response.json({ok:!0},{status:202})}function readInputResponses(e){if(typeof e!=`object`||!e||Array.isArray(e))return;let t=Reflect.get(e,`inputResponses`);if(!Array.isArray(t))return;let n=[];for(let e of t){if(typeof e!=`object`||!e||Array.isArray(e))return;let t=Reflect.get(e,`requestId`),r=Reflect.get(e,`optionId`),i=Reflect.get(e,`text`);if(typeof t!=`string`||r!==void 0&&typeof r!=`string`||i!==void 0&&typeof i!=`string`)return;let a={requestId:t};typeof r==`string`&&(a.optionId=r),typeof i==`string`&&(a.text=i),n.push(a)}return n}export{getTaskInputResponseChannelDefinitions,getTaskInputResponseChannelNames,handleTaskInputResponseRequest};

package/dist/src/shared/durable-dynamic-tool-callbacks.js

@@ -1 +0,0 @@
-import{resolveApprovalPolicy}from"#public/definitions/approval.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/shared/dynamic-tool-definition.d.ts

@@ -1,154 +0,0 @@
-import type { ModelMessage } from "ai";
-import type { PublicToolInputSchema, PublicToolOutputSchema, ToolModelOutput } from "#shared/tool-definition.js";
-import type { Approval } from "#public/definitions/approval.js";
-import type { ToolContext } from "#public/definitions/tool.js";
-import type { SessionAuth } from "#context/keys.js";
-import type { UnstampedMessageStreamEvent } from "#protocol/message.js";
-/**
- * Stream event types allowed for dynamic tool resolvers. Dispatch
- * supports any event; this extract restricts the public surface until
- * more events are validated.
- */
-export type DynamicToolEventName = Extract<UnstampedMessageStreamEvent["type"], "session.started" | "turn.started" | "step.started">;
-export declare const ALLOWED_DYNAMIC_TOOL_EVENTS: ReadonlySet<string>;
-/**
- * Instructions and skills are restricted to session/turn boundaries.
- * Keeping their resolved context stable within a turn avoids changing the
- * model input between tool-loop steps.
- */
-export declare const ALLOWED_DYNAMIC_INSTRUCTION_EVENTS: ReadonlySet<string>;
-export declare const ALLOWED_DYNAMIC_SKILL_EVENTS: ReadonlySet<string>;
-/**
- * Context passed to a dynamic resolver's event handler.
- *
- * Exposes read-only session identity, auth, and channel metadata. State
- * is not exposed here; resolvers read it through `defineState` handles or
- * the session context inside tool `execute` functions.
- */
-export interface DynamicResolveContext {
-    readonly session: {
-        readonly id: string;
-        readonly auth: SessionAuth;
-    };
-    /** Channel metadata for the request that triggered this resolve. */
-    readonly channel: {
-        /** Channel type that produced the request (e.g. `"slack"`, `"http"`), when known. */
-        readonly kind?: string;
-        /** Channel-owned resume handle for the conversation, when the channel supplies one. */
-        readonly continuationToken?: string;
-        /** Free-form channel-specific metadata attached to the request. */
-        readonly metadata?: Readonly<Record<string, unknown>>;
-    };
-    /** Conversation history visible at this resolve point, oldest first. */
-    readonly messages: readonly ModelMessage[];
-}
-/**
- * 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>;
-};
-/**
- * Base event handler map accepted by `defineDynamic`. Intentionally
- * wide so it accepts both tool-returning and skill-returning handlers:
- * the slot directory (tools/ vs skills/) determines the required return,
- * validated at runtime by the respective resolver.
- */
-export type DynamicEvents<TResult = unknown> = {
-    readonly [K in DynamicToolEventName]?: (event: unknown, ctx: DynamicResolveContext) => TResult | Promise<TResult>;
-};
-/**
- * Marker discriminator for a `defineDynamic({ events })` export.
- */
-export declare const DYNAMIC_SENTINEL_KIND: "eve:dynamic";
-/**
- * Return value of `defineDynamic`: the runtime shape of a dynamic export,
- * stamped with a sentinel kind the compiler/normalizer detects.
- */
-export type DynamicSentinel<TResult = unknown> = {
-    readonly kind: typeof DYNAMIC_SENTINEL_KIND;
-    readonly events: DynamicEvents<TResult>;
-};
-export declare function assertResolverOnlyDynamicSentinel(sentinel: DynamicSentinel, message: string): void;
-export declare function isDynamicSentinel(value: unknown): value is DynamicSentinel;
-/**
- * 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;
-/**
- * Symbol-based brand stamped by `defineInstructions` on every entry.
- * Invisible in IntelliSense, checked at runtime to validate that dynamic
- * instruction resolver returns are properly wrapped.
- */
-export declare const INSTRUCTIONS_BRAND: unique symbol;
-/**
- * Returns true if `value` carries the `defineInstructions` brand symbol.
- * Used to validate that dynamic instruction entries are properly wrapped.
- */
-export declare function isBrandedInstructionsEntry(value: unknown): boolean;
-/**
- * Symbol-based brand stamped by `defineSkill` on every entry. Invisible
- * in IntelliSense, checked at runtime to detect single-entry vs
- * map-of-entries return shapes in dynamic skill resolvers.
- */
-export declare const SKILL_BRAND: unique symbol;
-/**
- * Returns true if `value` carries the `defineSkill` brand symbol. Used
- * to detect single entry vs map of entries and to validate that entries
- * are properly wrapped.
- */
-export declare function isBrandedSkillEntry(value: unknown): boolean;

package/dist/src/shared/dynamic-tool-definition.js

@@ -1 +0,0 @@
-const ALLOWED_DYNAMIC_TOOL_EVENTS=new Set([`session.started`,`turn.started`,`step.started`]),ALLOWED_DYNAMIC_INSTRUCTION_EVENTS=new Set([`session.started`,`turn.started`]),ALLOWED_DYNAMIC_SKILL_EVENTS=new Set([`session.started`,`turn.started`]),DYNAMIC_SENTINEL_KIND=`eve:dynamic`;function assertResolverOnlyDynamicSentinel(e,t){let n=Object.keys(e).filter(e=>e!==`events`&&e!==`kind`);if(n.length>0)throw Error(`${t} Unknown key(s): ${n.join(`, `)}.`)}function isDynamicSentinel(e){return typeof e==`object`&&!!e&&e.kind===`eve:dynamic`}const TOOL_BRAND=Symbol.for(`eve:tool-brand`);function isBrandedToolEntry(e){return typeof e==`object`&&!!e&&e[TOOL_BRAND]===!0}const INSTRUCTIONS_BRAND=Symbol.for(`eve:instructions-brand`);function isBrandedInstructionsEntry(e){return typeof e==`object`&&!!e&&e[INSTRUCTIONS_BRAND]===!0}const SKILL_BRAND=Symbol.for(`eve:skill-brand`);function isBrandedSkillEntry(e){return typeof e==`object`&&!!e&&e[SKILL_BRAND]===!0}export{ALLOWED_DYNAMIC_INSTRUCTION_EVENTS,ALLOWED_DYNAMIC_SKILL_EVENTS,ALLOWED_DYNAMIC_TOOL_EVENTS,DYNAMIC_SENTINEL_KIND,INSTRUCTIONS_BRAND,SKILL_BRAND,TOOL_BRAND,assertResolverOnlyDynamicSentinel,isBrandedInstructionsEntry,isBrandedSkillEntry,isBrandedToolEntry,isDynamicSentinel};

package/dist/src/shared/eve-server-health.d.ts

@@ -1,5 +0,0 @@
-/** Returns whether an Eve server answers its health route successfully. */
-export declare function isEveServerHealthy(serverUrl: string, options?: {
-    readonly signal?: AbortSignal;
-    readonly timeoutMs?: number;
-}): Promise<boolean>;

package/dist/src/shared/eve-server-health.js

@@ -1 +0,0 @@
-import{EVE_HEALTH_ROUTE_PATH}from"#protocol/routes.js";async function isEveServerHealthy(e,t={}){let n=AbortSignal.timeout(t.timeoutMs??1e3),r=t.signal===void 0?n:AbortSignal.any([t.signal,n]);try{let t=new URL(EVE_HEALTH_ROUTE_PATH,e).toString();return(await fetch(t,{redirect:`error`,signal:r})).ok}catch{return!1}}export{isEveServerHealthy};

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

@@ -1,89 +0,0 @@
-import type { ToolExecutionOptions } from "ai";
-import type { StandardJSONSchemaV1, StandardSchemaV1 } from "#compiled/@standard-schema/spec/index.js";
-import type { JsonObject } from "#shared/json.js";
-import type { TaskExec } from "#shared/tool-task.js";
-/**
- * Options forwarded from the AI SDK to the tool's {@link ToolDefinition.execute}
- * function. These are the same options the SDK passes to every tool call.
- */
-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;
-}
-/**
- * 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 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;
-/**
- * Authored public tool definition shape. Identity is derived from the
- * file path at compile time, so `name` is intentionally absent here.
- */
-export interface PublicToolDefinition<TInput = unknown, TOutput = unknown> extends ToolDefinitionBase {
-    inputSchema: PublicToolInputSchema<TInput>;
-    /**
-     * Optional schema describing the value returned by the tool executor.
-     * The AI SDK can use this for tool result typing.
-     */
-    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>;
-}
-/**
- * eve-owned shape for the model-facing tool result produced by
- * `toModelOutput`. Structurally compatible with the AI SDK's
- * `ToolResultOutput` so the harness can forward it without conversion.
- *
- * The `content` variant carries an ordered list of
- * {@link ToolModelOutputPart} entries, letting a tool hand the model
- * text alongside inline files (e.g. a screenshot as vision input).
- */
-export type ToolModelOutput = {
-    readonly type: "text";
-    readonly value: string;
-} | {
-    readonly type: "json";
-    readonly value: unknown;
-} | {
-    readonly type: "content";
-    readonly value: readonly ToolModelOutputPart[];
-};
-/**
- * One part of a `content` {@link ToolModelOutput}. Mirrors the AI SDK's
- * `ToolResultOutput` content parts narrowed to the JSON-safe subset:
- * file data is the SDK's tagged `FileData` union restricted to
- * `{ type: "data" }` with a base64 string, so persisted tool results
- * survive the durable JSON boundary. Use the `toolOutputPart` builders
- * from `eve/tools` to construct parts without hand-writing the nesting.
- */
-export type ToolModelOutputPart = {
-    readonly type: "text";
-    readonly text: string;
-} | {
-    readonly type: "file";
-    /** Tagged file data; only JSON-safe base64 payloads are accepted. */
-    readonly data: {
-        readonly type: "data";
-        readonly data: string;
-    };
-    /** IANA media type, e.g. `image/png`. */
-    readonly mediaType: string;
-    readonly filename?: string;
-};
-export {};