@botbotgo/agent-harness 0.0.100 → 0.0.102

package/dist/package-version.d.ts

@@ -1 +1 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.99";
+export declare const AGENT_HARNESS_VERSION = "0.0.101";

package/dist/package-version.js

@@ -1 +1 @@
-export const AGENT_HARNESS_VERSION = "0.0.99";
+export const AGENT_HARNESS_VERSION = "0.0.101";

package/dist/persistence/sqlite-run-context-store.d.ts

@@ -0,0 +1,22 @@
+import type { InValue } from "@libsql/client";
+import type { TranscriptMessage } from "../contracts/types.js";
+import type { PersistedRunRequest, RecoveryIntent } from "./types.js";
+type SqlRow = Record<string, unknown>;
+type SqliteRunContextStoreDb = {
+    execute(sql: string, args?: InValue[]): Promise<void>;
+    selectOne(sql: string, args?: InValue[]): Promise<SqlRow | null>;
+    selectAll(sql: string, args?: InValue[]): Promise<SqlRow[]>;
+};
+export declare class SqliteRunContextStore {
+    private readonly db;
+    constructor(db: SqliteRunContextStoreDb);
+    saveRunRequest(threadId: string, runId: string, request: PersistedRunRequest): Promise<void>;
+    getRunRequest(threadId: string, runId: string): Promise<PersistedRunRequest | null>;
+    clearRunRequest(threadId: string, runId: string): Promise<void>;
+    appendThreadMessage(threadId: string, message: TranscriptMessage): Promise<void>;
+    listThreadMessages(threadId: string, limit?: number): Promise<TranscriptMessage[]>;
+    saveRecoveryIntent(threadId: string, runId: string, intent: RecoveryIntent): Promise<void>;
+    getRecoveryIntent(threadId: string, runId: string): Promise<RecoveryIntent | null>;
+    clearRecoveryIntent(threadId: string, runId: string): Promise<void>;
+}
+export {};

package/dist/persistence/sqlite-run-context-store.js

@@ -0,0 +1,64 @@
+function asString(value) {
+    return typeof value === "string" ? value : String(value ?? "");
+}
+function parseJson(value) {
+    return JSON.parse(asString(value));
+}
+function nowIso() {
+    return new Date(Date.now()).toISOString();
+}
+export class SqliteRunContextStore {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async saveRunRequest(threadId, runId, request) {
+        await this.db.execute(`INSERT OR REPLACE INTO run_requests
+       (run_id, thread_id, request_json, saved_at)
+       VALUES (?, ?, ?, ?)`, [runId, threadId, JSON.stringify(request), request.savedAt]);
+    }
+    async getRunRequest(threadId, runId) {
+        const row = await this.db.selectOne("SELECT request_json FROM run_requests WHERE thread_id = ? AND run_id = ?", [threadId, runId]);
+        return row ? parseJson(row.request_json) : null;
+    }
+    async clearRunRequest(threadId, runId) {
+        await this.db.execute("DELETE FROM run_requests WHERE thread_id = ? AND run_id = ?", [threadId, runId]);
+    }
+    async appendThreadMessage(threadId, message) {
+        await this.db.execute(`INSERT INTO thread_messages
+       (thread_id, role, content_json, run_id, created_at)
+       VALUES (?, ?, ?, ?, ?)`, [threadId, message.role, JSON.stringify(message.content), message.runId, message.createdAt]);
+    }
+    async listThreadMessages(threadId, limit = 12) {
+        const rows = await this.db.selectAll(`SELECT role, content_json, run_id, created_at
+       FROM (
+         SELECT role, content_json, run_id, created_at, id
+         FROM thread_messages
+         WHERE thread_id = ?
+         ORDER BY created_at DESC, id DESC
+         LIMIT ?
+       ) recent
+       ORDER BY created_at ASC, id ASC`, [threadId, limit]);
+        return rows.map((row) => ({
+            role: asString(row.role),
+            content: parseJson(row.content_json),
+            runId: asString(row.run_id),
+            createdAt: asString(row.created_at),
+        }));
+    }
+    async saveRecoveryIntent(threadId, runId, intent) {
+        const savedAt = typeof intent.savedAt === "string"
+            ? (intent.savedAt)
+            : nowIso();
+        await this.db.execute(`INSERT OR REPLACE INTO recovery_intents
+       (run_id, thread_id, intent_json, saved_at)
+       VALUES (?, ?, ?, ?)`, [runId, threadId, JSON.stringify(intent), savedAt]);
+    }
+    async getRecoveryIntent(threadId, runId) {
+        const row = await this.db.selectOne("SELECT intent_json FROM recovery_intents WHERE thread_id = ? AND run_id = ?", [threadId, runId]);
+        return row ? parseJson(row.intent_json) : null;
+    }
+    async clearRecoveryIntent(threadId, runId) {
+        await this.db.execute("DELETE FROM recovery_intents WHERE thread_id = ? AND run_id = ?", [threadId, runId]);
+    }
+}

