thebird 1.2.100 → 1.2.102

package/examples/streaming.js

@@ -1,81 +0,0 @@
-/**
- * streaming.js — Streaming with all event types demonstrated
- *
- * Usage:
- *   GEMINI_API_KEY=your-key node examples/streaming.js
- */
-const { streamGemini } = require('../index');
-
-const tools = {
-  get_time: {
-    description: 'Get the current time in a timezone.',
-    parameters: {
-      type: 'object',
-      properties: {
-        timezone: { type: 'string', description: 'IANA timezone name, e.g. America/New_York' }
-      },
-      required: ['timezone']
-    },
-    execute: async ({ timezone }) => {
-      const now = new Date().toLocaleString('en-US', { timeZone: timezone });
-      return { timezone, time: now };
-    }
-  }
-};
-
-async function main() {
-  console.log('Streaming all event types:\n');
-
-  const { fullStream } = streamGemini({
-    model: 'gemini-2.0-flash',
-    system: 'You are a helpful assistant. Be concise.',
-    messages: [
-      { role: 'user', content: "What time is it in Tokyo and New York right now?" }
-    ],
-    tools,
-    temperature: 0.3,
-    maxOutputTokens: 512,
-    onStepFinish: async () => {
-      console.log('\n[step finished]');
-    }
-  });
-
-  const stats = { steps: 0, toolCalls: 0, chars: 0 };
-
-  for await (const event of fullStream) {
-    switch (event.type) {
-      case 'start-step':
-        stats.steps++;
-        console.log(`\n[start-step #${stats.steps}]`);
-        break;
-
-      case 'text-delta':
-        stats.chars += event.textDelta.length;
-        process.stdout.write(event.textDelta);
-        break;
-
-      case 'tool-call':
-        stats.toolCalls++;
-        console.log(`\n[tool-call] id=${event.toolCallId} name=${event.toolName}`);
-        console.log('  args:', JSON.stringify(event.args));
-        break;
-
-      case 'tool-result':
-        console.log(`[tool-result] id=${event.toolCallId} name=${event.toolName}`);
-        console.log('  result:', JSON.stringify(event.result));
-        break;
-
-      case 'finish-step':
-        console.log(`\n[finish-step] reason=${event.finishReason}`);
-        break;
-
-      case 'error':
-        console.error('\n[error]', event.error.message);
-        break;
-    }
-  }
-
-  console.log(`\n\nStats: ${stats.steps} steps, ${stats.toolCalls} tool calls, ${stats.chars} chars`);
-}
-
-main().catch(console.error);

package/examples/tool-use.js

@@ -1,77 +0,0 @@
-/**
- * tool-use.js — Tool/function calling with generateGemini and streamGemini
- *
- * Usage:
- *   GEMINI_API_KEY=your-key node examples/tool-use.js
- */
-const { generateGemini, streamGemini } = require('../index');
-
-const tools = {
-  get_weather: {
-    description: 'Get the current weather for a given city.',
-    parameters: {
-      type: 'object',
-      properties: {
-        city: { type: 'string', description: 'The city name' },
-        unit: { type: 'string', enum: ['celsius', 'fahrenheit'], description: 'Temperature unit' }
-      },
-      required: ['city']
-    },
-    execute: async ({ city, unit = 'celsius' }) => {
-      // Simulated weather data
-      return { city, temperature: 22, unit, condition: 'Sunny' };
-    }
-  },
-  calculate: {
-    description: 'Evaluate a simple math expression.',
-    parameters: {
-      type: 'object',
-      properties: {
-        expression: { type: 'string', description: 'Math expression to evaluate, e.g. "2 + 2"' }
-      },
-      required: ['expression']
-    },
-    execute: async ({ expression }) => {
-      try {
-        // eslint-disable-next-line no-new-func
-        const result = Function('"use strict"; return (' + expression + ')')();
-        return { result };
-      } catch {
-        return { error: 'Invalid expression' };
-      }
-    }
-  }
-};
-
-async function nonStreamingExample() {
-  console.log('=== Non-streaming tool use ===');
-  const result = await generateGemini({
-    model: 'gemini-2.0-flash',
-    messages: [{ role: 'user', content: "What's the weather in Tokyo and what is 17 * 43?" }],
-    tools
-  });
-  console.log('Final answer:', result.text);
-}
-
-async function streamingExample() {
-  console.log('\n=== Streaming tool use ===');
-  const { fullStream } = streamGemini({
-    model: 'gemini-2.0-flash',
-    messages: [{ role: 'user', content: 'What is 100 / 4? Use the calculator.' }],
-    tools
-  });
-
-  for await (const event of fullStream) {
-    if (event.type === 'tool-call') console.log(`[tool-call] ${event.toolName}(${JSON.stringify(event.args)})`);
-    if (event.type === 'tool-result') console.log(`[tool-result] ${JSON.stringify(event.result)}`);
-    if (event.type === 'text-delta') process.stdout.write(event.textDelta);
-    if (event.type === 'finish-step') console.log(`\n[finish] reason=${event.finishReason}`);
-  }
-}
-
-async function main() {
-  await nonStreamingExample();
-  await streamingExample();
-}
-
-main().catch(console.error);

