@promptbook/cli 0.113.0-0 → 0.113.0-10

package/apps/agents-server/src/utils/getAdminChatTasksResponse/getAdminChatTasks/adminChatTaskSqlQuery.ts

@@ -0,0 +1,264 @@
+import type { AdminChatTaskView } from '../../chatTasksAdmin';
+import type { ParsedAdminChatTaskQuery } from '../parseAdminChatTaskQuery';
+
+/**
+ * Builds the shared union query that surfaces durable chat jobs and timeouts as one admin task stream.
+ *
+ * @private function of `getAdminChatTasks`
+ */
+export function createAdminChatTaskBaseQuery(options: {
+    userChatJobTable: string;
+    userChatTimeoutTable: string;
+    userTable: string;
+    agentTable: string;
+}): string {
+    return `
+        SELECT
+            job."id" AS "id",
+            'CHAT_COMPLETION'::text AS "kind",
+            job."status" AS "status",
+            job."createdAt" AS "createdAt",
+            job."queuedAt" AS "queuedAt",
+            job."startedAt" AS "startedAt",
+            job."updatedAt" AS "updatedAt",
+            job."completedAt" AS "finishedAt",
+            job."cancelRequestedAt" AS "cancelRequestedAt",
+            NULL::TIMESTAMP WITH TIME ZONE AS "pausedAt",
+            job."lastHeartbeatAt" AS "lastHeartbeatAt",
+            job."leaseExpiresAt" AS "leaseExpiresAt",
+            NULL::BIGINT AS "recurrenceIntervalMs",
+            job."attemptCount" AS "attemptCount",
+            job."failureReason" AS "lastErrorSummary",
+            job."failureDetails" AS "lastErrorDetails",
+            job."userId" AS "userId",
+            "user"."username" AS "username",
+            job."agentPermanentId" AS "agentPermanentId",
+            agent."agentName" AS "agentName",
+            job."chatId" AS "chatId"
+        FROM ${options.userChatJobTable} job
+        LEFT JOIN ${options.userTable} "user" ON "user"."id" = job."userId"
+        LEFT JOIN ${options.agentTable} agent ON agent."permanentId" = job."agentPermanentId"
+
+        UNION ALL
+
+        SELECT
+            timeout."id" AS "id",
+            'CHAT_TIMEOUT'::text AS "kind",
+            timeout."status" AS "status",
+            timeout."createdAt" AS "createdAt",
+            timeout."queuedAt" AS "queuedAt",
+            timeout."startedAt" AS "startedAt",
+            timeout."updatedAt" AS "updatedAt",
+            timeout."completedAt" AS "finishedAt",
+            timeout."cancelRequestedAt" AS "cancelRequestedAt",
+            timeout."pausedAt" AS "pausedAt",
+            NULL::TIMESTAMP WITH TIME ZONE AS "lastHeartbeatAt",
+            timeout."leaseExpiresAt" AS "leaseExpiresAt",
+            timeout."recurrenceIntervalMs" AS "recurrenceIntervalMs",
+            timeout."attemptCount" AS "attemptCount",
+            timeout."failureReason" AS "lastErrorSummary",
+            NULL::TEXT AS "lastErrorDetails",
+            timeout."userId" AS "userId",
+            "user"."username" AS "username",
+            timeout."agentPermanentId" AS "agentPermanentId",
+            agent."agentName" AS "agentName",
+            timeout."chatId" AS "chatId"
+        FROM ${options.userChatTimeoutTable} timeout
+        LEFT JOIN ${options.userTable} "user" ON "user"."id" = timeout."userId"
+        LEFT JOIN ${options.agentTable} agent ON agent."permanentId" = timeout."agentPermanentId"
+    `;
+}
+
+/**
+ * Builds the paginated admin task list query together with its bound parameter values.
+ *
+ * @private function of `getAdminChatTasks`
+ */
+export function createAdminChatTaskListQuery(options: { baseTaskQuery: string; query: ParsedAdminChatTaskQuery }): {
+    sql: string;
+    values: Array<string | number>;
+} {
+    const listQueryParts = createAdminChatTaskListQueryParts(options.query);
+
+    return {
+        sql: `
+            WITH tasks AS (
+                ${options.baseTaskQuery}
+            )
+            SELECT
+                task.*,
+                COUNT(*) OVER() AS "totalCount"
+            FROM tasks task
+            ${listQueryParts.whereClause}
+            ORDER BY ${createAdminChatTaskOrderBySql(options.query.view, 'task')}
+            LIMIT $${listQueryParts.limitPlaceholder}
+            OFFSET $${listQueryParts.offsetPlaceholder}
+        `,
+        values: listQueryParts.values,
+    };
+}
+
+/**
+ * Builds the task-manager summary counters query.
+ *
+ * @private function of `getAdminChatTasks`
+ */
+export function createAdminChatTaskCountersQuery(options: { baseTaskQuery: string }): string {
+    return `
+        WITH tasks AS (
+            ${options.baseTaskQuery}
+        )
+        SELECT
+            COUNT(*) FILTER (WHERE "status" = 'RUNNING') AS "runningCount",
+            COUNT(*) FILTER (WHERE "status" = 'QUEUED') AS "queuedCount",
+            COUNT(*) FILTER (
+                WHERE "status" = 'FAILED'
+                  AND "finishedAt" >= CURRENT_TIMESTAMP - INTERVAL '24 hours'
+            ) AS "failedLast24hCount",
+            CASE
+                WHEN MIN("queuedAt") FILTER (WHERE "status" = 'QUEUED') IS NULL THEN NULL
+                ELSE EXTRACT(EPOCH FROM (CURRENT_TIMESTAMP - MIN("queuedAt") FILTER (WHERE "status" = 'QUEUED'))) * 1000
+            END AS "oldestQueuedAgeMs"
+        FROM tasks
+    `;
+}
+
+/**
+ * Creates the `WHERE` clause and parameter list for the paginated admin task query.
+ *
+ * @private function of `getAdminChatTasks`
+ */
+function createAdminChatTaskListQueryParts(query: ParsedAdminChatTaskQuery): {
+    whereClause: string;
+    values: Array<string | number>;
+    limitPlaceholder: number;
+    offsetPlaceholder: number;
+} {
+    const values: Array<string | number> = [];
+    const whereParts: Array<string> = [];
+
+    appendAdminChatTaskViewClause(query, values, whereParts, 'task');
+    appendAdminChatTaskSearchClause(query.search, values, whereParts, 'task');
+
+    values.push(query.pageSize);
+    values.push((query.page - 1) * query.pageSize);
+
+    return {
+        whereClause: whereParts.length > 0 ? `WHERE ${whereParts.join(' AND ')}` : '',
+        values,
+        limitPlaceholder: values.length - 1,
+        offsetPlaceholder: values.length,
+    };
+}
+
+/**
+ * Appends the status/time-window filter for one dashboard view.
+ *
+ * @private function of `getAdminChatTasks`
+ */
+function appendAdminChatTaskViewClause(
+    query: ParsedAdminChatTaskQuery,
+    values: Array<string | number>,
+    whereParts: Array<string>,
+    alias: string,
+): void {
+    switch (query.view) {
+        case 'running':
+            whereParts.push(`${alias}."status" = 'RUNNING'`);
+            return;
+        case 'queued':
+            whereParts.push(`${alias}."status" = 'QUEUED'`);
+            return;
+        case 'failed':
+            whereParts.push(`${alias}."status" = 'FAILED'`);
+            whereParts.push(`${alias}."finishedAt" >= CURRENT_TIMESTAMP - INTERVAL '24 hours'`);
+            return;
+        case 'all':
+            values.push(query.timeWindowHours);
+            whereParts.push(`${alias}."updatedAt" >= CURRENT_TIMESTAMP - ($${values.length} * INTERVAL '1 hour')`);
+            return;
+        case 'active':
+        default:
+            whereParts.push(`${alias}."status" IN ('QUEUED', 'RUNNING')`);
+    }
+}
+
+/**
+ * Appends the free-text search clause used by the dashboard.
+ *
+ * @private function of `getAdminChatTasks`
+ */
+function appendAdminChatTaskSearchClause(
+    search: string,
+    values: Array<string | number>,
+    whereParts: Array<string>,
+    alias: string,
+): void {
+    if (!search) {
+        return;
+    }
+
+    values.push(search);
+    const exactPlaceholder = values.length;
+
+    values.push(`${search}%`);
+    const prefixPlaceholder = values.length;
+
+    values.push(`%${search}%`);
+    const containsPlaceholder = values.length;
+
+    const searchParts = [
+        `${alias}."id" = $${exactPlaceholder}`,
+        `${alias}."id" LIKE $${prefixPlaceholder}`,
+        `${alias}."chatId" = $${exactPlaceholder}`,
+        `${alias}."chatId" LIKE $${prefixPlaceholder}`,
+        `${alias}."agentPermanentId" = $${exactPlaceholder}`,
+        `${alias}."agentPermanentId" LIKE $${prefixPlaceholder}`,
+        `COALESCE(${alias}."agentName", '') ILIKE $${containsPlaceholder}`,
+        `COALESCE(${alias}."username", '') ILIKE $${containsPlaceholder}`,
+    ];
+
+    if (/^\d+$/.test(search)) {
+        values.push(Number.parseInt(search, 10));
+        searchParts.push(`${alias}."userId" = $${values.length}`);
+    }
+
+    whereParts.push(`(${searchParts.join(' OR ')})`);
+}
+
+/**
+ * Resolves the stable sort order used by each dashboard view.
+ *
+ * @private function of `getAdminChatTasks`
+ */
+function createAdminChatTaskOrderBySql(view: AdminChatTaskView, alias: string): string {
+    switch (view) {
+        case 'running':
+            return `${alias}."startedAt" DESC NULLS LAST, ${alias}."createdAt" DESC, ${alias}."id" DESC`;
+        case 'queued':
+            return `${alias}."createdAt" DESC, ${alias}."id" DESC`;
+        case 'failed':
+            return `${alias}."finishedAt" DESC NULLS LAST, ${alias}."updatedAt" DESC, ${alias}."id" DESC`;
+        case 'all':
+            return `${alias}."updatedAt" DESC, ${alias}."createdAt" DESC, ${alias}."id" DESC`;
+        case 'active':
+        default:
+            return `
+                CASE
+                    WHEN ${alias}."status" = 'RUNNING' THEN 0
+                    WHEN ${alias}."status" = 'QUEUED' THEN 1
+                    ELSE 2
+                END ASC,
+                CASE
+                    WHEN ${alias}."status" = 'RUNNING' THEN ${alias}."startedAt"
+                    ELSE NULL
+                END DESC NULLS LAST,
+                CASE
+                    WHEN ${alias}."status" = 'QUEUED' THEN ${alias}."createdAt"
+                    ELSE NULL
+                END DESC NULLS LAST,
+                ${alias}."updatedAt" DESC,
+                ${alias}."id" DESC
+            `;
+    }
+}

