eve 0.5.4 → 0.6.0-beta.3

package/dist/src/services/dev-client.d.ts

@@ -0,0 +1,75 @@
+import type { UserContent } from "ai";
+import { type SessionState } from "#client/index.js";
+import type { ClientSession } from "#client/session.js";
+import type { HandleMessageStreamEvent } from "#protocol/message.js";
+import type { InputResponse } from "#runtime/input/types.js";
+import type { JsonObject } from "#shared/json.js";
+/**
+ * Result returned after one development-client message exchange.
+ */
+export interface DevelopmentClientSendResult {
+    readonly events: HandleMessageStreamEvent[];
+    readonly sessionId: string;
+    readonly session: SessionState;
+}
+/**
+ * Stable service-style client for the Eve development message protocol.
+ */
+export interface DevelopmentMessageClient {
+    /**
+     * Clears the current durable session cursor.
+     */
+    clear(): Promise<void>;
+    /**
+     * Closes the client and disposes any session-attached resources.
+     */
+    close(): Promise<void>;
+    /**
+     * Returns the current durable session cursor.
+     */
+    getSession(): SessionState;
+    /**
+     * Sends one turn payload through the active development session.
+     */
+    send(input: {
+        readonly clientContext?: string | readonly string[] | JsonObject;
+        readonly inputResponses?: readonly InputResponse[];
+        readonly message?: string | UserContent;
+        onEvent?(event: HandleMessageStreamEvent): void;
+        onResponseStart?(response: {
+            sessionId?: string;
+        }): void;
+    }): Promise<DevelopmentClientSendResult>;
+}
+/**
+ * Tracks local dev runtime-artifact revisions and starts a fresh session for
+ * normal prompts after HMR, while preserving the current session for
+ * input-response resumes.
+ */
+export interface DevelopmentRuntimeArtifactSessionRefresher {
+    /**
+     * Clears the remembered runtime-artifact revision.
+     */
+    clear(): void;
+    /**
+     * Returns the session that should dispatch the next turn.
+     */
+    refresh(input: {
+        readonly createSession: () => ClientSession;
+        readonly inputResponses?: readonly InputResponse[];
+        readonly message?: string | UserContent;
+        readonly session: ClientSession;
+    }): Promise<ClientSession>;
+}
+/**
+ * Creates a revision-aware local dev session refresher.
+ */
+export declare function createDevelopmentRuntimeArtifactSessionRefresher(input: {
+    readonly serverUrl: string;
+}): DevelopmentRuntimeArtifactSessionRefresher;
+/**
+ * Creates a stateful development client bound to one Eve server URL.
+ */
+export declare function createDevClient(input: {
+    serverUrl: string;
+}): DevelopmentMessageClient;

package/dist/src/services/dev-client.js

