@k2b/nessi 0.10.0-rc.0

package/ai/providers/openai-compatible.js

@@ -0,0 +1,349 @@
+import { formatConnectionError, normalizeHttpError } from "../shared/errors.js";
+import { assertOnlySupportedFiles, buildAssistantMessage } from "../shared/messages.js";
+import { ensureRecord, safeJsonParse, stringifyJson } from "../shared/json.js";
+import { openSSEStream } from "../shared/stream-helpers.js";
+import { normalizeProviderStream } from "../shared/tool-stream-normalizer.js";
+import { createStrictToolCallIdFactory } from "../shared/tool-call-ids.js";
+import { toOpenAITools } from "../shared/tools.js";
+import { applyCredits, makeUsage } from "../shared/usage.js";
+const normalizeToolCallIds = (mode) => mode?.toolCallIdPolicy === "strict9";
+const mapFinishReason = (reason, hasTools) => {
+    if (reason === "tool_calls")
+        return "tool_use";
+    if (reason === "length")
+        return "max_tokens";
+    if (reason === "content_filter")
+        return "error";
+    if (hasTools)
+        return "tool_use";
+    return "stop";
+};
+const responseFormatName = (name) => {
+    const safe = (name ?? "structured_output").replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 64);
+    return safe || "structured_output";
+};
+const applyResponseFormat = (body, request, config) => {
+    if (!request.responseFormat)
+        return;
+    const mode = config.compat?.structuredOutput ?? "response_format";
+    if (mode === false)
+        return;
+    if (mode === "vllm_structured_outputs") {
+        body.structured_outputs = { json: request.responseFormat.schema };
+        return;
+    }
+    body.response_format = {
+        type: "json_schema",
+        json_schema: {
+            name: responseFormatName(request.responseFormat.name),
+            schema: request.responseFormat.schema,
+            strict: true,
+        },
+    };
+};
+const convertMessages = (messages, systemPrompt, config) => {
+    const result = [];
+    const strictIds = normalizeToolCallIds(config.compat);
+    const makeStrictId = createStrictToolCallIdFactory();
+    const pendingToolIds = new Map();
+    if (systemPrompt)
+        result.push({ role: "system", content: systemPrompt });
+    for (const message of messages) {
+        if (message.role === "user") {
+            assertOnlySupportedFiles(message.content, true, config.name);
+            const parts = [];
+            for (const part of message.content) {
+                if (typeof part === "string")
+                    parts.push({ type: "text", text: part });
+                else if (part.type === "text")
+                    parts.push({ type: "text", text: part.text });
+                else {
+                    parts.push({
+                        type: "image_url",
+                        image_url: { url: `data:${part.mediaType};base64,${part.data}` },
+                    });
+                }
+            }
+            if (parts.length === 1 && parts[0]?.type === "text")
+                result.push({ role: "user", content: parts[0].text });
+            else
+                result.push({ role: "user", content: parts });
+            continue;
+        }
+        if (message.role === "assistant") {
+            let text = "";
+            const toolCalls = [];
+            for (const block of message.content) {
+                if (block.type === "text")
+                    text += block.text;
+                else if (block.type === "tool_call") {
+                    const mappedId = strictIds ? makeStrictId(block.id) : block.id;
+                    if (strictIds) {
+                        const queue = pendingToolIds.get(block.id) ?? [];
+                        queue.push(mappedId);
+                        pendingToolIds.set(block.id, queue);
+                    }
+                    toolCalls.push({
+                        id: mappedId,
+                        type: "function",
+                        function: { name: block.name, arguments: stringifyJson(block.args) },
+                    });
+                }
+            }
+            const out = { role: "assistant", content: text || null };
+            if (toolCalls.length > 0)
+                out.tool_calls = toolCalls;
+            result.push(out);
+            continue;
+        }
+        let toolCallId = message.callId;
+        if (strictIds) {
+            const queue = pendingToolIds.get(message.callId);
+            const mapped = queue?.shift();
+            if (!mapped)
+                continue;
+            toolCallId = mapped;
+            if (queue && queue.length === 0)
+                pendingToolIds.delete(message.callId);
+        }
+        const toolMessage = {
+            role: "tool",
+            tool_call_id: toolCallId,
+            content: stringifyJson(message.result),
+        };
+        if (config.compat?.requiresToolResultName)
+            toolMessage.name = message.name;
+        result.push(toolMessage);
+    }
+    return result;
+};
+const usageFromChunk = (chunk, config) => {
+    if (!chunk.usage)
+        return undefined;
+    return applyCredits(makeUsage(chunk.usage.prompt_tokens ?? 0, chunk.usage.completion_tokens ?? 0), config.creditsPerInputToken, config.creditsPerOutputToken);
+};
+const thinkingFromDelta = (delta, config) => {
+    if (config.compat?.thinkingFormat === "text")
+        return delta.reasoning ?? "";
+    if (config.compat?.thinkingFormat === "reasoning_details") {
+        return (delta.reasoning_details ?? [])
+            .map((detail) => detail.text ?? detail.summary ?? "")
+            .join("");
+    }
+    return "";
+};
+const parseCompletionResponse = async (response, config) => {
+    const payload = safeJsonParse(await response.text());
+    if (!payload)
+        throw new Error(`${config.name} returned invalid JSON.`);
+    const choice = payload.choices?.[0];
+    const message = choice?.message;
+    const content = message?.content ?? "";
+    const toolCalls = (message?.tool_calls ?? []).map((call, index) => ({
+        type: "tool_call",
+        id: call.id ?? `${config.name}-${index}`,
+        name: call.function?.name ?? "",
+        args: ensureRecord(safeJsonParse(call.function?.arguments ?? "{}")),
+    }));
+    const usage = usageFromChunk(payload, config);
+    const finishReason = mapFinishReason(choice?.finish_reason, toolCalls.length > 0);
+    return {
+        message: buildAssistantMessage(config.model, content ?? "", "", toolCalls, usage, finishReason),
+        usage,
+        finishReason,
+        providerMeta: {
+            model: config.model,
+            requestId: response.headers.get("x-request-id") ?? response.headers.get("request-id") ?? undefined,
+        },
+    };
+};
+export const openAICompatible = (config) => {
+    const baseURL = config.baseURL.replace(/\/+$/, "");
+    const contextWindow = config.contextWindow ?? 128_000;
+    const resolveTemperature = (request) => request.temperature ?? config.temperature;
+    const provider = {
+        name: config.name,
+        family: "openai-compatible",
+        model: config.model,
+        contextWindow,
+        capabilities: {
+            streaming: true,
+            tools: true,
+            images: true,
+            thinking: config.compat?.thinkingFormat !== "none",
+            usage: true,
+            structuredOutput: config.compat?.structuredOutput !== undefined && config.compat.structuredOutput !== false,
+        },
+        async complete(request) {
+            const messages = convertMessages(request.messages, request.systemPrompt, config);
+            const tools = request.tools?.length ? toOpenAITools(request.tools) : undefined;
+            const body = {
+                model: config.model,
+                messages,
+                stream: false,
+            };
+            if (tools)
+                body.tools = tools;
+            applyResponseFormat(body, request, config);
+            if (request.maxOutputTokens !== undefined) {
+                body[config.compat?.maxTokensField ?? "max_completion_tokens"] = request.maxOutputTokens;
+            }
+            if (request.disableReasoning)
+                body.reasoning_effort = "low";
+            const temperature = resolveTemperature(request);
+            if (temperature !== undefined)
+                body.temperature = temperature;
+            const headers = {
+                "Content-Type": "application/json",
+                ...config.headers,
+            };
+            if (config.apiKey)
+                headers.Authorization = `Bearer ${config.apiKey}`;
+            const response = await fetch(`${baseURL}/chat/completions`, {
+                method: "POST",
+                headers,
+                body: JSON.stringify(body),
+                signal: request.signal,
+            }).catch((error) => {
+                throw new Error(formatConnectionError(config.name, error));
+            });
+            if (!response.ok) {
+                const normalized = await normalizeHttpError(config.name, response);
+                throw new Error(normalized.error);
+            }
+            return parseCompletionResponse(response, config);
+        },
+        stream(request) {
+            const raw = async function* () {
+                const messages = convertMessages(request.messages, request.systemPrompt, config);
+                const tools = request.tools?.length ? toOpenAITools(request.tools) : undefined;
+                const body = {
+                    model: config.model,
+                    messages,
+                    stream: true,
+                };
+                if (config.compat?.supportsUsageInStreaming !== false) {
+                    body.stream_options = { include_usage: true };
+                }
+                if (tools)
+                    body.tools = tools;
+                applyResponseFormat(body, request, config);
+                const temperature = resolveTemperature(request);
+                if (temperature !== undefined)
+                    body.temperature = temperature;
+                if (request.maxOutputTokens !== undefined) {
+                    body[config.compat?.maxTokensField ?? "max_completion_tokens"] = request.maxOutputTokens;
+                }
+                if (request.disableReasoning)
+                    body.reasoning_effort = "low";
+                const headers = {
+                    "Content-Type": "application/json",
+                    ...config.headers,
+                };
+                if (config.apiKey)
+                    headers.Authorization = `Bearer ${config.apiKey}`;
+                const result = await openSSEStream(`${baseURL}/chat/completions`, headers, body, config.name, request.signal, contextWindow, config.timeouts);
+                if (!result.ok) {
+                    yield result.error;
+                    return;
+                }
+                const toolBuffers = new Map();
+                let latestUsage;
+                let latestFinishReason;
+                const startToolCall = function* (buffer) {
+                    if (buffer.started || !buffer.name.trim())
+                        return;
+                    buffer.started = true;
+                    yield { type: "tool_start", callId: buffer.callId, name: buffer.name };
+                    if (buffer.argsBuffer)
+                        yield { type: "tool_delta", callId: buffer.callId, argsDelta: buffer.argsBuffer };
+                };
+                const flushToolCalls = function* () {
+                    for (const [, buffer] of toolBuffers) {
+                        yield* startToolCall(buffer);
+                        yield {
+                            type: "tool_call",
+                            callId: buffer.callId,
+                            name: buffer.name,
+                            args: ensureRecord(safeJsonParse(buffer.argsBuffer || "{}")),
+                        };
+                    }
+                    toolBuffers.clear();
+                };
+                for await (const event of result.events) {
+                    if (event.data === "[DONE]")
+                        break;
+                    const chunk = safeJsonParse(event.data);
+                    if (!chunk)
+                        continue;
+                    const choice = chunk.choices?.[0];
+                    const usage = usageFromChunk(chunk, config);
+                    if (!choice) {
+                        if (usage) {
+                            latestUsage = usage;
+                            yield { type: "usage", usage };
+                        }
+                        continue;
+                    }
+                    const delta = choice.delta;
+                    if (delta.content)
+                        yield { type: "text", delta: delta.content };
+                    const thinking = thinkingFromDelta(delta, config);
+                    if (thinking)
+                        yield { type: "thinking", delta: thinking };
+                    if (delta.tool_calls) {
+                        for (const toolCall of delta.tool_calls) {
+                            const existing = toolBuffers.get(toolCall.index);
+                            if (!existing) {
+                                const callId = toolCall.id ?? `${config.name}-${toolCall.index}`;
+                                const name = toolCall.function?.name ?? "";
+                                const argsDelta = toolCall.function?.arguments ?? "";
+                                const buffer = {
+                                    callId,
+                                    name,
+                                    argsBuffer: argsDelta,
+                                    started: false,
+                                };
+                                toolBuffers.set(toolCall.index, buffer);
+                                yield* startToolCall(buffer);
+                            }
+                            else {
+                                if (toolCall.function?.name)
+                                    existing.name = toolCall.function.name;
+                                const argsDelta = toolCall.function?.arguments ?? "";
+                                if (argsDelta)
+                                    existing.argsBuffer += argsDelta;
+                                const wasStarted = existing.started;
+                                yield* startToolCall(existing);
+                                if (wasStarted && argsDelta) {
+                                    yield { type: "tool_delta", callId: existing.callId, argsDelta };
+                                }
+                            }
+                        }
+                    }
+                    if (choice.finish_reason === "tool_calls") {
+                        yield* flushToolCalls();
+                    }
+                    latestFinishReason = mapFinishReason(choice.finish_reason, false);
+                    if (usage) {
+                        latestUsage = usage;
+                        yield { type: "usage", usage };
+                    }
+                }
+                if (toolBuffers.size > 0) {
+                    latestFinishReason = "tool_use";
+                    yield* flushToolCalls();
+                }
+                if (latestFinishReason) {
+                    yield {
+                        type: "usage",
+                        usage: latestUsage ?? makeUsage(),
+                        finishReason: latestFinishReason,
+                    };
+                }
+            };
+            return normalizeProviderStream(raw(), { suppressTextAfterMalformedTool: true });
+        },
+    };
+    return provider;
+};