package/apps/agents-server/src/utils/getAdminChatTasksResponse/getAdminChatTasks/adminChatTaskSqlValues.ts

@@ -0,0 +1,35 @@
+/**
+ * Converts PostgreSQL count-like values into safe JavaScript numbers.
+ *
+ * @private function of `getAdminChatTasks`
+ */
+export function resolveSqlCount(value: string | number | undefined): number {
+    if (typeof value === 'number') {
+        return value;
+    }
+
+    if (typeof value === 'string') {
+        const parsed = Number.parseInt(value, 10);
+        return Number.isFinite(parsed) ? parsed : 0;
+    }
+
+    return 0;
+}
+
+/**
+ * Converts nullable numeric SQL values into safe JavaScript numbers.
+ *
+ * @private function of `getAdminChatTasks`
+ */
+export function resolveNullableSqlNumber(value: string | number | null | undefined): number | null {
+    if (value === null || value === undefined) {
+        return null;
+    }
+
+    if (typeof value === 'number') {
+        return value;
+    }
+
+    const parsed = Number.parseFloat(value);
+    return Number.isFinite(parsed) ? parsed : null;
+}

package/apps/agents-server/src/utils/getAdminChatTasksResponse/getAdminChatTasks/adminChatTaskTimeUtilities.ts

