@cuylabs/agent-core 4.8.1 → 4.10.0

package/dist/{chunk-HSUPTXNV.js → chunk-EBVSPHXA.js}

@@ -1,10 +1,10 @@
-import {
-  Tool
-} from "./chunk-Q742PSH3.js";
 import {
   buildEntryPath,
   deserializeMessage
-} from "./chunk-H3GRHFFG.js";
+} from "./chunk-VMGZKIFT.js";
+import {
+  Tool
+} from "./chunk-MJML3A2F.js";
 
 // src/agent/session.ts
 async function ensureSessionLoaded(options) {
@@ -67,14 +67,17 @@ function getVisibleSessionMessages(sessions) {
   let skipUntilId;
   for (const entry of path) {
     if (entry.type === "compaction") {
-      visible.push({
-        id: entry.id,
-        role: "system",
-        content: `## Previous Conversation Summary
+      visible.length = 0;
+      if (entry.displaySummary !== false) {
+        visible.push({
+          id: entry.id,
+          role: "system",
+          content: `## Previous Conversation Summary
 
 ${entry.summary}`,
-        createdAt: new Date(entry.timestamp)
-      });
+          createdAt: new Date(entry.timestamp)
+        });
+      }
       skipUntilId = entry.firstKeptEntryId !== entry.id ? entry.firstKeptEntryId : void 0;
       continue;
     }

package/dist/chunk-EEAGM5MS.js

@@ -0,0 +1,257 @@
+// 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
+    },
+    turns: resolveAgentMemoryTurnConfig(config.turns),
+    tools: {
+      enabled: tools.enabled ?? true,
+      deferred: tools.deferred ?? false
+    }
+  };
+}
+function resolveAgentMemoryTurnConfig(input) {
+  const turns = input && typeof input === "object" ? input : { enabled: input !== false };
+  return {
+    enabled: turns.enabled ?? true,
+    contextMessageLimit: resolveContextMessageLimit(turns.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 notifyTurnStart(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 notifyTurnEnd(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 turns = resolveAgentMemoryTurnConfig(options.turns);
+  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 onChatStart(sessionId, message, ctx) {
+      activeInputs.set(turnKey(sessionId, ctx?.turnId), message);
+      if (!turns.enabled) return;
+      await notifyTurnStart({
+        provider: options.provider,
+        sessionId,
+        ...ctx?.turnId ? { turnId: ctx.turnId } : {},
+        cwd: options.cwd ?? process.cwd(),
+        input: message,
+        messages: collectTurnContextMessages({
+          history: ctx?.history,
+          limit: turns.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 (!turns.enabled) return;
+      await notifyTurnEnd({
+        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: turns.contextMessageLimit,
+          input,
+          ...result.output !== void 0 ? { output: result.output } : {}
+        })
+      });
+    }
+  };
+}
+
+export {
+  resolveAgentMemoryConfig,
+  resolveAgentMemoryTurnConfig,
+  normalizeMemoryRecords,
+  formatMemoryContextFragment,
+  createMemoryMiddleware
+};

package/dist/chunk-IQA64CAO.js

@@ -0,0 +1,84 @@
+import {
+  applyAgentContextFragmentsWithReport
+} from "./chunk-AAGKWUXR.js";
+
+// src/context/assembly/prepare.ts
+var DEFAULT_CONTEXT_FRAGMENT_BUDGET_RATIO = 0.1;
+var DEFAULT_MAX_CONTEXT_FRAGMENT_ESTIMATED_TOKENS = 8e3;
+var DEFAULT_MIN_CONTEXT_FRAGMENT_ESTIMATED_TOKENS = 512;
+async function collectRequestedContextFragments(options) {
+  const explicitContextFragments = [...options.contextFragments ?? []];
+  const collector = options.contextFragmentCollector;
+  if (!collector || collector.hasMiddleware === false) {
+    return explicitContextFragments;
+  }
+  const collected = await collector.collectContextFragments({
+    sessionId: options.sessionId,
+    ...options.turnId ? { turnId: options.turnId } : {},
+    step: options.step,
+    cwd: options.cwd,
+    messages: options.messages,
+    toolNames: options.toolNames ?? [],
+    mcpToolNames: options.mcpToolNames ?? [],
+    ...options.abort ? { abort: options.abort } : {}
+  });
+  return [...explicitContextFragments, ...collected];
+}
+function normalizeMaxEstimatedTokens(value) {
+  if (value === void 0 || !Number.isFinite(value)) return void 0;
+  return Math.max(0, Math.floor(value));
+}
+function resolveContextFragmentBudget(options) {
+  const configuredMaxEstimatedTokens = normalizeMaxEstimatedTokens(
+    options.configured?.maxEstimatedTokens
+  );
+  if (configuredMaxEstimatedTokens !== void 0) {
+    return { maxEstimatedTokens: configuredMaxEstimatedTokens };
+  }
+  if (!options.windowBefore) return void 0;
+  const proportional = Math.floor(
+    options.windowBefore.limit * DEFAULT_CONTEXT_FRAGMENT_BUDGET_RATIO
+  );
+  return {
+    maxEstimatedTokens: Math.min(
+      DEFAULT_MAX_CONTEXT_FRAGMENT_ESTIMATED_TOKENS,
+      Math.max(DEFAULT_MIN_CONTEXT_FRAGMENT_ESTIMATED_TOKENS, proportional)
+    )
+  };
+}
+async function assembleModelContext(options) {
+  const baseMessages = [...options.messages];
+  const windowBefore = options.window?.getStats(baseMessages);
+  const requestedContextFragments = await collectRequestedContextFragments(options);
+  const contextFragmentBudget = resolveContextFragmentBudget({
+    configured: options.contextFragmentBudget,
+    windowBefore
+  });
+  const contextFragmentResult = applyAgentContextFragmentsWithReport(
+    baseMessages,
+    requestedContextFragments,
+    contextFragmentBudget ? { budget: contextFragmentBudget } : {}
+  );
+  const messages = contextFragmentResult.messages;
+  const windowAfter = options.window?.getStats(messages);
+  const report = {
+    sessionId: options.sessionId,
+    ...options.turnId ? { turnId: options.turnId } : {},
+    step: options.step,
+    messages: {
+      inputCount: baseMessages.length,
+      outputCount: messages.length
+    },
+    contextFragments: contextFragmentResult.report,
+    window: {
+      ...windowBefore ? { before: windowBefore } : {},
+      ...windowAfter ? { after: windowAfter } : {}
+    },
+    ...options.compaction ? { compaction: options.compaction } : {}
+  };
+  return { messages, report };
+}
+
+export {
+  assembleModelContext
+};

package/dist/chunk-JFH6HBUG.js

@@ -0,0 +1,227 @@
+import {
+  advanceAgentTurnState,
+  createAgentTurnState,
+  failAgentTurnState
+} from "./chunk-E66PKKDL.js";
+import {
+  currentScope,
+  snapshotScope,
+  withinScope
+} from "./chunk-AHDCR7SX.js";
+import {
+  silentLogger
+} from "./chunk-S6AKEPAX.js";
+
+// src/execution/task/observer.ts
+function defaultAgentTaskCheckpointStrategy(input) {
+  switch (input.event.type) {
+    case "step-finish":
+      return "step-finish";
+    case "tool-result":
+      return "tool-result";
+    case "tool-error":
+      return "tool-error";
+    case "turn-boundary":
+      return input.event.boundary;
+    case "complete":
+      return "task-complete";
+    default:
+      return void 0;
+  }
+}
+
+// src/execution/task/runner.ts
+import { randomUUID } from "crypto";
+function normalizeNonEmpty(value, label) {
+  const normalized = value.trim();
+  if (!normalized) {
+    throw new Error(`${label} must not be empty`);
+  }
+  return normalized;
+}
+function sanitizeSegment(input) {
+  return input.trim().toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+}
+function buildRuntimeSessionId(prefix, key) {
+  const timestamp = Date.now().toString(36);
+  const suffix = randomUUID().slice(0, 8);
+  const normalizedPrefix = sanitizeSegment(prefix) || "runtime";
+  const normalizedKey = key ? sanitizeSegment(key) : "";
+  if (normalizedKey) {
+    return `${normalizedPrefix}:${normalizedKey}:${timestamp}:${suffix}`;
+  }
+  return `${normalizedPrefix}:${timestamp}:${suffix}`;
+}
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+async function notifyObservers(observers, invoke, logger) {
+  for (const observer of observers) {
+    try {
+      await invoke(observer);
+    } catch (error) {
+      logger.warn("observer error", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+}
+function createAgentTaskRunner(agent, options = {}) {
+  const prefix = options.sessionPrefix ?? "runtime";
+  const baseObservers = options.observers ?? [];
+  const checkpointStrategy = options.checkpointStrategy ?? defaultAgentTaskCheckpointStrategy;
+  const log = options.logger?.child("task-runner") ?? silentLogger;
+  return async (payload, context = {}) => {
+    const message = normalizeNonEmpty(payload.message, "payload.message");
+    const resolvedSessionId = payload.sessionId?.trim() || options.resolveSessionId?.(payload, context)?.trim() || buildRuntimeSessionId(prefix, context.fallbackSessionKey);
+    const sessionId = normalizeNonEmpty(resolvedSessionId, "sessionId");
+    const startedAt = nowIso();
+    const executionId = context.executionId?.trim() || `${sessionId}:${startedAt}`;
+    return withinScope(
+      {
+        kind: "task",
+        name: "agent-task",
+        sessionId,
+        taskId: context.fallbackSessionKey ?? sessionId,
+        attributes: {
+          ...context.trigger ? { trigger: context.trigger } : {}
+        }
+      },
+      async () => {
+        const run = {
+          payload,
+          context,
+          sessionId,
+          executionId,
+          startedAt: context.restoreFrom?.startedAt ?? startedAt,
+          scope: snapshotScope()
+        };
+        const toolCalls = context.restoreFrom?.toolCalls.map((tc) => ({ ...tc })) ?? [];
+        let turnState = createAgentTurnState({
+          sessionId,
+          startedAt: context.restoreFrom?.startedAt ?? startedAt,
+          restoreFrom: context.restoreFrom ? {
+            response: context.restoreFrom.response,
+            usage: { ...context.restoreFrom.usage },
+            step: context.restoreFrom.step,
+            eventCount: context.restoreFrom.eventCount
+          } : void 0
+        });
+        const createSnapshot = () => ({
+          sessionId,
+          response: turnState.response,
+          usage: { ...turnState.usage },
+          toolCalls: toolCalls.map((toolCall) => ({ ...toolCall })),
+          eventCount: turnState.eventCount,
+          activeStep: turnState.step > 0 ? turnState.step : void 0,
+          lastEvent: turnState.lastEvent,
+          error: turnState.error,
+          startedAt: turnState.startedAt,
+          updatedAt: turnState.updatedAt,
+          turnState,
+          scope: currentScope() ?? run.scope
+        });
+        const emitCheckpoint = async (reason, event) => {
+          if (baseObservers.length === 0) {
+            return;
+          }
+          const checkpoint = {
+            run,
+            reason,
+            snapshot: createSnapshot(),
+            event,
+            createdAt: turnState.updatedAt
+          };
+          await notifyObservers(
+            baseObservers,
+            async (observer) => {
+              await observer.onCheckpoint?.(checkpoint);
+            },
+            log
+          );
+        };
+        await notifyObservers(
+          baseObservers,
+          async (observer) => {
+            await observer.onTaskStart?.(run, createSnapshot());
+          },
+          log
+        );
+        await emitCheckpoint("task-start");
+        const activateCtx = baseObservers.find((o) => o.activateContext)?.activateContext?.bind(void 0, sessionId, executionId);
+        try {
+          const processChatStream = async () => {
+            for await (const event of agent.chat(sessionId, message, {
+              abort: context.signal,
+              system: payload.system
+            })) {
+              turnState = advanceAgentTurnState(turnState, event, nowIso());
+              if (event.type === "tool-result") {
+                toolCalls.push({ name: event.toolName, result: event.result });
+              }
+              const snapshot = createSnapshot();
+              await notifyObservers(
+                baseObservers,
+                async (observer) => {
+                  await observer.onTaskEvent?.(run, event, snapshot);
+                },
+                log
+              );
+              const checkpointReason = checkpointStrategy({
+                run,
+                event,
+                snapshot
+              });
+              if (checkpointReason) {
+                await emitCheckpoint(checkpointReason, event);
+              }
+              if (event.type === "error") {
+                throw event.error;
+              }
+            }
+          };
+          if (activateCtx) {
+            await activateCtx(processChatStream);
+          } else {
+            await processChatStream();
+          }
+          const result = {
+            response: turnState.response,
+            sessionId,
+            usage: { ...turnState.usage },
+            toolCalls
+          };
+          await notifyObservers(
+            baseObservers,
+            async (observer) => {
+              await observer.onTaskComplete?.(run, result, createSnapshot());
+            },
+            log
+          );
+          return result;
+        } catch (error) {
+          const normalizedError = error instanceof Error ? error : new Error(String(error));
+          turnState = failAgentTurnState(turnState, normalizedError, nowIso());
+          await notifyObservers(
+            baseObservers,
+            async (observer) => {
+              await observer.onTaskError?.(
+                run,
+                normalizedError,
+                createSnapshot()
+              );
+            },
+            log
+          );
+          await emitCheckpoint("task-error");
+          throw normalizedError;
+        }
+      }
+    );
+  };
+}
+
+export {
+  defaultAgentTaskCheckpointStrategy,
+  createAgentTaskRunner
+};

package/dist/{chunk-MWPU2EVV.js → chunk-JUIL2NJC.js}

@@ -1,3 +1,7 @@
+import {
+  snapshotScope,
+  withinScope
+} from "./chunk-AHDCR7SX.js";
 import {
   formatApprovalDeniedReason
 } from "./chunk-T33MQXUP.js";
@@ -5,82 +9,6 @@ import {
   requiresToolHost
 } from "./chunk-FII65CN7.js";
 
-// src/scope/store.ts
-import { AsyncLocalStorage } from "async_hooks";
-import { randomUUID } from "crypto";
-var scopeStore = new AsyncLocalStorage();
-function cloneAttributes(attributes) {
-  return { ...attributes };
-}
-function cloneScope(scope) {
-  return {
-    ...scope,
-    attributes: cloneAttributes(scope.attributes)
-  };
-}
-function getStoredScope() {
-  return scopeStore.getStore();
-}
-function buildScope(options, current) {
-  const parent = options.parent === void 0 ? current : options.parent ?? void 0;
-  const id = options.id ?? randomUUID();
-  return {
-    id,
-    rootId: parent?.rootId ?? id,
-    kind: options.kind,
-    name: options.name,
-    parentId: parent?.id,
-    depth: (parent?.depth ?? -1) + 1,
-    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    sessionId: options.sessionId ?? parent?.sessionId,
-    taskId: options.taskId ?? parent?.taskId,
-    step: options.step ?? parent?.step,
-    attributes: cloneAttributes(options.attributes ?? {})
-  };
-}
-function runWithScope(scope, fn) {
-  return Promise.resolve(scopeStore.run(scope, fn));
-}
-
-// src/scope/run.ts
-function currentScope() {
-  const scope = getStoredScope();
-  return scope ? cloneScope(scope) : void 0;
-}
-function snapshotScope(scope = getStoredScope()) {
-  return scope ? cloneScope(scope) : void 0;
-}
-function withinScope(options, fn) {
-  return runWithScope(buildScope(options, getStoredScope()), fn);
-}
-function restoreScope(snapshot, fn) {
-  if (!snapshot) {
-    return Promise.resolve(fn());
-  }
-  return runWithScope(cloneScope(snapshot), fn);
-}
-async function* streamWithinScope(options, iterable) {
-  const scope = buildScope(options, getStoredScope());
-  const iterator = await runWithScope(
-    scope,
-    () => iterable[Symbol.asyncIterator]()
-  );
-  try {
-    while (true) {
-      const next = await runWithScope(scope, () => iterator.next());
-      if (next.done) {
-        return next.value;
-      }
-      yield next.value;
-    }
-  } finally {
-    const returnFn = iterator.return?.bind(iterator);
-    if (returnFn) {
-      await runWithScope(scope, () => returnFn(void 0));
-    }
-  }
-}
-
 // src/tracking/file-tracking.ts
 function extractFilePathsFromArgs(args, meta) {
   if (!meta.pathArgs || meta.pathArgs.length === 0) {
@@ -252,11 +180,6 @@ ${transformed.supplement}` : transformed.output;
 }
 
 export {
-  currentScope,
-  snapshotScope,
-  withinScope,
-  restoreScope,
-  streamWithinScope,
   extractFilePathsFromArgs,
   shouldCaptureBaseline,
   executeAgentToolCall