@pasko70/pibo 1.1.0 → 1.2.0

package/dist/apps/chat/data/read-state-service.js

@@ -0,0 +1,42 @@
+export class ChatReadStateService {
+    store;
+    constructor(store) {
+        this.store = store;
+    }
+    markSessionRead(piboSessionId, lastReadStreamId) {
+        const now = new Date().toISOString();
+        this.store.db.prepare(`
+			INSERT INTO app_session_read_state (session_id, last_read_stream_id, last_read_at, updated_at)
+			VALUES (?, ?, ?, ?)
+			ON CONFLICT(session_id) DO UPDATE SET
+				last_read_stream_id = MAX(app_session_read_state.last_read_stream_id, excluded.last_read_stream_id),
+				last_read_at = excluded.last_read_at,
+				updated_at = excluded.updated_at
+		`).run(piboSessionId, lastReadStreamId, now, now);
+    }
+    countUnreadMessagesBySession(input) {
+        const counts = new Map();
+        if (!input.piboSessionIds.length)
+            return counts;
+        for (let offset = 0; offset < input.piboSessionIds.length; offset += 400) {
+            const ids = [...new Set(input.piboSessionIds)].slice(offset, offset + 400);
+            const placeholders = ids.map(() => "?").join(", ");
+            const rows = this.store.db.prepare(`
+				SELECT e.session_id, COUNT(*) AS count
+				FROM event_log e
+				LEFT JOIN app_session_read_state reads ON reads.session_id = e.session_id
+				WHERE e.session_id IN (${placeholders})
+					AND e.stream_id > COALESCE(reads.last_read_stream_id, 0)
+					AND (
+						(e.retention_class = 'chat_message' AND e.type IN ('user.message.accepted', 'assistant_message'))
+						OR e.type = 'session_error'
+					)
+				GROUP BY e.session_id
+			`).all(...ids);
+            for (const row of rows)
+                if (Number(row.count) > 0)
+                    counts.set(row.session_id, Number(row.count));
+        }
+        return counts;
+    }
+}

package/dist/apps/chat/data/room-service.js

