thebird 1.2.100 → 1.2.101

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

package/lib/convert.js

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

package/lib/errors.js

@@ -1,140 +0,0 @@
-const KEY_PATTERNS = [
-  /\b(AIza[A-Za-z0-9_-]{20,})/g,
-  /\b(sk-[A-Za-z0-9_-]{20,})/g,
-  /\b(key-[A-Za-z0-9_-]{20,})/g,
-  /((?:api[_-]?key|token|secret|authorization|bearer)[=:\s"']+)([A-Za-z0-9_-]{20,})/gi,
-];
-
-function redactKeys(str) {
-  if (typeof str !== 'string') return str;
-  let result = str;
-  result = result.replace(KEY_PATTERNS[0], m => `...${m.slice(-4)}`);
-  result = result.replace(KEY_PATTERNS[1], m => `...${m.slice(-4)}`);
-  result = result.replace(KEY_PATTERNS[2], m => `...${m.slice(-4)}`);
-  result = result.replace(KEY_PATTERNS[3], (_, prefix, val) => `${prefix}...${val.slice(-4)}`);
-  return result;
-}
-
-class BridgeError extends Error {
-  constructor(message, { status, code, retryable = false, provider, headers } = {}) {
-    super(redactKeys(message));
-    this.name = 'BridgeError';
-    this.status = status;
-    this.code = code;
-    this.retryable = retryable;
-    this.provider = provider;
-    this.headers = headers;
-  }
-}
-
-class AuthError extends BridgeError {
-  constructor(message, opts = {}) {
-    super(message, { ...opts, retryable: false });
-    this.name = 'AuthError';
-  }
-}
-
-class RateLimitError extends BridgeError {
-  constructor(message, opts = {}) {
-    super(message, { ...opts, retryable: true });
-    this.name = 'RateLimitError';
-  }
-}
-
-class TimeoutError extends BridgeError {
-  constructor(message, opts = {}) {
-    super(message, { ...opts, retryable: true });
-    this.name = 'TimeoutError';
-  }
-}
-
-class ContextWindowError extends BridgeError {
-  constructor(message, opts = {}) {
-    super(message, { ...opts, retryable: false });
-    this.name = 'ContextWindowError';
-  }
-}
-
-class ContentPolicyError extends BridgeError {
-  constructor(message, opts = {}) {
-    super(message, { ...opts, retryable: false });
-    this.name = 'ContentPolicyError';
-  }
-}
-
-class ProviderError extends BridgeError {
-  constructor(message, opts = {}) {
-    super(message, opts);
-    this.name = 'ProviderError';
-  }
-}
-
-const GeminiError = BridgeError;
-
-function classifyError(status, message, provider) {
-  const opts = { status, provider };
-  const msg = message || '';
-  if (status === 401 || status === 403) return new AuthError(msg, opts);
-  if (status === 429) return new RateLimitError(msg, opts);
-  if (status === 408 || /timeout/i.test(msg)) return new TimeoutError(msg, opts);
-  if (status === 413 || /context.?length|token.?limit|too.?long/i.test(msg)) return new ContextWindowError(msg, opts);
-  if (status === 451 || /safety|blocked|content.?policy|harmful/i.test(msg)) return new ContentPolicyError(msg, opts);
-  if (typeof status === 'number' && status >= 500) return new ProviderError(msg, { ...opts, retryable: true });
-  return new BridgeError(msg, { ...opts, retryable: false });
-}
-
-function isRetryable(err) {
-  if (err instanceof BridgeError) 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);
-}
-
-function parseRetryAfterHeader(err) {
-  const raw = err?.headers?.get?.('retry-after') ?? err?.retryAfter;
-  if (raw == null) return null;
-  const secs = Number(raw);
-  if (!isNaN(secs) && secs >= 0) return secs * 1000;
-  const date = Date.parse(raw);
-  if (!isNaN(date)) return Math.max(0, date - Date.now());
-  return null;
-}
-
-function parseRetryDelay(err) {
-  const headerDelay = parseRetryAfterHeader(err);
-  if (headerDelay != null) return headerDelay;
-  try {
-    const body = typeof err.message === 'string' ? JSON.parse(err.message) : err.message;
-    const details = body?.error?.details || [];
-    const retryInfo = details.find(d => d['@type']?.includes('RetryInfo'));
-    if (retryInfo?.retryDelay) {
-      const secs = parseFloat(retryInfo.retryDelay);
-      if (!isNaN(secs)) return secs * 1000;
-    }
-  } catch (_) {}
-  return null;
-}
-
-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 suggested = parseRetryDelay(err);
-      const delay = suggested != null ? suggested + Math.random() * 1000 : Math.min(1000 * 2 ** attempt + Math.random() * 200, 16000);
-      await new Promise(r => setTimeout(r, delay));
-    }
-  }
-  throw lastErr;
-}
-
-module.exports = {
-  BridgeError, GeminiError, AuthError, RateLimitError,
-  TimeoutError, ContextWindowError, ContentPolicyError,
-  ProviderError, classifyError, isRetryable, withRetry, redactKeys
-};