@@ -0,0 +1 @@
+import{EVE_DEV_RUNTIME_ARTIFACTS_ROUTE_PATH}from"#protocol/routes.js";import{isLocalDevelopmentServerUrl,resolveDevelopmentClientHeaders,resolveDevelopmentOidcToken}from"#services/dev-client/request-headers.js";import{Client}from"#client/index.js";var BufferedDevelopmentMessageClient=class{#e;#t;#n;constructor(e){let a=isLocalDevelopmentServerUrl(e.serverUrl);this.#t=createDevelopmentRuntimeArtifactSessionRefresher({serverUrl:e.serverUrl});let o={headers:()=>resolveDevelopmentClientHeaders({serverUrl:e.serverUrl}),host:e.serverUrl};this.#e=new Client(a?o:{...o,auth:{bearer:resolveDevelopmentOidcToken}}),this.#n=this.#e.session()}async clear(){this.#n=this.#e.session(),this.#t.clear()}async close(){}getSession(){return this.#n.state}async send(e){this.#n=await this.#t.refresh({createSession:()=>this.#e.session(),inputResponses:e.inputResponses,message:e.message,session:this.#n});let t=await this.#n.send({clientContext:e.clientContext,inputResponses:e.inputResponses,message:e.message});e.onResponseStart?.({sessionId:t.sessionId});let n=[];for await(let r of t)n.push(r),e.onEvent?.(r);return{events:n,sessionId:t.sessionId,session:this.#n.state}}},LocalDevelopmentRuntimeArtifactSessionRefresher=class{#e;#t;#n;constructor(e){this.#e=isLocalDevelopmentServerUrl(e.serverUrl),this.#t=e.serverUrl}clear(){this.#n=void 0}async refresh(e){if(!this.#e||!shouldRefreshRuntimeArtifactsForTurn(e))return e.session;let t=await this.#r();if(t===void 0)return e.session;let n=e.session;return this.#n!==void 0&&this.#n!==t&&n.state.continuationToken!==void 0&&(n=e.createSession()),this.#n=t,n}async#r(){try{let t=new URL(EVE_DEV_RUNTIME_ARTIFACTS_ROUTE_PATH,this.#t),r=await fetch(t,{headers:await resolveDevelopmentClientHeaders({serverUrl:this.#t})});if(!r.ok)return;let i=await r.json();return typeof i.revision==`string`&&i.revision.length>0?i.revision:void 0}catch{return}}};function shouldRefreshRuntimeArtifactsForTurn(e){return e.message!==void 0&&(e.inputResponses?.length??0)===0}function createDevelopmentRuntimeArtifactSessionRefresher(e){return new LocalDevelopmentRuntimeArtifactSessionRefresher(e)}function createDevClient(e){return new BufferedDevelopmentMessageClient(e)}export{createDevClient,createDevelopmentRuntimeArtifactSessionRefresher};

package/dist/src/services/inspect-application.d.ts

@@ -0,0 +1,23 @@
+import { type CompileAgentResult } from "#compiler/compile-agent.js";
+import { type ApplicationInfo } from "#internal/application/paths.js";
+/**
+ * Stable message-contract details surfaced to CLI consumers.
+ */
+export interface ApplicationInspectionMessaging {
+    readonly createSessionRoutePath: string;
+    readonly continueSessionRoutePattern: string;
+    readonly streamRoutePattern: string;
+}
+/**
+ * Structured application inspection data for CLI surfaces.
+ */
+export interface ApplicationInspection {
+    readonly application: ApplicationInfo;
+    readonly compiledState: CompileAgentResult | null;
+    readonly messaging: ApplicationInspectionMessaging;
+}
+/**
+ * Resolves application details, compile artifacts, and the active message
+ * contract for one Eve application root.
+ */
+export declare function inspectApplication(appRoot: string): Promise<ApplicationInspection>;

package/dist/src/services/inspect-application.js

@@ -0,0 +1 @@
+import{EVE_CONTINUE_SESSION_ROUTE_PATTERN,EVE_CREATE_SESSION_ROUTE_PATH,EVE_MESSAGE_STREAM_ROUTE_PATTERN}from"#protocol/routes.js";import{getApplicationInfo}from"#internal/application/paths.js";import{DiscoveryProjectResolutionError}from"#discover/project.js";import{MissingAgentConfigModuleError}from"#compiler/normalize-agent-config.js";import{CompileAgentError,compileAgent}from"#compiler/compile-agent.js";async function inspectApplication(t){let n=await loadCompiledApplicationState(t);return{application:getApplicationInfo(n?.project.appRoot??t),compiledState:n,messaging:{createSessionRoutePath:EVE_CREATE_SESSION_ROUTE_PATH,continueSessionRoutePattern:EVE_CONTINUE_SESSION_ROUTE_PATTERN,streamRoutePattern:EVE_MESSAGE_STREAM_ROUTE_PATTERN}}}async function loadCompiledApplicationState(e){try{return await compileAgent({startPath:e})}catch(e){if(e instanceof CompileAgentError)return e.result;if(e instanceof DiscoveryProjectResolutionError||e instanceof MissingAgentConfigModuleError)return null;throw e}}export{inspectApplication};

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

@@ -0,0 +1,154 @@
+import type { LanguageModel } from "ai";
+import type { StandardJSONSchemaV1 } from "#compiled/@standard-schema/spec/index.js";
+import type { JsonObject } from "#shared/json.js";
+import type { ModuleSourceRef } from "#shared/source-ref.js";
+/**
+ * Optional overrides that Eve forwards to the AI SDK model runtime call for
+ * this model.
+ */
+export interface AgentModelOptionsDefinition {
+    readonly providerOptions?: Record<string, JsonObject>;
+}
+export type InternalAgentModelDefinition = {
+    id: string;
+    contextWindowTokens?: number;
+    source?: ModuleSourceRef;
+    providerOptions?: Record<string, JsonObject>;
+};
+/**
+ * The model handle you assign to an agent's `model` field. This is the AI SDK
+ * `LanguageModel` value (for example, the result of a provider or gateway
+ * model call), not an Eve-authored definition object.
+ */
+export type PublicAgentModelDefinition = LanguageModel;
+export interface InternalAgentCompactionDefinition {
+    /**
+     * Optional model used only for generating compaction summaries.
+     *
+     * When omitted, Eve uses the active turn model for the summary call.
+     */
+    model?: InternalAgentModelDefinition;
+    /**
+     * Fraction of the primary model context window that triggers compaction.
+     *
+     * Eve defaults to `0.9` when this is omitted.
+     */
+    thresholdPercent?: number;
+}
+/**
+ * Configures conversation compaction: when the model context window fills past
+ * `thresholdPercent`, Eve summarizes earlier turns to reclaim space. Every
+ * field is optional; omit the block to use Eve's defaults.
+ */
+export interface PublicAgentCompactionDefinition {
+    /**
+     * Optional override for the compaction summary model's context window size,
+     * in tokens.
+     *
+     * Same escape hatch as the agent-level `modelContextWindowTokens`. When set,
+     * Eve uses this value verbatim and skips the AI Gateway lookup for the
+     * compaction summary model.
+     */
+    readonly modelContextWindowTokens?: number;
+    /**
+     * Optional model used only for generating compaction summaries.
+     *
+     * When omitted, Eve uses the active turn model for the summary call.
+     */
+    readonly model?: PublicAgentModelDefinition;
+    /**
+     * Fraction of the primary model context window that triggers compaction.
+     *
+     * Eve defaults to `0.9` when this is omitted.
+     */
+    readonly thresholdPercent?: number;
+}
+/**
+ * Experimental, opt-in agent capabilities authored in `agent.ts`.
+ *
+ * These options are unstable and may change or be removed in any release.
+ * Each agent (the root agent and every subagent) carries its own flags, so
+ * code mode can be enabled for the whole graph, only a subagent, or only
+ * the parent.
+ */
+export interface AgentExperimentalDefinition {
+    /**
+     * Routes executable tools through a sandboxed code-execution wrapper
+     * instead of exposing them directly to the model. The model writes
+     * JavaScript that calls the tools inside the sandbox.
+     *
+     * When unset, Eve falls back to the `EVE_EXPERIMENTAL_CODE_MODE`
+     * environment variable (`"1"` enables it) for backwards compatibility.
+     */
+    readonly codeMode?: boolean;
+}
+/**
+ * Advanced hosted-build controls authored in `agent.ts`.
+ *
+ * Eve uses these only while packaging the application host. They do not affect
+ * the runtime prompt or authored execution APIs.
+ */
+export interface AgentBuildDefinition {
+    /**
+     * Additional imported package names that Eve should keep external and trace
+     * into hosted build output.
+     *
+     * Prefer this when a package is sensitive to bundling and should ship via
+     * `server/node_modules` in hosted output.
+     */
+    readonly externalDependencies?: string[];
+}
+/**
+ * Compiled-side agent definition. Carries a `name` because the compiler
+ * stamps the path-derived `agentId` onto every compiled agent node.
+ */
+export type InternalAgentDefinition = {
+    name: string;
+    description?: string;
+    build?: AgentBuildDefinition;
+    compaction?: InternalAgentCompactionDefinition;
+    experimental?: AgentExperimentalDefinition;
+    model: InternalAgentModelDefinition;
+    outputSchema?: JsonObject;
+    source?: ModuleSourceRef;
+};
+/**
+ * Shared public definition for an agent.
+ *
+ * Identity is derived at compile time from `manifest.agentId` (the
+ * package name or app-root basename). Authored definitions do not carry
+ * a `name` field.
+ */
+export type PublicAgentDefinition = {
+    /**
+     * Human-readable description of the agent's purpose. Required for
+     * subagents (authored under `subagents/<id>/agent.ts`): surfaced to
+     * the parent agent as the lowered subagent tool's description.
+     */
+    readonly description?: string;
+    readonly build?: AgentBuildDefinition;
+    readonly compaction?: PublicAgentCompactionDefinition;
+    /**
+     * Experimental, opt-in capabilities. Unstable, see
+     * {@link AgentExperimentalDefinition}.
+     */
+    readonly experimental?: AgentExperimentalDefinition;
+    readonly model: PublicAgentModelDefinition;
+    /**
+     * Optional override for the primary model's context window size, in tokens.
+     *
+     * Escape hatch for cases where Eve cannot resolve the model's metadata via
+     * the AI Gateway model catalog (e.g. a custom or unlisted model id). When
+     * set, Eve uses this value verbatim and skips the AI Gateway lookup. Prefer
+     * leaving this unset so Eve can stay in sync with provider metadata.
+     */
+    readonly modelContextWindowTokens?: number;
+    readonly modelOptions?: AgentModelOptionsDefinition;
+    /**
+     * Optional structured return type used when this agent runs in task mode
+     * (for example as a subagent, schedule, or remote job). Interactive
+     * conversation turns ignore this field unless the client supplies a
+     * per-message output schema.
+     */
+    readonly outputSchema?: StandardJSONSchemaV1<unknown, unknown> | JsonObject;
+};

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

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

package/dist/src/shared/code-mode.d.ts

@@ -0,0 +1,29 @@
+import type * as CodeModeModule from "#compiled/experimental-ai-sdk-code-mode/index.js";
+/** Internal AI SDK tool name used for Eve's code-mode wrapper. */
+export declare const CODE_MODE_TOOL_NAME = "code_mode";
+/**
+ * Model-facing tool name for Eve's `Workflow` orchestration wrapper — a
+ * code-mode sandbox restricted to subagent and remote-agent calls. Reserved so
+ * authored tools cannot collide with it.
+ */
+export declare const WORKFLOW_TOOL_NAME = "Workflow";
+type CodeModeModuleNamespace = typeof CodeModeModule;
+export type { CodeModeApprovalInterrupt, CodeModeInterrupt, CodeModeInterruptExecutionContext, CodeModeInterruptPayload, CodeModeOptions, } from "#compiled/experimental-ai-sdk-code-mode/index.js";
+/**
+ * Reads the `EVE_EXPERIMENTAL_CODE_MODE` backstop. Per-agent
+ * `experimental.codeMode` takes precedence; this env var is the
+ * fallback applied to agents that do not set the flag.
+ */
+export declare function isCodeModeEnvEnabled(env?: {
+    readonly [name: string]: string | undefined;
+}): boolean;
+/**
+ * Resolves the effective code-mode setting for one agent. The authored
+ * `experimental.codeMode` flag wins; when omitted, Eve falls back to the
+ * {@link isCodeModeEnvEnabled} environment backstop.
+ */
+export declare function resolveCodeModeEnabled(experimentalCodeMode: boolean | undefined, env?: {
+    readonly [name: string]: string | undefined;
+}): boolean;
+export declare function installCodeModeModule(module: CodeModeModuleNamespace): void;
+export declare function loadCodeModeModule(): Promise<CodeModeModuleNamespace>;

package/dist/src/shared/code-mode.js

@@ -0,0 +1 @@
+const CODE_MODE_TOOL_NAME=`code_mode`,WORKFLOW_TOOL_NAME=`Workflow`,CODE_MODE_MODULE_KEY=Symbol.for(`eve.codeMode.module`),CODE_MODE_MODULE_SPECIFIER=[`#compiled`,`experimental-ai-sdk-code-mode`,`index.js`].join(`/`);let codeModeModulePromise;function isCodeModeEnvEnabled(e=process.env){return e.EVE_EXPERIMENTAL_CODE_MODE===`1`}function resolveCodeModeEnabled(e,t=process.env){return e??isCodeModeEnvEnabled(t)}function installCodeModeModule(e){globalThis[CODE_MODE_MODULE_KEY]=e}async function loadCodeModeModule(){let e=globalThis[CODE_MODE_MODULE_KEY];return e===void 0?(codeModeModulePromise??=importCodeModeModule(CODE_MODE_MODULE_SPECIFIER),await codeModeModulePromise):e}async function importCodeModeModule(e){return await import(e)}export{CODE_MODE_TOOL_NAME,WORKFLOW_TOOL_NAME,installCodeModeModule,isCodeModeEnvEnabled,loadCodeModeModule,resolveCodeModeEnabled};

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

@@ -0,0 +1,159 @@
+import type { ModelMessage } from "ai";
+import type { PublicToolInputSchema, PublicToolOutputSchema, ToolModelOutput } from "#shared/tool-definition.js";
+import type { SessionContext } from "#public/definitions/callback-context.js";
+import type { NeedsApprovalContext } from "#public/definitions/tool.js";
+import type { SessionAuth } from "#context/keys.js";
+import type { HandleMessageStreamEvent } from "#protocol/message.js";
+type ToolContext = SessionContext;
+/**
+ * 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<HandleMessageStreamEvent["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.
+ * They feed the system prompt, the most cache-sensitive position in the
+ * wire format; keeping them stable across steps within a turn maximizes
+ * cache hits.
+ */
+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 (tools and skills).
+ *
+ * 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
+     * `needsApproval` contract: return `true` to require user approval
+     * before the call executes. Only honored for step-scoped dynamic
+     * tools, whose live `execute` closures survive into the harness;
+     * session/turn-scoped tools replay from durable metadata and cannot
+     * carry a function across replay.
+     */
+    readonly needsApproval?: (ctx: NeedsApprovalContext) => boolean;
+}
+/**
+ * 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 = {
+    readonly [K in DynamicToolEventName]?: (event: unknown, ctx: DynamicResolveContext) => unknown | Promise<unknown>;
+};
+/**
+ * Marker discriminator for a `defineDynamic({ events })` export.
+ */
+export declare const DYNAMIC_SENTINEL_KIND: "eve:dynamic";
+/**
+ * Return value of `defineDynamic`: the runtime shape of a
+ * `defineDynamic({ events })` export, stamped with a sentinel kind the
+ * compiler/normalizer detects.
+ */
+export interface DynamicSentinel {
+    readonly kind: typeof DYNAMIC_SENTINEL_KIND;
+    readonly events: DynamicEvents;
+}
+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;
+export {};

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

