thebird 1.2.1

package/index.d.ts

@@ -0,0 +1,98 @@
+export interface TextBlock { type: 'text'; text: string }
+export interface ImageBlockBase64 { type: 'image'; source: { type: 'base64'; media_type: string; data: string } }
+export interface ImageBlockUrl { type: 'image'; source: { type: 'url'; url: string; media_type?: string } }
+export interface ImageBlockInline { inlineData: { mimeType: string; data: string } }
+export interface ImageBlockFile { fileData: { mimeType: string; fileUri: string } }
+export type ImageBlock = ImageBlockBase64 | ImageBlockUrl | ImageBlockInline | ImageBlockFile;
+export interface ToolUseBlock { type: 'tool_use'; name: string; input: Record<string, unknown> }
+export interface ToolResultBlock { type: 'tool_result'; name: string; content: string | Record<string, unknown> }
+export type ContentBlock = TextBlock | ImageBlock | ToolUseBlock | ToolResultBlock;
+export interface Message { role: 'user' | 'assistant'; content: string | ContentBlock[] }
+export interface ToolDefinition {
+  description?: string;
+  parameters?: Record<string, unknown>;
+  execute?: (args: Record<string, unknown>, ctx?: { toolCallId: string }) => Promise<unknown>;
+}
+export type Tools = Record<string, ToolDefinition>;
+export interface SafetySetting { category: string; threshold: string }
+export interface GenerationParams {
+  model?: string | { modelId?: string; id?: string };
+  system?: string;
+  messages: Message[];
+  tools?: Tools;
+  apiKey?: string;
+  temperature?: number;
+  maxOutputTokens?: number;
+  topP?: number;
+  topK?: number;
+  safetySettings?: SafetySetting[];
+  configPath?: string;
+  taskType?: 'background' | 'think' | 'webSearch' | 'image';
+}
+export interface StartStepEvent { type: 'start-step' }
+export interface TextDeltaEvent { type: 'text-delta'; textDelta: string }
+export interface ToolCallEvent { type: 'tool-call'; toolCallId: string; toolName: string; args: Record<string, unknown> }
+export interface ToolResultEvent { type: 'tool-result'; toolCallId: string; toolName: string; args: Record<string, unknown>; result: unknown }
+export interface FinishStepEvent { type: 'finish-step'; finishReason: 'stop' | 'tool-calls' | 'error' }
+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 function streamGemini(params: StreamParams): StreamResult;
+export interface GenerateResult { text: string; parts: unknown[]; response: unknown }
+export function generateGemini(params: GenerationParams): Promise<GenerateResult>;
+
+export type TransformerEntry = string | [string, Record<string, unknown>];
+export interface TransformerConfig {
+  use?: TransformerEntry[];
+  [modelName: string]: { use?: TransformerEntry[] } | TransformerEntry[] | undefined;
+}
+export interface ProviderConfig {
+  name: string;
+  api_base_url: string;
+  api_key: string;
+  models?: string[];
+  transformer?: TransformerConfig;
+}
+export interface RouterConfig {
+  default?: string;
+  background?: string;
+  think?: string;
+  longContext?: string;
+  longContextThreshold?: number;
+  webSearch?: string;
+  image?: string;
+}
+export interface RouterConfiguration {
+  Providers?: ProviderConfig[];
+  providers?: ProviderConfig[];
+  Router?: RouterConfig;
+  customRouter?: (params: GenerationParams, config: RouterConfig) => Promise<string | null>;
+  configPath?: string;
+}
+export interface RouterInstance {
+  stream(params: StreamParams): StreamResult;
+  generate(params: GenerationParams): Promise<GenerateResult | { text: string; response: unknown }>;
+}
+export function createRouter(config: RouterConfiguration): RouterInstance;
+export function streamRouter(params: StreamParams & RouterConfiguration): StreamResult;
+export function generateRouter(params: GenerationParams & RouterConfiguration): Promise<GenerateResult | { text: string; response: unknown }>;
+
+export interface GeminiPart {
+  text?: string;
+  functionCall?: { name: string; args: Record<string, unknown> };
+  functionResponse?: { name: string; response: unknown };
+  inlineData?: { mimeType: string; data: string };
+  fileData?: { mimeType: string; fileUri: string };
+}
+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';
+  status?: number;
+  code?: string | number;
+  retryable: boolean;
+  constructor(message: string, options?: { status?: number; code?: string | number; retryable?: boolean });
+}

