tova 0.1.1 → 0.2.2

package/src/parser/ast.js

@@ -1133,3 +1133,108 @@ export class TupleTypeAnnotation {
     this.loc = loc;
   }
 }
+
+// ============================================================
+// Column expressions (for table operations)
+// ============================================================
+
+export class ColumnExpression {
+  constructor(name, loc) {
+    this.type = 'ColumnExpression';
+    this.name = name;  // column name, e.g. "age" for .age
+    this.loc = loc;
+  }
+}
+
+export class ColumnAssignment {
+  constructor(target, expression, loc) {
+    this.type = 'ColumnAssignment';
+    this.target = target;       // column name to assign to
+    this.expression = expression; // expression computing the value
+    this.loc = loc;
+  }
+}
+
+export class NegatedColumnExpression {
+  constructor(name, loc) {
+    this.type = 'NegatedColumnExpression';
+    this.name = name;  // column name for exclusion, e.g. "password" for -.password
+    this.loc = loc;
+  }
+}
+
+// ============================================================
+// Data block nodes
+// ============================================================
+
+export class DataBlock {
+  constructor(body, loc) {
+    this.type = 'DataBlock';
+    this.body = body;  // Array of SourceDeclaration, PipelineDeclaration, ValidateBlock, RefreshPolicy
+    this.loc = loc;
+  }
+}
+
+export class SourceDeclaration {
+  constructor(name, typeAnnotation, expression, loc) {
+    this.type = 'SourceDeclaration';
+    this.name = name;
+    this.typeAnnotation = typeAnnotation;
+    this.expression = expression;
+    this.loc = loc;
+  }
+}
+
+export class PipelineDeclaration {
+  constructor(name, expression, loc) {
+    this.type = 'PipelineDeclaration';
+    this.name = name;
+    this.expression = expression;
+    this.loc = loc;
+  }
+}
+
+export class ValidateBlock {
+  constructor(typeName, rules, loc) {
+    this.type = 'ValidateBlock';
+    this.typeName = typeName;
+    this.rules = rules;  // Array of expression predicates
+    this.loc = loc;
+  }
+}
+
+export class RefreshPolicy {
+  constructor(sourceName, interval, loc) {
+    this.type = 'RefreshPolicy';
+    this.sourceName = sourceName;
+    this.interval = interval;  // { value, unit } or "on_demand"
+    this.loc = loc;
+  }
+}
+
+// ============================================================
+// AI configuration
+// ============================================================
+
+export class AiConfigDeclaration {
+  constructor(name, config, loc) {
+    this.type = 'AiConfigDeclaration';
+    this.name = name;    // optional string name (null for default)
+    this.config = config; // key-value config object
+    this.loc = loc;
+  }
+}
+
+// ============================================================
+// Refinement types
+// ============================================================
+
+export class RefinementType {
+  constructor(name, baseType, predicate, loc) {
+    this.type = 'RefinementType';
+    this.name = name;
+    this.baseType = baseType;      // TypeAnnotation
+    this.predicate = predicate;    // Expression (body of where block, uses 'it')
+    this.loc = loc;
+  }
+}

package/src/parser/parser.js

