thebird 1.2.71 → 1.2.73

package/.github/workflows/auto-declaudeify.yml

@@ -0,0 +1,44 @@
+name: Auto-Declaudeify
+
+on:
+  push:
+    branches: ['**']
+
+jobs:
+  declaudeify:
+    if: contains(github.event.head_commit.author.name, 'Claude') || contains(github.event.head_commit.author.email, 'claude')
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Check for Claude commits
+        id: check
+        run: |
+          CLAUDE_COMMITS=$(git log --all --author="Claude" --oneline | wc -l)
+          echo "count=$CLAUDE_COMMITS" >> $GITHUB_OUTPUT
+          if [ $CLAUDE_COMMITS -gt 0 ]; then
+            echo "Found $CLAUDE_COMMITS Claude commits, will filter"
+          fi
+
+      - name: Filter Claude from history
+        if: steps.check.outputs.count > 0
+        run: |
+          git filter-branch --force --env-filter \
+            'if [ "$GIT_AUTHOR_NAME" = "Claude" ]; then \
+              export GIT_AUTHOR_NAME="lanmower"; \
+              export GIT_AUTHOR_EMAIL="lanmower@lanmower.com"; \
+            fi; \
+            if [ "$GIT_COMMITTER_NAME" = "Claude" ]; then \
+              export GIT_COMMITTER_NAME="lanmower"; \
+              export GIT_COMMITTER_EMAIL="lanmower@lanmower.com"; \
+            fi' \
+            --tag-name-filter cat -- --all
+
+      - name: Force push filtered history
+        if: steps.check.outputs.count > 0
+        run: git push --all --force
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

package/index.js

@@ -1,10 +1,7 @@
 const { getClient } = require('./lib/client');
 const { GeminiError, withRetry } = require('./lib/errors');
 const { convertMessages, convertTools, cleanSchema, extractModelId, buildConfig } = require('./lib/convert');
