eve 0.5.4 → 0.6.0-beta.3

package/dist/src/cli/ui/output.js

@@ -0,0 +1,8 @@
+import picocolors from"#compiled/picocolors/index.js";function applyTone(e,t,n){switch(t){case`accent`:return e.accent(n);case`danger`:return e.danger(n);case`info`:return e.info(n);case`muted`:return e.muted(n);case`subagent`:return e.subagent(n);case`success`:return e.success(n);case`warning`:return e.warning(n);default:return e.plain(n)}}function renderIndentedLines(e,t){let[n=``,...r]=e;return[n,...r.map(e=>`${t}${e}`)]}function renderOrangeText(e){return e.color?`\u001B[38;5;208m${e.text}\u001B[39m`:e.text}function createCliTheme(t={}){let n=picocolors.createColors(t.color??!!process.stdout.isTTY);return{accent:e=>n.cyan(e),color:n.isColorSupported,danger:e=>n.red(e),heading:e=>n.bold(n.cyan(e)),info:e=>n.blue(e),label:e=>n.bold(e),muted:e=>n.dim(e),plain:e=>e,subagent:e=>renderOrangeText({color:n.isColorSupported,text:e}),success:e=>n.green(e),warning:e=>n.yellow(e)}}function renderCliBanner(e,t){let n=[e.heading(t.title),e.muted(`=`.repeat(t.title.length))];return t.subtitle&&n.push(e.muted(t.subtitle)),n.join(`
+`)}function renderCliSection(e,t){let n=t.rows.reduce((e,t)=>Math.max(e,t.label.length),0),r=[e.accent(t.title)];for(let i of t.rows){let[t=``,...a]=renderIndentedLines(applyTone(e,i.tone??`default`,i.value).split(`
+`),`${` `.repeat(n)}  `);r.push(`${e.label(i.label.padEnd(n))}  ${t}`),r.push(...a)}return r.join(`
+`)}function renderCliTaggedLine(e,t){let n=`[${t.tag.toUpperCase()}]`,[r=``,...i]=renderIndentedLines(applyTone(e,t.tone??`default`,t.message).split(`
+`),`${` `.repeat(n.length)} `);return[e.muted(n),r].join(` `)+(i.length>0?`\n${i.join(`
+`)}`:``)}function renderCliSpeakerLine(e,t){let n=`${t.speaker}>`,[r=``,...i]=renderIndentedLines(applyTone(e,t.tone??`default`,t.message).split(`
+`),`${` `.repeat(n.length)} `);return[e.muted(n),r].join(` `)+(i.length>0?`\n${i.join(`
+`)}`:``)}export{createCliTheme,renderCliBanner,renderCliSection,renderCliSpeakerLine,renderCliTaggedLine};

package/dist/src/client/client-error.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Error thrown when the Eve server returns a non-successful HTTP response.
+ */
+export declare class ClientError extends Error {
+    /**
+     * HTTP status code returned by the server.
+     */
+    readonly status: number;
+    /**
+     * Raw response body text.
+     */
+    readonly body: string;
+    constructor(status: number, body: string);
+}

package/dist/src/client/client-error.js

@@ -0,0 +1 @@
+import{isObject}from"#shared/guards.js";var ClientError=class extends Error{status;body;constructor(e,t){let n=t||`Server returned ${e}.`;try{let e=JSON.parse(t);isObject(e)&&typeof e.error==`string`&&(n=e.error)}catch{}super(n),this.name=`ClientError`,this.status=e,this.body=t}};export{ClientError};

package/dist/src/client/client.d.ts

@@ -0,0 +1,28 @@
+import { ClientSession } from "#client/session.js";
+import type { ClientOptions, HealthResult, SessionState } from "#client/types.js";
+/**
+ * HTTP client for talking to a deployed Eve agent.
+ *
+ * A single client is bound to one host and auth configuration. It can create
+ * many concurrent {@link ClientSession | sessions}, each tracking their own
+ * conversation state independently.
+ */
+export declare class Client {
+    #private;
+    constructor(options: ClientOptions);
+    /**
+     * Checks the health of the Eve agent server.
+     *
+     * @throws {ClientError} If the server returns a non-successful status.
+     */
+    health(): Promise<HealthResult>;
+    /**
+     * Creates a {@link ClientSession} handle for one conversation.
+     *
+     * - **No arguments**: starts a fresh conversation. The first
+     *   `session.send()` call creates the run on the server.
+     * - **{@link SessionState}**: resumes a previously serialized session.
+     * - **string**: shorthand for resuming with a continuation token alone.
+     */
+    session(state?: SessionState | string): ClientSession;
+}

package/dist/src/client/client.js

