@almadar/agent 1.1.4 → 1.2.1

package/dist/agent/index.d.ts

@@ -1,6 +1,6 @@
-export { E as EVENT_BUDGETS, S as SessionManager, d as SessionManagerOptions, e as Skill, f as SkillAgentOptions, g as SkillAgentResult, h as SkillLoader, i as SkillMeta, j as SkillRefLoader, l as createSkillAgent, m as getBudgetWarningMessage, n as getEventBudget, o as getInterruptConfig, r as resumeSkillAgent } from '../index-wLhxy6Gb.js';
+export { E as EVENT_BUDGETS, S as SessionManager, e as SessionManagerOptions, f as Skill, g as SkillAgentOptions, h as SkillAgentResult, i as SkillLoader, j as SkillMeta, k as SkillRefLoader, m as createSkillAgent, p as getBudgetWarningMessage, q as getEventBudget, r as getInterruptConfig, t as resumeSkillAgent } from '../index-D-Ahuo6F.js';
 export { Command } from '@langchain/langgraph';
-export { P as PersistenceMode, d as SessionMetadata, e as SessionRecord } from '../firestore-checkpointer-DxbQ10ve.js';
+export { P as PersistenceMode, S as SessionMetadata, e as SessionRecord } from '../firestore-checkpointer-CkNKXoun.js';
 import '@almadar/llm';
 import '../orbital-subagent-cNfTLdXQ.js';
 import '@langchain/core/tools';
@@ -9,4 +9,5 @@ import '../api-types-BW_58thJ.js';
 import '@almadar/core/types';
 import '@langchain/langgraph-checkpoint';
 import '@almadar/core';
+import '@langchain/core/messages';
 import '@langchain/core/runnables';

package/dist/agent/index.js

