@botbotgo/agent-harness 0.0.1

package/dist/runtime/agent-runtime-adapter.js

@@ -0,0 +1,445 @@
+import { Command, MemorySaver } from "@langchain/langgraph";
+import { createDeepAgent } from "deepagents";
+import { ChatAnthropic } from "@langchain/anthropic";
+import { ChatGoogle } from "@langchain/google";
+import { ChatOllama } from "@langchain/ollama";
+import { ChatOpenAI } from "@langchain/openai";
+import { createAgent, humanInTheLoopMiddleware, initChatModel } from "langchain";
+import { extractReasoningText, extractToolFallbackContext, extractVisibleOutput, isLikelyToolArgsObject, isToolCallParseFailure, STRICT_TOOL_JSON_INSTRUCTION, sanitizeVisibleText, tryParseJson, wrapResolvedModel, } from "./parsing/output-parsing.js";
+import { extractAgentStep, extractInterruptPayload, extractReasoningStreamOutput, extractTerminalStreamOutput, extractToolResult, normalizeTerminalOutputKey, readStreamDelta, } from "./parsing/stream-event-parsing.js";
+import { wrapToolForExecution } from "./tool-hitl.js";
+const AGENT_INTERRUPT_SENTINEL_PREFIX = "__agent_harness_interrupt__:";
+function asObject(value) {
+    return typeof value === "object" && value ? value : undefined;
+}
+function normalizeOpenAICompatibleInit(init) {
+    const normalized = { ...init };
+    const configuration = asObject(init.configuration) ?? {};
+    const baseUrl = typeof init.baseUrl === "string" && init.baseUrl.trim() ? init.baseUrl.trim() : undefined;
+    if (baseUrl && typeof configuration.baseURL !== "string") {
+        normalized.configuration = {
+            ...configuration,
+            baseURL: baseUrl,
+        };
+    }
+    delete normalized.baseUrl;
+    return normalized;
+}
+export class AgentRuntimeAdapter {
+    options;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    async materializeModelStream(streamFactory, input, config) {
+        const stream = await streamFactory(input, config);
+        let content = "";
+        for await (const chunk of stream) {
+            const delta = readStreamDelta(chunk) || extractVisibleOutput(chunk);
+            if (delta) {
+                content += delta;
+            }
+        }
+        return { content };
+    }
+    createModelFallbackRunnable(model) {
+        return {
+            invoke: async (input, config) => {
+                const request = typeof input === "object" && input !== null && "messages" in input
+                    ? input.messages
+                    : input;
+                if (typeof model.invoke === "function") {
+                    return model.invoke(request, config);
+                }
+                if (typeof model.stream === "function") {
+                    return this.materializeModelStream(model.stream.bind(model), request, config);
+                }
+                throw new Error("Resolved model must define invoke or stream.");
+            },
+            stream: async (input, config) => {
+                if (typeof model.stream === "function") {
+                    const request = typeof input === "object" && input !== null && "messages" in input
+                        ? input.messages
+                        : input;
+                    return model.stream(request, config);
+                }
+                if (typeof model.invoke === "function") {
+                    const request = typeof input === "object" && input !== null && "messages" in input
+                        ? input.messages
+                        : input;
+                    const result = await model.invoke(request, config);
+                    const text = extractVisibleOutput(result);
+                    async function* singleChunk() {
+                        yield { content: text };
+                    }
+                    return singleChunk();
+                }
+                throw new Error("Resolved model must define invoke or stream.");
+            },
+        };
+    }
+    applyStrictToolJsonInstruction(binding) {
+        if (binding.langchainAgentParams) {
+            return {
+                ...binding,
+                langchainAgentParams: {
+                    ...binding.langchainAgentParams,
+                    systemPrompt: [binding.langchainAgentParams.systemPrompt, STRICT_TOOL_JSON_INSTRUCTION].filter(Boolean).join("\n\n"),
+                },
+            };
+        }
+        if (binding.deepAgentParams) {
+            return {
+                ...binding,
+                deepAgentParams: {
+                    ...binding.deepAgentParams,
+                    systemPrompt: [binding.deepAgentParams.systemPrompt, STRICT_TOOL_JSON_INSTRUCTION].filter(Boolean).join("\n\n"),
+                },
+            };
+        }
+        return binding;
+    }
+    async synthesizeDeepAgentAnswer(binding, input, result) {
+        if (!binding.deepAgentParams) {
+            return "";
+        }
+        const toolContext = extractToolFallbackContext(result);
+        if (!toolContext) {
+            return "";
+        }
+        const model = (await this.resolveModel(binding.deepAgentParams.model));
+        if (!model?.invoke) {
+            return "";
+        }
+        const synthesized = await model.invoke([
+            {
+                role: "system",
+                content: "The previous agent run completed tool work but did not produce a final user-facing answer. Write the final answer now using the tool results provided. Do not expose internal state, tools, or reasoning.",
+            },
+            {
+                role: "user",
+                content: `Original user request:\n${input}\n\nTool results:\n${toolContext}`,
+            },
+        ]);
+        return sanitizeVisibleText(extractVisibleOutput(synthesized));
+    }
+    async resolveModel(model) {
+        if (this.options.modelResolver) {
+            return wrapResolvedModel(await this.options.modelResolver(model.id));
+        }
+        if (model.provider === "ollama" && typeof model.init.baseUrl === "string" && model.init.baseUrl.trim()) {
+            return wrapResolvedModel(new ChatOllama({ model: model.model, baseUrl: model.init.baseUrl, ...model.init }));
+        }
+        if (model.provider === "openai-compatible") {
+            return wrapResolvedModel(new ChatOpenAI({ model: model.model, ...normalizeOpenAICompatibleInit(model.init) }));
+        }
+        if (model.provider === "openai") {
+            return wrapResolvedModel(new ChatOpenAI({ model: model.model, ...model.init }));
+        }
+        if (model.provider === "anthropic") {
+            return wrapResolvedModel(new ChatAnthropic({ model: model.model, ...model.init }));
+        }
+        if (model.provider === "google" || model.provider === "google-genai" || model.provider === "gemini") {
+            return wrapResolvedModel(new ChatGoogle({ model: model.model, ...model.init }));
+        }
+        return wrapResolvedModel(await initChatModel(model.model, { modelProvider: model.provider, ...model.init }));
+    }
+    resolveTools(tools, binding) {
+        const resolved = this.options.toolResolver ? this.options.toolResolver(tools.map((tool) => tool.id), binding) : [];
+        return resolved.map((resolvedTool, index) => {
+            const compiledTool = tools[index];
+            return compiledTool ? wrapToolForExecution(resolvedTool, compiledTool) : resolvedTool;
+        });
+    }
+    normalizeInterruptPolicy(rule) {
+        if (!rule)
+            return null;
+        if (rule === true)
+            return ["approve", "edit", "reject"];
+        const typed = rule;
+        if (Array.isArray(typed.allowedDecisions)) {
+            return typed.allowedDecisions.filter((item) => item === "approve" || item === "edit" || item === "reject");
+        }
+        const decisions = [];
+        if (typed.allowAccept !== false)
+            decisions.push("approve");
+        if (typed.allowEdit !== false)
+            decisions.push("edit");
+        if (typed.allowReject !== false)
+            decisions.push("reject");
+        return decisions.length > 0 ? decisions : null;
+    }
+    compileInterruptOn(_tools, compatibilityRules) {
+        const compiled = new Map();
+        for (const [toolName, rule] of Object.entries(compatibilityRules ?? {})) {
+            const allowedDecisions = this.normalizeInterruptPolicy(rule);
+            if (!allowedDecisions) {
+                compiled.delete(toolName);
+            }
+            else {
+                compiled.set(toolName, { allowedDecisions });
+            }
+        }
+        return compiled.size > 0 ? Object.fromEntries(compiled.entries()) : undefined;
+    }
+    resolveInterruptOn(binding) {
+        if (binding.deepAgentParams) {
+            return this.compileInterruptOn(binding.deepAgentParams.tools, binding.deepAgentParams.interruptOn);
+        }
+        return this.compileInterruptOn(binding.langchainAgentParams?.tools ?? [], binding.agent.langchainAgentConfig?.interruptOn);
+    }
+    resolveMiddleware(binding, interruptOn) {
+        const middleware = this.options.middlewareResolver ? this.options.middlewareResolver(binding) : [];
+        if (interruptOn && Object.keys(interruptOn).length > 0) {
+            middleware.push(humanInTheLoopMiddleware({ interruptOn }));
+        }
+        return middleware;
+    }
+    resolveCheckpointer(binding) {
+        return this.options.checkpointerResolver ? this.options.checkpointerResolver(binding) : new MemorySaver();
+    }
+    buildRouteSystemPrompt(primaryBinding, secondaryBinding, overridePrompt) {
+        const defaultPrompt = `You are a routing classifier for an agent harness. Reply with exactly one agent id: ${primaryBinding.agent.id} or ${secondaryBinding.agent.id}.\n\n` +
+            `Choose ${primaryBinding.agent.id} only for lightweight conversational turns that can be answered directly in one step ` +
+            "without tool use, repository inspection, file lookup, external checkout, or orchestration.\n\n" +
+            `Choose ${secondaryBinding.agent.id} for tasks that need tools, multi-step execution, external research, repository or ` +
+            "file analysis, downloading or cloning content, codebase exploration, verification, or any task where the agent " +
+            "should inspect the workspace or another repository before answering.\n\n" +
+            `If the request asks to download, clone, fetch, inspect, analyze, trace, or locate implementation in a repo or codebase, choose ${secondaryBinding.agent.id}.\n\n` +
+            `When uncertain, prefer ${secondaryBinding.agent.id}.\n\n` +
+            `Agent ${primaryBinding.agent.id}: ${primaryBinding.agent.description}\n` +
+            `Agent ${secondaryBinding.agent.id}: ${secondaryBinding.agent.description}`;
+        if (!overridePrompt?.trim()) {
+            return defaultPrompt;
+        }
+        return overridePrompt
+            .replaceAll("{{primaryAgentId}}", primaryBinding.agent.id)
+            .replaceAll("{{primaryDescription}}", primaryBinding.agent.description)
+            .replaceAll("{{secondaryAgentId}}", secondaryBinding.agent.id)
+            .replaceAll("{{secondaryDescription}}", secondaryBinding.agent.description);
+    }
+    async resolveSubagents(subagents) {
+        return Promise.all(subagents.map(async (subagent) => ({
+            ...subagent,
+            model: subagent.model ? (await this.resolveModel(subagent.model)) : undefined,
+            tools: subagent.tools ? this.resolveTools(subagent.tools) : undefined,
+            interruptOn: this.compileInterruptOn(subagent.tools ?? [], subagent.interruptOn),
+        })));
+    }
+    buildConversation(systemPrompt, history, input) {
+        const messages = [];
+        if (systemPrompt) {
+            messages.push({ role: "system", content: systemPrompt });
+        }
+        for (const item of history) {
+            messages.push({ role: item.role, content: item.content });
+        }
+        messages.push({ role: "user", content: input });
+        return messages;
+    }
+    async create(binding) {
+        if (binding.langchainAgentParams) {
+            const interruptOn = this.resolveInterruptOn(binding);
+            const model = (await this.resolveModel(binding.langchainAgentParams.model));
+            const tools = this.resolveTools(binding.langchainAgentParams.tools, binding);
+            if (tools.length > 0 && typeof model.bindTools !== "function") {
+                return this.createModelFallbackRunnable(model);
+            }
+            return createAgent({
+                model: model,
+                tools: tools,
+                systemPrompt: binding.langchainAgentParams.systemPrompt,
+                middleware: this.resolveMiddleware(binding, interruptOn),
+                checkpointer: this.resolveCheckpointer(binding),
+            });
+        }
+        const params = binding.deepAgentParams;
+        if (!params) {
+            throw new Error(`Agent ${binding.agent.id} has no runnable params`);
+        }
+        return createDeepAgent({
+            model: (await this.resolveModel(params.model)),
+            tools: this.resolveTools(params.tools, binding),
+            systemPrompt: params.systemPrompt,
+            middleware: this.resolveMiddleware(binding),
+            subagents: (await this.resolveSubagents(params.subagents)),
+            checkpointer: this.resolveCheckpointer(binding),
+            store: this.options.storeResolver?.(binding),
+            backend: this.options.backendResolver?.(binding),
+            interruptOn: this.resolveInterruptOn(binding),
+            name: params.name,
+            memory: params.memory,
+            skills: params.skills,
+        });
+    }
+    async route(input, primaryBinding, secondaryBinding, options = {}) {
+        const routeModelConfig = primaryBinding.langchainAgentParams?.model ??
+            primaryBinding.deepAgentParams?.model ??
+            secondaryBinding.langchainAgentParams?.model ??
+            secondaryBinding.deepAgentParams?.model;
+        if (!routeModelConfig) {
+            throw new Error("No router model configuration available");
+        }
+        const routerModel = (await this.resolveModel(routeModelConfig));
+        if (!routerModel?.invoke) {
+            throw new Error("Router model does not support invoke()");
+        }
+        const result = await routerModel.invoke([
+            {
+                role: "system",
+                content: this.buildRouteSystemPrompt(primaryBinding, secondaryBinding, options.systemPrompt),
+            },
+            { role: "user", content: input },
+        ]);
+        const content = typeof result === "string"
+            ? result
+            : typeof result?.content === "string"
+                ? result.content
+                : JSON.stringify(result);
+        const normalized = content.trim().toLowerCase();
+        return normalized === secondaryBinding.agent.id.toLowerCase() || normalized.includes(secondaryBinding.agent.id.toLowerCase())
+            ? secondaryBinding.agent.id
+            : primaryBinding.agent.id;
+    }
+    async invoke(binding, input, threadId, runId, resumePayload, history = []) {
+        const request = resumePayload === undefined
+            ? { messages: this.buildConversation(binding.langchainAgentParams?.systemPrompt ?? binding.deepAgentParams?.systemPrompt, history, input) }
+            : new Command({ resume: resumePayload });
+        let result;
+        try {
+            const runnable = await this.create(binding);
+            result = (await runnable.invoke(request, { configurable: { thread_id: threadId } }));
+        }
+        catch (error) {
+            if (resumePayload !== undefined || !isToolCallParseFailure(error)) {
+                throw error;
+            }
+            const retriedBinding = this.applyStrictToolJsonInstruction(binding);
+            const runnable = await this.create(retriedBinding);
+            result = (await runnable.invoke({ messages: this.buildConversation(retriedBinding.langchainAgentParams?.systemPrompt ?? retriedBinding.deepAgentParams?.systemPrompt, history, input) }, { configurable: { thread_id: threadId } }));
+        }
+        const interruptContent = Array.isArray(result.__interrupt__) && result.__interrupt__.length > 0 ? JSON.stringify(result.__interrupt__) : undefined;
+        const extractedOutput = extractVisibleOutput(result);
+        const visibleOutput = extractedOutput && !isLikelyToolArgsObject(tryParseJson(extractedOutput)) ? extractedOutput : "";
+        const toolFallback = extractToolFallbackContext(result);
+        const output = visibleOutput || (await this.synthesizeDeepAgentAnswer(binding, input, result)) || toolFallback || JSON.stringify(result, null, 2);
+        return {
+            threadId,
+            runId,
+            agentId: binding.agent.id,
+            state: Array.isArray(result.__interrupt__) && result.__interrupt__.length > 0 ? "waiting_for_approval" : "completed",
+            interruptContent,
+            output: sanitizeVisibleText(output),
+        };
+    }
+    async *stream(binding, input, threadId, history = []) {
+        try {
+            if (binding.langchainAgentParams) {
+                const resolvedModel = (await this.resolveModel(binding.langchainAgentParams.model));
+                const tools = this.resolveTools(binding.langchainAgentParams.tools, binding);
+                const canUseDirectModelStream = tools.length === 0 || typeof resolvedModel.bindTools !== "function";
+                const model = canUseDirectModelStream
+                    ? resolvedModel
+                    : typeof resolvedModel.bindTools === "function" && tools.length > 0
+                        ? resolvedModel.bindTools(tools)
+                        : resolvedModel;
+                // For tool-using langchain agents, a raw model.stream pass cannot execute the
+                // agent loop and only adds an extra model round-trip before the runnable path.
+                if (canUseDirectModelStream && typeof model.stream === "function") {
+                    let emitted = false;
+                    const stream = await model.stream(this.buildConversation(binding.langchainAgentParams.systemPrompt, history, input));
+                    for await (const chunk of stream) {
+                        const delta = readStreamDelta(chunk);
+                        if (delta) {
+                            emitted = true;
+                            yield { kind: "content", content: delta };
+                            continue;
+                        }
+                        const reasoning = extractReasoningText(chunk);
+                        if (reasoning) {
+                            yield { kind: "reasoning", content: reasoning };
+                        }
+                    }
+                    if (emitted) {
+                        return;
+                    }
+                }
+            }
+            const runnable = await this.create(binding);
+            const request = { messages: this.buildConversation(binding.deepAgentParams?.systemPrompt, history, input) };
+            if (typeof runnable.streamEvents === "function") {
+                const events = await runnable.streamEvents(request, { configurable: { thread_id: threadId }, version: "v2" });
+                let terminalOutput = "";
+                const seenTerminalOutputs = new Set();
+                let lastStep = "";
+                for await (const event of events) {
+                    const interruptPayload = extractInterruptPayload(event);
+                    if (interruptPayload) {
+                        yield { kind: "interrupt", content: interruptPayload };
+                        continue;
+                    }
+                    const reasoning = extractReasoningStreamOutput(event);
+                    if (reasoning) {
+                        yield { kind: "reasoning", content: reasoning };
+                    }
+                    const agentStep = extractAgentStep(event);
+                    if (agentStep && agentStep !== lastStep) {
+                        lastStep = agentStep;
+                        yield { kind: "step", content: agentStep };
+                    }
+                    const toolResult = extractToolResult(event);
+                    if (toolResult) {
+                        yield { kind: "tool-result", toolName: toolResult.toolName, output: toolResult.output };
+                    }
+                    const output = extractTerminalStreamOutput(event);
+                    if (output) {
+                        const outputKey = normalizeTerminalOutputKey(output);
+                        if (outputKey && seenTerminalOutputs.has(outputKey)) {
+                            continue;
+                        }
+                        if (outputKey) {
+                            seenTerminalOutputs.add(outputKey);
+                        }
+                        terminalOutput += output;
+                    }
+                }
+                if (terminalOutput) {
+                    yield { kind: "content", content: sanitizeVisibleText(terminalOutput) };
+                    return;
+                }
+            }
+            if (binding.langchainAgentParams && typeof runnable.stream === "function") {
+                const stream = await runnable.stream(request, { configurable: { thread_id: threadId } });
+                let emitted = false;
+                for await (const chunk of stream) {
+                    const delta = readStreamDelta(chunk);
+                    if (delta) {
+                        emitted = true;
+                        yield { kind: "content", content: delta };
+                        continue;
+                    }
+                    const reasoning = extractReasoningText(chunk);
+                    if (reasoning) {
+                        yield { kind: "reasoning", content: reasoning };
+                    }
+                }
+                if (emitted) {
+                    return;
+                }
+            }
+            const result = await this.invoke(binding, input, threadId, threadId);
+            if (result.output) {
+                yield { kind: "content", content: sanitizeVisibleText(result.output) };
+            }
+        }
+        catch (error) {
+            if (!isToolCallParseFailure(error)) {
+                throw error;
+            }
+            const retried = await this.invoke(this.applyStrictToolJsonInstruction(binding), input, threadId, threadId, undefined, history);
+            if (retried.output) {
+                yield { kind: "content", content: sanitizeVisibleText(retried.output) };
+            }
+        }
+    }
+}
+export { AgentRuntimeAdapter as RuntimeAdapter, AGENT_INTERRUPT_SENTINEL_PREFIX, AGENT_INTERRUPT_SENTINEL_PREFIX as INTERRUPT_SENTINEL_PREFIX, };

