dsh-tdai-memory 0.4.1 → 0.4.2

package/recall-inject.js

@@ -1,86 +1,88 @@
-/**
- * tdai-recall-inject — agent-plane recall injection row for dsh-tdai-memory.
- *
- * Mounted INSIDE an agent preset (agent.cordis.yml), this row listens on the
- * `system-prompt/assemble` waterfall in the preset's scope, so it runs for
- * every assembly of every agent joined to that preset (agent -> preset scope
- * chain). It asks the `tdaiMemory` service (provided by the root-level
- * dsh-tdai-memory plugin) for relevant long-term memories and appends them
- * as dynamic context sections (user-role snapshots):
- *
- *   - tdai:recall  — relevant L1 memories for the current user message
- *   - tdai:profile — stable persona / scene navigation context
- *
- * The recall call is bounded by `recall.timeoutMs`; failures degrade to no
- * injection and never break the assembly.
- */
-import z from "@deepseek-ai/schemastery";
-
-/** Cordis plugin name. */
-const name = "tdai-recall-inject";
-/** Services consumed: the prompt registry and the memory core service. */
-const inject = ["systemPrompt", "tdaiMemory"];
-
-/** Runtime schema for the recall-inject row. */
-const Config = z.object({
-  /** Skip recall when the user message is shorter than this. */
-  minUserTextChars: z.number().default(1),
-  /** Per-session cache TTL for identical user text (ms). */
-  cacheTtlMs: z.number().default(30_000),
-});
-
-function apply(ctx, config) {
-  const cache = new Map();
-
-  ctx.on("system-prompt/assemble", async (assembly, context) => {
-    try {
-      const agent = context?.agent;
-      if (!agent) return assembly;
-      const session = agent.session;
-      if (!session) return assembly;
-      // Only real human input triggers recall. DSH injects synthetic
-      // user-role context (system reminders, runtime context, skill
-      // catalogs, …) whose source.kind is not "user"; recalling on those
-      // would pollute the prompt with irrelevant memories (issue #1).
-      const lastUser = [...session.deriveMessages()]
-        .reverse()
-        .find((m) => m.role === "user" && (m.source == null || m.source.kind === "user"));
-      if (!lastUser) return assembly;
-      const text = extractText(lastUser.content);
-      if (!text || text.length < config.minUserTextChars) return assembly;
-
-      const now = Date.now();
-      const cached = cache.get(session.id);
-      if (cached && cached.text === text && now - cached.ts < config.cacheTtlMs) {
-        return injectRecall(assembly, cached.result);
-      }
-      const result = await ctx.tdaiMemory
-        .handleBeforeRecall(text, session.id)
-        .catch(() => null);
-      cache.set(session.id, { text, result: result ?? {}, ts: now });
-      return injectRecall(assembly, result ?? {});
-    } catch {
-      return assembly;
-    }
-  });
-}
-
-function extractText(content) {
-  if (typeof content === "string") return content.trim();
-  if (!Array.isArray(content)) return "";
-  return content
-    .filter((b) => b && b.type === "text" && typeof b.text === "string")
-    .map((b) => b.text)
-    .join("\n")
-    .trim();
-}
-
-function injectRecall(assembly, result) {
-  const extras = [];
-  if (result.prependContext) extras.push({ name: "tdai:recall", order: 1000, text: result.prependContext });
-  if (result.appendSystemContext) extras.push({ name: "tdai:profile", order: 1001, text: result.appendSystemContext });
-  if (extras.length === 0) return assembly;
-  return { ...assembly, contexts: [...assembly.contexts, ...extras] };
-}
-
-export { Config, apply, inject, name };
+/**
+ * tdai-recall-inject — agent-plane recall injection row for dsh-tdai-memory.
+ *
+ * Mounted INSIDE an agent preset (agent.cordis.yml), this row listens on the
+ * `system-prompt/assemble` waterfall in the preset's scope, so it runs for
+ * every assembly of every agent joined to that preset (agent -> preset scope
+ * chain). It asks the `tdaiMemory` service (provided by the root-level
+ * dsh-tdai-memory plugin) for relevant long-term memories and appends them
+ * as dynamic context sections (user-role snapshots):
+ *
+ *   - tdai:recall  — relevant L1 memories for the current user message
+ *   - tdai:profile — stable persona / scene navigation context
+ *
+ * The recall call is bounded by this row's `timeoutMs`; failures degrade to no
+ * injection and never break the assembly.
+ */
+import z from "@deepseek-ai/schemastery";
+import { createRecallCache, recallWithTimeout } from "./recall-runtime.js";
+
+/** Cordis plugin name. */
+const name = "tdai-recall-inject";
+/** Services consumed: the prompt registry and the memory core service. */
+const inject = ["systemPrompt", "tdaiMemory"];
+
+/** Runtime schema for the recall-inject row. */
+const Config = z.object({
+  /** Skip recall when the user message is shorter than this. */
+  minUserTextChars: z.number().default(1),
+  /** Per-session cache TTL for identical user text (ms). */
+  cacheTtlMs: z.number().default(30_000),
+  /** Assembly deadline even when the memory service does not settle. */
+  timeoutMs: z.number().default(4000),
+});
+
+function apply(ctx, config) {
+  const cache = createRecallCache(config.cacheTtlMs ?? 30_000);
+
+  ctx.on("system-prompt/assemble", async (assembly, context) => {
+    try {
+      const agent = context?.agent;
+      if (!agent) return assembly;
+      const session = agent.session;
+      if (!session) return assembly;
+      // Only real human input triggers recall. DSH injects synthetic
+      // user-role context (system reminders, runtime context, skill
+      // catalogs, …) whose source.kind is not "user"; recalling on those
+      // would pollute the prompt with irrelevant memories (issue #1).
+      const lastUser = [...session.deriveMessages()]
+        .reverse()
+        .find((m) => m.role === "user" && (m.source == null || m.source.kind === "user"));
+      if (!lastUser) return assembly;
+      const text = extractText(lastUser.content);
+      if (!text || text.length < config.minUserTextChars) return assembly;
+
+      const cached = cache.get(session.id, text);
+      if (cached !== undefined) {
+        return injectRecall(assembly, cached);
+      }
+      const result = await recallWithTimeout(
+        () => ctx.tdaiMemory.handleBeforeRecall(text, session.id), config.timeoutMs,
+      );
+      cache.set(session.id, text, result);
+      return injectRecall(assembly, result ?? {});
+    } catch {
+      return assembly;
+    }
+  });
+}
+
+function extractText(content) {
+  if (typeof content === "string") return content.trim();
+  if (!Array.isArray(content)) return "";
+  return content
+    .filter((b) => b && b.type === "text" && typeof b.text === "string")
+    .map((b) => b.text)
+    .join("\n")
+    .trim();
+}
+
+function injectRecall(assembly, result) {
+  const extras = [];
+  if (result.prependContext) extras.push({ name: "tdai:recall", order: 1000, text: result.prependContext });
+  if (result.appendSystemContext) extras.push({ name: "tdai:profile", order: 1001, text: result.appendSystemContext });
+  if (extras.length === 0) return assembly;
+  return { ...assembly, contexts: [...assembly.contexts, ...extras] };
+}
+
+export { Config, apply, inject, name };

