@alhisan/gac 1.0.0 → 1.1.1

package/.github/workflows/npm-publish.yml

@@ -0,0 +1,35 @@
+name: Publish Package to npmjs
+
+on:
+  release:
+    # This triggers when you click 'Publish Release' in the GitHub UI
+    types: [published] 
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+      - run: npm ci
+      - run: npm test
+
+  publish-npm:
+    needs: build
+    runs-on: ubuntu-latest
+    # CRITICAL: These permissions are required for --provenance to work
+    permissions:
+      id-token: write
+      contents: read
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          registry-url: https://registry.npmjs.org
+      - run: npm ci
+      - run: npm publish --provenance --access public
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/README.md

@@ -1,10 +1,10 @@
-# GPT4All CLI (gac)
+# GAC CLI (gac)
 
-Terminal client for GPT4All running on localhost. Supports streaming responses, interactive chat, and configurable markdown rendering using `terminal-kit`.
+Terminal client for OpenAI-compatible APIs (including GPT4All) and Ollama. Supports streaming responses, interactive chat, and configurable markdown rendering using `terminal-kit`.
 
 ## Installation
 
-Requirements: Node.js 18+ and a running GPT4All OpenAI-compatible server.
+Requirements: Node.js 18+ and a running OpenAI-compatible server (like GPT4All) or Ollama.
 
 ```bash
 npm install -g @alhisan/gac
@@ -29,6 +29,7 @@ Single prompt:
 
 ```bash
 gac -a "Hello gpt4all, how are you doing today?"
+gac "How do I push to GitHub?"
 gac suggest "How do I connect to ssh server on a custom port 5322?"
 gac explain "How do I use rsync?"
 gac suggest -d "Give me step-by-step instructions to set up an SSH server on port 5322"
@@ -68,6 +69,7 @@ View and edit:
 
 ```bash
 gac config
+gac config tui
 gac config get baseUrl
 gac config set baseUrl http://localhost:4891
 gac config set model "Llama 3 8B Instruct"
@@ -77,11 +79,16 @@ gac config set detailedSuggest true
 
 ### Core settings
 
+- `provider` (string): `openai` (default) or `ollama`
 - `baseUrl` (string): GPT4All server base, e.g. `http://localhost:4891`
+- `ollamaBaseUrl` (string): Ollama base, e.g. `http://localhost:11434`
+- `apiKey` (string): API key for OpenAI-compatible services (empty for local servers)
 - `model` (string): model ID from `/v1/models`
 - `temperature` (number)
 - `maxTokens` (number)
 - `stream` (boolean)
+- `requestTimeoutMs` (number): request timeout in milliseconds (0 to disable). Useful for larger models or slower servers.
+- `defaultAction` (string): default mode for direct prompts (`suggest`, `ask`, or `explain`).
 - `detailedSuggest` (boolean): when `true`, `suggest` mode returns more detailed, step-by-step suggestions.
 - `renderMarkdown` (boolean)
 
@@ -136,9 +143,19 @@ Example:
 If you see connection errors, verify the server is reachable:
 
 ```bash
-curl http://localhost:4891/v1/models
+curl http://[SERVER_ADDRESS]:[SERVER_PORT]/v1/models
+```
+
+For Ollama:
+
+```bash
+curl http://[SERVER_ADDRESS]:[SERVER_PORT]/api/tags
 ```
 
 ## License
 
 GNU General Public License v3.0. See `LICENSE`.
+
+## Disclaimer
+
+This was mostly vibe coded and I'm treating it as a fun side project / tool that is likely to remain improved and updated by agentic models.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alhisan/gac",
-  "version": "1.0.0",
+  "version": "1.1.1",
   "description": "Terminal client for GPT4All running on localhost",
   "license": "GPL-3.0-only",
   "type": "module",
@@ -10,7 +10,14 @@
   "engines": {
     "node": ">=18.0.0"
   },
+  "scripts": {
+    "test": "echo \"No tests yet\""
+  },
   "dependencies": {
     "terminal-kit": "^3.1.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kwmx/gac"
   }
 }

package/src/cli.js

@@ -2,12 +2,13 @@ import terminalKit from "terminal-kit";
 import { chatCompletion, listModels } from "./gpt4all.js";
 import { getConfigPath, loadConfig, setConfigValue } from "./config.js";
 import { createMarkdownRenderer } from "./markdown.js";