@@ -0,0 +1 @@
+import{EVE_HEALTH_ROUTE_PATH}from"#protocol/routes.js";import{ClientError}from"#client/client-error.js";import{ClientSession}from"#client/session.js";import{createInitialSessionState}from"#client/session-utils.js";import{createClientUrl}from"#client/url.js";var Client=class{#e;#t;#n;#r;constructor(e){this.#n=e.host,this.#e=e.auth,this.#t=e.headers,this.#r=e.maxReconnectAttempts??3}async health(){let n=createClientUrl(this.#n,EVE_HEALTH_ROUTE_PATH),r=await this.#i(),i=await fetch(n,{headers:r});if(!i.ok){let e=await i.text();throw new ClientError(i.status,e)}return await i.json()}session(e){let t;return t=typeof e==`string`?{continuationToken:e,streamIndex:0}:e||createInitialSessionState(),new ClientSession({host:this.#n,maxReconnectAttempts:this.#r,resolveHeaders:e=>this.#i(e)},t)}async#i(e){let t=new Headers,n=await resolveHeadersValue(this.#t);for(let[e,r]of Object.entries(n))t.set(e,r);if(e)for(let[n,r]of Object.entries(e))t.set(n,r);let r=await this.#a();return r&&t.set(`authorization`,r),t}async#a(){let e=this.#e;if(e){if(`bearer`in e){let t=(await resolveTokenValue(e.bearer)).trim();return t.length===0?void 0:`Bearer ${t}`}if(`basic`in e){let t=await resolveTokenValue(e.basic.password);return`Basic ${encodeBasicCredentials(e.basic.username,t)}`}}}};async function resolveTokenValue(e){return typeof e==`function`?e():e}async function resolveHeadersValue(e){return e===void 0?{}:typeof e==`function`?await e():e}function encodeBasicCredentials(e,t){let n=new TextEncoder().encode(`${e}:${t}`),r=Array.from(n,e=>String.fromCodePoint(e)).join(``);return btoa(r)}export{Client};

package/dist/src/client/eve-agent-store.d.ts

@@ -0,0 +1,89 @@
+import type { EveAgentReducer } from "#client/reducer.js";
+import type { ClientSession } from "#client/session.js";
+import type { HandleMessageStreamEvent } from "#protocol/message.js";
+import type { ClientAuth, HeadersValue, SendTurnPayload, SessionState } from "#client/types.js";
+/**
+ * Lifecycle state of an {@link EveAgentStore}: `ready` (idle), `submitted`
+ * (turn sent, awaiting the first event), `streaming` (events arriving), and
+ * `error` (the turn failed). A turn advances `ready` to `submitted` to
+ * `streaming` to `ready` (or `error`).
+ */
+export type EveAgentStoreStatus = "error" | "ready" | "streaming" | "submitted";
+/**
+ * Prepares one outbound turn immediately before the client sends it, e.g. to
+ * attach fresh one-turn client state such as page context via `clientContext`.
+ */
+export type PrepareSend = (input: SendTurnPayload) => SendTurnPayload | Promise<SendTurnPayload>;
+/**
+ * Immutable projected state of an {@link EveAgentStore}, read on every render.
+ *
+ * `data` is the reducer output, `events` is the raw server stream-event log for
+ * this session, `session` is the current serializable cursor, `status` is the
+ * turn lifecycle state, and `error` is the last failure (or `undefined`).
+ */
+export interface EveAgentStoreSnapshot<TData> {
+    readonly data: TData;
+    readonly error: Error | undefined;
+    readonly events: readonly HandleMessageStreamEvent[];
+    readonly session: SessionState;
+    readonly status: EveAgentStoreStatus;
+}
+/**
+ * Hooks invoked while the store processes a turn.
+ *
+ * `onEvent`, `onError`, `onFinish`, and `onSessionChange` are observe-only.
+ * `prepareSend` runs before each turn is sent and may return a modified
+ * {@link SendTurnPayload} (for example to attach one-turn client context).
+ */
+export interface EveAgentStoreCallbacks<TData> {
+    readonly onError?: (error: Error) => void;
+    readonly onEvent?: (event: HandleMessageStreamEvent) => void;
+    readonly onFinish?: (snapshot: EveAgentStoreSnapshot<TData>) => void;
+    readonly onSessionChange?: (session: SessionState) => void;
+    readonly prepareSend?: PrepareSend;
+}
+/**
+ * Configuration for constructing an {@link EveAgentStore}.
+ *
+ * Requires a {@link EveAgentReducer | reducer}, plus either connection options
+ * (`host`, `auth`, `headers`, `maxReconnectAttempts`, `initialSession`) for a
+ * store-owned session or an existing {@link ClientSession} via `session`.
+ *
+ * `optimistic` (default `true`) projects submitted user messages before the
+ * server confirms them. `host` defaults to `""`. `initialEvents` and
+ * `initialSession` seed prior state on construction. Passing `session` makes
+ * `reset()` reuse that external session rather than create a new one.
+ */
+export interface EveAgentStoreInit<TData> {
+    readonly auth?: ClientAuth;
+    readonly headers?: HeadersValue;
+    readonly host?: string;
+    readonly initialEvents?: readonly HandleMessageStreamEvent[];
+    readonly initialSession?: SessionState;
+    readonly maxReconnectAttempts?: number;
+    readonly optimistic?: boolean;
+    readonly reducer: EveAgentReducer<TData>;
+    readonly session?: ClientSession;
+}
+/**
+ * Framework-agnostic state machine for an Eve agent session.
+ *
+ * Manages the send/stream lifecycle, optimistic projection, and subscriber
+ * notification; framework integrations (React, Vue) wrap it with their own
+ * reactivity primitives.
+ *
+ * Drives one turn at a time: `send` rejects if a turn is already submitted or
+ * streaming. Read the latest projection via the `snapshot` getter, observe
+ * changes with `subscribe`, register lifecycle hooks with `setCallbacks`,
+ * abort the in-flight turn with `stop`, and discard all state with `reset`.
+ */
+export declare class EveAgentStore<TData> {
+    #private;
+    constructor(init: EveAgentStoreInit<TData>);
+    get snapshot(): EveAgentStoreSnapshot<TData>;
+    setCallbacks(callbacks: EveAgentStoreCallbacks<TData>): void;
+    subscribe(callback: () => void): () => void;
+    send<TOutput = unknown>(input: SendTurnPayload<TOutput>): Promise<void>;
+    stop(): void;
+    reset(): void;
+}

package/dist/src/client/eve-agent-store.js

@@ -0,0 +1,2 @@
+import{toError}from"#shared/errors.js";import{Client}from"#client/client.js";var EveAgentStore=class{#e;#t;#n;#r=new Set;#i;#a={};#o;#s;#c;#l=0;#u;#d;#f;#p;#m=`ready`;constructor(e){this.#e=e.session?void 0:()=>new Client({auth:e.auth,headers:e.headers,host:e.host??``,maxReconnectAttempts:e.maxReconnectAttempts}).session(e.initialSession),this.#c=[...e.initialEvents??[]],this.#d=[...this.#c],this.#t=e.optimistic??!0,this.#n=e.reducer,this.#f=e.session??this.#h(),this.#o=this.#E(this.#d),this.#p=this.#D()}get snapshot(){return this.#p}setCallbacks(e){this.#a=e}subscribe(e){return this.#r.add(e),()=>{this.#r.delete(e)}}async send(t){if(this.#m===`streaming`||this.#m===`submitted`)throw Error(`Eve session is already processing a turn.`);let n=this.#g(),r=new AbortController;this.#i=r,this.#s=void 0,this.#m=`submitted`,this.#O();try{let e=await this.#a.prepareSend?.(t)??t;if(!this.#v(n))return;this.#y(e),this.#b(e),this.#O();let i=await this.#f.send({...e,signal:createAbortSignal(e.signal,r.signal)}),a=!1;for await(let e of i){if(!this.#v(n))return;a||(a=!0,this.#m=`streaming`),this.#c=[...this.#c,e],this.#x(e),this.#a.onEvent?.(e),this.#S(e),this.#O()}if(!this.#v(n))return;this.#m=this.#s===void 0?`ready`:`error`}catch(t){if(!this.#v(n))return;isAbortError(t)?(this.#m=`ready`,this.#C(toError(t))):(this.#s=toError(t),this.#m=`error`,this.#C(this.#s),this.#a.onError?.(this.#s))}finally{this.#v(n)&&(this.#i=void 0,this.#a.onSessionChange?.(this.#f.state),this.#O(),this.#a.onFinish?.(this.#p))}}stop(){this.#i?.abort()}reset(){this.#_(),this.stop(),this.#i=void 0,this.#f=this.#e?.()??this.#f,this.#c=[],this.#u=void 0,this.#d=[],this.#o=this.#n.initial(),this.#s=void 0,this.#m=`ready`,this.#a.onSessionChange?.(this.#f.state),this.#O()}#h(){if(!this.#e)throw Error(`Cannot create an owned Eve session from an external session.`);return this.#e()}#g(){return this.#l+=1,this.#l}#_(){this.#l+=1}#v(e){return this.#l===e}#y(e){if(!this.#t||e.message===void 0)return;let t=createSubmissionId(),n={createdAt:Date.now(),id:t,message:summarizeUserContent(e.message)};this.#u=n,this.#w({data:{createdAt:n.createdAt,message:n.message,submissionId:n.id},type:`client.message.submitted`})}#b(e){e.inputResponses===void 0||e.inputResponses.length===0||this.#w({data:{createdAt:Date.now(),responses:e.inputResponses},type:`client.input.responded`})}#x(e){if(e.type===`message.received`&&this.#u!==void 0){let t=this.#u.id;this.#u=void 0,this.#T(e=>e.type===`client.message.submitted`&&e.data.submissionId===t,e);return}this.#w(e)}#S(e){let t=toTerminalStreamFailureError(e);t!==void 0&&(this.#m=`error`,this.#C(t),this.#s===void 0&&(this.#s=t,this.#a.onError?.(t)))}#C(e){let t=this.#u;t!==void 0&&(this.#u=void 0,this.#T(e=>e.type===`client.message.submitted`&&e.data.submissionId===t.id,{data:{createdAt:t.createdAt,error:{message:e.message},message:t.message,submissionId:t.id},type:`client.message.failed`}))}#w(e){this.#d=[...this.#d,e],this.#o=this.#n.reduce(this.#o,e)}#T(e,t){let n=!1;this.#d=this.#d.map(r=>!n&&e(r)?(n=!0,t):r),n||(this.#d=[...this.#d,t]),this.#o=this.#E(this.#d)}#E(e){let t=this.#n.initial();for(let n of e)t=this.#n.reduce(t,n);return t}#D(){return{data:this.#o,error:this.#s,events:this.#c,session:this.#f.state,status:this.#m}}#O(){this.#p=this.#D();for(let e of this.#r)e()}};let submissionSequence=0;function createSubmissionId(){let e=globalThis.crypto?.randomUUID;return e===void 0?(submissionSequence+=1,`submission_${submissionSequence.toString()}`):e.call(globalThis.crypto)}function createAbortSignal(e,t){return e?AbortSignal.any([e,t]):t}function summarizeUserContent(e){if(typeof e==`string`)return e;let t=[];for(let n of e){if(n.type===`text`){t.push(n.text);continue}n.type===`file`&&t.push(n.filename?`[file: ${n.filename}]`:`[file]`)}return t.join(`
+`)}function isAbortError(e){return e instanceof Error&&e.name===`AbortError`}function toTerminalStreamFailureError(e){if(e.type!==`session.failed`)return;let t=Error(e.data.message);return t.name=e.data.code,t}export{EveAgentStore};

package/dist/src/client/index.d.ts

@@ -0,0 +1,15 @@
+export { EveAgentStore } from "#client/eve-agent-store.js";
+export { Client } from "#client/client.js";
+export { ClientError } from "#client/client-error.js";
+export { defaultMessageReducer } from "#client/message-reducer.js";
+export { MessageResponse } from "#client/message-response.js";
+export { ClientSession } from "#client/session.js";
+export type { EveAgentStoreCallbacks, EveAgentStoreInit, EveAgentStoreSnapshot, EveAgentStoreStatus, PrepareSend, } from "#client/eve-agent-store.js";
+export type { ClientAuth, ClientOptions, HeadersValue, HealthResult, MessageResult, SendTurnInput, SendTurnPayload, SessionState, StreamOptions, TokenValue, } from "#client/types.js";
+export type { EveAgentReducer, EveAgentReducerEvent, ClientInputRespondedEvent, ClientMessageFailedEvent, ClientMessageSubmittedEvent, } from "#client/reducer.js";
+export type { EveMessageData, EveDynamicToolPart, EveMessageInputRequest, EveMessage, EveMessageMetadata, EveMessagePart, EveMessageToolMetadata, } from "#client/message-reducer.js";
+export type { ActionResultStreamEvent, ActionsRequestedStreamEvent, AssistantStepFinishReason, CompactionCompletedStreamEvent, CompactionRequestedStreamEvent, AuthorizationCompletedStreamEvent, ConnectionAuthorizationOutcome, AuthorizationRequiredStreamEvent, HandleMessageStreamEvent, InputRequestedStreamEvent, MessageAppendedStreamEvent, MessageCompletedStreamEvent, MessageReceivedStreamEvent, ReasoningAppendedStreamEvent, ReasoningCompletedStreamEvent, ResultCompletedStreamEvent, SessionCompletedStreamEvent, SessionFailedStreamEvent, SessionStartedStreamEvent, SessionWaitingStreamEvent, StepCompletedStreamEvent, StepFailedStreamEvent, StepStartedStreamEvent, SubagentCalledStreamEvent, SubagentChildEventStreamEvent, SubagentCompletedStreamEvent, SubagentStartedStreamEvent, TurnCompletedStreamEvent, TurnFailedStreamEvent, TurnStartedStreamEvent, } from "#protocol/message.js";
+export { isCurrentTurnBoundaryEvent } from "#protocol/message.js";
+export type { InputOption, InputRequest, InputResponse } from "#runtime/input/types.js";
+export { inputOptionSchema, inputRequestSchema, inputResponseSchema, isInputRequest, isInputResponse, } from "#runtime/input/types.js";
+export { resolveTextToResponse, resolveTextToResponses } from "#channel/resolve-text.js";

package/dist/src/client/index.js

@@ -0,0 +1 @@
+import{resolveTextToResponse,resolveTextToResponses}from"#channel/resolve-text.js";import{isCurrentTurnBoundaryEvent}from"#protocol/message.js";import{ClientError}from"#client/client-error.js";import{ClientSession}from"#client/session.js";import{Client}from"#client/client.js";import{EveAgentStore}from"#client/eve-agent-store.js";import{defaultMessageReducer}from"#client/message-reducer.js";import{MessageResponse}from"#client/message-response.js";import{inputOptionSchema,inputRequestSchema,inputResponseSchema,isInputRequest,isInputResponse}from"#runtime/input/types.js";export{Client,ClientError,ClientSession,EveAgentStore,MessageResponse,defaultMessageReducer,inputOptionSchema,inputRequestSchema,inputResponseSchema,isCurrentTurnBoundaryEvent,isInputRequest,isInputResponse,resolveTextToResponse,resolveTextToResponses};

package/dist/src/client/message-reducer-types.d.ts

@@ -0,0 +1,174 @@
+import type { InputResponse } from "#runtime/input/types.js";
+/**
+ * UIMessage-compatible Eve message projection for chat and agent UIs.
+ */
+export interface EveMessageData {
+    readonly messages: readonly EveMessage[];
+}
+/**
+ * Eve-owned message shape that follows the AI SDK UIMessage convention.
+ */
+export interface EveMessage {
+    readonly id: string;
+    readonly metadata?: EveMessageMetadata;
+    readonly parts: readonly EveMessagePart[];
+    readonly role: "assistant" | "user";
+}
+/**
+ * Per-message metadata attached by the default projection.
+ *
+ * `status` tracks this message's own lifecycle (distinct from session-level
+ * status): user messages use `"submitted"` or `"failed"`, assistant messages
+ * use `"streaming"` or `"complete"`. `optimistic` is set only while a
+ * client-projected user message awaits server confirmation. `turnId` links the
+ * message to its runtime turn; `result` holds the harness structured result
+ * once the turn finalizes.
+ */
+export interface EveMessageMetadata {
+    readonly optimistic?: true;
+    readonly result?: unknown;
+    readonly status?: "complete" | "failed" | "streaming" | "submitted";
+    readonly turnId?: string;
+}
+/**
+ * One renderable part of an {@link EveMessage}, discriminated by `type`.
+ *
+ * `text` and `reasoning` store streamed content with a `state` of `"streaming"`
+ * or `"done"`; `step-start` marks the boundary of an agent step; and
+ * `dynamic-tool` ({@link EveDynamicToolPart}) holds the tool call and its
+ * lifecycle state. `stepIndex` ties a part to the agent step that produced it.
+ */
+export type EveMessagePart = {
+    readonly providerMetadata?: Record<string, unknown>;
+    readonly state?: "done" | "streaming";
+    readonly stepIndex?: number;
+    readonly text: string;
+    readonly type: "text";
+} | {
+    readonly providerMetadata?: Record<string, unknown>;
+    readonly state?: "done" | "streaming";
+    readonly stepIndex?: number;
+    readonly text: string;
+    readonly type: "reasoning";
+} | {
+    readonly type: "step-start";
+} | EveDynamicToolPart;
+/**
+ * A tool-call part of an assistant message, following the AI SDK `dynamic-tool`
+ * convention. `state` advances through the lifecycle: `"input-streaming"` and
+ * `"input-available"` (arguments arriving or complete), `"approval-requested"` and
+ * `"approval-responded"` (HITL approval pending or answered), then a terminal
+ * `"output-available"`, `"output-error"` (`errorText` set), or `"output-denied"`
+ * (`approval.approved` is `false`). Which of `input`, `output`, `errorText`, and
+ * `approval` are present depends on `state`, so narrow on `state` before reading them.
+ * `toolName` and `toolMetadata.eve` ({@link EveMessageToolMetadata}) record call identity.
+ */
+export type EveDynamicToolPart = {
+    readonly stepIndex?: number;
+    readonly toolCallId: string;
+    readonly toolMetadata?: EveMessageToolMetadata;
+    readonly toolName: string;
+    readonly type: "dynamic-tool";
+} & ({
+    readonly approval?: never;
+    readonly errorText?: never;
+    readonly input: unknown | undefined;
+    readonly output?: never;
+    readonly state: "input-streaming";
+} | {
+    readonly approval?: never;
+    readonly errorText?: never;
+    readonly input: unknown;
+    readonly output?: never;
+    readonly state: "input-available";
+} | {
+    readonly approval: {
+        readonly id: string;
+        readonly approved?: never;
+        readonly reason?: never;
+        readonly isAutomatic?: boolean;
+    };
+    readonly errorText?: never;
+    readonly input: unknown;
+    readonly output?: never;
+    readonly state: "approval-requested";
+} | {
+    readonly approval: {
+        readonly id: string;
+        readonly approved?: boolean;
+        readonly reason?: string;
+        readonly isAutomatic?: boolean;
+    };
+    readonly errorText?: never;
+    readonly input: unknown;
+    readonly output?: never;
+    readonly state: "approval-responded";
+} | {
+    readonly approval?: {
+        readonly id: string;
+        readonly approved: true;
+        readonly reason?: string;
+        readonly isAutomatic?: boolean;
+    };
+    readonly errorText?: never;
+    readonly input: unknown;
+    readonly output: unknown;
+    readonly state: "output-available";
+} | {
+    readonly approval?: {
+        readonly id: string;
+        readonly approved: true;
+        readonly reason?: string;
+        readonly isAutomatic?: boolean;
+    };
+    readonly errorText: string;
+    readonly input: unknown | undefined;
+    readonly output?: never;
+    readonly state: "output-error";
+} | {
+    readonly approval: {
+        readonly id: string;
+        readonly approved: false;
+        readonly reason?: string;
+        readonly isAutomatic?: boolean;
+    };
+    readonly errorText?: never;
+    readonly input: unknown;
+    readonly output?: never;
+    readonly state: "output-denied";
+});
+/**
+ * Eve-specific metadata attached to an {@link EveDynamicToolPart}. `eve.kind`
+ * classifies the action (`"tool-call"`, `"subagent-call"`, `"load-skill"`, or
+ * `"unknown"`), `eve.name` is the resolved action name, and `eve.inputRequest`
+ * and `eve.inputResponse` store the HITL prompt and submitted response when the
+ * call required approval.
+ */
+export interface EveMessageToolMetadata {
+    readonly eve?: {
+        readonly inputRequest?: EveMessageInputRequest;
+        readonly inputResponse?: InputResponse;
+        readonly kind: "load-skill" | "subagent-call" | "tool-call" | "unknown";
+        readonly name: string;
+    };
+}
+/**
+ * UI-facing projection of a pending HITL input request on a tool part. `prompt`
+ * is the question, `display` selects the control (`"confirmation"`, `"select"`,
+ * or `"text"`), `options` lists selectable choices (each with a `label` and
+ * optional `style`), and `allowFreeform` permits a typed response alongside the
+ * options. `requestId` is the stable identifier the client returns in the
+ * responding {@link InputResponse}.
+ */
+export interface EveMessageInputRequest {
+    readonly allowFreeform?: boolean;
+    readonly display?: "confirmation" | "select" | "text";
+    readonly options?: readonly {
+        readonly description?: string;
+        readonly id: string;
+        readonly label: string;
+        readonly style?: "danger" | "default" | "primary";
+    }[];
+    readonly prompt: string;
+    readonly requestId: string;
+}

package/dist/src/client/message-reducer-types.js

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

package/dist/src/client/message-reducer.d.ts

@@ -0,0 +1,14 @@
+import type { EveAgentReducer } from "#client/reducer.js";
+import type { EveMessageData } from "#client/message-reducer-types.js";
+export type { EveMessageData, EveDynamicToolPart, EveMessageInputRequest, EveMessage, EveMessageMetadata, EveMessagePart, EveMessageToolMetadata, } from "#client/message-reducer-types.js";
+/**
+ * Creates a UIMessage-compatible Eve reducer for chat and agent UIs.
+ *
+ * The returned projection keeps Eve-owned types while following the AI SDK
+ * `messages[].parts[]` rendering convention used by AI Elements. It projects
+ * text, reasoning, tool calls, tool results, tool approvals, and submitted
+ * HITL responses. Connection authorization stream events remain available to
+ * custom reducers through the reducer event contract until Eve has a dedicated
+ * message-part shape for authorization UI.
+ */
+export declare function defaultMessageReducer(): EveAgentReducer<EveMessageData>;

package/dist/src/client/message-reducer.js

@@ -0,0 +1 @@
+function defaultMessageReducer(){return{initial(){return{messages:[]}},reduce(e,t){return reduceMessageData(e,t)}}}function reduceMessageData(e,t){switch(t.type){case`client.message.submitted`:return upsertMessage(e,{id:optimisticUserMessageId(t.data.submissionId),metadata:{optimistic:!0,status:`submitted`},parts:[{type:`text`,text:t.data.message}],role:`user`});case`client.message.failed`:return upsertMessage(e,{id:optimisticUserMessageId(t.data.submissionId),metadata:{optimistic:!0,status:`failed`},parts:[{type:`text`,text:t.data.message}],role:`user`});case`client.input.responded`:{let n=e;for(let e of t.data.responses)n=respondToInputRequest(n,e);return n}case`message.received`:return upsertMessage(e,{id:`${t.data.turnId}:user`,metadata:{status:`complete`,turnId:t.data.turnId},parts:[{type:`text`,text:t.data.message,state:`done`}],role:`user`});case`step.started`:return updateAssistantMessage(e,t.data.turnId,e=>ensureStepStartPart(e,t.data.stepIndex));case`reasoning.appended`:return updateAssistantMessage(e,t.data.turnId,e=>upsertPart(ensureStepStartPart(e,t.data.stepIndex),{state:`streaming`,stepIndex:t.data.stepIndex,text:t.data.reasoningSoFar,type:`reasoning`}));case`reasoning.completed`:return updateAssistantMessage(e,t.data.turnId,e=>upsertPart(ensureStepStartPart(e,t.data.stepIndex),{state:`done`,stepIndex:t.data.stepIndex,text:t.data.reasoning,type:`reasoning`}));case`actions.requested`:{let n=e;for(let e of t.data.actions){let r=normalizeActionRequest(e);n=updateAssistantMessage(n,t.data.turnId,n=>upsertPart(ensureStepStartPart(n,t.data.stepIndex),{input:`input`in e?e.input:void 0,state:`input-available`,stepIndex:t.data.stepIndex,toolCallId:e.callId,toolMetadata:createToolMetadata(r),toolName:r.toolName,type:`dynamic-tool`}))}return n}case`input.requested`:{let n=e;for(let e of t.data.requests){let r=normalizeActionRequest(e.action);n=updateAssistantMessage(n,t.data.turnId,n=>upsertPart(ensureStepStartPart(n,t.data.stepIndex),{approval:{id:e.requestId},input:e.action.input,state:`approval-requested`,stepIndex:t.data.stepIndex,toolCallId:e.action.callId,toolMetadata:createToolMetadata(r,{inputRequest:toMessageInputRequest(e)}),toolName:r.toolName,type:`dynamic-tool`}))}return n}case`action.result`:{let n=normalizeActionResult(t.data.result),r=findToolPart(e,t.data.result.callId),i=t.data.error?.code===`TOOL_EXECUTION_DENIED`,a=t.data.status===`failed`&&!i,o=r?.approval?.id??t.data.result.callId,s=mergeToolMetadata(r?.toolMetadata,createToolMetadata(n)),c={input:r?.input,stepIndex:t.data.stepIndex,toolCallId:t.data.result.callId,toolMetadata:s,toolName:r?.toolName??n.toolName,type:`dynamic-tool`},l;return l=i?{...c,approval:{approved:!1,id:o,reason:t.data.error?.message},state:`output-denied`}:a?{...c,approval:approvedApproval(r),errorText:t.data.error?.message??stringifyUnknown(t.data.result.output),state:`output-error`}:{...c,approval:approvedApproval(r),output:t.data.result.output,state:`output-available`},r===void 0?updateAssistantMessage(e,t.data.turnId,e=>upsertPart(ensureStepStartPart(e,t.data.stepIndex),l)):updateToolPart(e,t.data.result.callId,l)}case`message.appended`:return updateAssistantMessage(e,t.data.turnId,e=>upsertPart(ensureStepStartPart(e,t.data.stepIndex),{state:`streaming`,stepIndex:t.data.stepIndex,text:t.data.messageSoFar,type:`text`}));case`message.completed`:return updateAssistantMessage(e,t.data.turnId,e=>t.data.message===null?completeExistingTextPart(e):upsertPart(ensureStepStartPart(e,t.data.stepIndex),{state:`done`,stepIndex:t.data.stepIndex,text:t.data.message,type:`text`}));case`result.completed`:return updateAssistantMetadata(e,t.data.turnId,{result:t.data.result});case`turn.completed`:return updateAssistantMetadata(e,t.data.turnId,{status:`complete`});case`turn.failed`:case`session.failed`:return e;default:return e}}function respondToInputRequest(e,t){let n=findToolPartByApprovalId(e,t.requestId);if(!n)return e;let r={id:t.requestId};return t.text!==void 0&&(r.reason=t.text),updateToolPart(e,n.toolCallId,{approval:r,input:n.input,state:`approval-responded`,stepIndex:n.stepIndex,toolCallId:n.toolCallId,toolMetadata:mergeToolMetadata(n.toolMetadata,{eve:{inputResponse:t,kind:n.toolMetadata?.eve?.kind??`unknown`,name:n.toolMetadata?.eve?.name??n.toolName}}),toolName:n.toolName,type:`dynamic-tool`})}function updateAssistantMessage(e,t,n){return upsertMessage(e,n(e.messages.find(e=>e.role===`assistant`&&e.metadata?.turnId===t)??createAssistantMessage(t)))}function updateAssistantMetadata(e,t,n){return updateAssistantMessage(e,t,e=>({...e,metadata:{...e.metadata,...n}}))}function createAssistantMessage(e){return{id:`${e}:assistant`,metadata:{status:`streaming`,turnId:e},parts:[],role:`assistant`}}function ensureStepStartPart(e,t){let n=e.parts.filter(e=>e.type===`step-start`).length;if(n>t)return e;let r=t-n+1;return{...e,parts:[...e.parts,...Array.from({length:r},()=>({type:`step-start`}))]}}function upsertPart(e,t){let n=e.parts.findIndex(e=>partKey(e)===partKey(t)),r=n===-1?[...e.parts,t]:[...e.parts.slice(0,n),t,...e.parts.slice(n+1)];return{...e,metadata:{...e.metadata,status:t.type===`text`&&t.state===`done`?`complete`:`streaming`},parts:r}}function completeExistingTextPart(e){let t=findLastIndex(e.parts,e=>e.type===`text`);if(t===-1)return e;let n=e.parts[t];return n?.type===`text`?{...e,metadata:{...e.metadata,status:`complete`},parts:[...e.parts.slice(0,t),{...n,state:`done`},...e.parts.slice(t+1)]}:e}function updateToolPart(e,t,n){let r=e.messages.find(e=>e.role===`assistant`&&e.parts.some(e=>e.type===`dynamic-tool`&&e.toolCallId===t));return r?upsertMessage(e,upsertPart(r,n)):e}function findToolPart(e,t){for(let n of e.messages)for(let e of n.parts)if(e.type===`dynamic-tool`&&e.toolCallId===t)return e}function findToolPartByApprovalId(e,t){for(let n of e.messages)for(let e of n.parts)if(e.type===`dynamic-tool`&&e.approval?.id===t)return e}function partKey(e){switch(e.type){case`text`:return`text:${e.stepIndex??0}`;case`reasoning`:return`reasoning:${e.stepIndex??0}`;case`step-start`:return`step-start`;case`dynamic-tool`:return`dynamic-tool:${e.toolCallId}`}}function upsertMessage(e,t){let n=e.messages.findIndex(e=>e.id===t.id);return n===-1?{messages:[...e.messages,t]}:{messages:[...e.messages.slice(0,n),t,...e.messages.slice(n+1)]}}function toMessageInputRequest(e){return{allowFreeform:e.allowFreeform,display:e.display,options:e.options,prompt:e.prompt,requestId:e.requestId}}function createToolMetadata(e,t){return{eve:{inputRequest:t?.inputRequest,kind:e.kind,name:e.name}}}function mergeToolMetadata(e,t){let n=t.eve?.kind??e?.eve?.kind??`unknown`,r=t.eve?.name??e?.eve?.name??`unknown`;return{eve:{...e?.eve,...t.eve,inputRequest:t.eve?.inputRequest??e?.eve?.inputRequest,inputResponse:t.eve?.inputResponse??e?.eve?.inputResponse,kind:n,name:r}}}function approvedApproval(e){if(e?.approval?.id)return{approved:!0,id:e.approval.id,isAutomatic:e.approval.isAutomatic,reason:e.approval.reason}}function normalizeActionRequest(e){switch(e.kind){case`load-skill`:return{kind:`load-skill`,name:`load_skill`,toolName:`eve:load-skill`};case`tool-call`:return{kind:`tool-call`,name:e.toolName,toolName:e.toolName};case`subagent-call`:return{kind:`subagent-call`,name:e.subagentName,toolName:`eve:subagent:${e.subagentName}`};case`remote-agent-call`:return{kind:`subagent-call`,name:e.remoteAgentName,toolName:`eve:subagent:${e.remoteAgentName}`}}}function normalizeActionResult(e){switch(e.kind){case`load-skill-result`:return{kind:`load-skill`,name:e.name??`load_skill`,toolName:`eve:load-skill`};case`tool-result`:return{kind:`tool-call`,name:e.toolName,toolName:e.toolName};case`subagent-result`:return{kind:`subagent-call`,name:e.subagentName,toolName:`eve:subagent:${e.subagentName}`}}}function optimisticUserMessageId(e){return`optimistic:${e}:user`}function stringifyUnknown(e){if(typeof e==`string`)return e;try{return JSON.stringify(e)}catch{return`Action failed.`}}function findLastIndex(e,t){for(let n=e.length-1;n>=0;--n)if(t(e[n]))return n;return-1}export{defaultMessageReducer};

package/dist/src/client/message-response.d.ts

@@ -0,0 +1,42 @@
+import type { HandleMessageStreamEvent } from "#protocol/message.js";
+import type { MessageResult } from "#client/types.js";
+/**
+ * Internal configuration passed to construct a {@link MessageResponse}.
+ */
+interface MessageResponseInput {
+    readonly continuationToken?: string;
+    readonly createStream: () => AsyncGenerator<HandleMessageStreamEvent>;
+    readonly sessionId: string;
+}
+/**
+ * The response from {@link ClientSession.send}.
+ *
+ * Like `fetch()`, the response exposes metadata (session ID, continuation
+ * token) as soon as the POST completes. Collect the event stream via
+ * {@link result} or iterate it with `for await...of`.
+ */
+export declare class MessageResponse<TOutput = unknown> implements AsyncIterable<HandleMessageStreamEvent> {
+    #private;
+    /**
+     * Continuation token returned by the server for follow-up messages.
+     */
+    readonly continuationToken: string | undefined;
+    /**
+     * Session ID assigned by the server.
+     */
+    readonly sessionId: string;
+    /** @internal */
+    constructor(input: MessageResponseInput);
+    /**
+     * Consumes the full event stream and returns the aggregated
+     * {@link MessageResult}.
+     */
+    result(): Promise<MessageResult<TOutput>>;
+    /**
+     * Yields stream events one at a time.
+     *
+     * Each response can only be consumed once.
+     */
+    [Symbol.asyncIterator](): AsyncIterator<HandleMessageStreamEvent>;
+}
+export {};

package/dist/src/client/message-response.js

@@ -0,0 +1 @@
+import{deriveResultStatus,extractCompletedMessage}from"#client/session-utils.js";import{extractCompletedResult}from"#client/output-schema.js";var MessageResponse=class{continuationToken;sessionId;#e=!1;#t;constructor(e){this.continuationToken=e.continuationToken,this.sessionId=e.sessionId,this.#t=e.createStream}async result(){let t=[];for await(let e of this)t.push(e);return{data:extractCompletedResult(t),events:t,message:extractCompletedMessage(t),sessionId:this.sessionId,status:deriveResultStatus(t)}}[Symbol.asyncIterator](){if(this.#e)throw Error(`MessageResponse has already been consumed.`);return this.#e=!0,this.#t()}};export{MessageResponse};

package/dist/src/client/ndjson.d.ts

@@ -0,0 +1,16 @@
+import type { HandleMessageStreamEvent } from "#protocol/message.js";
+/**
+ * Returns true when an error looks like a stream socket disconnection that
+ * can be recovered via reconnection.
+ */
+export declare function isStreamDisconnectError(error: unknown): boolean;
+/**
+ * Reads newline-delimited JSON events from a `ReadableStream<Uint8Array>`.
+ *
+ * Yields one parsed {@link HandleMessageStreamEvent} per complete NDJSON line.
+ * Handles partial lines across chunks via an internal buffer.
+ *
+ * All read errors — including socket disconnections — propagate to the caller.
+ * Use {@link isStreamDisconnectError} to classify them.
+ */
+export declare function readNdjsonStream(body: ReadableStream<Uint8Array>): AsyncGenerator<HandleMessageStreamEvent>;

package/dist/src/client/ndjson.js

@@ -0,0 +1,3 @@
+function isStreamDisconnectError(e){if(e instanceof DOMException)return e.name===`AbortError`;if(!(e instanceof Error))return!1;let t=`code`in e&&typeof e.code==`string`?e.code:void 0;return e.name===`AbortError`||e.message===`terminated`||t===`UND_ERR_SOCKET`||/abort|cancel|disconnect|premature close|socket|terminated/i.test(e.message)}async function*readNdjsonStream(e){let t=e.getReader(),n=new TextDecoder,r=``;try{for(;;){let e=await t.read();if(e.done){r+=n.decode();break}e.value&&(r+=n.decode(e.value,{stream:!0}));let i=r.indexOf(`
+`);for(;i!==-1;){let e=r.slice(0,i).trim();r=r.slice(i+1),e.length>0&&(yield JSON.parse(e)),i=r.indexOf(`
+`)}}let e=r.trim();e.length>0&&(yield JSON.parse(e))}finally{t.releaseLock()}}export{isStreamDisconnectError,readNdjsonStream};

package/dist/src/client/open-stream.d.ts

@@ -0,0 +1,18 @@
+import type { HandleMessageStreamEvent } from "#protocol/message.js";
+/**
+ * Internal configuration for opening a durable event stream.
+ */
+interface OpenStreamInput {
+    readonly host: string;
+    readonly maxReconnectAttempts: number;
+    readonly resolveHeaders: () => Promise<Headers>;
+    readonly sessionId: string;
+    readonly signal?: AbortSignal;
+    readonly startIndex: number;
+}
+/**
+ * Opens a durable NDJSON event stream with automatic reconnection on socket
+ * disconnection. Used by {@link ClientSession.stream}.
+ */
+export declare function openStreamIterable(input: OpenStreamInput): AsyncGenerator<HandleMessageStreamEvent>;
+export {};

package/dist/src/client/open-stream.js

@@ -0,0 +1 @@
+import{createEveMessageStreamRoutePath}from"#protocol/routes.js";import{ClientError}from"#client/client-error.js";import{createClientUrl}from"#client/url.js";import{isStreamDisconnectError,readNdjsonStream}from"#client/ndjson.js";async function*openStreamIterable(t){let n=t.startIndex,r=t.maxReconnectAttempts;for(;;){let i=createClientUrl(t.host,createEveMessageStreamRoutePath(t.sessionId),n>0?{startIndex:String(n)}:void 0),a=await t.resolveHeaders(),o=await fetch(i,{headers:a,signal:t.signal??null});if(!o.ok){let e=await o.text();throw new ClientError(o.status,e)}if(!o.body)throw new ClientError(o.status,`Response body is null.`);let s=!1;try{for await(let e of readNdjsonStream(o.body))n+=1,yield e}catch(e){if(!isStreamDisconnectError(e))throw e;s=!0}if(!s||r<=0)return;--r}}export{openStreamIterable};

package/dist/src/client/output-schema.d.ts

@@ -0,0 +1,12 @@
+import type { StandardJSONSchemaV1 } from "#compiled/@standard-schema/spec/index.js";
+import type { HandleMessageStreamEvent } from "#protocol/message.js";
+import type { JsonObject } from "#shared/json.js";
+/**
+ * Normalizes a client-supplied output schema into the wire-safe JSON Schema
+ * representation accepted by Eve message routes.
+ */
+export declare function normalizeOutputSchemaForRequest<TOutput>(schema: StandardJSONSchemaV1<unknown, TOutput> | JsonObject | undefined): JsonObject | undefined;
+/**
+ * Extracts the most recent finalized structured result from a turn event list.
+ */
+export declare function extractCompletedResult<TOutput>(events: readonly HandleMessageStreamEvent[]): TOutput | undefined;

package/dist/src/client/output-schema.js

@@ -0,0 +1 @@
+import{normalizeJsonSchemaDefinition}from"#shared/json-schema.js";function normalizeOutputSchemaForRequest(t){return t===void 0?void 0:normalizeJsonSchemaDefinition(t,`output`)}function extractCompletedResult(e){let t;for(let n of e)isResultCompletedEvent(n)&&(t=n.data.result);return t}function isResultCompletedEvent(e){return e.type===`result.completed`}export{extractCompletedResult,normalizeOutputSchemaForRequest};

package/dist/src/client/reducer.d.ts

@@ -0,0 +1,63 @@
+import type { HandleMessageStreamEvent } from "#protocol/message.js";
+import type { InputResponse } from "#runtime/input/types.js";
+/**
+ * Client-side reducer event emitted before Eve confirms a submitted user
+ * message with a `message.received` stream event.
+ */
+export interface ClientMessageSubmittedEvent {
+    readonly data: {
+        readonly createdAt: number;
+        readonly message: string;
+        readonly submissionId: string;
+    };
+    readonly type: "client.message.submitted";
+}
+/**
+ * Client-side reducer event emitted when a submitted user message fails before
+ * Eve confirms it with a `message.received` stream event.
+ */
+export interface ClientMessageFailedEvent {
+    readonly data: {
+        readonly createdAt: number;
+        readonly error: {
+            readonly message: string;
+        };
+        readonly message: string;
+        readonly submissionId: string;
+    };
+    readonly type: "client.message.failed";
+}
+/**
+ * Client-side reducer event emitted when the client submits HITL responses for
+ * pending input requests.
+ */
+export interface ClientInputRespondedEvent {
+    readonly data: {
+        readonly createdAt: number;
+        readonly responses: readonly InputResponse[];
+    };
+    readonly type: "client.input.responded";
+}
+/**
+ * Event consumed by Eve agent reducers.
+ *
+ * Server events are authoritative Eve stream events. They include text,
+ * reasoning, tool/action requests and results, HITL input requests, connection
+ * authorization events, subagent events, and session lifecycle events. Client
+ * events are projection-only events created by client state machines for local
+ * UI state such as optimistic user messages and submitted HITL responses.
+ */
+export type EveAgentReducerEvent = ClientInputRespondedEvent | ClientMessageFailedEvent | ClientMessageSubmittedEvent | HandleMessageStreamEvent;
+/**
+ * Projects Eve stream events into accumulated consumer data.
+ */
+export interface EveAgentReducer<TData> {
+    /**
+     * Creates the initial projection state.
+     */
+    initial(): TData;
+    /**
+     * Applies one server or client projection event to the current projection.
+     */
+    reduce(data: TData, event: EveAgentReducerEvent): TData;
+}

package/dist/src/client/reducer.js

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

package/dist/src/client/session-utils.d.ts

@@ -0,0 +1,29 @@
+import type { HandleMessageStreamEvent } from "#protocol/message.js";
+import type { SessionState } from "#client/types.js";
+/**
+ * Returns a fresh session state with no active run.
+ */
+export declare function createInitialSessionState(): SessionState;
+/**
+ * Advances the session cursor after one streamed turn completes.
+ *
+ * When the boundary event is `session.waiting`, the session is preserved for
+ * the next message. For `session.completed` and `session.failed`, the session
+ * resets so the next call starts a new conversation.
+ */
+export declare function advanceSession(input: {
+    readonly continuationToken?: string;
+    readonly events: readonly HandleMessageStreamEvent[];
+    readonly sessionId: string;
+    readonly session: SessionState;
+}): SessionState;
+/**
+ * Extracts the final completed assistant message text from a turn's events.
+ *
+ * Only considers terminal messages (finish reason is not `"tool-calls"`).
+ */
+export declare function extractCompletedMessage(events: readonly HandleMessageStreamEvent[]): string | undefined;
+/**
+ * Derives the result status from a turn's boundary event.
+ */
+export declare function deriveResultStatus(events: readonly HandleMessageStreamEvent[]): "completed" | "failed" | "waiting";

package/dist/src/client/session-utils.js

@@ -0,0 +1 @@
+import{isCurrentTurnBoundaryEvent}from"#protocol/message.js";function createInitialSessionState(){return{streamIndex:0}}function advanceSession(e){let t=findBoundaryEvent(e.events),n=e.session.streamIndex+e.events.length;return t?.type===`session.waiting`?{continuationToken:e.continuationToken??e.session.continuationToken,sessionId:e.sessionId,streamIndex:n}:createInitialSessionState()}function extractCompletedMessage(e){let t;for(let n of e)isFinalMessageCompleted(n)&&(t=n.data.message??void 0);return t}function deriveResultStatus(e){let t=findBoundaryEvent(e);return t?.type===`session.waiting`?`waiting`:t?.type===`session.failed`?`failed`:`completed`}function findBoundaryEvent(t){for(let n=t.length-1;n>=0;n--){let r=t[n];if(r!==void 0&&isCurrentTurnBoundaryEvent(r))return r}}function isFinalMessageCompleted(e){return e.type===`message.completed`&&e.data.finishReason!==`tool-calls`}export{advanceSession,createInitialSessionState,deriveResultStatus,extractCompletedMessage};