package/ai/providers/openai.d.ts

@@ -0,0 +1,12 @@
+import type { Provider, ProviderTimeouts } from "../types.js";
+export type OpenAIOptions = {
+    apiKey?: string;
+    baseURL?: string;
+    contextWindow?: number;
+    temperature?: number;
+    creditsPerInputToken?: number;
+    creditsPerOutputToken?: number;
+    normalizeToolCallIds?: "auto" | "never" | "strict9";
+    timeouts?: ProviderTimeouts;
+};
+export declare const openai: (model: string, options?: OpenAIOptions) => Provider;

package/ai/providers/openai.js

@@ -0,0 +1,22 @@
+import { openAICompatible } from "./openai-compatible.js";
+export const openai = (model, options) => {
+    const config = {
+        name: "openai",
+        model,
+        baseURL: options?.baseURL ?? "https://api.openai.com/v1",
+        apiKey: options?.apiKey ?? globalThis.process?.env?.OPENAI_API_KEY,
+        contextWindow: options?.contextWindow,
+        temperature: options?.temperature,
+        creditsPerInputToken: options?.creditsPerInputToken,
+        creditsPerOutputToken: options?.creditsPerOutputToken,
+        timeouts: options?.timeouts,
+        compat: {
+            toolCallIdPolicy: options?.normalizeToolCallIds === "strict9" ? "strict9" : "passthrough",
+            supportsUsageInStreaming: true,
+            thinkingFormat: "none",
+            maxTokensField: "max_completion_tokens",
+            structuredOutput: "response_format",
+        },
+    };
+    return openAICompatible(config);
+};