package/recall-runtime.js

@@ -0,0 +1,42 @@
+/** Bound recall latency without leaving a timer behind after a fast result.
+ * The underlying operation may continue; late failures remain handled. */
+export async function recallWithTimeout(operation, timeoutMs = 4000) {
+  const delay = Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs : 4000;
+  let timer;
+  try {
+    return await Promise.race([
+      Promise.resolve().then(operation),
+      new Promise(resolve => { timer = setTimeout(() => resolve(null), delay); }),
+    ]);
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+/** Expiring, capacity-limited per-session cache for long-running hosts. */
+export function createRecallCache(ttlMs = 30_000, capacity = 128, now = Date.now) {
+  const entries = new Map();
+  function prune() {
+    const time = now();
+    for (const [key, entry] of entries) {
+      if (time - entry.ts >= ttlMs) entries.delete(key);
+    }
+  }
+  return {
+    get(sessionId, text) {
+      prune();
+      const entry = entries.get(sessionId);
+      return entry?.text === text ? entry.result : undefined;
+    },
+    set(sessionId, text, result) {
+      prune();
+      if (ttlMs <= 0 || capacity <= 0 || result == null) return;
+      entries.delete(sessionId);
+      entries.set(sessionId, { text, result, ts: now() });
+      while (entries.size > capacity) entries.delete(entries.keys().next().value);
+    },
+    clear() { entries.clear(); },
+  };
+}

package/vendor/tdai/adapters/index.js

@@ -1,15 +1,15 @@
-/**
- * TDAI Adapters — barrel re-export for all host adapter implementations.
- *
- * Each adapter translates a specific host environment's API into
- * the host-neutral HostAdapter interface consumed by TdaiCore.
- *
- * Directory structure:
- *   adapters/
- *   ├── openclaw/      — OpenClaw plugin host (in-process, runEmbeddedPiAgent)
- *   └── standalone/    — Gateway / Hermes sidecar (HTTP, OpenAI-compatible API)
- */
-// OpenClaw adapter
-export { OpenClawHostAdapter, OpenClawLLMRunner, OpenClawLLMRunnerFactory } from "./openclaw/index.js";
-// Standalone adapter
-export { StandaloneHostAdapter, StandaloneLLMRunner, StandaloneLLMRunnerFactory } from "./standalone/index.js";
+/**
+ * TDAI Adapters — barrel re-export for all host adapter implementations.
+ *
+ * Each adapter translates a specific host environment's API into
+ * the host-neutral HostAdapter interface consumed by TdaiCore.
+ *
+ * Directory structure:
+ *   adapters/
+ *   ├── openclaw/      — OpenClaw plugin host (in-process, runEmbeddedPiAgent)
+ *   └── standalone/    — Gateway / Hermes sidecar (HTTP, OpenAI-compatible API)
+ */
+// OpenClaw adapter
+export { OpenClawHostAdapter, OpenClawLLMRunner, OpenClawLLMRunnerFactory } from "./openclaw/index.js";
+// Standalone adapter
+export { StandaloneHostAdapter, StandaloneLLMRunner, StandaloneLLMRunnerFactory } from "./standalone/index.js";

package/vendor/tdai/adapters/openclaw/host-adapter.js

@@ -1,83 +1,83 @@
-/**
- * OpenClawHostAdapter — translates OpenClaw's plugin API into TDAI Core's
- * unified HostAdapter interface.
- *
- * This is the "thin shell" that keeps OpenClaw-specific dependencies
- * (OpenClawPluginApi, pluginConfig, resolveStateDir, event system)
- * confined to the adapter layer while TDAI Core remains host-neutral.
- *
- * Usage (in index.ts):
- *   const adapter = new OpenClawHostAdapter({ api, pluginDataDir, config });
- *   const core = new TdaiCore({ hostAdapter: adapter, config: parsedConfig });
- */
-import { OpenClawLLMRunnerFactory } from "./llm-runner.js";
-// ============================
-// OpenClawHostAdapter
-// ============================
-export class OpenClawHostAdapter {
-    hostType = "openclaw";
-    api;
-    pluginDataDir;
-    openclawConfig;
-    runnerFactory;
-    constructor(opts) {
-        this.api = opts.api;
-        this.pluginDataDir = opts.pluginDataDir;
-        this.openclawConfig = opts.openclawConfig;
-        this.runnerFactory = new OpenClawLLMRunnerFactory({
-            config: opts.openclawConfig,
-            agentRuntime: opts.api.runtime.agent,
-            logger: opts.api.logger,
-        });
-    }
-    /**
-     * Build a RuntimeContext from the current OpenClaw session.
-     *
-     * In OpenClaw, sessionKey and sessionId come from the event/ctx objects
-     * passed to hooks. This method returns a context with sensible defaults;
-     * callers can override sessionKey/sessionId per-hook invocation using
-     * `buildRuntimeContextForSession()`.
-     */
-    getRuntimeContext() {
-        return {
-            userId: "default_user",
-            sessionId: "",
-            sessionKey: "",
-            platform: "openclaw",
-            workspaceDir: process.cwd(),
-            dataDir: this.pluginDataDir,
-        };
-    }
-    /**
-     * Build a RuntimeContext for a specific session (used per-hook).
-     *
-     * This is an OpenClaw-specific convenience that merges session-level
-     * identifiers from hook ctx into the base context.
-     */
-    buildRuntimeContextForSession(sessionKey, sessionId) {
-        return {
-            ...this.getRuntimeContext(),
-            sessionKey,
-            sessionId: sessionId ?? "",
-        };
-    }
-    getLogger() {
-        return this.api.logger;
-    }
-    getLLMRunnerFactory() {
-        return this.runnerFactory;
-    }
-    // -- OpenClaw-specific accessors (for index.ts bridge) --------------------
-    /** Get the raw OpenClaw plugin API (for legacy callers during migration). */
-    getPluginApi() {
-        return this.api;
-    }
-    /** Get the OpenClaw config object (for legacy callers during migration). */
-    getOpenClawConfig() {
-        return this.openclawConfig;
-    }
-    /** Get the resolved plugin data directory. */
-    getPluginDataDir() {
-        return this.pluginDataDir;
-    }
-}
+/**
+ * OpenClawHostAdapter — translates OpenClaw's plugin API into TDAI Core's
+ * unified HostAdapter interface.
+ *
+ * This is the "thin shell" that keeps OpenClaw-specific dependencies
+ * (OpenClawPluginApi, pluginConfig, resolveStateDir, event system)
+ * confined to the adapter layer while TDAI Core remains host-neutral.
+ *
+ * Usage (in index.ts):
+ *   const adapter = new OpenClawHostAdapter({ api, pluginDataDir, config });
+ *   const core = new TdaiCore({ hostAdapter: adapter, config: parsedConfig });
+ */
+import { OpenClawLLMRunnerFactory } from "./llm-runner.js";
+// ============================
+// OpenClawHostAdapter
+// ============================
+export class OpenClawHostAdapter {
+    hostType = "openclaw";
+    api;
+    pluginDataDir;
+    openclawConfig;
+    runnerFactory;
+    constructor(opts) {
+        this.api = opts.api;
+        this.pluginDataDir = opts.pluginDataDir;
+        this.openclawConfig = opts.openclawConfig;
+        this.runnerFactory = new OpenClawLLMRunnerFactory({
+            config: opts.openclawConfig,
+            agentRuntime: opts.api.runtime.agent,
+            logger: opts.api.logger,
+        });
+    }
+    /**
+     * Build a RuntimeContext from the current OpenClaw session.
+     *
+     * In OpenClaw, sessionKey and sessionId come from the event/ctx objects
+     * passed to hooks. This method returns a context with sensible defaults;
+     * callers can override sessionKey/sessionId per-hook invocation using
+     * `buildRuntimeContextForSession()`.
+     */
+    getRuntimeContext() {
+        return {
+            userId: "default_user",
+            sessionId: "",
+            sessionKey: "",
+            platform: "openclaw",
+            workspaceDir: process.cwd(),
+            dataDir: this.pluginDataDir,
+        };
+    }
+    /**
+     * Build a RuntimeContext for a specific session (used per-hook).
+     *
+     * This is an OpenClaw-specific convenience that merges session-level
+     * identifiers from hook ctx into the base context.
+     */
+    buildRuntimeContextForSession(sessionKey, sessionId) {
+        return {
+            ...this.getRuntimeContext(),
+            sessionKey,
+            sessionId: sessionId ?? "",
+        };
+    }
+    getLogger() {
+        return this.api.logger;
+    }
+    getLLMRunnerFactory() {
+        return this.runnerFactory;
+    }
+    // -- OpenClaw-specific accessors (for index.ts bridge) --------------------
+    /** Get the raw OpenClaw plugin API (for legacy callers during migration). */
+    getPluginApi() {
+        return this.api;
+    }
+    /** Get the OpenClaw config object (for legacy callers during migration). */
+    getOpenClawConfig() {
+        return this.openclawConfig;
+    }
+    /** Get the resolved plugin data directory. */
+    getPluginDataDir() {
+        return this.pluginDataDir;
+    }
+}

package/vendor/tdai/adapters/openclaw/index.js

@@ -1,5 +1,5 @@
-/**
- * OpenClaw adapter — barrel exports.
- */
-export { OpenClawHostAdapter } from "./host-adapter.js";
-export { OpenClawLLMRunner, OpenClawLLMRunnerFactory } from "./llm-runner.js";
+/**
+ * OpenClaw adapter — barrel exports.
+ */
+export { OpenClawHostAdapter } from "./host-adapter.js";
+export { OpenClawLLMRunner, OpenClawLLMRunnerFactory } from "./llm-runner.js";

package/vendor/tdai/adapters/openclaw/llm-runner.js

@@ -1,69 +1,69 @@
-/**
- * OpenClawLLMRunner — wraps the existing CleanContextRunner as a host-neutral LLMRunner.
- *
- * This is a compatibility bridge: TDAI Core modules (L1 extractor, L2 scene extractor,
- * L3 persona generator, L1 dedup) can depend on the `LLMRunner` interface, while
- * OpenClaw continues to use its native `runEmbeddedPiAgent` mechanism under the hood.
- *
- * Usage:
- *   const factory = new OpenClawLLMRunnerFactory({ config, agentRuntime, logger });
- *   const runner = factory.createRunner({ modelRef: "openai/gpt-4o", enableTools: true });
- *   const result = await runner.run({ prompt: "...", taskId: "l1-extraction" });
- */
-import { CleanContextRunner } from "../../utils/clean-context-runner.js";
-const TAG = "[memory-tdai] [openclaw-runner]";
-// ============================
-// OpenClawLLMRunner
-// ============================
-/**
- * LLMRunner implementation backed by CleanContextRunner.
- *
- * Each instance is configured with a fixed model + tools setting.
- * Create via `OpenClawLLMRunnerFactory.createRunner()`.
- */
-export class OpenClawLLMRunner {
-    runner;
-    constructor(runner) {
-        this.runner = runner;
-    }
-    async run(params) {
-        return this.runner.run({
-            prompt: params.prompt,
-            systemPrompt: params.systemPrompt,
-            taskId: params.taskId,
-            timeoutMs: params.timeoutMs,
-            maxTokens: params.maxTokens,
-            workspaceDir: params.workspaceDir,
-            instanceId: params.instanceId,
-        });
-    }
-}
-/**
- * Factory that creates OpenClawLLMRunner instances.
- *
- * Encapsulates the OpenClaw-specific dependencies (config, agentRuntime)
- * so that callers only need to specify model + tools.
- */
-export class OpenClawLLMRunnerFactory {
-    config;
-    agentRuntime;
-    logger;
-    constructor(opts) {
-        this.config = opts.config;
-        this.agentRuntime = opts.agentRuntime;
-        this.logger = opts.logger;
-    }
-    createRunner(opts) {
-        const enableTools = opts?.enableTools ?? false;
-        const modelRef = opts?.modelRef;
-        this.logger?.debug?.(`${TAG} Creating OpenClawLLMRunner: model=${modelRef ?? "(default)"}, tools=${enableTools}`);
-        const cleanRunner = new CleanContextRunner({
-            config: this.config,
-            modelRef,
-            enableTools,
-            agentRuntime: this.agentRuntime,
-            logger: this.logger,
-        });
-        return new OpenClawLLMRunner(cleanRunner);
-    }
-}
+/**
+ * OpenClawLLMRunner — wraps the existing CleanContextRunner as a host-neutral LLMRunner.
+ *
+ * This is a compatibility bridge: TDAI Core modules (L1 extractor, L2 scene extractor,
+ * L3 persona generator, L1 dedup) can depend on the `LLMRunner` interface, while
+ * OpenClaw continues to use its native `runEmbeddedPiAgent` mechanism under the hood.
+ *
+ * Usage:
+ *   const factory = new OpenClawLLMRunnerFactory({ config, agentRuntime, logger });
+ *   const runner = factory.createRunner({ modelRef: "openai/gpt-4o", enableTools: true });
+ *   const result = await runner.run({ prompt: "...", taskId: "l1-extraction" });
+ */
+import { CleanContextRunner } from "../../utils/clean-context-runner.js";
+const TAG = "[memory-tdai] [openclaw-runner]";
+// ============================
+// OpenClawLLMRunner
+// ============================
+/**
+ * LLMRunner implementation backed by CleanContextRunner.
+ *
+ * Each instance is configured with a fixed model + tools setting.
+ * Create via `OpenClawLLMRunnerFactory.createRunner()`.
+ */
+export class OpenClawLLMRunner {
+    runner;
+    constructor(runner) {
+        this.runner = runner;
+    }
+    async run(params) {
+        return this.runner.run({
+            prompt: params.prompt,
+            systemPrompt: params.systemPrompt,
+            taskId: params.taskId,
+            timeoutMs: params.timeoutMs,
+            maxTokens: params.maxTokens,
+            workspaceDir: params.workspaceDir,
+            instanceId: params.instanceId,
+        });
+    }
+}
+/**
+ * Factory that creates OpenClawLLMRunner instances.
+ *
+ * Encapsulates the OpenClaw-specific dependencies (config, agentRuntime)
+ * so that callers only need to specify model + tools.
+ */
+export class OpenClawLLMRunnerFactory {
+    config;
+    agentRuntime;
+    logger;
+    constructor(opts) {
+        this.config = opts.config;
+        this.agentRuntime = opts.agentRuntime;
+        this.logger = opts.logger;
+    }
+    createRunner(opts) {
+        const enableTools = opts?.enableTools ?? false;
+        const modelRef = opts?.modelRef;
+        this.logger?.debug?.(`${TAG} Creating OpenClawLLMRunner: model=${modelRef ?? "(default)"}, tools=${enableTools}`);
+        const cleanRunner = new CleanContextRunner({
+            config: this.config,
+            modelRef,
+            enableTools,
+            agentRuntime: this.agentRuntime,
+            logger: this.logger,
+        });
+        return new OpenClawLLMRunner(cleanRunner);
+    }
+}