thebird 1.2.100 → 1.2.102

package/lib/convert.js

@@ -1,87 +0,0 @@
-function cleanSchema(schema) {
-  if (!schema || typeof schema !== 'object') return schema;
-  if (Array.isArray(schema)) return schema.map(cleanSchema);
-  const out = {};
-  for (const [k, v] of Object.entries(schema)) {
-    if (k === 'additionalProperties' || k === '$schema') continue;
-    out[k] = cleanSchema(v);
-  }
-  return out;
-}
-
-function convertTools(tools) {
-  if (!tools || typeof tools !== 'object') return [];
-  return Object.entries(tools).map(([name, t]) => ({
-    name,
-    description: t.description || '',
-    parameters: cleanSchema(t.parameters?.jsonSchema || t.parameters || { type: 'object' })
-  }));
-}
-
-function convertImageBlock(b) {
-  // Handle inlineData: { mimeType, data } (base64)
-  if (b.inlineData || b.type === 'image') {
-    const src = b.inlineData || b.source;
-    if (src?.data) return { inlineData: { mimeType: src.mimeType || 'image/jpeg', data: src.data } };
-    if (src?.url) return { fileData: { mimeType: src.mimeType || 'image/jpeg', fileUri: src.url } };
-  }
-  // Handle fileData: { mimeType, fileUri }
-  if (b.fileData) return { fileData: { mimeType: b.fileData.mimeType, fileUri: b.fileData.fileUri } };
-  // Anthropic-style image block
-  if (b.type === 'image' && b.source) {
-    if (b.source.type === 'base64') return { inlineData: { mimeType: b.source.media_type, data: b.source.data } };
-    if (b.source.type === 'url') return { fileData: { mimeType: b.source.media_type || 'image/jpeg', fileUri: b.source.url } };
-  }
-  return null;
-}
-
-function convertMessages(messages) {
-  const contents = [];
-  for (const m of messages) {
-    const role = m.role === 'assistant' ? 'model' : 'user';
-    if (typeof m.content === 'string') {
-      if (m.content) contents.push({ role, parts: [{ text: m.content }] });
-      continue;
-    }
-    if (Array.isArray(m.content)) {
-      const parts = m.content.map(b => {
-        if (b.type === 'text' && b.text) return { text: b.text };
-        if (b.type === 'image' || b.inlineData || b.fileData) return convertImageBlock(b);
-        if (b.type === 'tool_use') return { functionCall: { name: b.name, args: b.input || {} } };
-        if (b.type === 'tool_result') {
-          let resp;
-          try { resp = typeof b.content === 'string' ? JSON.parse(b.content) : (b.content || {}); }
-          catch { resp = { result: b.content }; }
-          return { functionResponse: { name: b.name || 'unknown', response: resp } };
-        }
-        return null;
-      }).filter(Boolean);
-      if (parts.length) contents.push({ role, parts });
-    }
-  }
-  return contents;
-}
-
-function extractModelId(model) {
-  if (typeof model === 'string') return model;
-  if (model?.modelId) return model.modelId;
-  if (model?.id) return model.id;
-  return 'gemini-2.0-flash';
-}
-
-function buildConfig({ system, tools, temperature, maxOutputTokens, topP, topK, safetySettings, responseModalities } = {}) {
-  const geminiTools = convertTools(tools);
-  const config = {
-    maxOutputTokens: maxOutputTokens ?? 8192,
-    temperature: temperature ?? 0.5,
-    topP: topP ?? 0.95
-  };
-  if (topK != null) config.topK = topK;
-  if (system) config.systemInstruction = system;
-  if (geminiTools.length > 0) config.tools = [{ functionDeclarations: geminiTools }];
-  if (safetySettings) config.safetySettings = safetySettings;
-  if (responseModalities) config.responseModalities = responseModalities;
-  return { config, geminiTools };
-}
-
-module.exports = { cleanSchema, convertTools, convertMessages, extractModelId, buildConfig, convertImageBlock };

package/lib/errors.js

@@ -1,140 +0,0 @@
-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 BridgeError) return err.retryable;
-  const status = err?.status ?? err?.code;
-  if (status === 429) return true;
-  if (typeof status === 'number' && status >= 500) return true;
-  const msg = err?.message ?? '';
-  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 || [];
-    const retryInfo = details.find(d => d['@type']?.includes('RetryInfo'));
-    if (retryInfo?.retryDelay) {
-      const secs = parseFloat(retryInfo.retryDelay);
-      if (!isNaN(secs)) return secs * 1000;
-    }
-  } catch (_) {}
-  return null;
-}
-
-async function withRetry(fn, maxRetries = 3) {
-  let lastErr;
-  for (let attempt = 0; attempt <= maxRetries; attempt++) {
-    try {
-      return await fn();
-    } catch (err) {
-      lastErr = err;
-      if (!isRetryable(err) || attempt === maxRetries) throw err;
-      const suggested = parseRetryDelay(err);
-      const delay = suggested != null ? suggested + Math.random() * 1000 : Math.min(1000 * 2 ** attempt + Math.random() * 200, 16000);
-      await new Promise(r => setTimeout(r, delay));
-    }
-  }
-  throw lastErr;
-}
-
-module.exports = {
-  BridgeError, GeminiError, AuthError, RateLimitError,
-  TimeoutError, ContextWindowError, ContentPolicyError,
-  ProviderError, classifyError, isRetryable, withRetry, redactKeys
-};