package/examples/vision.js

@@ -1,84 +0,0 @@
-/**
- * vision.js — Image/vision understanding examples
- *
- * Demonstrates three ways to pass images:
- *   1. Base64 inline data (Anthropic SDK style)
- *   2. Gemini inlineData style
- *   3. Public URL via fileData
- *
- * Usage:
- *   GEMINI_API_KEY=your-key node examples/vision.js
- */
-const fs = require('fs');
-const path = require('path');
-const { generateGemini } = require('../index');
-
-async function base64Example() {
-  console.log('=== Base64 image (Anthropic style) ===');
-  // Read a local image and encode as base64
-  // const imageBuffer = fs.readFileSync(path.join(__dirname, 'sample.jpg'));
-  // const base64 = imageBuffer.toString('base64');
-
-  // For demo purposes, use a tiny 1x1 transparent PNG
-  const base64 = 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==';
-
-  const result = await generateGemini({
-    model: 'gemini-2.0-flash',
-    messages: [{
-      role: 'user',
-      content: [
-        {
-          type: 'image',
-          source: { type: 'base64', media_type: 'image/png', data: base64 }
-        },
-        { type: 'text', text: 'Describe this image in one sentence.' }
-      ]
-    }]
-  });
-  console.log('Response:', result.text);
-}
-
-async function inlineDataExample() {
-  console.log('\n=== Gemini inlineData style ===');
-  const base64 = 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==';
-
-  const result = await generateGemini({
-    model: 'gemini-2.0-flash',
-    messages: [{
-      role: 'user',
-      content: [
-        { inlineData: { mimeType: 'image/png', data: base64 } },
-        { type: 'text', text: 'What color is this image?' }
-      ]
-    }]
-  });
-  console.log('Response:', result.text);
-}
-
-async function publicUrlExample() {
-  console.log('\n=== Public URL via fileData ===');
-  const result = await generateGemini({
-    model: 'gemini-2.0-flash',
-    messages: [{
-      role: 'user',
-      content: [
-        {
-          fileData: {
-            mimeType: 'image/jpeg',
-            fileUri: 'https://upload.wikimedia.org/wikipedia/commons/thumb/4/47/PNG_transparency_demonstration_1.png/240px-PNG_transparency_demonstration_1.png'
-          }
-        },
-        { type: 'text', text: 'What do you see in this image?' }
-      ]
-    }]
-  });
-  console.log('Response:', result.text);
-}
-
-async function main() {
-  await base64Example();
-  await inlineDataExample();
-  // await publicUrlExample(); // Uncomment to test with public URLs
-}
-
-main().catch(console.error);

