narraeon 0.1.0

package/dist/node/runtime/model/ModelHostStream.js

@@ -0,0 +1,367 @@
+import { ModelHostFailureError } from "./ModelHost.js";
+import { providerStreamEvents } from "./ProviderStream.js";
+export async function aggregateChatModelStream(body, onDelta) {
+    let content = "";
+    let reasoningContent = "";
+    let usage;
+    let completed = false;
+    let sawPayload = false;
+    const calls = new Map();
+    for await (const event of modelHostEvents(body)) {
+        if (event.data === "[DONE]") {
+            completed = true;
+            break;
+        }
+        const payload = streamRecord(event.data);
+        sawPayload = true;
+        if (isRecord(payload.error))
+            throw new ModelHostFailureError("Provider SSE returned an explicit error");
+        if (!Array.isArray(payload.choices))
+            throw new Error("Chat SSE choices are invalid");
+        if (payload.choices.length > 1)
+            throw new Error("Chat SSE returned multiple choices");
+        if (payload.usage !== undefined)
+            usage = payload.usage;
+        for (const choiceValue of payload.choices) {
+            if (!isRecord(choiceValue) || !isRecord(choiceValue.delta))
+                throw new Error("Chat SSE choice delta is invalid");
+            if (choiceValue.index !== undefined && choiceValue.index !== 0)
+                throw new Error("Chat SSE choice index is invalid");
+            if (choiceValue.finish_reason !== undefined &&
+                choiceValue.finish_reason !== null &&
+                typeof choiceValue.finish_reason !== "string")
+                throw new Error("Chat SSE finish_reason is invalid");
+            const delta = choiceValue.delta;
+            if (delta.role !== undefined && delta.role !== "assistant")
+                throw new Error("Chat SSE assistant role is invalid");
+            if (delta.content !== undefined &&
+                delta.content !== null &&
+                typeof delta.content !== "string")
+                throw new Error("Chat SSE content delta is invalid");
+            if (typeof delta.content === "string" && delta.content !== "") {
+                content += delta.content;
+                onDelta?.({ kind: "text", text: delta.content });
+            }
+            if (delta.reasoning_content !== undefined &&
+                delta.reasoning_content !== null &&
+                typeof delta.reasoning_content !== "string")
+                throw new Error("Chat SSE reasoning delta is invalid");
+            if (typeof delta.reasoning_content === "string" &&
+                delta.reasoning_content !== "") {
+                reasoningContent += delta.reasoning_content;
+                onDelta?.({ kind: "reasoning", text: delta.reasoning_content });
+            }
+            if (delta.tool_calls === undefined)
+                continue;
+            if (!Array.isArray(delta.tool_calls))
+                throw new Error("Chat SSE tool_calls delta is invalid");
+            for (const [position, fragmentValue] of delta.tool_calls.entries()) {
+                if (!isRecord(fragmentValue))
+                    throw new Error("Chat SSE tool-call fragment is invalid");
+                const index = typeof fragmentValue.index === "number"
+                    ? fragmentValue.index
+                    : position;
+                if (!Number.isSafeInteger(index) || index < 0)
+                    throw new Error("Chat SSE tool-call index is invalid");
+                const current = calls.get(index) ?? {
+                    id: "",
+                    name: "",
+                    type: "function",
+                    arguments: "",
+                };
+                if (fragmentValue.id !== undefined) {
+                    if (typeof fragmentValue.id !== "string")
+                        throw new Error("Chat SSE tool-call id is invalid");
+                    current.id += fragmentValue.id;
+                }
+                if (fragmentValue.type !== undefined) {
+                    if (fragmentValue.type !== "function")
+                        throw new Error("Chat SSE tool-call type is invalid");
+                    current.type = fragmentValue.type;
+                }
+                if (fragmentValue.function !== undefined) {
+                    if (!isRecord(fragmentValue.function))
+                        throw new Error("Chat SSE tool-call function is invalid");
+                    const function_ = fragmentValue.function;
+                    if (function_.name !== undefined) {
+                        if (typeof function_.name !== "string")
+                            throw new Error("Chat SSE tool-call name is invalid");
+                        current.name += function_.name;
+                    }
+                    if (function_.arguments !== undefined) {
+                        if (typeof function_.arguments !== "string")
+                            throw new Error("Chat SSE tool-call arguments are invalid");
+                        current.arguments += function_.arguments;
+                        if (function_.arguments !== "")
+                            onDelta?.({ kind: "tool", text: function_.arguments });
+                    }
+                }
+                calls.set(index, current);
+            }
+        }
+    }
+    if (!completed || !sawPayload)
+        throw new Error("Chat SSE ended before a complete response");
+    const toolCalls = [...calls.entries()]
+        .sort(([left], [right]) => left - right)
+        .map(([, call]) => {
+        if (call.id === "" || call.name === "" || call.type !== "function")
+            throw new Error("Chat SSE tool call is incomplete");
+        return { id: call.id, name: call.name, arguments: call.arguments };
+    });
+    const assistantMessage = {
+        role: "assistant",
+        content: content === "" ? null : content,
+        ...(reasoningContent === "" ? {} : { reasoning_content: reasoningContent }),
+        ...(toolCalls.length === 0
+            ? {}
+            : {
+                tool_calls: toolCalls.map((call) => ({
+                    id: call.id,
+                    type: "function",
+                    function: { name: call.name, arguments: call.arguments },
+                })),
+            }),
+    };
+    return {
+        content,
+        reasoningContent,
+        assistantMessage,
+        toolCalls,
+        usage,
+    };
+}
+export async function aggregateAnthropicModelStream(body, onDelta) {
+    const blocks = new Map();
+    const usage = {};
+    let started = false;
+    let stopped = false;
+    let responseId;
+    let model;
+    let stopReason;
+    stream: for await (const event of modelHostEvents(body)) {
+        const payload = streamRecord(event.data);
+        if (typeof payload.type !== "string")
+            throw new Error("Anthropic SSE type is invalid");
+        if (event.event !== null && event.event !== payload.type)
+            throw new Error("Anthropic SSE event and payload type do not match");
+        switch (payload.type) {
+            case "message_start": {
+                if (started || !isRecord(payload.message))
+                    throw new Error("Anthropic SSE message_start is invalid");
+                if (payload.message.role !== "assistant" ||
+                    !Array.isArray(payload.message.content))
+                    throw new Error("Anthropic SSE initial message is invalid");
+                started = true;
+                responseId = stringOrUndefined(payload.message.id);
+                model = stringOrUndefined(payload.message.model);
+                mergeUsage(usage, payload.message.usage);
+                break;
+            }
+            case "content_block_start": {
+                const index = streamIndex(payload.index);
+                if (!isRecord(payload.content_block) || blocks.has(index))
+                    throw new Error("Anthropic SSE content block start is invalid");
+                blocks.set(index, {
+                    value: structuredClone(payload.content_block),
+                    partialJson: "",
+                    stopped: false,
+                });
+                break;
+            }
+            case "content_block_delta": {
+                const block = blocks.get(streamIndex(payload.index));
+                if (block === undefined || block.stopped || !isRecord(payload.delta))
+                    throw new Error("Anthropic SSE content block delta is invalid");
+                const delta = payload.delta;
+                if (delta.type === "text_delta" && typeof delta.text === "string") {
+                    appendBlockString(block.value, "text", delta.text, "text");
+                    if (delta.text !== "")
+                        onDelta?.({ kind: "text", text: delta.text });
+                    break;
+                }
+                if (delta.type === "thinking_delta" &&
+                    typeof delta.thinking === "string") {
+                    appendBlockString(block.value, "thinking", delta.thinking, "thinking");
+                    if (delta.thinking !== "")
+                        onDelta?.({ kind: "reasoning", text: delta.thinking });
+                    break;
+                }
+                if (delta.type === "signature_delta" &&
+                    typeof delta.signature === "string") {
+                    appendBlockString(block.value, "signature", delta.signature, "thinking");
+                    break;
+                }
+                if (delta.type === "input_json_delta" &&
+                    typeof delta.partial_json === "string" &&
+                    block.value.type === "tool_use") {
+                    block.partialJson += delta.partial_json;
+                    if (delta.partial_json !== "")
+                        onDelta?.({ kind: "tool", text: delta.partial_json });
+                    break;
+                }
+                throw new Error("Anthropic SSE delta type is not supported");
+            }
+            case "content_block_stop": {
+                const block = blocks.get(streamIndex(payload.index));
+                if (block === undefined || block.stopped)
+                    throw new Error("Anthropic SSE content block stop is invalid");
+                block.stopped = true;
+                if (block.value.type === "tool_use" && block.partialJson !== "")
+                    block.value.input = parseStreamJson(block.partialJson);
+                break;
+            }
+            case "message_delta": {
+                if (!isRecord(payload.delta))
+                    throw new Error("Anthropic SSE message_delta is invalid");
+                if (payload.delta.stop_reason !== undefined &&
+                    payload.delta.stop_reason !== null &&
+                    typeof payload.delta.stop_reason !== "string")
+                    throw new Error("Anthropic SSE stop_reason is invalid");
+                stopReason = payload.delta.stop_reason;
+                mergeUsage(usage, payload.usage);
+                break;
+            }
+            case "message_stop":
+                stopped = true;
+                break stream;
+            case "ping":
+                break;
+            case "error":
+                throw new ModelHostFailureError("Anthropic SSE returned an explicit error");
+            default:
+                // Anthropic may add top-level event types. Unknown events do not alter
+                // the content blocks that form the final continuation.
+                break;
+        }
+    }
+    if (!started || !stopped)
+        throw new Error("Anthropic SSE ended before a complete response");
+    const content = [...blocks.entries()]
+        .sort(([left], [right]) => left - right)
+        .map(([, block]) => {
+        if (!block.stopped)
+            throw new Error("Anthropic SSE content block did not end");
+        return block.value;
+    });
+    const text = content
+        .flatMap((block) => block.type === "text" && typeof block.text === "string"
+        ? [block.text]
+        : [])
+        .join("");
+    const reasoningContent = content
+        .flatMap((block) => block.type === "thinking" && typeof block.thinking === "string"
+        ? [block.thinking]
+        : [])
+        .join("");
+    const toolCalls = content.flatMap((block) => {
+        if (block.type !== "tool_use")
+            return [];
+        if (typeof block.id !== "string" ||
+            block.id === "" ||
+            typeof block.name !== "string" ||
+            block.name === "" ||
+            !isRecord(block.input))
+            throw new Error("Anthropic SSE tool call is incomplete");
+        return [{ id: block.id, name: block.name, arguments: block.input }];
+    });
+    return {
+        content,
+        text,
+        reasoningContent,
+        toolCalls,
+        usage,
+        ...(responseId === undefined ? {} : { responseId }),
+        ...(model === undefined ? {} : { model }),
+        ...(stopReason === undefined ? {} : { stopReason }),
+    };
+}
+export async function aggregateResponsesModelStream(body, onDelta) {
+    let completed = null;
+    for await (const event of modelHostEvents(body)) {
+        const payload = streamRecord(event.data);
+        if (typeof payload.type !== "string")
+            throw new Error("Responses SSE type is invalid");
+        if (event.event !== null && event.event !== payload.type)
+            throw new Error("Responses SSE event and payload type do not match");
+        if ((payload.type === "response.output_text.delta" ||
+            payload.type === "response.reasoning_text.delta" ||
+            payload.type === "response.reasoning_summary_text.delta" ||
+            payload.type === "response.function_call_arguments.delta") &&
+            typeof payload.delta !== "string")
+            throw new Error("Responses SSE delta is invalid");
+        if (payload.type === "response.output_text.delta" && payload.delta !== "")
+            onDelta?.({ kind: "text", text: payload.delta });
+        else if ((payload.type === "response.reasoning_text.delta" ||
+            payload.type === "response.reasoning_summary_text.delta") &&
+            payload.delta !== "")
+            onDelta?.({ kind: "reasoning", text: payload.delta });
+        else if (payload.type === "response.function_call_arguments.delta" &&
+            payload.delta !== "")
+            onDelta?.({ kind: "tool", text: payload.delta });
+        else if (payload.type === "response.completed") {
+            if (completed !== null || !isRecord(payload.response))
+                throw new Error("Responses SSE completed event is invalid");
+            if (payload.response.status !== undefined &&
+                payload.response.status !== "completed")
+                throw new Error("Responses SSE completed response status is invalid");
+            completed = structuredClone(payload.response);
+            break;
+        }
+        else if (payload.type === "response.failed" ||
+            payload.type === "response.incomplete" ||
+            payload.type === "response.cancelled" ||
+            payload.type === "error") {
+            throw new ModelHostFailureError("Responses SSE returned an explicit failure");
+        }
+    }
+    if (completed === null)
+        throw new Error("Responses SSE ended before response.completed");
+    return completed;
+}
+function modelHostEvents(body) {
+    return providerStreamEvents(body);
+}
+function streamRecord(data) {
+    const value = parseStreamJson(data);
+    if (!isRecord(value))
+        throw new Error("Provider SSE data is not an object");
+    return value;
+}
+function parseStreamJson(source) {
+    try {
+        return JSON.parse(source);
+    }
+    catch {
+        throw new Error("Provider SSE data is not valid JSON");
+    }
+}
+function streamIndex(value) {
+    if (!Number.isSafeInteger(value) || value < 0)
+        throw new Error("Provider SSE content index is invalid");
+    return value;
+}
+function appendBlockString(block, field, delta, expectedType) {
+    if (block.type !== expectedType || typeof block[field] !== "string")
+        throw new Error("Anthropic SSE content block does not match its delta");
+    block[field] += delta;
+}
+function mergeUsage(target, value) {
+    if (!isRecord(value))
+        return;
+    for (const field of [
+        "input_tokens",
+        "output_tokens",
+        "cache_read_input_tokens",
+        "cache_creation_input_tokens",
+    ]) {
+        if (value[field] !== undefined)
+            target[field] = value[field];
+    }
+}
+function stringOrUndefined(value) {
+    return typeof value === "string" ? value : undefined;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/node/runtime/model/ProviderExchangeState.js

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

package/dist/node/runtime/model/ProviderStream.js

@@ -0,0 +1,90 @@
+export async function* providerStreamEvents(body) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let pending = "";
+    let event = null;
+    let data = [];
+    let reachedEof = false;
+    const flush = () => {
+        if (data.length === 0) {
+            event = null;
+            return null;
+        }
+        const framed = { event, data: data.join("\n") };
+        event = null;
+        data = [];
+        return framed;
+    };
+    try {
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                reachedEof = true;
+            // `stream: true` keeps a split multi-byte character pending in the
+            // decoder instead of emitting a replacement character for each half.
+            pending += done
+                ? decoder.decode()
+                : decoder.decode(value, { stream: true });
+            let newline = pending.indexOf("\n");
+            while (newline >= 0) {
+                const line = pending.slice(0, newline).replace(/\r$/u, "");
+                pending = pending.slice(newline + 1);
+                if (line === "") {
+                    const framed = flush();
+                    if (framed !== null) {
+                        yield framed;
+                    }
+                }
+                else if (!line.startsWith(":")) {
+                    const colon = line.indexOf(":");
+                    const field = colon < 0 ? line : line.slice(0, colon);
+                    const rawValue = colon < 0 ? "" : line.slice(colon + 1);
+                    const value_ = rawValue.startsWith(" ")
+                        ? rawValue.slice(1)
+                        : rawValue;
+                    if (field === "event")
+                        event = value_;
+                    else if (field === "data")
+                        data.push(value_);
+                }
+                newline = pending.indexOf("\n");
+            }
+            if (done)
+                break;
+        }
+        // A stream that ends without a trailing blank line still carries an event.
+        if (pending.trim() !== "") {
+            const line = pending.replace(/\r$/u, "");
+            if (line.startsWith("data:")) {
+                const rawValue = line.slice(5);
+                data.push(rawValue.startsWith(" ") ? rawValue.slice(1) : rawValue);
+            }
+        }
+        const framed = flush();
+        if (framed !== null)
+            yield framed;
+    }
+    finally {
+        if (!reachedEof) {
+            try {
+                await reader.cancel();
+            }
+            catch {
+                // The terminal Provider event already decides the result; a transport
+                // cancellation failure must not replace it.
+            }
+        }
+        reader.releaseLock();
+    }
+}
+/** Parses one `data` payload, skipping the `[DONE]` sentinel and junk. */
+export function providerStreamJson(data) {
+    if (data === "" || data === "[DONE]")
+        return null;
+    try {
+        return JSON.parse(data);
+    }
+    catch {
+        return null;
+    }
+}

