free-antigravity-cli 1.0.0

package/src/proxy/translators/ollama.ts

@@ -0,0 +1,88 @@
+/**
+ * Ollama Translator.
+ *
+ * Ollama is fully OpenAI-compatible (channels/v1/chat/completions).
+ * This module re-exports the OpenAI translator functions and adds
+ * Ollama-specific helpers:
+ *   - Default URL normalization (localhost:11434 fallback)
+ *   - User-friendly error message translation
+ */
+
+import { log } from '../../logger';
+
+// ─── Re-export all OpenAI translator functions ────────────────────────────
+// The registry auto-discovers these by naming convention:
+//   mapGeminiToOpenAI, mapOpenAIToGemini, mapOpenAIChunkToGemini
+// Ollama uses the exact same format, so we re-export verbatim.
+
+export { mapGeminiToOpenAI, mapOpenAIToGemini, mapOpenAIChunkToGemini } from './openai';
+
+// ─── Ollama-Specific Helpers ──────────────────────────────────────────────
+
+/**
+ * Normalizes an Ollama API URL to the standard chat completions endpoint.
+ *
+ * Handles these common patterns:
+ *   http://localhost:11434              → http://localhost:11434/v1/chat/completions
+ *   http://localhost:11434/v1           → http://localhost:11434/v1/chat/completions
+ *   http://localhost                    → http://localhost:11434/v1/chat/completions
+ *   http://10.0.0.5:11434/api/generate  → kept as-is (non-chat endpoint)
+ *
+ * If localhost has no port, defaults to Ollama's standard port 11434.
+ */
+export function getOllamaApiUrl(baseUrl: string): string {
+  let url = baseUrl;
+
+  // If it already has a specific API path, don't touch it
+  if (url.includes('/api/')) {
+    return url;
+  }
+
+  // Clean trailing slash
+  url = url.replace(/\/$/, '');
+
+  // If no port on localhost, use default Ollama port
+  if (url.match(/^https?:\/\/localhost$/)) {
+    url = 'http://localhost:11434';
+    log.info('[OllamaTranslator] Added default Ollama port 11434');
+  }
+
+  // If URL ends with /v1, append /chat/completions
+  if (url.endsWith('/v1')) {
+    url += '/chat/completions';
+    return url;
+  }
+
+  // If URL doesn't have a chat completions path, add full /v1/chat/completions
+  if (!url.includes('/chat/completions') && !url.includes('/completions')) {
+    url += '/v1/chat/completions';
+  }
+
+  return url;
+}
+
+/**
+ * Translate raw Ollama errors into user-friendly messages.
+ */
+export function translateOllamaError(statusCode: number, body: string): string {
+  // Connection refused — Ollama service not running
+  if (body.includes('ECONNREFUSED') || body.includes('connect ECONNREFUSED')) {
+    return 'Ollama is not running. Start it with `ollama serve` or launch the Ollama desktop app.';
+  }
+
+  // Model not pulled yet
+  if (statusCode === 404 || (body.includes('model') && body.includes('not found'))) {
+    const modelMatch = body.match(/model ['"]([^'"]+)['"]/);
+    const modelName = modelMatch ? modelMatch[1] : 'unknown';
+    return `Ollama model "${modelName}" not found. Pull it: ollama pull ${modelName}`;
+  }
+
+  // Server-side errors (OOM, crash, etc.)
+  if (statusCode >= 500) {
+    return `Ollama server error (${statusCode}). Check if Ollama has enough resources (RAM/VRAM).`;
+  }
+
+  // Generic fallback with truncated body
+  const snippet = body.substring(0, 200);
+  return `Ollama error (${statusCode}): ${snippet}`;
+}

package/src/proxy/translators/openai.ts

