lazlo-ai 1.0.0

package/src/providers/ollama.ts

@@ -0,0 +1,151 @@
+/**
+ * Ollama Provider - Local LLM inference
+ */
+
+import axios, { AxiosInstance } from 'axios';
+import { 
+  BaseChatModel, 
+  Message, 
+  ChatResponse, 
+  ToolDefinition,
+  StreamChunk 
+} from '../core/types.js';
+import { logger } from '../utils/logger.js';
+
+// ============================================================================
+// Ollama Provider
+// ============================================================================
+
+export interface OllamaOptions {
+  model?: string;
+  baseURL?: string;
+  timeout?: number;
+}
+
+export class Ollama implements BaseChatModel {
+  readonly supportsTools = true;
+  readonly supportsStructuredOutput = true;
+  
+  private model: string;
+  private baseURL: string;
+  private client: AxiosInstance;
+  
+  constructor(options: OllamaOptions = {}) {
+    this.model = options.model ?? 'llama3.2';
+    this.baseURL = (options.baseURL ?? 'http://localhost:11434').replace(/\/$/, '');
+    
+    this.client = axios.create({
+      baseURL: this.baseURL,
+      headers: { 'Content-Type': 'application/json' },
+      timeout: options.timeout ?? 300000,
+    });
+    
+    logger.info(`Ollama Provider ready. Model: ${this.model}. Endpoint: ${this.baseURL}`);
+  }
+  
+  private formatMessages(messages: Message[]): { role: string; content: string }[] {
+    return messages.map(m => ({
+      role: m.role,
+      content: m.content,
+    }));
+  }
+  
+  async invoke(
+    messages: Message[],
+    options: {
+      model?: string;
+      tools?: ToolDefinition[];
+      temperature?: number;
+    } = {}
+  ): Promise<ChatResponse> {
+    const model = options.model ?? this.model;
+    
+    const payload: Record<string, unknown> = {
+      model,
+      messages: this.formatMessages(messages),
+      stream: false,
+    };
+    
+    if (options.tools) {
+      payload.tools = options.tools;
+    }
+    
+    try {
+      const response = await this.client.post('/api/chat', payload);
+      const data = response.data;
+      const message = data.message;
+      
+      return {
+        content: message?.content ?? '',
+        tool_calls: message?.tool_calls,
+        model: model,
+        finish_reason: data.done ? 'stop' : null,
+      };
+    } catch (error: any) {
+      if (error.code === 'ECONNREFUSED') {
+        throw new Error(`Cannot connect to Ollama at ${this.baseURL}. Is Ollama running?`);
+      }
+      logger.error(`Ollama invoke error: ${error.message}`);
+      throw error;
+    }
+  }
+  
+  async *stream(
+    messages: Message[],
+    options: {
+      model?: string;
+    } = {}
+  ): AsyncGenerator<StreamChunk> {
+    const model = options.model ?? this.model;
+    
+    const payload = {
+      model,
+      messages: this.formatMessages(messages),
+      stream: true,
+    };
+    
+    const response = await this.client.post('/api/chat', payload, {
+      responseType: 'stream',
+    });
+    
+    for await (const chunk of response.data) {
+      const lines = chunk.toString().split('\n').filter((l: string) => l.trim());
+      
+      for (const line of lines) {
+        try {
+          const data = JSON.parse(line);
+          const content = data.message?.content ?? '';
+          
+          if (content) {
+            yield { delta: content };
+          }
+          
+          if (data.done) {
+            return;
+          }
+        } catch {
+          // Skip invalid JSON
+        }
+      }
+    }
+  }
+  
+  async listModels(): Promise<string[]> {
+    try {
+      const response = await this.client.get('/api/tags');
+      return response.data.models?.map((m: any) => m.name) ?? [];
+    } catch (error) {
+      logger.error(`Could not list Ollama models: ${error}`);
+      return [];
+    }
+  }
+  
+  close(): void {
+    logger.info('Ollama client closed.');
+  }
+}
+
+// Factory
+export function createOllama(options?: OllamaOptions): Ollama {
+  return new Ollama(options);
+}

package/src/providers/openai.ts