-const { loadConfig } = require('./lib/config');
-const { route } = require('./lib/router');
-const { resolveTransformers, applyRequestTransformers } = require('./lib/transformers');
-const openaiProv = require('./lib/providers/openai');
+const { guardStream } = require('./lib/stream-guard');
 
 function streamGemini({ model, system, messages, tools, onStepFinish, apiKey,
   temperature, maxOutputTokens, topP, topK, safetySettings, responseModalities }) {
@@ -14,7 +11,7 @@ function streamGemini({ model, system, messages, tools, onStepFinish, apiKey,
   };
 }
 
-async function* createFullStream({ model, system, messages, tools, onStepFinish, apiKey, temperature, maxOutputTokens, topP, topK, safetySettings, responseModalities }) {
+async function* createFullStream({ model, system, messages, tools, onStepFinish, apiKey, temperature, maxOutputTokens, topP, topK, safetySettings, responseModalities, streamGuard }) {
   const client = getClient(apiKey);
   const modelId = extractModelId(model);
   let contents = convertMessages(messages);
@@ -24,7 +21,7 @@ async function* createFullStream({ model, system, messages, tools, onStepFinish,
     try {
       const stream = await withRetry(() => client.models.generateContentStream({ model: modelId, contents, config }));
       const allParts = [];
-      for await (const chunk of stream) {
+      for await (const chunk of guardStream(stream, streamGuard)) {
         for (const candidate of (chunk.candidates || [])) {
           for (const part of (candidate.content?.parts || [])) {
             allParts.push(part);
@@ -98,79 +95,9 @@ async function generateGemini({ model, system, messages, tools, apiKey, temperat
   }
 }
 
-function isGeminiProvider(p) {
-  return p.name === 'gemini' || (p.api_base_url || '').includes('generativelanguage.googleapis.com');
-}
-
-function findProvider(providers, providerName, modelName) {
-  if (providerName) return providers.find(p => p.name === providerName);
-  if (modelName) return providers.find(p => (p.models || []).includes(modelName));
-  return providers[0];
-}
-
-function buildOpenAIUrl(base) {
-  const clean = (base || '').replace(/\/$/g, '');
-  return clean.includes('/completions') ? clean : clean + '/chat/completions';
-}
-
-function resolveForProvider(provider, model, customMap) {
-  const useList = provider.transformer?.[model]?.use || provider.transformer?.use || [];
-  return resolveTransformers(useList, customMap);
-}
-
-async function* routerStream(params, resolver) {
-  const { provider, actualModel, transformers } = await resolver(params);
-  if (isGeminiProvider(provider)) {
-    yield* createFullStream({ ...params, model: actualModel, apiKey: provider.api_key || params.apiKey });
-  } else {
-    const oaiMsgs = openaiProv.convertMessages(params.messages, params.system);
-    const oaiTools = openaiProv.convertTools(params.tools);
-    let req = { messages: oaiMsgs, model: actualModel, max_tokens: params.maxOutputTokens || 8192, temperature: params.temperature ?? 0.5 };
-    if (oaiTools) req.tools = oaiTools;
-    req = applyRequestTransformers(req, transformers);
-    yield* openaiProv.streamOpenAI({ url: buildOpenAIUrl(provider.api_base_url), apiKey: provider.api_key, headers: req._extraHeaders, body: req, tools: params.tools, onStepFinish: params.onStepFinish });
-  }
-}
-
-function createRouter(config) {
-  const providers = config.Providers || config.providers || [];
-  const routerCfg = config.Router || {};
-  async function resolve(params) {
-    const { providerName, modelName } = await route(params, routerCfg, config.customRouter);
-    const provider = findProvider(providers, providerName, modelName) || providers[0];
-    if (!provider) throw new Error('[thebird] no provider configured');
-    const actualModel = modelName || (provider.models || [])[0] || extractModelId(params.model) || 'gemini-2.0-flash';
-    const transformers = resolveForProvider(provider, actualModel, config._transformers);
-    return { provider, actualModel, transformers };
-  }
-  return {
-    stream(params) { return { fullStream: routerStream(params, resolve), warnings: Promise.resolve([]) }; },
-    async generate(params) {
-      const { provider, actualModel, transformers } = await resolve(params);
-      if (isGeminiProvider(provider)) return generateGemini({ ...params, model: actualModel, apiKey: provider.api_key || params.apiKey });
-      const oaiMsgs = openaiProv.convertMessages(params.messages, params.system);
-      const oaiTools = openaiProv.convertTools(params.tools);
-      let req = { messages: oaiMsgs, model: actualModel, max_tokens: params.maxOutputTokens || 8192, temperature: params.temperature ?? 0.5 };
-      if (oaiTools) req.tools = oaiTools;
-      req = applyRequestTransformers(req, transformers);
-      return openaiProv.generateOpenAI({ url: buildOpenAIUrl(provider.api_base_url), apiKey: provider.api_key, headers: req._extraHeaders, body: req, tools: params.tools });
-    }
-  };
-}
-
-function streamRouter(params) {
-  const config = loadConfig(params.configPath);
-  if (!(config.Providers || config.providers)?.length) return streamGemini(params);
-  return createRouter(config).stream(params);
-}
-
-async function generateRouter(params) {
-  const config = loadConfig(params.configPath);
-  if (!(config.Providers || config.providers)?.length) return generateGemini(params);
-  return createRouter(config).generate(params);
-}
-
+const { streamRouter, generateRouter, createRouter } = require('./lib/router-stream');
 const { cloudGenerate, streamCloud, cloudStream } = require('./lib/cloud-generate');
 const { ensureAuth, login: oauthLogin } = require('./lib/oauth');
+const { TimeoutError } = require('./lib/stream-guard');
 
-module.exports = { streamGemini, generateGemini, streamRouter, generateRouter, createRouter, convertMessages, convertTools, cleanSchema, GeminiError, cloudGenerate, streamCloud, cloudStream, ensureAuth, oauthLogin };
+module.exports = { streamGemini, createFullStream, generateGemini, streamRouter, generateRouter, createRouter, convertMessages, convertTools, cleanSchema, GeminiError, TimeoutError, cloudGenerate, streamCloud, cloudStream, ensureAuth, oauthLogin };

package/lib/errors.js

@@ -1,15 +1,73 @@
-class GeminiError extends Error {
-  constructor(message, { status, code, retryable = false } = {}) {
+class BridgeError extends Error {
+  constructor(message, { status, code, retryable = false, provider, headers } = {}) {
     super(message);
-    this.name = 'GeminiError';
+    this.name = 'BridgeError';
     this.status = status;
     this.code = code;
     this.retryable = retryable;
+    this.provider = provider;
+    this.headers = headers;
   }
 }
 
+class AuthError extends BridgeError {
+  constructor(message, opts = {}) {
+    super(message, { ...opts, retryable: false });
+    this.name = 'AuthError';
+  }
+}
+
+class RateLimitError extends BridgeError {
+  constructor(message, opts = {}) {
+    super(message, { ...opts, retryable: true });
+    this.name = 'RateLimitError';
+  }
+}
+
+class TimeoutError extends BridgeError {
+  constructor(message, opts = {}) {
+    super(message, { ...opts, retryable: true });
+    this.name = 'TimeoutError';
+  }
+}
+
+class ContextWindowError extends BridgeError {
+  constructor(message, opts = {}) {
+    super(message, { ...opts, retryable: false });
+    this.name = 'ContextWindowError';
+  }
+}
+
+class ContentPolicyError extends BridgeError {
+  constructor(message, opts = {}) {
+    super(message, { ...opts, retryable: false });
+    this.name = 'ContentPolicyError';
+  }
+}
+
+class ProviderError extends BridgeError {
+  constructor(message, opts = {}) {
+    super(message, opts);
+    this.name = 'ProviderError';
+  }
+}
+
+const GeminiError = BridgeError;
+
+function classifyError(status, message, provider) {
+  const opts = { status, provider };
+  const msg = message || '';
+  if (status === 401 || status === 403) return new AuthError(msg, opts);
+  if (status === 429) return new RateLimitError(msg, opts);
+  if (status === 408 || /timeout/i.test(msg)) return new TimeoutError(msg, opts);
+  if (status === 413 || /context.?length|token.?limit|too.?long/i.test(msg)) return new ContextWindowError(msg, opts);
+  if (status === 451 || /safety|blocked|content.?policy|harmful/i.test(msg)) return new ContentPolicyError(msg, opts);
+  if (typeof status === 'number' && status >= 500) return new ProviderError(msg, { ...opts, retryable: true });
+  return new BridgeError(msg, { ...opts, retryable: false });
+}
+
 function isRetryable(err) {
-  if (err instanceof GeminiError) return err.retryable;
+  if (err instanceof BridgeError) return err.retryable;
   const status = err?.status ?? err?.code;
   if (status === 429) return true;
   if (typeof status === 'number' && status >= 500) return true;
@@ -17,7 +75,19 @@ function isRetryable(err) {
   return /quota|rate.?limit|overloaded|unavailable/i.test(msg);
 }
 
+function parseRetryAfterHeader(err) {
+  const raw = err?.headers?.get?.('retry-after') ?? err?.retryAfter;
+  if (raw == null) return null;
+  const secs = Number(raw);
+  if (!isNaN(secs) && secs >= 0) return secs * 1000;
+  const date = Date.parse(raw);
+  if (!isNaN(date)) return Math.max(0, date - Date.now());
+  return null;
+}
+
 function parseRetryDelay(err) {
+  const headerDelay = parseRetryAfterHeader(err);
+  if (headerDelay != null) return headerDelay;
   try {
     const body = typeof err.message === 'string' ? JSON.parse(err.message) : err.message;
     const details = body?.error?.details || [];
@@ -46,4 +116,8 @@ async function withRetry(fn, maxRetries = 3) {
   throw lastErr;
 }
 
-module.exports = { GeminiError, isRetryable, withRetry };
+module.exports = {
+  BridgeError, GeminiError, AuthError, RateLimitError,
+  TimeoutError, ContextWindowError, ContentPolicyError,
+  ProviderError, classifyError, isRetryable, withRetry
+};

package/lib/providers/openai.js

@@ -1,4 +1,5 @@
 const { GeminiError } = require('../errors');
+const { guardStream } = require('../stream-guard');
 
 function convertMessages(messages, system) {
   const result = [];
@@ -40,22 +41,28 @@ async function callOpenAI({ url, apiKey, headers, body }) {
   const res = await fetch(url, { method: 'POST',
     headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${apiKey}`, ...(headers || {}) },
     body: JSON.stringify(body) });
-  if (!res.ok) { const t = await res.text(); throw new GeminiError(t, { status: res.status, retryable: res.status === 429 || res.status >= 500 }); }
+  if (!res.ok) { const t = await res.text(); throw new GeminiError(t, { status: res.status, retryable: res.status === 429 || res.status >= 500, headers: res.headers }); }
   return res;
 }
 
-async function* streamOpenAI({ url, apiKey, headers, body, tools, onStepFinish }) {
+async function* readerIterable(reader) {
+  const dec = new TextDecoder();
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) return;
+    yield dec.decode(value, { stream: true });
+  }
+}
+
+async function* streamOpenAI({ url, apiKey, headers, body, tools, onStepFinish, streamGuard }) {
   while (true) {
     yield { type: 'start-step' };
     const res = await callOpenAI({ url, apiKey, headers, body: { ...body, stream: true } });
     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 });
+      for await (const text of guardStream(readerIterable(reader), streamGuard)) {
+        buf += text;
         const lines = buf.split('\n');
         buf = lines.pop();
         for (const line of lines) {

package/lib/router-stream.js

@@ -0,0 +1,83 @@
+const { extractModelId } = require('./convert');
+const { resolveTransformers, applyRequestTransformers } = require('./transformers');
+const { loadConfig } = require('./config');
+const { route } = require('./router');
+const openaiProv = require('./providers/openai');
+
+function isGeminiProvider(p) {
+  return p.name === 'gemini' || (p.api_base_url || '').includes('generativelanguage.googleapis.com');
+}
+
+function findProvider(providers, providerName, modelName) {
+  if (providerName) return providers.find(p => p.name === providerName);
+  if (modelName) return providers.find(p => (p.models || []).includes(modelName));
+  return providers[0];
+}
+
+function buildOpenAIUrl(base) {
+  const clean = (base || '').replace(/\/$/g, '');
+  return clean.includes('/completions') ? clean : clean + '/chat/completions';
+}
+
+function resolveForProvider(provider, model, customMap) {
+  const useList = provider.transformer?.[model]?.use || provider.transformer?.use || [];
+  return resolveTransformers(useList, customMap);
+}
+
+async function* routerStream(params, resolver) {
+  const { createFullStream } = require('../index');
+  const { provider, actualModel, transformers } = await resolver(params);
+  if (isGeminiProvider(provider)) {
+    yield* createFullStream({ ...params, model: actualModel, apiKey: provider.api_key || params.apiKey });
+  } else {
+    const oaiMsgs = openaiProv.convertMessages(params.messages, params.system);
+    const oaiTools = openaiProv.convertTools(params.tools);
+    let req = { messages: oaiMsgs, model: actualModel, max_tokens: params.maxOutputTokens || 8192, temperature: params.temperature ?? 0.5 };
+    if (oaiTools) req.tools = oaiTools;
+    req = applyRequestTransformers(req, transformers);
+    yield* openaiProv.streamOpenAI({ url: buildOpenAIUrl(provider.api_base_url), apiKey: provider.api_key, headers: req._extraHeaders, body: req, tools: params.tools, onStepFinish: params.onStepFinish, streamGuard: params.streamGuard });
+  }
+}
+
+function createRouter(config) {
+  const { generateGemini } = require('../index');
+  const providers = config.Providers || config.providers || [];
+  const routerCfg = config.Router || {};
+  async function resolve(params) {
+    const { providerName, modelName } = await route(params, routerCfg, config.customRouter);
+    const provider = findProvider(providers, providerName, modelName) || providers[0];
+    if (!provider) throw new Error('[thebird] no provider configured');
+    const actualModel = modelName || (provider.models || [])[0] || extractModelId(params.model) || 'gemini-2.0-flash';
+    const transformers = resolveForProvider(provider, actualModel, config._transformers);
+    return { provider, actualModel, transformers };
+  }
+  return {
+    stream(params) { return { fullStream: routerStream(params, resolve), warnings: Promise.resolve([]) }; },
+    async generate(params) {
+      const { provider, actualModel, transformers } = await resolve(params);
+      if (isGeminiProvider(provider)) return generateGemini({ ...params, model: actualModel, apiKey: provider.api_key || params.apiKey });
+      const oaiMsgs = openaiProv.convertMessages(params.messages, params.system);
+      const oaiTools = openaiProv.convertTools(params.tools);
+      let req = { messages: oaiMsgs, model: actualModel, max_tokens: params.maxOutputTokens || 8192, temperature: params.temperature ?? 0.5 };
+      if (oaiTools) req.tools = oaiTools;
+      req = applyRequestTransformers(req, transformers);
+      return openaiProv.generateOpenAI({ url: buildOpenAIUrl(provider.api_base_url), apiKey: provider.api_key, headers: req._extraHeaders, body: req, tools: params.tools });
+    }
+  };
+}
+
+function streamRouter(params) {
+  const { streamGemini } = require('../index');
+  const config = loadConfig(params.configPath);
+  if (!(config.Providers || config.providers)?.length) return streamGemini(params);
+  return createRouter(config).stream(params);
+}
+
+async function generateRouter(params) {
+  const { generateGemini } = require('../index');
+  const config = loadConfig(params.configPath);
+  if (!(config.Providers || config.providers)?.length) return generateGemini(params);
+  return createRouter(config).generate(params);
+}
+
+module.exports = { routerStream, createRouter, streamRouter, generateRouter, findProvider, buildOpenAIUrl, resolveForProvider, isGeminiProvider };

package/lib/stream-guard.js

@@ -0,0 +1,42 @@
+const { GeminiError } = require('./errors');
+
+class TimeoutError extends GeminiError {
+  constructor(ms) {
+    super(`Stream chunk timeout after ${ms}ms`, { retryable: true });
+    this.name = 'TimeoutError';
+  }
+}
+
+async function* guardStream(iterable, opts = {}) {
+  const timeoutMs = opts.chunkTimeoutMs ?? 30000;
+  const maxRepeats = opts.maxRepeats ?? 100;
+  let lastChunk = null;
+  let repeatCount = 0;
+  for await (const chunk of raceTimeout(iterable, timeoutMs)) {
+    const key = JSON.stringify(chunk);
+    if (key === lastChunk && key !== '{}' && key !== 'null') {
+      repeatCount++;
+      if (repeatCount >= maxRepeats) {
+        throw new GeminiError(`Same chunk repeated ${maxRepeats} times`, { retryable: false });
+      }
+    } else {
+      lastChunk = key;
+      repeatCount = 1;
+    }
+    yield chunk;
+  }
+}
+
+async function* raceTimeout(iterable, ms) {
+  const iter = iterable[Symbol.asyncIterator]();
+  while (true) {
+    const result = await Promise.race([
+      iter.next(),
+      new Promise((_, reject) => setTimeout(() => reject(new TimeoutError(ms)), ms))
+    ]);
+    if (result.done) return;
+    yield result.value;
+  }
+}
+
+module.exports = { guardStream, TimeoutError };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thebird",
-  "version": "1.2.71",
+  "version": "1.2.73",
   "description": "Anthropic SDK to Gemini streaming bridge — drop-in proxy that translates Anthropic message format and tool calls to Google Gemini",
   "scripts": {
     "start": "node serve.js"