@@ -189,6 +189,10 @@ export class Parser {
     if (this.check(TokenType.CLIENT)) return this.parseClientBlock();
     if (this.check(TokenType.SHARED)) return this.parseSharedBlock();
     if (this.check(TokenType.IMPORT)) return this.parseImport();
+    // data block: data { ... }
+    if (this.check(TokenType.IDENTIFIER) && this.current().value === 'data' && this.peek(1).type === TokenType.LBRACE) {
+      return this.parseDataBlock();
+    }
     // test block: test "name" { ... } or test { ... }
     if (this.check(TokenType.IDENTIFIER) && this.current().value === 'test') {
       const next = this.peek(1);
@@ -292,6 +296,124 @@ export class Parser {
     return new AST.SharedBlock(body, l, name);
   }
 
+  // ─── Data block ────────────────────────────────────────────
+
+  parseDataBlock() {
+    const l = this.loc();
+    this.advance(); // consume 'data'
+    this.expect(TokenType.LBRACE, "Expected '{' after 'data'");
+    const body = [];
+    while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+      try {
+        const stmt = this.parseDataStatement();
+        if (stmt) body.push(stmt);
+      } catch (e) {
+        this.errors.push(e);
+        this._synchronizeBlock();
+      }
+    }
+    this.expect(TokenType.RBRACE, "Expected '}' to close data block");
+    return new AST.DataBlock(body, l);
+  }
+
+  parseDataStatement() {
+    if (!this.check(TokenType.IDENTIFIER)) {
+      return this.parseStatement();
+    }
+
+    const val = this.current().value;
+
+    // source customers: Table<Customer> = read("customers.csv")
+    if (val === 'source') {
+      return this.parseSourceDeclaration();
+    }
+
+    // pipeline clean_customers = customers |> where(...)
+    if (val === 'pipeline') {
+      return this.parsePipelineDeclaration();
+    }
+
+    // validate Customer { .email |> contains("@"), ... }
+    if (val === 'validate') {
+      return this.parseValidateBlock();
+    }
+
+    // refresh customers every 15.minutes
+    // refresh orders on_demand
+    if (val === 'refresh') {
+      return this.parseRefreshPolicy();
+    }
+
+    return this.parseStatement();
+  }
+
+  parseSourceDeclaration() {
+    const l = this.loc();
+    this.advance(); // consume 'source'
+    const name = this.expect(TokenType.IDENTIFIER, "Expected source name").value;
+
+    // Optional type annotation: source customers: Table<Customer>
+    let typeAnnotation = null;
+    if (this.match(TokenType.COLON)) {
+      typeAnnotation = this.parseTypeAnnotation();
+    }
+
+    this.expect(TokenType.ASSIGN, "Expected '=' after source name");
+    const expression = this.parseExpression();
+
+    return new AST.SourceDeclaration(name, typeAnnotation, expression, l);
+  }
+
+  parsePipelineDeclaration() {
+    const l = this.loc();
+    this.advance(); // consume 'pipeline'
+    const name = this.expect(TokenType.IDENTIFIER, "Expected pipeline name").value;
+    this.expect(TokenType.ASSIGN, "Expected '=' after pipeline name");
+    const expression = this.parseExpression();
+    return new AST.PipelineDeclaration(name, expression, l);
+  }
+
+  parseValidateBlock() {
+    const l = this.loc();
+    this.advance(); // consume 'validate'
+    const typeName = this.expect(TokenType.IDENTIFIER, "Expected type name after 'validate'").value;
+    this.expect(TokenType.LBRACE, "Expected '{' after validate type name");
+
+    const rules = [];
+    while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+      const rule = this.parseExpression();
+      rules.push(rule);
+      this.match(TokenType.COMMA); // optional comma separator
+    }
+
+    this.expect(TokenType.RBRACE, "Expected '}' to close validate block");
+    return new AST.ValidateBlock(typeName, rules, l);
+  }
+
+  parseRefreshPolicy() {
+    const l = this.loc();
+    this.advance(); // consume 'refresh'
+    const sourceName = this.expect(TokenType.IDENTIFIER, "Expected source name after 'refresh'").value;
+
+    // refresh X every N.unit  OR  refresh X on_demand
+    if (this.check(TokenType.IDENTIFIER) && this.current().value === 'on_demand') {
+      this.advance();
+      return new AST.RefreshPolicy(sourceName, 'on_demand', l);
+    }
+
+    // expect 'every'
+    if (this.check(TokenType.IDENTIFIER) && this.current().value === 'every') {
+      this.advance(); // consume 'every'
+    }
+
+    // Parse interval: N.unit (e.g., 15.minutes, 1.hour)
+    const value = this.expect(TokenType.NUMBER, "Expected interval value").value;
+    this.expect(TokenType.DOT, "Expected '.' after interval value");
+    const unit = this.expect(TokenType.IDENTIFIER, "Expected time unit (minutes, hours, seconds)").value;
+
+    return new AST.RefreshPolicy(sourceName, { value, unit }, l);
+  }
+
   // ─── Server-specific statements ───────────────────────────
 
   parseServerStatement() {
@@ -375,6 +497,10 @@ export class Parser {
       if (val === 'model' && this.peek(1).type === TokenType.IDENTIFIER) {
         return this.parseModelDeclaration();
       }
+      // ai { ... } or ai "name" { ... }
+      if (val === 'ai' && (this.peek(1).type === TokenType.LBRACE || this.peek(1).type === TokenType.STRING)) {
+        return this.parseAiConfig();
+      }
     }
 
     return this.parseStatement();
@@ -649,6 +775,29 @@ export class Parser {
     return new AST.SessionDeclaration(config, l);
   }
 
+  parseAiConfig() {
+    const l = this.loc();
+    this.advance(); // consume 'ai'
+
+    // Optional name: ai "claude" { ... }
+    let name = null;
+    if (this.check(TokenType.STRING)) {
+      name = this.advance().value;
+    }
+
+    this.expect(TokenType.LBRACE, "Expected '{' after 'ai'");
+    const config = {};
+    while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+      const key = this.expect(TokenType.IDENTIFIER, "Expected ai config key").value;
+      this.expect(TokenType.COLON, "Expected ':' after ai config key");
+      const value = this.parseExpression();
+      config[key] = value;
+      this.match(TokenType.COMMA);
+    }
+    this.expect(TokenType.RBRACE, "Expected '}' to close ai config");
+    return new AST.AiConfigDeclaration(name, config, l);
+  }
+
   parseDbConfig() {
     const l = this.loc();
     this.advance(); // consume 'db'
@@ -1514,8 +1663,32 @@ export class Parser {
     }
 
     // Type alias: type Name = TypeExpr
+    // OR Refinement type: type Name = TypeExpr where { ... }
     if (this.match(TokenType.ASSIGN)) {
       const typeExpr = this.parseTypeAnnotation();
+
+      // Check for refinement type: type Email = String where { ... }
+      if (this.check(TokenType.IDENTIFIER) && this.current().value === 'where') {
+        this.advance(); // consume 'where'
+        this.expect(TokenType.LBRACE, "Expected '{' after 'where'");
+
+        // Parse predicate block — uses 'it' as implicit parameter
+        const predicates = [];
+        while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+          predicates.push(this.parseExpression());
+          this.match(TokenType.COMMA); // optional comma between predicates
+        }
+        this.expect(TokenType.RBRACE, "Expected '}' to close where block");
+
+        // Combine predicates with 'and'
+        let predicate = predicates[0];
+        for (let i = 1; i < predicates.length; i++) {
+          predicate = new AST.LogicalExpression('and', predicate, predicates[i], l);
+        }
+
+        return new AST.RefinementType(name, typeExpr, predicate, l);
+      }
+
       return new AST.TypeAlias(name, typeExpr, l);
     }
 