package/dist/runtime/event-bus.d.ts

@@ -0,0 +1,6 @@
+import type { HarnessEvent } from "../contracts/types.js";
+export declare class EventBus {
+    private readonly emitter;
+    publish(event: HarnessEvent): void;
+    subscribe(listener: (event: HarnessEvent) => void): () => void;
+}

package/dist/runtime/event-bus.js

@@ -0,0 +1,15 @@
+import { EventEmitter } from "node:events";
+import { getEventSubscribers } from "../extensions.js";
+export class EventBus {
+    emitter = new EventEmitter();
+    publish(event) {
+        this.emitter.emit("event", event);
+        for (const subscriber of getEventSubscribers()) {
+            void Promise.resolve(subscriber.onEvent(event));
+        }
+    }
+    subscribe(listener) {
+        this.emitter.on("event", listener);
+        return () => this.emitter.off("event", listener);
+    }
+}

package/dist/runtime/file-checkpoint-saver.d.ts

@@ -0,0 +1,20 @@
+import { MemorySaver } from "@langchain/langgraph";
+type MemorySaverConfig = Parameters<MemorySaver["getTuple"]>[0];
+type MemorySaverListOptions = Parameters<MemorySaver["list"]>[1];
+type MemorySaverPutCheckpoint = Parameters<MemorySaver["put"]>[1];
+type MemorySaverPutMetadata = Parameters<MemorySaver["put"]>[2];
+type MemorySaverPutWrites = Parameters<MemorySaver["putWrites"]>[1];
+type MemorySaverPutResult = ReturnType<MemorySaver["put"]>;
+export declare class FileCheckpointSaver extends MemorySaver {
+    private readonly filePath;
+    private loaded;
+    constructor(filePath: string);
+    private ensureLoaded;
+    private persist;
+    getTuple(config: MemorySaverConfig): Promise<import("@langchain/langgraph").CheckpointTuple | undefined>;
+    list(config: MemorySaverConfig, options?: MemorySaverListOptions): AsyncGenerator<import("@langchain/langgraph").CheckpointTuple, void, unknown>;
+    put(config: MemorySaverConfig, checkpoint: MemorySaverPutCheckpoint, metadata: MemorySaverPutMetadata): MemorySaverPutResult;
+    putWrites(config: MemorySaverConfig, writes: MemorySaverPutWrites, taskId: string): Promise<void>;
+    deleteThread(threadId: string): Promise<void>;
+}
+export { FileCheckpointSaver as FileCheckpointer };