package/index.d.ts

@@ -1,126 +0,0 @@
-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; streamGuard?: StreamGuardOptions }
-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;
-  capabilities?: Partial<CapabilitySet>;
-}
-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;
-  circuitBreaker?: CircuitBreakerOptions;
-}
-export interface RouterInstance {
-  breaker: { isOpen(name: string): boolean; recordFailure(name: string): void; recordSuccess(name: string): void };
-  stream(params: StreamParams): StreamResult;
-  generate(params: GenerationParams): Promise<GenerateResult | { text: string; response: unknown }>;
-}
-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 interface StreamGuardOptions {
-  chunkTimeoutMs?: number;
-  maxRepeats?: number;
-}
-export interface CapabilitySet {
-  streaming: boolean;
-  toolUse: boolean;
-  vision: boolean;
-  systemMessage: boolean;
-  jsonMode: boolean;
-}
-export interface CircuitBreakerOptions {
-  maxFailures?: number;
-  cooldownMs?: number;
-}
-export class BridgeError extends Error {
-  name: string;
-  status?: number;
-  code?: string | number;
-  retryable: boolean;
-  provider?: string;
-  constructor(message: string, options?: { status?: number; code?: string | number; retryable?: boolean; provider?: string; headers?: unknown });
-}
-export class AuthError extends BridgeError {}
-export class RateLimitError extends BridgeError {}
-export class TimeoutError extends BridgeError {}
-export class ContextWindowError extends BridgeError {}
-export class ContentPolicyError extends BridgeError {}
-export class ProviderError extends BridgeError {}
-export const GeminiError: typeof BridgeError;
-export function classifyError(status: number, message: string, provider?: string): BridgeError;
-export function redactKeys(str: string): string;

package/lib/capabilities.js

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

package/lib/circuit-breaker.js

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

package/lib/client.js

@@ -1,10 +0,0 @@
-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/cloud-generate.js