@@ -0,0 +1,320 @@
+/**
+ * OpenAI Provider
+ * 
+ * Direct API access to OpenAI models. No massive SDKs, just axios calls.
+ */
+
+import axios, { AxiosInstance, AxiosError } from 'axios';
+import { 
+  BaseChatModel, 
+  Message, 
+  ChatResponse, 
+  ToolDefinition,
+  ResponseFormat,
+  StreamChunk 
+} from '../core/types.js';
+import { logger } from '../utils/logger.js';
+import { calculateCost } from '../utils/pricing.js';
+
+// ============================================================================
+// Circuit Breaker
+// ============================================================================
+
+class CircuitBreaker {
+  private failures = 0;
+  private lastFailure = 0;
+  private state: 'closed' | 'open' | 'half-open' = 'closed';
+  
+  constructor(
+    private failMax = 5,
+    private resetTimeout = 60000
+  ) {}
+  
+  async execute<T>(fn: () => Promise<T>): Promise<T> {
+    if (this.state === 'open') {
+      if (Date.now() - this.lastFailure > this.resetTimeout) {
+        this.state = 'half-open';
+      } else {
+        throw new Error('Circuit breaker open');
+      }
+    }
+    
+    try {
+      const result = await fn();
+      if (this.state === 'half-open') {
+        this.state = 'closed';
+        this.failures = 0;
+      }
+      return result;
+    } catch (error) {
+      this.failures++;
+      this.lastFailure = Date.now();
+      if (this.failures >= this.failMax) {
+        this.state = 'open';
+      }
+      throw error;
+    }
+  }
+}
+
+const openAICircuitBreaker = new CircuitBreaker();
+
+// ============================================================================
+// Helper Functions
+// ============================================================================
+
+function isRetryableError(error: AxiosError): boolean {
+  if (axios.isAxiosError(error)) {
+    const status = error.response?.status;
+    return status === undefined || status === 429 || status >= 500;
+  }
+  return true;
+}
+
+function parseResponseFormat(format?: ResponseFormat): Record<string, unknown> | undefined {
+  if (!format) return undefined;
+  
+  if (format.type === 'json_schema' && format.json_schema) {
+    return {
+      type: 'json_schema',
+      json_schema: {
+        name: format.json_schema.name,
+        schema: format.json_schema.schema,
+        strict: format.json_schema.strict ?? true,
+      },
+    };
+  }
+  
+  return { type: format.type };
+}
+
+// Simple rate limiting
+let lastRequestTime = 0;
+const MIN_REQUEST_INTERVAL = 100; // ms between requests
+
+async function rateLimit(): Promise<void> {
+  const now = Date.now();
+  const elapsed = now - lastRequestTime;
+  if (elapsed < MIN_REQUEST_INTERVAL) {
+    await new Promise(resolve => setTimeout(resolve, MIN_REQUEST_INTERVAL - elapsed));
+  }
+  lastRequestTime = Date.now();
+}
+
+// ============================================================================
+// OpenAI Provider
+// ============================================================================
+
+export class OpenAI implements BaseChatModel {
+  readonly supportsTools = true;
+  readonly supportsStructuredOutput = true;
+  
+  private client: AxiosInstance;
+  private defaultModel: string;
+  
+  constructor(
+    apiKey?: string,
+    defaultModel = 'gpt-4o',
+    options: {
+      baseURL?: string;
+      timeout?: number;
+    } = {}
+  ) {
+    const key = apiKey ?? (typeof process !== 'undefined' ? (process as any).env?.OPENAI_API_KEY : undefined);
+    if (!key) {
+      throw new Error('OPENAI_API_KEY is required');
+    }
+    
+    this.defaultModel = defaultModel;
+    this.client = axios.create({
+      baseURL: options.baseURL ?? 'https://api.openai.com/v1',
+      headers: {
+        'Content-Type': 'application/json',
+        Authorization: `Bearer ${key}`,
+      },
+      timeout: options.timeout ?? 120000,
+    });
+    
+    logger.info(`OpenAI Provider ready. Default Model: ${this.defaultModel}`);
+  }
+  
+  private preparePayload(
+    model: string,
+    messages: Message[],
+    options: {
+      tools?: ToolDefinition[];
+      responseFormat?: ResponseFormat;
+      temperature?: number;
+      maxTokens?: number;
+      topP?: number;
+      stop?: string[];
+      stream?: boolean;
+    } = {}
+  ): Record<string, unknown> {
+    const payload: Record<string, unknown> = {
+      model,
+      messages,
+    };
+    
+    if (options.tools) {
+      payload.tools = options.tools;
+    }
+    
+    if (options.responseFormat) {
+      payload.response_format = parseResponseFormat(options.responseFormat);
+    }
+    
+    if (options.temperature !== undefined) payload.temperature = options.temperature;
+    if (options.maxTokens !== undefined) payload.max_tokens = options.maxTokens;
+    if (options.topP !== undefined) payload.top_p = options.topP;
+    if (options.stop !== undefined) payload.stop = options.stop;
+    if (options.stream !== undefined) payload.stream = options.stream;
+    
+    return payload;
+  }
+  
+  async invoke(
+    messages: Message[],
+    options: {
+      model?: string;
+      tools?: ToolDefinition[];
+      responseFormat?: ResponseFormat;
+      temperature?: number;
+      maxTokens?: number;
+      topP?: number;
+      frequencyPenalty?: number;
+      presencePenalty?: number;
+      stop?: string | string[];
+    } = {}
+  ): Promise<ChatResponse> {
+    const model = options.model ?? this.defaultModel;
+    
+    // Handle string input
+    const formattedMessages: Message[] = typeof messages === 'string' 
+      ? [{ role: 'user', content: messages }] 
+      : messages;
+    
+    // Convert stop to array if needed
+    const stop = options.stop 
+      ? (Array.isArray(options.stop) ? options.stop : [options.stop]) 
+      : undefined;
+    
+    const payload = this.preparePayload(model, formattedMessages, {
+      ...options,
+      stop,
+    });
+    
+    return openAICircuitBreaker.execute(async () => {
+      await rateLimit();
+      
+      try {
+        const response = await this.client.post('/chat/completions', payload);
+        const data = response.data;
+        
+        if (!data.choices?.length) {
+          throw new Error('Empty response from OpenAI');
+        }
+        
+        const choice = data.choices[0];
+        const usage = data.usage ?? {};
+        
+        const result: ChatResponse = {
+          content: choice.message?.content ?? '',
+          tool_calls: choice.message?.tool_calls,
+          usage: {
+            prompt_tokens: usage.prompt_tokens ?? 0,
+            completion_tokens: usage.completion_tokens ?? 0,
+            total_tokens: usage.total_tokens ?? 0,
+          },
+          model: model,
+          finish_reason: choice.finish_reason,
+        };
+        
+        logger.debug(`OpenAI: ${usage.total_tokens ?? 0} tokens, $${calculateCost(model, usage.prompt_tokens ?? 0, usage.completion_tokens ?? 0).toFixed(6)}`);
+        
+        return result;
+      } catch (error) {
+        if (axios.isAxiosError(error)) {
+          logger.error(`OpenAI API error: ${error.message}`);
+        }
+        throw error;
+      }
+    });
+  }
+  
+  async *stream(
+    messages: Message[],
+    options: {
+      model?: string;
+      temperature?: number;
+      maxTokens?: number;
+      topP?: number;
+      stop?: string[];
+    } = {}
+  ): AsyncGenerator<StreamChunk> {
+    const model = options.model ?? this.defaultModel;
+    
+    const formattedMessages: Message[] = typeof messages === 'string'
+      ? [{ role: 'user', content: messages }]
+      : messages;
+    
+    const payload = this.preparePayload(model, formattedMessages, { ...options, stream: true });
+    
+    const response = await this.client.post('/chat/completions', payload, {
+      responseType: 'stream',
+    });
+    
+    for await (const chunk of response.data) {
+      const lines = chunk.toString().split('\n').filter((line: string) => line.trim() !== '');
+      
+      for (const line of lines) {
+        if (line.startsWith('data: ')) {
+          const data = line.slice(6);
+          
+          if (data === '[DONE]') {
+            return;
+          }
+          
+          try {
+            const parsed = JSON.parse(data);
+            const delta = parsed.choices?.[0]?.delta?.content;
+            
+            if (delta) {
+              yield {
+                delta,
+                finish_reason: parsed.choices[0]?.finish_reason,
+                index: parsed.choices[0]?.index,
+              };
+            }
+          } catch {
+            // Skip malformed JSON
+          }
+        }
+      }
+    }
+  }
+  
+  close(): void {
+    logger.info('OpenAI client closed.');
+  }
+  
+  // Alias for compatibility - async version calls the same implementation
+  async ainvoke(messages: Message[], options?: {
+    model?: string;
+    tools?: ToolDefinition[];
+    responseFormat?: ResponseFormat;
+    temperature?: number;
+    maxTokens?: number;
+    topP?: number;
+  }): Promise<ChatResponse> {
+    return this.invoke(messages, options);
+  }
+}
+
+// ============================================================================
+// Factory Function
+// ============================================================================
+
+export function createOpenAI(apiKey?: string, defaultModel?: string): OpenAI {
+  return new OpenAI(apiKey, defaultModel);
+}

