@botbotgo/agent-harness 0.0.80 → 0.0.82

package/dist/persistence/sqlite-store.js

@@ -2,7 +2,7 @@ import path from "node:path";
 import { mkdir, rm } from "node:fs/promises";
 import { createClient } from "@libsql/client";
 import { fileExists, readJson, writeJson } from "../utils/fs.js";
-const RUNTIME_SQLITE_SCHEMA_VERSION = 1;
+const RUNTIME_SQLITE_SCHEMA_VERSION = 2;
 const RUNTIME_SQLITE_SCHEMA_FAMILY = "agent-harness-runtime";
 function asRow(value) {
     return value;
@@ -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 [];
@@ -187,6 +197,37 @@ export class SqlitePersistence {
           FOREIGN KEY (thread_id) REFERENCES threads(thread_id),
           FOREIGN KEY (run_id) REFERENCES runs(run_id)
         )
+      `);
+            await this.rawExecute(`
+        CREATE TABLE IF NOT EXISTS run_queue (
+          run_id TEXT PRIMARY KEY,
+          thread_id TEXT NOT NULL,
+          priority INTEGER NOT NULL DEFAULT 0,
+          queue_key TEXT,
+          enqueued_at TEXT NOT NULL,
+          available_at TEXT NOT NULL,
+          claimed_by TEXT,
+          claimed_at TEXT,
+          lease_expires_at TEXT,
+          attempt_count INTEGER NOT NULL DEFAULT 0,
+          last_error TEXT,
+          FOREIGN KEY (thread_id) REFERENCES threads(thread_id),
+          FOREIGN KEY (run_id) REFERENCES runs(run_id)
+        )
+      `);
+            await this.rawExecute("CREATE INDEX IF NOT EXISTS run_queue_available_idx ON run_queue(available_at, priority DESC, enqueued_at ASC)");
+            await this.rawExecute("CREATE INDEX IF NOT EXISTS run_queue_claim_idx ON run_queue(claimed_by, lease_expires_at)");
+            await this.rawExecute(`
+        CREATE TABLE IF NOT EXISTS run_control (
+          run_id TEXT PRIMARY KEY,
+          cancel_requested INTEGER NOT NULL DEFAULT 0,
+          cancel_reason TEXT,
+          cancel_requested_at TEXT,
+          heartbeat_at TEXT,
+          worker_id TEXT,
+          worker_started_at TEXT,
+          FOREIGN KEY (run_id) REFERENCES runs(run_id)
+        )
       `);
             await this.rawExecute(`
         CREATE TABLE IF NOT EXISTS artifacts (
@@ -292,6 +333,10 @@ export class SqlitePersistence {
         if (family !== RUNTIME_SQLITE_SCHEMA_FAMILY) {
             throw new Error(`Unsupported runtime sqlite schema family ${JSON.stringify(family)} in ${this.dbPath}. Expected ${JSON.stringify(RUNTIME_SQLITE_SCHEMA_FAMILY)}.`);
         }
+        if (version === "1") {
+            await this.rawExecute("INSERT OR REPLACE INTO runtime_metadata (key, value) VALUES (?, ?)", ["schema_version", String(RUNTIME_SQLITE_SCHEMA_VERSION)]);
+            return;
+        }
         if (version !== String(RUNTIME_SQLITE_SCHEMA_VERSION)) {
             throw new Error(`Unsupported runtime sqlite schema version ${JSON.stringify(version)} in ${this.dbPath}. Expected ${RUNTIME_SQLITE_SCHEMA_VERSION}.`);
         }
@@ -321,6 +366,9 @@ export class SqlitePersistence {
             0,
             null,
         ]);
+        await this.execute(`INSERT OR REPLACE INTO run_control
+       (run_id, cancel_requested, cancel_reason, cancel_requested_at, heartbeat_at, worker_id, worker_started_at)
+       VALUES (?, 0, NULL, NULL, NULL, NULL, NULL)`, [input.runId]);
     }
     async setRunState(threadId, runId, state, checkpointRef) {
         const current = await this.getRunLifecycle(threadId, runId);
@@ -339,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) {
@@ -392,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) {
@@ -445,9 +506,11 @@ export class SqlitePersistence {
         await this.execute("DELETE FROM artifacts WHERE thread_id = ?", [threadId]);
         await this.execute("DELETE FROM approvals WHERE thread_id = ?", [threadId]);
         await this.execute("DELETE FROM events WHERE thread_id = ?", [threadId]);
+        await this.execute("DELETE FROM run_queue WHERE thread_id = ?", [threadId]);
         await this.execute("DELETE FROM run_requests WHERE thread_id = ?", [threadId]);
         await this.execute("DELETE FROM recovery_intents WHERE thread_id = ?", [threadId]);
         await this.execute("DELETE FROM thread_messages WHERE thread_id = ?", [threadId]);
+        await this.execute("DELETE FROM run_control WHERE run_id IN (SELECT run_id FROM runs WHERE thread_id = ?)", [threadId]);
         await this.execute("DELETE FROM runs WHERE thread_id = ?", [threadId]);
         await this.execute("DELETE FROM threads WHERE thread_id = ?", [threadId]);
         await rm(this.threadDir(threadId), { recursive: true, force: true });
@@ -559,6 +622,108 @@ export class SqlitePersistence {
     async clearRecoveryIntent(threadId, runId) {
         await this.execute("DELETE FROM recovery_intents WHERE thread_id = ? AND run_id = ?", [threadId, runId]);
     }
+    mapQueuedRun(row) {
+        return {
+            runId: asString(row.run_id),
+            threadId: asString(row.thread_id),
+            priority: Number(row.priority ?? 0),
+            queueKey: asNullableString(row.queue_key),
+            enqueuedAt: asString(row.enqueued_at),
+            availableAt: asString(row.available_at),
+            claimedBy: asNullableString(row.claimed_by),
+            claimedAt: asNullableString(row.claimed_at),
+            leaseExpiresAt: asNullableString(row.lease_expires_at),
+            attemptCount: Number(row.attempt_count ?? 0),
+            lastError: asNullableString(row.last_error),
+        };
+    }
+    mapRunControl(row) {
+        return {
+            runId: asString(row.run_id),
+            cancelRequested: asBoolean(row.cancel_requested),
+            cancelReason: asNullableString(row.cancel_reason),
+            cancelRequestedAt: asNullableString(row.cancel_requested_at),
+            heartbeatAt: asNullableString(row.heartbeat_at),
+            workerId: asNullableString(row.worker_id),
+            workerStartedAt: asNullableString(row.worker_started_at),
+        };
+    }
+    async enqueueRun(input) {
+        const enqueuedAt = nowIso();
+        await this.execute(`INSERT OR REPLACE INTO run_queue
+       (run_id, thread_id, priority, queue_key, enqueued_at, available_at, claimed_by, claimed_at, lease_expires_at, attempt_count, last_error)
+       VALUES (?, ?, ?, ?, ?, ?, NULL, NULL, NULL, COALESCE((SELECT attempt_count FROM run_queue WHERE run_id = ?), 0), NULL)`, [
+            input.runId,
+            input.threadId,
+            input.priority ?? 0,
+            input.queueKey ?? null,
+            enqueuedAt,
+            input.availableAt ?? enqueuedAt,
+            input.runId,
+        ]);
+    }
+    async getQueuedRun(runId) {
+        const row = await this.selectOne("SELECT * FROM run_queue WHERE run_id = ?", [runId]);
+        return row ? this.mapQueuedRun(row) : null;
+    }
+    async claimQueuedRun(input) {
+        const claimedAt = input.claimedAt ?? nowIso();
+        await this.execute(`UPDATE run_queue
+       SET claimed_by = ?, claimed_at = ?, lease_expires_at = ?, attempt_count = attempt_count + 1
+       WHERE run_id = ? AND thread_id = ?`, [input.workerId, claimedAt, input.leaseExpiresAt, input.runId, input.threadId]);
+        await this.execute(`UPDATE run_control
+       SET heartbeat_at = ?, worker_id = ?, worker_started_at = COALESCE(worker_started_at, ?)
+       WHERE run_id = ?`, [claimedAt, input.workerId, claimedAt, input.runId]);
+        const claimed = await this.getQueuedRun(input.runId);
+        if (!claimed) {
+            throw new Error(`Missing queued run ${input.runId}`);
+        }
+        return claimed;
+    }
+    async renewRunLease(input) {
+        const heartbeatAt = input.heartbeatAt ?? nowIso();
+        await this.execute(`UPDATE run_queue
+       SET lease_expires_at = ?, claimed_by = COALESCE(claimed_by, ?), claimed_at = COALESCE(claimed_at, ?)
+       WHERE run_id = ?`, [input.leaseExpiresAt, input.workerId, heartbeatAt, input.runId]);
+        await this.execute(`UPDATE run_control
+       SET heartbeat_at = ?, worker_id = ?, worker_started_at = COALESCE(worker_started_at, ?)
+       WHERE run_id = ?`, [heartbeatAt, input.workerId, heartbeatAt, input.runId]);
+    }
+    async releaseRunClaim(runId) {
+        await this.execute("DELETE FROM run_queue WHERE run_id = ?", [runId]);
+        await this.execute(`UPDATE run_control
+       SET heartbeat_at = NULL, worker_id = NULL, worker_started_at = NULL
+       WHERE run_id = ?`, [runId]);
+    }
+    async listExpiredClaimedRuns(cutoffIso) {
+        const rows = await this.selectAll(`SELECT *
+       FROM run_queue
+       WHERE claimed_by IS NOT NULL
+         AND lease_expires_at IS NOT NULL
+         AND lease_expires_at <= ?
+       ORDER BY lease_expires_at ASC, run_id ASC`, [cutoffIso]);
+        return rows.map((row) => this.mapQueuedRun(row));
+    }
+    async getRunControl(runId) {
+        const row = await this.selectOne("SELECT * FROM run_control WHERE run_id = ?", [runId]);
+        return row ? this.mapRunControl(row) : null;
+    }
+    async requestRunCancel(runId, reason) {
+        const now = nowIso();
+        await this.execute(`UPDATE run_control
+       SET cancel_requested = 1, cancel_reason = ?, cancel_requested_at = ?
+       WHERE run_id = ?`, [reason ?? null, now, runId]);
+        const updated = await this.getRunControl(runId);
+        if (!updated) {
+            throw new Error(`Missing run control for ${runId}`);
+        }
+        return updated;
+    }
+    async clearRunCancel(runId) {
+        await this.execute(`UPDATE run_control
+       SET cancel_requested = 0, cancel_reason = NULL, cancel_requested_at = NULL
+       WHERE run_id = ?`, [runId]);
+    }
     async readArtifact(threadId, runId, artifactPath) {
         const filePath = path.join(this.runDir(threadId, runId), artifactPath);
         if (!(await fileExists(filePath))) {

package/dist/persistence/types.d.ts

@@ -37,6 +37,41 @@ export type RecoveryIntent = {
     resumePayload: unknown;
     attempts: number;
 };
+export type PersistedRunQueueRecord = {
+    runId: string;
+    threadId: string;
+    priority: number;
+    queueKey: string | null;
+    enqueuedAt: string;
+    availableAt: string;
+    claimedBy: string | null;
+    claimedAt: string | null;
+    leaseExpiresAt: string | null;
+    attemptCount: number;
+    lastError: string | null;
+};
+export type PersistedRunControlRecord = {
+    runId: string;
+    cancelRequested: boolean;
+    cancelReason: string | null;
+    cancelRequestedAt: string | null;
+    heartbeatAt: string | null;
+    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: {
@@ -56,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>;
@@ -80,4 +115,30 @@ export interface RuntimePersistence {
     saveRecoveryIntent(threadId: string, runId: string, intent: RecoveryIntent): Promise<void>;
     getRecoveryIntent(threadId: string, runId: string): Promise<RecoveryIntent | null>;
     clearRecoveryIntent(threadId: string, runId: string): Promise<void>;
+    enqueueRun(input: {
+        threadId: string;
+        runId: string;
+        priority?: number;
+        queueKey?: string | null;
+        availableAt?: string;
+    }): Promise<void>;
+    getQueuedRun(runId: string): Promise<PersistedRunQueueRecord | null>;
+    claimQueuedRun(input: {
+        threadId: string;
+        runId: string;
+        workerId: string;
+        claimedAt?: string;
+        leaseExpiresAt: string;
+    }): Promise<PersistedRunQueueRecord>;
+    renewRunLease(input: {
+        runId: string;
+        workerId: string;
+        heartbeatAt?: string;
+        leaseExpiresAt: string;
+    }): Promise<void>;
+    releaseRunClaim(runId: string): Promise<void>;
+    listExpiredClaimedRuns(cutoffIso: string): Promise<PersistedRunQueueRecord[]>;
+    getRunControl(runId: string): Promise<PersistedRunControlRecord | null>;
+    requestRunCancel(runId: string, reason?: string): Promise<PersistedRunControlRecord>;
+    clearRunCancel(runId: string): Promise<void>;
 }

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) }));
-        }
-        if (model.provider === "openai") {
-            return wrapResolvedModel(new ChatOpenAI({ model: model.model, ...model.init }));
+        const cacheKey = this.getModelCacheKey(model);
+        const cached = this.modelCache.get(cacheKey);
+        if (cached) {
+            return cached;
         }
-        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`);
                     }
@@ -1377,7 +1443,15 @@ export class AgentRuntimeAdapter {
         const visibleOutput = extractedOutput && !isLikelyToolArgsObject(tryParseJson(extractedOutput)) ? extractedOutput : "";
         const emptyAssistantMessageFailure = extractEmptyAssistantMessageFailure(result);
         const toolFallback = extractToolFallbackContext(result);
-        const synthesizedOutput = await this.synthesizeDeepAgentAnswer(binding, input, result);
+        let synthesizedOutput = "";
+        try {
+            synthesizedOutput = await this.synthesizeDeepAgentAnswer(binding, input, result);
+        }
+        catch (error) {
+            if (!(error instanceof RuntimeOperationTimeoutError) || !toolFallback) {
+                throw error;
+            }
+        }
         if (!visibleOutput && !synthesizedOutput && !toolFallback && emptyAssistantMessageFailure) {
             throw new Error(emptyAssistantMessageFailure);
         }

package/dist/runtime/harness.d.ts

@@ -1,4 +1,4 @@
-import type { ApprovalRecord, HarnessEvent, HarnessStreamItem, RuntimeHealthSnapshot, MessageContent, RunRecord, RunStartOptions, RestartConversationOptions, RuntimeAdapterOptions, ResumeOptions, RunOptions, RunResult, RunSummary, ThreadSummary, ThreadRecord, WorkspaceBundle } from "../contracts/types.js";
+import type { ApprovalRecord, CancelOptions, HarnessEvent, HarnessStreamItem, RuntimeHealthSnapshot, MessageContent, RunRecord, RunStartOptions, RestartConversationOptions, RuntimeAdapterOptions, ResumeOptions, RunOptions, RunResult, RunSummary, ThreadSummary, ThreadRecord, WorkspaceBundle } from "../contracts/types.js";
 import { type ToolMcpServerOptions } from "../mcp.js";
 import { type InventoryAgentRecord, type InventorySkillRecord } from "./inventory.js";
 import type { RequirementAssessmentOptions } from "./skill-requirements.js";
@@ -27,6 +27,7 @@ export declare class AgentHarnessRuntime {
     private readonly healthMonitor;
     private readonly recoveryConfig;
     private readonly concurrencyConfig;
+    private readonly workerId;
     private activeRunSlots;
     private readonly pendingRunSlots;
     private runtimeEventSequence;
@@ -84,6 +85,9 @@ export declare class AgentHarnessRuntime {
     private loadPriorHistory;
     private loadRunInput;
     private appendAssistantMessage;
+    private getRunCancellation;
+    private expirePendingApprovals;
+    private finalizeCancelledRun;
     private invokeWithHistory;
     private buildPersistedRunRequest;
     private executeQueuedRun;
@@ -100,6 +104,7 @@ export declare class AgentHarnessRuntime {
     private isDecisionRun;
     private notifyListener;
     private acquireRunSlot;
+    private dropPendingRunSlot;
     private dispatchRunListeners;
     run(options: RunOptions): Promise<RunResult>;
     streamEvents(options: RunStartOptions): AsyncGenerator<HarnessStreamItem>;
@@ -110,6 +115,9 @@ export declare class AgentHarnessRuntime {
     }>;
     close(): Promise<void>;
     stop(): Promise<void>;
+    cancelRun(options: CancelOptions): Promise<RunResult>;
     private recoverStartupRuns;
+    private reclaimExpiredClaimedRuns;
+    private isStaleRunningRun;
 }
 export { AgentHarnessRuntime as AgentHarness };