@botbotgo/agent-harness 0.0.40 → 0.0.42

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

@@ -12,6 +12,9 @@ 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";
+function countConfiguredTools(binding) {
+    return binding.langchainAgentParams?.tools.length ?? binding.deepAgentParams?.tools.length ?? 0;
+}
 const AGENT_INTERRUPT_SENTINEL_PREFIX = "__agent_harness_interrupt__:";
 const MODEL_SAFE_TOOL_NAME_PATTERN = /^[a-zA-Z0-9_-]+$/;
 class RuntimeOperationTimeoutError extends Error {
@@ -163,33 +166,11 @@ 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);
     }
@@ -377,6 +358,13 @@ export class AgentRuntimeAdapter {
             { role: "user", content: normalizeMessageContent(input) },
         ];
     }
+    buildInvocationRequest(history, input, options = {}) {
+        return {
+            ...(options.state ?? {}),
+            ...(options.files ? { files: options.files } : {}),
+            messages: this.buildAgentMessages(history, input),
+        };
+    }
     buildRawModelMessages(systemPrompt, history, input) {
         const messages = [];
         if (systemPrompt) {
@@ -445,6 +433,8 @@ export class AgentRuntimeAdapter {
         const declarativeMiddleware = await resolveDeclaredMiddleware(binding.langchainAgentParams?.middleware ??
             binding.deepAgentParams?.middleware, {
             resolveModel: (model) => this.resolveModel(model),
+            resolveCustom: this.options.declaredMiddlewareResolver,
+            binding,
         });
         const middleware = [
             ...declarativeMiddleware,
@@ -478,7 +468,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,
@@ -488,6 +478,8 @@ export class AgentRuntimeAdapter {
             contextSchema: subagent.contextSchema,
             middleware: (await resolveDeclaredMiddleware(subagent.middleware, {
                 resolveModel: (model) => this.resolveModel(model),
+                resolveCustom: this.options.declaredMiddlewareResolver,
+                binding,
             })),
         })));
     }
