@rohirik/openltm-core 2.8.0

package/src/janitor/providers/gemini.ts

@@ -0,0 +1,156 @@
+/**
+ * gemini.ts — Google Gemini provider for embeddings and LLM chat.
+ * Uses the Gemini REST API directly (no SDK dependency).
+ */
+import {
+  SETTING_KEYS,
+  type ChatInput,
+  type ChatResult,
+  type EmbedInput,
+  type EmbedResult,
+  type EmbeddingProvider,
+  type EmbeddingVector,
+  type LLMProvider,
+} from "./types.js";
+import { httpErrorResult, makeApiKeyGetter, makeModelGetter } from "./utils.js";
+
+const GEMINI_API_BASE = "https://generativelanguage.googleapis.com/v1beta";
+
+const getApiKey = makeApiKeyGetter(SETTING_KEYS.GEMINI_API_KEY, "GEMINI_API_KEY", "Gemini");
+const getEmbedModel = makeModelGetter(SETTING_KEYS.GEMINI_EMBED_MODEL);
+const getLlmModel = makeModelGetter(SETTING_KEYS.GEMINI_LLM_MODEL);
+
+export const geminiEmbedding: EmbeddingProvider = {
+  name: "gemini",
+
+  async embed(input: EmbedInput): Promise<EmbedResult> {
+    const apiKey = getApiKey();
+    const model = getEmbedModel();
+
+    // Gemini batchEmbedContents supports up to 100 texts per call
+    const requests = input.texts.map((text) => ({
+      model: `models/${model}`,
+      content: { parts: [{ text }] },
+    }));
+
+    const res = await fetch(
+      `${GEMINI_API_BASE}/models/${model}:batchEmbedContents?key=${apiKey}`,
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ requests }),
+      },
+    );
+
+    if (!res.ok) {
+      const body = await res.text();
+      throw new Error(`Gemini embed failed (${res.status}): ${body}`);
+    }
+
+    const data = (await res.json()) as {
+      embeddings: Array<{ values: number[] }>;
+    };
+
+    const vectors: EmbeddingVector[] = data.embeddings.map(
+      (e) => new Float32Array(e.values),
+    );
+    const dimensions = vectors[0]?.length ?? 0;
+
+    return {
+      vectors,
+      model,
+      dimensions,
+      // Gemini doesn't return token counts for embeddings; estimate
+      totalTokens: input.texts.reduce(
+        (sum, t) => sum + Math.ceil(t.length / 4),
+        0,
+      ),
+    };
+  },
+
+  async verify(): Promise<{ ok: boolean; error?: string }> {
+    try {
+      const apiKey = getApiKey();
+      // Verify the key by listing models — works regardless of which embed model is configured
+      const res = await fetch(`${GEMINI_API_BASE}/models?key=${apiKey}&pageSize=1`);
+      if (!res.ok) return httpErrorResult(res);
+      return { ok: true };
+    } catch (e) {
+      return { ok: false, error: String(e) };
+    }
+  },
+};
+
+export const geminiLLM: LLMProvider = {
+  name: "gemini",
+
+  async chat(input: ChatInput): Promise<ChatResult> {
+    const apiKey = getApiKey();
+    const model = getLlmModel();
+
+    // Convert ChatMessage[] to Gemini format
+    // Gemini uses "user"/"model" roles; system goes in systemInstruction
+    const systemMsg = input.messages.find((m) => m.role === "system");
+    const contents = input.messages
+      .filter((m) => m.role !== "system")
+      .map((m) => ({
+        role: m.role === "assistant" ? "model" : "user",
+        parts: [{ text: m.content }],
+      }));
+
+    const body: Record<string, unknown> = {
+      contents,
+      generationConfig: {
+        maxOutputTokens: input.maxTokens ?? 1024,
+        temperature: input.temperature ?? 0.1,
+        ...(input.jsonMode ? { responseMimeType: "application/json" } : {}),
+      },
+    };
+
+    if (systemMsg) {
+      body.systemInstruction = { parts: [{ text: systemMsg.content }] };
+    }
+
+    const res = await fetch(
+      `${GEMINI_API_BASE}/models/${model}:generateContent?key=${apiKey}`,
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body),
+      },
+    );
+
+    if (!res.ok) {
+      const errBody = await res.text();
+      throw new Error(`Gemini chat failed (${res.status}): ${errBody}`);
+    }
+
+    const data = (await res.json()) as {
+      candidates: Array<{ content: { parts: Array<{ text: string }> } }>;
+      usageMetadata?: {
+        promptTokenCount?: number;
+        candidatesTokenCount?: number;
+      };
+    };
+
+    const content = data.candidates?.[0]?.content?.parts?.[0]?.text ?? "";
+
+    return {
+      content,
+      model,
+      promptTokens: data.usageMetadata?.promptTokenCount ?? 0,
+      completionTokens: data.usageMetadata?.candidatesTokenCount ?? 0,
+    };
+  },
+
+  async verify(): Promise<{ ok: boolean; error?: string }> {
+    try {
+      const apiKey = getApiKey();
+      const res = await fetch(`${GEMINI_API_BASE}/models?key=${apiKey}&pageSize=1`);
+      if (!res.ok) return httpErrorResult(res);
+      return { ok: true };
+    } catch (e) {
+      return { ok: false, error: String(e) };
+    }
+  },
+};