@@ -0,0 +1,30 @@
+/**
+ * Milliseconds in one hour.
+ *
+ * @private constant of `getAdminChatTasks`
+ */
+export const HOUR_IN_MILLISECONDS = 60 * 60 * 1000;
+
+/**
+ * Parses one ISO timestamp into milliseconds since epoch.
+ *
+ * @private function of `getAdminChatTasks`
+ */
+export function parseIsoTimestamp(timestampIso: string | null): number | null {
+    if (!timestampIso) {
+        return null;
+    }
+
+    const timestamp = Date.parse(timestampIso);
+    return Number.isFinite(timestamp) ? timestamp : null;
+}
+
+/**
+ * Returns whether one ISO timestamp is at or after the given cutoff.
+ *
+ * @private function of `getAdminChatTasks`
+ */
+export function isIsoTimestampAtOrAfter(timestampIso: string | null, cutoffTimestamp: number): boolean {
+    const timestamp = parseIsoTimestamp(timestampIso);
+    return timestamp !== null && timestamp >= cutoffTimestamp;
+}

package/apps/agents-server/src/utils/getAdminChatTasksResponse/getAdminChatTasks/compareAdminChatTasks.ts

@@ -0,0 +1,135 @@
+import type { AdminChatTaskRecord, AdminChatTaskView } from '../../chatTasksAdmin';
+import type { UserChatJobStatus } from '../../userChat/UserChatJobRecord';
+import { parseIsoTimestamp } from './adminChatTaskTimeUtilities';
+
+/**
+ * Compares two tasks using the same ordering semantics as the PostgreSQL dashboard query.
+ *
+ * @private function of `getAdminChatTasks`
+ */
+export function compareAdminChatTasks(
+    leftTask: AdminChatTaskRecord,
+    rightTask: AdminChatTaskRecord,
+    view: AdminChatTaskView,
+): number {
+    switch (view) {
+        case 'running':
+            return (
+                compareNullableIsoTimestampsDescending(leftTask.startedAt, rightTask.startedAt) ||
+                compareIsoTimestampsDescending(leftTask.createdAt, rightTask.createdAt) ||
+                compareStringsDescending(leftTask.id, rightTask.id)
+            );
+        case 'queued':
+            return (
+                compareIsoTimestampsDescending(leftTask.createdAt, rightTask.createdAt) ||
+                compareStringsDescending(leftTask.id, rightTask.id)
+            );
+        case 'failed':
+            return (
+                compareNullableIsoTimestampsDescending(leftTask.finishedAt, rightTask.finishedAt) ||
+                compareIsoTimestampsDescending(leftTask.updatedAt, rightTask.updatedAt) ||
+                compareStringsDescending(leftTask.id, rightTask.id)
+            );
+        case 'all':
+            return (
+                compareIsoTimestampsDescending(leftTask.updatedAt, rightTask.updatedAt) ||
+                compareIsoTimestampsDescending(leftTask.createdAt, rightTask.createdAt) ||
+                compareStringsDescending(leftTask.id, rightTask.id)
+            );
+        case 'active':
+        default:
+            return (
+                compareNumbersAscending(
+                    resolveAdminChatTaskActiveStatusRank(leftTask.status),
+                    resolveAdminChatTaskActiveStatusRank(rightTask.status),
+                ) ||
+                compareNullableIsoTimestampsDescending(
+                    leftTask.status === 'RUNNING' ? leftTask.startedAt : null,
+                    rightTask.status === 'RUNNING' ? rightTask.startedAt : null,
+                ) ||
+                compareNullableIsoTimestampsDescending(
+                    leftTask.status === 'QUEUED' ? leftTask.createdAt : null,
+                    rightTask.status === 'QUEUED' ? rightTask.createdAt : null,
+                ) ||
+                compareIsoTimestampsDescending(leftTask.updatedAt, rightTask.updatedAt) ||
+                compareStringsDescending(leftTask.id, rightTask.id)
+            );
+    }
+}
+
+/**
+ * Resolves the status sort bucket used by the `Active` dashboard view.
+ *
+ * @private function of `getAdminChatTasks`
+ */
+function resolveAdminChatTaskActiveStatusRank(status: UserChatJobStatus): number {
+    switch (status) {
+        case 'RUNNING':
+            return 0;
+        case 'QUEUED':
+            return 1;
+        default:
+            return 2;
+    }
+}
+
+/**
+ * Sorts timestamps descending while keeping `null` values last.
+ *
+ * @private function of `getAdminChatTasks`
+ */
+function compareNullableIsoTimestampsDescending(
+    leftTimestampIso: string | null,
+    rightTimestampIso: string | null,
+): number {
+    const leftTimestamp = parseIsoTimestamp(leftTimestampIso);
+    const rightTimestamp = parseIsoTimestamp(rightTimestampIso);
+
+    if (leftTimestamp === rightTimestamp) {
+        return 0;
+    }
+    if (leftTimestamp === null) {
+        return 1;
+    }
+    if (rightTimestamp === null) {
+        return -1;
+    }
+
+    return compareNumbersDescending(leftTimestamp, rightTimestamp);
+}
+
+/**
+ * Sorts required timestamps descending.
+ *
+ * @private function of `getAdminChatTasks`
+ */
+function compareIsoTimestampsDescending(leftTimestampIso: string, rightTimestampIso: string): number {
+    return compareNullableIsoTimestampsDescending(leftTimestampIso, rightTimestampIso);
+}
+
+/**
+ * Sorts numbers ascending.
+ *
+ * @private function of `getAdminChatTasks`
+ */
+function compareNumbersAscending(leftNumber: number, rightNumber: number): number {
+    return leftNumber - rightNumber;
+}
+
+/**
+ * Sorts numbers descending.
+ *
+ * @private function of `getAdminChatTasks`
+ */
+function compareNumbersDescending(leftNumber: number, rightNumber: number): number {
+    return rightNumber - leftNumber;
+}
+
+/**
+ * Sorts strings descending.
+ *
+ * @private function of `getAdminChatTasks`
+ */
+function compareStringsDescending(leftString: string, rightString: string): number {
+    return leftString === rightString ? 0 : leftString < rightString ? 1 : -1;
+}

