@cuylabs/agent-core 4.9.0 → 5.0.0

package/dist/chunk-DD7S7ZG4.js

@@ -0,0 +1,274 @@
+// src/memory/config.ts
+function isMemoryConfig(input) {
+  return "provider" in input;
+}
+function resolveAgentMemoryConfig(input) {
+  if (!input) return void 0;
+  const config = isMemoryConfig(input) ? input : { provider: input };
+  const recall = typeof config.recall === "object" ? config.recall : { enabled: config.recall !== false };
+  const tools = typeof config.tools === "object" ? config.tools : { enabled: config.tools !== false };
+  return {
+    provider: config.provider,
+    recall: {
+      enabled: recall.enabled ?? true,
+      frequency: recall.frequency ?? "per-turn",
+      limit: recall.limit ?? 5,
+      maxRecords: recall.maxRecords ?? recall.limit ?? 5,
+      maxRecordChars: recall.maxRecordChars ?? 700
+    },
+    capture: resolveAgentMemoryCaptureConfig(config.capture),
+    tools: {
+      enabled: tools.enabled ?? true,
+      deferred: tools.deferred ?? false
+    }
+  };
+}
+function resolveAgentMemoryCaptureConfig(input) {
+  const capture = input && typeof input === "object" ? input : { enabled: input !== false };
+  return {
+    enabled: capture.enabled ?? true,
+    contextMessageLimit: resolveContextMessageLimit(
+      capture.contextMessageLimit
+    )
+  };
+}
+function resolveContextMessageLimit(value) {
+  if (value === void 0) return 0;
+  if (!Number.isFinite(value)) return 0;
+  return Math.max(0, Math.floor(value));
+}
+
+// src/memory/format.ts
+function normalizeMemoryRecords(result) {
+  if (!result) return [];
+  if (Array.isArray(result)) return result;
+  return result.records ?? [];
+}
+function truncateText(text, maxChars) {
+  if (text.length <= maxChars) return text;
+  return `${text.slice(0, Math.max(0, maxChars - 1)).trimEnd()}...`;
+}
+function formatMemoryRecord(record, maxRecordChars) {
+  const label = record.title?.trim() || record.kind || record.id;
+  const scope = record.scope ? ` [${record.scope}]` : "";
+  const tags = record.tags && record.tags.length > 0 ? ` (${record.tags.join(", ")})` : "";
+  return `- ${label}${scope}${tags}: ${truncateText(record.content.trim(), maxRecordChars)}`;
+}
+function formatMemoryContextFragment(options) {
+  const lines = [
+    "Relevant memory recalled for this step. Use it only when it helps answer the current user request."
+  ];
+  if (options.instructions?.trim()) {
+    lines.push("", options.instructions.trim());
+  }
+  lines.push(
+    "",
+    ...options.records.map(
+      (record) => formatMemoryRecord(record, options.maxRecordChars)
+    )
+  );
+  return lines.join("\n");
+}
+
+// src/memory/middleware.ts
+function latestRealUserMessage(messages) {
+  for (let index = messages.length - 1; index >= 0; index--) {
+    const message = messages[index];
+    if (message?.role === "user" && !message.contextFragment) {
+      return message.content;
+    }
+  }
+  return "";
+}
+function turnKey(sessionId, turnId) {
+  return `${sessionId}:${turnId ?? "latest"}`;
+}
+function recallKey(options) {
+  return `${options.sessionId}:${options.turnId ?? options.query}`;
+}
+function removeLatestMatchingMessage(messages, role, content) {
+  if (content === void 0) return [...messages];
+  const next = [...messages];
+  for (let index = next.length - 1; index >= 0; index--) {
+    const message = next[index];
+    if (message?.role === role && message.content === content) {
+      next.splice(index, 1);
+      break;
+    }
+  }
+  return next;
+}
+function collectTurnContextMessages(options) {
+  if (!options.history || options.limit <= 0) return [];
+  const currentTurnMessageAllowance = 1 + (options.output !== void 0 ? 1 : 0);
+  const messages = options.history.getRecentMessages({
+    limit: options.limit + currentTurnMessageAllowance
+  });
+  const withoutCurrentInput = removeLatestMatchingMessage(
+    messages,
+    "user",
+    options.input
+  );
+  const withoutCurrentTurn = removeLatestMatchingMessage(
+    withoutCurrentInput,
+    "assistant",
+    options.output
+  );
+  return withoutCurrentTurn.slice(-options.limit);
+}
+async function notifyCaptureStart(options) {
+  if (!options.provider.onTurnStart) return;
+  await options.provider.onTurnStart({
+    sessionId: options.sessionId,
+    ...options.turnId ? { turnId: options.turnId } : {},
+    cwd: options.cwd,
+    input: options.input,
+    messages: options.messages
+  });
+}
+async function notifyCaptureEnd(options) {
+  if (!options.provider.onTurnEnd) return;
+  const input = {
+    sessionId: options.sessionId,
+    ...options.turnId ? { turnId: options.turnId } : {},
+    cwd: options.cwd,
+    input: options.input,
+    ...options.output !== void 0 ? { output: options.output } : {},
+    ...options.error ? { error: options.error } : {},
+    ...options.usage ? { usage: options.usage } : {},
+    messages: options.messages
+  };
+  await options.provider.onTurnEnd(input);
+}
+function createMemoryMiddleware(options) {
+  const activeInputs = /* @__PURE__ */ new Map();
+  const recallCache = /* @__PURE__ */ new Map();
+  const capture = resolveAgentMemoryCaptureConfig(options.capture);
+  const recallFrequency = options.recall.frequency ?? "per-turn";
+  return {
+    name: `memory:${options.provider.id}`,
+    async contextFragments(ctx) {
+      if (!options.recall.enabled || !options.provider.recall) return void 0;
+      const query = latestRealUserMessage(ctx.messages);
+      if (query.trim().length === 0) return void 0;
+      const cacheKey = recallKey({
+        sessionId: ctx.sessionId,
+        ...ctx.turnId ? { turnId: ctx.turnId } : {},
+        query
+      });
+      let response;
+      if (recallFrequency === "per-turn" && recallCache.has(cacheKey)) {
+        response = recallCache.get(cacheKey);
+      } else {
+        response = await options.provider.recall({
+          sessionId: ctx.sessionId,
+          ...ctx.turnId ? { turnId: ctx.turnId } : {},
+          step: ctx.step,
+          cwd: ctx.cwd,
+          query,
+          messages: ctx.messages,
+          limit: options.recall.limit,
+          toolNames: ctx.toolNames,
+          mcpToolNames: ctx.mcpToolNames,
+          ...ctx.abort ? { abort: ctx.abort } : {}
+        });
+        if (recallFrequency === "per-turn") {
+          recallCache.set(cacheKey, response);
+        }
+      }
+      const records = normalizeMemoryRecords(response).slice(
+        0,
+        options.recall.maxRecords
+      );
+      if (records.length === 0) return void 0;
+      const instructions = response && !Array.isArray(response) ? response.instructions : void 0;
+      return {
+        kind: "memory",
+        title: "Relevant Memory",
+        source: options.provider.id,
+        placement: "after-latest-user",
+        lifetime: "turn",
+        budgetBehavior: "droppable",
+        dedupeKey: `memory:${options.provider.id}:recall`,
+        content: formatMemoryContextFragment({
+          records,
+          instructions,
+          maxRecordChars: options.recall.maxRecordChars
+        }),
+        metadata: {
+          providerId: options.provider.id,
+          recordIds: records.map((record) => record.id)
+        }
+      };
+    },
+    async beforeContextCompactionCommit(ctx) {
+      if (!options.provider.captureBeforeCompactionCommit) return;
+      if (ctx.removedMessages.length === 0) return;
+      await options.provider.captureBeforeCompactionCommit({
+        sessionId: ctx.sessionId,
+        ...ctx.turnId ? { turnId: ctx.turnId } : {},
+        cwd: ctx.cwd,
+        ...ctx.phase ? { phase: ctx.phase } : {},
+        removedMessages: ctx.removedMessages,
+        recentKeptMessages: ctx.keptMessages.slice(-20),
+        ...ctx.previousSummary !== void 0 ? { previousSummary: ctx.previousSummary } : {},
+        ...ctx.nextSummary !== void 0 ? { nextSummary: ctx.nextSummary } : {},
+        ...ctx.abort ? { abort: ctx.abort } : {}
+      });
+    },
+    async onChatStart(sessionId, message, ctx) {
+      activeInputs.set(turnKey(sessionId, ctx?.turnId), message);
+      if (!capture.enabled) return;
+      await notifyCaptureStart({
+        provider: options.provider,
+        sessionId,
+        ...ctx?.turnId ? { turnId: ctx.turnId } : {},
+        cwd: options.cwd ?? process.cwd(),
+        input: message,
+        messages: collectTurnContextMessages({
+          history: ctx?.history,
+          limit: capture.contextMessageLimit,
+          input: message
+        })
+      });
+    },
+    async onChatEnd(sessionId, result, ctx) {
+      const key = turnKey(sessionId, ctx?.turnId);
+      const input = activeInputs.get(key);
+      activeInputs.delete(key);
+      if (!input) return;
+      recallCache.delete(
+        recallKey({
+          sessionId,
+          ...ctx?.turnId ? { turnId: ctx.turnId } : {},
+          query: input
+        })
+      );
+      if (!capture.enabled) return;
+      await notifyCaptureEnd({
+        provider: options.provider,
+        sessionId,
+        ...ctx?.turnId ? { turnId: ctx.turnId } : {},
+        cwd: options.cwd ?? process.cwd(),
+        input,
+        ...result.output !== void 0 ? { output: result.output } : {},
+        ...result.error ? { error: result.error } : {},
+        ...result.usage ? { usage: result.usage } : {},
+        messages: collectTurnContextMessages({
+          history: ctx?.history,
+          limit: capture.contextMessageLimit,
+          input,
+          ...result.output !== void 0 ? { output: result.output } : {}
+        })
+      });
+    }
+  };
+}
+
+export {
+  resolveAgentMemoryConfig,
+  resolveAgentMemoryCaptureConfig,
+  normalizeMemoryRecords,
+  formatMemoryContextFragment,
+  createMemoryMiddleware
+};