windmill-components 1.655.2 → 1.665.0

package/package/components/copilot/chat/__tests__/shared/baseEvalRunner.js

@@ -1,132 +1,106 @@
-import OpenAI, { APIError } from 'openai';
+import OpenAI from 'openai';
+import Anthropic from '@anthropic-ai/sdk';
+import { runChatLoop } from '../../chatLoop';
 /**
- * Runs a generic evaluation with real LLM API calls.
- * Executes tool calls in a loop until the LLM stops calling tools.
- *
- * This is the core execution loop shared across all chat eval tests.
+ * Creates SDK clients for the given provider.
+ */
+function createEvalClients(provider, apiKey) {
+    if (provider === 'anthropic') {
+        return {
+            openai: new OpenAI({ apiKey: 'unused' }),
+            anthropic: new Anthropic({ apiKey })
+        };
+    }
+    return {
+        openai: new OpenAI({ apiKey }),
+        anthropic: new Anthropic({ apiKey: 'unused' })
+    };
+}
+/**
+ * Resolves model string to AIProviderModel.
+ */
+function resolveModelProvider(model, provider) {
+    if (provider)
+        return { provider, model };
+    if (model.startsWith('claude'))
+        return { provider: 'anthropic', model };
+    if (model.startsWith('gpt') || model.startsWith('o'))
+        return { provider: 'openai', model };
+    return { provider: 'openai', model };
+}
+/**
+ * Runs a generic evaluation using the shared chat loop (same code path as production).
+ * Uses streaming via real provider SDKs instead of OpenRouter non-streaming.
  */
 export async function runEval(params) {
-    const { systemMessage, userMessage, toolDefs, tools, helpers, apiKey, getOutput, options } = params;
-    const client = new OpenAI({ baseURL: 'https://openrouter.ai/api/v1', apiKey });
+    const { systemMessage, userMessage, tools, helpers, apiKey, getOutput, options } = params;
     const model = options?.model ?? 'gpt-4o';
     const maxIterations = options?.maxIterations ?? 20;
     const workspace = options?.workspace ?? 'test-workspace';
-    const messages = [systemMessage, userMessage];
-    const totalTokens = { prompt: 0, completion: 0, total: 0 };
+    const provider = options?.provider;
+    const modelProvider = resolveModelProvider(model, provider);
+    const clients = createEvalClients(modelProvider.provider, apiKey);
+    const messages = [userMessage];
     let toolCallsCount = 0;
     const toolsCalled = [];
     const toolCallDetails = [];
-    let iterations = 0;
-    // No-op tool callbacks for eval
-    const toolCallbacks = {
-        setToolStatus: () => { },
-        removeToolStatus: () => { }
-    };
-    try {
-        // Tool resolution loop
-        while (iterations < maxIterations) {
-            iterations++;
-            const response = await client.chat.completions.create({
-                model,
-                messages,
-                tools: toolDefs,
-                temperature: 0
-            });
-            // Track token usage
-            if (response.usage) {
-                totalTokens.prompt += response.usage.prompt_tokens;
-                totalTokens.completion += response.usage.completion_tokens;
-                totalTokens.total += response.usage.total_tokens;
-            }
-            if (!response.choices.length) {
-                throw new Error('No response from API');
-            }
-            const choice = response.choices[0];
-            const assistantMessage = choice.message;
-            // Add assistant message to history
-            messages.push(assistantMessage);
-            // If no tool calls, we're done
-            if (!assistantMessage.tool_calls?.length) {
-                break;
+    // Wrap tools to intercept fn calls for tracking.
+    // Cast to ProductionTool since the eval Tool has a narrower toolCallbacks type
+    // but the actual callbacks passed at runtime will satisfy both interfaces.
+    const wrappedTools = tools.map((tool) => ({
+        ...tool,
+        fn: async (p) => {
+            toolCallsCount++;
+            toolsCalled.push(tool.def.function.name);
+            try {
+                const args = typeof p.args === 'string' ? JSON.parse(p.args) : p.args;
+                toolCallDetails.push({ name: tool.def.function.name, arguments: args });
             }
-            // Execute each tool call
-            for (const toolCall of assistantMessage.tool_calls) {
-                toolCallsCount++;
-                // Type guard: only handle function tool calls
-                if (toolCall.type !== 'function') {
-                    messages.push({
-                        role: 'tool',
-                        tool_call_id: toolCall.id,
-                        content: `Unsupported tool type: ${toolCall.type}`
-                    });
-                    continue;
-                }
-                toolsCalled.push(toolCall.function.name);
-                const tool = tools.find((t) => t.def.function.name === toolCall.function.name);
-                if (!tool) {
-                    messages.push({
-                        role: 'tool',
-                        tool_call_id: toolCall.id,
-                        content: `Unknown tool: ${toolCall.function.name}`
-                    });
-                    continue;
-                }
-                try {
-                    const args = JSON.parse(toolCall.function.arguments);
-                    toolCallDetails.push({ name: toolCall.function.name, arguments: args });
-                    const result = await tool.fn({
-                        args,
-                        workspace,
-                        helpers,
-                        toolCallbacks,
-                        toolId: toolCall.id
-                    });
-                    messages.push({
-                        role: 'tool',
-                        tool_call_id: toolCall.id,
-                        content: result
-                    });
-                }
-                catch (err) {
-                    const errorMessage = err instanceof Error ? err.message : String(err);
-                    messages.push({
-                        role: 'tool',
-                        tool_call_id: toolCall.id,
-                        content: `Error: ${errorMessage}`
-                    });
-                }
+            catch {
+                toolCallDetails.push({
+                    name: tool.def.function.name,
+                    arguments: p.args
+                });
             }
+            return tool.fn(p);
         }
+    }));
+    // No-op callbacks for eval
+    const callbacks = {
+        setToolStatus: () => { },
+        removeToolStatus: () => { },
+        onNewToken: () => { },
+        onMessageEnd: () => { }
+    };
+    const abortController = new AbortController();
+    try {
+        const result = await runChatLoop({
+            messages,
+            systemMessage,
+            tools: wrappedTools,
+            helpers,
+            abortController,
+            callbacks,
+            modelProvider,
+            clients,
+            workspace,
+            maxIterations,
+            skipResponsesApi: modelProvider.provider !== 'openai' && modelProvider.provider !== 'azure_openai'
+        });
         return {
             success: true,
             output: getOutput(),
-            tokenUsage: totalTokens,
+            tokenUsage: { prompt: 0, completion: 0, total: 0 },
             toolCallsCount,
             toolsCalled,
             toolCallDetails,
-            iterations,
+            iterations: Math.max(1, result.addedMessages.filter((m) => m.role === 'assistant').length),
             messages
         };
     }
     catch (err) {
-        // Build detailed error message
         let errorMessage;
-        if (err instanceof APIError) {
-            const details = [`${err.status} ${err.message}`];
-            if (err.code)
-                details.push(`Code: ${err.code}`);
-            if (err.type)
-                details.push(`Type: ${err.type}`);
-            if (err.param)
-                details.push(`Param: ${err.param}`);
-            if (err.requestID)
-                details.push(`Request ID: ${err.requestID}`);
-            if (err.error && typeof err.error === 'object') {
-                details.push(`Response: ${JSON.stringify(err.error, null, 2)}`);
-            }
-            errorMessage = details.join('\n');
-        }
-        else if (err instanceof Error) {
+        if (err instanceof Error) {
             errorMessage = err.stack ?? err.message;
         }
         else {
@@ -136,11 +110,11 @@ export async function runEval(params) {
             success: false,
             output: getOutput(),
             error: errorMessage,
-            tokenUsage: totalTokens,
+            tokenUsage: { prompt: 0, completion: 0, total: 0 },
             toolCallsCount,
             toolsCalled,
             toolCallDetails,
-            iterations,
+            iterations: 0,
             messages
         };
     }

package/package/components/copilot/chat/__tests__/shared/baseLLMEvaluator.d.ts

@@ -11,9 +11,9 @@ export interface EvaluateParams {
     expectedOutput: unknown;
     /** Domain-specific system prompt for the evaluator */
     evaluatorSystemPrompt: string;
-    /** API key for OpenRouter */
-    apiKey: string;
-    /** Model to use for evaluation (default: 'anthropic/claude-sonnet-4.5') */
+    /** Anthropic API key for evaluation */
+    apiKey?: string;
+    /** Model to use for evaluation (default: 'claude-sonnet-4-5-20250514') */
     model?: string;
 }
 /**
@@ -23,9 +23,6 @@ export interface EvaluateParams {
 export declare const BASE_EVALUATOR_RESPONSE_FORMAT = "\n## Response Format\nYou MUST respond with valid JSON only, no additional text:\n{\n  \"resemblanceScore\": <0-100 integer>,\n  \"statement\": \"<brief 1-2 sentence summary of how well the output matches the user request and expected output>\",\n  \"missingRequirements\": [\"<list any requirements from user prompt that are missing or incorrectly implemented>\"]\n}\n\nScore guidelines:\n- 90-100: Fully addresses user request, functionally equivalent to expected output\n- 70-89: Addresses most user requirements, same overall structure with minor differences\n- 50-69: Partially addresses user request, achieves similar goal but different approach\n- 30-49: Missing significant requirements from user request\n- 0-29: Does not address user request or significantly incorrect";
 /**
  * Evaluates how well a generated output matches an expected output using an LLM.
- * Returns a resemblance score (0-100), a qualitative statement, and any missing requirements.
- *
- * @param params Evaluation parameters including prompts, outputs, and API configuration
- * @returns Evaluation result with score, statement, and missing requirements
+ * Uses Anthropic API directly instead of OpenRouter.
  */
 export declare function evaluateWithLLM(params: EvaluateParams): Promise<EvaluationResult>;

package/package/components/copilot/chat/__tests__/shared/baseLLMEvaluator.js

@@ -1,4 +1,4 @@
-import OpenAI from 'openai';
+import Anthropic from '@anthropic-ai/sdk';
 /**
  * Base evaluator system prompt template.
  * Domain-specific evaluators should build on this structure.
@@ -20,14 +20,21 @@ Score guidelines:
 - 0-29: Does not address user request or significantly incorrect`;
 /**
  * Evaluates how well a generated output matches an expected output using an LLM.
- * Returns a resemblance score (0-100), a qualitative statement, and any missing requirements.
- *
- * @param params Evaluation parameters including prompts, outputs, and API configuration
- * @returns Evaluation result with score, statement, and missing requirements
+ * Uses Anthropic API directly instead of OpenRouter.
  */
 export async function evaluateWithLLM(params) {
-    const { userPrompt, generatedOutput, expectedOutput, evaluatorSystemPrompt, apiKey, model = 'anthropic/claude-sonnet-4.5' } = params;
-    const client = new OpenAI({ baseURL: 'https://openrouter.ai/api/v1', apiKey });
+    const { userPrompt, generatedOutput, expectedOutput, evaluatorSystemPrompt, apiKey, model = 'claude-sonnet-4-5-20250514' } = params;
+    // @ts-ignore - process.env
+    const anthropicKey = apiKey ?? process.env.ANTHROPIC_API_KEY;
+    if (!anthropicKey) {
+        return {
+            success: false,
+            resemblanceScore: 0,
+            statement: 'No API key available for evaluation',
+            error: 'ANTHROPIC_API_KEY not set and no apiKey provided'
+        };
+    }
+    const client = new Anthropic({ apiKey: anthropicKey });
     const userMessage = `## User's Original Request
 ${userPrompt}
 
@@ -45,15 +52,17 @@ Please evaluate how well the generated output:
 1. Fulfills ALL requirements from the user's original request
 2. Matches the structure and logic of the expected reference output`;
     try {
-        const response = await client.chat.completions.create({
+        const response = await client.messages.create({
             model,
+            max_tokens: 2048,
+            system: evaluatorSystemPrompt,
             messages: [
-                { role: 'system', content: evaluatorSystemPrompt },
                 { role: 'user', content: userMessage }
             ],
             temperature: 0
         });
-        const content = response.choices[0]?.message?.content;
+        const textBlock = response.content.find((block) => block.type === 'text');
+        const content = textBlock?.text;
         if (!content) {
             return {
                 success: false,
@@ -65,7 +74,6 @@ Please evaluate how well the generated output:
         // Parse JSON response - handle potential markdown code blocks
         let jsonContent = content.trim();
         if (jsonContent.startsWith('```')) {
-            // Remove markdown code block wrapper
             jsonContent = jsonContent.replace(/^```(?:json)?\n?/, '').replace(/\n?```$/, '');
         }
         const parsed = JSON.parse(jsonContent);

package/package/components/copilot/chat/__tests__/shared/types.d.ts

@@ -1,4 +1,5 @@
 import type { ChatCompletionMessageParam } from 'openai/resources/chat/completions.mjs';
+import type { AIProvider } from '../../../../../gen/types.gen';
 /**
  * Token usage tracking for LLM calls.
  */
@@ -84,6 +85,8 @@ export interface EvalRunnerOptions {
     model?: string;
     /** Workspace ID for tool calls */
     workspace?: string;
+    /** AI provider (inferred from model name if omitted) */
+    provider?: AIProvider;
 }
 /**
  * No-op tool callbacks for eval testing.

package/package/components/copilot/chat/anthropic.d.ts

@@ -1,13 +1,20 @@
 import { OpenAI } from 'openai';
+import Anthropic from '@anthropic-ai/sdk';
 import type { ChatCompletionMessageParam } from 'openai/resources/index.mjs';
 import type { MessageParam, TextBlockParam, ToolUnion } from '@anthropic-ai/sdk/resources';
 import type { MessageStream } from '@anthropic-ai/sdk/lib/MessageStream';
+import type { AIProviderModel } from '../../../gen';
 import { type Tool, type ToolCallbacks } from './shared';
-export declare function getAnthropicCompletion(messages: ChatCompletionMessageParam[], abortController: AbortController, tools?: OpenAI.Chat.Completions.ChatCompletionFunctionTool[]): Promise<MessageStream>;
+export declare function getAnthropicCompletion(messages: ChatCompletionMessageParam[], abortController: AbortController, tools?: OpenAI.Chat.Completions.ChatCompletionFunctionTool[], options?: {
+    forceModelProvider?: AIProviderModel;
+    anthropicClient?: Anthropic;
+}): Promise<MessageStream>;
 export declare function parseAnthropicCompletion(completion: MessageStream, callbacks: ToolCallbacks & {
     onNewToken: (token: string) => void;
     onMessageEnd: () => void;
-}, messages: ChatCompletionMessageParam[], addedMessages: ChatCompletionMessageParam[], tools: Tool<any>[], helpers: any, abortController?: AbortController): Promise<boolean>;
+}, messages: ChatCompletionMessageParam[], addedMessages: ChatCompletionMessageParam[], tools: Tool<any>[], helpers: any, abortController?: AbortController, options?: {
+    workspace?: string;
+}): Promise<boolean>;
 export declare function convertOpenAIToAnthropicMessages(messages: ChatCompletionMessageParam[]): {
     system: TextBlockParam[] | undefined;
     messages: MessageParam[];

package/package/components/copilot/chat/anthropic.js

@@ -1,11 +1,16 @@
 import { OpenAI } from 'openai';
+import Anthropic from '@anthropic-ai/sdk';
 import { getProviderAndCompletionConfig, workspaceAIClients } from '../lib';
 import { processToolCall } from './shared';
-export async function getAnthropicCompletion(messages, abortController, tools) {
-    const { provider, config } = getProviderAndCompletionConfig({ messages, stream: true });
+export async function getAnthropicCompletion(messages, abortController, tools, options) {
+    const { provider, config } = getProviderAndCompletionConfig({
+        messages,
+        stream: true,
+        forceModelProvider: options?.forceModelProvider
+    });
     const { system, messages: anthropicMessages } = convertOpenAIToAnthropicMessages(messages);
     const anthropicTools = convertOpenAIToolsToAnthropic(tools);
-    const anthropicClient = workspaceAIClients.getAnthropicClient();
+    const client = options?.anthropicClient ?? workspaceAIClients.getAnthropicClient();
     const anthropicParams = {
         model: config.model,
         max_tokens: config.max_tokens,
@@ -14,7 +19,7 @@ export async function getAnthropicCompletion(messages, abortController, tools) {
         ...(anthropicTools && { tools: anthropicTools }),
         ...(typeof config.temperature === 'number' && { temperature: config.temperature })
     };
-    const stream = anthropicClient.messages.stream(anthropicParams, {
+    const stream = client.messages.stream(anthropicParams, {
         signal: abortController.signal,
         headers: {
             'X-Provider': provider,
@@ -24,7 +29,7 @@ export async function getAnthropicCompletion(messages, abortController, tools) {
     });
     return stream;
 }
-export async function parseAnthropicCompletion(completion, callbacks, messages, addedMessages, tools, helpers, abortController) {
+export async function parseAnthropicCompletion(completion, callbacks, messages, addedMessages, tools, helpers, abortController, options) {
     let toolCallsToProcess = [];
     let error = null;
     let currentStreamingTool = undefined;
@@ -156,7 +161,8 @@ export async function parseAnthropicCompletion(completion, callbacks, messages,
                 tools,
                 toolCall,
                 helpers,
-                toolCallbacks: callbacks
+                toolCallbacks: callbacks,
+                workspace: options?.workspace
             });
             messages.push(messageToAdd);
             addedMessages.push(messageToAdd);

package/package/components/copilot/chat/app/core.js

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { createSearchHubScriptsTool, createToolDef, createSearchWorkspaceTool, createGetRunnableDetailsTool } from '../shared';
+import { getDatatableSdkReference } from '../../../../system_prompts';
 import { aiChatManager } from '../AIChatManager.svelte';
 // ============= Utility =============
 /** Maximum characters per file in get_files tool */
@@ -519,38 +520,30 @@ For inline scripts, the code must have a \`main\` function as its entrypoint.
 
 Backend runnables should only perform **data operations** (SELECT, INSERT, UPDATE, DELETE) on **existing tables**. Never use CREATE TABLE, DROP TABLE, or ALTER TABLE inside runnables.
 
-**TypeScript (Bun)**:
+**TypeScript (Bun) example**:
 \`\`\`typescript
 import * as wmill from 'windmill-client';
 
 export async function main(user_id: string) {
   const sql = ${datatableCall};
-
-  // Safe string interpolation (parameterized query)
   const user = await sql\`SELECT * FROM ${schemaPrefix}users WHERE id = \${user_id}\`.fetchOne();
   return user;
 }
 \`\`\`
 
-**Python**:
+**Python example**:
 \`\`\`python
 import wmill
 
 def main(user_id: str):
     db = ${datatableCall}
-
-    # Use positional arguments ($1, $2, etc.)
     user = db.query('SELECT * FROM ${schemaPrefix}users WHERE id = $1', user_id).fetch_one()
     return user
 \`\`\`
 
-### Common Operations (for use in backend runnables)
+### Datatable Client API Reference
 
-- **Fetch all**: \`sql\`SELECT * FROM ${schemaPrefix}table\`.fetch()\` or \`db.query('SELECT * FROM ${schemaPrefix}table').fetch()\`
-- **Fetch one**: \`.fetchOne()\` or \`.fetch_one()\`
-- **Insert**: \`sql\`INSERT INTO ${schemaPrefix}table (col) VALUES (\${value})\`\`
-- **Update**: \`sql\`UPDATE ${schemaPrefix}table SET col = \${value} WHERE id = \${id}\`\`
-- **Delete**: \`sql\`DELETE FROM ${schemaPrefix}table WHERE id = \${id}\`\`
+${getDatatableSdkReference()}
 
 ### Schema Modifications (DDL) - Use exec_datatable_sql tool ONLY
 

package/package/components/copilot/chat/chatLoop.d.ts

@@ -0,0 +1,40 @@
+import OpenAI from 'openai';
+import Anthropic from '@anthropic-ai/sdk';
+import type { ChatCompletionMessageParam, ChatCompletionSystemMessageParam, ChatCompletionUserMessageParam } from 'openai/resources/chat/completions.mjs';
+import type { AIProviderModel } from '../../../gen';
+import type { Tool, ToolCallbacks } from './shared';
+export interface ChatClients {
+    openai: OpenAI;
+    anthropic: Anthropic;
+}
+export interface ChatLoopConfig {
+    messages: ChatCompletionMessageParam[];
+    /**
+     * System message, tools, helpers, and modelProvider are re-read from this config
+     * on every iteration. Callers can use JS getters to provide dynamic values
+     * (e.g. AIChatManager uses getters so mode changes mid-loop take effect).
+     */
+    systemMessage: ChatCompletionSystemMessageParam;
+    tools: Tool<any>[];
+    helpers: any;
+    abortController: AbortController;
+    callbacks: ToolCallbacks & {
+        onNewToken: (token: string) => void;
+        onMessageEnd: () => void;
+    };
+    modelProvider: AIProviderModel;
+    clients: ChatClients;
+    workspace: string;
+    /** Maximum iterations for the loop. undefined = unlimited (production). */
+    maxIterations?: number;
+    skipResponsesApi?: boolean;
+    onSkipResponsesApi?: () => void;
+    /** Return a pending user message to inject between iterations, or undefined. */
+    getPendingUserMessage?: () => ChatCompletionUserMessageParam | undefined;
+    /** Called before each iteration (e.g. to refresh tool schemas). */
+    onBeforeIteration?: (tools: Tool<any>[], helpers: any) => Promise<void>;
+}
+export interface ChatLoopResult {
+    addedMessages: ChatCompletionMessageParam[];
+}
+export declare function runChatLoop(config: ChatLoopConfig): Promise<ChatLoopResult>;

package/package/components/copilot/chat/chatLoop.js

@@ -0,0 +1,97 @@
+import OpenAI from 'openai';
+import Anthropic from '@anthropic-ai/sdk';
+import { getCompletion, parseOpenAICompletion } from '../lib';
+import { getAnthropicCompletion, parseAnthropicCompletion } from './anthropic';
+import { getOpenAIResponsesCompletion, parseOpenAIResponsesCompletion } from './openai-responses';
+export async function runChatLoop(config) {
+    const { messages, abortController, callbacks, clients, workspace, maxIterations, onSkipResponsesApi, getPendingUserMessage, onBeforeIteration } = config;
+    let skipResponsesApi = config.skipResponsesApi ?? false;
+    const addedMessages = [];
+    let iterations = 0;
+    while (true) {
+        if (maxIterations !== undefined && iterations >= maxIterations) {
+            break;
+        }
+        iterations++;
+        // Re-read these from config each iteration so that mode changes
+        // (e.g. changeModeTool in Navigator) take effect immediately.
+        // Callers can use JS getter properties to provide dynamic values.
+        const tools = config.tools;
+        const helpers = config.helpers;
+        const systemMessage = config.systemMessage;
+        const modelProvider = config.modelProvider;
+        if (onBeforeIteration) {
+            await onBeforeIteration(tools, helpers);
+        }
+        const pendingUserMessage = getPendingUserMessage?.();
+        const isOpenAI = modelProvider.provider === 'openai' || modelProvider.provider === 'azure_openai';
+        const isAnthropic = modelProvider.provider === 'anthropic';
+        const messageParams = [
+            systemMessage,
+            ...messages,
+            ...(pendingUserMessage ? [pendingUserMessage] : [])
+        ];
+        const toolDefs = tools.map((t) => t.def);
+        const parseOptions = { workspace };
+        if (isOpenAI) {
+            let useCompletionsApi = skipResponsesApi;
+            if (!skipResponsesApi) {
+                try {
+                    const completion = await getOpenAIResponsesCompletion(messageParams, abortController, toolDefs, {
+                        forceModelProvider: modelProvider,
+                        openaiClient: clients.openai
+                    });
+                    const continueCompletion = await parseOpenAIResponsesCompletion(completion, callbacks, messages, addedMessages, tools, helpers, parseOptions);
+                    if (!continueCompletion) {
+                        break;
+                    }
+                }
+                catch (err) {
+                    console.warn('OpenAI Responses API failed, falling back to Completions API:', err);
+                    const errorMessage = err instanceof Error ? err.message : String(err);
+                    if (errorMessage.includes('Responses API is not enabled')) {
+                        skipResponsesApi = true;
+                        onSkipResponsesApi?.();
+                    }
+                    useCompletionsApi = true;
+                }
+            }
+            if (useCompletionsApi) {
+                const completion = await getCompletion(messageParams, abortController, toolDefs, {
+                    forceCompletions: true,
+                    forceModelProvider: modelProvider,
+                    openaiClient: clients.openai
+                });
+                const continueCompletion = await parseOpenAICompletion(completion, callbacks, messages, addedMessages, tools, helpers, undefined, parseOptions);
+                if (!continueCompletion) {
+                    break;
+                }
+            }
+        }
+        else if (isAnthropic) {
+            const completion = await getAnthropicCompletion(messageParams, abortController, toolDefs, {
+                forceModelProvider: modelProvider,
+                anthropicClient: clients.anthropic
+            });
+            if (completion) {
+                const continueCompletion = await parseAnthropicCompletion(completion, callbacks, messages, addedMessages, tools, helpers, abortController, parseOptions);
+                if (!continueCompletion) {
+                    break;
+                }
+            }
+        }
+        else {
+            const completion = await getCompletion(messageParams, abortController, toolDefs, {
+                forceModelProvider: modelProvider,
+                openaiClient: clients.openai
+            });
+            if (completion) {
+                const continueCompletion = await parseOpenAICompletion(completion, callbacks, messages, addedMessages, tools, helpers, undefined, parseOptions);
+                if (!continueCompletion) {
+                    break;
+                }
+            }
+        }
+    }
+    return { addedMessages };
+}

package/package/components/copilot/chat/openai-responses.d.ts

@@ -3,14 +3,20 @@ import type { ChatCompletionMessageParam } from 'openai/resources/index.mjs';
 import { type Tool, type ToolCallbacks } from './shared';
 import type { ResponseStream } from 'openai/lib/responses/ResponseStream.mjs';
 import type { AIProviderModel } from '../../../gen';
-export declare function getOpenAIResponsesCompletion(messages: ChatCompletionMessageParam[], abortController: AbortController, tools?: OpenAI.Chat.Completions.ChatCompletionTool[]): Promise<ResponseStream<null>>;
+export declare function getOpenAIResponsesCompletion(messages: ChatCompletionMessageParam[], abortController: AbortController, tools?: OpenAI.Chat.Completions.ChatCompletionTool[], options?: {
+    forceModelProvider?: AIProviderModel;
+    openaiClient?: OpenAI;
+}): Promise<ResponseStream<null>>;
 export declare function getOpenAIResponsesCompletionStream(messages: ChatCompletionMessageParam[], abortController: AbortController, tools?: OpenAI.Chat.Completions.ChatCompletionTool[]): AsyncGenerator<OpenAI.Chat.Completions.ChatCompletionChunk>;
 export declare function parseOpenAIResponsesCompletion(runner: ResponseStream, callbacks: ToolCallbacks & {
     onNewToken: (token: string) => void;
     onMessageEnd: () => void;
-}, messages: ChatCompletionMessageParam[], addedMessages: ChatCompletionMessageParam[], tools: Tool<any>[], helpers: any): Promise<boolean>;
+}, messages: ChatCompletionMessageParam[], addedMessages: ChatCompletionMessageParam[], tools: Tool<any>[], helpers: any, options?: {
+    workspace?: string;
+}): Promise<boolean>;
 export declare function getNonStreamingOpenAIResponsesCompletion(messages: ChatCompletionMessageParam[], abortController: AbortController, testOptions?: {
     apiKey?: string;
+    workspace?: string;
     resourcePath?: string;
     forceModelProvider: AIProviderModel;
 }): Promise<string>;