package/src/janitor/providers/ollama.ts

@@ -0,0 +1,177 @@
+/**
+ * ollama.ts — Ollama local provider for embeddings and LLM chat.
+ * Connects to a local Ollama instance (default http://localhost:11434).
+ * No API key required — fully local inference.
+ */
+import { getSetting } from "../../shared-db.js";
+import {
+  SETTING_KEYS,
+  getDefault,
+  type ChatInput,
+  type ChatResult,
+  type EmbedInput,
+  type EmbedResult,
+  type EmbeddingProvider,
+  type EmbeddingVector,
+  type LLMProvider,
+} from "./types.js";
+
+function getBaseUrl(): string {
+  return (
+    getSetting(SETTING_KEYS.OLLAMA_BASE_URL) ||
+    process.env.OLLAMA_BASE_URL ||
+    getDefault(SETTING_KEYS.OLLAMA_BASE_URL)
+  );
+}
+
+function getEmbedModel(): string {
+  return (
+    getSetting(SETTING_KEYS.OLLAMA_EMBED_MODEL) ||
+    getDefault(SETTING_KEYS.OLLAMA_EMBED_MODEL)
+  );
+}
+
+function getLlmModel(): string {
+  return (
+    getSetting(SETTING_KEYS.OLLAMA_LLM_MODEL) ||
+    getDefault(SETTING_KEYS.OLLAMA_LLM_MODEL)
+  );
+}
+
+/**
+ * Verify Ollama is reachable and the specified model is pulled.
+ * Shared between embedding and LLM providers.
+ */
+async function verifyModel(model: string): Promise<{ ok: boolean; error?: string }> {
+  try {
+    const baseUrl = getBaseUrl();
+
+    const pingRes = await fetch(`${baseUrl}/api/tags`, {
+      signal: AbortSignal.timeout(3000),
+    });
+    if (!pingRes.ok) {
+      return { ok: false, error: `Ollama not reachable at ${baseUrl}` };
+    }
+
+    const tags = (await pingRes.json()) as {
+      models: Array<{ name: string }>;
+    };
+    const available = tags.models.map((m) => m.name.split(":")[0]);
+    if (!available.includes(model.split(":")[0])) {
+      return {
+        ok: false,
+        error: `Model "${model}" not found. Available: ${available.join(", ")}. Run: ollama pull ${model}`,
+      };
+    }
+
+    return { ok: true };
+  } catch (e) {
+    return { ok: false, error: String(e) };
+  }
+}
+
+export const ollamaEmbedding: EmbeddingProvider = {
+  name: "ollama",
+
+  async embed(input: EmbedInput): Promise<EmbedResult> {
+    const baseUrl = getBaseUrl();
+    const model = getEmbedModel();
+
+    // Ollama doesn't support batch embedding natively; we call per-text
+    // and parallelize with Promise.all (local, so latency is low)
+    const results = await Promise.all(
+      input.texts.map(async (text) => {
+        const res = await fetch(`${baseUrl}/api/embed`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ model, input: text }),
+        });
+
+        if (!res.ok) {
+          const body = await res.text();
+          throw new Error(`Ollama embed failed (${res.status}): ${body}`);
+        }
+
+        const data = (await res.json()) as {
+          embeddings: number[][];
+        };
+
+        const embedding = data.embeddings[0];
+        if (!embedding) throw new Error("Ollama returned empty embedding");
+        return embedding;
+      }),
+    );
+
+    const vectors: EmbeddingVector[] = results.map(
+      (v) => new Float32Array(v),
+    );
+    const dimensions = vectors[0]?.length ?? 0;
+
+    return {
+      vectors,
+      model,
+      dimensions,
+      // Ollama doesn't report token usage for embeddings
+      totalTokens: 0,
+    };
+  },
+
+  async verify(): Promise<{ ok: boolean; error?: string }> {
+    return verifyModel(getEmbedModel());
+  },
+};
+
+export const ollamaLLM: LLMProvider = {
+  name: "ollama",
+
+  async chat(input: ChatInput): Promise<ChatResult> {
+    const baseUrl = getBaseUrl();
+    const model = getLlmModel();
+
+    const body: Record<string, unknown> = {
+      model,
+      messages: input.messages.map((m) => ({
+        role: m.role,
+        content: m.content,
+      })),
+      stream: false,
+      options: {
+        num_predict: input.maxTokens ?? 1024,
+        temperature: input.temperature ?? 0.1,
+      },
+    };
+
+    if (input.jsonMode) {
+      body.format = "json";
+    }
+
+    const res = await fetch(`${baseUrl}/api/chat`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+    });
+
+    if (!res.ok) {
+      const errBody = await res.text();
+      throw new Error(`Ollama chat failed (${res.status}): ${errBody}`);
+    }
+
+    const data = (await res.json()) as {
+      message: { content: string };
+      model: string;
+      prompt_eval_count?: number;
+      eval_count?: number;
+    };
+
+    return {
+      content: data.message?.content ?? "",
+      model: data.model || model,
+      promptTokens: data.prompt_eval_count ?? 0,
+      completionTokens: data.eval_count ?? 0,
+    };
+  },
+
+  async verify(): Promise<{ ok: boolean; error?: string }> {
+    return verifyModel(getLlmModel());
+  },
+};

