gencode-ai 0.4.0 → 0.5.0

package/src/core/providers/registry.ts

@@ -0,0 +1,203 @@
+/**
+ * Provider Registry - Provider class registry with metadata
+ */
+
+import type { Provider, AuthMethod, ProviderClassMeta, LLMProvider } from './types.js';
+import type { SearchProviderName } from './search/types.js';
+import { AnthropicProvider } from './anthropic.js';
+import { AnthropicVertexProvider } from './anthropic-vertex.js';
+import { OpenAIProvider } from './openai.js';
+import { GoogleProvider } from './google.js';
+
+// ============================================================================
+// LLM Provider Classes
+// ============================================================================
+
+export type ProviderClass = {
+  new (config?: any): LLMProvider;
+  meta: ProviderClassMeta;
+};
+
+/**
+ * All registered provider classes
+ * Each class has static metadata describing which provider and auth method it implements
+ */
+export const PROVIDER_CLASSES: ProviderClass[] = [
+  AnthropicProvider,
+  AnthropicVertexProvider,
+  OpenAIProvider,
+  GoogleProvider,
+];
+
+/**
+ * Provider metadata (for UI display)
+ */
+export interface ProviderMeta {
+  id: Provider;
+  name: string;
+  popularity: number; // Lower = more popular
+}
+
+export const PROVIDER_METADATA: ProviderMeta[] = [
+  { id: 'anthropic', name: 'Anthropic', popularity: 1 },
+  { id: 'openai', name: 'OpenAI', popularity: 2 },
+  { id: 'google', name: 'Google', popularity: 3 },
+];
+
+// ============================================================================
+// Helper Functions
+// ============================================================================
+
+/**
+ * Get a specific provider class by provider and auth method
+ */
+export function getProviderClass(
+  provider: Provider,
+  authMethod: AuthMethod
+): ProviderClass | undefined {
+  return PROVIDER_CLASSES.find(
+    (cls) => cls.meta.provider === provider && cls.meta.authMethod === authMethod
+  );
+}
+
+/**
+ * Get all provider classes for a given provider
+ */
+export function getProviderClasses(provider: Provider): ProviderClass[] {
+  return PROVIDER_CLASSES.filter((cls) => cls.meta.provider === provider);
+}
+
+/**
+ * Check if a provider class is ready (has required env vars)
+ */
+export function isProviderReady(providerClass: ProviderClass): boolean {
+  // Special case for Vertex AI: requires explicit opt-in
+  if (providerClass.meta.authMethod === 'vertex') {
+    const useVertex = process.env.CLAUDE_CODE_USE_VERTEX === '1' || process.env.CLAUDE_CODE_USE_VERTEX === 'true';
+    const hasProject = !!(
+      process.env.ANTHROPIC_VERTEX_PROJECT_ID ||
+      process.env.GCLOUD_PROJECT ||
+      process.env.GOOGLE_CLOUD_PROJECT
+    );
+    return useVertex && hasProject;
+  }
+
+  // For other providers: check if any required env var is set
+  return providerClass.meta.envVars.some((v) => !!process.env[v]);
+}
+
+/**
+ * Get provider metadata by ID
+ */
+export function getProviderMeta(id: Provider): ProviderMeta | undefined {
+  return PROVIDER_METADATA.find((p) => p.id === id);
+}
+
+/**
+ * Get all providers sorted by popularity
+ */
+export function getProvidersSorted(): ProviderMeta[] {
+  return [...PROVIDER_METADATA].sort((a, b) => a.popularity - b.popularity);
+}
+
+/**
+ * Get the first available (ready) provider class for a provider
+ */
+export function getAvailableProviderClass(provider: Provider): ProviderClass | undefined {
+  const classes = getProviderClasses(provider);
+  return classes.find((cls) => isProviderReady(cls));
+}
+
+/**
+ * Get all available (ready) provider classes for a provider
+ */
+export function getAvailableProviderClasses(provider: Provider): ProviderClass[] {
+  return getProviderClasses(provider).filter((cls) => isProviderReady(cls));
+}
+
+// ============================================================================
+// Legacy Support (for backward compatibility with search providers)
+// ============================================================================
+
+export interface ConnectionOption {
+  name: string;
+  envVars: string[];
+  description?: string;
+}
+
+export interface SearchProviderDefinition {
+  id: SearchProviderName;
+  name: string;
+  popularity: number;
+  connections: ConnectionOption[];
+  requiresKey: boolean;
+}
+
+/**
+ * All supported search providers
+ */
+export const SEARCH_PROVIDERS: SearchProviderDefinition[] = [
+  {
+    id: 'exa',
+    name: 'Exa AI',
+    popularity: 1,
+    connections: [
+      {
+        name: 'Public API',
+        envVars: [],
+        description: 'No API key required',
+      },
+    ],
+    requiresKey: false,
+  },
+  {
+    id: 'serper',
+    name: 'Serper.dev',
+    popularity: 2,
+    connections: [
+      {
+        name: 'API Key',
+        envVars: ['SERPER_API_KEY'],
+        description: 'Google Search via Serper',
+      },
+    ],
+    requiresKey: true,
+  },
+  {
+    id: 'brave',
+    name: 'Brave Search',
+    popularity: 3,
+    connections: [
+      {
+        name: 'API Key',
+        envVars: ['BRAVE_API_KEY'],
+        description: 'Privacy-focused search',
+      },
+    ],
+    requiresKey: true,
+  },
+];
+
+/**
+ * Get search provider definition by ID
+ */
+export function getSearchProvider(id: SearchProviderName): SearchProviderDefinition | undefined {
+  return SEARCH_PROVIDERS.find((p) => p.id === id);
+}
+
+/**
+ * Get all search providers sorted by popularity
+ */
+export function getSearchProvidersSorted(): SearchProviderDefinition[] {
+  return [...SEARCH_PROVIDERS].sort((a, b) => a.popularity - b.popularity);
+}
+
+// Helper: check if any env var in the list is set
+const hasAnyEnvVar = (envVars: string[]) => envVars.some((v) => !!process.env[v]);
+
+/**
+ * Check if a specific connection option has its env vars set
+ */
+export function isConnectionReady(conn: ConnectionOption): boolean {
+  return hasAnyEnvVar(conn.envVars);
+}

