@pasko70/pibo 1.9.9 → 1.9.10

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,126 @@
+import { chatRoomIdFromMetadata } from "../types/rooms.js";
+import { sessionFromRow, statusFromOutputEvent } from "./chat-data-mappers.js";
+import { rootSessionId } from "../../../data/session-store.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) {
+        let written = 0;
+        let skipped = 0;
+        for (const session of sessions) {
+            if (this.sessionIndexMatches(session)) {
+                skipped++;
+                continue;
+            }
+            this.upsertSession(session);
+            written++;
+        }
+        return { checked: sessions.length, written, skipped };
+    }
+    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() { }
+    sessionIndexMatches(session, status = "idle") {
+        const roomId = chatRoomIdFromMetadata(session.metadata) ?? "room_default";
+        const title = session.title || "Untitled Session";
+        const metadataJson = JSON.stringify(session.metadata ?? {});
+        const activeModelJson = session.activeModel ? JSON.stringify(session.activeModel) : null;
+        const row = this.store.db.prepare(`
+			SELECT
+				s.pi_session_id,
+				s.room_id,
+				s.root_session_id,
+				s.parent_id,
+				s.origin_id,
+				s.channel,
+				s.kind,
+				s.profile,
+				s.active_model_json,
+				s.workspace,
+				s.title,
+				s.status,
+				s.metadata_json,
+				s.created_at,
+				s.updated_at,
+				s.last_activity_at,
+				n.status AS navigation_status,
+				n.title AS navigation_title,
+				n.sort_key AS navigation_sort_key,
+				n.updated_at AS navigation_updated_at
+			FROM sessions s
+			LEFT JOIN session_navigation n ON n.session_id = s.id
+			WHERE s.id = ? AND s.deleted_at IS NULL
+		`).get(session.id);
+        if (!row)
+            return false;
+        return row.pi_session_id === session.piSessionId
+            && row.room_id === roomId
+            && row.root_session_id === rootSessionId(session)
+            && row.parent_id === (session.parentId ?? null)
+            && row.origin_id === (session.originId ?? null)
+            && row.channel === session.channel
+            && row.kind === session.kind
+            && row.profile === session.profile
+            && row.active_model_json === activeModelJson
+            && row.workspace === (session.workspace ?? null)
+            && row.title === title
+            && row.status === status
+            && row.metadata_json === metadataJson
+            && row.created_at === session.createdAt
+            && row.updated_at === session.updatedAt
+            && row.last_activity_at === session.updatedAt
+            && row.navigation_status === status
+            && row.navigation_title === title
+            && row.navigation_sort_key === session.updatedAt
+            && row.navigation_updated_at === session.updatedAt;
+    }
+    upsertNavigation(session, roomId, status, now) {
+        this.store.navigation.upsertSession({
+            roomId,
+            sessionId: session.id,
+            rootSessionId: rootSessionId(session),
+            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,102 @@
+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 session_sequence AS latest_sequence
+			FROM event_log
+			WHERE session_id = ?
+			ORDER BY session_sequence DESC, stream_id DESC
+			LIMIT 1
+		`).get(piboSessionId);
+        return row?.latest_sequence ?? 0;
+    }
+    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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,53 @@
+import { createAgentSessionServices } from "@earendil-works/pi-coding-agent";
+import { registerMiniMaxProvider } from "../../providers/minimax.js";
+import { registerGlmProvider } from "../../providers/glm.js";
+import { registerOpenAiGpt56Models } from "../../providers/openai-gpt56.js";
+export function buildModelCatalogFromRegistry(registry) {
+    const providers = new Map();
+    for (const model of registry.getAll()) {
+        const providerId = model.provider;
+        let provider = providers.get(providerId);
+        if (!provider) {
+            const authConfigured = registry.getProviderAuthStatus?.(providerId).configured ?? false;
+            provider = {
+                id: providerId,
+                label: registry.getProviderDisplayName?.(providerId) ?? providerId,
+                authConfigured,
+                models: [],
+            };
+            providers.set(providerId, provider);
+        }
+        provider.models.push({
+            provider: providerId,
+            id: model.id,
+            label: model.name || model.id,
+            authConfigured: provider.authConfigured,
+            supportsReasoning: model.reasoning || undefined,
+        });
+    }
+    return {
+        providers: [...providers.values()]
+            .sort((left, right) => left.label.localeCompare(right.label) || left.id.localeCompare(right.id))
+            .map((provider) => ({
+            ...provider,
+            models: [...provider.models].sort((left, right) => left.label.localeCompare(right.label) || left.id.localeCompare(right.id)),
+        })),
+    };
+}
+export async function loadModelCatalogWithServices(createServices, cwd = process.cwd(), extensionHook) {
+    try {
+        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, (registry) => {
+        registerOpenAiGpt56Models(registry);
+        registerMiniMaxProvider(registry);
+        registerGlmProvider(registry);
+    });
+}

package/dist/apps/chat/output-compactor.js

@@ -0,0 +1,126 @@
+import { assistantOutputKey, isLiveOnlyOutputEvent, thinkingOutputKey, toolOutputKey } from "./output-event-policy.js";
+export class OutputCompactor {
+    assistantBuffers = new Map();
+    thinkingBuffers = new Map();
+    toolSnapshots = new Map();
+    compact(event) {
+        const persistedEvents = [];
+        const snapshots = [];
+        switch (event.type) {
+            case "assistant_delta": {
+                const key = assistantOutputKey(event);
+                const previous = this.assistantBuffers.get(key);
+                const text = `${previous?.text ?? ""}${event.text}`;
+                this.assistantBuffers.set(key, { event, text });
+                snapshots.push({ ...event, text });
+                break;
+            }
+            case "assistant_message": {
+                const key = assistantOutputKey(event);
+                const buffered = this.assistantBuffers.get(key);
+                this.assistantBuffers.delete(key);
+                persistedEvents.push({ ...event, text: event.text || buffered?.text || "" });
+                break;
+            }
+            case "thinking_started": {
+                const key = thinkingOutputKey(event);
+                this.thinkingBuffers.set(key, { base: event, text: "" });
+                persistedEvents.push(event);
+                break;
+            }
+            case "thinking_delta": {
+                const key = thinkingOutputKey(event);
+                const previous = this.thinkingBuffers.get(key);
+                const text = `${previous?.text ?? ""}${event.text}`;
+                this.thinkingBuffers.set(key, { base: previous?.base ?? event, text });
+                snapshots.push({ ...event, text });
+                break;
+            }
+            case "thinking_finished": {
+                const key = thinkingOutputKey(event);
+                const buffered = this.thinkingBuffers.get(key);
+                this.thinkingBuffers.delete(key);
+                persistedEvents.push({ ...event, text: event.text || buffered?.text || "" });
+                break;
+            }
+            case "tool_execution_updated": {
+                this.toolSnapshots.set(toolOutputKey(event), event);
+                snapshots.push(event);
+                break;
+            }
+            case "tool_execution_finished": {
+                this.toolSnapshots.delete(toolOutputKey(event));
+                persistedEvents.push(event);
+                break;
+            }
+            case "message_finished":
+            case "session_error": {
+                persistedEvents.push(...this.flushForBoundary(event));
+                persistedEvents.push(event);
+                break;
+            }
+            default:
+                if (!isLiveOnlyOutputEvent(event))
+                    persistedEvents.push(event);
+                break;
+        }
+        return { liveEvents: [event], persistedEvents, snapshots };
+    }
+    snapshotsForSession(piboSessionId) {
+        const snapshots = [];
+        for (const buffer of this.assistantBuffers.values()) {
+            if (buffer.event.piboSessionId === piboSessionId)
+                snapshots.push({ ...buffer.event, text: buffer.text });
+        }
+        for (const buffer of this.thinkingBuffers.values()) {
+            if (buffer.base.piboSessionId !== piboSessionId)
+                continue;
+            if (buffer.base.type === "thinking_delta")
+                snapshots.push({ ...buffer.base, text: buffer.text });
+            else
+                snapshots.push({ ...buffer.base, type: "thinking_delta", text: buffer.text });
+        }
+        for (const event of this.toolSnapshots.values()) {
+            if (event.piboSessionId === piboSessionId)
+                snapshots.push(event);
+        }
+        return snapshots;
+    }
+    flushForBoundary(event) {
+        const flushed = [];
+        for (const [key, buffer] of Array.from(this.assistantBuffers.entries())) {
+            if (!matchesBoundary(buffer.event, event))
+                continue;
+            this.assistantBuffers.delete(key);
+            flushed.push({
+                type: "assistant_message",
+                piboSessionId: buffer.event.piboSessionId,
+                eventId: buffer.event.eventId,
+                assistantIndex: buffer.event.assistantIndex,
+                contentIndex: buffer.event.contentIndex,
+                text: buffer.text,
+            });
+        }
+        for (const [key, buffer] of Array.from(this.thinkingBuffers.entries())) {
+            if (!matchesBoundary(buffer.base, event))
+                continue;
+            this.thinkingBuffers.delete(key);
+            flushed.push({
+                type: "thinking_finished",
+                piboSessionId: buffer.base.piboSessionId,
+                eventId: buffer.base.eventId,
+                thinkingIndex: "thinkingIndex" in buffer.base ? buffer.base.thinkingIndex : undefined,
+                contentIndex: buffer.base.contentIndex,
+                text: buffer.text,
+            });
+        }
+        return flushed;
+    }
+}
+function matchesBoundary(bufferEvent, boundary) {
+    if (bufferEvent.piboSessionId !== boundary.piboSessionId)
+        return false;
+    if (boundary.type === "session_error")
+        return !boundary.eventId || bufferEvent.eventId === boundary.eventId;
+    return bufferEvent.eventId === boundary.eventId;
+}

package/dist/apps/chat/output-event-policy.js

@@ -0,0 +1,17 @@
+export function isLiveOnlyOutputEvent(event) {
+    return event.type === "assistant_delta" || event.type === "thinking_delta" || event.type === "tool_execution_updated";
+}
+export function isPersistableOutputEvent(event) {
+    return !isLiveOnlyOutputEvent(event);
+}
+export function assistantOutputKey(event) {
+    const partIndex = event.assistantIndex ?? event.contentIndex ?? 0;
+    return [event.piboSessionId, event.eventId ?? "", partIndex].join(":");
+}
+export function thinkingOutputKey(event) {
+    const partIndex = event.thinkingIndex ?? event.contentIndex ?? 0;
+    return [event.piboSessionId, event.eventId ?? "", partIndex].join(":");
+}
+export function toolOutputKey(event) {
+    return [event.piboSessionId, event.eventId ?? "", event.toolCallId].join(":");
+}