@@ -503,33 +495,22 @@ export class AgentRuntimeAdapter {
                 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)) {
-            const interruptOn = this.resolveInterruptOn(binding);
-            const model = (await this.resolveModel(params.model));
-            const tools = this.resolveTools(params.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 ${params.model.id} does not support tool binding.`);
-            }
-            return createAgent({
-                model: model,
-                tools: tools,
-                systemPrompt: params.systemPrompt,
-                responseFormat: params.responseFormat,
-                contextSchema: params.contextSchema,
-                middleware: (await this.resolveMiddleware(binding, interruptOn)),
-                checkpointer: this.resolveCheckpointer(binding),
-            });
-        }
         const deepAgentConfig = {
             model: (await this.resolveModel(params.model)),
             tools: this.resolveTools(params.tools, binding),
@@ -537,7 +518,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),
@@ -545,6 +526,8 @@ export class AgentRuntimeAdapter {
             name: params.name,
             memory: params.memory,
             skills: params.skills,
+            generalPurposeAgent: params.generalPurposeAgent,
+            taskDescription: params.taskDescription,
         };
         return createDeepAgent(deepAgentConfig);
     }
@@ -577,14 +560,14 @@ export class AgentRuntimeAdapter {
             ? secondaryBinding.agent.id
             : primaryBinding.agent.id;
     }
-    async invoke(binding, input, threadId, runId, resumePayload, history = []) {
+    async invoke(binding, input, threadId, runId, resumePayload, history = [], options = {}) {
         const request = resumePayload === undefined
-            ? { messages: this.buildAgentMessages(history, input) }
+            ? this.buildInvocationRequest(history, input, options)
             : new Command({ resume: resumePayload });
         let result;
         try {
             const runnable = await this.create(binding);
-            result = (await this.withTimeout(() => runnable.invoke(request, { configurable: { thread_id: threadId } }), this.resolveBindingTimeout(binding), "agent invoke", "invoke"));
+            result = (await this.withTimeout(() => runnable.invoke(request, { configurable: { thread_id: threadId }, ...(options.context ? { context: options.context } : {}) }), this.resolveBindingTimeout(binding), "agent invoke", "invoke"));
         }
         catch (error) {
             if (resumePayload !== undefined || !isToolCallParseFailure(error)) {
@@ -592,7 +575,7 @@ export class AgentRuntimeAdapter {
             }
             const retriedBinding = this.applyStrictToolJsonInstruction(binding);
             const runnable = await this.create(retriedBinding);
-            result = (await this.withTimeout(() => runnable.invoke({ messages: this.buildAgentMessages(history, input) }, { configurable: { thread_id: threadId } }), this.resolveBindingTimeout(retriedBinding), "agent invoke", "invoke"));
+            result = (await this.withTimeout(() => runnable.invoke(this.buildInvocationRequest(history, input, options), { configurable: { thread_id: threadId }, ...(options.context ? { context: options.context } : {}) }), this.resolveBindingTimeout(retriedBinding), "agent invoke", "invoke"));
         }
         const interruptContent = Array.isArray(result.__interrupt__) && result.__interrupt__.length > 0 ? JSON.stringify(result.__interrupt__) : undefined;
         const extractedOutput = extractVisibleOutput(result);
@@ -613,7 +596,7 @@ export class AgentRuntimeAdapter {
             output: sanitizeVisibleText(output),
         };
     }
-    async *stream(binding, input, threadId, history = []) {
+    async *stream(binding, input, threadId, history = [], options = {}) {
         try {
             const invokeTimeoutMs = this.resolveBindingTimeout(binding);
             const streamIdleTimeoutMs = this.resolveStreamIdleTimeout(binding);
@@ -651,9 +634,9 @@ export class AgentRuntimeAdapter {
                 }
             }
             const runnable = await this.create(binding);
-            const request = { messages: this.buildAgentMessages(history, input) };
+            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" }), computeRemainingTimeoutMs(streamDeadlineAt, invokeTimeoutMs), "agent streamEvents start", "stream");
+                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);
                 let emittedOutput = "";
                 let emittedToolError = false;

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

@@ -1,4 +1,4 @@
-import { modelCallLimitMiddleware, modelRetryMiddleware, summarizationMiddleware, todoListMiddleware, toolCallLimitMiddleware, toolRetryMiddleware, } from "langchain";
+import { anthropicPromptCachingMiddleware, contextEditingMiddleware, llmToolSelectorMiddleware, modelCallLimitMiddleware, modelFallbackMiddleware, modelRetryMiddleware, openAIModerationMiddleware, summarizationMiddleware, todoListMiddleware, toolCallLimitMiddleware, toolEmulatorMiddleware, toolRetryMiddleware, } from "langchain";
 function asMiddlewareConfig(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value) ? { ...value } : null;
 }
@@ -13,6 +13,18 @@ function omitKind(config) {
     const { kind: _kind, ...rest } = config;
     return rest;
 }
+async function resolveReferencedModel(value, options) {
+    if (value && typeof value === "object" && "id" in value) {
+        return options.resolveModel(value);
+    }
+    return value;
+}
+async function resolveReferencedModelList(values, options) {
+    if (!Array.isArray(values)) {
+        return undefined;
+    }
+    return Promise.all(values.map((value) => resolveReferencedModel(value, options)));
+}
 export async function resolveDeclaredMiddleware(middlewareConfigs, options) {
     const resolved = [];
     for (const rawConfig of middlewareConfigs ?? []) {
@@ -24,18 +36,29 @@ export async function resolveDeclaredMiddleware(middlewareConfigs, options) {
         const runtimeConfig = omitKind(config);
         switch (kind) {
             case "summarization": {
-                if (runtimeConfig.model && typeof runtimeConfig.model === "object" && runtimeConfig.model !== null && "id" in runtimeConfig.model) {
-                    runtimeConfig.model = await options.resolveModel(runtimeConfig.model);
-                }
+                runtimeConfig.model = await resolveReferencedModel(runtimeConfig.model, options);
                 if (runtimeConfig.model === undefined) {
                     throw new Error("summarization middleware requires model or modelRef");
                 }
                 resolved.push(summarizationMiddleware(runtimeConfig));
                 break;
             }
+            case "llmToolSelector":
+                runtimeConfig.model = await resolveReferencedModel(runtimeConfig.model, options);
+                resolved.push(llmToolSelectorMiddleware(runtimeConfig));
+                break;
             case "modelRetry":
                 resolved.push(modelRetryMiddleware(runtimeConfig));
                 break;
+            case "modelFallback": {
+                const fallbackModels = (await resolveReferencedModelList(runtimeConfig.fallbackModels, options)) ??
+                    (await resolveReferencedModelList(runtimeConfig.models, options));
+                if (!fallbackModels || fallbackModels.length === 0) {
+                    throw new Error("modelFallback middleware requires fallbackModels or models");
+                }
+                resolved.push(modelFallbackMiddleware(...fallbackModels));
+                break;
+            }
             case "toolRetry":
                 resolved.push(toolRetryMiddleware(runtimeConfig));
                 break;
@@ -48,8 +71,37 @@ export async function resolveDeclaredMiddleware(middlewareConfigs, options) {
             case "todoList":
                 resolved.push(todoListMiddleware(runtimeConfig));
                 break;
-            default:
+            case "contextEditing":
+                resolved.push(contextEditingMiddleware(runtimeConfig));
+                break;
+            case "toolEmulator":
+                resolved.push(toolEmulatorMiddleware(runtimeConfig));
+                break;
+            case "openAIModeration":
+                resolved.push(openAIModerationMiddleware(runtimeConfig));
+                break;
+            case "anthropicPromptCaching":
+                resolved.push(anthropicPromptCachingMiddleware(runtimeConfig));
+                break;
+            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

@@ -20,6 +20,10 @@ export declare class AgentHarnessRuntime {
     private readonly unregisterThreadMemorySync;
     private readonly resolvedRuntimeAdapterOptions;
     private readonly checkpointMaintenance;
+    private readonly recoveryConfig;
+    private readonly concurrencyConfig;
+    private activeRunSlots;
+    private readonly pendingRunSlots;
     private listHostBindings;
     private defaultRunRoot;
     private heuristicRoute;
@@ -53,8 +57,11 @@ export declare class AgentHarnessRuntime {
     private emit;
     private ensureThreadStarted;
     private loadPriorHistory;
+    private loadRunInput;
     private appendAssistantMessage;
     private invokeWithHistory;
+    private checkpointRefForState;
+    private finalizeContinuedRun;
     private emitOutputDeltaAndCreateItem;
     private emitRunCreated;
     private setRunStateAndEmit;
@@ -64,6 +71,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>;
@@ -73,5 +81,6 @@ export declare class AgentHarnessRuntime {
     }>;
     close(): Promise<void>;
     stop(): Promise<void>;
+    private recoverStartupRuns;
 }
 export { AgentHarnessRuntime as AgentHarness };