@@ -0,0 +1,52 @@
+import { randomUUID } from "node:crypto";
+import { roomWorkspaceFromMetadata } from "../types/rooms.js";
+import { roomFromRow } from "./chat-data-mappers.js";
+export class ChatRoomService {
+    store;
+    constructor(store) {
+        this.store = store;
+    }
+    createRoom(input) {
+        const now = new Date().toISOString();
+        const room = { id: input.id ?? `room_${randomUUID()}`, name: input.name, topic: input.topic, workspace: roomWorkspaceFromMetadata(input.metadata), type: input.type ?? "chat", parentRoomId: input.parentRoomId, createdAt: now, updatedAt: now, retentionPolicyId: input.retentionPolicyId, metadata: input.metadata ?? {} };
+        const columns = ["id", "name", "topic", "type", "parent_room_id", "workspace", "retention_policy_id", "metadata_json", "created_at", "updated_at"];
+        this.store.db.prepare(`INSERT INTO rooms (${columns.join(", ")}) VALUES (${columns.map(() => "?").join(", ")})`).run(room.id, room.name, room.topic ?? null, room.type, room.parentRoomId ?? null, room.workspace ?? null, room.retentionPolicyId ?? null, JSON.stringify(room.metadata), room.createdAt, room.updatedAt);
+        return room;
+    }
+    updateRoom(id, input) {
+        const existing = this.getRoom(id);
+        if (!existing)
+            return undefined;
+        const metadata = input.metadata ?? existing.metadata;
+        const updated = { ...existing, name: input.name ?? existing.name, topic: input.topic === null ? undefined : input.topic ?? existing.topic, parentRoomId: input.parentRoomId === null ? undefined : input.parentRoomId ?? existing.parentRoomId, retentionPolicyId: input.retentionPolicyId === null ? undefined : input.retentionPolicyId ?? existing.retentionPolicyId, metadata, workspace: roomWorkspaceFromMetadata(metadata), updatedAt: new Date().toISOString() };
+        this.store.db.prepare("UPDATE rooms SET name = ?, topic = ?, parent_room_id = ?, workspace = ?, retention_policy_id = ?, metadata_json = ?, updated_at = ? WHERE id = ?").run(updated.name, updated.topic ?? null, updated.parentRoomId ?? null, updated.workspace ?? null, updated.retentionPolicyId ?? null, JSON.stringify(updated.metadata), updated.updatedAt, id);
+        return this.getRoom(id);
+    }
+    deleteRooms(ids) {
+        if (!ids.length)
+            return 0;
+        const placeholders = ids.map(() => "?").join(", ");
+        const result = this.store.db.prepare(`DELETE FROM rooms WHERE id IN (${placeholders})`).run(...ids);
+        return Number(result.changes ?? 0);
+    }
+    getRoom(id) { const row = this.store.db.prepare("SELECT * FROM rooms WHERE id = ?").get(id); return row ? roomFromRow(row) : undefined; }
+    listRooms() { return this.store.db.prepare("SELECT * FROM rooms ORDER BY updated_at DESC, id ASC").all().map(roomFromRow); }
+    listRoomTree() { const byId = new Map(this.listRooms().map((room) => [room.id, { ...room, children: [] }])); const roots = []; for (const node of byId.values()) {
+        const parent = node.parentRoomId ? byId.get(node.parentRoomId) : undefined;
+        if (parent)
+            parent.children.push(node);
+        else
+            roots.push(node);
+    } return roots; }
+    listRoomSubtree(roomId) { const root = this.getRoom(roomId); if (!root)
+        return []; const rooms = this.listRooms(); const byParent = new Map(); for (const room of rooms)
+        if (room.parentRoomId)
+            byParent.set(room.parentRoomId, [...(byParent.get(room.parentRoomId) ?? []), room]); const result = []; const visit = (room) => { result.push(room); for (const child of byParent.get(room.id) ?? [])
+        visit(child); }; visit(root); return result; }
+    ensureDefaultRoom(input = {}) { const existing = this.store.db.prepare("SELECT * FROM rooms WHERE json_extract(metadata_json, '$.default') IS 1 ORDER BY updated_at DESC, id ASC LIMIT 1").get(); if (existing)
+        return roomFromRow(existing); return this.createRoom({ name: input.name ?? "Shared Chat", type: "chat", metadata: { default: true } }); }
+    updateReadCursor(roomId, lastReadStreamId) { const now = new Date().toISOString(); this.store.db.prepare("INSERT INTO app_room_read_state (room_id, last_read_stream_id, last_read_at, updated_at) VALUES (?, ?, ?, ?) ON CONFLICT(room_id) DO UPDATE SET last_read_stream_id = MAX(app_room_read_state.last_read_stream_id, excluded.last_read_stream_id), last_read_at = excluded.last_read_at, updated_at = excluded.updated_at").run(roomId, lastReadStreamId, now, now); }
+    requireRoom(roomId) { const room = this.getRoom(roomId); if (!room)
+        throw new Error("Room not found"); return room; }
+    close() { }
+}

package/dist/apps/chat/data/session-query-service.js