package/dist/runtime/file-checkpoint-saver.js

@@ -0,0 +1,91 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { MemorySaver } from "@langchain/langgraph";
+function encodeBinary(value) {
+    if (value instanceof Uint8Array) {
+        return {
+            __type: "Uint8Array",
+            data: Array.from(value),
+        };
+    }
+    if (Array.isArray(value)) {
+        return value.map((item) => encodeBinary(item));
+    }
+    if (typeof value === "object" && value) {
+        return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, encodeBinary(entry)]));
+    }
+    return value;
+}
+function decodeBinary(value) {
+    if (Array.isArray(value)) {
+        return value.map((item) => decodeBinary(item));
+    }
+    if (typeof value === "object" && value) {
+        const typed = value;
+        if (typed.__type === "Uint8Array" && Array.isArray(typed.data)) {
+            return new Uint8Array(typed.data.map((item) => Number(item)));
+        }
+        return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, decodeBinary(entry)]));
+    }
+    return value;
+}
+export class FileCheckpointSaver extends MemorySaver {
+    filePath;
+    loaded = false;
+    constructor(filePath) {
+        super();
+        this.filePath = filePath;
+    }
+    async ensureLoaded() {
+        if (this.loaded) {
+            return;
+        }
+        try {
+            const raw = await readFile(this.filePath, "utf8");
+            const parsed = JSON.parse(raw);
+            this.storage = decodeBinary(parsed.storage ?? {});
+            this.writes = decodeBinary(parsed.writes ?? {});
+        }
+        catch {
+            this.storage = {};
+            this.writes = {};
+        }
+        this.loaded = true;
+    }
+    async persist() {
+        await mkdir(path.dirname(this.filePath), { recursive: true });
+        await writeFile(this.filePath, JSON.stringify({
+            storage: this.storage,
+            writes: this.writes,
+        }, (_, value) => encodeBinary(value), 2), "utf8");
+    }
+    async getTuple(config) {
+        await this.ensureLoaded();
+        return super.getTuple(config);
+    }
+    async *list(config, options) {
+        await this.ensureLoaded();
+        for await (const item of super.list(config, options)) {
+            yield item;
+        }
+    }
+    async put(config, checkpoint, metadata) {
+        await this.ensureLoaded();
+        const result = await super.put(config, checkpoint, metadata);
+        await this.persist();
+        return result;
+    }
+    async putWrites(config, writes, taskId) {
+        await this.ensureLoaded();
+        const result = await super.putWrites(config, writes, taskId);
+        await this.persist();
+        return result;
+    }
+    async deleteThread(threadId) {
+        await this.ensureLoaded();
+        const result = await super.deleteThread(threadId);
+        await this.persist();
+        return result;
+    }
+}
+export { FileCheckpointSaver as FileCheckpointer };

