Episodic Replay

from dakera import DakeraClient
import uuid
from typing import Literal

client = DakeraClient(base_url="http://localhost:3300", api_key="dk-...")

Role = Literal["user", "agent"]
Significance = Literal["normal", "hypothesis", "error", "decision", "solution", "breakthrough"]

IMPORTANCE_BY_SIGNIFICANCE = {
    "normal": 0.72,
    "hypothesis": 0.75,
    "error": 0.80,
    "decision": 0.92,
    "solution": 0.95,
    "breakthrough": 0.97,
}

class EpisodicSession:
    """Records a conversation episode with full replay capability."""

    def __init__(self, agent_id: str, session_id: str = None):
        self.agent_id = agent_id
        self.session_id = session_id or f"sess-{uuid.uuid4().hex[:8]}"
        self.sequence = 0

    def record(
        self,
        role: Role,
        content: str,
        significance: Significance = "normal"
    ) -> dict:
        """Store one interaction turn."""
        self.sequence += 1
        importance = IMPORTANCE_BY_SIGNIFICANCE[significance]

        tags = [
            "episode",
            self.session_id,
            f"role:{role}",
            significance,
            f"seq:{self.sequence}"
        ]

        return client.store_memory(
            agent_id=self.agent_id,
            content=f"[{role}] {content}",
            memory_type="episodic",
            importance=importance,
            tags=tags
        )

    def replay_full(self) -> list[str]:
        """Replay all turns in this session in order."""
        results = client.recall(
            agent_id=self.agent_id,
            query=f"{self.session_id} episode conversation turns",
            top_k=200
        )
        memories = results.get("memories", [])
        # Sort by sequence number extracted from tags
        def get_seq(m):
            for tag in (m.get("tags") or []):
                if tag.startswith("seq:"):
                    return int(tag[4:])
            return 0
        memories.sort(key=get_seq)
        return [m["content"] for m in memories]

    def replay_decisions_only(self) -> list[str]:
        """Replay only high-significance turns (decisions, solutions)."""
        results = client.recall(
            agent_id=self.agent_id,
            query=f"{self.session_id} decision root cause solution breakthrough",
            top_k=20,
            min_importance=0.90
        )
        memories = results.get("memories", [])

        def get_seq(m):
            for tag in (m.get("tags") or []):
                if tag.startswith("seq:"):
                    return int(tag[4:])
            return 0
        memories.sort(key=get_seq)
        return [m["content"] for m in memories]

# --- Record the debugging session ---
session = EpisodicSession("codeassist-dev-7", "sess-20260519")

session.record("user",
    "TypeError: cannot read property 'length' of undefined in parser.js:42",
    significance="error"
)
session.record("agent",
    "Likely a null check missing. Try: if (arr && arr.length) before accessing.",
    significance="hypothesis"
)
session.record("user",
    "Still failing on the same line. I already had that null check.",
    significance="normal"
)
session.record("agent",
    "Root cause: fetchData() at line 38 is not awaited. Async race condition. Add 'await' before the call.",
    significance="decision"
)
session.record("user",
    "That was it! Adding await before fetchData() fixed the TypeError. Tests all green.",
    significance="solution"
)

# --- Replay later (new process, resuming work) ---
replay_session = EpisodicSession("codeassist-dev-7", "sess-20260519")

print("=== FULL REPLAY ===")
for turn in replay_session.replay_full():
    print(turn)