@@ -0,0 +1 @@
+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 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,isBrandedInstructionsEntry,isBrandedSkillEntry,isBrandedToolEntry,isDynamicSentinel};

package/dist/src/shared/errors.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Shared pure error projections used by public helpers and internals.
+ */
+/**
+ * Projects an unknown throwable into a human-readable string.
+ *
+ * Plain objects are rendered as JSON rather than `"[object Object]"`.
+ */
+export declare function toErrorMessage(error: unknown): string;
+/**
+ * Coerces an unknown throwable into a proper {@link Error} instance.
+ *
+ * Returns real Errors unchanged. For plain-object shapes (common after
+ * structured-clone strips prototypes), copies useful `message`, `name`,
+ * `stack`, and `cause` fields onto a fresh Error.
+ */
+export declare function toError(raw: unknown): Error;

package/dist/src/shared/errors.js

@@ -0,0 +1 @@
+import{isObject}from"#shared/guards.js";function toErrorMessage(t){return t instanceof Error?t.message:typeof t==`string`?t:t==null?String(t):isObject(t)?typeof t.message==`string`&&t.message.length>0?t.message:safeJsonStringify(t):String(t)}function toError(t){if(t instanceof Error)return t;let n=Error(toErrorMessage(t));return isObject(t)?(typeof t.name==`string`&&t.name.length>0&&(n.name=t.name),typeof t.stack==`string`&&t.stack.length>0&&(n.stack=t.stack),`cause`in t&&t.cause!==void 0&&t.cause!==t&&(n.cause=t.cause),n):n}function safeJsonStringify(e){try{return JSON.stringify(e)??String(e)}catch{return String(e)}}export{toError,toErrorMessage};

