thebird 1.2.37 → 1.2.38

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thebird",
-  "version": "1.2.37",
+  "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

@@ -1,3 +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

@@ -90,4 +90,107 @@ async function generateGemini({ model, system, messages, tools, apiKey, temperat
   }
 }
 
-module.exports = { streamGemini, generateGemini };
+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 };