@meshagent/meshagent-agents 0.43.0

package/dist/esm/thread-storage.js

@@ -0,0 +1,465 @@
+import { Field, Schema, Utf8, tableFromArrays, } from "apache-arrow";
+import { ChangeEmitter } from "./change-emitter.js";
+import { DeleteThread, ListThreads, RenameThread, } from "./agent-messages.js";
+export const defaultUntitledThreadName = "New Chat";
+const uuidPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+export class ThreadListEntry {
+    constructor({ path, name, createdAt, modifiedAt }) {
+        this.path = path;
+        this.name = name;
+        this.createdAt = createdAt;
+        this.modifiedAt = modifiedAt;
+    }
+    renamed(name, modifiedAt) {
+        return new ThreadListEntry({
+            path: this.path,
+            name,
+            createdAt: this.createdAt,
+            modifiedAt,
+        });
+    }
+    static fromDatasetRow(row) {
+        const rawPath = row.path;
+        if (typeof rawPath !== "string" || rawPath.trim() === "") {
+            return null;
+        }
+        const threadPath = rawPath.trim();
+        const rawName = row.name;
+        const rawCreatedAt = row.created_at;
+        const rawModifiedAt = row.modified_at;
+        return new ThreadListEntry({
+            path: threadPath,
+            name: typeof rawName === "string" && rawName.trim() !== "" ? rawName.trim() : defaultThreadDisplayNameFromPath(threadPath),
+            createdAt: typeof rawCreatedAt === "string" ? rawCreatedAt : "",
+            modifiedAt: typeof rawModifiedAt === "string" ? rawModifiedAt : "",
+        });
+    }
+}
+export class ThreadStorage {
+}
+export class ThreadStorageRepository extends ChangeEmitter {
+}
+export class DatasetThreadListRef {
+    constructor({ namespace, table }) {
+        this.namespace = namespace;
+        this.table = table;
+    }
+    static parse(url) {
+        let path = url.trim();
+        if (!path.startsWith("dataset://")) {
+            throw new TypeError("dataset thread list URL must start with dataset://");
+        }
+        path = path.slice("dataset://".length);
+        if (path.startsWith("/")) {
+            throw new TypeError("dataset thread list URL must use dataset://path");
+        }
+        const parts = path.split("/").map((part) => part.trim()).filter((part) => part !== "");
+        if (parts.length === 0) {
+            throw new TypeError("dataset thread list URL must include a table name");
+        }
+        return new DatasetThreadListRef({
+            namespace: parts.length === 1 ? undefined : parts.slice(0, -1),
+            table: parts[parts.length - 1],
+        });
+    }
+}
+export class DatasetThreadStorageRepository extends ThreadStorageRepository {
+    constructor({ room, path }) {
+        super();
+        this.entriesByPath = new Map();
+        this.initialSnapshotReady = false;
+        this.closed = true;
+        this.room = room;
+        this.path = path.trim();
+        this.ref = DatasetThreadListRef.parse(this.path);
+    }
+    async open() {
+        this.closed = false;
+        await this.ensureTable();
+        this.abortController = new AbortController();
+        const ready = new Promise((resolve, reject) => {
+            this.watchTask = this.watchLoop(resolve, reject);
+        });
+        await ready;
+    }
+    async watchLoop(resolveReady, rejectReady) {
+        let readyResolved = false;
+        try {
+            for await (const event of this.room.datasets.watchTable({ table: this.ref.table, namespace: this.ref.namespace })) {
+                if (this.closed) {
+                    return;
+                }
+                const initialSnapshotCompleted = this.handleWatchEvent(event);
+                if (initialSnapshotCompleted && !readyResolved) {
+                    readyResolved = true;
+                    resolveReady();
+                }
+            }
+            if (!readyResolved && !this.closed) {
+                rejectReady(new Error("Dataset thread list watch closed before initial snapshot."));
+            }
+        }
+        catch (error) {
+            if (this.closed) {
+                return;
+            }
+            if (!readyResolved) {
+                rejectReady(error);
+            }
+            else {
+                throw error;
+            }
+        }
+    }
+    async close() {
+        this.abortController?.abort();
+        this.abortController = undefined;
+        this.initialSnapshotReady = false;
+        this.closed = true;
+        this.watchTask = undefined;
+        const refreshEntriesFuture = this.refreshEntriesFuture;
+        this.refreshEntriesFuture = undefined;
+        if (refreshEntriesFuture != null) {
+            try {
+                await refreshEntriesFuture;
+            }
+            catch {
+            }
+        }
+    }
+    entries() {
+        return [...this.entriesByPath.values()];
+    }
+    async addOrUpdateThread(entry) {
+        await this.ensureTable();
+        await this.room.datasets.merge({
+            table: this.ref.table,
+            on: "path",
+            records: this.batchFor([entry]),
+            namespace: this.ref.namespace,
+        });
+    }
+    async deleteThread(threadPath) {
+        const normalized = normalizeThreadPath(threadPath);
+        await this.ensureTable();
+        await this.room.datasets.delete({
+            table: this.ref.table,
+            where: pathWhere(normalized),
+            namespace: this.ref.namespace,
+        });
+        if (this.entriesByPath.delete(normalized)) {
+            this.notifyListeners();
+        }
+    }
+    async renameThread(threadPath, name) {
+        const normalized = normalizeThreadPath(threadPath);
+        const trimmedName = name.trim();
+        if (trimmedName === "") {
+            throw new TypeError("thread name cannot be empty");
+        }
+        const now = new Date().toISOString();
+        const existing = this.entriesByPath.get(normalized);
+        await this.addOrUpdateThread(new ThreadListEntry({
+            path: normalized,
+            name: trimmedName,
+            createdAt: existing?.createdAt ?? now,
+            modifiedAt: now,
+        }));
+    }
+    async ensureTable() {
+        await this.room.datasets.createTableWithSchema({
+            name: this.ref.table,
+            schema: DatasetThreadStorageRepository.schema,
+            mode: "create_if_not_exists",
+            namespace: this.ref.namespace,
+        });
+    }
+    handleWatchEvent(event) {
+        const rows = event.table == null ? [] : rowsFromTable(event.table);
+        if (event.phase === "initial") {
+            for (const row of rows) {
+                const entry = ThreadListEntry.fromDatasetRow(row);
+                if (entry != null) {
+                    this.entriesByPath.set(entry.path, entry);
+                }
+            }
+            if (event.kind === "ready") {
+                this.initialSnapshotReady = true;
+                return true;
+            }
+            if (this.initialSnapshotReady && rows.length > 0) {
+                this.notifyListeners();
+            }
+            return false;
+        }
+        if (event.kind === "ready") {
+            return false;
+        }
+        const changeType = event.changeType?.trim().toLowerCase() ?? "";
+        if (changeType === "deleted" ||
+            changeType === "delete" ||
+            changeType === "removed" ||
+            changeType === "remove" ||
+            event.deletePredicate != null ||
+            event.kind.trim().toLowerCase() === "delete") {
+            let removed = false;
+            for (const row of rows) {
+                const entry = ThreadListEntry.fromDatasetRow(row);
+                if (entry != null) {
+                    removed = this.entriesByPath.delete(entry.path) || removed;
+                }
+            }
+            const deletedPath = threadPathFromDeletePredicate(event.deletePredicate);
+            if (deletedPath != null) {
+                removed = this.entriesByPath.delete(deletedPath) || removed;
+            }
+            if (rows.length === 0 && deletedPath == null) {
+                const refreshEntriesFuture = this.refreshEntries();
+                this.refreshEntriesFuture = refreshEntriesFuture;
+                void refreshEntriesFuture.catch(() => undefined);
+                return false;
+            }
+            if (removed || rows.length === 0) {
+                this.notifyListeners();
+            }
+            return false;
+        }
+        let changed = false;
+        for (const row of rows) {
+            const entry = ThreadListEntry.fromDatasetRow(row);
+            if (entry != null) {
+                this.entriesByPath.set(entry.path, entry);
+                changed = true;
+            }
+        }
+        if (changed) {
+            this.notifyListeners();
+        }
+        return false;
+    }
+    async refreshEntries() {
+        if (this.closed) {
+            return;
+        }
+        const table = await this.room.datasets.search({
+            table: this.ref.table,
+            namespace: this.ref.namespace,
+            select: ["path", "name", "created_at", "modified_at"],
+        });
+        if (this.closed) {
+            return;
+        }
+        const nextEntries = new Map();
+        for (const row of rowsFromTable(table)) {
+            const entry = ThreadListEntry.fromDatasetRow(row);
+            if (entry != null) {
+                nextEntries.set(entry.path, entry);
+            }
+        }
+        this.entriesByPath.clear();
+        for (const [path, entry] of nextEntries) {
+            this.entriesByPath.set(path, entry);
+        }
+        if (!this.closed) {
+            this.notifyListeners();
+        }
+    }
+    batchFor(entries) {
+        return tableFromArrays({
+            path: entries.map((entry) => entry.path),
+            name: entries.map((entry) => entry.name),
+            created_at: entries.map((entry) => entry.createdAt),
+            modified_at: entries.map((entry) => entry.modifiedAt),
+        });
+    }
+}
+DatasetThreadStorageRepository.schema = new Schema([
+    new Field("path", new Utf8(), false),
+    new Field("name", new Utf8(), true),
+    new Field("created_at", new Utf8(), true),
+    new Field("modified_at", new Utf8(), true),
+]);
+export class AgentThreadStorageRepository extends ThreadStorageRepository {
+    constructor({ chatClient, limit = 200 }) {
+        super();
+        this.entriesByPath = new Map();
+        this.closed = true;
+        this.chatClient = chatClient;
+        this.limit = limit;
+    }
+    async open() {
+        if (!this.closed) {
+            return;
+        }
+        this.closed = false;
+        const iterator = this.chatClient.events[Symbol.asyncIterator]();
+        let active = true;
+        this.subscription = () => { active = false; };
+        void (async () => {
+            while (active && !this.closed) {
+                const next = await iterator.next();
+                if (next.done) {
+                    return;
+                }
+                this.handleEvent(next.value);
+            }
+        })();
+        await new Promise((resolve) => {
+            this.pendingOpen = { resolve };
+            void this.requestList();
+        });
+    }
+    async close() {
+        this.closed = true;
+        this.subscription?.();
+        this.subscription = undefined;
+        this.pendingListMessageId = undefined;
+        this.pendingOpen?.resolve();
+        this.pendingOpen = undefined;
+    }
+    entries() {
+        return [...this.entriesByPath.values()];
+    }
+    async addOrUpdateThread(_entry) {
+        throw new Error("Agent thread storage cannot directly upsert thread entries.");
+    }
+    async deleteThread(threadPath) {
+        const normalized = normalizeThreadPath(threadPath);
+        await this.chatClient.sendAgentMessage(new DeleteThread({ threadId: normalized }));
+        if (this.entriesByPath.delete(normalized)) {
+            this.notifyListeners();
+        }
+        void this.requestList();
+    }
+    async renameThread(threadPath, name) {
+        const normalized = normalizeThreadPath(threadPath);
+        const trimmedName = name.trim();
+        if (trimmedName === "") {
+            throw new TypeError("thread name cannot be empty");
+        }
+        await this.chatClient.sendAgentMessage(new RenameThread({ threadId: normalized, name: trimmedName }));
+        const existing = this.entriesByPath.get(normalized);
+        if (existing != null) {
+            this.entriesByPath.set(normalized, existing.renamed(trimmedName, new Date().toISOString()));
+            this.notifyListeners();
+        }
+        void this.requestList();
+    }
+    async requestList() {
+        if (this.closed) {
+            return;
+        }
+        const request = new ListThreads({ limit: this.limit, offset: 0 });
+        this.pendingListMessageId = request.messageId;
+        await this.chatClient.sendAgentMessage(request, { ignoreOffline: true });
+    }
+    handleEvent(event) {
+        const message = event.message;
+        if (message.type === "meshagent.agent.thread.listed") {
+            this.handleThreadsListed(message);
+            return;
+        }
+        if (message.type === "meshagent.agent.thread.created") {
+            this.upsertThread(message.thread);
+            return;
+        }
+        if (message.type === "meshagent.agent.thread.updated") {
+            this.upsertThread(message.thread);
+            return;
+        }
+        if (message.type === "meshagent.agent.thread.deleted") {
+            const normalized = normalizeThreadPath(String(message.path));
+            if (this.entriesByPath.delete(normalized) && !this.closed) {
+                this.notifyListeners();
+            }
+        }
+    }
+    handleThreadsListed(message) {
+        const nextEntries = new Map();
+        for (const thread of message.threads) {
+            const entry = this.entryFromAgentThread(thread);
+            if (entry != null) {
+                nextEntries.set(entry.path, entry);
+            }
+        }
+        this.entriesByPath.clear();
+        for (const [path, entry] of nextEntries) {
+            this.entriesByPath.set(path, entry);
+        }
+        if (this.pendingOpen != null && (this.pendingListMessageId == null || message.sourceMessageId === this.pendingListMessageId)) {
+            this.pendingOpen.resolve();
+            this.pendingOpen = undefined;
+        }
+        if (!this.closed) {
+            this.notifyListeners();
+        }
+    }
+    upsertThread(thread) {
+        const entry = this.entryFromAgentThread(thread);
+        if (entry == null) {
+            return;
+        }
+        this.entriesByPath.set(entry.path, entry);
+        if (!this.closed) {
+            this.notifyListeners();
+        }
+    }
+    entryFromAgentThread(thread) {
+        const path = thread.path.trim();
+        if (path === "") {
+            return null;
+        }
+        const name = thread.name.trim();
+        return new ThreadListEntry({
+            path,
+            name: name !== "" ? name : defaultThreadDisplayNameFromPath(path),
+            createdAt: thread.createdAt,
+            modifiedAt: thread.modifiedAt,
+        });
+    }
+}
+export class DatasetThreadStorage extends DatasetThreadStorageRepository {
+}
+export function defaultThreadDisplayNameFromPath(path) {
+    const segments = path.split("/").filter((segment) => segment !== "");
+    const basename = segments.length === 0 ? path : segments[segments.length - 1];
+    const rawName = basename.endsWith(".thread") ? basename.slice(0, -".thread".length) : basename;
+    const trimmed = rawName.trim();
+    if (trimmed === "" || uuidPattern.test(trimmed)) {
+        return defaultUntitledThreadName;
+    }
+    const normalized = trimmed.replace(/[_-]+/g, " ").replace(/\s+/g, " ").trim();
+    if (normalized === "") {
+        return defaultUntitledThreadName;
+    }
+    return normalized
+        .split(" ")
+        .filter((segment) => segment !== "")
+        .map((segment) => segment.length === 1 ? segment.toUpperCase() : `${segment[0].toUpperCase()}${segment.slice(1)}`)
+        .join(" ");
+}
+function normalizeThreadPath(threadPath) {
+    const normalized = threadPath.trim();
+    if (normalized === "") {
+        throw new TypeError("thread path cannot be empty");
+    }
+    return normalized;
+}
+function pathWhere(threadPath) {
+    return `path = ${datasetStringLiteral(threadPath)}`;
+}
+function datasetStringLiteral(value) {
+    return `'${value.replace(/'/g, "''")}'`;
+}
+function threadPathFromDeletePredicate(predicate) {
+    const trimmed = predicate?.trim();
+    if (trimmed == null || trimmed === "") {
+        return undefined;
+    }
+    const match = /^path\s*=\s*(['"])(.*)\1$/i.exec(trimmed);
+    return match == null ? undefined : match[2].replace(/''/g, "'");
+}
+function rowsFromTable(table) {
+    const tables = Array.isArray(table) ? table : [table];
+    return tables.flatMap((entry) => entry.toArray().map((row) => ({ ...row })));
+}