@botbotgo/agent-harness 0.0.298 → 0.0.299

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

@@ -1,12 +1,13 @@
 import path from "node:path";
 import { MemorySaver } from "@langchain/langgraph";
-import { createDeepAgent, FilesystemBackend, } from "deepagents";
-import { createAgent } from "langchain";
+import { createDeepAgent, createFilesystemMiddleware, createPatchToolCallsMiddleware, FilesystemBackend, } from "deepagents";
+import { createAgent, todoListMiddleware } from "langchain";
 import { wrapResolvedModel, } from "./parsing/output-parsing.js";
 import { UPSTREAM_REQUEST_CONFIG_KEY, UPSTREAM_SESSION_CONFIG_KEY } from "./adapter/upstream-configurable-keys.js";
 import { resolveDeepAgentSkillSourcePaths, } from "./adapter/compat/deepagent-compat.js";
 import { buildToolNameMapping, } from "./adapter/tool/tool-name-mapping.js";
 import { executeRequestInvocation } from "./adapter/flow/invocation-flow.js";
+import { asStructuredExecutableTool } from "./adapter/tool/resolved-tool.js";
 import { streamRuntimeExecution } from "./adapter/flow/stream-runtime.js";
 import { applyToolRecoveryInstruction as applyToolRecoveryInstructionHelper, applyStrictToolJsonInstruction as applyStrictToolJsonInstructionHelper, callRuntimeWithToolParseRecovery as callRuntimeWithToolParseRecoveryHelper, createModelFallbackRunnable as createModelFallbackRunnableHelper, invokeWithProviderRetry as invokeWithProviderRetryHelper, iterateWithTimeout as iterateWithTimeoutHelper, materializeModelStream as materializeModelStreamHelper, RuntimeOperationTimeoutError, withRuntimeTimeout, } from "./adapter/runtime-shell.js";
 import { invokeBuiltinTaskTool as invokeBuiltinTaskToolHelper, materializeAutomaticSummarizationMiddleware as materializeAutomaticSummarizationMiddlewareHelper, resolveBuiltinMiddlewareBackend as resolveBuiltinMiddlewareBackendHelper, resolveBuiltinMiddlewareTools as resolveBuiltinMiddlewareToolsHelper, resolveLangChainRuntimeExtensionMiddleware as resolveLangChainRuntimeExtensionMiddlewareHelper, resolveMiddleware as resolveMiddlewareHelper, resolveSubagents as resolveSubagentsHelper, } from "./adapter/middleware-assembly.js";
@@ -15,6 +16,7 @@ import { createResolvedModel } from "./adapter/model/model-providers.js";
 import { compileInterruptOn } from "./adapter/tool/interrupt-policy.js";
 import { resolveAdapterTools } from "./adapter/tool-resolution.js";
 import { resolveRuntimeStreamExecutionContext, } from "./adapter/flow/execution-context.js";
+import { isRetryableProviderError } from "./adapter/resilience.js";
 export { applyDeepAgentDelegationPromptCompatibility, materializeDeepAgentSkillSourcePaths, resolveDeepAgentSkillSourcePaths, relativizeDeepAgentSkillSourcePaths, shouldRelaxDeepAgentDelegationPrompt, } from "./adapter/compat/deepagent-compat.js";
 export { buildAuthOmittingFetch, normalizeOpenAICompatibleInit } from "./adapter/compat/openai-compatible.js";
 export { buildToolNameMapping, createModelFacingToolNameCandidates, createModelFacingToolNameLookupCandidates, resolveModelFacingToolName, sanitizeToolNameForModel, } from "./adapter/tool/tool-name-mapping.js";
@@ -42,6 +44,32 @@ const UPSTREAM_BUILTIN_MIDDLEWARE_TOOL_NAMES = Object.freeze([
     "task",
     "delegate_task",
 ]);