package/ai/providers/openrouter.d.ts

@@ -0,0 +1,13 @@
+import type { Provider, ProviderTimeouts } from "../types.js";
+export type OpenRouterOptions = {
+    apiKey?: string;
+    baseURL?: string;
+    contextWindow?: number;
+    temperature?: number;
+    referer?: string;
+    title?: string;
+    creditsPerInputToken?: number;
+    creditsPerOutputToken?: number;
+    timeouts?: ProviderTimeouts;
+};
+export declare const openrouter: (model: string, options?: OpenRouterOptions) => Provider;

package/ai/providers/openrouter.js

@@ -0,0 +1,28 @@
+import { openAICompatible } from "./openai-compatible.js";
+export const openrouter = (model, options) => {
+    const headers = {};
+    if (options?.referer)
+        headers["HTTP-Referer"] = options.referer;
+    if (options?.title)
+        headers["X-Title"] = options.title;
+    const config = {
+        name: "openrouter",
+        model,
+        baseURL: options?.baseURL ?? "https://openrouter.ai/api/v1",
+        apiKey: options?.apiKey ?? globalThis.process?.env?.OPENROUTER_API_KEY,
+        contextWindow: options?.contextWindow,
+        temperature: options?.temperature,
+        creditsPerInputToken: options?.creditsPerInputToken,
+        creditsPerOutputToken: options?.creditsPerOutputToken,
+        timeouts: options?.timeouts,
+        headers,
+        compat: {
+            toolCallIdPolicy: "passthrough",
+            supportsUsageInStreaming: true,
+            thinkingFormat: "reasoning_details",
+            maxTokensField: "max_tokens",
+            structuredOutput: "response_format",
+        },
+    };
+    return openAICompatible(config);
+};

