thebird 1.2.35 → 1.2.37

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.35",
+  "version": "1.2.37",
   "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,3 @@
+import tb from './thebird-browser-entry.js';
+export const streamGemini = tb.streamGemini;
+export const generateGemini = tb.generateGemini;

package/thebird-browser-entry.js

@@ -0,0 +1,93 @@
+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 });
+  }
+}
+
+module.exports = { streamGemini, generateGemini };