libre-webui 0.15.0 → 0.16.0

package/backend/dist/services/workAgentService.js

@@ -14,13 +14,15 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import workModelProviderService from './workModelProviderService.js';
+import workModelProviderService, { WORK_TOOL_ARGUMENTS_ERROR_METADATA_KEY, WORK_TOOL_ARGUMENTS_ERROR_MESSAGE, } from './workModelProviderService.js';
 import workEventService from './workEventService.js';
-import { buildWorkAgentSystemPrompt, buildWorkBudgetExhaustionPrompt, WORK_AGENT_SKILLS, workToolCallBudget, } from './workAgentGuidance.js';
+import { buildWorkAgentSystemPrompt, buildWorkBudgetExhaustionPrompt, WORK_AGENT_SKILLS, WORK_WRITE_FILE_RECOMMENDED_CHARS, workToolCallBudget, } from './workAgentGuidance.js';
 import workRuntimeService from './workRuntimeService.js';
-import workTaskService, { WorkConflictError, WorkNotFoundError, } from './workTaskService.js';
+import workTaskService, { WORK_MESSAGE_METADATA_MAX_BYTES, WorkConflictError, WorkNotFoundError, } from './workTaskService.js';
 import { createLogger } from '../utils/logger.js';
+import { boundedOpenAIResponsesOutputItems, OPENAI_RESPONSES_OUTPUT_ITEMS_METADATA_KEY, OPENAI_RESPONSES_STATE_DROPPED_METADATA_KEY, OPENAI_RESPONSES_STATE_SCOPE_METADATA_KEY, } from '../utils/openAIResponsesAdapter.js';
 const logger = createLogger('services:work-agent');
