@ai-setting/roy-agent-core 1.5.15-test → 1.5.17-beta.1

package/dist/shared/@ai-setting/roy-agent-core-81w1963m.js

@@ -0,0 +1,762 @@
+import {
+  init_search_query_parser,
+  matchesQuery,
+  parseSearchQuery
+} from "./roy-agent-core-rvxg1wps.js";
+import {
+  SummaryAgent
+} from "./roy-agent-core-eajcvp4e.js";
+import {
+  envKeyToConfigKey
+} from "./roy-agent-core-qxhq8ven.js";
+import {
+  BaseComponent
+} from "./roy-agent-core-kkbwepqb.js";
+import {
+  MemorySessionStore,
+  SQLiteSessionStore
+} from "./roy-agent-core-d7cyjkf7.js";
+import {
+  TracedAs,
+  init_decorator
+} from "./roy-agent-core-zgypchmt.js";
+import {
+  createLogger,
+  init_logger
+} from "./roy-agent-core-44hnfb02.js";
+import {
+  __legacyDecorateClassTS
+} from "./roy-agent-core-fs0mn2jk.js";
+
+// src/env/session/session-component.ts
+init_logger();
+init_decorator();
+
+// src/env/session/session-config-registration.ts
+var SESSION_DEFAULTS = {
+  "session.defaultDirectory": "/tmp",
+  "session.defaultTitleTemplate": "Session - {date}",
+  "session.maxMessages": 100,
+  "session.compactionThreshold": 80,
+  "session.autoCompact": true,
+  "session.storage.type": "sqlite",
+  "session.storage.dbPath": undefined,
+  "session.checkpoint.enabled": false,
+  "session.contextLimit": 1e5,
+  "session.maxSessions": 100
+};
+var SESSION_CONFIG_REGISTRATION = {
+  name: "session",
+  sources: [
+    { type: "env", envPrefix: "SESSION", priority: 20, watch: false }
+  ],
+  keys: [
+    { key: "session.defaultDirectory", sources: ["env", "file"] },
+    { key: "session.defaultTitleTemplate", sources: ["env", "file"] },
+    { key: "session.maxMessages", sources: ["env", "file"] },
+    { key: "session.compactionThreshold", sources: ["env", "file"] },
+    { key: "session.autoCompact", sources: ["env", "file"] },
+    { key: "session.storage.type", sources: ["env", "file"] },
+    { key: "session.storage.dbPath", sources: ["env", "file"] },
+    { key: "session.checkpoint.enabled", sources: ["env", "file"] },
+    { key: "session.contextLimit", sources: ["env", "file"] },
+    { key: "session.maxSessions", sources: ["env", "file"] }
+  ]
+};
+
+// src/env/session/session-component.ts
+init_search_query_parser();
+import path from "path";
+var logger = createLogger("session");
+
+class SessionComponent extends BaseComponent {
+  name = "session";
+  version = "1.1.0";
+  config;
+  store;
+  activeSessionId;
+  hooksConfig = {};
+  configComponent;
+  configWatcher;
+  summaryAgent;
+  promptComponent;
+  llmComponent;
+  constructor() {
+    super();
+  }
+  async init(config) {
+    await super.init(config);
+    const options = config?.options;
+    if (!options?.configComponent) {
+      throw new Error("ConfigComponent is required for SessionComponent initialization");
+    }
+    this.configComponent = options.configComponent;
+    await this.registerConfig(options);
+    const storageConfig = this.config?.storage;
+    if (storageConfig?.type === "sqlite") {
+      this.store = new SQLiteSessionStore(storageConfig.dbPath);
+      logger.info(`[SessionComponent] Using SQLite storage: ${storageConfig.dbPath || "default path"}`);
+    } else {
+      this.store = new MemorySessionStore;
+      logger.info("[SessionComponent] Using memory storage");
+    }
+    this.setStatus("running");
+    logger.info("[SessionComponent] Initialized");
+  }
+  getDefaultSessionDbPath() {
+    const home = process.env.HOME || process.env.USERPROFILE || "/tmp";
+    return path.join(home, ".local", "share", "roy-agent", "sessions.db");
+  }
+  async registerConfig(options) {
+    const configComponent = options.configComponent;
+    if (!configComponent)
+      return;
+    const { configPath, envPrefix, config } = options;
+    const prefix = envPrefix !== undefined ? envPrefix : "SESSION";
+    configComponent.registerComponent(SESSION_CONFIG_REGISTRATION);
+    if (configPath) {
+      configComponent.registerSource({
+        type: "file",
+        relativePath: configPath,
+        optional: true,
+        watch: false
+      });
+    }
+    configComponent.registerSource({
+      type: "env",
+      envPrefix: prefix,
+      priority: 20,
+      watch: false
+    });
+    await configComponent.load("session");
+    for (const envKey of Object.keys(process.env)) {
+      const configKey = envKeyToConfigKey(envKey, prefix, "session");
+      if (!configKey)
+        continue;
+      const value = process.env[envKey];
+      if (value !== undefined) {
+        await configComponent.set(configKey, value);
+      }
+    }
+    for (const [key, value] of Object.entries(SESSION_DEFAULTS)) {
+      if (configComponent.get(key) === undefined) {
+        await configComponent.set(key, value);
+      }
+    }
+    if (configComponent.get("session.storage.dbPath") === undefined) {
+      await configComponent.set("session.storage.dbPath", this.getDefaultSessionDbPath());
+    }
+    if (config) {
+      const flatConfig = this.flattenConfig(config);
+      for (const [key, value] of Object.entries(flatConfig)) {
+        await configComponent.set(key, value);
+      }
+    }
+    this.registerConfigWatcher(configComponent);
+    this.config = this.buildConfig(configComponent);
+  }
+  buildConfig(configComponent) {
+    return {
+      defaultDirectory: configComponent.get("session.defaultDirectory"),
+      defaultTitleTemplate: configComponent.get("session.defaultTitleTemplate"),
+      maxMessages: configComponent.get("session.maxMessages"),
+      compactionThreshold: configComponent.get("session.compactionThreshold"),
+      autoCompact: configComponent.get("session.autoCompact"),
+      storage: {
+        type: configComponent.get("session.storage.type"),
+        dbPath: configComponent.get("session.storage.dbPath")
+      }
+    };
+  }
+  flattenConfig(obj, prefix = "session") {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      const fullKey = `${prefix}.${key}`;
+      if (value && typeof value === "object" && !Array.isArray(value)) {
+        Object.assign(result, this.flattenConfig(value, fullKey));
+      } else {
+        result[fullKey] = value;
+      }
+    }
+    return result;
+  }
+  registerConfigWatcher(configComponent) {
+    if (typeof configComponent.watch !== "function") {
+      return;
+    }
+    this.configWatcher = configComponent.watch("session.*", (event) => {
+      this.onConfigChange(event);
+    });
+  }
+  onConfigChange(event) {
+    logger.info(`Session config changed: ${event.key}`, {
+      oldValue: event.oldValue,
+      newValue: event.newValue
+    });
+  }
+  async onStart() {
+    logger.info("[SessionComponent] Started");
+  }
+  async onStop() {
+    this.configWatcher?.();
+    this.configWatcher = undefined;
+    await this.store?.close();
+    this.store = undefined;
+    this.setStatus("stopped");
+    logger.info("[SessionComponent] Stopped");
+  }
+  async create(options = {}) {
+    await this.executeBeforeHooks("create", { options });
+    const title = options.title ?? this.generateTitle();
+    const session = await this.store.create({
+      ...options,
+      title
+    });
+    logger.info(`[SessionComponent] Created session: ${session.id}`, { title });
+    await this.executeAfterHooks("create", { session, options });
+    return session;
+  }
+  async get(id) {
+    await this.executeBeforeHooks("session.get", { id });
+    const session = await this.store?.get(id);
+    await this.executeAfterHooks("session.get", { session });
+    return session;
+  }
+  async getSession(id) {
+    const session = await this.get(id);
+    if (!session) {
+      return null;
+    }
+    const messages = await this.getMessages(id);
+    return {
+      sessionId: session.id,
+      title: session.title || "Untitled",
+      messages: messages.map((m) => ({
+        role: m.role,
+        content: m.content,
+        timestamp: m.timestamp
+      }))
+    };
+  }
+  async searchSessions(query, options) {
+    const limit = options?.limit ?? 20;
+    if (options?.session_id) {
+      const session = await this.get(options.session_id);
+      if (session) {
+        const messages = await this.getMessages(options.session_id);
+        const lastMessage = messages[messages.length - 1];
+        return [{
+          sessionId: session.id,
+          title: session.title || "Untitled",
+          preview: lastMessage?.content?.substring(0, 200) || "",
+          timestamp: session.updatedAt || session.createdAt
+        }];
+      }
+      return [];
+    }
+    const sessions = await this.list({ limit });
+    const results = [];
+    for (const session of sessions) {
+      if (results.length >= limit)
+        break;
+      const messages = await this.getMessages(session.id);
+      const lastMessage = messages[messages.length - 1];
+      const preview = lastMessage?.content?.substring(0, 200) || "";
+      if (query) {
+        const lowerQuery = query.toLowerCase();
+        const titleMatch = (session.title || "").toLowerCase().includes(lowerQuery);
+        const previewMatch = preview.toLowerCase().includes(lowerQuery);
+        if (!titleMatch && !previewMatch) {
+          continue;
+        }
+      }
+      results.push({
+        sessionId: session.id,
+        title: session.title || "Untitled",
+        preview,
+        timestamp: session.updatedAt || session.createdAt
+      });
+    }
+    return results;
+  }
+  async list(options) {
+    await this.executeBeforeHooks("session.list", { options });
+    const sessions = await this.store?.list(options) ?? [];
+    await this.executeAfterHooks("session.list", { sessions });
+    return sessions;
+  }
+  async getCount() {
+    return await this.store?.getCount() ?? 0;
+  }
+  async update(id, updates) {
+    await this.executeBeforeHooks("session.update", { id, updates });
+    const success = await this.store?.update(id, updates);
+    if (success) {
+      logger.info(`[SessionComponent] Updated session: ${id}`, { updates });
+      await this.executeAfterHooks("session.update", { id, updates });
+    }
+    return success ?? false;
+  }
+  async delete(id) {
+    await this.executeBeforeHooks("session.delete", { id });
+    const success = await this.store?.delete(id);
+    if (success) {
+      if (this.activeSessionId === id) {
+        this.activeSessionId = undefined;
+      }
+      logger.info(`[SessionComponent] Deleted session: ${id}`);
+      await this.executeAfterHooks("session.delete", { id });
+    }
+    return success ?? false;
+  }
+  getActiveSession() {
+    if (!this.activeSessionId)
+      return;
+    return;
+  }
+  getActiveSessionId() {
+    return this.activeSessionId;
+  }
+  async setActiveSession(id) {
+    const session = await this.store?.get(id);
+    if (!session)
+      return false;
+    this.activeSessionId = id;
+    logger.info(`[SessionComponent] Active session set: ${id}`);
+    return true;
+  }
+  async addMessage(sessionId, message) {
+    const contentPreview = typeof message.content === "string" ? message.content.substring(0, 100) : JSON.stringify(message.content).substring(0, 100);
+    logger.info(`[SessionComponent.addMessage] sessionId=${sessionId}, role=${message.role}, content="${contentPreview}"`);
+    try {
+      const messageId = await this.store?.addMessage(sessionId, message);
+      logger.info(`[SessionComponent.addMessage] Success: messageId=${messageId}`);
+      return messageId;
+    } catch (error) {
+      logger.error(`[SessionComponent] Failed to add message: ${error}`);
+      return;
+    }
+  }
+  async getMessages(sessionId, options) {
+    const messages = await this.store?.getMessages(sessionId, options?.offset, options?.limit);
+    return messages ?? [];
+  }
+  async getMessageCount(sessionId, includeArchived) {
+    return this.store?.getMessageCount(sessionId, includeArchived) ?? 0;
+  }
+  async getMessageIndexes(sessionId, role) {
+    return this.store?.getMessageIndexes(sessionId, role) ?? [];
+  }
+  async executeBeforeHooks(operation, context) {
+    const hookKey = `before.session.${operation}`;
+    const hooks = this.hooksConfig[hookKey] ?? [];
+    const hookContext = context;
+    for (const hook of hooks) {
+      if (hook.before) {
+        await hook.before(hookContext);
+      }
+    }
+    const options = context.options;
+    if (options?.hooks) {
+      const hookArray = options.hooks[hookKey] ?? [];
+      for (const hook of hookArray) {
+        if (hook.before) {
+          await hook.before(hookContext);
+        }
+      }
+    }
+  }
+  async executeAfterHooks(operation, context) {
+    const hookKey = `after.session.${operation}`;
+    const hooks = this.hooksConfig[hookKey] ?? [];
+    const hookContext = context;
+    for (const hook of hooks) {
+      if (hook.after) {
+        await hook.after(hookContext);
+      }
+    }
+    const options = context.options;
+    if (options?.hooks) {
+      const hookArray = options.hooks[hookKey] ?? [];
+      for (const hook of hookArray) {
+        if (hook.after) {
+          await hook.after(hookContext);
+        }
+      }
+    }
+  }
+  generateTitle() {
+    const template = this.config?.defaultTitleTemplate ?? "Session - {date}";
+    const date = new Date().toISOString().replace("T", " ").substring(0, 19);
+    return template.replace("{date}", date);
+  }
+  setSummaryComponents(promptComponent, llmComponent) {
+    this.promptComponent = promptComponent;
+    this.llmComponent = llmComponent;
+    this.summaryAgent = new SummaryAgent(promptComponent, llmComponent);
+  }
+  ensureSummaryAgent() {
+    if (!this.summaryAgent) {
+      if (!this.promptComponent || !this.llmComponent) {
+        throw new Error("SummaryAgent components not initialized. Call setSummaryComponents() first.");
+      }
+      this.summaryAgent = new SummaryAgent(this.promptComponent, this.llmComponent);
+    }
+  }
+  async generateCompactHint(sessionId) {
+    const session = await this.get(sessionId);
+    if (!session) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+    const latestCheckpoint = this.getLatestCheckpoint(session);
+    const startIndex = latestCheckpoint?.messageIndex ?? 0;
+    const MAX_SAFE_MESSAGES = Number.MAX_SAFE_INTEGER;
+    const messages = await this.store.getMessages(sessionId, startIndex, MAX_SAFE_MESSAGES, { includeArchived: false });
+    if (messages.length < 3) {
+      logger.warn("[SessionComponent] Not enough messages for hint generation");
+      return "";
+    }
+    this.ensureSummaryAgent();
+    const result = await this.summaryAgent.generateCompactHint({
+      messages: messages.map((m) => ({ role: m.role, content: m.content })),
+      sessionContext: {}
+    });
+    logger.info("[SessionComponent] Compact hint generated", {
+      sessionId,
+      hintLength: result.hint.length
+    });
+    return result.hint;
+  }
+  async compact(sessionId, options) {
+    const session = await this.get(sessionId);
+    if (!session) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+    const latestCheckpoint = this.getLatestCheckpoint(session);
+    const startIndex = latestCheckpoint?.messageIndex ?? 0;
+    const MAX_SAFE_MESSAGES = Number.MAX_SAFE_INTEGER;
+    const messages = await this.store.getMessages(sessionId, startIndex, MAX_SAFE_MESSAGES, { includeArchived: false });
+    if (messages.length < 3) {
+      throw new Error("Not enough messages to compact (minimum 3 required)");
+    }
+    const recentMessages = this.extractRecentMessages(messages, 2);
+    this.ensureSummaryAgent();
+    await this.executeBeforeHooks("compact", { session, options });
+    const summaryResult = await this.summaryAgent.run({
+      messages: messages.map((m) => ({ role: m.role, content: m.content })),
+      userContext: options?.summary,
+      outputFormat: "json",
+      scenarioHint: options?.scenarioHint
+    });
+    const checkpointId = `cp_${Date.now().toString(36)}_${Math.random().toString(36).substring(2, 8)}`;
+    const checkpoint = {
+      id: checkpointId,
+      messageIndex: startIndex,
+      title: summaryResult.title,
+      summary: [
+        `Process: ${summaryResult.processKeyPoints.join("; ")}`,
+        `State: ${summaryResult.currentState}`
+      ].join(`
+`),
+      processKeyPoints: summaryResult.processKeyPoints,
+      currentState: summaryResult.currentState,
+      nextSteps: summaryResult.nextSteps,
+      userIntents: summaryResult.userIntents,
+      messageCountBefore: messages.length,
+      createdAt: Date.now(),
+      type: "compact",
+      recentMessages
+    };
+    await this.store.saveCheckpoint(sessionId, checkpoint);
+    await this.store.archiveMessages(sessionId, checkpointId, messages.length);
+    const checkpointMessage = this.createCheckpointMessage(checkpoint);
+    await this.store.addMessage(sessionId, checkpointMessage);
+    const updatedSession = await this.get(sessionId);
+    const remainingMessageCount = updatedSession?.messageCount ?? 0;
+    const checkpointCount = updatedSession?.metadata?.checkpoints?.checkpoints?.length ?? 0;
+    logger.info(`[SessionComponent] Compacted session: ${sessionId}`, {
+      checkpointId,
+      archivedCount: messages.length,
+      remainingCount: remainingMessageCount,
+      hasScenarioHint: !!options?.scenarioHint,
+      recentMessagesCount: recentMessages.length
+    });
+    await this.executeAfterHooks("compact", { session, checkpoint, options });
+    return {
+      checkpoint,
+      deletedMessageCount: messages.length,
+      remainingMessageCount,
+      checkpointCount
+    };
+  }
+  extractRecentMessages(messages, turnCount = 2) {
+    const recentMessages = [];
+    let turnsExtracted = 0;
+    let i = messages.length - 1;
+    while (i >= 0 && turnsExtracted < turnCount) {
+      const msg = messages[i];
+      if (msg.metadata?.isCheckpoint) {
+        i--;
+        continue;
+      }
+      const hasToolParts = msg.parts?.some((p) => p.type === "tool-call" || p.type === "tool-result");
+      if (msg.role === "assistant" && !hasToolParts && msg.content.trim()) {
+        recentMessages.unshift({
+          role: "assistant",
+          content: msg.content
+        });
+        let j = i - 1;
+        while (j >= 0) {
+          const prevMsg = messages[j];
+          if (prevMsg.metadata?.isCheckpoint) {
+            j--;
+            continue;
+          }
+          if (prevMsg.role === "user") {
+            recentMessages.unshift({
+              role: "user",
+              content: prevMsg.content
+            });
+            turnsExtracted++;
+            break;
+          }
+          j--;
+        }
+        i = j;
+      } else {
+        i--;
+      }
+    }
+    logger.debug("[SessionComponent] Extracted recent messages", {
+      turnCount,
+      messagesExtracted: recentMessages.length
+    });
+    return recentMessages;
+  }
+  async previewCompact(sessionId) {
+    const session = await this.get(sessionId);
+    if (!session) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+    const latestCheckpoint = this.getLatestCheckpoint(session);
+    const startIndex = latestCheckpoint?.messageIndex ?? 0;
+    const MAX_SAFE_MESSAGES = Number.MAX_SAFE_INTEGER;
+    const messages = await this.store.getMessages(sessionId, startIndex, MAX_SAFE_MESSAGES, { includeArchived: false });
+    const estimatedTokens = messages.reduce((sum, m) => sum + m.content.length * 0.25, 0);
+    return {
+      messageCountToCompact: messages.length,
+      estimatedCheckpointTokens: Math.round(estimatedTokens * 0.1),
+      wouldTrigger: messages.length >= (this.config?.maxMessages ?? 50)
+    };
+  }
+  async getCheckpoints(sessionId) {
+    return await this.store.getCheckpoints(sessionId);
+  }
+  async getCheckpoint(sessionId, checkpointId) {
+    return await this.store.getCheckpoint(sessionId, checkpointId);
+  }
+  async deleteCheckpoint(sessionId, checkpointId) {
+    await this.executeBeforeHooks("deleteCheckpoint", { sessionId, checkpointId });
+    const success = await this.store.deleteCheckpoint(sessionId, checkpointId);
+    if (success) {
+      logger.info(`[SessionComponent] Deleted checkpoint: ${checkpointId}`);
+      await this.executeAfterHooks("deleteCheckpoint", { sessionId, checkpointId });
+    }
+    return success;
+  }
+  async getContext(sessionId, options) {
+    const session = await this.get(sessionId);
+    if (!session) {
+      throw new Error(`Session not found`);
+    }
+    let contextMessages = [];
+    let startCheckpoint;
+    if (options?.fullHistory) {
+      const MAX_SAFE_MESSAGES = Number.MAX_SAFE_INTEGER;
+      contextMessages = await this.store.getMessages(sessionId, 0, MAX_SAFE_MESSAGES, {
+        includeArchived: true
+      });
+    } else {
+      const latestCheckpointId = session.metadata?.checkpoints?.latestCheckpointId;
+      if (latestCheckpointId) {
+        startCheckpoint = await this.store.getCheckpoint(sessionId, latestCheckpointId);
+        if (startCheckpoint) {
+          const MAX_SAFE_MESSAGES = Number.MAX_SAFE_INTEGER;
+          contextMessages = await this.store.getMessages(sessionId, startCheckpoint.messageIndex, MAX_SAFE_MESSAGES, { includeArchived: false });
+        }
+      }
+      if (contextMessages.length === 0) {
+        const MAX_SAFE_MESSAGES = Number.MAX_SAFE_INTEGER;
+        contextMessages = await this.store.getMessages(sessionId, 0, MAX_SAFE_MESSAGES, {
+          includeArchived: false
+        });
+      }
+    }
+    if (options?.minUserMessages && options.minUserMessages > 0) {
+      const userIndexes = [];
+      for (let i = 0;i < contextMessages.length; i++) {
+        if (contextMessages[i].role === "user") {
+          userIndexes.push(i);
+        }
+      }
+      if (userIndexes.length > options.minUserMessages) {
+        const targetIndex = userIndexes[userIndexes.length - options.minUserMessages];
+        contextMessages = contextMessages.slice(targetIndex);
+      }
+    }
+    if (options?.messageLimit) {
+      contextMessages = contextMessages.slice(-options.messageLimit);
+    }
+    const checkpoints = contextMessages.filter((m) => m.metadata?.isCheckpoint).map((m) => m.metadata.checkpointMeta);
+    const estimatedTokens = contextMessages.reduce((sum, m) => sum + m.content.length * 0.25, 0);
+    return {
+      session,
+      checkpoints,
+      startCheckpoint: startCheckpoint ?? checkpoints[checkpoints.length - 1],
+      messages: contextMessages,
+      totalMessageCount: contextMessages.length,
+      activeMessageCount: contextMessages.filter((m) => !m.isArchived).length,
+      archivedMessageCount: contextMessages.filter((m) => m.isArchived).length,
+      estimatedTokens: Math.round(estimatedTokens)
+    };
+  }
+  async shouldCompact(sessionId) {
+    const session = await this.get(sessionId);
+    if (!session)
+      return false;
+    const preview = await this.previewCompact(sessionId);
+    return preview.wouldTrigger;
+  }
+  async searchMessages(options) {
+    const {
+      query,
+      sessionId,
+      limit = 10,
+      maxResults = 100,
+      beforeTime,
+      afterTime,
+      includeArchived = false,
+      includeContext = false,
+      contextLines = 2
+    } = options;
+    if (!this.store) {
+      return [];
+    }
+    let sessions;
+    if (sessionId) {
+      const session = await this.get(sessionId);
+      sessions = session ? [session] : [];
+    } else {
+      sessions = await this.list({ limit: 1000 });
+    }
+    const results = [];
+    let totalMatches = 0;
+    for (const session of sessions) {
+      if (beforeTime && session.updatedAt > beforeTime)
+        continue;
+      if (afterTime && session.updatedAt < afterTime)
+        continue;
+      const messages = await this.store.getMessages(session.id, 0, 1000, { includeArchived });
+      const queryTerms = parseSearchQuery(query);
+      const matches = [];
+      for (const msg of messages) {
+        if (beforeTime && msg.timestamp > beforeTime)
+          continue;
+        if (afterTime && msg.timestamp < afterTime)
+          continue;
+        if (matchesQuery(msg.content, queryTerms)) {
+          const match = {
+            messageId: msg.id,
+            sessionId: session.id,
+            role: msg.role,
+            content: msg.content,
+            timestamp: msg.timestamp
+          };
+          if (includeContext) {
+            const msgIndex = messages.indexOf(msg);
+            const beforeMsgs = messages.slice(Math.max(0, msgIndex - contextLines), msgIndex);
+            const afterMsgs = messages.slice(msgIndex + 1, msgIndex + 1 + contextLines);
+            match.contextBefore = beforeMsgs.map((m) => m.content).join(`
+`);
+            match.contextAfter = afterMsgs.map((m) => m.content).join(`
+`);
+          }
+          matches.push(match);
+          if (matches.length >= limit)
+            break;
+        }
+      }
+      if (matches.length > 0) {
+        results.push({
+          sessionId: session.id,
+          sessionTitle: session.title,
+          sessionDirectory: session.directory,
+          updatedAt: session.updatedAt,
+          messageCount: session.messageCount,
+          matches
+        });
+        totalMatches += matches.length;
+        if (totalMatches >= maxResults)
+          break;
+      }
+    }
+    return results;
+  }
+  getLatestCheckpoint(session) {
+    const latestId = session.metadata?.checkpoints?.latestCheckpointId;
+    if (!latestId)
+      return;
+    return session.metadata?.checkpointDetails?.[latestId];
+  }
+  createCheckpointMessage(checkpoint) {
+    const lines = [
+      `# Checkpoint: ${checkpoint.title}`,
+      "",
+      "## Process Key Points",
+      ...checkpoint.processKeyPoints.map((p, i) => `${i + 1}. ${p}`),
+      "",
+      "## Current State",
+      checkpoint.currentState,
+      ""
+    ];
+    if (checkpoint.nextSteps?.length) {
+      lines.push("## Next Steps");
+      checkpoint.nextSteps.forEach((s, i) => lines.push(`${i + 1}. ${s}`));
+      lines.push("");
+    }
+    lines.push("## Messages Compacted");
+    lines.push(`${checkpoint.messageCountBefore} messages compacted at ${new Date(checkpoint.createdAt).toISOString()}`);
+    const content = lines.join(`
+`);
+    return {
+      role: "user",
+      content,
+      parts: [{
+        type: "checkpoint",
+        checkpointId: checkpoint.id,
+        content,
+        title: checkpoint.title,
+        processKeyPoints: checkpoint.processKeyPoints,
+        currentState: checkpoint.currentState,
+        nextSteps: checkpoint.nextSteps,
+        messageCountBefore: checkpoint.messageCountBefore,
+        createdAt: checkpoint.createdAt
+      }],
+      metadata: {
+        isCheckpoint: true,
+        checkpointId: checkpoint.id,
+        checkpointMeta: checkpoint
+      }
+    };
+  }
+}
+__legacyDecorateClassTS([
+  TracedAs("session.generateCompactHint")
+], SessionComponent.prototype, "generateCompactHint", null);
+__legacyDecorateClassTS([
+  TracedAs("session.compact", { recordParams: true, recordResult: true })
+], SessionComponent.prototype, "compact", null);
+__legacyDecorateClassTS([
+  TracedAs("session.extractRecentMessages")
+], SessionComponent.prototype, "extractRecentMessages", null);
+export { SessionComponent };