@agent-native/dispatch 0.2.20 → 0.4.0

package/dist/server/lib/thread-debug-store.js

@@ -0,0 +1,587 @@
+import { createDbExec, getDbExec } from "@agent-native/core/db";
+import { currentOrgId, currentOwnerEmail } from "./dispatch-store.js";
+const CONFIG_ENV_KEY = "AGENT_NATIVE_THREAD_DEBUG_DATABASES";
+const MAX_RAW_PREVIEW_CHARS = 1_500;
+const DEFAULT_SEARCH_LIMIT = 25;
+const MAX_SEARCH_LIMIT = 100;
+const DEFAULT_RUN_LIMIT = 20;
+const DEFAULT_EVENT_LIMIT = 600;
+const DEFAULT_TRACE_SPAN_LIMIT = 500;
+const execCache = new Map();
+function envEmails(name) {
+    return (process.env[name] ?? "")
+        .split(",")
+        .map((value) => value.trim().toLowerCase())
+        .filter(Boolean);
+}
+function isEnvAdmin(email) {
+    const normalized = email.trim().toLowerCase();
+    return [
+        ...envEmails("DISPATCH_ADMIN_EMAILS"),
+        ...envEmails("WORKSPACE_OWNER_EMAIL"),
+        ...envEmails("DISPATCH_DEFAULT_OWNER_EMAIL"),
+    ].includes(normalized);
+}
+function isMissingTableError(error) {
+    const message = String(error?.message ?? error).toLowerCase();
+    return (message.includes("no such table") ||
+        message.includes("does not exist") ||
+        message.includes("unknown table") ||
+        message.includes("undefined table"));
+}
+async function optionalRows(exec, sql, args = []) {
+    try {
+        return (await exec.execute({ sql, args })).rows;
+    }
+    catch (error) {
+        if (isMissingTableError(error))
+            return [];
+        throw error;
+    }
+}
+async function queryRows(exec, sql, args = []) {
+    try {
+        return (await exec.execute({ sql, args })).rows;
+    }
+    catch (error) {
+        if (isMissingTableError(error)) {
+            throw new Error("This database does not have agent chat thread tables yet.");
+        }
+        throw error;
+    }
+}
+function numberField(value) {
+    const parsed = Number(value ?? 0);
+    return Number.isFinite(parsed) ? parsed : 0;
+}
+function nullableNumberField(value) {
+    if (value == null)
+        return null;
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : null;
+}
+function safeJsonParse(value, fallback) {
+    if (value == null || value === "")
+        return fallback;
+    try {
+        return JSON.parse(String(value));
+    }
+    catch {
+        return fallback;
+    }
+}
+function safeJsonStringify(value) {
+    try {
+        return JSON.stringify(value, null, 2);
+    }
+    catch {
+        return String(value);
+    }
+}
+function textFromContent(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .map((part) => {
+        if (part?.type === "text" && typeof part.text === "string") {
+            return part.text;
+        }
+        if (part?.type === "tool-call") {
+            const name = part.toolName ?? part.name ?? "tool";
+            return `[tool:${name}] ${safeJsonStringify(part.args ?? part.input ?? {})}`;
+        }
+        if (part?.type === "tool-result") {
+            return `[tool-result:${part.toolName ?? part.toolCallId ?? "tool"}] ${typeof part.content === "string"
+                ? part.content
+                : safeJsonStringify(part.content)}`;
+        }
+        return "";
+    })
+        .filter(Boolean)
+        .join("\n");
+}
+function normalizeMessages(threadData) {
+    const messages = Array.isArray(threadData?.messages)
+        ? threadData.messages
+        : [];
+    return messages.map((entry, index) => {
+        const message = entry?.message ?? entry;
+        const content = message?.content;
+        const contentParts = Array.isArray(content) ? content : [];
+        return {
+            index,
+            id: typeof message?.id === "string" ? message.id : null,
+            role: typeof message?.role === "string" ? message.role : "unknown",
+            createdAt: message?.createdAt ?? null,
+            status: message?.status ?? null,
+            text: textFromContent(content),
+            contentParts,
+            attachments: Array.isArray(message?.attachments)
+                ? message.attachments
+                : [],
+            metadata: message?.metadata ?? null,
+            parentId: entry?.parentId ?? null,
+        };
+    });
+}
+function snippetFor(row, query) {
+    const raw = `${row.title ?? ""}\n${row.preview ?? ""}\n${row.thread_data ?? ""}`;
+    const compact = raw.replace(/\s+/g, " ").trim();
+    if (!query.trim()) {
+        return compact.slice(0, MAX_RAW_PREVIEW_CHARS);
+    }
+    const lower = compact.toLowerCase();
+    const needle = query.trim().toLowerCase();
+    const match = lower.indexOf(needle);
+    if (match === -1)
+        return compact.slice(0, MAX_RAW_PREVIEW_CHARS);
+    const start = Math.max(0, match - 160);
+    const end = Math.min(compact.length, match + needle.length + 320);
+    const prefix = start > 0 ? "..." : "";
+    const suffix = end < compact.length ? "..." : "";
+    return `${prefix}${compact.slice(start, end)}${suffix}`;
+}
+function envPrefixForSourceId(sourceId) {
+    return sourceId.toUpperCase().replace(/[^A-Z0-9]+/g, "_");
+}
+function sourceIdFromEnvPrefix(prefix) {
+    return prefix.toLowerCase().replace(/_/g, "-");
+}
+function labelFromSourceId(sourceId) {
+    return sourceId
+        .split(/[-_\s]+/)
+        .filter(Boolean)
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join(" ");
+}
+function currentDatabaseUrlEnv() {
+    const appName = process.env.APP_NAME?.toUpperCase().replace(/-/g, "_");
+    if (appName && process.env[`${appName}_DATABASE_URL`]) {
+        return `${appName}_DATABASE_URL`;
+    }
+    return process.env.DATABASE_URL ? "DATABASE_URL" : null;
+}
+function parseConfiguredSources() {
+    const raw = process.env[CONFIG_ENV_KEY];
+    if (!raw)
+        return [];
+    const parsed = safeJsonParse(raw, null);
+    const entries = Array.isArray(parsed)
+        ? parsed
+        : parsed && typeof parsed === "object"
+            ? Object.entries(parsed).map(([id, value]) => ({ id, ...value }))
+            : [];
+    return entries
+        .map((entry) => {
+        const id = typeof entry?.id === "string" ? entry.id.trim() : "";
+        if (!id)
+            return null;
+        const databaseUrlEnv = typeof entry.databaseUrlEnv === "string"
+            ? entry.databaseUrlEnv.trim()
+            : null;
+        const databaseAuthTokenEnv = typeof entry.databaseAuthTokenEnv === "string"
+            ? entry.databaseAuthTokenEnv.trim()
+            : null;
+        const databaseUrl = typeof entry.databaseUrl === "string" && entry.databaseUrl.trim()
+            ? entry.databaseUrl.trim()
+            : databaseUrlEnv
+                ? process.env[databaseUrlEnv]
+                : undefined;
+        if (!databaseUrl)
+            return null;
+        return {
+            id,
+            label: typeof entry.label === "string" && entry.label.trim()
+                ? entry.label.trim()
+                : labelFromSourceId(id),
+            kind: "configured",
+            databaseUrl,
+            databaseAuthToken: typeof entry.databaseAuthToken === "string"
+                ? entry.databaseAuthToken
+                : databaseAuthTokenEnv
+                    ? process.env[databaseAuthTokenEnv]
+                    : undefined,
+            databaseUrlEnv,
+            databaseAuthTokenEnv,
+        };
+    })
+        .filter((source) => Boolean(source));
+}
+function discoverEnvSources() {
+    const ignored = new Set([
+        "DATABASE_URL",
+        "NETLIFY_DATABASE_URL",
+        "NETLIFY_DATABASE_URL_UNPOOLED",
+    ]);
+    const currentAppPrefix = process.env.APP_NAME?.toUpperCase().replace(/-/g, "_");
+    const sources = [];
+    for (const [key, value] of Object.entries(process.env)) {
+        if (!value || !key.endsWith("_DATABASE_URL"))
+            continue;
+        if (ignored.has(key) || key.endsWith("_UNPOOLED_DATABASE_URL"))
+            continue;
+        const prefix = key.slice(0, -"_DATABASE_URL".length);
+        if (!prefix || prefix === "NETLIFY")
+            continue;
+        if (currentAppPrefix && prefix === currentAppPrefix)
+            continue;
+        const id = sourceIdFromEnvPrefix(prefix);
+        const tokenEnv = `${prefix}_DATABASE_AUTH_TOKEN`;
+        sources.push({
+            id,
+            label: labelFromSourceId(id),
+            kind: "env",
+            databaseUrl: value,
+            databaseAuthToken: process.env[tokenEnv],
+            databaseUrlEnv: key,
+            databaseAuthTokenEnv: process.env[tokenEnv] ? tokenEnv : null,
+        });
+    }
+    return sources;
+}
+function sourceConfigs() {
+    const byId = new Map();
+    byId.set("current", {
+        id: "current",
+        label: "Current Dispatch DB",
+        kind: "current",
+        databaseUrlEnv: currentDatabaseUrlEnv(),
+        databaseAuthTokenEnv: process.env.DATABASE_AUTH_TOKEN
+            ? "DATABASE_AUTH_TOKEN"
+            : null,
+    });
+    for (const source of discoverEnvSources())
+        byId.set(source.id, source);
+    for (const source of parseConfiguredSources())
+        byId.set(source.id, source);
+    return [...byId.values()];
+}
+function resolveSourceConfig(sourceId = "current") {
+    const normalized = sourceId.trim() || "current";
+    const direct = sourceConfigs().find((source) => source.id === normalized);
+    if (direct)
+        return direct;
+    const prefix = envPrefixForSourceId(normalized);
+    const databaseUrlEnv = `${prefix}_DATABASE_URL`;
+    const databaseUrl = process.env[databaseUrlEnv];
+    if (!databaseUrl) {
+        throw new Error(`Thread debug source "${normalized}" is not configured.`);
+    }
+    const tokenEnv = `${prefix}_DATABASE_AUTH_TOKEN`;
+    return {
+        id: normalized,
+        label: labelFromSourceId(normalized),
+        kind: "env",
+        databaseUrl,
+        databaseAuthToken: process.env[tokenEnv],
+        databaseUrlEnv,
+        databaseAuthTokenEnv: process.env[tokenEnv] ? tokenEnv : null,
+    };
+}
+async function execForSource(source) {
+    if (source.kind === "current")
+        return getDbExec();
+    const cacheKey = `${source.databaseUrl ?? ""}\n${source.databaseAuthToken ?? ""}`;
+    if (!execCache.has(cacheKey)) {
+        execCache.set(cacheKey, createDbExec({
+            url: source.databaseUrl,
+            authToken: source.databaseAuthToken,
+        }));
+    }
+    return execCache.get(cacheKey);
+}
+async function currentDbRows(sql, args = []) {
+    return optionalRows(getDbExec(), sql, args);
+}
+async function viewerOrgRole(orgId, viewerEmail) {
+    if (!orgId)
+        return null;
+    const rows = await currentDbRows(`SELECT role FROM org_members WHERE org_id = ? AND LOWER(email) = ? LIMIT 1`, [orgId, viewerEmail.toLowerCase()]);
+    return typeof rows[0]?.role === "string" ? rows[0].role : null;
+}
+async function currentOrgMembers(orgId) {
+    if (!orgId)
+        return [];
+    const rows = await currentDbRows(`SELECT email FROM org_members WHERE org_id = ?`, [orgId]);
+    return rows.map((row) => String(row.email ?? "").trim()).filter(Boolean);
+}
+async function resolveDebugAccess() {
+    const viewerEmail = currentOwnerEmail();
+    const orgId = currentOrgId();
+    const role = await viewerOrgRole(orgId, viewerEmail);
+    const envAdmin = isEnvAdmin(viewerEmail);
+    const canInspectAll = envAdmin || role === "owner" || role === "admin";
+    const memberEmails = canInspectAll
+        ? await currentOrgMembers(orgId)
+        : [viewerEmail];
+    return {
+        viewerEmail,
+        orgId,
+        role,
+        envAdmin,
+        canInspectAll,
+        memberEmails: memberEmails.length > 0 ? memberEmails : [viewerEmail],
+    };
+}
+function assertSourceAccess(source, access) {
+    if (source.kind === "current")
+        return;
+    if (!access.canInspectAll) {
+        throw new Error("Only Dispatch admins can inspect thread databases from other apps.");
+    }
+}
+function ownerScope(access, ownerEmail) {
+    const requested = ownerEmail?.trim();
+    if (!access.canInspectAll) {
+        return {
+            sql: "owner_email = ?",
+            args: [access.viewerEmail],
+            label: access.viewerEmail,
+        };
+    }
+    if (requested && requested !== "*") {
+        return {
+            sql: "owner_email = ?",
+            args: [requested],
+            label: requested,
+        };
+    }
+    if (access.envAdmin && !access.orgId) {
+        return { sql: "1 = 1", args: [], label: "all users" };
+    }
+    const emails = access.memberEmails;
+    if (emails.length === 0) {
+        return {
+            sql: "owner_email = ?",
+            args: [access.viewerEmail],
+            label: access.viewerEmail,
+        };
+    }
+    const placeholders = emails.map(() => "?").join(", ");
+    return {
+        sql: `owner_email IN (${placeholders})`,
+        args: emails,
+        label: access.orgId ? "current organization" : "all users",
+    };
+}
+function serializeThreadSummary(row, query = "") {
+    return {
+        id: String(row.id),
+        ownerEmail: String(row.owner_email ?? ""),
+        title: String(row.title ?? ""),
+        preview: String(row.preview ?? ""),
+        messageCount: numberField(row.message_count),
+        createdAt: numberField(row.created_at),
+        updatedAt: numberField(row.updated_at),
+        snippet: snippetFor(row, query),
+    };
+}
+function serializeRun(row, events = []) {
+    return {
+        id: String(row.id),
+        threadId: String(row.thread_id),
+        status: String(row.status),
+        abortReason: row.abort_reason ? String(row.abort_reason) : null,
+        startedAt: numberField(row.started_at),
+        completedAt: nullableNumberField(row.completed_at),
+        heartbeatAt: nullableNumberField(row.heartbeat_at),
+        events,
+    };
+}
+function parseRunEvent(row) {
+    const raw = String(row.event_data ?? "");
+    return {
+        runId: String(row.run_id ?? ""),
+        seq: numberField(row.seq),
+        event: safeJsonParse(raw, { type: "unparseable", raw }),
+        rawEventData: raw,
+    };
+}
+export async function listThreadDebugSources() {
+    const access = await resolveDebugAccess();
+    return {
+        access: {
+            viewerEmail: access.viewerEmail,
+            orgId: access.orgId,
+            role: access.role,
+            envAdmin: access.envAdmin,
+            canInspectAll: access.canInspectAll,
+            memberCount: access.memberEmails.length,
+        },
+        sources: sourceConfigs().map((source) => ({
+            id: source.id,
+            label: source.label,
+            kind: source.kind,
+            current: source.kind === "current",
+            connected: source.kind === "current" || Boolean(source.databaseUrl),
+            databaseUrlEnv: source.databaseUrlEnv ?? null,
+            databaseAuthTokenEnv: source.databaseAuthTokenEnv ?? null,
+            canInspectAll: access.canInspectAll,
+        })),
+    };
+}
+export async function searchAgentThreads(input) {
+    const source = resolveSourceConfig(input.sourceId ?? "current");
+    const access = await resolveDebugAccess();
+    assertSourceAccess(source, access);
+    const exec = await execForSource(source);
+    const limit = Math.max(1, Math.min(MAX_SEARCH_LIMIT, input.limit ?? DEFAULT_SEARCH_LIMIT));
+    const q = input.query?.trim() ?? "";
+    const scope = ownerScope(access, input.ownerEmail);
+    const where = [scope.sql];
+    const args = [...scope.args];
+    if (q) {
+        const pattern = `%${q.toLowerCase()}%`;
+        where.push(`(LOWER(title) LIKE ? OR LOWER(preview) LIKE ? OR LOWER(thread_data) LIKE ?)`);
+        args.push(pattern, pattern, pattern);
+    }
+    args.push(limit);
+    const rows = await optionalRows(exec, `SELECT id, owner_email, title, preview, thread_data, message_count, created_at, updated_at
+       FROM chat_threads
+      WHERE ${where.join(" AND ")}
+      ORDER BY updated_at DESC
+      LIMIT ?`, args);
+    return {
+        source: {
+            id: source.id,
+            label: source.label,
+            kind: source.kind,
+            databaseUrlEnv: source.databaseUrlEnv ?? null,
+        },
+        access: {
+            viewerEmail: access.viewerEmail,
+            scope: scope.label,
+            canInspectAll: access.canInspectAll,
+        },
+        query: q,
+        count: rows.length,
+        threads: rows.map((row) => serializeThreadSummary(row, q)),
+    };
+}
+export async function getAgentThreadDebug(input) {
+    const source = resolveSourceConfig(input.sourceId ?? "current");
+    const access = await resolveDebugAccess();
+    assertSourceAccess(source, access);
+    const exec = await execForSource(source);
+    const scope = ownerScope(access, input.ownerEmail);
+    const rows = await queryRows(exec, `SELECT id, owner_email, title, preview, thread_data, message_count, created_at, updated_at
+       FROM chat_threads
+      WHERE id = ? AND ${scope.sql}
+      LIMIT 1`, [input.threadId, ...scope.args]);
+    const row = rows[0];
+    if (!row) {
+        throw new Error(`Thread "${input.threadId}" was not found.`);
+    }
+    const threadData = safeJsonParse(row.thread_data, {});
+    const maxRuns = Math.max(1, Math.min(50, input.maxRuns ?? DEFAULT_RUN_LIMIT));
+    const maxEvents = Math.max(1, Math.min(2_000, input.maxEvents ?? DEFAULT_EVENT_LIMIT));
+    const maxTraceSpans = Math.max(1, Math.min(2_000, input.maxTraceSpans ?? DEFAULT_TRACE_SPAN_LIMIT));
+    const runRows = await optionalRows(exec, `SELECT id, thread_id, status, abort_reason, started_at, heartbeat_at, completed_at
+       FROM agent_runs
+      WHERE thread_id = ?
+      ORDER BY started_at DESC
+      LIMIT ?`, [row.id, maxRuns]);
+    const runs = [];
+    for (const run of runRows) {
+        const eventRows = await optionalRows(exec, `SELECT run_id, seq, event_data
+         FROM agent_run_events
+        WHERE run_id = ?
+        ORDER BY seq ASC
+        LIMIT ?`, [run.id, maxEvents]);
+        runs.push(serializeRun(run, eventRows.map(parseRunEvent)));
+    }
+    const runIds = runRows.map((run) => run.id);
+    const runPlaceholders = runIds.map(() => "?").join(", ");
+    const traceSummaryRows = await optionalRows(exec, runIds.length > 0
+        ? `SELECT *
+           FROM agent_trace_summaries
+          WHERE thread_id = ? OR run_id IN (${runPlaceholders})
+          ORDER BY created_at DESC
+          LIMIT 50`
+        : `SELECT *
+           FROM agent_trace_summaries
+          WHERE thread_id = ?
+          ORDER BY created_at DESC
+          LIMIT 50`, runIds.length > 0 ? [row.id, ...runIds] : [row.id]);
+    const traceSpanRows = await optionalRows(exec, runIds.length > 0
+        ? `SELECT *
+           FROM agent_trace_spans
+          WHERE thread_id = ? OR run_id IN (${runPlaceholders})
+          ORDER BY created_at ASC
+          LIMIT ?`
+        : `SELECT *
+           FROM agent_trace_spans
+          WHERE thread_id = ?
+          ORDER BY created_at ASC
+          LIMIT ?`, runIds.length > 0
+        ? [row.id, ...runIds, maxTraceSpans]
+        : [row.id, maxTraceSpans]);
+    const feedbackRows = await optionalRows(exec, `SELECT *
+       FROM agent_feedback
+      WHERE thread_id = ?
+      ORDER BY created_at DESC
+      LIMIT 50`, [row.id]);
+    const satisfactionRows = await optionalRows(exec, `SELECT *
+       FROM agent_satisfaction_scores
+      WHERE thread_id = ?
+      ORDER BY computed_at DESC
+      LIMIT 10`, [row.id]);
+    const evalRows = await optionalRows(exec, runIds.length > 0
+        ? `SELECT *
+           FROM agent_evals
+          WHERE thread_id = ? OR run_id IN (${runPlaceholders})
+          ORDER BY created_at DESC
+          LIMIT 50`
+        : `SELECT *
+           FROM agent_evals
+          WHERE thread_id = ?
+          ORDER BY created_at DESC
+          LIMIT 50`, runIds.length > 0 ? [row.id, ...runIds] : [row.id]);
+    const checkpointRows = await optionalRows(exec, `SELECT id, thread_id, run_id, commit_sha, message, created_at
+       FROM agent_checkpoints
+      WHERE thread_id = ?
+      ORDER BY created_at DESC
+      LIMIT 50`, [row.id]);
+    return {
+        source: {
+            id: source.id,
+            label: source.label,
+            kind: source.kind,
+            databaseUrlEnv: source.databaseUrlEnv ?? null,
+        },
+        access: {
+            viewerEmail: access.viewerEmail,
+            scope: scope.label,
+            canInspectAll: access.canInspectAll,
+        },
+        thread: {
+            id: String(row.id),
+            ownerEmail: String(row.owner_email ?? ""),
+            title: String(row.title ?? ""),
+            preview: String(row.preview ?? ""),
+            messageCount: numberField(row.message_count),
+            createdAt: numberField(row.created_at),
+            updatedAt: numberField(row.updated_at),
+        },
+        messages: normalizeMessages(threadData),
+        debug: threadData?._debug ?? null,
+        debugRuns: Array.isArray(threadData?._debugRuns)
+            ? threadData._debugRuns
+            : [],
+        queuedMessages: threadData?.queuedMessages ?? [],
+        threadData,
+        rawThreadData: row.thread_data ?? "",
+        runs,
+        traces: {
+            summaries: traceSummaryRows,
+            spans: traceSpanRows,
+        },
+        feedback: feedbackRows,
+        satisfaction: satisfactionRows,
+        evals: evalRows,
+        checkpoints: checkpointRows,
+    };
+}
+//# sourceMappingURL=thread-debug-store.js.map