All your AI agent sessions in one place — browse, search, resume. Rust + GPUI.
Rust
use super::parse_utils::*;
use super::sqlite_ro::{has_table, open_sqlite_ro, strip_virtual_path, virtual_path, SqliteRo};
use super::AgentAdapter;
use crate::models::*;
use anyhow::{anyhow, Result};
use serde_json::Value;
use std::collections::HashMap;
use std::path::{Path, PathBuf};
use std::sync::Arc;
/// OpenCode stable:`~/.local/share/opencode/opencode.db`;OpenCode 2 next 渠道
/// 另用同目录的 `opencode-next.db`。两库可同时存在,必须并行扫描而不是二选一。
///
/// v1:session 表 + 正文在 part 表({type:text|reasoning|tool},synthetic=注入),
/// message 表只有角色与时间。OpenCode 2(binary `opencode2`)的真实 next schema
/// 仍用 session 表,正文改放 session_message(type 列
/// user|synthetic|assistant,data JSON)。早期 preview 曾用 session_v2 表,这里也
/// 保持兼容。parent_id 非空 = 子代理(task 工具派出去的)会话:照常收录,经 `parent_links`
/// 挂到派它的会话下面。
///
/// Kilo Code 是同一个引擎上的另一个产品(见 `Flavor`),`OpencodeAdapter::kilo()`
/// 读它的 `~/.local/share/kilo/kilo.db`——WorkBuddy 之于 CodeBuddy 的同一种孪生
pub struct OpencodeAdapter {
flavor: &'static Flavor,
dbs: Vec<OcDb>,
}
/// 跑在 OpenCode 引擎上的产品。Kilo Code 2026-04 起整个换成 OpenCode 的分支(VS Code
/// 扩展在后台起 `kilo serve`,CLI 与 JetBrains 插件同一个引擎),三端共用一个库,表与
/// OpenCode 同形;差别只有下面这几项
struct Flavor {
agent: AgentId,
/// `$XDG_DATA_HOME`(缺省 `~/.local/share`)下的目录名。Windows 上同样是
/// `%USERPROFILE%\.local\share`(两家都用 xdg-basedir,它在 Windows 上也这么算)
dir: &'static str,
/// 常驻 roster 的固定候选库名:没装也在,装上后普通刷新就能发现
db_names: &'static [&'static str],
/// 指定库的环境变量:绝对路径,或相对数据目录的文件名(两家同一规则)
db_env: &'static str,
/// 有没有 OpenCode 2 的 preview / next 渠道:那边的会话打 opencode2 徽章,resume 据此
/// 换 opencode2 二进制(`OcRow::source`)。Kilo 没有这条渠道
marks_preview: bool,
}
/// OpenCode 2 next 渠道另起的库名(preview 会话的最强信号,见 `OcRow::source`)
const NEXT_DB: &str = "opencode-next.db";
const OPENCODE: Flavor = Flavor {
agent: AgentId::Opencode,
dir: "opencode",
db_names: &["opencode.db", NEXT_DB],
db_env: "OPENCODE_DB",
marks_preview: true,
};
/// 渠道库(`kilo-<channel>.db`)只有 Kilo 自己的开发构建会写,扩展还强制
/// `KILO_DISABLE_CHANNEL_DB=true`,所以只认 `kilo.db`
const KILO: Flavor = Flavor {
agent: AgentId::Kilo,
dir: "kilo",
db_names: &["kilo.db"],
db_env: "KILO_DB",
marks_preview: false,
};
struct OcDb {
path: PathBuf,
/// 元数据查询带全表相关子查询,按各库 mtime 分别缓存一轮扫描内的重复调用
rows_cache: MtimeCache<Arc<Vec<OcRow>>>,
}
/// 两代 session 表的公共列(别名 s;content_len 子查询两代不同,单独拼)
const ROW_COLS: &str = "s.id, s.directory, s.title, s.time_created, s.time_updated,
s.model, s.tokens_input + s.tokens_output + s.tokens_reasoning,
s.time_archived, s.version";
fn select_from(table: &str, content_len: &str, v2_messages: &str) -> String {
format!(
"SELECT {ROW_COLS}, {content_len} AS content_len,
{v2_messages} AS v2_messages, s.parent_id
FROM {table} s"
)
}
/// 根据库内真实表组合生成一次枚举 SQL。新版 next 与 v1 共用 session 表,
/// 所以必须逐会话看 session_message 是否有正文;仅检查 session_v2 会把真实
/// next 会话误走 part 路径并以 content_len=0 全部过滤(GitHub #2)。
///
/// 两代表都有行时,session_message 里有用户 / 助手消息才算 v2 转录;只有 shell /
/// compaction 这类旁路记录的(实验开关 `*_EXPERIMENTAL_EVENT_SYSTEM` 下 v1 运行时的
/// 零星双写,Kilo 实测)读 message + part,否则整段对话会被换成那几条
/// Ok(None) = 没有会话表
fn rows_sql(conn: &rusqlite::Connection) -> rusqlite::Result<Option<String>> {
let has_session = has_table(conn, "session")?;
let has_session_v2 = has_table(conn, "session_v2")?;
let has_parts = has_table(conn, "part")?;
let has_messages_v2 = has_table(conn, "session_message")?;
if !has_session && !has_session_v2 {
return Ok(None);
}
let part_len = "(SELECT COALESCE(SUM(LENGTH(p.data)), 0) FROM part p \
WHERE p.session_id = s.id)";
let message_len = "(SELECT COALESCE(SUM(LENGTH(m.data)), 0) FROM session_message m \
WHERE m.session_id = s.id)";
let v2_transcript = "(EXISTS(SELECT 1 FROM session_message m WHERE m.session_id = s.id \
AND m.type IN ('user', 'assistant')) \
OR NOT EXISTS(SELECT 1 FROM message mm WHERE mm.session_id = s.id))";
let mut selects = Vec::new();
// 早期 preview schema:session_v2 是全集,session 仅作 v1 回捞。
if has_session_v2 {
let len = if has_messages_v2 { message_len } else { "0" };
selects.push(select_from("session_v2", len, "1"));
}
if has_session {
let (len, v2) = match (has_parts, has_messages_v2) {
(true, true) => (
format!("CASE WHEN {v2_transcript} THEN {message_len} ELSE {part_len} END"),
v2_transcript.to_string(),
),
(true, false) => (part_len.to_string(), "0".to_string()),
(false, true) => (message_len.to_string(), "1".to_string()),
(false, false) => ("0".to_string(), "0".to_string()),
};
let mut sql = select_from("session", &len, &v2);
if has_session_v2 {
sql.push_str(" WHERE s.id NOT IN (SELECT id FROM session_v2)");
}
selects.push(sql);
}
Ok(Some(selects.join(" UNION ALL ")))
}
/// 没有 session 表的库(刚建好、还没迁移)是确定没有会话,不是读不出
fn query_rows(conn: &rusqlite::Connection, id: Option<&str>) -> Result<Vec<OcRow>> {
let Some(sql) = rows_sql(conn)? else {
return Ok(Vec::new());
};
let sql = match id {
Some(_) => format!("SELECT * FROM ({sql}) WHERE id = ?1"),
None => sql,
};
let mut stmt = conn.prepare(&sql)?;
let rows = match id {
Some(id) => stmt
.query_map([id], row_from)?
.collect::<rusqlite::Result<Vec<_>>>()?,
None => stmt
.query_map([], row_from)?
.collect::<rusqlite::Result<Vec<_>>>()?,
};
Ok(rows)
}
fn row_from(r: &rusqlite::Row) -> rusqlite::Result<OcRow> {
Ok(OcRow {
id: r.get(0)?,
directory: r.get::<_, Option<String>>(1)?.unwrap_or_default(),
title: r.get::<_, Option<String>>(2)?.unwrap_or_default(),
created_ms: r.get::<_, Option<i64>>(3)?.unwrap_or(0),
updated_ms: r.get::<_, Option<i64>>(4)?.unwrap_or(0),
model_json: r.get::<_, Option<String>>(5)?.unwrap_or_default(),
tokens: r.get::<_, Option<i64>>(6)?.unwrap_or(0),
archived: r.get::<_, Option<i64>>(7)?.is_some(),
version: r.get::<_, Option<String>>(8)?.unwrap_or_default(),
content_len: r.get(9)?,
v2_messages: r.get::<_, i64>(10)? != 0,
parent: r
.get::<_, Option<String>>(11)?
.filter(|parent| !parent.is_empty()),
})
}
impl OcDb {
fn new(path: PathBuf) -> Self {
Self {
path,
rows_cache: MtimeCache::new(),
}
}
}
fn push_unique(paths: &mut Vec<PathBuf>, path: PathBuf) {
if !paths.contains(&path) {
paths.push(path);
}
}
fn known_db_paths(flavor: &Flavor, dir: &Path) -> Vec<PathBuf> {
flavor.db_names.iter().map(|name| dir.join(name)).collect()
}
/// OpenCode 的数据目录服从 XDG;next 渠道另命名数据库而非替换 stable 库。
/// 两个固定候选都常驻 roster,这样 Wake 启动后才安装任一 CLI,普通刷新也能发现。
/// OPENCODE_DB 若被 GUI 进程继承则作为额外候选,但绝不压掉两个标准位置。
/// Kilo 同一套规则(`KILO_DB`,固定候选只有 `kilo.db`)
fn default_db_paths(flavor: &Flavor) -> Vec<PathBuf> {
let default_dir = super::home_dir()
.unwrap_or_default()
.join(".local")
.join("share")
.join(flavor.dir);
let xdg_dir = super::env_dir("XDG_DATA_HOME").map(|x| x.join(flavor.dir));
let active_dir = xdg_dir
.as_ref()
.filter(|dir| known_db_paths(flavor, dir).iter().any(|p| p.is_file()))
.unwrap_or(&default_dir);
let mut paths = Vec::new();
if let Some(value) = std::env::var_os(flavor.db_env).filter(|v| !v.is_empty()) {
let configured = PathBuf::from(value);
if configured != Path::new(":memory:") {
let configured = if configured.is_absolute() {
configured
} else {
active_dir.join(configured)
};
if configured.is_file() {
push_unique(&mut paths, configured);
}
}
}
for path in known_db_paths(flavor, active_dir) {
push_unique(&mut paths, path);
}
// XDG 位置被采信时,默认目录里已有的库仍是只读候选,避免稳定版历史消失。
if active_dir != &default_dir {
for path in known_db_paths(flavor, &default_dir)
.into_iter()
.filter(|p| p.is_file())
{
push_unique(&mut paths, path);
}
}
paths
}
fn custom_db_paths(flavor: &Flavor, dir: PathBuf) -> Vec<PathBuf> {
if dir.is_file() {
return vec![dir];
}
let nested = dir.join(flavor.dir);
let db_dir = if nested.is_dir() || known_db_paths(flavor, &nested).iter().any(|p| p.is_file()) {
nested
} else {
dir
};
known_db_paths(flavor, &db_dir)
}
impl OpencodeAdapter {
pub fn new() -> Self {
Self::with_dbs(&OPENCODE, default_db_paths(&OPENCODE))
}
/// Kilo Code 的新版(2026-04 起)数据源:`~/.local/share/kilo/kilo.db`。旧版扩展的
/// 任务目录是同一家的第二个实例(adapters::kilo)
pub fn kilo() -> Self {
Self::with_dbs(&KILO, default_db_paths(&KILO))
}
fn with_dbs(flavor: &'static Flavor, paths: Vec<PathBuf>) -> Self {
Self {
flavor,
dbs: paths.into_iter().map(OcDb::new).collect(),
}
}
fn open(&self, db: &Path) -> Option<SqliteRo> {
open_sqlite_ro(db, self.flavor.dir)
}
/// None = 库在却读不出(打不开、查询出错)
fn rows(&self, db: &OcDb) -> Option<Arc<Vec<OcRow>>> {
let stamp = super::sqlite_ro::db_cache_stamp(&db.path);
db.rows_cache.get_or_try_build(stamp, || {
let ro = self.open(&db.path)?;
query_rows(&ro.conn, None).ok().map(Arc::new)
})
}
fn db_for_ref(&self, r: &SessionFileRef) -> Option<&OcDb> {
let db_path = Path::new(strip_virtual_path(&r.file_path));
self.dbs.iter().find(|db| db.path == db_path)
}
fn build_meta(
&self,
r: &SessionFileRef,
row: &OcRow,
db: &Path,
message_count: i64,
) -> SessionMeta {
let title = clean_title_candidate(&row.title);
let model = serde_json::from_str::<Value>(&row.model_json)
.ok()
.and_then(|m| m.get("id").and_then(|v| v.as_str()).map(String::from));
let project_path = canonical_project_path(&row.directory);
SessionMeta {
key: session_key(self.flavor.agent, "", &row.id),
host: String::new(),
id: row.id.clone(),
agent: self.flavor.agent,
title: if title.is_empty() {
UNTITLED.to_string()
} else {
title
},
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,
size_bytes: r.size,
git_branch: None,
model,
tokens_used: if row.tokens > 0 {
Some(row.tokens)
} else {
None
},
archived: row.archived,
source: self.flavor.marks_preview.then(|| row.source(db)).flatten(),
spawned: row.parent.is_some(),
favorite: false,
pinned: false,
}
}
/// 单会话解析:一次连接;v2 行命中走 session_message,否则回落 v1 的
/// message + part 两表路径
fn parse(
&self,
r: &SessionFileRef,
decode_images: bool,
) -> Result<(SessionMeta, Vec<TranscriptMessage>, u32)> {
let _image_budget = transcript_image_decode_budget(decode_images);
let db = self
.db_for_ref(r)
.ok_or_else(|| anyhow!("opencode database is outside adapter roots"))?;
let ro = self
.open(&db.path)
.ok_or_else(|| anyhow!("cannot open {} db", self.flavor.dir))?;
let row = query_rows(&ro.conn, Some(&r.native_id))?
.into_iter()
.next()
.ok_or_else(|| anyhow!("opencode session {} not in db", r.native_id))?;
let (messages, unknown) = match row.v2_messages {
true => parse_v2_messages(&ro, &r.native_id, decode_images)?,
false => parse_v1_messages(
&ro,
&r.native_id,
decode_images,
&V1Query::OPENCODE,
|_, _, _, _| {},
)?,
};
let count = messages
.iter()
.filter(|m| m.kind == MessageKind::Text)
.count() as i64;
let meta = self.build_meta(r, &row, &db.path, count);
Ok((meta, messages, unknown))
}
}
/// v1 两表路径的取法:排序子句,与 message 表上的筛选。OpenCode 按 id(前缀时间有序)读整个
/// 会话;ZCode 的两张表另有 autofill 的 sequence 列,优先按它;MiMo Code 只读要显示的那一段
pub(crate) struct V1Query {
pub(crate) part: &'static str,
pub(crate) message: &'static str,
/// message 表上追加的条件。`?1` 是会话 id;条件既拼进 message 查询,也拼进 part 查询里挑消息
/// 的子查询,不带表名的列都要落在 message 表上;part 只取被选中的消息的。None = 整个会话
pub(crate) filter: Option<String>,
}
impl V1Query {
pub(crate) const OPENCODE: V1Query = V1Query {
part: "message_id, id",
message: "time_created, id",
filter: None,
};
}
/// JSON 列直接从 SQLite 的缓冲区解析,不先拷成 String:part 载荷(工具输出)
/// 动辄几十 KB、一条会话几百个。非文本 / 坏 JSON 给 None,调用方计 unknown
fn json_at(r: &rusqlite::Row<'_>, ix: usize) -> rusqlite::Result<Option<Value>> {
Ok(r.get_ref(ix)?
.as_str()
.ok()
.and_then(|s| serde_json::from_str(s).ok()))
}
/// v1 正文:message 表(角色/时间)+ part 表(内容块)按 message_id 分组。
/// `on_message` 对每一行 message 都调一次——带上这一行的 part 与已判好的角色,第四个参数是这一行
/// 拼出的消息,全空(如只有 error 的失败 turn)时为 None;ZCode / MiMo Code 用它拿 model / token /
/// semantics(MiMo 还从 part 里认派活的道与检查点),OpenCode 传空闭包。各家的差异只在这里和取法
/// (`V1Query`)
pub(crate) fn parse_v1_messages(
ro: &SqliteRo,
sid: &str,
decode_images: bool,
query: &V1Query,
mut on_message: impl FnMut(&Value, &[Value], Role, Option<&mut TranscriptMessage>),
) -> Result<(Vec<TranscriptMessage>, u32)> {
// 筛过的只取被选中消息的 part,按 message_id 走索引:挑消息的子查询已经钉住了会话,再写
// `session_id = ?1` 会让 SQLite 改走会话索引,把整个会话的 part 读一遍再排序
let (part_where, message_filter) = match &query.filter {
Some(f) => (
format!("message_id IN (SELECT id FROM message WHERE session_id = ?1 AND {f})"),
format!(" AND {f}"),
),
None => ("session_id = ?1".to_string(), String::new()),
};
let mut parts_by_msg: HashMap<String, Vec<Value>> = HashMap::new();
{
let mut stmt = ro.conn.prepare(&format!(
"SELECT message_id, data FROM part WHERE {part_where} ORDER BY {}",
query.part
))?;
let rows = stmt.query_map([sid], |p| Ok((p.get::<_, String>(0)?, json_at(p, 1)?)))?;
for (mid, data) in rows.flatten() {
if let Some(v) = data {
parts_by_msg.entry(mid).or_default().push(v);
}
}
}
let mut messages: Vec<TranscriptMessage> = Vec::new();
let mut unknown = 0u32;
let mut stmt = ro.conn.prepare(&format!(
"SELECT id, data FROM message WHERE session_id = ?1{message_filter} ORDER BY {}",
query.message
))?;
let msg_rows = stmt.query_map([sid], |m| Ok((m.get::<_, String>(0)?, json_at(m, 1)?)))?;
for (mid, data) in msg_rows.flatten() {
let Some(md) = data else {
unknown += 1;
continue;
};
let role = match md.get("role").and_then(|v| v.as_str()) {
Some("user") => Role::User,
Some("assistant") => Role::Assistant,
_ => Role::System,
};
let ts = md
.get("time")
.and_then(|t| t.get("created"))
.and_then(|v| v.as_i64())
.unwrap_or(0);
let mut acc = BlockAcc::default();
let parts = parts_by_msg.remove(&mid).unwrap_or_default();
for p in &parts {
if !acc.push_part(p, decode_images) {
unknown += 1;
}
}
let mut built = acc.into_message(role, ts, None);
on_message(&md, &parts, role, built.as_mut());
if let Some(m) = built {
messages.push(m);
}
}
assign_seq(&mut messages);
Ok((messages, unknown))
}
/// v2 正文:session_message 单表按 seq 有序,type 列分 user/synthetic/assistant,
/// data JSON——user 的 text 在顶层,assistant 的 content 是块数组
fn parse_v2_messages(
ro: &SqliteRo,
sid: &str,
decode_images: bool,
) -> Result<(Vec<TranscriptMessage>, u32)> {
let mut messages: Vec<TranscriptMessage> = Vec::new();
let mut unknown = 0u32;
let mut stmt = ro
.conn
.prepare("SELECT type, data FROM session_message WHERE session_id = ?1 ORDER BY seq")?;
let rows = stmt.query_map([sid], |m| {
Ok((m.get::<_, String>(0)?, m.get::<_, String>(1)?))
})?;
for (mtype, data) in rows.flatten() {
let Ok(md) = serde_json::from_str::<Value>(&data) else {
unknown += 1;
continue;
};
let ts = md
.get("time")
.and_then(|t| t.get("created"))
.and_then(|v| v.as_i64())
.unwrap_or(0);
match mtype.as_str() {
"user" => {
let text = md.get("text").and_then(|v| v.as_str()).unwrap_or("").trim();
let mut parsed = content_parts(
md.get("content")
.or_else(|| md.get("attachments"))
.unwrap_or(&Value::Null),
decode_images,
);
if text == parsed.text.trim() {
parsed.text = text.to_string();
} else if !text.is_empty() {
let mut combined = ParsedContent::default();
combined.push_text(text);
combined.append(parsed);
parsed = combined;
}
if !parsed.text.is_empty() || !parsed.images.is_empty() {
let mut message = text_msg(Role::User, &parsed.text, ts);
message.images = parsed.images;
messages.push(message);
}
}
"synthetic" => {
// 注入内容(编辑器上下文等),归 Meta 折叠
let text = md.get("text").and_then(|v| v.as_str()).unwrap_or("").trim();
if !text.is_empty() {
let mut m = text_msg(Role::User, text, ts);
m.kind = MessageKind::Meta;
messages.push(m);
}
}
"system" => {
let text = md.get("text").and_then(|v| v.as_str()).unwrap_or("").trim();
if !text.is_empty() {
let mut m = text_msg(Role::System, text, ts);
m.kind = MessageKind::Meta;
messages.push(m);
}
}
"shell" => {
let command = md.get("command").and_then(|v| v.as_str()).unwrap_or("");
let input = serde_json::json!({ "command": command });
let output = md
.get("output")
.and_then(|v| v.as_str())
.filter(|s| !s.is_empty())
.map(String::from);
let mut acc = BlockAcc::default();
acc.tools.push(tool_call_view(
md.get("callID")
.and_then(|v| v.as_str())
.unwrap_or("")
.to_string(),
"shell",
&input,
output,
false,
));
if let Some(m) = acc.into_message(Role::Assistant, ts, None) {
messages.push(m);
}
}
"assistant" => {
let model = md
.pointer("/model/id")
.and_then(|v| v.as_str())
.map(String::from);
let mut acc = BlockAcc::default();
for b in md
.get("content")
.and_then(|c| c.as_array())
.into_iter()
.flatten()
{
// v2 的助手块从不带 synthetic,分派与 v1 同一份
if !acc.push_part(b, decode_images) {
unknown += 1;
}
}
if let Some(m) = acc.into_message(Role::Assistant, ts, model) {
messages.push(m);
}
}
"compaction" => {
let summary = md
.get("summary")
.and_then(|v| v.as_str())
.unwrap_or("")
.trim();
if !summary.is_empty() {
let mut m = text_msg(Role::System, summary, ts);
m.kind = MessageKind::CompactSummary;
messages.push(m);
}
}
// 纯状态切换不形成对话消息,但它们是已知 schema,不计未知行。
"agent-switched" | "model-switched" => {}
_ => unknown += 1,
}
}
assign_seq(&mut messages);
Ok((messages, unknown))
}
/// 一条消息的内容块累加器(text/synthetic/reasoning/tool),两代路径共用
#[derive(Default)]
struct BlockAcc {
content: ParsedContent,
synthetic: Vec<String>,
thinking: Vec<String>,
tools: Vec<ToolCallView>,
}
impl BlockAcc {
/// 一个 part 块 → 累加器;返回 false = 表外类型(调用方计 unknown)。
/// ZCode 与 MiMo Code 的 part 与这里同形(都是 OpenCode 的衍生物),共用这一个分派
fn push_part(&mut self, p: &Value, decode_images: bool) -> bool {
match p.get("type").and_then(|v| v.as_str()) {
Some("text") => {
let t = p.get("text").and_then(|v| v.as_str()).unwrap_or("");
if t.trim().is_empty() {
return true;
}
if p.get("synthetic").and_then(|v| v.as_bool()) == Some(true) {
self.synthetic.push(t.trim().to_string());
} else {
self.content.push_text(t);
}
}
Some("reasoning") => self.push_reasoning(p),
Some("tool") => self.push_tool(p, decode_images),
Some("image") => self.push_image(p, decode_images),
// 用户敲的命令要派子代理时,这一条用户消息里只有它(没有 text 块):照用户
// 敲的写回 `/命令`,命令名缺席才退到描述与派给子代理的提示词
Some("subtask") => {
let text = match optional_string(p.get("command")) {
Some(command) => format!("/{command}"),
None => ["description", "prompt"]
.iter()
.find_map(|k| optional_string(p.get(*k)))
.unwrap_or_default(),
};
self.content.push_text(&text);
}
// agent = 正文里 @ 了哪个代理(文字本身在 text 块里);retry = 请求重试的记录;
// compaction = 触发压缩的标记(摘要本身是后面那条助手消息);timeline = ZCode 画在
// 对话里的分隔条(分叉、压缩进度),没有正文;checkpoint = MiMo Code 的上下文检查点
// (那条消息怎么折由 MiMo 的钩子定)
Some("step-start") | Some("step-finish") | Some("snapshot") | Some("patch")
| Some("agent") | Some("retry") | Some("compaction") | Some("timeline")
| Some("checkpoint") => {}
Some("file") if is_image_part(p) => self.push_image(p, decode_images),
Some("file") => {}
_ => return false,
}
true
}
fn push_reasoning(&mut self, b: &Value) {
if let Some(t) = b.get("text").and_then(|v| v.as_str()) {
if !t.trim().is_empty() {
self.thinking.push(t.trim().to_string());
}
}
}
/// tool 块兼容两种形态:
/// preview 早期 `{callID,tool,state:{input,output}}` 与真实 next
/// `{id,name,state:{input,content,result,error}}`。
fn push_tool(&mut self, b: &Value, decode_images: bool) {
let state = b.get("state").cloned().unwrap_or(Value::Null);
let input = state.get("input").cloned().unwrap_or(Value::Null);
let mut output = opencode_tool_output(&state);
if let Some(content) = state.get("content") {
let parsed = content_parts(content, decode_images);
if !parsed.text.is_empty() {
output = Some(parsed.text);
}
let mut images = parsed.images;
for image in &mut images {
image.text_offset = self.content.text.len();
}
self.content.images.extend(images);
}
let mut call = tool_call_view(
b.get("callID")
.or_else(|| b.get("id"))
.and_then(|v| v.as_str())
.unwrap_or("")
.to_string(),
b.get("tool")
.or_else(|| b.get("name"))
.and_then(|v| v.as_str())
.unwrap_or("tool"),
&input,
output,
state.get("status").and_then(|v| v.as_str()) == Some("error"),
);
// task 工具派出去的子会话:它的 id 记在调用的 metadata 里
call.child_id = optional_string(state.pointer("/metadata/sessionId"));
self.tools.push(call);
}
fn push_image(&mut self, block: &Value, decode_images: bool) {
let parsed = content_parts(block, decode_images);
self.content.append(parsed);
}
/// 组装为消息;全空返回 None。只有注入内容的消息归 Meta 折叠。
fn into_message(self, role: Role, ts: i64, model: Option<String>) -> Option<TranscriptMessage> {
let ParsedContent { text, images } = self.content;
let (text, kind) = if text.is_empty() && !self.synthetic.is_empty() {
(self.synthetic.join("\n\n"), MessageKind::Meta)
} else {
(text, MessageKind::Text)
};
if text.is_empty() && self.thinking.is_empty() && self.tools.is_empty() && images.is_empty()
{
return None;
}
let (clipped, truncated) = clip(&text, MAX_MSG_TEXT);
Some(TranscriptMessage {
seq: 0,
role,
kind,
text: clipped,
truncated,
tool_calls: self.tools,
thinking: if self.thinking.is_empty() {
None
} else {
Some(clip(&self.thinking.join("\n\n"), MAX_TOOL_IO).0)
},
timestamp: if ts > 0 { Some(ts) } else { None },
model,
images,
})
}
}
fn opencode_tool_output(state: &Value) -> Option<String> {
if let Some(output) = state.get("output") {
return match output {
Value::String(s) if !s.is_empty() => Some(s.clone()),
v if !v.is_null() => serde_json::to_string(v).ok(),
_ => None,
};
}
if let Some(content) = state.get("content").and_then(|v| v.as_array()) {
let rendered = content
.iter()
.filter_map(|item| match item.get("type").and_then(|v| v.as_str()) {
Some("text") => item.get("text").and_then(|v| v.as_str()).map(String::from),
Some("file") => item
.get("name")
.or_else(|| item.get("uri"))
.and_then(|v| v.as_str())
.map(|s| format!("[file: {s}]")),
_ => None,
})
.collect::<Vec<_>>()
.join("\n");
if !rendered.is_empty() {
return Some(rendered);
}
}
if let Some(result) = state.get("result").filter(|v| !v.is_null()) {
return match result {
Value::String(s) => Some(s.clone()),
v => serde_json::to_string(v).ok(),
};
}
state
.pointer("/error/message")
.and_then(|v| v.as_str())
.filter(|s| !s.is_empty())
.map(String::from)
}
#[derive(Clone)]
struct OcRow {
id: String,
directory: String,
title: String,
created_ms: i64,
updated_ms: i64,
model_json: String,
tokens: i64,
archived: bool,
/// 会话产生时的 CLI 版本("1.14.50" / "0.0.0-beta-17639"),v2 迁移保留原值
version: String,
content_len: i64,
/// 这条会话的正文实际来自 session_message,而不是旧 message + part。
v2_messages: bool,
/// 派出这个子代理会话的会话 id
parent: Option<String>,
}
impl OcRow {
/// preview 会话在 UI 标 "opencode2",resume 据此换二进制。next 库名本身
/// 是最强信号;共享库/早期 schema 则回看写入 session.version 的渠道标记。
fn source(&self, db: &Path) -> Option<String> {
let next_db = db.file_name().and_then(|n| n.to_str()) == Some(NEXT_DB);
let v2 = next_db
|| self.version.starts_with('2')
|| self.version.contains("beta")
|| self.version.contains("next");
v2.then(|| "opencode2".to_string())
}
}
impl AgentAdapter for OpencodeAdapter {
fn agent(&self) -> AgentId {
self.flavor.agent
}
fn list_session_files(&self) -> Result<Vec<SessionFileRef>> {
let mut out = Vec::new();
// 库不在 = 没有会话;库在却读不出报 Err,scanner 冻结这一家这一轮(不变量 8①)——
// 当成没有会话的话,这一轮会把整家会话当"磁盘已删"清掉
for db in self.dbs.iter().filter(|db| db.path.is_file()) {
let rows = self
.rows(db)
.ok_or_else(|| anyhow!("{} exists but could not be read", db.path.display()))?;
out.extend(
rows.iter()
.filter(|row| row.content_len > 0)
.map(|row| SessionFileRef {
agent: self.flavor.agent,
native_id: row.id.clone(),
file_path: virtual_path(&db.path, &row.id),
mtime_ms: row.updated_ms,
size: row.content_len,
}),
);
}
Ok(out)
}
fn manages_parent_links(&self) -> bool {
true
}
/// 子代理会话那一行的 parent_id,取这一轮枚举读到的那份(`MtimeCache::latest`:扫描末尾
/// 才问到这里,库在扫描期间被写过时按戳重读就是把整个枚举查询再跑一遍)。库不在 = 没有
/// 关系;库在却从没读成功过 = 不知道(None),库里的关系原样保留
fn parent_links(&self) -> Option<Vec<(String, String)>> {
let mut snapshots = Vec::new();
for db in self.dbs.iter().filter(|db| db.path.is_file()) {
snapshots.push((db, db.rows_cache.latest()?));
}
// 同一会话在 stable 与 next 两个库里各有一份时,关系跟 scanner 选中的那份走(两个库
// 位次相同:更新时间新的,平局虚拟路径小的);每个库各报一遍的话,后报的说了算
let mut chosen: HashMap<&str, (&OcDb, &OcRow)> = HashMap::new();
for (db, rows) in &snapshots {
// 没有正文的副本不列(list_session_files 同一条),scanner 用的是另一份,也就不参与裁决
for row in rows.iter().filter(|row| row.content_len > 0) {
let wins = chosen.get(row.id.as_str()).is_none_or(|(best_db, best)| {
row.updated_ms > best.updated_ms
|| (row.updated_ms == best.updated_ms
&& virtual_path(&db.path, &row.id)
< virtual_path(&best_db.path, &best.id))
});
if wins {
chosen.insert(&row.id, (db, row));
}
}
}
Some(super::link_keys(
self.flavor.agent,
chosen
.into_iter()
.filter_map(|(id, (_, row))| Some((id, row.parent.as_deref()?))),
))
}
/// 关系记在子会话自己那一行:多 location 下按子会话的胜出副本认边
fn parent_links_in_child(&self) -> bool {
true
}
fn quick_meta(&self, refs: &[SessionFileRef]) -> Option<HashMap<String, SessionMeta>> {
let mut out = HashMap::new();
let mut opened = false;
for db in &self.dbs {
let Some(rows) = self.rows(db) else { continue };
opened = true;
let by_id: HashMap<&str, &OcRow> =
rows.iter().map(|row| (row.id.as_str(), row)).collect();
for r in refs
.iter()
.filter(|r| Path::new(strip_virtual_path(&r.file_path)) == db.path.as_path())
{
if let Some(row) = by_id.get(r.native_id.as_str()) {
out.insert(r.file_path.clone(), self.build_meta(r, row, &db.path, 0));
}
}
}
opened.then_some(out)
}
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 with_custom_root(&self, dir: PathBuf) -> Box<dyn AgentAdapter> {
// 目录 location 同时扫描 stable + next,直接给库文件则只认该文件。
// 选中 XDG data 根或 opencode / kilo 目录本身都可归一化(Kilo 旧版扩展的任务
// 目录由旧版实例认领,见 adapters::kilo)
Box::new(Self::with_dbs(
self.flavor,
custom_db_paths(self.flavor, dir),
))
}
fn data_roots(&self) -> Vec<PathBuf> {
self.dbs.iter().map(|db| db.path.clone()).collect()
}
fn supports_individual_root_removal(&self) -> bool {
true
}
/// Kilo 一家两源(本实例的 kilo.db 与 adapters::kilo 的旧版任务目录):排除列表按
/// agent 收集,里面可能全是另一个源的根——那时原样交回自己,与"与我无关"等价
fn excluding_data_roots(&self, roots: &[PathBuf]) -> Option<Box<dyn AgentAdapter>> {
Some(Box::new(Self::with_dbs(
self.flavor,
self.dbs
.iter()
.filter(|db| !roots.contains(&db.path))
.map(|db| db.path.clone())
.collect(),
)))
}
}