@cuylabs/agent-core 4.9.0 → 5.0.0

package/dist/{chunk-H3GRHFFG.js → chunk-EDKZOPUV.js}

@@ -1,7 +1,11 @@
-// src/storage/types.ts
-var STORAGE_VERSION = 1;
+import {
+  createAgentContextFragmentMessage
+} from "./chunk-CGP6UNCQ.js";
+
+// src/sessions/types.ts
+var SESSION_FORMAT_VERSION = 1;
 
-// src/storage/utils.ts
+// src/sessions/utils.ts
 function generateEntryId(existingIds) {
   for (let i = 0; i < 100; i++) {
     const id = crypto.randomUUID().slice(0, 8);
@@ -34,7 +38,8 @@ function serializeMessage(message) {
     id: message.id,
     role: message.role,
     content: typeof message.content === "string" ? message.content : JSON.stringify(message.content),
-    createdAt: message.createdAt.toISOString()
+    createdAt: message.createdAt.toISOString(),
+    ...message.contextFragment ? { contextFragment: structuredClone(message.contextFragment) } : {}
   };
   if (message.role === "user" && "system" in message) {
     serialized.system = message.system;
@@ -57,7 +62,8 @@ function serializeMessage(message) {
 function deserializeMessage(serialized) {
   const base = {
     id: serialized.id,
-    createdAt: new Date(serialized.createdAt)
+    createdAt: new Date(serialized.createdAt),
+    ...serialized.contextFragment ? { contextFragment: structuredClone(serialized.contextFragment) } : {}
   };
   switch (serialized.role) {
     case "user":
@@ -129,7 +135,7 @@ function extractSessionInfo(entries, path) {
     lastTimestamp = entry.timestamp;
     if (entry.type === "message") {
       messageCount++;
-      if (!firstMessage && entry.message.role === "user") {
+      if (!firstMessage && entry.message.role === "user" && !entry.message.contextFragment) {
         firstMessage = entry.message.content.slice(0, 100);
       }
     }
@@ -208,14 +214,16 @@ function buildMessagesFromEntries(entries, leafId) {
     if (entry.type === "compaction") {
       messages.length = 0;
       skipUntilId = entry.firstKeptEntryId !== entry.id ? entry.firstKeptEntryId : void 0;
-      messages.push({
-        id: entry.id,
-        role: "system",
-        content: `## Previous Conversation Summary
+      if (entry.displaySummary !== false) {
+        messages.push({
+          id: entry.id,
+          role: "system",
+          content: `## Previous Conversation Summary
 
 ${entry.summary}`,
-        createdAt: new Date(entry.timestamp)
-      });
+          createdAt: new Date(entry.timestamp)
+        });
+      }
       continue;
     }
     if (skipUntilId && entry.id !== skipUntilId) {
@@ -262,6 +270,9 @@ function buildRecentMessagesFromEntryMap(entriesById, leafId, options = {}) {
         recent.push(message);
       }
     } else if (entry.type === "compaction") {
+      if (entry.displaySummary === false) {
+        break;
+      }
       recent.push({
         id: entry.id,
         role: "system",
@@ -287,8 +298,8 @@ function normalizeRecentMessagesLimit(limit) {
   return Math.floor(limit);
 }
 
-// src/storage/memory.ts
-var MemoryStorage = class {
+// src/sessions/store/memory.ts
+var InMemorySessionStore = class {
   sessions = /* @__PURE__ */ new Map();
   async create(header) {
     if (this.sessions.has(header.id)) {
@@ -339,224 +350,7 @@ var MemoryStorage = class {
   }
 };
 
-// src/storage/file/helpers.ts
-import {
-  appendFile,
-  mkdir,
-  readFile,
-  readdir,
-  stat,
-  unlink,
-  writeFile
-} from "fs/promises";
-import { existsSync } from "fs";
-import { basename, join } from "path";
-async function ensureStorageDirectory(directory) {
-  if (!existsSync(directory)) {
-    await mkdir(directory, { recursive: true });
-  }
-}
-function getSessionFilePath(directory, extension, sessionId) {
-  const safeId = sessionId.replace(/[^a-zA-Z0-9-_]/g, "_");
-  const needsHash = safeId !== sessionId;
-  if (needsHash) {
-    let hash = 2166136261;
-    for (let i = 0; i < sessionId.length; i++) {
-      hash ^= sessionId.charCodeAt(i);
-      hash = hash * 16777619 >>> 0;
-    }
-    const suffix = hash.toString(16).padStart(8, "0");
-    return join(directory, `${safeId}_${suffix}${extension}`);
-  }
-  return join(directory, `${safeId}${extension}`);
-}
-async function loadEntriesFromDisk(filePath, sessionId) {
-  try {
-    const content = await readFile(filePath, "utf-8");
-    return parseJSONL(content);
-  } catch (error) {
-    if (error.code === "ENOENT") {
-      throw new Error(`Session not found: ${sessionId}`);
-    }
-    throw error;
-  }
-}
-async function createSessionFile(filePath, header) {
-  await writeFile(filePath, toJSONL(header), "utf-8");
-}
-async function appendSessionEntry(filePath, entry) {
-  await appendFile(filePath, toJSONL(entry), "utf-8");
-}
-async function appendSessionEntries(filePath, entries) {
-  await appendFile(filePath, toJSONLBatch(entries), "utf-8");
-}
-function sessionFileExists(filePath) {
-  return existsSync(filePath);
-}
-async function deleteSessionFile(filePath) {
-  if (!existsSync(filePath)) {
-    return false;
-  }
-  try {
-    await unlink(filePath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function listSessionIds(directory, extension) {
-  try {
-    const files = await readdir(directory);
-    return files.filter((file) => file.endsWith(extension)).map((file) => basename(file, extension));
-  } catch {
-    return [];
-  }
-}
-async function clearSessionFiles(directory, extension) {
-  try {
-    const files = await readdir(directory);
-    await Promise.all(
-      files.filter((file) => file.endsWith(extension)).map((file) => unlink(join(directory, file)).catch(() => {
-      }))
-    );
-  } catch {
-  }
-}
-async function getSessionFileStats(filePath) {
-  try {
-    const info = await stat(filePath);
-    return {
-      size: info.size,
-      mtime: info.mtime
-    };
-  } catch {
-    return null;
-  }
-}
-
-// src/storage/file/storage.ts
-var FileStorage = class {
-  directory;
-  extension;
-  useCache;
-  cache = /* @__PURE__ */ new Map();
-  initialized = false;
-  constructor(options) {
-    this.directory = options.directory;
-    this.extension = options.extension ?? ".jsonl";
-    this.useCache = options.cache ?? true;
-  }
-  async ensureDir() {
-    if (this.initialized) return;
-    await ensureStorageDirectory(this.directory);
-    this.initialized = true;
-  }
-  getPath(sessionId) {
-    return getSessionFilePath(this.directory, this.extension, sessionId);
-  }
-  async getEntries(sessionId) {
-    if (this.useCache && this.cache.has(sessionId)) {
-      return this.cache.get(sessionId);
-    }
-    const entries = await loadEntriesFromDisk(
-      this.getPath(sessionId),
-      sessionId
-    );
-    if (this.useCache) {
-      this.cache.set(sessionId, entries);
-    }
-    return entries;
-  }
-  async create(header) {
-    await this.ensureDir();
-    const filePath = this.getPath(header.id);
-    if (sessionFileExists(filePath)) {
-      throw new Error(`Session already exists: ${header.id}`);
-    }
-    await createSessionFile(filePath, header);
-    if (this.useCache) {
-      this.cache.set(header.id, [header]);
-    }
-  }
-  async append(sessionId, entry) {
-    await this.ensureDir();
-    const filePath = this.getPath(sessionId);
-    if (!sessionFileExists(filePath)) {
-      throw new Error(`Session not found: ${sessionId}`);
-    }
-    await appendSessionEntry(filePath, entry);
-    if (this.useCache) {
-      this.cache.get(sessionId)?.push(entry);
-    }
-  }
-  async appendBatch(sessionId, entries) {
-    if (entries.length === 0) return;
-    await this.ensureDir();
-    const filePath = this.getPath(sessionId);
-    if (!sessionFileExists(filePath)) {
-      throw new Error(`Session not found: ${sessionId}`);
-    }
-    await appendSessionEntries(filePath, entries);
-    if (this.useCache) {
-      this.cache.get(sessionId)?.push(...entries);
-    }
-  }
-  async read(sessionId) {
-    await this.ensureDir();
-    return [...await this.getEntries(sessionId)];
-  }
-  async delete(sessionId) {
-    this.cache.delete(sessionId);
-    return deleteSessionFile(this.getPath(sessionId));
-  }
-  async exists(sessionId) {
-    if (this.useCache && this.cache.has(sessionId)) {
-      return true;
-    }
-    return sessionFileExists(this.getPath(sessionId));
-  }
-  async list() {
-    await this.ensureDir();
-    const infos = [];
-    for (const sessionId of await listSessionIds(
-      this.directory,
-      this.extension
-    )) {
-      try {
-        const info = extractSessionInfo(
-          await this.getEntries(sessionId),
-          this.getPath(sessionId)
-        );
-        if (info) {
-          infos.push(info);
-        }
-      } catch {
-      }
-    }
-    infos.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
-    return infos;
-  }
-  async clear() {
-    this.cache.clear();
-    await clearSessionFiles(this.directory, this.extension);
-  }
-  flushCache() {
-    this.cache.clear();
-  }
-  async reload(sessionId) {
-    this.cache.delete(sessionId);
-    return this.read(sessionId);
-  }
-  async listIds() {
-    await this.ensureDir();
-    return listSessionIds(this.directory, this.extension);
-  }
-  async getStats(sessionId) {
-    return getSessionFileStats(this.getPath(sessionId));
-  }
-};
-
-// src/storage/lock.ts
+// src/sessions/store/lock.ts
 var LocalSessionTurnLock = class {
   locks = /* @__PURE__ */ new Map();
   async acquire(sessionId, options = {}) {
@@ -631,74 +425,29 @@ function createAbortError() {
   return error;
 }
 
-// src/storage/paths.ts
-import { homedir } from "os";
-import { join as join2 } from "path";
-import { execSync } from "child_process";
-function getDataDir(appName = "cuylabs") {
-  const platform = process.platform;
-  if (platform === "darwin") {
-    return join2(homedir(), `.${appName}`);
-  }
-  if (platform === "win32") {
-    return join2(
-      process.env.APPDATA || join2(homedir(), "AppData", "Roaming"),
-      appName
-    );
-  }
-  const xdgData = process.env.XDG_DATA_HOME || join2(homedir(), ".local", "share");
-  return join2(xdgData, appName);
-}
-function getSessionsDir(appName = "cuylabs") {
-  return join2(getDataDir(appName), "sessions");
-}
-function getGitRootHash(cwd) {
-  try {
-    const result = execSync("git rev-list --max-parents=0 --all 2>/dev/null", {
-      cwd,
-      encoding: "utf-8"
-    });
-    const roots = result.split("\n").filter(Boolean).map((s) => s.trim()).sort();
-    return roots[0] || null;
-  } catch {
-    return null;
-  }
-}
-function getProjectId(cwd) {
-  const gitHash = getGitRootHash(cwd);
-  if (gitHash) {
-    return gitHash.slice(0, 12);
-  }
-  return cwd.replace(/^\//, "").replace(/[/\\:]/g, "-").replace(/\s+/g, "-").toLowerCase().slice(-50);
-}
-function getProjectSessionsDir(cwd, appName = "cuylabs") {
-  const projectId = getProjectId(cwd);
-  return join2(getSessionsDir(appName), projectId);
-}
-
-// src/storage/manager/session-manager.ts
+// src/sessions/manager/session-manager.ts
 var SessionManager = class {
-  storage;
+  store;
   currentSessionId = null;
   currentLeafId = null;
   entriesCache = [];
   idsCache = /* @__PURE__ */ new Set();
   entriesByIdCache = /* @__PURE__ */ new Map();
-  constructor(storage) {
-    this.storage = storage ?? new MemoryStorage();
+  constructor(store) {
+    this.store = store ?? new InMemorySessionStore();
   }
   async create(options) {
     const id = options.id ?? crypto.randomUUID();
     const header = {
       type: "header",
-      version: STORAGE_VERSION,
+      version: SESSION_FORMAT_VERSION,
       id,
       cwd: options.cwd,
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
       title: options.title,
       parentSessionId: options.parentSessionId
     };
-    await this.storage.create(header);
+    await this.store.create(header);
     this.currentSessionId = id;
     this.currentLeafId = null;
     this.entriesCache = [header];
@@ -707,7 +456,7 @@ var SessionManager = class {
     return id;
   }
   async load(sessionId) {
-    const entries = await this.storage.read(sessionId);
+    const entries = await this.store.read(sessionId);
     if (entries.length === 0) {
       throw new Error(`Empty session: ${sessionId}`);
     }
@@ -739,7 +488,7 @@ var SessionManager = class {
       this.currentLeafId,
       this.idsCache
     );
-    await this.storage.append(this.currentSessionId, entry);
+    await this.store.append(this.currentSessionId, entry);
     this.entriesCache.push(entry);
     this.idsCache.add(entry.id);
     this.entriesByIdCache.set(entry.id, entry);
@@ -762,11 +511,20 @@ var SessionManager = class {
       this.entriesByIdCache.set(entry.id, entry);
       parentId = entry.id;
     }
-    await this.storage.appendBatch(this.currentSessionId, entries);
+    await this.store.appendBatch(this.currentSessionId, entries);
     this.entriesCache.push(...entries);
     this.currentLeafId = entries[entries.length - 1].id;
     return entries.map((entry) => entry.id);
   }
+  async addContextFragment(contextFragment) {
+    return this.addMessage(
+      createAgentContextFragmentMessage({
+        lifetime: "session",
+        placement: "before-history",
+        ...contextFragment
+      })
+    );
+  }
   getMessages(leafId) {
     return buildMessagesFromEntries(
       this.entriesCache,
@@ -791,7 +549,7 @@ var SessionManager = class {
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
       ...options
     };
-    await this.storage.append(this.currentSessionId, entry);
+    await this.store.append(this.currentSessionId, entry);
     this.entriesCache.push(entry);
     this.idsCache.add(entry.id);
     this.entriesByIdCache.set(entry.id, entry);
@@ -817,14 +575,19 @@ var SessionManager = class {
       id: compactionId,
       parentId: this.currentLeafId,
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      ...options.phase ? { phase: options.phase } : {},
+      ...options.trigger ? { trigger: options.trigger } : {},
+      ...options.reason ? { reason: options.reason } : {},
       summary: options.summary,
+      ...options.displaySummary === false ? { displaySummary: false } : {},
       firstKeptEntryId: messageEntries[0]?.id ?? compactionId,
       tokensBefore: options.tokensBefore,
       tokensAfter: options.tokensAfter,
+      ...options.cutReason ? { cutReason: options.cutReason } : {},
       ...options.readFiles ? { readFiles: options.readFiles } : {},
       ...options.modifiedFiles ? { modifiedFiles: options.modifiedFiles } : {}
     };
-    await this.storage.appendBatch(this.currentSessionId, [
+    await this.store.appendBatch(this.currentSessionId, [
       compactionEntry,
       ...messageEntries
     ]);
@@ -851,7 +614,7 @@ var SessionManager = class {
       branchFromId: fromEntryId,
       summary
     };
-    await this.storage.append(this.currentSessionId, entry);
+    await this.store.append(this.currentSessionId, entry);
     this.entriesCache.push(entry);
     this.idsCache.add(entry.id);
     this.entriesByIdCache.set(entry.id, entry);
@@ -873,7 +636,7 @@ var SessionManager = class {
       this.currentLeafId,
       this.idsCache
     );
-    await this.storage.append(this.currentSessionId, entry);
+    await this.store.append(this.currentSessionId, entry);
     this.entriesCache.push(entry);
     this.idsCache.add(entry.id);
     this.entriesByIdCache.set(entry.id, entry);
@@ -912,10 +675,10 @@ var SessionManager = class {
     return header?.type === "header" ? header : null;
   }
   async listSessions() {
-    return this.storage.list();
+    return this.store.list();
   }
   async deleteSession(sessionId) {
-    const result = await this.storage.delete(sessionId);
+    const result = await this.store.delete(sessionId);
     if (sessionId === this.currentSessionId) {
       this.currentSessionId = null;
       this.currentLeafId = null;
@@ -926,14 +689,14 @@ var SessionManager = class {
     return result;
   }
   async sessionExists(sessionId) {
-    return this.storage.exists(sessionId);
+    return this.store.exists(sessionId);
   }
-  getStorage() {
-    return this.storage;
+  getStore() {
+    return this.store;
   }
 };
 
-// src/storage/manager/default.ts
+// src/sessions/manager/default.ts
 var defaultManager = null;
 function getDefaultSessionManager() {
   if (!defaultManager) {
@@ -941,13 +704,13 @@ function getDefaultSessionManager() {
   }
   return defaultManager;
 }
-function configureDefaultSessionManager(storage) {
-  defaultManager = new SessionManager(storage);
+function configureDefaultSessionManager(store) {
+  defaultManager = new SessionManager(store);
   return defaultManager;
 }
 
 export {
-  STORAGE_VERSION,
+  SESSION_FORMAT_VERSION,
   generateEntryId,
   parseJSONL,
   toJSONL,
@@ -962,14 +725,8 @@ export {
   buildMessagesFromEntries,
   buildRecentMessagesFromEntries,
   buildRecentMessagesFromEntryMap,
-  MemoryStorage,
-  FileStorage,
+  InMemorySessionStore,
   LocalSessionTurnLock,
-  getDataDir,
-  getSessionsDir,
-  getGitRootHash,
-  getProjectId,
-  getProjectSessionsDir,
   SessionManager,
   getDefaultSessionManager,
   configureDefaultSessionManager

package/dist/{chunk-GEBFHREI.js → chunk-GHVW7L4P.js}

@@ -1,7 +1,6 @@
 import {
-  DEFAULT_AGENT_NAME,
   isBlockedModelCall
-} from "./chunk-CJI7PVS2.js";
+} from "./chunk-W6LWIMIX.js";
 import {
   extractModelId,
   extractProvider
@@ -199,6 +198,70 @@ var MiddlewareRunner = class {
     return sections;
   }
   // --------------------------------------------------------------------------
+  // contextFragments — array order, transient model-visible context
+  // --------------------------------------------------------------------------
+  async collectContextFragments(ctx) {
+    const contextFragments = [];
+    for (const mw of this.stack) {
+      if (!mw.contextFragments) continue;
+      try {
+        const result = await mw.contextFragments(ctx);
+        if (!result) continue;
+        if (Array.isArray(result)) {
+          contextFragments.push(...result);
+        } else {
+          contextFragments.push(result);
+        }
+      } catch (err) {
+        this.log.warn(
+          `"${mw.name}" contextFragments error: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }
+    return contextFragments;
+  }
+  // --------------------------------------------------------------------------
+  // context compaction commit lifecycle — before in array order, after in reverse order
+  // --------------------------------------------------------------------------
+  /**
+   * Run all `beforeContextCompactionCommit` hooks in order.
+   *
+   * Hooks are awaited because durability work, such as memory capture, must
+   * complete before old context is replaced. Errors are logged and do not abort
+   * compaction.
+   */
+  async runBeforeContextCompactionCommit(ctx) {
+    for (const mw of this.stack) {
+      if (!mw.beforeContextCompactionCommit) continue;
+      try {
+        await mw.beforeContextCompactionCommit(ctx);
+      } catch (err) {
+        this.log.warn(
+          `"${mw.name}" beforeContextCompactionCommit error: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }
+  }
+  /**
+   * Run all `afterContextCompactionCommit` hooks in reverse order.
+   *
+   * This mirrors `afterToolCall` / `model.output` ordering. Errors are logged
+   * and do not abort the turn.
+   */
+  async runAfterContextCompactionCommit(ctx) {
+    for (let i = this.stack.length - 1; i >= 0; i--) {
+      const mw = this.stack[i];
+      if (!mw.afterContextCompactionCommit) continue;
+      try {
+        await mw.afterContextCompactionCommit(ctx);
+      } catch (err) {
+        this.log.warn(
+          `"${mw.name}" afterContextCompactionCommit error: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }
+  }
+  // --------------------------------------------------------------------------
   // onEvent — fire-and-forget, all run
   // --------------------------------------------------------------------------
   /**
@@ -212,7 +275,10 @@ var MiddlewareRunner = class {
       if (!mw.onEvent) continue;
       try {
         mw.onEvent(event);
-      } catch {
+      } catch (err) {
+        this.log.warn(
+          `"${mw.name}" onEvent error: ${err instanceof Error ? err.message : String(err)}`
+        );
       }
     }
   }
@@ -375,6 +441,7 @@ function safeJsonStringify(value) {
   }
 }
 var A365_MESSAGE_SCHEMA_VERSION = "0.1.0";
+var DEFAULT_TELEMETRY_AGENT_NAME = "agent";
 function createInputMessagesAttribute(content) {
   return JSON.stringify({
     version: A365_MESSAGE_SCHEMA_VERSION,
@@ -421,7 +488,7 @@ function scheduleSpanTimeout(options) {
 function otelMiddleware(config = {}) {
   const recordInputs = config.recordInputs ?? true;
   const recordOutputs = config.recordOutputs ?? true;
-  const agentName = config.agentName ?? DEFAULT_AGENT_NAME;
+  const agentName = config.agentName ?? DEFAULT_TELEMETRY_AGENT_NAME;
   const emitToolSpans = config.emitToolSpans ?? true;
   const spanTimeoutMs = config.spanTimeoutMs ?? 5 * 60 * 1e3;
   const configuredSpanAttributes = config.spanAttributes ?? {};
@@ -776,7 +843,6 @@ async function createAndRegisterProvider(spanProcessor, serviceName) {
   ]);
   const provider = new NodeTracerProvider({
     resource: resourceFromAttributes({ [ATTR_SERVICE_NAME]: serviceName }),
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     spanProcessors: [spanProcessor]
   });
   provider.register();