package/dist/src/shared/guards.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Small, unavoidable type guards used across the framework.
+ *
+ * Before adding a new guard: check whether `shared/json.ts`,
+ * `shared/optional.ts`, or an existing standard-library predicate
+ * already covers the case. This module exists specifically to stop
+ * the same 3-line `typeof x === "object" && x !== null` pattern from
+ * proliferating in every file that duck-types a field off an
+ * `unknown` value.
+ */
+/**
+ * Returns `true` when `value` is a non-null object that is not an
+ * `Array`. Refines the type to `Record<string, unknown>` so callers
+ * can duck-type fields without a subsequent `as { foo?: unknown }`
+ * cast.
+ *
+ * Arrays are excluded because every use site in the codebase is
+ * reading named fields (`value.message`, `value.errorId`,
+ * `value.kind`, etc.) — none of which are meaningful on an array. If
+ * you need "any non-null object including arrays", use
+ * `typeof value === "object" && value !== null` inline.
+ */
+export declare function isObject(value: unknown): value is Record<string, unknown>;
+/**
+ * Returns `true` when `value` is a string with at least one
+ * character. The zero-length check matters: empty strings routinely
+ * fall out of optional-field projections (Slack `team_id`, HTTP
+ * headers, JSON parse results) and should not be treated as a
+ * meaningful value by display or correlation logic.
+ */
+export declare function isNonEmptyString(value: unknown): value is string;
+/**
+ * Returns `true` when `value` is a thenable — an object with a `then`
+ * function. Used to reject async instrumentation metadata projectors
+ * that accidentally return a Promise instead of a plain record.
+ */
+export declare function isThenable(value: unknown): value is PromiseLike<unknown>;
+/**
+ * Returns `true` when `value` is a plain object record — `{}`,
+ * `Object.create(null)`, or an object whose prototype is
+ * `Object.prototype`. Class instances, `Map`, `Date`, and other
+ * exotic objects are excluded even though `isObject` would accept
+ * them.
+ */
+export declare function isPlainRecord(value: unknown): value is Record<string, unknown>;

