All your AI agent sessions in one place — browse, search, resume. Rust + GPUI.
Rust
//! MiMo Code(小米 MiMo 团队的终端 coding agent,github.com/XiaomiMiMo/MiMo-Code,MIT;
//! issue #77)。从 OpenCode fork 出来:`<数据根>/mimocode.db` 的 session / message / part
//! 三表与 OpenCode v1 同名,part 的 JSON 同形,正文解码走 opencode.rs 的
//! `parse_v1_messages`。分家的地方(与 ZCode 同一个理由,不能当孪生实例):
//!
//! - session 表没有 model / tokens 三列(fork 自 2026-01 的 OpenCode,那时还没有这几列),
//! OpenCode 的枚举 SQL 对它 prepare 就失败。模型取助手消息的 `modelID`,token 按调用累加
//! `tokens.input / output / reasoning`(与 OpenCode 会话列同一个口径)。
//! - 一个会话里不止一条"道":`message.agent_id` 为 `main` 的是主线,同会话的子代理(actor 的
//! subagent 模式,`explore-1` 这类)各写各的道。会话本身显示哪条照 MiMo 自己界面的
//! `selectMessages`:有 main 用 main;peer 模式派出的子会话把自己那几轮写在以子会话 id 命名的
//! 道上;都没有(`ask:` 旁问的宿主会话)用最新的那条。其余的道各是一条子会话(Kimi 的
//! `agents/<非 main>` 同形):原生 id `<会话>/<actor id>`(`lane_id`),父会话写在 id 里
//! (`parent_in_path`:停在直接父会话上、不能单独恢复),标题是派活时那句 description(没给时
//! 它等于 agent 类型名,退回收到的任务),跟着所在会话归档,token 各算各的道;派它的 actor
//! 调用跳得过去。运行时自己派的那几种(见下)的道是簿记、不列;fork 复制来的道(每条消息都早于
//! 会话的创建)也不列。
//! - 会导入别家的会话(`external_import`:Claude Code、Codex、OpenCode,用户在 MiMo 里点导入):
//! 导进来的消息原样复制进 main 道,`message_ids` 记着哪些是导入的。那几家 Wake 本来就索引着,
//! 只有导入的会话不列;导入后在 MiMo 里接着聊过的照列,导入的那段折成一条标记、token 不算。
//! `message_ids` 读不出的老记录分不清哪些是导入的,整条当导入。
//! - fork(`Session.fork`)把原会话的消息复制进新会话(新 id、保留原时间)、不记父会话:复制来的
//! 消息时间都早于新会话的创建时间,按这一条折成一条标记,token 与模型只算之后的(Codex / ZCode
//! 的分叉同一个理由)。
//! - 哪些会话显示照 MiMo 的 `session/visibility.ts`:顶层会话与 peer 子会话都显示;运行时自己派的
//! checkpoint-writer / dream / distill(`SYSTEM_SPAWNED_AGENT_TYPES`)的宿主子会话是簿记、
//! 不是对话,不列。自动整理记忆的 "Auto Dream" / "Auto Distill" 顶层会话 MiMo 自己照列(带
//! Auto 徽章),这里也列,但不算用户开的会话(`spawned`)。
//!
//! 用户消息带 `provenance`(钩子、主机自动化、别的 agent 发来的)就不是人打的字,归 Meta(MiMo
//! 自己起标题也这么认);钩子发来的、收件箱投递的文本块本身就标了 synthetic。助手消息
//! `summary: true` 是压缩出的摘要、带 `checkpoint` 块的那条是检查点重建的上下文,都折成摘要。
//! 标题来源 `fallback` 时标题只是占位的 "Untitled",退回首条提问(2026-09 之前的老库占位是空串)。
//!
//! 数据根:它用的 xdg-basedir 5.1.0 在三个平台都给 `~/.local/share/mimocode`(`XDG_DATA_HOME`
//! 覆盖),设了 `MIMOCODE_HOME` 就是 `$MIMOCODE_HOME/data`。它的 README 说 macOS 在
//! `~/Library/Application Support/mimocode`、Windows 在 `%LOCALAPPDATA%\mimocode`,与代码对不上,
//! 两处都只当候选(真有库才采信,Devin 同款)。`MIMOCODE_DB` 与渠道库(`mimocode-<渠道>.db`)
//! 只有测试与开发构建用,不跟。库里同时存着账号的 access / refresh token,所以不做远程同步。
//!
//! 本机没装 MiMo Code:格式全按源码(main 2026-10-22,v0.1.15 之后)推断、**未经真机验证**,
//! fixture 合成。
use super::opencode::{parse_v1_messages, V1Query};
use super::parse_utils::*;
use super::sqlite_ro::{
db_cache_stamp, has_table, open_sqlite_ro, split_virtual_path, strip_virtual_path,
table_columns, virtual_path, SqliteRo,
};
use super::{AgentAdapter, ParentInPath};
use crate::models::*;
use anyhow::{anyhow, Result};
use rusqlite::{Connection, OptionalExtension as _};
use serde_json::Value;
use std::collections::HashSet;
use std::path::{Path, PathBuf};
use std::sync::Arc;
const DB_NAME: &str = "mimocode.db";
/// XDG data 根下的目录名
const DATA_DIR: &str = "mimocode";
/// 运行时自己派的 agent(MiMo 的 `SYSTEM_SPAWNED_AGENT_TYPES`):它们的宿主子会话与道不是对话
const SYSTEM_AGENTS: [&str; 3] = ["checkpoint-writer", "dream", "distill"];
/// 自动整理记忆的顶层会话(MiMo 的 `isSystemSession` 按标题认)
const SYSTEM_TITLES: [&str; 2] = ["Auto Dream", "Auto Distill"];
/// 同会话子代理那条道作为子会话时的原生 id:`<会话>/<actor id>`(两段里都没有 `/`:会话 id 是
/// `ses_…`,actor id 是 `<agent>-<n>`)
fn lane_id(session: &str, actor: &str) -> String {
format!("{session}/{actor}")
}
/// `lane_id` 反过来:原生 id 拆成 (会话, 道);会话本身没有道
fn split_lane(id: &str) -> (&str, Option<&str>) {
match id.split_once('/') {
Some((session, actor)) => (session, Some(actor)),
None => (id, None),
}
}
/// 道子会话的父会话(`parent_in_path`):虚拟路径 `<库>#<会话>/<actor id>` 里的会话 id;会话本身
/// 给 None
fn lane_parent(path: &Path) -> Option<String> {
let (_, id) = split_virtual_path(path.to_str()?)?;
let (session, actor) = split_lane(id);
actor.map(|_| session.to_string())
}
/// actor 工具派活调用跳去的子会话(`ToolCallView::child_id`):metadata 记着会话与 actor。peer 是
/// 另一个会话(actor id 就是它的会话 id),同会话的子代理是这个会话里的一条道;指回会话自己的
/// (缺了 actorId,分不出是哪条道)不算
fn actor_child(session: &str, metadata: &Value) -> Option<String> {
let target = optional_string(metadata.get("sessionId"))?;
let child = match optional_string(metadata.get("actorId")) {
Some(actor) if actor != target => lane_id(&target, &actor),
_ => target,
};
(child != session).then_some(child)
}
/// part 的类型(`text` / `tool` / `checkpoint` …)
fn part_type(part: &Value) -> Option<&str> {
part.get("type").and_then(Value::as_str)
}
pub struct MimoAdapter {
db: PathBuf,
/// 列出来的会话与道子会话,按库戳缓存一轮扫描内的重复调用(枚举查询带全表相关子查询)
rows_cache: MtimeCache<Arc<Vec<MiRow>>>,
}
/// 列出来的一条:会话本身(`query_rows`),或会话里同会话子代理的一条道(`query_lanes`)
struct MiRow {
/// 原生 id:会话 id,或道的 `lane_id`
id: String,
/// 消息所在的会话
session: String,
/// 道子会话读的那条道;None = 会话本身(读要显示的那条)
actor: Option<String>,
/// 道子会话的项目与归档跟着所在的会话
directory: String,
/// 会话的标题;道子会话是派活时那句 description(没给是空串,退回收到的任务)
title: String,
/// 标题来源 `fallback`:占位的 "Untitled"
placeholder_title: bool,
created_ms: i64,
updated_ms: i64,
archived: bool,
/// part.data 字节数(会话算全部道)——SessionFileRef.size 的脏判据(单条取行时不算)
content_len: i64,
/// 会话自己那一行的 parent_id;道子会话的父会话在 id 里(`lane_parent`)
parent: Option<String>,
}
impl MiRow {
/// `query_rows` 与 `query_lanes` 共用的列序:会话 id、道(会话本身是 NULL)、目录、标题、标题
/// 来源、起止时间、归档时间、parent_id、part 字节数。缺列给默认值:老库不得整家消失
fn from_sql(r: &rusqlite::Row<'_>) -> rusqlite::Result<Self> {
let session: String = r.get(0)?;
let actor: Option<String> = r.get(1)?;
Ok(Self {
id: match &actor {
Some(actor) => lane_id(&session, actor),
None => session.clone(),
},
session,
actor,
directory: r.get::<_, Option<String>>(2)?.unwrap_or_default(),
title: r.get::<_, Option<String>>(3)?.unwrap_or_default(),
placeholder_title: r.get::<_, Option<String>>(4)?.as_deref() == Some("fallback"),
created_ms: r.get::<_, Option<i64>>(5)?.unwrap_or(0),
updated_ms: r.get::<_, Option<i64>>(6)?.unwrap_or(0),
archived: r.get::<_, Option<i64>>(7)?.is_some(),
parent: r
.get::<_, Option<String>>(8)?
.filter(|parent| !parent.is_empty()),
content_len: r.get::<_, Option<i64>>(9)?.unwrap_or(0),
})
}
/// 不是用户开的会话:子会话(peer 子代理、旁问、工作流的一步、同会话子代理的道),与自动整理
/// 记忆的那两种
fn spawned(&self) -> bool {
self.actor.is_some()
|| self.parent.is_some()
|| SYSTEM_TITLES.contains(&self.title.as_str())
}
}
/// 逐版加进来的表与列各自在不在(初始 schema 里的不用探)
#[derive(Clone, Copy)]
struct MiSchema {
/// 刚建好、还没迁移的库没有会话表:确定没有会话
sessions: bool,
/// message.agent_id(2026-05 起;之前一个会话只有一条道)
lanes: bool,
/// message.agent_id 还可以为空:2026-05-21 加这一列时主线的消息留着 NULL,05-26 才补成 'main'
/// 并改成 NOT NULL。停在这几天之间的库,NULL 就是主线(`agent`)
null_main: bool,
/// session.title_source(2026-09 起)
title_source: bool,
/// external_import 表(2026-06 起)
imports: bool,
/// actor_registry 带着 session_id / mode / agent:它 2026-05-15 由 task_registry 改名而来,
/// 05-21 重建之后才是这个形状,只探表名会把中间那几天的库读挂
actors: bool,
}
impl MiSchema {
/// 查询出错(文件不是 SQLite、读到一半出错)往上交,别当成没有
fn probe(conn: &Connection) -> rusqlite::Result<Self> {
let actors = table_columns(conn, "actor_registry");
// agent_id 在不在、是不是 NOT NULL
let agent_id: Option<bool> = conn
.query_row(
"SELECT \"notnull\" FROM pragma_table_info('message') WHERE name = 'agent_id'",
[],
|r| r.get(0),
)
.optional()?;
Ok(Self {
sessions: has_table(conn, "session")?,
lanes: agent_id.is_some(),
null_main: agent_id == Some(false),
title_source: table_columns(conn, "session").contains("title_source"),
imports: has_table(conn, "external_import")?,
actors: ["session_id", "mode", "agent"]
.iter()
.all(|c| actors.contains(*c)),
})
}
/// 消息在哪条道(`col` 是 agent_id 列,带表名):`null_main` 的库里 NULL 算 main。别的库原样用
/// 列,(session_id, agent_id) 索引照走
fn agent(&self, col: &str) -> String {
if self.null_main {
format!("COALESCE({col}, 'main')")
} else {
col.to_string()
}
}
/// 会话要显示的那条道(MiMo 界面的 `selectMessages`):有 main 用 main,peer 子会话用以它自己的
/// id 命名的那条,都没有用最新消息所在的那条。`sid` 是会话 id 的 SQL 表达式;老库只有一条道
fn lane(&self, sid: &str) -> Option<String> {
let agent = self.agent("x.agent_id");
self.lanes.then(|| {
format!(
"(CASE WHEN EXISTS (SELECT 1 FROM message x WHERE x.session_id = {sid} AND {agent} = 'main') THEN 'main'
WHEN EXISTS (SELECT 1 FROM message x WHERE x.session_id = {sid} AND {agent} = {sid}) THEN {sid}
ELSE (SELECT {agent} FROM message x WHERE x.session_id = {sid} ORDER BY x.id DESC LIMIT 1) END)"
)
})
}
/// 列哪些会话(枚举的 WHERE)。一是 MiMo 的 `classifySession`:顶层会话与 peer 子会话恒显示,
/// 宿主着运行时自己派的 agent 的子会话不显示。二是导入的会话只在 MiMo 里接着聊过才列——main 道
/// 里有不是导入的消息(导入只写 main 道);导入记录分不清哪些是导入的(`message_ids` 为空或读
/// 不出),整条当导入。导入那几个子查询都不相关、整条语句只建一次:按 s.id 取的相关写法每条
/// 消息求值一遍、每遍整表扫 external_import(它在 session_id 上没有索引),一千条导入就要好几秒
fn listed(&self) -> String {
let mut conds = Vec::new();
if self.actors {
conds.push(format!(
"NOT (COALESCE(s.parent_id, '') != ''
AND NOT EXISTS (SELECT 1 FROM actor_registry a WHERE a.session_id = s.id AND a.mode = 'peer')
AND EXISTS (SELECT 1 FROM actor_registry a WHERE a.session_id = s.id AND a.agent IN ({})))",
system_agents()
));
}
if self.imports {
conds.push(format!(
"(s.id NOT IN (SELECT session_id FROM external_import)
OR (s.id NOT IN (SELECT session_id FROM external_import
WHERE message_ids IS NULL OR NOT json_valid(message_ids))
AND EXISTS (SELECT 1 FROM message m WHERE m.session_id = s.id AND {} = 'main'
AND m.id NOT IN {})))",
self.agent("m.agent_id"),
imported_ids(None)
));
}
if conds.is_empty() {
"1".to_string()
} else {
conds.join(" AND ")
}
}
/// 转录读哪些消息(`V1Query::filter`,`?1` = 会话 id):会话读要显示的那条道、导入过就去掉
/// 导入的;道子会话读它那条道
fn transcript(&self, row: &MiRow, imported: bool) -> Option<String> {
let lane = match &row.actor {
Some(actor) => Some(sql_text(actor)),
None => self.lane("?1"),
};
let conds: Vec<String> = [
lane.map(|lane| format!("{} = {lane}", self.agent("agent_id"))),
imported.then(|| format!("id NOT IN {}", imported_ids(Some("?1")))),
]
.into_iter()
.flatten()
.collect();
(!conds.is_empty()).then(|| conds.join(" AND "))
}
}
/// SQL 字符串字面量(单引号转义)
fn sql_text(s: &str) -> String {
format!("'{}'", s.replace('\'', "''"))
}
/// 运行时自己派的 agent,拼进 `IN (…)`
fn system_agents() -> String {
SYSTEM_AGENTS
.iter()
.map(|a| sql_text(a))
.collect::<Vec<_>>()
.join(", ")
}
/// 导入来的消息 id(`external_import.message_ids`);`scope` 给了(会话 id 的 SQL 表达式)就只取
/// 那个会话的。不是合法 JSON 的按空的算;只取字符串元素——`NOT IN` 的列表里混进一个 NULL,整个
/// 条件就是 NULL、一条都选不中。消息 id 是主键,左边只放它一列、不配会话 id:换成 (会话, 消息) 对
/// 的话,SQLite 没法一次判完列表里有没有 NULL,每次没命中都把整份列表扫一遍(一千多条导入时列
/// 一遍会话要两秒多)
fn imported_ids(scope: Option<&str>) -> String {
let scope = scope
.map(|sid| format!(" AND e.session_id = {sid}"))
.unwrap_or_default();
format!(
"(SELECT j.value FROM external_import e,
json_each(CASE WHEN json_valid(e.message_ids) THEN e.message_ids ELSE '[]' END) j
WHERE j.type = 'text'{scope})"
)
}
/// 一次会话解析的产物:正文之外还带枚举列里没有的 token 累计
struct Parsed {
messages: Vec<TranscriptMessage>,
unknown: u32,
tokens: i64,
}
impl MimoAdapter {
pub fn new() -> Self {
let home = super::home_dir().unwrap_or_default();
let local = home.join(".local").join("share").join(DATA_DIR);
// MIMOCODE_HOME 必须是绝对路径(MiMo 自己对相对路径直接报错)
let mimo_home = super::env_dir("MIMOCODE_HOME")
.filter(|dir| dir.is_absolute())
.map(|dir| dir.join("data"));
let xdg = super::env_dir("XDG_DATA_HOME").map(|dir| dir.join(DATA_DIR));
// README 的说法(与 xdg-basedir 的实现对不上):macOS 的 Application Support、Windows 的
// %LOCALAPPDATA%;别的平台上不存在,无条件作候选无害
let app_support = home
.join("Library")
.join("Application Support")
.join(DATA_DIR);
let local_appdata = home.join("AppData").join("Local").join(DATA_DIR);
let hit = mimo_home
.iter()
.chain(&xdg)
.chain([&local, &app_support, &local_appdata])
.find(|dir| dir.join(DB_NAME).is_file())
.cloned();
// 哪儿都没有库:环境变量指着的位置(MiMo 在同一个环境里会写到那里),再回落默认位置
let root = hit.unwrap_or_else(|| mimo_home.or(xdg).unwrap_or(local));
Self::with_db(root.join(DB_NAME))
}
fn with_db(db: PathBuf) -> Self {
Self {
db,
rows_cache: MtimeCache::new(),
}
}
fn open(&self) -> Option<SqliteRo> {
open_sqlite_ro(&self.db, "mimo-code")
}
/// 列出来的会话与道子会话(没有正文的不收),按库(含 -wal)戳缓存。None = 库在却读不出
/// (打不开、查询出错)
fn rows(&self) -> Option<Arc<Vec<MiRow>>> {
let stamp = db_cache_stamp(&self.db);
self.rows_cache.get_or_try_build(stamp, || {
let ro = self.open()?;
let schema = MiSchema::probe(&ro.conn).ok()?;
let mut rows = query_rows(&ro.conn, schema, None).ok()?;
// 列出来的会话里的道才是子会话(导入的、簿记的会话里的不算)
let listed: HashSet<&str> = rows.iter().map(|row| row.session.as_str()).collect();
let lanes: Vec<MiRow> = query_lanes(&ro.conn, schema, None)
.ok()?
.into_iter()
.filter(|lane| listed.contains(lane.session.as_str()))
.collect();
rows.extend(lanes);
rows.retain(|row| row.content_len > 0);
Some(Arc::new(rows))
})
}
fn parse(
&self,
r: &SessionFileRef,
decode_images: bool,
) -> Result<(SessionMeta, Vec<TranscriptMessage>, u32)> {
let _image_budget = transcript_image_decode_budget(decode_images);
if Path::new(strip_virtual_path(&r.file_path)) != self.db.as_path() {
return Err(anyhow!("mimo code database is outside adapter roots"));
}
let ro = self
.open()
.ok_or_else(|| anyhow!("cannot open mimo code db"))?;
let schema = MiSchema::probe(&ro.conn)?;
let (session, actor) = split_lane(&r.native_id);
let row = match actor {
None => query_rows(&ro.conn, schema, Some(session))?,
Some(actor) => query_lanes(&ro.conn, schema, Some((session, actor)))?,
}
.into_iter()
.next()
.ok_or_else(|| anyhow!("mimo code session {} not in db", r.native_id))?;
let parsed = parse_messages(&ro, &row, schema, decode_images)?;
let meta = build_meta(r, &row, &parsed);
Ok((meta, parsed.messages, parsed.unknown))
}
}
fn build_meta(r: &SessionFileRef, row: &MiRow, parsed: &Parsed) -> SessionMeta {
let project_path = canonical_project_path(&row.directory);
SessionMeta {
key: session_key(AgentId::MimoCode, "", &row.id),
host: String::new(),
id: row.id.clone(),
agent: AgentId::MimoCode,
title: session_title(&row.title, row.placeholder_title, &parsed.messages),
project_name: project_name_of(&project_path),
project_path,
file_path: r.file_path.clone(),
created_at: if row.created_ms > 0 {
row.created_ms
} else {
r.mtime_ms
},
updated_at: if row.updated_ms > 0 {
row.updated_ms
} else {
r.mtime_ms
},
message_count: parsed
.messages
.iter()
.filter(|m| m.kind == MessageKind::Text)
.count() as i64,
size_bytes: r.size,
git_branch: None,
// 同一会话会换模型,取最后一条助手消息用的
model: parsed.messages.iter().rev().find_map(|m| m.model.clone()),
tokens_used: (parsed.tokens > 0).then_some(parsed.tokens),
archived: row.archived,
source: None,
spawned: row.spawned(),
favorite: false,
pinned: false,
}
}
/// 自定义 location:选中库文件本身就用它;选中 `MIMOCODE_HOME`(里面是 data/)或 XDG data 根
/// (里面是 mimocode/)往下找一层;其余当数据目录本身。MiMo Code 不做远程同步,没有"同步前
/// 目录还不存在"的挂载点,可以看存在性(OpenCode 的 custom_db_paths 同样)
fn custom_db(dir: PathBuf) -> PathBuf {
if dir.extension().is_some_and(|ext| ext == "db") {
return dir;
}
["data", DATA_DIR]
.iter()
.map(|sub| dir.join(sub).join(DB_NAME))
.find(|db| db.is_file())
.unwrap_or_else(|| dir.join(DB_NAME))
}
/// 枚举 / 单会话取行
fn query_rows(
conn: &Connection,
schema: MiSchema,
id: Option<&str>,
) -> rusqlite::Result<Vec<MiRow>> {
if !schema.sessions {
return Ok(Vec::new());
}
let title_source = if schema.title_source {
"s.title_source"
} else {
"NULL"
};
// 单会话取行按主键找,不卡列不列(列表那一步卡过)、不算字节数(parse 拿的是 r.size)。
// 枚举用 octet_length:只读记录头、不碰溢出页,工具输出动辄几十 KB,LENGTH 得把它们整份读
// 出来数字符;字节数照样是合格的脏判据
let (content_len, filter) = match id {
Some(_) => ("0", "s.id = ?1".to_string()),
None => (
"(SELECT COALESCE(SUM(octet_length(p.data)), 0) FROM part p WHERE p.session_id = s.id)",
schema.listed(),
),
};
let sql = format!(
"SELECT s.id, NULL, s.directory, s.title, {title_source}, s.time_created, s.time_updated,
s.time_archived, s.parent_id, {content_len}
FROM session s WHERE {filter}"
);
let mut stmt = conn.prepare(&sql)?;
let rows = stmt.query_map(rusqlite::params_from_iter(id), MiRow::from_sql)?;
rows.collect()
}
/// 同会话子代理的道:不是所在会话要显示的那条,不是运行时自己派的(那几种是簿记),至少有一条消息
/// 不早于会话的创建(只有 fork 复制来的消息的道,原会话里已经有一份);时间只按这些消息算,项目与
/// 归档跟着所在的会话。更新时间取消息的 time_updated:它是这条道的变更戳,消息原地改写(事后补写
/// token 之类)时 part 字节数未必变,拿创建时间当戳,增量扫描就认不出、一直留着旧值。`one` 给了
/// (会话, actor id) 就只取那一条、不算字节数。按道判的两条放在 HAVING、每条道求一遍:放进 WHERE
/// 就是每条消息一遍,"要显示哪条道"那个 CASE 的 ELSE 还要把整个会话排一遍序
fn query_lanes(
conn: &Connection,
schema: MiSchema,
one: Option<(&str, &str)>,
) -> rusqlite::Result<Vec<MiRow>> {
let Some(shown) = schema.lane("m.session_id") else {
return Ok(Vec::new());
};
// 派活时那句 description;没给时它等于 agent 类型名,算没有
let (description, system) = if schema.actors {
(
"(SELECT NULLIF(a.description, a.agent) FROM actor_registry a
WHERE a.session_id = m.session_id AND a.actor_id = m.agent_id)",
format!(
" AND NOT EXISTS (SELECT 1 FROM actor_registry a WHERE a.session_id = m.session_id
AND a.actor_id = m.agent_id AND a.agent IN ({}))",
system_agents()
),
)
} else {
("NULL", String::new())
};
// `m.agent_id != 'main'` 也不收 NULL:`null_main` 的库里那是主线
let (content_len, parts, which) = match one {
Some(_) => ("0", "", " AND m.session_id = ?1 AND m.agent_id = ?2"),
None => (
"SUM(octet_length(p.data))",
" LEFT JOIN part p ON p.message_id = m.id",
"",
),
};
let sql = format!(
"SELECT m.session_id, m.agent_id, s.directory, {description}, NULL, MIN(m.time_created),
MAX(m.time_updated), s.time_archived, NULL, {content_len}
FROM message m JOIN session s ON s.id = m.session_id{parts}
WHERE m.agent_id != 'main' AND m.time_created >= s.time_created{which}
GROUP BY m.session_id, m.agent_id
HAVING m.agent_id != {shown}{system}"
);
let mut stmt = conn.prepare(&sql)?;
let params: Vec<&str> = one.map(|(s, a)| vec![s, a]).unwrap_or_default();
let lanes = stmt.query_map(rusqlite::params_from_iter(params), MiRow::from_sql)?;
lanes.collect()
}
/// OpenCode 的 v1 两表循环 + MiMo 自己的几处差异(见模块注释):只读这条会话的那条道、导入的
/// 不读;助手消息逐条带模型与 token;actor 派活的调用跳到它派出的子会话;provenance 归 Meta,
/// 检查点与压缩摘要折成摘要;fork 复制来的那段折成一条、token 不算;导入过的会话开头留一条标记
fn parse_messages(
ro: &SqliteRo,
row: &MiRow,
schema: MiSchema,
decode_images: bool,
) -> Result<Parsed> {
// 导入只写在会话的 main 道上
let import = match row.actor {
None => import_of(&ro.conn, schema, &row.session)?,
Some(_) => None,
};
let query = V1Query {
filter: schema.transcript(row, import.is_some()),
..V1Query::OPENCODE
};
let mut tokens = 0i64;
// 已拼出几条消息;最后一条 fork 复制来的(含)之前有几条
let mut built = 0usize;
let mut inherited = 0usize;
let (mut messages, unknown) = parse_v1_messages(
ro,
&row.session,
decode_images,
&query,
|md, parts, role, message| {
// fork 复制来的:时间早于会话(道子会话是它那条道)的起点
let ts = md
.pointer("/time/created")
.and_then(Value::as_i64)
.unwrap_or(0);
let copied = row.created_ms > 0 && ts > 0 && ts < row.created_ms;
// 一次调用 = input + output + reasoning,与 OpenCode 会话列同一个口径;拼不出消息的
// 失败 turn 照算
if role == Role::Assistant && !copied {
tokens += ["input", "output", "reasoning"]
.iter()
.filter_map(|k| md.get("tokens")?.get(k)?.as_i64())
.sum::<i64>();
}
let Some(m) = message else { return };
built += 1;
if copied {
inherited = built;
}
// 共用解析每个 tool 块按序出一个调用
let tools = parts.iter().filter(|p| part_type(p) == Some("tool"));
for (part, call) in tools.zip(&mut m.tool_calls) {
call.child_id = part
.pointer("/state/metadata")
.and_then(|metadata| actor_child(&row.session, metadata));
}
// 检查点重建的上下文:带 checkpoint 块、只有 synthetic 文本(共用解析给成 Meta)的那条
if m.kind == MessageKind::Meta
&& parts.iter().any(|p| part_type(p) == Some("checkpoint"))
{
m.kind = MessageKind::CompactSummary;
}
match role {
Role::Assistant => {
m.model = optional_string(md.get("modelID"));
if true_at(md, "summary") {
m.kind = MessageKind::CompactSummary;
}
}
Role::User if md.get("provenance").is_some_and(|p| !p.is_null()) => {
m.kind = MessageKind::Meta;
}
_ => {}
}
},
)?;
collapse_inherited(&mut messages, inherited, "session");
// 导入的那段(转录里已经去掉)在开头留一条标记,与分叉复制来的那段同一种折法——内容本体在原来
// 那家 agent 的会话里
if let Some((source, count)) = import.filter(|(_, count)| *count > 0) {
let from = match source.as_str() {
"cc" => Some(AgentId::ClaudeCode),
other => AgentId::from_str(other),
}
.map_or(source.as_str(), |agent| agent.display_name());
messages.insert(
0,
collapsed_marker(
count as usize,
&format!("imported from {from}"),
row.created_ms,
),
);
}
assign_seq(&mut messages);
Ok(Parsed {
messages,
unknown,
tokens,
})
}
/// 这个会话的导入记录:来源(cc / codex / opencode)与导入了几条。没有导入表、没导入过给 None
fn import_of(
conn: &Connection,
schema: MiSchema,
sid: &str,
) -> rusqlite::Result<Option<(String, i64)>> {
if !schema.imports {
return Ok(None);
}
conn.query_row(
"SELECT source, CASE WHEN json_valid(message_ids) THEN json_array_length(message_ids) ELSE 0 END
FROM external_import WHERE session_id = ?1 ORDER BY time_imported DESC LIMIT 1",
[sid],
|r| Ok((r.get(0)?, r.get(1)?)),
)
.optional()
}
impl AgentAdapter for MimoAdapter {
fn agent(&self) -> AgentId {
AgentId::MimoCode
}
fn list_session_files(&self) -> Result<Vec<SessionFileRef>> {
// 库不在 = 没有会话;库在却读不出报 Err,scanner 冻结这一家这一轮(不变量 8①)——
// 当成没有会话的话,这一轮会把整家会话当"磁盘已删"清掉
if !self.db.is_file() {
return Ok(Vec::new());
}
let rows = self
.rows()
.ok_or_else(|| anyhow!("{} exists but could not be read", self.db.display()))?;
Ok(rows
.iter()
.map(|row| SessionFileRef {
agent: AgentId::MimoCode,
native_id: row.id.clone(),
file_path: virtual_path(&self.db, &row.id),
mtime_ms: row.updated_ms,
// 道子会话跟着会话归档,而 MiMo 归档只改会话那一行:归档那一位并进引用,道的戳没动
// 也会重解析(Kimi 的子代理同款)
size: row.content_len + i64::from(row.archived),
})
.collect())
}
fn manages_parent_links(&self) -> bool {
true
}
/// 子会话那一行的 parent_id,取这一轮枚举读到的那份(`MtimeCache::latest`,OpenCode 同款:
/// 扫描末尾才问到这里,按戳重读就是把整个枚举查询再跑一遍);还没枚举过就现读。库不在 =
/// 没有关系;库在却从没读成功过 = 不知道(None),库里的关系原样保留。道子会话的父会话写在
/// 它的 id 里(`parent_in_path`),不在这里报
fn parent_links(&self) -> Option<Vec<(String, String)>> {
if !self.db.is_file() {
return Some(Vec::new());
}
let rows = self.rows_cache.latest().or_else(|| self.rows())?;
Some(super::link_keys(
AgentId::MimoCode,
rows.iter()
.filter_map(|row| Some((row.id.as_str(), row.parent.as_deref()?))),
))
}
/// 关系记在子会话自己那一行:多 location 下按子会话的胜出副本认边
fn parent_links_in_child(&self) -> bool {
true
}
fn parent_in_path(&self) -> Option<ParentInPath> {
Some(lane_parent)
}
fn parse_session(&self, r: &SessionFileRef) -> Result<ParsedSession> {
let (meta, messages, unknown) = self.parse(r, false)?;
Ok(ParsedSession::derive(meta, &messages, unknown))
}
fn parse_transcript(&self, r: &SessionFileRef) -> Result<ParsedTranscript> {
let (meta, messages, unknown) = self.parse(r, true)?;
Ok(ParsedTranscript {
meta,
mainline: messages,
sidechains: Vec::new(),
unknown_line_count: unknown,
})
}
fn data_roots(&self) -> Vec<PathBuf> {
vec![self.db.clone()]
}
fn with_custom_root(&self, dir: PathBuf) -> Box<dyn AgentAdapter> {
Box::new(Self::with_db(custom_db(dir)))
}
}