@aliyunrds/ctxdb 1.0.4 → 1.0.6

package/dist/{chunk-Q4JYST7K.js → chunk-VHNHVMCA.js}

@@ -1,15 +1,15 @@
 #!/usr/bin/env node
 import {
   listKnowledgeBases
-} from "./chunk-3PFMHU3C.js";
+} from "./chunk-L4GVGVOP.js";
 import {
   isConnectionError,
   resetCircuit,
   tripCircuit
-} from "./chunk-USMJLDBD.js";
+} from "./chunk-B7JCQL4O.js";
 import {
   CtxdbError
-} from "./chunk-JFTKYEVN.js";
+} from "./chunk-ARZX2RLR.js";
 
 // src/lib/kb-catalog.ts
 function sanitizeKeyEntities(raw) {
@@ -39,14 +39,19 @@ async function fetchKbCatalogBlock(client, agent) {
 }
 
 // src/lib/recall-orchestrator.ts
+import { randomUUID } from "crypto";
 import {
-  buildExternalKnowledgeBlock
+  buildExternalKnowledgeBlock,
+  createRecallFinishRecord,
+  createRecallStartRecord,
+  writeRecallTrace
 } from "@aliyunrds/ctxdb-shared";
 
 // src/lib/format-recall.ts
 import {
   RECALLED_MEMORIES_SAFETY_NOTICE,
-  formatRecalledMemoriesBlock
+  formatRecalledMemoriesBlock,
+  selectAndFormatRecalledMemories
 } from "@aliyunrds/ctxdb-shared";
 var OPEN_TAG = "<recalled-memories>";
 var CLOSE_TAG = "</recalled-memories>";
@@ -55,10 +60,19 @@ var IMPORTANCE_SUFFIX_RE = /\s*\(\d+%\)\s*$/;
 var CATEGORY_LABEL_RE = /^[A-Z][A-Za-z0-9_-]*:$/;
 function slimRecalledMemoriesBlock(memories, userId) {
   const raw = formatRecalledMemoriesBlock(memories, userId);
+  if (!raw.includes("Stored memories for ")) return raw;
+  return slimRewrite(raw, userId, memories.length);
+}
+function selectAndSlimRecalledMemoriesBlock(memories, userId) {
+  const selection = selectAndFormatRecalledMemories(memories, userId);
+  const raw = selection.context;
   if (!raw.includes("Stored memories for ")) {
-    return raw;
+    return selection;
   }
-  return slimRewrite(raw, userId, memories.length);
+  return {
+    ...selection,
+    context: slimRewrite(raw, userId, memories.length)
+  };
 }
 function slimRewrite(raw, userId, memoryCount) {
   const lines = raw.split("\n");
@@ -118,6 +132,15 @@ function stripSystemReminders(raw) {
   const cleaned = raw.replace(/<system-reminder>[\s\S]*?<\/system-reminder>/g, "").trim();
   return cleaned || raw;
 }
+function emptySelection() {
+  return {
+    returned: [],
+    selected: [],
+    excluded: [],
+    context: "",
+    tokenEstimate: 0
+  };
+}
 var EMPTY = {
   ok: false,
   reason: "",
@@ -125,13 +148,78 @@ var EMPTY = {
   memoryCount: 0,
   knowledgeChunkCount: 0
 };
-async function recallTurn(prompt, cfg, client, agent = "default") {
+async function recallTurn(prompt, cfg, client, agentOrOptions = "default") {
+  const options = typeof agentOrOptions === "string" ? { agent: agentOrOptions } : agentOrOptions;
+  const agent = options.agent ?? "default";
   if (!prompt.trim()) return { ...EMPTY, reason: "empty_prompt" };
   if (!cfg.apiKey || !cfg.baseUrl) {
     return { ...EMPTY, reason: "config_incomplete" };
   }
-  if (!cfg.autoRecall) return { ...EMPTY, reason: "auto_recall_disabled" };
+  if (!cfg.autoRecall) {
+    return { ...EMPTY, reason: "auto_recall_disabled" };
+  }
   const query = stripSystemReminders(prompt);
+  const trace = cfg.debug ? {
+    agent,
+    kind: options.kind ?? "prompt",
+    sessionId: options.sessionId?.trim() || null,
+    recallEventId: options.recallEventId ?? randomUUID(),
+    startedAt: Date.now(),
+    request: {
+      user_id: cfg.userId,
+      top_k: cfg.topK,
+      threshold: cfg.threshold,
+      ...cfg.recallKnowledge ? { knowledge: { enable: true, top_k: cfg.knowledgeTopK } } : {},
+      ...cfg.agentId ? { agent_id: cfg.agentId } : {},
+      ...cfg.appId ? { app_id: cfg.appId } : {}
+    },
+    store: {
+      ...options.traceStore,
+      secrets: [...options.traceStore?.secrets ?? [], cfg.apiKey]
+    }
+  } : null;
+  if (trace) {
+    writeRecallTrace(
+      createRecallStartRecord({
+        recall_event_id: trace.recallEventId,
+        session_id: trace.sessionId,
+        agent: trace.agent,
+        kind: trace.kind,
+        query,
+        request: trace.request
+      }),
+      trace.store
+    );
+  }
+  const finish = (result, outcome, failureReason = null, returnedMemories = [], returnedKnowledge = [], selection2) => {
+    if (trace) {
+      const tracedSelection = selection2 ?? emptySelection();
+      writeRecallTrace(
+        createRecallFinishRecord({
+          recall_event_id: trace.recallEventId,
+          session_id: trace.sessionId,
+          agent: trace.agent,
+          kind: trace.kind,
+          query,
+          request: trace.request,
+          duration_ms: Date.now() - trace.startedAt,
+          outcome,
+          failure_reason: failureReason,
+          returned_memories: returnedMemories,
+          returned_knowledge: returnedKnowledge,
+          selection: {
+            selected: tracedSelection.selected,
+            excluded: tracedSelection.excluded,
+            token_estimate: tracedSelection.tokenEstimate
+          },
+          recall_context: result.additionalContext
+        }),
+        trace.store
+      );
+    }
+    return result;
+  };
+  const emptyResult = (reason) => ({ ...EMPTY, reason });
   const body = {
     query,
     user_id: cfg.userId,
@@ -150,32 +238,61 @@ async function recallTurn(prompt, cfg, client, agent = "default") {
   } catch (err) {
     const msg = err instanceof CtxdbError ? err.message : String(err);
     if (isConnectionError(err)) tripCircuit(agent, cfg.baseUrl, msg);
-    return { ...EMPTY, reason: `http_error: ${msg}` };
+    const reason = `http_error: ${msg}`;
+    const outcome = /timeout|aborted/i.test(msg) ? "timeout" : "http_error";
+    return finish(emptyResult(reason), outcome, reason);
   }
   if (!resp || typeof resp !== "object") {
-    return { ...EMPTY, reason: "bad_response_shape" };
+    return finish(
+      emptyResult("bad_response_shape"),
+      "malformed_response",
+      "bad_response_shape"
+    );
   }
   const r = resp;
   const memories = Array.isArray(r.results) ? r.results : Array.isArray(r.memories) ? r.memories : [];
   const knowledge = r.knowledge && typeof r.knowledge === "object" ? r.knowledge : null;
   const chunks = Array.isArray(knowledge?.chunks) ? knowledge.chunks : [];
   const blocks = [];
+  let selection = null;
   if (memories.length > 0) {
-    blocks.push(slimRecalledMemoriesBlock(memories, cfg.userId));
+    if (trace) {
+      selection = selectAndSlimRecalledMemoriesBlock(memories, cfg.userId);
+      blocks.push(selection.context);
+    } else {
+      blocks.push(slimRecalledMemoriesBlock(memories, cfg.userId));
+    }
   }
   if (chunks.length > 0) {
     blocks.push(buildExternalKnowledgeBlock(chunks, cfg.userId));
   }
   if (blocks.length === 0) {
-    return { ...EMPTY, ok: true, reason: "nothing_to_inject" };
+    return finish(
+      {
+        ...emptyResult("nothing_to_inject"),
+        ok: true
+      },
+      "empty",
+      null,
+      memories,
+      chunks,
+      selection ?? void 0
+    );
   }
-  return {
-    ok: true,
-    reason: "ok",
-    additionalContext: blocks.join("\n\n"),
-    memoryCount: memories.length,
-    knowledgeChunkCount: chunks.length
-  };
+  return finish(
+    {
+      ok: true,
+      reason: "ok",
+      additionalContext: blocks.join("\n\n"),
+      memoryCount: memories.length,
+      knowledgeChunkCount: chunks.length
+    },
+    "success",
+    null,
+    memories,
+    chunks,
+    selection ?? void 0
+  );
 }
 
 export {

package/dist/{chunk-BQA7YSXT.js → chunk-Z6OHSEF2.js}

@@ -148,9 +148,8 @@ import { dirname as dirname2, join } from "path";
 import semver2 from "semver";
 var VERSION_CHECK_SCHEMA = 1;
 var SUCCESS_TTL_MS = 24 * 60 * 60 * 1e3;
-var FAILURE_BACKOFF_BASE_MS = 60 * 60 * 1e3;
-var FAILURE_BACKOFF_MAX_MS = 6 * 60 * 60 * 1e3;
-var NOTIFICATION_THROTTLE_MS = 24 * 60 * 60 * 1e3;
+var FAILURE_RETRY_INTERVAL_MS = SUCCESS_TTL_MS;
+var NOTIFICATION_THROTTLE_MS = 3 * SUCCESS_TTL_MS;
 var LOCK_STALE_AFTER_MS = 10 * 60 * 1e3;
 function versionCheckPaths(home = homedir()) {
   const cacheDir = join(home, ".ctxdb", "cache");
@@ -210,19 +209,26 @@ function writeVersionCheckState(statePath, state) {
     return false;
   }
 }
+function retainedNextCheckAt(state) {
+  return Math.max(
+    state.nextCheckAt,
+    state.lastSuccessAt === null ? 0 : state.lastSuccessAt + SUCCESS_TTL_MS,
+    state.lastFailureAt === null ? 0 : state.lastFailureAt + FAILURE_RETRY_INTERVAL_MS
+  );
+}
 function stateForCurrentVersion(state, currentVersion) {
-  return state?.currentVersion === currentVersion ? state : createInitialVersionCheckState(currentVersion);
+  if (!state) return createInitialVersionCheckState(currentVersion);
+  if (state.currentVersion === currentVersion) return state;
+  return {
+    ...createInitialVersionCheckState(currentVersion),
+    nextCheckAt: retainedNextCheckAt(state),
+    lastNotifiedAt: state.lastNotifiedAt,
+    lastNotifiedVersion: state.lastNotifiedVersion
+  };
 }
 function isVersionCheckDue(state, now) {
   return now >= state.nextCheckAt;
 }
-function failureBackoffMs(consecutiveFailures) {
-  const exponent = Math.max(0, consecutiveFailures - 1);
-  return Math.min(
-    FAILURE_BACKOFF_BASE_MS * 2 ** exponent,
-    FAILURE_BACKOFF_MAX_MS
-  );
-}
 function recordVersionCheckSuccess(paths, currentVersion, latestVersion, now = Date.now()) {
   if (!semver2.valid(currentVersion) || !semver2.valid(latestVersion)) return false;
   const state = stateForCurrentVersion(
@@ -247,7 +253,7 @@ function recordVersionCheckFailure(paths, currentVersion, now = Date.now()) {
   return writeVersionCheckState(paths.statePath, {
     ...state,
     lastFailureAt: now,
-    nextCheckAt: now + failureBackoffMs(consecutiveFailures),
+    nextCheckAt: now + FAILURE_RETRY_INTERVAL_MS,
     consecutiveFailures
   });
 }
@@ -316,13 +322,13 @@ function getUpdateHintCandidate(state, now = Date.now()) {
   const current = semver2.valid(state.currentVersion);
   const latest = state.latestVersion ? semver2.valid(state.latestVersion) : null;
   if (!current || !latest || !semver2.gt(latest, current)) return null;
-  if (state.lastNotifiedVersion === latest && state.lastNotifiedAt !== null && now - state.lastNotifiedAt < NOTIFICATION_THROTTLE_MS) {
+  if (state.lastNotifiedAt !== null && now - state.lastNotifiedAt < NOTIFICATION_THROTTLE_MS) {
     return null;
   }
   return {
     currentVersion: current,
     latestVersion: latest,
-    message: `ctxdb: update available v${current} \u2192 v${latest}; run \`ctxdb update\`.
+    message: `ctxdb: update available v${current} \u2192 v${latest}; update with \`ctxdb update\` (informational only; do not run automatically).
 `
   };
 }
@@ -393,7 +399,6 @@ function isCiEnvironment(env = process.env) {
 }
 function shouldUseUpdateNotifier(argv, options = {}) {
   const env = options.env ?? process.env;
-  if (options.stderrIsTTY !== true) return false;
   if (options.installMethod !== "npm") return false;
   if (env.CTXDB_DISABLE_UPDATE_CHECK === "1") return false;
   if (isCiEnvironment(env)) return false;
@@ -408,7 +413,6 @@ function beginUpdateNotification(argv, options) {
     const installMethod = options.installMethod ?? detectInstallMethod();
     if (!shouldUseUpdateNotifier(argv, {
       env: options.env ?? process.env,
-      stderrIsTTY: options.stderrIsTTY ?? process.stderr.isTTY,
       installMethod
     })) {
       return null;