@botbotgo/agent-harness 0.0.81 → 0.0.82

package/dist/package-version.d.ts

@@ -1 +1 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.80";
+export declare const AGENT_HARNESS_VERSION = "0.0.81";

package/dist/package-version.js

@@ -1 +1 @@
-export const AGENT_HARNESS_VERSION = "0.0.80";
+export const AGENT_HARNESS_VERSION = "0.0.81";

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

@@ -1,5 +1,5 @@
 import type { ArtifactListing, ArtifactRecord, DelegationRecord, HarnessEvent, InternalApprovalRecord, RunSummary, RunState, ThreadSummary, ThreadRunRecord, TranscriptMessage } from "../contracts/types.js";
-import type { PersistedRunRequest, PersistedRunControlRecord, PersistedRunQueueRecord, PersistenceLifecycle as Lifecycle, RuntimePersistence, RecoveryIntent, PersistenceRunMeta as RunMeta, PersistenceThreadMeta as ThreadMeta } from "./types.js";
+import type { ApprovalFilter, PersistedRunRequest, PersistedRunControlRecord, PersistedRunQueueRecord, PersistenceLifecycle as Lifecycle, RuntimePersistence, RecoveryIntent, PersistenceRunMeta as RunMeta, RunSummaryFilter, ThreadSummaryFilter, PersistenceThreadMeta as ThreadMeta } from "./types.js";
 type RunIndexRecord = {
     runId: string;
     threadId: string;
@@ -36,16 +36,16 @@ export declare class FilePersistence implements RuntimePersistence {
     }): Promise<void>;
     setRunState(threadId: string, runId: string, state: RunState, checkpointRef?: string | null): Promise<void>;
     appendEvent(event: HarnessEvent): Promise<void>;
-    listSessions(): Promise<ThreadSummary[]>;
+    listSessions(filter?: ThreadSummaryFilter): Promise<ThreadSummary[]>;
     listRunIndexes(): Promise<RunIndexRecord[]>;
     private readRunSummary;
-    listRuns(): Promise<RunSummary[]>;
+    listRuns(filter?: RunSummaryFilter): Promise<RunSummary[]>;
     getRun(runId: string): Promise<RunSummary | null>;
     getSession(threadId: string): Promise<ThreadSummary | null>;
     getThreadMeta(threadId: string): Promise<ThreadMeta | null>;
     listThreadRuns(threadId: string): Promise<ThreadRunRecord[]>;
     listRunEvents(threadId: string, runId: string): Promise<HarnessEvent[]>;
-    listApprovals(): Promise<InternalApprovalRecord[]>;
+    listApprovals(filter?: ApprovalFilter): Promise<InternalApprovalRecord[]>;
     getApproval(approvalId: string): Promise<InternalApprovalRecord | null>;
     getRunApprovals(threadId: string, runId: string): Promise<InternalApprovalRecord[]>;
     getRunMeta(threadId: string, runId: string): Promise<RunMeta>;

package/dist/persistence/file-store.js

@@ -182,7 +182,7 @@ export class FilePersistence {
         const sequenceId = String(event.sequence).padStart(6, "0");
         await writeJson(path.join(this.runDir(event.threadId, event.runId), "events", `${sequenceId}.json`), event);
     }
-    async listSessions() {
+    async listSessions(filter = {}) {
         const threadIndexDir = path.join(this.runRoot, "indexes", "threads");
         if (!(await fileExists(threadIndexDir))) {
             return [];
@@ -200,7 +200,9 @@ export class FilePersistence {
                 status: index.status,
             };
         }));
-        return records.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+        return records
+            .filter((record) => !filter.agentId || record.agentId === filter.agentId)
+            .sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
     }
     async listRunIndexes() {
         const runIndexDir = path.join(this.runRoot, "indexes", "runs");
@@ -229,10 +231,23 @@ export class FilePersistence {
             resumable: lifecycle.resumable,
         };
     }