package/apps/agents-server/src/utils/getAdminChatTasksResponse/getAdminChatTasks/createAdminChatTaskCounters.ts

@@ -0,0 +1,29 @@
+import type { AdminChatTaskCounters, AdminChatTaskRecord } from '../../chatTasksAdmin';
+import { HOUR_IN_MILLISECONDS, isIsoTimestampAtOrAfter, parseIsoTimestamp } from './adminChatTaskTimeUtilities';
+
+/**
+ * Calculates the summary counters rendered above the admin task table.
+ *
+ * @private function of `getAdminChatTasks`
+ */
+export function createAdminChatTaskCounters(
+    tasks: ReadonlyArray<AdminChatTaskRecord>,
+    nowTimestamp: number,
+): AdminChatTaskCounters {
+    const queuedTimestamps = tasks
+        .filter((task) => task.status === 'QUEUED')
+        .map((task) => parseIsoTimestamp(task.queuedAt))
+        .filter((timestamp): timestamp is number => timestamp !== null);
+    const oldestQueuedTimestamp = queuedTimestamps.length > 0 ? Math.min(...queuedTimestamps) : null;
+
+    return {
+        runningCount: tasks.filter((task) => task.status === 'RUNNING').length,
+        queuedCount: tasks.filter((task) => task.status === 'QUEUED').length,
+        failedLast24hCount: tasks.filter(
+            (task) =>
+                task.status === 'FAILED' &&
+                isIsoTimestampAtOrAfter(task.finishedAt, nowTimestamp - 24 * HOUR_IN_MILLISECONDS),
+        ).length,
+        oldestQueuedAgeMs: oldestQueuedTimestamp === null ? null : Math.max(0, nowTimestamp - oldestQueuedTimestamp),
+    };
+}