package/ai/providers/vllm.d.ts

@@ -0,0 +1,11 @@
+import type { Provider, ProviderTimeouts } from "../types.js";
+export type VLLMOptions = {
+    apiKey?: string;
+    baseURL?: string;
+    contextWindow?: number;
+    temperature?: number;
+    creditsPerInputToken?: number;
+    creditsPerOutputToken?: number;
+    timeouts?: ProviderTimeouts;
+};
+export declare const vllm: (model: string, options?: VLLMOptions) => Provider;

package/ai/providers/vllm.js

@@ -0,0 +1,22 @@
+import { openAICompatible } from "./openai-compatible.js";
+export const vllm = (model, options) => {
+    const config = {
+        name: "vllm",
+        model,
+        baseURL: options?.baseURL ?? "http://localhost:8000/v1",
+        apiKey: options?.apiKey,
+        contextWindow: options?.contextWindow,
+        temperature: options?.temperature,
+        creditsPerInputToken: options?.creditsPerInputToken,
+        creditsPerOutputToken: options?.creditsPerOutputToken,
+        timeouts: options?.timeouts,
+        compat: {
+            toolCallIdPolicy: "passthrough",
+            supportsUsageInStreaming: true,
+            thinkingFormat: "none",
+            maxTokensField: "max_tokens",
+            structuredOutput: "vllm_structured_outputs",
+        },
+    };
+    return openAICompatible(config);
+};

