@console-agent/agent 1.2.2 → 1.2.3

package/README.md

@@ -1,5 +1,8 @@
-# @console-agent/agent
-
+```
+█▀▀ █▀█ █▄ █ █▀ █▀█ █   █▀▀
+█▄▄ █▄█ █ ▀█ ▄█ █▄█ █▄▄ ██▄
+       .agent
+```
 > Drop `console.agent(...)` anywhere in your code to execute agentic workflows — as easy as `console.log()`
 
 [![npm](https://img.shields.io/npm/v/@console-agent/agent)](https://www.npmjs.com/package/@console-agent/agent)
@@ -39,14 +42,65 @@ console.agent.debug("why is this slow?", { duration, query });
 console.agent.architect("review this API design", endpoint);
 ```
 
+## 🔌 Providers
+
+### Google Gemini (default)
+
+Cloud-hosted, full tool support, API key required.
+
+```typescript
+import { init } from '@console-agent/agent';
+
+init({
+  provider: 'google',                    // default
+  apiKey: process.env.GEMINI_API_KEY,
+  model: 'gemini-2.5-flash-lite',
+});
+```
+
+### Ollama (Local Models)
+
+Run models locally with [Ollama](https://ollama.com). Free, private, no API key needed.
+
+```bash
+# 1. Install Ollama: https://ollama.com
+# 2. Pull a model
+ollama pull llama3.2
+```
+
+```typescript
+import { init } from '@console-agent/agent';
+
+init({
+  provider: 'ollama',
+  model: 'llama3.2',                     // any model from `ollama list`
+  ollamaHost: 'http://localhost:11434',   // default
+});
+```
+
+### Provider Comparison
+
+| | Google Gemini | Ollama |
+|---|---|---|
+| Setup | `GEMINI_API_KEY` env var | Install Ollama + pull model |
+| Config | `provider: 'google'` | `provider: 'ollama'` |
+| Models | `gemini-2.5-flash-lite`, etc. | `llama3.2`, any `ollama list` model |
+| Tools | ✅ google_search, code_execution, url_context | ❌ Not supported |
+| Thinking | ✅ Supported | ❌ Not supported |
+| File attachments | ✅ Full support | ⚠️ Text-only |
+| Cost | Pay per token (very cheap) | Free (local) |
+| Privacy | Cloud (with anonymization) | 100% local |
+
 ## Configuration
 
 ```typescript
 import { init } from '@console-agent/agent';
 
 init({
+  provider: 'google',                    // 'google' | 'ollama'
   apiKey: process.env.GEMINI_API_KEY,    // Or set GEMINI_API_KEY env var
   model: 'gemini-2.5-flash-lite',        // Default (fast & cheap)
+  ollamaHost: 'http://localhost:11434',   // Ollama host (when provider='ollama')
   persona: 'general',                     // 'debugger' | 'security' | 'architect' | 'general'
   mode: 'fire-and-forget',               // 'fire-and-forget' | 'blocking'
   timeout: 10000,                         // ms

package/dist/index.cjs

@@ -799,6 +799,130 @@ function parseResponse(text) {
   }
 }
 
+// src/providers/ollama.ts
+var JSON_RESPONSE_INSTRUCTION2 = `
+
+IMPORTANT: You MUST respond with ONLY a valid JSON object (no markdown, no code fences, no extra text).
+Use this exact format:
+{"success": true, "summary": "one-line conclusion", "reasoning": "your thought process", "data": {"result": "primary finding"}, "actions": ["tools/steps used"], "confidence": 0.95}`;
+function buildMessages2(prompt, context, sourceFile, _files) {
+  const parts = [];
+  parts.push({ type: "text", text: prompt });
+  if (context) {
+    parts.push({ type: "text", text: `
+--- Context ---
+${context}` });
+  }
+  if (sourceFile) {
+    const formatted = formatSourceForContext(sourceFile);
+    parts.push({ type: "text", text: `
+${formatted}` });
+  }
+  if (_files && _files.length > 0) {
+    logDebug("WARNING: File attachments have limited support with Ollama. Only text-based files included as context.");
+  }
+  return [{ role: "user", content: parts }];
+}
+function parseResponse2(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    const jsonMatch = text.match(/```(?:json)?\s*\n?([\s\S]*?)\n?\s*```/);
+    if (jsonMatch) {
+      try {
+        return JSON.parse(jsonMatch[1]);
+      } catch {
+      }
+    }
+    const objectMatch = text.match(/\{[\s\S]*\}/);
+    if (objectMatch) {
+      try {
+        return JSON.parse(objectMatch[0]);
+      } catch {
+      }
+    }
+    return {
+      success: true,
+      summary: text.substring(0, 200),
+      data: { raw: text },
+      actions: [],
+      confidence: 0.5
+    };
+  }
+}
+async function callOllama(prompt, context, persona, config2, options, sourceFile, files) {
+  const startTime = Date.now();
+  let modelName = options?.model ?? config2.model;
+  if (modelName.startsWith("gemini")) {
+    modelName = "llama3.2";
+    logDebug(`Ollama provider: defaulting model to ${modelName}`);
+  }
+  logDebug(`Using model: ${modelName}`);
+  logDebug(`Persona: ${persona.name}`);
+  const host = config2.ollamaHost || process.env.OLLAMA_HOST || "http://localhost:11434";
+  if (options?.tools && options.tools.length > 0) {
+    logDebug('WARNING: Tools are not supported with the Ollama provider. Tools will be ignored. Use provider="google" for tool support.');
+  }
+  if (options?.thinking) {
+    logDebug("WARNING: Thinking config is not supported with the Ollama provider. It will be ignored.");
+  }
+  logDebug(`Ollama host: ${host}`);
+  const { createOllama } = await import('ai-sdk-ollama');
+  const { generateText: generateText2 } = await import('ai');
+  const ollama = createOllama({ baseURL: host });
+  const useCustomSchema = !!(options?.schema || options?.responseFormat);
+  const systemPrompt = useCustomSchema ? `${persona.systemPrompt}
+
+IMPORTANT: You must respond with structured data matching the requested output schema. Do not include AgentResult wrapper fields \u2014 just return the data matching the schema.` : persona.systemPrompt + JSON_RESPONSE_INSTRUCTION2;
+  const messages = buildMessages2(prompt, context, sourceFile, files);
+  const result = await generateText2({
+    model: ollama(modelName),
+    system: systemPrompt,
+    messages,
+    maxOutputTokens: config2.budget.maxTokensPerCall,
+    abortSignal: AbortSignal.timeout(config2.timeout)
+  });
+  const latencyMs = Date.now() - startTime;
+  const tokensUsed = result.usage?.totalTokens ?? 0;
+  const collectedToolCalls = [];
+  logDebug(`Response received: ${latencyMs}ms, ${tokensUsed} tokens`);
+  if (useCustomSchema) {
+    const parsed2 = parseResponse2(result.text);
+    const customData = parsed2 && !parsed2.raw ? parsed2 : { result: result.text };
+    logDebug("Custom schema output received, wrapping in AgentResult");
+    return {
+      success: true,
+      summary: `Structured output returned (${Object.keys(customData).length} fields)`,
+      data: customData,
+      actions: [],
+      confidence: 1,
+      metadata: {
+        model: modelName,
+        tokensUsed,
+        latencyMs,
+        toolCalls: collectedToolCalls,
+        cached: false
+      }
+    };
+  }
+  const parsed = parseResponse2(result.text);
+  return {
+    success: parsed?.success ?? true,
+    summary: parsed?.summary ?? result.text.substring(0, 200),
+    reasoning: parsed?.reasoning,
+    data: parsed?.data ?? { raw: result.text },
+    actions: parsed?.actions ?? [],
+    confidence: parsed?.confidence ?? 0.5,
+    metadata: {
+      model: modelName,
+      tokensUsed,
+      latencyMs,
+      toolCalls: collectedToolCalls,
+      cached: false
+    }
+  };
+}
+
 // src/utils/anonymize.ts
 var patterns = {
   // API keys and tokens (long alphanumeric strings near sensitive keywords)
@@ -995,6 +1119,7 @@ var BudgetTracker = class {
 var DEFAULT_CONFIG = {
   provider: "google",
   model: "gemini-2.5-flash-lite",
+  ollamaHost: "http://localhost:11434",
   persona: "general",
   budget: {
     maxCallsPerDay: 100,
@@ -1081,8 +1206,9 @@ async function executeAgent(prompt, context, options) {
   const files = options?.files;
   const spinner = startSpinner(persona, processedPrompt, verbose);
   try {
+    const providerCall = config.provider === "ollama" ? callOllama(processedPrompt, contextStr, persona, config, options, sourceFile, files) : callGoogle(processedPrompt, contextStr, persona, config, options, sourceFile, files);
     const result = await Promise.race([
-      callGoogle(processedPrompt, contextStr, persona, config, options, sourceFile, files),
+      providerCall,
       createTimeout(config.timeout)
     ]);
     budgetTracker.recordUsage(