package/apps/agents-server/src/utils/getAdminChatTasksResponse/getAdminChatTasks/filterAdminChatTasks.ts

@@ -0,0 +1,78 @@
+import type { AdminChatTaskRecord } from '../../chatTasksAdmin';
+import type { ParsedAdminChatTaskQuery } from '../parseAdminChatTaskQuery';
+import { HOUR_IN_MILLISECONDS, isIsoTimestampAtOrAfter } from './adminChatTaskTimeUtilities';
+
+/**
+ * Keeps only the tasks that belong to the requested admin task-manager view and search.
+ *
+ * @private function of `getAdminChatTasks`
+ */
+export function filterAdminChatTasks(
+    tasks: ReadonlyArray<AdminChatTaskRecord>,
+    query: ParsedAdminChatTaskQuery,
+    nowTimestamp: number,
+): Array<AdminChatTaskRecord> {
+    return tasks.filter(
+        (task) => matchesAdminChatTaskView(task, query, nowTimestamp) && matchesAdminChatTaskSearch(task, query.search),
+    );
+}
+
+/**
+ * Returns whether one task belongs in the requested admin task-manager view.
+ *
+ * @private function of `getAdminChatTasks`
+ */
+function matchesAdminChatTaskView(
+    task: AdminChatTaskRecord,
+    query: ParsedAdminChatTaskQuery,
+    nowTimestamp: number,
+): boolean {
+    switch (query.view) {
+        case 'running':
+            return task.status === 'RUNNING';
+        case 'queued':
+            return task.status === 'QUEUED';
+        case 'failed':
+            return (
+                task.status === 'FAILED' &&
+                isIsoTimestampAtOrAfter(task.finishedAt, nowTimestamp - 24 * HOUR_IN_MILLISECONDS)
+            );
+        case 'all':
+            return isIsoTimestampAtOrAfter(task.updatedAt, nowTimestamp - query.timeWindowHours * HOUR_IN_MILLISECONDS);
+        case 'active':
+        default:
+            return task.status === 'QUEUED' || task.status === 'RUNNING';
+    }
+}
+
+/**
+ * Returns whether one task matches the free-text admin search input.
+ *
+ * @private function of `getAdminChatTasks`
+ */
+function matchesAdminChatTaskSearch(task: AdminChatTaskRecord, search: string): boolean {
+    if (!search) {
+        return true;
+    }
+
+    if (
+        task.id === search ||
+        task.id.startsWith(search) ||
+        task.chatId === search ||
+        task.chatId.startsWith(search) ||
+        task.agentPermanentId === search ||
+        task.agentPermanentId.startsWith(search)
+    ) {
+        return true;
+    }
+
+    const normalizedSearch = search.toLowerCase();
+    if ((task.agentName || '').toLowerCase().includes(normalizedSearch)) {
+        return true;
+    }
+    if ((task.username || '').toLowerCase().includes(normalizedSearch)) {
+        return true;
+    }
+
+    return /^\d+$/.test(search) && task.userId === Number.parseInt(search, 10);
+}

