@remnic/core 9.69.66 → 9.69.67

package/dist/transfer/export-okf.js

@@ -4,33 +4,33 @@ import {
   exportOkfBundle,
   firstHeading,
   parseIncludeStatus
-} from "../chunk-WZ33AIOP.js";
+} from "../chunk-5ID5RTHY.js";
 import {
   OKF_EXPORT_VERSION
 } from "../chunk-UJX4I26O.js";
 import "../chunk-D24OXEPB.js";
 import "../chunk-3UXOZBHV.js";
-import "../chunk-LI4IWBLN.js";
+import "../chunk-GNC5X3J7.js";
 import "../chunk-46WM6JX2.js";
 import "../chunk-UHVXE24Y.js";
 import "../chunk-D5F7TKMH.js";
-import "../chunk-C2W6JKQQ.js";
-import "../chunk-EK4MOTHM.js";
+import "../chunk-BGBW4H7C.js";
+import "../chunk-MQTCNXTG.js";
+import "../chunk-T3FMRLWQ.js";
 import "../chunk-7VO6E5UD.js";
 import "../chunk-Z4TXB4K7.js";
 import "../chunk-S7LWX2PQ.js";
 import "../chunk-T2YX56QI.js";
-import "../chunk-CYEPCZN5.js";
-import "../chunk-T3FMRLWQ.js";
 import "../chunk-4O6WRBGE.js";
 import "../chunk-GUMZC2BO.js";
+import "../chunk-CYEPCZN5.js";
 import "../chunk-TFA6HPOA.js";
 import "../chunk-F4TWWUMP.js";
 import "../chunk-72A4L5JJ.js";
 import "../chunk-A7Q43EUZ.js";
 import "../chunk-S2V7RUCL.js";
-import "../chunk-MRPOZBJC.js";
 import "../chunk-S2HLHAZ4.js";
+import "../chunk-MRPOZBJC.js";
 import "../chunk-DM2T26WE.js";
 import "../chunk-LDXUBPMO.js";
 import "../chunk-FF6N7BXC.js";

package/dist/verified-recall.js

@@ -1,29 +1,29 @@
 import {
   compareVerifiedEpisodeResults,
   searchVerifiedEpisodes
-} from "./chunk-L4HT5QZ5.js";
+} from "./chunk-DDNML3YE.js";
 import "./chunk-B7RWBZXW.js";
-import "./chunk-LI4IWBLN.js";
+import "./chunk-GNC5X3J7.js";
 import "./chunk-46WM6JX2.js";
 import "./chunk-UHVXE24Y.js";
 import "./chunk-D5F7TKMH.js";
-import "./chunk-C2W6JKQQ.js";
-import "./chunk-EK4MOTHM.js";
+import "./chunk-BGBW4H7C.js";
+import "./chunk-MQTCNXTG.js";
+import "./chunk-T3FMRLWQ.js";
 import "./chunk-7VO6E5UD.js";
 import "./chunk-Z4TXB4K7.js";
 import "./chunk-S7LWX2PQ.js";
 import "./chunk-T2YX56QI.js";
-import "./chunk-CYEPCZN5.js";
-import "./chunk-T3FMRLWQ.js";
 import "./chunk-4O6WRBGE.js";
 import "./chunk-GUMZC2BO.js";
+import "./chunk-CYEPCZN5.js";
 import "./chunk-TFA6HPOA.js";
 import "./chunk-F4TWWUMP.js";
 import "./chunk-72A4L5JJ.js";
 import "./chunk-A7Q43EUZ.js";
 import "./chunk-S2V7RUCL.js";
-import "./chunk-MRPOZBJC.js";
 import "./chunk-S2HLHAZ4.js";
+import "./chunk-MRPOZBJC.js";
 import "./chunk-DM2T26WE.js";
 import "./chunk-LDXUBPMO.js";
 import "./chunk-FF6N7BXC.js";

package/dist/who-knows-cli.js