package/ai/shared/errors.d.ts

@@ -0,0 +1,15 @@
+export declare const isRetryableStatus: (status: number) => boolean;
+export declare const isContextOverflow: (status: number, message: string) => boolean;
+/**
+ * Try to extract an overflow ratio from a provider error message.
+ * Many providers include token counts like:
+ * "maximum context length is 32768 tokens ... your prompt contains 45000 tokens"
+ */
+export declare const parseOverflowRatio: (message: string) => number | undefined;
+export declare const normalizeHttpError: (label: string, response: Response, retryableOverride?: boolean) => Promise<{
+    error: string;
+    retryable: boolean;
+    contextOverflow: boolean;
+    overflowRatio: number | undefined;
+}>;
+export declare const formatConnectionError: (label: string, error: unknown) => string;

package/ai/shared/errors.js

@@ -0,0 +1,56 @@
+import { safeJsonParse } from "./json.js";
+const parseErrorMessage = (rawText) => {
+    const parsed = safeJsonParse(rawText);
+    if (!parsed)
+        return { message: rawText };
+    const nestedError = parsed.error;
+    const message = (typeof nestedError?.message === "string" && nestedError.message) ||
+        (typeof parsed.message === "string" && parsed.message) ||
+        rawText;
+    const code = (typeof nestedError?.code === "string" && nestedError.code) ||
+        (typeof parsed.code === "string" && parsed.code) ||
+        undefined;
+    return { message, code };
+};
+export const isRetryableStatus = (status) => status === 408 || status === 409 || status === 425 || status === 429 || status >= 500;
+export const isContextOverflow = (status, message) => {
+    if (status !== 400 && status !== 413 && status !== 422)
+        return false;
+    const lower = message.toLowerCase();
+    return lower.includes("context")
+        || lower.includes("too long")
+        || lower.includes("maximum")
+        || lower.includes("max tokens")
+        || lower.includes("context window")
+        || lower.includes("token limit")
+        || lower.includes("prompt is too long")
+        || lower.includes("reduce the length")
+        || lower.includes("exceeded");
+};
+/**
+ * Try to extract an overflow ratio from a provider error message.
+ * Many providers include token counts like:
+ * "maximum context length is 32768 tokens ... your prompt contains 45000 tokens"
+ */
+export const parseOverflowRatio = (message) => {
+    const maxMatch = message.match(/(?:maximum|max)\s+(?:context\s+)?(?:length|window|limit)\s+(?:is|of)\s+([\d,]+)/i);
+    const actualMatch = message.match(/(?:resulted?\s+in|contains?\s+(?:at\s+least\s+)?|received|totale?\s+of\s+(?:at\s+least\s+)?)\s*([\d,]+)\s*(?:tokens|input)/i);
+    if (!maxMatch?.[1] || !actualMatch?.[1])
+        return undefined;
+    const max = parseInt(maxMatch[1].replace(/,/g, ""), 10);
+    const actual = parseInt(actualMatch[1].replace(/,/g, ""), 10);
+    return max > 0 ? actual / max : undefined;
+};
+export const normalizeHttpError = async (label, response, retryableOverride) => {
+    const rawText = await response.text().catch(() => "");
+    const { message, code } = parseErrorMessage(rawText);
+    const fullMessage = code ? `${message} (code: ${code})` : message || `HTTP ${response.status}`;
+    const contextOverflow = isContextOverflow(response.status, fullMessage);
+    return {
+        error: `${label} ${response.status}: ${fullMessage}`,
+        retryable: retryableOverride ?? isRetryableStatus(response.status),
+        contextOverflow,
+        overflowRatio: contextOverflow ? parseOverflowRatio(fullMessage) : undefined,
+    };
+};
+export const formatConnectionError = (label, error) => `${label} connection failed: ${error instanceof Error ? error.message : String(error)}`;

package/ai/shared/json.d.ts

@@ -0,0 +1,3 @@
+export declare const safeJsonParse: <T>(input: string) => T | null;
+export declare const stringifyJson: (value: unknown) => string;
+export declare const ensureRecord: (value: unknown) => Record<string, unknown>;

package/ai/shared/json.js