package/lib/oauth.js

@@ -1,133 +0,0 @@
-const http = require('http');
-const crypto = require('crypto');
-const fs = require('fs');
-const path = require('path');
-
-const CLIENT_ID = process.env.GOOGLE_OAUTH_CLIENT_ID || '';
-const CLIENT_SECRET = process.env.GOOGLE_OAUTH_CLIENT_SECRET || '';
-const SCOPES = 'https://www.googleapis.com/auth/cloud-platform https://www.googleapis.com/auth/userinfo.email https://www.googleapis.com/auth/userinfo.profile';
-const AUTH_URL = 'https://accounts.google.com/o/oauth2/v2/auth';
-const TOKEN_URL = 'https://oauth2.googleapis.com/token';
-const CODE_ASSIST_BASE = 'https://cloudcode-pa.googleapis.com/v1internal';
-const CODE_ASSIST_HEADERS = { 'X-Goog-Api-Client': 'gl-node/22.17.0', 'Client-Metadata': 'ideType=IDE_UNSPECIFIED,platform=PLATFORM_UNSPECIFIED,pluginType=GEMINI' };
-const TOKEN_PATH = path.join(process.env.HOME || process.env.USERPROFILE || '.', '.thebird', 'oauth-tokens.json');
-
-function base64url(buf) {
-  return buf.toString('base64').replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
-}
-
-function generatePkce() {
-  const verifier = base64url(crypto.randomBytes(32));
-  const challenge = base64url(crypto.createHash('sha256').update(verifier).digest());
-  return { verifier, challenge };
-}
-
-function readTokens() {
-  try { return JSON.parse(fs.readFileSync(TOKEN_PATH, 'utf8')); } catch { return null; }
-}
-
-function writeTokens(tokens) {
-  fs.mkdirSync(path.dirname(TOKEN_PATH), { recursive: true });
-  fs.writeFileSync(TOKEN_PATH, JSON.stringify(tokens, null, 2));
-}
-
-async function refreshAccessToken(refreshToken) {
-  const res = await fetch(TOKEN_URL, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
-    body: new URLSearchParams({ grant_type: 'refresh_token', refresh_token: refreshToken, client_id: CLIENT_ID, client_secret: CLIENT_SECRET })
-  });
-  if (!res.ok) throw new Error('Token refresh failed: ' + await res.text());
-  const data = await res.json();
-  return { accessToken: data.access_token, refreshToken: data.refresh_token || refreshToken, expiresAt: Date.now() + data.expires_in * 1000 };
-}
-
-async function getValidToken() {
-  const tokens = readTokens();
-  if (!tokens?.refreshToken) return null;
-  if (tokens.expiresAt && tokens.expiresAt > Date.now() + 60000) return tokens;
-  const refreshed = await refreshAccessToken(tokens.refreshToken);
-  const updated = { ...tokens, ...refreshed };
-  writeTokens(updated);
-  return updated;
-}
-
-async function resolveProject(accessToken) {
-  const res = await fetch(`${CODE_ASSIST_BASE}:loadCodeAssist`, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${accessToken}`, ...CODE_ASSIST_HEADERS },
-    body: JSON.stringify({ metadata: { ideType: 'IDE_UNSPECIFIED', platform: 'PLATFORM_UNSPECIFIED', pluginType: 'GEMINI' } })
-  });
-  if (!res.ok) throw new Error('Failed to load Code Assist project');
-  const data = await res.json();
-  const proj = data.cloudaicompanionProject;
-  if (proj) return typeof proj === 'string' ? proj : proj.id;
-  const tier = data.allowedTiers?.find(t => t.id === 'free-tier') || data.allowedTiers?.[0];
-  if (!tier) throw new Error('No eligible tier: ' + (data.ineligibleTiers?.[0]?.reasonMessage || 'unknown'));
-  const obRes = await fetch(`${CODE_ASSIST_BASE}:onboardUser`, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${accessToken}`, ...CODE_ASSIST_HEADERS },
-    body: JSON.stringify({ tierId: tier.id || 'legacy-tier', metadata: { ideType: 'IDE_UNSPECIFIED', platform: 'PLATFORM_UNSPECIFIED', pluginType: 'GEMINI' } })
-  });
-  if (!obRes.ok) throw new Error('Onboarding failed');
-  let op = await obRes.json();
-  for (let i = 0; i < 10 && !op.done && op.name; i++) {
-    await new Promise(r => setTimeout(r, 5000));
-    const pollRes = await fetch(`${CODE_ASSIST_BASE}/${op.name}`, { headers: { Authorization: `Bearer ${accessToken}`, ...CODE_ASSIST_HEADERS } });
-    if (pollRes.ok) op = await pollRes.json();
-  }
-  return op.response?.cloudaicompanionProject?.id;
-}
-
-function login(port) {
-  return new Promise((resolve, reject) => {
-    const { verifier, challenge } = generatePkce();
-    const state = crypto.randomBytes(32).toString('hex');
-    const callbackUrl = `http://localhost:${port}/callback`;
-    const url = new URL(AUTH_URL);
-    url.searchParams.set('client_id', CLIENT_ID);
-    url.searchParams.set('response_type', 'code');
-    url.searchParams.set('redirect_uri', callbackUrl);
-    url.searchParams.set('scope', SCOPES);
-    url.searchParams.set('code_challenge', challenge);
-    url.searchParams.set('code_challenge_method', 'S256');
-    url.searchParams.set('state', state);
-    url.searchParams.set('access_type', 'offline');
-    url.searchParams.set('prompt', 'consent');
-
-    const server = http.createServer(async (req, res) => {
-      const u = new URL(req.url, `http://localhost:${port}`);
-      if (!u.pathname.startsWith('/callback')) { res.end('waiting...'); return; }
-      if (u.searchParams.get('state') !== state) { res.end('Invalid state'); server.close(); reject(new Error('Invalid state')); return; }
-      const code = u.searchParams.get('code');
-      try {
-        const tokRes = await fetch(TOKEN_URL, {
-          method: 'POST',
-          headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
-          body: new URLSearchParams({ client_id: CLIENT_ID, client_secret: CLIENT_SECRET, code, grant_type: 'authorization_code', redirect_uri: callbackUrl, code_verifier: verifier })
-        });
-        if (!tokRes.ok) throw new Error('Token exchange failed: ' + await tokRes.text());
-        const payload = await tokRes.json();
-        if (!payload.refresh_token) throw new Error('No refresh token — ensure prompt=consent');
-        const projectId = await resolveProject(payload.access_token);
-        const tokens = { accessToken: payload.access_token, refreshToken: payload.refresh_token, expiresAt: Date.now() + payload.expires_in * 1000, projectId };
-        writeTokens(tokens);
-        res.end('Authenticated! You can close this tab.');
-        server.close();
-        resolve(tokens);
-      } catch (e) { res.end('Error: ' + e.message); server.close(); reject(e); }
-    });
-    server.listen(port, () => {
-      console.log(`Open this URL to authenticate:\n${url.toString()}\n`);
-      try { const { exec } = require('child_process'); exec(`start "" "${url.toString()}"`); } catch {}
-    });
-  });
-}
-
-async function ensureAuth(port) {
-  const existing = await getValidToken();
-  if (existing?.accessToken && existing?.projectId) return existing;
-  return login(port || 8585);
-}
-
-module.exports = { login, ensureAuth, getValidToken, readTokens, writeTokens, resolveProject, CODE_ASSIST_BASE, CODE_ASSIST_HEADERS };