@@ -0,0 +1,556 @@
+/**
+ * OpenAI/Ollama provider translator.
+ * Handles Gemini ↔ OpenAI/Ollama request/response mapping and streaming chunks.
+ */
+
+import { log } from '../../logger';
+import {
+  fixParamTypes,
+  translateToolCallToNative,
+  formatTranslatedResponse,
+  normalizeToolArgs,
+  ToolCallArgs,
+  TranslatedCallInfo,
+} from './utils';
+import {
+  modelToolCallIds,
+  modelReasoningContent,
+  activeStreamContexts,
+  translatedToolCalls,
+  stateTimestamps,
+  touchStateTimestamp,
+  StreamContext,
+} from '../shared';
+
+// ─── Types ────────────────────────────────────────────────────────────────
+
+interface GeminiTool {
+  functionDeclarations?: GeminiFunctionDeclaration[];
+}
+
+interface GeminiFunctionDeclaration {
+  name: string;
+  description?: string;
+  parameters?: GeminiParameters;
+}
+
+interface GeminiParameters {
+  type: string;
+  properties?: Record<string, unknown>;
+}
+
+interface OpenAITool {
+  type: 'function';
+  function: {
+    name: string;
+    description: string;
+    parameters: Record<string, unknown>;
+  };
+}
+
+interface GeminiContent {
+  role?: string;
+  parts?: GeminiPart[];
+}
+
+interface GeminiPart {
+  text?: string;
+  thought?: boolean;
+  functionCall?: GeminiFunctionCall;
+  functionResponse?: GeminiFunctionResponse;
+}
+
+interface GeminiFunctionCall {
+  name: string;
+  args: Record<string, unknown>;
+  id?: string;
+}
+
+interface GeminiFunctionResponse {
+  name: string;
+  response: unknown;
+  id?: string;
+}
+
+interface GeminiRequestBody {
+  systemInstruction?: { parts: GeminiPart[] };
+  contents?: GeminiContent[];
+  tools?: GeminiTool[];
+  generationConfig?: {
+    temperature?: number;
+    maxOutputTokens?: number;
+  };
+}
+
+interface OpenAIMessage {
+  role: string;
+  content: string | null;
+  tool_calls?: OpenAIToolCall[];
+  tool_call_id?: string;
+  reasoning_content?: string;
+}
+
+interface OpenAIToolCall {
+  id: string;
+  type: 'function';
+  function: {
+    name: string;
+    arguments: string;
+  };
+}
+
+interface OpenAIRequestBody {
+  model: string;
+  messages: OpenAIMessage[];
+  temperature?: number;
+  max_tokens?: number;
+  tools?: OpenAITool[];
+  stream?: boolean;
+}
+
+interface OpenAIResponse {
+  choices?: OpenAIChoice[];
+  usage?: {
+    prompt_tokens: number;
+    completion_tokens: number;
+    total_tokens: number;
+  };
+}
+
+interface OpenAIChoice {
+  message?: {
+    content: string;
+    reasoning_content?: string;
+    reasoning?: string;
+    tool_calls?: OpenAIToolCall[];
+  };
+  finish_reason?: string;
+  delta?: {
+    content?: string;
+    reasoning_content?: string;
+    reasoning?: string;
+    tool_calls?: OpenAIToolCallDelta[];
+  };
+}
+
+interface OpenAIToolCallDelta {
+  index?: number;
+  id?: string;
+  function?: {
+    name?: string;
+    arguments?: string;
+  };
+}
+
+interface GeminiGenerateContentResponse {
+  candidates: GeminiCandidate[];
+  usageMetadata?: GeminiUsageMetadata;
+}
+
+interface GeminiCandidate {
+  content: {
+    parts: GeminiPart[];
+    role: string;
+  };
+  finishReason: string;
+  index: number;
+}
+
+interface GeminiUsageMetadata {
+  promptTokenCount: number;
+  candidatesTokenCount: number;
+  totalTokenCount: number;
+}
+
+interface DSMLParsedResult {
+  functionCalls: { name: string; args: Record<string, unknown> }[];
+  cleanText: string;
+}
+
+// ─── REQUEST: Gemini → OpenAI ──────────────────────────────────────────────
+
+function mapGeminiToolsToOpenAI(geminiTools: GeminiTool[]): OpenAITool[] {
+  if (!geminiTools || !Array.isArray(geminiTools)) return [];
+  const openaiTools: OpenAITool[] = [];
+  for (const toolGroup of geminiTools) {
+    if (toolGroup.functionDeclarations && Array.isArray(toolGroup.functionDeclarations)) {
+      for (const func of toolGroup.functionDeclarations) {
+        const params = func.parameters
+          ? (JSON.parse(JSON.stringify(func.parameters)) as Record<string, unknown>)
+          : { type: 'object', properties: {} };
+        if (params.type && typeof params.type === 'string') {
+          (params as Record<string, string>).type = (params.type as string).toLowerCase();
+        }
+        if (params.properties) {
+          fixParamTypes(params.properties as Record<string, unknown>);
+        }
+        openaiTools.push({
+          type: 'function',
+          function: {
+            name: func.name,
+            description: func.description || '',
+            parameters: params,
+          },
+        });
+      }
+    }
+  }
+  return openaiTools;
+}
+
+export function mapGeminiToOpenAI(geminiBody: GeminiRequestBody, modelName: string): OpenAIRequestBody {
+  const messages: OpenAIMessage[] = [];
+
+  if (geminiBody.systemInstruction && geminiBody.systemInstruction.parts) {
+    const systemText = geminiBody.systemInstruction.parts.map((p) => p.text || '').join('');
+    if (systemText) {
+      messages.push({ role: 'system', content: systemText });
+    }
+  }
+
+  if (geminiBody.contents) {
+    for (const item of geminiBody.contents) {
+      if (item.parts) {
+        const hasFunctionCall = item.parts.some((p) => p.functionCall);
+        const hasFunctionResponse = item.parts.some((p) => p.functionResponse);
+
+        if (hasFunctionCall && item.role === 'model') {
+          const toolCalls: OpenAIToolCall[] = [];
+          for (const p of item.parts) {
+            if (p.functionCall) {
+              const callId = p.functionCall.id || 'call_' + Math.random().toString(36).slice(2, 10);
+              let originalName = p.functionCall.name;
+              let originalArgs = p.functionCall.args;
+              const translatedInfo = translatedToolCalls.get(callId);
+              if (translatedInfo) {
+                originalName = translatedInfo.originalName;
+                originalArgs = { CommandLine: translatedInfo.cmd, Cwd: translatedInfo.cwd };
+              }
+              toolCalls.push({
+                id: callId,
+                type: 'function',
+                function: {
+                  name: originalName,
+                  arguments: typeof originalArgs === 'string' ? originalArgs : JSON.stringify(originalArgs || {}),
+                },
+              });
+            }
+          }
+          messages.push({ role: 'assistant', content: null, tool_calls: toolCalls });
+        } else if (hasFunctionResponse) {
+          for (const p of item.parts) {
+            if (p.functionResponse) {
+              const funcName = p.functionResponse.name || '';
+              const modelTCIds = modelToolCallIds.get(modelName) || {};
+              const toolCallId = p.functionResponse.id || modelTCIds[funcName] || 'call_' + funcName;
+              const responseData = p.functionResponse.response;
+              let contentStr = '';
+              const translatedInfo = translatedToolCalls.get(toolCallId);
+              if (translatedInfo) {
+                contentStr = formatTranslatedResponse(translatedInfo, responseData);
+              } else {
+                contentStr = typeof responseData === 'string' ? responseData : JSON.stringify(responseData || {});
+              }
+              messages.push({ role: 'tool', content: contentStr, tool_call_id: toolCallId });
+            }
+          }
+        } else {
+          const role = item.role === 'model' ? 'assistant' : item.role || 'user';
+          let content = '';
+          let reasoning_content = '';
+          if (role === 'assistant') {
+            const regularParts = (item.parts || []).filter((p) => !p.thought);
+            const thoughtParts = (item.parts || []).filter((p) => p.thought);
+            content = regularParts.map((p) => p.text || '').join('');
+            reasoning_content = thoughtParts.map((p) => p.text || '').join('');
+          } else {
+            content = (item.parts || []).map((p) => p.text || '').join('');
+          }
+          const msg: OpenAIMessage = { role, content };
+          if (reasoning_content) msg.reasoning_content = reasoning_content;
+          messages.push(msg);
+        }
+      }
+    }
+  }
+
+  // Inject reasoning_content into assistant messages missing it
+  let lastAssistantIdx = -1;
+  for (let i = 0; i < messages.length; i++) {
+    if (messages[i].role === 'assistant') lastAssistantIdx = i;
+  }
+  for (let i = 0; i < messages.length; i++) {
+    if (messages[i].role === 'assistant' && !(messages[i] as OpenAIMessage).reasoning_content) {
+      const preservedReasoning = modelReasoningContent.get(modelName) || '';
+      messages[i].reasoning_content = i === lastAssistantIdx && preservedReasoning ? preservedReasoning : '';
+    }
+  }
+
+  const payload: OpenAIRequestBody = {
+    model: modelName,
+    messages,
+    temperature: geminiBody.generationConfig?.temperature ?? 0.7,
+    max_tokens: geminiBody.generationConfig?.maxOutputTokens ?? 4000,
+  };
+
+  if (geminiBody.tools && Array.isArray(geminiBody.tools)) {
+    const openaiTools = mapGeminiToolsToOpenAI(geminiBody.tools);
+    if (openaiTools.length > 0) payload.tools = openaiTools;
+  }
+
+  return payload;
+}
+
+// ─── RESPONSE: OpenAI → Gemini ─────────────────────────────────────────────
+
+function parseDSMLToolCalls(text: string): DSMLParsedResult | null {
+  try {
+    const invokeRegex = /<DSML\|invoke name="([^"]+)">([\s\S]*?)<\/DSML\|invoke>/g;
+    const functionCalls: { name: string; args: Record<string, unknown> }[] = [];
+    let invokeMatch: RegExpExecArray | null;
+    while ((invokeMatch = invokeRegex.exec(text)) !== null) {
+      const funcName = invokeMatch[1];
+      const paramsBlock = invokeMatch[2];
+      const args: Record<string, unknown> = {};
+      const paramRegex = /<DSML\|parameter name="([^"]+)"(?: string="([^"]+)")?>([\s\S]*?)<\/DSML\|parameter>/g;
+      let paramMatch: RegExpExecArray | null;
+      while ((paramMatch = paramRegex.exec(paramsBlock)) !== null) {
+        const paramName = paramMatch[1];
+        let paramValue: unknown = paramMatch[3].trim();
+        const isString = paramMatch[2] === 'true';
+        if (!isString) {
+          try {
+            paramValue = JSON.parse(paramValue as string);
+          } catch (e) {
+            log.debug('[OpenAI] DSML param parse fallback:', (e as Error).message); /* keep as string */
+          }
+        }
+        args[paramName] = paramValue;
+      }
+      functionCalls.push({ name: funcName, args });
+    }
+    if (functionCalls.length === 0) return null;
+    log.info(
+      `[Proxy] Detected ${functionCalls.length} DSML tool call(s): ${functionCalls.map((f) => f.name).join(', ')}`,
+    );
+    let cleanText = text;
+    cleanText = cleanText.replace(/<DSML\|tool_calls>[\s\S]*?<\/DSML\|tool_calls>/g, '');
+    cleanText = cleanText.replace(/<DSML\|invoke name="[^"]+">[\s\S]*?<\/DSML\|invoke>/g, '');
+    cleanText = cleanText.trim();
+    return { functionCalls, cleanText };
+  } catch (e) {
+    log.error('[Proxy] Failed to parse DSML tool calls:', e);
+    return null;
+  }
+}
+
+export function mapOpenAIToGemini(openAiRes: OpenAIResponse, modelName: string): GeminiGenerateContentResponse {
+  const choice = openAiRes.choices?.[0];
+
+  if (choice?.message?.tool_calls && choice.message.tool_calls.length > 0) {
+    const parts: GeminiPart[] = choice.message.tool_calls.map((tc) => {
+      let args: ToolCallArgs;
+      try {
+        args =
+          typeof tc.function.arguments === 'string'
+            ? JSON.parse(tc.function.arguments)
+            : (tc.function.arguments as unknown as ToolCallArgs);
+      } catch (e) {
+        log.debug('[OpenAI] Tool call args parse fallback:', (e as Error).message);
+        args = {};
+      }
+      args = normalizeToolArgs(tc.function.name, args) as ToolCallArgs;
+      const modelTCIds = modelToolCallIds.get(modelName) || {};
+      modelTCIds[tc.function.name] = tc.id;
+      modelToolCallIds.set(modelName, modelTCIds);
+      touchStateTimestamp(stateTimestamps.toolCallIds, modelName);
+      const translated = translateToolCallToNative(tc.function.name, args);
+      if (translated.name !== tc.function.name) {
+        translated.args = normalizeToolArgs(translated.name, translated.args) as Record<string, unknown>;
+        translatedToolCalls.set(tc.id, {
+          originalName: tc.function.name,
+          translatedName: translated.name,
+          cmd: args.CommandLine || '',
+          cwd: args.Cwd || '',
+        });
+        touchStateTimestamp(stateTimestamps.translatedCalls, tc.id);
+      }
+      return { functionCall: { name: translated.name, args: translated.args as Record<string, unknown>, id: tc.id } };
+    });
+    return {
+      candidates: [{ content: { parts, role: 'model' }, finishReason: 'TOOL_CALL', index: 0 }],
+      usageMetadata: {
+        promptTokenCount: openAiRes.usage?.prompt_tokens || 0,
+        candidatesTokenCount: openAiRes.usage?.completion_tokens || 0,
+        totalTokenCount: openAiRes.usage?.total_tokens || 0,
+      },
+    };
+  }
+
+  const text = choice?.message?.content || '';
+  const dsml = parseDSMLToolCalls(text);
+  if (dsml && dsml.functionCalls.length > 0) {
+    const parts: GeminiPart[] = dsml.functionCalls.map((fc) => {
+      const na = normalizeToolArgs(fc.name, fc.args);
+      const tr = translateToolCallToNative(fc.name, na);
+      return { functionCall: { name: tr.name, args: tr.args as Record<string, unknown> } };
+    });
+    if (dsml.cleanText) parts.unshift({ text: dsml.cleanText });
+    return {
+      candidates: [{ content: { parts, role: 'model' }, finishReason: 'TOOL_CALL', index: 0 }],
+      usageMetadata: {
+        promptTokenCount: openAiRes.usage?.prompt_tokens || 0,
+        candidatesTokenCount: openAiRes.usage?.completion_tokens || 0,
+        totalTokenCount: openAiRes.usage?.total_tokens || 0,
+      },
+    };
+  }
+
+  const reasoning = choice?.message?.reasoning_content || choice?.message?.reasoning || '';
+  const parts: GeminiPart[] = [];
+  if (reasoning) parts.push({ text: reasoning, thought: true });
+  if (text) parts.push({ text });
+  const finishReason = choice?.finish_reason === 'stop' ? 'STOP' : 'OTHER';
+  return {
+    candidates: [{ content: { parts, role: 'model' }, finishReason, index: 0 }],
+    usageMetadata: {
+      promptTokenCount: openAiRes.usage?.prompt_tokens || 0,
+      candidatesTokenCount: openAiRes.usage?.completion_tokens || 0,
+      totalTokenCount: openAiRes.usage?.total_tokens || 0,
+    },
+  };
+}
+
+// ─── STREAM CHUNK: OpenAI → Gemini ────────────────────────────────────────
+
+export function mapOpenAIChunkToGemini(chunk: OpenAIResponse, modelName: string): GeminiCandidate | null {
+  const choice = chunk.choices?.[0];
+  if (!choice) return null;
+  const delta = choice.delta;
+  const streamId = ((chunk as Record<string, unknown>).id as string) || 'default_stream';
+
+  if (!activeStreamContexts.has(streamId)) {
+    activeStreamContexts.set(streamId, { accumulatedText: '', accumulatedReasoning: '', toolCalls: {} });
+    touchStateTimestamp(stateTimestamps.streamCtx, streamId);
+  }
+  const context = activeStreamContexts.get(streamId)!;
+
+  if (delta?.tool_calls && Array.isArray(delta.tool_calls)) {
+    for (const tc of delta.tool_calls) {
+      const idx = tc.index ?? 0;
+      if (!context.toolCalls[idx]) context.toolCalls[idx] = { id: '', name: '', arguments: '' };
+      if (tc.id) context.toolCalls[idx].id = tc.id;
+      if (tc.function?.name) context.toolCalls[idx].name += tc.function.name;
+      if (tc.function?.arguments) context.toolCalls[idx].arguments += tc.function.arguments;
+    }
+  }
+
+  let text = delta?.content || '';
+  const reasoning = delta?.reasoning_content || delta?.reasoning || '';
+  if (reasoning) {
+    context.accumulatedReasoning += reasoning;
+    return { content: { parts: [{ text: reasoning, thought: true }], role: 'model' }, finishReason: 'OTHER', index: 0 };
+  }
+  if (text) context.accumulatedText += text;
+
+  const dsml = parseDSMLToolCalls(context.accumulatedText);
+  if (dsml && dsml.functionCalls.length > 0) {
+    const parts: GeminiPart[] = dsml.functionCalls.map((fc) => {
+      const na = normalizeToolArgs(fc.name, fc.args);
+      const tr = translateToolCallToNative(fc.name, na);
+      return { functionCall: { name: tr.name, args: tr.args as Record<string, unknown> } };
+    });
+    context.accumulatedText = '';
+    return { content: { parts, role: 'model' }, finishReason: 'TOOL_CALL', index: 0 };
+  }
+
+  const finishReason = choice.finish_reason;
+  if (finishReason === 'stop' || finishReason === 'length') {
+    // Check for pending native tool_calls before closing stream
+    const pendingToolCalls = Object.values(context.toolCalls).filter((tc) => tc.name && tc.arguments);
+    if (pendingToolCalls.length > 0) {
+      const parts: GeminiPart[] = pendingToolCalls.map((tc) => {
+        let args: ToolCallArgs = {};
+        try {
+          args = JSON.parse(tc.arguments);
+        } catch (_e) {
+          args = {};
+        }
+        args = normalizeToolArgs(tc.name, args) as ToolCallArgs;
+        const modelTCIds = modelToolCallIds.get(modelName) || {};
+        modelTCIds[tc.name] = tc.id;
+        modelToolCallIds.set(modelName, modelTCIds);
+        touchStateTimestamp(stateTimestamps.toolCallIds, modelName);
+        const translated = translateToolCallToNative(tc.name, args);
+        if (translated.name !== tc.name) {
+          translatedToolCalls.set(tc.id, {
+            originalName: tc.name,
+            translatedName: translated.name,
+            cmd: args.CommandLine || '',
+            cwd: args.Cwd || '',
+          });
+          touchStateTimestamp(stateTimestamps.translatedCalls, tc.id);
+        }
+        return { functionCall: { name: translated.name, args: translated.args as Record<string, unknown>, id: tc.id } };
+      });
+      activeStreamContexts.delete(streamId);
+      return { content: { parts, role: 'model' }, finishReason: 'TOOL_CALL', index: 0 };
+    }
+    // Check for accumulated DSML tool calls
+    if (context.accumulatedText) {
+      const dsml2 = parseDSMLToolCalls(context.accumulatedText);
+      if (dsml2 && dsml2.functionCalls.length > 0) {
+        const parts: GeminiPart[] = dsml2.functionCalls.map((fc) => {
+          const na = normalizeToolArgs(fc.name, fc.args);
+          const tr = translateToolCallToNative(fc.name, na);
+          return { functionCall: { name: tr.name, args: tr.args as Record<string, unknown> } };
+        });
+        if (dsml2.cleanText) parts.unshift({ text: dsml2.cleanText });
+        activeStreamContexts.delete(streamId);
+        return { content: { parts, role: 'model' }, finishReason: 'TOOL_CALL', index: 0 };
+      }
+    }
+    activeStreamContexts.delete(streamId);
+    return { content: { parts: text ? [{ text }] : [], role: 'model' }, finishReason: 'STOP', index: 0 };
+  }
+
+  // Only emit tool calls when finishReason signals completion (args are fully accumulated)
+  if (finishReason === 'tool_calls') {
+    const parts: GeminiPart[] = Object.values(context.toolCalls).map((tc) => {
+      let args: ToolCallArgs = {};
+      try {
+        args = JSON.parse(tc.arguments);
+      } catch (e) {
+        log.debug('[OpenAI] Stream tool args parse fallback:', (e as Error).message);
+        args = {};
+      }
+      args = normalizeToolArgs(tc.name, args) as ToolCallArgs;
+      const modelTCIds = modelToolCallIds.get(modelName) || {};
+      modelTCIds[tc.name] = tc.id;
+      modelToolCallIds.set(modelName, modelTCIds);
+      touchStateTimestamp(stateTimestamps.toolCallIds, modelName);
+      const translated = translateToolCallToNative(tc.name, args);
+      if (translated.name !== tc.name) {
+        translated.args = normalizeToolArgs(translated.name, translated.args) as Record<string, unknown>;
+        translatedToolCalls.set(tc.id, {
+          originalName: tc.name,
+          translatedName: translated.name,
+          cmd: args.CommandLine || '',
+          cwd: args.Cwd || '',
+        });
+        touchStateTimestamp(stateTimestamps.translatedCalls, tc.id);
+      }
+      return { functionCall: { name: translated.name, args: translated.args as Record<string, unknown>, id: tc.id } };
+    });
+    activeStreamContexts.delete(streamId);
+    return { content: { parts, role: 'model' }, finishReason: 'TOOL_CALL', index: 0 };
+  }
+
+  if (text) {
+    return { content: { parts: [{ text }], role: 'model' }, finishReason: 'OTHER', index: 0 };
+  }
+
+  return null;
+}
+
+export { mapGeminiToolsToOpenAI };