@@ -0,0 +1,15 @@
+export const safeJsonParse = (input) => {
+    try {
+        return JSON.parse(input);
+    }
+    catch {
+        return null;
+    }
+};
+export const stringifyJson = (value) => typeof value === "string" ? value : JSON.stringify(value);
+export const ensureRecord = (value) => {
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+        return value;
+    }
+    return {};
+};

package/ai/shared/messages.d.ts

@@ -0,0 +1,15 @@
+import type { AssistantMessage, AssistantContentBlock, ContentPart, InputFilePart, Message, TextBlock, ThinkingBlock, ToolCallBlock } from "../types.js";
+export declare const textPart: (text: string) => {
+    type: "text";
+    text: string;
+};
+export declare const textBlock: (text: string) => TextBlock;
+export declare const thinkingBlock: (thinking: string) => ThinkingBlock;
+export declare const toolCallBlock: (id: string, name: string, args: Record<string, unknown>) => ToolCallBlock;
+export declare const appendAssistantContentBlock: (content: AssistantContentBlock[], block: AssistantContentBlock) => void;
+export declare const contentPartToText: (part: ContentPart) => string;
+export declare const isImageFilePart: (part: ContentPart) => part is InputFilePart;
+export declare const assertOnlySupportedFiles: (parts: ContentPart[], supportImages: boolean, label: string) => void;
+export declare const buildAssistantMessage: (model: string, text: string, thinking: string, toolCalls: ToolCallBlock[], usage?: AssistantMessage["usage"], stopReason?: AssistantMessage["stopReason"]) => AssistantMessage;
+export declare const buildAssistantMessageFromContent: (model: string, content: AssistantContentBlock[], usage?: AssistantMessage["usage"], stopReason?: AssistantMessage["stopReason"]) => AssistantMessage;
+export declare const extractAssistantText: (message: Message) => string;

package/ai/shared/messages.js

@@ -0,0 +1,58 @@
+export const textPart = (text) => ({ type: "text", text });
+export const textBlock = (text) => ({ type: "text", text });
+export const thinkingBlock = (thinking) => ({ type: "thinking", thinking });
+export const toolCallBlock = (id, name, args) => ({ type: "tool_call", id, name, args });
+export const appendAssistantContentBlock = (content, block) => {
+    if (block.type === "text" && block.text.length === 0)
+        return;
+    if (block.type === "thinking" && block.thinking.length === 0)
+        return;
+    const last = content.at(-1);
+    if (block.type === "text" && last?.type === "text") {
+        last.text += block.text;
+        return;
+    }
+    if (block.type === "thinking" && last?.type === "thinking") {
+        last.thinking += block.thinking;
+        return;
+    }
+    content.push(block);
+};
+const cloneAssistantContentBlock = (block) => ({ ...block });
+export const contentPartToText = (part) => {
+    if (typeof part === "string")
+        return part;
+    if (part.type === "text")
+        return part.text;
+    return "";
+};
+export const isImageFilePart = (part) => typeof part !== "string" && part.type === "file" && part.mediaType.startsWith("image/");
+export const assertOnlySupportedFiles = (parts, supportImages, label) => {
+    for (const part of parts) {
+        if (typeof part === "string" || part.type === "text")
+            continue;
+        if (supportImages && part.mediaType.startsWith("image/"))
+            continue;
+        throw new Error(`${label} does not support input file type '${part.mediaType}'.`);
+    }
+};
+export const buildAssistantMessage = (model, text, thinking, toolCalls, usage, stopReason) => {
+    const content = [
+        ...(text ? [textBlock(text)] : []),
+        ...(thinking ? [thinkingBlock(thinking)] : []),
+        ...toolCalls,
+    ];
+    return buildAssistantMessageFromContent(model, content, usage, stopReason);
+};
+export const buildAssistantMessageFromContent = (model, content, usage, stopReason) => {
+    const clonedContent = content.map(cloneAssistantContentBlock);
+    return { role: "assistant", content: clonedContent, model, usage, stopReason };
+};
+export const extractAssistantText = (message) => {
+    if (message.role !== "assistant")
+        return "";
+    return message.content
+        .filter((block) => block.type === "text")
+        .map((block) => block.text)
+        .join("");
+};

package/ai/shared/ndjson.d.ts

@@ -0,0 +1,4 @@
+export declare const parseNDJSON: <T>(reader: ReadableStreamDefaultReader<Uint8Array>, timeouts?: {
+    firstByteMs?: number;
+    idleMs?: number;
+}) => AsyncGenerator<T>;