package/dist/persistence/sqlite-run-queue-store.d.ts

@@ -0,0 +1,41 @@
+import type { InValue } from "@libsql/client";
+import type { PersistedRunControlRecord, PersistedRunQueueRecord } from "./types.js";
+type SqlRow = Record<string, unknown>;
+type SqliteRunQueueStoreDb = {
+    execute(sql: string, args?: InValue[]): Promise<void>;
+    selectOne(sql: string, args?: InValue[]): Promise<SqlRow | null>;
+    selectAll(sql: string, args?: InValue[]): Promise<SqlRow[]>;
+};
+export declare class SqliteRunQueueStore {
+    private readonly db;
+    constructor(db: SqliteRunQueueStoreDb);
+    private mapQueuedRun;
+    private mapRunControl;
+    enqueueRun(input: {
+        threadId: string;
+        runId: string;
+        priority?: number;
+        queueKey?: string | null;
+        availableAt?: string;
+    }): Promise<void>;
+    getQueuedRun(runId: string): Promise<PersistedRunQueueRecord | null>;
+    claimQueuedRun(input: {
+        threadId: string;
+        runId: string;
+        workerId: string;
+        claimedAt?: string;
+        leaseExpiresAt: string;
+    }): Promise<PersistedRunQueueRecord>;
+    renewRunLease(input: {
+        runId: string;
+        workerId: string;
+        heartbeatAt?: string;
+        leaseExpiresAt: string;
+    }): Promise<void>;
+    releaseRunClaim(runId: string): Promise<void>;
+    listExpiredClaimedRuns(cutoffIso: string): Promise<PersistedRunQueueRecord[]>;
+    getRunControl(runId: string): Promise<PersistedRunControlRecord | null>;
+    requestRunCancel(runId: string, reason?: string): Promise<PersistedRunControlRecord>;
+    clearRunCancel(runId: string): Promise<void>;
+}
+export {};

package/dist/persistence/sqlite-run-queue-store.js