package/lib/oauth.js

@@ -1,133 +0,0 @@
-const http = require('http');
-const crypto = require('crypto');
-const fs = require('fs');
-const path = require('path');
-
-const CLIENT_ID = process.env.GOOGLE_OAUTH_CLIENT_ID || '';
-const CLIENT_SECRET = process.env.GOOGLE_OAUTH_CLIENT_SECRET || '';
-const SCOPES = 'https://www.googleapis.com/auth/cloud-platform https://www.googleapis.com/auth/userinfo.email https://www.googleapis.com/auth/userinfo.profile';
-const AUTH_URL = 'https://accounts.google.com/o/oauth2/v2/auth';
-const TOKEN_URL = 'https://oauth2.googleapis.com/token';
-const CODE_ASSIST_BASE = 'https://cloudcode-pa.googleapis.com/v1internal';
-const CODE_ASSIST_HEADERS = { 'X-Goog-Api-Client': 'gl-node/22.17.0', 'Client-Metadata': 'ideType=IDE_UNSPECIFIED,platform=PLATFORM_UNSPECIFIED,pluginType=GEMINI' };
-const TOKEN_PATH = path.join(process.env.HOME || process.env.USERPROFILE || '.', '.thebird', 'oauth-tokens.json');
-
-function base64url(buf) {
-  return buf.toString('base64').replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
-}
-
-function generatePkce() {
-  const verifier = base64url(crypto.randomBytes(32));
-  const challenge = base64url(crypto.createHash('sha256').update(verifier).digest());
-  return { verifier, challenge };
-}
-
-function readTokens() {
-  try { return JSON.parse(fs.readFileSync(TOKEN_PATH, 'utf8')); } catch { return null; }
-}
-
-function writeTokens(tokens) {
-  fs.mkdirSync(path.dirname(TOKEN_PATH), { recursive: true });
-  fs.writeFileSync(TOKEN_PATH, JSON.stringify(tokens, null, 2));
-}
-
-async function refreshAccessToken(refreshToken) {
-  const res = await fetch(TOKEN_URL, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
-    body: new URLSearchParams({ grant_type: 'refresh_token', refresh_token: refreshToken, client_id: CLIENT_ID, client_secret: CLIENT_SECRET })
-  });
-  if (!res.ok) throw new Error('Token refresh failed: ' + await res.text());
-  const data = await res.json();
-  return { accessToken: data.access_token, refreshToken: data.refresh_token || refreshToken, expiresAt: Date.now() + data.expires_in * 1000 };
-}
-
-async function getValidToken() {
-  const tokens = readTokens();
-  if (!tokens?.refreshToken) return null;
-  if (tokens.expiresAt && tokens.expiresAt > Date.now() + 60000) return tokens;
-  const refreshed = await refreshAccessToken(tokens.refreshToken);
-  const updated = { ...tokens, ...refreshed };
-  writeTokens(updated);
-  return updated;
-}
-
-async function resolveProject(accessToken) {
-  const res = await fetch(`${CODE_ASSIST_BASE}:loadCodeAssist`, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${accessToken}`, ...CODE_ASSIST_HEADERS },
-    body: JSON.stringify({ metadata: { ideType: 'IDE_UNSPECIFIED', platform: 'PLATFORM_UNSPECIFIED', pluginType: 'GEMINI' } })
-  });
-  if (!res.ok) throw new Error('Failed to load Code Assist project');
-  const data = await res.json();
-  const proj = data.cloudaicompanionProject;
-  if (proj) return typeof proj === 'string' ? proj : proj.id;
-  const tier = data.allowedTiers?.find(t => t.id === 'free-tier') || data.allowedTiers?.[0];
-  if (!tier) throw new Error('No eligible tier: ' + (data.ineligibleTiers?.[0]?.reasonMessage || 'unknown'));
-  const obRes = await fetch(`${CODE_ASSIST_BASE}:onboardUser`, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${accessToken}`, ...CODE_ASSIST_HEADERS },
-    body: JSON.stringify({ tierId: tier.id || 'legacy-tier', metadata: { ideType: 'IDE_UNSPECIFIED', platform: 'PLATFORM_UNSPECIFIED', pluginType: 'GEMINI' } })
-  });
-  if (!obRes.ok) throw new Error('Onboarding failed');
-  let op = await obRes.json();
-  for (let i = 0; i < 10 && !op.done && op.name; i++) {
-    await new Promise(r => setTimeout(r, 5000));
-    const pollRes = await fetch(`${CODE_ASSIST_BASE}/${op.name}`, { headers: { Authorization: `Bearer ${accessToken}`, ...CODE_ASSIST_HEADERS } });
-    if (pollRes.ok) op = await pollRes.json();
-  }
-  return op.response?.cloudaicompanionProject?.id;
-}
-
-function login(port) {
-  return new Promise((resolve, reject) => {
-    const { verifier, challenge } = generatePkce();
-    const state = crypto.randomBytes(32).toString('hex');
-    const callbackUrl = `http://localhost:${port}/callback`;
-    const url = new URL(AUTH_URL);
-    url.searchParams.set('client_id', CLIENT_ID);
-    url.searchParams.set('response_type', 'code');
-    url.searchParams.set('redirect_uri', callbackUrl);
-    url.searchParams.set('scope', SCOPES);
-    url.searchParams.set('code_challenge', challenge);
-    url.searchParams.set('code_challenge_method', 'S256');
-    url.searchParams.set('state', state);
-    url.searchParams.set('access_type', 'offline');
-    url.searchParams.set('prompt', 'consent');
-
-    const server = http.createServer(async (req, res) => {
-      const u = new URL(req.url, `http://localhost:${port}`);
-      if (!u.pathname.startsWith('/callback')) { res.end('waiting...'); return; }
-      if (u.searchParams.get('state') !== state) { res.end('Invalid state'); server.close(); reject(new Error('Invalid state')); return; }
-      const code = u.searchParams.get('code');
-      try {
-        const tokRes = await fetch(TOKEN_URL, {
-          method: 'POST',
-          headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
-          body: new URLSearchParams({ client_id: CLIENT_ID, client_secret: CLIENT_SECRET, code, grant_type: 'authorization_code', redirect_uri: callbackUrl, code_verifier: verifier })
-        });
-        if (!tokRes.ok) throw new Error('Token exchange failed: ' + await tokRes.text());
-        const payload = await tokRes.json();
-        if (!payload.refresh_token) throw new Error('No refresh token — ensure prompt=consent');
-        const projectId = await resolveProject(payload.access_token);
-        const tokens = { accessToken: payload.access_token, refreshToken: payload.refresh_token, expiresAt: Date.now() + payload.expires_in * 1000, projectId };
-        writeTokens(tokens);
-        res.end('Authenticated! You can close this tab.');
-        server.close();
-        resolve(tokens);
-      } catch (e) { res.end('Error: ' + e.message); server.close(); reject(e); }
-    });
-    server.listen(port, () => {
-      console.log(`Open this URL to authenticate:\n${url.toString()}\n`);
-      try { const { exec } = require('child_process'); exec(`start "" "${url.toString()}"`); } catch {}
-    });
-  });
-}
-
-async function ensureAuth(port) {
-  const existing = await getValidToken();
-  if (existing?.accessToken && existing?.projectId) return existing;
-  return login(port || 8585);
-}
-
-module.exports = { login, ensureAuth, getValidToken, readTokens, writeTokens, resolveProject, CODE_ASSIST_BASE, CODE_ASSIST_HEADERS };

