claude-opencode-sessions 0.1.0__py3-none-any.whl

claude_opencode_sessions/sqlite_backend.py

@@ -0,0 +1,249 @@
+"""Read-only access to opencode's SQLite database.
+
+Supported layouts (detected per database, and per session for messages):
+
+* opencode 1.x (>= 1.2): ``session`` + ``message`` + ``part``.
+* opencode 2.x: ``session_v2`` (or ``session`` on early 2.x builds) +
+  ``session_message``. Legacy 1.x rows that still live in the same file are
+  merged in, de-duplicated by session id (2.x wins).
+
+The database is opened with ``mode=ro``: this module never writes.
+"""
+
+from __future__ import annotations
+
+import sqlite3
+from collections.abc import Iterable
+from pathlib import Path
+from typing import Any
+
+from .errors import SchemaError
+from .models import Message, Session, format_model
+from .parse import loads, parse_v1_message, parse_v2_row
+
+__all__ = ["SqliteBackend"]
+
+_SESSION_COLUMNS = (
+    "id",
+    "title",
+    "directory",
+    "project_id",
+    "parent_id",
+    "time_created",
+    "time_updated",
+    "time_archived",
+    "agent",
+    "model",
+    "version",
+    "cost",
+    "tokens_input",
+    "tokens_output",
+)
+_REQUIRED_SESSION_COLUMNS = {"id", "directory", "time_updated"}
+_REQUIRED_V2_MESSAGE_COLUMNS = {"id", "session_id", "type", "data", "seq"}
+_REQUIRED_V1_MESSAGE_COLUMNS = {"id", "session_id", "data"}
+_CONVERSATION_TYPES = ("user", "assistant")
+
+
+def _placeholders(count: int) -> str:
+    return ",".join("?" * count)
+
+
+class SqliteBackend:
+    name = "sqlite"
+
+    def __init__(self, path: str | Path, timeout: float = 2.0) -> None:
+        self.path = Path(path)
+        uri = f"{self.path.resolve().as_uri()}?mode=ro"
+        try:
+            self.conn = sqlite3.connect(uri, uri=True, timeout=timeout)
+        except sqlite3.Error as exc:
+            raise SchemaError(f"cannot open {self.path}: {exc}") from exc
+        self.conn.row_factory = sqlite3.Row
+        try:
+            self._detect()
+        except sqlite3.DatabaseError as exc:
+            self.conn.close()
+            raise SchemaError(f"cannot read {self.path}: {exc}") from exc
+        except SchemaError:
+            self.conn.close()
+            raise
+
+    # -- schema detection -------------------------------------------------
+
+    def _tables(self) -> set[str]:
+        rows = self.conn.execute(
+            "SELECT name FROM sqlite_master WHERE type = 'table'"
+        ).fetchall()
+        return {row[0] for row in rows}
+
+    def _columns(self, table: str) -> set[str]:
+        rows = self.conn.execute(f'PRAGMA table_info("{table}")').fetchall()
+        return {row[1] for row in rows}
+
+    def _detect(self) -> None:
+        tables = self._tables()
+        self.session_tables: list[str] = [
+            t
+            for t in ("session_v2", "session")
+            if t in tables and _REQUIRED_SESSION_COLUMNS <= self._columns(t)
+        ]
+        if not self.session_tables:
+            raise SchemaError(
+                f"{self.path} has no opencode session table "
+                "(needs opencode >= 1.2; JSON storage of older versions is "
+                "not supported)"
+            )
+        self.has_v2_messages = (
+            "session_message" in tables
+            and _REQUIRED_V2_MESSAGE_COLUMNS <= self._columns("session_message")
+        )
+        self.has_v1_messages = (
+            "message" in tables
+            and "part" in tables
+            and _REQUIRED_V1_MESSAGE_COLUMNS <= self._columns("message")
+            and {"message_id", "data"} <= self._columns("part")
+        )
+        if not (self.has_v2_messages or self.has_v1_messages):
+            raise SchemaError(f"{self.path} has no opencode message tables")
+
+    def describe(self) -> str:
+        """Human-readable description of the detected layout."""
+        layouts = []
+        if self.has_v2_messages and self._count("session_message"):
+            layouts.append("2.x session_message")
+        if self.has_v1_messages and self._count("message"):
+            layouts.append("1.x message/part")
+        if not layouts:
+            layouts.append("empty")
+        return f"{'+'.join(self.session_tables)} · {', '.join(layouts)}"
+
+    def _count(self, table: str) -> int:
+        row = self.conn.execute(f'SELECT count(*) FROM "{table}"').fetchone()
+        return int(row[0])
+
+    def table_report(self) -> dict[str, int]:
+        """Row counts of the tables this backend reads (for ``doctor``)."""
+        report: dict[str, int] = {}
+        tables = self._tables()
+        for table in ("session_v2", "session", "session_message", "message", "part"):
+            if table in tables:
+                report[table] = self._count(table)
+        return report
+
+    # -- sessions ---------------------------------------------------------
+
+    def _message_counts(self) -> dict[str, int]:
+        counts: dict[str, int] = {}
+        if self.has_v1_messages:
+            for row in self.conn.execute(
+                "SELECT session_id, count(*) FROM message GROUP BY session_id"
+            ):
+                counts[row[0]] = int(row[1])
+        if self.has_v2_messages:
+            sql = (
+                "SELECT session_id, count(*) FROM session_message "
+                f"WHERE type IN ({_placeholders(len(_CONVERSATION_TYPES))}) "
+                "GROUP BY session_id"
+            )
+            for row in self.conn.execute(sql, _CONVERSATION_TYPES):
+                counts[row[0]] = int(row[1])
+        return counts
+
+    def _select_sessions(self, table: str) -> Iterable[sqlite3.Row]:
+        available = self._columns(table)
+        exprs = [
+            f'"{col}" AS {col}' if col in available else f"NULL AS {col}"
+            for col in _SESSION_COLUMNS
+        ]
+        sql = f'SELECT {", ".join(exprs)} FROM "{table}"'
+        return self.conn.execute(sql)
+
+    def list_sessions(self) -> list[Session]:
+        counts = self._message_counts()
+        seen: dict[str, Session] = {}
+        for table in self.session_tables:
+            for row in self._select_sessions(table):
+                if row["id"] in seen:
+                    continue
+                seen[row["id"]] = Session(
+                    id=row["id"],
+                    title=row["title"] or "(untitled)",
+                    directory=row["directory"] or "",
+                    project_id=row["project_id"],
+                    parent_id=row["parent_id"],
+                    time_created=row["time_created"],
+                    time_updated=row["time_updated"],
+                    time_archived=row["time_archived"],
+                    agent=row["agent"],
+                    model=format_model(row["model"]),
+                    version=row["version"],
+                    message_count=counts.get(row["id"], 0),
+                    cost=row["cost"],
+                    tokens_input=row["tokens_input"],
+                    tokens_output=row["tokens_output"],
+                    origin=table,
+                )
+        return list(seen.values())
+
+    # -- messages ---------------------------------------------------------
+
+    def _load_v2(self, session_id: str) -> tuple[list[Message], int]:
+        rows = self.conn.execute(
+            "SELECT id, type, seq, time_created, data FROM session_message "
+            "WHERE session_id = ? ORDER BY seq",
+            (session_id,),
+        ).fetchall()
+        messages: list[Message] = []
+        errors = 0
+        for row in rows:
+            message, ok = parse_v2_row(
+                row["id"], row["type"], row["data"], row["seq"], row["time_created"]
+            )
+            errors += 0 if ok else 1
+            messages.append(message)
+        return messages, errors
+
+    def _load_v1(self, session_id: str) -> tuple[list[Message], int]:
+        msg_rows = self.conn.execute(
+            "SELECT id, time_created, data FROM message "
+            "WHERE session_id = ? ORDER BY time_created, id",
+            (session_id,),
+        ).fetchall()
+        parts_by_message: dict[str, list[Any]] = {}
+        for row in self.conn.execute(
+            "SELECT message_id, data FROM part WHERE session_id = ? "
+            "ORDER BY message_id, id",
+            (session_id,),
+        ):
+            parts_by_message.setdefault(row["message_id"], []).append(
+                loads(row["data"])
+            )
+        messages: list[Message] = []
+        errors = 0
+        for index, row in enumerate(msg_rows, start=1):
+            info = loads(row["data"])
+            if not isinstance(info, dict):
+                errors += 1
+                info = {}
+            info.setdefault("id", row["id"])
+            info.setdefault("time", {"created": row["time_created"]})
+            parts = parts_by_message.get(row["id"], [])
+            errors += sum(1 for p in parts if p is None)
+            messages.append(
+                parse_v1_message(info, [p for p in parts if p is not None], index)
+            )
+        return messages, errors
+
+    def load_messages(self, session_id: str) -> tuple[list[Message], int]:
+        """Return ``(messages, parse_errors)`` for one session."""
+        if self.has_v2_messages:
+            messages, errors = self._load_v2(session_id)
+            if messages:
+                return messages, errors
+        if self.has_v1_messages:
+            return self._load_v1(session_id)
+        return [], 0
+
+    def close(self) -> None:
+        self.conn.close()

