@botbotgo/agent-harness 0.0.41 → 0.0.43

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

@@ -12,6 +12,10 @@ import { computeIncrementalOutput, extractAgentStep, extractInterruptPayload, ex
 import { wrapToolForExecution } from "./tool-hitl.js";
 import { resolveDeclaredMiddleware } from "./declared-middleware.js";
 import { extractMessageText, normalizeMessageContent } from "../utils/message-content.js";
+import { getBindingDeepAgentParams, getBindingInterruptCompatibilityRules, getBindingLangChainParams, getBindingMiddlewareConfigs, getBindingModelInit, getBindingPrimaryModel, getBindingPrimaryTools, getBindingSystemPrompt, isDeepAgentBinding, isLangChainBinding, } from "./support/compiled-binding.js";
+function countConfiguredTools(binding) {
+    return getBindingPrimaryTools(binding).length;
+}
 const AGENT_INTERRUPT_SENTINEL_PREFIX = "__agent_harness_interrupt__:";
 const MODEL_SAFE_TOOL_NAME_PATTERN = /^[a-zA-Z0-9_-]+$/;
 class RuntimeOperationTimeoutError extends Error {
@@ -139,6 +143,11 @@ function hasCallableToolHandler(value) {
     const typed = value;
     return typeof typed.invoke === "function" || typeof typed.call === "function" || typeof typed.func === "function";
 }
+function asRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        ? { ...value }
+        : undefined;
+}
 function normalizeResolvedToolSchema(resolvedTool) {
     const schema = resolvedTool.schema;
     if (schema && typeof schema.parse === "function" && "_def" in schema) {
@@ -163,38 +172,16 @@ function asStructuredExecutableTool(resolvedTool, modelFacingName, description)
         schema: normalizeResolvedToolSchema(resolvedTool),
     });
 }
