@benzsiangco/jarvis 1.0.2 → 1.1.0

package/src/providers/index.ts

@@ -0,0 +1,523 @@
+// Provider abstraction layer for Jarvis
+// Supports: Anthropic, OpenAI, Google, Groq, Mistral, Cohere, and more
+import { createAnthropic } from '@ai-sdk/anthropic';
+import { createOpenAI } from '@ai-sdk/openai';
+import { createGoogleGenerativeAI } from '@ai-sdk/google';
+import type { LanguageModel } from 'ai';
+import type { JarvisConfig } from '../core/types';
+import { parseModelId } from '../config';
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { 
+  getNextAccount, 
+  trackAccountUsage, 
+  markAccountRateLimited,
+  clearExpiredRateLimits,
+  hasAntigravityAccounts,
+  getAccountWithValidToken,
+  refreshAccountToken,
+  type AntigravityAccount 
+} from './antigravity';
+
+// Antigravity API endpoints
+const ANTIGRAVITY_ENDPOINTS = [
+  'https://daily-cloudcode-pa.sandbox.googleapis.com',
+  'https://autopush-cloudcode-pa.sandbox.googleapis.com',
+  'https://cloudcode-pa.googleapis.com',
+];
+
+// Load saved API keys from config
+const API_KEYS_FILE = join(homedir(), '.config', 'jarvis', 'api-keys.json');
+
+function loadSavedApiKeys(): Record<string, string> {
+  if (!existsSync(API_KEYS_FILE)) {
+    return {};
+  }
+  try {
+    return JSON.parse(readFileSync(API_KEYS_FILE, 'utf-8'));
+  } catch {
+    return {};
+  }
+}
+
+// Get API key from saved keys or environment
+function getApiKey(envVar: string, savedKeyId?: string): string | undefined {
+  // Environment variable takes precedence
+  const envKey = process.env[envVar];
+  if (envKey) return envKey;
+  
+  // Fall back to saved keys
+  if (savedKeyId) {
+    const savedKeys = loadSavedApiKeys();
+    return savedKeys[savedKeyId];
+  }
+  
+  return undefined;
+}
+
+export type ProviderType = 
+  | 'anthropic' 
+  | 'openai' 
+  | 'google' 
+  | 'groq' 
+  | 'mistral' 
+  | 'cohere'
+  | 'together'
+  | 'perplexity'
+  | 'fireworks'
+  | 'deepseek'
+  | 'xai'
+  | 'local';
+
+interface ProviderInstance {
+  id: ProviderType;
+  name: string;
+  createModel: (modelId: string, options?: Record<string, unknown>) => LanguageModel;
+  isAvailable: boolean;
+}
+
+// Provider registry
+const providers = new Map<ProviderType, ProviderInstance>();
+
+// Track current Antigravity account for rotation
+let currentAntigravityAccount: AntigravityAccount | undefined;
+
+// Initialize providers based on available API keys
+export async function initializeProviders(config: JarvisConfig): Promise<void> {
+  providers.clear();
+  clearExpiredRateLimits();
+
+  // Anthropic
+  const anthropicKey = getApiKey('ANTHROPIC_API_KEY', 'anthropic');
+  if (anthropicKey) {
+    const anthropic = createAnthropic({ apiKey: anthropicKey });
+    providers.set('anthropic', {
+      id: 'anthropic',
+      name: 'Anthropic',
+      createModel: (modelId, options) => anthropic(modelId, options),
+      isAvailable: true,
+    });
+  }
+
+  // OpenAI
+  const openaiKey = getApiKey('OPENAI_API_KEY', 'openai');
+  if (openaiKey) {
+    const openai = createOpenAI({ apiKey: openaiKey });
+    providers.set('openai', {
+      id: 'openai',
+      name: 'OpenAI',
+      createModel: (modelId, options) => openai(modelId, options),
+      isAvailable: true,
+    });
+  }
+
+  // Google AI (standard API key) - only if no Antigravity accounts
+  const googleKey = getApiKey('GOOGLE_API_KEY', 'google') || process.env['GOOGLE_GENERATIVE_AI_API_KEY'];
+  
+  // For now, prefer API key auth as Antigravity OAuth requires complex request transformation
+  if (googleKey) {
+    const google = createGoogleGenerativeAI({ apiKey: googleKey });
+    providers.set('google', {
+      id: 'google',
+      name: 'Google AI',
+      createModel: (modelId, options) => {
+        const mappedModel = mapAntigravityModel(modelId);
+        // Extract variant and apply thinking config if present
+        const variant = options?.variant as string | undefined;
+        let finalOptions = { ...options };
+        
+        if (variant) {
+          const { providerId, modelId: baseModelId } = parseModelId(modelId);
+          const modelCfg = config.provider?.[providerId]?.models?.[baseModelId];
+          const variantCfg = modelCfg?.variants?.[variant];
+          if (variantCfg) {
+            finalOptions = { ...finalOptions, ...variantCfg };
+          }
+        }
+        
+        return google(mappedModel, finalOptions);
+      },
+      isAvailable: true,
+    });
+  } else if (hasAntigravityAccounts()) {
+    // Antigravity OAuth - requires request transformation
+    // For now, show as available but warn user they need API key for full functionality
+    await initializeAntigravityProvider();
+  }
+
+  // Groq
+  const groqKey = getApiKey('GROQ_API_KEY', 'groq');
+  if (groqKey) {
+    const groq = createOpenAI({ 
+      apiKey: groqKey, 
+      baseURL: 'https://api.groq.com/openai/v1' 
+    });
+    providers.set('groq', {
+      id: 'groq',
+      name: 'Groq',
+      createModel: (modelId, options) => groq(modelId, options),
+      isAvailable: true,
+    });
+  }
+
+  // Mistral
+  const mistralKey = getApiKey('MISTRAL_API_KEY', 'mistral');
+  if (mistralKey) {
+    const mistral = createOpenAI({ 
+      apiKey: mistralKey, 
+      baseURL: 'https://api.mistral.ai/v1' 
+    });
+    providers.set('mistral', {
+      id: 'mistral',
+      name: 'Mistral',
+      createModel: (modelId, options) => mistral(modelId, options),
+      isAvailable: true,
+    });
+  }
+
+  // Together AI
+  const togetherKey = getApiKey('TOGETHER_API_KEY', 'together');
+  if (togetherKey) {
+    const together = createOpenAI({ 
+      apiKey: togetherKey, 
+      baseURL: 'https://api.together.xyz/v1' 
+    });
+    providers.set('together', {
+      id: 'together',
+      name: 'Together AI',
+      createModel: (modelId, options) => together(modelId, options),
+      isAvailable: true,
+    });
+  }
+
+  // Perplexity
+  const perplexityKey = getApiKey('PERPLEXITY_API_KEY', 'perplexity');
+  if (perplexityKey) {
+    const perplexity = createOpenAI({ 
+      apiKey: perplexityKey, 
+      baseURL: 'https://api.perplexity.ai' 
+    });
+    providers.set('perplexity', {
+      id: 'perplexity',
+      name: 'Perplexity',
+      createModel: (modelId, options) => perplexity(modelId, options),
+      isAvailable: true,
+    });
+  }
+
+  // Fireworks
+  const fireworksKey = getApiKey('FIREWORKS_API_KEY', 'fireworks');
+  if (fireworksKey) {
+    const fireworks = createOpenAI({ 
+      apiKey: fireworksKey, 
+      baseURL: 'https://api.fireworks.ai/inference/v1' 
+    });
+    providers.set('fireworks', {
+      id: 'fireworks',
+      name: 'Fireworks',
+      createModel: (modelId, options) => fireworks(modelId, options),
+      isAvailable: true,
+    });
+  }
+
+  // DeepSeek
+  const deepseekKey = getApiKey('DEEPSEEK_API_KEY', 'deepseek');
+  if (deepseekKey) {
+    const deepseek = createOpenAI({ 
+      apiKey: deepseekKey, 
+      baseURL: 'https://api.deepseek.com/v1' 
+    });
+    providers.set('deepseek', {
+      id: 'deepseek',
+      name: 'DeepSeek',
+      createModel: (modelId, options) => deepseek(modelId, options),
+      isAvailable: true,
+    });
+  }
+
+  // xAI (Grok)
+  const xaiKey = getApiKey('XAI_API_KEY', 'xai');
+  if (xaiKey) {
+    const xai = createOpenAI({ 
+      apiKey: xaiKey, 
+      baseURL: 'https://api.x.ai/v1' 
+    });
+    providers.set('xai', {
+      id: 'xai',
+      name: 'xAI',
+      createModel: (modelId, options) => xai(modelId, options),
+      isAvailable: true,
+    });
+  }
+
+  // Local LLM (OpenAI Compatible - Ollama, LM Studio, etc.)
+  // Does not require API key strictly, but checks for base URL
+  const localUrl = getApiKey('LOCAL_API_URL', 'local') || process.env['LOCAL_API_URL'] || 'http://localhost:11434/v1';
+  // We register it even if no custom key, using default localhost
+  const local = createOpenAI({
+    apiKey: 'not-needed',
+    baseURL: localUrl,
+  });
+  providers.set('local', {
+    id: 'local',
+    name: 'Local LLM',
+    createModel: (modelId, options) => local(modelId, options),
+    isAvailable: true,
+  });
+}
+
+// Initialize Antigravity provider with OAuth tokens using the plugin's loader
+async function initializeAntigravityProvider(): Promise<void> {
+  try {
+    // Use the plugin's loader to get the custom fetch function
+    const { initializeAntigravityLoader } = await import('./antigravity-loader.js');
+    const antigravityFetch = await initializeAntigravityLoader();
+
+    // Register Antigravity-enabled provider using Google Generative AI SDK
+    const google = createGoogleGenerativeAI({
+      baseURL: 'https://generativelanguage.googleapis.com/v1beta',
+      apiKey: '', // Empty - OAuth handled by custom fetch
+      fetch: antigravityFetch as typeof fetch,
+    });
+
+    // This provider handles google/* models
+    providers.set('google', {
+      id: 'google',
+      name: 'Google (Antigravity)',
+      createModel: (modelId, options) => {
+        // Use model name as-is - plugin handles the transformation
+        return google(modelId, options);
+      },
+      isAvailable: true,
+    });
+  } catch (error) {
+    console.error('Failed to initialize Antigravity provider:', error);
+  }
+}
+
+// Map Antigravity model names to actual model identifiers
+// For Antigravity Cloud Code endpoint, use model names as-is
+function mapAntigravityModel(modelId: string): string {
+  // Don't transform - Antigravity handles these model names directly
+  return modelId;
+}
+
+// Refresh Antigravity account (call before requests)
+export function refreshAntigravityAccount(): AntigravityAccount | undefined {
+  clearExpiredRateLimits();
+  const account = getNextAccount();
+  if (account) {
+    currentAntigravityAccount = account;
+  }
+  return account;
+}
+
+// Get current Antigravity account
+export function getCurrentAntigravityAccount(): AntigravityAccount | undefined {
+  return currentAntigravityAccount;
+}
+
+export function getProvider(providerId: ProviderType): ProviderInstance | undefined {
+  return providers.get(providerId);
+}
+
+export function getModel(modelId: string, options?: Record<string, unknown>): LanguageModel | undefined {
+  const { providerId, modelId: model } = parseModelId(modelId);
+  const provider = providers.get(providerId as ProviderType);
+  
+  if (!provider) {
+    return undefined;
+  }
+  
+  return provider.createModel(model, options);
+}
+
+export function listProviders(): ProviderType[] {
+  return Array.from(providers.keys());
+}
+
+export function hasProvider(providerId: string): boolean {
+  return providers.has(providerId as ProviderType);
+}
+
+// Get all available providers with status
+export function getProvidersWithStatus(): Array<{
+  id: ProviderType;
+  name: string;
+  isAvailable: boolean;
+  envVar: string;
+  maskedKey?: string;
+}> {
+  // Helper to mask key
+  const mask = (key?: string) => {
+    if (!key) return undefined;
+    if (key.length < 8) return '********';
+    return `${key.substring(0, 3)}...${key.substring(key.length - 4)}`;
+  };
+
+  const allProviders: Array<{
+    id: ProviderType;
+    name: string;
+    isAvailable: boolean;
+    envVar: string;
+    maskedKey?: string;
+  }> = [
+    { 
+      id: 'anthropic', 
+      name: 'Anthropic (Claude)', 
+      isAvailable: providers.has('anthropic'), 
+      envVar: 'ANTHROPIC_API_KEY',
+      maskedKey: mask(getApiKey('ANTHROPIC_API_KEY', 'anthropic'))
+    },
+    { 
+      id: 'openai', 
+      name: 'OpenAI (GPT)', 
+      isAvailable: providers.has('openai'), 
+      envVar: 'OPENAI_API_KEY',
+      maskedKey: mask(getApiKey('OPENAI_API_KEY', 'openai'))
+    },
+    { 
+      id: 'google', 
+      name: 'Google (Gemini)', 
+      isAvailable: providers.has('google'), 
+      envVar: 'GOOGLE_API_KEY or OAuth',
+      maskedKey: mask(getApiKey('GOOGLE_API_KEY', 'google'))
+    },
+    { 
+      id: 'groq', 
+      name: 'Groq', 
+      isAvailable: providers.has('groq'), 
+      envVar: 'GROQ_API_KEY',
+      maskedKey: mask(getApiKey('GROQ_API_KEY', 'groq'))
+    },
+    { 
+      id: 'mistral', 
+      name: 'Mistral', 
+      isAvailable: providers.has('mistral'), 
+      envVar: 'MISTRAL_API_KEY',
+      maskedKey: mask(getApiKey('MISTRAL_API_KEY', 'mistral'))
+    },
+    { 
+      id: 'together', 
+      name: 'Together AI', 
+      isAvailable: providers.has('together'), 
+      envVar: 'TOGETHER_API_KEY',
+      maskedKey: mask(getApiKey('TOGETHER_API_KEY', 'together'))
+    },
+    { 
+      id: 'perplexity', 
+      name: 'Perplexity', 
+      isAvailable: providers.has('perplexity'), 
+      envVar: 'PERPLEXITY_API_KEY',
+      maskedKey: mask(getApiKey('PERPLEXITY_API_KEY', 'perplexity'))
+    },
+    { 
+      id: 'fireworks', 
+      name: 'Fireworks', 
+      isAvailable: providers.has('fireworks'), 
+      envVar: 'FIREWORKS_API_KEY',
+      maskedKey: mask(getApiKey('FIREWORKS_API_KEY', 'fireworks'))
+    },
+    { 
+      id: 'deepseek', 
+      name: 'DeepSeek', 
+      isAvailable: providers.has('deepseek'), 
+      envVar: 'DEEPSEEK_API_KEY',
+      maskedKey: mask(getApiKey('DEEPSEEK_API_KEY', 'deepseek'))
+    },
+    { 
+      id: 'xai', 
+      name: 'xAI (Grok)', 
+      isAvailable: providers.has('xai'), 
+      envVar: 'XAI_API_KEY',
+      maskedKey: mask(getApiKey('XAI_API_KEY', 'xai'))
+    },
+    { 
+      id: 'local', 
+      name: 'Local (LM Studio / Ollama)', 
+      isAvailable: providers.has('local'), 
+      envVar: 'LOCAL_API_URL',
+      maskedKey: getApiKey('LOCAL_API_URL', 'local') || 'http://localhost:11434/v1'
+    },
+  ];
+  
+  return allProviders;
+}
+
+// Fetch dynamic models from Local LLM provider (Ollama/LM Studio)
+export async function fetchLocalModels(): Promise<Array<{ id: string; name: string; provider: string; isAvailable: boolean }>> {
+  const localUrl = getApiKey('LOCAL_API_URL', 'local') || process.env['LOCAL_API_URL'] || 'http://localhost:11434/v1';
+  
+  try {
+    const baseUrl = localUrl.replace(/\/+$/, '');
+    // Handle both /v1/models (standard) and just /models if user omitted v1 but server needs it? 
+    // Usually user provides ".../v1".
+    const modelsUrl = `${baseUrl}/models`;
+    
+    // Add timeout to prevent hanging
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 3000); // 3 second timeout
+    
+    const response = await fetch(modelsUrl, { 
+      signal: controller.signal,
+      // Add some headers to make it more compatible
+      headers: {
+        'Accept': 'application/json',
+        'User-Agent': 'JARVIS-LocalLLM-Fetcher/1.0'
+      }
+    });
+    
+    clearTimeout(timeoutId);
+    
+    if (!response.ok) return [];
+    
+    const data = await response.json();
+    const list = Array.isArray(data) ? data : (data.data && Array.isArray(data.data) ? data.data : []);
+    
+    return list.map((m: any) => ({
+      id: `local/${m.id}`,
+      name: m.id, // Ollama/LM Studio models often use the ID as the name
+      provider: 'local',
+      isAvailable: true
+    }));
+  } catch (e) {
+    // Quiet fail if local is not running or times out
+    console.debug('[Local Models] Could not fetch:', (e as Error).message);
+    return [];
+  }
+}
+
+// Get available models from config
+export function getAvailableModels(config: JarvisConfig): Array<{ id: string; name: string; provider: string; isAvailable: boolean }> {
+  const models: Array<{ id: string; name: string; provider: string; isAvailable: boolean }> = [];
+  
+  // Always use the full provider set from config
+  const providersToUse = config.provider || {};
+
+  for (const [providerId, providerConfig] of Object.entries(providersToUse)) {
+    // Check if the provider is actually initialized in the map
+    const isAvailable = providers.has(providerId as ProviderType);
+    
+    if (providerConfig?.models) {
+      for (const [modelId, modelConfig] of Object.entries(providerConfig.models)) {
+        models.push({
+          id: `${providerId}/${modelId}`,
+          name: modelConfig.name,
+          provider: providerId,
+          isAvailable,
+        });
+      }
+    }
+  }
+  
+  // Absolute fallback if everything else fails
+  if (models.length === 0) {
+    return [
+      { id: 'google/antigravity-claude-sonnet-4-5', name: 'Claude Sonnet 4.5 (Antigravity)', provider: 'google', isAvailable: true },
+      { id: 'google/antigravity-gemini-3-pro', name: 'Gemini 3 Pro (Antigravity)', provider: 'google', isAvailable: true },
+    ];
+  }
+  
+  return models;
+}

