libre-webui 0.15.0 → 0.16.0

package/backend/dist/services/workModelProviderService.js

@@ -15,11 +15,15 @@
  * limitations under the License.
  */
 import axios from 'axios';
+import { createHash } from 'crypto';
 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 { OPENAI_RESPONSES_OUTPUT_ITEMS_METADATA_KEY, OPENAI_RESPONSES_STATE_SCOPE_METADATA_KEY, createOpenAIResponsesStateScope, createPluginCredentialFingerprint, normalizeOpenAIResponsesResponse, toOpenAIResponsesInput, toOpenAIResponsesTools, } from '../utils/openAIResponsesAdapter.js';
+import { streamAnthropicResponse, streamOpenAICompatibleResponse, streamOpenAIResponsesResponse, } from '../utils/pluginStreamAdapter.js';
+import { applyModelEndpointTemplate, assertSafePluginEndpoint, buildPluginAuthHeaders, inferPluginApiMode, pluginRequiresApiKey, resolvePluginApiConfig, validatePluginModel, } from '../utils/pluginValidation.js';
 import ollamaService from './ollamaService.js';
 import pluginService from './pluginService.js';
+export const WORK_TOOL_ARGUMENTS_ERROR_METADATA_KEY = 'libreToolArgumentsError';
+export const WORK_TOOL_ARGUMENTS_ERROR_MESSAGE = 'The provider returned incomplete or invalid JSON for this tool call, likely because its output-token limit was reached. Retry with a smaller payload; split large write_file content into focused files.';
 export class WorkModelProviderError extends Error {
     constructor(message, status, code) {
         super(message);
@@ -67,6 +71,55 @@ export class WorkModelProviderService {
             throw new WorkModelProviderError(`Model "${cleaned}" does not advertise tool support.`, 422, 'WORK_MODEL_TOOLS_UNSUPPORTED');
         }
     }
+    getResponsesStateScope(model, provider, userId) {
+        if (provider.providerType !== 'plugin')
+            return undefined;
+        const providerId = provider.providerId?.trim();
+        if (!providerId)
+            return undefined;
+        const plugin = this.dependencies.plugins.getPlugin(providerId, userId);
+        if (!plugin || !plugin.active || !plugin.model_map.includes(model)) {
+            return undefined;
+        }
+        const variables = this.dependencies.plugins.getPluginVariables(plugin, userId);
+        const apiConfig = resolvePluginApiConfig(plugin, variables);
+        if (apiConfig.apiMode !== 'responses')
+            return undefined;
+        const endpoint = applyModelEndpointTemplate(apiConfig.endpoint, model);
+        const apiKey = this.dependencies.plugins.getApiKey(plugin, userId);
+        if (pluginRequiresApiKey(plugin) && !apiKey)
+            return undefined;
+        return createOpenAIResponsesStateScope(plugin.id, model, endpoint, createPluginCredentialFingerprint(apiKey));
+    }
+    getRoutingFingerprint(model, provider, userId) {
+        if (provider.providerType === 'ollama') {
+            assertOllamaProvider(provider);
+            return createHash('sha256')
+                .update(JSON.stringify({
+                version: 1,
+                providerType: 'ollama',
+                model,
+            }))
+                .digest('hex');
+        }
+        const plugin = this.requireExactPlugin(provider.providerId, model, userId);
+        const variables = this.dependencies.plugins.getPluginVariables(plugin, userId);
+        const apiConfig = resolvePluginApiConfig(plugin, variables);
+        const endpoint = applyModelEndpointTemplate(apiConfig.endpoint, model);
+        assertSafePluginEndpoint(endpoint, 'Work model endpoint');
+        const apiKey = this.dependencies.plugins.getApiKey(plugin, userId);
+        return createHash('sha256')
+            .update(JSON.stringify({
+            version: 2,
+            providerType: 'plugin',
+            providerId: plugin.id,
+            model,
+            apiMode: apiConfig.apiMode,
+            endpoint,
+            credentialFingerprint: createPluginCredentialFingerprint(apiKey),
+        }))
+            .digest('hex');
+    }
     async generateChatResponse(request, provider, userId, signal) {
         if (provider.providerType === 'ollama') {
             assertOllamaProvider(provider);
@@ -86,17 +139,18 @@ export class WorkModelProviderService {
     }
     hasConfiguredPlugin(userId) {
         return this.dependencies.plugins
-            .getActivePlugins()
+            .getActivePlugins(userId)
             .filter(isWorkPlugin)
             .some(plugin => plugin.model_map.length > 0 &&
-            Boolean(this.dependencies.plugins.getApiKey(plugin, userId)));
+            (!pluginRequiresApiKey(plugin) ||
+                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);
+        const plugin = this.dependencies.plugins.getPlugin(cleanedProviderId, userId);
         if (!plugin || !plugin.active) {
             throw new WorkModelProviderError(`Plugin "${cleanedProviderId}" is not active.`, 422, 'WORK_PLUGIN_UNAVAILABLE');
         }
@@ -104,30 +158,37 @@ export class WorkModelProviderService {
         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)) {
+        resolvePluginApiConfig(plugin, this.dependencies.plugins.getPluginVariables(plugin, userId));
+        if (pluginRequiresApiKey(plugin) &&
+            !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 variables = this.dependencies.plugins.getPluginVariables(plugin, userId);
+        const apiConfig = resolvePluginApiConfig(plugin, variables);
+        const endpoint = applyModelEndpointTemplate(apiConfig.endpoint, request.model);
+        assertSafePluginEndpoint(endpoint, 'Work model endpoint');
         const apiKey = this.dependencies.plugins.getApiKey(plugin, userId);
-        if (!apiKey) {
+        if (pluginRequiresApiKey(plugin) && !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 providerStateScope = apiConfig.apiMode === 'responses'
+            ? createOpenAIResponsesStateScope(plugin.id, request.model, endpoint, createPluginCredentialFingerprint(apiKey))
+            : undefined;
         const headers = buildPluginAuthHeaders(plugin, apiKey);
-        const { payload, extraHeaders } = buildPluginWorkPayload(plugin, request, variables);
+        const { payload, extraHeaders } = buildPluginWorkPayload(plugin, request, variables, apiConfig.apiMode, providerStateScope);
         Object.assign(headers, extraHeaders);
         try {
             const response = await this.dependencies.post(endpoint, payload, {
                 headers,
                 signal,
                 timeout: 300000,
+                maxRedirects: 0,
             });
-            return normalizePluginWorkResponse(plugin, response.data, request.model);
+            return normalizePluginWorkResponse(plugin, response.data, request.model, apiConfig.apiMode, providerStateScope);
         }
         catch (error) {
             if (signal?.aborted)
@@ -210,18 +271,23 @@ export class WorkModelProviderService {
     }
     async generatePluginStream(plugin, request, userId, observer, signal) {
         validatePluginModel(request.model);
+        const variables = this.dependencies.plugins.getPluginVariables(plugin, userId);
+        const apiConfig = resolvePluginApiConfig(plugin, variables);
+        let endpoint = applyModelEndpointTemplate(apiConfig.endpoint, request.model);
+        assertSafePluginEndpoint(endpoint, 'Work model endpoint');
         const apiKey = this.dependencies.plugins.getApiKey(plugin, userId);
-        if (!apiKey) {
+        if (pluginRequiresApiKey(plugin) && !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);
+        const providerStateScope = apiConfig.apiMode === 'responses'
+            ? createOpenAIResponsesStateScope(plugin.id, request.model, endpoint, createPluginCredentialFingerprint(apiKey))
+            : undefined;
         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);
+        const { payload, extraHeaders } = buildPluginWorkPayload(plugin, { ...request, stream: true }, variables, apiConfig.apiMode, providerStateScope);
         Object.assign(headers, extraHeaders);
         const timeoutSignal = AbortSignal.timeout(300000);
         const requestSignal = signal
@@ -233,13 +299,14 @@ export class WorkModelProviderService {
                 headers,
                 body: JSON.stringify(payload),
                 signal: requestSignal,
+                redirect: 'error',
             });
             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);
+                const normalized = normalizePluginWorkResponse(plugin, data, request.model, apiConfig.apiMode, providerStateScope);
                 if (normalized.message.thinking) {
                     observer.onReasoning?.(normalized.message.thinking);
                 }
@@ -252,7 +319,9 @@ export class WorkModelProviderService {
                 ? streamAnthropicResponse(response)
                 : plugin.id === 'gemini'
                     ? streamGeminiWorkResponse(response)
-                    : streamOpenAICompatibleResponse(response);
+                    : apiConfig.apiMode === 'responses'
+                        ? streamOpenAIResponsesResponse(response, providerStateScope)
+                        : streamOpenAICompatibleResponse(response);
             return await collectPluginWorkStream(chunks, request.model, observer);
         }
         catch (error) {
@@ -267,7 +336,7 @@ export class WorkModelProviderService {
         }
     }
 }
-export function buildPluginWorkPayload(plugin, request, variables = {}) {
+export function buildPluginWorkPayload(plugin, request, variables = {}, apiMode = resolvePluginApiConfig(plugin, variables).apiMode, providerStateScope) {
     const options = (request.options || {});
     const params = resolvePluginChatParameters(options, variables);
     if (plugin.id === 'anthropic') {
@@ -282,6 +351,24 @@ export function buildPluginWorkPayload(plugin, request, variables = {}) {
             extraHeaders: {},
         };
     }
+    if (apiMode === 'responses') {
+        const sampling = getOpenAICompatibleSamplingParameters(plugin, params);
+        const tools = toOpenAIResponsesTools(request.tools || []);
+        return {
+            payload: {
+                model: request.model,
+                input: toOpenAIResponsesWorkInput(request.messages, providerStateScope),
+                ...(tools.length ? { tools, tool_choice: 'auto' } : {}),
+                temperature: sampling.temperature,
+                top_p: sampling.top_p,
+                max_output_tokens: params.maxTokens,
+                stream: Boolean(request.stream),
+                store: false,
+                include: ['reasoning.encrypted_content'],
+            },
+            extraHeaders: {},
+        };
+    }
     return {
         payload: {
             model: request.model,
@@ -295,13 +382,17 @@ export function buildPluginWorkPayload(plugin, request, variables = {}) {
         extraHeaders: {},
     };
 }
-export function normalizePluginWorkResponse(plugin, response, model) {
+export function normalizePluginWorkResponse(plugin, response, model, apiMode = plugin.api_mode ||
+    inferPluginApiMode(plugin.endpoint), providerStateScope) {
     if (plugin.id === 'anthropic') {
         return normalizeAnthropicWorkResponse(response, model);
     }
     if (plugin.id === 'gemini') {
         return normalizeGeminiWorkResponse(response, model);
     }
+    if (apiMode === 'responses') {
+        return normalizeOpenAIResponsesWorkResponse(response, model, providerStateScope);
+    }
     return normalizeOpenAIWorkResponse(response, model);
 }
 export function toOpenAIWorkMessages(messages) {
@@ -342,12 +433,94 @@ export function toOpenAIWorkMessages(messages) {
                 role: 'tool',
                 content: message.content,
                 name: message.tool_name,
-                tool_call_id: matching?.id || `work-tool-${messageIndex}`,
+                tool_call_id: message.tool_call_id || matching?.id || `work-tool-${messageIndex}`,
             };
         }
         return { role: message.role, content: message.content };
     });
 }
+export function toOpenAIResponsesWorkInput(messages, expectedStateScope) {
+    const input = [];
+    let pendingCalls = [];
+    for (const [messageIndex, message] of messages.entries()) {
+        if (message.role === 'assistant') {
+            const toolCalls = normalizeOutboundToolCalls(message.tool_calls);
+            const responseOutputItems = Array.isArray(message.providerMetadata?.[OPENAI_RESPONSES_OUTPUT_ITEMS_METADATA_KEY])
+                ? message.providerMetadata[OPENAI_RESPONSES_OUTPUT_ITEMS_METADATA_KEY]
+                : [];
+            const replayableOutputItems = expectedStateScope === undefined ||
+                message.providerMetadata?.[OPENAI_RESPONSES_STATE_SCOPE_METADATA_KEY] === expectedStateScope
+                ? responseOutputItems.flatMap(rawItem => {
+                    const item = asObject(rawItem);
+                    return item ? [{ ...item }] : [];
+                })
+                : [];
+            if (replayableOutputItems.length > 0) {
+                pendingCalls = replayableOutputItems.flatMap(item => {
+                    if (item.type !== 'function_call')
+                        return [];
+                    const id = typeof item.call_id === 'string'
+                        ? item.call_id
+                        : typeof item.id === 'string'
+                            ? item.id
+                            : undefined;
+                    return id && typeof item.name === 'string'
+                        ? [{ id, name: item.name }]
+                        : [];
+                });
+                input.push(...replayableOutputItems);
+                continue;
+            }
+            pendingCalls = toolCalls.map(call => ({
+                id: String(call.id),
+                name: String(call.function.name),
+            }));
+            // Compatibility for Work messages created before full Responses output
+            // items were retained.
+            for (const call of toolCalls) {
+                const metadata = asObject(call.providerMetadata);
+                const reasoningItems = Array.isArray(metadata?.openAIResponsesReasoningItems)
+                    ? metadata.openAIResponsesReasoningItems
+                    : [];
+                for (const rawItem of reasoningItems) {
+                    const item = asObject(rawItem);
+                    if (item?.type === 'reasoning') {
+                        input.push({ ...item });
+                    }
+                }
+            }
+            input.push(...toOpenAIResponsesInput([
+                {
+                    role: 'assistant',
+                    content: message.content,
+                    tool_calls: toolCalls,
+                },
+            ]));
+            continue;
+        }
+        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;
+            input.push(...toOpenAIResponsesInput([
+                {
+                    role: 'tool',
+                    content: message.content,
+                    name: message.tool_name,
+                    tool_call_id: message.tool_call_id ||
+                        matching?.id ||
+                        `work-tool-${messageIndex}`,
+                },
+            ]));
+            continue;
+        }
+        input.push(...toOpenAIResponsesInput([
+            { role: message.role, content: message.content },
+        ]));
+    }
+    return input;
+}
 function buildAnthropicWorkPayload(model, messages, tools, maxTokens, stream = false) {
     const system = messages
         .filter(message => message.role === 'system')
@@ -523,6 +696,45 @@ function normalizeOpenAIWorkResponse(response, model) {
         ? message.reasoning_content
         : '');
 }
+function normalizeOpenAIResponsesWorkResponse(response, model, providerStateScope) {
+    const normalized = normalizeOpenAIResponsesResponse(response, model, providerStateScope);
+    const choice = normalized.choices[0];
+    const message = asObject(choice?.message);
+    if (!message) {
+        throw new WorkModelProviderError('Plugin returned an invalid Responses API response.', 502, 'WORK_PLUGIN_INVALID_RESPONSE');
+    }
+    const reasoning = typeof message.reasoning_content === 'string'
+        ? message.reasoning_content
+        : '';
+    const toolCalls = normalizeInboundToolCalls(message.tool_calls);
+    if (reasoning && toolCalls[0]) {
+        toolCalls[0].providerMetadata = {
+            ...asObject(toolCalls[0].providerMetadata),
+            openAIReasoningContent: reasoning,
+        };
+    }
+    const incompleteReason = response.status === 'incomplete'
+        ? typeof asObject(response.incomplete_details)?.reason === 'string'
+            ? String(asObject(response.incomplete_details)?.reason)
+            : 'unknown'
+        : undefined;
+    return {
+        ...workResponse(model, contentText(message.content), toolCalls, reasoning, {
+            ...(normalized.providerMetadata
+                ? { providerMetadata: normalized.providerMetadata }
+                : {}),
+            ...(incompleteReason
+                ? { doneReason: `incomplete:${incompleteReason}` }
+                : {}),
+        }),
+        ...(normalized.usage
+            ? {
+                prompt_eval_count: normalized.usage.prompt_tokens,
+                eval_count: normalized.usage.completion_tokens,
+            }
+            : {}),
+    };
+}
 function normalizeAnthropicWorkResponse(response, model) {
     const blocks = Array.isArray(response.content) ? response.content : [];
     const text = [];
@@ -590,7 +802,7 @@ function normalizeGeminiWorkResponse(response, model) {
     }
     return workResponse(model, text.join(''), calls, reasoning.join(''));
 }
-function workResponse(model, content, toolCalls, reasoning = '') {
+function workResponse(model, content, toolCalls, reasoning = '', options = {}) {
     return {
         model,
         created_at: new Date().toISOString(),
@@ -599,14 +811,20 @@ function workResponse(model, content, toolCalls, reasoning = '') {
             content,
             ...(reasoning ? { thinking: reasoning } : {}),
             tool_calls: toolCalls,
+            ...(options.providerMetadata
+                ? { providerMetadata: options.providerMetadata }
+                : {}),
         },
         done: true,
+        ...(options.doneReason ? { done_reason: options.doneReason } : {}),
     };
 }
 async function collectPluginWorkStream(chunks, model, observer) {
     let content = '';
     let reasoning = '';
     let usage = {};
+    let doneReason;
+    let providerMetadata;
     const toolCalls = [];
     for await (const chunk of chunks) {
         if (chunk.type === 'content') {
@@ -625,7 +843,15 @@ async function collectPluginWorkStream(chunks, model, observer) {
             continue;
         }
         if (chunk.type === 'tool_call') {
-            const metadata = chunk.toolCall.providerMetadata;
+            const parsedArguments = parseToolArgumentsWithStatus(chunk.toolCall.arguments);
+            const metadata = {
+                ...chunk.toolCall.providerMetadata,
+                ...(parsedArguments.error
+                    ? {
+                        [WORK_TOOL_ARGUMENTS_ERROR_METADATA_KEY]: parsedArguments.error,
+                    }
+                    : {}),
+            };
             toolCalls.push({
                 id: chunk.toolCall.id || `work-plugin-${toolCalls.length}`,
                 ...(typeof metadata?.geminiThoughtSignature === 'string'
@@ -639,9 +865,16 @@ async function collectPluginWorkStream(chunks, model, observer) {
                     : {}),
                 function: {
                     name: chunk.toolCall.name,
-                    arguments: parseToolArguments(chunk.toolCall.arguments),
+                    arguments: parsedArguments.arguments,
                 },
             });
+            continue;
+        }
+        if (chunk.type === 'done') {
+            doneReason = chunk.doneReason;
+            providerMetadata = chunk.providerMetadata
+                ? { ...providerMetadata, ...chunk.providerMetadata }
+                : providerMetadata;
         }
     }
     if (reasoning && toolCalls[0]) {
@@ -655,7 +888,10 @@ async function collectPluginWorkStream(chunks, model, observer) {
         }
     }
     return {
-        ...workResponse(model, content, toolCalls, reasoning),
+        ...workResponse(model, content, toolCalls, reasoning, {
+            ...(providerMetadata ? { providerMetadata } : {}),
+            ...(doneReason ? { doneReason } : {}),
+        }),
         prompt_eval_count: usage.promptTokens,
         eval_count: usage.completionTokens,
     };
@@ -808,19 +1044,29 @@ function normalizeInboundToolCalls(value) {
         const fn = asObject(call?.function);
         if (!fn || typeof fn.name !== 'string')
             return [];
-        const providerMetadata = asObject(call?.providerMetadata);
+        const parsedArguments = parseToolArgumentsWithStatus(fn.arguments);
+        const providerMetadata = {
+            ...asObject(call?.providerMetadata),
+            ...(parsedArguments.error
+                ? {
+                    [WORK_TOOL_ARGUMENTS_ERROR_METADATA_KEY]: parsedArguments.error,
+                }
+                : {}),
+        };
         return [
             {
                 id: typeof call?.id === 'string' ? call.id : `work-plugin-${index}`,
                 ...(typeof call?.thoughtSignature === 'string'
                     ? { thoughtSignature: call.thoughtSignature }
                     : {}),
-                ...(providerMetadata ? { providerMetadata } : {}),
+                ...(Object.keys(providerMetadata).length > 0
+                    ? { providerMetadata }
+                    : {}),
                 function: {
                     name: fn.name,
-                    arguments: typeof fn.arguments === 'string'
+                    arguments: typeof fn.arguments === 'string' && !parsedArguments.error
                         ? fn.arguments
-                        : asObject(fn.arguments) || {},
+                        : parsedArguments.arguments,
                 },
             },
         ];
@@ -844,18 +1090,32 @@ function toAnthropicTools(tools) {
     });
 }
 function parseToolArguments(value) {
+    return parseToolArgumentsWithStatus(value).arguments;
+}
+function parseToolArgumentsWithStatus(value) {
     if (value && typeof value === 'object' && !Array.isArray(value)) {
-        return value;
+        return { arguments: value };
     }
     if (typeof value === 'string') {
+        if (!value.trim())
+            return { arguments: {} };
         try {
-            return asObject(JSON.parse(value)) || {};
+            const parsed = asObject(JSON.parse(value));
+            return parsed
+                ? { arguments: parsed }
+                : {
+                    arguments: {},
+                    error: WORK_TOOL_ARGUMENTS_ERROR_MESSAGE,
+                };
         }
         catch {
-            return {};
+            return {
+                arguments: {},
+                error: WORK_TOOL_ARGUMENTS_ERROR_MESSAGE,
+            };
         }
     }
-    return {};
+    return { arguments: {} };
 }
 function contentText(value) {
     if (typeof value === 'string')