package/lib/providers/acp.js

@@ -1,88 +0,0 @@
-const { BridgeError } = require('../errors');
-
-async function postJson(url, body) {
-  const res = await fetch(url, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(body) });
-  if (!res.ok) { const t = await res.text(); throw new BridgeError(t, { status: res.status, retryable: res.status === 429 || res.status >= 500 }); }
-  return res.json();
-}
-
-function subscribeSSE(url, onEvent) {
-  const ctrl = new AbortController();
-  (async () => {
-    try {
-      const res = await fetch(url, { signal: ctrl.signal });
-      if (!res.ok || !res.body) return;
-      const reader = res.body.getReader();
-      const dec = new TextDecoder();
-      let buf = '';
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done) return;
-        buf += dec.decode(value, { stream: true });
-        let i;
-        while ((i = buf.indexOf('\n\n')) >= 0) {
-          const chunk = buf.slice(0, i); buf = buf.slice(i + 2);
-          const line = chunk.split('\n').find(l => l.startsWith('data:'));
-          if (!line) continue;
-          try { onEvent(JSON.parse(line.slice(5))); } catch (_) {}
-        }
-      }
-    } catch (e) { if (e.name !== 'AbortError') throw e; }
-  })();
-  return () => ctrl.abort();
-}
-
-function toUserText(messages) {
-  return messages.filter(m => m.role === 'user').map(m =>
-    typeof m.content === 'string' ? m.content : (m.content || []).filter(b => b.type === 'text').map(b => b.text).join('')
-  ).join('\n');
-}
-
-async function* streamACP({ url, model, messages, onStepFinish }) {
-  yield { type: 'start-step' };
-  const base = (url || 'http://localhost:4780').replace(/\/$/, '');
-  const { id: sessionId } = await postJson(base + '/session', {});
-  const queue = []; let resolveNext = null; let done = false;
-  const push = ev => { queue.push(ev); if (resolveNext) { const r = resolveNext; resolveNext = null; r(); } };
-  const textSeen = new Map();
-  const toolState = new Map();
-  const unsubscribe = subscribeSSE(base + '/event', (msg) => {
-    if (msg.type !== 'message.part.updated') return;
-    const part = msg.properties?.part;
-    if (!part) return;
-    if (part.type === 'text' && part.messageID) {
-      const prior = textSeen.get(part.id) || '';
-      const txt = part.text || '';
-      if (txt.length > prior.length) { push({ type: 'text-delta', textDelta: txt.slice(prior.length) }); textSeen.set(part.id, txt); }
-    } else if (part.type === 'tool') {
-      const cid = part.callID; const st = part.state?.status;
-      if (st === 'running' && !toolState.has(cid)) { toolState.set(cid, { name: part.tool, args: part.state.input || {} }); push({ type: 'tool-call', toolCallId: cid, toolName: part.tool, args: part.state.input || {} }); }
-      else if (st === 'completed' && toolState.has(cid) && !toolState.get(cid).completed) { toolState.get(cid).completed = true; push({ type: 'tool-result', toolCallId: cid, toolName: part.tool, args: part.state.input || {}, result: part.state.output || '' }); }
-    }
-  });
-  const promptPromise = postJson(base + '/session/' + sessionId + '/message', {
-    parts: [{ type: 'text', text: toUserText(messages) }],
-    providerID: 'kilo',
-    modelID: model || 'x-ai/grok-code-fast-1:optimized:free',
-  }).finally(() => { done = true; if (resolveNext) { const r = resolveNext; resolveNext = null; r(); } });
-  while (!done || queue.length) {
-    if (queue.length) { yield queue.shift(); continue; }
-    await new Promise(r => { resolveNext = r; });
-  }
-  const result = await promptPromise;
-  unsubscribe();
-  yield { type: 'finish-step', finishReason: result.info?.finish || 'stop' };
-  if (onStepFinish) await onStepFinish();
-}
-
-async function generateACP(opts) {
-  let text = '';
-  const toolCalls = [];
-  for await (const ev of streamACP(opts)) {
-    if (ev.type === 'text-delta') text += ev.textDelta;
-    else if (ev.type === 'tool-call') toolCalls.push({ id: ev.toolCallId, name: ev.toolName, args: ev.args });
-  }
-  return { text, toolCalls };
-}
-
-module.exports = { streamACP, generateACP };