@@ -0,0 +1,63 @@
+import { chatRoomIdFromMetadata } from "../types/rooms.js";
+import { sessionFromRow, statusFromOutputEvent } from "./chat-data-mappers.js";
+export class ChatSessionQueryService {
+    store;
+    constructor(store) {
+        this.store = store;
+    }
+    upsertSession(session, status = "idle") {
+        const roomId = chatRoomIdFromMetadata(session.metadata) ?? "room_default";
+        this.store.sessions.upsertSession({ session, roomId, status, lastActivityAt: session.updatedAt });
+        this.upsertNavigation(session, roomId, status, session.updatedAt);
+    }
+    upsertSessionsIfChanged(sessions) {
+        for (const session of sessions)
+            this.upsertSession(session);
+        return { checked: sessions.length, written: sessions.length, skipped: 0 };
+    }
+    recordEvent(event, session) {
+        if (session)
+            this.upsertSession(session, statusFromOutputEvent(event));
+        return undefined;
+    }
+    listSessions() {
+        const rows = this.store.db.prepare("SELECT * FROM sessions WHERE deleted_at IS NULL ORDER BY last_activity_at DESC, created_at DESC").all();
+        return rows.map(sessionFromRow);
+    }
+    getSession(piboSessionId) {
+        const row = this.store.db.prepare("SELECT * FROM sessions WHERE id = ? AND deleted_at IS NULL").get(piboSessionId);
+        return row ? sessionFromRow(row) : undefined;
+    }
+    hasSessionActivity(piboSessionId) {
+        const row = this.store.db.prepare("SELECT 1 AS found FROM event_log WHERE session_id = ? AND type NOT IN ('assistant_delta', 'thinking_delta', 'tool_execution_updated') LIMIT 1").get(piboSessionId);
+        return Boolean(row) || this.getSession(piboSessionId)?.status === "running";
+    }
+    deleteSessions(piboSessionIds) {
+        if (!piboSessionIds.length)
+            return 0;
+        const placeholders = piboSessionIds.map(() => "?").join(", ");
+        this.store.db.prepare(`DELETE FROM observations WHERE session_id IN (${placeholders})`).run(...piboSessionIds);
+        this.store.db.prepare(`DELETE FROM chat_messages WHERE session_id IN (${placeholders})`).run(...piboSessionIds);
+        this.store.db.prepare(`DELETE FROM event_log WHERE session_id IN (${placeholders})`).run(...piboSessionIds);
+        this.store.db.prepare(`DELETE FROM session_navigation WHERE session_id IN (${placeholders})`).run(...piboSessionIds);
+        const result = this.store.db.prepare(`UPDATE sessions SET deleted_at = COALESCE(deleted_at, ?) WHERE id IN (${placeholders})`).run(new Date().toISOString(), ...piboSessionIds);
+        return Number(result.changes ?? 0);
+    }
+    close() { }
+    upsertNavigation(session, roomId, status, now) {
+        this.store.navigation.upsertSession({
+            roomId,
+            sessionId: session.id,
+            rootSessionId: session.parentId ? (typeof session.metadata?.rootSessionId === "string" ? session.metadata.rootSessionId : session.parentId) : session.id,
+            parentId: session.parentId,
+            originId: session.originId,
+            title: session.title || "Untitled Session",
+            profile: session.profile,
+            status,
+            archivedAt: typeof session.metadata?.archivedAt === "string" ? session.metadata.archivedAt : undefined,
+            lastActivityAt: now,
+            sortKey: now,
+            updatedAt: now,
+        });
+    }
+}

package/dist/apps/chat/data/timeline-query-service.js

