thebird 1.2.100 → 1.2.102

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;

package/thebird-browser-entry.js

@@ -1,196 +0,0 @@
-const { getClient } = require('./lib/client.js');
-const { GeminiError, withRetry } = require('./lib/errors.js');
-const { convertMessages, convertTools, cleanSchema, extractModelId, buildConfig } = require('./lib/convert.js');
-
-function streamGemini({ model, system, messages, tools, onStepFinish, apiKey, temperature, maxOutputTokens, topP, topK, safetySettings, responseModalities }) {
-  return { fullStream: createFullStream({ model, system, messages, tools, onStepFinish, apiKey, temperature, maxOutputTokens, topP, topK, safetySettings, responseModalities }), warnings: Promise.resolve([]) };
-}
-
-async function* createFullStream({ model, system, messages, tools, onStepFinish, apiKey, temperature, maxOutputTokens, topP, topK, safetySettings, responseModalities }) {
-  const client = getClient(apiKey);
-  const modelId = extractModelId(model);
-  let contents = convertMessages(messages);
-  const { config } = buildConfig({ system, tools, temperature, maxOutputTokens, topP, topK, safetySettings, responseModalities });
-  while (true) {
-    yield { type: 'start-step' };
-    try {
-      const stream = await withRetry(() => client.models.generateContentStream({ model: modelId, contents, config }));
-      const allParts = [];
-      for await (const chunk of stream) {
-        for (const candidate of (chunk.candidates || [])) {
-          for (const part of (candidate.content?.parts || [])) {
-            allParts.push(part);
-            if (part.text && !part.thought) yield { type: 'text-delta', textDelta: part.text };
-          }
-        }
-      }
-      const fcParts = allParts.filter(p => p.functionCall);
-      if (fcParts.length === 0) {
-        yield { type: 'finish-step', finishReason: 'stop' };
-        if (onStepFinish) await onStepFinish();
-        return;
-      }
-      const toolResultParts = [];
-      for (const part of fcParts) {
-        const name = part.functionCall.name;
-        const args = part.functionCall.args || {};
-        const toolId = 'toolu_' + Math.random().toString(36).slice(2, 10);
-        yield { type: 'tool-call', toolCallId: toolId, toolName: name, args };
-        const toolDef = tools?.[name];
-        let result = toolDef ? null : { error: true, message: 'Tool not found: ' + name };
-        if (toolDef?.execute) {
-          try { result = await toolDef.execute(args, { toolCallId: toolId }); }
-          catch (e) { result = { error: true, message: e.message }; }
-        }
-        yield { type: 'tool-result', toolCallId: toolId, toolName: name, args, result };
-        toolResultParts.push({ functionResponse: { name, response: typeof result === 'string' ? { output: result } : (result || {}) } });
-      }
-      yield { type: 'finish-step', finishReason: 'tool-calls' };
-      if (onStepFinish) await onStepFinish();
-      contents.push({ role: 'model', parts: allParts });
-      contents.push({ role: 'user', parts: toolResultParts });
-    } catch (err) {
-      yield { type: 'error', error: err };
-      yield { type: 'finish-step', finishReason: 'error' };
-      if (onStepFinish) await onStepFinish();
-      return;
-    }
-  }
-}
-
-async function generateGemini({ model, system, messages, tools, apiKey, temperature, maxOutputTokens, topP, topK, safetySettings, responseModalities }) {
-  const client = getClient(apiKey);
-  const modelId = extractModelId(model);
-  let contents = convertMessages(messages);
-  const { config } = buildConfig({ system, tools, temperature, maxOutputTokens, topP, topK, safetySettings, responseModalities });
-  while (true) {
-    const response = await withRetry(() => client.models.generateContent({ model: modelId, contents, config }));
-    const candidate = response.candidates?.[0];
-    if (!candidate) throw new GeminiError('No candidates returned', { retryable: false });
-    const allParts = candidate.content?.parts || [];
-    const fcParts = allParts.filter(p => p.functionCall);
-    if (fcParts.length === 0) {
-      const text = allParts.filter(p => p.text && !p.thought).map(p => p.text).join('');
-      return { text, parts: allParts, response };
-    }
-    const toolResultParts = [];
-    for (const part of fcParts) {
-      const name = part.functionCall.name;
-      const args = part.functionCall.args || {};
-      const toolDef = tools?.[name];
-      let result = toolDef ? null : { error: true, message: 'Tool not found: ' + name };
-      if (toolDef?.execute) {
-        try { result = await toolDef.execute(args); }
-        catch (e) { result = { error: true, message: e.message }; }
-      }
-      toolResultParts.push({ functionResponse: { name, response: typeof result === 'string' ? { output: result } : (result || {}) } });
-    }
-    contents.push({ role: 'model', parts: allParts });
-    contents.push({ role: 'user', parts: toolResultParts });
-  }
-}
-
-function convertMessagesOAI(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 convertToolsOAI(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* streamOpenAI({ url, apiKey, messages, system, model, tools, maxOutputTokens, temperature, onStepFinish }) {
-  const oaiMsgs = convertMessagesOAI(messages, system);
-  const oaiTools = convertToolsOAI(tools);
-  let body = { messages: oaiMsgs, model, max_tokens: maxOutputTokens || 8192, temperature: temperature ?? 0.5 };
-  if (oaiTools) body.tools = oaiTools;
-  while (true) {
-    yield { type: 'start-step' };
-    const res = await fetch(url, { method: 'POST',
-      headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${apiKey}` },
-      body: JSON.stringify({ ...body, stream: true }) });
-    if (!res.ok) { const t = await res.text(); throw new Error(t); }
-    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 });
-        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 = {};
-  }
-}
-
-module.exports = { streamGemini, generateGemini, streamOpenAI };