agent-relay 1.3.0 → 1.3.2

package/dist/cloud/api/test-helpers.js

@@ -108,6 +108,136 @@ testHelpersRouter.post('/create-daemon', async (req, res) => {
         res.status(500).json({ error: 'Failed to create test daemon' });
     }
 });
+/**
+ * POST /api/test/create-workspace
+ * Creates a test workspace for integration tests with optional linked repository
+ */
+testHelpersRouter.post('/create-workspace', async (req, res) => {
+    if (!isTestMode) {
+        return res.status(403).json({ error: 'Test endpoints disabled in production' });
+    }
+    try {
+        const { name, repoFullName, userId: providedUserId } = req.body;
+        const db = getDb();
+        // Use provided userId, session userId, or create a test user
+        let targetUserId = providedUserId || req.session.userId;
+        if (!targetUserId) {
+            // Create a test user if none exists
+            const testId = `test-ws-${randomUUID()}`;
+            const [newUser] = await db.insert(users).values({
+                email: `${testId}@test.local`,
+                githubId: testId,
+                githubUsername: 'workspace-test-user',
+                avatarUrl: null,
+                plan: 'free',
+            }).returning();
+            targetUserId = newUser.id;
+        }
+        const targetRepoFullName = repoFullName || `test-org/test-repo-${Date.now()}`;
+        // Create workspace
+        const [workspace] = await db.insert(workspaces).values({
+            userId: targetUserId,
+            name: name || `Test Workspace ${Date.now()}`,
+            status: 'running',
+            publicUrl: 'http://localhost:3889',
+            computeProvider: 'docker',
+            computeId: `test-${randomUUID().slice(0, 8)}`,
+            config: {
+                providers: ['anthropic'],
+                repositories: [targetRepoFullName],
+                supervisorEnabled: true,
+                maxAgents: 10,
+            },
+        }).returning();
+        // Create a linked repository for workspace lookup via repoFullName
+        const [repo] = await db.insert(repositories).values({
+            userId: targetUserId,
+            workspaceId: workspace.id,
+            githubId: Math.floor(Math.random() * 1000000),
+            githubFullName: targetRepoFullName,
+            isPrivate: false,
+            defaultBranch: 'main',
+            syncStatus: 'synced',
+            nangoConnectionId: `mock-${randomUUID().slice(0, 8)}`,
+            lastSyncedAt: new Date(),
+        }).returning();
+        res.json({
+            workspaceId: workspace.id,
+            name: workspace.name,
+            repoFullName: repo.githubFullName,
+            repoId: repo.id,
+            userId: targetUserId,
+        });
+    }
+    catch (error) {
+        console.error('Error creating test workspace:', error);
+        res.status(500).json({ error: 'Failed to create test workspace' });
+    }
+});
+/**
+ * POST /api/test/create-daemon-with-workspace
+ * Creates a test daemon linked to a workspace
+ */
+testHelpersRouter.post('/create-daemon-with-workspace', async (req, res) => {
+    if (!isTestMode) {
+        return res.status(403).json({ error: 'Test endpoints disabled in production' });
+    }
+    try {
+        const { name, machineId, workspaceId, userId: providedUserId } = req.body;
+        if (!name) {
+            return res.status(400).json({ error: 'name is required' });
+        }
+        const db = getDb();
+        // Get or create test user
+        let targetUserId = providedUserId;
+        if (!targetUserId) {
+            const existingUsers = await db.select().from(users).limit(1);
+            if (existingUsers.length > 0) {
+                targetUserId = existingUsers[0].id;
+            }
+            else {
+                const testId = `test-daemon-${randomUUID()}`;
+                const [newUser] = await db.insert(users).values({
+                    email: `${testId}@test.local`,
+                    githubId: testId,
+                    githubUsername: 'daemon-test-user',
+                    avatarUrl: null,
+                    plan: 'free',
+                }).returning();
+                targetUserId = newUser.id;
+            }
+        }
+        // Generate API key
+        const apiKey = `ar_live_${randomBytes(32).toString('hex')}`;
+        const apiKeyHash = createHash('sha256').update(apiKey).digest('hex');
+        // Create daemon with optional workspace link
+        const [daemon] = await db.insert(linkedDaemons).values({
+            userId: targetUserId,
+            workspaceId: workspaceId || null,
+            name,
+            machineId: machineId || randomUUID(),
+            apiKeyHash,
+            status: 'online',
+            metadata: {
+                hostname: 'test-host',
+                platform: 'linux',
+                version: '1.0.0-test',
+            },
+        }).returning();
+        res.json({
+            daemonId: daemon.id,
+            apiKey,
+            name: daemon.name,
+            machineId: daemon.machineId,
+            workspaceId: daemon.workspaceId,
+            userId: targetUserId,
+        });
+    }
+    catch (error) {
+        console.error('Error creating test daemon:', error);
+        res.status(500).json({ error: 'Failed to create test daemon' });
+    }
+});
 /**
  * DELETE /api/test/cleanup
  * Cleans up test data

package/dist/cloud/api/workspaces.js

@@ -891,10 +891,41 @@ workspacesRouter.post('/:id/repos', async (req, res) => {
         if (workspace.userId !== userId) {
             return res.status(403).json({ error: 'Unauthorized' });
         }
-        // Assign repositories to workspace
+        const reposToAssign = [];
+        const repoFullNames = [];
         for (const repoId of repositoryIds) {
+            const repo = await db.repositories.findById(repoId);
+            if (!repo || repo.userId !== userId) {
+                return res.status(404).json({ error: 'Repository not found' });
+            }
+            if (repo.workspaceId && repo.workspaceId !== id) {
+                return res.status(409).json({
+                    error: 'Repository already linked to another workspace',
+                    workspaceId: repo.workspaceId,
+                });
+            }
+            if (!repo.installationId) {
+                return res.status(400).json({
+                    error: 'Repository not authorized via GitHub App',
+                    message: 'Install the GitHub App for this repository before adding it to a workspace.',
+                });
+            }
+            reposToAssign.push(repo.id);
+            repoFullNames.push(repo.githubFullName);
+        }
+        // Assign repositories to workspace
+        for (const repoId of reposToAssign) {
             await db.repositories.assignToWorkspace(repoId, id);
         }
+        // Update workspace config repositories list
+        const existingRepos = workspace.config.repositories ?? [];
+        const updatedRepos = Array.from(new Set([...existingRepos, ...repoFullNames]));
+        if (updatedRepos.length !== existingRepos.length) {
+            await db.workspaces.updateConfig(id, {
+                ...workspace.config,
+                repositories: updatedRepos,
+            });
+        }
         res.json({ success: true, message: 'Repositories added' });
     }
     catch (error) {
@@ -1456,7 +1487,10 @@ workspacesRouter.all('/:id/proxy/{*proxyPath}', async (req, res) => {
             // The workspace port is 3888 inside the container
             targetBaseUrl = `http://${workspace.computeId}:3888`;
         }
-        const targetUrl = `${targetBaseUrl}/api/${proxyPath}`;
+        // Preserve query string when proxying - this is critical for API calls like
+        // /trajectory/steps?trajectoryId=xxx which need the query params forwarded
+        const queryString = req.url.includes('?') ? req.url.substring(req.url.indexOf('?')) : '';
+        const targetUrl = `${targetBaseUrl}/api/${proxyPath}${queryString}`;
         console.log(`[workspace-proxy] ${req.method} ${targetUrl}`);
         // Store targetUrl for error handling
         req._proxyTargetUrl = targetUrl;
@@ -1534,7 +1568,7 @@ workspacesRouter.all('/:id/proxy/{*proxyPath}', async (req, res) => {
 workspacesRouter.post('/:id/agents', async (req, res) => {
     const userId = req.session.userId;
     const { id } = req.params;
-    const { name, provider, task, temporary, interactive } = req.body;
+    const { name, provider, task, temporary: _temporary, interactive } = req.body;
     if (!userId) {
         return res.status(401).json({ error: 'Not authenticated' });
     }
@@ -1571,6 +1605,7 @@ workspacesRouter.post('/:id/agents', async (req, res) => {
                 cli: provider || 'claude', // Map provider to cli
                 task: task || '', // Empty task = interactive mode, user responds to prompts
                 interactive: interactive ?? true, // Default to interactive for setup flows
+                userId,
             }),
             signal: AbortSignal.timeout(30000),
         });

package/dist/cloud/db/bulk-ingest.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Bulk Ingest Utilities
+ *
+ * Optimized bulk insert operations for high-volume message sync.
+ * Uses raw SQL for performance instead of ORM-generated queries.
+ *
+ * Key optimizations:
+ * - Multi-row INSERT with VALUES for batches
+ * - Streaming COPY for very large batches (>1000 rows)
+ * - Proper JSONB serialization
+ * - Connection reuse via pool
+ * - Chunk processing for memory efficiency
+ */
+import { Pool } from 'pg';
+import type { NewAgentMessage } from './schema.js';
+export interface PoolConfig {
+    connectionString: string;
+    /** Maximum number of connections in pool (default: 20) */
+    max?: number;
+    /** How long a client can be idle before being closed (default: 30000) */
+    idleTimeoutMillis?: number;
+    /** Max time to wait for a connection (default: 10000) */
+    connectionTimeoutMillis?: number;
+    /** Enable SSL (default: based on connection string) */
+    ssl?: boolean | {
+        rejectUnauthorized: boolean;
+    };
+}
+export declare const DEFAULT_POOL_CONFIG: Partial<PoolConfig>;
+/**
+ * Result of a bulk insert operation
+ */
+export interface BulkInsertResult {
+    inserted: number;
+    duplicates: number;
+    errors: number;
+    durationMs: number;
+}
+/**
+ * Bulk insert messages using optimized multi-row INSERT.
+ *
+ * Uses ON CONFLICT DO NOTHING for deduplication.
+ * Much faster than individual inserts for batches.
+ *
+ * @param pool Database connection pool
+ * @param messages Messages to insert
+ * @param chunkSize Number of rows per INSERT statement (default: 100)
+ */
+export declare function bulkInsertMessages(pool: Pool, messages: NewAgentMessage[], chunkSize?: number): Promise<BulkInsertResult>;
+/**
+ * Streaming bulk insert using staging table for very large batches.
+ *
+ * Uses chunked multi-row INSERT into a temp staging table,
+ * then a single INSERT SELECT for deduplication.
+ * This avoids holding all data in memory and is efficient for large batches.
+ *
+ * @param pool Database connection pool
+ * @param messages Messages to insert
+ */
+export declare function streamingBulkInsert(pool: Pool, messages: NewAgentMessage[]): Promise<BulkInsertResult>;
+/**
+ * Optimized bulk insert that chooses strategy based on batch size.
+ *
+ * - Small batches (<100): Use regular ORM insert
+ * - Medium batches (100-1000): Use multi-row INSERT
+ * - Large batches (>1000): Use streaming COPY
+ *
+ * @param pool Database connection pool
+ * @param messages Messages to insert
+ */
+export declare function optimizedBulkInsert(pool: Pool, messages: NewAgentMessage[]): Promise<BulkInsertResult>;
+/**
+ * Get pool statistics for monitoring.
+ */
+export declare function getPoolStats(pool: Pool): {
+    total: number;
+    idle: number;
+    waiting: number;
+};
+/**
+ * Health check for the connection pool.
+ */
+export declare function checkPoolHealth(pool: Pool): Promise<{
+    healthy: boolean;
+    latencyMs: number;
+    error?: string;
+}>;
+//# sourceMappingURL=bulk-ingest.d.ts.map