@@ -1,119 +0,0 @@
-const { convertMessages, convertTools, cleanSchema, extractModelId, buildConfig } = require('./convert');
-const { ensureAuth, CODE_ASSIST_BASE, CODE_ASSIST_HEADERS } = require('./oauth');
-const crypto = require('crypto');
-
-function buildUserAgent(model) {
-  return `gemini-cli/0.30.0 (node; ${process.platform}) model/${model || 'unknown'}`;
-}
-
-async function cloudGenerate({ model, system, messages, tools, temperature, maxOutputTokens, topP, topK, safetySettings, responseModalities, authPort }) {
-  const tokens = await ensureAuth(authPort);
-  const modelId = extractModelId(model);
-  const contents = convertMessages(messages);
-  const { config } = buildConfig({ system, tools, temperature, maxOutputTokens, topP, topK, safetySettings, responseModalities });
-
-  const request = { contents };
-  if (config.systemInstruction) request.systemInstruction = { parts: [{ text: config.systemInstruction }] };
-  if (config.tools) request.tools = config.tools;
-  const genConfig = {};
-  if (config.maxOutputTokens) genConfig.maxOutputTokens = config.maxOutputTokens;
-  if (config.temperature != null) genConfig.temperature = config.temperature;
-  if (config.topP != null) genConfig.topP = config.topP;
-  if (config.topK != null) genConfig.topK = config.topK;
-  if (config.responseModalities) genConfig.responseModalities = config.responseModalities;
-  if (Object.keys(genConfig).length) request.generationConfig = genConfig;
-
-  const envelope = { project: tokens.projectId, model: modelId, user_prompt_id: crypto.randomUUID(), request };
-
-  const res = await fetch(`${CODE_ASSIST_BASE}:generateContent`, {
-    method: 'POST',
-    headers: {
-      'Content-Type': 'application/json',
-      Authorization: `Bearer ${tokens.accessToken}`,
-      'User-Agent': buildUserAgent(modelId),
-      'x-activity-request-id': crypto.randomUUID(),
-      ...CODE_ASSIST_HEADERS
-    },
-    body: JSON.stringify(envelope)
-  });
-
-  if (!res.ok) throw new Error(`Cloud generate failed (${res.status}): ${await res.text()}`);
-  const data = await res.json();
-  const inner = data.response || data;
-  const candidate = inner.candidates?.[0];
-  if (!candidate) throw new Error('No candidates returned');
-  const allParts = candidate.content?.parts || [];
-  const text = allParts.filter(p => p.text && !p.thought).map(p => p.text).join('');
-  return { text, parts: allParts, response: inner };
-}
-
-async function* cloudStream({ model, system, messages, tools, onStepFinish, temperature, maxOutputTokens, topP, topK, safetySettings, responseModalities, authPort }) {
-  const tokens = await ensureAuth(authPort);
-  const modelId = extractModelId(model);
-  const contents = convertMessages(messages);
-  const { config } = buildConfig({ system, tools, temperature, maxOutputTokens, topP, topK, safetySettings, responseModalities });
-
-  const request = { contents };
-  if (config.systemInstruction) request.systemInstruction = { parts: [{ text: config.systemInstruction }] };
-  if (config.tools) request.tools = config.tools;
-  const genConfig = {};
-  if (config.maxOutputTokens) genConfig.maxOutputTokens = config.maxOutputTokens;
-  if (config.temperature != null) genConfig.temperature = config.temperature;
-  if (config.topP != null) genConfig.topP = config.topP;
-  if (config.topK != null) genConfig.topK = config.topK;
-  if (config.responseModalities) genConfig.responseModalities = config.responseModalities;
-  if (Object.keys(genConfig).length) request.generationConfig = genConfig;
-
-  const envelope = { project: tokens.projectId, model: modelId, user_prompt_id: crypto.randomUUID(), request };
-
-  const res = await fetch(`${CODE_ASSIST_BASE}:streamGenerateContent?alt=sse`, {
-    method: 'POST',
-    headers: {
-      'Content-Type': 'application/json',
-      Authorization: `Bearer ${tokens.accessToken}`,
-      'User-Agent': buildUserAgent(modelId),
-      'x-activity-request-id': crypto.randomUUID(),
-      Accept: 'text/event-stream',
-      ...CODE_ASSIST_HEADERS
-    },
-    body: JSON.stringify(envelope)
-  });
-
-  if (!res.ok) throw new Error(`Cloud stream failed (${res.status}): ${await res.text()}`);
-
-  yield { type: 'start-step' };
-  const reader = res.body.getReader();
-  const decoder = new TextDecoder();
-  let buffer = '';
-
-  while (true) {
-    const { done, value } = await reader.read();
-    if (done) break;
-    buffer += decoder.decode(value, { stream: true });
-    const lines = buffer.split('\n');
-    buffer = lines.pop() || '';
-    for (const line of lines) {
-      const trimmed = line.trim();
-      if (!trimmed.startsWith('data:')) continue;
-      const json = trimmed.slice(5).trim();
-      if (!json || json === '[DONE]') continue;
-      try {
-        const parsed = JSON.parse(json);
-        const inner = parsed.response || parsed;
-        const parts = inner.candidates?.[0]?.content?.parts || [];
-        for (const part of parts) {
-          if (part.text && !part.thought) yield { type: 'text-delta', textDelta: part.text };
-          if (part.inlineData) yield { type: 'image-data', inlineData: part.inlineData };
-        }
-      } catch {}
-    }
-  }
-  yield { type: 'finish-step', finishReason: 'stop' };
-  if (onStepFinish) await onStepFinish();
-}
-
-function streamCloud(params) {
-  return { fullStream: cloudStream(params), warnings: Promise.resolve([]) };
-}
-
-module.exports = { cloudGenerate, cloudStream, streamCloud };

package/lib/config.js

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