package/apps/agents-server/src/utils/getAdminChatTasksResponse/getAdminChatTasks/getAdminChatTasksViaClientSql.ts

@@ -0,0 +1,62 @@
+import { $getTableName } from '@/src/database/$getTableName';
+import { $provideClientSql } from '@/src/database/$provideClientSql';
+import type { ParsedAdminChatTaskQuery } from '../parseAdminChatTaskQuery';
+import {
+    createAdminChatTaskBaseQuery,
+    createAdminChatTaskCountersQuery,
+    createAdminChatTaskListQuery,
+} from './adminChatTaskSqlQuery';
+import { resolveSqlCount } from './adminChatTaskSqlValues';
+import type { GetAdminChatTasksData } from './GetAdminChatTasksData';
+import type { AdminChatTaskCountersSqlRow, AdminChatTaskSqlRow } from './mapAdminChatTaskSqlRows';
+import { mapAdminChatTaskCounters, mapAdminChatTaskSqlRow } from './mapAdminChatTaskSqlRows';
+
+/**
+ * Loads admin task-manager data through the existing PostgreSQL raw SQL path.
+ *
+ * @private function of `getAdminChatTasks`
+ */
+export async function getAdminChatTasksViaClientSql(query: ParsedAdminChatTaskQuery): Promise<GetAdminChatTasksData> {
+    const sql = await $provideClientSql();
+    const userChatJobTable = quoteIdentifier(await $getTableName('UserChatJob'));
+    const userChatTimeoutTable = quoteIdentifier(await resolvePrefixedTableName('UserChatTimeout'));
+    const userTable = quoteIdentifier(await $getTableName('User'));
+    const agentTable = quoteIdentifier(await $getTableName('Agent'));
+    const baseTaskQuery = createAdminChatTaskBaseQuery({
+        userChatJobTable,
+        userChatTimeoutTable,
+        userTable,
+        agentTable,
+    });
+    const listQuery = createAdminChatTaskListQuery({ baseTaskQuery, query });
+    const listRows = await sql.raw<Array<AdminChatTaskSqlRow>>(listQuery.sql, listQuery.values);
+    const counterRows = await sql.raw<Array<AdminChatTaskCountersSqlRow>>(
+        createAdminChatTaskCountersQuery({ baseTaskQuery }),
+    );
+
+    return {
+        items: listRows.map(mapAdminChatTaskSqlRow),
+        counters: mapAdminChatTaskCounters(counterRows[0]),
+        total: resolveSqlCount(listRows[0]?.totalCount),
+    };
+}
+
+/**
+ * Quotes one trusted internal table identifier for raw SQL usage.
+ *
+ * @private function of `getAdminChatTasks`
+ */
+function quoteIdentifier(identifier: string): string {
+    return `"${identifier.replace(/"/g, '""')}"`;
+}
+
+/**
+ * Resolves one prefixed table name using the runtime-configured Supabase prefix.
+ *
+ * @private function of `getAdminChatTasks`
+ */
+async function resolvePrefixedTableName(tableName: string): Promise<string> {
+    const prefixedUserTable = await $getTableName('User');
+    const tablePrefix = prefixedUserTable.slice(0, prefixedUserTable.length - 'User'.length);
+    return `${tablePrefix}${tableName}`;
+}