claude_opencode_sessions/tests/conftest.py

@@ -0,0 +1,314 @@
+from __future__ import annotations
+
+import json
+import shutil
+import sqlite3
+import subprocess
+import sys
+import textwrap
+from collections.abc import Iterator
+from pathlib import Path
+from typing import Any
+
+import pytest
+
+FIXTURES = Path(__file__).parent / "fixtures"
+NOW = 1_790_000_000_000  # ms
+HOUR = 3_600_000
+
+
+class DbBuilder:
+    """Create opencode-like databases from the fixture schemas."""
+
+    def __init__(self, path: Path, schema: str) -> None:
+        self.path = path
+        self.conn = sqlite3.connect(path)
+        self.conn.executescript((FIXTURES / schema).read_text())
+        self._part = 0
+
+    def close(self) -> None:
+        if self.conn is not None:
+            self.conn.commit()
+            self.conn.close()
+            self.conn = None  # type: ignore[assignment]
+
+    # -- 1.x --------------------------------------------------------------
+
+    def session_1x(
+        self,
+        sid: str,
+        directory: str,
+        *,
+        title: str = "",
+        updated: int = NOW,
+        project_id: str = "proj1",
+        parent_id: str | None = None,
+        archived: int | None = None,
+        messages: list[tuple[dict[str, Any], list[dict[str, Any]]]] | None = None,
+        table: str = "session",
+    ) -> None:
+        self.conn.execute(
+            f"INSERT INTO {table} (id, project_id, parent_id, slug, directory, title,"
+            " version, time_created, time_updated, time_archived, agent, model)"
+            " VALUES (?, ?, ?, 'slug', ?, ?, '1.18.32', ?, ?, ?, 'build', ?)",
+            (
+                sid,
+                project_id,
+                parent_id,
+                directory,
+                title or f"Session {sid}",
+                updated - HOUR,
+                updated,
+                archived,
+                json.dumps({"id": "gpt-x", "providerID": "openai"}),
+            ),
+        )
+        for index, (info, parts) in enumerate(messages or [], start=1):
+            mid = f"{sid}_msg_{index:03d}"
+            info = {"id": mid, "sessionID": sid, **info}
+            info.setdefault("time", {"created": updated - HOUR + index * 1000})
+            self.conn.execute(
+                "INSERT INTO message (id, session_id, time_created, time_updated, data)"
+                " VALUES (?, ?, ?, ?, ?)",
+                (mid, sid, info["time"]["created"], updated, json.dumps(info)),
+            )
+            for part in parts:
+                self._part += 1
+                raw = part if isinstance(part, str) else json.dumps(part)
+                self.conn.execute(
+                    "INSERT INTO part (id, message_id, session_id, time_created,"
+                    " time_updated, data) VALUES (?, ?, ?, ?, ?, ?)",
+                    (f"prt_{self._part:06d}", mid, sid, updated, updated, raw),
+                )
+
+    # -- 2.x --------------------------------------------------------------
+
+    def session_2x(
+        self,
+        sid: str,
+        directory: str,
+        *,
+        title: str = "",
+        updated: int = NOW,
+        project_id: str = "proj1",
+        parent_id: str | None = None,
+        archived: int | None = None,
+        rows: list[tuple[str, Any]] | None = None,
+    ) -> None:
+        self.conn.execute(
+            "INSERT INTO session_v2 (id, project_id, parent_id, directory, title,"
+            " agent, model, time_created, time_updated, time_archived)"
+            " VALUES (?, ?, ?, ?, ?, 'build', ?, ?, ?, ?)",
+            (
+                sid,
+                project_id,
+                parent_id,
+                directory,
+                title or f"Session {sid}",
+                json.dumps({"id": "gpt-x", "providerID": "openai"}),
+                updated - HOUR,
+                updated,
+                archived,
+            ),
+        )
+        for seq, (kind, data) in enumerate(rows or [], start=1):
+            raw = data if isinstance(data, str) else json.dumps(data)
+            self.conn.execute(
+                "INSERT INTO session_message (id, session_id, type, time_created,"
+                " time_updated, data, seq) VALUES (?, ?, ?, ?, ?, ?, ?)",
+                (
+                    f"{sid}_sm_{seq:03d}",
+                    sid,
+                    kind,
+                    updated - HOUR + seq,
+                    updated,
+                    raw,
+                    seq,
+                ),
+            )
+
+
+def text_of(message: Any) -> str:
+    """Concatenated non-synthetic text parts of a parsed message."""
+    return "\n\n".join(
+        p.text for p in message.parts if p.kind == "text" and not p.synthetic
+    ).strip()
+
+
+def user(text: str, **extra: Any) -> tuple[dict[str, Any], list[dict[str, Any]]]:
+    return {"role": "user", **extra}, [{"type": "text", "text": text}]
+
+
+def assistant(
+    *parts: dict[str, Any], **extra: Any
+) -> tuple[dict[str, Any], list[dict[str, Any]]]:
+    info = {
+        "role": "assistant",
+        "agent": "build",
+        "modelID": "gpt-x",
+        "providerID": "openai",
+        "tokens": {"input": 100, "output": 20},
+        "cost": 0.01,
+        **extra,
+    }
+    return info, [{"type": "step-start"}, *parts, {"type": "step-finish"}]
+
+
+def text(value: str) -> dict[str, Any]:
+    return {"type": "text", "text": value}
+
+
+def tool(
+    name: str, args: dict[str, Any], output: str = "ok", status: str = "completed"
+) -> dict[str, Any]:
+    return {
+        "type": "tool",
+        "tool": name,
+        "callID": "c1",
+        "state": {"status": status, "input": args, "output": output, "title": name},
+    }
+
+
+@pytest.fixture
+def db_1x(tmp_path: Path) -> Iterator[DbBuilder]:
+    builder = DbBuilder(tmp_path / "opencode.db", "schema_1x.sql")
+    yield builder
+    builder.close()
+
+
+@pytest.fixture
+def db_2x(tmp_path: Path) -> Iterator[DbBuilder]:
+    builder = DbBuilder(tmp_path / "opencode.db", "schema_2x.sql")
+    yield builder
+    builder.close()
+
+
+needs_git = pytest.mark.skipif(shutil.which("git") is None, reason="git not installed")
+
+
+def _git(*args: str, cwd: Path) -> None:
+    subprocess.run(
+        ["git", *args],
+        cwd=cwd,
+        check=True,
+        capture_output=True,
+        env={
+            "GIT_AUTHOR_NAME": "t",
+            "GIT_AUTHOR_EMAIL": "t@example.com",
+            "GIT_COMMITTER_NAME": "t",
+            "GIT_COMMITTER_EMAIL": "t@example.com",
+            "PATH": __import__("os").environ.get("PATH", ""),
+            "HOME": str(cwd),
+        },
+    )
+
+
+@pytest.fixture
+def git_repo(tmp_path: Path) -> dict[str, Path]:
+    """A repo with one extra worktree and a subdirectory, plus a non-git dir."""
+    if shutil.which("git") is None:
+        pytest.skip("git not installed")
+    repo = tmp_path / "repo"
+    (repo / "sub" / "deep").mkdir(parents=True)
+    _git("init", "-q", "-b", "main", cwd=repo)
+    (repo / "README").write_text("x")
+    _git("add", ".", cwd=repo)
+    _git("commit", "-q", "-m", "init", cwd=repo)
+    feature = tmp_path / "repo-feature"
+    _git("worktree", "add", "-q", "-b", "feature", str(feature), cwd=repo)
+    plain = tmp_path / "plain"
+    (plain / "inner").mkdir(parents=True)
+    return {
+        "repo": repo.resolve(),
+        "feature": feature.resolve(),
+        "plain": plain.resolve(),
+        "other": (tmp_path / "elsewhere").resolve(),
+    }
+
+
+@pytest.fixture
+def fake_opencode(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> Path:
+    """Install a fake ``opencode`` executable on PATH that serves fixture JSON."""
+    bindir = tmp_path / "fakebin"
+    bindir.mkdir()
+    data = tmp_path / "fake-data.json"
+    data.write_text(
+        json.dumps(
+            {
+                "version": "1.18.32",
+                "sessions": [
+                    {
+                        "id": "ses_cli_1",
+                        "title": "From the CLI",
+                        "directory": str(tmp_path / "proj"),
+                        "projectID": "p",
+                        "time": {"created": NOW - HOUR, "updated": NOW},
+                    }
+                ],
+                "exports": {
+                    "ses_cli_1": {
+                        "info": {
+                            "id": "ses_cli_1",
+                            "title": "From the CLI",
+                            "directory": str(tmp_path / "proj"),
+                            "time": {"created": NOW - HOUR, "updated": NOW},
+                        },
+                        "messages": [
+                            {
+                                "info": {
+                                    "id": "m1",
+                                    "role": "user",
+                                    "time": {"created": NOW - 10},
+                                },
+                                "parts": [
+                                    {"type": "text", "text": "hello from export"}
+                                ],
+                            },
+                            {
+                                "info": {
+                                    "id": "m2",
+                                    "role": "assistant",
+                                    "modelID": "gpt-x",
+                                    "providerID": "openai",
+                                    "time": {"created": NOW - 5},
+                                },
+                                "parts": [{"type": "text", "text": "hi back"}],
+                            },
+                        ],
+                    }
+                },
+            }
+        )
+    )
+    script = bindir / "opencode"
+    script.write_text(
+        textwrap.dedent(
+            f"""\
+            #!{sys.executable}
+            import json, sys
+            data = json.load(open({str(data)!r}))
+            args = sys.argv[1:]
+            if args == ["--version"]:
+                print(data["version"])
+            elif args[:2] == ["session", "list"]:
+                print("INFO some log line")
+                print(json.dumps(data["sessions"]))
+            elif args[:1] == ["export"]:
+                sid = args[1]
+                if sid not in data["exports"]:
+                    print("Session not found", file=sys.stderr)
+                    sys.exit(1)
+                print("Exporting session: " + sid)
+                print(json.dumps(data["exports"][sid]))
+            elif args == ["db", "path"]:
+                print(data.get("db_path", "/nonexistent/opencode.db"))
+            else:
+                sys.exit(2)
+            """
+        )
+    )
+    script.chmod(0o755)
+    monkeypatch.setenv(
+        "PATH", f"{bindir}{__import__('os').pathsep}{__import__('os').environ['PATH']}"
+    )
+    return data

claude_opencode_sessions/tests/fixtures/schema_1x.sql

@@ -0,0 +1,76 @@
+-- Schema of the tables read by claude-opencode-sessions, copied from a real
+-- opencode 1.18.32 database (schema only, no data).
+
+CREATE TABLE `project` (
+	`id` text PRIMARY KEY,
+	`worktree` text NOT NULL,
+	`vcs` text,
+	`name` text,
+	`icon_url` text,
+	`icon_color` text,
+	`time_created` integer NOT NULL,
+	`time_updated` integer NOT NULL,
+	`time_initialized` integer,
+	`sandboxes` text NOT NULL
+, `commands` text, `icon_url_override` text);
+
+CREATE TABLE `session` (
+	`id` text PRIMARY KEY,
+	`project_id` text NOT NULL,
+	`parent_id` text,
+	`slug` text NOT NULL,
+	`directory` text NOT NULL,
+	`title` text NOT NULL,
+	`version` text NOT NULL,
+	`share_url` text,
+	`summary_additions` integer,
+	`summary_deletions` integer,
+	`summary_files` integer,
+	`summary_diffs` text,
+	`revert` text,
+	`permission` text,
+	`time_created` integer NOT NULL,
+	`time_updated` integer NOT NULL,
+	`time_compacting` integer,
+	`time_archived` integer, `workspace_id` text, `path` text, `agent` text, `model` text, `cost` real DEFAULT 0 NOT NULL, `tokens_input` integer DEFAULT 0 NOT NULL, `tokens_output` integer DEFAULT 0 NOT NULL, `tokens_reasoning` integer DEFAULT 0 NOT NULL, `tokens_cache_read` integer DEFAULT 0 NOT NULL, `tokens_cache_write` integer DEFAULT 0 NOT NULL, `metadata` text,
+	CONSTRAINT `fk_session_project_id_project_id_fk` FOREIGN KEY (`project_id`) REFERENCES `project`(`id`) ON DELETE CASCADE
+);
+CREATE INDEX `session_project_idx` ON `session` (`project_id`);
+CREATE INDEX `session_parent_idx` ON `session` (`parent_id`);
+CREATE INDEX `session_workspace_idx` ON `session` (`workspace_id`);
+
+CREATE TABLE `message` (
+	`id` text PRIMARY KEY,
+	`session_id` text NOT NULL,
+	`time_created` integer NOT NULL,
+	`time_updated` integer NOT NULL,
+	`data` text NOT NULL,
+	CONSTRAINT `fk_message_session_id_session_id_fk` FOREIGN KEY (`session_id`) REFERENCES `session`(`id`) ON DELETE CASCADE
+);
+CREATE INDEX `message_session_time_created_id_idx` ON `message` (`session_id`,`time_created`,`id`);
+
+CREATE TABLE `part` (
+	`id` text PRIMARY KEY,
+	`message_id` text NOT NULL,
+	`session_id` text NOT NULL,
+	`time_created` integer NOT NULL,
+	`time_updated` integer NOT NULL,
+	`data` text NOT NULL,
+	CONSTRAINT `fk_part_message_id_message_id_fk` FOREIGN KEY (`message_id`) REFERENCES `message`(`id`) ON DELETE CASCADE
+);
+CREATE INDEX `part_session_idx` ON `part` (`session_id`);
+CREATE INDEX `part_message_id_id_idx` ON `part` (`message_id`,`id`);
+
+CREATE TABLE `session_message` (
+	`id` text PRIMARY KEY,
+	`session_id` text NOT NULL,
+	`type` text NOT NULL,
+	`time_created` integer NOT NULL,
+	`time_updated` integer NOT NULL,
+	`data` text NOT NULL, `seq` integer NOT NULL,
+	CONSTRAINT `fk_session_message_session_id_session_id_fk` FOREIGN KEY (`session_id`) REFERENCES `session`(`id`) ON DELETE CASCADE
+);
+CREATE INDEX `session_message_time_created_idx` ON `session_message` (`time_created`);
+CREATE INDEX `session_message_session_time_created_id_idx` ON `session_message` (`session_id`,`time_created`,`id`);
+CREATE INDEX `session_message_session_type_seq_idx` ON `session_message` (`session_id`,`type`,`seq`);
+CREATE UNIQUE INDEX `session_message_session_seq_idx` ON `session_message` (`session_id`,`seq`);

claude_opencode_sessions/tests/fixtures/schema_2x.sql

@@ -0,0 +1,37 @@
+-- opencode 2.x layout (>= ~2.0.18): sessions in `session_v2`, conversation
+-- events in `session_message`. Reconstructed from the 1.18 tables plus
+-- public reports (no real 2.x database was available); columns this package
+-- does not read are omitted. The frozen 1.x tables may coexist in the file.
+
+CREATE TABLE `project` (
+	`id` text PRIMARY KEY,
+	`worktree` text NOT NULL,
+	`vcs` text,
+	`name` text,
+	`time_created` integer NOT NULL,
+	`time_updated` integer NOT NULL
+);
+
+CREATE TABLE `session_v2` (
+	`id` text PRIMARY KEY,
+	`project_id` text NOT NULL,
+	`parent_id` text,
+	`directory` text NOT NULL,
+	`title` text NOT NULL,
+	`agent` text,
+	`model` text,
+	`time_created` integer NOT NULL,
+	`time_updated` integer NOT NULL,
+	`time_archived` integer
+);
+
+CREATE TABLE `session_message` (
+	`id` text PRIMARY KEY,
+	`session_id` text NOT NULL,
+	`type` text NOT NULL,
+	`time_created` integer NOT NULL,
+	`time_updated` integer NOT NULL,
+	`data` text NOT NULL,
+	`seq` integer NOT NULL
+);
+CREATE UNIQUE INDEX `session_message_session_seq_idx` ON `session_message` (`session_id`,`seq`);