package/src/janitor/providers/openai.ts

@@ -0,0 +1,121 @@
+/**
+ * openai.ts — OpenAI provider for embeddings and LLM chat.
+ * Supports text-embedding-3-* for embeddings and GPT-4o family for LLM.
+ */
+import {
+  SETTING_KEYS,
+  type ChatInput,
+  type ChatResult,
+  type EmbedInput,
+  type EmbedResult,
+  type EmbeddingProvider,
+  type EmbeddingVector,
+  type LLMProvider,
+} from "./types.js";
+import { httpErrorResult, makeApiKeyGetter, makeModelGetter } from "./utils.js";
+
+const OPENAI_API_BASE = "https://api.openai.com/v1";
+
+const getApiKey = makeApiKeyGetter(SETTING_KEYS.OPENAI_API_KEY, "OPENAI_API_KEY", "OpenAI");
+const getEmbedModel = makeModelGetter(SETTING_KEYS.OPENAI_EMBED_MODEL);
+const getLlmModel = makeModelGetter(SETTING_KEYS.OPENAI_LLM_MODEL);
+
+function authHeaders(apiKey: string) {
+  return { "Content-Type": "application/json", Authorization: `Bearer ${apiKey}` };
+}
+
+export const openaiEmbedding: EmbeddingProvider = {
+  name: "openai",
+
+  async embed(input: EmbedInput): Promise<EmbedResult> {
+    const apiKey = getApiKey();
+    const model = getEmbedModel();
+
+    const res = await fetch(`${OPENAI_API_BASE}/embeddings`, {
+      method: "POST",
+      headers: authHeaders(apiKey),
+      body: JSON.stringify({ model, input: input.texts }),
+    });
+
+    if (!res.ok) return Promise.reject(new Error((await httpErrorResult(res)).error));
+
+    const data = (await res.json()) as {
+      data: Array<{ embedding: number[]; index: number }>;
+      usage: { total_tokens: number };
+    };
+
+    // OpenAI guarantees response order matches input order
+    const vectors: EmbeddingVector[] = data.data.map((e) => new Float32Array(e.embedding));
+    const dimensions = vectors[0]?.length ?? 0;
+
+    return { vectors, model, dimensions, totalTokens: data.usage.total_tokens };
+  },
+
+  async verify(): Promise<{ ok: boolean; error?: string }> {
+    try {
+      await this.embed({ texts: ["test"] });
+      return { ok: true };
+    } catch (e) {
+      return { ok: false, error: String(e) };
+    }
+  },
+};
+
+export const openaiLLM: LLMProvider = {
+  name: "openai",
+
+  async chat(input: ChatInput): Promise<ChatResult> {
+    const apiKey = getApiKey();
+    const model = getLlmModel();
+
+    const res = await fetch(`${OPENAI_API_BASE}/chat/completions`, {
+      method: "POST",
+      headers: authHeaders(apiKey),
+      body: JSON.stringify({
+        model,
+        messages: input.messages,
+        max_tokens: input.maxTokens ?? 1024,
+        temperature: input.temperature ?? 0.1,
+        ...(input.jsonMode ? { response_format: { type: "json_object" } } : {}),
+      }),
+    });
+
+    if (!res.ok) {
+      const { error } = await httpErrorResult(res);
+      throw new Error(`OpenAI chat failed: ${error}`);
+    }
+
+    const data = (await res.json()) as {
+      choices: Array<{ message: { content: string } }>;
+      model: string;
+      usage: { prompt_tokens: number; completion_tokens: number };
+    };
+
+    return {
+      content: data.choices[0]?.message.content ?? "",
+      model: data.model,
+      promptTokens: data.usage.prompt_tokens,
+      completionTokens: data.usage.completion_tokens,
+    };
+  },
+
+  async verify(): Promise<{ ok: boolean; error?: string }> {
+    try {
+      const apiKey = getApiKey();
+      const model = getLlmModel();
+      const res = await fetch(`${OPENAI_API_BASE}/chat/completions`, {
+        method: "POST",
+        headers: authHeaders(apiKey),
+        body: JSON.stringify({
+          model,
+          messages: [{ role: "user", content: "Reply with OK" }],
+          max_tokens: 5,
+        }),
+      });
+      if (!res.ok) return httpErrorResult(res);
+      return { ok: true };
+    } catch (e) {
+      return { ok: false, error: String(e) };
+    }
+  },
+};

