friend-assistant 0.1.3 → 0.1.5

package/README.md

@@ -127,10 +127,11 @@ Connectors (Gmail, Chrome control, any MCP service) are managed inside the app,
 
 | Key | What it is |
 |---|---|
-| `provider` | Which model answers: `claude` (API key), `claude-code` (your subscription) or `ollama` (this PC). |
+| `provider` | Which model answers: `claude` (API key), `claude-code` (your subscription), `ollama` (this PC) or `openai` (any OpenAI-compatible server, such as OmniRoute). |
 | `apiKey`, `model` | The Anthropic API key and the Claude model used with it. |
 | `claudeCode.model`, `claudeCode.command`, `claudeCode.fallback` | The subscription route: model (`sonnet`, `haiku`, `opus`), the command that starts Claude Code, and `ollama` or `none` for what to use when Claude is unavailable. |
 | `ollama.url`, `ollama.model`, `ollama.vision`, `ollama.contextTokens` | The local model: server address, model name, whether it can see pictures, and how much it remembers at once. |
+| `openai.url`, `openai.model`, `openai.apiKey`, `openai.vision` | An OpenAI-compatible server: its address (ending in `/v1`), the model name it knows, its API key (or empty), and whether the model can see pictures. For OmniRoute (https://github.com/diegosouzapw/OmniRoute) run `npm install -g omniroute` and `omniroute`, then `friend config set provider openai` (the defaults are OmniRoute's: `http://localhost:20128/v1` and model `auto`). Also works with LM Studio, LiteLLM, vLLM and OpenRouter. |
 | `voice.enabled`, `voice.sttModel`, `voice.ttsVoice`, `voice.language`, `voice.speakTyped`, `voice.accept`, `voice.challenge` | Speech on or off, the listening model, the speaking voice, a forced language, speaking typed replies, and the two thresholds for recognising your voice. |
 | `bind`, `port` | Where Friend listens (easier: `friend lan`). |
 | `https` | `true` serves a secure `https://` address with a certificate Friend makes for itself, so a phone may use the microphone (easier: `friend lan https on`). |

package/dist/BUILD.json

@@ -1,5 +1,5 @@
 {
   "name": "friend-assistant",
-  "version": "0.1.3",
-  "builtAt": "2026-10-09T05:15:27.134Z"
+  "version": "0.1.5",
+  "builtAt": "2026-10-09T06:20:45.511Z"
 }

package/dist/friend.mjs

@@ -3263,6 +3263,7 @@ import { join as join12 } from "node:path";
 import { chmodSync as chmodSync3, existsSync as existsSync5, mkdirSync as mkdirSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync4 } from "node:fs";
 import { homedir as homedir2 } from "node:os";
 import { join as join8 } from "node:path";
+var DEFAULT_OPENAI = { url: "http://localhost:20128/v1", model: "auto", apiKey: null, vision: false };
 var DEFAULT_CLAUDE_CODE = { model: "sonnet", command: "claude", fallback: "ollama" };
 function sanitizeClaudeCode(raw) {
   const r = raw && typeof raw === "object" ? raw : {};
@@ -3351,6 +3352,7 @@ var defaults = (dataDir) => ({
   apiKey: null,
   provider: "claude",
   ollama: { ...DEFAULT_OLLAMA },
+  openai: { ...DEFAULT_OPENAI },
   claudeCode: { ...DEFAULT_CLAUDE_CODE },
   voice: { ...DEFAULT_VOICE },
   view: "companion",
@@ -3386,6 +3388,7 @@ function loadConfig(dataDir = defaultDataDir()) {
     https: stored.https === true,
     destructivePatterns,
     ollama: { ...DEFAULT_OLLAMA, ...stored.ollama },
+    openai: { ...DEFAULT_OPENAI, ...stored.openai },
     claudeCode: sanitizeClaudeCode(stored.claudeCode),
     voice: sanitizeVoice({ ...DEFAULT_VOICE, ...stored.voice }),
     view: stored.view === "minimal" || stored.view === "workspace" ? stored.view : "companion",
@@ -4991,7 +4994,7 @@ import { z as z11 } from "zod";
 var word = /^[\w.:/\\-]+$/;
 var modelName = z11.string().trim().min(1).max(100).regex(/^[A-Za-z0-9][\w.:/-]*$/, "A model name has no spaces");
 var SettingsPatch = z11.object({
-  provider: z11.enum(["claude", "claude-code", "ollama"]),
+  provider: z11.enum(["claude", "claude-code", "ollama", "openai"]),
   model: modelName,
   /** Empty means "leave the saved key alone". */
   apiKey: z11.string().trim().max(400),
@@ -5013,6 +5016,13 @@ var SettingsPatch = z11.object({
     vision: z11.boolean(),
     contextTokens: z11.number().int().min(1024).max(131072)
   }).partial().strict(),
+  openai: z11.object({
+    url: z11.string().trim().max(300),
+    model: modelName,
+    /** Empty means "leave the saved key alone". */
+    apiKey: z11.string().trim().max(400),
+    vision: z11.boolean()
+  }).partial().strict(),
   claudeCode: z11.object({
     model: modelName,
     command: z11.string().trim().min(1).max(260).regex(word, "The command is one word or path without spaces"),
@@ -5036,6 +5046,7 @@ function settingsView(c) {
     view: c.view,
     look: { ...c.look },
     ollama: { url: c.ollama.url, model: c.ollama.model, vision: !!c.ollama.vision, contextTokens: c.ollama.contextTokens },
+    openai: { url: c.openai.url, model: c.openai.model, vision: !!c.openai.vision, apiKeySet: !!c.openai.apiKey },
     claudeCode: { ...c.claudeCode },
     voice: {
       enabled: c.voice.enabled,
@@ -5053,10 +5064,11 @@ var SettingsError = class extends Error {
 function refuseForAgent(raw) {
   const r = raw && typeof raw === "object" ? raw : {};
   const cc = r.claudeCode && typeof r.claudeCode === "object" ? r.claudeCode : {};
-  if ("apiKey" in r) throw new SettingsError("The API key can only be changed by the owner on the settings screen.");
+  const oa = r.openai && typeof r.openai === "object" ? r.openai : {};
+  if ("apiKey" in r || "apiKey" in oa) throw new SettingsError("The API key can only be changed by the owner on the settings screen.");
   if ("command" in cc) throw new SettingsError("The Claude Code command can only be changed by the owner on the settings screen.");
 }
-var PROVIDER_KEYS = /* @__PURE__ */ new Set(["provider", "model", "apiKey", "ollama", "claudeCode"]);
+var PROVIDER_KEYS = /* @__PURE__ */ new Set(["provider", "model", "apiKey", "ollama", "openai", "claudeCode"]);
 var RESTART_VOICE = ["enabled", "sttModel"];
 function applySettings(config, raw) {
   const parsed = SettingsPatch.safeParse(raw);
@@ -5076,6 +5088,17 @@ function applySettings(config, raw) {
     if (u.protocol !== "http:" && u.protocol !== "https:") throw new SettingsError("ollama.url: The URL must start with http:// or https://");
     p.ollama.url = u.origin;
   }
+  const openaiUrl = p.openai?.url;
+  if (openaiUrl !== void 0) {
+    let u;
+    try {
+      u = new URL(openaiUrl);
+    } catch {
+      throw new SettingsError("openai.url: Expected a URL such as http://localhost:20128/v1");
+    }
+    if (u.protocol !== "http:" && u.protocol !== "https:") throw new SettingsError("openai.url: The URL must start with http:// or https://");
+    p.openai.url = (u.origin + u.pathname).replace(/\/+$/, "");
+  }
   const next = {
     provider: p.provider ?? config.provider,
     apiKey: p.apiKey ? p.apiKey : config.apiKey,
@@ -5098,6 +5121,11 @@ function applySettings(config, raw) {
   if (p.model) config.model = p.model;
   if (p.apiKey) config.apiKey = p.apiKey;
   if (p.ollama) Object.assign(config.ollama, p.ollama);
+  if (p.openai) {
+    const { apiKey, ...rest } = p.openai;
+    Object.assign(config.openai, rest);
+    if (apiKey) config.openai.apiKey = apiKey;
+  }
   if (p.claudeCode) Object.assign(config.claudeCode, p.claudeCode);
   if (p.voice) {
     const safe = next.voice;
@@ -5282,6 +5310,173 @@ var OllamaProvider = class {
   }
 };
 
+// ../server/src/provider/openai.ts
+import { Agent as Agent3, fetch as undiciFetch2 } from "undici";
+var encodeName3 = (n) => n.replaceAll(".", "__");
+var decodeName3 = (n) => n.replaceAll("__", ".");
+function toOpenAiMessages(system, messages, vision) {
+  const out = [{ role: "system", content: system }];
+  for (const m of messages) {
+    if (m.role === "user") {
+      out.push({ role: "user", content: m.content.map((b) => b.type === "text" ? b.text : "").join("\n") });
+    } else if (m.role === "assistant") {
+      const text2 = m.content.map((b) => b.type === "text" ? b.text : "").join("");
+      const calls = m.content.filter((b) => b.type === "tool_use");
+      out.push({
+        role: "assistant",
+        content: text2 || null,
+        ...calls.length ? { tool_calls: calls.map((c) => ({ id: c.id, type: "function", function: { name: encodeName3(c.name), arguments: JSON.stringify(c.input ?? {}) } })) } : {}
+      });
+    } else {
+      for (const b of m.content) if (b.type === "tool_result") out.push({ role: "tool", tool_call_id: b.toolUseId, content: b.content });
+      const pictures = vision ? m.content.flatMap((b) => b.type === "image" ? [`data:${b.mime};base64,${b.data}`] : []) : [];
+      if (pictures.length) out.push({ role: "user", content: [{ type: "text", text: "Here is the picture from the camera." }, ...pictures.map((url) => ({ type: "image_url", image_url: { url } }))] });
+    }
+  }
+  return out;
+}
+function parseArgs2(raw) {
+  if (!raw.trim()) return {};
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+var OpenAiProvider = class {
+  constructor(opts) {
+    this.opts = opts;
+    const limit = opts.timeoutMs && opts.timeoutMs > 0 ? opts.timeoutMs : 0;
+    this.agent = new Agent3({ headersTimeout: limit, bodyTimeout: limit });
+  }
+  opts;
+  id = "openai";
+  agent;
+  get vision() {
+    return this.opts.vision === true;
+  }
+  async *stream(req) {
+    const base = this.opts.url.replace(/\/+$/, "");
+    const body = {
+      model: this.opts.model,
+      stream: true,
+      stream_options: { include_usage: true },
+      messages: [
+        ...toOpenAiMessages(req.system, req.messages, this.vision),
+        // last of all, so every message before it stays identical between requests and a gateway can reuse its cache of them
+        ...req.context ? [{ role: "user", content: req.context }] : []
+      ],
+      ...req.tools.length ? { tools: req.tools.map((t) => ({ type: "function", function: { name: encodeName3(t.name), description: t.description, parameters: t.inputSchema } })) } : {}
+    };
+    let res;
+    try {
+      res = await undiciFetch2(`${base}/chat/completions`, {
+        method: "POST",
+        headers: { "content-type": "application/json", ...this.opts.apiKey ? { authorization: `Bearer ${this.opts.apiKey}` } : {} },
+        body: JSON.stringify(body),
+        signal: req.signal,
+        dispatcher: this.agent
+      });
+    } catch (e) {
+      if (req.signal.aborted) return;
+      const code = e.cause?.code ?? "";
+      if (code === "UND_ERR_HEADERS_TIMEOUT" || code === "UND_ERR_BODY_TIMEOUT") {
+        yield { type: "error", userFacing: true, message: "The model took too long to answer. Try again, or choose a faster model." };
+        return;
+      }
+      yield { type: "error", userFacing: true, message: `I can't reach the model server at ${base}. Is it running? Check the address in Settings.` };
+      return;
+    }
+    if (!res.ok) {
+      let detail = "";
+      try {
+        const j = await res.json();
+        detail = typeof j.error === "string" ? j.error : j.error?.message ?? "";
+      } catch {
+      }
+      if (res.status === 401 || res.status === 403) yield { type: "error", userFacing: true, message: "The model server refused the API key. Check it in Settings." };
+      else if (res.status === 404) yield { type: "error", userFacing: true, message: `The model server has no "${this.opts.model}", or the address is wrong (it should end in /v1). ${detail}`.trim() };
+      else if (res.status === 429) yield { type: "error", userFacing: true, message: "The model server says too many requests or the limit is used up. Try again in a moment." };
+      else yield { type: "error", message: `Model server error (${res.status})${detail ? `: ${detail}` : ""}` };
+      return;
+    }
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let finished = false;
+    const calls = /* @__PURE__ */ new Map();
+    let usage = null;
+    const flush = function* () {
+      for (const [, c] of [...calls.entries()].sort((a, b) => a[0] - b[0])) {
+        if (c.name) yield { type: "tool_call", id: c.id || `openai-${Date.now().toString(36)}-${c.name}`, name: decodeName3(c.name), args: parseArgs2(c.args) };
+      }
+      calls.clear();
+    };
+    const handle = function* (line) {
+      const text2 = line.trim();
+      if (!text2.startsWith("data:")) return;
+      const data = text2.slice(5).trim();
+      if (data === "[DONE]") {
+        yield* flush();
+        if (usage) yield { type: "usage", ...usage };
+        yield { type: "done" };
+        finished = true;
+        return;
+      }
+      let obj;
+      try {
+        obj = JSON.parse(data);
+      } catch {
+        return;
+      }
+      if (obj.error) {
+        yield { type: "error", message: `Model server error: ${typeof obj.error === "string" ? obj.error : obj.error.message ?? "unknown"}` };
+        finished = true;
+        return;
+      }
+      if (obj.usage) usage = { input: obj.usage.prompt_tokens ?? 0, output: obj.usage.completion_tokens ?? 0 };
+      for (const choice of obj.choices ?? []) {
+        const delta = choice.delta ?? {};
+        if (typeof delta.content === "string" && delta.content) yield { type: "text_delta", text: delta.content };
+        for (const tc of delta.tool_calls ?? []) {
+          const i = typeof tc.index === "number" ? tc.index : 0;
+          const cur = calls.get(i) ?? { id: "", name: "", args: "" };
+          if (tc.id) cur.id = tc.id;
+          if (tc.function?.name) cur.name += tc.function.name;
+          if (typeof tc.function?.arguments === "string") cur.args += tc.function.arguments;
+          calls.set(i, cur);
+        }
+      }
+    };
+    try {
+      while (!finished) {
+        const { value, done } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        let nl;
+        while (!finished && (nl = buffer.indexOf("\n")) >= 0) {
+          const line = buffer.slice(0, nl);
+          buffer = buffer.slice(nl + 1);
+          yield* handle(line);
+        }
+      }
+      if (!finished && buffer.trim()) yield* handle(buffer);
+      if (!finished) {
+        yield* flush();
+        const u = usage;
+        if (u) yield { type: "usage", input: u.input, output: u.output };
+        yield { type: "done" };
+      }
+    } catch (e) {
+      if (req.signal.aborted) return;
+      yield { type: "error", message: `Lost the connection to the model server: ${e.message}` };
+    } finally {
+      reader.cancel().catch(() => {
+      });
+    }
+  }
+};
+
 // ../server/src/tls.ts
 import { chmodSync as chmodSync5, existsSync as existsSync8, mkdirSync as mkdirSync7, readFileSync as readFileSync5, writeFileSync as writeFileSync6 } from "node:fs";
 import { networkInterfaces } from "node:os";
@@ -5826,6 +6021,7 @@ async function createApp(opts) {
       return config.claudeCode.fallback === "ollama" ? new FallbackProvider(cc, new OllamaProvider({ ...config.ollama }), (reason) => tellFallback(reason)) : cc;
     }
     if (config.provider === "ollama") return new OllamaProvider({ ...config.ollama });
+    if (config.provider === "openai") return new OpenAiProvider({ ...config.openai });
     return config.apiKey ? new ClaudeProvider({ apiKey: config.apiKey, model: config.model }) : new MissingKeyProvider();
   };
   const switchable = opts.provider ? null : new SwitchableProvider(makeProvider());
@@ -6529,7 +6725,7 @@ var PARSERS = {
     return n;
   },
   provider: (v) => {
-    if (v !== "claude" && v !== "ollama" && v !== "claude-code") throw new Error("Provider must be claude, ollama or claude-code");
+    if (v !== "claude" && v !== "ollama" && v !== "claude-code" && v !== "openai") throw new Error("Provider must be claude, ollama, claude-code or openai");
     return v;
   },
   roots: list,
@@ -6558,6 +6754,24 @@ var GROUPS = {
       return v;
     }
   },
+  openai: {
+    url: (v) => {
+      let u;
+      try {
+        u = new URL(v.trim());
+      } catch {
+        throw new Error("Expected a URL that ends in /v1, such as http://localhost:20128/v1");
+      }
+      if (u.protocol !== "http:" && u.protocol !== "https:") throw new Error("The URL must start with http:// or https://");
+      return (u.origin + u.pathname).replace(/\/+$/, "");
+    },
+    model: (v) => {
+      if (!/^[A-Za-z0-9][\w.:/-]*$/.test(v.trim())) throw new Error("Expected a model name without spaces, such as auto");
+      return v.trim();
+    },
+    apiKey: (v) => v.trim() === "" ? null : v.trim(),
+    vision: bool
+  },
   ollama: {
     url: httpUrl,
     model: nonEmpty,
@@ -6572,7 +6786,7 @@ var GROUPS = {
 var KEY_HELP = {
   apiKey: 'Anthropic API key, used when the model is "claude"',
   model: "Claude model name, used with the API key",
-  provider: "which model answers: claude (API key), claude-code (your Claude subscription) or ollama (on this PC)",
+  provider: "which model answers: claude (API key), claude-code (your Claude subscription), ollama (on this PC) or openai (any OpenAI-compatible server, such as OmniRoute)",
   bind: "address Friend listens on: 127.0.0.1 is this PC only, 0.0.0.0 is your whole network (easier: friend lan on)",
   port: "the web port (easier: friend lan port N)",
   https: "true serves a secure https:// address (Friend makes its own certificate), so a phone may use the microphone (easier: friend lan https on)",
@@ -6592,6 +6806,10 @@ var KEY_HELP = {
   "ollama.model": "the local model, for example qwen2.5:7b",
   "ollama.vision": "true or false: the local model can look at pictures",
   "ollama.contextTokens": "how much the local model remembers at once (1024 to 131072)",
+  "openai.url": "address of an OpenAI-compatible server, ending in /v1; OmniRoute is http://localhost:20128/v1",
+  "openai.model": "the model name that server knows; OmniRoute answers to auto",
+  "openai.apiKey": "the server's API key, or empty when it asks for none (stored in your private config file)",
+  "openai.vision": "true or false: that model can look at pictures",
   "claudeCode.model": "model for your Claude subscription: sonnet, haiku, opus or a full name",
   "claudeCode.command": "the command that starts Claude Code, if it is not on the PATH",
   "claudeCode.fallback": "ollama or none: what to use when Claude is unavailable"
@@ -8348,7 +8566,7 @@ async function model(c) {
     io2.out("No model is ready yet. Finish one of: `friend claude setup --use`, `friend ollama setup --use`, or `friend config set apiKey <key>`.");
     return "later";
   }
-  io2.out(`Friend will think with: ${cfg.provider === "claude-code" ? `Claude (${cfg.claudeCode.model}) through your subscription${cfg.claudeCode.fallback === "ollama" ? ", with the local model as a safety net" : ""}` : cfg.provider === "claude" ? "Claude with your API key" : `${cfg.ollama.model} on this PC`}.`);
+  io2.out(`Friend will think with: ${cfg.provider === "claude-code" ? `Claude (${cfg.claudeCode.model}) through your subscription${cfg.claudeCode.fallback === "ollama" ? ", with the local model as a safety net" : ""}` : cfg.provider === "claude" ? "Claude with your API key" : cfg.provider === "openai" ? `${cfg.openai.model} through ${cfg.openai.url}` : `${cfg.ollama.model} on this PC`}.`);
   return "done";
 }
 async function voice(c) {
@@ -8463,7 +8681,7 @@ function summary(cfg, c) {
   }
   return [
     `  Assistant:  ${owner}`,
-    `  Thinks with: ${cfg.provider === "claude-code" ? `Claude (${cfg.claudeCode.model}), your subscription` : cfg.provider === "claude" ? cfg.apiKey ? "Claude, API key" : "Claude, API key missing" : `${cfg.ollama.model} on this PC`}`,
+    `  Thinks with: ${cfg.provider === "claude-code" ? `Claude (${cfg.claudeCode.model}), your subscription` : cfg.provider === "claude" ? cfg.apiKey ? "Claude, API key" : "Claude, API key missing" : cfg.provider === "openai" ? `${cfg.openai.model} through ${cfg.openai.url}` : `${cfg.ollama.model} on this PC`}`,
     `  Voice:      ${has(c, "voice") ? voiceLabel(cfg.voice.ttsVoice) : "off"}`,
     `  Workspace:  ${cfg.roots[0] ?? "none (every file action asks)"}`,
     `  Address:    ${u.local}${u.network.length ? ` and ${u.network.join(", ")}` : ""}`,
@@ -8874,7 +9092,7 @@ var USAGE4 = `Usage: friend <command>
   node --url <ws-url> --code <code> [--roots a,b] [--name pc]
                              connect this PC to a Friend gateway
   ollama setup|status        use a local model through Ollama (no API key needed)
-  lan status|on|off|port N   let other devices on your network open Friend, or change the port (restart to apply)
+  lan status|on|off|port N|https on|off  let other devices on your network open Friend, change the port, or turn on the secure (https) address a phone needs for the microphone (restart to apply)
   claude setup|status        use your Claude subscription through Claude Code (no API key needed)
   voice setup|list|status|forget  install local speech and choose a female or male voice; check it; forget deletes your saved voice
   memory list|forget <n>|clear  see and delete the notes Friend keeps about you
@@ -8908,10 +9126,15 @@ async function run(argv, io2) {
         return await onboardCommand(rest, io2);
       case "doctor":
         return await doctorCommand(io2);
+      case "help":
+      case "--help":
+      case "-h":
+        io2.out(USAGE4);
+        return 0;
       case "version":
       case "--version":
       case "-v":
-        io2.out(true ? "0.1.3" : "development");
+        io2.out(true ? "0.1.5" : "development");
         return 0;
       case "lan":
         return await lanCommand(rest, io2);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "friend-assistant",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "A self-hosted personal AI assistant for your own PC: a full-screen stage, voice, tools with your approval, and your Claude subscription or a local model.",
   "keywords": ["ai", "assistant", "jarvis", "voice", "claude", "ollama", "mcp", "self-hosted"],
   "license": "UNLICENSED",