@@ -0,0 +1,120 @@
+function asString(value) {
+    return typeof value === "string" ? value : String(value ?? "");
+}
+function asNullableString(value) {
+    return value == null ? null : asString(value);
+}
+function asBoolean(value) {
+    return value === true || value === 1 || value === "1";
+}
+function nowIso() {
+    return new Date(Date.now()).toISOString();
+}
+export class SqliteRunQueueStore {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    mapQueuedRun(row) {
+        return {
+            runId: asString(row.run_id),
+            threadId: asString(row.thread_id),
+            priority: Number(row.priority ?? 0),
+            queueKey: asNullableString(row.queue_key),
+            enqueuedAt: asString(row.enqueued_at),
+            availableAt: asString(row.available_at),
+            claimedBy: asNullableString(row.claimed_by),
+            claimedAt: asNullableString(row.claimed_at),
+            leaseExpiresAt: asNullableString(row.lease_expires_at),
+            attemptCount: Number(row.attempt_count ?? 0),
+            lastError: asNullableString(row.last_error),
+        };
+    }
+    mapRunControl(row) {
+        return {
+            runId: asString(row.run_id),
+            cancelRequested: asBoolean(row.cancel_requested),
+            cancelReason: asNullableString(row.cancel_reason),
+            cancelRequestedAt: asNullableString(row.cancel_requested_at),
+            heartbeatAt: asNullableString(row.heartbeat_at),
+            workerId: asNullableString(row.worker_id),
+            workerStartedAt: asNullableString(row.worker_started_at),
+        };
+    }
+    async enqueueRun(input) {
+        const enqueuedAt = nowIso();
+        await this.db.execute(`INSERT OR REPLACE INTO run_queue
+       (run_id, thread_id, priority, queue_key, enqueued_at, available_at, claimed_by, claimed_at, lease_expires_at, attempt_count, last_error)
+       VALUES (?, ?, ?, ?, ?, ?, NULL, NULL, NULL, COALESCE((SELECT attempt_count FROM run_queue WHERE run_id = ?), 0), NULL)`, [
+            input.runId,
+            input.threadId,
+            input.priority ?? 0,
+            input.queueKey ?? null,
+            enqueuedAt,
+            input.availableAt ?? enqueuedAt,
+            input.runId,
+        ]);
+    }
+    async getQueuedRun(runId) {
+        const row = await this.db.selectOne("SELECT * FROM run_queue WHERE run_id = ?", [runId]);
+        return row ? this.mapQueuedRun(row) : null;
+    }
+    async claimQueuedRun(input) {
+        const claimedAt = input.claimedAt ?? nowIso();
+        await this.db.execute(`UPDATE run_queue
+       SET claimed_by = ?, claimed_at = ?, lease_expires_at = ?, attempt_count = attempt_count + 1
+       WHERE run_id = ? AND thread_id = ?`, [input.workerId, claimedAt, input.leaseExpiresAt, input.runId, input.threadId]);
+        await this.db.execute(`UPDATE run_control
+       SET heartbeat_at = ?, worker_id = ?, worker_started_at = COALESCE(worker_started_at, ?)
+       WHERE run_id = ?`, [claimedAt, input.workerId, claimedAt, input.runId]);
+        const claimed = await this.getQueuedRun(input.runId);
+        if (!claimed) {
+            throw new Error(`Missing queued run ${input.runId}`);
+        }
+        return claimed;
+    }
+    async renewRunLease(input) {
+        const heartbeatAt = input.heartbeatAt ?? nowIso();
+        await this.db.execute(`UPDATE run_queue
+       SET lease_expires_at = ?, claimed_by = COALESCE(claimed_by, ?), claimed_at = COALESCE(claimed_at, ?)
+       WHERE run_id = ?`, [input.leaseExpiresAt, input.workerId, heartbeatAt, input.runId]);
+        await this.db.execute(`UPDATE run_control
+       SET heartbeat_at = ?, worker_id = ?, worker_started_at = COALESCE(worker_started_at, ?)
+       WHERE run_id = ?`, [heartbeatAt, input.workerId, heartbeatAt, input.runId]);
+    }
+    async releaseRunClaim(runId) {
+        await this.db.execute("DELETE FROM run_queue WHERE run_id = ?", [runId]);
+        await this.db.execute(`UPDATE run_control
+       SET heartbeat_at = NULL, worker_id = NULL, worker_started_at = NULL
+       WHERE run_id = ?`, [runId]);
+    }
+    async listExpiredClaimedRuns(cutoffIso) {
+        const rows = await this.db.selectAll(`SELECT *
+       FROM run_queue
+       WHERE claimed_by IS NOT NULL
+         AND lease_expires_at IS NOT NULL
+         AND lease_expires_at <= ?
+       ORDER BY lease_expires_at ASC, run_id ASC`, [cutoffIso]);
+        return rows.map((row) => this.mapQueuedRun(row));
+    }
+    async getRunControl(runId) {
+        const row = await this.db.selectOne("SELECT * FROM run_control WHERE run_id = ?", [runId]);
+        return row ? this.mapRunControl(row) : null;
+    }
+    async requestRunCancel(runId, reason) {
+        const requestedAt = nowIso();
+        await this.db.execute(`UPDATE run_control
+       SET cancel_requested = 1, cancel_reason = ?, cancel_requested_at = ?
+       WHERE run_id = ?`, [reason ?? null, requestedAt, runId]);
+        const updated = await this.getRunControl(runId);
+        if (!updated) {
+            throw new Error(`Missing run control for ${runId}`);
+        }
+        return updated;
+    }
+    async clearRunCancel(runId) {
+        await this.db.execute(`UPDATE run_control
+       SET cancel_requested = 0, cancel_reason = NULL, cancel_requested_at = NULL
+       WHERE run_id = ?`, [runId]);
+    }
+}

package/dist/persistence/sqlite-store.d.ts

