experimental-ash 0.18.0 → 0.18.1

package/dist/src/cli/run.js

@@ -1,3 +1,3 @@
-import{t as e}from"../chunks/package-DmsQgn4v.js";import{createCliTheme as t,renderCliTaggedLine as n}from"./ui/output.js";import{i as r,n as i,r as a,t as o}from"../chunks/url-BVRhVE2O.js";import{resolve as s}from"node:path";async function c(){return(await import(`../chunks/host-CIU0NATc.js`).then(e=>e.t)).buildHost}async function l(){return(await import(`./commands/info.js`)).printApplicationInfo}async function u(){return(await import(`./dev/repl.js`)).runDevelopmentRepl}async function d(){return(await import(`../evals/cli/eval.js`)).runEvalCommand}async function f(){return(await import(`../chunks/host-CIU0NATc.js`).then(e=>e.t)).startHost}function p(e=process.cwd()){return s(e)}function m(e){return`Ash (v${e})`}function h(e){return e.name()===`info`||e.name()===`dev`}async function g(e){await new Promise((t,n)=>{let r=!1,i=()=>{process.off(`SIGINT`,a),process.off(`SIGTERM`,a)},a=()=>{r||(r=!0,i(),e.close().then(t,n))};process.once(`SIGINT`,a),process.once(`SIGTERM`,a)})}function _(e){if(!/^-?\d+$/.test(e))throw new r(`Expected a numeric port, received "${e}".`);let t=Number(e);if(!Number.isInteger(t))throw new r(`Expected a numeric port, received "${e}".`);if(t<0||t>65535)throw new r(`Expected a port between 0 and 65535, received "${e}".`);return t}function v(){return!!(process.stdin.isTTY&&process.stdout.isTTY)}function y(e){let t=e[1];return e[0]!==`dev`||e.length!==2||t===void 0||t.startsWith(`-`)?[...e]:[`dev`,`--url`,t]}function b(e){if(e.url){if(e.host!==void 0)throw new r(`The --host option cannot be used with --url.`);if(e.port!==void 0)throw new r(`The --port option cannot be used with --url.`);if(e.repl===!1)throw new r(`The --no-repl option cannot be used with --url.`);return e.url}}function x(r,a){let s=p(),y=e().version,x=new i,S=t();return x.name(`ash`).description(`Build and run an Ash application.`).version(y).showHelpAfterError().exitOverride().hook(`preAction`,(e,t)=>{h(t)&&r.log(m(y))}).configureOutput({writeErr:e=>{r.error(e.trimEnd())},writeOut:e=>{r.log(e.trimEnd())}}),x.command(`build`).description(`Build the current Ash application.`).action(async()=>{let{loadDevelopmentEnvironmentFiles:e}=await import(`./dev/environment.js`);e(s);let t=await(a.buildHost??await c())(s);r.log(n(S,{message:`built output at ${t}`,tag:`build`,tone:`success`}))}),x.command(`dev`).description(`Start the Ash development server or connect the REPL to an existing URL.`).option(`--host <host>`,`Host interface to bind`).option(`--no-repl`,`Start the server without the interactive REPL`).option(`--port <port>`,`Port to listen on (defaults to $PORT, then 3000)`,_).option(`--schedules`,`Run scheduled tasks during development (off by default)`).option(`-u, --url <url>`,`Connect the REPL to an existing server URL`,o).addHelpText(`after`,`
+import{t as e}from"../chunks/package-DmsQgn4v.js";import{createCliTheme as t,renderCliTaggedLine as n}from"./ui/output.js";import{i as r,n as i,r as a,t as o}from"../chunks/url-BVRhVE2O.js";import{resolve as s}from"node:path";async function c(){return(await import(`../chunks/host-Dor4C8jo.js`).then(e=>e.t)).buildHost}async function l(){return(await import(`./commands/info.js`)).printApplicationInfo}async function u(){return(await import(`./dev/repl.js`)).runDevelopmentRepl}async function d(){return(await import(`../evals/cli/eval.js`)).runEvalCommand}async function f(){return(await import(`../chunks/host-Dor4C8jo.js`).then(e=>e.t)).startHost}function p(e=process.cwd()){return s(e)}function m(e){return`Ash (v${e})`}function h(e){return e.name()===`info`||e.name()===`dev`}async function g(e){await new Promise((t,n)=>{let r=!1,i=()=>{process.off(`SIGINT`,a),process.off(`SIGTERM`,a)},a=()=>{r||(r=!0,i(),e.close().then(t,n))};process.once(`SIGINT`,a),process.once(`SIGTERM`,a)})}function _(e){if(!/^-?\d+$/.test(e))throw new r(`Expected a numeric port, received "${e}".`);let t=Number(e);if(!Number.isInteger(t))throw new r(`Expected a numeric port, received "${e}".`);if(t<0||t>65535)throw new r(`Expected a port between 0 and 65535, received "${e}".`);return t}function v(){return!!(process.stdin.isTTY&&process.stdout.isTTY)}function y(e){let t=e[1];return e[0]!==`dev`||e.length!==2||t===void 0||t.startsWith(`-`)?[...e]:[`dev`,`--url`,t]}function b(e){if(e.url){if(e.host!==void 0)throw new r(`The --host option cannot be used with --url.`);if(e.port!==void 0)throw new r(`The --port option cannot be used with --url.`);if(e.repl===!1)throw new r(`The --no-repl option cannot be used with --url.`);return e.url}}function x(r,a){let s=p(),y=e().version,x=new i,S=t();return x.name(`ash`).description(`Build and run an Ash application.`).version(y).showHelpAfterError().exitOverride().hook(`preAction`,(e,t)=>{h(t)&&r.log(m(y))}).configureOutput({writeErr:e=>{r.error(e.trimEnd())},writeOut:e=>{r.log(e.trimEnd())}}),x.command(`build`).description(`Build the current Ash application.`).action(async()=>{let{loadDevelopmentEnvironmentFiles:e}=await import(`./dev/environment.js`);e(s);let t=await(a.buildHost??await c())(s);r.log(n(S,{message:`built output at ${t}`,tag:`build`,tone:`success`}))}),x.command(`dev`).description(`Start the Ash development server or connect the REPL to an existing URL.`).option(`--host <host>`,`Host interface to bind`).option(`--no-repl`,`Start the server without the interactive REPL`).option(`--port <port>`,`Port to listen on (defaults to $PORT, then 3000)`,_).option(`--schedules`,`Run scheduled tasks during development (off by default)`).option(`-u, --url <url>`,`Connect the REPL to an existing server URL`,o).addHelpText(`after`,`
 You can also pass a bare URL as the only argument, for example: ash dev https://example.com
 `).action(async e=>{let t=b(e),{loadDevelopmentEnvironmentFiles:i}=await import(`./dev/environment.js`);if(i(s),t){if(r.log(n(S,{message:`REPL connecting to ${t}`,tag:`dev`,tone:`info`})),!v()){r.log(n(S,{message:`Interactive REPL disabled because the current terminal is not a TTY.`,tag:`dev`,tone:`warning`}));return}r.log(``),await(a.runDevelopmentRepl??await u())({serverUrl:t});return}let o=await(a.startHost??await f())(s,{host:e.host,port:e.port,schedules:e.schedules===!0}),c=!1,l=async()=>{c||(c=!0,await o.close())};try{if(r.log(n(S,{message:`server listening at ${o.url}`,tag:`dev`,tone:`success`})),e.repl===!1)return await g({close:l});if(!v())return r.log(n(S,{message:`Interactive REPL disabled because the current terminal is not a TTY.`,tag:`dev`,tone:`warning`})),await g({close:l});r.log(``),await(a.runDevelopmentRepl??await u())({serverUrl:o.url})}finally{await l()}}),x.command(`info`).description(`Print resolved application information.`).action(async()=>{await(a.printApplicationInfo??await l())(r,s)}),x.command(`eval`).description(`Run eval suites against an Ash agent.`).option(`--suite <id...>`,`Suite IDs to run (repeatable)`).option(`--all`,`Run all discovered suites`).option(`--url <url>`,`Remote agent URL (skip local host startup)`).option(`--timeout <ms>`,`Per-case timeout in milliseconds`).option(`--max-concurrency <n>`,`Max concurrent case executions per suite`).option(`--json`,`Output results as JSON`).option(`--list-suites`,`List discovered suites and exit`).option(`--skip-report`,`Skip suite-defined reporters (e.g. Braintrust)`).action(async e=>{await(a.runEvalCommand??await d())(e,r)}),x}async function S(e=process.argv.slice(2),t=console,n={}){let r=x(t,n),i=e.length===0?[`info`]:y(e);try{await r.parseAsync(i,{from:`user`})}catch(e){if(e instanceof a){if(e.exitCode===0)return;throw Error(e.message)}throw e}}export{S as runCli};

package/dist/src/client/client.js

@@ -2,6 +2,7 @@ import { ASH_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";
 /**
  * HTTP client for talking to a deployed Ash agent.
  *
@@ -26,7 +27,7 @@ export class Client {
      * @throws {ClientError} If the server returns a non-successful status.
      */
     async health() {
-        const url = new URL(ASH_HEALTH_ROUTE_PATH, this.#host);
+        const url = createClientUrl(this.#host, ASH_HEALTH_ROUTE_PATH);
         const headers = await this.#resolveHeaders();
         const response = await fetch(url, { headers });
         if (!response.ok) {

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

@@ -1,8 +1,11 @@
 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 { ClientAuth, ClientOptions, HeadersValue, HealthResult, MessageResult, OpenStreamOptions, SendMessageOptions, SendTurnInput, SessionState, TokenValue, } from "#client/types.js";
+export type { AshAgentReducer, AshAgentReducerEvent, ClientInputRespondedEvent, ClientMessageFailedEvent, ClientMessageSubmittedEvent, } from "#client/reducer.js";
+export type { AshMessageData, AshDynamicToolPart, AshMessageInputRequest, AshMessage, AshMessageMetadata, AshMessagePart, AshMessageToolMetadata, } from "#client/message-reducer.js";
 export type { ActionResultStreamEvent, ActionsRequestedStreamEvent, AssistantStepFinishReason, CompactionCompletedStreamEvent, CompactionRequestedStreamEvent, HandleMessageStreamEvent, InputRequestedStreamEvent, MessageAppendedStreamEvent, MessageCompletedStreamEvent, MessageReceivedStreamEvent, ReasoningAppendedStreamEvent, ReasoningCompletedStreamEvent, 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";

package/dist/src/client/index.js

@@ -3,6 +3,7 @@
 // ---------------------------------------------------------------------------
 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 { isCurrentTurnBoundaryEvent } from "#protocol/message.js";

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

@@ -0,0 +1,130 @@
+import type { InputResponse } from "#runtime/input/types.js";
+/**
+ * UIMessage-compatible Ash message projection for chat and agent UIs.
+ */
+export interface AshMessageData {
+    readonly messages: readonly AshMessage[];
+}
+/**
+ * Ash-owned message shape that follows the AI SDK UIMessage convention.
+ */
+export interface AshMessage {
+    readonly id: string;
+    readonly metadata?: AshMessageMetadata;
+    readonly parts: readonly AshMessagePart[];
+    readonly role: "assistant" | "user";
+}
+export interface AshMessageMetadata {
+    readonly optimistic?: true;
+    readonly status?: "complete" | "failed" | "streaming" | "submitted";
+    readonly turnId?: string;
+}
+export type AshMessagePart = {
+    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";
+} | AshDynamicToolPart;
+export type AshDynamicToolPart = {
+    readonly stepIndex?: number;
+    readonly toolCallId: string;
+    readonly toolMetadata?: AshMessageToolMetadata;
+    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";
+});
+export interface AshMessageToolMetadata {
+    readonly ash?: {
+        readonly inputRequest?: AshMessageInputRequest;
+        readonly inputResponse?: InputResponse;
+        readonly kind: "load-skill" | "subagent-call" | "tool-call" | "unknown";
+        readonly name: string;
+    };
+}
+export interface AshMessageInputRequest {
+    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 { AshAgentReducer } from "#client/reducer.js";
+import type { AshMessageData } from "#client/message-reducer-types.js";
+export type { AshMessageData, AshDynamicToolPart, AshMessageInputRequest, AshMessage, AshMessageMetadata, AshMessagePart, AshMessageToolMetadata, } from "#client/message-reducer-types.js";
+/**
+ * Creates a UIMessage-compatible Ash reducer for chat and agent UIs.
+ *
+ * The returned projection keeps Ash-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 Ash has a dedicated
+ * message-part shape for authorization UI.
+ */
+export declare function defaultMessageReducer(): AshAgentReducer<AshMessageData>;

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

@@ -0,0 +1,462 @@
+/**
+ * Creates a UIMessage-compatible Ash reducer for chat and agent UIs.
+ *
+ * The returned projection keeps Ash-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 Ash has a dedicated
+ * message-part shape for authorization UI.
+ */
+export function defaultMessageReducer() {
+    return {
+        initial() {
+            return { messages: [] };
+        },
+        reduce(data, event) {
+            return reduceMessageData(data, event);
+        },
+    };
+}
+function reduceMessageData(data, event) {
+    switch (event.type) {
+        case "client.message.submitted":
+            return upsertMessage(data, {
+                id: optimisticUserMessageId(event.data.submissionId),
+                metadata: {
+                    optimistic: true,
+                    status: "submitted",
+                },
+                parts: [{ type: "text", text: event.data.message }],
+                role: "user",
+            });
+        case "client.message.failed":
+            return upsertMessage(data, {
+                id: optimisticUserMessageId(event.data.submissionId),
+                metadata: {
+                    optimistic: true,
+                    status: "failed",
+                },
+                parts: [{ type: "text", text: event.data.message }],
+                role: "user",
+            });
+        case "client.input.responded": {
+            let next = data;
+            for (const response of event.data.responses) {
+                next = respondToInputRequest(next, response);
+            }
+            return next;
+        }
+        case "message.received":
+            return upsertMessage(data, {
+                id: `${event.data.turnId}:user`,
+                metadata: {
+                    status: "complete",
+                    turnId: event.data.turnId,
+                },
+                parts: [{ type: "text", text: event.data.message, state: "done" }],
+                role: "user",
+            });
+        case "step.started":
+            return updateAssistantMessage(data, event.data.turnId, (message) => ensureStepStartPart(message, event.data.stepIndex));
+        case "reasoning.appended":
+            return updateAssistantMessage(data, event.data.turnId, (message) => upsertPart(ensureStepStartPart(message, event.data.stepIndex), {
+                state: "streaming",
+                stepIndex: event.data.stepIndex,
+                text: event.data.reasoningSoFar,
+                type: "reasoning",
+            }));
+        case "reasoning.completed":
+            return updateAssistantMessage(data, event.data.turnId, (message) => upsertPart(ensureStepStartPart(message, event.data.stepIndex), {
+                state: "done",
+                stepIndex: event.data.stepIndex,
+                text: event.data.reasoning,
+                type: "reasoning",
+            }));
+        case "actions.requested": {
+            let next = data;
+            for (const action of event.data.actions) {
+                const descriptor = normalizeActionRequest(action);
+                next = updateAssistantMessage(next, event.data.turnId, (message) => upsertPart(ensureStepStartPart(message, event.data.stepIndex), {
+                    input: "input" in action ? action.input : undefined,
+                    state: "input-available",
+                    stepIndex: event.data.stepIndex,
+                    toolCallId: action.callId,
+                    toolMetadata: createToolMetadata(descriptor, event.data.stepIndex),
+                    toolName: descriptor.toolName,
+                    type: "dynamic-tool",
+                }));
+            }
+            return next;
+        }
+        case "input.requested": {
+            let next = data;
+            for (const request of event.data.requests) {
+                const descriptor = normalizeActionRequest(request.action);
+                next = updateAssistantMessage(next, event.data.turnId, (message) => upsertPart(ensureStepStartPart(message, event.data.stepIndex), {
+                    approval: {
+                        id: request.requestId,
+                    },
+                    input: request.action.input,
+                    state: "approval-requested",
+                    stepIndex: event.data.stepIndex,
+                    toolCallId: request.action.callId,
+                    toolMetadata: createToolMetadata(descriptor, event.data.stepIndex, {
+                        inputRequest: toMessageInputRequest(request),
+                    }),
+                    toolName: descriptor.toolName,
+                    type: "dynamic-tool",
+                }));
+            }
+            return next;
+        }
+        case "action.result": {
+            const descriptor = normalizeActionResult(event.data.result);
+            const existing = findToolPart(data, event.data.result.callId);
+            const denied = event.data.error?.code === "TOOL_EXECUTION_DENIED";
+            const failed = event.data.status === "failed" && !denied;
+            const approvalId = existing?.approval?.id ?? event.data.result.callId;
+            const toolMetadata = mergeToolMetadata(existing?.toolMetadata, createToolMetadata(descriptor, event.data.stepIndex));
+            const resultPartBase = {
+                input: existing?.input,
+                stepIndex: event.data.stepIndex,
+                toolCallId: event.data.result.callId,
+                toolMetadata,
+                toolName: existing?.toolName ?? descriptor.toolName,
+                type: "dynamic-tool",
+            };
+            let nextPart;
+            if (denied) {
+                nextPart = {
+                    ...resultPartBase,
+                    approval: {
+                        approved: false,
+                        id: approvalId,
+                        reason: event.data.error?.message,
+                    },
+                    state: "output-denied",
+                };
+            }
+            else if (failed) {
+                nextPart = {
+                    ...resultPartBase,
+                    approval: approvedApproval(existing),
+                    errorText: event.data.error?.message ?? stringifyUnknown(event.data.result.output),
+                    state: "output-error",
+                };
+            }
+            else {
+                nextPart = {
+                    ...resultPartBase,
+                    approval: approvedApproval(existing),
+                    output: event.data.result.output,
+                    state: "output-available",
+                };
+            }
+            if (existing !== undefined) {
+                // Approved tool results can arrive on a later runtime turn; keep
+                // the UI lifecycle anchored to the original tool call.
+                return updateToolPart(data, event.data.result.callId, nextPart);
+            }
+            return updateAssistantMessage(data, event.data.turnId, (message) => upsertPart(ensureStepStartPart(message, event.data.stepIndex), nextPart));
+        }
+        case "message.appended":
+            return updateAssistantMessage(data, event.data.turnId, (message) => upsertPart(ensureStepStartPart(message, event.data.stepIndex), {
+                state: "streaming",
+                stepIndex: event.data.stepIndex,
+                text: event.data.messageSoFar,
+                type: "text",
+            }));
+        case "message.completed":
+            return updateAssistantMessage(data, event.data.turnId, (message) => {
+                if (event.data.message === null) {
+                    return completeExistingTextPart(message);
+                }
+                return upsertPart(ensureStepStartPart(message, event.data.stepIndex), {
+                    state: "done",
+                    stepIndex: event.data.stepIndex,
+                    text: event.data.message,
+                    type: "text",
+                });
+            });
+        case "turn.completed":
+            return updateAssistantMetadata(data, event.data.turnId, { status: "complete" });
+        case "turn.failed":
+        case "session.failed":
+            return data;
+        default:
+            return data;
+    }
+}
+function respondToInputRequest(data, response) {
+    const existing = findToolPartByApprovalId(data, response.requestId);
+    if (!existing) {
+        return data;
+    }
+    const approval = {
+        id: response.requestId,
+    };
+    if (response.text !== undefined) {
+        approval.reason = response.text;
+    }
+    return updateToolPart(data, existing.toolCallId, {
+        approval,
+        input: existing.input,
+        state: "approval-responded",
+        stepIndex: existing.stepIndex,
+        toolCallId: existing.toolCallId,
+        toolMetadata: mergeToolMetadata(existing.toolMetadata, {
+            ash: {
+                inputResponse: response,
+                kind: existing.toolMetadata?.ash?.kind ?? "unknown",
+                name: existing.toolMetadata?.ash?.name ?? existing.toolName,
+            },
+        }),
+        toolName: existing.toolName,
+        type: "dynamic-tool",
+    });
+}
+function updateAssistantMessage(data, turnId, update) {
+    const existing = data.messages.find((message) => message.role === "assistant" && message.metadata?.turnId === turnId);
+    const message = existing ?? createAssistantMessage(turnId);
+    return upsertMessage(data, update(message));
+}
+function updateAssistantMetadata(data, turnId, metadata) {
+    return updateAssistantMessage(data, turnId, (message) => ({
+        ...message,
+        metadata: {
+            ...message.metadata,
+            ...metadata,
+        },
+    }));
+}
+function createAssistantMessage(turnId) {
+    return {
+        id: `${turnId}:assistant`,
+        metadata: {
+            status: "streaming",
+            turnId,
+        },
+        parts: [],
+        role: "assistant",
+    };
+}
+function ensureStepStartPart(message, stepIndex) {
+    const stepStartCount = message.parts.filter((part) => part.type === "step-start").length;
+    if (stepStartCount > stepIndex) {
+        return message;
+    }
+    const missingCount = stepIndex - stepStartCount + 1;
+    return {
+        ...message,
+        parts: [
+            ...message.parts,
+            ...Array.from({ length: missingCount }, () => ({ type: "step-start" })),
+        ],
+    };
+}
+function upsertPart(message, next) {
+    const index = message.parts.findIndex((part) => partKey(part) === partKey(next));
+    const parts = index === -1
+        ? [...message.parts, next]
+        : [...message.parts.slice(0, index), next, ...message.parts.slice(index + 1)];
+    return {
+        ...message,
+        metadata: {
+            ...message.metadata,
+            status: next.type === "text" && next.state === "done" ? "complete" : "streaming",
+        },
+        parts,
+    };
+}
+function completeExistingTextPart(message) {
+    const index = findLastIndex(message.parts, (part) => part.type === "text");
+    if (index === -1) {
+        return message;
+    }
+    const existing = message.parts[index];
+    if (existing?.type !== "text") {
+        return message;
+    }
+    return {
+        ...message,
+        metadata: {
+            ...message.metadata,
+            status: "complete",
+        },
+        parts: [
+            ...message.parts.slice(0, index),
+            { ...existing, state: "done" },
+            ...message.parts.slice(index + 1),
+        ],
+    };
+}
+function updateToolPart(data, toolCallId, next) {
+    const message = data.messages.find((candidate) => candidate.role === "assistant" &&
+        candidate.parts.some((part) => part.type === "dynamic-tool" && part.toolCallId === toolCallId));
+    if (!message) {
+        return data;
+    }
+    return upsertMessage(data, upsertPart(message, next));
+}
+function findToolPart(data, toolCallId) {
+    for (const message of data.messages) {
+        for (const part of message.parts) {
+            if (part.type === "dynamic-tool" && part.toolCallId === toolCallId) {
+                return part;
+            }
+        }
+    }
+    return undefined;
+}
+function findToolPartByApprovalId(data, approvalId) {
+    for (const message of data.messages) {
+        for (const part of message.parts) {
+            if (part.type === "dynamic-tool" && part.approval?.id === approvalId) {
+                return part;
+            }
+        }
+    }
+    return undefined;
+}
+function partKey(part) {
+    switch (part.type) {
+        case "text":
+            return `text:${part.stepIndex ?? 0}`;
+        case "reasoning":
+            return `reasoning:${part.stepIndex ?? 0}`;
+        case "step-start":
+            return "step-start";
+        case "dynamic-tool":
+            return `dynamic-tool:${part.toolCallId}`;
+    }
+}
+function upsertMessage(data, next) {
+    const index = data.messages.findIndex((message) => message.id === next.id);
+    if (index === -1) {
+        return { messages: [...data.messages, next] };
+    }
+    return {
+        messages: [...data.messages.slice(0, index), next, ...data.messages.slice(index + 1)],
+    };
+}
+function toMessageInputRequest(request) {
+    return {
+        allowFreeform: request.allowFreeform,
+        display: request.display,
+        options: request.options,
+        prompt: request.prompt,
+        requestId: request.requestId,
+    };
+}
+function createToolMetadata(descriptor, _stepIndex, extra) {
+    return {
+        ash: {
+            inputRequest: extra?.inputRequest,
+            kind: descriptor.kind,
+            name: descriptor.name,
+        },
+    };
+}
+function mergeToolMetadata(current, next) {
+    const kind = next.ash?.kind ?? current?.ash?.kind ?? "unknown";
+    const name = next.ash?.name ?? current?.ash?.name ?? "unknown";
+    return {
+        ash: {
+            ...current?.ash,
+            ...next.ash,
+            inputRequest: next.ash?.inputRequest ?? current?.ash?.inputRequest,
+            inputResponse: next.ash?.inputResponse ?? current?.ash?.inputResponse,
+            kind,
+            name,
+        },
+    };
+}
+function approvedApproval(part) {
+    if (!part?.approval?.id) {
+        return undefined;
+    }
+    return {
+        approved: true,
+        id: part.approval.id,
+        isAutomatic: part.approval.isAutomatic,
+        reason: part.approval.reason,
+    };
+}
+function normalizeActionRequest(action) {
+    switch (action.kind) {
+        case "load-skill":
+            return {
+                kind: "load-skill",
+                name: action.name ?? "load_skill",
+                toolName: "ash:load-skill",
+            };
+        case "tool-call":
+            return {
+                kind: "tool-call",
+                name: action.toolName ?? "tool",
+                toolName: action.toolName ?? "tool",
+            };
+        case "subagent-call":
+            return {
+                kind: "subagent-call",
+                name: action.subagentName ?? action.name ?? "subagent",
+                toolName: `ash:subagent:${action.subagentName ?? action.name ?? "subagent"}`,
+            };
+        default:
+            return {
+                kind: "unknown",
+                name: action.toolName ?? action.subagentName ?? action.name ?? action.kind,
+                toolName: action.toolName ?? action.subagentName ?? action.name ?? action.kind,
+            };
+    }
+}
+function normalizeActionResult(result) {
+    switch (result.kind) {
+        case "load-skill-result":
+            return {
+                kind: "load-skill",
+                name: result.name ?? "load_skill",
+                toolName: "ash:load-skill",
+            };
+        case "tool-result":
+            return {
+                kind: "tool-call",
+                name: result.toolName ?? "tool",
+                toolName: result.toolName ?? "tool",
+            };
+        case "subagent-result":
+            return {
+                kind: "subagent-call",
+                name: result.subagentName ?? "subagent",
+                toolName: `ash:subagent:${result.subagentName ?? "subagent"}`,
+            };
+        default:
+            return {
+                kind: "unknown",
+                name: result.toolName ?? result.subagentName ?? result.name ?? result.kind,
+                toolName: result.toolName ?? result.subagentName ?? result.name ?? result.kind,
+            };
+    }
+}
+function optimisticUserMessageId(submissionId) {
+    return `optimistic:${submissionId}:user`;
+}
+function stringifyUnknown(value) {
+    if (typeof value === "string")
+        return value;
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return "Action failed.";
+    }
+}
+function findLastIndex(items, predicate) {
+    for (let index = items.length - 1; index >= 0; index -= 1) {
+        if (predicate(items[index])) {
+            return index;
+        }
+    }
+    return -1;
+}