import { InMemoryMemory, TDAIMemory, TypeORMMemory } from '@ag-kit/agents/storage';

// Choose implementation based on your needs
const memory = new InMemoryMemory(); // For development
// const memory = new TDAIMemory({ ... }); // For production
// const memory = new TypeORMMemory({ ... }); // For custom databases

// All implementations share the same interface
await memory.add({
  message: {
    id: 'msg-1',
    role: 'user',
    content: 'Hello, I need help with my project',
    timestamp: new Date()
  },
  state: { userId: 'user-123', context: 'project-help' }
});

// Common operations across all implementations
const events = await memory.list({ limit: 10, maxTokens: 4000 });
const results = await memory.retrieve('project help');
const count = await memory.getCount();

// Configure context thresholds for automatic management
const memory = new SomeMemory({
  enableContextManagement: true,
  thresholds: {
    preRotThreshold: 8000,        // Start management at 8000 tokens
    compactionTrigger: 0.8,       // Compact at 80% of threshold
    summarizationTrigger: 0.95,   // Summarize at 95% of threshold
    recentToKeep: 10              // Always keep last 10 messages
  }
});

// Context is automatically managed during operations
await memory.add(event); // Auto-triggers compression if needed

import { TokenTrimmer, TiktokenTokenizer } from '@ag-kit/agents/storage';

// Create tokenizer and trimmer
const tokenizer = new TiktokenTokenizer('gpt-4');
const trimmer = new TokenTrimmer(tokenizer);

// Count tokens
const tokenCount = tokenizer.countTokens('Hello, world!');

// Trim messages to fit context window
const events = await memory.list();
const trimmed = trimmer.trimMessages(events, 4000, 'newest_first');

// Semantic search for relevant memories
const results = await memory.retrieve('project help', {
  limit: 5,
  threshold: 0.7,
  sessionId: 'user-session'
});

// Results include relevance scores
results.forEach(event => {
  console.log(`Score: ${event.score}, Content: ${event.message.content}`);
});

// Work with different sessions
await memory.add(event1, { sessionId: 'session-A' });
await memory.add(event2, { sessionId: 'session-B' });

// Session utilities
const sessionIds = memory.getSessionIds?.() || [];
const count = await memory.getCount({ sessionId: 'session-A' });
await memory.clear({ sessionId: 'session-A' });

// Create and switch to a new branch
await memory.branch('experiment-1');
await memory.checkout('experiment-1');

// List all branches
const branches = await memory.listBranches();

// Time travel to a specific event
await memory.checkout('msg-5', { type: 'event' });

// Clean up unused branches
await memory.cleanupBranches();

import { TokenTrimmer, TiktokenTokenizer } from '@ag-kit/agents/storage';

// Create tokenizer and trimmer
const tokenizer = new TiktokenTokenizer('gpt-4');
const trimmer = new TokenTrimmer(tokenizer);

// Count tokens
const tokenCount = tokenizer.countTokens('Hello, world!');

// Trim messages to fit context window
const events = await memory.list();
const trimmed = trimmer.trimMessages(events, 4000, 'newest_first');

import { Mem0LongTermMemory } from '@ag-kit/agents/storage';

const longTermMemory = new Mem0LongTermMemory({
  apiKey: 'your-mem0-api-key',
  userId: 'user-123'
});

// Record memory
await longTermMemory.record({
  id: 'mem-1',
  strategy: 'user_preferences',
  content: 'User prefers dark mode and minimal UI',
  metadata: { confidence: 0.9 },
  createdAt: new Date()
});

// Semantic search
const results = await longTermMemory.semanticSearch('UI preferences');

interface MemoryEntity {
  id: string;
  strategy: string;                    // Memory strategy/category for organization
  role?: 'user' | 'assistant';         // Optional role information
  content: string;                     // Memory content text
  metadata: Record<string, any>;       // Additional context and metadata
  createdAt: Date;                     // Creation timestamp
  updatedAt?: Date;                    // Last update timestamp
}

interface MemoryQuery {
  query?: string;                      // Semantic query text for search
  strategy?: string | string[];        // Strategy filter(s)
  limit?: number;                      // Maximum results to return
  offset?: number;                     // Pagination offset
  threshold?: number;                  // Similarity threshold (0-1)
  filters?: Record<string, any>;       // Additional filters
  orderBy?: Record<string, 'asc' | 'desc'>; // Sorting options
  [key: string]: any;                  // Extensible for implementation-specific options
}

abstract class BaseLongTermMemory {
  // Core CRUD operations
  abstract record(memory: MemoryEntity): Promise<void>;
  abstract recordBatch(memories: MemoryEntity[]): Promise<void>;
  abstract retrieve(query: MemoryQuery): Promise<MemoryEntity[]>;
  abstract delete(memoryId: string | MemoryQuery): Promise<void>;
  abstract update(memoryId: string, updates: Partial<MemoryEntity>): Promise<void>;
  abstract clear(strategy?: string): Promise<void>;

  // Advanced features
  abstract extractAndRecord(messages: Message[], context: Record<string, any>): Promise<MemoryEntity[]>;
  abstract semanticSearch(query: string, options?: MemoryQuery): Promise<MemoryEntity[]>;
  abstract getRelatedMemories(memoryId: string, depth?: number): Promise<MemoryEntity[]>;
  abstract consolidate(): Promise<void>;
}

constructor(config: Mem0LongTermMemoryConfig)

constructor(encodingName?: TiktokenEncoding)

constructor(tokenizer?: ITokenizer)

constructor(tokensPerChar?: number)

import { InMemoryMemory, Mem0LongTermMemory } from '@ag-kit/agents/storage';

class ChatApplication {
  private shortTermMemory: InMemoryMemory;
  private longTermMemory: Mem0LongTermMemory;

  constructor() {
    this.shortTermMemory = new InMemoryMemory();
    this.longTermMemory = new Mem0LongTermMemory({
      apiKey: process.env.MEM0_API_KEY!,
      userId: 'default-user'
    });
  }

  async handleMessage(sessionId: string, userId: string, message: string) {
    // Store in short-term memory
    await this.shortTermMemory.add({
      message: {
        id: `msg-${Date.now()}`,
        role: 'user',
        content: message,
        timestamp: new Date()
      },
      state: { userId, sessionId, context: 'chat' }
    }, { sessionId });

    // Get conversation context (last 10 messages, max 4000 tokens)
    const context = await this.shortTermMemory.list({
      sessionId,
      limit: 10,
      order: 'desc',
      maxTokens: 4000
    });

    // Search long-term memory for relevant information
    const relevantMemories = await this.longTermMemory.semanticSearch(message, {
      threshold: 0.7,
      limit: 5
    });

    return context;
  }
}

// Create and switch to a new branch
await memory.branch('experiment-1');
await memory.checkout('experiment-1');

// List all branches
const branches = await memory.listBranches();

// Time travel to a specific event
await memory.checkout('msg-5', { type: 'event' });

// Clean up unused branches
await memory.cleanupBranches();