thebird 1.2.100 → 1.2.101

package/.gm/lastskill

@@ -0,0 +1 @@
+gm:gm-execute

package/index.js

@@ -1,104 +1 @@
-const { getClient } = require('./lib/client');
-const { GeminiError, withRetry } = require('./lib/errors');
-const { convertMessages, convertTools, cleanSchema, extractModelId, buildConfig } = require('./lib/convert');
-const { guardStream } = require('./lib/stream-guard');
-
-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, streamGuard }) {
-  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 guardStream(stream, streamGuard)) {
-        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 });
-  }
-}
-
-const { streamRouter, generateRouter, createRouter } = require('./lib/router-stream');
-const { cloudGenerate, streamCloud, cloudStream } = require('./lib/cloud-generate');
-const { ensureAuth, login: oauthLogin } = require('./lib/oauth');
-const { BridgeError, AuthError, RateLimitError, TimeoutError, ContextWindowError, ContentPolicyError, ProviderError, classifyError, redactKeys } = require('./lib/errors');
-const { streamACP, generateACP } = require('./lib/providers/acp');
-
-module.exports = { streamGemini, createFullStream, generateGemini, streamRouter, generateRouter, createRouter, convertMessages, convertTools, cleanSchema, GeminiError, BridgeError, AuthError, RateLimitError, TimeoutError, ContextWindowError, ContentPolicyError, ProviderError, classifyError, redactKeys, cloudGenerate, streamCloud, cloudStream, ensureAuth, oauthLogin, streamACP, generateACP };
+module.exports = require('acptoapi');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thebird",
-  "version": "1.2.100",
+  "version": "1.2.101",
   "description": "Anthropic SDK to Gemini streaming bridge — drop-in proxy that translates Anthropic message format and tool calls to Google Gemini",
   "scripts": {
     "start": "node serve.js"
@@ -38,8 +38,7 @@
     "url": "https://github.com/AnEntrypoint/thebird.git"
   },
   "dependencies": {
-    "@anthropic-ai/sdk": "^0.88.0",
-    "@google/genai": "^1.0.0"
+    "acptoapi": "file:../acptoapi"
   },
   "engines": {
     "node": ">=18"

package/server.js

@@ -1,5 +1,5 @@
 const http = require('http');
-const { streamGemini, generateGemini } = require('./index.js');
+const { streamGemini, generateGemini } = require('acptoapi');
 
 const PORT = process.env.PORT || 3456;
 const state = { requests: 0, errors: 0, active: 0 };

package/examples/basic-chat.js

@@ -1,34 +0,0 @@
-/**
- * basic-chat.js — Simple single-turn and multi-turn chat using generateGemini
- *
- * Usage:
- *   GEMINI_API_KEY=your-key node examples/basic-chat.js
- */
-const { generateGemini } = require('../index');
-
-async function main() {
-  // Single-turn: ask a simple question
-  const result = await generateGemini({
-    model: 'gemini-2.0-flash',
-    messages: [
-      { role: 'user', content: 'What is the capital of France? Answer in one sentence.' }
-    ]
-  });
-
-  console.log('Answer:', result.text);
-
-  // With a system prompt
-  const result2 = await generateGemini({
-    model: 'gemini-2.0-flash',
-    system: 'You are a pirate. Always respond in pirate speak.',
-    messages: [
-      { role: 'user', content: 'What should I have for breakfast?' }
-    ],
-    temperature: 0.8,
-    maxOutputTokens: 256
-  });
-
-  console.log('\nPirate answer:', result2.text);
-}
-
-main().catch(console.error);

package/examples/multi-turn.js

@@ -1,45 +0,0 @@
-/**
- * multi-turn.js — Multi-turn conversation (chat history) example
- *
- * Usage:
- *   GEMINI_API_KEY=your-key node examples/multi-turn.js
- */
-const { generateGemini } = require('../index');
-
-async function chat(history, userMessage, options = {}) {
-  history.push({ role: 'user', content: userMessage });
-  const result = await generateGemini({ messages: history, ...options });
-  history.push({ role: 'assistant', content: result.text });
-  return result.text;
-}
-
-async function main() {
-  const history = [];
-  const opts = {
-    model: 'gemini-2.0-flash',
-    system: 'You are a knowledgeable astronomy tutor. Keep answers brief.',
-    temperature: 0.4
-  };
-
-  console.log('=== Multi-turn conversation ===\n');
-
-  let reply = await chat(history, 'What is a black hole?', opts);
-  console.log('User: What is a black hole?');
-  console.log('Assistant:', reply, '\n');
-
-  reply = await chat(history, 'How does one form?', opts);
-  console.log('User: How does one form?');
-  console.log('Assistant:', reply, '\n');
-
-  reply = await chat(history, 'Can anything escape from it?', opts);
-  console.log('User: Can anything escape from it?');
-  console.log('Assistant:', reply, '\n');
-
-  reply = await chat(history, 'Summarize our conversation so far in bullet points.', opts);
-  console.log('User: Summarize our conversation so far in bullet points.');
-  console.log('Assistant:', reply, '\n');
-
-  console.log(`Total turns: ${history.length / 2}`);
-}
-
-main().catch(console.error);

package/examples/sdk-validate.js

@@ -1,31 +0,0 @@
-const Anthropic = require('@anthropic-ai/sdk').default;
-
-const client = new Anthropic({
-  apiKey: 'placeholder',
-  baseURL: process.env.THEBIRD_URL || 'http://localhost:3456',
-});
-
-async function main() {
-  process.stdout.write('[streaming] ');
-  const stream = client.messages.stream({
-    model: 'gemini-2.5-flash',
-    max_tokens: 256,
-    messages: [{ role: 'user', content: 'Say exactly: thebird works' }],
-  });
-  for await (const ev of stream) {
-    if (ev.type === 'content_block_delta' && ev.delta.type === 'text_delta') {
-      process.stdout.write(ev.delta.text);
-    }
-  }
-  process.stdout.write('\n');
-
-  process.stdout.write('[non-streaming] ');
-  const msg = await client.messages.create({
-    model: 'gemini-2.5-flash',
-    max_tokens: 256,
-    messages: [{ role: 'user', content: 'Say exactly: thebird works' }],
-  });
-  console.log(msg.content[0].text);
-}
-
-main().catch(e => { process.stderr.write(e.message + '\n'); process.exit(1); });

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