thebird 1.2.72 → 1.2.74

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 ## [Unreleased]
 
+### Added
+- `lib/errors.js`: Typed error hierarchy — BridgeError, AuthError, RateLimitError, TimeoutError, ContextWindowError, ContentPolicyError, ProviderError with classifyError factory. GeminiError kept as alias.
+- `lib/errors.js`: `redactKeys()` — auto-redacts API keys (AIza, sk-, key- patterns) in error messages to `...XXXX`
+- `lib/errors.js`: `parseRetryAfterHeader()` — parses standard HTTP Retry-After header (seconds and date formats) in addition to Gemini-specific retry info
+- `lib/stream-guard.js`: `guardStream()` — wraps async iterables with per-chunk timeout (30s default) and repeated-chunk detection (100 threshold)
+- `lib/circuit-breaker.js`: `createCircuitBreaker()` — per-provider failure tracking with auto-recovery after cooldown
+- `lib/capabilities.js`: `getCapabilities()` / `stripUnsupported()` — provider capability metadata with automatic feature stripping and warnings
+- `lib/router-stream.js`: Router logic extracted from index.js — circuit breaker and capability checks integrated
+
+### Changed
+- `index.js`: Trimmed from 177 to 104 lines by extracting router logic to lib/router-stream.js
+- `index.d.ts`: Added types for BridgeError hierarchy, StreamGuardOptions, CapabilitySet, CircuitBreakerOptions
+- `lib/providers/openai.js`: Passes response headers to error objects for Retry-After parsing; integrates guardStream
+
 ### Added
 - `docs/app.js`: Cerebras as OpenAI-compatible provider option (https://api.cerebras.ai/v1)
 - `docs/shell.js`: `createShell({ term, onPreviewWrite })` — POSIX shell + Node REPL using browser V8 eval + xstate v5 state machine. Dispatch table of built-ins: ls, cat, echo, pwd, cd, mkdir, rm, cp, mv, env, export, clear, help, node, npm install, exit. Pipe support via ` | ` split. `window.__debug.shell` exposes state, cwd, env, history, httpHandlers, nodeMode. `http.createServer` polyfill registers handlers in httpHandlers map.

package/index.d.ts

@@ -37,7 +37,7 @@ export interface FinishStepEvent { type: 'finish-step'; finishReason: 'stop' | '
 export interface ErrorEvent { type: 'error'; error: Error }
 export type StreamEvent = StartStepEvent | TextDeltaEvent | ToolCallEvent | ToolResultEvent | FinishStepEvent | ErrorEvent;
 export interface StreamResult { fullStream: AsyncIterable<StreamEvent>; warnings: Promise<unknown[]> }
-export interface StreamParams extends GenerationParams { onStepFinish?: () => Promise<void> | void }
+export interface StreamParams extends GenerationParams { onStepFinish?: () => Promise<void> | void; streamGuard?: StreamGuardOptions }
 export function streamGemini(params: StreamParams): StreamResult;
 export interface GenerateResult { text: string; parts: unknown[]; response: unknown }
 export function generateGemini(params: GenerationParams): Promise<GenerateResult>;
@@ -53,6 +53,7 @@ export interface ProviderConfig {
   api_key: string;
   models?: string[];
   transformer?: TransformerConfig;
+  capabilities?: Partial<CapabilitySet>;
 }
 export interface RouterConfig {
   default?: string;
@@ -69,8 +70,10 @@ export interface RouterConfiguration {
   Router?: RouterConfig;
   customRouter?: (params: GenerationParams, config: RouterConfig) => Promise<string | null>;
   configPath?: string;
+  circuitBreaker?: CircuitBreakerOptions;
 }
 export interface RouterInstance {
+  breaker: { isOpen(name: string): boolean; recordFailure(name: string): void; recordSuccess(name: string): void };
   stream(params: StreamParams): StreamResult;
   generate(params: GenerationParams): Promise<GenerateResult | { text: string; response: unknown }>;
 }
@@ -89,10 +92,35 @@ export interface GeminiContent { role: 'user' | 'model'; parts: GeminiPart[] }
 export function convertMessages(messages: Message[]): GeminiContent[];
 export function convertTools(tools: Tools): Array<{ name: string; description: string; parameters: Record<string, unknown> }>;
 export function cleanSchema(schema: unknown): unknown;
-export class GeminiError extends Error {
-  name: 'GeminiError';
+export interface StreamGuardOptions {
+  chunkTimeoutMs?: number;
+  maxRepeats?: number;
+}
+export interface CapabilitySet {
+  streaming: boolean;
+  toolUse: boolean;
+  vision: boolean;
+  systemMessage: boolean;
+  jsonMode: boolean;
+}
+export interface CircuitBreakerOptions {
+  maxFailures?: number;
+  cooldownMs?: number;
+}
+export class BridgeError extends Error {
+  name: string;
   status?: number;
   code?: string | number;
   retryable: boolean;
-  constructor(message: string, options?: { status?: number; code?: string | number; retryable?: boolean });
+  provider?: string;
+  constructor(message: string, options?: { status?: number; code?: string | number; retryable?: boolean; provider?: string; headers?: unknown });
 }
+export class AuthError extends BridgeError {}
+export class RateLimitError extends BridgeError {}
+export class TimeoutError extends BridgeError {}
+export class ContextWindowError extends BridgeError {}
+export class ContentPolicyError extends BridgeError {}
+export class ProviderError extends BridgeError {}
+export const GeminiError: typeof BridgeError;
+export function classifyError(status: number, message: string, provider?: string): BridgeError;
+export function redactKeys(str: string): string;

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 { BridgeError, AuthError, RateLimitError, TimeoutError, ContextWindowError, ContentPolicyError, ProviderError, classifyError } = require('./lib/errors');
 
-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, BridgeError, AuthError, RateLimitError, TimeoutError, ContextWindowError, ContentPolicyError, ProviderError, classifyError, cloudGenerate, streamCloud, cloudStream, ensureAuth, oauthLogin };

package/lib/capabilities.js

@@ -0,0 +1,50 @@
+const DEFAULTS = {
+  streaming: true,
+  toolUse: true,
+  vision: true,
+  systemMessage: true,
+  jsonMode: false
+};
+
+function getCapabilities(provider) {
+  return { ...DEFAULTS, ...(provider.capabilities || {}) };
+}
+
+function stripImageBlocks(messages) {
+  return messages.map(msg => {
+    if (!Array.isArray(msg.content)) return msg;
+    const filtered = msg.content.filter(b => b.type !== 'image' && b.type !== 'image_url');
+    if (filtered.length === 0) return { ...msg, content: [{ type: 'text', text: '[image removed - unsupported by provider]' }] };
+    return { ...msg, content: filtered };
+  });
+}
+
+function prependSystemAsUser(messages, system) {
+  if (!system) return { messages, system: undefined };
+  const text = Array.isArray(system) ? system.map(b => b.text || '').join('\n') : system;
+  const sysMsg = { role: 'user', content: [{ type: 'text', text }] };
+  return { messages: [sysMsg, ...messages], system: undefined };
+}
+
+function stripUnsupported(params, caps) {
+  const warnings = [];
+  const result = { ...params };
+  if (!caps.toolUse && result.tools) {
+    delete result.tools;
+    delete result.tool_choice;
+    warnings.push('toolUse not supported — tools removed');
+  }
+  if (!caps.vision && result.messages) {
+    result.messages = stripImageBlocks(result.messages);
+    warnings.push('vision not supported — image blocks removed');
+  }
+  if (!caps.systemMessage && result.system) {
+    const { messages, system } = prependSystemAsUser(result.messages || [], result.system);
+    result.messages = messages;
+    result.system = system;
+    warnings.push('systemMessage not supported — prepended as user message');
+  }
+  return { params: result, warnings };
+}
+
+module.exports = { getCapabilities, stripUnsupported, DEFAULTS };

package/lib/circuit-breaker.js

@@ -0,0 +1,36 @@
+function createCircuitBreaker(opts = {}) {
+  const maxFailures = opts.maxFailures || 5;
+  const cooldownMs = opts.cooldownMs || 60000;
+  const state = new Map();
+
+  function getState(name) {
+    if (!state.has(name)) state.set(name, { failures: 0, openedAt: 0 });
+    return state.get(name);
+  }
+
+  function isOpen(name) {
+    const s = getState(name);
+    if (s.failures < maxFailures) return false;
+    if (Date.now() - s.openedAt >= cooldownMs) {
+      s.failures = maxFailures;
+      return false;
+    }
+    return true;
+  }
+
+  function recordFailure(name) {
+    const s = getState(name);
+    s.failures++;
+    if (s.failures >= maxFailures) s.openedAt = Date.now();
+  }
+
+  function recordSuccess(name) {
+    const s = getState(name);
+    s.failures = 0;
+    s.openedAt = 0;
+  }
+
+  return { isOpen, recordFailure, recordSuccess };
+}
+
+module.exports = { createCircuitBreaker };

package/lib/errors.js

@@ -1,15 +1,90 @@
-class GeminiError extends Error {
-  constructor(message, { status, code, retryable = false } = {}) {
-    super(message);
-    this.name = 'GeminiError';
+const KEY_PATTERNS = [
+  /\b(AIza[A-Za-z0-9_-]{20,})/g,
+  /\b(sk-[A-Za-z0-9]{20,})/g,
+  /\b(key-[A-Za-z0-9]{20,})/g,
+  /((?:api[_-]?key|token|secret|authorization|bearer)[=:\s"']+)([A-Za-z0-9_-]{20,})/gi,
+];
+
+function redactKeys(str) {
+  if (typeof str !== 'string') return str;
+  let result = str;
+  result = result.replace(KEY_PATTERNS[0], m => `...${m.slice(-4)}`);
+  result = result.replace(KEY_PATTERNS[1], m => `...${m.slice(-4)}`);
+  result = result.replace(KEY_PATTERNS[2], m => `...${m.slice(-4)}`);
+  result = result.replace(KEY_PATTERNS[3], (_, prefix, val) => `${prefix}...${val.slice(-4)}`);
+  return result;
+}
+
+class BridgeError extends Error {
+  constructor(message, { status, code, retryable = false, provider, headers } = {}) {
+    super(redactKeys(message));
+    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 +92,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 +133,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, redactKeys
+};

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,95 @@
+const { extractModelId } = require('./convert');
+const { resolveTransformers, applyRequestTransformers } = require('./transformers');
+const { loadConfig } = require('./config');
+const { route } = require('./router');
+const openaiProv = require('./providers/openai');
+const { createCircuitBreaker } = require('./circuit-breaker');
+const { getCapabilities, stripUnsupported } = require('./capabilities');
+
+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, caps } = await resolver(params);
+  const stripped = stripUnsupported(params, caps);
+  params = stripped.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 || {};
+  const breaker = createCircuitBreaker(config.circuitBreaker);
+  async function resolve(params) {
+    const { providerName, modelName } = await route(params, routerCfg, config.customRouter);
+    let provider = findProvider(providers, providerName, modelName) || providers[0];
+    if (provider && breaker.isOpen(provider.name)) {
+      const fallback = providers.find(p => p !== provider && !breaker.isOpen(p.name));
+      if (fallback) provider = fallback;
+    }
+    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);
+    const caps = getCapabilities(provider);
+    return { provider, actualModel, transformers, caps };
+  }
+  return {
+    breaker,
+    stream(params) { return { fullStream: routerStream(params, resolve), warnings: Promise.resolve([]) }; },
+    async generate(params) {
+      const { provider, actualModel, transformers, caps } = await resolve(params);
+      params = stripUnsupported(params, caps).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,35 @@
+const { TimeoutError, BridgeError } = require('./errors');
+
+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 BridgeError(`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(`Stream chunk timeout after ${ms}ms`)), ms))
+    ]);
+    if (result.done) return;
+    yield result.value;
+  }
+}
+
+module.exports = { guardStream };

package/package.json

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