@@ -4,29 +4,29 @@ import {
   renderWhoKnows,
   renderWhoKnowsJson,
   renderWhoKnowsText
-} from "./chunk-OBD77TYC.js";
-import "./chunk-7L747CFR.js";
-import "./chunk-LI4IWBLN.js";
+} from "./chunk-RG7ZWG3M.js";
+import "./chunk-CMAGVPS2.js";
+import "./chunk-GNC5X3J7.js";
 import "./chunk-46WM6JX2.js";
 import "./chunk-UHVXE24Y.js";
 import "./chunk-D5F7TKMH.js";
-import "./chunk-C2W6JKQQ.js";
-import "./chunk-EK4MOTHM.js";
+import "./chunk-BGBW4H7C.js";
+import "./chunk-MQTCNXTG.js";
+import "./chunk-T3FMRLWQ.js";
 import "./chunk-7VO6E5UD.js";
 import "./chunk-Z4TXB4K7.js";
 import "./chunk-S7LWX2PQ.js";
 import "./chunk-T2YX56QI.js";
-import "./chunk-CYEPCZN5.js";
-import "./chunk-T3FMRLWQ.js";
 import "./chunk-4O6WRBGE.js";
 import "./chunk-GUMZC2BO.js";
+import "./chunk-CYEPCZN5.js";
 import "./chunk-TFA6HPOA.js";
 import "./chunk-F4TWWUMP.js";
 import "./chunk-72A4L5JJ.js";
 import "./chunk-A7Q43EUZ.js";
 import "./chunk-S2V7RUCL.js";
-import "./chunk-MRPOZBJC.js";
 import "./chunk-S2HLHAZ4.js";
+import "./chunk-MRPOZBJC.js";
 import "./chunk-DM2T26WE.js";
 import "./chunk-LDXUBPMO.js";
 import "./chunk-FF6N7BXC.js";

package/dist/who-knows.js

@@ -9,28 +9,28 @@ import {
   loadWhoKnowsEntities,
   tokenizeTopic,
   validateWhoKnowsInput
-} from "./chunk-7L747CFR.js";
-import "./chunk-LI4IWBLN.js";
+} from "./chunk-CMAGVPS2.js";
+import "./chunk-GNC5X3J7.js";
 import "./chunk-46WM6JX2.js";
 import "./chunk-UHVXE24Y.js";
 import "./chunk-D5F7TKMH.js";
-import "./chunk-C2W6JKQQ.js";
-import "./chunk-EK4MOTHM.js";
+import "./chunk-BGBW4H7C.js";
+import "./chunk-MQTCNXTG.js";
+import "./chunk-T3FMRLWQ.js";
 import "./chunk-7VO6E5UD.js";
 import "./chunk-Z4TXB4K7.js";
 import "./chunk-S7LWX2PQ.js";
 import "./chunk-T2YX56QI.js";
-import "./chunk-CYEPCZN5.js";
-import "./chunk-T3FMRLWQ.js";
 import "./chunk-4O6WRBGE.js";
 import "./chunk-GUMZC2BO.js";
+import "./chunk-CYEPCZN5.js";
 import "./chunk-TFA6HPOA.js";
 import "./chunk-F4TWWUMP.js";
 import "./chunk-72A4L5JJ.js";
 import "./chunk-A7Q43EUZ.js";
 import "./chunk-S2V7RUCL.js";
-import "./chunk-MRPOZBJC.js";
 import "./chunk-S2HLHAZ4.js";
+import "./chunk-MRPOZBJC.js";
 import "./chunk-DM2T26WE.js";
 import "./chunk-LDXUBPMO.js";
 import "./chunk-FF6N7BXC.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remnic/core",
-  "version": "9.69.66",
+  "version": "9.69.67",
   "description": "Framework-agnostic Remnic memory engine — orchestrator, storage, extraction, search, trust zones",
   "type": "module",
   "main": "dist/index.js",