package/dist/cloud/db/bulk-ingest.js

@@ -0,0 +1,268 @@
+/**
+ * Bulk Ingest Utilities
+ *
+ * Optimized bulk insert operations for high-volume message sync.
+ * Uses raw SQL for performance instead of ORM-generated queries.
+ *
+ * Key optimizations:
+ * - Multi-row INSERT with VALUES for batches
+ * - Streaming COPY for very large batches (>1000 rows)
+ * - Proper JSONB serialization
+ * - Connection reuse via pool
+ * - Chunk processing for memory efficiency
+ */
+export const DEFAULT_POOL_CONFIG = {
+    max: 20,
+    idleTimeoutMillis: 30000,
+    connectionTimeoutMillis: 10000,
+};
+/**
+ * Bulk insert messages using optimized multi-row INSERT.
+ *
+ * Uses ON CONFLICT DO NOTHING for deduplication.
+ * Much faster than individual inserts for batches.
+ *
+ * @param pool Database connection pool
+ * @param messages Messages to insert
+ * @param chunkSize Number of rows per INSERT statement (default: 100)
+ */
+export async function bulkInsertMessages(pool, messages, chunkSize = 100) {
+    if (messages.length === 0) {
+        return { inserted: 0, duplicates: 0, errors: 0, durationMs: 0 };
+    }
+    const startTime = Date.now();
+    let totalInserted = 0;
+    let totalErrors = 0;
+    // Process in chunks to avoid query size limits
+    for (let i = 0; i < messages.length; i += chunkSize) {
+        const chunk = messages.slice(i, i + chunkSize);
+        const result = await insertMessageChunk(pool, chunk);
+        totalInserted += result.inserted;
+        totalErrors += result.errors;
+    }
+    return {
+        inserted: totalInserted,
+        duplicates: messages.length - totalInserted - totalErrors,
+        errors: totalErrors,
+        durationMs: Date.now() - startTime,
+    };
+}
+/**
+ * Insert a chunk of messages with multi-row VALUES.
+ */
+async function insertMessageChunk(pool, messages) {
+    if (messages.length === 0) {
+        return { inserted: 0, errors: 0 };
+    }
+    // Build parameterized multi-row INSERT
+    const columns = [
+        'workspace_id',
+        'daemon_id',
+        'original_id',
+        'from_agent',
+        'to_agent',
+        'body',
+        'kind',
+        'topic',
+        'thread',
+        'channel',
+        'is_broadcast',
+        'is_urgent',
+        'data',
+        'payload_meta',
+        'message_ts',
+        'expires_at',
+    ];
+    const values = [];
+    const placeholders = [];
+    for (let i = 0; i < messages.length; i++) {
+        const msg = messages[i];
+        const offset = i * columns.length;
+        const rowPlaceholders = columns.map((_, j) => `$${offset + j + 1}`);
+        placeholders.push(`(${rowPlaceholders.join(', ')})`);
+        values.push(msg.workspaceId, msg.daemonId ?? null, msg.originalId, msg.fromAgent, msg.toAgent, msg.body, msg.kind ?? 'message', msg.topic ?? null, msg.thread ?? null, msg.channel ?? null, msg.isBroadcast ?? false, msg.isUrgent ?? false, msg.data ? JSON.stringify(msg.data) : null, msg.payloadMeta ? JSON.stringify(msg.payloadMeta) : null, msg.messageTs, msg.expiresAt ?? null);
+    }
+    const query = `
+    INSERT INTO agent_messages (${columns.join(', ')})
+    VALUES ${placeholders.join(', ')}
+    ON CONFLICT (workspace_id, original_id) DO NOTHING
+  `;
+    try {
+        const result = await pool.query(query, values);
+        return { inserted: result.rowCount ?? 0, errors: 0 };
+    }
+    catch (err) {
+        console.error('[bulk-ingest] Chunk insert failed:', err);
+        return { inserted: 0, errors: messages.length };
+    }
+}
+/**
+ * Streaming bulk insert using staging table for very large batches.
+ *
+ * Uses chunked multi-row INSERT into a temp staging table,
+ * then a single INSERT SELECT for deduplication.
+ * This avoids holding all data in memory and is efficient for large batches.
+ *
+ * @param pool Database connection pool
+ * @param messages Messages to insert
+ */
+export async function streamingBulkInsert(pool, messages) {
+    if (messages.length === 0) {
+        return { inserted: 0, duplicates: 0, errors: 0, durationMs: 0 };
+    }
+    const startTime = Date.now();
+    const client = await pool.connect();
+    try {
+        // Start transaction
+        await client.query('BEGIN');
+        // Create temp staging table
+        await client.query(`
+      CREATE TEMP TABLE _staging_messages (
+        workspace_id UUID NOT NULL,
+        daemon_id UUID,
+        original_id VARCHAR(255) NOT NULL,
+        from_agent VARCHAR(255) NOT NULL,
+        to_agent VARCHAR(255) NOT NULL,
+        body TEXT NOT NULL,
+        kind VARCHAR(50) DEFAULT 'message',
+        topic VARCHAR(255),
+        thread VARCHAR(255),
+        channel VARCHAR(255),
+        is_broadcast BOOLEAN DEFAULT false,
+        is_urgent BOOLEAN DEFAULT false,
+        data JSONB,
+        payload_meta JSONB,
+        message_ts TIMESTAMP NOT NULL,
+        expires_at TIMESTAMP
+      ) ON COMMIT DROP
+    `);
+        // Insert into staging table in chunks
+        const chunkSize = 200;
+        for (let i = 0; i < messages.length; i += chunkSize) {
+            const chunk = messages.slice(i, i + chunkSize);
+            await insertStagingChunk(client, chunk);
+        }
+        // Insert from staging to main table with dedup
+        const result = await client.query(`
+      INSERT INTO agent_messages (
+        workspace_id, daemon_id, original_id, from_agent, to_agent, body,
+        kind, topic, thread, channel, is_broadcast, is_urgent,
+        data, payload_meta, message_ts, expires_at
+      )
+      SELECT
+        workspace_id, daemon_id, original_id, from_agent, to_agent, body,
+        kind, topic, thread, channel, is_broadcast, is_urgent,
+        data, payload_meta, message_ts, expires_at
+      FROM _staging_messages
+      ON CONFLICT (workspace_id, original_id) DO NOTHING
+    `);
+        await client.query('COMMIT');
+        return {
+            inserted: result.rowCount ?? 0,
+            duplicates: messages.length - (result.rowCount ?? 0),
+            errors: 0,
+            durationMs: Date.now() - startTime,
+        };
+    }
+    catch (err) {
+        await client.query('ROLLBACK').catch(() => { });
+        console.error('[bulk-ingest] Streaming insert failed:', err);
+        return {
+            inserted: 0,
+            duplicates: 0,
+            errors: messages.length,
+            durationMs: Date.now() - startTime,
+        };
+    }
+    finally {
+        client.release();
+    }
+}
+/**
+ * Insert a chunk of messages into the staging table.
+ */
+async function insertStagingChunk(client, messages) {
+    if (messages.length === 0)
+        return;
+    const columns = [
+        'workspace_id',
+        'daemon_id',
+        'original_id',
+        'from_agent',
+        'to_agent',
+        'body',
+        'kind',
+        'topic',
+        'thread',
+        'channel',
+        'is_broadcast',
+        'is_urgent',
+        'data',
+        'payload_meta',
+        'message_ts',
+        'expires_at',
+    ];
+    const values = [];
+    const placeholders = [];
+    for (let i = 0; i < messages.length; i++) {
+        const msg = messages[i];
+        const offset = i * columns.length;
+        const rowPlaceholders = columns.map((_, j) => `$${offset + j + 1}`);
+        placeholders.push(`(${rowPlaceholders.join(', ')})`);
+        values.push(msg.workspaceId, msg.daemonId ?? null, msg.originalId, msg.fromAgent, msg.toAgent, msg.body, msg.kind ?? 'message', msg.topic ?? null, msg.thread ?? null, msg.channel ?? null, msg.isBroadcast ?? false, msg.isUrgent ?? false, msg.data ? JSON.stringify(msg.data) : null, msg.payloadMeta ? JSON.stringify(msg.payloadMeta) : null, msg.messageTs, msg.expiresAt ?? null);
+    }
+    await client.query(`INSERT INTO _staging_messages (${columns.join(', ')}) VALUES ${placeholders.join(', ')}`, values);
+}
+/**
+ * Optimized bulk insert that chooses strategy based on batch size.
+ *
+ * - Small batches (<100): Use regular ORM insert
+ * - Medium batches (100-1000): Use multi-row INSERT
+ * - Large batches (>1000): Use streaming COPY
+ *
+ * @param pool Database connection pool
+ * @param messages Messages to insert
+ */
+export async function optimizedBulkInsert(pool, messages) {
+    const count = messages.length;
+    if (count === 0) {
+        return { inserted: 0, duplicates: 0, errors: 0, durationMs: 0 };
+    }
+    // For very large batches, use streaming COPY
+    if (count > 1000) {
+        return streamingBulkInsert(pool, messages);
+    }
+    // For medium batches, use multi-row INSERT
+    return bulkInsertMessages(pool, messages);
+}
+/**
+ * Get pool statistics for monitoring.
+ */
+export function getPoolStats(pool) {
+    return {
+        total: pool.totalCount,
+        idle: pool.idleCount,
+        waiting: pool.waitingCount,
+    };
+}
+/**
+ * Health check for the connection pool.
+ */
+export async function checkPoolHealth(pool) {
+    const start = Date.now();
+    try {
+        await pool.query('SELECT 1');
+        return {
+            healthy: true,
+            latencyMs: Date.now() - start,
+        };
+    }
+    catch (err) {
+        return {
+            healthy: false,
+            latencyMs: Date.now() - start,
+            error: String(err),
+        };
+    }
+}
+//# sourceMappingURL=bulk-ingest.js.map