+const BUILTIN_MIDDLEWARE_ALIAS_TOOL_NAMES = new Set([
+    "list_files",
+    "search_files",
+    "run_command",
+    "delegate_task",
+]);
+const MODEL_EXPOSED_BUILTIN_MIDDLEWARE_TOOL_NAMES = new Set([
+    "fetch_url",
+    "http_request",
+    "send_message",
+    "request_approval",
+    "schedule_task",
+]);
+export function materializeModelExposedBuiltinMiddlewareTools(input) {
+    const explicitToolNames = new Set(input.explicitToolNames ?? []);
+    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)) {
+            continue;
+        }
+        tools.push(asStructuredExecutableTool(tool, toolName, tool.name));
+    }
+    return tools;
+}
 export function resolveRunnableCheckpointer(options, binding) {
     return options.checkpointerResolver ? options.checkpointerResolver(binding) : new MemorySaver();
 }
@@ -116,6 +144,9 @@ export function resolveLangChainInvocationConfig(binding, options) {
     if (options.context) {
         config.context = options.context;
     }
+    if (options.toolRuntimeContext) {
+        config.toolRuntimeContext = options.toolRuntimeContext;
+    }
     return config;
 }
 export function buildDeepAgentCreateParams(input) {
@@ -152,6 +183,55 @@ export function buildDeepAgentCreateParams(input) {
         ...(input.resolvedBackend !== undefined ? { backend: input.resolvedBackend } : {}),
     };
 }