package/dist/src/shared/guards.js

@@ -0,0 +1 @@
+function isObject(e){return typeof e==`object`&&!!e&&!Array.isArray(e)}function isNonEmptyString(e){return typeof e==`string`&&e.length>0}function isThenable(e){return isObject(e)&&typeof e.then==`function`}function isPlainRecord(e){if(!isObject(e))return!1;let t=Object.getPrototypeOf(e);return t===Object.prototype||t===null}export{isNonEmptyString,isObject,isPlainRecord,isThenable};

package/dist/src/shared/json-schema.d.ts

@@ -0,0 +1,9 @@
+import type { StandardJSONSchemaV1 } from "#compiled/@standard-schema/spec/index.js";
+import { type JsonObject } from "#shared/json.js";
+type JsonSchemaDirection = "input" | "output";
+/**
+ * Normalizes one Standard Schema or JSON Schema definition into plain JSON
+ * Schema data that can cross Eve runtime and client boundaries.
+ */
+export declare function normalizeJsonSchemaDefinition(value: StandardJSONSchemaV1 | Record<string, unknown> | unknown, direction?: JsonSchemaDirection): JsonObject;
+export {};

package/dist/src/shared/json-schema.js

@@ -0,0 +1 @@
+import{parseJsonObject}from"#shared/json.js";function normalizeJsonSchemaDefinition(t,n=`input`){return isStandardSchema(t)?parseJsonObject(t[`~standard`].jsonSchema[n]({target:`draft-07`})):parseJsonObject(t)}function isStandardSchema(e){return typeof e==`object`&&!!e&&`~standard`in e}export{normalizeJsonSchemaDefinition};

