memorix 1.4.6 → 1.5.1

package/dist/media-video-runner.js

@@ -2141,6 +2141,7 @@ var init_resolved_config = __esm({
 // src/config.ts
 var config_exports = {};
 __export(config_exports, {
+  defaultEmbeddingModelFor: () => defaultEmbeddingModelFor,
   getAgentLLMApiKey: () => getAgentLLMApiKey,
   getAgentLLMBaseUrl: () => getAgentLLMBaseUrl,
   getAgentLLMModel: () => getAgentLLMModel,
@@ -2203,7 +2204,19 @@ function getEmbeddingBaseUrl() {
   return getResolvedEmbeddingLane().baseUrl || "https://api.openai.com/v1";
 }
 function getEmbeddingModel() {
-  return getResolvedEmbeddingLane().model || "text-embedding-3-small";
+  const lane = getResolvedEmbeddingLane();
+  return defaultEmbeddingModelFor(lane.baseUrl, lane.model);
+}
+function defaultEmbeddingModelFor(baseUrl, explicitModel) {
+  if (explicitModel) return explicitModel;
+  try {
+    const url = baseUrl ? new URL(baseUrl) : null;
+    if (url && (url.hostname === "openrouter.ai" || url.hostname.endsWith(".openrouter.ai"))) {
+      return "qwen/qwen3-embedding-8b";
+    }
+  } catch {
+  }
+  return "text-embedding-3-small";
 }
 function getEmbeddingDimensions() {
   return getResolvedEmbeddingLane().dimensions ?? null;
@@ -2742,6 +2755,8 @@ function getPreferredBatchSize(config) {
 }
 function parseBatchLimit(error) {
   if (!(error instanceof Error)) return null;
+  const status = error instanceof EmbeddingAPIError ? error.status : Number(error.message.match(/Embedding API error \((\d{3})\)/i)?.[1] ?? 0);
+  if (status > 0 && status !== 400) return null;
   const explicit = error.message.match(/should not be larger than\s+(\d+)/i);
   if (explicit) return parseInt(explicit[1], 10);
   if (/batch size/i.test(error.message)) {
@@ -2754,37 +2769,99 @@ async function fetchWithRetry(url, apiKey, body, options = {}, attempt = 0, nati
   const controller = new AbortController();
   const timeoutMs = typeof options.timeoutMs === "number" && Number.isFinite(options.timeoutMs) ? Math.max(100, Math.min(Math.floor(options.timeoutMs), 6e4)) : 1e4;
   const timeout = setTimeout(() => controller.abort(), timeoutMs);
+  const signal = options.signal ? AbortSignal.any([options.signal, controller.signal]) : controller.signal;
   let response;
   try {
     response = await fetch(url, {
       method: "POST",
       headers: nativeGemini ? { "Content-Type": "application/json", "x-goog-api-key": apiKey } : { "Content-Type": "application/json", "Authorization": `Bearer ${apiKey}` },
       body: JSON.stringify(body),
-      signal: controller.signal
+      signal
     });
   } catch (err) {
     clearTimeout(timeout);
-    if (err instanceof Error && err.name === "AbortError") {
+    if (err instanceof Error && (err.name === "AbortError" || controller.signal.aborted || options.signal?.aborted)) {
       throw new Error(`Embedding API timeout after ${timeoutMs}ms: ${url}`);
     }
     throw err;
   }
-  clearTimeout(timeout);
-  if (response.ok) {
-    return response.json();
+  try {
+    if (response.ok) {
+      return await raceWithAbort(
+        response.json(),
+        signal
+      );
+    }
+    if (options.retry !== false && (response.status === 429 || response.status >= 500) && attempt < MAX_RETRIES2) {
+      const delay2 = BASE_DELAY_MS * Math.pow(2, attempt);
+      const retryAfter = response.headers.get("retry-after");
+      const parsedRetryAfter = retryAfter ? parseInt(retryAfter, 10) * 1e3 : NaN;
+      const waitMs = Number.isFinite(parsedRetryAfter) ? parsedRetryAfter : delay2;
+      console.error(`[memorix] Embedding API ${response.status}, retry ${attempt + 1}/${MAX_RETRIES2} in ${waitMs}ms`);
+      await waitForRetry(waitMs, options.signal);
+      return fetchWithRetry(url, apiKey, body, options, attempt + 1, nativeGemini);
+    }
+    const errorText2 = await raceWithAbort(
+      response.text().catch(() => "unknown error"),
+      signal
+    );
+    throw new EmbeddingAPIError(response.status, errorText2);
+  } catch (err) {
+    if (err instanceof Error && (err.name === "AbortError" || controller.signal.aborted || options.signal?.aborted)) {
+      throw new Error(`Embedding API timeout after ${timeoutMs}ms: ${url}`);
+    }
+    throw err;
+  } finally {
+    clearTimeout(timeout);
   }
-  if (options.retry !== false && (response.status === 429 || response.status >= 500) && attempt < MAX_RETRIES2) {
-    const delay2 = BASE_DELAY_MS * Math.pow(2, attempt);
-    const retryAfter = response.headers.get("retry-after");
-    const waitMs = retryAfter ? parseInt(retryAfter, 10) * 1e3 : delay2;
-    console.error(`[memorix] Embedding API ${response.status}, retry ${attempt + 1}/${MAX_RETRIES2} in ${waitMs}ms`);
+}
+function abortError() {
+  const error = new Error("Embedding API request aborted");
+  error.name = "AbortError";
+  return error;
+}
+function raceWithAbort(promise, signal) {
+  if (signal.aborted) return Promise.reject(abortError());
+  return new Promise((resolve, reject) => {
+    const onAbort = () => {
+      signal.removeEventListener("abort", onAbort);
+      reject(abortError());
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    promise.then(
+      (value) => {
+        signal.removeEventListener("abort", onAbort);
+        resolve(value);
+      },
+      (error) => {
+        signal.removeEventListener("abort", onAbort);
+        reject(error);
+      }
+    );
+  });
+}
+async function waitForRetry(waitMs, signal) {
+  if (!signal) {
     await new Promise((resolve) => setTimeout(resolve, waitMs));
-    return fetchWithRetry(url, apiKey, body, options, attempt + 1, nativeGemini);
+    return;
   }
-  const errorText2 = await response.text().catch(() => "unknown error");
-  throw new Error(`Embedding API error (${response.status}): ${errorText2}`);
+  const abortSignal = signal;
+  if (abortSignal.aborted) throw new Error("Embedding API retry aborted");
+  await new Promise((resolve, reject) => {
+    const timer = setTimeout(done, waitMs);
+    const onAbort = () => {
+      clearTimeout(timer);
+      abortSignal.removeEventListener("abort", onAbort);
+      reject(new Error("Embedding API retry aborted"));
+    };
+    function done() {
+      abortSignal.removeEventListener("abort", onAbort);
+      resolve();
+    }
+    abortSignal.addEventListener("abort", onAbort, { once: true });
+  });
 }
-var cache3, MAX_CACHE_SIZE3, diskCacheDirty2, diskSaveTimer, diskCacheLoaded, diskCacheLoadPromise, MAX_INPUT_CHARS, MAX_CONCURRENCY, DISK_SAVE_DEBOUNCE_MS, DEFAULT_MAX_BATCH_SIZE, DASHSCOPE_MAX_BATCH_SIZE, MAX_RETRIES2, BASE_DELAY_MS, APIEmbeddingProvider;
+var cache3, MAX_CACHE_SIZE3, diskCacheDirty2, diskSaveTimer, diskCacheLoaded, diskCacheLoadPromise, MAX_INPUT_CHARS, MAX_CONCURRENCY, DISK_SAVE_DEBOUNCE_MS, DEFAULT_MAX_BATCH_SIZE, DASHSCOPE_MAX_BATCH_SIZE, MAX_RETRIES2, BASE_DELAY_MS, EmbeddingAPIError, APIEmbeddingProvider;
 var init_api_provider = __esm({
   "src/embedding/api-provider.ts"() {
     "use strict";
@@ -2803,6 +2880,14 @@ var init_api_provider = __esm({
     DASHSCOPE_MAX_BATCH_SIZE = 10;
     MAX_RETRIES2 = 3;
     BASE_DELAY_MS = 500;
+    EmbeddingAPIError = class extends Error {
+      status;
+      constructor(status, detail) {
+        super(`Embedding API error (${status}): ${detail}`);
+        this.name = "EmbeddingAPIError";
+        this.status = status;
+      }
+    };
     APIEmbeddingProvider = class _APIEmbeddingProvider {
       name;
       dimensions;
@@ -3014,15 +3099,14 @@ var init_api_provider = __esm({
             }
           } catch (error) {
             const providerLimit = parseBatchLimit(error);
-            const fallbackSize = providerLimit ?? Math.ceil(chunkTexts.length / 2);
-            if (chunkTexts.length > 1 && fallbackSize < chunkTexts.length) {
+            if (providerLimit !== null && chunkTexts.length > 1 && providerLimit < chunkTexts.length) {
               console.error(
-                `[memorix] Embedding batch too large for provider, retrying in chunks of ${fallbackSize}`
+                `[memorix] Embedding batch too large for provider, retrying in chunks of ${providerLimit}`
               );
-              for (let start = 0; start < chunkTexts.length; start += fallbackSize) {
+              for (let start = 0; start < chunkTexts.length; start += providerLimit) {
                 await processChunk(
-                  chunkTexts.slice(start, start + fallbackSize),
-                  chunkIndices.slice(start, start + fallbackSize)
+                  chunkTexts.slice(start, start + providerLimit),
+                  chunkIndices.slice(start, start + providerLimit)
                 );
               }
               return;
@@ -3886,22 +3970,23 @@ function getLLMConfig() {
 function setLLMConfig(config) {
   currentConfig = config;
 }
-async function callLLM(systemPrompt, userMessage) {
+async function callLLM(systemPrompt, userMessage, signal) {
   if (!currentConfig) {
     throw new Error("LLM not configured. Set MEMORIX_LLM_API_KEY or OPENAI_API_KEY.");
   }
   if (currentConfig.provider === "anthropic") {
-    return callAnthropic(systemPrompt, userMessage);
+    return callAnthropic(systemPrompt, userMessage, signal);
   }
-  return callOpenAICompatible(systemPrompt, userMessage);
+  return callOpenAICompatible(systemPrompt, userMessage, signal);
 }
-async function callOpenAICompatible(systemPrompt, userMessage) {
+async function callOpenAICompatible(systemPrompt, userMessage, signal) {
   const config = currentConfig;
   let base = config.baseUrl.replace(/\/+$/, "");
   if (!base.endsWith("/v1")) base += "/v1";
   const url = `${base}/chat/completions`;
+  const fetchSignal = signal ? AbortSignal.any([signal, AbortSignal.timeout(LLM_CALL_TIMEOUT_MS)]) : AbortSignal.timeout(LLM_CALL_TIMEOUT_MS);
   const response = await fetch(url, {
-    signal: AbortSignal.timeout(LLM_CALL_TIMEOUT_MS),
+    signal: fetchSignal,
     method: "POST",
     headers: {
       "Content-Type": "application/json",
@@ -3918,10 +4003,10 @@ async function callOpenAICompatible(systemPrompt, userMessage) {
     })
   });
   if (!response.ok) {
-    const error = await readResponseText(response, void 0, 64 * 1024).catch(() => "unknown error");
+    const error = await readResponseText(response, signal, 64 * 1024).catch(() => "unknown error");
     throw new Error(`LLM API error (${response.status}): ${error}`);
   }
-  const data = await readResponseJson(response);
+  const data = await readResponseJson(response, signal);
   return {
     content: data.choices[0]?.message?.content ?? "",
     usage: data.usage ? {
@@ -3930,11 +4015,12 @@ async function callOpenAICompatible(systemPrompt, userMessage) {
     } : void 0
   };
 }
-async function callAnthropic(systemPrompt, userMessage) {
+async function callAnthropic(systemPrompt, userMessage, signal) {
   const config = currentConfig;
   const url = `${config.baseUrl}/messages`;
+  const fetchSignal = signal ? AbortSignal.any([signal, AbortSignal.timeout(LLM_CALL_TIMEOUT_MS)]) : AbortSignal.timeout(LLM_CALL_TIMEOUT_MS);
   const response = await fetch(url, {
-    signal: AbortSignal.timeout(LLM_CALL_TIMEOUT_MS),
+    signal: fetchSignal,
     method: "POST",
     headers: {
       "Content-Type": "application/json",
@@ -3952,10 +4038,10 @@ async function callAnthropic(systemPrompt, userMessage) {
     })
   });
   if (!response.ok) {
-    const error = await readResponseText(response, void 0, 64 * 1024).catch(() => "unknown error");
+    const error = await readResponseText(response, signal, 64 * 1024).catch(() => "unknown error");
     throw new Error(`Anthropic API error (${response.status}): ${error}`);
   }
-  const data = await readResponseJson(response);
+  const data = await readResponseJson(response, signal);
   return {
     content: data.content[0]?.text ?? "",
     usage: data.usage ? {
@@ -4460,6 +4546,57 @@ function withTimeout(promise, ms, label) {
     );
   });
 }
+function withTimeoutSignal(operation, ms, label, parentSignal) {
+  const controller = new AbortController();
+  const signal = parentSignal ? AbortSignal.any([parentSignal, controller.signal]) : controller.signal;
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    let timedOut = false;
+    let timer;
+    const cleanup = () => {
+      if (timer !== void 0) clearTimeout(timer);
+      parentSignal?.removeEventListener("abort", onParentAbort);
+    };
+    const onParentAbort = () => {
+      if (settled || timedOut) return;
+      settled = true;
+      cleanup();
+      reject(parentSignal?.reason ?? new Error(`${label} aborted`));
+    };
+    parentSignal?.addEventListener("abort", onParentAbort, { once: true });
+    timer = setTimeout(() => {
+      if (settled) return;
+      timedOut = true;
+      controller.abort(new Error(`${label} timed out after ${ms}ms`));
+      settled = true;
+      cleanup();
+      reject(new Error(`${label} timed out after ${ms}ms`));
+    }, ms);
+    let pending;
+    try {
+      pending = operation(signal);
+    } catch (error) {
+      settled = true;
+      cleanup();
+      reject(error);
+      return;
+    }
+    pending.then(
+      (value) => {
+        if (settled) return;
+        settled = true;
+        cleanup();
+        resolve(value);
+      },
+      (error) => {
+        if (settled) return;
+        settled = true;
+        cleanup();
+        reject(timedOut ? new Error(`${label} timed out after ${ms}ms`) : error);
+      }
+    );
+  });
+}
 var init_timeout = __esm({
   "src/timeout.ts"() {
     "use strict";
@@ -5324,16 +5461,18 @@ async function searchObservations(options) {
           );
         } else {
           const EMBEDDING_TIMEOUT_MS = 15e3;
-          queryVector = await withTimeout(
-            provider2.embedInput ? provider2.embedInput(
+          queryVector = await withTimeoutSignal(
+            (signal) => provider2.embedInput ? provider2.embedInput(
               { modality: "text", text: expandedEmbeddingQuery },
-              { intent: "query", timeoutMs: EMBEDDING_TIMEOUT_MS, retry: false }
+              { intent: "query", timeoutMs: EMBEDDING_TIMEOUT_MS, retry: false, signal }
             ) : provider2.embed(expandedEmbeddingQuery, {
               timeoutMs: EMBEDDING_TIMEOUT_MS,
-              retry: false
+              retry: false,
+              signal
             }),
             EMBEDDING_TIMEOUT_MS,
-            "Embedding"
+            "Embedding",
+            options.signal
           );
           mark("embedding");
           const cjkRatio = (originalQuery.match(/[\u4e00-\u9fff\u3040-\u309f\u30a0-\u30ff\uac00-\ud7af]/g) || []).length / originalQuery.length;
@@ -143253,7 +143392,13 @@ async function maintainLongTermMemories(input) {
   }
   for (const group of groups.values()) {
     if (group.length < 2) continue;
-    group.sort((a, b) => Date.parse(b.createdAt) - Date.parse(a.createdAt));
+    group.sort((a, b) => {
+      const byCreatedAt = Date.parse(b.createdAt) - Date.parse(a.createdAt);
+      if (byCreatedAt !== 0) return byCreatedAt;
+      const byUpdatedAt = Date.parse(b.updatedAt) - Date.parse(a.updatedAt);
+      if (byUpdatedAt !== 0) return byUpdatedAt;
+      return b.id.localeCompare(a.id);
+    });
     const newest = group[0];
     for (const older of group.slice(1)) {
       try {

package/dist/memcode-runtime/CHANGELOG.md

@@ -2,6 +2,44 @@
 
 All notable changes to this project will be documented in this file.
 
+## [Unreleased]
+
+## [1.5.1] - 2026-08-16
+
+### Fixed
+- **Bounded formation cancellation** -- Formation deadlines now abort the
+  LLM and vector-search work they started, including response-body reads and
+  retry waits. A provider that ignores cancellation still cannot hold the
+  caller past its deadline.
+- **Embedding error classification** -- Only an explicit HTTP 400 batch-shape
+  error may trigger batch splitting. Authentication, billing, quota, and
+  upstream errors fail once instead of multiplying latency through recursive
+  retries.
+
+## [1.5.0] - 2026-08-14
+
+### Added
+- **Stability stress suite** -- Five deterministic, offline stress exams now
+  run in the normal test suite: a 2,000-observation corpus (planted needles,
+  ranked determinism, project isolation), 60-way parallel writes plus
+  20-way same-topic upserts, session churn across projects with parallel
+  starts, 300-record long-term maintenance exactness, and repeated CLI
+  invocations. Live embedding stress exams are env-gated
+  (`MEMORIX_RUN_LIVE_EMBEDDING_TESTS=1`) and never run in CI.
+- **Provider-aware embedding default** -- When the embedding base URL
+  points at OpenRouter and no model is configured, the default is now
+  `qwen/qwen3-embedding-8b` (4096 dimensions) instead of the OpenAI-only
+  default. An explicitly configured model always wins.
+
+### Changed
+- **Verified OpenRouter embedding lane** -- The `api` embedding provider
+  was exercised live against `qwen/qwen3-embedding-8b` on OpenRouter:
+  a 100-text batch, cache round-trip, and provider-singleton stability all
+  pass. Docs cover the env-var form and borrowing `OPENROUTER_API_KEY`.
+- **Multimodal vision option documented** -- Image analysis can run on the
+  LLM lane through an OpenAI-compatible vision endpoint, including
+  OpenRouter models such as `qwen/qwen3-vl-8b-instruct`.
+
 ## [1.4.6] - 2026-08-14
 
 ### Added