@quilltap/plugin-utils 1.4.1 → 1.5.1

package/dist/converters-BPYo8xdH.d.mts

@@ -0,0 +1,245 @@
+import { ToolCallRequest, AnthropicToolDefinition, UniversalTool, GoogleToolDefinition, OpenAIToolDefinition } from '@quilltap/plugin-types';
+
+/**
+ * Tool Call Parsers
+ *
+ * Provider-specific parsers for extracting tool calls from LLM responses.
+ * Each parser converts from a provider's native format to the standardized
+ * ToolCallRequest format.
+ *
+ * @module @quilltap/plugin-utils/tools/parsers
+ */
+
+/**
+ * Supported tool call response formats
+ */
+type ToolCallFormat = 'openai' | 'anthropic' | 'google' | 'auto';
+/**
+ * Parse OpenAI format tool calls from LLM response
+ *
+ * Extracts tool calls from OpenAI/Grok API responses which return
+ * tool_calls in the message object.
+ *
+ * Expected response structures:
+ * - `response.tool_calls` (direct)
+ * - `response.choices[0].message.tool_calls` (nested)
+ *
+ * @param response - The raw response from provider API
+ * @returns Array of parsed tool call requests
+ *
+ * @example
+ * ```typescript
+ * const response = await openai.chat.completions.create({...});
+ * const toolCalls = parseOpenAIToolCalls(response);
+ * // Returns: [{ name: 'search_web', arguments: { query: 'hello' } }]
+ * ```
+ */
+declare function parseOpenAIToolCalls(response: unknown): ToolCallRequest[];
+/**
+ * Parse Anthropic format tool calls from LLM response
+ *
+ * Extracts tool calls from Anthropic API responses which return
+ * tool_use blocks in the content array.
+ *
+ * Expected response structure:
+ * - `response.content` array with `{ type: 'tool_use', name, input }`
+ *
+ * @param response - The raw response from provider API
+ * @returns Array of parsed tool call requests
+ *
+ * @example
+ * ```typescript
+ * const response = await anthropic.messages.create({...});
+ * const toolCalls = parseAnthropicToolCalls(response);
+ * // Returns: [{ name: 'search_web', arguments: { query: 'hello' } }]
+ * ```
+ */
+declare function parseAnthropicToolCalls(response: unknown): ToolCallRequest[];
+/**
+ * Parse Google Gemini format tool calls from LLM response
+ *
+ * Extracts tool calls from Google Gemini API responses which return
+ * functionCall objects in the parts array.
+ *
+ * Expected response structure:
+ * - `response.candidates[0].content.parts` array with `{ functionCall: { name, args } }`
+ *
+ * @param response - The raw response from provider API
+ * @returns Array of parsed tool call requests
+ *
+ * @example
+ * ```typescript
+ * const response = await gemini.generateContent({...});
+ * const toolCalls = parseGoogleToolCalls(response);
+ * // Returns: [{ name: 'search_web', arguments: { query: 'hello' } }]
+ * ```
+ */
+declare function parseGoogleToolCalls(response: unknown): ToolCallRequest[];
+/**
+ * Detect the format of a tool call response
+ *
+ * Analyzes the response structure to determine which provider format it uses.
+ *
+ * @param response - The raw response from a provider API
+ * @returns The detected format, or null if unrecognized
+ */
+declare function detectToolCallFormat(response: unknown): ToolCallFormat | null;
+/**
+ * Parse tool calls with auto-detection or explicit format
+ *
+ * A unified parser that can either auto-detect the response format
+ * or use a specified format. This is useful when you're not sure
+ * which provider's response you're handling.
+ *
+ * @param response - The raw response from a provider API
+ * @param format - The format to use: 'openai', 'anthropic', 'google', or 'auto'
+ * @returns Array of parsed tool call requests
+ *
+ * @example
+ * ```typescript
+ * // Auto-detect format
+ * const toolCalls = parseToolCalls(response, 'auto');
+ *
+ * // Or specify format explicitly
+ * const toolCalls = parseToolCalls(response, 'openai');
+ * ```
+ */
+declare function parseToolCalls(response: unknown, format?: ToolCallFormat): ToolCallRequest[];
+/**
+ * Check if a response contains tool calls
+ *
+ * Quick check to determine if a response has any tool calls
+ * without fully parsing them.
+ *
+ * @param response - The raw response from a provider API
+ * @returns True if the response contains tool calls
+ */
+declare function hasToolCalls(response: unknown): boolean;
+
+/**
+ * Tool Format Converters
+ *
+ * Utilities for converting between different provider tool formats.
+ * The universal format (OpenAI-style) serves as the baseline for all conversions.
+ *
+ * @module @quilltap/plugin-utils/tools/converters
+ */
+
+/**
+ * Convert OpenAI/Universal format tool to Anthropic format
+ *
+ * Anthropic uses a tool_use format with:
+ * - name: string
+ * - description: string
+ * - input_schema: JSON schema object
+ *
+ * @param tool - Universal tool or OpenAI tool definition
+ * @returns Tool formatted for Anthropic's tool_use
+ *
+ * @example
+ * ```typescript
+ * const anthropicTool = convertToAnthropicFormat(universalTool);
+ * // Returns: {
+ * //   name: 'search_web',
+ * //   description: 'Search the web',
+ * //   input_schema: {
+ * //     type: 'object',
+ * //     properties: { query: { type: 'string' } },
+ * //     required: ['query']
+ * //   }
+ * // }
+ * ```
+ */
+declare function convertToAnthropicFormat(tool: UniversalTool | OpenAIToolDefinition): AnthropicToolDefinition;
+/**
+ * Convert OpenAI/Universal format tool to Google Gemini format
+ *
+ * Google uses a function calling format with:
+ * - name: string
+ * - description: string
+ * - parameters: JSON schema object
+ *
+ * @param tool - Universal tool or OpenAI tool definition
+ * @returns Tool formatted for Google's functionCall
+ *
+ * @example
+ * ```typescript
+ * const googleTool = convertToGoogleFormat(universalTool);
+ * // Returns: {
+ * //   name: 'search_web',
+ * //   description: 'Search the web',
+ * //   parameters: {
+ * //     type: 'object',
+ * //     properties: { query: { type: 'string' } },
+ * //     required: ['query']
+ * //   }
+ * // }
+ * ```
+ */
+declare function convertToGoogleFormat(tool: UniversalTool | OpenAIToolDefinition): GoogleToolDefinition;
+/**
+ * Convert Anthropic format tool to Universal/OpenAI format
+ *
+ * @param tool - Anthropic format tool
+ * @returns Tool in universal OpenAI format
+ */
+declare function convertFromAnthropicFormat(tool: AnthropicToolDefinition): UniversalTool;
+/**
+ * Convert Google format tool to Universal/OpenAI format
+ *
+ * @param tool - Google format tool
+ * @returns Tool in universal OpenAI format
+ */
+declare function convertFromGoogleFormat(tool: GoogleToolDefinition): UniversalTool;
+/**
+ * Apply prompt/description length limit to a tool
+ *
+ * Modifies a tool's description if it exceeds maxBytes, appending a warning
+ * that the description was truncated. This is useful for providers with
+ * strict token limits.
+ *
+ * @param tool - Tool object (any format) with a description property
+ * @param maxBytes - Maximum bytes allowed for description (including warning)
+ * @returns Modified tool with truncated description if needed
+ *
+ * @example
+ * ```typescript
+ * const limitedTool = applyDescriptionLimit(tool, 500);
+ * // If description > 500 bytes, truncates and adds warning
+ * ```
+ */
+declare function applyDescriptionLimit<T extends {
+    description: string;
+}>(tool: T, maxBytes: number): T;
+/**
+ * Target format for tool conversion
+ */
+type ToolConvertTarget = 'openai' | 'anthropic' | 'google';
+/**
+ * Convert a universal tool to a specific provider format
+ *
+ * @param tool - Universal tool or OpenAI tool definition
+ * @param target - Target provider format
+ * @returns Tool in the target format
+ */
+declare function convertToolTo(tool: UniversalTool | OpenAIToolDefinition, target: ToolConvertTarget): UniversalTool | OpenAIToolDefinition | AnthropicToolDefinition | GoogleToolDefinition;
+/**
+ * Convert multiple tools to a specific provider format
+ *
+ * @param tools - Array of universal tools or OpenAI tool definitions
+ * @param target - Target provider format
+ * @returns Array of tools in the target format
+ */
+declare function convertToolsTo(tools: Array<UniversalTool | OpenAIToolDefinition>, target: ToolConvertTarget): Array<UniversalTool | OpenAIToolDefinition | AnthropicToolDefinition | GoogleToolDefinition>;
+/**
+ * Alias for convertToAnthropicFormat
+ * @deprecated Use convertToAnthropicFormat instead
+ */
+declare const convertOpenAIToAnthropicFormat: typeof convertToAnthropicFormat;
+/**
+ * Alias for convertToGoogleFormat
+ * @deprecated Use convertToGoogleFormat instead
+ */
+declare const convertOpenAIToGoogleFormat: typeof convertToGoogleFormat;
+
+export { type ToolCallFormat as T, type ToolConvertTarget as a, applyDescriptionLimit as b, convertFromAnthropicFormat as c, convertFromGoogleFormat as d, convertOpenAIToAnthropicFormat as e, convertOpenAIToGoogleFormat as f, convertToAnthropicFormat as g, convertToGoogleFormat as h, convertToolTo as i, convertToolsTo as j, detectToolCallFormat as k, hasToolCalls as l, parseGoogleToolCalls as m, parseOpenAIToolCalls as n, parseToolCalls as o, parseAnthropicToolCalls as p };