package/dist/src/shared/json-schemas.d.ts

@@ -0,0 +1,10 @@
+import { z } from "#compiled/zod/index.js";
+import { type JsonObject, type JsonValue } from "#shared/json.js";
+/**
+ * Zod schema for JSON-serializable values.
+ */
+export declare const jsonValueSchema: z.ZodType<JsonValue>;
+/**
+ * Zod schema for JSON-serializable object values.
+ */
+export declare const jsonObjectSchema: z.ZodType<JsonObject>;

package/dist/src/shared/json-schemas.js

@@ -0,0 +1 @@
+import{z}from"#compiled/zod/index.js";import{parseJsonObject,parseJsonValue}from"#shared/json.js";const jsonValueSchema=z.unknown().transform((t,r)=>{try{return parseJsonValue(t)}catch(t){return r.addIssue({code:`custom`,message:formatJsonParseError(t,`Expected a JSON-serializable value.`)}),z.NEVER}}),jsonObjectSchema=z.unknown().transform((n,r)=>{try{return parseJsonObject(n)}catch(t){return r.addIssue({code:`custom`,message:formatJsonParseError(t,`Expected a JSON-serializable object.`)}),z.NEVER}});function formatJsonParseError(e,t){return e instanceof Error?e.message:t}export{jsonObjectSchema,jsonValueSchema};

