experimental-ash 0.26.0 → 0.27.0

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

@@ -1,456 +1 @@
-/**
- * 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),
-                    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, {
-                        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));
-            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, 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: "load_skill",
-                toolName: "ash:load-skill",
-            };
-        case "tool-call":
-            return {
-                kind: "tool-call",
-                name: action.toolName,
-                toolName: action.toolName,
-            };
-        case "subagent-call":
-            return {
-                kind: "subagent-call",
-                name: action.subagentName,
-                toolName: `ash:subagent:${action.subagentName}`,
-            };
-        case "remote-agent-call":
-            return {
-                kind: "subagent-call",
-                name: action.remoteAgentName,
-                toolName: `ash:subagent:${action.remoteAgentName}`,
-            };
-    }
-}
-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,
-                toolName: result.toolName,
-            };
-        case "subagent-result":
-            return {
-                kind: "subagent-call",
-                name: result.subagentName,
-                toolName: `ash:subagent:${result.subagentName}`,
-            };
-    }
-}
-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;
-}
+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`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,{ash:{inputResponse:t,kind:n.toolMetadata?.ash?.kind??`unknown`,name:n.toolMetadata?.ash?.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{ash:{inputRequest:t?.inputRequest,kind:e.kind,name:e.name}}}function mergeToolMetadata(e,t){let n=t.ash?.kind??e?.ash?.kind??`unknown`,r=t.ash?.name??e?.ash?.name??`unknown`;return{ash:{...e?.ash,...t.ash,inputRequest:t.ash?.inputRequest??e?.ash?.inputRequest,inputResponse:t.ash?.inputResponse??e?.ash?.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:`ash: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:`ash:subagent:${e.subagentName}`};case`remote-agent-call`:return{kind:`subagent-call`,name:e.remoteAgentName,toolName:`ash:subagent:${e.remoteAgentName}`}}}function normalizeActionResult(e){switch(e.kind){case`load-skill-result`:return{kind:`load-skill`,name:e.name??`load_skill`,toolName:`ash: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:`ash: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.js

@@ -1,55 +1 @@
-import { deriveResultStatus, extractCompletedMessage } from "#client/session-utils.js";
-/**
- * The response from {@link ClientSession.sendMessage}.
- *
- * Like `fetch()`, metadata (session ID, continuation token) is available
- * immediately after the POST completes. The event stream is consumed
- * separately — either collected via {@link result} or iterated with
- * `for await...of`.
- */
-export class MessageResponse {
-    /**
-     * Continuation token returned by the server for follow-up messages.
-     */
-    continuationToken;
-    /**
-     * Session ID assigned by the server.
-     */
-    sessionId;
-    #consumed = false;
-    #createStream;
-    /** @internal */
-    constructor(input) {
-        this.continuationToken = input.continuationToken;
-        this.sessionId = input.sessionId;
-        this.#createStream = input.createStream;
-    }
-    /**
-     * Consumes the full event stream and returns the aggregated
-     * {@link MessageResult}.
-     */
-    async result() {
-        const events = [];
-        for await (const event of this) {
-            events.push(event);
-        }
-        return {
-            events,
-            message: extractCompletedMessage(events),
-            sessionId: this.sessionId,
-            status: deriveResultStatus(events),
-        };
-    }
-    /**
-     * Yields stream events one at a time.
-     *
-     * Each response can only be consumed once.
-     */
-    [Symbol.asyncIterator]() {
-        if (this.#consumed) {
-            throw new Error("MessageResponse has already been consumed.");
-        }
-        this.#consumed = true;
-        return this.#createStream();
-    }
-}
+import{deriveResultStatus,extractCompletedMessage}from"#client/session-utils.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{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.js

@@ -1,62 +1,3 @@
-/**
- * Returns true when an error looks like a stream socket disconnection that
- * can be recovered via reconnection.
- */
-export function isStreamDisconnectError(error) {
-    if (error instanceof DOMException) {
-        return error.name === "AbortError";
-    }
-    if (!(error instanceof Error)) {
-        return false;
-    }
-    const errorCode = "code" in error && typeof error.code === "string" ? error.code : undefined;
-    return (error.name === "AbortError" ||
-        error.message === "terminated" ||
-        errorCode === "UND_ERR_SOCKET" ||
-        /abort|cancel|disconnect|premature close|socket|terminated/i.test(error.message));
-}
-/**
- * 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 async function* readNdjsonStream(body) {
-    const reader = body.getReader();
-    const decoder = new TextDecoder();
-    let buffer = "";
-    try {
-        while (true) {
-            const result = await reader.read();
-            if (result.done) {
-                // Flush any remaining bytes in the decoder.
-                buffer += decoder.decode();
-                break;
-            }
-            if (result.value) {
-                buffer += decoder.decode(result.value, { stream: true });
-            }
-            // Yield every complete line currently in the buffer.
-            let newlineIndex = buffer.indexOf("\n");
-            while (newlineIndex !== -1) {
-                const line = buffer.slice(0, newlineIndex).trim();
-                buffer = buffer.slice(newlineIndex + 1);
-                if (line.length > 0) {
-                    yield JSON.parse(line);
-                }
-                newlineIndex = buffer.indexOf("\n");
-            }
-        }
-        // Yield any trailing content without a final newline.
-        const trailing = buffer.trim();
-        if (trailing.length > 0) {
-            yield JSON.parse(trailing);
-        }
-    }
-    finally {
-        reader.releaseLock();
-    }
-}
+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.js

@@ -1,45 +1 @@
-import { createAshMessageStreamRoutePath } from "#protocol/routes.js";
-import { ClientError } from "#client/client-error.js";
-import { isStreamDisconnectError, readNdjsonStream } from "#client/ndjson.js";
-import { createClientUrl } from "#client/url.js";
-/**
- * Opens a durable NDJSON event stream with automatic reconnection on socket
- * disconnection. Used by {@link ClientSession.openStream}.
- */
-export async function* openStreamIterable(input) {
-    let startIndex = input.startIndex;
-    let remainingReconnectAttempts = input.maxReconnectAttempts;
-    while (true) {
-        const url = createClientUrl(input.host, createAshMessageStreamRoutePath(input.sessionId), startIndex > 0 ? { startIndex: String(startIndex) } : undefined);
-        const headers = await input.resolveHeaders();
-        const response = await fetch(url, {
-            headers,
-            signal: input.signal ?? null,
-        });
-        if (!response.ok) {
-            const body = await response.text();
-            throw new ClientError(response.status, body);
-        }
-        if (!response.body) {
-            throw new ClientError(response.status, "Response body is null.");
-        }
-        let disconnected = false;
-        try {
-            for await (const event of readNdjsonStream(response.body)) {
-                startIndex += 1;
-                yield event;
-            }
-        }
-        catch (error) {
-            if (!isStreamDisconnectError(error)) {
-                throw error;
-            }
-            disconnected = true;
-        }
-        // Only reconnect on socket disconnection, not clean EOF.
-        if (!disconnected || remainingReconnectAttempts <= 0) {
-            return;
-        }
-        remainingReconnectAttempts -= 1;
-    }
-}
+import{createAshMessageStreamRoutePath}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,createAshMessageStreamRoutePath(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/reducer.js

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