do-memory-core 0.1.31

Core episodic learning system for AI agents with pattern extraction, reward scoring, and dual storage backend
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

//!
//! Test module for the reflection subsystem
//!
//! Contains tests organized by component:
//! - `generator.rs`: Tests for `ReflectionGenerator`
//! - `success_analyzer.rs`: Tests for success analysis
//! - `improvement_analyzer.rs`: Tests for improvement analysis
//! - `insight_generator.rs`: Tests for insight generation
//! - `helpers.rs`: Tests for helper functions
//!

#![allow(dead_code)]

use crate::ExecutionStep;
use crate::episode::Episode;
use crate::types::{ExecutionResult, TaskContext, TaskOutcome, TaskType};

// ---------------------------------------------------------------------------
// Test helper functions shared across test modules
// ---------------------------------------------------------------------------

pub(super) fn failed_step(
    step_number: usize,
    tool: &str,
    action: &str,
    error_msg: &str,
) -> ExecutionStep {
    let mut step = ExecutionStep::new(step_number, tool.to_string(), action.to_string());
    step.result = Some(ExecutionResult::Error {
        message: error_msg.to_string(),
    });
    step.latency_ms = 200;
    step.tokens_used = Some(25);
    step
}

pub(super) fn successful_step(step_number: usize, tool: &str, action: &str) -> ExecutionStep {
    let mut step = ExecutionStep::new(step_number, tool.to_string(), action.to_string());
    step.result = Some(ExecutionResult::Success {
        output: "Success".to_string(),
    });
    step.latency_ms = 100;
    step.tokens_used = Some(50);
    step
}

pub(super) fn successful_step_with_latency(
    step_number: usize,
    tool: &str,
    action: &str,
    latency_ms: u64,
) -> ExecutionStep {
    let mut step = successful_step(step_number, tool, action);
    step.latency_ms = latency_ms;
    step
}

pub(super) fn create_test_episode(
    description: &str,
    task_type: TaskType,
    steps: Vec<ExecutionStep>,
    outcome: Option<TaskOutcome>,
) -> Episode {
    let mut episode = Episode::new(description.to_string(), TaskContext::default(), task_type);
    for step in steps {
        episode.add_step(step);
    }
    if let Some(outcome) = outcome {
        episode.complete(outcome);
    }
    episode
}

mod generator;
mod helpers;
mod improvement_analyzer;
mod insight_generator;
mod success_analyzer;