print("
=== DECISIONS ONLY ===")
for turn in replay_session.replay_decisions_only():
    print(turn)

# Output (decisions only):
# [agent] Root cause: fetchData() not awaited. Async race. Add 'await'.
# [user] Fixed! Tests green.

import { DakeraClient } from '@dakera-ai/dakera';
import { randomUUID } from 'crypto';

const client = new DakeraClient({ baseUrl: 'http://localhost:3300', apiKey: 'dk-...' });

type Role = 'user' | 'agent';
type Significance = 'normal' | 'hypothesis' | 'error' | 'decision' | 'solution' | 'breakthrough';

const IMPORTANCE: Record<Significance, number> = {
  normal: 0.72,
  hypothesis: 0.75,
  error: 0.80,
  decision: 0.92,
  solution: 0.95,
  breakthrough: 0.97,
};

class EpisodicSession {
  private agentId: string;
  private sessionId: string;
  private seq = 0;

  constructor(agentId: string, sessionId?: string) {
    this.agentId = agentId;
    this.sessionId = sessionId ?? `sess-${randomUUID().slice(0, 8)}`;
  }

  get id(): string { return this.sessionId; }

  async record(role: Role, content: string, sig: Significance = 'normal'): Promise<void> {
    this.seq += 1;
    const seqNum = this.seq;

    await client.storeMemory(this.agentId, {
      content: `[${role}] ${content}`,
      memoryType: 'episodic',
      importance: IMPORTANCE[sig],
      tags: ['episode', this.sessionId, `role:${role}`, sig, `seq:${seqNum}`],
    });
  }

  private getSeq(tags: string[] = []): number {
    const seqTag = tags.find(t => t.startsWith('seq:'));
    return seqTag ? parseInt(seqTag.slice(4), 10) : 0;
  }

  async replayFull(): Promise<string[]> {
    const results = await client.recall(
      this.agentId,
      `${this.sessionId} episode conversation turns`,
      { top_k: 200 }
    );
    return results.memories
      .sort((a, b) => this.getSeq(a.tags) - this.getSeq(b.tags))
      .map(m => m.content);
  }

  async replayDecisionsOnly(): Promise<string[]> {
    const results = await client.recall(
      this.agentId,
      `${this.sessionId} decision root cause solution breakthrough`,
      { top_k: 20, min_importance: 0.90 }
    );
    return results.memories
      .sort((a, b) => this.getSeq(a.tags) - this.getSeq(b.tags))
      .map(m => m.content);
  }
}

// --- Record the debugging session ---
const session = new EpisodicSession('codeassist-dev-7', 'sess-20260519');

await session.record('user', "TypeError: cannot read property 'length' of undefined in parser.js:42", 'error');
await session.record('agent', "Likely null check missing. Try: if (arr && arr.length) before accessing.", 'hypothesis');
await session.record('user', "Still failing on same line. Already had that null check.", 'normal');
await session.record('agent', "Root cause: fetchData() at line 38 not awaited. Async race. Add await.", 'decision');
await session.record('user', "That fixed it! Tests green. Shipping to staging.", 'solution');

// --- Replay later ---
const replaySession = new EpisodicSession('codeassist-dev-7', 'sess-20260519');

const allTurns = await replaySession.replayFull();
console.log('Full replay:', allTurns);

const keyTurns = await replaySession.replayDecisionsOnly();
console.log('Decisions only:', keyTurns);

use dakera_rs::{Client, StoreMemoryRequest, RecallRequest};

let client = Client::new("http://localhost:3300", "dk-...");
let agent_id = "codeassist-dev-7";
let session_id = "sess-20260519";

struct Turn {
    role: &'static str,
    content: &'static str,
    importance: f32,
    seq: u32,
}

let turns = vec![
    Turn { role: "user", content: "TypeError: cannot read property length of undefined in parser.js:42", importance: 0.80, seq: 1 },
    Turn { role: "agent", content: "Likely null check missing. Try: if (arr && arr.length) before accessing.", importance: 0.75, seq: 2 },
    Turn { role: "user", content: "Still failing. Already tried the null check.", importance: 0.72, seq: 3 },
    Turn { role: "agent", content: "Root cause: fetchData() not awaited at line 38. Async race. Add await.", importance: 0.92, seq: 4 },
    Turn { role: "user", content: "Fixed! Tests all green. Shipping to staging.", importance: 0.95, seq: 5 },
];

// Store all turns
for turn in &turns {
    client.store_memory(agent_id, StoreMemoryRequest {
        content: format!("[{}] {}", turn.role, turn.content),
        memory_type: "episodic".into(),
        importance: Some(turn.importance),
        tags: vec![
            "episode".into(),
            session_id.into(),
            format!("role:{}", turn.role),
            format!("seq:{}", turn.seq),
        ],
        ..Default::default()
    }).await?;
}

// Replay: recall all, sort by seq tag
let results = client.recall(agent_id, RecallRequest {
    query: format!("{} episode conversation turns", session_id),
    top_k: Some(200),
    ..Default::default()
}).await?;

let mut memories = results.memories;
memories.sort_by_key(|m| {
    m.tags.iter()
        .find(|t| t.starts_with("seq:"))
        .and_then(|t| t[4..].parse::<u32>().ok())
        .unwrap_or(0)
});

for m in &memories {
    println!("{}", m.content);
}

package main

import (
    "context"
    "fmt"
    "sort"
    "strconv"
    "strings"
    dakera "github.com/dakera-ai/dakera-go"
)

type Turn struct {
    Role       string
    Content    string
    Importance float64
    Seq        int
}

func getSeq(tags []string) int {
    for _, tag := range tags {
        if strings.HasPrefix(tag, "seq:") {
            if n, err := strconv.Atoi(tag[4:]); err == nil {
                return n
            }
        }
    }
    return 0
}

func main() {
    client := dakera.NewClient("http://localhost:3300", "dk-...")
    ctx := context.Background()
    agentID := "codeassist-dev-7"
    sessionID := "sess-20260519"

    turns := []Turn{
        {"user", "TypeError: cannot read property length of undefined in parser.js:42", 0.80, 1},
        {"agent", "Likely null check missing. Try: if (arr && arr.length) before accessing.", 0.75, 2},
        {"user", "Still failing. Already tried the null check.", 0.72, 3},
        {"agent", "Root cause: fetchData() at line 38 not awaited. Async race. Fix: add await.", 0.92, 4},
        {"user", "Fixed! Tests green. Shipping to staging.", 0.95, 5},
    }

    // Record all turns
    for _, t := range turns {
        client.StoreMemory(ctx, agentID, dakera.StoreMemoryRequest{
            Content:    fmt.Sprintf("[%s] %s", t.Role, t.Content),
            MemoryType: "episodic",
            Importance: t.Importance,
            Tags: []string{
                "episode", sessionID,
                "role:" + t.Role,
                fmt.Sprintf("seq:%d", t.Seq),
            },
        })
    }

    // Replay: recall and sort by seq
    results, _ := client.Recall(ctx, agentID, dakera.RecallRequest{
        Query: sessionID + " episode conversation turns",
        TopK:  200,
    })

    sort.Slice(results.Memories, func(i, j int) bool {
        return getSeq(results.Memories[i].Tags) < getSeq(results.Memories[j].Tags)
    })

    for _, m := range results.Memories {
        fmt.Println(m.Content)
    }
}