@@ -0,0 +1,96 @@
+import { storedChatEventFromV2Row, storedPiboEventFromV2Row } from "./chat-data-mappers.js";
+export class ChatTimelineQueryService {
+    store;
+    constructor(store) {
+        this.store = store;
+    }
+    listEvents(input = {}) {
+        const clauses = [];
+        const values = [];
+        if (input.roomId) {
+            clauses.push("room_id = ?");
+            values.push(input.roomId);
+        }
+        if (input.piboSessionId) {
+            clauses.push("session_id = ?");
+            values.push(input.piboSessionId);
+        }
+        if (input.afterStreamId !== undefined) {
+            clauses.push("stream_id > ?");
+            values.push(input.afterStreamId);
+        }
+        const where = clauses.length ? `WHERE ${clauses.join(" AND ")}` : "";
+        const limit = Math.max(1, Math.min(input.limit ?? 1000, 5000));
+        const rows = this.store.db.prepare(`SELECT * FROM event_log ${where} ORDER BY stream_id ASC LIMIT ?`).all(...values, limit);
+        return rows.map(storedChatEventFromV2Row);
+    }
+    listSessionEvents(piboSessionId, limit = 1000) {
+        return this.listTraceEvents({ piboSessionId, limit, includeLive: true });
+    }
+    listAllSessionEvents(piboSessionId) {
+        return this.listTraceEvents({ piboSessionId, limit: 10000, includeLive: true });
+    }
+    listTraceEvents(input) {
+        const piboSessionId = typeof input === "string" ? input : input.piboSessionId;
+        const limit = Math.max(1, Math.min((typeof input === "string" ? undefined : input.limit) ?? 2000, 10000));
+        const beforeOrAtSequence = typeof input === "string" ? undefined : input.beforeOrAtSequence;
+        const beforeSequence = typeof input === "string" ? undefined : input.beforeSequence;
+        const includeLive = typeof input === "string" ? false : input.includeLive === true;
+        const clauses = ["session_id = ?"];
+        const values = [piboSessionId];
+        if (!includeLive)
+            clauses.push("type NOT IN ('assistant_delta', 'thinking_delta', 'tool_execution_updated')");
+        if (beforeSequence !== undefined) {
+            clauses.push("session_sequence < ?");
+            values.push(beforeSequence);
+        }
+        else if (beforeOrAtSequence !== undefined) {
+            clauses.push("session_sequence <= ?");
+            values.push(beforeOrAtSequence);
+        }
+        const rows = this.store.db.prepare(`
+			SELECT * FROM (
+				SELECT * FROM event_log
+				WHERE ${clauses.join(" AND ")}
+				ORDER BY session_sequence DESC, stream_id DESC
+				LIMIT ?
+			)
+			ORDER BY session_sequence ASC, stream_id ASC
+		`).all(...values, limit);
+        return rows.map(storedPiboEventFromV2Row).filter((event) => event !== undefined);
+    }
+    countEventsByType(input = {}) {
+        const clauses = [];
+        const values = [];
+        if (input.piboSessionId) {
+            clauses.push("session_id = ?");
+            values.push(input.piboSessionId);
+        }
+        if (input.eventTypes?.length) {
+            clauses.push(`type IN (${input.eventTypes.map(() => "?").join(", ")})`);
+            values.push(...input.eventTypes);
+        }
+        const where = clauses.length ? `WHERE ${clauses.join(" AND ")}` : "";
+        const rows = this.store.db.prepare(`SELECT type, COUNT(*) AS count FROM event_log ${where} GROUP BY type ORDER BY type`).all(...values);
+        return rows.map((row) => ({ eventType: row.type, count: Number(row.count) }));
+    }
+    getLatestEventSequence(piboSessionId) {
+        const row = this.store.db.prepare("SELECT COALESCE(MAX(session_sequence), 0) AS latest_sequence FROM event_log WHERE session_id = ?").get(piboSessionId);
+        return row.latest_sequence;
+    }
+    getLatestStreamId(input = {}) {
+        const clauses = [];
+        const values = [];
+        if (input.roomId) {
+            clauses.push("room_id = ?");
+            values.push(input.roomId);
+        }
+        if (input.piboSessionId) {
+            clauses.push("session_id = ?");
+            values.push(input.piboSessionId);
+        }
+        const where = clauses.length ? `WHERE ${clauses.join(" AND ")}` : "";
+        const row = this.store.db.prepare(`SELECT MAX(stream_id) AS stream_id FROM event_log ${where}`).get(...values);
+        return row?.stream_id ?? undefined;
+    }
+}

package/dist/apps/chat/event-log.js