+export function shouldUseMinimalDeepAgentAssembly(input) {
+    const executionKind = getBindingExecutionKind(input.binding);
+    if (executionKind !== "deepagent") {
+        return false;
+    }
+    if (input.resolvedBackend === undefined) {
+        return false;
+    }
+    if (input.resolvedSkills.length > 0) {
+        return false;
+    }
+    if (input.resolvedSubagents.length > 0 || getBindingDeepAgentSubagents(input.binding).length > 0) {
+        return false;
+    }
+    if (getBindingMemorySources(input.binding).length > 0) {
+        return false;
+    }
+    if (input.resolvedMiddleware.length > 0 || (getBindingMiddlewareConfigs(input.binding)?.length ?? 0) > 0) {
+        return false;
+    }
+    return input.resolvedInterruptOn === undefined || Object.keys(input.resolvedInterruptOn).length === 0;
+}
+export function buildMinimalDeepAgentCreateParams(input) {
+    const executionKind = getBindingExecutionKind(input.binding);
+    if (executionKind !== "deepagent" || !getBindingExecutionParams(input.binding)) {
+        throw new Error(`Agent ${input.binding.agent.id} has no runnable params`);
+    }
+    const upstreamParams = buildUpstreamCreateBaseParams(input.binding, [
+        "systemPrompt",
+        "contextSchema",
+        "responseFormat",
+        "name",
+        "description",
+        "includeAgentName",
+        "version",
+    ]);
+    return {
+        ...upstreamParams,
+        model: input.resolvedModel,
+        tools: input.resolvedTools,
+        middleware: [
+            todoListMiddleware(),
+            createFilesystemMiddleware({ backend: input.resolvedBackend }),
+            createPatchToolCallsMiddleware(),
+        ],
+        ...(input.resolvedCheckpointer !== undefined ? { checkpointer: input.resolvedCheckpointer } : {}),
+        ...(input.resolvedStore !== undefined ? { store: input.resolvedStore } : {}),
+    };
+}
 function shouldAttachMinimalDeepAgentCheckpointer(binding, resolvedInterruptOn) {
     if (binding.harnessRuntime.checkpointer !== undefined) {
         return true;
@@ -289,12 +369,37 @@ export class AgentRuntimeAdapter {
         return path.isAbsolute(rendered) ? rendered : path.resolve(workspaceRoot, rendered);
     }
     resolveBuiltinMiddlewareBackend(binding, options = {}) {
-        return resolveBuiltinMiddlewareBackendHelper({
+        const resolved = resolveBuiltinMiddlewareBackendHelper({
             binding,
             runtimeAdapterOptions: this.options,
             resolveFilesystemBackend: (currentBinding) => this.resolveFilesystemBackend(currentBinding),
             options,
         });
+        if (!this.options.scheduleManager || typeof resolved !== "object" || !resolved) {
+            return resolved;
+        }
+        const decorated = Object.create(resolved);
+        decorated.manageSchedule = (input) => this.options.scheduleManager.manageSchedule(input);
+        return decorated;
+    }
+    buildFunctionToolRuntimeContext(binding, options = {}) {
+        if (!this.options.functionToolContextResolver) {
+            return undefined;
+        }
+        const backend = this.resolveBuiltinMiddlewareBackend(binding, options);
+        return {
+            ...this.options.functionToolContextResolver({
+                binding,
+                sessionId: options.sessionId,
+                requestId: options.requestId,
+            }),
+            backend,
+            invocation: {
+                ...(options.context ? { context: options.context } : {}),
+                ...(options.sessionId ? { sessionId: options.sessionId } : {}),
+                ...(options.requestId ? { requestId: options.requestId } : {}),
+            },
+        };
     }
     createDeclaredMiddlewareResolverOptions(binding, options = {}) {
         return {
@@ -399,17 +504,21 @@ export class AgentRuntimeAdapter {
         const interruptOn = resolveRunnableInterruptOn(binding);
         const resolvedModel = await this.resolveModel(primaryModel);
         const resolvedTools = this.resolveTools(primaryTools, binding);
+        const builtinMiddlewareTools = materializeModelExposedBuiltinMiddlewareTools({
+            builtinTools: await this.resolveBuiltinMiddlewareTools(binding, { sessionId: options.sessionId ?? options.legacySessionId }),
+            explicitToolNames: primaryTools.map((tool) => tool.name),
+        });
         const resolvedMiddleware = await this.resolveMiddleware(binding, interruptOn, { sessionId: options.sessionId ?? options.legacySessionId });
         const resolvedCheckpointer = resolveRunnableCheckpointer(this.options, binding);
         const resolvedStore = this.options.storeResolver?.(binding);
         const model = resolvedModel;
-        if (resolvedTools.length > 0 && typeof model.bindTools !== "function") {
-            throw new Error(`Agent ${binding.agent.id} configures ${resolvedTools.length} tool(s), but resolved model ${primaryModel.id} does not support tool binding.`);
+        if (resolvedTools.length + builtinMiddlewareTools.length > 0 && typeof model.bindTools !== "function") {
+            throw new Error(`Agent ${binding.agent.id} configures ${resolvedTools.length + builtinMiddlewareTools.length} tool(s), but resolved model ${primaryModel.id} does not support tool binding.`);
         }
         return createAgent(buildLangChainCreateParams({
             binding,
             resolvedModel: model,
-            resolvedTools,
+            resolvedTools: [...resolvedTools, ...builtinMiddlewareTools],
             resolvedMiddleware,
             resolvedCheckpointer,
             resolvedStore,
@@ -435,6 +544,10 @@ export class AgentRuntimeAdapter {
         }
         const resolvedModel = await this.resolveModel(primaryModel);
         const resolvedTools = this.resolveTools(primaryTools, binding);
+        const builtinMiddlewareTools = materializeModelExposedBuiltinMiddlewareTools({
+            builtinTools: await this.resolveBuiltinMiddlewareTools(binding),
+            explicitToolNames: primaryTools.map((tool) => tool.name),
+        });
         const resolvedMiddleware = await this.resolveMiddleware(binding);
         const resolvedSubagents = await this.resolveDeepAgentSubagents(getBindingDeepAgentSubagents(binding), binding);
         const resolvedInterruptOn = resolveRunnableInterruptOn(binding);
@@ -459,7 +572,7 @@ export class AgentRuntimeAdapter {
         const deepAgentConfig = buildDeepAgentCreateParams({
             binding,
             resolvedModel,
-            resolvedTools,
+            resolvedTools: [...resolvedTools, ...builtinMiddlewareTools],
             resolvedMiddleware,
             resolvedSubagents,
             resolvedCheckpointer,
@@ -468,6 +581,24 @@ export class AgentRuntimeAdapter {
             resolvedInterruptOn,
             resolvedSkills,
         });
+        if (shouldUseMinimalDeepAgentAssembly({
+            binding,
+            resolvedMiddleware,
+            resolvedSubagents,
+            resolvedInterruptOn,
+            resolvedSkills,
+            resolvedBackend,
+        })) {
+            const minimalDeepAgentConfig = buildMinimalDeepAgentCreateParams({
+                binding,
+                resolvedModel,
+                resolvedTools: [...resolvedTools, ...builtinMiddlewareTools],
+                resolvedCheckpointer,
+                resolvedStore,
+                resolvedBackend,
+            });
+            return createAgent(minimalDeepAgentConfig);
+        }
         return createDeepAgent(deepAgentConfig);
     }
     buildRunnableCacheKey(binding, sessionId) {
@@ -502,6 +633,11 @@ export class AgentRuntimeAdapter {
                     sessionId,
                     requestId,
                     context: options.context,
+                    toolRuntimeContext: this.buildFunctionToolRuntimeContext(activeBinding, {
+                        ...options,
+                        sessionId,
+                        requestId,
+                    }),
                 })), resolveBindingTimeout(activeBinding), "agent invoke", "invoke"));
             });
         };
@@ -513,19 +649,27 @@ export class AgentRuntimeAdapter {
                 callRuntime,
             });
         };
-        return executeRequestInvocation({
+        const toolRuntimeContext = this.buildFunctionToolRuntimeContext(binding, {
+            ...options,
+            sessionId,
+            requestId,
+        });
+        return this.invokeWithProviderRetry(binding, async () => executeRequestInvocation({
             binding,
             input,
             sessionId,
             requestId,
             resumePayload,
             history,
-            invokeOptions: options,
+            invokeOptions: {
+                ...options,
+                ...(toolRuntimeContext ? { toolRuntimeContext } : {}),
+            },
             resolveTools: (tools, currentBinding) => this.resolveTools(tools, currentBinding),
             getToolNameMapping: (currentBinding) => this.getToolNameMapping(currentBinding),
-            resolveBuiltinMiddlewareTools: (currentBinding, currentOptions) => this.resolveBuiltinMiddlewareTools(currentBinding, { ...currentOptions, sessionId }),
+            resolveBuiltinMiddlewareTools: (currentBinding, currentOptions) => this.resolveBuiltinMiddlewareTools(currentBinding, { ...currentOptions, sessionId, requestId }),
             callRuntimeWithToolParseRecovery,
-        });
+        }));
     }
     async *stream(binding, input, sessionId, history = [], options = {}) {
         const invokeTimeoutMs = resolveBindingTimeout(binding);
@@ -537,6 +681,11 @@ export class AgentRuntimeAdapter {
             resolveModel: (model) => this.resolveModel(model),
             resolveTools: (tools, currentBinding) => this.resolveTools(tools, currentBinding),
         });
+        const streamToolRuntimeContext = this.buildFunctionToolRuntimeContext(binding, {
+            ...options,
+            sessionId,
+            requestId: options.requestId,
+        });
         yield* streamRuntimeExecution({
             binding,
             input,
@@ -545,6 +694,8 @@ export class AgentRuntimeAdapter {
             runtimeOptions: {
                 ...options,
                 requestId: options.requestId,
+                profiling: options.profiling,
+                ...(streamToolRuntimeContext ? { toolRuntimeContext: streamToolRuntimeContext } : {}),
             },
             primaryTools,
             toolNameMapping,
@@ -559,6 +710,7 @@ export class AgentRuntimeAdapter {
             streamDeadlineAt,
             invoke: (activeBinding, activeInput, activeSessionId, activeRequestId, resumePayload, activeHistory, invokeOptions) => this.invoke(activeBinding, activeInput, activeSessionId, activeRequestId, resumePayload, activeHistory, invokeOptions),
             applyToolRecoveryInstruction: (activeBinding, instruction) => applyToolRecoveryInstructionHelper(activeBinding, instruction),
+            isRetryableProviderError: (activeBinding, error) => isRetryableProviderError(activeBinding, error),
             getSystemPrompt: (activeBinding) => getBindingSystemPrompt(activeBinding),
             isLangChainBinding,
             isDeepAgentBinding,

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

@@ -4,4 +4,5 @@ export declare class EventBus implements RuntimeEventSink {
     publish(event: HarnessEvent): void;
     subscribe(listener: HarnessEventListener): () => void;
     registerProjection(projection: HarnessEventProjection): () => void;
+    drain(): Promise<void>;
 }

package/dist/runtime/harness/events/event-bus.js

@@ -10,4 +10,7 @@ export class EventBus {
     registerProjection(projection) {
         return this.sink.registerProjection(projection);
     }
+    async drain() {
+        await this.sink.drain();
+    }
 }

package/dist/runtime/harness/events/event-sink.d.ts

@@ -2,8 +2,11 @@ import type { HarnessEvent, HarnessEventListener, HarnessEventProjection, Runtim
 export declare class RuntimeEventSinkImpl implements RuntimeEventSink {
     private readonly emitter;
     private readonly projections;
+    private readonly inflightProjectionTasks;
+    private trackProjectionTask;
     publish(event: HarnessEvent): void;
     subscribe(listener: HarnessEventListener): () => void;
     registerProjection(projection: HarnessEventProjection): () => void;
+    drain(): Promise<void>;
 }
 export declare function createRuntimeEventSink(): RuntimeEventSinkImpl;

package/dist/runtime/harness/events/event-sink.js

@@ -3,19 +3,23 @@ import { getEventSubscribers } from "../../../extensions.js";
 function dispatchListener(listener, event) {
     void Promise.resolve(listener(event));
 }
-function dispatchProjection(projection, event) {
-    if (projection.shouldHandle && !projection.shouldHandle(event)) {
-        return;
-    }
-    void Promise.resolve(projection.handleEvent(event));
-}
 export class RuntimeEventSinkImpl {
     emitter = new EventEmitter();
     projections = new Set();
+    inflightProjectionTasks = new Set();
+    trackProjectionTask(task) {
+        this.inflightProjectionTasks.add(task);
+        void task.finally(() => {
+            this.inflightProjectionTasks.delete(task);
+        });
+    }
     publish(event) {
         this.emitter.emit("event", event);
         for (const projection of this.projections) {
-            dispatchProjection(projection, event);
+            if (projection.shouldHandle && !projection.shouldHandle(event)) {
+                continue;
+            }
+            this.trackProjectionTask(Promise.resolve(projection.handleEvent(event)));
         }
         for (const subscriber of getEventSubscribers()) {
             dispatchListener(subscriber.onEvent, event);
@@ -29,6 +33,11 @@ export class RuntimeEventSinkImpl {
         this.projections.add(projection);
         return () => this.projections.delete(projection);
     }
+    async drain() {
+        while (this.inflightProjectionTasks.size > 0) {
+            await Promise.allSettled(Array.from(this.inflightProjectionTasks));
+        }
+    }
 }
 export function createRuntimeEventSink() {
     return new RuntimeEventSinkImpl();

package/dist/runtime/harness/events/streaming.d.ts

@@ -1,5 +1,11 @@
-import type { HarnessEvent, HarnessStreamItem, RequestListeners, RequestResult } from "../../../contracts/types.js";
+import type { HarnessEvent, HarnessStreamItem, RequestListeners, RequestPlanState, RequestResult } from "../../../contracts/types.js";
 export type InternalHarnessStreamItem = HarnessStreamItem | {
+    type: "commentary";
+    sessionId: string;
+    requestId: string;
+    agentId: string;
+    content: string;
+} | {
     type: "content";
     sessionId: string;
     requestId: string;
@@ -19,6 +25,17 @@ export type InternalHarnessStreamItem = HarnessStreamItem | {
     toolName: string;
     output: unknown;
     isError?: boolean;
+} | {
+    type: "plan-state";
+    sessionId: string;
+    requestId: string;
+    agentId: string;
+    planState: RequestPlanState;
+} | {
+    type: "profile-step";
+    sessionId: string;
+    requestId: string;
+    step: import("../../../contracts/types.js").RequestExecutionStep;
 };
 export declare function emitOutputDeltaAndCreateItem(emit: (sessionId: string, requestId: string, sequence: number, eventType: string, payload: Record<string, unknown>) => Promise<HarnessEvent>, sessionId: string, requestId: string, agentId: string, content: string): Promise<InternalHarnessStreamItem>;
 export declare function createContentBlocksItem(sessionId: string, requestId: string, agentId: string, contentBlocks: unknown[]): InternalHarnessStreamItem;

package/dist/runtime/harness/events/streaming.js

@@ -1,4 +1,5 @@
 import { createFallbackRequestResultFromLatestEvent, mergeRequestResultOutput } from "../run/helpers.js";
+import { applyRequestStreamItemToSnapshot, createInitialRequestEventSnapshot, toRequestDataEvent, } from "../../../request-events.js";
 export async function emitOutputDeltaAndCreateItem(emit, sessionId, requestId, agentId, content) {
     await emit(sessionId, requestId, 3, "output.delta", {
         content,
@@ -31,35 +32,47 @@ export function createToolResultKey(toolName, output, isError) {
     return JSON.stringify([toolName, serializedOutput, isError === true]);
 }
 export async function dispatchRequestListeners(stream, listeners, options) {
+    const notifyIfPresent = async (listener, value) => {
+        if (!listener) {
+            return;
+        }
+        await options.notifyListener(listener, value);
+    };
     let latestEvent;
     let latestResult;
     let output = "";
+    let snapshot = createInitialRequestEventSnapshot();
     for await (const item of stream) {
+        snapshot = applyRequestStreamItemToSnapshot(snapshot, item);
         if (item.type === "event") {
             latestEvent = item.event;
-            await options.notifyListener(listeners.onEvent, item.event);
-            continue;
+            await notifyIfPresent(listeners.onEvent, item.event);
         }
-        if (item.type === "upstream-event") {
-            await options.notifyListener(listeners.onUpstreamEvent, item.event);
+        else if (item.type === "upstream-event") {
+            await notifyIfPresent(listeners.onUpstreamEvent, item.event);
             if (item.surfaceItem) {
-                await options.notifyListener(listeners.onTraceItem, {
+                await notifyIfPresent(listeners.onTraceItem, {
                     sessionId: item.sessionId,
                     requestId: item.requestId,
                     surfaceItem: item.surfaceItem,
                     event: item.event,
                 });
             }
-            continue;
         }
-        if (item.type === "result") {
+        else if (item.type === "result") {
             latestResult = item.result;
-            continue;
         }
-        if (item.type === "content") {
+        else if (item.type === "plan-state") {
+            await notifyIfPresent(listeners.onPlanState, item.planState);
+        }
+        else if (item.type === "content") {
             output += item.content;
-            continue;
         }
+        const dataEvent = toRequestDataEvent(item);
+        if (dataEvent) {
+            await notifyIfPresent(listeners.dataListener, dataEvent);
+        }
+        await notifyIfPresent(listeners.eventListener, snapshot);
     }
     if (!latestEvent) {
         throw new Error("run did not emit any events");

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

@@ -1,8 +1,9 @@
 import { readSkillMetadata } from "../../support/skill-metadata.js";
 import { createUpstreamTimelineReducer } from "../../../upstream-events.js";
 import { formatAgentName } from "../../../utils/agent-display.js";
-import { getBindingMemorySources, getBindingPrimaryModel, getBindingPrimaryTools, getBindingSkills, getBindingSubagents, } from "../../support/compiled-binding.js";
+import { getBindingMemorySources, getBindingPrimaryModel, getBindingPrimaryTools, getBindingSkills, getBindingSubagents, isDeepAgentBinding, } from "../../support/compiled-binding.js";
 import { buildRuntimeGovernanceBundles } from "./governance.js";
+import { BUILTIN_MIDDLEWARE_TOOL_DESCRIPTORS } from "../../adapter/tool/builtin-middleware-tools.js";
 import { buildSurfaceId, resolveSurfaceAction, resolveSurfaceDisplayName, } from "./surface-semantics.js";
 function asObject(value) {
     return typeof value === "object" && value !== null ? value : null;
@@ -10,6 +11,14 @@ function asObject(value) {
 function readStringArray(value) {
     return Array.isArray(value) ? value.filter((item) => typeof item === "string" && item.trim().length > 0) : [];
 }
+function getBindingSkillNames(binding) {
+    if (!binding) {
+        return [];
+    }
+    return getBindingSkills(binding)
+        .map((skillPath) => readSkillMetadata(skillPath).name)
+        .filter((name) => typeof name === "string" && name.trim().length > 0);
+}
 function isTaskDelegationCompletionEvent(event) {
     const eventName = typeof event.event === "string" ? event.event : "";
     const name = typeof event.name === "string" ? event.name : "";
@@ -83,6 +92,18 @@ export function buildRequestRuntimeSnapshot(binding, options) {
         : typeof init.baseURL === "string" && init.baseURL.trim().length > 0
             ? init.baseURL.trim()
             : undefined;
+    const declaredTools = getBindingPrimaryTools(binding).map((tool) => ({
+        name: tool.name,
+        description: tool.description,
+    }));
+    const tools = isDeepAgentBinding(binding)
+        ? [
+            ...declaredTools,
+            ...BUILTIN_MIDDLEWARE_TOOL_DESCRIPTORS
+                .filter((descriptor) => !declaredTools.some((tool) => tool.name === descriptor.name))
+                .map((descriptor) => ({ ...descriptor })),
+        ]
+        : declaredTools;
     return {
         agentId: binding.agent.id,
         ...(model ? {
@@ -93,10 +114,7 @@ export function buildRequestRuntimeSnapshot(binding, options) {
                 ...(baseUrl ? { baseUrl } : {}),
             },
         } : {}),
-        tools: getBindingPrimaryTools(binding).map((tool) => ({
-            name: tool.name,
-            description: tool.description,
-        })),
+        tools,
         skills: getBindingSkills(binding).map((skillPath) => {
             const metadata = readSkillMetadata(skillPath);
             return {
@@ -339,6 +357,9 @@ export function projectRuntimeSurfaceFromSingleUpstreamEvent(input) {
             detail: {
                 step: projection.step,
                 category: projection.category,
+                ...(kind === "skill" && getBindingSkillNames(input.binding).length > 0
+                    ? { skillNames: getBindingSkillNames(input.binding) }
+                    : {}),
             },
         });
     }

package/dist/runtime/harness/run/stream-run.d.ts

@@ -1,12 +1,18 @@
-import type { CompiledAgentBinding, HarnessEvent, MessageContent, RequestResult, RuntimeSnapshot, TranscriptMessage } from "../../../contracts/types.js";
+import type { CompiledAgentBinding, HarnessEvent, MemoryRecord, MessageContent, RequestResult, RequestExecutionStep, RuntimeSnapshot, TranscriptMessage } from "../../../contracts/types.js";
 import { type InternalHarnessStreamItem } from "../events/streaming.js";
-type RuntimeStreamChunk = string | {
-    kind: "content" | "interrupt" | "reasoning" | "step" | "tool-result" | "upstream-event";
+type RuntimeStreamChunk = {
+    kind: "commentary";
+    content: string;
+} | string | {
+    kind: "content" | "interrupt" | "reasoning" | "tool-result" | "upstream-event";
     content?: string;
     toolName?: string;
     output?: unknown;
     isError?: boolean;
     event?: unknown;
+} | {
+    kind: "profile";
+    step: RequestExecutionStep;
 };
 type StreamRunOptions = {
     binding: CompiledAgentBinding;
@@ -16,7 +22,10 @@ type StreamRunOptions = {
         context?: Record<string, unknown>;
         state?: Record<string, unknown>;
         files?: Record<string, unknown>;
-        memoryContext?: string;
+        memoryRecall?: {
+            prompt?: string;
+            items: MemoryRecord[];
+        };
     };
     sessionId: string;
     requestId: string;