-    async listRuns() {
+    async listRuns(filter = {}) {
         const indexes = await this.listRunIndexes();
         const runs = await Promise.all(indexes.map((record) => this.readRunSummary(record.threadId, record.runId)));
-        return runs.sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
+        return runs
+            .filter((run) => {
+            if (filter.agentId && run.agentId !== filter.agentId) {
+                return false;
+            }
+            if (filter.threadId && run.threadId !== filter.threadId) {
+                return false;
+            }
+            if (filter.state && run.state !== filter.state) {
+                return false;
+            }
+            return true;
+        })
+            .sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
     }
     async getRun(runId) {
         const indexPath = this.runIndexPath(runId);
@@ -284,13 +299,25 @@ export class FilePersistence {
         const entries = (await readdir(eventsDir)).sort();
         return Promise.all(entries.map((entry) => readJson(path.join(eventsDir, entry))));
     }
-    async listApprovals() {
+    async listApprovals(filter = {}) {
         const approvalsDir = path.join(this.runRoot, "indexes", "approvals");
         if (!(await fileExists(approvalsDir))) {
             return [];
         }
         const entries = (await readdir(approvalsDir)).sort();
-        return Promise.all(entries.map((entry) => readJson(path.join(approvalsDir, entry))));
+        const approvals = await Promise.all(entries.map((entry) => readJson(path.join(approvalsDir, entry))));
+        return approvals.filter((approval) => {
+            if (filter.status && approval.status !== filter.status) {
+                return false;
+            }
+            if (filter.threadId && approval.threadId !== filter.threadId) {
+                return false;
+            }
+            if (filter.runId && approval.runId !== filter.runId) {
+                return false;
+            }
+            return true;
+        });
     }
     async getApproval(approvalId) {
         const approvalPath = path.join(this.runRoot, "indexes", "approvals", `${approvalId}.json`);

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

@@ -1,5 +1,5 @@
 import type { ArtifactListing, ArtifactRecord, HarnessEvent, InternalApprovalRecord, RunState, RunSummary, ThreadRunRecord, ThreadSummary, TranscriptMessage } from "../contracts/types.js";
-import type { PersistedRunRequest, PersistedRunControlRecord, PersistedRunQueueRecord, PersistenceLifecycle, PersistenceRunMeta, PersistenceThreadMeta, RecoveryIntent, RuntimePersistence } from "./types.js";
+import type { PersistedRunRequest, PersistedRunControlRecord, PersistedRunQueueRecord, PersistenceLifecycle, PersistenceRunMeta, PersistenceThreadMeta, RecoveryIntent, RuntimePersistence, ApprovalFilter, RunSummaryFilter, ThreadSummaryFilter } from "./types.js";
 export declare function listProtectedCheckpointThreadIds(dbPath: string): Promise<Set<string>>;
 export declare class SqlitePersistence implements RuntimePersistence {
     private readonly runRoot;
@@ -39,14 +39,14 @@ export declare class SqlitePersistence implements RuntimePersistence {
     }): Promise<void>;
     setRunState(threadId: string, runId: string, state: RunState, checkpointRef?: string | null): Promise<void>;
     appendEvent(event: HarnessEvent): Promise<void>;
-    listSessions(): Promise<ThreadSummary[]>;
-    listRuns(): Promise<RunSummary[]>;
+    listSessions(filter?: ThreadSummaryFilter): Promise<ThreadSummary[]>;
+    listRuns(filter?: RunSummaryFilter): Promise<RunSummary[]>;
     getRun(runId: string): Promise<RunSummary | null>;
     getSession(threadId: string): Promise<ThreadSummary | null>;
     getThreadMeta(threadId: string): Promise<PersistenceThreadMeta | null>;
     listThreadRuns(threadId: string): Promise<ThreadRunRecord[]>;
     listRunEvents(threadId: string, runId: string): Promise<HarnessEvent[]>;
-    listApprovals(): Promise<InternalApprovalRecord[]>;
+    listApprovals(filter?: ApprovalFilter): Promise<InternalApprovalRecord[]>;
     getApproval(approvalId: string): Promise<InternalApprovalRecord | null>;
     getRunApprovals(threadId: string, runId: string): Promise<InternalApprovalRecord[]>;
     getRunMeta(threadId: string, runId: string): Promise<PersistenceRunMeta>;

package/dist/persistence/sqlite-store.js

@@ -25,6 +25,16 @@ function toSqliteUrl(filePath) {
 function nowIso() {
     return new Date(Date.now()).toISOString();
 }
+function buildWhereClause(filters) {
+    const active = filters.filter(([, value]) => value !== undefined);
+    if (active.length === 0) {
+        return { clause: "", args: [] };
+    }
+    return {
+        clause: ` WHERE ${active.map(([sql]) => sql).join(" AND ")}`,
+        args: active.map(([, value]) => value),
+    };
+}
 async function selectProtectedThreadIds(dbPath) {
     if (!(await fileExists(dbPath))) {
         return [];
@@ -377,16 +387,24 @@ export class SqlitePersistence {
        (thread_id, run_id, sequence, event_json, created_at)
        VALUES (?, ?, ?, ?, ?)`, [event.threadId, event.runId, event.sequence, JSON.stringify(event), event.timestamp]);
     }
-    async listSessions() {
+    async listSessions(filter = {}) {
+        const { clause, args } = buildWhereClause([
+            ["entry_agent_id = ?", filter.agentId],
+        ]);
         const rows = await this.selectAll(`SELECT thread_id, entry_agent_id, latest_run_id, created_at, updated_at, status
-       FROM threads
-       ORDER BY updated_at DESC`);
+       FROM threads${clause}
+       ORDER BY updated_at DESC`, args);
         return rows.map((row) => this.mapThreadSummary(row));
     }
-    async listRuns() {
+    async listRuns(filter = {}) {
+        const { clause, args } = buildWhereClause([
+            ["agent_id = ?", filter.agentId],
+            ["thread_id = ?", filter.threadId],
+            ["state = ?", filter.state],
+        ]);
         const rows = await this.selectAll(`SELECT run_id, thread_id, agent_id, execution_mode, adapter_kind, created_at, updated_at, state, checkpoint_ref, resumable
-       FROM runs
-       ORDER BY updated_at DESC`);
+       FROM runs${clause}
+       ORDER BY updated_at DESC`, args);
         return rows.map((row) => this.mapRunSummary(row));
     }
     async getRun(runId) {
@@ -430,8 +448,13 @@ export class SqlitePersistence {
        ORDER BY sequence ASC`, [threadId, runId]);
         return rows.map((row) => parseJson(row.event_json));
     }
-    async listApprovals() {
-        const rows = await this.selectAll("SELECT * FROM approvals ORDER BY requested_at ASC, approval_id ASC");
+    async listApprovals(filter = {}) {
+        const { clause, args } = buildWhereClause([
+            ["status = ?", filter.status],
+            ["thread_id = ?", filter.threadId],
+            ["run_id = ?", filter.runId],
+        ]);
+        const rows = await this.selectAll(`SELECT * FROM approvals${clause} ORDER BY requested_at ASC, approval_id ASC`, args);
         return rows.map((row) => this.mapApproval(row));
     }
     async getApproval(approvalId) {

package/dist/persistence/types.d.ts

@@ -59,6 +59,19 @@ export type PersistedRunControlRecord = {
     workerId: string | null;
     workerStartedAt: string | null;
 };
+export type ThreadSummaryFilter = {
+    agentId?: string;
+};
+export type RunSummaryFilter = {
+    agentId?: string;
+    threadId?: string;
+    state?: RunSummary["state"];
+};
+export type ApprovalFilter = {
+    status?: InternalApprovalRecord["status"];
+    threadId?: string;
+    runId?: string;
+};
 export interface RuntimePersistence {
     initialize(): Promise<void>;
     createThread(input: {
@@ -78,13 +91,13 @@ export interface RuntimePersistence {
     }): Promise<void>;
     setRunState(threadId: string, runId: string, state: RunState, checkpointRef?: string | null): Promise<void>;
     appendEvent(event: HarnessEvent): Promise<void>;
-    listSessions(): Promise<ThreadSummary[]>;
-    listRuns(): Promise<RunSummary[]>;
+    listSessions(filter?: ThreadSummaryFilter): Promise<ThreadSummary[]>;
+    listRuns(filter?: RunSummaryFilter): Promise<RunSummary[]>;
     getRun(runId: string): Promise<RunSummary | null>;
     getSession(threadId: string): Promise<ThreadSummary | null>;
     getThreadMeta(threadId: string): Promise<PersistenceThreadMeta | null>;
     listThreadRuns(threadId: string): Promise<ThreadRunRecord[]>;
-    listApprovals(): Promise<InternalApprovalRecord[]>;
+    listApprovals(filter?: ApprovalFilter): Promise<InternalApprovalRecord[]>;
     getApproval(approvalId: string): Promise<InternalApprovalRecord | null>;
     getRunApprovals(threadId: string, runId: string): Promise<InternalApprovalRecord[]>;
     getRunMeta(threadId: string, runId: string): Promise<PersistenceRunMeta>;

package/dist/runtime/agent-runtime-adapter.d.ts

@@ -21,7 +21,10 @@ export declare function materializeDeepAgentSkillSourcePaths(options: {
 }): Promise<string[] | undefined>;
 export declare class AgentRuntimeAdapter {
     private readonly options;
+    private readonly modelCache;
+    private readonly runnableCache;
     constructor(options?: RuntimeAdapterOptions);
+    private getModelCacheKey;
     private resolveBindingTimeout;
     private resolveStreamIdleTimeout;
     private resolveProviderRetryPolicy;
@@ -48,11 +51,13 @@ export declare class AgentRuntimeAdapter {
     private resolveBuiltinMiddlewareBackend;
     private invokeBuiltinTaskTool;
     private resolveBuiltinMiddlewareTools;
+    private canReplayToolCallsLocally;
     private resolveLangChainAutomaticMiddleware;
     private resolveMiddleware;
     private resolveCheckpointer;
     private buildRouteSystemPrompt;
     private resolveSubagents;
+    private createRunnable;
     create(binding: CompiledAgentBinding): Promise<RunnableLike>;
     route(input: MessageContent, primaryBinding: CompiledAgentBinding, secondaryBinding: CompiledAgentBinding, options?: {
         systemPrompt?: string;

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

@@ -471,9 +471,19 @@ function asStructuredExecutableTool(resolvedTool, modelFacingName, description)
 }
 export class AgentRuntimeAdapter {
     options;
+    modelCache = new Map();
+    runnableCache = new WeakMap();
     constructor(options = {}) {
         this.options = options;
     }
+    getModelCacheKey(model) {
+        return JSON.stringify({
+            id: model.id,
+            runtimeValue: model.runtimeValue,
+            init: model.init,
+            clientRef: model.clientRef,
+        });
+    }
     resolveBindingTimeout(binding) {
         return resolveTimeoutMs(getBindingModelInit(binding)?.timeout);
     }
@@ -686,25 +696,40 @@ export class AgentRuntimeAdapter {
         return sanitizeVisibleText(extractVisibleOutput(synthesized));
     }
     async resolveModel(model) {
-        if (this.options.modelResolver) {
-            return wrapResolvedModel(await this.options.modelResolver(model.id));
-        }
-        if (model.provider === "ollama") {
-            return wrapResolvedModel(new ChatOllama({ model: model.model, ...model.init }));
-        }
-        if (model.provider === "openai-compatible") {
-            return wrapResolvedModel(new ChatOpenAI({ model: model.model, ...normalizeOpenAICompatibleInit(model.init) }));
+        const cacheKey = this.getModelCacheKey(model);
+        const cached = this.modelCache.get(cacheKey);
+        if (cached) {
+            return cached;
         }
-        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 }));
+        const pending = (async () => {
+            if (this.options.modelResolver) {
+                return wrapResolvedModel(await this.options.modelResolver(model.id));
+            }
+            if (model.provider === "ollama") {
+                return wrapResolvedModel(new ChatOllama({ model: model.model, ...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 }));
+        })();
+        this.modelCache.set(cacheKey, pending);
+        try {
+            return await pending;
         }
-        if (model.provider === "google" || model.provider === "google-genai" || model.provider === "gemini") {
-            return wrapResolvedModel(new ChatGoogle({ model: model.model, ...model.init }));
+        catch (error) {
+            this.modelCache.delete(cacheKey);
+            throw error;
         }
-        return wrapResolvedModel(await initChatModel(model.model, { modelProvider: model.provider, ...model.init }));
     }
     buildToolNameMapping(tools) {
         return buildToolNameMapping(tools);
@@ -1065,6 +1090,27 @@ export class AgentRuntimeAdapter {
         }
         return tools;
     }
+    canReplayToolCallsLocally(binding, toolCalls, primaryTools, toolNameMapping, executableTools, builtinExecutableTools) {
+        if (toolCalls.length === 0) {
+            return false;
+        }
+        if (isLangChainBinding(binding)) {
+            return true;
+        }
+        return toolCalls.every((toolCall) => {
+            const resolvedToolName = resolveModelFacingToolName(toolCall.name, toolNameMapping, primaryTools);
+            const executable = executableTools.get(toolCall.name) ?? executableTools.get(resolvedToolName);
+            if (executable) {
+                return false;
+            }
+            const builtinExecutable = builtinExecutableTools.get(toolCall.name) ??
+                builtinExecutableTools.get(resolvedToolName) ??
+                createModelFacingToolNameLookupCandidates(toolCall.name)
+                    .map((candidate) => builtinExecutableTools.get(candidate))
+                    .find((candidate) => candidate !== undefined);
+            return builtinExecutable !== undefined;
+        });
+    }
     async resolveLangChainAutomaticMiddleware(binding) {
         const params = getBindingLangChainParams(binding);
         if (!params) {
@@ -1170,7 +1216,7 @@ export class AgentRuntimeAdapter {
             })),
         })));
     }
-    async create(binding) {
+    async createRunnable(binding) {
         if (isLangChainBinding(binding)) {
             const params = getBindingLangChainParams(binding);
             const interruptOn = this.resolveInterruptOn(binding);
@@ -1226,6 +1272,21 @@ export class AgentRuntimeAdapter {
         };
         return createDeepAgent(deepAgentConfig);
     }
+    async create(binding) {
+        const cached = this.runnableCache.get(binding);
+        if (cached) {
+            return cached;
+        }
+        const pending = this.createRunnable(binding);
+        this.runnableCache.set(binding, pending);
+        try {
+            return await pending;
+        }
+        catch (error) {
+            this.runnableCache.delete(binding);
+            throw error;
+        }
+    }
     async route(input, primaryBinding, secondaryBinding, options = {}) {
         const routeModelConfig = getBindingPrimaryModel(primaryBinding) ??
             getBindingPrimaryModel(secondaryBinding);
@@ -1323,12 +1384,17 @@ export class AgentRuntimeAdapter {
                 let activeRequest = request;
                 let currentMessages = Array.isArray(activeRequest.messages) ? [...activeRequest.messages] : [];
                 const maxToolIterations = 8;
+                let pendingResult;
                 for (let iteration = 0; iteration < maxToolIterations; iteration += 1) {
-                    result = await callRuntimeWithToolParseRecovery(activeRequest);
+                    result = pendingResult ?? await callRuntimeWithToolParseRecovery(activeRequest);
+                    pendingResult = undefined;
                     const toolCalls = extractToolCallsFromResult(result);
                     if (toolCalls.length === 0) {
                         break;
                     }
+                    if (!this.canReplayToolCallsLocally(binding, toolCalls, primaryTools, toolNameMapping, executableTools, builtinExecutableTools)) {
+                        break;
+                    }
                     if (iteration + 1 === maxToolIterations) {
                         throw new Error(`Tool-calling loop exceeded the maximum of ${maxToolIterations} iterations`);
                     }

package/dist/runtime/harness.js

@@ -261,26 +261,10 @@ export class AgentHarnessRuntime {
         return tools.every((tool) => tool.retryable === true);
     }
     async listThreads(filter) {
-        const threadSummaries = await this.persistence.listSessions();
-        if (!filter?.agentId) {
-            return threadSummaries;
-        }
-        return threadSummaries.filter((thread) => thread.agentId === filter.agentId);
+        return this.persistence.listSessions(filter);
     }
     async listRuns(filter) {
-        const runs = await this.persistence.listRuns();
-        return runs.filter((run) => {
-            if (filter?.agentId && run.agentId !== filter.agentId) {
-                return false;
-            }
-            if (filter?.threadId && run.threadId !== filter.threadId) {
-                return false;
-            }
-            if (filter?.state && run.state !== filter.state) {
-                return false;
-            }
-            return true;
-        });
+        return this.persistence.listRuns(filter);
     }
     async getRun(runId) {
         return this.persistence.getRun(runId);
@@ -324,21 +308,8 @@ export class AgentHarnessRuntime {
         };
     }
     async listApprovals(filter) {
-        const approvals = filter?.threadId && filter?.runId
-            ? await this.persistence.getRunApprovals(filter.threadId, filter.runId)
-            : await this.persistence.listApprovals();
-        return approvals.filter((approval) => {
-            if (filter?.status && approval.status !== filter.status) {
-                return false;
-            }
-            if (filter?.threadId && approval.threadId !== filter.threadId) {
-                return false;
-            }
-            if (filter?.runId && approval.runId !== filter.runId) {
-                return false;
-            }
-            return true;
-        }).map((approval) => this.toPublicApprovalRecord(approval));
+        const approvals = await this.persistence.listApprovals(filter);
+        return approvals.map((approval) => this.toPublicApprovalRecord(approval));
     }
     async getApproval(approvalId) {
         const approval = await this.persistence.getApproval(approvalId);

package/package.json

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