@botbotgo/agent-harness 0.0.46 → 0.0.48

package/README.md

@@ -521,7 +521,7 @@ spec:
   systemPrompt: Coordinate the request.
 ```
 
-`kind: DeepAgent` and `kind: LangChainAgent` remain supported as compatibility forms, but `kind: Agent` is the recommended product-facing entry point.
+Only `kind: Agent` is supported for agent objects. Select the concrete backend with `spec.execution.backend`.
 
 Common client-configurable agent fields:
 

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.47";

package/dist/package-version.js

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

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/dist/workspace/object-loader.js

@@ -93,10 +93,6 @@ function normalizeKind(kind) {
     switch (kind) {
         case "Agent":
             return "agent";
-        case "LangChainAgent":
-            return "langchain-agent";
-        case "DeepAgent":
-            return "deepagent";
         case "FileStore":
             return "file-store";
         case "InMemoryStore":
@@ -138,6 +134,9 @@ function normalizeKind(kind) {
     }
 }
 export function normalizeYamlItem(item) {
+    if (item.kind === "DeepAgent" || item.kind === "LangChainAgent") {
+        throw new Error(`YAML object kind ${String(item.kind)} is no longer supported; use kind: Agent with spec.execution.backend instead`);
+    }
     const metadata = asObject(item.metadata);
     const spec = asObject(item.spec);
     const kind = typeof item.kind === "string" ? normalizeKind(item.kind) : undefined;
@@ -161,20 +160,6 @@ export function normalizeYamlItem(item) {
         ...(kind ? { kind } : {}),
     };
 }
-function normalizeResourceItem(item) {
-    if ("metadata" in item || "spec" in item || "path" in item || typeof item.name !== "string") {
-        return item;
-    }
-    const { name, description, kind, ...spec } = item;
-    return {
-        ...(typeof kind === "string" ? { kind } : {}),
-        metadata: {
-            name,
-            ...(typeof description === "string" ? { description } : {}),
-        },
-        spec,
-    };
-}
 function readRefArray(items) {
     return toArray(items)
         .map((item) => typeof item === "string"
@@ -323,32 +308,8 @@ async function objectItemsFromDocument(document, sourcePath) {
     if (catalogItems.length > 0) {
         return catalogItems;
     }
-    const items = document.items;
-    if (Array.isArray(items)) {
-        const records = [];
-        for (const item of items) {
-            if (typeof item !== "object" || !item) {
-                continue;
-            }
-            const typedItem = item;
-            if (typeof typedItem.path === "string" && typedItem.path.trim()) {
-                const referencedPath = path.isAbsolute(typedItem.path)
-                    ? typedItem.path
-                    : path.join(path.dirname(sourcePath), typedItem.path);
-                if (existsSync(referencedPath) && statSync(referencedPath).isDirectory()) {
-                    const discoveredItems = await readYamlItems(referencedPath, undefined, { recursive: true });
-                    records.push(...discoveredItems.map(({ item }) => item));
-                    continue;
-                }
-                const parsedDocuments = parseAllDocuments(await readYamlOrJson(referencedPath));
-                for (const parsedDocument of parsedDocuments) {
-                    records.push(...(await objectItemsFromDocument(parsedDocument.toJSON(), referencedPath)));
-                }
-                continue;
-            }
-            records.push(normalizeResourceItem(typedItem));
-        }
-        return records;
+    if ("items" in document) {
+        throw new Error(`YAML document ${sourcePath} uses unsupported legacy items wrapper; use kind/spec catalog documents or metadata/spec objects instead`);
     }
     return [document];
 }

package/package.json

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