package/index.js

@@ -0,0 +1,173 @@
+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');
+
+function streamGemini({ model, system, messages, tools, onStepFinish, apiKey,
+  temperature, maxOutputTokens, topP, topK, safetySettings }) {
+  return {
+    fullStream: createFullStream({ model, system, messages, tools, onStepFinish, apiKey, temperature, maxOutputTokens, topP, topK, safetySettings }),
+    warnings: Promise.resolve([])
+  };
+}
+
+async function* createFullStream({ model, system, messages, tools, onStepFinish, apiKey, temperature, maxOutputTokens, topP, topK, safetySettings }) {
+  const client = getClient(apiKey);
+  const modelId = extractModelId(model);
+  let contents = convertMessages(messages);
+  const { config } = buildConfig({ system, tools, temperature, maxOutputTokens, topP, topK, safetySettings });
+  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: 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 }) {
+  const client = getClient(apiKey);
+  const modelId = extractModelId(model);
+  let contents = convertMessages(messages);
+  const { config } = buildConfig({ system, tools, temperature, maxOutputTokens, topP, topK, safetySettings });
+  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: result || {} } });
+    }
+    contents.push({ role: 'model', parts: allParts });
+    contents.push({ role: 'user', parts: toolResultParts });
+  }
+}
+
+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);
+}
+
+module.exports = { streamGemini, generateGemini, streamRouter, generateRouter, createRouter, convertMessages, convertTools, cleanSchema, GeminiError };

package/lib/client.js

@@ -0,0 +1,10 @@
+const { GoogleGenAI } = require('@google/genai');
+
+let _client = null;
+
+function getClient(apiKey) {
+  if (!_client || apiKey) _client = new GoogleGenAI({ apiKey: apiKey || process.env.GEMINI_API_KEY });
+  return _client;
+}
+
+module.exports = { getClient };

package/lib/config.js

@@ -0,0 +1,24 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+function interpolateEnv(val) {
+  if (typeof val === 'string') return val.replace(/\$\{([^}]+)\}|\$([A-Z_][A-Z0-9_]*)/g, (_, a, b) => process.env[a || b] || '');
+  if (Array.isArray(val)) return val.map(interpolateEnv);
+  if (val && typeof val === 'object') {
+    const out = {};
+    for (const [k, v] of Object.entries(val)) out[k] = interpolateEnv(v);
+    return out;
+  }
+  return val;
+}
+
+function loadConfig(configPath) {
+  const fp = configPath || process.env.THEBIRD_CONFIG || path.join(os.homedir(), '.thebird', 'config.json');
+  try {
+    const raw = JSON.parse(fs.readFileSync(fp, 'utf8'));
+    return interpolateEnv(raw);
+  } catch { return {}; }
+}
+
+module.exports = { loadConfig, interpolateEnv };

package/lib/convert.js

@@ -0,0 +1,86 @@
+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 } = {}) {
+  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;
+  return { config, geminiTools };
+}
+
+module.exports = { cleanSchema, convertTools, convertMessages, extractModelId, buildConfig, convertImageBlock };

package/lib/errors.js

@@ -0,0 +1,35 @@
+class GeminiError extends Error {
+  constructor(message, { status, code, retryable = false } = {}) {
+    super(message);
+    this.name = 'GeminiError';
+    this.status = status;
+    this.code = code;
+    this.retryable = retryable;
+  }
+}
+
+function isRetryable(err) {
+  if (err instanceof GeminiError) 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);
+}
+
+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 delay = Math.min(1000 * 2 ** attempt + Math.random() * 200, 16000);
+      await new Promise(r => setTimeout(r, delay));
+    }
+  }
+  throw lastErr;
+}
+
+module.exports = { GeminiError, isRetryable, withRetry };

package/lib/providers/openai.js

@@ -0,0 +1,127 @@
+const { GeminiError } = require('../errors');
+
+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 }); }
+  return res;
+}
+
+async function* streamOpenAI({ url, apiKey, headers, body, tools, onStepFinish }) {
+  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 });
+        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.js

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