package/dist/converters-BPYo8xdH.d.ts

@@ -0,0 +1,245 @@
+import { ToolCallRequest, AnthropicToolDefinition, UniversalTool, GoogleToolDefinition, OpenAIToolDefinition } from '@quilltap/plugin-types';
+
+/**
+ * Tool Call Parsers
+ *
+ * Provider-specific parsers for extracting tool calls from LLM responses.
+ * Each parser converts from a provider's native format to the standardized
+ * ToolCallRequest format.
+ *
+ * @module @quilltap/plugin-utils/tools/parsers
+ */
+
+/**
+ * Supported tool call response formats
+ */
+type ToolCallFormat = 'openai' | 'anthropic' | 'google' | 'auto';
+/**
+ * Parse OpenAI format tool calls from LLM response
+ *
+ * Extracts tool calls from OpenAI/Grok API responses which return
+ * tool_calls in the message object.
+ *
+ * Expected response structures:
+ * - `response.tool_calls` (direct)
+ * - `response.choices[0].message.tool_calls` (nested)
+ *
+ * @param response - The raw response from provider API
+ * @returns Array of parsed tool call requests
+ *
+ * @example
+ * ```typescript
+ * const response = await openai.chat.completions.create({...});
+ * const toolCalls = parseOpenAIToolCalls(response);
+ * // Returns: [{ name: 'search_web', arguments: { query: 'hello' } }]
+ * ```
+ */
+declare function parseOpenAIToolCalls(response: unknown): ToolCallRequest[];
+/**
+ * Parse Anthropic format tool calls from LLM response
+ *
+ * Extracts tool calls from Anthropic API responses which return
+ * tool_use blocks in the content array.
+ *
+ * Expected response structure:
+ * - `response.content` array with `{ type: 'tool_use', name, input }`
+ *
+ * @param response - The raw response from provider API
+ * @returns Array of parsed tool call requests
+ *
+ * @example
+ * ```typescript
+ * const response = await anthropic.messages.create({...});
+ * const toolCalls = parseAnthropicToolCalls(response);
+ * // Returns: [{ name: 'search_web', arguments: { query: 'hello' } }]
+ * ```
+ */
+declare function parseAnthropicToolCalls(response: unknown): ToolCallRequest[];
+/**
+ * Parse Google Gemini format tool calls from LLM response
+ *
+ * Extracts tool calls from Google Gemini API responses which return
+ * functionCall objects in the parts array.
+ *
+ * Expected response structure:
+ * - `response.candidates[0].content.parts` array with `{ functionCall: { name, args } }`
+ *
+ * @param response - The raw response from provider API
+ * @returns Array of parsed tool call requests
+ *
+ * @example
+ * ```typescript
+ * const response = await gemini.generateContent({...});
+ * const toolCalls = parseGoogleToolCalls(response);
+ * // Returns: [{ name: 'search_web', arguments: { query: 'hello' } }]
+ * ```
+ */
+declare function parseGoogleToolCalls(response: unknown): ToolCallRequest[];
+/**
+ * Detect the format of a tool call response
+ *
+ * Analyzes the response structure to determine which provider format it uses.
+ *
+ * @param response - The raw response from a provider API
+ * @returns The detected format, or null if unrecognized
+ */
+declare function detectToolCallFormat(response: unknown): ToolCallFormat | null;
+/**
+ * Parse tool calls with auto-detection or explicit format
+ *
+ * A unified parser that can either auto-detect the response format
+ * or use a specified format. This is useful when you're not sure
+ * which provider's response you're handling.
+ *
+ * @param response - The raw response from a provider API
+ * @param format - The format to use: 'openai', 'anthropic', 'google', or 'auto'
+ * @returns Array of parsed tool call requests
+ *
+ * @example
+ * ```typescript
+ * // Auto-detect format
+ * const toolCalls = parseToolCalls(response, 'auto');
+ *
+ * // Or specify format explicitly
+ * const toolCalls = parseToolCalls(response, 'openai');
+ * ```
+ */
+declare function parseToolCalls(response: unknown, format?: ToolCallFormat): ToolCallRequest[];
+/**
+ * Check if a response contains tool calls
+ *
+ * Quick check to determine if a response has any tool calls
+ * without fully parsing them.
+ *
+ * @param response - The raw response from a provider API
+ * @returns True if the response contains tool calls
+ */
+declare function hasToolCalls(response: unknown): boolean;
+
+/**
+ * Tool Format Converters
+ *
+ * Utilities for converting between different provider tool formats.
+ * The universal format (OpenAI-style) serves as the baseline for all conversions.
+ *
+ * @module @quilltap/plugin-utils/tools/converters
+ */
+
+/**
+ * Convert OpenAI/Universal format tool to Anthropic format
+ *
+ * Anthropic uses a tool_use format with:
+ * - name: string
+ * - description: string
+ * - input_schema: JSON schema object
+ *
+ * @param tool - Universal tool or OpenAI tool definition
+ * @returns Tool formatted for Anthropic's tool_use
+ *
+ * @example
+ * ```typescript
+ * const anthropicTool = convertToAnthropicFormat(universalTool);
+ * // Returns: {
+ * //   name: 'search_web',
+ * //   description: 'Search the web',
+ * //   input_schema: {
+ * //     type: 'object',
+ * //     properties: { query: { type: 'string' } },
+ * //     required: ['query']
+ * //   }
+ * // }
+ * ```
+ */
+declare function convertToAnthropicFormat(tool: UniversalTool | OpenAIToolDefinition): AnthropicToolDefinition;
+/**
+ * Convert OpenAI/Universal format tool to Google Gemini format
+ *
+ * Google uses a function calling format with:
+ * - name: string
+ * - description: string
+ * - parameters: JSON schema object
+ *
+ * @param tool - Universal tool or OpenAI tool definition
+ * @returns Tool formatted for Google's functionCall
+ *
+ * @example
+ * ```typescript
+ * const googleTool = convertToGoogleFormat(universalTool);
+ * // Returns: {
+ * //   name: 'search_web',
+ * //   description: 'Search the web',
+ * //   parameters: {
+ * //     type: 'object',
+ * //     properties: { query: { type: 'string' } },
+ * //     required: ['query']
+ * //   }
+ * // }
+ * ```
+ */
+declare function convertToGoogleFormat(tool: UniversalTool | OpenAIToolDefinition): GoogleToolDefinition;
+/**
+ * Convert Anthropic format tool to Universal/OpenAI format
+ *
+ * @param tool - Anthropic format tool
+ * @returns Tool in universal OpenAI format
+ */
+declare function convertFromAnthropicFormat(tool: AnthropicToolDefinition): UniversalTool;
+/**
+ * Convert Google format tool to Universal/OpenAI format
+ *
+ * @param tool - Google format tool
+ * @returns Tool in universal OpenAI format
+ */
+declare function convertFromGoogleFormat(tool: GoogleToolDefinition): UniversalTool;
+/**
+ * Apply prompt/description length limit to a tool
+ *
+ * Modifies a tool's description if it exceeds maxBytes, appending a warning
+ * that the description was truncated. This is useful for providers with
+ * strict token limits.
+ *
+ * @param tool - Tool object (any format) with a description property
+ * @param maxBytes - Maximum bytes allowed for description (including warning)
+ * @returns Modified tool with truncated description if needed
+ *
+ * @example
+ * ```typescript
+ * const limitedTool = applyDescriptionLimit(tool, 500);
+ * // If description > 500 bytes, truncates and adds warning
+ * ```
+ */
+declare function applyDescriptionLimit<T extends {
+    description: string;
+}>(tool: T, maxBytes: number): T;
+/**
+ * Target format for tool conversion
+ */
+type ToolConvertTarget = 'openai' | 'anthropic' | 'google';
+/**
+ * Convert a universal tool to a specific provider format
+ *
+ * @param tool - Universal tool or OpenAI tool definition
+ * @param target - Target provider format
+ * @returns Tool in the target format
+ */
+declare function convertToolTo(tool: UniversalTool | OpenAIToolDefinition, target: ToolConvertTarget): UniversalTool | OpenAIToolDefinition | AnthropicToolDefinition | GoogleToolDefinition;
+/**
+ * Convert multiple tools to a specific provider format
+ *
+ * @param tools - Array of universal tools or OpenAI tool definitions
+ * @param target - Target provider format
+ * @returns Array of tools in the target format
+ */
+declare function convertToolsTo(tools: Array<UniversalTool | OpenAIToolDefinition>, target: ToolConvertTarget): Array<UniversalTool | OpenAIToolDefinition | AnthropicToolDefinition | GoogleToolDefinition>;
+/**
+ * Alias for convertToAnthropicFormat
+ * @deprecated Use convertToAnthropicFormat instead
+ */
+declare const convertOpenAIToAnthropicFormat: typeof convertToAnthropicFormat;
+/**
+ * Alias for convertToGoogleFormat
+ * @deprecated Use convertToGoogleFormat instead
+ */
+declare const convertOpenAIToGoogleFormat: typeof convertToGoogleFormat;
+
+export { type ToolCallFormat as T, type ToolConvertTarget as a, applyDescriptionLimit as b, convertFromAnthropicFormat as c, convertFromGoogleFormat as d, convertOpenAIToAnthropicFormat as e, convertOpenAIToGoogleFormat as f, convertToAnthropicFormat as g, convertToGoogleFormat as h, convertToolTo as i, convertToolsTo as j, detectToolCallFormat as k, hasToolCalls as l, parseGoogleToolCalls as m, parseOpenAIToolCalls as n, parseToolCalls as o, parseAnthropicToolCalls as p };