package/dist/src/shared/json.d.ts

@@ -0,0 +1,34 @@
+/**
+ * JSON-serializable primitive values that can safely cross workflow and step boundaries.
+ */
+export type JsonPrimitive = boolean | number | string | null;
+/**
+ * JSON-serializable array values that can safely cross workflow and step boundaries.
+ */
+export type JsonArray = readonly JsonValue[];
+/**
+ * JSON-serializable object values that can safely cross workflow and step boundaries.
+ */
+export interface JsonObject {
+    readonly [key: string]: JsonValue;
+}
+/**
+ * JSON-serializable values that can safely cross workflow and step boundaries.
+ */
+export type JsonValue = JsonArray | JsonObject | JsonPrimitive;
+/**
+ * Returns the normalized JSON value for one runtime payload.
+ *
+ * Object properties whose value is `undefined` are treated as omitted so
+ * callers can pass normal JavaScript option bags without tripping the JSON
+ * boundary on absent optional fields. Lossy JavaScript values such as `Date`,
+ * `Map`, `Set`, `NaN`, and cyclic structures are rejected.
+ */
+export declare function parseJsonValue(value: unknown): JsonValue;
+/**
+ * Returns the normalized JSON object for one runtime payload.
+ *
+ * Top-level arrays and primitives are rejected. Object properties whose
+ * value is `undefined` are treated as omitted.
+ */
+export declare function parseJsonObject(value: unknown): JsonObject;

package/dist/src/shared/json.js

