@botbotgo/agent-harness 0.0.342 → 0.0.343

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 || wroteContent || wroteRenderableBlocks) {
+            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/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.343";
 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.343";
 export const AGENT_HARNESS_RELEASE_DATE = "2026-04-24";

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/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.343",
   "description": "Workspace runtime for multi-agent applications",
   "license": "MIT",
   "type": "module",