@console-agent/agent 1.2.1 → 1.2.3

package/dist/index.js

@@ -293,6 +293,16 @@ var INTERNAL_PATTERNS = [
   "node:async_hooks",
   "<anonymous>"
 ];
+function normalizeFilePath(filePath) {
+  if (filePath.startsWith("file://")) {
+    try {
+      return new URL(filePath).pathname;
+    } catch {
+      return filePath.replace(/^file:\/\//, "");
+    }
+  }
+  return filePath;
+}
 function parseStackFrames(stack) {
   const frames = [];
   const lines = stack.split("\n");
@@ -338,7 +348,8 @@ function getErrorSourceFile(error) {
 }
 function readSourceFile(filePath, line, column) {
   try {
-    const resolvedPath = resolve(filePath);
+    const normalizedPath = normalizeFilePath(filePath);
+    const resolvedPath = resolve(normalizedPath);
     if (!existsSync(resolvedPath)) return null;
     const { statSync } = __require("fs");
     const stats = statSync(resolvedPath);
@@ -781,6 +792,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)
@@ -977,6 +1112,7 @@ var BudgetTracker = class {
 var DEFAULT_CONFIG = {
   provider: "google",
   model: "gemini-2.5-flash-lite",
+  ollamaHost: "http://localhost:11434",
   persona: "general",
   budget: {
     maxCallsPerDay: 100,
@@ -1063,8 +1199,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(