@aria_asi/cli 0.2.26 → 0.2.29

package/runtime-src/provider-proxy.mjs

@@ -0,0 +1,594 @@
+#!/usr/bin/env node
+
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+const CONFIG_PATH = join(homedir(), '.aria', 'config.json');
+const DEFAULT_OLLAMA_BASE_URL = process.env.OLLAMA_BASE_URL || 'http://127.0.0.1:11434';
+const DEFAULT_DEEPSEEK_BASE_URL = process.env.DEEPSEEK_API_BASE || 'https://api.deepseek.com/v1/chat/completions';
+const DEFAULT_OLLAMA_MODEL =
+  process.env.ARIA_RUNTIME_MODEL ||
+  process.env.ARIA_LOCAL_MODEL ||
+  process.env.OLLAMA_MODEL ||
+  'llama3';
+const DEFAULT_CHAT_MODEL =
+  process.env.ARIA_CHAT_MODEL ||
+  process.env.ARIA_CASUAL_MODEL ||
+  'deepseek-v4-flash';
+const DEFAULT_DEEP_MODEL =
+  process.env.ARIA_DEEP_MODEL ||
+  'deepseek-v4-pro';
+const DEFAULT_XAI_BASE_URL = process.env.XAI_API_BASE || 'https://api.x.ai/v1/chat/completions';
+const DEFAULT_XAI_FALLBACK_MODEL =
+  process.env.ARIA_XAI_FALLBACK_MODEL ||
+  'grok-4-2-reasoning';
+const DEFAULT_NIM_BASE_URL = process.env.NIM_BASE_URL || 'https://integrate.api.nvidia.com/v1/chat/completions';
+const DEFAULT_NIM_FALLBACK_MODEL =
+  process.env.ARIA_NIM_FALLBACK_MODEL ||
+  'qwen/qwen3.5-122b-a10b';
+
+function safeJsonParse(raw, fallback = null) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return fallback;
+  }
+}
+
+function loadLocalConfig() {
+  if (!existsSync(CONFIG_PATH)) return null;
+  return safeJsonParse(readFileSync(CONFIG_PATH, 'utf8'), null);
+}
+
+function coerceString(value) {
+  return typeof value === 'string' && value.trim() ? value.trim() : '';
+}
+
+function loadRuntimeProfiles(local) {
+  const profiles = local?.runtimeProfiles && typeof local.runtimeProfiles === 'object' ? local.runtimeProfiles : {};
+  return {
+    chatModel: coerceString(profiles.chatModel || local?.chatModel || local?.model?.chatModel) || DEFAULT_CHAT_MODEL,
+    deepModel: coerceString(profiles.deepModel || local?.deepModel || local?.model?.deepModel) || DEFAULT_DEEP_MODEL,
+    xaiFallbackModel: coerceString(profiles.xaiFallbackModel || local?.xaiFallbackModel || local?.model?.xaiFallbackModel) || DEFAULT_XAI_FALLBACK_MODEL,
+    nimFallbackModel: coerceString(profiles.nimFallbackModel || local?.nimFallbackModel || local?.model?.nimFallbackModel) || DEFAULT_NIM_FALLBACK_MODEL,
+    xaiApiKey: coerceString(profiles.xaiApiKey || local?.xaiApiKey),
+    nimApiKey: coerceString(profiles.nimApiKey || local?.nimApiKey),
+    xaiBaseUrl: coerceString(profiles.xaiBaseUrl || local?.xaiBaseUrl) || DEFAULT_XAI_BASE_URL,
+    nimBaseUrl: coerceString(profiles.nimBaseUrl || local?.nimBaseUrl) || DEFAULT_NIM_BASE_URL,
+  };
+}
+
+function extractIntentText(body = {}) {
+  const pieces = [];
+  if (typeof body.ariaPlannedApproach === 'string') pieces.push(body.ariaPlannedApproach);
+  if (typeof body.ariaRationale === 'string') pieces.push(body.ariaRationale);
+  if (typeof body.prompt === 'string') pieces.push(body.prompt);
+  if (typeof body.input === 'string') pieces.push(body.input);
+  if (typeof body.modelIntent === 'string') pieces.push(body.modelIntent);
+  if (typeof body?.metadata?.roleProfile === 'string') pieces.push(body.metadata.roleProfile);
+  if (typeof body?.metadata?.intent === 'string') pieces.push(body.metadata.intent);
+  if (typeof body?.metadata?.mode === 'string') pieces.push(body.metadata.mode);
+  if (Array.isArray(body.messages)) {
+    for (const message of body.messages) {
+      if (typeof message?.content === 'string') pieces.push(message.content);
+      if (Array.isArray(message?.content)) {
+        for (const part of message.content) {
+          if (typeof part === 'string') pieces.push(part);
+          if (typeof part?.text === 'string') pieces.push(part.text);
+        }
+      }
+    }
+  }
+  return pieces.filter(Boolean).join('\n');
+}
+
+function isDeepArchitectureIntent(body = {}) {
+  const intent = extractIntentText(body).toLowerCase();
+  if (!intent) return false;
+  return /\b(architect|architecture|system design|design doc|deepwork|deep work|reasoning|first principles|migration plan|refactor plan|root cause|tradeoff|trade-off|analy[sz]e deeply|complex code|hardener|planner)\b/i.test(intent);
+}
+
+function resolveProviderApiKey(provider, overrideApiKey = '', localApiKey = '') {
+  if (overrideApiKey) return overrideApiKey;
+  if (localApiKey) return localApiKey;
+  switch (provider) {
+    case 'deepseek':
+      return process.env.DEEPSEEK_API_KEY || '';
+    case 'openai':
+      return process.env.OPENAI_API_KEY || '';
+    case 'anthropic':
+      return process.env.ANTHROPIC_API_KEY || '';
+    case 'google':
+      return process.env.GOOGLE_API_KEY || process.env.GEMINI_API_KEY || '';
+    case 'openrouter':
+      return process.env.OPENROUTER_API_KEY || '';
+    case 'xai':
+      return process.env.XAI_API_KEY || '';
+    case 'nim':
+    case 'nvidia-nim':
+      return process.env.NVIDIA_NIM_API_KEY || process.env.NIM_API_KEY || '';
+    default:
+      return '';
+  }
+}
+
+function resolveDefaultModel(provider, body, localModel, runtimeProfiles) {
+  const explicitModel = coerceString(body?.llm?.model || body?.providerConfig?.model || body?.model);
+  if (explicitModel) return explicitModel;
+  if (provider === 'deepseek') {
+    return isDeepArchitectureIntent(body) ? runtimeProfiles.deepModel : runtimeProfiles.chatModel;
+  }
+  if (provider === 'xai') return runtimeProfiles.xaiFallbackModel;
+  if (provider === 'nim' || provider === 'nvidia-nim') return runtimeProfiles.nimFallbackModel;
+  if (coerceString(localModel?.model)) return coerceString(localModel.model);
+  if (provider === 'ollama') return DEFAULT_OLLAMA_MODEL;
+  return '';
+}
+
+function buildFallbackChain(body, runtimeProfiles) {
+  if (body.allowProviderFallback === false) return [];
+  const explicitFallbacks = Array.isArray(body?.llm?.fallbacks)
+    ? body.llm.fallbacks
+    : Array.isArray(body?.providerConfig?.fallbacks)
+      ? body.providerConfig.fallbacks
+      : [];
+  if (explicitFallbacks.length > 0) return explicitFallbacks;
+  return [
+    {
+      provider: 'xai',
+      model: runtimeProfiles.xaiFallbackModel,
+      baseUrl: runtimeProfiles.xaiBaseUrl,
+      apiKey: runtimeProfiles.xaiApiKey || process.env.XAI_API_KEY || '',
+      reason: 'xai reasoning fallback',
+    },
+    {
+      provider: 'nim',
+      model: runtimeProfiles.nimFallbackModel,
+      baseUrl: runtimeProfiles.nimBaseUrl,
+      apiKey: runtimeProfiles.nimApiKey || process.env.NVIDIA_NIM_API_KEY || process.env.NIM_API_KEY || '',
+      reason: 'nim qwen fallback',
+    },
+  ].filter((entry) => entry.apiKey && entry.model);
+}
+
+async function callResolvedProvider(config, body, ariaSystemPrompt) {
+  const model = body.model || config.model || 'gpt-4o';
+  const messages = composeOpenAIMessages(Array.isArray(body.messages) ? body.messages : [], ariaSystemPrompt);
+  const maxTokens = Number(body.max_tokens || body.max_completion_tokens || 4096);
+
+  if (config.provider === 'anthropic') {
+    const anthropicPayload = {
+      model,
+      max_tokens: maxTokens,
+      messages: messages.filter((message) => message.role !== 'system').map((message) => ({
+        role: message.role,
+        content: [{ type: 'text', text: message.content }],
+      })),
+      system: messages.filter((message) => message.role === 'system').map((message) => ({
+        type: 'text',
+        text: message.content,
+      })),
+    };
+    const data = await callAnthropic(config.baseUrl || 'https://api.anthropic.com/v1/messages', config.apiKey, anthropicPayload);
+    const text = Array.isArray(data.content)
+      ? data.content.filter((part) => part?.type === 'text').map((part) => part.text).join('')
+      : '';
+    return {
+      provider: config.provider,
+      model,
+      text,
+      usage: asUsage(data?.usage?.input_tokens, data?.usage?.output_tokens),
+      finishReason: data?.stop_reason || 'stop',
+      raw: data,
+    };
+  }
+
+  if (config.provider === 'google') {
+    const googlePayload = {
+      contents: messages
+        .filter((message) => message.role !== 'system')
+        .map((message) => ({
+          role: message.role === 'assistant' ? 'model' : 'user',
+          parts: [{ text: message.content }],
+        })),
+      system_instruction: {
+        parts: [{ text: messages.filter((message) => message.role === 'system').map((message) => message.content).join('\n\n') }],
+      },
+      generationConfig: {
+        maxOutputTokens: maxTokens,
+      },
+    };
+    const data = await callGoogle(model || 'gemini-2.5-pro', config.apiKey, googlePayload);
+    const text = data?.candidates?.[0]?.content?.parts?.map((part) => part.text).join('') || '';
+    return {
+      provider: config.provider,
+      model,
+      text,
+      usage: asUsage(data?.usageMetadata?.promptTokenCount, data?.usageMetadata?.candidatesTokenCount),
+      finishReason: data?.candidates?.[0]?.finishReason || 'stop',
+      raw: data,
+    };
+  }
+
+  if (config.provider === 'ollama') {
+    const data = await callOllama(config.baseUrl || process.env.OLLAMA_HOST || 'http://localhost:11434', {
+      model,
+      messages,
+      stream: false,
+      options: { num_predict: maxTokens },
+    });
+    return {
+      provider: config.provider,
+      model,
+      text: data?.message?.content || '',
+      usage: asUsage(data?.prompt_eval_count, data?.eval_count),
+      finishReason: data?.done ? 'stop' : 'unknown',
+      raw: data,
+    };
+  }
+
+  const urlByProvider = {
+    openai: config.baseUrl || 'https://api.openai.com/v1/chat/completions',
+    deepseek: config.baseUrl || 'https://api.deepseek.com/v1/chat/completions',
+    openrouter: config.baseUrl || 'https://openrouter.ai/api/v1/chat/completions',
+    xai: config.baseUrl || DEFAULT_XAI_BASE_URL,
+    nim: config.baseUrl || DEFAULT_NIM_BASE_URL,
+    'nvidia-nim': config.baseUrl || DEFAULT_NIM_BASE_URL,
+  };
+  const providerUrl = urlByProvider[config.provider] || urlByProvider.openai;
+  const extraHeaders = config.provider === 'openrouter'
+    ? {
+        'HTTP-Referer': 'http://127.0.0.1',
+        'X-Title': 'Aria Mounted Runtime',
+      }
+    : {};
+  const data = await callOpenAICompatible(providerUrl, config.apiKey, {
+    model,
+    messages,
+    max_tokens: maxTokens,
+    stream: false,
+    temperature: body.temperature,
+    top_p: body.top_p,
+    tools: Array.isArray(body.tools) ? body.tools : undefined,
+    tool_choice: body.tool_choice,
+  }, extraHeaders);
+
+  return {
+    provider: config.provider,
+    model,
+    text: data?.choices?.[0]?.message?.content || '',
+    usage: asUsage(data?.usage?.prompt_tokens, data?.usage?.completion_tokens),
+    finishReason: data?.choices?.[0]?.finish_reason || 'stop',
+    raw: data,
+  };
+}
+
+export function resolveProviderConfig(body = {}) {
+  const local = loadLocalConfig();
+  const localModel = local?.model && typeof local.model === 'object' ? local.model : null;
+  const override = body.llm && typeof body.llm === 'object' ? body.llm : body.providerConfig && typeof body.providerConfig === 'object' ? body.providerConfig : null;
+  const runtimeProfiles = loadRuntimeProfiles(local);
+  const provider =
+    override?.provider ||
+    body.provider ||
+    localModel?.provider ||
+    coerceString(local?.defaultProvider) ||
+    (process.env.DEEPSEEK_API_KEY ? 'deepseek' : 'ollama');
+  const merged = {
+    provider,
+    model: resolveDefaultModel(provider, body, localModel, runtimeProfiles),
+    apiKey: resolveProviderApiKey(
+      provider,
+      coerceString(override?.apiKey || body.providerApiKey),
+      coerceString(localModel?.apiKey),
+    ),
+    baseUrl:
+      override?.baseUrl ||
+      body.providerBaseUrl ||
+      localModel?.baseUrl ||
+      (provider === 'ollama'
+        ? DEFAULT_OLLAMA_BASE_URL
+        : provider === 'deepseek'
+          ? DEFAULT_DEEPSEEK_BASE_URL
+          : provider === 'xai'
+            ? DEFAULT_XAI_BASE_URL
+            : provider === 'nim' || provider === 'nvidia-nim'
+              ? DEFAULT_NIM_BASE_URL
+          : ''),
+  };
+
+  if (!merged.provider) {
+    throw new Error('No provider configured. Save one in ~/.aria/config.json or pass llm/providerConfig in the request body.');
+  }
+
+  if (merged.provider !== 'ollama' && merged.provider !== 'google' && !merged.apiKey) {
+    throw new Error(`No API key configured for provider ${merged.provider}. Save one in ~/.aria/config.json or pass llm.apiKey.`);
+  }
+
+  return merged;
+}
+
+export function extractOpenAIUserMessage(messages = []) {
+  const reversed = [...messages].reverse();
+  for (const message of reversed) {
+    if (message?.role === 'user') return flattenOpenAIContent(message.content);
+  }
+  return '';
+}
+
+export function extractAnthropicUserMessage(messages = []) {
+  const reversed = [...messages].reverse();
+  for (const message of reversed) {
+    if (message?.role === 'user') return flattenAnthropicContent(message.content);
+  }
+  return '';
+}
+
+function flattenOpenAIContent(content) {
+  if (typeof content === 'string') return content;
+  if (!Array.isArray(content)) return '';
+  return content
+    .map((part) => {
+      if (typeof part === 'string') return part;
+      if (part?.type === 'text' && typeof part.text === 'string') return part.text;
+      if (typeof part?.content === 'string') return part.content;
+      return '';
+    })
+    .filter(Boolean)
+    .join('\n');
+}
+
+function flattenAnthropicContent(content) {
+  if (typeof content === 'string') return content;
+  if (!Array.isArray(content)) return '';
+  return content
+    .map((part) => {
+      if (typeof part === 'string') return part;
+      if (part?.type === 'text' && typeof part.text === 'string') return part.text;
+      return '';
+    })
+    .filter(Boolean)
+    .join('\n');
+}
+
+function extractOpenAISystem(messages = []) {
+  return messages
+    .filter((message) => message?.role === 'system')
+    .map((message) => flattenOpenAIContent(message.content))
+    .filter(Boolean)
+    .join('\n\n');
+}
+
+function extractAnthropicSystem(systemField) {
+  if (typeof systemField === 'string') return systemField;
+  if (!Array.isArray(systemField)) return '';
+  return systemField
+    .map((part) => {
+      if (typeof part === 'string') return part;
+      if (part?.type === 'text' && typeof part.text === 'string') return part.text;
+      return '';
+    })
+    .filter(Boolean)
+    .join('\n\n');
+}
+
+export function composeOpenAIMessages(messages = [], ariaSystemPrompt) {
+  const incomingSystem = extractOpenAISystem(messages);
+  const mergedSystem = [ariaSystemPrompt, incomingSystem].filter(Boolean).join('\n\n');
+  const nonSystem = messages
+    .filter((message) => message?.role !== 'system')
+    .map((message) => ({
+      role: message.role,
+      content: flattenOpenAIContent(message.content),
+    }));
+  return [{ role: 'system', content: mergedSystem }, ...nonSystem];
+}
+
+export function composeAnthropicRequest(body = {}, ariaSystemPrompt) {
+  const incomingSystem = extractAnthropicSystem(body.system);
+  const mergedSystem = [ariaSystemPrompt, incomingSystem].filter(Boolean).join('\n\n');
+  const messages = Array.isArray(body.messages) ? body.messages.map((message) => ({
+    role: message.role,
+    content: Array.isArray(message.content)
+      ? message.content
+      : [{ type: 'text', text: flattenAnthropicContent(message.content) }],
+  })) : [];
+  return {
+    system: mergedSystem,
+    messages,
+  };
+}
+
+function asUsage(promptTokens, completionTokens) {
+  if (promptTokens == null && completionTokens == null) return null;
+  return {
+    promptTokens: Number(promptTokens || 0),
+    completionTokens: Number(completionTokens || 0),
+  };
+}
+
+async function callOpenAICompatible(url, apiKey, payload, extraHeaders = {}) {
+  let response;
+  try {
+    response = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        Authorization: `Bearer ${apiKey}`,
+        ...extraHeaders,
+      },
+      body: JSON.stringify(payload),
+    });
+  } catch (error) {
+    throw new Error(`Provider fetch failed for ${url}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+
+  if (!response.ok) {
+    const body = await response.text().catch(() => response.statusText);
+    throw new Error(`Provider error ${response.status}: ${body}`);
+  }
+
+  return response.json();
+}
+
+async function callAnthropic(url, apiKey, payload) {
+  let response;
+  try {
+    response = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'x-api-key': apiKey,
+        'anthropic-version': '2023-06-01',
+      },
+      body: JSON.stringify(payload),
+    });
+  } catch (error) {
+    throw new Error(`Anthropic fetch failed for ${url}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+
+  if (!response.ok) {
+    const body = await response.text().catch(() => response.statusText);
+    throw new Error(`Anthropic error ${response.status}: ${body}`);
+  }
+
+  return response.json();
+}
+
+async function callGoogle(model, apiKey, payload) {
+  const url = `https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent?key=${apiKey}`;
+  let response;
+  try {
+    response = await fetch(url, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(payload),
+    });
+  } catch (error) {
+    throw new Error(`Google fetch failed for ${url}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+
+  if (!response.ok) {
+    const body = await response.text().catch(() => response.statusText);
+    throw new Error(`Google error ${response.status}: ${body}`);
+  }
+
+  return response.json();
+}
+
+async function callOllama(baseUrl, payload) {
+  const url = `${baseUrl.replace(/\/$/, '')}/api/chat`;
+  let response;
+  try {
+    response = await fetch(url, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(payload),
+    });
+  } catch (error) {
+    throw new Error(`Ollama fetch failed for ${url}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+
+  if (!response.ok) {
+    const body = await response.text().catch(() => response.statusText);
+    throw new Error(`Ollama error ${response.status}: ${body}`);
+  }
+
+  return response.json();
+}
+
+export async function callProviderForOpenAI(body, ariaSystemPrompt) {
+  const config = resolveProviderConfig(body);
+  const runtimeProfiles = loadRuntimeProfiles(loadLocalConfig());
+  try {
+    return await callResolvedProvider(config, body, ariaSystemPrompt);
+  } catch (primaryError) {
+    const fallbacks = buildFallbackChain(body, runtimeProfiles)
+      .filter((fallback) => fallback.provider !== config.provider || fallback.model !== config.model);
+    for (const fallback of fallbacks) {
+      try {
+        return await callResolvedProvider({
+          provider: fallback.provider,
+          model: fallback.model,
+          apiKey: fallback.apiKey,
+          baseUrl: fallback.baseUrl,
+        }, {
+          ...body,
+          allowProviderFallback: false,
+          llm: {
+            ...(body.llm && typeof body.llm === 'object' ? body.llm : {}),
+            provider: fallback.provider,
+            model: fallback.model,
+            apiKey: fallback.apiKey,
+            baseUrl: fallback.baseUrl,
+          },
+          metadata: {
+            ...(body.metadata && typeof body.metadata === 'object' ? body.metadata : {}),
+            provider_fallback_from: `${config.provider}:${config.model}`,
+            provider_fallback_to: `${fallback.provider}:${fallback.model}`,
+            provider_fallback_reason: fallback.reason || 'fallback',
+          },
+        }, ariaSystemPrompt);
+      } catch {}
+    }
+    throw primaryError;
+  }
+}
+
+export async function callProviderForAnthropic(body, ariaSystemPrompt) {
+  const config = resolveProviderConfig(body);
+  const model = body.model || config.model || 'claude-sonnet-4-20250514';
+  const req = composeAnthropicRequest(body, ariaSystemPrompt);
+  const maxTokens = Number(body.max_tokens || 4096);
+
+  if (config.provider === 'anthropic') {
+    const data = await callAnthropic(config.baseUrl || 'https://api.anthropic.com/v1/messages', config.apiKey, {
+      model,
+      max_tokens: maxTokens,
+      messages: req.messages,
+      system: [{ type: 'text', text: req.system }],
+    });
+    const text = Array.isArray(data.content)
+      ? data.content.filter((part) => part?.type === 'text').map((part) => part.text).join('')
+      : '';
+    return {
+      provider: config.provider,
+      model,
+      text,
+      usage: asUsage(data?.usage?.input_tokens, data?.usage?.output_tokens),
+      finishReason: data?.stop_reason || 'stop',
+      raw: data,
+    };
+  }
+
+  const openAiMessages = [
+    { role: 'system', content: req.system },
+    ...req.messages.map((message) => ({
+      role: message.role,
+      content: flattenAnthropicContent(message.content),
+    })),
+  ];
+  return callProviderForOpenAI({
+    ...body,
+    provider: config.provider,
+    model,
+    messages: openAiMessages,
+    llm: config,
+  }, req.system);
+}
+
+export function chunkText(text, maxChunkChars = 120) {
+  const content = String(text || '');
+  if (!content) return [''];
+  const chunks = [];
+  let remaining = content;
+  while (remaining.length > maxChunkChars) {
+    let cut = remaining.lastIndexOf(' ', maxChunkChars);
+    if (cut < Math.floor(maxChunkChars / 2)) cut = maxChunkChars;
+    chunks.push(remaining.slice(0, cut));
+    remaining = remaining.slice(cut).trimStart();
+  }
+  if (remaining) chunks.push(remaining);
+  return chunks;
+}