package/dist/runtime/harness.d.ts

@@ -0,0 +1,57 @@
+import { Readable } from "node:stream";
+import type { ApprovalRecord, ArtifactListing, DelegationRecord, HarnessEvent, HarnessStreamItem, RestartConversationOptions, RuntimeAdapterOptions, ResumeOptions, RunOptions, RunResult, SessionRecord, WorkspaceBundle } from "../contracts/types.js";
+export declare class AgentHarness {
+    private readonly workspace;
+    private readonly runtimeAdapterOptions;
+    private readonly eventBus;
+    private readonly persistence;
+    private readonly policyEngine;
+    private readonly runtimeAdapter;
+    private readonly checkpointers;
+    private readonly stores;
+    private readonly embeddingModels;
+    private readonly vectorStores;
+    private readonly defaultStore;
+    private readonly routingSystemPrompt?;
+    private readonly threadMemorySync;
+    private readonly unsubscribeThreadMemorySync;
+    private listHostBindings;
+    private defaultRunRoot;
+    private heuristicRoute;
+    private buildRoutingInput;
+    private resolveSelectedAgentId;
+    private resolveStore;
+    private resolveEmbeddingModel;
+    private resolveVectorStore;
+    constructor(workspace: WorkspaceBundle, runtimeAdapterOptions?: RuntimeAdapterOptions);
+    initialize(): Promise<void>;
+    subscribeEvents(listener: (event: HarnessEvent) => void): () => void;
+    subscribe(listener: (event: HarnessEvent) => void): () => void;
+    listSessions(filter?: {
+        agentId?: string;
+    }): Promise<SessionRecord[]>;
+    getSession(threadId: string): Promise<SessionRecord | null>;
+    getEvents(threadId: string, runId?: string): Promise<HarnessEvent[]>;
+    listPendingApprovals(): Promise<ApprovalRecord[]>;
+    getApproval(approvalId: string): Promise<ApprovalRecord | null>;
+    listDelegations(): Promise<DelegationRecord[]>;
+    routeAgent(input: string, options?: {
+        threadId?: string;
+    }): Promise<string>;
+    artifacts(threadId: string, runId?: string): Promise<ArtifactListing>;
+    private emit;
+    private persistApproval;
+    private resolveApprovalRecord;
+    run(options: RunOptions): Promise<RunResult>;
+    stream(options: RunOptions): AsyncGenerator<string>;
+    streamEvents(options: RunOptions): AsyncGenerator<HarnessStreamItem>;
+    streamReadable(options: RunOptions): Promise<Readable>;
+    resume(options: ResumeOptions): Promise<RunResult>;
+    submitDecision(options: ResumeOptions): Promise<RunResult>;
+    approve(threadId: string, runId?: string): Promise<RunResult>;
+    reject(threadId: string, runId?: string): Promise<RunResult>;
+    restartConversation(options: RestartConversationOptions): Promise<RunResult & {
+        restart: Record<string, string>;
+    }>;
+    close(): Promise<void>;
+}