@wangzhizhi/remi 0.0.1-alpha

package/node_modules/@remi/llm/dist/index.js

@@ -0,0 +1,804 @@
+import { modelRoles, providerApiKeyStatus, resolveProviderApiKey } from '@remi/config';
+export const llmPackageName = '@remi/llm';
+export class ProviderRegistry {
+    providers;
+    env;
+    constructor(providers, env = process.env) {
+        this.providers = providers;
+        this.env = env;
+    }
+    list() {
+        return Object.entries(this.providers).map(([alias, provider]) => ({
+            alias,
+            type: provider.type,
+            baseURL: provider.baseURL,
+            apiKeyStatus: providerApiKeyStatus(provider, this.env),
+        }));
+    }
+    get(alias) {
+        return this.providers[alias];
+    }
+}
+export class ModelRegistry {
+    models;
+    profiles;
+    constructor(models, profiles) {
+        this.models = models;
+        this.profiles = profiles;
+    }
+    list() {
+        return Object.entries(this.models).map(([alias, model]) => ({
+            alias,
+            displayName: model.displayName ?? alias,
+            provider: model.provider,
+            model: model.model,
+            contextWindow: model.contextWindow,
+            supportsTools: model.supportsTools,
+            supportsReasoning: model.supportsReasoning,
+            ...(model.tokenEstimator ? { tokenEstimator: model.tokenEstimator } : {}),
+            ...(model.tokenEstimateProfile ? { tokenEstimateProfile: model.tokenEstimateProfile } : {}),
+            usedBy: this.findUsage(alias),
+        }));
+    }
+    get(alias) {
+        return this.models[alias];
+    }
+    findUsage(modelAlias) {
+        const usage = [];
+        for (const [profileName, profile] of Object.entries(this.profiles)) {
+            for (const role of modelRoles) {
+                if (profile.roles[role] === modelAlias) {
+                    usage.push(`${profileName}:${role}`);
+                }
+            }
+        }
+        return usage;
+    }
+}
+export class ModelRouter {
+    config;
+    env;
+    activeProfile;
+    sessionRoleOverrides = new Map();
+    nextTurnRoleOverrides = new Map();
+    providers;
+    models;
+    constructor(config, env = process.env) {
+        this.config = config;
+        this.env = env;
+        this.activeProfile = config.activeProfile ?? 'daily';
+        this.providers = new ProviderRegistry(config.providers ?? {}, env);
+        this.models = new ModelRegistry(config.models ?? {}, config.profiles ?? {});
+    }
+    getActiveProfile() {
+        return this.activeProfile;
+    }
+    useProfile(profileName) {
+        if (!this.config.profiles?.[profileName]) {
+            throw new Error(`Unknown model profile: ${profileName}`);
+        }
+        this.activeProfile = profileName;
+    }
+    switchRoleModel(role, modelAlias) {
+        this.assertRole(role);
+        this.assertModel(modelAlias);
+        this.sessionRoleOverrides.set(role, modelAlias);
+    }
+    useModelForNextTurn(role, modelAlias) {
+        this.assertRole(role);
+        this.assertModel(modelAlias);
+        this.nextTurnRoleOverrides.set(role, modelAlias);
+    }
+    resolve(role, context = {}) {
+        this.assertRole(role);
+        const profileName = context.profile ?? this.activeProfile;
+        const profile = this.resolveProfile(profileName);
+        const alias = this.nextTurnRoleOverrides.get(role) ?? this.sessionRoleOverrides.get(role) ?? profile.roles[role];
+        if (!alias) {
+            throw new Error(`No model configured for role ${role} in profile ${profileName}`);
+        }
+        const model = this.config.models?.[alias];
+        if (!model) {
+            throw new Error(`Unknown model alias: ${alias}`);
+        }
+        const provider = this.config.providers?.[model.provider];
+        if (!provider) {
+            throw new Error(`Unknown provider alias: ${model.provider}`);
+        }
+        this.nextTurnRoleOverrides.delete(role);
+        const resolved = {
+            role,
+            profile: profileName,
+            alias,
+            displayName: model.displayName ?? alias,
+            providerAlias: model.provider,
+            providerType: provider.type,
+            baseURL: provider.baseURL,
+            model: model.model,
+            contextWindow: model.contextWindow,
+            supportsTools: model.supportsTools,
+            supportsReasoning: model.supportsReasoning,
+            apiKeyStatus: providerApiKeyStatus(provider, this.env),
+        };
+        if (profile.effort !== undefined)
+            resolved.effort = profile.effort;
+        if (model.maxOutputTokens !== undefined)
+            resolved.maxOutputTokens = model.maxOutputTokens;
+        if (model.tokenEstimator !== undefined)
+            resolved.tokenEstimator = model.tokenEstimator;
+        if (model.tokenEstimateProfile !== undefined)
+            resolved.tokenEstimateProfile = model.tokenEstimateProfile;
+        if (model.usageShape !== undefined)
+            resolved.usageShape = model.usageShape;
+        if (model.cacheUsageShape !== undefined)
+            resolved.cacheUsageShape = model.cacheUsageShape;
+        return resolved;
+    }
+    resolveProfile(profileName, seen = new Set()) {
+        const profile = this.config.profiles?.[profileName];
+        if (!profile) {
+            throw new Error(`Unknown model profile: ${profileName}`);
+        }
+        if (!profile.extends) {
+            return profile;
+        }
+        if (seen.has(profileName)) {
+            throw new Error(`Circular model profile inheritance: ${profileName}`);
+        }
+        seen.add(profileName);
+        const parent = this.resolveProfile(profile.extends, seen);
+        const resolved = {
+            roles: {
+                ...parent.roles,
+                ...profile.roles,
+            },
+        };
+        const effort = profile.effort ?? parent.effort;
+        if (effort !== undefined)
+            resolved.effort = effort;
+        return resolved;
+    }
+    assertRole(role) {
+        if (!modelRoles.includes(role)) {
+            throw new Error(`Unknown model role: ${role}`);
+        }
+    }
+    assertModel(modelAlias) {
+        if (!this.config.models?.[modelAlias]) {
+            throw new Error(`Unknown model alias: ${modelAlias}`);
+        }
+    }
+}
+export function createModelRouter(config, env = process.env) {
+    return new ModelRouter(config, env);
+}
+export class TokenEstimatorRegistry {
+    estimators = new Map();
+    constructor(estimators = []) {
+        this.register(createHeuristicTokenEstimator());
+        for (const estimator of estimators) {
+            this.register(estimator);
+        }
+    }
+    register(estimator) {
+        this.estimators.set(estimator.kind, estimator);
+    }
+    resolve(model) {
+        const requestedKind = model.tokenEstimator ?? 'heuristic';
+        const profile = model.tokenEstimateProfile ?? 'default';
+        const estimator = this.estimators.get(requestedKind);
+        if (estimator) {
+            return {
+                estimator,
+                requestedKind,
+                actualKind: estimator.kind,
+                profile,
+                fallback: false,
+            };
+        }
+        const fallback = this.estimators.get('heuristic') ?? createHeuristicTokenEstimator();
+        return {
+            estimator: fallback,
+            requestedKind,
+            actualKind: fallback.kind,
+            profile,
+            fallback: true,
+            reason: tokenEstimatorFallbackReason(requestedKind),
+        };
+    }
+}
+export function createTokenEstimatorRegistry(estimators) {
+    return new TokenEstimatorRegistry(estimators);
+}
+export function createHeuristicTokenEstimator() {
+    return {
+        kind: 'heuristic',
+        estimateText(input) {
+            const profile = input.profile ?? 'default';
+            return {
+                tokens: estimateTextTokensHeuristic(input.text, profile),
+                estimator: 'heuristic',
+                profile,
+            };
+        },
+    };
+}
+export function estimateTextTokensHeuristic(text, profile = 'default') {
+    if (text.length === 0) {
+        return 0;
+    }
+    const weights = heuristicWeights(profile);
+    let asciiLike = 0;
+    let wideLike = 0;
+    let whitespace = 0;
+    for (const char of text) {
+        const code = char.codePointAt(0) ?? 0;
+        if (isCjkLikeCodePoint(code)) {
+            wideLike += 1;
+        }
+        else if (/\s/u.test(char)) {
+            whitespace += 1;
+        }
+        else {
+            asciiLike += 1;
+        }
+    }
+    return Math.max(1, Math.ceil(asciiLike / weights.asciiCharsPerToken + wideLike * weights.wideTokenWeight + whitespace / weights.whitespaceCharsPerToken));
+}
+export function estimateMessagesTokensWithEstimator(messages, resolution) {
+    return messages.reduce((sum, message) => {
+        const text = `${message.role}\n${message.content}`;
+        return sum + resolution.estimator.estimateText({ text, profile: resolution.profile }).tokens;
+    }, 0);
+}
+function tokenEstimatorFallbackReason(kind) {
+    if (kind === 'deepseek-local-tokenizer') {
+        return 'DeepSeek local tokenizer adapter is not registered in this runtime';
+    }
+    if (kind === 'ark-tokenization-api') {
+        return 'Ark Tokenization API adapter is not registered in this runtime';
+    }
+    if (kind === 'anthropic-count-tokens') {
+        return 'Anthropic countTokens adapter is not registered in this runtime';
+    }
+    if (kind === 'tiktoken') {
+        return 'tiktoken adapter is not registered in this runtime';
+    }
+    return 'Requested token estimator is unavailable';
+}
+function heuristicWeights(profile) {
+    if (profile === 'code-heavy') {
+        return { asciiCharsPerToken: 3.2, wideTokenWeight: 0.9, whitespaceCharsPerToken: 8 };
+    }
+    if (profile === 'json-heavy') {
+        return { asciiCharsPerToken: 2.8, wideTokenWeight: 0.9, whitespaceCharsPerToken: 10 };
+    }
+    if (profile === 'cjk-heavy') {
+        return { asciiCharsPerToken: 3.8, wideTokenWeight: 1, whitespaceCharsPerToken: 8 };
+    }
+    return { asciiCharsPerToken: 4, wideTokenWeight: 0.8, whitespaceCharsPerToken: 12 };
+}
+function isCjkLikeCodePoint(code) {
+    return ((code >= 0x3400 && code <= 0x9fff) ||
+        (code >= 0xf900 && code <= 0xfaff) ||
+        (code >= 0x3040 && code <= 0x30ff) ||
+        (code >= 0xac00 && code <= 0xd7af));
+}
+export class OpenAICompatibleProvider {
+    options;
+    env;
+    fetchImpl;
+    constructor(options) {
+        this.options = options;
+        this.env = options.env ?? process.env;
+        this.fetchImpl = options.fetch ?? fetch;
+    }
+    async *streamChat(messages, model, options = {}) {
+        const apiKey = resolveProviderApiKey(this.options.provider, this.env);
+        if (!apiKey) {
+            throw new Error(`Missing API key for provider ${model.providerAlias}`);
+        }
+        const controller = createTimeoutController(options.signal, options.timeoutMs);
+        const response = await this.fetchImpl(chatCompletionsUrl(this.options.provider.baseURL), {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${apiKey}`,
+                ...(this.options.provider.headers ?? {}),
+            },
+            body: JSON.stringify({
+                model: model.model,
+                messages: messages.map(toOpenAIMessage),
+                stream: true,
+                stream_options: { include_usage: true },
+                ...(options.tools && options.tools.length > 0 && model.supportsTools
+                    ? {
+                        tools: options.tools.map(tool => ({
+                            type: 'function',
+                            function: {
+                                name: tool.name,
+                                description: tool.description,
+                                parameters: tool.parameters,
+                            },
+                        })),
+                        tool_choice: 'auto',
+                    }
+                    : {}),
+            }),
+            signal: controller.signal,
+        });
+        if (!response.ok) {
+            throw new Error(await formatHttpError(response, model.displayName));
+        }
+        if (!response.body) {
+            throw new Error('LLM request did not return a response body');
+        }
+        try {
+            yield* parseOpenAIStream(response.body);
+        }
+        finally {
+            controller.dispose();
+        }
+    }
+}
+export class AnthropicCompatibleProvider {
+    options;
+    env;
+    fetchImpl;
+    constructor(options) {
+        this.options = options;
+        this.env = options.env ?? process.env;
+        this.fetchImpl = options.fetch ?? fetch;
+    }
+    async *streamChat(messages, model, options = {}) {
+        const apiKey = resolveProviderApiKey(this.options.provider, this.env);
+        if (!apiKey) {
+            throw new Error(`Missing API key for provider ${model.providerAlias}`);
+        }
+        const controller = createTimeoutController(options.signal, options.timeoutMs);
+        const response = await this.fetchImpl(anthropicMessagesUrl(this.options.provider.baseURL), {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'anthropic-version': '2023-06-01',
+                'x-api-key': apiKey,
+                ...(this.options.provider.headers ?? {}),
+            },
+            body: JSON.stringify(createAnthropicMessagesBody(messages, model)),
+            signal: controller.signal,
+        });
+        if (!response.ok) {
+            throw new Error(await formatHttpError(response, model.displayName));
+        }
+        if (!response.body) {
+            throw new Error('LLM request did not return a response body');
+        }
+        try {
+            yield* parseAnthropicStream(response.body);
+        }
+        finally {
+            controller.dispose();
+        }
+    }
+}
+export function createProviderClient(provider, env = process.env, fetchImpl = fetch) {
+    if (provider.type === 'openai-compatible') {
+        return new OpenAICompatibleProvider({ provider, env, fetch: fetchImpl });
+    }
+    if (provider.type === 'anthropic-compatible') {
+        return new AnthropicCompatibleProvider({ provider, env, fetch: fetchImpl });
+    }
+    throw new Error(`Provider type is not implemented yet: ${provider.type}`);
+}
+export async function* parseOpenAIStream(body) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    const pendingToolCalls = new Map();
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+            break;
+        }
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split(/\r?\n/);
+        buffer = lines.pop() ?? '';
+        for (const line of lines) {
+            const chunk = parseOpenAIStreamLine(line);
+            if (chunk !== undefined) {
+                if (isOpenAIToolCallDelta(chunk)) {
+                    mergeToolCallDelta(pendingToolCalls, chunk);
+                }
+                else if (isToolCallsDone(chunk)) {
+                    yield* flushPendingToolCalls(pendingToolCalls);
+                }
+                else {
+                    yield chunk;
+                }
+            }
+        }
+    }
+    buffer += decoder.decode();
+    const chunk = parseOpenAIStreamLine(buffer);
+    if (chunk !== undefined) {
+        if (isOpenAIToolCallDelta(chunk)) {
+            mergeToolCallDelta(pendingToolCalls, chunk);
+        }
+        else if (isToolCallsDone(chunk)) {
+            yield* flushPendingToolCalls(pendingToolCalls);
+        }
+        else {
+            yield chunk;
+        }
+    }
+    yield* flushPendingToolCalls(pendingToolCalls);
+}
+export function parseOpenAIStreamLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith('data:')) {
+        return undefined;
+    }
+    const payload = trimmed.slice('data:'.length).trim();
+    if (!payload || payload === '[DONE]') {
+        return undefined;
+    }
+    const parsed = JSON.parse(payload);
+    const usage = parseOpenAIUsage(parsed.usage);
+    if (usage) {
+        return { type: 'usage', usage };
+    }
+    const choice = parsed.choices?.[0];
+    if (choice?.finish_reason === 'tool_calls') {
+        return { type: 'tool_calls_done' };
+    }
+    const toolCall = choice?.delta?.tool_calls?.[0];
+    if (toolCall) {
+        const index = typeof toolCall.index === 'number' ? toolCall.index : 0;
+        const id = typeof toolCall.id === 'string' ? toolCall.id : undefined;
+        const name = typeof toolCall.function?.name === 'string' ? toolCall.function.name : undefined;
+        const argumentsDelta = typeof toolCall.function?.arguments === 'string' ? toolCall.function.arguments : undefined;
+        return {
+            type: 'tool_call_delta',
+            index,
+            ...(id ? { id } : {}),
+            ...(name ? { name } : {}),
+            ...(argumentsDelta ? { argumentsDelta } : {}),
+        };
+    }
+    const reasoningContent = choice?.delta?.reasoning_content;
+    if (typeof reasoningContent === 'string' && reasoningContent.length > 0) {
+        return { type: 'reasoning_delta', text: reasoningContent };
+    }
+    const content = choice?.delta?.content;
+    if (typeof content !== 'string' || content.length === 0) {
+        return undefined;
+    }
+    return content;
+}
+export async function* parseAnthropicStream(body) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    let usage;
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+            break;
+        }
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split(/\r?\n/);
+        buffer = lines.pop() ?? '';
+        for (const line of lines) {
+            const chunk = parseAnthropicStreamLine(line);
+            if (typeof chunk === 'string') {
+                yield chunk;
+            }
+            else if (isUsageChunk(chunk)) {
+                usage = mergeAnthropicUsage(usage, chunk.usage);
+            }
+        }
+    }
+    buffer += decoder.decode();
+    const chunk = parseAnthropicStreamLine(buffer);
+    if (typeof chunk === 'string') {
+        yield chunk;
+    }
+    else if (isUsageChunk(chunk)) {
+        usage = mergeAnthropicUsage(usage, chunk.usage);
+    }
+    if (usage) {
+        yield { type: 'usage', usage };
+    }
+}
+export function parseAnthropicStreamLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith('data:')) {
+        return undefined;
+    }
+    const payload = trimmed.slice('data:'.length).trim();
+    if (!payload || payload === '[DONE]') {
+        return undefined;
+    }
+    const parsed = JSON.parse(payload);
+    const delta = objectField(parsed, 'delta');
+    const text = delta?.text;
+    if (typeof text === 'string' && text.length > 0) {
+        return text;
+    }
+    const message = objectField(parsed, 'message');
+    const messageUsage = message ? objectField(message, 'usage') : undefined;
+    const usage = parseAnthropicUsage(objectField(parsed, 'usage') ?? messageUsage);
+    if (usage) {
+        return { type: 'usage', usage };
+    }
+    return undefined;
+}
+function parseOpenAIUsage(rawUsage) {
+    if (!rawUsage || typeof rawUsage !== 'object') {
+        return undefined;
+    }
+    const usage = rawUsage;
+    const promptDetails = objectField(usage, 'prompt_tokens_details') ?? objectField(usage, 'input_tokens_details');
+    const completionDetails = objectField(usage, 'completion_tokens_details') ?? objectField(usage, 'output_tokens_details');
+    const promptCacheHitTokens = numberField(usage, 'prompt_cache_hit_tokens');
+    const promptCacheMissTokens = numberField(usage, 'prompt_cache_miss_tokens');
+    const fallbackInputTokens = promptCacheHitTokens !== undefined || promptCacheMissTokens !== undefined
+        ? (promptCacheMissTokens ?? 0)
+        : 0;
+    const inputTokens = numberField(usage, 'prompt_tokens') ?? numberField(usage, 'input_tokens') ?? fallbackInputTokens;
+    const outputTokens = numberField(usage, 'completion_tokens') ?? numberField(usage, 'output_tokens') ?? 0;
+    const cachedInputTokens = firstNumberField([
+        numberField(promptDetails, 'cached_tokens'),
+        numberField(promptDetails, 'cached_input_tokens'),
+        numberField(promptDetails, 'cache_read_input_tokens'),
+        numberField(promptDetails, 'cache_read_tokens'),
+        numberField(usage, 'cached_tokens'),
+        numberField(usage, 'cached_input_tokens'),
+        numberField(usage, 'cache_read_input_tokens'),
+        numberField(usage, 'cache_read_tokens'),
+        promptCacheHitTokens,
+    ]);
+    const totalTokens = normalizeTokenTotal(inputTokens, outputTokens, cachedInputTokens, numberField(usage, 'total_tokens'));
+    const reasoningOutputTokens = numberField(completionDetails, 'reasoning_tokens') ??
+        numberField(completionDetails, 'reasoning_output_tokens') ??
+        numberField(usage, 'reasoning_tokens') ??
+        numberField(usage, 'reasoning_output_tokens');
+    if (inputTokens === 0 && outputTokens === 0 && totalTokens === 0 && cachedInputTokens === undefined && reasoningOutputTokens === undefined) {
+        return undefined;
+    }
+    return {
+        inputTokens,
+        outputTokens,
+        totalTokens,
+        ...(cachedInputTokens !== undefined ? { cachedInputTokens } : {}),
+        ...(reasoningOutputTokens !== undefined ? { reasoningOutputTokens } : {}),
+    };
+}
+function parseAnthropicUsage(rawUsage) {
+    if (!rawUsage || typeof rawUsage !== 'object') {
+        return undefined;
+    }
+    const usage = rawUsage;
+    const inputTokens = (numberField(usage, 'input_tokens') ?? 0) + (numberField(usage, 'cache_creation_input_tokens') ?? 0);
+    const outputTokens = numberField(usage, 'output_tokens') ?? 0;
+    const cachedInputTokens = numberField(usage, 'cache_read_input_tokens') ?? numberField(usage, 'cached_input_tokens');
+    const reasoningOutputTokens = numberField(usage, 'reasoning_output_tokens') ?? numberField(usage, 'reasoning_tokens');
+    const totalTokens = normalizeTokenTotal(inputTokens, outputTokens, cachedInputTokens);
+    if (inputTokens === 0 && outputTokens === 0 && cachedInputTokens === undefined && reasoningOutputTokens === undefined) {
+        return undefined;
+    }
+    return {
+        inputTokens,
+        outputTokens,
+        totalTokens,
+        ...(cachedInputTokens !== undefined ? { cachedInputTokens } : {}),
+        ...(reasoningOutputTokens !== undefined ? { reasoningOutputTokens } : {}),
+    };
+}
+function mergeAnthropicUsage(current, next) {
+    const inputTokens = Math.max(current?.inputTokens ?? 0, next.inputTokens);
+    const outputTokens = Math.max(current?.outputTokens ?? 0, next.outputTokens);
+    const cachedInputTokens = maxOptionalNumber(current?.cachedInputTokens, next.cachedInputTokens);
+    const reasoningOutputTokens = maxOptionalNumber(current?.reasoningOutputTokens, next.reasoningOutputTokens);
+    return {
+        inputTokens,
+        outputTokens,
+        totalTokens: normalizeTokenTotal(inputTokens, outputTokens, cachedInputTokens),
+        ...(cachedInputTokens !== undefined ? { cachedInputTokens } : {}),
+        ...(reasoningOutputTokens !== undefined ? { reasoningOutputTokens } : {}),
+    };
+}
+function normalizeTokenTotal(inputTokens, outputTokens, cachedInputTokens, reportedTotalTokens) {
+    return Math.max(reportedTotalTokens ?? 0, inputTokens + outputTokens + (cachedInputTokens ?? 0));
+}
+function maxOptionalNumber(left, right) {
+    if (left === undefined && right === undefined) {
+        return undefined;
+    }
+    return Math.max(left ?? 0, right ?? 0);
+}
+function createAnthropicMessagesBody(messages, model) {
+    const system = messages
+        .filter(message => message.role === 'system')
+        .map(message => message.content)
+        .filter(content => content.length > 0)
+        .join('\n\n');
+    const body = {
+        model: model.model,
+        max_tokens: model.maxOutputTokens ?? 4096,
+        messages: messages
+            .filter(message => message.role !== 'system')
+            .map(message => ({
+            role: message.role,
+            content: message.content,
+        })),
+        stream: true,
+    };
+    if (system.length > 0) {
+        body.system = system;
+    }
+    return body;
+}
+function toOpenAIMessage(message) {
+    if (message.role === 'tool') {
+        return {
+            role: 'tool',
+            tool_call_id: message.toolCallId,
+            content: message.content,
+        };
+    }
+    if (message.role === 'assistant' && message.toolCalls && message.toolCalls.length > 0) {
+        return {
+            role: 'assistant',
+            content: message.content.length > 0 ? message.content : null,
+            ...(message.reasoningContent && message.reasoningContent.length > 0
+                ? { reasoning_content: message.reasoningContent }
+                : {}),
+            tool_calls: message.toolCalls.map(toolCall => ({
+                id: toolCall.id,
+                type: 'function',
+                function: {
+                    name: toolCall.name,
+                    arguments: toolCall.arguments,
+                },
+            })),
+        };
+    }
+    return {
+        role: message.role,
+        content: message.content,
+    };
+}
+function isOpenAIToolCallDelta(chunk) {
+    return typeof chunk !== 'string' && chunk.type === 'tool_call_delta';
+}
+function isToolCallsDone(chunk) {
+    return typeof chunk !== 'string' && chunk.type === 'tool_calls_done';
+}
+function isUsageChunk(chunk) {
+    return typeof chunk === 'object' && chunk !== null && chunk.type === 'usage';
+}
+function mergeToolCallDelta(pendingToolCalls, delta) {
+    const current = pendingToolCalls.get(delta.index) ?? {};
+    pendingToolCalls.set(delta.index, {
+        ...current,
+        ...(delta.id ? { id: delta.id } : {}),
+        ...(delta.name ? { name: delta.name } : {}),
+        arguments: `${current.arguments ?? ''}${delta.argumentsDelta ?? ''}`,
+    });
+}
+function* flushPendingToolCalls(pendingToolCalls) {
+    const calls = [...pendingToolCalls.entries()].sort(([left], [right]) => left - right);
+    pendingToolCalls.clear();
+    for (const [index, call] of calls) {
+        if (!call.id || !call.name) {
+            continue;
+        }
+        yield {
+            type: 'tool_call',
+            toolCall: {
+                id: call.id,
+                name: call.name,
+                arguments: call.arguments ?? '{}',
+            },
+        };
+    }
+}
+function objectField(record, key) {
+    const value = record[key];
+    return value && typeof value === 'object' ? value : undefined;
+}
+function numberField(record, key) {
+    const value = record?.[key];
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+function firstNumberField(values) {
+    return values.find(value => value !== undefined);
+}
+export async function formatHttpError(response, modelName) {
+    const modelText = modelName ? ` for model ${modelName}` : '';
+    const statusText = response.statusText ? ` ${response.statusText}` : '';
+    const reason = response.status === 429 ? 'rate limit or quota exceeded' : 'request failed';
+    const detail = await safeErrorDetail(response);
+    return `LLM request failed${modelText} with HTTP ${response.status}${statusText} (${reason})${detail ? `: ${detail}` : ''}`;
+}
+async function safeErrorDetail(response) {
+    let raw = '';
+    try {
+        raw = await response.text();
+    }
+    catch {
+        return undefined;
+    }
+    if (!raw.trim()) {
+        return undefined;
+    }
+    const parsedDetail = parseErrorDetail(raw);
+    return truncateDetail(parsedDetail ?? raw.replace(/\s+/g, ' ').trim());
+}
+function parseErrorDetail(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        return extractErrorDetail(parsed);
+    }
+    catch {
+        return undefined;
+    }
+}
+function extractErrorDetail(value) {
+    if (typeof value === 'string') {
+        return value;
+    }
+    if (!value || typeof value !== 'object') {
+        return undefined;
+    }
+    const record = value;
+    const error = record['error'];
+    const errorDetail = error && typeof error === 'object' ? extractErrorDetail(error) : undefined;
+    const candidates = [
+        errorDetail,
+        stringField(record, 'message'),
+        stringField(record, 'msg'),
+        stringField(record, 'code'),
+        stringField(record, 'type'),
+    ].filter((item) => item !== undefined && item.length > 0);
+    return candidates.length > 0 ? candidates.join(' - ') : undefined;
+}
+function stringField(record, key) {
+    const value = record[key];
+    return typeof value === 'string' ? value : undefined;
+}
+function truncateDetail(detail) {
+    return detail.length <= 500 ? detail : `${detail.slice(0, 497)}...`;
+}
+function chatCompletionsUrl(baseURL) {
+    return `${baseURL.replace(/\/$/, '')}/chat/completions`;
+}
+function anthropicMessagesUrl(baseURL) {
+    const normalized = baseURL.replace(/\/$/, '');
+    return normalized.endsWith('/v1') ? `${normalized}/messages` : `${normalized}/v1/messages`;
+}
+function createTimeoutController(parentSignal, timeoutMs) {
+    const controller = new AbortController();
+    const onAbort = () => controller.abort(parentSignal?.reason);
+    let timer;
+    if (parentSignal) {
+        if (parentSignal.aborted) {
+            controller.abort(parentSignal.reason);
+        }
+        else {
+            parentSignal.addEventListener('abort', onAbort, { once: true });
+        }
+    }
+    if (timeoutMs !== undefined && timeoutMs > 0) {
+        timer = setTimeout(() => controller.abort(new Error('LLM request timed out')), timeoutMs);
+    }
+    return {
+        signal: controller.signal,
+        dispose: () => {
+            if (timer)
+                clearTimeout(timer);
+            parentSignal?.removeEventListener('abort', onAbort);
+        },
+    };
+}