+export const WORK_PROVIDER_STATE_METADATA_KEY = 'workProviderState';
 export const WORK_TOOL_SCHEMAS = [
     functionTool('list_files', 'List direct children of a workspace directory.', {
         path: stringProperty('Relative directory path. Defaults to workspace root.'),
@@ -28,7 +30,7 @@ export const WORK_TOOL_SCHEMAS = [
     functionTool('read_file', 'Read a UTF-8 text file from the persistent workspace.', { path: stringProperty('Relative file path.') }, ['path']),
     functionTool('write_file', 'Create or replace a UTF-8 text file in the persistent workspace.', {
         path: stringProperty('Relative file path.'),
-        content: stringProperty('Complete file content.'),
+        content: stringProperty(`Complete file content. Keep one write below ${WORK_WRITE_FILE_RECOMMENDED_CHARS.toLocaleString('en-US')} characters and split larger implementations into focused files.`),
     }, ['path', 'content']),
     functionTool('search_files', 'Search text recursively in workspace files.', {
         query: stringProperty('Literal text to find.'),
@@ -245,7 +247,13 @@ export class WorkAgentService {
             workTaskService.updateTaskStatus(taskId, 'running');
             const roundLimit = workRuntimeService.limits.maxRounds;
             const toolCallLimit = workToolCallBudget(roundLimit);
-            const messages = this.contextMessages(task, roundLimit);
+            const providerSelection = {
+                providerType: run.providerType,
+                providerId: run.providerId,
+            };
+            const providerRoutingFingerprint = workModelProviderService.getRoutingFingerprint(run.model, providerSelection, userId);
+            const providerStateScope = workModelProviderService.getResponsesStateScope(run.model, providerSelection, userId);
+            const messages = this.contextMessages(task, roundLimit, providerStateScope, run);
             let totalToolCalls = 0;
             let accumulatedInputTokens = 0;
             let accumulatedOutputTokens = 0;
@@ -267,18 +275,13 @@ export class WorkAgentService {
                 const roundStartedAt = Date.now();
                 let response;
                 try {
+                    this.assertStableProviderRouting(run, userId, providerRoutingFingerprint);
                     response = await workModelProviderService.generateChatStreamResponse({
                         model: run.model,
                         messages,
                         tools: WORK_TOOL_SCHEMAS,
-                        options: run.providerType === 'plugin'
-                            ? { num_predict: 4096 }
-                            : undefined,
                         stream: true,
-                    }, {
-                        providerType: run.providerType,
-                        providerId: run.providerId,
-                    }, userId, {
+                    }, providerSelection, userId, {
                         onContent: delta => contentStream.push(delta),
                         onReasoning: delta => reasoningStream.push(delta),
                         onUsage: usage => {
@@ -303,9 +306,30 @@ export class WorkAgentService {
                     streamedReasoningTotal = reasoningStream.currentTotal;
                 }
                 this.throwIfCancelled(runId, controller);
+                assertCompleteProviderResponse(response);
                 accumulatedInputTokens += roundInputTokens;
                 accumulatedOutputTokens += roundOutputTokens;
                 const toolCalls = normalizeToolCalls(response);
+                const boundedProviderOutput = boundedOpenAIResponsesOutputItems(response.message.providerMetadata?.[OPENAI_RESPONSES_OUTPUT_ITEMS_METADATA_KEY]);
+                const providerMetadata = response.message.providerMetadata;
+                const hasResponsesStateMetadata = providerMetadata?.[OPENAI_RESPONSES_STATE_DROPPED_METADATA_KEY] ===
+                    true ||
+                    providerMetadata?.[OPENAI_RESPONSES_OUTPUT_ITEMS_METADATA_KEY] !==
+                        undefined ||
+                    providerMetadata?.[OPENAI_RESPONSES_STATE_SCOPE_METADATA_KEY] !==
+                        undefined;
+                const providerStateMetadata = toPersistedWorkProviderState(run, providerMetadata);
+                if (toolCalls.length > 0 &&
+                    (providerStateScope || hasResponsesStateMetadata) &&
+                    (providerMetadata?.[OPENAI_RESPONSES_STATE_DROPPED_METADATA_KEY] ===
+                        true ||
+                        !providerStateScope ||
+                        providerMetadata?.[OPENAI_RESPONSES_STATE_SCOPE_METADATA_KEY] !==
+                            providerStateScope ||
+                        !boundedProviderOutput.items ||
+                        !providerStateMetadata)) {
+                    throw new WorkAgentHttpError('The provider returned tool calls without bounded durable replay state.', 502, 'WORK_PROVIDER_INVALID_TOOL_CALLS');
+                }
                 totalToolCalls += toolCalls.length;
                 if (totalToolCalls > toolCallLimit) {
                     budgetReason = 'tool-call';
@@ -319,7 +343,7 @@ export class WorkAgentService {
                 if (toolCalls.length === 0) {
                     const finalContent = assistantContent ||
                         'The model completed without returning a text response.';
-                    workTaskService.addMessage(taskId, runId, 'assistant', 'message', finalContent);
+                    workTaskService.addMessage(taskId, runId, 'assistant', 'message', finalContent, providerStateMetadata);
                     // Keep completion hidden until the disposable container has either
                     // stopped or been retained for a verified live preview. Consumers
                     // can then refresh files immediately without racing teardown.
@@ -335,13 +359,26 @@ export class WorkAgentService {
                     });
                     return;
                 }
+                const toolValidationErrors = new Map();
+                for (const call of toolCalls) {
+                    const validationError = validateToolCallArguments(call);
+                    if (validationError)
+                        toolValidationErrors.set(call, validationError);
+                }
+                const hasInvalidToolArguments = toolValidationErrors.size > 0;
                 messages.push({
                     role: 'assistant',
                     content: assistantContent,
                     tool_calls: toolCalls,
+                    ...(response.message.providerMetadata
+                        ? { providerMetadata: response.message.providerMetadata }
+                        : {}),
                 });
                 if (assistantContent) {
-                    workTaskService.addMessage(taskId, runId, 'assistant', 'message', assistantContent);
+                    workTaskService.addMessage(taskId, runId, 'assistant', 'message', assistantContent, providerStateMetadata);
+                }
+                else if (providerStateMetadata) {
+                    workTaskService.addMessage(taskId, runId, 'assistant', 'provider_state', '', providerStateMetadata);
                 }
                 for (const call of toolCalls) {
                     this.throwIfCancelled(runId, controller);
@@ -368,6 +405,13 @@ export class WorkAgentService {
                         toolName: call.function.name,
                     };
                     try {
+                        const validationError = toolValidationErrors.get(call);
+                        if (validationError) {
+                            throw new WorkAgentHttpError(validationError, 400, 'WORK_INVALID_TOOL_ARGUMENTS');
+                        }
+                        if (hasInvalidToolArguments) {
+                            throw new WorkAgentHttpError('This tool call was not executed because another call in the same model response had incomplete or invalid arguments. Retry the batch with smaller payloads.', 400, 'WORK_TOOL_BATCH_NOT_EXECUTED');
+                        }
                         const result = await this.executeTool(task, call);
                         toolOutput = result.content;
                         toolMetadata = { ...toolMetadata, ...result.metadata };
@@ -397,6 +441,7 @@ export class WorkAgentService {
                         role: 'tool',
                         content: toolOutput,
                         tool_name: call.function.name,
+                        tool_call_id: call.id,
                     });
                 }
             }
@@ -415,6 +460,7 @@ export class WorkAgentService {
             let handoffResponse;
             try {
                 try {
+                    this.assertStableProviderRouting(run, userId, providerRoutingFingerprint);
                     handoffResponse =
                         await workModelProviderService.generateChatStreamResponse({
                             model: run.model,
@@ -430,10 +476,7 @@ export class WorkAgentService {
                                 ? { num_predict: 2048 }
                                 : undefined,
                             stream: true,
-                        }, {
-                            providerType: run.providerType,
-                            providerId: run.providerId,
-                        }, userId, {
+                        }, providerSelection, userId, {
                             onContent: delta => handoffContentStream.push(delta),
                             onReasoning: delta => handoffReasoningStream.push(delta),
                             onUsage: usage => {
@@ -451,6 +494,7 @@ export class WorkAgentService {
                                 });
                             },
                         }, controller.signal);
+                    assertCompleteProviderResponse(handoffResponse);
                 }
                 catch (error) {
                     if (controller.signal.aborted)
@@ -479,7 +523,12 @@ export class WorkAgentService {
             }
             const handoffContent = boundUtf8(handoffResponse.message?.content?.trim() ||
                 `The run reached its ${budgetReason} budget. Start a follow-up run to continue in the same workspace.`, 100000);
-            workTaskService.addMessage(taskId, runId, 'assistant', 'message', handoffContent, { budgetHandoff: true, budgetReason });
+            const handoffProviderStateMetadata = toPersistedWorkProviderState(run, handoffResponse.message.providerMetadata);
+            workTaskService.addMessage(taskId, runId, 'assistant', 'message', handoffContent, {
+                budgetHandoff: true,
+                budgetReason,
+                ...handoffProviderStateMetadata,
+            });
             await settleExecutionContainer();
             this.throwIfCancelled(runId, controller);
             if (!isActiveRunStatus(workTaskService.getRun(runId)?.status))
@@ -589,13 +638,17 @@ export class WorkAgentService {
             logger.error(`Could not stop idle Work container ${task.containerName}:`, error);
         }
     }
-    contextMessages(task, roundLimit) {
-        const persisted = workTaskService
-            .getRecentConversationMessages(task.id, 30)
-            .map(message => ({
-            role: message.role,
-            content: message.content,
-        }));
+    assertStableProviderRouting(run, userId, expectedFingerprint) {
+        const currentFingerprint = workModelProviderService.getRoutingFingerprint(run.model, {
+            providerType: run.providerType,
+            providerId: run.providerId,
+        }, userId);
+        if (currentFingerprint !== expectedFingerprint) {
+            throw new WorkAgentHttpError('The provider routing changed while this Work run was active. Start a new run with the updated provider configuration.', 409, 'WORK_PROVIDER_ROUTING_CHANGED');
+        }
+    }
+    contextMessages(task, roundLimit, providerStateScope, provider = task) {
+        const persisted = restorePersistedWorkContext(workTaskService.getRecentModelContextMessages(task.id, 30), provider, providerStateScope);
         return [
             {
                 role: 'system',
@@ -717,55 +770,298 @@ export class WorkAgentHttpError extends Error {
         this.code = code;
     }
 }
+function toPersistedWorkProviderState(run, providerMetadata) {
+    const boundedOutput = boundedOpenAIResponsesOutputItems(providerMetadata?.[OPENAI_RESPONSES_OUTPUT_ITEMS_METADATA_KEY]);
+    if (providerMetadata?.[OPENAI_RESPONSES_STATE_DROPPED_METADATA_KEY] === true ||
+        !boundedOutput.items ||
+        typeof providerMetadata?.[OPENAI_RESPONSES_STATE_SCOPE_METADATA_KEY] !==
+            'string') {
+        return undefined;
+    }
+    const persisted = {
+        [WORK_PROVIDER_STATE_METADATA_KEY]: {
+            providerType: run.providerType,
+            ...(run.providerId ? { providerId: run.providerId } : {}),
+            model: run.model,
+            providerMetadata: {
+                ...providerMetadata,
+                [OPENAI_RESPONSES_OUTPUT_ITEMS_METADATA_KEY]: boundedOutput.items,
+            },
+        },
+    };
+    try {
+        return Buffer.byteLength(JSON.stringify(persisted), 'utf8') <=
+            WORK_MESSAGE_METADATA_MAX_BYTES
+            ? persisted
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function restorePersistedWorkContext(messages, provider, expectedStateScope) {
+    const restored = [];
+    let pendingGroup;
+    const flushPendingGroup = () => {
+        if (!pendingGroup)
+            return;
+        if (pendingGroup.invalid) {
+            if (pendingGroup.fallback)
+                restored.push(pendingGroup.fallback);
+            pendingGroup = undefined;
+            return;
+        }
+        restored.push(pendingGroup.assistant, ...pendingGroup.results);
+        for (const call of pendingGroup.calls) {
+            if (pendingGroup.resultIds.has(call.id))
+                continue;
+            restored.push({
+                role: 'tool',
+                content: 'Tool execution was interrupted; outcome unknown. Inspect the workspace before retrying.',
+                tool_name: call.name,
+                tool_call_id: call.id,
+            });
+        }
+        pendingGroup = undefined;
+    };
+    for (const message of messages) {
+        if (message.kind === 'provider_state' ||
+            (message.role === 'assistant' && message.kind === 'message')) {
+            flushPendingGroup();
+            const providerMetadata = matchingWorkProviderMetadata(message, provider, expectedStateScope);
+            const responseCalls = providerMetadata
+                ? responseFunctionCalls(providerMetadata)
+                : [];
+            const rawFunctionCallCount = Array.isArray(providerMetadata?.[OPENAI_RESPONSES_OUTPUT_ITEMS_METADATA_KEY])
+                ? providerMetadata[OPENAI_RESPONSES_OUTPUT_ITEMS_METADATA_KEY].filter(item => objectValue(item)?.type === 'function_call').length
+                : 0;
+            const expectedCallIds = new Set(responseCalls.map(call => call.id));
+            if (message.kind === 'provider_state' && !providerMetadata) {
+                continue;
+            }
+            if (message.kind !== 'message' && message.kind !== 'provider_state') {
+                continue;
+            }
+            if (expectedCallIds.size !== responseCalls.length ||
+                rawFunctionCallCount !== responseCalls.length) {
+                if (message.kind === 'message') {
+                    restored.push({ role: 'assistant', content: message.content });
+                }
+                continue;
+            }
+            const assistant = {
+                role: 'assistant',
+                content: message.content,
+                ...(responseCalls.length > 0
+                    ? {
+                        tool_calls: responseCalls.map(call => ({
+                            id: call.id,
+                            type: 'function',
+                            function: {
+                                name: call.name,
+                                arguments: call.arguments,
+                            },
+                        })),
+                    }
+                    : {}),
+                ...(providerMetadata ? { providerMetadata } : {}),
+            };
+            if (responseCalls.length === 0) {
+                restored.push(assistant);
+                continue;
+            }
+            pendingGroup = {
+                assistant,
+                ...(message.kind === 'message'
+                    ? {
+                        fallback: {
+                            role: 'assistant',
+                            content: message.content,
+                        },
+                    }
+                    : {}),
+                calls: responseCalls,
+                expectedCallIds,
+                results: [],
+                resultIds: new Set(),
+                invalid: false,
+            };
+            continue;
+        }
+        if (message.role === 'user' && message.kind === 'message') {
+            flushPendingGroup();
+            restored.push({ role: 'user', content: message.content });
+            continue;
+        }
+        if (message.role !== 'tool' || message.kind !== 'tool_result') {
+            continue;
+        }
+        const toolCallId = typeof message.metadata?.toolCallId === 'string'
+            ? message.metadata.toolCallId
+            : undefined;
+        if (!toolCallId || !pendingGroup)
+            continue;
+        if (!pendingGroup.expectedCallIds.has(toolCallId) ||
+            pendingGroup.resultIds.has(toolCallId)) {
+            pendingGroup.invalid = true;
+            continue;
+        }
+        const matchingCall = pendingGroup.calls.find(call => call.id === toolCallId);
+        if (!matchingCall) {
+            pendingGroup.invalid = true;
+            continue;
+        }
+        const persistedName = typeof message.metadata?.name === 'string'
+            ? message.metadata.name
+            : undefined;
+        pendingGroup.results.push({
+            role: 'tool',
+            content: message.content,
+            tool_name: persistedName || matchingCall.name,
+            tool_call_id: toolCallId,
+        });
+        pendingGroup.resultIds.add(toolCallId);
+    }
+    flushPendingGroup();
+    return restored;
+}
+function matchingWorkProviderMetadata(message, provider, expectedStateScope) {
+    const state = objectValue(message.metadata?.[WORK_PROVIDER_STATE_METADATA_KEY]);
+    const providerMetadata = objectValue(state?.providerMetadata);
+    const boundedOutput = boundedOpenAIResponsesOutputItems(providerMetadata?.[OPENAI_RESPONSES_OUTPUT_ITEMS_METADATA_KEY]);
+    if (state?.providerType !== provider.providerType ||
+        (state.providerId || undefined) !== (provider.providerId || undefined) ||
+        state.model !== provider.model ||
+        !expectedStateScope ||
+        providerMetadata?.[OPENAI_RESPONSES_STATE_SCOPE_METADATA_KEY] !==
+            expectedStateScope ||
+        !boundedOutput.items) {
+        return undefined;
+    }
+    return {
+        ...providerMetadata,
+        [OPENAI_RESPONSES_OUTPUT_ITEMS_METADATA_KEY]: boundedOutput.items,
+    };
+}
+function responseFunctionCalls(providerMetadata) {
+    const outputItems = providerMetadata[OPENAI_RESPONSES_OUTPUT_ITEMS_METADATA_KEY];
+    if (!Array.isArray(outputItems))
+        return [];
+    return outputItems.flatMap(itemValue => {
+        const item = objectValue(itemValue);
+        if (item?.type !== 'function_call' ||
+            typeof item.name !== 'string' ||
+            item.name.length === 0 ||
+            typeof item.call_id !== 'string' ||
+            item.call_id.length === 0) {
+            return [];
+        }
+        return [
+            {
+                id: item.call_id,
+                name: item.name,
+                arguments: item.arguments ?? '',
+            },
+        ];
+    });
+}
+function objectValue(value) {
+    return value && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function assertCompleteProviderResponse(response) {
+    if (!response.done_reason?.startsWith('incomplete:'))
+        return;
+    const reason = response.done_reason.slice('incomplete:'.length) || 'unknown';
+    throw new WorkAgentHttpError(`The provider returned an incomplete response (${reason}). Retry with a larger output-token limit or a smaller request.`, 502, 'WORK_PROVIDER_INCOMPLETE_RESPONSE');
+}
 export function normalizeToolCalls(response) {
     const raw = response.message?.tool_calls;
     if (!Array.isArray(raw))
         return [];
-    return raw
-        .flatMap((value, index) => {
-        if (!value || typeof value !== 'object')
-            return [];
+    const responsesMetadata = response.message?.providerMetadata;
+    const isResponsesCallBatch = typeof responsesMetadata?.[OPENAI_RESPONSES_STATE_SCOPE_METADATA_KEY] ===
+        'string' ||
+        responsesMetadata?.[OPENAI_RESPONSES_STATE_DROPPED_METADATA_KEY] === true ||
+        Array.isArray(responsesMetadata?.[OPENAI_RESPONSES_OUTPUT_ITEMS_METADATA_KEY]);
+    const calls = [];
+    for (const [index, value] of raw.entries()) {
+        if (!value || typeof value !== 'object') {
+            if (isResponsesCallBatch) {
+                throw new WorkAgentHttpError('The provider returned a malformed tool call.', 502, 'WORK_PROVIDER_INVALID_TOOL_CALLS');
+            }
+            continue;
+        }
         const record = value;
         const fn = record.function && typeof record.function === 'object'
             ? record.function
             : undefined;
-        if (!fn || typeof fn.name !== 'string')
-            return [];
+        if (!fn || typeof fn.name !== 'string' || !fn.name) {
+            if (isResponsesCallBatch) {
+                throw new WorkAgentHttpError('The provider returned a tool call without a function name.', 502, 'WORK_PROVIDER_INVALID_TOOL_CALLS');
+            }
+            continue;
+        }
         let args = {};
+        let argumentError;
         if (fn.arguments && typeof fn.arguments === 'object') {
             args = fn.arguments;
         }
         else if (typeof fn.arguments === 'string') {
             try {
                 const parsed = JSON.parse(fn.arguments);
-                if (parsed && typeof parsed === 'object') {
+                if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
                     args = parsed;
                 }
+                else if (fn.arguments.trim()) {
+                    argumentError = WORK_TOOL_ARGUMENTS_ERROR_MESSAGE;
+                }
             }
             catch {
                 args = {};
+                if (fn.arguments.trim()) {
+                    argumentError = WORK_TOOL_ARGUMENTS_ERROR_MESSAGE;
+                }
             }
         }
-        return [
-            {
-                id: typeof record.id === 'string'
-                    ? record.id
-                    : `tool-${Date.now()}-${index}`,
-                ...(typeof record.thoughtSignature === 'string'
-                    ? { thoughtSignature: record.thoughtSignature }
-                    : {}),
-                ...(record.providerMetadata &&
-                    typeof record.providerMetadata === 'object' &&
-                    !Array.isArray(record.providerMetadata)
-                    ? {
-                        providerMetadata: record.providerMetadata,
-                    }
-                    : {}),
-                function: { name: fn.name, arguments: args },
-            },
-        ];
-    })
-        .slice(0, 16);
+        const providerMetadata = record.providerMetadata &&
+            typeof record.providerMetadata === 'object' &&
+            !Array.isArray(record.providerMetadata)
+            ? {
+                ...record.providerMetadata,
+            }
+            : {};
+        if (argumentError) {
+            providerMetadata[WORK_TOOL_ARGUMENTS_ERROR_METADATA_KEY] = argumentError;
+        }
+        const explicitId = typeof record.id === 'string' ? record.id : undefined;
+        if (explicitId !== undefined && !explicitId.trim()) {
+            throw new WorkAgentHttpError('The provider returned a tool call with an empty ID.', 502, 'WORK_PROVIDER_INVALID_TOOL_CALLS');
+        }
+        if (isResponsesCallBatch && explicitId === undefined) {
+            throw new WorkAgentHttpError('The Responses provider returned a tool call without an exact call_id.', 502, 'WORK_PROVIDER_INVALID_TOOL_CALLS');
+        }
+        calls.push({
+            id: explicitId ?? `tool-${Date.now()}-${index}`,
+            ...(typeof record.thoughtSignature === 'string'
+                ? { thoughtSignature: record.thoughtSignature }
+                : {}),
+            ...(Object.keys(providerMetadata).length > 0 ? { providerMetadata } : {}),
+            function: { name: fn.name, arguments: args },
+        });
+    }
+    if (calls.length > 16) {
+        throw new WorkAgentHttpError('The provider returned more than 16 tool calls in one response.', 502, 'WORK_PROVIDER_INVALID_TOOL_CALLS');
+    }
+    const callIds = new Set();
+    for (const call of calls) {
+        if (callIds.has(call.id)) {
+            throw new WorkAgentHttpError(`The provider returned duplicate tool call ID "${call.id}".`, 502, 'WORK_PROVIDER_INVALID_TOOL_CALLS');
+        }
+        callIds.add(call.id);
+    }
+    return calls;
 }
 function functionTool(name, description, properties, required = []) {
     return {
@@ -798,6 +1094,36 @@ function optionalInteger(value) {
         ? value
         : undefined;
 }
+function validateToolCallArguments(call) {
+    const providerArgumentError = call.providerMetadata?.[WORK_TOOL_ARGUMENTS_ERROR_METADATA_KEY];
+    if (typeof providerArgumentError === 'string') {
+        return providerArgumentError;
+    }
+    const args = call.function.arguments;
+    const invalidRequiredString = (name, allowEmpty = false) => {
+        const value = args[name];
+        if (typeof value === 'string' && (allowEmpty || value.trim())) {
+            return undefined;
+        }
+        return `The model returned invalid arguments for ${call.function.name}: "${name}" must be a string. Retry with every required field; split large write_file content into focused files.`;
+    };
+    switch (call.function.name) {
+        case 'list_files':
+        case 'start_preview':
+        case 'stop_preview':
+            return undefined;
+        case 'read_file':
+            return invalidRequiredString('path');
+        case 'write_file':
+            return (invalidRequiredString('path') || invalidRequiredString('content', true));
+        case 'search_files':
+            return invalidRequiredString('query');
+        case 'run_command':
+            return invalidRequiredString('command');
+        default:
+            return `The model requested an unknown tool: ${call.function.name}.`;
+    }
+}
 function isActiveRunStatus(status) {
     return status === 'queued' || status === 'preparing' || status === 'running';
 }