package/lib/providers/openai.js

@@ -1,134 +0,0 @@
-const { GeminiError } = require('../errors');
-const { guardStream } = require('../stream-guard');
-
-function convertMessages(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 convertTools(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 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, headers: res.headers }); }
-  return res;
-}
-
-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();
-    let buf = '', toolCallsMap = {};
-    try {
-      for await (const text of guardStream(readerIterable(reader), streamGuard)) {
-        buf += text;
-        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 = {};
-  }
-}
-
-async function generateOpenAI({ url, apiKey, headers, body, tools }) {
-  while (true) {
-    const res = await callOpenAI({ url, apiKey, headers, body: { ...body, stream: false } });
-    const data = await res.json();
-    const msg = data.choices?.[0]?.message;
-    if (!msg) throw new GeminiError('No message in response', { retryable: false });
-    if (!msg.tool_calls?.length) return { text: msg.content || '', response: data };
-    const toolResultMsgs = [];
-    for (const tc of msg.tool_calls) {
-      let args; try { args = JSON.parse(tc.function?.arguments || '{}'); } catch { args = {}; }
-      const toolDef = tools?.[tc.function?.name];
-      let result = toolDef ? null : { error: true, message: 'Tool not found: ' + tc.function?.name };
-      if (toolDef?.execute) try { result = await toolDef.execute(args); } catch(e) { result = { error: true, message: e.message }; }
-      toolResultMsgs.push({ role: 'tool', tool_call_id: tc.id, content: JSON.stringify(result ?? '') });
-    }
-    body = { ...body, messages: [...body.messages, msg, ...toolResultMsgs] };
-  }
-}
-
-module.exports = { streamOpenAI, generateOpenAI, convertMessages, convertTools };

package/lib/router-stream.js

@@ -1,95 +0,0 @@
-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 };