@almightygpt/core 0.10.1 → 0.11.1

package/src/auth/validator.ts

@@ -72,6 +72,20 @@ export async function validateKey(
       case "google":
         result = await validateGoogle(key);
         break;
+      case "openrouter":
+        result = await validateOpenRouter(key);
+        break;
+      case "ollama":
+        // Ollama has no key — "validation" means probing the local
+        // daemon. The key arg is ignored.
+        result = await validateOllama();
+        break;
+      default: {
+        // Exhaustiveness check — TypeScript will error here if a new
+        // ProviderId is added without a switch case.
+        const _exhaustive: never = provider;
+        throw new Error(`Unknown provider: ${String(_exhaustive)}`);
+      }
     }
     result.latencyMs = Date.now() - start;
     return result;
@@ -187,6 +201,105 @@ async function validateGoogle(key: string): Promise<ValidationResult> {
   }
 }
 
+async function validateOpenRouter(key: string): Promise<ValidationResult> {
+  // OpenRouter is OpenAI-compatible at https://openrouter.ai/api/v1.
+  // Same chat-completions shape — point fetch at OR's base URL.
+  const model = DEFAULT_MODELS.openrouter;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), VALIDATION_TIMEOUT_MS);
+  try {
+    const res = await fetch("https://openrouter.ai/api/v1/chat/completions", {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        authorization: `Bearer ${key}`,
+        "HTTP-Referer": "https://github.com/roxjayanath/almightygpt",
+        "X-Title": "AlmightyGPT validation",
+      },
+      body: JSON.stringify({
+        model,
+        messages: [{ role: "user", content: "hi" }],
+        max_tokens: 1,
+      }),
+      signal: controller.signal,
+    });
+    if (!res.ok) {
+      const rawBody = await res.text().catch(() => "");
+      return {
+        ok: false,
+        statusCode: res.status,
+        error: normalizeOpenRouterError(res.status, rawBody, key),
+        rawBody,
+      };
+    }
+    const data = (await res.json()) as { model?: string };
+    return { ok: true, model: data.model ?? model };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+async function validateOllama(): Promise<ValidationResult> {
+  // v0.12.1 (per Codex P2 #3): probe /api/tags AND check the
+  // configured default model is installed. Previously this only
+  // verified the daemon was running — users would see "valid" then
+  // their first review would fail because llama3.3:70b was never
+  // pulled. For a local-first provider, that's the wrong first
+  // impression.
+  const baseUrl = process.env["OLLAMA_BASE_URL"] ?? "http://localhost:11434";
+  const probeUrl = baseUrl.replace(/\/v1\/?$/, "") + "/api/tags";
+  const expectedModel = DEFAULT_MODELS.ollama;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), 3000);
+  try {
+    const res = await fetch(probeUrl, { signal: controller.signal });
+    if (!res.ok) {
+      return {
+        ok: false,
+        statusCode: res.status,
+        error: `[${res.status}] Ollama daemon at ${baseUrl} responded with an error.`,
+      };
+    }
+    // Parse the model list — shape is { models: [{ name: string, ... }] }.
+    const data = (await res.json()) as { models?: Array<{ name?: string }> };
+    const installed = (data.models ?? [])
+      .map((m) => m.name)
+      .filter((n): n is string => typeof n === "string");
+
+    // Match strategy: exact name match, OR base-name match (e.g. the
+    // default "llama3.3:70b" should also be considered installed if
+    // the user only has "llama3.3:latest" or another tag of the same
+    // base model — close enough for "did you pull this family?").
+    const expectedBase = expectedModel.split(":")[0] ?? expectedModel;
+    const hasExact = installed.includes(expectedModel);
+    const hasBase = installed.some((n) => n.split(":")[0] === expectedBase);
+    if (!hasExact && !hasBase) {
+      return {
+        ok: false,
+        error:
+          `Ollama daemon at ${baseUrl} is running, but the configured ` +
+          `default model "${expectedModel}" is not installed locally. ` +
+          `Pull it first:  ollama pull ${expectedModel}` +
+          (installed.length > 0
+            ? `\n(Installed models: ${installed.slice(0, 5).join(", ")}${installed.length > 5 ? "…" : ""})`
+            : "\n(No models installed yet.)"),
+      };
+    }
+
+    return { ok: true, model: expectedModel };
+  } catch (err) {
+    return {
+      ok: false,
+      error:
+        `Ollama daemon unreachable at ${baseUrl}. Is Ollama installed ` +
+        `and running? Try \`ollama serve\` or open the Ollama app.`,
+      rawBody: err instanceof Error ? err.message : String(err),
+    };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
 // ─── Error normalization (Codex v0.8 P2 #6) ──────────────────────────
 //
 // Parse known provider JSON error shapes into short, user-safe messages.
@@ -258,6 +371,28 @@ function redactKey(msg: string, key: string): string {
   return msg.split(key).join("<redacted-key>");
 }
 
+function normalizeOpenRouterError(
+  status: number,
+  rawBody: string,
+  submittedKey: string,
+): string {
+  // OpenRouter forwards provider errors but wraps them; shape is
+  // typically { "error": { "message": "...", "code": N } }.
+  try {
+    const parsed = JSON.parse(rawBody) as {
+      error?: { message?: string; code?: number };
+    };
+    let msg = parsed.error?.message ?? "";
+    if (submittedKey && msg.includes(submittedKey)) {
+      msg = msg.replace(submittedKey, "<redacted-key>");
+    }
+    if (msg) return `[${status}] OpenRouter: ${truncate(msg, 200)}`;
+  } catch {
+    /* fall through */
+  }
+  return statusOnlyMessage("OpenRouter", status);
+}
+
 function statusOnlyMessage(provider: string, status: number): string {
   if (status === 401 || status === 403) {
     return `[${status}] ${provider} rejected the key (unauthorized).`;

package/src/config/schema.ts

@@ -13,7 +13,14 @@ export const AgentRoleSchema = z.enum(["worker", "reviewer", "both", "optional"]
 export const AgentConfigSchema = z
   .object({
     enabled: z.boolean().default(true),
-    provider: z.enum(["openai", "anthropic", "google", "mock"]),
+    provider: z.enum([
+      "openai",
+      "anthropic",
+      "google",
+      "openrouter",
+      "ollama",
+      "mock",
+    ]),
     mode: z.enum(["api", "cli"]).default("api"),
     role: AgentRoleSchema.default("optional"),
     memoryFile: z.string().min(1),

package/src/index.ts

@@ -13,7 +13,7 @@
  *   - budget/     ✅ task #14 BudgetTracker + BudgetExceededError
  */
 
-export const VERSION = "0.10.1";
+export const VERSION = "0.11.1";
 
 // MCP server (v0.9.0+) — exposes AlmightyGPT's review surface as MCP tools.
 export { startMcpServer } from "./mcp/server.js";