package/dist/index.d.mts

@@ -1,5 +1,5 @@
 export { AnthropicToolDefinition, GoogleToolDefinition, LogContext, LogLevel, OpenAIToolDefinition, PluginLogger, ToolCall, ToolCallRequest, ToolFormatOptions, ToolResult, UniversalTool, createConsoleLogger, createNoopLogger } from '@quilltap/plugin-types';
-export { ToolCallFormat, ToolConvertTarget, applyDescriptionLimit, convertFromAnthropicFormat, convertFromGoogleFormat, convertOpenAIToAnthropicFormat, convertOpenAIToGoogleFormat, convertToAnthropicFormat, convertToGoogleFormat, convertToolTo, convertToolsTo, detectToolCallFormat, hasToolCalls, parseAnthropicToolCalls, parseGoogleToolCalls, parseOpenAIToolCalls, parseToolCalls } from './tools/index.mjs';
+export { T as ToolCallFormat, a as ToolConvertTarget, b as applyDescriptionLimit, c as convertFromAnthropicFormat, d as convertFromGoogleFormat, e as convertOpenAIToAnthropicFormat, f as convertOpenAIToGoogleFormat, g as convertToAnthropicFormat, h as convertToGoogleFormat, i as convertToolTo, j as convertToolsTo, k as detectToolCallFormat, l as hasToolCalls, p as parseAnthropicToolCalls, m as parseGoogleToolCalls, n as parseOpenAIToolCalls, o as parseToolCalls } from './converters-BPYo8xdH.mjs';
 export { PluginLoggerWithChild, __clearCoreLoggerFactory, __injectCoreLoggerFactory, createPluginLogger, getLogLevelFromEnv, hasCoreLogger } from './logging/index.mjs';
 export { OpenAICompatibleProvider, OpenAICompatibleProviderConfig } from './providers/index.mjs';
 export { CreateRoleplayTemplatePluginOptions, CreateSingleTemplatePluginOptions, createRoleplayTemplatePlugin, createSingleTemplatePlugin, validateRoleplayTemplatePlugin, validateTemplateConfig } from './roleplay-templates/index.mjs';

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export { AnthropicToolDefinition, GoogleToolDefinition, LogContext, LogLevel, OpenAIToolDefinition, PluginLogger, ToolCall, ToolCallRequest, ToolFormatOptions, ToolResult, UniversalTool, createConsoleLogger, createNoopLogger } from '@quilltap/plugin-types';
-export { ToolCallFormat, ToolConvertTarget, applyDescriptionLimit, convertFromAnthropicFormat, convertFromGoogleFormat, convertOpenAIToAnthropicFormat, convertOpenAIToGoogleFormat, convertToAnthropicFormat, convertToGoogleFormat, convertToolTo, convertToolsTo, detectToolCallFormat, hasToolCalls, parseAnthropicToolCalls, parseGoogleToolCalls, parseOpenAIToolCalls, parseToolCalls } from './tools/index.js';
+export { T as ToolCallFormat, a as ToolConvertTarget, b as applyDescriptionLimit, c as convertFromAnthropicFormat, d as convertFromGoogleFormat, e as convertOpenAIToAnthropicFormat, f as convertOpenAIToGoogleFormat, g as convertToAnthropicFormat, h as convertToGoogleFormat, i as convertToolTo, j as convertToolsTo, k as detectToolCallFormat, l as hasToolCalls, p as parseAnthropicToolCalls, m as parseGoogleToolCalls, n as parseOpenAIToolCalls, o as parseToolCalls } from './converters-BPYo8xdH.js';
 export { PluginLoggerWithChild, __clearCoreLoggerFactory, __injectCoreLoggerFactory, createPluginLogger, getLogLevelFromEnv, hasCoreLogger } from './logging/index.js';
 export { OpenAICompatibleProvider, OpenAICompatibleProviderConfig } from './providers/index.js';
 export { CreateRoleplayTemplatePluginOptions, CreateSingleTemplatePluginOptions, createRoleplayTemplatePlugin, createSingleTemplatePlugin, validateRoleplayTemplatePlugin, validateTemplateConfig } from './roleplay-templates/index.js';

