thebird 1.2.36 → 1.2.38

package/CHANGELOG.md

@@ -1,3 +1,9 @@
+## [Unreleased]
+
+### Fixed
+- Gemini tool result wrapping: string results wrapped as `{ output: result }` to satisfy Gemini Struct requirement for `function_response.response`
+- Browser bundle rebuilt with fix
+
 ## [Unreleased - agent-tools]
 
 ### Added

package/docs/agent-chat.js

@@ -1,4 +1,4 @@
-import { streamGemini } from './vendor/thebird-browser.js';
+import { streamGemini, streamOpenAI } from './vendor/thebird-browser.js';
 
 function idbRead(path) {
   const snap = window.__debug.idbSnapshot;
@@ -85,12 +85,20 @@ const TOOLS = {
   },
 };
 
-export async function agentGenerate(apiKey, model, messages, onChunk, onTool) {
+function buildStream(provider) {
+  if (provider.type === 'gemini') {
+    return streamGemini({ model: provider.model, messages: provider.messages, tools: TOOLS, apiKey: provider.apiKey, maxOutputTokens: 8192 }).fullStream;
+  }
+  const url = (provider.baseUrl || '').replace(/\/$/, '') + '/chat/completions';
+  return streamOpenAI({ url, apiKey: provider.apiKey, messages: provider.messages, model: provider.model, tools: TOOLS, maxOutputTokens: 8192 });
+}
+
+export async function agentGenerate(provider, messages, onChunk, onTool) {
   Object.assign(window.__debug = window.__debug || {}, {
-    agent: { model, active: true, lastTool: null },
+    agent: { provider: provider.type, model: provider.model, active: true, lastTool: null },
   });
   try {
-    for await (const ev of streamGemini({ model, messages, tools: TOOLS, apiKey, maxOutputTokens: 8192 }).fullStream) {
+    for await (const ev of buildStream({ ...provider, messages })) {
       if (ev.type === 'text-delta') onChunk(ev.textDelta);
       else if (ev.type === 'tool-call') {
         window.__debug.agent.lastTool = { name: ev.toolName, args: ev.args };

package/docs/app.js

@@ -3,10 +3,18 @@ import { agentGenerate } from './agent-chat.js';
 
 const html = htm.bind(createElement);
 
-const BASE = 'https://generativelanguage.googleapis.com/v1beta';
+const PROVIDERS = {
+  gemini:   { label: 'Google Gemini',   baseUrl: 'https://generativelanguage.googleapis.com/v1beta', keyPlaceholder: 'GEMINI_API_KEY', models: [] },
+  openai:   { label: 'OpenAI',          baseUrl: 'https://api.openai.com/v1',                        keyPlaceholder: 'OPENAI_API_KEY', models: ['gpt-4.1', 'gpt-4o', 'gpt-4o-mini', 'o3', 'o4-mini'] },
+  xai:      { label: 'xAI Grok',        baseUrl: 'https://api.x.ai/v1',                              keyPlaceholder: 'XAI_API_KEY',    models: ['grok-3', 'grok-3-mini', 'grok-3-fast'] },
+  groq:     { label: 'Groq',            baseUrl: 'https://api.groq.com/openai/v1',                   keyPlaceholder: 'GROQ_API_KEY',   models: ['llama-3.3-70b-versatile', 'llama-3.1-8b-instant', 'mixtral-8x7b-32768'] },
+  mistral:  { label: 'Mistral',         baseUrl: 'https://api.mistral.ai/v1',                        keyPlaceholder: 'MISTRAL_API_KEY', models: ['mistral-large-latest', 'mistral-small-latest', 'codestral-latest'] },
+  deepseek: { label: 'DeepSeek',        baseUrl: 'https://api.deepseek.com/v1',                      keyPlaceholder: 'DEEPSEEK_API_KEY', models: ['deepseek-chat', 'deepseek-reasoner'] },
+  custom:   { label: 'Custom (OpenAI-compat)', baseUrl: '',                                           keyPlaceholder: 'API_KEY',        models: [] },
+};
 
-async function fetchModels(apiKey) {
-  const res = await fetch(`${BASE}/models?key=${apiKey}`);
+async function fetchGeminiModels(apiKey) {
+  const res = await fetch(`https://generativelanguage.googleapis.com/v1beta/models?key=${apiKey}`);
   if (!res.ok) throw new Error(`Models API ${res.status}`);
   const { models = [] } = await res.json();
   return models
@@ -14,13 +22,35 @@ async function fetchModels(apiKey) {
     .map(m => ({ id: m.name.replace('models/', ''), label: m.displayName || m.name }));
 }
 
+async function fetchOpenAIModels(baseUrl, apiKey) {
+  const url = baseUrl.replace(/\/$/, '') + '/models';
+  const res = await fetch(url, { headers: { 'Authorization': `Bearer ${apiKey}` } });
+  if (!res.ok) throw new Error(`Models API ${res.status}`);
+  const { data = [] } = await res.json();
+  return data.map(m => ({ id: m.id, label: m.id })).sort((a, b) => a.id.localeCompare(b.id));
+}
+
+async function fetchModels(providerType, baseUrl, apiKey) {
+  if (providerType === 'gemini') return fetchGeminiModels(apiKey);
+  const staticModels = PROVIDERS[providerType]?.models || [];
+  try {
+    return await fetchOpenAIModels(baseUrl, apiKey);
+  } catch {
+    return staticModels.map(id => ({ id, label: id }));
+  }
+}
 
 class BirdChat extends HTMLElement {
   constructor() {
     super();
+    const savedProvider = localStorage.getItem('provider_type') || 'gemini';
+    const savedBaseUrl = localStorage.getItem('provider_base_url') || PROVIDERS[savedProvider]?.baseUrl || '';
     this.state = {
-      messages: [], streaming: false, model: 'gemini-2.5-flash',
-      apiKey: localStorage.getItem('gemini_api_key') || '',
+      messages: [], streaming: false,
+      providerType: savedProvider,
+      baseUrl: savedBaseUrl,
+      model: localStorage.getItem('provider_model') || (savedProvider === 'gemini' ? 'gemini-2.5-flash' : (PROVIDERS[savedProvider]?.models[0] || '')),
+      apiKey: localStorage.getItem('provider_api_key') || '',
       models: [], modelsLoading: false, status: '', streamingText: '',
     };
     const self = this;
@@ -33,15 +63,16 @@ class BirdChat extends HTMLElement {
 
   connectedCallback() {
     this.render();
-    if (this.state.apiKey) this.loadModels(this.state.apiKey);
+    if (this.state.apiKey) this.loadModels();
   }
 
   setState(patch) { Object.assign(this.state, patch); this.render(); }
 
-  async loadModels(apiKey) {
+  async loadModels() {
+    const { providerType, baseUrl, apiKey } = this.state;
     this.setState({ modelsLoading: true, status: '' });
     try {
-      const models = await fetchModels(apiKey);
+      const models = await fetchModels(providerType, baseUrl, apiKey);
       const current = this.state.model;
       const model = models.find(m => m.id === current) ? current : (models[0]?.id || current);
       this.setState({ models, model, modelsLoading: false });
@@ -50,25 +81,48 @@ class BirdChat extends HTMLElement {
     }
   }
 
+  setProvider(type) {
+    const def = PROVIDERS[type] || {};
+    const baseUrl = type === 'custom' ? '' : (def.baseUrl || '');
+    const model = def.models?.[0] || '';
+    localStorage.setItem('provider_type', type);
+    localStorage.setItem('provider_base_url', baseUrl);
+    localStorage.setItem('provider_model', model);
+    this.setState({ providerType: type, baseUrl, model, models: [], apiKey: localStorage.getItem('provider_api_key') || '' });
+  }
+
   render() {
-    const { messages, streaming, model, apiKey, models, modelsLoading, status, streamingText } = this.state;
-    const opts = (models.length === 0 ? [{ id: model, label: model }] : models)
+    const { messages, streaming, model, apiKey, models, modelsLoading, status, providerType, baseUrl } = this.state;
+    const provDef = PROVIDERS[providerType] || PROVIDERS.custom;
+    const opts = (models.length === 0 ? (provDef.models.length ? provDef.models.map(id => ({ id, label: id })) : [{ id: model, label: model }]) : models)
       .map(m => html`<option value=${m.id} selected=${m.id === model}>${m.label}</option>`);
+    const provOpts = Object.entries(PROVIDERS).map(([id, p]) =>
+      html`<option value=${id} selected=${id === providerType}>${p.label}</option>`);
 
     applyDiff(this, html`
       <div class="flex flex-col h-full">
         <header class="navbar bg-base-200 border-b border-base-300 gap-2 flex-wrap px-4 py-2">
           <span class="text-primary font-bold text-lg mr-2">🐦 thebird</span>
-          <span class="text-base-content/50 text-xs hidden sm:inline">Anthropic SDK format → Gemini API</span>
           <div class="flex gap-2 flex-1 min-w-0 items-center flex-wrap">
-            <input id="api-key-input" type="password" class="input input-sm input-bordered flex-1 min-w-[160px]"
-              placeholder="GEMINI_API_KEY" value=${apiKey}
-              onchange=${e => { const v = e.target.value.trim(); localStorage.setItem('gemini_api_key', v); this.setState({ apiKey: v }); if (v) this.loadModels(v); }} />
+            <select class="select select-sm select-bordered"
+              onchange=${e => this.setProvider(e.target.value)}>${provOpts}</select>
+            ${providerType === 'custom' ? html`
+              <input type="text" class="input input-sm input-bordered flex-1 min-w-[160px]"
+                placeholder="https://your-endpoint/v1" value=${baseUrl}
+                onchange=${e => { localStorage.setItem('provider_base_url', e.target.value); this.setState({ baseUrl: e.target.value }); }} />` : ''}
+            <input id="api-key-input" type="password" class="input input-sm input-bordered flex-1 min-w-[140px]"
+              placeholder=${provDef.keyPlaceholder} value=${apiKey}
+              onchange=${e => {
+                const v = e.target.value.trim();
+                localStorage.setItem('provider_api_key', v);
+                this.setState({ apiKey: v });
+                if (v) this.loadModels();
+              }} />
             <div class="relative">
               ${modelsLoading
                 ? html`<span class="loading loading-spinner loading-sm text-primary"></span>`
-                : html`<select class="select select-sm select-bordered" value=${model} disabled=${models.length === 0}
-                    onchange=${e => this.setState({ model: e.target.value })}>${opts}</select>`}
+                : html`<select class="select select-sm select-bordered" value=${model}
+                    onchange=${e => { localStorage.setItem('provider_model', e.target.value); this.setState({ model: e.target.value }); }}>${opts}</select>`}
             </div>
             <button class="btn btn-sm btn-ghost" onclick=${() => this.setState({ messages: [], status: '' })}>Clear</button>
           </div>
@@ -100,12 +154,13 @@ class BirdChat extends HTMLElement {
     const input = this.querySelector('#chat-input');
     const text = input?.value.trim();
     if (!text || this.state.streaming) return;
-    const { apiKey, model } = this.state;
-    if (!apiKey) { this.setState({ status: 'Enter a Gemini API key above.' }); return; }
+    const { apiKey, model, providerType, baseUrl } = this.state;
+    if (!apiKey) { this.setState({ status: 'Enter an API key above.' }); return; }
     input.value = '';
     input.style.height = 'auto';
     const messages = [...this.state.messages, { role: 'user', content: text }];
     this.setState({ messages, streaming: true, status: '', streamingText: '' });
+    const provider = { type: providerType, apiKey, model, baseUrl: providerType === 'gemini' ? '' : baseUrl };
     try {
       let full = '';
       const streamEl = document.createElement('div');
@@ -119,7 +174,7 @@ class BirdChat extends HTMLElement {
       wrap.appendChild(cursor);
       const list = this.querySelector('#msg-list');
       if (list) list.appendChild(wrap);
-      await agentGenerate(apiKey, model, messages,
+      await agentGenerate(provider, messages,
         chunk => { full += chunk; streamEl.textContent = full; const l = this.querySelector('#msg-list'); if (l) l.scrollTop = l.scrollHeight; },
         (name, args) => { full += `\n[tool: ${name}(${JSON.stringify(args)})]\n`; streamEl.textContent = full; }
       );

package/docs/vendor/thebird-browser.js

@@ -18321,10 +18321,7 @@ var require_thebird_browser_entry = __commonJS({
     var { GeminiError, withRetry } = require_errors();
     var { convertMessages, convertTools, cleanSchema, extractModelId, buildConfig } = require_convert();
     function streamGemini2({ model, system, messages, tools, onStepFinish, apiKey, temperature, maxOutputTokens, topP, topK, safetySettings, responseModalities }) {
-      return {
-        fullStream: createFullStream({ model, system, messages, tools, onStepFinish, apiKey, temperature, maxOutputTokens, topP, topK, safetySettings, responseModalities }),
-        warnings: Promise.resolve([])
-      };
+      return { fullStream: createFullStream({ model, system, messages, tools, onStepFinish, apiKey, temperature, maxOutputTokens, topP, topK, safetySettings, responseModalities }), warnings: Promise.resolve([]) };
     }
     async function* createFullStream({ model, system, messages, tools, onStepFinish, apiKey, temperature, maxOutputTokens, topP, topK, safetySettings, responseModalities }) {
       const client = getClient(apiKey);
@@ -18366,7 +18363,7 @@ var require_thebird_browser_entry = __commonJS({
               }
             }
             yield { type: "tool-result", toolCallId: toolId, toolName: name, args, result };
-            toolResultParts.push({ functionResponse: { name, response: result || {} } });
+            toolResultParts.push({ functionResponse: { name, response: typeof result === "string" ? { output: result } : result || {} } });
           }
           yield { type: "finish-step", finishReason: "tool-calls" };
           if (onStepFinish) await onStepFinish();
@@ -18408,13 +18405,148 @@ var require_thebird_browser_entry = __commonJS({
               result = { error: true, message: e.message };
             }
           }
-          toolResultParts.push({ functionResponse: { name, response: result || {} } });
+          toolResultParts.push({ functionResponse: { name, response: typeof result === "string" ? { output: result } : result || {} } });
         }
         contents.push({ role: "model", parts: allParts });
         contents.push({ role: "user", parts: toolResultParts });
       }
     }
-    module.exports = { streamGemini: streamGemini2, generateGemini: generateGemini2 };
+    function convertMessagesOAI(messages, system) {
+      const result = [];
+      if (system) result.push({ role: "system", content: typeof system === "string" ? system : JSON.stringify(system) });
+      for (const m of messages) {
+        if (typeof m.content === "string") {
+          result.push({ role: m.role, content: m.content });
+          continue;
+        }
+        if (!Array.isArray(m.content)) continue;
+        const toolCalls = m.content.filter((b) => b.type === "tool_use");
+        const toolResults = m.content.filter((b) => b.type === "tool_result");
+        if (toolResults.length) {
+          for (const b of toolResults) {
+            const c = typeof b.content === "string" ? b.content : JSON.stringify(b.content || "");
+            result.push({ role: "tool", tool_call_id: b.tool_use_id || b.id || b.name, content: c });
+          }
+          continue;
+        }
+        const textParts = m.content.filter((b) => b.type === "text").map((b) => b.text).join("");
+        if (toolCalls.length) {
+          result.push({
+            role: "assistant",
+            content: textParts || null,
+            tool_calls: toolCalls.map((b) => ({
+              id: b.id || "call_" + Math.random().toString(36).slice(2, 8),
+              type: "function",
+              function: { name: b.name, arguments: JSON.stringify(b.input || {}) }
+            }))
+          });
+        } else {
+          result.push({ role: m.role, content: textParts });
+        }
+      }
+      return result;
+    }
+    function convertToolsOAI(tools) {
+      if (!tools || typeof tools !== "object") return void 0;
+      const list = Object.entries(tools).map(([name, t]) => ({
+        type: "function",
+        function: {
+          name,
+          description: t.description || "",
+          parameters: t.parameters?.jsonSchema || t.parameters || { type: "object" }
+        }
+      }));
+      return list.length ? list : void 0;
+    }
+    async function* streamOpenAI2({ url, apiKey, messages, system, model, tools, maxOutputTokens, temperature, onStepFinish }) {
+      const oaiMsgs = convertMessagesOAI(messages, system);
+      const oaiTools = convertToolsOAI(tools);
+      let body = { messages: oaiMsgs, model, max_tokens: maxOutputTokens || 8192, temperature: temperature ?? 0.5 };
+      if (oaiTools) body.tools = oaiTools;
+      while (true) {
+        yield { type: "start-step" };
+        const res = await fetch(url, {
+          method: "POST",
+          headers: { "Content-Type": "application/json", "Authorization": `Bearer ${apiKey}` },
+          body: JSON.stringify({ ...body, stream: true })
+        });
+        if (!res.ok) {
+          const t = await res.text();
+          throw new Error(t);
+        }
+        const reader = res.body.getReader();
+        const dec = new TextDecoder();
+        let buf = "", toolCallsMap = {};
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done) break;
+            buf += dec.decode(value, { stream: true });
+            const lines = buf.split("\n");
+            buf = lines.pop();
+            for (const line of lines) {
+              if (!line.startsWith("data: ")) continue;
+              const d = line.slice(6).trim();
+              if (d === "[DONE]") break;
+              let chunk;
+              try {
+                chunk = JSON.parse(d);
+              } catch {
+                continue;
+              }
+              const delta = chunk.choices?.[0]?.delta;
+              if (!delta) continue;
+              if (delta.content) yield { type: "text-delta", textDelta: delta.content };
+              if (delta.tool_calls) {
+                for (const tc of delta.tool_calls) {
+                  const idx = tc.index ?? 0;
+                  if (!toolCallsMap[idx]) toolCallsMap[idx] = { id: tc.id || "", name: "", args: "" };
+                  if (tc.id) toolCallsMap[idx].id = tc.id;
+                  if (tc.function?.name) toolCallsMap[idx].name += tc.function.name;
+                  if (tc.function?.arguments) toolCallsMap[idx].args += tc.function.arguments;
+                }
+              }
+            }
+          }
+        } finally {
+          reader.releaseLock();
+        }
+        const pending = Object.values(toolCallsMap);
+        if (!pending.length) {
+          yield { type: "finish-step", finishReason: "stop" };
+          if (onStepFinish) await onStepFinish();
+          return;
+        }
+        const toolResultMsgs = [];
+        for (const tc of pending) {
+          let args;
+          try {
+            args = JSON.parse(tc.args || "{}");
+          } catch {
+            args = {};
+          }
+          const toolDef = tools?.[tc.name];
+          let result = toolDef ? null : { error: true, message: "Tool not found: " + tc.name };
+          if (toolDef?.execute) try {
+            result = await toolDef.execute(args, { toolCallId: tc.id });
+          } catch (e) {
+            result = { error: true, message: e.message };
+          }
+          yield { type: "tool-call", toolCallId: tc.id, toolName: tc.name, args };
+          yield { type: "tool-result", toolCallId: tc.id, toolName: tc.name, args, result };
+          toolResultMsgs.push({ role: "tool", tool_call_id: tc.id, content: JSON.stringify(result ?? "") });
+        }
+        yield { type: "finish-step", finishReason: "tool-calls" };
+        if (onStepFinish) await onStepFinish();
+        body = { ...body, messages: [
+          ...body.messages,
+          { role: "assistant", content: null, tool_calls: pending.map((tc) => ({ id: tc.id, type: "function", function: { name: tc.name, arguments: tc.args } })) },
+          ...toolResultMsgs
+        ] };
+        toolCallsMap = {};
+      }
+    }
+    module.exports = { streamGemini: streamGemini2, generateGemini: generateGemini2, streamOpenAI: streamOpenAI2 };
   }
 });
 
@@ -18422,9 +18554,11 @@ var require_thebird_browser_entry = __commonJS({
 var import_thebird_browser_entry = __toESM(require_thebird_browser_entry());
 var streamGemini = import_thebird_browser_entry.default.streamGemini;
 var generateGemini = import_thebird_browser_entry.default.generateGemini;
+var streamOpenAI = import_thebird_browser_entry.default.streamOpenAI;
 export {
   generateGemini,
-  streamGemini
+  streamGemini,
+  streamOpenAI
 };
 /*! Bundled license information:
 

package/index.js

@@ -51,7 +51,7 @@ async function* createFullStream({ model, system, messages, tools, onStepFinish,
           catch (e) { result = { error: true, message: e.message }; }
         }
         yield { type: 'tool-result', toolCallId: toolId, toolName: name, args, result };
-        toolResultParts.push({ functionResponse: { name, response: result || {} } });
+        toolResultParts.push({ functionResponse: { name, response: typeof result === 'string' ? { output: result } : (result || {}) } });
       }
       yield { type: 'finish-step', finishReason: 'tool-calls' };
       if (onStepFinish) await onStepFinish();
@@ -91,7 +91,7 @@ async function generateGemini({ model, system, messages, tools, apiKey, temperat
         try { result = await toolDef.execute(args); }
         catch (e) { result = { error: true, message: e.message }; }
       }
-      toolResultParts.push({ functionResponse: { name, response: result || {} } });
+      toolResultParts.push({ functionResponse: { name, response: typeof result === 'string' ? { output: result } : (result || {}) } });
     }
     contents.push({ role: 'model', parts: allParts });
     contents.push({ role: 'user', parts: toolResultParts });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thebird",
-  "version": "1.2.36",
+  "version": "1.2.38",
   "description": "Anthropic SDK to Gemini streaming bridge — drop-in proxy that translates Anthropic message format and tool calls to Google Gemini",
   "main": "index.js",
   "types": "index.d.ts",

package/thebird-browser-entry-esm.js

@@ -0,0 +1,4 @@
+import tb from './thebird-browser-entry.js';
+export const streamGemini = tb.streamGemini;
+export const generateGemini = tb.generateGemini;
+export const streamOpenAI = tb.streamOpenAI;

package/thebird-browser-entry.js

@@ -0,0 +1,196 @@
+const { getClient } = require('./lib/client.js');
+const { GeminiError, withRetry } = require('./lib/errors.js');
+const { convertMessages, convertTools, cleanSchema, extractModelId, buildConfig } = require('./lib/convert.js');
+
+function streamGemini({ model, system, messages, tools, onStepFinish, apiKey, temperature, maxOutputTokens, topP, topK, safetySettings, responseModalities }) {
+  return { fullStream: createFullStream({ model, system, messages, tools, onStepFinish, apiKey, temperature, maxOutputTokens, topP, topK, safetySettings, responseModalities }), warnings: Promise.resolve([]) };
+}
+
+async function* createFullStream({ model, system, messages, tools, onStepFinish, apiKey, temperature, maxOutputTokens, topP, topK, safetySettings, responseModalities }) {
+  const client = getClient(apiKey);
+  const modelId = extractModelId(model);
+  let contents = convertMessages(messages);
+  const { config } = buildConfig({ system, tools, temperature, maxOutputTokens, topP, topK, safetySettings, responseModalities });
+  while (true) {
+    yield { type: 'start-step' };
+    try {
+      const stream = await withRetry(() => client.models.generateContentStream({ model: modelId, contents, config }));
+      const allParts = [];
+      for await (const chunk of stream) {
+        for (const candidate of (chunk.candidates || [])) {
+          for (const part of (candidate.content?.parts || [])) {
+            allParts.push(part);
+            if (part.text && !part.thought) yield { type: 'text-delta', textDelta: part.text };
+          }
+        }
+      }
+      const fcParts = allParts.filter(p => p.functionCall);
+      if (fcParts.length === 0) {
+        yield { type: 'finish-step', finishReason: 'stop' };
+        if (onStepFinish) await onStepFinish();
+        return;
+      }
+      const toolResultParts = [];
+      for (const part of fcParts) {
+        const name = part.functionCall.name;
+        const args = part.functionCall.args || {};
+        const toolId = 'toolu_' + Math.random().toString(36).slice(2, 10);
+        yield { type: 'tool-call', toolCallId: toolId, toolName: name, args };
+        const toolDef = tools?.[name];
+        let result = toolDef ? null : { error: true, message: 'Tool not found: ' + name };
+        if (toolDef?.execute) {
+          try { result = await toolDef.execute(args, { toolCallId: toolId }); }
+          catch (e) { result = { error: true, message: e.message }; }
+        }
+        yield { type: 'tool-result', toolCallId: toolId, toolName: name, args, result };
+        toolResultParts.push({ functionResponse: { name, response: typeof result === 'string' ? { output: result } : (result || {}) } });
+      }
+      yield { type: 'finish-step', finishReason: 'tool-calls' };
+      if (onStepFinish) await onStepFinish();
+      contents.push({ role: 'model', parts: allParts });
+      contents.push({ role: 'user', parts: toolResultParts });
+    } catch (err) {
+      yield { type: 'error', error: err };
+      yield { type: 'finish-step', finishReason: 'error' };
+      if (onStepFinish) await onStepFinish();
+      return;
+    }
+  }
+}
+
+async function generateGemini({ model, system, messages, tools, apiKey, temperature, maxOutputTokens, topP, topK, safetySettings, responseModalities }) {
+  const client = getClient(apiKey);
+  const modelId = extractModelId(model);
+  let contents = convertMessages(messages);
+  const { config } = buildConfig({ system, tools, temperature, maxOutputTokens, topP, topK, safetySettings, responseModalities });
+  while (true) {
+    const response = await withRetry(() => client.models.generateContent({ model: modelId, contents, config }));
+    const candidate = response.candidates?.[0];
+    if (!candidate) throw new GeminiError('No candidates returned', { retryable: false });
+    const allParts = candidate.content?.parts || [];
+    const fcParts = allParts.filter(p => p.functionCall);
+    if (fcParts.length === 0) {
+      const text = allParts.filter(p => p.text && !p.thought).map(p => p.text).join('');
+      return { text, parts: allParts, response };
+    }
+    const toolResultParts = [];
+    for (const part of fcParts) {
+      const name = part.functionCall.name;
+      const args = part.functionCall.args || {};
+      const toolDef = tools?.[name];
+      let result = toolDef ? null : { error: true, message: 'Tool not found: ' + name };
+      if (toolDef?.execute) {
+        try { result = await toolDef.execute(args); }
+        catch (e) { result = { error: true, message: e.message }; }
+      }
+      toolResultParts.push({ functionResponse: { name, response: typeof result === 'string' ? { output: result } : (result || {}) } });
+    }
+    contents.push({ role: 'model', parts: allParts });
+    contents.push({ role: 'user', parts: toolResultParts });
+  }
+}
+
+function convertMessagesOAI(messages, system) {
+  const result = [];
+  if (system) result.push({ role: 'system', content: typeof system === 'string' ? system : JSON.stringify(system) });
+  for (const m of messages) {
+    if (typeof m.content === 'string') { result.push({ role: m.role, content: m.content }); continue; }
+    if (!Array.isArray(m.content)) continue;
+    const toolCalls = m.content.filter(b => b.type === 'tool_use');
+    const toolResults = m.content.filter(b => b.type === 'tool_result');
+    if (toolResults.length) {
+      for (const b of toolResults) {
+        const c = typeof b.content === 'string' ? b.content : JSON.stringify(b.content || '');
+        result.push({ role: 'tool', tool_call_id: b.tool_use_id || b.id || b.name, content: c });
+      }
+      continue;
+    }
+    const textParts = m.content.filter(b => b.type === 'text').map(b => b.text).join('');
+    if (toolCalls.length) {
+      result.push({ role: 'assistant', content: textParts || null,
+        tool_calls: toolCalls.map(b => ({ id: b.id || ('call_' + Math.random().toString(36).slice(2,8)), type: 'function',
+          function: { name: b.name, arguments: JSON.stringify(b.input || {}) } })) });
+    } else {
+      result.push({ role: m.role, content: textParts });
+    }
+  }
+  return result;
+}
+
+function convertToolsOAI(tools) {
+  if (!tools || typeof tools !== 'object') return undefined;
+  const list = Object.entries(tools).map(([name, t]) => ({
+    type: 'function', function: { name, description: t.description || '',
+      parameters: t.parameters?.jsonSchema || t.parameters || { type: 'object' } }
+  }));
+  return list.length ? list : undefined;
+}
+
+async function* streamOpenAI({ url, apiKey, messages, system, model, tools, maxOutputTokens, temperature, onStepFinish }) {
+  const oaiMsgs = convertMessagesOAI(messages, system);
+  const oaiTools = convertToolsOAI(tools);
+  let body = { messages: oaiMsgs, model, max_tokens: maxOutputTokens || 8192, temperature: temperature ?? 0.5 };
+  if (oaiTools) body.tools = oaiTools;
+  while (true) {
+    yield { type: 'start-step' };
+    const res = await fetch(url, { method: 'POST',
+      headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${apiKey}` },
+      body: JSON.stringify({ ...body, stream: true }) });
+    if (!res.ok) { const t = await res.text(); throw new Error(t); }
+    const reader = res.body.getReader();
+    const dec = new TextDecoder();
+    let buf = '', toolCallsMap = {};
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buf += dec.decode(value, { stream: true });
+        const lines = buf.split('\n');
+        buf = lines.pop();
+        for (const line of lines) {
+          if (!line.startsWith('data: ')) continue;
+          const d = line.slice(6).trim();
+          if (d === '[DONE]') break;
+          let chunk; try { chunk = JSON.parse(d); } catch { continue; }
+          const delta = chunk.choices?.[0]?.delta;
+          if (!delta) continue;
+          if (delta.content) yield { type: 'text-delta', textDelta: delta.content };
+          if (delta.tool_calls) {
+            for (const tc of delta.tool_calls) {
+              const idx = tc.index ?? 0;
+              if (!toolCallsMap[idx]) toolCallsMap[idx] = { id: tc.id || '', name: '', args: '' };
+              if (tc.id) toolCallsMap[idx].id = tc.id;
+              if (tc.function?.name) toolCallsMap[idx].name += tc.function.name;
+              if (tc.function?.arguments) toolCallsMap[idx].args += tc.function.arguments;
+            }
+          }
+        }
+      }
+    } finally { reader.releaseLock(); }
+    const pending = Object.values(toolCallsMap);
+    if (!pending.length) {
+      yield { type: 'finish-step', finishReason: 'stop' };
+      if (onStepFinish) await onStepFinish();
+      return;
+    }
+    const toolResultMsgs = [];
+    for (const tc of pending) {
+      let args; try { args = JSON.parse(tc.args || '{}'); } catch { args = {}; }
+      const toolDef = tools?.[tc.name];
+      let result = toolDef ? null : { error: true, message: 'Tool not found: ' + tc.name };
+      if (toolDef?.execute) try { result = await toolDef.execute(args, { toolCallId: tc.id }); } catch(e) { result = { error: true, message: e.message }; }
+      yield { type: 'tool-call', toolCallId: tc.id, toolName: tc.name, args };
+      yield { type: 'tool-result', toolCallId: tc.id, toolName: tc.name, args, result };
+      toolResultMsgs.push({ role: 'tool', tool_call_id: tc.id, content: JSON.stringify(result ?? '') });
+    }
+    yield { type: 'finish-step', finishReason: 'tool-calls' };
+    if (onStepFinish) await onStepFinish();
+    body = { ...body, messages: [...body.messages,
+      { role: 'assistant', content: null, tool_calls: pending.map(tc => ({ id: tc.id, type: 'function', function: { name: tc.name, arguments: tc.args } })) },
+      ...toolResultMsgs
+    ]};
+    toolCallsMap = {};
+  }
+}
+
+module.exports = { streamGemini, generateGemini, streamOpenAI };