package/src/janitor/providers/openrouter.ts

@@ -0,0 +1,182 @@
+/**
+ * openrouter.ts — OpenRouter provider for embeddings and LLM chat.
+ * Uses OpenAI-compatible API endpoints.
+ */
+import { getSetting } from "../../shared-db.js";
+import {
+  SETTING_KEYS,
+  getDefault,
+  type ChatInput,
+  type ChatResult,
+  type EmbedInput,
+  type EmbedResult,
+  type EmbeddingProvider,
+  type EmbeddingVector,
+  type LLMProvider,
+} from "./types.js";
+
+const OPENROUTER_API_BASE = "https://openrouter.ai/api/v1";
+
+function getApiKey(): string {
+  const key =
+    getSetting(SETTING_KEYS.OPENROUTER_API_KEY) ||
+    process.env.OPENROUTER_API_KEY ||
+    "";
+  if (!key) throw new Error("OpenRouter API key not configured. Set it in Settings or OPENROUTER_API_KEY env var.");
+  return key;
+}
+
+function getEmbedModel(): string {
+  return (
+    getSetting(SETTING_KEYS.OPENROUTER_EMBED_MODEL) ||
+    getDefault(SETTING_KEYS.OPENROUTER_EMBED_MODEL)
+  );
+}
+
+function getLlmModel(): string {
+  return (
+    getSetting(SETTING_KEYS.OPENROUTER_LLM_MODEL) ||
+    getDefault(SETTING_KEYS.OPENROUTER_LLM_MODEL)
+  );
+}
+
+function headers(apiKey: string): Record<string, string> {
+  return {
+    Authorization: `Bearer ${apiKey}`,
+    "Content-Type": "application/json",
+    "HTTP-Referer": "https://github.com/rohirikman/claude-ltm",
+    "X-Title": "Claude LTM Janitor",
+  };
+}
+
+export const openrouterEmbedding: EmbeddingProvider = {
+  name: "openrouter",
+
+  async embed(input: EmbedInput): Promise<EmbedResult> {
+    const apiKey = getApiKey();
+    const model = getEmbedModel();
+
+    const res = await fetch(`${OPENROUTER_API_BASE}/embeddings`, {
+      method: "POST",
+      headers: headers(apiKey),
+      body: JSON.stringify({
+        model,
+        input: input.texts,
+      }),
+    });
+
+    if (!res.ok) {
+      const body = await res.text();
+      throw new Error(`OpenRouter embed failed (${res.status}): ${body}`);
+    }
+
+    const data = (await res.json()) as {
+      data: Array<{ embedding: number[]; index: number }>;
+      model: string;
+      usage?: { prompt_tokens?: number; total_tokens?: number };
+    };
+
+    // Sort by index to maintain input order
+    const sorted = data.data.sort((a, b) => a.index - b.index);
+    const vectors: EmbeddingVector[] = sorted.map(
+      (d) => new Float32Array(d.embedding),
+    );
+    const dimensions = vectors[0]?.length ?? 0;
+
+    return {
+      vectors,
+      model: data.model || model,
+      dimensions,
+      totalTokens: data.usage?.total_tokens ?? 0,
+    };
+  },
+
+  async verify(): Promise<{ ok: boolean; error?: string }> {
+    try {
+      const apiKey = getApiKey();
+      const model = getEmbedModel();
+      const res = await fetch(`${OPENROUTER_API_BASE}/embeddings`, {
+        method: "POST",
+        headers: headers(apiKey),
+        body: JSON.stringify({ model, input: ["test"] }),
+      });
+      if (!res.ok) {
+        const body = await res.text();
+        return { ok: false, error: `${res.status}: ${body}` };
+      }
+      return { ok: true };
+    } catch (e) {
+      return { ok: false, error: String(e) };
+    }
+  },
+};
+
+export const openrouterLLM: LLMProvider = {
+  name: "openrouter",
+
+  async chat(input: ChatInput): Promise<ChatResult> {
+    const apiKey = getApiKey();
+    const model = getLlmModel();
+
+    const body: Record<string, unknown> = {
+      model,
+      messages: input.messages.map((m) => ({
+        role: m.role,
+        content: m.content,
+      })),
+      max_tokens: input.maxTokens ?? 1024,
+      temperature: input.temperature ?? 0.1,
+    };
+
+    if (input.jsonMode) {
+      body.response_format = { type: "json_object" };
+    }
+
+    const res = await fetch(`${OPENROUTER_API_BASE}/chat/completions`, {
+      method: "POST",
+      headers: headers(apiKey),
+      body: JSON.stringify(body),
+    });
+
+    if (!res.ok) {
+      const errBody = await res.text();
+      throw new Error(`OpenRouter chat failed (${res.status}): ${errBody}`);
+    }
+
+    const data = (await res.json()) as {
+      choices: Array<{ message: { content: string } }>;
+      model: string;
+      usage?: { prompt_tokens?: number; completion_tokens?: number };
+    };
+
+    return {
+      content: data.choices?.[0]?.message?.content ?? "",
+      model: data.model || model,
+      promptTokens: data.usage?.prompt_tokens ?? 0,
+      completionTokens: data.usage?.completion_tokens ?? 0,
+    };
+  },
+
+  async verify(): Promise<{ ok: boolean; error?: string }> {
+    try {
+      const apiKey = getApiKey();
+      const model = getLlmModel();
+      const res = await fetch(`${OPENROUTER_API_BASE}/chat/completions`, {
+        method: "POST",
+        headers: headers(apiKey),
+        body: JSON.stringify({
+          model,
+          messages: [{ role: "user", content: "Reply with OK" }],
+          max_tokens: 5,
+        }),
+      });
+      if (!res.ok) {
+        const body = await res.text();
+        return { ok: false, error: `${res.status}: ${body}` };
+      }
+      return { ok: true };
+    } catch (e) {
+      return { ok: false, error: String(e) };
+    }
+  },
+};