package/dist/index.js

@@ -95,7 +95,8 @@ function parseOpenAIToolCalls(response) {
           try {
             toolCalls.push({
               name: tc.function.name,
-              arguments: JSON.parse(argsStr)
+              arguments: JSON.parse(argsStr),
+              callId: tc.id || void 0
             });
           } catch {
             continue;
@@ -120,7 +121,8 @@ function parseAnthropicToolCalls(response) {
       if (b.type === "tool_use" && b.name) {
         toolCalls.push({
           name: b.name,
-          arguments: b.input || {}
+          arguments: b.input || {},
+          callId: b.id || void 0
         });
       }
     }
@@ -458,10 +460,33 @@ var OpenAICompatibleProvider = class {
       apiKey: this.getEffectiveApiKey(apiKey),
       baseURL: this.baseUrl
     });
-    const messages = params.messages.filter((m) => m.role !== "tool").map((m) => ({
-      role: m.role,
-      content: m.content
-    }));
+    const messages = params.messages.filter((m) => {
+      if (m.role === "tool" && !m.toolCallId) return false;
+      return true;
+    }).map((m) => {
+      if (m.role === "tool" && m.toolCallId) {
+        return {
+          role: "tool",
+          tool_call_id: m.toolCallId,
+          content: m.content
+        };
+      }
+      if (m.role === "assistant" && m.toolCalls && m.toolCalls.length > 0) {
+        return {
+          role: "assistant",
+          content: m.content || null,
+          tool_calls: m.toolCalls.map((tc) => ({
+            id: tc.id,
+            type: tc.type,
+            function: tc.function
+          }))
+        };
+      }
+      return {
+        role: m.role,
+        content: m.content
+      };
+    });
     try {
       const response = await client.chat.completions.create({
         model: params.model,
@@ -506,10 +531,33 @@ var OpenAICompatibleProvider = class {
       apiKey: this.getEffectiveApiKey(apiKey),
       baseURL: this.baseUrl
     });
-    const messages = params.messages.filter((m) => m.role !== "tool").map((m) => ({
-      role: m.role,
-      content: m.content
-    }));
+    const messages = params.messages.filter((m) => {
+      if (m.role === "tool" && !m.toolCallId) return false;
+      return true;
+    }).map((m) => {
+      if (m.role === "tool" && m.toolCallId) {
+        return {
+          role: "tool",
+          tool_call_id: m.toolCallId,
+          content: m.content
+        };
+      }
+      if (m.role === "assistant" && m.toolCalls && m.toolCalls.length > 0) {
+        return {
+          role: "assistant",
+          content: m.content || null,
+          tool_calls: m.toolCalls.map((tc) => ({
+            id: tc.id,
+            type: tc.type,
+            function: tc.function
+          }))
+        };
+      }
+      return {
+        role: m.role,
+        content: m.content
+      };
+    });
     try {
       const stream = await client.chat.completions.create({
         model: params.model,