@botbotgo/agent-harness 0.0.46 → 0.0.47

package/dist/api.d.ts

@@ -13,6 +13,7 @@ export declare function run(runtime: AgentHarnessRuntime, options: RunOptions):
 export declare function subscribe(runtime: AgentHarnessRuntime, listener: Parameters<AgentHarnessRuntime["subscribe"]>[0]): () => void;
 export declare function listThreads(runtime: AgentHarnessRuntime, filter?: Parameters<AgentHarnessRuntime["listThreads"]>[0]): Promise<ThreadSummary[]>;
 export declare function getThread(runtime: AgentHarnessRuntime, threadId: string): Promise<ThreadRecord | null>;
+export declare function deleteThread(runtime: AgentHarnessRuntime, threadId: string): Promise<boolean>;
 export declare function listApprovals(runtime: AgentHarnessRuntime, filter?: Parameters<AgentHarnessRuntime["listApprovals"]>[0]): Promise<ApprovalRecord[]>;
 export declare function getApproval(runtime: AgentHarnessRuntime, approvalId: string): Promise<ApprovalRecord | null>;
 export declare function stop(runtime: AgentHarnessRuntime): Promise<void>;

package/dist/api.js

@@ -21,6 +21,9 @@ export async function listThreads(runtime, filter) {
 export async function getThread(runtime, threadId) {
     return runtime.getThread(threadId);
 }
+export async function deleteThread(runtime, threadId) {
+    return runtime.deleteThread(threadId);
+}
 export async function listApprovals(runtime, filter) {
     return runtime.listApprovals(filter);
 }

package/dist/index.d.ts

@@ -1,3 +1,3 @@
-export { AgentHarnessRuntime, createAgentHarness, createToolMcpServer, getApproval, getThread, listApprovals, listThreads, run, serveToolsOverStdio, subscribe, stop, } from "./api.js";
+export { AgentHarnessRuntime, createAgentHarness, createToolMcpServer, deleteThread, getApproval, getThread, listApprovals, listThreads, run, serveToolsOverStdio, subscribe, stop, } from "./api.js";
 export type { ToolMcpServerOptions } from "./mcp.js";
 export { tool } from "./tools.js";

package/dist/index.js

@@ -1,2 +1,2 @@
-export { AgentHarnessRuntime, createAgentHarness, createToolMcpServer, getApproval, getThread, listApprovals, listThreads, run, serveToolsOverStdio, subscribe, stop, } from "./api.js";
+export { AgentHarnessRuntime, createAgentHarness, createToolMcpServer, deleteThread, getApproval, getThread, listApprovals, listThreads, run, serveToolsOverStdio, subscribe, stop, } from "./api.js";
 export { tool } from "./tools.js";

package/dist/package-version.d.ts

@@ -1 +1 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.45";
+export declare const AGENT_HARNESS_VERSION = "0.0.46";

package/dist/package-version.js

@@ -1 +1 @@
-export const AGENT_HARNESS_VERSION = "0.0.45";
+export const AGENT_HARNESS_VERSION = "0.0.46";

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

@@ -47,6 +47,10 @@ type PersistedRunRequest = {
 export declare class FilePersistence {
     private readonly runRoot;
     constructor(runRoot: string);
+    private threadIndexPath;
+    private runIndexPath;
+    private approvalIndexPath;
+    private delegationIndexPath;
     initialize(): Promise<void>;
     threadDir(threadId: string): string;
     runDir(threadId: string, runId: string): string;
@@ -78,6 +82,7 @@ export declare class FilePersistence {
     getRunApprovals(threadId: string, runId: string): Promise<InternalApprovalRecord[]>;
     getRunMeta(threadId: string, runId: string): Promise<RunMeta>;
     getRunLifecycle(threadId: string, runId: string): Promise<Lifecycle>;
+    deleteThread(threadId: string): Promise<boolean>;
     saveRunRequest(threadId: string, runId: string, request: PersistedRunRequest): Promise<void>;
     getRunRequest(threadId: string, runId: string): Promise<PersistedRunRequest | null>;
     clearRunRequest(threadId: string, runId: string): Promise<void>;

package/dist/persistence/file-store.js

@@ -7,6 +7,18 @@ export class FilePersistence {
     constructor(runRoot) {
         this.runRoot = runRoot;
     }
+    threadIndexPath(threadId) {
+        return path.join(this.runRoot, "indexes", "threads", `${threadId}.json`);
+    }
+    runIndexPath(runId) {
+        return path.join(this.runRoot, "indexes", "runs", `${runId}.json`);
+    }
+    approvalIndexPath(approvalId) {
+        return path.join(this.runRoot, "indexes", "approvals", `${approvalId}.json`);
+    }
+    delegationIndexPath(delegationId) {
+        return path.join(this.runRoot, "indexes", "delegations", `${delegationId}.json`);
+    }
     async initialize() {
         await Promise.all([
             "indexes/threads",
@@ -266,6 +278,32 @@ export class FilePersistence {
     async getRunLifecycle(threadId, runId) {
         return readJson(path.join(this.runDir(threadId, runId), "lifecycle.json"));
     }
+    async deleteThread(threadId) {
+        const threadDir = this.threadDir(threadId);
+        const threadIndexPath = this.threadIndexPath(threadId);
+        if (!(await fileExists(threadDir)) && !(await fileExists(threadIndexPath))) {
+            return false;
+        }
+        const [runIndexes, approvals, delegations] = await Promise.all([
+            this.listRunIndexes(),
+            this.listApprovals(),
+            this.listDelegations(),
+        ]);
+        await Promise.all([
+            ...runIndexes
+                .filter((record) => record.threadId === threadId)
+                .map((record) => rm(this.runIndexPath(record.runId), { force: true })),
+            ...approvals
+                .filter((record) => record.threadId === threadId)
+                .map((record) => rm(this.approvalIndexPath(record.approvalId), { force: true })),
+            ...delegations
+                .filter((record) => record.threadId === threadId)
+                .map((record) => rm(this.delegationIndexPath(record.delegationId), { force: true })),
+            rm(threadIndexPath, { force: true }),
+            rm(threadDir, { recursive: true, force: true }),
+        ]);
+        return true;
+    }
     async saveRunRequest(threadId, runId, request) {
         await writeJson(path.join(this.runDir(threadId, runId), "request.json"), request);
     }

package/dist/runtime/harness.d.ts

@@ -26,6 +26,7 @@ export declare class AgentHarnessRuntime {
     private readonly pendingRunSlots;
     private toPublicApprovalRecord;
     private normalizeInvocationEnvelope;
+    private isTerminalRunState;
     private listHostBindings;
     private defaultRunRoot;
     private heuristicRoute;
@@ -52,6 +53,8 @@ export declare class AgentHarnessRuntime {
         runId?: string;
     }): Promise<ApprovalRecord[]>;
     getApproval(approvalId: string): Promise<ApprovalRecord | null>;
+    private deleteThreadCheckpoints;
+    deleteThread(threadId: string): Promise<boolean>;
     createToolMcpServer(options: ToolMcpServerOptions): Promise<import("@modelcontextprotocol/sdk/server/mcp.js").McpServer>;
     serveToolsOverStdio(options: ToolMcpServerOptions): Promise<import("@modelcontextprotocol/sdk/server/mcp.js").McpServer>;
     routeAgent(input: MessageContent, options?: {

package/dist/runtime/harness.js

@@ -53,6 +53,9 @@ export class AgentHarnessRuntime {
             invocation,
         };
     }
+    isTerminalRunState(state) {
+        return state === "completed" || state === "failed";
+    }
     listHostBindings() {
         return inferRoutingBindings(this.workspace).hostBindings;
     }
@@ -283,6 +286,39 @@ export class AgentHarnessRuntime {
         const approval = await this.persistence.getApproval(approvalId);
         return approval ? this.toPublicApprovalRecord(approval) : null;
     }
+    async deleteThreadCheckpoints(threadId) {
+        const resolver = this.resolvedRuntimeAdapterOptions.checkpointerResolver;
+        if (!resolver) {
+            return;
+        }
+        const seen = new Set();
+        for (const binding of this.workspace.bindings.values()) {
+            const saver = resolver(binding);
+            if (!saver || seen.has(saver)) {
+                continue;
+            }
+            seen.add(saver);
+            const maybeDeleteThread = saver.deleteThread;
+            if (typeof maybeDeleteThread === "function") {
+                await maybeDeleteThread.call(saver, threadId);
+            }
+        }
+    }
+    async deleteThread(threadId) {
+        const thread = await this.getThread(threadId);
+        if (!thread) {
+            return false;
+        }
+        const activeRun = thread.runs.find((run) => !this.isTerminalRunState(run.state));
+        if (activeRun) {
+            throw new Error(`Cannot delete thread ${threadId} while run ${activeRun.runId} is ${activeRun.state}`);
+        }
+        const deleted = await this.persistence.deleteThread(threadId);
+        if (deleted) {
+            await this.deleteThreadCheckpoints(threadId);
+        }
+        return deleted;
+    }
     async createToolMcpServer(options) {
         const tools = this.resolveAgentTools(options.agentId).map(({ compiledTool, resolvedTool }) => ({
             compiledTool,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botbotgo/agent-harness",
-  "version": "0.0.46",
+  "version": "0.0.47",
   "description": "Workspace runtime for multi-agent applications",
   "type": "module",
   "packageManager": "npm@10.9.2",