package/apps/agents-server/src/utils/getAdminChatTasksResponse/getAdminChatTasks/getAdminChatTasksViaSupabaseQuery.ts

@@ -0,0 +1,29 @@
+import type { ParsedAdminChatTaskQuery } from '../parseAdminChatTaskQuery';
+import { compareAdminChatTasks } from './compareAdminChatTasks';
+import { createAdminChatTaskCounters } from './createAdminChatTaskCounters';
+import { filterAdminChatTasks } from './filterAdminChatTasks';
+import type { GetAdminChatTasksData } from './GetAdminChatTasksData';
+import { loadAdminChatTaskFallbackData } from './loadAdminChatTaskFallbackData';
+import { mapAdminChatTaskFallbackRows } from './mapAdminChatTaskFallbackRows';
+
+/**
+ * Loads admin task-manager data through the shared Supabase-shaped adapters used by SQLite mode.
+ *
+ * @private function of `getAdminChatTasks`
+ */
+export async function getAdminChatTasksViaSupabaseQuery(
+    query: ParsedAdminChatTaskQuery,
+): Promise<GetAdminChatTasksData> {
+    const allTasks = mapAdminChatTaskFallbackRows(await loadAdminChatTaskFallbackData());
+    const nowTimestamp = Date.now();
+    const filteredTasks = filterAdminChatTasks(allTasks, query, nowTimestamp).sort((leftTask, rightTask) =>
+        compareAdminChatTasks(leftTask, rightTask, query.view),
+    );
+    const pageOffset = (query.page - 1) * query.pageSize;
+
+    return {
+        items: filteredTasks.slice(pageOffset, pageOffset + query.pageSize),
+        counters: createAdminChatTaskCounters(allTasks, nowTimestamp),
+        total: filteredTasks.length,
+    };
+}