package/lib/providers/acp.js

@@ -1,88 +0,0 @@
-const { BridgeError } = require('../errors');
-
-async function postJson(url, body) {
-  const res = await fetch(url, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(body) });
-  if (!res.ok) { const t = await res.text(); throw new BridgeError(t, { status: res.status, retryable: res.status === 429 || res.status >= 500 }); }
-  return res.json();
-}
-
-function subscribeSSE(url, onEvent) {
-  const ctrl = new AbortController();
-  (async () => {
-    try {
-      const res = await fetch(url, { signal: ctrl.signal });
-      if (!res.ok || !res.body) return;
-      const reader = res.body.getReader();
-      const dec = new TextDecoder();
-      let buf = '';
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done) return;
-        buf += dec.decode(value, { stream: true });
-        let i;
-        while ((i = buf.indexOf('\n\n')) >= 0) {
-          const chunk = buf.slice(0, i); buf = buf.slice(i + 2);
-          const line = chunk.split('\n').find(l => l.startsWith('data:'));
-          if (!line) continue;
-          try { onEvent(JSON.parse(line.slice(5))); } catch (_) {}
-        }
-      }
-    } catch (e) { if (e.name !== 'AbortError') throw e; }
-  })();
-  return () => ctrl.abort();
-}
-
-function toUserText(messages) {
-  return messages.filter(m => m.role === 'user').map(m =>
-    typeof m.content === 'string' ? m.content : (m.content || []).filter(b => b.type === 'text').map(b => b.text).join('')
-  ).join('\n');
-}
-
-async function* streamACP({ url, model, messages, onStepFinish }) {
-  yield { type: 'start-step' };
-  const base = (url || 'http://localhost:4780').replace(/\/$/, '');
-  const { id: sessionId } = await postJson(base + '/session', {});
-  const queue = []; let resolveNext = null; let done = false;
-  const push = ev => { queue.push(ev); if (resolveNext) { const r = resolveNext; resolveNext = null; r(); } };
-  const textSeen = new Map();
-  const toolState = new Map();
-  const unsubscribe = subscribeSSE(base + '/event', (msg) => {
-    if (msg.type !== 'message.part.updated') return;
-    const part = msg.properties?.part;
-    if (!part) return;
-    if (part.type === 'text' && part.messageID) {
-      const prior = textSeen.get(part.id) || '';
-      const txt = part.text || '';
-      if (txt.length > prior.length) { push({ type: 'text-delta', textDelta: txt.slice(prior.length) }); textSeen.set(part.id, txt); }
-    } else if (part.type === 'tool') {
-      const cid = part.callID; const st = part.state?.status;
-      if (st === 'running' && !toolState.has(cid)) { toolState.set(cid, { name: part.tool, args: part.state.input || {} }); push({ type: 'tool-call', toolCallId: cid, toolName: part.tool, args: part.state.input || {} }); }
-      else if (st === 'completed' && toolState.has(cid) && !toolState.get(cid).completed) { toolState.get(cid).completed = true; push({ type: 'tool-result', toolCallId: cid, toolName: part.tool, args: part.state.input || {}, result: part.state.output || '' }); }
-    }
-  });
-  const promptPromise = postJson(base + '/session/' + sessionId + '/message', {
-    parts: [{ type: 'text', text: toUserText(messages) }],
-    providerID: 'kilo',
-    modelID: model || 'x-ai/grok-code-fast-1:optimized:free',
-  }).finally(() => { done = true; if (resolveNext) { const r = resolveNext; resolveNext = null; r(); } });
-  while (!done || queue.length) {
-    if (queue.length) { yield queue.shift(); continue; }
-    await new Promise(r => { resolveNext = r; });
-  }
-  const result = await promptPromise;
-  unsubscribe();
-  yield { type: 'finish-step', finishReason: result.info?.finish || 'stop' };
-  if (onStepFinish) await onStepFinish();
-}
-
-async function generateACP(opts) {
-  let text = '';
-  const toolCalls = [];
-  for await (const ev of streamACP(opts)) {
-    if (ev.type === 'text-delta') text += ev.textDelta;
-    else if (ev.type === 'tool-call') toolCalls.push({ id: ev.toolCallId, name: ev.toolName, args: ev.args });
-  }
-  return { text, toolCalls };
-}
-
-module.exports = { streamACP, generateACP };