@@ -1,307 +1 @@
-import { randomUUID } from "node:crypto";
-import { mkdirSync } from "node:fs";
-import { dirname, resolve } from "node:path";
-import { DatabaseSync } from "node:sqlite";
-export class ChatEventLog {
-    db;
-    constructor(path) {
-        const resolvedPath = path === ":memory:" ? path : resolve(path);
-        if (resolvedPath !== ":memory:") {
-            mkdirSync(dirname(resolvedPath), { recursive: true });
-        }
-        this.db = new DatabaseSync(resolvedPath);
-        this.db.exec("PRAGMA busy_timeout = 5000");
-        if (resolvedPath !== ":memory:")
-            this.db.exec("PRAGMA journal_mode = WAL");
-        this.db.exec(`
-			CREATE TABLE IF NOT EXISTS chat_events (
-				stream_id INTEGER PRIMARY KEY,
-				room_id TEXT,
-				pibo_session_id TEXT,
-				event_id TEXT NOT NULL,
-				event_type TEXT NOT NULL,
-				actor_type TEXT,
-				actor_id TEXT,
-				client_txn_id TEXT,
-				created_at TEXT NOT NULL,
-				retention_class TEXT NOT NULL,
-				payload_json TEXT NOT NULL
-			);
-
-			CREATE INDEX IF NOT EXISTS idx_chat_events_room_stream
-				ON chat_events(room_id, stream_id);
-			CREATE INDEX IF NOT EXISTS idx_chat_events_session_stream
-				ON chat_events(pibo_session_id, stream_id);
-			CREATE INDEX IF NOT EXISTS idx_chat_events_event_id
-				ON chat_events(event_id);
-			CREATE UNIQUE INDEX IF NOT EXISTS idx_chat_events_client_txn
-				ON chat_events(room_id, actor_id, client_txn_id)
-				WHERE client_txn_id IS NOT NULL;
-
-			CREATE TABLE IF NOT EXISTS chat_retention_policies (
-				id TEXT PRIMARY KEY,
-				delete_live_deltas_after_ms INTEGER,
-				delete_trace_events_after_ms INTEGER,
-				delete_chat_messages_after_ms INTEGER
-			);
-
-			CREATE TABLE IF NOT EXISTS chat_session_reads (
-				pibo_session_id TEXT NOT NULL,
-				principal_id TEXT NOT NULL,
-				last_read_stream_id INTEGER NOT NULL,
-				updated_at TEXT NOT NULL,
-				PRIMARY KEY(pibo_session_id, principal_id)
-			);
-		`);
-    }
-    appendEvent(input) {
-        const eventId = input.eventId ?? `ce_${randomUUID()}`;
-        const createdAt = input.createdAt ?? new Date().toISOString();
-        const payloadJson = JSON.stringify(input.payload);
-        const result = this.db
-            .prepare(`
-				INSERT OR IGNORE INTO chat_events (
-					room_id,
-					pibo_session_id,
-					event_id,
-					event_type,
-					actor_type,
-					actor_id,
-					client_txn_id,
-					created_at,
-					retention_class,
-					payload_json
-				) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-			`)
-            .run(input.roomId ?? null, input.piboSessionId ?? null, eventId, input.eventType, input.actorType ?? null, input.actorId ?? null, input.clientTxnId ?? null, createdAt, input.retentionClass, payloadJson);
-        if (input.clientTxnId) {
-            const existing = this.findByClientTxn(input.roomId, input.actorId, input.clientTxnId);
-            if (existing)
-                return existing;
-        }
-        const streamId = Number(result.lastInsertRowid);
-        const stored = this.db.prepare("SELECT * FROM chat_events WHERE stream_id = ?").get(streamId);
-        if (!stored)
-            throw new Error(`Failed to append chat event "${eventId}"`);
-        return eventFromRow(stored);
-    }
-    appendOutputEvent(event, input = {}) {
-        return this.appendEvent({
-            roomId: input.roomId,
-            piboSessionId: event.piboSessionId,
-            eventId: "eventId" in event && event.eventId ? `pibo:${event.piboSessionId}:${event.eventId}:${event.type}` : undefined,
-            eventType: event.type,
-            actorType: actorTypeForOutputEvent(event),
-            actorId: input.actorId,
-            retentionClass: retentionClassForOutputEvent(event),
-            payload: event,
-        });
-    }
-    listEvents(input = {}) {
-        const clauses = [];
-        const values = [];
-        if (input.roomId) {
-            clauses.push("room_id = ?");
-            values.push(input.roomId);
-        }
-        if (input.piboSessionId) {
-            clauses.push("pibo_session_id = ?");
-            values.push(input.piboSessionId);
-        }
-        if (input.afterStreamId !== undefined) {
-            clauses.push("stream_id > ?");
-            values.push(input.afterStreamId);
-        }
-        const where = clauses.length ? `WHERE ${clauses.join(" AND ")}` : "";
-        const limit = Math.max(1, Math.min(input.limit ?? 1000, 5000));
-        const rows = this.db
-            .prepare(`SELECT * FROM chat_events ${where} ORDER BY stream_id ASC LIMIT ?`)
-            .all(...values, limit);
-        return rows.map(eventFromRow);
-    }
-    getEvent(streamId) {
-        const row = this.db.prepare("SELECT * FROM chat_events WHERE stream_id = ?").get(streamId);
-        return row ? eventFromRow(row) : undefined;
-    }
-    findByClientTxn(roomId, actorId, clientTxnId) {
-        if (!roomId || !actorId)
-            return undefined;
-        const row = this.db
-            .prepare(`
-				SELECT * FROM chat_events
-				WHERE room_id = ? AND actor_id = ? AND client_txn_id = ?
-				ORDER BY stream_id ASC
-				LIMIT 1
-			`)
-            .get(roomId, actorId, clientTxnId);
-        return row ? eventFromRow(row) : undefined;
-    }
-    getLatestStreamId(input = {}) {
-        const clauses = [];
-        const values = [];
-        if (input.roomId) {
-            clauses.push("room_id = ?");
-            values.push(input.roomId);
-        }
-        if (input.piboSessionId) {
-            clauses.push("pibo_session_id = ?");
-            values.push(input.piboSessionId);
-        }
-        const where = clauses.length ? `WHERE ${clauses.join(" AND ")}` : "";
-        const row = this.db.prepare(`SELECT MAX(stream_id) AS stream_id FROM chat_events ${where}`).get(...values);
-        return row?.stream_id ?? undefined;
-    }
-    getSessionReadCursor(piboSessionId, principalId) {
-        const row = this.db
-            .prepare("SELECT * FROM chat_session_reads WHERE pibo_session_id = ? AND principal_id = ?")
-            .get(piboSessionId, principalId);
-        return row?.last_read_stream_id;
-    }
-    markSessionRead(piboSessionId, principalId, lastReadStreamId) {
-        this.db
-            .prepare(`
-				INSERT INTO chat_session_reads (pibo_session_id, principal_id, last_read_stream_id, updated_at)
-				VALUES (?, ?, ?, ?)
-				ON CONFLICT(pibo_session_id, principal_id) DO UPDATE SET
-					last_read_stream_id = MAX(chat_session_reads.last_read_stream_id, excluded.last_read_stream_id),
-					updated_at = excluded.updated_at
-			`)
-            .run(piboSessionId, principalId, lastReadStreamId, new Date().toISOString());
-    }
-    countUnreadMessages(input) {
-        const clauses = [
-            "retention_class = 'chat_message'",
-            "event_type IN ('user.message.accepted', 'assistant_message')",
-            "(actor_type IS NULL OR actor_type != 'user' OR actor_id IS NULL OR actor_id != ?)",
-        ];
-        const values = [input.principalId];
-        if (input.roomId) {
-            clauses.push("room_id = ?");
-            values.push(input.roomId);
-        }
-        if (input.piboSessionId) {
-            clauses.push("pibo_session_id = ?");
-            values.push(input.piboSessionId);
-        }
-        if (input.afterStreamId !== undefined) {
-            clauses.push("stream_id > ?");
-            values.push(input.afterStreamId);
-        }
-        const row = this.db
-            .prepare(`SELECT COUNT(*) AS count FROM chat_events WHERE ${clauses.join(" AND ")}`)
-            .get(...values);
-        return Number(row?.count ?? 0);
-    }
-    deleteSessions(piboSessionIds) {
-        if (!piboSessionIds.length)
-            return 0;
-        const placeholders = piboSessionIds.map(() => "?").join(", ");
-        this.db.prepare(`DELETE FROM chat_session_reads WHERE pibo_session_id IN (${placeholders})`).run(...piboSessionIds);
-        const result = this.db.prepare(`DELETE FROM chat_events WHERE pibo_session_id IN (${placeholders})`).run(...piboSessionIds);
-        return Number(result.changes ?? 0);
-    }
-    deleteRooms(roomIds) {
-        if (!roomIds.length)
-            return 0;
-        const placeholders = roomIds.map(() => "?").join(", ");
-        const result = this.db.prepare(`DELETE FROM chat_events WHERE room_id IN (${placeholders})`).run(...roomIds);
-        return Number(result.changes ?? 0);
-    }
-    upsertRetentionPolicy(policy) {
-        this.db
-            .prepare(`
-				INSERT INTO chat_retention_policies (
-					id,
-					delete_live_deltas_after_ms,
-					delete_trace_events_after_ms,
-					delete_chat_messages_after_ms
-				) VALUES (?, ?, ?, ?)
-				ON CONFLICT(id) DO UPDATE SET
-					delete_live_deltas_after_ms = excluded.delete_live_deltas_after_ms,
-					delete_trace_events_after_ms = excluded.delete_trace_events_after_ms,
-					delete_chat_messages_after_ms = excluded.delete_chat_messages_after_ms
-			`)
-            .run(policy.id, policy.deleteLiveDeltasAfterMs ?? null, policy.deleteTraceEventsAfterMs ?? null, policy.deleteChatMessagesAfterMs ?? null);
-        return this.getRetentionPolicy(policy.id) ?? policy;
-    }
-    getRetentionPolicy(id) {
-        const row = this.db.prepare("SELECT * FROM chat_retention_policies WHERE id = ?").get(id);
-        return row ? policyFromRow(row) : undefined;
-    }
-    purgeExpired(input = {}) {
-        const now = input.now ?? new Date();
-        const policy = input.policy ?? this.getRetentionPolicy("default") ?? { id: "default" };
-        const batchSize = Math.max(1, Math.min(input.batchSize ?? 500, 5000));
-        const clauses = [];
-        const values = [];
-        addRetentionClause(clauses, values, "live_delta", policy.deleteLiveDeltasAfterMs, now);
-        addRetentionClause(clauses, values, "trace_event", policy.deleteTraceEventsAfterMs, now);
-        addRetentionClause(clauses, values, "chat_message", policy.deleteChatMessagesAfterMs, now);
-        if (!clauses.length)
-            return 0;
-        const result = this.db
-            .prepare(`
-				DELETE FROM chat_events
-				WHERE stream_id IN (
-					SELECT stream_id FROM chat_events
-					WHERE ${clauses.join(" OR ")}
-					ORDER BY stream_id ASC
-					LIMIT ${batchSize}
-				)
-			`)
-            .run(...values);
-        return Number(result.changes ?? 0);
-    }
-    close() {
-        this.db.close();
-    }
-}
-export function createDefaultChatEventLog(cwd = process.cwd()) {
-    return new ChatEventLog(resolve(cwd, ".pibo/web-chat.sqlite"));
-}
-function eventFromRow(row) {
-    return {
-        streamId: row.stream_id,
-        roomId: row.room_id ?? undefined,
-        piboSessionId: row.pibo_session_id ?? undefined,
-        eventId: row.event_id,
-        eventType: row.event_type,
-        actorType: row.actor_type,
-        actorId: row.actor_id ?? undefined,
-        clientTxnId: row.client_txn_id ?? undefined,
-        createdAt: row.created_at,
-        retentionClass: row.retention_class,
-        payload: JSON.parse(row.payload_json),
-    };
-}
-function policyFromRow(row) {
-    return {
-        id: row.id,
-        deleteLiveDeltasAfterMs: row.delete_live_deltas_after_ms ?? undefined,
-        deleteTraceEventsAfterMs: row.delete_trace_events_after_ms ?? undefined,
-        deleteChatMessagesAfterMs: row.delete_chat_messages_after_ms ?? undefined,
-    };
-}
-function retentionClassForOutputEvent(event) {
-    if (event.type === "assistant_delta" || event.type === "thinking_delta")
-        return "live_delta";
-    if (event.type === "assistant_message" || event.type === "message_started" || event.type === "message_finished") {
-        return "chat_message";
-    }
-    return "trace_event";
-}
-function actorTypeForOutputEvent(event) {
-    if (event.type === "assistant_delta" || event.type === "assistant_message" || event.type.startsWith("thinking_")) {
-        return "assistant";
-    }
-    if (event.type === "message_queued" || event.type === "message_started" || event.type === "message_finished") {
-        return "user";
-    }
-    return "agent";
-}
-function addRetentionClause(clauses, values, retentionClass, ageMs, now) {
-    if (!ageMs || ageMs <= 0)
-        return;
-    clauses.push("(retention_class = ? AND created_at < ?)");
-    values.push(retentionClass, new Date(now.getTime() - ageMs).toISOString());
-}
+export {};

package/dist/apps/chat/model-catalog.js

@@ -1,4 +1,5 @@
 import { createAgentSessionServices } from "@mariozechner/pi-coding-agent";
+import { registerMiniMaxProvider } from "../../providers/minimax.js";
 export function buildModelCatalogFromRegistry(registry) {
     const providers = new Map();
     for (const model of registry.getAll()) {
@@ -31,12 +32,16 @@ export function buildModelCatalogFromRegistry(registry) {
         })),
     };
 }
-export async function loadModelCatalog(cwd = process.cwd()) {
+export async function loadModelCatalogWithServices(createServices, cwd = process.cwd(), extensionHook) {
     try {
-        const services = await createAgentSessionServices({ cwd });
+        const services = await createServices({ cwd });
+        extensionHook?.(services.modelRegistry);
         return buildModelCatalogFromRegistry(services.modelRegistry);
     }
     catch {
         return { providers: [] };
     }
 }
+export async function loadModelCatalog(cwd = process.cwd()) {
+    return loadModelCatalogWithServices(createAgentSessionServices, cwd, registerMiniMaxProvider);
+}