package/src/retrievers/index.ts

@@ -0,0 +1,182 @@
+/**
+ * Retrievers
+ * 
+ * Base interfaces for document retrieval
+ */
+
+import { InMemoryVectorStore } from '../vectorstores/index.js';
+import { logger } from '../utils/logger.js';
+
+export interface BaseRetriever {
+  getRelevantDocuments(query: string): Promise<Document[]>;
+}
+
+export interface Document {
+  pageContent: string;
+  metadata: Record<string, unknown>;
+}
+
+export interface VectorStore {
+  similaritySearch(query: string, k?: number): Promise<Document[]>;
+  similaritySearchWithScore(query: string, k?: number): Promise<[Document, number][]>;
+  addDocuments(documents: Document[]): Promise<void>;
+}
+
+/**
+ * Contextual Compression Retriever
+ * 
+ * Compresses retrieved documents based on query context
+ */
+export class ContextualCompressionRetriever implements BaseRetriever {
+  private baseRetriever: BaseRetriever;
+  private compressor?: (doc: Document, query: string) => Promise<Document>;
+
+  constructor(options: {
+    baseRetriever: BaseRetriever;
+    compressor?: (doc: Document, query: string) => Promise<Document>;
+  }) {
+    this.baseRetriever = options.baseRetriever;
+    this.compressor = options.compressor;
+  }
+
+  async getRelevantDocuments(query: string): Promise<Document[]> {
+    const docs = await this.baseRetriever.getRelevantDocuments(query);
+    
+    if (!this.compressor) {
+      return docs;
+    }
+
+    // Compress each document
+    const compressed: Document[] = [];
+    for (const doc of docs) {
+      const compressedDoc = await this.compressor(doc, query);
+      compressed.push(compressedDoc);
+    }
+
+    return compressed;
+  }
+}
+
+/**
+ * Parent Document Retriever
+ * 
+ * Retrieves full parent documents from embedded chunks
+ */
+export class ParentDocumentRetriever implements BaseRetriever {
+  private childRetriever: BaseRetriever;
+  private idKey: string;
+  private parentDocuments: Map<string, Document> = new Map();
+
+  constructor(options: {
+    childRetriever: BaseRetriever;
+    idKey?: string;
+  }) {
+    this.childRetriever = options.childRetriever;
+    this.idKey = options.idKey || 'parent_id';
+  }
+
+  /**
+   * Add parent documents
+   */
+  addParentDocuments(documents: Document[]): void {
+    for (const doc of documents) {
+      const id = doc.metadata[this.idKey] as string || crypto.randomUUID();
+      this.parentDocuments.set(id, doc);
+    }
+  }
+
+  async getRelevantDocuments(query: string): Promise<Document[]> {
+    const childDocs = await this.childRetriever.getRelevantDocuments(query);
+    
+    // Get unique parent IDs
+    const parentIds = new Set<string>();
+    for (const doc of childDocs) {
+      const parentId = doc.metadata[this.idKey] as string;
+      if (parentId) {
+        parentIds.add(parentId);
+      }
+    }
+
+    // Return parent documents
+    const parents: Document[] = [];
+    for (const id of parentIds) {
+      const parent = this.parentDocuments.get(id);
+      if (parent) {
+        parents.push(parent);
+      }
+    }
+
+    return parents.length > 0 ? parents : childDocs;
+  }
+}
+
+/**
+ * Ensemble Retriever
+ * 
+ * Combines multiple retrievers with weighted scoring
+ */
+export class EnsembleRetriever implements BaseRetriever {
+  private retrievers: { retriever: BaseRetriever; weight: number }[];
+
+  constructor(retrievers: { retriever: BaseRetriever; weight: number }[]) {
+    this.retrievers = retrievers;
+  }
+
+  async getRelevantDocuments(query: string): Promise<Document[]> {
+    const allDocs: Map<string, { doc: Document; score: number }> = new Map();
+    
+    // Fetch from all retrievers
+    for (const { retriever, weight } of this.retrievers) {
+      try {
+        const docs = await retriever.getRelevantDocuments(query);
+        
+        for (let i = 0; i < docs.length; i++) {
+          const doc = docs[i];
+          const key = `${doc.pageContent.slice(0, 50)}`;
+          
+          const score = weight * (docs.length - i) / docs.length;
+          
+          if (allDocs.has(key)) {
+            allDocs.get(key)!.score += score;
+          } else {
+            allDocs.set(key, { doc, score });
+          }
+        }
+      } catch (error) {
+        logger.warn(`[EnsembleRetriever] Error from retriever: ${error}`);
+      }
+    }
+
+    // Sort by score and return
+    const sorted = Array.from(allDocs.values())
+      .sort((a, b) => b.score - a.score)
+      .map(({ doc }) => doc);
+
+    return sorted;
+  }
+}
+
+/**
+ * Create a vector store retriever
+ */
+export function createVectorStoreRetriever(
+  vectorStore: VectorStore,
+  options: {
+    k?: number;
+    filter?: (doc: Document) => boolean;
+  } = {}
+): BaseRetriever {
+  const k = options.k || 4;
+
+  return {
+    async getRelevantDocuments(query: string): Promise<Document[]> {
+      let docs = await vectorStore.similaritySearch(query, k);
+      
+      if (options.filter) {
+        docs = docs.filter(options.filter);
+      }
+      
+      return docs;
+    }
+  };
+}