thebird 1.2.99 → 1.2.101

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 };

package/lib/router.js

@@ -1,51 +0,0 @@
-const { loadConfig } = require('./config');
-
-const SUBAGENT_RE = /<CCR-SUBAGENT-MODEL>([^<]+)<\/CCR-SUBAGENT-MODEL>/;
-
-function estimateTokens(messages, system) {
-  let chars = typeof system === 'string' ? system.length : (system ? JSON.stringify(system).length : 0);
-  for (const m of (messages || [])) {
-    chars += typeof m.content === 'string' ? m.content.length : JSON.stringify(m.content || '').length;
-  }
-  return Math.ceil(chars / 4);
-}
-
-function extractSubagentModel(messages) {
-  const first = messages?.[0];
-  if (!first) return null;
-  const text = typeof first.content === 'string' ? first.content :
-    (Array.isArray(first.content) ? first.content.map(b => b.text || '').join('') : '');
-  const m = SUBAGENT_RE.exec(text);
-  return m ? m[1].trim() : null;
-}
-
-function parseProviderModel(str) {
-  const idx = str.indexOf(',');
-  if (idx === -1) return { providerName: null, modelName: str };
-  return { providerName: str.slice(0, idx), modelName: str.slice(idx + 1) };
-}
-
-async function route(params, routerCfg, customRouterFn) {
-  const { messages, system, taskType } = params;
-
-  if (customRouterFn) {
-    const custom = await customRouterFn(params, routerCfg);
-    if (custom) return parseProviderModel(custom);
-  }
-
-  const subagent = extractSubagentModel(messages);
-  if (subagent) return parseProviderModel(subagent);
-
-  if (taskType === 'background' && routerCfg.background) return parseProviderModel(routerCfg.background);
-  if (taskType === 'think' && routerCfg.think) return parseProviderModel(routerCfg.think);
-  if (taskType === 'webSearch' && routerCfg.webSearch) return parseProviderModel(routerCfg.webSearch);
-  if (taskType === 'image' && routerCfg.image) return parseProviderModel(routerCfg.image);
-
-  const threshold = routerCfg.longContextThreshold || 60000;
-  if (routerCfg.longContext && estimateTokens(messages, system) > threshold) return parseProviderModel(routerCfg.longContext);
-
-  if (routerCfg.default) return parseProviderModel(routerCfg.default);
-  return { providerName: null, modelName: null };
-}
-
-module.exports = { route, estimateTokens, parseProviderModel };

package/lib/stream-guard.js

@@ -1,35 +0,0 @@
-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/lib/transformers.js

@@ -1,93 +0,0 @@
-function removeCacheControl(obj) {
-  if (!obj || typeof obj !== 'object') return obj;
-  if (Array.isArray(obj)) return obj.map(removeCacheControl);
-  const out = {};
-  for (const [k, v] of Object.entries(obj)) {
-    if (k === 'cache_control') continue;
-    out[k] = removeCacheControl(v);
-  }
-  return out;
-}
-
-const BUILT_IN = {
-  cleancache: {
-    request(req) { return { ...req, messages: removeCacheControl(req.messages), system: removeCacheControl(req.system) }; }
-  },
-  deepseek: {
-    request(req) {
-      const r = removeCacheControl(req);
-      if (r.system && typeof r.system !== 'string') {
-        r.system = (Array.isArray(r.system) ? r.system : [r.system]).map(b => b.text || '').join('\n');
-      }
-      return r;
-    }
-  },
-  openrouter: {
-    options: {},
-    request(req, opts) {
-      const headers = { 'HTTP-Referer': 'https://github.com/AnEntrypoint/thebird', 'X-Title': 'thebird', ...(opts || {}).headers };
-      if ((opts || {}).provider) req = { ...req, provider: (opts || {}).provider };
-      return { ...req, _extraHeaders: { ...(req._extraHeaders || {}), ...headers } };
-    }
-  },
-  maxtoken: {
-    request(req, opts) { return { ...req, max_tokens: (opts || {}).max_tokens || req.max_tokens }; }
-  },
-  tooluse: {
-    request(req) {
-      if (req.tools && req.tools.length > 0) return { ...req, tool_choice: { type: 'required' } };
-      return req;
-    }
-  },
-  reasoning: {
-    request(req) { return req; },
-    response(res) {
-      if (!res.choices) return res;
-      return {
-        ...res,
-        choices: res.choices.map(c => {
-          if (!c.message) return c;
-          const msg = { ...c.message };
-          if (msg.reasoning_content) { msg._reasoning = msg.reasoning_content; delete msg.reasoning_content; }
-          return { ...c, message: msg };
-        })
-      };
-    }
-  },
-  sampling: {
-    request(req) {
-      const r = { ...req };
-      delete r.top_k;
-      delete r.repetition_penalty;
-      return r;
-    }
-  },
-  groq: {
-    request(req) {
-      const r = { ...req };
-      delete r.top_k;
-      return r;
-    }
-  }
-};
-
-function resolveTransformers(useList, customMap) {
-  if (!useList) return [];
-  return useList.map(entry => {
-    const name = Array.isArray(entry) ? entry[0] : entry;
-    const opts = Array.isArray(entry) ? entry[1] : undefined;
-    const t = (customMap && customMap[name]) || BUILT_IN[name];
-    if (!t) { console.warn('[thebird] unknown transformer:', name); return null; }
-    return { transformer: t, opts };
-  }).filter(Boolean);
-}
-
-function applyRequestTransformers(req, transformers) {
-  return transformers.reduce((r, { transformer, opts }) => transformer.request ? transformer.request(r, opts) : r, req);
-}
-
-function applyResponseTransformers(res, transformers) {
-  return transformers.reduce((r, { transformer, opts }) => transformer.response ? transformer.response(r, opts) : r, res);
-}
-
-module.exports = { resolveTransformers, applyRequestTransformers, applyResponseTransformers, BUILT_IN };

package/thebird-browser-entry-esm.js

@@ -1,4 +0,0 @@
-import tb from './thebird-browser-entry.js';
-export const streamGemini = tb.streamGemini;
-export const generateGemini = tb.generateGemini;
-export const streamOpenAI = tb.streamOpenAI;