package/src/core/providers/search/exa.ts

@@ -0,0 +1,220 @@
+/**
+ * Exa AI Search Provider
+ *
+ * Uses Exa's public MCP endpoint (no API key required).
+ * Based on OpenCode's implementation pattern.
+ */
+
+import type { SearchProvider, SearchResult, SearchOptions } from './types.js';
+
+const API_CONFIG = {
+  BASE_URL: 'https://mcp.exa.ai',
+  ENDPOINT: '/mcp',
+  DEFAULT_NUM_RESULTS: 8,
+  DEFAULT_TIMEOUT: 25000,
+} as const;
+
+interface McpSearchRequest {
+  jsonrpc: string;
+  id: number;
+  method: string;
+  params: {
+    name: string;
+    arguments: {
+      query: string;
+      numResults?: number;
+      livecrawl?: 'fallback' | 'preferred';
+      type?: 'auto' | 'fast' | 'deep';
+      contextMaxCharacters?: number;
+    };
+  };
+}
+
+interface McpSearchResponse {
+  jsonrpc: string;
+  result: {
+    content: Array<{
+      type: string;
+      text: string;
+    }>;
+  };
+}
+
+/**
+ * Parse Exa's response text into structured search results
+ *
+ * Exa returns results in this format:
+ * Title: ...
+ * URL: ...
+ * Text: ...
+ */
+function parseExaResults(text: string): SearchResult[] {
+  const results: SearchResult[] = [];
+  const lines = text.split('\n');
+
+  let currentResult: Partial<SearchResult> = {};
+  let collectingText = false;
+  let textBuffer: string[] = [];
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+
+    // Check for "Title: ..." line
+    if (trimmed.startsWith('Title:')) {
+      // Save previous result if exists
+      if (currentResult.title && currentResult.url) {
+        results.push({
+          title: currentResult.title,
+          url: currentResult.url,
+          snippet: textBuffer.join(' ').trim().substring(0, 300),
+        });
+      }
+      currentResult = { title: trimmed.substring(6).trim() };
+      collectingText = false;
+      textBuffer = [];
+      continue;
+    }
+
+    // Check for "URL: ..." line
+    if (trimmed.startsWith('URL:')) {
+      currentResult.url = trimmed.substring(4).trim();
+      continue;
+    }
+
+    // Check for "Text: ..." line - start of snippet
+    if (trimmed.startsWith('Text:')) {
+      collectingText = true;
+      const initialText = trimmed.substring(5).trim();
+      if (initialText) {
+        textBuffer.push(initialText);
+      }
+      continue;
+    }
+
+    // Collect text lines until next Title
+    if (collectingText && trimmed && !trimmed.startsWith('Title:')) {
+      textBuffer.push(trimmed);
+    }
+  }
+
+  // Add the last result
+  if (currentResult.title && currentResult.url) {
+    results.push({
+      title: currentResult.title,
+      url: currentResult.url,
+      snippet: textBuffer.join(' ').trim().substring(0, 300),
+    });
+  }
+
+  return results;
+}
+
+/**
+ * Filter results by allowed/blocked domains
+ */
+function filterByDomain(results: SearchResult[], options?: SearchOptions): SearchResult[] {
+  if (!options?.allowedDomains?.length && !options?.blockedDomains?.length) {
+    return results;
+  }
+
+  return results.filter((result) => {
+    try {
+      const domain = new URL(result.url).hostname;
+
+      if (options.allowedDomains?.length) {
+        return options.allowedDomains.some(
+          (allowed) => domain === allowed || domain.endsWith('.' + allowed)
+        );
+      }
+
+      if (options.blockedDomains?.length) {
+        return !options.blockedDomains.some(
+          (blocked) => domain === blocked || domain.endsWith('.' + blocked)
+        );
+      }
+
+      return true;
+    } catch {
+      return true;
+    }
+  });
+}
+
+export class ExaProvider implements SearchProvider {
+  readonly name = 'exa' as const;
+
+  async search(query: string, options?: SearchOptions): Promise<SearchResult[]> {
+    const searchRequest: McpSearchRequest = {
+      jsonrpc: '2.0',
+      id: 1,
+      method: 'tools/call',
+      params: {
+        name: 'web_search_exa',
+        arguments: {
+          query,
+          type: 'auto',
+          numResults: options?.numResults ?? API_CONFIG.DEFAULT_NUM_RESULTS,
+          livecrawl: 'fallback',
+          contextMaxCharacters: 10000,
+        },
+      },
+    };
+
+    const controller = new AbortController();
+    const timeoutId = setTimeout(
+      () => controller.abort(),
+      options?.timeout ?? API_CONFIG.DEFAULT_TIMEOUT
+    );
+
+    try {
+      const signals = options?.abortSignal
+        ? [controller.signal, options.abortSignal]
+        : [controller.signal];
+
+      const response = await fetch(`${API_CONFIG.BASE_URL}${API_CONFIG.ENDPOINT}`, {
+        method: 'POST',
+        headers: {
+          Accept: 'application/json, text/event-stream',
+          'Content-Type': 'application/json',
+          // Explicitly omit authentication (Exa's public endpoint)
+          'X-Api-Key': '',
+          Authorization: '',
+        },
+        body: JSON.stringify(searchRequest),
+        signal: AbortSignal.any(signals),
+      });
+
+      clearTimeout(timeoutId);
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Exa search error (${response.status}): ${errorText}`);
+      }
+
+      const responseText = await response.text();
+
+      // Parse SSE response
+      const lines = responseText.split('\n');
+      for (const line of lines) {
+        if (line.startsWith('data: ')) {
+          const data: McpSearchResponse = JSON.parse(line.substring(6));
+          if (data.result?.content?.length > 0) {
+            const text = data.result.content[0].text;
+            const results = parseExaResults(text);
+            return filterByDomain(results, options);
+          }
+        }
+      }
+
+      return [];
+    } catch (error) {
+      clearTimeout(timeoutId);
+
+      if (error instanceof Error && error.name === 'AbortError') {
+        throw new Error('Search request timed out');
+      }
+
+      throw error;
+    }
+  }
+}

package/src/core/session/index.ts

@@ -0,0 +1,10 @@
+/**
+ * Session Management
+ */
+
+export * from './types.js';
+export { SessionManager } from './manager.js';
+export * from './compression/index.js';
+export * from './checkpointing/index.js';
+export * from './tasks/index.js';
+export * from './input/index.js';