agents 0.13.0 → 0.13.1

package/dist/index.js

@@ -120,7 +120,7 @@ const DEFAULT_KEEP_ALIVE_INTERVAL_MS = 3e4;
 * The constructor stores this as a row in cf_agents_state and checks it
 * on wake to skip DDL on established DOs.
 */
-const CURRENT_SCHEMA_VERSION = 7;
+const CURRENT_SCHEMA_VERSION = 8;
 const SCHEMA_VERSION_ROW_ID = "cf_schema_version";
 const STATE_ROW_ID = "cf_state_row_id";
 const STATE_WAS_CHANGED = "cf_state_was_changed";
@@ -549,6 +549,32 @@ var Agent = class Agent extends Server {
 			this.sql`
         CREATE INDEX IF NOT EXISTS idx_facet_runs_owner_path_key
         ON cf_agents_facet_runs(owner_path_key)
+      `;
+			this.sql`
+        CREATE TABLE IF NOT EXISTS cf_agents_fibers (
+          fiber_id TEXT PRIMARY KEY,
+          idempotency_key TEXT UNIQUE,
+          name TEXT NOT NULL,
+          status TEXT NOT NULL,
+          snapshot TEXT,
+          metadata_json TEXT,
+          error_message TEXT,
+          created_at INTEGER NOT NULL,
+          started_at INTEGER,
+          completed_at INTEGER
+        )
+      `;
+			this.sql`
+        CREATE INDEX IF NOT EXISTS idx_fibers_status_created
+        ON cf_agents_fibers(status, created_at, fiber_id)
+      `;
+			this.sql`
+        CREATE INDEX IF NOT EXISTS idx_fibers_name_status_created
+        ON cf_agents_fibers(name, status, created_at, fiber_id)
+      `;
+			this.sql`
+        CREATE INDEX IF NOT EXISTS idx_fibers_status_completed
+        ON cf_agents_fibers(status, completed_at, created_at)
       `;
 			this.sql`
         CREATE TABLE IF NOT EXISTS cf_agent_tool_runs (
@@ -595,6 +621,9 @@ var Agent = class Agent extends Server {
 		this._keepAliveRefs = 0;
 		this._facetKeepAliveTokens = /* @__PURE__ */ new Set();
 		this._runFiberActiveFibers = /* @__PURE__ */ new Set();
+		this._managedFiberAbortControllers = /* @__PURE__ */ new Map();
+		this._managedFiberExecutions = /* @__PURE__ */ new Map();
+		this._managedFiberTerminalWaiters = /* @__PURE__ */ new Map();
 		this._runFiberRecoveryInProgress = false;
 		this._ParentClass = Object.getPrototypeOf(this).constructor;
 		this.initialState = DEFAULT_STATE;
@@ -2211,6 +2240,295 @@ var Agent = class Agent extends Server {
 			dispose();
 		}
 	}
+	_isTerminalFiberStatus(status) {
+		return status === "completed" || status === "aborted" || status === "interrupted" || status === "error";
+	}
+	_notifyManagedFiberTerminal(fiberId) {
+		const row = this._readFiber(fiberId);
+		if (row && !this._isTerminalFiberStatus(row.status)) return;
+		const waiters = this._managedFiberTerminalWaiters.get(fiberId);
+		if (!waiters) return;
+		this._managedFiberTerminalWaiters.delete(fiberId);
+		for (const resolve of waiters) resolve();
+	}
+	_waitForManagedFiberTerminal(fiberId) {
+		const row = this._readFiber(fiberId);
+		if (!row || this._isTerminalFiberStatus(row.status)) return Promise.resolve();
+		return new Promise((resolve) => {
+			let waiters = this._managedFiberTerminalWaiters.get(fiberId);
+			if (!waiters) {
+				waiters = /* @__PURE__ */ new Set();
+				this._managedFiberTerminalWaiters.set(fiberId, waiters);
+			}
+			waiters.add(resolve);
+		});
+	}
+	_normalizeFiberStatusFilter(status) {
+		if (!status) return null;
+		return new Set(Array.isArray(status) ? status : [status]);
+	}
+	_parseFiberJsonObject(value) {
+		if (value === null) return null;
+		try {
+			const parsed = JSON.parse(value);
+			if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) return parsed;
+		} catch {}
+		return null;
+	}
+	_parseFiberSnapshot(value) {
+		if (value === null) return void 0;
+		try {
+			return JSON.parse(value);
+		} catch {
+			return;
+		}
+	}
+	_fiberErrorMessage(error) {
+		return error instanceof Error ? error.message : String(error);
+	}
+	_stringifyFiberSnapshot(snapshot) {
+		return snapshot === void 0 ? null : JSON.stringify(snapshot);
+	}
+	_fiberRecoveryErrorMessage(result) {
+		if (result.status === "error") return result.error === void 0 ? null : this._fiberErrorMessage(result.error);
+		if (result.status === "aborted" || result.status === "interrupted") return result.reason ?? null;
+		return null;
+	}
+	_applyManagedFiberRecoveryResult(fiberId, result) {
+		const completedAt = Date.now();
+		const snapshot = this._stringifyFiberSnapshot(result.snapshot);
+		const errorMessage = this._fiberRecoveryErrorMessage(result);
+		const metadata = result.status === "completed" && result.metadata !== void 0 ? JSON.stringify(result.metadata) : void 0;
+		if (metadata !== void 0) {
+			this.sql`
+        UPDATE cf_agents_fibers
+        SET status = ${result.status},
+            snapshot = COALESCE(${snapshot}, snapshot),
+            metadata_json = ${metadata},
+            error_message = ${errorMessage},
+            completed_at = ${completedAt}
+        WHERE fiber_id = ${fiberId}
+          AND status = 'interrupted'
+      `;
+			this._notifyManagedFiberTerminal(fiberId);
+			return;
+		}
+		this.sql`
+      UPDATE cf_agents_fibers
+      SET status = ${result.status},
+          snapshot = COALESCE(${snapshot}, snapshot),
+          error_message = ${errorMessage},
+          completed_at = ${completedAt}
+      WHERE fiber_id = ${fiberId}
+        AND status = 'interrupted'
+    `;
+		this._notifyManagedFiberTerminal(fiberId);
+	}
+	_settleManagedFiberExecution(fiberId, outcome, signal) {
+		const completedAt = Date.now();
+		if (outcome.ok) {
+			this.sql`
+        UPDATE cf_agents_fibers
+        SET status = 'completed', completed_at = ${completedAt}
+        WHERE fiber_id = ${fiberId} AND status = 'running'
+      `;
+			this._notifyManagedFiberTerminal(fiberId);
+			return;
+		}
+		const message = this._fiberErrorMessage(outcome.error);
+		const status = signal.aborted ? "aborted" : "error";
+		this.sql`
+      UPDATE cf_agents_fibers
+      SET status = ${status},
+          error_message = ${message},
+          completed_at = ${completedAt}
+      WHERE fiber_id = ${fiberId} AND status = 'running'
+    `;
+		this._notifyManagedFiberTerminal(fiberId);
+	}
+	_parseFiberRecoverySnapshot(fiberId, snapshotText) {
+		if (!snapshotText) return null;
+		try {
+			return JSON.parse(snapshotText);
+		} catch {
+			console.warn(`[Agent] Corrupted snapshot for fiber ${fiberId}, treating as null`);
+			return null;
+		}
+	}
+	async _runFiberRecoveryHook(ctx, managedRow) {
+		try {
+			if (!await this._handleInternalFiberRecovery(ctx)) {
+				const recoveryResult = await this.onFiberRecovered(ctx);
+				if (managedRow && recoveryResult) this._applyManagedFiberRecoveryResult(ctx.id, recoveryResult);
+			}
+		} catch (e) {
+			if (managedRow) this.sql`
+          UPDATE cf_agents_fibers
+          SET error_message = ${this._fiberErrorMessage(e)}
+          WHERE fiber_id = ${ctx.id}
+            AND status = 'interrupted'
+        `;
+			console.error(`[Agent] Fiber recovery failed for "${ctx.name}" (${ctx.id}):`, e);
+		}
+	}
+	_fiberInspectionFromRow(row) {
+		const snapshot = this._parseFiberSnapshot(row.snapshot);
+		const inspection = {
+			fiberId: row.fiber_id,
+			name: row.name,
+			status: row.status,
+			createdAt: row.created_at
+		};
+		if (row.idempotency_key !== null) inspection.idempotencyKey = row.idempotency_key;
+		if (snapshot !== void 0) inspection.snapshot = snapshot;
+		if (row.error_message !== null) inspection.error = row.error_message;
+		const metadata = this._parseFiberJsonObject(row.metadata_json);
+		if (metadata !== null) inspection.metadata = metadata;
+		if (row.started_at !== null) inspection.startedAt = row.started_at;
+		if (row.completed_at !== null) inspection.settledAt = row.completed_at;
+		return inspection;
+	}
+	async _waitForManagedFiber(fiberId) {
+		const row = this._readFiber(fiberId);
+		if (!row || this._isTerminalFiberStatus(row.status)) return row ? this._fiberInspectionFromRow(row) : null;
+		if (this._managedFiberExecutions.has(fiberId)) {
+			await this._waitForManagedFiberTerminal(fiberId);
+			return this.inspectFiber(fiberId);
+		}
+		await this._checkRunFibers();
+		await this._waitForManagedFiberTerminal(fiberId);
+		return this.inspectFiber(fiberId);
+	}
+	_readFiber(fiberId) {
+		return this.sql`
+      SELECT fiber_id, idempotency_key, name, status, snapshot, metadata_json,
+             error_message, created_at, started_at, completed_at
+      FROM cf_agents_fibers
+      WHERE fiber_id = ${fiberId}
+      LIMIT 1
+    `[0] ?? null;
+	}
+	_readFiberByKey(idempotencyKey) {
+		return this.sql`
+      SELECT fiber_id, idempotency_key, name, status, snapshot, metadata_json,
+             error_message, created_at, started_at, completed_at
+      FROM cf_agents_fibers
+      WHERE idempotency_key = ${idempotencyKey}
+      LIMIT 1
+    `[0] ?? null;
+	}
+	_listFiberRows(options) {
+		const limit = Math.min(Math.max(options?.limit ?? 50, 1), 100);
+		const statuses = this._normalizeFiberStatusFilter(options?.status);
+		if (statuses) return [...statuses].flatMap((status) => this._listFiberRowsByStatus(status, limit, options?.name)).sort((a, b) => b.created_at === a.created_at ? b.fiber_id.localeCompare(a.fiber_id) : b.created_at - a.created_at).slice(0, limit);
+		if (options?.name) return this.sql`
+        SELECT fiber_id, idempotency_key, name, status, snapshot, metadata_json,
+               error_message, created_at, started_at, completed_at
+        FROM cf_agents_fibers
+        WHERE name = ${options.name}
+        ORDER BY created_at DESC, fiber_id DESC
+        LIMIT ${limit}
+      `;
+		return this.sql`
+      SELECT fiber_id, idempotency_key, name, status, snapshot, metadata_json,
+             error_message, created_at, started_at, completed_at
+      FROM cf_agents_fibers
+      ORDER BY created_at DESC, fiber_id DESC
+      LIMIT ${limit}
+    `;
+	}
+	_listFiberRowsByStatus(status, limit, name) {
+		if (name) return this.sql`
+        SELECT fiber_id, idempotency_key, name, status, snapshot, metadata_json,
+               error_message, created_at, started_at, completed_at
+        FROM cf_agents_fibers
+        WHERE status = ${status} AND name = ${name}
+        ORDER BY created_at DESC, fiber_id DESC
+        LIMIT ${limit}
+      `;
+		return this.sql`
+      SELECT fiber_id, idempotency_key, name, status, snapshot, metadata_json,
+             error_message, created_at, started_at, completed_at
+      FROM cf_agents_fibers
+      WHERE status = ${status}
+      ORDER BY created_at DESC, fiber_id DESC
+      LIMIT ${limit}
+    `;
+	}
+	async inspectFiber(fiberId) {
+		const row = this._readFiber(fiberId);
+		return row ? this._fiberInspectionFromRow(row) : null;
+	}
+	async inspectFiberByKey(idempotencyKey) {
+		const row = this._readFiberByKey(idempotencyKey);
+		return row ? this._fiberInspectionFromRow(row) : null;
+	}
+	async listFibers(options) {
+		return this._listFiberRows(options).map((row) => this._fiberInspectionFromRow(row));
+	}
+	async cancelFiber(fiberId, reason) {
+		const row = this._readFiber(fiberId);
+		if (!row || this._isTerminalFiberStatus(row.status)) return false;
+		const now = Date.now();
+		this.sql`
+      UPDATE cf_agents_fibers
+      SET status = 'aborted',
+          error_message = ${reason ?? null},
+          completed_at = ${now}
+      WHERE fiber_id = ${fiberId}
+        AND status IN ('pending', 'running')
+    `;
+		this._managedFiberAbortControllers.get(fiberId)?.abort(reason);
+		this._notifyManagedFiberTerminal(fiberId);
+		return true;
+	}
+	async cancelFiberByKey(idempotencyKey, reason) {
+		const row = this._readFiberByKey(idempotencyKey);
+		return row ? this.cancelFiber(row.fiber_id, reason) : false;
+	}
+	async resolveFiber(fiberId, result) {
+		const row = this._readFiber(fiberId);
+		if (!row || row.status !== "interrupted") return false;
+		this._applyManagedFiberRecoveryResult(fiberId, result);
+		return true;
+	}
+	async deleteFibers(options) {
+		const terminalStatuses = [...this._normalizeFiberStatusFilter(options?.status) ?? new Set([
+			"completed",
+			"aborted",
+			"error"
+		])].filter((status) => this._isTerminalFiberStatus(status));
+		if (terminalStatuses.length === 0) return 0;
+		const limit = Math.min(Math.max(options?.limit ?? 100, 1), 500);
+		const settledBefore = options?.settledBefore?.getTime();
+		const rows = terminalStatuses.flatMap((status) => this._listTerminalFiberRowsForDelete(status, limit, settledBefore)).sort((a, b) => a.completed_at === b.completed_at ? a.created_at - b.created_at : (a.completed_at ?? 0) - (b.completed_at ?? 0)).slice(0, limit);
+		for (const row of rows) this.sql`
+        DELETE FROM cf_agents_fibers
+        WHERE fiber_id = ${row.fiber_id}
+          AND status IN ('completed', 'aborted', 'interrupted', 'error')
+      `;
+		return rows.length;
+	}
+	_listTerminalFiberRowsForDelete(status, limit, settledBefore) {
+		if (settledBefore !== void 0) return this.sql`
+        SELECT fiber_id, idempotency_key, name, status, snapshot, metadata_json,
+               error_message, created_at, started_at, completed_at
+        FROM cf_agents_fibers
+        WHERE status = ${status}
+          AND completed_at IS NOT NULL
+          AND completed_at < ${settledBefore}
+        ORDER BY completed_at ASC, created_at ASC
+        LIMIT ${limit}
+      `;
+		return this.sql`
+      SELECT fiber_id, idempotency_key, name, status, snapshot, metadata_json,
+             error_message, created_at, started_at, completed_at
+      FROM cf_agents_fibers
+      WHERE status = ${status}
+      ORDER BY completed_at ASC, created_at ASC
+      LIMIT ${limit}
+    `;
+	}
 	/**
 	* Run a function as a durable fiber. The fiber is registered in SQLite
 	* before execution, checkpointable during execution via `ctx.stash()`,
@@ -2225,7 +2543,100 @@ var Agent = class Agent extends Server {
 	* @returns The return value of fn
 	*/
 	async runFiber(name, fn) {
-		const id = nanoid();
+		return this._runFiberInternal(nanoid(), name, fn);
+	}
+	async startFiber(name, fn, options) {
+		const fiberId = options?.fiberId ?? nanoid();
+		const idempotencyKey = options?.idempotencyKey;
+		if (options?.fiberId !== void 0 && options.fiberId.trim() === "") throw new Error("fiberId must not be blank");
+		if (options?.idempotencyKey !== void 0 && options.idempotencyKey.trim() === "") throw new Error("idempotencyKey must not be blank");
+		const existingById = this._readFiber(fiberId);
+		const existingByKey = idempotencyKey ? this._readFiberByKey(idempotencyKey) : null;
+		if (existingById && existingByKey && existingById.fiber_id !== existingByKey.fiber_id) throw new Error("fiberId and idempotencyKey refer to different fibers");
+		if (existingByKey && options?.fiberId && existingByKey.fiber_id !== fiberId) throw new Error("fiberId and idempotencyKey refer to different fibers");
+		const existing = existingById ?? existingByKey;
+		if (existing) {
+			if (options?.waitForCompletion && !this._isTerminalFiberStatus(existing.status)) {
+				const waited = await this._waitForManagedFiber(existing.fiber_id);
+				if (waited) return {
+					...waited,
+					accepted: false
+				};
+				throw new Error(`Fiber ${existing.fiber_id} no longer exists`);
+			}
+			return {
+				...this._fiberInspectionFromRow(existing),
+				accepted: false
+			};
+		}
+		const now = Date.now();
+		this.sql`
+      INSERT INTO cf_agents_fibers
+        (fiber_id, idempotency_key, name, status, snapshot, metadata_json,
+         error_message, created_at, started_at, completed_at)
+      VALUES
+        (${fiberId}, ${idempotencyKey ?? null}, ${name}, 'pending', NULL,
+         ${options?.metadata ? JSON.stringify(options.metadata) : null}, NULL,
+         ${now}, NULL, NULL)
+    `;
+		const row = this._readFiber(fiberId);
+		if (!row) throw new Error(`Failed to create fiber ${fiberId}`);
+		const execution = this._executeManagedFiber(fiberId, name, fn).catch((error) => {
+			console.error(`[Agent] Managed fiber "${name}" (${fiberId}) failed:`, error);
+		}).finally(() => {
+			if (this._managedFiberExecutions.get(fiberId) === execution) this._managedFiberExecutions.delete(fiberId);
+		});
+		this._managedFiberExecutions.set(fiberId, execution);
+		if (options?.waitForCompletion) {
+			const completed = await this._waitForManagedFiber(fiberId);
+			if (!completed) throw new Error(`Fiber ${fiberId} no longer exists`);
+			return {
+				...completed,
+				accepted: true
+			};
+		}
+		return {
+			...this._fiberInspectionFromRow(row),
+			accepted: true
+		};
+	}
+	async _executeManagedFiber(fiberId, name, fn) {
+		const row = this._readFiber(fiberId);
+		if (!row || row.status !== "pending") return;
+		const controller = new AbortController();
+		this._managedFiberAbortControllers.set(fiberId, controller);
+		const now = Date.now();
+		this.sql`
+      UPDATE cf_agents_fibers
+      SET status = 'running', started_at = ${now}
+      WHERE fiber_id = ${fiberId} AND status = 'pending'
+    `;
+		const updated = this._readFiber(fiberId);
+		if (!updated || updated.status !== "running") {
+			this._managedFiberAbortControllers.delete(fiberId);
+			return;
+		}
+		let settled = false;
+		try {
+			await this._runFiberInternal(fiberId, name, fn, {
+				signal: controller.signal,
+				managed: true,
+				beforeRunCleanup: (outcome) => {
+					settled = true;
+					this._settleManagedFiberExecution(fiberId, outcome, controller.signal);
+				}
+			});
+		} catch (error) {
+			if (!settled) this._settleManagedFiberExecution(fiberId, {
+				ok: false,
+				error
+			}, controller.signal);
+		} finally {
+			this._managedFiberAbortControllers.delete(fiberId);
+		}
+	}
+	async _runFiberInternal(id, name, fn, options) {
+		const signal = options?.signal ?? new AbortController().signal;
 		this.sql`
       INSERT INTO cf_agents_runs (id, name, snapshot, created_at)
       VALUES (${id}, ${name}, NULL, ${Date.now()})
@@ -2242,19 +2653,36 @@ var Agent = class Agent extends Server {
 			}
 			dispose = await this.keepAlive();
 			const stash = (data) => {
+				const snapshot = JSON.stringify(data);
 				this.sql`
-          UPDATE cf_agents_runs SET snapshot = ${JSON.stringify(data)}
+          UPDATE cf_agents_runs SET snapshot = ${snapshot}
           WHERE id = ${id}
         `;
+				if (options?.managed) this.sql`
+            UPDATE cf_agents_fibers SET snapshot = ${snapshot}
+            WHERE fiber_id = ${id}
+          `;
 			};
-			return await _fiberALS.run({
-				id,
-				stash
-			}, () => fn({
-				id,
-				stash,
-				snapshot: null
-			}));
+			try {
+				const result = await _fiberALS.run({
+					id,
+					signal,
+					stash
+				}, () => fn({
+					id,
+					signal,
+					stash,
+					snapshot: null
+				}));
+				options?.beforeRunCleanup?.({ ok: true });
+				return result;
+			} catch (error) {
+				options?.beforeRunCleanup?.({
+					ok: false,
+					error
+				});
+				throw error;
+			}
 		} finally {
 			this._runFiberActiveFibers.delete(id);
 			this.sql`DELETE FROM cf_agents_runs WHERE id = ${id}`;
@@ -2306,24 +2734,67 @@ var Agent = class Agent extends Server {
 			const rows = this.sql`SELECT id, name, snapshot, created_at FROM cf_agents_runs`;
 			for (const row of rows) {
 				if (this._runFiberActiveFibers.has(row.id)) continue;
-				let snapshot = null;
-				if (row.snapshot) try {
-					snapshot = JSON.parse(row.snapshot);
-				} catch {
-					console.warn(`[Agent] Corrupted snapshot for fiber ${row.id}, treating as null`);
-				}
+				const snapshot = this._parseFiberRecoverySnapshot(row.id, row.snapshot);
 				const ctx = {
 					id: row.id,
 					name: row.name,
 					snapshot,
 					createdAt: row.created_at
 				};
-				try {
-					if (!await this._handleInternalFiberRecovery(ctx)) await this.onFiberRecovered(ctx);
-				} catch (e) {
-					console.error(`[Agent] Fiber recovery failed for "${ctx.name}" (${ctx.id}):`, e);
+				const managedRow = this._readFiber(row.id);
+				if (managedRow) {
+					if (this._isTerminalFiberStatus(managedRow.status)) {
+						this.sql`DELETE FROM cf_agents_runs WHERE id = ${row.id}`;
+						this._notifyManagedFiberTerminal(row.id);
+						continue;
+					}
+					const completedAt = Date.now();
+					this.sql`
+            UPDATE cf_agents_fibers
+            SET status = 'interrupted',
+                snapshot = ${row.snapshot},
+                completed_at = ${completedAt}
+            WHERE fiber_id = ${row.id}
+              AND status IN ('pending', 'running')
+          `;
+					ctx.idempotencyKey = managedRow.idempotency_key ?? void 0;
+					ctx.metadata = this._parseFiberJsonObject(managedRow.metadata_json);
+					ctx.status = "interrupted";
 				}
+				await this._runFiberRecoveryHook(ctx, managedRow);
 				this.sql`DELETE FROM cf_agents_runs WHERE id = ${row.id}`;
+				if (managedRow) this._notifyManagedFiberTerminal(row.id);
+			}
+			const ledgerOnlyRows = this.sql`
+        SELECT f.fiber_id, f.idempotency_key, f.name, f.status, f.snapshot,
+               f.metadata_json, f.error_message, f.created_at, f.started_at,
+               f.completed_at
+        FROM cf_agents_fibers f
+        LEFT JOIN cf_agents_runs r ON r.id = f.fiber_id
+        WHERE f.status IN ('pending', 'running')
+          AND r.id IS NULL
+      `;
+			for (const row of ledgerOnlyRows) {
+				if (this._runFiberActiveFibers.has(row.fiber_id)) continue;
+				const snapshot = this._parseFiberRecoverySnapshot(row.fiber_id, row.snapshot);
+				const completedAt = Date.now();
+				this.sql`
+          UPDATE cf_agents_fibers
+          SET status = 'interrupted',
+              completed_at = ${completedAt}
+          WHERE fiber_id = ${row.fiber_id}
+            AND status IN ('pending', 'running')
+        `;
+				await this._runFiberRecoveryHook({
+					id: row.fiber_id,
+					name: row.name,
+					snapshot,
+					createdAt: row.created_at,
+					idempotencyKey: row.idempotency_key ?? void 0,
+					metadata: this._parseFiberJsonObject(row.metadata_json),
+					status: "interrupted"
+				}, row);
+				this._notifyManagedFiberTerminal(row.fiber_id);
 			}
 		} finally {
 			this._runFiberRecoveryInProgress = false;
@@ -4021,6 +4492,7 @@ var Agent = class Agent extends Server {
 		this.sql`DROP TABLE IF EXISTS cf_agents_workflows`;
 		this.sql`DROP TABLE IF EXISTS cf_agents_sub_agents`;
 		this.sql`DROP TABLE IF EXISTS cf_agents_runs`;
+		this.sql`DROP TABLE IF EXISTS cf_agents_fibers`;
 		this.sql`DROP TABLE IF EXISTS cf_agents_facet_runs`;
 		this.sql`DROP TABLE IF EXISTS cf_agent_tool_runs`;
 	}