package/dist/cloud/db/drizzle.d.ts

@@ -8,6 +8,11 @@ import { Pool } from 'pg';
 import * as schema from './schema.js';
 export type { User, NewUser, GitHubInstallation, NewGitHubInstallation, Credential, NewCredential, Workspace, NewWorkspace, WorkspaceConfig, WorkspaceMember, NewWorkspaceMember, ProjectGroup, NewProjectGroup, CoordinatorAgentConfig, ProjectAgentConfig, Repository, NewRepository, LinkedDaemon, NewLinkedDaemon, Subscription, NewSubscription, UsageRecord, NewUsageRecord, AgentSession, NewAgentSession, AgentSummary, NewAgentSummary, } from './schema.js';
 export * from './schema.js';
+/**
+ * Get the raw connection pool for bulk operations.
+ * Use this for optimized bulk inserts that bypass the ORM.
+ */
+export declare function getRawPool(): Pool;
 export declare function getDb(): import("drizzle-orm/node-postgres").NodePgDatabase<Record<string, unknown>> & {
     $client: Pool;
 };
@@ -51,6 +56,7 @@ export interface WorkspaceQueries {
     findById(id: string): Promise<schema.Workspace | null>;
     findByUserId(userId: string): Promise<schema.Workspace[]>;
     findByCustomDomain(domain: string): Promise<schema.Workspace | null>;
+    findByRepoFullName(repoFullName: string): Promise<schema.Workspace | null>;
     findAll(): Promise<schema.Workspace[]>;
     create(data: schema.NewWorkspace): Promise<schema.Workspace>;
     update(id: string, data: Partial<Pick<schema.Workspace, 'name' | 'config'>>): Promise<void>;
@@ -101,6 +107,7 @@ export interface DaemonUpdate {
 export interface LinkedDaemonQueries {
     findById(id: string): Promise<schema.LinkedDaemon | null>;
     findByUserId(userId: string): Promise<schema.LinkedDaemon[]>;
+    findByWorkspaceId(workspaceId: string): Promise<schema.LinkedDaemon[]>;
     findByMachineId(userId: string, machineId: string): Promise<schema.LinkedDaemon | null>;
     findByApiKeyHash(apiKeyHash: string): Promise<schema.LinkedDaemon | null>;
     create(data: schema.NewLinkedDaemon): Promise<schema.LinkedDaemon>;
@@ -109,6 +116,7 @@ export interface LinkedDaemonQueries {
     delete(id: string): Promise<void>;
     markStale(): Promise<number>;
     getAllAgentsForUser(userId: string): Promise<DaemonAgentInfo[]>;
+    getAgentsForWorkspace(workspaceId: string): Promise<DaemonAgentInfo[]>;
     getPendingUpdates(id: string): Promise<DaemonUpdate[]>;
     queueUpdate(id: string, update: DaemonUpdate): Promise<void>;
     queueMessage(id: string, message: Record<string, unknown>): Promise<void>;
@@ -213,6 +221,31 @@ export interface CommentMentionQueries {
     markIgnored(id: string): Promise<void>;
 }
 export declare const commentMentionQueries: CommentMentionQueries;
+export interface MessageQuery {
+    workspaceId: string;
+    limit?: number;
+    offset?: number;
+    fromAgent?: string;
+    toAgent?: string;
+    thread?: string;
+    channel?: string;
+    sinceTs?: Date;
+    beforeTs?: Date;
+    includeExpired?: boolean;
+}
+export interface AgentMessageQueries {
+    create(data: schema.NewAgentMessage): Promise<schema.AgentMessage>;
+    createMany(data: schema.NewAgentMessage[]): Promise<schema.AgentMessage[]>;
+    findById(id: string): Promise<schema.AgentMessage | null>;
+    findByOriginalId(workspaceId: string, originalId: string): Promise<schema.AgentMessage | null>;
+    query(params: MessageQuery): Promise<schema.AgentMessage[]>;
+    getUnindexed(workspaceId: string, limit?: number): Promise<schema.AgentMessage[]>;
+    markIndexed(ids: string[]): Promise<void>;
+    deleteExpired(): Promise<number>;
+    countByWorkspace(workspaceId: string): Promise<number>;
+    getThreadMessages(workspaceId: string, thread: string, limit?: number): Promise<schema.AgentMessage[]>;
+}
+export declare const agentMessageQueries: AgentMessageQueries;
 export declare function runMigrations(): Promise<void>;
 export declare function closeDb(): Promise<void>;
 //# sourceMappingURL=drizzle.d.ts.map