Skip to content

Solution for long term memory for agent coding CLIs and to facilitate handoff between different agent vendors

Rust
8.4 KB
Raw Blame
//! Bounded transcript coordinates. Tool payloads never enter this state.
//!
//! Claude tool ids pair `tool_use` with `tool_result`:
//! https://platform.claude.com/docs/en/agents-and-tools/tool-use/handle-tool-calls
//! Codex turn/response coordinates are explicit protocol fields:
//! https://github.com/openai/codex/blob/main/codex-rs/core/src/state/session.rs
//! https://github.com/openai/codex/blob/main/codex-rs/core/src/session/turn_context.rs
//! A Codex tool in the same turn is an association, never an inferred cause.

use ai_memory_core::{AgentKind, TokenCall, TokenCallContext, TokenToolRef, TokenToolRelation};
use serde::{Deserialize, Serialize};
use serde_json::Value;

#[derive(Clone, Default, Serialize, Deserialize)]
#[serde(default)]
pub(super) struct ScanContext {
    turn: Option<String>,
    known: Vec<TokenToolRef>,
    input_parent: Option<String>,
    inputs: Vec<TokenToolRef>,
    last: Option<TokenCall>,
}

fn id(value: Option<&Value>) -> Option<String> {
    value
        .and_then(Value::as_str)
        .filter(|s| {
            !s.is_empty()
                && s.len() <= 128
                && s.bytes()
                    .all(|b| b.is_ascii_alphanumeric() || matches!(b, b'-' | b'_' | b':' | b'.'))
        })
        .map(str::to_owned)
}

fn add(to: &mut Vec<TokenToolRef>, tool: TokenToolRef) {
    if let Some(old) = to
        .iter_mut()
        .find(|t| t.id == tool.id && t.relation == tool.relation)
    {
        old.is_error = match (old.is_error, tool.is_error) {
            (Some(true), _) | (_, Some(true)) => Some(true),
            (_, v) => v.or(old.is_error),
        };
    } else if to.len() < 16 {
        to.push(tool);
    }
}

impl ScanContext {
    fn set_turn(&mut self, turn: Option<String>) {
        if self.turn != turn {
            self.known.clear();
            self.inputs.clear();
            self.input_parent = None;
            self.last = None;
        }
        self.turn = turn;
    }

    pub(super) fn observe(&mut self, v: &Value, agent: AgentKind) -> Option<TokenCall> {
        let mut changed = false;
        if agent == AgentKind::ClaudeCode {
            if v["type"] == "user" && v["isMeta"] != true {
                let results = v
                    .pointer("/message/content")
                    .and_then(Value::as_array)
                    .map(|c| {
                        c.iter()
                            .filter(|b| b["type"] == "tool_result")
                            .collect::<Vec<_>>()
                    })
                    .unwrap_or_default();
                if results.is_empty() {
                    self.set_turn(id(v.get("uuid")));
                } else {
                    self.input_parent = id(v.get("uuid"));
                    self.inputs.clear();
                    for result in results {
                        let Some(tool_id) = id(result.get("tool_use_id")) else {
                            continue;
                        };
                        if let Some(tool) = self.known.iter_mut().find(|t| t.id == tool_id) {
                            tool.is_error = result.get("is_error").and_then(Value::as_bool);
                            let mut input = tool.clone();
                            input.relation = TokenToolRelation::Input;
                            add(&mut self.inputs, input);
                            changed = true;
                        }
                    }
                }
            }
            if v["type"] == "assistant"
                && let Some(content) = v.pointer("/message/content").and_then(Value::as_array)
            {
                for block in content.iter().filter(|b| b["type"] == "tool_use") {
                    if let (Some(id), Some(name)) = (
                        id(block.get("id")),
                        block
                            .get("name")
                            .and_then(Value::as_str)
                            .filter(|n| n.len() <= 128),
                    ) {
                        add(
                            &mut self.known,
                            TokenToolRef {
                                id,
                                name: name.into(),
                                relation: TokenToolRelation::Requested,
                                is_error: None,
                            },
                        );
                    }
                }
            }
        } else {
            if v["type"] == "turn_context" {
                self.set_turn(id(v.pointer("/payload/turn_id")));
            }
            if let Some(turn) = id(v.pointer("/payload/turn_id")) {
                self.set_turn(Some(turn));
            }
            if v["type"] == "response_item"
                && matches!(
                    v.pointer("/payload/type").and_then(Value::as_str),
                    Some("function_call" | "custom_tool_call")
                )
                && self.turn.is_some()
                && let (Some(id), Some(name)) = (
                    id(v.pointer("/payload/call_id")),
                    v.pointer("/payload/name")
                        .and_then(Value::as_str)
                        .filter(|n| n.len() <= 128),
                )
            {
                add(
                    &mut self.known,
                    TokenToolRef {
                        id,
                        name: name.into(),
                        relation: TokenToolRelation::Turn,
                        is_error: None,
                    },
                );
                changed = true;
            }
        }
        if !changed {
            return None;
        }
        let mut last = self.last.clone()?;
        let context = last.context.as_mut()?;
        if self.turn.is_none() || context.turn_id != self.turn {
            return None;
        }
        if agent == AgentKind::ClaudeCode {
            for tool in &mut context.tools {
                if let Some(known) = self.known.iter().find(|k| k.id == tool.id) {
                    tool.is_error = known.is_error.or(tool.is_error);
                }
            }
        } else {
            for tool in &self.known {
                add(&mut context.tools, tool.clone());
            }
        }
        self.last = Some(last.clone());
        Some(last)
    }

    pub(super) fn for_call(&self, v: &Value, agent: AgentKind) -> TokenCallContext {
        let mut tools = Vec::new();
        if agent == AgentKind::ClaudeCode {
            if self.input_parent.is_some() && id(v.get("parentUuid")) == self.input_parent {
                for tool in &self.inputs {
                    add(&mut tools, tool.clone());
                }
            }
            if let Some(content) = v.pointer("/message/content").and_then(Value::as_array) {
                for block in content.iter().filter(|b| b["type"] == "tool_use") {
                    if let Some(id) = id(block.get("id"))
                        && let Some(tool) = self.known.iter().find(|t| t.id == id)
                    {
                        add(&mut tools, tool.clone());
                    }
                }
            }
        } else if self.turn.is_some() {
            tools = self.known.clone();
        }
        TokenCallContext {
            turn_id: self.turn.clone(),
            response_id: id(if agent == AgentKind::ClaudeCode {
                v.pointer("/message/id")
            } else {
                v.pointer("/payload/response_id")
            }),
            recorded_at: v
                .get("timestamp")
                .and_then(Value::as_str)
                .filter(|s| s.len() <= 64)
                .and_then(|s| s.parse::<jiff::Timestamp>().ok())
                .map(|t| t.to_string()),
            tools,
        }
    }

    pub(super) fn remember(&mut self, call: &TokenCall) {
        self.last = Some(call.clone());
    }
}

pub(super) fn merge_context(old: &mut TokenCall, new: &TokenCall) {
    if let Some(next) = &new.context {
        if let Some(context) = old.context.as_mut() {
            if context.turn_id.is_none() {
                context.turn_id = next.turn_id.clone();
            }
            if context.response_id.is_none() {
                context.response_id = next.response_id.clone();
            }
            if context.recorded_at.is_none() {
                context.recorded_at = next.recorded_at.clone();
            }
            for tool in &next.tools {
                add(&mut context.tools, tool.clone());
            }
        } else {
            old.context = Some(next.clone());
        }
    }
}