veryfront 0.1.149 → 0.1.150

package/esm/src/provider/runtime-loader.js

@@ -0,0 +1,1307 @@
+import * as dntShim from "../../_dnt.shims.js";
+const DEFAULT_ANTHROPIC_BASE_URL = "https://api.anthropic.com/v1";
+const DEFAULT_OPENAI_BASE_URL = "https://api.openai.com/v1";
+const DEFAULT_GOOGLE_BASE_URL = "https://generativelanguage.googleapis.com/v1beta";
+function joinUrl(base, path) {
+    return `${base.replace(/\/+$/, "")}/${path.replace(/^\/+/, "")}`;
+}
+function getOpenAIEmbeddingUrl(baseURL) {
+    return joinUrl(baseURL ?? DEFAULT_OPENAI_BASE_URL, "embeddings");
+}
+function getAnthropicMessagesUrl(baseURL) {
+    return joinUrl(baseURL ?? DEFAULT_ANTHROPIC_BASE_URL, "messages");
+}
+function getOpenAIChatCompletionsUrl(baseURL) {
+    return joinUrl(baseURL ?? DEFAULT_OPENAI_BASE_URL, "chat/completions");
+}
+function getGoogleGenerateContentUrl(baseURL, modelId) {
+    return joinUrl(baseURL ?? DEFAULT_GOOGLE_BASE_URL, `models/${encodeURIComponent(modelId)}:generateContent`);
+}
+function getGoogleStreamGenerateContentUrl(baseURL, modelId) {
+    return joinUrl(baseURL ?? DEFAULT_GOOGLE_BASE_URL, `models/${encodeURIComponent(modelId)}:streamGenerateContent?alt=sse`);
+}
+function getGoogleEmbeddingUrl(baseURL, modelId) {
+    return joinUrl(baseURL ?? DEFAULT_GOOGLE_BASE_URL, `models/${encodeURIComponent(modelId)}:embedContent`);
+}
+function isNumberArray(value) {
+    return Array.isArray(value) && value.every((entry) => typeof entry === "number");
+}
+function readRecord(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return undefined;
+    }
+    return Object.fromEntries(Object.entries(value));
+}
+function extractOpenAIEmbeddings(payload) {
+    const record = readRecord(payload);
+    const data = record?.data;
+    if (!Array.isArray(data)) {
+        throw new Error("Invalid OpenAI embedding response: data array missing");
+    }
+    const embeddings = [];
+    for (const item of data) {
+        const itemRecord = readRecord(item);
+        const embedding = itemRecord?.embedding;
+        if (!isNumberArray(embedding)) {
+            throw new Error("Invalid OpenAI embedding response: embedding vector missing");
+        }
+        embeddings.push(embedding);
+    }
+    return embeddings;
+}
+function extractOpenAIUsageTokens(payload) {
+    const record = readRecord(payload);
+    const usage = readRecord(record?.usage);
+    const totalTokens = usage?.total_tokens;
+    return typeof totalTokens === "number" ? totalTokens : undefined;
+}
+function extractGoogleEmbedding(payload) {
+    const record = readRecord(payload);
+    const embeddings = record?.embeddings;
+    if (Array.isArray(embeddings) && embeddings.length > 0) {
+        const firstEmbedding = readRecord(embeddings[0]);
+        const values = firstEmbedding?.values;
+        if (isNumberArray(values)) {
+            return values;
+        }
+    }
+    const embedding = readRecord(record?.embedding);
+    const values = embedding?.values;
+    if (isNumberArray(values)) {
+        return values;
+    }
+    throw new Error("Invalid Google embedding response: embedding vector missing");
+}
+function extractGoogleUsageTokens(payload) {
+    const record = readRecord(payload);
+    const usageMetadata = readRecord(record?.usageMetadata);
+    const promptTokenCount = usageMetadata?.promptTokenCount;
+    return typeof promptTokenCount === "number" ? promptTokenCount : undefined;
+}
+async function readErrorMessage(response) {
+    const text = await response.text();
+    return text.trim() || `${response.status} ${response.statusText}`.trim();
+}
+async function requestJson(options) {
+    const response = await options.fetchImpl(options.url, options.init);
+    if (!response.ok) {
+        const message = await readErrorMessage(response);
+        throw new Error(`${options.providerLabel} request failed: ${message}`);
+    }
+    return response.json();
+}
+async function requestStream(options) {
+    const response = await options.fetchImpl(options.url, options.init);
+    if (!response.ok) {
+        const message = await readErrorMessage(response);
+        throw new Error(`${options.providerLabel} request failed: ${message}`);
+    }
+    if (!response.body) {
+        throw new Error(`${options.providerLabel} request failed: stream body missing`);
+    }
+    return response.body;
+}
+function stringifyJsonValue(value) {
+    if (typeof value === "string") {
+        return value;
+    }
+    return JSON.stringify(value);
+}
+function readTextParts(parts) {
+    let text = "";
+    for (const part of parts) {
+        if (part.type === "text" && typeof part.text === "string") {
+            text += part.text;
+        }
+    }
+    return text;
+}
+function toOpenAICompatibleMessages(prompt) {
+    const messages = [];
+    for (const message of prompt) {
+        switch (message.role) {
+            case "system":
+                messages.push({ role: "system", content: message.content });
+                break;
+            case "user":
+                messages.push({ role: "user", content: readTextParts(message.content) });
+                break;
+            case "assistant": {
+                let text = "";
+                const toolCalls = [];
+                for (const part of message.content) {
+                    if (part.type === "text") {
+                        text += part.text;
+                        continue;
+                    }
+                    toolCalls.push({
+                        id: part.toolCallId,
+                        type: "function",
+                        function: {
+                            name: part.toolName,
+                            arguments: stringifyJsonValue(part.input),
+                        },
+                    });
+                }
+                messages.push({
+                    role: "assistant",
+                    content: text.length > 0 ? text : null,
+                    ...(toolCalls.length > 0 ? { tool_calls: toolCalls } : {}),
+                });
+                break;
+            }
+            case "tool":
+                for (const part of message.content) {
+                    messages.push({
+                        role: "tool",
+                        tool_call_id: part.toolCallId,
+                        content: stringifyJsonValue(part.output.value),
+                    });
+                }
+                break;
+        }
+    }
+    return messages;
+}
+function toOpenAICompatibleTools(tools) {
+    if (!tools) {
+        return undefined;
+    }
+    const functions = tools.flatMap((tool) => tool.type === "function"
+        ? [{
+                type: "function",
+                function: {
+                    name: tool.name,
+                    parameters: tool.inputSchema,
+                    ...(typeof tool.description === "string" ? { description: tool.description } : {}),
+                },
+            }]
+        : []);
+    return functions.length > 0 ? functions : undefined;
+}
+function readProviderOptions(providerOptions, ...providerNames) {
+    if (!providerOptions) {
+        return {};
+    }
+    const merged = {};
+    for (const key of providerNames) {
+        const value = providerOptions[key];
+        const record = readRecord(value);
+        if (record) {
+            Object.assign(merged, record);
+        }
+    }
+    return merged;
+}
+function createRequestHeaders(options) {
+    const headers = new dntShim.Headers(options.extraHeaders);
+    headers.set("content-type", "application/json");
+    headers.set(options.apiKeyHeaderName, options.apiKey);
+    return headers;
+}
+function normalizeAnthropicFinishReason(raw) {
+    if (typeof raw !== "string") {
+        return null;
+    }
+    switch (raw) {
+        case "tool_use":
+            return { unified: "tool-calls", raw };
+        case "end_turn":
+        case "stop_sequence":
+            return { unified: "stop", raw };
+        case "max_tokens":
+            return { unified: "length", raw };
+        default:
+            return raw;
+    }
+}
+function extractAnthropicUsage(payload) {
+    const record = readRecord(payload);
+    const usage = readRecord(record?.usage);
+    if (!usage) {
+        return undefined;
+    }
+    const inputTokens = usage.input_tokens;
+    const outputTokens = usage.output_tokens;
+    return {
+        inputTokens: typeof inputTokens === "number" ? inputTokens : undefined,
+        outputTokens: typeof outputTokens === "number" ? outputTokens : undefined,
+        totalTokens: typeof inputTokens === "number" || typeof outputTokens === "number"
+            ? (typeof inputTokens === "number" ? inputTokens : 0) +
+                (typeof outputTokens === "number" ? outputTokens : 0)
+            : undefined,
+    };
+}
+function mergeUsage(current, next) {
+    if (!current) {
+        return next;
+    }
+    if (!next) {
+        return current;
+    }
+    const inputTokens = next.inputTokens ?? current.inputTokens;
+    const outputTokens = next.outputTokens ?? current.outputTokens;
+    return {
+        inputTokens,
+        outputTokens,
+        totalTokens: (inputTokens ?? 0) + (outputTokens ?? 0),
+    };
+}
+function normalizeAnthropicToolChoice(toolChoice) {
+    if (typeof toolChoice === "string") {
+        return { type: toolChoice };
+    }
+    return toolChoice;
+}
+function toSnakeCaseRecord(record) {
+    return Object.fromEntries(Object.entries(record).map(([key, value]) => [
+        key.replace(/[A-Z]/g, (match) => `_${match.toLowerCase()}`),
+        value,
+    ]));
+}
+function toAnthropicMessages(prompt) {
+    const systemParts = [];
+    const messages = [];
+    for (const message of prompt) {
+        switch (message.role) {
+            case "system":
+                if (message.content.length > 0) {
+                    systemParts.push(message.content);
+                }
+                break;
+            case "user":
+                messages.push({
+                    role: "user",
+                    content: [{ type: "text", text: readTextParts(message.content) }],
+                });
+                break;
+            case "assistant":
+                messages.push({
+                    role: "assistant",
+                    content: message.content.map((part) => part.type === "text" ? { type: "text", text: part.text } : {
+                        type: "tool_use",
+                        id: part.toolCallId,
+                        name: part.toolName,
+                        input: part.input,
+                    }),
+                });
+                break;
+            case "tool":
+                messages.push({
+                    role: "user",
+                    content: message.content.map((part) => ({
+                        type: "tool_result",
+                        tool_use_id: part.toolCallId,
+                        content: stringifyJsonValue(part.output.value),
+                    })),
+                });
+                break;
+        }
+    }
+    return {
+        ...(systemParts.length > 0 ? { system: systemParts.join("\n\n") } : {}),
+        messages,
+    };
+}
+function toAnthropicTools(tools) {
+    if (!tools) {
+        return undefined;
+    }
+    const normalized = [];
+    for (const tool of tools) {
+        if (tool.type === "function") {
+            normalized.push({
+                name: tool.name,
+                ...(typeof tool.description === "string" ? { description: tool.description } : {}),
+                input_schema: tool.inputSchema,
+            });
+            continue;
+        }
+        if (!tool.id.startsWith("anthropic.")) {
+            continue;
+        }
+        const providerType = tool.id.slice("anthropic.".length);
+        if (providerType.length === 0) {
+            continue;
+        }
+        normalized.push({
+            type: providerType,
+            name: tool.name,
+            ...toSnakeCaseRecord(tool.args),
+        });
+    }
+    return normalized.length > 0 ? normalized : undefined;
+}
+function createAnthropicRequestHeaders(options) {
+    const headers = new dntShim.Headers(options.extraHeaders);
+    headers.set("content-type", "application/json");
+    headers.set("anthropic-version", headers.get("anthropic-version") ?? "2023-06-01");
+    if (options.authToken) {
+        headers.set("authorization", `Bearer ${options.authToken}`);
+    }
+    else if (options.apiKey) {
+        headers.set("x-api-key", options.apiKey);
+    }
+    return headers;
+}
+function buildAnthropicMessagesRequest(modelId, providerName, options, stream) {
+    const { system, messages } = toAnthropicMessages(options.prompt);
+    const body = {
+        model: modelId,
+        messages,
+        max_tokens: options.maxOutputTokens ?? 1024,
+        ...(stream ? { stream: true } : {}),
+        ...(system ? { system } : {}),
+        ...(options.temperature !== undefined ? { temperature: options.temperature } : {}),
+        ...(options.topP !== undefined ? { top_p: options.topP } : {}),
+        ...(options.stopSequences && options.stopSequences.length > 0
+            ? { stop_sequences: options.stopSequences }
+            : {}),
+        ...(toAnthropicTools(options.tools) ? { tools: toAnthropicTools(options.tools) } : {}),
+        ...(options.toolChoice !== undefined
+            ? { tool_choice: normalizeAnthropicToolChoice(options.toolChoice) }
+            : {}),
+    };
+    Object.assign(body, readProviderOptions(options.providerOptions, "anthropic", providerName));
+    return body;
+}
+function buildAnthropicGenerateResult(payload) {
+    const record = readRecord(payload);
+    const content = Array.isArray(record?.content) ? record.content : [];
+    const normalized = [];
+    for (const blockValue of content) {
+        const block = readRecord(blockValue);
+        const blockType = typeof block?.type === "string" ? block.type : undefined;
+        if (blockType === "text" && typeof block?.text === "string" && block.text.length > 0) {
+            normalized.push({ type: "text", text: block.text });
+            continue;
+        }
+        if ((blockType === "tool_use" || blockType === "server_tool_use") &&
+            typeof block?.id === "string" &&
+            typeof block?.name === "string") {
+            normalized.push({
+                type: "tool-call",
+                toolCallId: block.id,
+                toolName: block.name,
+                input: stringifyJsonValue(block.input ?? {}),
+            });
+            continue;
+        }
+        if (blockType === "web_search_tool_result" &&
+            typeof block?.tool_use_id === "string" &&
+            Array.isArray(block?.content)) {
+            normalized.push({
+                type: "tool-result",
+                toolCallId: block.tool_use_id,
+                toolName: "web_search",
+                result: block.content,
+            });
+        }
+    }
+    return {
+        content: normalized,
+        finishReason: normalizeAnthropicFinishReason(record?.stop_reason),
+        usage: extractAnthropicUsage(payload),
+    };
+}
+function parseAnthropicSseChunk(chunk) {
+    const blocks = chunk.split("\n\n");
+    const remainder = blocks.pop() ?? "";
+    const events = blocks.flatMap((block) => {
+        const dataLines = block.split("\n")
+            .filter((line) => line.startsWith("data:"))
+            .map((line) => line.slice(5).trimStart());
+        if (!dataLines.length) {
+            return [];
+        }
+        const payload = dataLines.join("\n").trim();
+        if (payload === "[DONE]") {
+            return ["[DONE]"];
+        }
+        try {
+            return [JSON.parse(payload)];
+        }
+        catch {
+            return [];
+        }
+    });
+    return { events, remainder };
+}
+async function* streamAnthropicCompatibleParts(stream) {
+    const decoder = new TextDecoder();
+    let buffer = "";
+    const toolCalls = new Map();
+    let finishReason = null;
+    let usage;
+    for await (const chunk of stream) {
+        buffer += decoder.decode(chunk, { stream: true });
+        const parsed = parseAnthropicSseChunk(buffer);
+        buffer = parsed.remainder;
+        for (const event of parsed.events) {
+            if (event === "[DONE]") {
+                continue;
+            }
+            const record = readRecord(event);
+            const eventType = typeof record?.type === "string" ? record.type : undefined;
+            usage = mergeUsage(usage, extractAnthropicUsage(record));
+            if (eventType === "message_start") {
+                usage = mergeUsage(usage, extractAnthropicUsage(record?.message));
+                continue;
+            }
+            if (eventType === "content_block_start") {
+                const index = typeof record?.index === "number" ? record.index : 0;
+                const contentBlock = readRecord(record?.content_block);
+                const blockType = typeof contentBlock?.type === "string" ? contentBlock.type : undefined;
+                if (blockType === "text" && typeof contentBlock?.text === "string" &&
+                    contentBlock.text.length > 0) {
+                    yield { type: "text-delta", delta: contentBlock.text };
+                    continue;
+                }
+                if ((blockType === "tool_use" || blockType === "server_tool_use") &&
+                    typeof contentBlock?.id === "string" &&
+                    typeof contentBlock?.name === "string") {
+                    const providerExecuted = blockType === "server_tool_use" ? true : undefined;
+                    const current = {
+                        id: contentBlock.id,
+                        name: contentBlock.name,
+                        input: "",
+                        ...(providerExecuted ? { providerExecuted } : {}),
+                    };
+                    toolCalls.set(index, current);
+                    yield {
+                        type: "tool-input-start",
+                        id: current.id,
+                        toolName: current.name,
+                        ...(providerExecuted ? { providerExecuted } : {}),
+                    };
+                    const initialInput = contentBlock.input;
+                    if (initialInput !== undefined) {
+                        const serializedInput = stringifyJsonValue(initialInput);
+                        current.input += serializedInput;
+                        yield {
+                            type: "tool-input-delta",
+                            id: current.id,
+                            delta: serializedInput,
+                        };
+                    }
+                    continue;
+                }
+                if (blockType === "web_search_tool_result" &&
+                    typeof contentBlock?.tool_use_id === "string" &&
+                    Array.isArray(contentBlock?.content)) {
+                    yield {
+                        type: "tool-result",
+                        toolCallId: contentBlock.tool_use_id,
+                        toolName: "web_search",
+                        result: contentBlock.content,
+                        providerExecuted: true,
+                    };
+                }
+                continue;
+            }
+            if (eventType === "content_block_delta") {
+                const index = typeof record?.index === "number" ? record.index : 0;
+                const delta = readRecord(record?.delta);
+                const deltaType = typeof delta?.type === "string" ? delta.type : undefined;
+                if (deltaType === "text_delta" && typeof delta?.text === "string" && delta.text.length > 0) {
+                    yield { type: "text-delta", delta: delta.text };
+                    continue;
+                }
+                if (deltaType === "input_json_delta" && typeof delta?.partial_json === "string") {
+                    const current = toolCalls.get(index);
+                    if (!current) {
+                        continue;
+                    }
+                    current.input += delta.partial_json;
+                    yield {
+                        type: "tool-input-delta",
+                        id: current.id,
+                        delta: delta.partial_json,
+                    };
+                }
+                continue;
+            }
+            if (eventType === "content_block_stop") {
+                const index = typeof record?.index === "number" ? record.index : 0;
+                const current = toolCalls.get(index);
+                if (!current) {
+                    continue;
+                }
+                yield {
+                    type: "tool-call",
+                    toolCallId: current.id,
+                    toolName: current.name,
+                    input: current.input.length > 0 ? current.input : "{}",
+                    ...(current.providerExecuted ? { providerExecuted: true } : {}),
+                };
+                toolCalls.delete(index);
+                continue;
+            }
+            if (eventType === "message_delta") {
+                const delta = readRecord(record?.delta);
+                const normalizedFinishReason = normalizeAnthropicFinishReason(delta?.stop_reason);
+                if (normalizedFinishReason) {
+                    finishReason = normalizedFinishReason;
+                }
+            }
+        }
+    }
+    if (buffer.trim().length > 0) {
+        const parsed = parseAnthropicSseChunk(`${buffer}\n\n`);
+        for (const event of parsed.events) {
+            if (event === "[DONE]") {
+                continue;
+            }
+            const record = readRecord(event);
+            usage = mergeUsage(usage, extractAnthropicUsage(record));
+        }
+    }
+    yield {
+        type: "finish",
+        finishReason,
+        ...(usage ? { usage } : {}),
+    };
+}
+function normalizeOpenAIFinishReason(raw) {
+    if (typeof raw !== "string") {
+        return null;
+    }
+    if (raw === "tool_calls") {
+        return { unified: "tool-calls", raw };
+    }
+    if (raw === "content_filter") {
+        return { unified: "content-filter", raw };
+    }
+    return raw;
+}
+function extractOpenAIUsage(payload) {
+    const record = readRecord(payload);
+    const usage = readRecord(record?.usage);
+    if (!usage) {
+        return undefined;
+    }
+    const inputTokens = usage.prompt_tokens;
+    const outputTokens = usage.completion_tokens;
+    const totalTokens = usage.total_tokens;
+    return {
+        inputTokens: typeof inputTokens === "number" ? inputTokens : undefined,
+        outputTokens: typeof outputTokens === "number" ? outputTokens : undefined,
+        totalTokens: typeof totalTokens === "number" ? totalTokens : undefined,
+    };
+}
+function extractOpenAIContentText(content) {
+    if (typeof content === "string") {
+        return content;
+    }
+    if (!Array.isArray(content)) {
+        return "";
+    }
+    let text = "";
+    for (const part of content) {
+        const record = readRecord(part);
+        const type = record?.type;
+        if (type === "text" && typeof record?.text === "string") {
+            text += record.text;
+        }
+    }
+    return text;
+}
+function extractOpenAIToolCalls(message) {
+    const toolCalls = message.tool_calls;
+    if (!Array.isArray(toolCalls)) {
+        return [];
+    }
+    const normalized = [];
+    for (const entry of toolCalls) {
+        const record = readRecord(entry);
+        const id = typeof record?.id === "string" ? record.id : undefined;
+        const fn = readRecord(record?.function);
+        const name = typeof fn?.name === "string" ? fn.name : undefined;
+        const argumentsText = typeof fn?.arguments === "string" ? fn.arguments : undefined;
+        if (!id || !name || argumentsText === undefined) {
+            continue;
+        }
+        normalized.push({
+            toolCallId: id,
+            toolName: name,
+            input: argumentsText,
+        });
+    }
+    return normalized;
+}
+function buildOpenAIChatRequest(modelId, providerName, options, stream) {
+    const body = {
+        model: modelId,
+        messages: toOpenAICompatibleMessages(options.prompt),
+        ...(stream ? { stream: true, stream_options: { include_usage: true } } : {}),
+        ...(options.maxOutputTokens !== undefined ? { max_tokens: options.maxOutputTokens } : {}),
+        ...(options.temperature !== undefined ? { temperature: options.temperature } : {}),
+        ...(options.topP !== undefined ? { top_p: options.topP } : {}),
+        ...(options.stopSequences && options.stopSequences.length > 0
+            ? { stop: options.stopSequences }
+            : {}),
+        ...(toOpenAICompatibleTools(options.tools)
+            ? { tools: toOpenAICompatibleTools(options.tools) }
+            : {}),
+        ...(options.toolChoice !== undefined ? { tool_choice: options.toolChoice } : {}),
+        ...(options.seed !== undefined ? { seed: options.seed } : {}),
+        ...(options.presencePenalty !== undefined ? { presence_penalty: options.presencePenalty } : {}),
+        ...(options.frequencyPenalty !== undefined
+            ? { frequency_penalty: options.frequencyPenalty }
+            : {}),
+    };
+    Object.assign(body, readProviderOptions(options.providerOptions, "openai", providerName));
+    return body;
+}
+function normalizeGoogleFinishReason(raw) {
+    if (typeof raw !== "string") {
+        return null;
+    }
+    switch (raw) {
+        case "STOP":
+            return { unified: "stop", raw };
+        case "MAX_TOKENS":
+            return { unified: "length", raw };
+        case "SAFETY":
+        case "RECITATION":
+            return { unified: "content-filter", raw };
+        default:
+            return raw.toLowerCase();
+    }
+}
+function extractGoogleUsage(payload) {
+    const record = readRecord(payload);
+    const usage = readRecord(record?.usageMetadata);
+    if (!usage) {
+        return undefined;
+    }
+    const inputTokens = usage.promptTokenCount;
+    const outputTokens = usage.candidatesTokenCount;
+    const totalTokens = usage.totalTokenCount;
+    return {
+        inputTokens: typeof inputTokens === "number" ? inputTokens : undefined,
+        outputTokens: typeof outputTokens === "number" ? outputTokens : undefined,
+        totalTokens: typeof totalTokens === "number" ? totalTokens : undefined,
+    };
+}
+function toGoogleContents(prompt) {
+    const systemParts = [];
+    const contents = [];
+    for (const message of prompt) {
+        switch (message.role) {
+            case "system":
+                if (message.content.length > 0) {
+                    systemParts.push(message.content);
+                }
+                break;
+            case "user":
+                contents.push({
+                    role: "user",
+                    parts: [{ text: readTextParts(message.content) }],
+                });
+                break;
+            case "assistant":
+                contents.push({
+                    role: "model",
+                    parts: message.content.map((part) => part.type === "text" ? { text: part.text } : {
+                        functionCall: {
+                            id: part.toolCallId,
+                            name: part.toolName,
+                            args: part.input,
+                        },
+                    }),
+                });
+                break;
+            case "tool":
+                contents.push({
+                    role: "user",
+                    parts: message.content.map((part) => ({
+                        functionResponse: {
+                            id: part.toolCallId,
+                            name: part.toolName,
+                            response: {
+                                result: part.output.value,
+                            },
+                        },
+                    })),
+                });
+                break;
+        }
+    }
+    return {
+        ...(systemParts.length > 0
+            ? { systemInstruction: { parts: systemParts.map((text) => ({ text })) } }
+            : {}),
+        contents,
+    };
+}
+function toGoogleTools(tools) {
+    if (!tools) {
+        return undefined;
+    }
+    const functionDeclarations = tools.flatMap((tool) => tool.type === "function"
+        ? [{
+                name: tool.name,
+                ...(typeof tool.description === "string" ? { description: tool.description } : {}),
+                parameters: tool.inputSchema,
+            }]
+        : []);
+    return functionDeclarations.length > 0 ? [{ functionDeclarations }] : undefined;
+}
+function normalizeGoogleToolChoice(toolChoice) {
+    if (toolChoice === undefined) {
+        return undefined;
+    }
+    if (typeof toolChoice === "string") {
+        switch (toolChoice) {
+            case "none":
+                return { functionCallingConfig: { mode: "NONE" } };
+            case "any":
+            case "required":
+                return { functionCallingConfig: { mode: "ANY" } };
+            default:
+                return { functionCallingConfig: { mode: "AUTO" } };
+        }
+    }
+    const record = readRecord(toolChoice);
+    if (record?.type === "tool" && typeof record.name === "string") {
+        return {
+            functionCallingConfig: {
+                mode: "ANY",
+                allowedFunctionNames: [record.name],
+            },
+        };
+    }
+    return undefined;
+}
+function buildGoogleGenerationConfig(options) {
+    const config = {
+        ...(options.maxOutputTokens !== undefined ? { maxOutputTokens: options.maxOutputTokens } : {}),
+        ...(options.temperature !== undefined ? { temperature: options.temperature } : {}),
+        ...(options.topP !== undefined ? { topP: options.topP } : {}),
+        ...(options.topK !== undefined ? { topK: options.topK } : {}),
+        ...(options.stopSequences && options.stopSequences.length > 0
+            ? { stopSequences: options.stopSequences }
+            : {}),
+        ...(options.seed !== undefined ? { seed: options.seed } : {}),
+    };
+    return Object.keys(config).length > 0 ? config : undefined;
+}
+function buildGoogleGenerateContentRequest(providerName, options) {
+    const { systemInstruction, contents } = toGoogleContents(options.prompt);
+    const body = {
+        contents,
+        ...(systemInstruction ? { systemInstruction } : {}),
+        ...(toGoogleTools(options.tools) ? { tools: toGoogleTools(options.tools) } : {}),
+        ...(normalizeGoogleToolChoice(options.toolChoice)
+            ? { toolConfig: normalizeGoogleToolChoice(options.toolChoice) }
+            : {}),
+        ...(buildGoogleGenerationConfig(options)
+            ? { generationConfig: buildGoogleGenerationConfig(options) }
+            : {}),
+    };
+    Object.assign(body, readProviderOptions(options.providerOptions, "google", providerName));
+    return body;
+}
+function extractFirstGoogleCandidate(payload) {
+    const record = readRecord(payload);
+    const candidates = record?.candidates;
+    if (!Array.isArray(candidates) || candidates.length === 0) {
+        return undefined;
+    }
+    return readRecord(candidates[0]);
+}
+function extractGoogleCandidateParts(payload) {
+    const candidate = extractFirstGoogleCandidate(payload);
+    const content = readRecord(candidate?.content);
+    const parts = content?.parts;
+    if (!Array.isArray(parts)) {
+        return [];
+    }
+    return parts.flatMap((part) => {
+        const record = readRecord(part);
+        return record ? [record] : [];
+    });
+}
+function buildGoogleGenerateResult(payload) {
+    const parts = extractGoogleCandidateParts(payload);
+    const content = [];
+    for (const [index, part] of parts.entries()) {
+        if (typeof part.text === "string" && part.text.length > 0) {
+            content.push({ type: "text", text: part.text });
+            continue;
+        }
+        const functionCall = readRecord(part.functionCall);
+        if (typeof functionCall?.name === "string") {
+            content.push({
+                type: "tool-call",
+                toolCallId: typeof functionCall.id === "string" ? functionCall.id : `tool-${index}`,
+                toolName: functionCall.name,
+                input: stringifyJsonValue(functionCall.args ?? {}),
+            });
+        }
+    }
+    return {
+        content,
+        finishReason: normalizeGoogleFinishReason(extractFirstGoogleCandidate(payload)?.finishReason),
+        usage: extractGoogleUsage(payload),
+    };
+}
+async function* streamGoogleCompatibleParts(stream) {
+    const decoder = new TextDecoder();
+    let buffer = "";
+    const seenToolCalls = new Set();
+    let finishReason = null;
+    let usage;
+    for await (const chunk of stream) {
+        buffer += decoder.decode(chunk, { stream: true });
+        const parsed = parseOpenAISseChunk(buffer);
+        buffer = parsed.remainder;
+        for (const event of parsed.events) {
+            if (event === "[DONE]") {
+                continue;
+            }
+            usage = extractGoogleUsage(event) ?? usage;
+            const candidate = extractFirstGoogleCandidate(event);
+            const normalizedFinishReason = normalizeGoogleFinishReason(candidate?.finishReason);
+            if (normalizedFinishReason) {
+                finishReason = normalizedFinishReason;
+            }
+            for (const [index, part] of extractGoogleCandidateParts(event).entries()) {
+                if (typeof part.text === "string" && part.text.length > 0) {
+                    yield { type: "text-delta", delta: part.text };
+                    continue;
+                }
+                const functionCall = readRecord(part.functionCall);
+                if (typeof functionCall?.name !== "string") {
+                    continue;
+                }
+                const toolCallId = typeof functionCall.id === "string" ? functionCall.id : `tool-${index}`;
+                if (seenToolCalls.has(toolCallId)) {
+                    continue;
+                }
+                const serializedInput = stringifyJsonValue(functionCall.args ?? {});
+                seenToolCalls.add(toolCallId);
+                yield {
+                    type: "tool-input-start",
+                    id: toolCallId,
+                    toolName: functionCall.name,
+                };
+                yield {
+                    type: "tool-input-delta",
+                    id: toolCallId,
+                    delta: serializedInput,
+                };
+                yield {
+                    type: "tool-call",
+                    toolCallId,
+                    toolName: functionCall.name,
+                    input: serializedInput,
+                };
+            }
+        }
+    }
+    if (buffer.trim().length > 0) {
+        const parsed = parseOpenAISseChunk(`${buffer}\n\n`);
+        for (const event of parsed.events) {
+            if (event === "[DONE]") {
+                continue;
+            }
+            usage = extractGoogleUsage(event) ?? usage;
+        }
+    }
+    yield {
+        type: "finish",
+        finishReason,
+        ...(usage ? { usage } : {}),
+    };
+}
+function extractFirstChoice(payload) {
+    const record = readRecord(payload);
+    const choices = record?.choices;
+    if (!Array.isArray(choices) || choices.length === 0) {
+        return undefined;
+    }
+    const first = readRecord(choices[0]);
+    if (!first) {
+        return undefined;
+    }
+    return first;
+}
+function buildOpenAIGenerateResult(payload) {
+    const choice = extractFirstChoice(payload);
+    const message = readRecord(choice?.message);
+    const text = extractOpenAIContentText(message?.content);
+    const toolCalls = message ? extractOpenAIToolCalls(message) : [];
+    return {
+        content: [
+            ...(text.length > 0 ? [{ type: "text", text }] : []),
+            ...toolCalls.map((toolCall) => ({
+                type: "tool-call",
+                toolCallId: toolCall.toolCallId,
+                toolName: toolCall.toolName,
+                input: toolCall.input,
+            })),
+        ],
+        finishReason: normalizeOpenAIFinishReason(choice?.finish_reason),
+        usage: extractOpenAIUsage(payload),
+    };
+}
+function parseOpenAISseChunk(chunk) {
+    const blocks = chunk.split("\n\n");
+    const remainder = blocks.pop() ?? "";
+    const events = blocks.flatMap((block) => {
+        const dataLines = block.split("\n")
+            .filter((line) => line.startsWith("data:"))
+            .map((line) => line.slice(5).trimStart());
+        if (!dataLines.length) {
+            return [];
+        }
+        const payload = dataLines.join("\n").trim();
+        if (payload === "[DONE]") {
+            return ["[DONE]"];
+        }
+        try {
+            return [JSON.parse(payload)];
+        }
+        catch {
+            return [];
+        }
+    });
+    return { events, remainder };
+}
+async function* streamOpenAICompatibleParts(stream) {
+    const decoder = new TextDecoder();
+    let buffer = "";
+    const toolCalls = new Map();
+    let finishReason = null;
+    let usage;
+    for await (const chunk of stream) {
+        buffer += decoder.decode(chunk, { stream: true });
+        const parsed = parseOpenAISseChunk(buffer);
+        buffer = parsed.remainder;
+        for (const event of parsed.events) {
+            if (event === "[DONE]") {
+                continue;
+            }
+            const record = readRecord(event);
+            usage = extractOpenAIUsage(record) ?? usage;
+            const choices = Array.isArray(record?.choices) ? record.choices : [];
+            for (const choiceValue of choices) {
+                const choice = readRecord(choiceValue);
+                if (!choice) {
+                    continue;
+                }
+                const delta = readRecord(choice.delta);
+                const textDelta = extractOpenAIContentText(delta?.content);
+                if (textDelta.length > 0) {
+                    yield { type: "text-delta", delta: textDelta };
+                }
+                const rawToolCalls = Array.isArray(delta?.tool_calls) ? delta.tool_calls : [];
+                for (const rawToolCall of rawToolCalls) {
+                    const toolCallRecord = readRecord(rawToolCall);
+                    const index = typeof toolCallRecord?.index === "number" ? toolCallRecord.index : 0;
+                    const current = toolCalls.get(index) ?? {
+                        id: typeof toolCallRecord?.id === "string" ? toolCallRecord.id : `tool-${index}`,
+                        name: "",
+                        arguments: "",
+                        started: false,
+                    };
+                    if (typeof toolCallRecord?.id === "string") {
+                        current.id = toolCallRecord.id;
+                    }
+                    const fn = readRecord(toolCallRecord?.function);
+                    if (typeof fn?.name === "string") {
+                        current.name = fn.name;
+                    }
+                    if (!current.started && current.name.length > 0) {
+                        current.started = true;
+                        yield {
+                            type: "tool-input-start",
+                            id: current.id,
+                            toolName: current.name,
+                        };
+                    }
+                    if (typeof fn?.arguments === "string" && fn.arguments.length > 0) {
+                        current.arguments += fn.arguments;
+                        yield {
+                            type: "tool-input-delta",
+                            id: current.id,
+                            delta: fn.arguments,
+                        };
+                    }
+                    toolCalls.set(index, current);
+                }
+                const normalizedFinishReason = normalizeOpenAIFinishReason(choice.finish_reason);
+                if (normalizedFinishReason) {
+                    finishReason = normalizedFinishReason;
+                }
+            }
+        }
+    }
+    if (buffer.trim().length > 0) {
+        const parsed = parseOpenAISseChunk(`${buffer}\n\n`);
+        for (const event of parsed.events) {
+            if (event === "[DONE]") {
+                continue;
+            }
+            const record = readRecord(event);
+            usage = extractOpenAIUsage(record) ?? usage;
+        }
+    }
+    if (finishReason &&
+        typeof finishReason === "object" &&
+        finishReason.unified === "tool-calls") {
+        for (const toolCall of toolCalls.values()) {
+            yield {
+                type: "tool-call",
+                toolCallId: toolCall.id,
+                toolName: toolCall.name,
+                input: toolCall.arguments,
+            };
+        }
+    }
+    yield {
+        type: "finish",
+        finishReason,
+        ...(usage ? { usage } : {}),
+    };
+}
+export function createOpenAIModelRuntime(config, modelId) {
+    const fetchImpl = config.fetch ?? dntShim.dntGlobalThis.fetch;
+    return {
+        provider: config.name ?? "openai",
+        modelId,
+        specificationVersion: "v3",
+        supportedUrls: {},
+        doGenerate(optionsForRuntime) {
+            const options = optionsForRuntime;
+            const url = getOpenAIChatCompletionsUrl(config.baseURL);
+            const body = buildOpenAIChatRequest(modelId, config.name ?? "openai", options, false);
+            return requestJson({
+                url,
+                fetchImpl,
+                providerLabel: config.name ?? "openai",
+                init: {
+                    method: "POST",
+                    headers: createRequestHeaders({
+                        apiKeyHeaderName: "authorization",
+                        apiKey: `Bearer ${config.apiKey}`,
+                        extraHeaders: options.headers,
+                    }),
+                    body: JSON.stringify(body),
+                    signal: options.abortSignal,
+                },
+            }).then(buildOpenAIGenerateResult);
+        },
+        doStream(optionsForRuntime) {
+            const options = optionsForRuntime;
+            const url = getOpenAIChatCompletionsUrl(config.baseURL);
+            const body = buildOpenAIChatRequest(modelId, config.name ?? "openai", options, true);
+            return requestStream({
+                url,
+                fetchImpl,
+                providerLabel: config.name ?? "openai",
+                init: {
+                    method: "POST",
+                    headers: createRequestHeaders({
+                        apiKeyHeaderName: "authorization",
+                        apiKey: `Bearer ${config.apiKey}`,
+                        extraHeaders: options.headers,
+                    }),
+                    body: JSON.stringify(body),
+                    signal: options.abortSignal,
+                },
+            }).then((responseStream) => ({
+                stream: ReadableStream.from(streamOpenAICompatibleParts(responseStream)),
+            }));
+        },
+    };
+}
+export function createAnthropicModelRuntime(config, modelId) {
+    const fetchImpl = config.fetch ?? dntShim.dntGlobalThis.fetch;
+    return {
+        provider: config.name ?? "anthropic",
+        modelId,
+        specificationVersion: "v3",
+        supportedUrls: {},
+        doGenerate(optionsForRuntime) {
+            const options = optionsForRuntime;
+            const url = getAnthropicMessagesUrl(config.baseURL);
+            const body = buildAnthropicMessagesRequest(modelId, config.name ?? "anthropic", options, false);
+            return requestJson({
+                url,
+                fetchImpl,
+                providerLabel: config.name ?? "anthropic",
+                init: {
+                    method: "POST",
+                    headers: createAnthropicRequestHeaders({
+                        apiKey: config.apiKey,
+                        authToken: config.authToken,
+                        extraHeaders: options.headers,
+                    }),
+                    body: JSON.stringify(body),
+                    signal: options.abortSignal,
+                },
+            }).then(buildAnthropicGenerateResult);
+        },
+        doStream(optionsForRuntime) {
+            const options = optionsForRuntime;
+            const url = getAnthropicMessagesUrl(config.baseURL);
+            const body = buildAnthropicMessagesRequest(modelId, config.name ?? "anthropic", options, true);
+            return requestStream({
+                url,
+                fetchImpl,
+                providerLabel: config.name ?? "anthropic",
+                init: {
+                    method: "POST",
+                    headers: createAnthropicRequestHeaders({
+                        apiKey: config.apiKey,
+                        authToken: config.authToken,
+                        extraHeaders: options.headers,
+                    }),
+                    body: JSON.stringify(body),
+                    signal: options.abortSignal,
+                },
+            }).then((responseStream) => ({
+                stream: ReadableStream.from(streamAnthropicCompatibleParts(responseStream)),
+            }));
+        },
+    };
+}
+export function createGoogleModelRuntime(config, modelId) {
+    const fetchImpl = config.fetch ?? dntShim.dntGlobalThis.fetch;
+    return {
+        provider: config.name ?? "google",
+        modelId,
+        specificationVersion: "v3",
+        supportedUrls: {},
+        doGenerate(optionsForRuntime) {
+            const options = optionsForRuntime;
+            const url = getGoogleGenerateContentUrl(config.baseURL, modelId);
+            const body = buildGoogleGenerateContentRequest(config.name ?? "google", options);
+            return requestJson({
+                url,
+                fetchImpl,
+                providerLabel: config.name ?? "google",
+                init: {
+                    method: "POST",
+                    headers: createRequestHeaders({
+                        apiKeyHeaderName: "x-goog-api-key",
+                        apiKey: config.apiKey,
+                        extraHeaders: options.headers,
+                    }),
+                    body: JSON.stringify(body),
+                    signal: options.abortSignal,
+                },
+            }).then(buildGoogleGenerateResult);
+        },
+        doStream(optionsForRuntime) {
+            const options = optionsForRuntime;
+            const url = getGoogleStreamGenerateContentUrl(config.baseURL, modelId);
+            const body = buildGoogleGenerateContentRequest(config.name ?? "google", options);
+            return requestStream({
+                url,
+                fetchImpl,
+                providerLabel: config.name ?? "google",
+                init: {
+                    method: "POST",
+                    headers: createRequestHeaders({
+                        apiKeyHeaderName: "x-goog-api-key",
+                        apiKey: config.apiKey,
+                        extraHeaders: options.headers,
+                    }),
+                    body: JSON.stringify(body),
+                    signal: options.abortSignal,
+                },
+            }).then((responseStream) => ({
+                stream: ReadableStream.from(streamGoogleCompatibleParts(responseStream)),
+            }));
+        },
+    };
+}
+export function createOpenAIEmbeddingRuntime(config, modelId) {
+    const fetchImpl = config.fetch ?? dntShim.dntGlobalThis.fetch;
+    return {
+        provider: config.name ?? "openai",
+        modelId,
+        supportsParallelCalls: true,
+        doEmbed({ values, abortSignal }) {
+            if (values.length === 0) {
+                return Promise.resolve({
+                    embeddings: [],
+                    warnings: [],
+                    rawResponse: { data: [] },
+                });
+            }
+            const url = getOpenAIEmbeddingUrl(config.baseURL);
+            return requestJson({
+                url,
+                fetchImpl,
+                providerLabel: config.name ?? "openai",
+                init: {
+                    method: "POST",
+                    headers: {
+                        "content-type": "application/json",
+                        authorization: `Bearer ${config.apiKey}`,
+                    },
+                    body: JSON.stringify({
+                        model: modelId,
+                        input: values,
+                    }),
+                    signal: abortSignal,
+                },
+            }).then((payload) => ({
+                embeddings: extractOpenAIEmbeddings(payload),
+                usage: {
+                    tokens: extractOpenAIUsageTokens(payload),
+                },
+                rawResponse: payload,
+                warnings: [],
+            }));
+        },
+    };
+}
+export function createGoogleEmbeddingRuntime(config, modelId) {
+    const fetchImpl = config.fetch ?? dntShim.dntGlobalThis.fetch;
+    return {
+        provider: config.name ?? "google",
+        modelId,
+        supportsParallelCalls: true,
+        doEmbed({ values, abortSignal }) {
+            if (values.length === 0) {
+                return Promise.resolve({
+                    embeddings: [],
+                    warnings: [],
+                    rawResponse: { embeddings: [] },
+                });
+            }
+            const url = getGoogleEmbeddingUrl(config.baseURL, modelId);
+            return Promise.all(values.map((value) => requestJson({
+                url,
+                fetchImpl,
+                providerLabel: config.name ?? "google",
+                init: {
+                    method: "POST",
+                    headers: {
+                        "content-type": "application/json",
+                        "x-goog-api-key": config.apiKey,
+                    },
+                    body: JSON.stringify({
+                        content: {
+                            parts: [{ text: value }],
+                        },
+                    }),
+                    signal: abortSignal,
+                },
+            }))).then((payloads) => ({
+                embeddings: payloads.map(extractGoogleEmbedding),
+                usage: {
+                    tokens: payloads.reduce((total, payload) => total + (extractGoogleUsageTokens(payload) ?? 0), 0),
+                },
+                rawResponse: payloads,
+                warnings: [],
+            }));
+        },
+    };
+}