@botbotgo/agent-harness 0.0.342 → 0.0.344

package/dist/cli/chat-stream.d.ts

@@ -16,6 +16,7 @@ export declare function streamChatMessage(input: {
     colorRequestTree?: boolean;
     showToolResults?: boolean;
     showRunningState?: boolean;
+    idleProgressMs?: number;
 }): Promise<{
     sessionId?: string;
     requestId?: string;

package/dist/cli/chat-stream.js

@@ -3,6 +3,7 @@ import { countRenderedLines, renderChatRequestRunning, renderChatTextChunk, summ
 import { buildTerminalRequestSnapshot, buildTodoContinuationSignature, flattenRequestExecutionSteps, renderRequestEventContinuation, renderRequestSnapshotTree, renderRequestTodoContinuation, } from "./request-tree.js";
 export async function streamChatMessage(input) {
     const requestStartedAt = Date.now();
+    const idleProgressMs = input.idleProgressMs ?? 30_000;
     let firstSnapshotAt;
     let firstDataAt;
     let latestSnapshot;
@@ -27,6 +28,8 @@ export async function streamChatMessage(input) {
     const requestTreeRenderThrottleMs = 75;
     let suppressRequestTreeRendering = false;
     let lastStableRequestTreeKey;
+    let idleProgressTimer;
+    let lastRuntimeProgressAt = requestStartedAt;
     let stdoutWriteChain = Promise.resolve();
     let stderrWriteChain = Promise.resolve();
     const enqueueChatWrite = (sink, _stream, chain, message) => chain.then(async () => {
@@ -173,6 +176,27 @@ export async function streamChatMessage(input) {
         }
         stderrWriteChain = enqueueChatWrite(input.stderr, input.stderrStream, stderrWriteChain, message);
     };
+    const clearIdleProgressTimer = () => {
+        if (idleProgressTimer) {
+            clearTimeout(idleProgressTimer);
+            idleProgressTimer = undefined;
+        }
+    };
+    const scheduleIdleProgress = () => {
+        clearIdleProgressTimer();
+        if (idleProgressMs <= 0) {
+            return;
+        }
+        idleProgressTimer = setTimeout(() => {
+            const idleSeconds = Math.max(1, Math.round((Date.now() - lastRuntimeProgressAt) / 1000));
+            writeChatStderr(`[${formatPerfClock(Date.now())} +${formatElapsed(Date.now())}]${formatAgentProgressLabel(latestAgentId)} Still working; no runtime update for ${idleSeconds}s.\n`);
+            scheduleIdleProgress();
+        }, idleProgressMs);
+    };
+    const markRuntimeProgress = () => {
+        lastRuntimeProgressAt = Date.now();
+        scheduleIdleProgress();
+    };
     const suspendRequestTreeRendering = () => {
         if (!input.requestEvents || !input.liveRequestTree) {
             return;
@@ -258,6 +282,7 @@ export async function streamChatMessage(input) {
         ...(input.sessionId ? { sessionId: input.sessionId } : {}),
         input: input.message,
         eventListener(snapshot) {
+            markRuntimeProgress();
             latestSessionId = snapshot.sessionId || latestSessionId;
             latestRequestId = snapshot.requestId || latestRequestId;
             latestAgentId = snapshot.agentId || latestAgentId;
@@ -303,6 +328,7 @@ export async function streamChatMessage(input) {
             }
         },
         dataListener(delta) {
+            markRuntimeProgress();
             latestSessionId = delta.sessionId || latestSessionId;
             latestRequestId = delta.requestId || latestRequestId;
             firstDataAt ??= Date.now();
@@ -342,6 +368,7 @@ export async function streamChatMessage(input) {
             }
         },
     });
+    clearIdleProgressTimer();
     if (!result) {
         throw new Error("chat request completed without a terminal result");
     }

package/dist/cli/chat-workspace.js

@@ -161,10 +161,12 @@ export function renderChatRuntimeFailure(output, modelInfo) {
     if (!normalized.includes("fetch failed") &&
         !normalized.includes("connection error") &&
         !normalized.includes("timed out") &&
+        !normalized.includes("error 524") &&
         !normalized.includes("404 page not found")) {
         return output;
     }
     const lines = [trimmed];
+    const isTimeoutStyleError = /(\berror 524\b|\btimeout\b|\btimed out\b)/i.test(trimmed);
     if (modelInfo?.provider || modelInfo?.model) {
         lines.push(`provider=${modelInfo?.provider ?? "unknown"}${modelInfo?.model ? ` model=${modelInfo.model}` : ""}`);
     }
@@ -178,6 +180,9 @@ export function renderChatRuntimeFailure(output, modelInfo) {
     if (hint) {
         lines.push(hint);
     }
+    if (isTimeoutStyleError) {
+        lines.push("Hint: this usually indicates the model endpoint dropped the connection before producing a full answer.");
+    }
     return lines.join("\n");
 }
 export async function probeChatWorkspace(input) {

package/dist/cli.js

@@ -4,5 +4,5 @@ import { runCli, resolveInvokedCliHref } from "./cli/main.js";
 const invokedPath = resolveInvokedCliHref(process.argv[1]);
 if (import.meta.url === invokedPath) {
     const exitCode = await runCli(process.argv.slice(2));
-    process.exitCode = exitCode;
+    process.exit(exitCode);
 }

package/dist/contracts/workspace.d.ts

@@ -187,6 +187,7 @@ export type CompiledSubAgent = {
     builtinTools?: {
         filesystem?: boolean;
         todos?: boolean;
+        modelExposed?: boolean | string[];
     };
 };
 export type CompiledAsyncSubAgent = {
@@ -197,6 +198,11 @@ export type CompiledAsyncSubAgent = {
     headers?: Record<string, string>;
 };
 export type CompiledDeepAgentSubAgent = CompiledSubAgent | CompiledAsyncSubAgent;
+export type CompiledBuiltinToolsConfig = {
+    filesystem?: boolean;
+    todos?: boolean;
+    modelExposed?: boolean | string[];
+};
 export type LangChainAgentParams = {
     model: CompiledModel;
     tools: CompiledTool[];
@@ -209,6 +215,7 @@ export type LangChainAgentParams = {
     version?: "v1" | "v2";
     name?: string;
     description: string;
+    builtinTools?: CompiledBuiltinToolsConfig;
 };
 export type DeepAgentParams = {
     model: CompiledModel;
@@ -225,10 +232,7 @@ export type DeepAgentParams = {
     memory: string[];
     skills: string[];
     interactionMode?: "stream" | "invoke";
-    builtinTools?: {
-        filesystem?: boolean;
-        todos?: boolean;
-    };
+    builtinTools?: CompiledBuiltinToolsConfig;
 };
 export type LegacyLangChainAgentParams = LangChainAgentParams & {
     passthrough?: Record<string, unknown>;

package/dist/package-version.d.ts

@@ -1,2 +1,2 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.342";
+export declare const AGENT_HARNESS_VERSION = "0.0.344";
 export declare const AGENT_HARNESS_RELEASE_DATE = "2026-04-24";

package/dist/package-version.js

@@ -1,2 +1,2 @@
-export const AGENT_HARNESS_VERSION = "0.0.342";
+export const AGENT_HARNESS_VERSION = "0.0.344";
 export const AGENT_HARNESS_RELEASE_DATE = "2026-04-24";

package/dist/runtime/adapter/flow/stream-runtime.js

@@ -84,6 +84,19 @@ function hasMissingDelegatedExecutionEvidence(evidence) {
 function hasMissingDelegatedFindings(evidence) {
     return evidence.hasDelegatedAgentWithConfiguredTools && evidence.hasOnlyPlaceholderTaskCompletion;
 }
+function isRuntimeFailureOutput(value) {
+    return value.trim().startsWith("runtime_error=");
+}
+function resolveStreamedRuntimeFailureRecoveryInstruction(output, evidence) {
+    if (!isRuntimeFailureOutput(output)) {
+        return null;
+    }
+    const hasExecutionEvidence = evidence.hasToolResultEvidence
+        || evidence.hasPlanStateEvidence
+        || evidence.hasOpenTaskDelegation
+        || evidence.hasDelegatedExecutionToolEvidence;
+    return hasExecutionEvidence ? null : EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION;
+}
 function resolveDelegatedExecutionRecoveryInstruction(evidence) {
     if (hasMissingDelegatedFindings(evidence)
         || (evidence.hasOpenTaskDelegation
@@ -442,6 +455,9 @@ export async function* streamRuntimeExecution(options) {
                     hasMissingDelegatedExecutionEvidence: hasMissingDelegatedExecutionEvidence(streamedExecutionEvidence),
                 })
                 : null;
+            const streamedRuntimeFailureRecoveryInstruction = projectionState.emittedOutput
+                ? resolveStreamedRuntimeFailureRecoveryInstruction(projectionState.emittedOutput, streamedExecutionEvidence)
+                : null;
             const missingPlanRecoveryInstruction = !hasUnresolvedExecution(streamedExecutionEvidence) && !delegatedExecutionRecoveryInstruction
                 ? resolveMissingPlanRecoveryInstruction({
                     request,
@@ -453,7 +469,10 @@ export async function* streamRuntimeExecution(options) {
                 : null;
             const retryInstruction = !emittedUnsafeStreamSideEffects && sawRetrySafeInvalidToolSelectionError
                 ? INVALID_TOOL_SELECTION_RECOVERY_INSTRUCTION
-                : delegatedExecutionRecoveryInstruction ?? missingPlanRecoveryInstruction ?? executionWithoutToolEvidenceInstruction;
+                : delegatedExecutionRecoveryInstruction
+                    ?? streamedRuntimeFailureRecoveryInstruction
+                    ?? missingPlanRecoveryInstruction
+                    ?? executionWithoutToolEvidenceInstruction;
             if (retryInstruction) {
                 let retried;
                 retried = await options.invoke(options.applyToolRecoveryInstruction(options.binding, retryInstruction), options.input, options.sessionId, options.runtimeOptions.requestId ?? options.sessionId, undefined, options.history, options.runtimeOptions);

package/dist/runtime/adapter/resilience.js

@@ -32,6 +32,10 @@ export function resolveStreamIdleTimeout(binding) {
 }
 const BUILTIN_RETRYABLE_PROVIDER_MESSAGES = [
     "unexpected eof",
+    "other side closed",
+    "socket hang up",
+    "connection reset",
+    "econnreset",
 ];
 function isEmptyFinalAiMessageError(error) {
     const message = error instanceof Error ? error.message : String(error);

package/dist/runtime/adapter/tool/builtin-middleware-tools.d.ts

@@ -246,6 +246,7 @@ export declare const BUILTIN_MIDDLEWARE_TOOL_DESCRIPTORS: readonly [{
 export declare function filterBuiltinMiddlewareToolDescriptors(options?: {
     filesystem?: boolean;
     todos?: boolean;
+    modelExposed?: boolean | string[];
 }): Array<{
     name: string;
     description: string;

package/dist/runtime/adapter/tool/builtin-middleware-tools.js

@@ -29,6 +29,16 @@ export const BUILTIN_MIDDLEWARE_TOOL_DESCRIPTORS = [
     { name: "task", description: "Delegate a bounded task to a subagent." },
 ];
 export function filterBuiltinMiddlewareToolDescriptors(options) {
+    const modelExposedNames = new Set([
+        "fetch_url",
+        "http_request",
+        "send_message",
+        "request_approval",
+        "schedule_task",
+    ]);
+    const allowedModelExposedNames = Array.isArray(options?.modelExposed)
+        ? new Set(options.modelExposed)
+        : undefined;
     return BUILTIN_MIDDLEWARE_TOOL_DESCRIPTORS.filter((descriptor) => {
         if (options?.todos === false
             && (descriptor.name === "write_todos" || descriptor.name === "read_todos")) {
@@ -49,6 +59,14 @@ export function filterBuiltinMiddlewareToolDescriptors(options) {
             ].includes(descriptor.name)) {
             return false;
         }
+        if (modelExposedNames.has(descriptor.name)) {
+            if (options?.modelExposed === false) {
+                return false;
+            }
+            if (allowedModelExposedNames && !allowedModelExposedNames.has(descriptor.name)) {
+                return false;
+            }
+        }
         return true;
     }).map((descriptor) => ({ ...descriptor }));
 }

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

@@ -360,6 +360,7 @@ export class AgentRuntimeAdapter {
                 }),
             }),
             explicitToolNames: primaryTools.map((tool) => tool.name),
+            modelExposed: getBindingBuiltinToolsConfig(binding)?.modelExposed,
         });
         const resolvedMiddleware = await this.resolveMiddleware(binding, interruptOn, { sessionId: options.sessionId ?? options.legacySessionId });
         const resolvedCheckpointer = resolveRunnableCheckpointer(this.options, binding);
@@ -405,6 +406,7 @@ export class AgentRuntimeAdapter {
                 }),
             }),
             explicitToolNames: primaryTools.map((tool) => tool.name),
+            modelExposed: getBindingBuiltinToolsConfig(binding)?.modelExposed,
         });
         const resolvedMiddleware = await this.resolveMiddleware(binding);
         const resolvedSubagents = await this.resolveDeepAgentSubagents(getBindingDeepAgentSubagents(binding), binding, { sessionId: options.sessionId ?? options.legacySessionId });

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

@@ -6,6 +6,7 @@ export declare const DEFAULT_DEEPAGENT_RECURSION_LIMIT = 100;
 export declare function materializeModelExposedBuiltinMiddlewareTools(input: {
     builtinTools: Map<string, ExecutableTool>;
     explicitToolNames?: string[];
+    modelExposed?: boolean | string[];
 }): unknown[];
 export declare function resolveRunnableCheckpointer(options: RuntimeAdapterOptions, binding: CompiledAgentBinding): unknown;
 export declare function resolveRunnableInterruptOn(binding: CompiledAgentBinding): Record<string, {

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

@@ -18,12 +18,19 @@ const MODEL_EXPOSED_BUILTIN_MIDDLEWARE_TOOL_NAMES = new Set([
     "schedule_task",
 ]);
 export function materializeModelExposedBuiltinMiddlewareTools(input) {
+    if (input.modelExposed === false) {
+        return [];
+    }
     const explicitToolNames = new Set(input.explicitToolNames ?? []);
+    const allowedToolNames = Array.isArray(input.modelExposed)
+        ? new Set(input.modelExposed)
+        : undefined;
     const tools = [];
     for (const [toolName, tool] of input.builtinTools.entries()) {
         if (explicitToolNames.has(toolName)
             || BUILTIN_MIDDLEWARE_ALIAS_TOOL_NAMES.has(toolName)
-            || !MODEL_EXPOSED_BUILTIN_MIDDLEWARE_TOOL_NAMES.has(toolName)) {
+            || !MODEL_EXPOSED_BUILTIN_MIDDLEWARE_TOOL_NAMES.has(toolName)
+            || (allowedToolNames && !allowedToolNames.has(toolName))) {
             continue;
         }
         tools.push(asStructuredExecutableTool(tool, toolName, tool.name));

package/dist/runtime/harness/run/inspection.js

@@ -11,6 +11,13 @@ function asObject(value) {
 function readStringArray(value) {
     return Array.isArray(value) ? value.filter((item) => typeof item === "string" && item.trim().length > 0) : [];
 }
+const MODEL_EXPOSED_BUILTIN_TOOL_NAMES = new Set([
+    "fetch_url",
+    "http_request",
+    "send_message",
+    "request_approval",
+    "schedule_task",
+]);
 function getBindingSkillNames(binding) {
     if (!binding) {
         return [];
@@ -106,13 +113,20 @@ export function buildRequestRuntimeSnapshot(binding, options) {
         name: tool.name,
         description: tool.description,
     }));
+    const builtinToolsConfig = getBindingBuiltinToolsConfig(binding);
+    const builtinToolDescriptors = filterBuiltinMiddlewareToolDescriptors(builtinToolsConfig)
+        .filter((descriptor) => !declaredTools.some((tool) => tool.name === descriptor.name));
     const tools = isDeepAgentBinding(binding)
         ? [
             ...declaredTools,
-            ...filterBuiltinMiddlewareToolDescriptors(getBindingBuiltinToolsConfig(binding))
-                .filter((descriptor) => !declaredTools.some((tool) => tool.name === descriptor.name)),
+            ...builtinToolDescriptors,
         ]
-        : declaredTools;
+        : builtinToolsConfig !== undefined
+            ? [
+                ...declaredTools,
+                ...builtinToolDescriptors.filter((descriptor) => MODEL_EXPOSED_BUILTIN_TOOL_NAMES.has(descriptor.name)),
+            ]
+            : declaredTools;
     return {
         agentId: binding.agent.id,
         ...(model ? {

package/dist/runtime/harness/run/stream-run.js

@@ -332,7 +332,16 @@ function normalizeStreamChunk(chunk) {
     return { kind: "content", content: chunk.content ?? "" };
 }
 function normalizeCommentaryText(value) {
-    return value.replace(/\s+/g, " ").trim();
+    return value
+        .split("\n")
+        .map((line) => {
+        const leading = /^\s*/.exec(line)?.[0] ?? "";
+        const body = line.slice(leading.length).replace(/[^\S\n]+/g, " ").trimEnd();
+        return `${leading}${body}`;
+    })
+        .join("\n")
+        .replace(/\n{3,}/g, "\n\n")
+        .trim();
 }
 function ensureCommentarySentence(value) {
     const normalized = normalizeCommentaryText(value);
@@ -359,9 +368,9 @@ function summarizePlanState(planState) {
                 return "[ ]";
         }
     };
-    const items = planState.items.slice(0, 6).map((item) => `${statusMarker(item.status)} ${item.content}`);
-    const suffix = planState.items.length > items.length ? ` | +${planState.items.length - items.length} more` : "";
-    return `TODO: ${items.join(" | ")}${suffix}`;
+    const items = planState.items.slice(0, 6).map((item) => `  ${statusMarker(item.status)} ${item.content}`);
+    const suffix = planState.items.length > items.length ? [`  ... ${planState.items.length - items.length} more`] : [];
+    return ["TODO", ...items, ...suffix].join("\n");
 }
 function summarizePlanStateTerminalTransitions(previousPlanState, nextPlanState) {
     const previousByKey = new Map((previousPlanState?.items ?? []).map((item) => [normalizePlanItemKey(item), item]));
@@ -523,6 +532,45 @@ function createRuntimeMemoryRecallSteps(sessionId, requestId, items) {
         },
     ];
 }
+function readObject(value) {
+    return typeof value === "object" && value !== null ? value : null;
+}
+function isFallbackSafeUpstreamStartupEvent(event, rootAgentId) {
+    const typed = readObject(event);
+    const eventName = typeof typed?.event === "string" ? typed.event : "";
+    if (eventName.startsWith("on_chat_model_") || eventName.startsWith("on_llm_")) {
+        return true;
+    }
+    if (!eventName.startsWith("on_chain_")) {
+        return false;
+    }
+    if (typed?.run_type === "tool") {
+        return false;
+    }
+    const name = typeof typed?.name === "string" ? typed.name : "";
+    const metadata = readObject(typed?.metadata);
+    const langgraphNode = typeof metadata?.langgraph_node === "string" ? metadata.langgraph_node : "";
+    const langchainAgentName = typeof metadata?.lc_agent_name === "string" ? metadata.lc_agent_name : "";
+    return (name === "__start__"
+        || langgraphNode === "__start__"
+        || langgraphNode === "model_request"
+        || name.endsWith(".before_agent")
+        || name.endsWith(".before_model")
+        || (name === rootAgentId && langchainAgentName === rootAgentId));
+}
+function planStateHasAnyItems(planState) {
+    return (planState?.items.length ?? 0) > 0;
+}
+function isStartupRuntimeFailureOutput(value) {
+    const normalized = value.trim().toLowerCase();
+    if (!normalized.startsWith("runtime_error=")) {
+        return false;
+    }
+    return ((normalized.includes("terminated") && normalized.includes("other side closed"))
+        || normalized.includes("socket hang up")
+        || normalized.includes("connection reset")
+        || normalized.includes("econnreset"));
+}
 export async function* streamHarnessRun(options) {
     const priorHistoryPromise = Promise.resolve(options.isNewSession ? [] : undefined).then((historyHint) => historyHint ?? options.loadPriorHistory(options.sessionId, options.requestId));
     yield { type: "event", event: await options.requestCreatedEventPromise };
@@ -533,6 +581,7 @@ export async function* streamHarnessRun(options) {
     let emitted = false;
     let streamActivityObserved = false;
     let nonUpstreamStreamActivityObserved = false;
+    let observedOnlyFallbackSafeUpstreamEvents = true;
     let assistantOutput = "";
     let assistantOutputCameFromInvokeFallback = false;
     const bufferAssistantTextUntilCompletion = true;
@@ -589,6 +638,9 @@ export async function* streamHarnessRun(options) {
             streamActivityObserved = true;
             const normalizedChunk = normalizeStreamChunk(rawChunk);
             if (normalizedChunk.kind === "upstream-event") {
+                if (!isFallbackSafeUpstreamStartupEvent(normalizedChunk.event, options.selectedAgentId)) {
+                    observedOnlyFallbackSafeUpstreamEvents = false;
+                }
                 const upstreamPlanState = getPlanStateFromUpstreamEvent({
                     sessionId: options.sessionId,
                     requestId: options.requestId,
@@ -833,6 +885,15 @@ export async function* streamHarnessRun(options) {
             emitted = emitted || assistantOutput.length > 0;
         }
         currentPlanState = await refreshPlanStateFromPersistence(options, currentPlanState);
+        if (assistantOutput
+            && isStartupRuntimeFailureOutput(assistantOutput)
+            && executedToolResults.length === 0
+            && !sawSuccessfulToolResult
+            && observedOnlyFallbackSafeUpstreamEvents
+            && !planStateHasAnyItems(currentPlanState)) {
+            assistantOutput = "";
+            emitted = false;
+        }
         if (!assistantOutput) {
             const actual = await options.invokeWithHistory(options.binding, options.input, options.sessionId, options.requestId);
             if (Array.isArray(actual.contentBlocks) && actual.contentBlocks.length > 0) {
@@ -1019,8 +1080,12 @@ export async function* streamHarnessRun(options) {
         }
         const shouldRetryAfterStreamingCompatibilityError = !assistantOutput &&
             isOpenAICompatibleStreamingCompatibilityError(options.binding, error);
-        if ((emitted || streamActivityObserved)
-            && !shouldRetryAfterStreamingCompatibilityError) {
+        const streamHadExecutionSideEffects = emitted
+            || nonUpstreamStreamActivityObserved
+            || sawSuccessfulToolResult
+            || executedToolResults.length > 0
+            || !observedOnlyFallbackSafeUpstreamEvents;
+        if (streamHadExecutionSideEffects && !shouldRetryAfterStreamingCompatibilityError) {
             const runtimeFailure = renderRuntimeFailure(error);
             const detailedError = describeRuntimeError(error);
             yield {

package/dist/runtime/harness.d.ts

@@ -132,6 +132,7 @@ export declare class AgentHarnessRuntime {
     private emit;
     private trackBackgroundTask;
     private scheduleBackgroundStartupTask;
+    private drainBackgroundTasksForClose;
     private resolveToolMcpServerTools;
     private loadPriorHistory;
     private loadRequestInput;

package/dist/runtime/harness.js

@@ -46,6 +46,7 @@ import { defaultRequestedAgentId, prepareRunStart } from "./harness/run/start-ru
 import { buildRequestInspectionRecord, buildSessionInspectionRecord, deleteSessionRecord, getPublicApproval, listPublicApprovals, } from "./harness/run/session-records.js";
 import { createKnowledgeModule } from "../knowledge/index.js";
 import { createProceduralMemoryManager, ProceduralMemoryFormationSync, readProceduralMemoryRuntimeConfig, } from "../knowledge/procedural/index.js";
+const BACKGROUND_TASK_CLOSE_DRAIN_TIMEOUT_MS = 1_000;
 const ACTIVE_REQUEST_STATES = [
     "queued",
     "claimed",
@@ -945,6 +946,23 @@ export class AgentHarnessRuntime {
     scheduleBackgroundStartupTask(task) {
         this.trackBackgroundTask(task.then(() => undefined).catch(() => undefined));
     }
+    async drainBackgroundTasksForClose() {
+        const tasks = Array.from(this.backgroundTasks);
+        if (tasks.length === 0) {
+            return;
+        }
+        let timeoutHandle;
+        await Promise.race([
+            Promise.allSettled(tasks),
+            new Promise((resolve) => {
+                timeoutHandle = setTimeout(resolve, BACKGROUND_TASK_CLOSE_DRAIN_TIMEOUT_MS);
+                timeoutHandle.unref?.();
+            }),
+        ]);
+        if (timeoutHandle) {
+            clearTimeout(timeoutHandle);
+        }
+    }
     resolveToolMcpServerTools(agentId) {
         return resolveWorkspaceAgentTools({
             workspace: this.workspace,
@@ -1375,7 +1393,7 @@ export class AgentHarnessRuntime {
         this.unregisterMem0IngestionSync();
         this.unregisterRuntimeMemoryFormationSync();
         this.unregisterProceduralMemoryFormationSync();
-        await Promise.allSettled(Array.from(this.backgroundTasks));
+        await this.drainBackgroundTasksForClose();
         await this.sessionMemorySync?.close();
         await this.runtimeMemorySync?.close();
         await this.mem0IngestionSync?.close();

package/dist/runtime/support/compiled-binding.d.ts

@@ -1,4 +1,4 @@
-import type { CompiledAgentBinding, CompiledDeepAgentSubAgent, CompiledExecutionBinding, CompiledModel, CompiledSubAgent, CompiledTool, DeepAgentParams, LegacyDeepAgentParams, LegacyLangChainAgentParams, LangChainAgentParams } from "../../contracts/types.js";
+import type { CompiledAgentBinding, CompiledBuiltinToolsConfig, CompiledDeepAgentSubAgent, CompiledExecutionBinding, CompiledModel, CompiledSubAgent, CompiledTool, DeepAgentParams, LegacyDeepAgentParams, LegacyLangChainAgentParams, LangChainAgentParams } from "../../contracts/types.js";
 export type BindingExecutionView = {
     adapterKind: string;
     langchainParams?: LegacyLangChainAgentParams;
@@ -32,10 +32,7 @@ export declare function getBindingGeneralPurposeAgent(binding: CompiledAgentBind
 export declare function getBindingTaskDescription(binding: CompiledAgentBinding): string | undefined;
 export declare function getBindingBackendConfig(binding: CompiledAgentBinding): Record<string, unknown> | undefined;
 export declare function getBindingInteractionMode(binding: CompiledAgentBinding): "stream" | "invoke" | undefined;
-export declare function getBindingBuiltinToolsConfig(binding: CompiledAgentBinding): {
-    filesystem?: boolean;
-    todos?: boolean;
-} | undefined;
+export declare function getBindingBuiltinToolsConfig(binding: CompiledAgentBinding): CompiledBuiltinToolsConfig | undefined;
 export declare function getBindingFilesystemConfig(binding: CompiledAgentBinding): Record<string, unknown> | undefined;
 export declare function isLangChainBinding(binding: CompiledAgentBinding): boolean;
 export declare function isDeepAgentBinding(binding: CompiledAgentBinding): boolean;

package/dist/workspace/agent-binding-compiler.js

@@ -463,6 +463,7 @@ export function compileBinding(workspaceRoot, agent, agents, referencedSubagentI
                     : undefined,
                 name: resolveAgentRuntimeName(agent),
                 description: agent.description,
+                builtinTools: getAgentExecutionObject(agent, "builtinTools"),
             },
         };
         return attachLegacyExecutionAliases({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botbotgo/agent-harness",
-  "version": "0.0.342",
+  "version": "0.0.344",
   "description": "Workspace runtime for multi-agent applications",
   "license": "MIT",
   "type": "module",