package/dist/node/runtime/model/SettingAuthorStream.js

@@ -0,0 +1,118 @@
+import { providerStreamEvents, providerStreamJson } from "./ProviderStream.js";
+export async function aggregateChatSettingStream(body, onDelta) {
+    let content = "";
+    let reasoningContent = "";
+    let usage = null;
+    // Tool calls arrive as fragments keyed by index; id and name usually only
+    // appear on the first fragment, while arguments accumulate across many.
+    const calls = new Map();
+    for await (const event of providerStreamEvents(body)) {
+        const payload = providerStreamJson(event.data);
+        if (!isRecord(payload))
+            continue;
+        if (isRecord(payload.usage))
+            usage = payload.usage;
+        const choices = Array.isArray(payload.choices)
+            ? payload.choices
+            : [];
+        const choice = choices[0];
+        if (!isRecord(choice) || !isRecord(choice.delta))
+            continue;
+        const { delta } = choice;
+        if (typeof delta.content === "string" && delta.content !== "") {
+            content += delta.content;
+            onDelta?.({ kind: "text", text: delta.content });
+        }
+        if (typeof delta.reasoning_content === "string" &&
+            delta.reasoning_content !== "") {
+            reasoningContent += delta.reasoning_content;
+            onDelta?.({ kind: "reasoning", text: delta.reasoning_content });
+        }
+        if (!Array.isArray(delta.tool_calls))
+            continue;
+        for (const [position, fragment] of delta.tool_calls.entries()) {
+            if (!isRecord(fragment))
+                continue;
+            const index = typeof fragment.index === "number" ? fragment.index : position;
+            const current = calls.get(index) ?? { id: "", name: "", arguments: "" };
+            if (typeof fragment.id === "string" && fragment.id !== "")
+                current.id = fragment.id;
+            const call = isRecord(fragment.function) ? fragment.function : {};
+            if (typeof call.name === "string" && call.name !== "")
+                current.name = call.name;
+            if (typeof call.arguments === "string" && call.arguments !== "") {
+                current.arguments += call.arguments;
+                onDelta?.({ kind: "tool", text: call.arguments });
+            }
+            calls.set(index, current);
+        }
+    }
+    return {
+        content,
+        reasoningContent,
+        toolCalls: [...calls.entries()]
+            .sort(([left], [right]) => left - right)
+            .map(([, call]) => call),
+        usage,
+    };
+}
+export async function aggregateAnthropicSettingStream(body, onDelta) {
+    let content = "";
+    let reasoningContent = "";
+    let inputTokens;
+    let outputTokens;
+    // Anthropic streams one block at a time, so the open block's index decides
+    // which accumulator a delta belongs to.
+    const blocks = new Map();
+    for await (const event of providerStreamEvents(body)) {
+        const payload = providerStreamJson(event.data);
+        if (!isRecord(payload))
+            continue;
+        if (isRecord(payload.message) && isRecord(payload.message.usage))
+            inputTokens = payload.message.usage.input_tokens;
+        if (isRecord(payload.usage) && payload.usage.output_tokens !== undefined)
+            outputTokens = payload.usage.output_tokens;
+        const index = typeof payload.index === "number" ? payload.index : -1;
+        if (payload.type === "content_block_start") {
+            const block = isRecord(payload.content_block)
+                ? payload.content_block
+                : {};
+            if (block.type === "tool_use")
+                blocks.set(index, {
+                    id: typeof block.id === "string" ? block.id : "",
+                    name: typeof block.name === "string" ? block.name : "",
+                    arguments: "",
+                });
+            continue;
+        }
+        if (payload.type !== "content_block_delta" || !isRecord(payload.delta))
+            continue;
+        const { delta } = payload;
+        if (typeof delta.text === "string" && delta.text !== "") {
+            content += delta.text;
+            onDelta?.({ kind: "text", text: delta.text });
+        }
+        if (typeof delta.thinking === "string" && delta.thinking !== "") {
+            reasoningContent += delta.thinking;
+            onDelta?.({ kind: "reasoning", text: delta.thinking });
+        }
+        if (typeof delta.partial_json === "string" && delta.partial_json !== "") {
+            const current = blocks.get(index);
+            if (current !== undefined) {
+                current.arguments += delta.partial_json;
+                onDelta?.({ kind: "tool", text: delta.partial_json });
+            }
+        }
+    }
+    return {
+        content,
+        reasoningContent,
+        toolCalls: [...blocks.entries()]
+            .sort(([left], [right]) => left - right)
+            .map(([, call]) => call),
+        usage: { input_tokens: inputTokens, output_tokens: outputTokens },
+    };
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}