package/src/sessions/index.ts

@@ -0,0 +1,194 @@
+// Session management for Jarvis
+import { randomUUID } from 'crypto';
+import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync, unlinkSync } from 'fs';
+import { join } from 'path';
+import { getConfigDir } from '../config';
+import type { Session, Message, MessagePart } from '../core/types';
+
+const SESSIONS_DIR = join(getConfigDir(), 'sessions');
+
+interface TodoItem {
+  id: string;
+  content: string;
+  status: 'pending' | 'in_progress' | 'completed' | 'cancelled';
+  priority: 'high' | 'medium' | 'low';
+}
+
+interface SessionState {
+  todos: TodoItem[];
+}
+
+// In-memory session store
+const sessions = new Map<string, Session>();
+const sessionStates = new Map<string, SessionState>();
+
+export function ensureSessionsDir(): void {
+  if (!existsSync(SESSIONS_DIR)) {
+    mkdirSync(SESSIONS_DIR, { recursive: true });
+  }
+}
+
+export function createSession(agentId: string, title?: string, parentId?: string, workdir?: string): Session {
+  const session: Session = {
+    id: randomUUID(),
+    title: title || `Session ${new Date().toLocaleString()}`,
+    agentId,
+    workdir: workdir || process.cwd(),
+    messages: [],
+    createdAt: new Date(),
+    updatedAt: new Date(),
+    parentId,
+  };
+
+  sessions.set(session.id, session);
+  sessionStates.set(session.id, { todos: [] });
+  saveSession(session);
+  
+  return session;
+}
+
+export function getSession(id: string): Session | undefined {
+  // Try memory first
+  let session = sessions.get(id);
+  
+  if (!session) {
+    // Try loading from disk
+    session = loadSessionFromDisk(id);
+    if (session) {
+      sessions.set(id, session);
+    }
+  }
+  
+  return session;
+}
+
+export function updateSession(session: Session): void {
+  session.updatedAt = new Date();
+  sessions.set(session.id, session);
+  saveSession(session);
+}
+
+export function deleteSession(id: string): boolean {
+  const session = sessions.get(id);
+  if (!session) return false;
+  
+  sessions.delete(id);
+  sessionStates.delete(id);
+  
+  // Delete from disk
+  const filePath = join(SESSIONS_DIR, `${id}.json`);
+  if (existsSync(filePath)) {
+    unlinkSync(filePath);
+  }
+  
+  return true;
+}
+
+export function listSessions(): Session[] {
+  ensureSessionsDir();
+  
+  // Load all sessions from disk
+  const files = readdirSync(SESSIONS_DIR).filter(f => f.endsWith('.json'));
+  
+  const allSessions: Session[] = [];
+  for (const file of files) {
+    const id = file.replace('.json', '');
+    const session = getSession(id);
+    if (session) {
+      allSessions.push(session);
+    }
+  }
+  
+  // Sort by updated date, newest first
+  return allSessions.sort((a, b) => 
+    new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime()
+  );
+}
+
+export function addMessage(sessionId: string, message: Omit<Message, 'id' | 'timestamp'>): Message {
+  const session = getSession(sessionId);
+  if (!session) {
+    throw new Error(`Session not found: ${sessionId}`);
+  }
+  
+  const fullMessage: Message = {
+    ...message,
+    id: randomUUID(),
+    timestamp: new Date(),
+  };
+  
+  session.messages.push(fullMessage);
+  updateSession(session);
+  
+  return fullMessage;
+}
+
+export function getMessages(sessionId: string): Message[] {
+  const session = getSession(sessionId);
+  return session?.messages || [];
+}
+
+// Session state management (todos, etc.)
+export function getSessionState(sessionId: string): SessionState {
+  return sessionStates.get(sessionId) || { todos: [] };
+}
+
+export function setTodos(sessionId: string, todos: TodoItem[]): void {
+  const state = getSessionState(sessionId);
+  state.todos = todos;
+  sessionStates.set(sessionId, state);
+}
+
+export function getTodos(sessionId: string): TodoItem[] {
+  return getSessionState(sessionId).todos;
+}
+
+// Persistence
+function saveSession(session: Session): void {
+  ensureSessionsDir();
+  const filePath = join(SESSIONS_DIR, `${session.id}.json`);
+  writeFileSync(filePath, JSON.stringify(session, null, 2));
+}
+
+function loadSessionFromDisk(id: string): Session | undefined {
+  ensureSessionsDir();
+  const filePath = join(SESSIONS_DIR, `${id}.json`);
+  
+  if (!existsSync(filePath)) {
+    return undefined;
+  }
+  
+  try {
+    const data = readFileSync(filePath, 'utf-8');
+    const session = JSON.parse(data) as Session;
+    
+    // Convert date strings to Date objects
+    session.createdAt = new Date(session.createdAt);
+    session.updatedAt = new Date(session.updatedAt);
+    session.messages.forEach(m => {
+      m.timestamp = new Date(m.timestamp);
+    });
+    
+    return session;
+  } catch (error) {
+    console.error(`Error loading session ${id}:`, error);
+    return undefined;
+  }
+}
+
+// Get child sessions
+export function getChildSessions(parentId: string): Session[] {
+  return listSessions().filter(s => s.parentId === parentId);
+}
+
+// Clear all sessions (for testing/reset)
+export function clearAllSessions(): void {
+  sessions.clear();
+  sessionStates.clear();
+  
+  ensureSessionsDir();
+  const files = readdirSync(SESSIONS_DIR).filter(f => f.endsWith('.json'));
+  for (const file of files) {
+    unlinkSync(join(SESSIONS_DIR, file));
+  }
+}