@@ -4,6 +4,8 @@ export declare function listProtectedCheckpointThreadIds(dbPath: string): Promis
 export declare class SqlitePersistence implements RuntimePersistence {
     private readonly runRoot;
     private readonly dbPath;
+    private readonly runContextStore;
+    private readonly runQueueStore;
     private client;
     private initialized;
     private initialization;
@@ -77,8 +79,6 @@ export declare class SqlitePersistence implements RuntimePersistence {
     saveRecoveryIntent(threadId: string, runId: string, intent: RecoveryIntent): Promise<void>;
     getRecoveryIntent(threadId: string, runId: string): Promise<RecoveryIntent | null>;
     clearRecoveryIntent(threadId: string, runId: string): Promise<void>;
-    private mapQueuedRun;
-    private mapRunControl;
     enqueueRun(input: {
         threadId: string;
         runId: string;

package/dist/persistence/sqlite-store.js

@@ -2,6 +2,8 @@ import path from "node:path";
 import { mkdir, rm } from "node:fs/promises";
 import { createClient } from "@libsql/client";
 import { fileExists, readJson, writeJson } from "../utils/fs.js";
+import { SqliteRunContextStore } from "./sqlite-run-context-store.js";
+import { SqliteRunQueueStore } from "./sqlite-run-queue-store.js";
 const RUNTIME_SQLITE_SCHEMA_VERSION = 2;
 const RUNTIME_SQLITE_SCHEMA_FAMILY = "agent-harness-runtime";
 function asRow(value) {
@@ -53,12 +55,24 @@ export async function listProtectedCheckpointThreadIds(dbPath) {
 export class SqlitePersistence {
     runRoot;
     dbPath;
+    runContextStore;
+    runQueueStore;
     client = null;
     initialized = false;
     initialization = null;
     constructor(runRoot, dbFile = "runtime.sqlite") {
         this.runRoot = runRoot;
         this.dbPath = path.join(runRoot, dbFile);
+        this.runContextStore = new SqliteRunContextStore({
+            execute: (sql, args) => this.execute(sql, args),
+            selectOne: (sql, args) => this.selectOne(sql, args),
+            selectAll: (sql, args) => this.selectAll(sql, args),
+        });
+        this.runQueueStore = new SqliteRunQueueStore({
+            execute: (sql, args) => this.execute(sql, args),
+            selectOne: (sql, args) => this.selectOne(sql, args),
+            selectAll: (sql, args) => this.selectAll(sql, args),
+        });
     }
     async getClient() {
         if (!this.client) {
@@ -597,16 +611,13 @@ export class SqlitePersistence {
         return true;
     }
     async saveRunRequest(threadId, runId, request) {
-        await this.execute(`INSERT OR REPLACE INTO run_requests
-       (run_id, thread_id, request_json, saved_at)
-       VALUES (?, ?, ?, ?)`, [runId, threadId, JSON.stringify(request), request.savedAt]);
+        await this.runContextStore.saveRunRequest(threadId, runId, request);
     }
     async getRunRequest(threadId, runId) {
-        const row = await this.selectOne("SELECT request_json FROM run_requests WHERE thread_id = ? AND run_id = ?", [threadId, runId]);
-        return row ? parseJson(row.request_json) : null;
+        return this.runContextStore.getRunRequest(threadId, runId);
     }
     async clearRunRequest(threadId, runId) {
-        await this.execute("DELETE FROM run_requests WHERE thread_id = ? AND run_id = ?", [threadId, runId]);
+        await this.runContextStore.clearRunRequest(threadId, runId);
     }
     async createApproval(record) {
         await this.execute(`INSERT OR REPLACE INTO approvals
@@ -666,143 +677,46 @@ export class SqlitePersistence {
         };
     }
     async appendThreadMessage(threadId, message) {
-        await this.execute(`INSERT INTO thread_messages
-       (thread_id, role, content_json, run_id, created_at)
-       VALUES (?, ?, ?, ?, ?)`, [threadId, message.role, JSON.stringify(message.content), message.runId, message.createdAt]);
+        await this.runContextStore.appendThreadMessage(threadId, message);
     }
     async listThreadMessages(threadId, limit = 12) {
-        const rows = await this.selectAll(`SELECT role, content_json, run_id, created_at
-       FROM (
-         SELECT role, content_json, run_id, created_at, id
-         FROM thread_messages
-         WHERE thread_id = ?
-         ORDER BY created_at DESC, id DESC
-         LIMIT ?
-       ) recent
-       ORDER BY created_at ASC, id ASC`, [threadId, limit]);
-        return rows.map((row) => ({
-            role: asString(row.role),
-            content: parseJson(row.content_json),
-            runId: asString(row.run_id),
-            createdAt: asString(row.created_at),
-        }));
+        return this.runContextStore.listThreadMessages(threadId, limit);
     }
     async saveRecoveryIntent(threadId, runId, intent) {
-        const savedAt = typeof intent.savedAt === "string"
-            ? (intent.savedAt)
-            : nowIso();
-        await this.execute(`INSERT OR REPLACE INTO recovery_intents
-       (run_id, thread_id, intent_json, saved_at)
-       VALUES (?, ?, ?, ?)`, [runId, threadId, JSON.stringify(intent), savedAt]);
+        await this.runContextStore.saveRecoveryIntent(threadId, runId, intent);
     }
     async getRecoveryIntent(threadId, runId) {
-        const row = await this.selectOne("SELECT intent_json FROM recovery_intents WHERE thread_id = ? AND run_id = ?", [threadId, runId]);
-        return row ? parseJson(row.intent_json) : null;
+        return this.runContextStore.getRecoveryIntent(threadId, runId);
     }
     async clearRecoveryIntent(threadId, runId) {
-        await this.execute("DELETE FROM recovery_intents WHERE thread_id = ? AND run_id = ?", [threadId, runId]);
-    }
-    mapQueuedRun(row) {
-        return {
-            runId: asString(row.run_id),
-            threadId: asString(row.thread_id),
-            priority: Number(row.priority ?? 0),
-            queueKey: asNullableString(row.queue_key),
-            enqueuedAt: asString(row.enqueued_at),
-            availableAt: asString(row.available_at),
-            claimedBy: asNullableString(row.claimed_by),
-            claimedAt: asNullableString(row.claimed_at),
-            leaseExpiresAt: asNullableString(row.lease_expires_at),
-            attemptCount: Number(row.attempt_count ?? 0),
-            lastError: asNullableString(row.last_error),
-        };
-    }
-    mapRunControl(row) {
-        return {
-            runId: asString(row.run_id),
-            cancelRequested: asBoolean(row.cancel_requested),
-            cancelReason: asNullableString(row.cancel_reason),
-            cancelRequestedAt: asNullableString(row.cancel_requested_at),
-            heartbeatAt: asNullableString(row.heartbeat_at),
-            workerId: asNullableString(row.worker_id),
-            workerStartedAt: asNullableString(row.worker_started_at),
-        };
+        await this.runContextStore.clearRecoveryIntent(threadId, runId);
     }
     async enqueueRun(input) {
-        const enqueuedAt = nowIso();
-        await this.execute(`INSERT OR REPLACE INTO run_queue
-       (run_id, thread_id, priority, queue_key, enqueued_at, available_at, claimed_by, claimed_at, lease_expires_at, attempt_count, last_error)
-       VALUES (?, ?, ?, ?, ?, ?, NULL, NULL, NULL, COALESCE((SELECT attempt_count FROM run_queue WHERE run_id = ?), 0), NULL)`, [
-            input.runId,
-            input.threadId,
-            input.priority ?? 0,
-            input.queueKey ?? null,
-            enqueuedAt,
-            input.availableAt ?? enqueuedAt,
-            input.runId,
-        ]);
+        await this.runQueueStore.enqueueRun(input);
     }
     async getQueuedRun(runId) {
-        const row = await this.selectOne("SELECT * FROM run_queue WHERE run_id = ?", [runId]);
-        return row ? this.mapQueuedRun(row) : null;
+        return this.runQueueStore.getQueuedRun(runId);
     }
     async claimQueuedRun(input) {
-        const claimedAt = input.claimedAt ?? nowIso();
-        await this.execute(`UPDATE run_queue
-       SET claimed_by = ?, claimed_at = ?, lease_expires_at = ?, attempt_count = attempt_count + 1
-       WHERE run_id = ? AND thread_id = ?`, [input.workerId, claimedAt, input.leaseExpiresAt, input.runId, input.threadId]);
-        await this.execute(`UPDATE run_control
-       SET heartbeat_at = ?, worker_id = ?, worker_started_at = COALESCE(worker_started_at, ?)
-       WHERE run_id = ?`, [claimedAt, input.workerId, claimedAt, input.runId]);
-        const claimed = await this.getQueuedRun(input.runId);
-        if (!claimed) {
-            throw new Error(`Missing queued run ${input.runId}`);
-        }
-        return claimed;
+        return this.runQueueStore.claimQueuedRun(input);
     }
     async renewRunLease(input) {
-        const heartbeatAt = input.heartbeatAt ?? nowIso();
-        await this.execute(`UPDATE run_queue
-       SET lease_expires_at = ?, claimed_by = COALESCE(claimed_by, ?), claimed_at = COALESCE(claimed_at, ?)
-       WHERE run_id = ?`, [input.leaseExpiresAt, input.workerId, heartbeatAt, input.runId]);
-        await this.execute(`UPDATE run_control
-       SET heartbeat_at = ?, worker_id = ?, worker_started_at = COALESCE(worker_started_at, ?)
-       WHERE run_id = ?`, [heartbeatAt, input.workerId, heartbeatAt, input.runId]);
+        await this.runQueueStore.renewRunLease(input);
     }
     async releaseRunClaim(runId) {
-        await this.execute("DELETE FROM run_queue WHERE run_id = ?", [runId]);
-        await this.execute(`UPDATE run_control
-       SET heartbeat_at = NULL, worker_id = NULL, worker_started_at = NULL
-       WHERE run_id = ?`, [runId]);
+        await this.runQueueStore.releaseRunClaim(runId);
     }
     async listExpiredClaimedRuns(cutoffIso) {
-        const rows = await this.selectAll(`SELECT *
-       FROM run_queue
-       WHERE claimed_by IS NOT NULL
-         AND lease_expires_at IS NOT NULL
-         AND lease_expires_at <= ?
-       ORDER BY lease_expires_at ASC, run_id ASC`, [cutoffIso]);
-        return rows.map((row) => this.mapQueuedRun(row));
+        return this.runQueueStore.listExpiredClaimedRuns(cutoffIso);
     }
     async getRunControl(runId) {
-        const row = await this.selectOne("SELECT * FROM run_control WHERE run_id = ?", [runId]);
-        return row ? this.mapRunControl(row) : null;
+        return this.runQueueStore.getRunControl(runId);
     }
     async requestRunCancel(runId, reason) {
-        const now = nowIso();
-        await this.execute(`UPDATE run_control
-       SET cancel_requested = 1, cancel_reason = ?, cancel_requested_at = ?
-       WHERE run_id = ?`, [reason ?? null, now, runId]);
-        const updated = await this.getRunControl(runId);
-        if (!updated) {
-            throw new Error(`Missing run control for ${runId}`);
-        }
-        return updated;
+        return this.runQueueStore.requestRunCancel(runId, reason);
     }
     async clearRunCancel(runId) {
-        await this.execute(`UPDATE run_control
-       SET cancel_requested = 0, cancel_reason = NULL, cancel_requested_at = NULL
-       WHERE run_id = ?`, [runId]);
+        await this.runQueueStore.clearRunCancel(runId);
     }
     async readArtifact(threadId, runId, artifactPath) {
         const filePath = path.join(this.runDir(threadId, runId), artifactPath);

package/dist/resource/mcp-tool-support.d.ts

@@ -0,0 +1,21 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import type { RuntimeAdapterOptions, WorkspaceBundle } from "../contracts/types.js";
+export type McpServerConfig = {
+    transport?: "stdio" | "http" | "sse" | "websocket";
+    command?: string;
+    args?: string[];
+    env?: Record<string, string>;
+    cwd?: string;
+    url?: string;
+    token?: string;
+    headers?: Record<string, string>;
+};
+export type McpToolDescriptor = {
+    name: string;
+    description?: string;
+    inputSchema?: Record<string, unknown>;
+};
+export declare function readMcpServerConfig(workspace: WorkspaceBundle, tool: WorkspaceBundle["tools"] extends Map<any, infer T> ? T : never): McpServerConfig | null;
+export declare function getOrCreateMcpClient(config: McpServerConfig): Promise<Client>;
+export declare function listRemoteMcpTools(config: McpServerConfig): Promise<McpToolDescriptor[]>;
+export declare function createMcpToolResolver(workspace: WorkspaceBundle): NonNullable<RuntimeAdapterOptions["toolResolver"]>;