@@ -2123,6 +2296,14 @@ export class Parser {
       const operand = this.parseUnary();
       return new AST.YieldExpression(operand, delegate, l);
     }
+    // Negated column expression: -.column (for select exclusion)
+    if (this.check(TokenType.MINUS) && this.peek(1).type === TokenType.DOT && this.peek(2).type === TokenType.IDENTIFIER) {
+      const l = this.loc();
+      this.advance(); // consume -
+      this.advance(); // consume .
+      const name = this.advance().value;
+      return new AST.NegatedColumnExpression(name, l);
+    }
     if (this.check(TokenType.MINUS)) {
       const l = this.loc();
       this.advance();
@@ -2343,13 +2524,32 @@ export class Parser {
       return this.parseObjectOrDictComprehension();
     }
 
+    // Column expression: .column (for table operations)
+    // Appears at expression-start when DOT followed by IDENTIFIER
+    // but NOT when preceded by an expression (which would be member access)
+    if (this.check(TokenType.DOT) && this.peek(1).type === TokenType.IDENTIFIER) {
+      // Check this isn't inside a method pipe (|> .method) — that's handled in parsePipe
+      // Column expressions appear in function arguments and assignments
+      this.advance(); // consume .
+      const name = this.advance().value; // consume identifier
+
+      // Check for column assignment: .col = expr (used in derive)
+      if (this.check(TokenType.ASSIGN)) {
+        this.advance(); // consume =
+        const expr = this.parseExpression();
+        return new AST.ColumnAssignment(name, expr, l);
+      }
+
+      return new AST.ColumnExpression(name, l);
+    }
+
     // Parenthesized expression or arrow lambda
     if (this.check(TokenType.LPAREN)) {
       return this.parseParenOrArrowLambda();
     }
 
-    // server/client/shared as identifiers in expression position (for RPC: server.get_users())
-    if (this.check(TokenType.SERVER) || this.check(TokenType.CLIENT) || this.check(TokenType.SHARED)) {
+    // Keywords that can appear as identifiers in expression position
+    if (this.check(TokenType.SERVER) || this.check(TokenType.CLIENT) || this.check(TokenType.SHARED) || this.check(TokenType.DERIVE)) {
       const name = this.advance().value;
       return new AST.Identifier(name, l);
     }

package/src/runtime/ai.js

@@ -0,0 +1,305 @@
+// AI Runtime for Tova — Multi-provider AI client
+// Supports: anthropic, openai, ollama, custom (OpenAI-compatible)
+
+// ── Provider Implementations ──────────────────────────
+
+const providers = {
+  async anthropic(config, method, args) {
+    const baseUrl = config.base_url || 'https://api.anthropic.com';
+    const headers = {
+      'Content-Type': 'application/json',
+      'x-api-key': config.api_key,
+      'anthropic-version': '2023-06-01',
+      ...(config.headers || {}),
+    };
+
+    switch (method) {
+      case 'ask': {
+        const [prompt, opts = {}] = args;
+        const body = {
+          model: config.model || 'claude-sonnet-4-20250514',
+          max_tokens: opts.max_tokens || config.max_tokens || 4096,
+          messages: [{ role: 'user', content: prompt }],
+        };
+        if (opts.temperature ?? config.temperature) body.temperature = opts.temperature ?? config.temperature;
+        if (opts.tools) {
+          body.tools = opts.tools.map(t => ({
+            name: t.name,
+            description: t.description,
+            input_schema: { type: 'object', properties: t.params ? Object.fromEntries(Object.entries(t.params).map(([k, v]) => [k, { type: typeof v === 'string' ? v.toLowerCase() : 'string' }])) : {} },
+          }));
+        }
+        const res = await fetch(`${baseUrl}/v1/messages`, { method: 'POST', headers, body: JSON.stringify(body) });
+        if (!res.ok) throw new Error(`Anthropic API error ${res.status}: ${await res.text()}`);
+        const data = await res.json();
+        if (opts.tools && data.content.some(c => c.type === 'tool_use')) {
+          return { text: data.content.filter(c => c.type === 'text').map(c => c.text).join(''), tool_calls: data.content.filter(c => c.type === 'tool_use') };
+        }
+        return data.content.map(c => c.text).join('');
+      }
+      case 'chat': {
+        const [messages, opts = {}] = args;
+        const systemMessages = messages.filter(m => m.role === 'system');
+        const nonSystemMessages = messages.filter(m => m.role !== 'system');
+        const body = {
+          model: config.model || 'claude-sonnet-4-20250514',
+          max_tokens: opts.max_tokens || config.max_tokens || 4096,
+          messages: nonSystemMessages,
+        };
+        if (systemMessages.length > 0) body.system = systemMessages.map(m => m.content).join('\n');
+        if (opts.temperature ?? config.temperature) body.temperature = opts.temperature ?? config.temperature;
+        const res = await fetch(`${baseUrl}/v1/messages`, { method: 'POST', headers, body: JSON.stringify(body) });
+        if (!res.ok) throw new Error(`Anthropic API error ${res.status}: ${await res.text()}`);
+        const data = await res.json();
+        return data.content.map(c => c.text).join('');
+      }
+      case 'embed': {
+        // Anthropic doesn't have embeddings — fall through to openai-compatible
+        throw new Error('Anthropic does not support embeddings. Use an OpenAI-compatible provider.');
+      }
+      case 'extract': {
+        const [prompt, schema, opts = {}] = args;
+        const body = {
+          model: config.model || 'claude-sonnet-4-20250514',
+          max_tokens: opts.max_tokens || config.max_tokens || 4096,
+          messages: [{ role: 'user', content: `${prompt}\n\nRespond with a JSON object matching this schema: ${JSON.stringify(schema)}` }],
+        };
+        if (opts.temperature ?? config.temperature) body.temperature = opts.temperature ?? config.temperature;
+        const res = await fetch(`${baseUrl}/v1/messages`, { method: 'POST', headers, body: JSON.stringify(body) });
+        if (!res.ok) throw new Error(`Anthropic API error ${res.status}: ${await res.text()}`);
+        const data = await res.json();
+        const text = data.content.map(c => c.text).join('');
+        try { return JSON.parse(text); } catch { return JSON.parse(text.match(/\{[\s\S]*\}/)?.[0] || '{}'); }
+      }
+      case 'classify': {
+        const [text, categories, opts = {}] = args;
+        const catList = Array.isArray(categories) ? categories : Object.keys(categories);
+        const body = {
+          model: config.model || 'claude-sonnet-4-20250514',
+          max_tokens: opts.max_tokens || config.max_tokens || 100,
+          messages: [{ role: 'user', content: `Classify the following text into exactly one of these categories: ${catList.join(', ')}\n\nText: "${text}"\n\nRespond with only the category name, nothing else.` }],
+        };
+        if (opts.temperature ?? config.temperature) body.temperature = opts.temperature ?? config.temperature;
+        const res = await fetch(`${baseUrl}/v1/messages`, { method: 'POST', headers, body: JSON.stringify(body) });
+        if (!res.ok) throw new Error(`Anthropic API error ${res.status}: ${await res.text()}`);
+        const data = await res.json();
+        const result = data.content.map(c => c.text).join('').trim();
+        // Match against categories (case-insensitive)
+        return catList.find(c => c.toLowerCase() === result.toLowerCase()) || result;
+      }
+      default:
+        throw new Error(`Unknown AI method: ${method}`);
+    }
+  },
+
+  async openai(config, method, args) {
+    const baseUrl = config.base_url || 'https://api.openai.com';
+    const headers = {
+      'Content-Type': 'application/json',
+      'Authorization': `Bearer ${config.api_key}`,
+      ...(config.headers || {}),
+    };
+
+    switch (method) {
+      case 'ask': {
+        const [prompt, opts = {}] = args;
+        const body = {
+          model: config.model || 'gpt-4o',
+          messages: [{ role: 'user', content: prompt }],
+        };
+        if (opts.max_tokens || config.max_tokens) body.max_tokens = opts.max_tokens || config.max_tokens;
+        if (opts.temperature ?? config.temperature) body.temperature = opts.temperature ?? config.temperature;
+        if (opts.tools) {
+          body.tools = opts.tools.map(t => ({
+            type: 'function',
+            function: { name: t.name, description: t.description, parameters: { type: 'object', properties: t.params ? Object.fromEntries(Object.entries(t.params).map(([k, v]) => [k, { type: typeof v === 'string' ? v.toLowerCase() : 'string' }])) : {} } },
+          }));
+        }
+        const res = await fetch(`${baseUrl}/v1/chat/completions`, { method: 'POST', headers, body: JSON.stringify(body) });
+        if (!res.ok) throw new Error(`OpenAI API error ${res.status}: ${await res.text()}`);
+        const data = await res.json();
+        const choice = data.choices[0];
+        if (opts.tools && choice.message.tool_calls) {
+          return { text: choice.message.content || '', tool_calls: choice.message.tool_calls };
+        }
+        return choice.message.content;
+      }
+      case 'chat': {
+        const [messages, opts = {}] = args;
+        const body = { model: config.model || 'gpt-4o', messages };
+        if (opts.max_tokens || config.max_tokens) body.max_tokens = opts.max_tokens || config.max_tokens;
+        if (opts.temperature ?? config.temperature) body.temperature = opts.temperature ?? config.temperature;
+        const res = await fetch(`${baseUrl}/v1/chat/completions`, { method: 'POST', headers, body: JSON.stringify(body) });
+        if (!res.ok) throw new Error(`OpenAI API error ${res.status}: ${await res.text()}`);
+        const data = await res.json();
+        return data.choices[0].message.content;
+      }
+      case 'embed': {
+        const [input, opts = {}] = args;
+        const body = { model: config.model || 'text-embedding-3-small', input };
+        const res = await fetch(`${baseUrl}/v1/embeddings`, { method: 'POST', headers, body: JSON.stringify(body) });
+        if (!res.ok) throw new Error(`OpenAI API error ${res.status}: ${await res.text()}`);
+        const data = await res.json();
+        if (Array.isArray(input)) return data.data.map(d => d.embedding);
+        return data.data[0].embedding;
+      }
+      case 'extract': {
+        const [prompt, schema, opts = {}] = args;
+        const body = {
+          model: config.model || 'gpt-4o',
+          messages: [{ role: 'user', content: `${prompt}\n\nRespond with a JSON object matching this schema: ${JSON.stringify(schema)}` }],
+          response_format: { type: 'json_object' },
+        };
+        if (opts.max_tokens || config.max_tokens) body.max_tokens = opts.max_tokens || config.max_tokens;
+        const res = await fetch(`${baseUrl}/v1/chat/completions`, { method: 'POST', headers, body: JSON.stringify(body) });
+        if (!res.ok) throw new Error(`OpenAI API error ${res.status}: ${await res.text()}`);
+        const data = await res.json();
+        return JSON.parse(data.choices[0].message.content);
+      }
+      case 'classify': {
+        const [text, categories, opts = {}] = args;
+        const catList = Array.isArray(categories) ? categories : Object.keys(categories);
+        const body = {
+          model: config.model || 'gpt-4o',
+          messages: [{ role: 'user', content: `Classify into one of: ${catList.join(', ')}\n\nText: "${text}"\n\nRespond with only the category.` }],
+        };
+        if (opts.max_tokens || config.max_tokens) body.max_tokens = opts.max_tokens || config.max_tokens;
+        const res = await fetch(`${baseUrl}/v1/chat/completions`, { method: 'POST', headers, body: JSON.stringify(body) });
+        if (!res.ok) throw new Error(`OpenAI API error ${res.status}: ${await res.text()}`);
+        const data = await res.json();
+        const result = data.choices[0].message.content.trim();
+        return catList.find(c => c.toLowerCase() === result.toLowerCase()) || result;
+      }
+      default:
+        throw new Error(`Unknown AI method: ${method}`);
+    }
+  },
+
+  async ollama(config, method, args) {
+    const baseUrl = config.base_url || 'http://localhost:11434';
+    const headers = { 'Content-Type': 'application/json', ...(config.headers || {}) };
+
+    switch (method) {
+      case 'ask': {
+        const [prompt, opts = {}] = args;
+        const body = { model: config.model || 'llama3', messages: [{ role: 'user', content: prompt }], stream: false };
+        const res = await fetch(`${baseUrl}/api/chat`, { method: 'POST', headers, body: JSON.stringify(body) });
+        if (!res.ok) throw new Error(`Ollama API error ${res.status}: ${await res.text()}`);
+        const data = await res.json();
+        return data.message.content;
+      }
+      case 'chat': {
+        const [messages, opts = {}] = args;
+        const body = { model: config.model || 'llama3', messages, stream: false };
+        const res = await fetch(`${baseUrl}/api/chat`, { method: 'POST', headers, body: JSON.stringify(body) });
+        if (!res.ok) throw new Error(`Ollama API error ${res.status}: ${await res.text()}`);
+        const data = await res.json();
+        return data.message.content;
+      }
+      case 'embed': {
+        const [input, opts = {}] = args;
+        const body = { model: config.model || 'llama3', prompt: Array.isArray(input) ? input[0] : input };
+        const res = await fetch(`${baseUrl}/api/embeddings`, { method: 'POST', headers, body: JSON.stringify(body) });
+        if (!res.ok) throw new Error(`Ollama API error ${res.status}: ${await res.text()}`);
+        const data = await res.json();
+        if (Array.isArray(input)) {
+          const results = [];
+          for (const text of input) {
+            const r = await fetch(`${baseUrl}/api/embeddings`, { method: 'POST', headers, body: JSON.stringify({ model: config.model || 'llama3', prompt: text }) });
+            const d = await r.json();
+            results.push(d.embedding);
+          }
+          return results;
+        }
+        return data.embedding;
+      }
+      case 'extract': {
+        const [prompt, schema] = args;
+        const body = { model: config.model || 'llama3', messages: [{ role: 'user', content: `${prompt}\nRespond with JSON: ${JSON.stringify(schema)}` }], stream: false, format: 'json' };
+        const res = await fetch(`${baseUrl}/api/chat`, { method: 'POST', headers, body: JSON.stringify(body) });
+        if (!res.ok) throw new Error(`Ollama API error ${res.status}: ${await res.text()}`);
+        const data = await res.json();
+        return JSON.parse(data.message.content);
+      }
+      case 'classify': {
+        const [text, categories] = args;
+        const catList = Array.isArray(categories) ? categories : Object.keys(categories);
+        const body = { model: config.model || 'llama3', messages: [{ role: 'user', content: `Classify into one of: ${catList.join(', ')}\nText: "${text}"\nRespond with only the category.` }], stream: false };
+        const res = await fetch(`${baseUrl}/api/chat`, { method: 'POST', headers, body: JSON.stringify(body) });
+        if (!res.ok) throw new Error(`Ollama API error ${res.status}: ${await res.text()}`);
+        const data = await res.json();
+        const result = data.message.content.trim();
+        return catList.find(c => c.toLowerCase() === result.toLowerCase()) || result;
+      }
+      default:
+        throw new Error(`Unknown AI method: ${method}`);
+    }
+  },
+};
+
+// Custom provider uses OpenAI-compatible API format
+providers.custom = providers.openai;
+
+// ── AI Client Factory ─────────────────────────────────
+
+export function createAI(config = {}) {
+  const providerName = config.provider || 'custom';
+  const providerFn = providers[providerName] || providers.custom;
+
+  const client = {
+    _config: config,
+    _provider: providerFn,
+
+    async ask(prompt, opts = {}) {
+      const mergedConfig = { ...config, ...opts };
+      return providerFn(mergedConfig, 'ask', [prompt, opts]);
+    },
+
+    async chat(messages, opts = {}) {
+      const mergedConfig = { ...config, ...opts };
+      return providerFn(mergedConfig, 'chat', [messages, opts]);
+    },
+
+    async embed(input, opts = {}) {
+      const mergedConfig = { ...config, ...opts };
+      return providerFn(mergedConfig, 'embed', [input, opts]);
+    },
+
+    async extract(prompt, schema, opts = {}) {
+      const mergedConfig = { ...config, ...opts };
+      return providerFn(mergedConfig, 'extract', [prompt, schema, opts]);
+    },
+
+    async classify(text, categories, opts = {}) {
+      const mergedConfig = { ...config, ...opts };
+      return providerFn(mergedConfig, 'classify', [text, categories, opts]);
+    },
+  };
+
+  return client;
+}
+
+// ── Default AI object (for one-off calls) ─────────────
+
+export const defaultAI = {
+  async ask(prompt, opts = {}) {
+    const client = createAI(opts);
+    return client.ask(prompt, opts);
+  },
+  async chat(messages, opts = {}) {
+    const client = createAI(opts);
+    return client.chat(messages, opts);
+  },
+  async embed(input, opts = {}) {
+    const client = createAI(opts);
+    return client.embed(input, opts);
+  },
+  async extract(prompt, schema, opts = {}) {
+    const client = createAI(opts);
+    return client.extract(prompt, schema, opts);
+  },
+  async classify(text, categories, opts = {}) {
+    const client = createAI(opts);
+    return client.classify(text, categories, opts);
+  },
+};