+import fs from "fs";
 import os from "os";
 import process from "process";
 const { terminal: term } = terminalKit;
 
 function printHelp() {
-  term(`gac - GPT4All CLI\n\n`);
+  term(`gac - OpenAI-compatible & Ollama CLI\n\n`);
   term(`Options:\n`);
   term(`  -a                Single prompt mode (alias for ask)\n`);
   term(`  suggest           Suggestion mode\n`);
@@ -16,6 +17,7 @@ function printHelp() {
   term(`  chat              Interactive chat mode\n`);
   term(`  models            List models and set default\n`);
   term(`  config            View or edit configuration\n`);
+  term(`  config tui        Open interactive config editor\n`);
   term(`  --no-render      Disable markdown rendering\n`);
   term(`  --debug-render   Show both rendered and raw output\n`);
   term(
@@ -31,12 +33,40 @@ function printHelp() {
   term(`  gac chat\n`);
   term(`  gac models\n`);
   term(`  gac config\n`);
+  term(`  gac config tui\n`);
   term(`  gac config get <key>\n`);
   term(`  gac config set <key> <value>\n`);
   term(`  gac --no-render -a "Raw markdown output"\n`);
   term(`  gac --debug-render -a "Show rendered and raw output"\n`);
   term(`\n`);
 }
+function parseOsRelease(contents) {
+  const result = {};
+  const lines = contents.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#") || !trimmed.includes("=")) continue;
+    const [key, ...rest] = trimmed.split("=");
+    let value = rest.join("=").trim();
+    if (value.startsWith('"') && value.endsWith('"')) {
+      value = value.slice(1, -1);
+    }
+    if (value) {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+
+function readLinuxOsRelease() {
+  try {
+    const contents = fs.readFileSync("/etc/os-release", "utf8");
+    return parseOsRelease(contents);
+  } catch (err) {
+    return null;
+  }
+}
+
 function getOSVersion() {
   const platform = os.platform();
   if (platform === "win32") {
@@ -63,7 +93,14 @@ function getOSVersion() {
     return "macOS";
   }
   if (platform === "linux") {
-    // Find which distro
+    const osRelease = readLinuxOsRelease();
+    if (osRelease && (osRelease.PRETTY_NAME || osRelease.NAME)) {
+      const pretty = osRelease.PRETTY_NAME || osRelease.NAME;
+      const id = osRelease.ID ? `; id=${osRelease.ID}` : "";
+      const idLike = osRelease.ID_LIKE ? `; id_like=${osRelease.ID_LIKE}` : "";
+      return `Linux (${pretty}${id}${idLike})`;
+    }
+    // Find which distro (fallbacks)
     if (process.env.OS_RELEASE) {
       return `${platform}: ${process.env.OS_RELEASE}`;
     } else if (process.env.OS) {
@@ -86,24 +123,33 @@ function getOSVersion() {
 }
 function buildSystemPrompt(mode, config) {
   const osInfo = getOSVersion();
+  const osGuidance = `The user is using a system with the following OS: ${osInfo}. When providing commands or package install steps, use the native tooling for that OS (e.g., dnf for Fedora, apt for Debian/Ubuntu). Avoid giving instructions for other distros unless explicitly requested.`;
 
   if (mode === "suggest") {
     if (config.detailedSuggest === true) {
-      return `You are an expert technical assistant. The user is using a system with the following OS: ${osInfo}. When providing suggestions, give detailed, step-by-step instructions that the user can follow to achieve their goals. Include relevant commands, code snippets, or configurations as needed. Avoid unnecessary explanations or background information. Tailor your suggestions to be relevant to the user's operating system and environment.
+      return `You are an expert technical assistant. ${osGuidance} When providing suggestions, give detailed, step-by-step instructions that the user can follow to achieve their goals. Include relevant commands, code snippets, or configurations as needed. Avoid unnecessary explanations or background information. Tailor your suggestions to be relevant to the user's operating system and environment.
 Attempt to make it a single line response where possible. Prefer commands and code snippets over lengthy explanations. Always leave commands and codes in their own line for easy copying.`;
     } else {
-      return `You are an expert technical assistant. The user is using a system with the following OS: ${osInfo}. Provide concise and practical suggestions to help the user accomplish their tasks efficiently. Focus on clarity and brevity, ensuring that your suggestions are easy to understand and implement. Tailor your suggestions to be relevant to the user's operating system and environment. Avoid lengthy explanations or unnecessary details prefer single line commands or codes if you must include explainations make sure the commands and codes are in their own line for easy copying.`;
+      return `You are an expert technical assistant. ${osGuidance} Provide concise and practical suggestions to help the user accomplish their tasks efficiently. Focus on clarity and brevity, ensuring that your suggestions are easy to understand and implement. Tailor your suggestions to be relevant to the user's operating system and environment. Avoid lengthy explanations or unnecessary details prefer single line commands or codes if you must include explainations make sure the commands and codes are in their own line for easy copying.`;
     }
   }
   if (mode === "ask") {
-    return "Provide a helpful and accurate response to the user's question.";
+    return `Provide a helpful and accurate response to the user's question. ${osGuidance}`;
   }
   if (mode === "explain") {
-    return "Explain step-by-step with a short example if helpful.";
+    return `Explain step-by-step with a short example if helpful. ${osGuidance}`;
   }
   return null;
 }
 
+function normalizeDefaultAction(action) {
+  const normalized = String(action || "").trim().toLowerCase();
+  if (normalized === "ask" || normalized === "suggest" || normalized === "explain") {
+    return normalized;
+  }
+  return "suggest";
+}
+
 async function runSinglePrompt(mode, prompt, config) {
   const system = buildSystemPrompt(mode, config);
   const messages = [];
@@ -119,6 +165,11 @@ async function runSinglePrompt(mode, prompt, config) {
       term(`${reply}\n`);
     }
   }
+  if (!reply || !reply.trim()) {
+    term(
+      "No response from the model. The request may have timed out or returned empty content. Consider increasing requestTimeoutMs in the config or enabling streaming.\n"
+    );
+  }
   if (config.debugRender) {
     term(`\n--- RAW ---\n${reply}\n`);
   }
@@ -139,6 +190,251 @@ async function inputLine(label) {
   });
 }
 
+function formatConfigValue(value) {
+  if (typeof value === "string") {
+    if (!value) return "(empty)";
+    if (value.length > 48) return `${value.slice(0, 45)}...`;
+    return value;
+  }
+  return JSON.stringify(value);
+}
+
+function maskApiKey(apiKey) {
+  if (!apiKey) return "(empty)";
+  if (apiKey.length <= 6) return "***";
+  return `${apiKey.slice(0, 3)}...${apiKey.slice(-3)}`;
+}
+
+async function promptConfigValue(label, currentValue) {
+  term(`${label} [${formatConfigValue(currentValue)}]: `);
+  return new Promise((resolve) => {
+    term.inputField({ cancelable: true, default: String(currentValue ?? "") }, (error, input) => {
+      term("\n");
+      if (error || input === undefined || input === null) {
+        resolve(null);
+        return;
+      }
+      resolve(input.trim());
+    });
+  });
+}
+
+async function selectConfigProvider(config) {
+  const options = [
+    "OpenAI-compatible (includes GPT4All)",
+    "Ollama",
+  ];
+  const currentIndex = config.provider === "ollama" ? 1 : 0;
+  term("\nSelect provider:\n");
+  return new Promise((resolve) => {
+    term.singleColumnMenu(
+      options,
+      { cancelable: true, selectedIndex: currentIndex },
+      (error, response) => {
+        term("\n");
+        if (error || !response || response.canceled) {
+          resolve(null);
+          return;
+        }
+        resolve(response.selectedIndex === 1 ? "ollama" : "openai");
+      }
+    );
+  });
+}
+
+async function runConfigTui(config) {
+  term("Config editor (Esc to exit)\n\n");
+  let updatedConfig = { ...config };
+  term.grabInput({ mouse: "button" });
+  const cleanup = () => {
+    term.grabInput(false);
+    term.removeListener("key", onKey);
+    term.hideCursor(false);
+  };
+  const onKey = (name) => {
+    if (name === "CTRL_C") {
+      cleanup();
+      term("\nCanceled.\n");
+      term.processExit(0);
+    }
+  };
+  term.on("key", onKey);
+  const menuLoop = async () => {
+    const menuItems = [
+      `Provider: ${updatedConfig.provider === "ollama" ? "Ollama" : "OpenAI-compatible"}`,
+      `Base URL (OpenAI): ${formatConfigValue(updatedConfig.baseUrl)}`,
+      `Base URL (Ollama): ${formatConfigValue(updatedConfig.ollamaBaseUrl)}`,
+      `API Key: ${maskApiKey(updatedConfig.apiKey)}`,
+      `Model: ${formatConfigValue(updatedConfig.model)}`,
+      `Temperature: ${formatConfigValue(updatedConfig.temperature)}`,
+      `Max Tokens: ${formatConfigValue(updatedConfig.maxTokens)}`,
+      `Stream: ${formatConfigValue(updatedConfig.stream)}`,
+      `Request Timeout (ms): ${formatConfigValue(updatedConfig.requestTimeoutMs)}`,
+      `Default Action: ${formatConfigValue(updatedConfig.defaultAction)}`,
+      `Render Markdown: ${formatConfigValue(updatedConfig.renderMarkdown)}`,
+      `Debug Render: ${formatConfigValue(updatedConfig.debugRender)}`,
+      `Detailed Suggest: ${formatConfigValue(updatedConfig.detailedSuggest)}`,
+      "Save and exit",
+    ];
+
+    return new Promise((resolve) => {
+      term.singleColumnMenu(menuItems, { cancelable: true }, (error, response) => {
+        term("\n");
+        if (error || !response || response.canceled) {
+          resolve(false);
+          return;
+        }
+        resolve(response.selectedIndex);
+      });
+    });
+  };
+
+  while (true) {
+    const selection = await menuLoop();
+    if (selection === false) {
+      cleanup();
+      term("Config editor closed.\n");
+      break;
+    }
+
+    if (selection === 0) {
+      const provider = await selectConfigProvider(updatedConfig);
+      if (provider) {
+        setConfigValue("provider", provider);
+        updatedConfig.provider = provider;
+      }
+      continue;
+    }
+
+    if (selection === 1) {
+      const value = await promptConfigValue("OpenAI base URL", updatedConfig.baseUrl);
+      if (value !== null) {
+        setConfigValue("baseUrl", value);
+        updatedConfig.baseUrl = value;
+      }
+      continue;
+    }
+
+    if (selection === 2) {
+      const value = await promptConfigValue("Ollama base URL", updatedConfig.ollamaBaseUrl);
+      if (value !== null) {
+        setConfigValue("ollamaBaseUrl", value);
+        updatedConfig.ollamaBaseUrl = value;
+      }
+      continue;
+    }
+
+    if (selection === 3) {
+      term("API Key (leave empty to clear)\n");
+      const value = await promptConfigValue("API key", updatedConfig.apiKey);
+      if (value !== null) {
+        setConfigValue("apiKey", value);
+        updatedConfig.apiKey = value;
+      }
+      continue;
+    }
+
+    if (selection === 4) {
+      const value = await promptConfigValue("Model", updatedConfig.model);
+      if (value !== null) {
+        setConfigValue("model", value);
+        updatedConfig.model = value;
+      }
+      continue;
+    }
+
+    if (selection === 5) {
+      const value = await promptConfigValue("Temperature", updatedConfig.temperature);
+      if (value !== null) {
+        setConfigValue("temperature", value);
+        updatedConfig.temperature = value;
+      }
+      continue;
+    }
+
+    if (selection === 6) {
+      const value = await promptConfigValue("Max Tokens", updatedConfig.maxTokens);
+      if (value !== null) {
+        setConfigValue("maxTokens", value);
+        updatedConfig.maxTokens = value;
+      }
+      continue;
+    }
+
+    if (selection === 7) {
+      const value = await promptConfigValue("Stream (true/false)", updatedConfig.stream);
+      if (value !== null) {
+        setConfigValue("stream", value);
+        updatedConfig.stream = value;
+      }
+      continue;
+    }
+
+    if (selection === 8) {
+      const value = await promptConfigValue(
+        "Request timeout in ms (0 to disable)",
+        updatedConfig.requestTimeoutMs
+      );
+      if (value !== null) {
+        setConfigValue("requestTimeoutMs", value);
+        updatedConfig.requestTimeoutMs = value;
+      }
+      continue;
+    }
+
+    if (selection === 9) {
+      const value = await promptConfigValue(
+        "Default action (suggest/ask/explain)",
+        updatedConfig.defaultAction
+      );
+      if (value !== null) {
+        setConfigValue("defaultAction", value);
+        updatedConfig.defaultAction = value;
+      }
+      continue;
+    }
+
+    if (selection === 10) {
+      const value = await promptConfigValue(
+        "Render Markdown (true/false)",
+        updatedConfig.renderMarkdown
+      );
+      if (value !== null) {
+        setConfigValue("renderMarkdown", value);
+        updatedConfig.renderMarkdown = value;
+      }
+      continue;
+    }
+
+    if (selection === 11) {
+      const value = await promptConfigValue("Debug Render (true/false)", updatedConfig.debugRender);
+      if (value !== null) {
+        setConfigValue("debugRender", value);
+        updatedConfig.debugRender = value;
+      }
+      continue;
+    }
+
+    if (selection === 12) {
+      const value = await promptConfigValue(
+        "Detailed Suggest (true/false)",
+        updatedConfig.detailedSuggest
+      );
+      if (value !== null) {
+        setConfigValue("detailedSuggest", value);
+        updatedConfig.detailedSuggest = value;
+      }
+      continue;
+    }
+
+    if (selection === 13) {
+      cleanup();
+      term("Configuration saved.\n");
+      break;
+    }
+  }
+}
+
 async function runChat(config) {
   term('Interactive chat. Type "exit" to quit.\n\n');
   const messages = [];
@@ -179,6 +475,11 @@ async function runChat(config) {
     if (config.debugRender) {
       term(`\n--- RAW ---\n${reply}\n`);
     }
+    if (!reply || !reply.trim()) {
+      term(
+        "\nNo response from the model. The request may have timed out or returned empty content. Consider increasing requestTimeoutMs in the config or enabling streaming."
+      );
+    }
     term("\n\n");
     messages.push({ role: "assistant", content: reply });
   }
@@ -187,20 +488,20 @@ async function runChat(config) {
 async function runModels(config) {
   let models;
   try {
-    models = await listModels(config.baseUrl);
+    models = await listModels(config);
   } catch (err) {
     term(`Error: ${err.message}\n`);
     term.processExit(1);
   }
 
   if (!models.length) {
-    term("No models found from GPT4All server.\n");
+    term("No models found from the configured provider.\n");
     term.processExit(0);
   }
 
   term("Available models:\n");
-  // Append 'Use default gpt4all model' option at the top
-  models.unshift("Use default gpt4all setting");
+  // Append option to keep current default at the top
+  models.unshift("Keep current default");
   models.forEach((model) => term(`- ${model}\n`));
   term("\nSelect a default model (use arrows + Enter, Esc to cancel):\n");
 
@@ -231,9 +532,10 @@ async function runModels(config) {
           term.processExit(0);
         }
         let selected = models[response.selectedIndex];
-        // if user selected the default model option, set to 'gpt4all'
-        if (selected === "Use default gpt4all setting") {
-          selected = "gpt4all";
+        if (selected === "Keep current default") {
+          cleanup();
+          term(`Default model unchanged ("${config.model}").\n`);
+          term.processExit(0);
         }
         setConfigValue("model", selected);
         config.model = selected;
@@ -277,6 +579,10 @@ export async function runCli(argv) {
   }
 
   if (args[0] === "config") {
+    if (args[1] === "tui") {
+      await runConfigTui(config);
+      return;
+    }
     if (args[1] === "get" && args[2]) {
       const key = args[2];
       term(`${config[key]}\n`);
@@ -324,6 +630,17 @@ export async function runCli(argv) {
     return;
   }
 
+  if (!args[0].startsWith("-")) {
+    const prompt = args.join(" ").trim();
+    if (!prompt) {
+      term("Error: missing prompt.\n");
+      term.processExit(1);
+    }
+    const defaultAction = normalizeDefaultAction(config.defaultAction);
+    await runSinglePrompt(defaultAction, prompt, config);
+    return;
+  }
+
   term("Unknown command.\n\n");
   printHelp();
 }

package/src/config.js

@@ -3,11 +3,16 @@ import path from "path";
 import os from "os";
 
 const DEFAULT_CONFIG = {
+  provider: "openai",
   baseUrl: "http://localhost:4891",
+  ollamaBaseUrl: "http://localhost:11434",
+  apiKey: "",
   model: "gpt4all",
   temperature: 0.7,
   maxTokens: 512,
   stream: true,
+  requestTimeoutMs: 300000,
+  defaultAction: "suggest",
   renderMarkdown: true,
   debugRender: false,
   detailedSuggest: false,

package/src/gpt4all.js

@@ -1,37 +1,82 @@
-import terminalKit from 'terminal-kit';
-import { createMarkdownRenderer } from './markdown.js';
+import terminalKit from "terminal-kit";
+import { createMarkdownRenderer } from "./markdown.js";
 
 const { terminal: term } = terminalKit;
 
 function getContentDelta(chunk) {
-  if (!chunk || !chunk.choices || !chunk.choices[0]) return '';
+  if (!chunk || !chunk.choices || !chunk.choices[0]) return "";
   const choice = chunk.choices[0];
   if (choice.delta && choice.delta.content) return choice.delta.content;
   if (choice.message && choice.message.content) return choice.message.content;
   if (choice.text) return choice.text;
-  return '';
+  return "";
+}
+
+function getOllamaContentDelta(chunk) {
+  if (!chunk) return "";
+  if (chunk.message && chunk.message.content) return chunk.message.content;
+  if (chunk.response) return chunk.response;
+  return "";
+}
+
+function normalizeOpenAiBaseUrl(baseUrl) {
+  const trimmed = baseUrl.replace(/\/$/, "");
+  if (trimmed.endsWith("/v1")) return trimmed;
+  return `${trimmed}/v1`;
+}
+
+function normalizeOllamaBaseUrl(baseUrl) {
+  return baseUrl.replace(/\/$/, "");
+}
+
+function getProvider(config) {
+  return config.provider === "ollama" ? "ollama" : "openai";
+}
+
+function buildOpenAiHeaders(apiKey) {
+  const headers = { "Content-Type": "application/json" };
+  if (apiKey) {
+    headers.Authorization = `Bearer ${apiKey}`;
+  }
+  return headers;
+}
+
+function createTimeoutController(timeoutMs) {
+  if (!timeoutMs || Number.isNaN(timeoutMs) || timeoutMs <= 0) {
+    return null;
+  }
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+  return { controller, timeoutId };
 }
 
 async function parseStream(response, onToken, renderer) {
   const reader = response.body.getReader();
-  const decoder = new TextDecoder('utf-8');
-  let buffer = '';
-  let fullText = '';
-  let lineBuffer = '';
+  const decoder = new TextDecoder("utf-8");
+  let buffer = "";
+  let fullText = "";
+  let lineBuffer = "";
+  const flushLineBuffer = () => {
+    if (renderer && lineBuffer) {
+      onToken(renderer.renderLine(lineBuffer));
+      lineBuffer = "";
+    }
+  };
 
   while (true) {
     const { value, done } = await reader.read();
     if (done) break;
     buffer += decoder.decode(value, { stream: true });
 
-    const lines = buffer.split('\n');
-    buffer = lines.pop() || '';
+    const lines = buffer.split("\n");
+    buffer = lines.pop() || "";
 
     for (const line of lines) {
       const trimmed = line.trim();
-      if (!trimmed || !trimmed.startsWith('data:')) continue;
-      const payload = trimmed.replace(/^data:\s*/, '');
-      if (payload === '[DONE]') {
+      if (!trimmed || !trimmed.startsWith("data:")) continue;
+      const payload = trimmed.replace(/^data:\s*/, "");
+      if (payload === "[DONE]") {
+        flushLineBuffer();
         return fullText;
       }
 
@@ -44,8 +89,8 @@ async function parseStream(response, onToken, renderer) {
             onToken(delta);
           } else {
             lineBuffer += delta;
-            const lines = lineBuffer.split('\n');
-            lineBuffer = lines.pop() || '';
+            const lines = lineBuffer.split("\n");
+            lineBuffer = lines.pop() || "";
             for (const line of lines) {
               onToken(`${renderer.renderLine(line)}\n`);
             }
@@ -64,76 +109,168 @@ async function parseStream(response, onToken, renderer) {
   return fullText;
 }
 
-function normalizeBaseUrl(baseUrl) {
-  const trimmed = baseUrl.replace(/\/$/, '');
-  if (trimmed.endsWith('/v1')) return trimmed;
-  return `${trimmed}/v1`;
+async function parseOllamaStream(response, onToken, renderer) {
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder("utf-8");
+  let buffer = "";
+  let fullText = "";
+  let lineBuffer = "";
+  const flushLineBuffer = () => {
+    if (renderer && lineBuffer) {
+      onToken(renderer.renderLine(lineBuffer));
+      lineBuffer = "";
+    }
+  };
+
+  while (true) {
+    const { value, done } = await reader.read();
+    if (done) break;
+    buffer += decoder.decode(value, { stream: true });
+
+    const lines = buffer.split("\n");
+    buffer = lines.pop() || "";
+
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      try {
+        const json = JSON.parse(trimmed);
+        if (json.done) {
+          flushLineBuffer();
+          return fullText;
+        }
+        const delta = getOllamaContentDelta(json);
+        if (delta) {
+          fullText += delta;
+          if (!renderer) {
+            onToken(delta);
+          } else {
+            lineBuffer += delta;
+            const lines = lineBuffer.split("\n");
+            lineBuffer = lines.pop() || "";
+            for (const line of lines) {
+              onToken(`${renderer.renderLine(line)}\n`);
+            }
+          }
+        }
+      } catch (err) {
+        // Ignore non-JSON payloads
+      }
+    }
+  }
+
+  if (renderer && lineBuffer) {
+    onToken(renderer.renderLine(lineBuffer));
+  }
+
+  return fullText;
 }
 
-async function fetchJson(url, payload) {
+async function fetchJson(url, payload, errorLabel, timeoutMs) {
+  const timeout = createTimeoutController(timeoutMs);
   try {
-    const response = await fetch(url, payload);
+    const response = await fetch(url, {
+      ...payload,
+      signal: timeout ? timeout.controller.signal : undefined,
+    });
     if (!response.ok) {
       const text = await response.text();
-      throw new Error(`GPT4All error ${response.status}: ${text}`);
+      throw new Error(`${errorLabel} error ${response.status}: ${text}`);
     }
     return await response.json();
   } catch (err) {
-    if (err.message && err.message.startsWith('GPT4All error')) {
+    if (err.message && err.message.startsWith(`${errorLabel} error`)) {
       throw err;
     }
-    throw new Error(`Failed to connect to ${url}. Is GPT4All running and reachable? (${err.message})`);
+    if (err.name === "AbortError") {
+      throw new Error(
+        `${errorLabel} request timed out after ${timeoutMs}ms. Increase requestTimeoutMs in config if needed.`
+      );
+    }
+    throw new Error(`Failed to connect to ${url}. (${err.message})`);
+  } finally {
+    if (timeout) {
+      clearTimeout(timeout.timeoutId);
+    }
   }
 }
 
-export async function listModels(baseUrl) {
-  const url = `${normalizeBaseUrl(baseUrl)}/models`;
-  const json = await fetchJson(url, { method: 'GET' });
-  if (!json || !Array.isArray(json.data)) return [];
-  return json.data.map((model) => model.id).filter(Boolean);
-}
-
-async function fetchCompletion(url, payload) {
+async function fetchCompletion(url, payload, headers, errorLabel, timeoutMs) {
+  const timeout = createTimeoutController(timeoutMs);
   try {
     return await fetch(url, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify(payload)
+      method: "POST",
+      headers,
+      body: JSON.stringify(payload),
+      signal: timeout ? timeout.controller.signal : undefined,
     });
   } catch (err) {
-    throw new Error(`Failed to connect to ${url}. Is GPT4All running and reachable? (${err.message})`);
+    if (err.name === "AbortError") {
+      throw new Error(
+        `${errorLabel} request timed out after ${timeoutMs}ms. Increase requestTimeoutMs in config if needed.`
+      );
+    }
+    throw new Error(`Failed to connect to ${url}. (${err.message})`);
+  } finally {
+    if (timeout) {
+      clearTimeout(timeout.timeoutId);
+    }
   }
 }
 
-async function handleError(response) {
+async function handleError(response, errorLabel) {
   const text = await response.text();
-  throw new Error(`GPT4All error ${response.status}: ${text}`);
+  throw new Error(`${errorLabel} error ${response.status}: ${text}`);
+}
+
+export async function listModels(config) {
+  const provider = getProvider(config);
+  const timeoutMs = Number(config.requestTimeoutMs);
+  if (provider === "ollama") {
+    const baseUrl = normalizeOllamaBaseUrl(config.ollamaBaseUrl);
+    const url = `${baseUrl}/api/tags`;
+    const json = await fetchJson(url, { method: "GET" }, "Ollama", timeoutMs);
+    if (!json || !Array.isArray(json.models)) return [];
+    return json.models.map((model) => model.name).filter(Boolean);
+  }
+
+  const url = `${normalizeOpenAiBaseUrl(config.baseUrl)}/models`;
+  const headers = buildOpenAiHeaders(config.apiKey);
+  const json = await fetchJson(url, { method: "GET", headers }, "OpenAI", timeoutMs);
+  if (!json || !Array.isArray(json.data)) return [];
+  return json.data.map((model) => model.id).filter(Boolean);
 }
 
-export async function chatCompletion(
-  { baseUrl, model, temperature, maxTokens, stream, renderMarkdown, markdownStyles },
-  messages
-) {
-  const url = `${normalizeBaseUrl(baseUrl)}/chat/completions`;
+async function openAiChatCompletion(config, messages) {
+  const url = `${normalizeOpenAiBaseUrl(config.baseUrl)}/chat/completions`;
+  const timeoutMs = Number(config.requestTimeoutMs);
   const payload = {
-    model,
+    model: config.model,
     messages,
-    temperature,
-    max_tokens: maxTokens,
-    stream: Boolean(stream)
+    temperature: config.temperature,
+    max_tokens: config.maxTokens,
+    stream: Boolean(config.stream),
   };
 
-  let response = await fetchCompletion(url, payload);
+  const headers = buildOpenAiHeaders(config.apiKey);
+  let response = await fetchCompletion(url, payload, headers, "OpenAI", timeoutMs);
 
-  const renderer = renderMarkdown ? createMarkdownRenderer(markdownStyles) : null;
+  const renderer = config.renderMarkdown
+    ? createMarkdownRenderer(config.markdownStyles)
+    : null;
 
   if (!response.ok) {
     const text = await response.text();
-    if (stream && response.status === 400 && text.includes('stream') && text.includes('not supported')) {
+    if (
+      config.stream &&
+      response.status === 400 &&
+      text.includes("stream") &&
+      text.includes("not supported")
+    ) {
       const retryPayload = { ...payload, stream: false };
-      response = await fetchCompletion(url, retryPayload);
+      response = await fetchCompletion(url, retryPayload, headers, "OpenAI", timeoutMs);
       if (!response.ok) {
-        await handleError(response);
+        await handleError(response, "OpenAI");
       }
       const json = await response.json();
       const content = getContentDelta(json);
@@ -145,19 +282,19 @@ export async function chatCompletion(
       return content;
     }
 
-    throw new Error(`GPT4All error ${response.status}: ${text}`);
+    throw new Error(`OpenAI error ${response.status}: ${text}`);
   }
 
-  if (stream) {
-    const contentType = response.headers.get('content-type') || '';
-    if (contentType.includes('text/event-stream')) {
+  if (config.stream) {
+    const contentType = response.headers.get("content-type") || "";
+    if (contentType.includes("text/event-stream")) {
       return parseStream(response, (chunk) => term(chunk), renderer);
     }
   }
 
   const json = await response.json();
   const content = getContentDelta(json);
-  if (stream) {
+  if (config.stream) {
     if (renderer) {
       term(renderer.renderText(content));
     } else {
@@ -166,3 +303,56 @@ export async function chatCompletion(
   }
   return content;
 }
+
+async function ollamaChatCompletion(config, messages) {
+  const baseUrl = normalizeOllamaBaseUrl(config.ollamaBaseUrl);
+  const url = `${baseUrl}/api/chat`;
+  const timeoutMs = Number(config.requestTimeoutMs);
+  const payload = {
+    model: config.model,
+    messages,
+    stream: Boolean(config.stream),
+    options: {
+      temperature: config.temperature,
+      num_predict: config.maxTokens,
+    },
+  };
+
+  const renderer = config.renderMarkdown
+    ? createMarkdownRenderer(config.markdownStyles)
+    : null;
+  const response = await fetchCompletion(
+    url,
+    payload,
+    { "Content-Type": "application/json" },
+    "Ollama",
+    timeoutMs
+  );
+
+  if (!response.ok) {
+    await handleError(response, "Ollama");
+  }
+
+  if (config.stream) {
+    return parseOllamaStream(response, (chunk) => term(chunk), renderer);
+  }
+
+  const json = await response.json();
+  const content = getOllamaContentDelta(json);
+  if (config.stream) {
+    if (renderer) {
+      term(renderer.renderText(content));
+    } else {
+      term(content);
+    }
+  }
+  return content;
+}
+
+export async function chatCompletion(config, messages) {
+  const provider = getProvider(config);
+  if (provider === "ollama") {
+    return ollamaChatCompletion(config, messages);
+  }
+  return openAiChatCompletion(config, messages);
+}