-function countConfiguredTools(binding) {
-    return binding.langchainAgentParams?.tools.length ?? binding.deepAgentParams?.tools.length ?? 0;
-}
 export class AgentRuntimeAdapter {
     options;
     constructor(options = {}) {
         this.options = options;
     }
-    canUseSimpleDeepAgentFastPath(binding) {
-        const params = binding.deepAgentParams;
-        if (!params) {
-            return false;
-        }
-        if ((params.subagents?.length ?? 0) > 0) {
-            return false;
-        }
-        if ((params.memory?.length ?? 0) > 0) {
-            return false;
-        }
-        if ((params.skills?.length ?? 0) > 0) {
-            return false;
-        }
-        if (params.backend || params.store) {
-            return false;
-        }
-        return true;
-    }
     resolveBindingTimeout(binding) {
-        return resolveTimeoutMs(binding.langchainAgentParams?.model.init.timeout ?? binding.deepAgentParams?.model.init.timeout);
+        return resolveTimeoutMs(getBindingModelInit(binding)?.timeout);
     }
     resolveStreamIdleTimeout(binding) {
-        const configuredIdleTimeout = resolveTimeoutMs(binding.langchainAgentParams?.model.init.streamIdleTimeout ?? binding.deepAgentParams?.model.init.streamIdleTimeout);
+        const configuredIdleTimeout = resolveTimeoutMs(getBindingModelInit(binding)?.streamIdleTimeout);
         if (configuredIdleTimeout) {
             return configuredIdleTimeout;
         }
@@ -303,35 +290,38 @@ export class AgentRuntimeAdapter {
         };
     }
     applyStrictToolJsonInstruction(binding) {
-        if (binding.langchainAgentParams) {
+        if (isLangChainBinding(binding)) {
+            const params = getBindingLangChainParams(binding);
             return {
                 ...binding,
                 langchainAgentParams: {
-                    ...binding.langchainAgentParams,
-                    systemPrompt: [binding.langchainAgentParams.systemPrompt, STRICT_TOOL_JSON_INSTRUCTION].filter(Boolean).join("\n\n"),
+                    ...params,
+                    systemPrompt: [params.systemPrompt, STRICT_TOOL_JSON_INSTRUCTION].filter(Boolean).join("\n\n"),
                 },
             };
         }
-        if (binding.deepAgentParams) {
+        if (isDeepAgentBinding(binding)) {
+            const params = getBindingDeepAgentParams(binding);
             return {
                 ...binding,
                 deepAgentParams: {
-                    ...binding.deepAgentParams,
-                    systemPrompt: [binding.deepAgentParams.systemPrompt, STRICT_TOOL_JSON_INSTRUCTION].filter(Boolean).join("\n\n"),
+                    ...params,
+                    systemPrompt: [params.systemPrompt, STRICT_TOOL_JSON_INSTRUCTION].filter(Boolean).join("\n\n"),
                 },
             };
         }
         return binding;
     }
     async synthesizeDeepAgentAnswer(binding, input, result) {
-        if (!binding.deepAgentParams) {
+        const params = getBindingDeepAgentParams(binding);
+        if (!params) {
             return "";
         }
         const toolContext = extractToolFallbackContext(result);
         if (!toolContext) {
             return "";
         }
-        const model = (await this.resolveModel(binding.deepAgentParams.model));
+        const model = (await this.resolveModel(params.model));
         if (!model?.invoke) {
             return "";
         }
@@ -384,6 +374,14 @@ export class AgentRuntimeAdapter {
             messages: this.buildAgentMessages(history, input),
         };
     }
+    buildStateSnapshot(result) {
+        const snapshot = { ...result };
+        delete snapshot.messages;
+        delete snapshot.__interrupt__;
+        delete snapshot.structuredResponse;
+        delete snapshot.files;
+        return Object.keys(snapshot).length > 0 ? snapshot : undefined;
+    }
     buildRawModelMessages(systemPrompt, history, input) {
         const messages = [];
         if (systemPrompt) {
@@ -443,15 +441,13 @@ export class AgentRuntimeAdapter {
         return compiled.size > 0 ? Object.fromEntries(compiled.entries()) : undefined;
     }
     resolveInterruptOn(binding) {
-        if (binding.deepAgentParams) {
-            return this.compileInterruptOn(binding.deepAgentParams.tools, binding.deepAgentParams.interruptOn);
-        }
-        return this.compileInterruptOn(binding.langchainAgentParams?.tools ?? [], binding.agent.langchainAgentConfig?.interruptOn);
+        return this.compileInterruptOn(getBindingPrimaryTools(binding), getBindingInterruptCompatibilityRules(binding));
     }
     async resolveMiddleware(binding, interruptOn) {
-        const declarativeMiddleware = await resolveDeclaredMiddleware(binding.langchainAgentParams?.middleware ??
-            binding.deepAgentParams?.middleware, {
+        const declarativeMiddleware = await resolveDeclaredMiddleware(getBindingMiddlewareConfigs(binding), {
             resolveModel: (model) => this.resolveModel(model),
+            resolveCustom: this.options.declaredMiddlewareResolver,
+            binding,
         });
         const middleware = [
             ...declarativeMiddleware,
@@ -485,7 +481,7 @@ export class AgentRuntimeAdapter {
             .replaceAll("{{secondaryAgentId}}", secondaryBinding.agent.id)
             .replaceAll("{{secondaryDescription}}", secondaryBinding.agent.description);
     }
-    async resolveSubagents(subagents) {
+    async resolveSubagents(subagents, binding) {
         return Promise.all(subagents.map(async (subagent) => ({
             ...subagent,
             model: subagent.model ? (await this.resolveModel(subagent.model)) : undefined,
@@ -495,38 +491,14 @@ export class AgentRuntimeAdapter {
             contextSchema: subagent.contextSchema,
             middleware: (await resolveDeclaredMiddleware(subagent.middleware, {
                 resolveModel: (model) => this.resolveModel(model),
+                resolveCustom: this.options.declaredMiddlewareResolver,
+                binding,
             })),
         })));
     }
     async create(binding) {
-        if (binding.langchainAgentParams) {
-            const interruptOn = this.resolveInterruptOn(binding);
-            const model = (await this.resolveModel(binding.langchainAgentParams.model));
-            const tools = this.resolveTools(binding.langchainAgentParams.tools, binding);
-            if (tools.length > 0 && typeof model.bindTools !== "function") {
-                throw new Error(`Agent ${binding.agent.id} configures ${tools.length} tool(s), but resolved model ${binding.langchainAgentParams.model.id} does not support tool binding.`);
-            }
-            return createAgent({
-                model: model,
-                tools: tools,
-                systemPrompt: binding.langchainAgentParams.systemPrompt,
-                stateSchema: binding.langchainAgentParams.stateSchema,
-                responseFormat: binding.langchainAgentParams.responseFormat,
-                contextSchema: binding.langchainAgentParams.contextSchema,
-                middleware: (await this.resolveMiddleware(binding, interruptOn)),
-                checkpointer: this.resolveCheckpointer(binding),
-                store: this.options.storeResolver?.(binding),
-                includeAgentName: binding.langchainAgentParams.includeAgentName,
-                version: binding.langchainAgentParams.version,
-                name: binding.langchainAgentParams.name,
-                description: binding.langchainAgentParams.description,
-            });
-        }
-        const params = binding.deepAgentParams;
-        if (!params) {
-            throw new Error(`Agent ${binding.agent.id} has no runnable params`);
-        }
-        if (this.canUseSimpleDeepAgentFastPath(binding)) {
+        if (isLangChainBinding(binding)) {
+            const params = getBindingLangChainParams(binding);
             const interruptOn = this.resolveInterruptOn(binding);
             const model = (await this.resolveModel(params.model));
             const tools = this.resolveTools(params.tools, binding);
@@ -537,12 +509,22 @@ export class AgentRuntimeAdapter {
                 model: model,
                 tools: tools,
                 systemPrompt: params.systemPrompt,
+                stateSchema: params.stateSchema,
                 responseFormat: params.responseFormat,
                 contextSchema: params.contextSchema,
                 middleware: (await this.resolveMiddleware(binding, interruptOn)),
                 checkpointer: this.resolveCheckpointer(binding),
+                store: this.options.storeResolver?.(binding),
+                includeAgentName: params.includeAgentName,
+                version: params.version,
+                name: params.name,
+                description: params.description,
             });
         }
+        const params = getBindingDeepAgentParams(binding);
+        if (!params) {
+            throw new Error(`Agent ${binding.agent.id} has no runnable params`);
+        }
         const deepAgentConfig = {
             model: (await this.resolveModel(params.model)),
             tools: this.resolveTools(params.tools, binding),
@@ -550,7 +532,7 @@ export class AgentRuntimeAdapter {
             responseFormat: params.responseFormat,
             contextSchema: params.contextSchema,
             middleware: (await this.resolveMiddleware(binding)),
-            subagents: (await this.resolveSubagents(params.subagents)),
+            subagents: (await this.resolveSubagents(params.subagents, binding)),
             checkpointer: this.resolveCheckpointer(binding),
             store: this.options.storeResolver?.(binding),
             backend: this.options.backendResolver?.(binding),
@@ -564,10 +546,8 @@ export class AgentRuntimeAdapter {
         return createDeepAgent(deepAgentConfig);
     }
     async route(input, primaryBinding, secondaryBinding, options = {}) {
-        const routeModelConfig = primaryBinding.langchainAgentParams?.model ??
-            primaryBinding.deepAgentParams?.model ??
-            secondaryBinding.langchainAgentParams?.model ??
-            secondaryBinding.deepAgentParams?.model;
+        const routeModelConfig = getBindingPrimaryModel(primaryBinding) ??
+            getBindingPrimaryModel(secondaryBinding);
         if (!routeModelConfig) {
             throw new Error("No router model configuration available");
         }
@@ -619,13 +599,21 @@ export class AgentRuntimeAdapter {
             throw new Error(emptyAssistantMessageFailure);
         }
         const output = visibleOutput || synthesizedOutput || toolFallback || JSON.stringify(result, null, 2);
+        const finalMessageText = sanitizeVisibleText(output);
         return {
             threadId,
             runId,
             agentId: binding.agent.id,
             state: Array.isArray(result.__interrupt__) && result.__interrupt__.length > 0 ? "waiting_for_approval" : "completed",
             interruptContent,
-            output: sanitizeVisibleText(output),
+            output: finalMessageText,
+            finalMessageText,
+            metadata: {
+                ...(result.structuredResponse !== undefined ? { structuredResponse: result.structuredResponse } : {}),
+                ...(asRecord(result.files) ? { files: asRecord(result.files) } : {}),
+                ...(this.buildStateSnapshot(result) ? { stateSnapshot: this.buildStateSnapshot(result) } : {}),
+                upstreamResult: result,
+            },
         };
     }
     async *stream(binding, input, threadId, history = [], options = {}) {
@@ -633,9 +621,9 @@ export class AgentRuntimeAdapter {
             const invokeTimeoutMs = this.resolveBindingTimeout(binding);
             const streamIdleTimeoutMs = this.resolveStreamIdleTimeout(binding);
             const streamDeadlineAt = invokeTimeoutMs ? Date.now() + invokeTimeoutMs : undefined;
-            if (binding.langchainAgentParams) {
-                const langchainParams = binding.langchainAgentParams;
-                const resolvedModel = (await this.resolveModel(binding.langchainAgentParams.model));
+            if (isLangChainBinding(binding)) {
+                const langchainParams = getBindingLangChainParams(binding);
+                const resolvedModel = (await this.resolveModel(langchainParams.model));
                 const tools = this.resolveTools(langchainParams.tools, binding);
                 const canUseDirectModelStream = tools.length === 0 || typeof resolvedModel.bindTools !== "function";
                 const model = canUseDirectModelStream
@@ -647,7 +635,7 @@ export class AgentRuntimeAdapter {
                 // agent loop and only adds an extra model round-trip before the runnable path.
                 if (canUseDirectModelStream && typeof model.stream === "function") {
                     let emitted = false;
-                    const stream = await this.withTimeout(() => model.stream(this.buildRawModelMessages(langchainParams.systemPrompt, history, input)), computeRemainingTimeoutMs(streamDeadlineAt, invokeTimeoutMs), "model stream start", "stream");
+                    const stream = await this.withTimeout(() => model.stream(this.buildRawModelMessages(getBindingSystemPrompt(binding), history, input)), computeRemainingTimeoutMs(streamDeadlineAt, invokeTimeoutMs), "model stream start", "stream");
                     for await (const chunk of this.iterateWithTimeout(stream, streamIdleTimeoutMs, "model stream", streamDeadlineAt, invokeTimeoutMs)) {
                         const delta = readStreamDelta(chunk);
                         if (delta) {
@@ -669,7 +657,7 @@ export class AgentRuntimeAdapter {
             const request = this.buildInvocationRequest(history, input, options);
             if (typeof runnable.streamEvents === "function") {
                 const events = await this.withTimeout(() => runnable.streamEvents(request, { configurable: { thread_id: threadId }, version: "v2", ...(options.context ? { context: options.context } : {}) }), computeRemainingTimeoutMs(streamDeadlineAt, invokeTimeoutMs), "agent streamEvents start", "stream");
-                const allowVisibleStreamDeltas = Boolean(binding.langchainAgentParams);
+                const allowVisibleStreamDeltas = isLangChainBinding(binding);
                 let emittedOutput = "";
                 let emittedToolError = false;
                 const seenTerminalOutputs = new Set();
@@ -694,7 +682,7 @@ export class AgentRuntimeAdapter {
                             }
                         }
                     }
-                    if (binding.deepAgentParams) {
+                    if (isDeepAgentBinding(binding)) {
                         const stateStreamOutput = extractStateStreamOutput(event);
                         if (stateStreamOutput) {
                             const nextOutput = computeIncrementalOutput(emittedOutput, sanitizeVisibleText(stateStreamOutput));
@@ -734,7 +722,7 @@ export class AgentRuntimeAdapter {
                     return;
                 }
             }
-            if (binding.langchainAgentParams && typeof runnable.stream === "function") {
+            if (isLangChainBinding(binding) && typeof runnable.stream === "function") {
                 const stream = await this.withTimeout(() => runnable.stream(request, { configurable: { thread_id: threadId } }), computeRemainingTimeoutMs(streamDeadlineAt, invokeTimeoutMs), "agent stream start", "stream");
                 let emitted = false;
                 for await (const chunk of this.iterateWithTimeout(stream, streamIdleTimeoutMs, "agent stream", streamDeadlineAt, invokeTimeoutMs)) {

package/dist/runtime/checkpoint-maintenance.js

@@ -46,7 +46,7 @@ export function readCheckpointMaintenanceConfig(workspace) {
 }
 function resolveSqliteCheckpointPath(binding) {
     const config = binding.harnessRuntime.checkpointer;
-    if (!config) {
+    if (!config || typeof config === "boolean") {
         return null;
     }
     const kind = typeof config.kind === "string" ? config.kind : "FileCheckpointer";

package/dist/runtime/declared-middleware.d.ts

@@ -1,4 +1,11 @@
-import type { CompiledModel } from "../contracts/types.js";
+import type { CompiledAgentBinding, CompiledModel } from "../contracts/types.js";
 export declare function resolveDeclaredMiddleware(middlewareConfigs: unknown[] | undefined, options: {
     resolveModel: (model: CompiledModel) => Promise<unknown>;
+    resolveCustom?: (input: {
+        kind: string;
+        config: Record<string, unknown>;
+        binding?: CompiledAgentBinding;
+        resolveModel: (model: CompiledModel) => Promise<unknown>;
+    }) => unknown | unknown[] | null | undefined | Promise<unknown | unknown[] | null | undefined>;
+    binding?: CompiledAgentBinding;
 }): Promise<unknown[]>;

package/dist/runtime/declared-middleware.js

@@ -83,8 +83,25 @@ export async function resolveDeclaredMiddleware(middlewareConfigs, options) {
             case "anthropicPromptCaching":
                 resolved.push(anthropicPromptCachingMiddleware(runtimeConfig));
                 break;
-            default:
+            default: {
+                const customResolved = options.resolveCustom
+                    ? await options.resolveCustom({
+                        kind,
+                        config: runtimeConfig,
+                        binding: options.binding,
+                        resolveModel: options.resolveModel,
+                    })
+                    : undefined;
+                if (Array.isArray(customResolved)) {
+                    resolved.push(...customResolved);
+                    break;
+                }
+                if (customResolved) {
+                    resolved.push(customResolved);
+                    break;
+                }
                 throw new Error(`Unsupported declarative middleware kind ${kind}`);
+            }
         }
     }
     return resolved;

package/dist/runtime/harness.d.ts

@@ -21,6 +21,11 @@ export declare class AgentHarnessRuntime {
     private readonly resolvedRuntimeAdapterOptions;
     private readonly checkpointMaintenance;
     private readonly recoveryConfig;
+    private readonly concurrencyConfig;
+    private activeRunSlots;
+    private readonly pendingRunSlots;
+    private toPublicApprovalRecord;
+    private normalizeInvocationEnvelope;
     private listHostBindings;
     private defaultRunRoot;
     private heuristicRoute;
@@ -68,6 +73,7 @@ export declare class AgentHarnessRuntime {
     private resolveApprovalRecord;
     private isDecisionRun;
     private notifyListener;
+    private acquireRunSlot;
     private dispatchRunListeners;
     run(options: RunOptions): Promise<RunResult>;
     streamEvents(options: RunStartOptions): AsyncGenerator<HarnessStreamItem>;