@@ -3317,7 +3317,7 @@
     "core"
   ],
   "peerDependencies": {
-    "@remnic/coding-graph": "^9.69.66"
+    "@remnic/coding-graph": "^9.69.67"
   },
   "peerDependenciesMeta": {
     "@remnic/coding-graph": {

package/src/local-llm-probe-litellm.test.ts

@@ -0,0 +1,116 @@
+import assert from "node:assert/strict";
+import http from "node:http";
+import type { AddressInfo } from "node:net";
+import test from "node:test";
+
+import { LocalLlmClient } from "./local-llm.js";
+import { orderedLocalServers } from "./local-llm-servers.js";
+import type { PluginConfig } from "./types.js";
+
+/**
+ * A LiteLLM proxy answers `GET /` with the JSON string "LiteLLM: RUNNING" and
+ * runs a live completion against every deployment in its pool on `GET /health`.
+ * The availability probe must classify LiteLLM from `/` and never reach
+ * `/health`; before this test the once-a-minute probe was the largest load
+ * source on the pool behind the proxy.
+ */
+
+function createConfig(localLlmUrl: string): PluginConfig {
+  return {
+    localLlmEnabled: true,
+    localLlmModel: "test-local-model",
+    localLlmUrl,
+    localLlmTimeoutMs: 1_000,
+    localLlmRetry5xxCount: 0,
+    localLlmRetryBackoffMs: 1,
+    localLlmHeaders: {},
+    localLlmApiKey: undefined,
+    localLlmAuthHeader: false,
+    localLlm400TripThreshold: 3,
+    localLlm400CooldownMs: 60_000,
+    debug: false,
+    localLlmReasoningEffort: "none",
+    slowLogEnabled: false,
+    slowLogThresholdMs: 1_000,
+  } as unknown as PluginConfig;
+}
+
+async function startServer(
+  handle: (path: string, res: http.ServerResponse) => void,
+): Promise<{ url: string; paths: string[]; close(): Promise<void> }> {
+  const paths: string[] = [];
+  const server = http.createServer((req, res) => {
+    const path = req.url ?? "";
+    paths.push(path);
+    handle(path, res);
+  });
+  await new Promise<void>((resolve) => server.listen(0, "127.0.0.1", resolve));
+  const { port } = server.address() as AddressInfo;
+  return {
+    url: `http://127.0.0.1:${port}/v1`,
+    paths,
+    close: () => new Promise<void>((resolve) => server.close(() => resolve())),
+  };
+}
+
+function json(res: http.ServerResponse, body: unknown): void {
+  res.writeHead(200, { "content-type": "application/json" });
+  res.end(JSON.stringify(body));
+}
+
+function startLiteLlmShapedServer() {
+  return startServer((path, res) => {
+    if (path === "/") return json(res, "LiteLLM: RUNNING");
+    if (path === "/v1/models") return json(res, { data: [{ id: "test-local-model" }] });
+    json(res, { healthy_endpoints: [], unhealthy_endpoints: [] });
+  });
+}
+
+test("a LiteLLM proxy is detected from GET / and /health is never probed", async () => {
+  const server = await startLiteLlmShapedServer();
+  try {
+    const client = new LocalLlmClient(createConfig(server.url));
+    assert.equal(await client.checkAvailability(), true);
+    assert.equal(client.getDetectedType(), "litellm");
+    assert.ok(!server.paths.includes("/health"), `probe hit /health: ${server.paths.join(", ")}`);
+    assert.equal(server.paths.filter((p) => p === "/").length, 1, "GET / must be fetched once per pass");
+  } finally {
+    await server.close();
+  }
+});
+
+test("LiteLLM is probed before any /health probe on every port; other orders are unchanged", () => {
+  for (const port of [8080, 8000, 11434, 1234, 4000, null]) {
+    const url = port === null ? "http://127.0.0.1/v1" : `http://127.0.0.1:${port}/v1`;
+    const order = orderedLocalServers(url);
+    const types = order.map((s) => s.type);
+    const litellmAt = types.indexOf("litellm");
+    const firstHealth = order.findIndex((s) => s.healthEndpoint === "/health");
+    assert.ok(litellmAt !== -1 && litellmAt < firstHealth, `${url}: ${types.join(" > ")}`);
+  }
+  // Port-matched shapes with harmless probes keep the lead they had before.
+  assert.equal(orderedLocalServers("http://127.0.0.1:1234/v1")[0]?.type, "lmstudio");
+  assert.equal(orderedLocalServers("http://127.0.0.1:11434/v1")[0]?.type, "ollama");
+  // LiteLLM displaces the port-matched llama.cpp / vLLM /health probes.
+  assert.deepEqual(orderedLocalServers("http://127.0.0.1:8080/v1").map((s) => s.type).slice(0, 3), ["litellm", "llamacpp", "mlx"]);
+  assert.deepEqual(orderedLocalServers("http://127.0.0.1:8000/v1").map((s) => s.type).slice(0, 2), ["litellm", "vllm"]);
+});
+
+test("a root response is fetched once even when a later detector matches it", async () => {
+  const server = await startServer((path, res) => {
+    if (path === "/") {
+      res.writeHead(200, { "content-type": "text/plain" });
+      res.end("Ollama is running");
+      return;
+    }
+    json(res, {});
+  });
+  try {
+    const client = new LocalLlmClient(createConfig(server.url));
+    assert.equal(await client.checkAvailability(), true);
+    assert.equal(client.getDetectedType(), "ollama");
+    assert.equal(server.paths.filter((p) => p === "/").length, 1, `paths: ${server.paths.join(", ")}`);
+  } finally {
+    await server.close();
+  }
+});

package/src/local-llm-servers.ts

@@ -0,0 +1,104 @@
+/**
+ * Server shapes the local-LLM availability probe can recognise, and the order
+ * in which they are tried for a configured base URL. Split from local-llm.ts
+ * (file-size ratchet) — no runtime dependency on the client.
+ */
+
+export type LocalLlmType = "litellm" | "lmstudio" | "ollama" | "mlx" | "vllm" | "llamacpp" | "generic";
+
+export interface LocalServerConfig {
+  type: LocalLlmType;
+  defaultPort: number;
+  healthEndpoint: string;
+  modelsEndpoint: string;
+  detectFn: (response: unknown) => boolean;
+}
+
+export function isObjectRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}
+
+function explicitPortFromUrl(s: string): number | null {
+  try {
+    const parsed = new URL(s);
+    if (!parsed.port) return null;
+    const port = Number(parsed.port);
+    return Number.isInteger(port) ? port : null;
+  } catch {
+    return null;
+  }
+}
+
+// LiteLLM must be recognised before the llama.cpp / vLLM probes: on a LiteLLM
+// proxy `GET /health` runs a live completion against EVERY deployment in its
+// pool, so a once-a-minute 2 s probe turns into a permanent load generator on
+// the backends (4,600 probe completions in 12 h observed). `GET /` is
+// auth-gated on LiteLLM and answers the JSON string "LiteLLM: RUNNING".
+// Not part of LOCAL_SERVERS: `orderedLocalServers` positions it explicitly.
+const LITELLM_SERVER: LocalServerConfig = {
+  type: "litellm",
+  defaultPort: 4000,
+  healthEndpoint: "/",
+  modelsEndpoint: "/v1/models",
+  detectFn: (resp) => typeof resp === "string" && resp.includes("LiteLLM"),
+};
+
+const LOCAL_SERVERS: LocalServerConfig[] = [
+  {
+    type: "ollama",
+    defaultPort: 11434,
+    healthEndpoint: "/",
+    modelsEndpoint: "/api/tags",
+    detectFn: (resp) => typeof resp === "string" && resp.includes("Ollama"),
+  },
+  {
+    type: "llamacpp",
+    defaultPort: 8080,
+    healthEndpoint: "/health",
+    modelsEndpoint: "/v1/models",
+    detectFn: (resp) => isObjectRecord(resp) && resp.status === "ok",
+  },
+  {
+    type: "mlx",
+    defaultPort: 8080,
+    healthEndpoint: "/v1/models",
+    modelsEndpoint: "/v1/models",
+    detectFn: (resp) => isObjectRecord(resp) && Array.isArray(resp.data),
+  },
+  {
+    type: "lmstudio",
+    defaultPort: 1234,
+    healthEndpoint: "/v1/models",
+    modelsEndpoint: "/v1/models",
+    detectFn: (resp) => isObjectRecord(resp) && Array.isArray(resp.data),
+  },
+  {
+    type: "vllm",
+    defaultPort: 8000,
+    healthEndpoint: "/health",
+    modelsEndpoint: "/v1/models",
+    detectFn: (resp) => resp === "" || (isObjectRecord(resp) && !("status" in resp)),
+  },
+];
+
+/**
+ * Probe order for a configured base URL. Entries whose default port matches
+ * the URL's explicit port go first, in the same order as before; the LiteLLM
+ * entry is placed immediately ahead of the first entry that would probe
+ * `GET /health`, so that request never reaches a LiteLLM proxy on any port.
+ * LM Studio / Ollama / MLX probes are harmless on LiteLLM and keep their spot.
+ */
+export function orderedLocalServers(configuredBaseUrl: string): LocalServerConfig[] {
+  const configuredPort = explicitPortFromUrl(configuredBaseUrl);
+  const matching = configuredPort === null
+    ? []
+    : LOCAL_SERVERS.filter((serverConfig) => serverConfig.defaultPort === configuredPort);
+  const matchingTypes = new Set(matching.map((serverConfig) => serverConfig.type));
+  const ordered = [
+    ...matching,
+    ...LOCAL_SERVERS.filter((serverConfig) => !matchingTypes.has(serverConfig.type)),
+  ];
+  const firstHealthProbe = ordered.findIndex((serverConfig) => serverConfig.healthEndpoint === "/health");
+  ordered.splice(firstHealthProbe === -1 ? ordered.length : firstHealthProbe, 0, LITELLM_SERVER);
+  return ordered;
+}

package/src/local-llm.ts

@@ -22,6 +22,13 @@ import {
   type LocalLlmChatCompletionOptions,
   type LocalLlmChatCompletionResult,
 } from "./local-llm-helpers.js";
+import {
+  isObjectRecord,
+  orderedLocalServers,
+  type LocalLlmType,
+} from "./local-llm-servers.js";
+
+export type { LocalLlmType } from "./local-llm-servers.js";
 
 /** Trim trailing slash characters without backtracking regex. */
 function trimTrailingSlashes(s: string): string {
@@ -34,21 +41,6 @@ function stripTrailingV1Path(s: string): string {
   return s.endsWith("/v1") ? s.slice(0, -3) : s;
 }
 
-function explicitPortFromUrl(s: string): number | null {
-  try {
-    const parsed = new URL(s);
-    if (!parsed.port) return null;
-    const port = Number(parsed.port);
-    return Number.isInteger(port) ? port : null;
-  } catch {
-    return null;
-  }
-}
-
-function isObjectRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null;
-}
-
 function isLlamaCppPropsResponse(value: unknown): boolean {
   return (
     isObjectRecord(value) &&
@@ -118,15 +110,6 @@ function isLmStudioNativeModelsResponse(value: unknown): boolean {
   return isLmStudioApiV1ModelsResponse(value) || isLmStudioApiV0ModelsResponse(value);
 }
 
-/**
- * Local LLM client for OpenAI-compatible endpoints (LM Studio, Ollama, MLX, etc.)
- *
- * Based on openclaw-tactician's provider detection patterns for consistency.
- * Provides privacy-preserving, cost-effective LLM operations with
- * graceful fallback to cloud providers when local LLM is unavailable.
- */
-export type LocalLlmType = "lmstudio" | "ollama" | "mlx" | "vllm" | "llamacpp" | "generic";
-
 /**
  * Backends known to honor `chat_template_kwargs: { enable_thinking: false }`
  * on OpenAI-compatible `/v1/chat/completions`.  LM Studio, vLLM, and
@@ -160,66 +143,6 @@ const THINKING_SUPPRESSED_OPERATIONS: ReadonlySet<string> = new Set([
   "hourly_summary_extended",
 ]);
 
-interface LocalServerConfig {
-  type: LocalLlmType;
-  defaultPort: number;
-  healthEndpoint: string;
-  modelsEndpoint: string;
-  detectFn: (response: unknown) => boolean;
-}
-
-const LOCAL_SERVERS: LocalServerConfig[] = [
-  {
-    type: "ollama",
-    defaultPort: 11434,
-    healthEndpoint: "/",
-    modelsEndpoint: "/api/tags",
-    detectFn: (resp) => typeof resp === "string" && resp.includes("Ollama"),
-  },
-  {
-    type: "llamacpp",
-    defaultPort: 8080,
-    healthEndpoint: "/health",
-    modelsEndpoint: "/v1/models",
-    detectFn: (resp) => isObjectRecord(resp) && resp.status === "ok",
-  },
-  {
-    type: "mlx",
-    defaultPort: 8080,
-    healthEndpoint: "/v1/models",
-    modelsEndpoint: "/v1/models",
-    detectFn: (resp) => isObjectRecord(resp) && Array.isArray(resp.data),
-  },
-  {
-    type: "lmstudio",
-    defaultPort: 1234,
-    healthEndpoint: "/v1/models",
-    modelsEndpoint: "/v1/models",
-    detectFn: (resp) => isObjectRecord(resp) && Array.isArray(resp.data),
-  },
-  {
-    type: "vllm",
-    defaultPort: 8000,
-    healthEndpoint: "/health",
-    modelsEndpoint: "/v1/models",
-    detectFn: (resp) => resp === "" || (isObjectRecord(resp) && !("status" in resp)),
-  },
-];
-
-function orderedLocalServers(configuredBaseUrl: string): LocalServerConfig[] {
-  const configuredPort = explicitPortFromUrl(configuredBaseUrl);
-  if (configuredPort === null) return LOCAL_SERVERS;
-  const matching = LOCAL_SERVERS.filter(
-    (serverConfig) => serverConfig.defaultPort === configuredPort,
-  );
-  if (matching.length === 0) return LOCAL_SERVERS;
-  const matchingTypes = new Set(matching.map((serverConfig) => serverConfig.type));
-  return [
-    ...matching,
-    ...LOCAL_SERVERS.filter((serverConfig) => !matchingTypes.has(serverConfig.type)),
-  ];
-}
-
 export interface LocalModelInfo {
   id: string;
   contextWindow?: number;
@@ -244,6 +167,13 @@ type LocalLlmBackendState = {
   untilMs: number;
   reason: string;
 };
+/**
+ * Local LLM client for OpenAI-compatible endpoints (LM Studio, Ollama, MLX, etc.)
+ *
+ * Based on openclaw-tactician's provider detection patterns for consistency.
+ * Provides privacy-preserving, cost-effective LLM operations with
+ * graceful fallback to cloud providers when local LLM is unavailable.
+ */
 export class LocalLlmClient {
   private config: PluginConfig;
   private isAvailable: boolean | null = null;
@@ -435,6 +365,16 @@ export class LocalLlmClient {
     // is down (issue #2210). Tracked separately so a loaded daemon cannot cache
     // itself into a blackout.
     let sawAbortedProbe = false;
+    // Several server shapes share a probe URL (LiteLLM and Ollama both use
+    // `/`); fetch each URL once per pass.
+    const probed = new Map<string, ProbeFetchResult>();
+    const probeOnce = async (url: string): Promise<ProbeFetchResult> => {
+      const cached = probed.get(url);
+      if (cached) return cached;
+      const result = await this.fetchWithTimeout(url, 2000, undefined, signal);
+      probed.set(url, result);
+      return result;
+    };
 
     // Try to detect which server type is running
     if (signal?.aborted) return false;
@@ -442,7 +382,7 @@ export class LocalLlmClient {
       const healthUrl = `${probeBaseUrl}${serverConfig.healthEndpoint}`;
       log.debug(`checking ${serverConfig.type} at ${healthUrl}`);
 
-      const result = await this.fetchWithTimeout(healthUrl, 2000, undefined, signal);
+      const result = await probeOnce(healthUrl);
       if (result.aborted) sawAbortedProbe = true;
       if (signal?.aborted) return false;
       if (result.ok && serverConfig.detectFn(result.data)) {