@@ -3258,9 +3258,13 @@ var SessionManager = class {
   constructor(options = {}) {
     this.firestoreCheckpointer = null;
     this.firestoreSessionStore = null;
+    this.memoryManager = null;
+    this.compactionConfig = null;
     this.mode = options.mode ?? "memory";
     this.memoryBackend = new MemorySessionBackend();
     this.memoryCheckpointers = /* @__PURE__ */ new Map();
+    this.memoryManager = options.memoryManager ?? null;
+    this.compactionConfig = options.compactionConfig ?? null;
     if (this.mode === "firestore" && options.firestoreDb) {
       this.firestoreCheckpointer = new FirestoreCheckpointer({ db: options.firestoreDb });
       this.firestoreSessionStore = new FirestoreSessionStore({ db: options.firestoreDb });
@@ -3360,6 +3364,260 @@ var SessionManager = class {
     }
     return this.memoryBackend.list();
   }
+  // ============================================================================
+  // Session → Memory Sync (GAP-002D)
+  // ============================================================================
+  /**
+   * Sync a completed session to orbital memory.
+   * This enables the agent to learn from past sessions.
+   *
+   * @param threadId - The session thread ID
+   * @param userId - The user ID for memory association
+   * @param sessionData - Additional session data to record
+   * @returns Promise that resolves when sync is complete
+   */
+  async syncSessionToMemory(threadId, userId, sessionData) {
+    if (!this.memoryManager) {
+      console.warn("[SessionManager] No memory manager configured, skipping session sync");
+      return;
+    }
+    const metadata = this.get(threadId);
+    if (!metadata) {
+      console.warn(`[SessionManager] Session ${threadId} not found, skipping sync`);
+      return;
+    }
+    try {
+      await this.memoryManager.recordGeneration(userId, {
+        threadId,
+        prompt: sessionData.inputDescription,
+        skill: metadata.skill,
+        generatedSchema: sessionData.generatedOrbital ? { name: sessionData.generatedOrbital } : void 0,
+        patterns: sessionData.patternsUsed ?? [],
+        entities: sessionData.entities ?? [],
+        success: sessionData.success,
+        completedAt: /* @__PURE__ */ new Date()
+      });
+      if (sessionData.patternsUsed && sessionData.patternsUsed.length > 0) {
+        await this.memoryManager.updateUserPreferences(userId, {
+          preferredPatterns: sessionData.patternsUsed,
+          commonEntities: sessionData.entities
+        });
+      }
+      if (sessionData.entities && sessionData.entities.length > 0) {
+        await this.memoryManager.updateProjectContext(sessionData.appId, {
+          userId,
+          existingEntities: sessionData.entities
+        });
+      }
+      console.log(`[SessionManager] Session ${threadId} synced to memory for user ${userId}`);
+    } catch (error) {
+      console.error("[SessionManager] Failed to sync session to memory:", error);
+    }
+  }
+  // ============================================================================
+  // Interrupt → Memory Sync (GAP-003: Interrupt Memory)
+  // ============================================================================
+  /**
+   * Record an interrupt decision to memory.
+   * This enables learning from HITL (Human-in-the-Loop) decisions.
+   *
+   * @param sessionId - The session thread ID
+   * @param userId - The user who made the decision
+   * @param interruptData - The interrupt decision data
+   * @returns Promise that resolves when sync is complete
+   */
+  async recordInterruptDecision(sessionId, userId, interruptData) {
+    if (!this.memoryManager) {
+      console.warn("[SessionManager] No memory manager configured, skipping interrupt sync");
+      return;
+    }
+    try {
+      await this.memoryManager.recordInterruptDecision(sessionId, userId, interruptData);
+      console.log(`[SessionManager] Interrupt recorded for user ${userId}: ${interruptData.toolName} ${interruptData.decision}`);
+    } catch (error) {
+      console.error("[SessionManager] Failed to record interrupt:", error);
+    }
+  }
+  /**
+   * Get interrupt history for a session.
+   */
+  async getSessionInterrupts(sessionId) {
+    if (!this.memoryManager) {
+      return [];
+    }
+    return this.memoryManager.getSessionInterrupts(sessionId);
+  }
+  /**
+   * Check if a tool should be auto-approved for a user.
+   */
+  async shouldAutoApproveTool(userId, toolName) {
+    if (!this.memoryManager) {
+      return false;
+    }
+    return this.memoryManager.shouldAutoApproveTool(userId, toolName);
+  }
+  // ============================================================================
+  // Checkpoint Management (GAP-004: Checkpoint → Memory)
+  // ============================================================================
+  /**
+   * Record a checkpoint to memory for learning.
+   *
+   * @param userId - The user who owns this checkpoint
+   * @param checkpointData - Checkpoint information
+   * @returns Promise that resolves when checkpoint is recorded
+   */
+  async recordCheckpoint(userId, checkpointData) {
+    if (!this.memoryManager) {
+      console.warn("[SessionManager] No memory manager configured, skipping checkpoint record");
+      return;
+    }
+    try {
+      await this.memoryManager.recordCheckpoint(userId, checkpointData);
+      console.log(`[SessionManager] Checkpoint ${checkpointData.checkpointId} recorded for user ${userId}`);
+    } catch (error) {
+      console.error("[SessionManager] Failed to record checkpoint:", error);
+    }
+  }
+  /**
+   * Record a rollback to a checkpoint.
+   *
+   * @param userId - The user who performed the rollback
+   * @param checkpointId - The checkpoint rolled back to
+   * @param reason - Optional reason for rollback
+   * @returns Promise that resolves when rollback is recorded
+   */
+  async recordRollback(userId, checkpointId, reason) {
+    if (!this.memoryManager) {
+      console.warn("[SessionManager] No memory manager configured, skipping rollback record");
+      return;
+    }
+    try {
+      await this.memoryManager.recordRollback(userId, checkpointId, reason);
+      console.log(`[SessionManager] Rollback to ${checkpointId} recorded for user ${userId}`);
+    } catch (error) {
+      console.error("[SessionManager] Failed to record rollback:", error);
+    }
+  }
+  /**
+   * Mark a checkpoint as successful (terminal state).
+   *
+   * @param userId - The user who owns this checkpoint
+   * @param checkpointId - The checkpoint that was successful
+   * @returns Promise that resolves when success is recorded
+   */
+  async markCheckpointSuccessful(userId, checkpointId) {
+    if (!this.memoryManager) {
+      console.warn("[SessionManager] No memory manager configured, skipping success mark");
+      return;
+    }
+    try {
+      await this.memoryManager.markCheckpointSuccessful(userId, checkpointId);
+      console.log(`[SessionManager] Checkpoint ${checkpointId} marked as successful for user ${userId}`);
+    } catch (error) {
+      console.error("[SessionManager] Failed to mark checkpoint as successful:", error);
+    }
+  }
+  /**
+   * Get checkpoint history for a thread.
+   *
+   * @param threadId - The thread to get checkpoints for
+   * @returns Array of checkpoint records
+   */
+  async getThreadCheckpoints(threadId) {
+    if (!this.memoryManager) {
+      return [];
+    }
+    return this.memoryManager.getThreadCheckpoints(threadId);
+  }
+  /**
+   * Get frequently rolled-back checkpoints (problem areas).
+   *
+   * @param userId - The user to get problem checkpoints for
+   * @param minRollbackCount - Minimum rollback count (default: 2)
+   * @returns Array of checkpoint records with rollback issues
+   */
+  async getProblemCheckpoints(userId, minRollbackCount = 2) {
+    if (!this.memoryManager) {
+      return [];
+    }
+    return this.memoryManager.getProblemCheckpoints(userId, minRollbackCount);
+  }
+  // ============================================================================
+  // Context Compaction (GAP-005)
+  // ============================================================================
+  /**
+   * Get the context compaction configuration.
+   * @returns The compaction configuration or null if not configured.
+   */
+  getCompactionConfig() {
+    return this.compactionConfig;
+  }
+  /**
+   * Check if a session's messages need compaction based on token count.
+   * Uses character-based estimation for quick checks.
+   *
+   * @param messages - Array of messages to check
+   * @returns True if compaction is recommended
+   */
+  shouldCompactMessages(messages) {
+    if (!this.compactionConfig) {
+      return false;
+    }
+    const totalChars = messages.reduce((sum, msg) => {
+      const content = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content);
+      return sum + content.length;
+    }, 0);
+    const estimatedTokens = totalChars / 4;
+    const threshold = this.compactionConfig.maxTokens ?? 15e4;
+    return estimatedTokens > threshold * 0.8;
+  }
+  /**
+   * Record a compaction event for a session.
+   * This helps track when and why compaction occurs.
+   *
+   * @param threadId - The session thread ID
+   * @param originalMessageCount - Number of messages before compaction
+   * @param compactedMessageCount - Number of messages after compaction
+   * @param reason - Reason for compaction
+   */
+  async recordCompaction(threadId, originalMessageCount, compactedMessageCount, reason) {
+    if (!this.memoryManager) {
+      console.warn("[SessionManager] No memory manager configured, skipping compaction record");
+      return;
+    }
+    try {
+      const metadata = this.get(threadId);
+      if (metadata) {
+        const compactionInfo = {
+          timestamp: Date.now(),
+          originalMessageCount,
+          compactedMessageCount,
+          reason: reason ?? "token_limit"
+        };
+        const meta = metadata;
+        const existingCompactions = meta.compactions ?? [];
+        meta.compactions = [...existingCompactions, compactionInfo];
+        this.store(threadId, metadata);
+      }
+      console.log(`[SessionManager] Compaction recorded for ${threadId}: ${originalMessageCount} \u2192 ${compactedMessageCount} messages`);
+    } catch (error) {
+      console.error("[SessionManager] Failed to record compaction:", error);
+    }
+  }
+  /**
+   * Get compaction history for a session.
+   *
+   * @param threadId - The session thread ID
+   * @returns Array of compaction events
+   */
+  getCompactionHistory(threadId) {
+    const metadata = this.get(threadId);
+    if (!metadata) {
+      return [];
+    }
+    const meta = metadata;
+    return meta.compactions ?? [];
+  }
 };
 
 // src/agent/interrupt-config.ts