libre-webui 0.14.3 → 0.15.0

package/backend/dist/services/workModelProviderService.js

@@ -0,0 +1,916 @@
+/*
+ * Libre WebUI
+ * Copyright (C) 2025 Kroonen AI, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import axios from 'axios';
+import { getOpenAICompatibleSamplingParameters, resolvePluginChatParameters, } from '../utils/pluginChatAdapter.js';
+import { streamAnthropicResponse, streamOpenAICompatibleResponse, } from '../utils/pluginStreamAdapter.js';
+import { applyModelEndpointTemplate, assertSafePluginEndpoint, buildPluginAuthHeaders, resolvePluginEndpoint, validatePluginModel, } from '../utils/pluginValidation.js';
+import ollamaService from './ollamaService.js';
+import pluginService from './pluginService.js';
+export class WorkModelProviderError extends Error {
+    constructor(message, status, code) {
+        super(message);
+        this.name = 'WorkModelProviderError';
+        this.status = status;
+        this.code = code;
+    }
+}
+export class WorkModelProviderService {
+    constructor(dependencies = {
+        ollama: ollamaService,
+        plugins: pluginService,
+        post: axios.post.bind(axios),
+    }) {
+        this.dependencies = dependencies;
+    }
+    async availability(userId) {
+        const [ollamaAvailable, pluginAvailable] = await Promise.all([
+            this.dependencies.ollama.isHealthy(),
+            Promise.resolve(this.hasConfiguredPlugin(userId)),
+        ]);
+        return { ollamaAvailable, pluginAvailable };
+    }
+    async assertModelSupportsTools(model, provider, userId) {
+        const cleaned = model.trim();
+        if (!cleaned) {
+            throw new WorkModelProviderError('A Work model is required.', 422, 'WORK_MODEL_TOOLS_UNSUPPORTED');
+        }
+        if (provider.providerType === 'plugin') {
+            this.requireExactPlugin(provider.providerId, cleaned, userId);
+            return;
+        }
+        assertOllamaProvider(provider);
+        let details;
+        try {
+            details = await this.dependencies.ollama.showModel(cleaned, false);
+        }
+        catch (error) {
+            throw new WorkModelProviderError(error instanceof Error ? error.message : 'Could not inspect model.', 503, 'WORK_MODEL_UNAVAILABLE');
+        }
+        const capabilities = Array.isArray(details.capabilities)
+            ? details.capabilities.map(value => String(value).toLowerCase())
+            : [];
+        if (!capabilities.includes('tools')) {
+            throw new WorkModelProviderError(`Model "${cleaned}" does not advertise tool support.`, 422, 'WORK_MODEL_TOOLS_UNSUPPORTED');
+        }
+    }
+    async generateChatResponse(request, provider, userId, signal) {
+        if (provider.providerType === 'ollama') {
+            assertOllamaProvider(provider);
+            return this.dependencies.ollama.generateChatResponse(request, signal);
+        }
+        const plugin = this.requireExactPlugin(provider.providerId, request.model, userId);
+        return this.generatePluginResponse(plugin, request, userId, signal);
+    }
+    async generateChatStreamResponse(request, provider, userId, observer, signal) {
+        const streamRequest = { ...request, stream: true };
+        if (provider.providerType === 'ollama') {
+            assertOllamaProvider(provider);
+            return this.generateOllamaStream(streamRequest, observer, signal);
+        }
+        const plugin = this.requireExactPlugin(provider.providerId, request.model, userId);
+        return this.generatePluginStream(plugin, streamRequest, userId, observer, signal);
+    }
+    hasConfiguredPlugin(userId) {
+        return this.dependencies.plugins
+            .getActivePlugins()
+            .filter(isWorkPlugin)
+            .some(plugin => plugin.model_map.length > 0 &&
+            Boolean(this.dependencies.plugins.getApiKey(plugin, userId)));
+    }
+    requireExactPlugin(providerId, model, userId) {
+        const cleanedProviderId = providerId?.trim();
+        if (!cleanedProviderId) {
+            throw new WorkModelProviderError('A plugin provider ID is required.', 400, 'WORK_PLUGIN_ID_REQUIRED');
+        }
+        const plugin = this.dependencies.plugins.getPlugin(cleanedProviderId);
+        if (!plugin || !plugin.active) {
+            throw new WorkModelProviderError(`Plugin "${cleanedProviderId}" is not active.`, 422, 'WORK_PLUGIN_UNAVAILABLE');
+        }
+        assertWorkPluginType(plugin);
+        if (!plugin.model_map.includes(model)) {
+            throw new WorkModelProviderError(`Model "${model}" is not configured for plugin "${plugin.id}".`, 422, 'WORK_PLUGIN_MODEL_UNAVAILABLE');
+        }
+        if (!this.dependencies.plugins.getApiKey(plugin, userId)) {
+            throw new WorkModelProviderError(`API key not found for plugin ${plugin.id}.`, 422, 'WORK_PLUGIN_CREDENTIALS_MISSING');
+        }
+        return plugin;
+    }
+    async generatePluginResponse(plugin, request, userId, signal) {
+        validatePluginModel(request.model);
+        const apiKey = this.dependencies.plugins.getApiKey(plugin, userId);
+        if (!apiKey) {
+            throw new WorkModelProviderError(`API key not found for plugin ${plugin.id}.`, 422, 'WORK_PLUGIN_CREDENTIALS_MISSING');
+        }
+        const variables = this.dependencies.plugins.getPluginVariables(plugin, userId);
+        const endpoint = applyModelEndpointTemplate(resolvePluginEndpoint(plugin.endpoint, variables.endpoint), request.model);
+        assertSafePluginEndpoint(endpoint, 'Work model endpoint');
+        const headers = buildPluginAuthHeaders(plugin, apiKey);
+        const { payload, extraHeaders } = buildPluginWorkPayload(plugin, request, variables);
+        Object.assign(headers, extraHeaders);
+        try {
+            const response = await this.dependencies.post(endpoint, payload, {
+                headers,
+                signal,
+                timeout: 300000,
+            });
+            return normalizePluginWorkResponse(plugin, response.data, request.model);
+        }
+        catch (error) {
+            if (signal?.aborted)
+                throw error;
+            const message = axios.isAxiosError(error) && error.response
+                ? `Plugin API error: ${error.response.status} - ${providerErrorMessage(error.response.data)}`
+                : error instanceof Error
+                    ? error.message
+                    : 'Plugin request failed.';
+            throw new WorkModelProviderError(message, 502, 'WORK_PLUGIN_REQUEST_FAILED');
+        }
+    }
+    async generateOllamaStream(request, observer, signal) {
+        const stream = this.dependencies.ollama.generateChatStreamResponse;
+        if (!stream) {
+            const response = await this.dependencies.ollama.generateChatResponse({ ...request, stream: false }, signal);
+            if (response.message?.thinking) {
+                observer.onReasoning?.(response.message.thinking);
+            }
+            if (response.message?.content) {
+                observer.onContent?.(response.message.content);
+            }
+            observer.onUsage?.(ollamaUsage(response));
+            return response;
+        }
+        return new Promise((resolve, reject) => {
+            let settled = false;
+            let content = '';
+            let reasoning = '';
+            let latest;
+            const toolCalls = [];
+            const finish = (error) => {
+                if (settled)
+                    return;
+                settled = true;
+                if (error) {
+                    reject(error);
+                    return;
+                }
+                const response = {
+                    ...(latest || {
+                        model: request.model,
+                        created_at: new Date().toISOString(),
+                        done: true,
+                    }),
+                    message: {
+                        role: 'assistant',
+                        content,
+                        ...(reasoning ? { thinking: reasoning } : {}),
+                        ...(toolCalls.length ? { tool_calls: toolCalls } : {}),
+                    },
+                    done: true,
+                };
+                observer.onUsage?.(ollamaUsage(response));
+                resolve(response);
+            };
+            void stream
+                .call(this.dependencies.ollama, request, chunk => {
+                latest = chunk;
+                const contentDelta = chunk.message?.content || '';
+                const reasoningDelta = chunk.message?.thinking || '';
+                if (contentDelta) {
+                    content += contentDelta;
+                    observer.onContent?.(contentDelta);
+                }
+                if (reasoningDelta) {
+                    reasoning += reasoningDelta;
+                    observer.onReasoning?.(reasoningDelta);
+                }
+                if (Array.isArray(chunk.message?.tool_calls)) {
+                    for (const call of chunk.message.tool_calls) {
+                        toolCalls.push(call);
+                    }
+                }
+                if (chunk.done)
+                    finish();
+            }, error => finish(error), () => finish(), signal)
+                .catch(error => finish(error instanceof Error ? error : new Error(String(error))));
+        });
+    }
+    async generatePluginStream(plugin, request, userId, observer, signal) {
+        validatePluginModel(request.model);
+        const apiKey = this.dependencies.plugins.getApiKey(plugin, userId);
+        if (!apiKey) {
+            throw new WorkModelProviderError(`API key not found for plugin ${plugin.id}.`, 422, 'WORK_PLUGIN_CREDENTIALS_MISSING');
+        }
+        const variables = this.dependencies.plugins.getPluginVariables(plugin, userId);
+        let endpoint = applyModelEndpointTemplate(resolvePluginEndpoint(plugin.endpoint, variables.endpoint), request.model);
+        if (plugin.id === 'gemini') {
+            endpoint = geminiStreamingEndpoint(endpoint);
+        }
+        assertSafePluginEndpoint(endpoint, 'Work model endpoint');
+        const headers = buildPluginAuthHeaders(plugin, apiKey);
+        const { payload, extraHeaders } = buildPluginWorkPayload(plugin, { ...request, stream: true }, variables);
+        Object.assign(headers, extraHeaders);
+        const timeoutSignal = AbortSignal.timeout(300000);
+        const requestSignal = signal
+            ? AbortSignal.any([signal, timeoutSignal])
+            : timeoutSignal;
+        try {
+            const response = await fetch(endpoint, {
+                method: 'POST',
+                headers,
+                body: JSON.stringify(payload),
+                signal: requestSignal,
+            });
+            const contentType = response.headers.get('content-type') || '';
+            if (response.ok &&
+                !contentType.includes('text/event-stream') &&
+                !contentType.includes('application/x-ndjson')) {
+                const data = (await response.json());
+                const normalized = normalizePluginWorkResponse(plugin, data, request.model);
+                if (normalized.message.thinking) {
+                    observer.onReasoning?.(normalized.message.thinking);
+                }
+                if (normalized.message.content) {
+                    observer.onContent?.(normalized.message.content);
+                }
+                return normalized;
+            }
+            const chunks = plugin.id === 'anthropic'
+                ? streamAnthropicResponse(response)
+                : plugin.id === 'gemini'
+                    ? streamGeminiWorkResponse(response)
+                    : streamOpenAICompatibleResponse(response);
+            return await collectPluginWorkStream(chunks, request.model, observer);
+        }
+        catch (error) {
+            if (signal?.aborted)
+                throw error;
+            if (timeoutSignal.aborted) {
+                throw new WorkModelProviderError('Plugin request timed out after 300 seconds.', 504, 'WORK_PLUGIN_REQUEST_TIMEOUT');
+            }
+            if (error instanceof WorkModelProviderError)
+                throw error;
+            throw new WorkModelProviderError(error instanceof Error ? error.message : 'Plugin request failed.', 502, 'WORK_PLUGIN_REQUEST_FAILED');
+        }
+    }
+}
+export function buildPluginWorkPayload(plugin, request, variables = {}) {
+    const options = (request.options || {});
+    const params = resolvePluginChatParameters(options, variables);
+    if (plugin.id === 'anthropic') {
+        return {
+            payload: buildAnthropicWorkPayload(request.model, request.messages, request.tools || [], params.maxTokens, Boolean(request.stream)),
+            extraHeaders: { 'anthropic-version': '2023-06-01' },
+        };
+    }
+    if (plugin.id === 'gemini') {
+        return {
+            payload: buildGeminiWorkPayload(request.messages, request.tools || [], params),
+            extraHeaders: {},
+        };
+    }
+    return {
+        payload: {
+            model: request.model,
+            messages: toOpenAIWorkMessages(request.messages),
+            tools: request.tools,
+            tool_choice: request.tools?.length ? 'auto' : undefined,
+            ...getOpenAICompatibleSamplingParameters(plugin, params),
+            max_tokens: params.maxTokens,
+            stream: Boolean(request.stream),
+        },
+        extraHeaders: {},
+    };
+}
+export function normalizePluginWorkResponse(plugin, response, model) {
+    if (plugin.id === 'anthropic') {
+        return normalizeAnthropicWorkResponse(response, model);
+    }
+    if (plugin.id === 'gemini') {
+        return normalizeGeminiWorkResponse(response, model);
+    }
+    return normalizeOpenAIWorkResponse(response, model);
+}
+export function toOpenAIWorkMessages(messages) {
+    let pendingCalls = [];
+    return messages.map((message, messageIndex) => {
+        if (message.role === 'assistant') {
+            const toolCalls = normalizeOutboundToolCalls(message.tool_calls);
+            const reasoningContent = toolCalls
+                .map(call => asObject(call.providerMetadata)?.openAIReasoningContent)
+                .find(value => typeof value === 'string');
+            pendingCalls = toolCalls.map(call => ({
+                id: String(call.id),
+                name: String(call.function.name),
+            }));
+            return {
+                role: 'assistant',
+                content: message.content || null,
+                ...(typeof reasoningContent === 'string'
+                    ? { reasoning_content: reasoningContent }
+                    : {}),
+                ...(toolCalls.length
+                    ? {
+                        tool_calls: toolCalls.map(call => ({
+                            id: call.id,
+                            type: 'function',
+                            function: call.function,
+                        })),
+                    }
+                    : {}),
+            };
+        }
+        if (message.role === 'tool') {
+            const matchingIndex = pendingCalls.findIndex(call => !message.tool_name || call.name === message.tool_name);
+            const matching = matchingIndex >= 0
+                ? pendingCalls.splice(matchingIndex, 1)[0]
+                : undefined;
+            return {
+                role: 'tool',
+                content: message.content,
+                name: message.tool_name,
+                tool_call_id: matching?.id || `work-tool-${messageIndex}`,
+            };
+        }
+        return { role: message.role, content: message.content };
+    });
+}
+function buildAnthropicWorkPayload(model, messages, tools, maxTokens, stream = false) {
+    const system = messages
+        .filter(message => message.role === 'system')
+        .map(message => message.content)
+        .join('\n');
+    const providerMessages = [];
+    let pendingCalls = [];
+    let appendToolResult = false;
+    for (const [messageIndex, message] of messages.entries()) {
+        if (message.role === 'system')
+            continue;
+        if (message.role === 'assistant') {
+            const blocks = [];
+            const toolCalls = normalizeOutboundToolCalls(message.tool_calls);
+            const anthropicThinkingBlocks = toolCalls.flatMap(call => {
+                const metadata = asObject(call.providerMetadata);
+                return Array.isArray(metadata?.anthropicThinkingBlocks)
+                    ? metadata.anthropicThinkingBlocks.flatMap(block => asObject(block) ? [block] : [])
+                    : [];
+            });
+            blocks.push(...anthropicThinkingBlocks);
+            if (message.content)
+                blocks.push({ type: 'text', text: message.content });
+            pendingCalls = toolCalls.map(call => ({
+                id: String(call.id),
+                name: String(call.function.name),
+            }));
+            for (const call of toolCalls) {
+                const fn = call.function;
+                blocks.push({
+                    type: 'tool_use',
+                    id: call.id,
+                    name: fn.name,
+                    input: parseToolArguments(fn.arguments),
+                });
+            }
+            providerMessages.push({ role: 'assistant', content: blocks });
+            appendToolResult = false;
+            continue;
+        }
+        if (message.role === 'tool') {
+            const matchIndex = pendingCalls.findIndex(call => !message.tool_name || call.name === message.tool_name);
+            const matching = matchIndex >= 0 ? pendingCalls.splice(matchIndex, 1)[0] : undefined;
+            const block = {
+                type: 'tool_result',
+                tool_use_id: matching?.id || `work-tool-${messageIndex}`,
+                content: message.content,
+            };
+            const previous = providerMessages[providerMessages.length - 1];
+            if (appendToolResult && previous?.role === 'user') {
+                previous.content.push(block);
+            }
+            else {
+                providerMessages.push({ role: 'user', content: [block] });
+            }
+            appendToolResult = true;
+            continue;
+        }
+        providerMessages.push({
+            role: 'user',
+            content: [{ type: 'text', text: message.content }],
+        });
+        appendToolResult = false;
+    }
+    return {
+        model,
+        system: system || undefined,
+        messages: providerMessages,
+        tools: toAnthropicTools(tools),
+        max_tokens: maxTokens ?? 4096,
+        stream,
+    };
+}
+function buildGeminiWorkPayload(messages, tools, params) {
+    const system = messages
+        .filter(message => message.role === 'system')
+        .map(message => message.content)
+        .join('\n');
+    const contents = [];
+    let pendingCalls = [];
+    const append = (role, part) => {
+        const previous = contents[contents.length - 1];
+        if (previous?.role === role)
+            previous.parts.push(part);
+        else
+            contents.push({ role, parts: [part] });
+    };
+    for (const [messageIndex, message] of messages.entries()) {
+        if (message.role === 'system')
+            continue;
+        if (message.role === 'assistant') {
+            if (message.content)
+                append('model', { text: message.content });
+            const calls = normalizeOutboundToolCalls(message.tool_calls);
+            pendingCalls = calls.map(call => ({
+                id: String(call.id),
+                name: String(call.function.name),
+            }));
+            for (const call of calls) {
+                const fn = call.function;
+                append('model', {
+                    functionCall: {
+                        id: call.id,
+                        name: fn.name,
+                        args: parseToolArguments(fn.arguments),
+                    },
+                    ...(typeof call.thoughtSignature === 'string'
+                        ? { thoughtSignature: call.thoughtSignature }
+                        : {}),
+                });
+            }
+            continue;
+        }
+        if (message.role === 'tool') {
+            const matchIndex = pendingCalls.findIndex(call => !message.tool_name || call.name === message.tool_name);
+            const matching = matchIndex >= 0 ? pendingCalls.splice(matchIndex, 1)[0] : undefined;
+            append('user', {
+                functionResponse: {
+                    id: matching?.id || `work-tool-${messageIndex}`,
+                    name: message.tool_name || matching?.name || 'work_tool',
+                    response: { result: message.content },
+                },
+            });
+            continue;
+        }
+        append('user', { text: message.content });
+    }
+    return {
+        systemInstruction: system ? { parts: [{ text: system }] } : undefined,
+        contents,
+        ...(tools.length
+            ? {
+                tools: [
+                    {
+                        functionDeclarations: tools.flatMap(tool => {
+                            const fn = asObject(tool.function);
+                            return fn
+                                ? [
+                                    {
+                                        name: fn.name,
+                                        description: fn.description,
+                                        parameters: fn.parameters,
+                                    },
+                                ]
+                                : [];
+                        }),
+                    },
+                ],
+            }
+            : {}),
+        generationConfig: {
+            temperature: params.temperature,
+            maxOutputTokens: params.maxTokens ?? 4096,
+            topP: params.topP,
+        },
+    };
+}
+function normalizeOpenAIWorkResponse(response, model) {
+    const choices = Array.isArray(response.choices) ? response.choices : [];
+    const choice = asObject(choices[0]);
+    const message = asObject(choice?.message);
+    if (!message) {
+        throw new WorkModelProviderError('Plugin returned an invalid chat response.', 502, 'WORK_PLUGIN_INVALID_RESPONSE');
+    }
+    const toolCalls = normalizeInboundToolCalls(message.tool_calls);
+    if (typeof message.reasoning_content === 'string' && toolCalls[0]) {
+        toolCalls[0].providerMetadata = {
+            ...asObject(toolCalls[0].providerMetadata),
+            openAIReasoningContent: message.reasoning_content,
+        };
+    }
+    return workResponse(model, contentText(message.content), toolCalls, typeof message.reasoning_content === 'string'
+        ? message.reasoning_content
+        : '');
+}
+function normalizeAnthropicWorkResponse(response, model) {
+    const blocks = Array.isArray(response.content) ? response.content : [];
+    const text = [];
+    const calls = [];
+    const thinkingBlocks = [];
+    const reasoning = [];
+    for (const [index, value] of blocks.entries()) {
+        const block = asObject(value);
+        if (block?.type === 'thinking' || block?.type === 'redacted_thinking') {
+            thinkingBlocks.push(block);
+            if (typeof block.thinking === 'string')
+                reasoning.push(block.thinking);
+        }
+        if (block?.type === 'text' && typeof block.text === 'string') {
+            text.push(block.text);
+        }
+        if (block?.type === 'tool_use' && typeof block.name === 'string') {
+            calls.push({
+                id: typeof block.id === 'string' ? block.id : `work-anthropic-${index}`,
+                function: {
+                    name: block.name,
+                    arguments: asObject(block.input) || {},
+                },
+            });
+        }
+    }
+    if (thinkingBlocks.length > 0 && calls[0]) {
+        calls[0].providerMetadata = {
+            anthropicThinkingBlocks: thinkingBlocks,
+        };
+    }
+    return workResponse(model, text.join(''), calls, reasoning.join(''));
+}
+function normalizeGeminiWorkResponse(response, model) {
+    const candidates = Array.isArray(response.candidates)
+        ? response.candidates
+        : [];
+    const candidate = asObject(candidates[0]);
+    const content = asObject(candidate?.content);
+    const parts = Array.isArray(content?.parts) ? content.parts : [];
+    const text = [];
+    const reasoning = [];
+    const calls = [];
+    for (const [index, value] of parts.entries()) {
+        const part = asObject(value);
+        if (typeof part?.text === 'string') {
+            if (part.thought === true)
+                reasoning.push(part.text);
+            else
+                text.push(part.text);
+        }
+        const call = asObject(part?.functionCall);
+        if (call && typeof call.name === 'string') {
+            calls.push({
+                id: typeof call.id === 'string' ? call.id : `work-gemini-${index}`,
+                ...(typeof part?.thoughtSignature === 'string'
+                    ? { thoughtSignature: part.thoughtSignature }
+                    : {}),
+                function: {
+                    name: call.name,
+                    arguments: asObject(call.args) || {},
+                },
+            });
+        }
+    }
+    return workResponse(model, text.join(''), calls, reasoning.join(''));
+}
+function workResponse(model, content, toolCalls, reasoning = '') {
+    return {
+        model,
+        created_at: new Date().toISOString(),
+        message: {
+            role: 'assistant',
+            content,
+            ...(reasoning ? { thinking: reasoning } : {}),
+            tool_calls: toolCalls,
+        },
+        done: true,
+    };
+}
+async function collectPluginWorkStream(chunks, model, observer) {
+    let content = '';
+    let reasoning = '';
+    let usage = {};
+    const toolCalls = [];
+    for await (const chunk of chunks) {
+        if (chunk.type === 'content') {
+            content += chunk.content;
+            observer.onContent?.(chunk.content);
+            continue;
+        }
+        if (chunk.type === 'reasoning') {
+            reasoning += chunk.content;
+            observer.onReasoning?.(chunk.content);
+            continue;
+        }
+        if (chunk.type === 'usage') {
+            usage = { ...usage, ...chunk.usage };
+            observer.onUsage?.(usage);
+            continue;
+        }
+        if (chunk.type === 'tool_call') {
+            const metadata = chunk.toolCall.providerMetadata;
+            toolCalls.push({
+                id: chunk.toolCall.id || `work-plugin-${toolCalls.length}`,
+                ...(typeof metadata?.geminiThoughtSignature === 'string'
+                    ? { thoughtSignature: metadata.geminiThoughtSignature }
+                    : {}),
+                ...(metadata &&
+                    Object.keys(metadata).some(key => key !== 'geminiThoughtSignature')
+                    ? {
+                        providerMetadata: Object.fromEntries(Object.entries(metadata).filter(([key]) => key !== 'geminiThoughtSignature')),
+                    }
+                    : {}),
+                function: {
+                    name: chunk.toolCall.name,
+                    arguments: parseToolArguments(chunk.toolCall.arguments),
+                },
+            });
+        }
+    }
+    if (reasoning && toolCalls[0]) {
+        const firstMetadata = asObject(toolCalls[0].providerMetadata) || {};
+        if (!firstMetadata.openAIReasoningContent &&
+            !firstMetadata.anthropicThinkingBlocks) {
+            toolCalls[0].providerMetadata = {
+                ...firstMetadata,
+                openAIReasoningContent: reasoning,
+            };
+        }
+    }
+    return {
+        ...workResponse(model, content, toolCalls, reasoning),
+        prompt_eval_count: usage.promptTokens,
+        eval_count: usage.completionTokens,
+    };
+}
+function ollamaUsage(response) {
+    return {
+        promptTokens: response.prompt_eval_count,
+        completionTokens: response.eval_count,
+        totalTokens: response.prompt_eval_count !== undefined ||
+            response.eval_count !== undefined
+            ? (response.prompt_eval_count || 0) + (response.eval_count || 0)
+            : undefined,
+    };
+}
+function geminiStreamingEndpoint(endpoint) {
+    const url = new URL(endpoint);
+    url.pathname = url.pathname.replace(/:generateContent$/, ':streamGenerateContent');
+    url.searchParams.set('alt', 'sse');
+    return url.toString();
+}
+async function* streamGeminiWorkResponse(response) {
+    if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Plugin API error: ${response.status} - ${errorText.slice(0, 200)}`);
+    }
+    if (!response.body) {
+        throw new Error('No response body for streaming');
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    let callIndex = 0;
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split('\n');
+            buffer = lines.pop() || '';
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (!trimmed.startsWith('data:'))
+                    continue;
+                let payload;
+                try {
+                    payload = JSON.parse(trimmed.slice(5).trim());
+                }
+                catch {
+                    continue;
+                }
+                const streamError = providerStreamErrorMessage(payload);
+                if (streamError) {
+                    throw new Error(`Plugin API error: ${streamError}`);
+                }
+                const candidates = Array.isArray(payload.candidates)
+                    ? payload.candidates
+                    : [];
+                const candidate = asObject(candidates[0]);
+                const candidateContent = asObject(candidate?.content);
+                const parts = Array.isArray(candidateContent?.parts)
+                    ? candidateContent.parts
+                    : [];
+                for (const rawPart of parts) {
+                    const part = asObject(rawPart);
+                    if (typeof part?.text === 'string' && part.text) {
+                        yield part.thought === true
+                            ? { type: 'reasoning', content: part.text }
+                            : { type: 'content', content: part.text };
+                    }
+                    const call = asObject(part?.functionCall);
+                    if (call && typeof call.name === 'string') {
+                        yield {
+                            type: 'tool_call',
+                            toolCall: {
+                                id: typeof call.id === 'string'
+                                    ? call.id
+                                    : `work-gemini-${callIndex++}`,
+                                name: call.name,
+                                arguments: JSON.stringify(asObject(call.args) || {}),
+                                ...(typeof part?.thoughtSignature === 'string'
+                                    ? {
+                                        providerMetadata: {
+                                            geminiThoughtSignature: part.thoughtSignature,
+                                        },
+                                    }
+                                    : {}),
+                            },
+                        };
+                    }
+                }
+                const usageMetadata = asObject(payload.usageMetadata);
+                if (usageMetadata) {
+                    const promptTokens = typeof usageMetadata.promptTokenCount === 'number'
+                        ? usageMetadata.promptTokenCount
+                        : undefined;
+                    const completionTokens = typeof usageMetadata.candidatesTokenCount === 'number'
+                        ? usageMetadata.candidatesTokenCount
+                        : undefined;
+                    const totalTokens = typeof usageMetadata.totalTokenCount === 'number'
+                        ? usageMetadata.totalTokenCount
+                        : promptTokens !== undefined || completionTokens !== undefined
+                            ? (promptTokens || 0) + (completionTokens || 0)
+                            : undefined;
+                    yield {
+                        type: 'usage',
+                        usage: { promptTokens, completionTokens, totalTokens },
+                    };
+                }
+            }
+        }
+        yield { type: 'done' };
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
+function normalizeOutboundToolCalls(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.flatMap((raw, index) => {
+        const call = asObject(raw);
+        const fn = asObject(call?.function);
+        if (!fn || typeof fn.name !== 'string')
+            return [];
+        const providerMetadata = asObject(call?.providerMetadata);
+        return [
+            {
+                id: typeof call?.id === 'string' ? call.id : `work-tool-call-${index}`,
+                ...(typeof call?.thoughtSignature === 'string'
+                    ? { thoughtSignature: call.thoughtSignature }
+                    : {}),
+                ...(providerMetadata ? { providerMetadata } : {}),
+                type: 'function',
+                function: {
+                    name: fn.name,
+                    arguments: typeof fn.arguments === 'string'
+                        ? fn.arguments
+                        : JSON.stringify(asObject(fn.arguments) || {}),
+                },
+            },
+        ];
+    });
+}
+function normalizeInboundToolCalls(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.flatMap((raw, index) => {
+        const call = asObject(raw);
+        const fn = asObject(call?.function);
+        if (!fn || typeof fn.name !== 'string')
+            return [];
+        const providerMetadata = asObject(call?.providerMetadata);
+        return [
+            {
+                id: typeof call?.id === 'string' ? call.id : `work-plugin-${index}`,
+                ...(typeof call?.thoughtSignature === 'string'
+                    ? { thoughtSignature: call.thoughtSignature }
+                    : {}),
+                ...(providerMetadata ? { providerMetadata } : {}),
+                function: {
+                    name: fn.name,
+                    arguments: typeof fn.arguments === 'string'
+                        ? fn.arguments
+                        : asObject(fn.arguments) || {},
+                },
+            },
+        ];
+    });
+}
+function toAnthropicTools(tools) {
+    return tools.flatMap(tool => {
+        const fn = asObject(tool.function);
+        if (!fn || typeof fn.name !== 'string')
+            return [];
+        return [
+            {
+                name: fn.name,
+                description: fn.description,
+                input_schema: fn.parameters || {
+                    type: 'object',
+                    properties: {},
+                },
+            },
+        ];
+    });
+}
+function parseToolArguments(value) {
+    if (value && typeof value === 'object' && !Array.isArray(value)) {
+        return value;
+    }
+    if (typeof value === 'string') {
+        try {
+            return asObject(JSON.parse(value)) || {};
+        }
+        catch {
+            return {};
+        }
+    }
+    return {};
+}
+function contentText(value) {
+    if (typeof value === 'string')
+        return value;
+    if (!Array.isArray(value))
+        return '';
+    return value
+        .flatMap(item => {
+        const block = asObject(item);
+        return typeof block?.text === 'string' ? [block.text] : [];
+    })
+        .join('');
+}
+function providerErrorMessage(value) {
+    const payload = asObject(value);
+    const error = asObject(payload?.error);
+    if (typeof error?.message === 'string')
+        return error.message;
+    if (typeof payload?.message === 'string')
+        return payload.message;
+    return 'Request failed.';
+}
+function providerStreamErrorMessage(value) {
+    const payload = asObject(value);
+    if (!payload)
+        return undefined;
+    const error = asObject(payload.error);
+    const message = typeof error?.message === 'string'
+        ? error.message
+        : typeof payload.error === 'string'
+            ? payload.error
+            : typeof payload.message === 'string' &&
+                (payload.type === 'error' || payload.status === 'error')
+                ? payload.message
+                : undefined;
+    return message?.slice(0, 500);
+}
+function asObject(value) {
+    return value && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function isWorkPlugin(plugin) {
+    return plugin.type === 'completion' || plugin.type === 'chat';
+}
+function assertWorkPluginType(plugin) {
+    if (!isWorkPlugin(plugin)) {
+        throw new WorkModelProviderError(`Plugin "${plugin.name}" does not provide chat completions.`, 422, 'WORK_PLUGIN_TOOLS_UNSUPPORTED');
+    }
+}
+function assertOllamaProvider(provider) {
+    if (provider.providerType !== 'ollama' || provider.providerId) {
+        throw new WorkModelProviderError('Invalid Ollama provider selection.', 400, 'WORK_PROVIDER_INVALID');
+    }
+}
+export const workModelProviderService = new WorkModelProviderService();
+export default workModelProviderService;
+//# sourceMappingURL=workModelProviderService.js.map