@@ -0,0 +1 @@
+const INVALID_JSON_VALUE_CANDIDATE=Symbol(`invalid-json-value-candidate`);function parseJsonValue(t){let n=normalizeJsonValueCandidate(t);if(n===INVALID_JSON_VALUE_CANDIDATE)throw TypeError(`Expected a JSON-serializable value.`);return n}function parseJsonObject(e){let t=parseJsonValue(e);if(!isJsonObjectValue(t))throw TypeError(`Expected a JSON-serializable object.`);return t}function normalizeJsonValueCandidate(t,n=new WeakSet){if(t===null||typeof t==`boolean`||typeof t==`string`)return t;if(typeof t==`number`)return Number.isFinite(t)?t:INVALID_JSON_VALUE_CANDIDATE;if(Array.isArray(t)){let r=[];for(let i of t){let t=normalizeJsonValueCandidate(i,n);if(t===INVALID_JSON_VALUE_CANDIDATE)return INVALID_JSON_VALUE_CANDIDATE;r.push(t)}return r}if(typeof t!=`object`||t===void 0||!isPlainObject(t)||n.has(t))return INVALID_JSON_VALUE_CANDIDATE;n.add(t);let r={};for(let[i,a]of Object.entries(t)){if(a===void 0)continue;let t=normalizeJsonValueCandidate(a,n);if(t===INVALID_JSON_VALUE_CANDIDATE)return INVALID_JSON_VALUE_CANDIDATE;r[i]=t}return n.delete(t),r}function isJsonObjectValue(e){return e!==null&&!Array.isArray(e)&&typeof e==`object`}function isPlainObject(e){let t=Object.getPrototypeOf(e);return t===null||t===Object.prototype}export{parseJsonObject,parseJsonValue};

package/dist/src/shared/network-address.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Whether `host` is an IP literal in a private, link-local, or otherwise
+ * reserved range that an outbound framework request must not target — an SSRF
+ * guard for caller-supplied URLs (covers RFC1918, CGNAT, link-local incl. cloud
+ * metadata at `169.254.169.254`, IPv6 ULA/link-local, and the unspecified
+ * address). Loopback is intentionally allowed (see {@link reservedRanges}).
+ *
+ * Plain hostnames return `false`: no DNS resolution is performed here, so a
+ * hostname that resolves to a private address is not caught at this layer.
+ */
+export declare function isReservedIpAddress(host: string): boolean;

package/dist/src/shared/network-address.js

@@ -0,0 +1 @@
+import{BlockList,isIP}from"node:net";const reservedRanges=new BlockList;reservedRanges.addSubnet(`0.0.0.0`,8,`ipv4`),reservedRanges.addSubnet(`10.0.0.0`,8,`ipv4`),reservedRanges.addSubnet(`100.64.0.0`,10,`ipv4`),reservedRanges.addSubnet(`169.254.0.0`,16,`ipv4`),reservedRanges.addSubnet(`172.16.0.0`,12,`ipv4`),reservedRanges.addSubnet(`192.168.0.0`,16,`ipv4`),reservedRanges.addSubnet(`198.18.0.0`,15,`ipv4`),reservedRanges.addAddress(`::`,`ipv6`),reservedRanges.addSubnet(`fc00::`,7,`ipv6`),reservedRanges.addSubnet(`fe80::`,10,`ipv6`);function normalizeAddress(e){let t=e.trim().replace(/^\[(.*)\]$/u,`$1`),n=t.indexOf(`%`),r=n===-1?t:t.slice(0,n);if(r.toLowerCase().startsWith(`::ffff:`)){let e=r.slice(7);if(isIP(e)===4)return e}return r}function isReservedIpAddress(e){let n=normalizeAddress(e),r=isIP(n);return r===0?!1:reservedRanges.check(n,r===4?`ipv4`:`ipv6`)}export{isReservedIpAddress};

package/dist/src/shared/node.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Shared type for a node, e.g. in the agent graph.
+ */
+export interface Node {
+    nodeId: string;
+}

package/dist/src/shared/node.js

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

package/dist/src/shared/optional.d.ts

@@ -0,0 +1,3 @@
+export type Optional<T, K extends keyof T> = {
+    [P in keyof (Omit<T, K> & Partial<Pick<T, K>>)]: (Omit<T, K> & Partial<Pick<T, K>>)[P];
+};

package/dist/src/shared/optional.js

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

package/dist/src/shared/run-mode.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Execution mode for one runtime-owned run.
+ *
+ * Conversation runs may park and resume on follow-up input. Task runs must
+ * finish within the current invocation and cannot wait for another message.
+ */
+export type RunMode = "conversation" | "task";