@botbotgo/agent-harness 0.0.109 → 0.0.111

package/dist/package-version.d.ts

@@ -1 +1 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.108";
+export declare const AGENT_HARNESS_VERSION = "0.0.110";

package/dist/package-version.js

@@ -1 +1 @@
-export const AGENT_HARNESS_VERSION = "0.0.108";
+export const AGENT_HARNESS_VERSION = "0.0.110";

package/dist/runtime/adapter/invocation-result.js

@@ -16,6 +16,8 @@ export function finalizeInvocationResult(params) {
     const outputContent = extractOutputContent(result);
     const contentBlocks = extractContentBlocks(result);
     const structuredResponse = result.structuredResponse;
+    const files = asRecord(result.files);
+    const stateSnapshot = buildStateSnapshot(result);
     return {
         threadId,
         runId,
@@ -32,8 +34,8 @@ export function finalizeInvocationResult(params) {
             ...(structuredResponse !== undefined ? { structuredResponse } : {}),
             ...(outputContent !== undefined ? { outputContent } : {}),
             ...(contentBlocks.length > 0 ? { contentBlocks } : {}),
-            ...(asRecord(result.files) ? { files: asRecord(result.files) } : {}),
-            ...(buildStateSnapshot(result) ? { stateSnapshot: buildStateSnapshot(result) } : {}),
+            ...(files ? { files } : {}),
+            ...(stateSnapshot ? { stateSnapshot } : {}),
             upstreamResult: result,
         },
     };

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

@@ -1,22 +1,19 @@
-import { getBindingExecutionView } from "../support/compiled-binding.js";
+import { bindingHasLangChainSubagentSupport, bindingHasMiddlewareKind, getBindingToolCount, } from "../support/compiled-binding.js";
+import { isRecord as isRecordValue } from "../../utils/object.js";
 export function countConfiguredTools(binding) {
-    return getBindingExecutionView(binding).primaryTools.length;
+    return getBindingToolCount(binding);
 }
 export function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
 export function hasConfiguredSubagentSupport(binding) {
-    const params = getBindingExecutionView(binding).langchainParams;
-    if (!params) {
-        return false;
-    }
-    return (params.subagents?.length ?? 0) > 0 || params.generalPurposeAgent === true || Boolean(params.taskDescription?.trim());
+    return bindingHasLangChainSubagentSupport(binding);
 }
 export function hasConfiguredMiddlewareKind(binding, kind) {
-    return getBindingExecutionView(binding).middlewareConfigs?.some((entry) => entry.kind === kind) ?? false;
+    return bindingHasMiddlewareKind(binding, kind);
 }
 export function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
+    return isRecordValue(value);
 }
 export function isObject(value) {
     return isRecord(value);

package/dist/runtime/adapter/tool/tool-arguments.js

@@ -1,7 +1,5 @@
 import { salvageToolArgs } from "../../parsing/output-parsing.js";
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
+import { isRecord } from "../../../utils/object.js";
 function isObject(value) {
     return isRecord(value);
 }

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

@@ -30,6 +30,7 @@ export declare class AgentRuntimeAdapter {
     private resolveFilesystemBackend;
     private resolveBuiltinMiddlewareBackend;
     private createDeclaredMiddlewareResolverOptions;
+    private createAssemblyResolvers;
     private invokeBuiltinTaskTool;
     private resolveBuiltinMiddlewareTools;
     private resolveAutomaticSummarizationMiddleware;

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

@@ -149,57 +149,76 @@ export class AgentRuntimeAdapter {
             binding,
         };
     }
+    createAssemblyResolvers(binding, options = {}) {
+        return {
+            resolveModel: (model) => this.resolveModel(model),
+            resolveTools: (tools, currentBinding) => this.resolveTools(tools, currentBinding),
+            resolveFilesystemBackend: (currentBinding) => this.resolveFilesystemBackend(currentBinding),
+            createDeclaredMiddlewareResolverOptions: (currentBinding) => this.createDeclaredMiddlewareResolverOptions(currentBinding),
+            resolveBuiltinMiddlewareBackend: (currentBinding, currentOptions = {}) => this.resolveBuiltinMiddlewareBackend(currentBinding, currentOptions),
+            resolveSubagents: (subagents, currentBinding) => this.resolveSubagents(subagents, currentBinding),
+            invokeBuiltinTaskTool: (currentBinding, toolInput, currentOptions = {}) => this.invokeBuiltinTaskTool(currentBinding, toolInput, currentOptions),
+            binding,
+            options,
+        };
+    }
     async invokeBuiltinTaskTool(binding, input, options = {}) {
+        const assembly = this.createAssemblyResolvers(binding, options);
         return invokeBuiltinTaskToolHelper({
             binding,
             toolInput: input,
             options,
-            resolveBuiltinMiddlewareBackend: (currentBinding, currentOptions) => this.resolveBuiltinMiddlewareBackend(currentBinding, currentOptions),
-            resolveSubagents: (subagents, currentBinding) => this.resolveSubagents(subagents, currentBinding),
-            resolveModel: (model) => this.resolveModel(model),
-            resolveTools: (tools, currentBinding) => this.resolveTools(tools, currentBinding),
+            resolveBuiltinMiddlewareBackend: assembly.resolveBuiltinMiddlewareBackend,
+            resolveSubagents: assembly.resolveSubagents,
+            resolveModel: assembly.resolveModel,
+            resolveTools: assembly.resolveTools,
         });
     }
     async resolveBuiltinMiddlewareTools(binding, options = {}) {
+        const assembly = this.createAssemblyResolvers(binding, options);
         return resolveBuiltinMiddlewareToolsHelper({
             binding,
             options,
-            resolveBuiltinMiddlewareBackend: (currentBinding, currentOptions) => this.resolveBuiltinMiddlewareBackend(currentBinding, currentOptions),
-            invokeBuiltinTaskTool: (currentBinding, toolInput, currentOptions) => this.invokeBuiltinTaskTool(currentBinding, toolInput, currentOptions),
+            resolveBuiltinMiddlewareBackend: assembly.resolveBuiltinMiddlewareBackend,
+            invokeBuiltinTaskTool: assembly.invokeBuiltinTaskTool,
         });
     }
     async resolveAutomaticSummarizationMiddleware(binding) {
+        const assembly = this.createAssemblyResolvers(binding);
         return resolveAutomaticSummarizationMiddlewareHelper({
             binding,
-            createDeclaredMiddlewareResolverOptions: (currentBinding) => this.createDeclaredMiddlewareResolverOptions(currentBinding),
+            createDeclaredMiddlewareResolverOptions: assembly.createDeclaredMiddlewareResolverOptions,
         });
     }
     async resolveLangChainAutomaticMiddleware(binding) {
+        const assembly = this.createAssemblyResolvers(binding);
         return resolveLangChainAutomaticMiddlewareHelper({
             binding,
             resolveAutomaticSummarizationMiddleware: (currentBinding) => this.resolveAutomaticSummarizationMiddleware(currentBinding),
-            resolveFilesystemBackend: (currentBinding) => this.resolveFilesystemBackend(currentBinding),
-            resolveModel: (model) => this.resolveModel(model),
-            resolveTools: (tools, currentBinding) => this.resolveTools(tools, currentBinding),
-            resolveSubagents: (subagents, currentBinding) => this.resolveSubagents(subagents, currentBinding),
+            resolveFilesystemBackend: assembly.resolveFilesystemBackend,
+            resolveModel: assembly.resolveModel,
+            resolveTools: assembly.resolveTools,
+            resolveSubagents: assembly.resolveSubagents,
         });
     }
     async resolveMiddleware(binding, interruptOn) {
+        const assembly = this.createAssemblyResolvers(binding);
         return resolveMiddlewareHelper({
             binding,
             interruptOn,
             runtimeAdapterOptions: this.options,
-            createDeclaredMiddlewareResolverOptions: (currentBinding) => this.createDeclaredMiddlewareResolverOptions(currentBinding),
+            createDeclaredMiddlewareResolverOptions: assembly.createDeclaredMiddlewareResolverOptions,
             resolveLangChainAutomaticMiddleware: (currentBinding) => this.resolveLangChainAutomaticMiddleware(currentBinding),
         });
     }
     async resolveSubagents(subagents, binding) {
+        const assembly = this.createAssemblyResolvers(binding);
         return resolveSubagentsHelper({
             subagents,
             binding,
-            resolveModel: (model) => this.resolveModel(model),
-            resolveTools: (tools, currentBinding) => this.resolveTools(tools, currentBinding),
-            createDeclaredMiddlewareResolverOptions: (currentBinding) => this.createDeclaredMiddlewareResolverOptions(currentBinding),
+            resolveModel: assembly.resolveModel,
+            resolveTools: assembly.resolveTools,
+            createDeclaredMiddlewareResolverOptions: assembly.createDeclaredMiddlewareResolverOptions,
         });
     }
     async createLangChainRunnable(binding, options = {}) {

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

@@ -1,28 +1,37 @@
 import { normalizeRunPriority } from "./helpers.js";
-export async function recoverQueuedStartupRun(context, thread) {
-    if (thread.status !== "queued") {
-        return false;
+async function failRecovery(context, thread, previousState, error, options = {}) {
+    await context.setRunStateAndEmit(thread.threadId, thread.latestRunId, 100, "failed", {
+        previousState,
+        error,
+    });
+    if (options.releaseRunClaim) {
+        await context.persistence.releaseRunClaim(thread.latestRunId);
     }
+    return true;
+}
+async function resolveRecoveryBinding(context, thread) {
     const runMeta = await context.persistence.getRunMeta(thread.threadId, thread.latestRunId);
     const binding = context.getBinding(runMeta.agentId);
     if (!binding) {
-        return true;
-    }
-    const request = await context.persistence.getRunRequest(thread.threadId, thread.latestRunId);
-    if (!request) {
-        await context.setRunStateAndEmit(thread.threadId, thread.latestRunId, 100, "failed", {
-            previousState: "queued",
-            error: "missing persisted run request for queued run recovery",
-        });
-        return true;
+        return null;
     }
+    return {
+        binding,
+        agentId: runMeta.agentId,
+    };
+}
+async function executeRecoveredRun(context, input) {
+    const { thread, binding, agentId, request, previousState, emitResumeEvent } = input;
     const releaseRunSlot = await context.acquireRunSlot(thread.threadId, thread.latestRunId, "running", normalizeRunPriority(request.priority));
     try {
-        await context.executeQueuedRun(binding, request.input, thread.threadId, thread.latestRunId, runMeta.agentId, {
+        if (emitResumeEvent) {
+            await context.emit(thread.threadId, thread.latestRunId, emitResumeEvent.sequence, emitResumeEvent.eventType, emitResumeEvent.payload);
+        }
+        await context.executeQueuedRun(binding, request.input, thread.threadId, thread.latestRunId, agentId, {
             context: request.invocation?.context,
             state: request.invocation?.inputs,
             files: request.invocation?.attachments,
-            previousState: "queued",
+            previousState,
             stateSequence: 103,
             approvalSequence: 104,
         });
@@ -32,6 +41,26 @@ export async function recoverQueuedStartupRun(context, thread) {
     }
     return true;
 }
+export async function recoverQueuedStartupRun(context, thread) {
+    if (thread.status !== "queued") {
+        return false;
+    }
+    const resolved = await resolveRecoveryBinding(context, thread);
+    if (!resolved) {
+        return true;
+    }
+    const request = await context.persistence.getRunRequest(thread.threadId, thread.latestRunId);
+    if (!request) {
+        return failRecovery(context, thread, "queued", "missing persisted run request for queued run recovery");
+    }
+    return executeRecoveredRun(context, {
+        thread,
+        binding: resolved.binding,
+        agentId: resolved.agentId,
+        request,
+        previousState: "queued",
+    });
+}
 export async function recoverRunningStartupRun(context, thread) {
     if (thread.status !== "running") {
         return false;
@@ -40,47 +69,36 @@ export async function recoverRunningStartupRun(context, thread) {
     if (!isStale) {
         return true;
     }
-    const runMeta = await context.persistence.getRunMeta(thread.threadId, thread.latestRunId);
-    const binding = context.getBinding(runMeta.agentId);
-    if (!binding) {
+    const resolved = await resolveRecoveryBinding(context, thread);
+    if (!resolved) {
         return true;
     }
-    if (!context.supportsRunningReplay(binding)) {
-        await context.setRunStateAndEmit(thread.threadId, thread.latestRunId, 100, "failed", {
-            previousState: "running",
-            error: "stale running run cannot be replayed safely",
+    if (!context.supportsRunningReplay(resolved.binding)) {
+        return failRecovery(context, thread, "running", "stale running run cannot be replayed safely", {
+            releaseRunClaim: true,
         });
-        await context.persistence.releaseRunClaim(thread.latestRunId);
-        return true;
     }
     const request = await context.persistence.getRunRequest(thread.threadId, thread.latestRunId);
     if (!request) {
-        await context.setRunStateAndEmit(thread.threadId, thread.latestRunId, 100, "failed", {
-            previousState: "running",
-            error: "missing persisted run request for stale running run recovery",
+        return failRecovery(context, thread, "running", "missing persisted run request for stale running run recovery", {
+            releaseRunClaim: true,
         });
-        await context.persistence.releaseRunClaim(thread.latestRunId);
-        return true;
     }
-    const releaseRunSlot = await context.acquireRunSlot(thread.threadId, thread.latestRunId, "running", normalizeRunPriority(request.priority));
-    try {
-        await context.emit(thread.threadId, thread.latestRunId, 100, "run.resumed", {
-            resumeKind: "startup-running-recovery",
-            state: "running",
-        });
-        await context.executeQueuedRun(binding, request.input, thread.threadId, thread.latestRunId, runMeta.agentId, {
-            context: request.invocation?.context,
-            state: request.invocation?.inputs,
-            files: request.invocation?.attachments,
-            previousState: "running",
-            stateSequence: 103,
-            approvalSequence: 104,
-        });
-    }
-    finally {
-        await releaseRunSlot();
-    }
-    return true;
+    return executeRecoveredRun(context, {
+        thread,
+        binding: resolved.binding,
+        agentId: resolved.agentId,
+        request,
+        previousState: "running",
+        emitResumeEvent: {
+            sequence: 100,
+            eventType: "run.resumed",
+            payload: {
+                resumeKind: "startup-running-recovery",
+                state: "running",
+            },
+        },
+    });
 }
 export async function recoverResumingStartupRun(context, thread) {
     if (thread.status !== "resuming" || !context.recoveryConfig.resumeResumingRunsOnStartup) {

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

@@ -1,4 +1,14 @@
 import { isTerminalRunState } from "./helpers.js";
+async function finalizeIfCancellationRequested(input) {
+    const cancellation = await input.getRunCancellation(input.runId);
+    if (!cancellation.requested) {
+        return null;
+    }
+    return input.finalizeCancelledRun(input.threadId, input.runId, input.previousState, cancellation.reason);
+}
+function normalizeContinuationState(previousState) {
+    return previousState === "queued" ? "running" : previousState;
+}
 export async function resumeRun(runtime, options) {
     const approvalById = options.approvalId ? await runtime.getApprovalById(options.approvalId) : null;
     const thread = options.threadId
@@ -17,9 +27,15 @@ export async function resumeRun(runtime, options) {
         throw new Error(`Unknown agent ${thread.agentId}`);
     }
     const resumePayload = runtime.buildResumePayload(binding, approval, options);
-    const cancellation = await runtime.getRunCancellation(runId);
-    if (cancellation.requested) {
-        return runtime.finalizeCancelledRun(threadId, runId, thread.status, cancellation.reason);
+    const cancelledBeforeResume = await finalizeIfCancellationRequested({
+        getRunCancellation: runtime.getRunCancellation,
+        finalizeCancelledRun: runtime.finalizeCancelledRun,
+        threadId,
+        runId,
+        previousState: thread.status,
+    });
+    if (cancelledBeforeResume) {
+        return cancelledBeforeResume;
     }
     const checkpointRef = `checkpoints/${threadId}/${runId}/cp-1`;
     await runtime.setRunState(threadId, runId, "resuming", checkpointRef);
@@ -53,9 +69,15 @@ export async function resumeRun(runtime, options) {
         try {
             const actual = await runtime.invoke(binding, "", threadId, runId, resumePayload, priorHistory);
             runtime.recordLlmSuccess(startedAt);
-            const cancelledAfterInvoke = await runtime.getRunCancellation(runId);
-            if (cancelledAfterInvoke.requested) {
-                return runtime.finalizeCancelledRun(threadId, runId, "resuming", cancelledAfterInvoke.reason);
+            const cancelledAfterInvoke = await finalizeIfCancellationRequested({
+                getRunCancellation: runtime.getRunCancellation,
+                finalizeCancelledRun: runtime.finalizeCancelledRun,
+                threadId,
+                runId,
+                previousState: "resuming",
+            });
+            if (cancelledAfterInvoke) {
+                return cancelledAfterInvoke;
             }
             await runtime.clearRecoveryIntent(threadId, runId);
             const finalized = await runtime.finalizeContinuedRun(binding, threadId, runId, runInput, actual, {
@@ -125,9 +147,15 @@ export async function executeQueuedRunOperation(runtime, input) {
             output: "cancelled",
         };
     }
-    const cancellation = await runtime.getRunCancellation(runId);
-    if (cancellation.requested) {
-        return runtime.finalizeCancelledRun(threadId, runId, previousState, cancellation.reason);
+    const cancelledBeforeInvoke = await finalizeIfCancellationRequested({
+        getRunCancellation: runtime.getRunCancellation,
+        finalizeCancelledRun: runtime.finalizeCancelledRun,
+        threadId,
+        runId,
+        previousState,
+    });
+    if (cancelledBeforeInvoke) {
+        return cancelledBeforeInvoke;
     }
     if (previousState === "queued") {
         await runtime.emit(threadId, runId, 101, "run.dequeued", {
@@ -140,18 +168,25 @@ export async function executeQueuedRunOperation(runtime, input) {
             previousState: "queued",
         });
     }
+    const continuationState = normalizeContinuationState(previousState);
     try {
         const actual = await runtime.invokeWithHistory(binding, message, threadId, runId, undefined, options.priorHistory, {
             context: options.context,
             state: options.state,
             files: options.files,
         });
-        const cancelledAfterInvoke = await runtime.getRunCancellation(runId);
-        if (cancelledAfterInvoke.requested) {
-            return runtime.finalizeCancelledRun(threadId, runId, previousState === "queued" ? "running" : previousState, cancelledAfterInvoke.reason);
+        const cancelledAfterInvoke = await finalizeIfCancellationRequested({
+            getRunCancellation: runtime.getRunCancellation,
+            finalizeCancelledRun: runtime.finalizeCancelledRun,
+            threadId,
+            runId,
+            previousState: continuationState,
+        });
+        if (cancelledAfterInvoke) {
+            return cancelledAfterInvoke;
         }
         const finalized = await runtime.finalizeContinuedRun(binding, threadId, runId, message, actual, {
-            previousState: previousState === "queued" ? "running" : previousState,
+            previousState: continuationState,
             stateSequence: options.stateSequence ?? 103,
             approvalSequence: options.approvalSequence ?? 104,
         });
@@ -163,7 +198,7 @@ export async function executeQueuedRunOperation(runtime, input) {
     catch (error) {
         await runtime.emitSyntheticFallback(threadId, runId, agentId, error);
         await runtime.setRunStateAndEmit(threadId, runId, 104, "failed", {
-            previousState: previousState === "queued" ? "running" : previousState,
+            previousState: continuationState,
             error: error instanceof Error ? error.message : String(error),
         });
         return {

package/dist/runtime/harness.d.ts

@@ -40,6 +40,7 @@ export declare class AgentHarnessRuntime {
     private defaultRunRoot;
     private getDefaultHostAgentId;
     private resolveSelectedAgentId;
+    private createPrepareRunStartRuntime;
     constructor(workspace: WorkspaceBundle, runtimeAdapterOptions?: RuntimeAdapterOptions);
     private createHealthMonitor;
     private recordLlmSuccess;

package/dist/runtime/harness.js

@@ -12,10 +12,10 @@ import { HealthMonitor, readHealthMonitorConfig, } from "./harness/system/health
 import { normalizeInvocationEnvelope, normalizeRunPriority, resolveRunListeners, } from "./harness/run/helpers.js";
 import { emitHarnessEvent, } from "./harness/events/events.js";
 import { createRuntimeEventOperations } from "./harness/events/runtime-event-operations.js";
-import { finalizeCancelledRun as finalizeLifecycleCancelledRun, finalizeContinuedRun as finalizeLifecycleContinuedRun, } from "./harness/run/run-lifecycle.js";
+import { appendAssistantMessage as appendLifecycleAssistantMessage, finalizeCancelledRun as finalizeLifecycleCancelledRun, finalizeContinuedRun as finalizeLifecycleContinuedRun, } from "./harness/run/run-lifecycle.js";
 import { createListenerDispatchRuntime } from "./harness/events/listener-runtime.js";
+import { buildResumePayload as buildHarnessResumePayload, resolveApprovalRecord as resolveHarnessApprovalRecord, } from "./harness/run/resume.js";
 import { cancelRunOperation, executeQueuedRunOperation, resumeRun } from "./harness/run/run-operations.js";
-import { createResumeRunRuntime } from "./harness/run/resume-runtime.js";
 import { acquireRunSlot as acquireHarnessRunSlot } from "./harness/run/run-slot-acquisition.js";
 import { dropPendingRunSlot, enqueuePendingRunSlot } from "./harness/run/run-queue.js";
 import { getDefaultHostAgentId, resolveSelectedAgentId, routeAgentId } from "./harness/run/routing.js";
@@ -28,7 +28,6 @@ import { createDefaultHealthSnapshot, isInventoryEnabled, isThreadMemorySyncEnab
 import { resolveRuntimeAdapterOptions } from "./support/runtime-adapter-options.js";
 import { initializeHarnessRuntime, reclaimExpiredClaimedRuns as reclaimHarnessExpiredClaimedRuns, recoverStartupRuns as recoverHarnessStartupRuns, isStaleRunningRun as isHarnessStaleRunningRun, } from "./harness/run/startup-runtime.js";
 import { streamHarnessRun } from "./harness/run/stream-run.js";
-import { createStreamRunRuntime } from "./harness/run/stream-runtime.js";
 import { defaultRequestedAgentId, prepareRunStart } from "./harness/run/start-run.js";
 import { deleteThreadRecord, getPublicApproval, getThreadRecord, listPublicApprovals, } from "./harness/run/thread-records.js";
 export class AgentHarnessRuntime {
@@ -88,6 +87,16 @@ export class AgentHarnessRuntime {
             getThreadSummary: (currentThreadId) => this.getSession(currentThreadId),
         });
     }
+    createPrepareRunStartRuntime() {
+        return {
+            workspace: this.workspace,
+            policyEngine: this.policyEngine,
+            persistence: this.persistence,
+            resolveSelectedAgentId: (input, requestedAgentId, threadId) => this.resolveSelectedAgentId(input, requestedAgentId, threadId),
+            emitRunCreated: (threadId, runId, payload) => this.runtimeEventOperations.emitRunCreated(threadId, runId, payload),
+            acquireRunSlot: (threadId, runId, activeState, priority) => this.acquireRunSlot(threadId, runId, activeState, priority),
+        };
+    }
     constructor(workspace, runtimeAdapterOptions = {}) {
         this.workspace = workspace;
         this.runtimeAdapterOptions = runtimeAdapterOptions;
@@ -422,14 +431,7 @@ export class AgentHarnessRuntime {
             }).dispatchRunListeners(this.streamEvents(options), resolvedListeners);
         }
         const invocation = normalizeInvocationEnvelope(options);
-        const { binding, selectedAgentId, threadId, runId, isNewThread, runCreatedEventPromise, releaseRunSlotPromise, } = await prepareRunStart({
-            workspace: this.workspace,
-            policyEngine: this.policyEngine,
-            persistence: this.persistence,
-            resolveSelectedAgentId: (input, requestedAgentId, threadId) => this.resolveSelectedAgentId(input, requestedAgentId, threadId),
-            emitRunCreated: (threadId, runId, payload) => this.runtimeEventOperations.emitRunCreated(threadId, runId, payload),
-            acquireRunSlot: (threadId, runId, activeState, priority) => this.acquireRunSlot(threadId, runId, activeState, priority),
-        }, {
+        const { binding, selectedAgentId, threadId, runId, isNewThread, runCreatedEventPromise, releaseRunSlotPromise, } = await prepareRunStart(this.createPrepareRunStartRuntime(), {
             options,
             invocation,
             runCreatedPayload: (activeBinding, activeSelectedAgentId) => ({
@@ -473,14 +475,7 @@ export class AgentHarnessRuntime {
             }
             return;
         }
-        const { threadId, runId, isNewThread, runCreatedEventPromise, releaseRunSlotPromise, } = await prepareRunStart({
-            workspace: this.workspace,
-            policyEngine: this.policyEngine,
-            persistence: this.persistence,
-            resolveSelectedAgentId: (input, requestedAgentId, threadId) => this.resolveSelectedAgentId(input, requestedAgentId, threadId),
-            emitRunCreated: (threadId, runId, payload) => this.runtimeEventOperations.emitRunCreated(threadId, runId, payload),
-            acquireRunSlot: (threadId, runId, activeState, priority) => this.acquireRunSlot(threadId, runId, activeState, priority),
-        }, {
+        const { threadId, runId, isNewThread, runCreatedEventPromise, releaseRunSlotPromise, } = await prepareRunStart(this.createPrepareRunStartRuntime(), {
             options,
             invocation,
             runCreatedPayload: (_binding, activeSelectedAgentId) => ({
@@ -491,16 +486,6 @@ export class AgentHarnessRuntime {
                 state: "running",
             }),
         });
-        const streamRuntime = createStreamRunRuntime({
-            persistence: this.persistence,
-            runtimeAdapter: this.runtimeAdapter,
-            emit: (threadId, runId, sequence, eventType, payload) => this.emit(threadId, runId, sequence, eventType, payload),
-            setRunStateAndEmit: (threadId, runId, sequence, state, stateOptions) => this.setRunStateAndEmit(threadId, runId, sequence, state, stateOptions),
-            requestApprovalAndEmit: (threadId, runId, input, interruptContent, checkpointRef, sequence) => this.requestApprovalAndEmit(threadId, runId, input, interruptContent, checkpointRef, sequence),
-            loadPriorHistory: (threadId, runId) => this.loadPriorHistory(threadId, runId),
-            invokeWithHistory: (binding, input, threadId, runId) => this.invokeWithHistory(binding, input, threadId, runId),
-            emitSyntheticFallback: (threadId, runId, selectedAgentId, error) => this.runtimeEventOperations.emitSyntheticFallback(threadId, runId, selectedAgentId, error),
-        });
         yield* streamHarnessRun({
             binding,
             input: options.input,
@@ -511,25 +496,40 @@ export class AgentHarnessRuntime {
             isNewThread,
             runCreatedEventPromise,
             releaseRunSlotPromise,
-            ...streamRuntime,
+            loadPriorHistory: (threadId, runId) => this.loadPriorHistory(threadId, runId),
+            stream: (binding, message, threadId, priorHistory, streamOptions) => this.runtimeAdapter.stream(binding, message, threadId, priorHistory, streamOptions),
+            invokeWithHistory: (binding, input, threadId, runId) => this.invokeWithHistory(binding, input, threadId, runId),
+            emit: (threadId, runId, sequence, eventType, payload) => this.emit(threadId, runId, sequence, eventType, payload),
+            setRunStateAndEmit: (threadId, runId, sequence, state, stateOptions) => this.setRunStateAndEmit(threadId, runId, sequence, state, stateOptions),
+            requestApprovalAndEmit: (threadId, runId, input, interruptContent, checkpointRef, sequence) => this.requestApprovalAndEmit(threadId, runId, input, interruptContent, checkpointRef, sequence),
+            appendAssistantMessage: (threadId, runId, content) => appendLifecycleAssistantMessage(this.persistence, threadId, runId, content),
+            clearRunRequest: (threadId, runId) => this.persistence.clearRunRequest(threadId, runId),
+            emitSyntheticFallback: (threadId, runId, selectedAgentId, error) => this.runtimeEventOperations.emitSyntheticFallback(threadId, runId, selectedAgentId, error),
         });
     }
     async resume(options) {
-        return resumeRun(createResumeRunRuntime({
-            persistence: this.persistence,
-            workspace: this.workspace,
-            runtimeAdapter: this.runtimeAdapter,
+        return resumeRun({
+            getApprovalById: (approvalId) => this.persistence.getApproval(approvalId),
             getSession: (threadId) => this.getSession(threadId),
+            resolveApprovalRecord: (resumeOptions, thread) => resolveHarnessApprovalRecord(this.persistence, resumeOptions, thread),
+            getBinding: (agentId) => getWorkspaceBinding(this.workspace, agentId),
+            buildResumePayload: (binding, approval, resumeOptions) => buildHarnessResumePayload(binding, approval, resumeOptions),
             getRunCancellation: (runId) => this.getRunCancellation(runId),
             finalizeCancelledRun: (threadId, runId, previousState, reason) => this.finalizeCancelledRun(threadId, runId, previousState, reason),
+            setRunState: (threadId, runId, state, checkpointRef) => this.persistence.setRunState(threadId, runId, state, checkpointRef),
             acquireRunSlot: (threadId, runId, activeState, priority) => this.acquireRunSlot(threadId, runId, activeState, priority),
             resolvePersistedRunPriority: (threadId, runId) => this.resolvePersistedRunPriority(threadId, runId),
+            saveRecoveryIntent: (threadId, runId, payload) => this.persistence.saveRecoveryIntent(threadId, runId, payload),
             emit: (threadId, runId, sequence, eventType, payload) => this.emit(threadId, runId, sequence, eventType, payload),
+            resolveApproval: (threadId, runId, approvalId, resolution) => this.persistence.resolveApproval(threadId, runId, approvalId, resolution),
+            listThreadMessages: (threadId) => this.persistence.listThreadMessages(threadId),
             loadRunInput: (threadId, runId) => this.loadRunInput(threadId, runId),
+            invoke: (binding, input, threadId, runId, resumePayload, priorHistory) => this.runtimeAdapter.invoke(binding, input, threadId, runId, resumePayload, priorHistory),
             recordLlmSuccess: (startedAt) => this.recordLlmSuccess(startedAt),
             recordLlmFailure: (startedAt) => this.recordLlmFailure(startedAt),
+            clearRecoveryIntent: (threadId, runId) => this.persistence.clearRecoveryIntent(threadId, runId),
             finalizeContinuedRun: (binding, threadId, runId, input, actual, operationOptions) => this.finalizeContinuedRun(binding, threadId, runId, input, actual, operationOptions),
-        }), options);
+        }, options);
     }
     async restartConversation(options) {
         const thread = await this.getSession(options.threadId);

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

@@ -9,8 +9,12 @@ export type BindingExecutionView = {
     primaryModel?: CompiledModel;
     systemPrompt?: string;
     middlewareConfigs?: Array<Record<string, unknown>>;
+    middlewareKinds: Set<string>;
     interruptCompatibilityRules?: Record<string, boolean | object>;
     storeConfig?: Record<string, unknown>;
+    toolCount: number;
+    langChainSubagentSupport: boolean;
+    deepAgentSubagentCount: number;
 };
 export declare function getBindingExecutionView(binding: CompiledAgentBinding): BindingExecutionView;
 export declare function getBindingAdapterKind(binding: CompiledAgentBinding): string;
@@ -24,6 +28,9 @@ export declare function getBindingPrimaryModel(binding: CompiledAgentBinding): C
 export declare function getBindingRuntimeModel(binding: CompiledAgentBinding, slot: RuntimeModelSlot): CompiledModel | undefined;
 export declare function getBindingSystemPrompt(binding: CompiledAgentBinding): string | undefined;
 export declare function getBindingMiddlewareConfigs(binding: CompiledAgentBinding): Array<Record<string, unknown>> | undefined;
+export declare function getBindingToolCount(binding: CompiledAgentBinding): number;
+export declare function bindingHasMiddlewareKind(binding: CompiledAgentBinding, kind: string): boolean;
+export declare function bindingHasLangChainSubagentSupport(binding: CompiledAgentBinding): boolean;
 export declare function getBindingInterruptCompatibilityRules(binding: CompiledAgentBinding): Record<string, boolean | object> | undefined;
 export declare function getBindingModelInit(binding: CompiledAgentBinding): Record<string, unknown> | undefined;
 export declare function getBindingStoreConfig(binding: CompiledAgentBinding): Record<string, unknown> | undefined;

package/dist/runtime/support/compiled-binding.js

@@ -1,8 +1,4 @@
-function asRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value)
-        ? value
-        : undefined;
-}
+import { asRecord } from "../../utils/object.js";
 const bindingExecutionViewCache = new WeakMap();
 function deriveBindingExecutionView(binding) {
     const cached = bindingExecutionViewCache.get(binding);
@@ -19,6 +15,10 @@ function deriveBindingExecutionView(binding) {
         ? adapterParams
         : binding.deepAgentParams;
     const primaryTools = langchainParams?.tools ?? deepAgentParams?.tools ?? [];
+    const middlewareConfigs = langchainParams?.middleware ?? deepAgentParams?.middleware;
+    const middlewareKinds = new Set((middlewareConfigs ?? [])
+        .map((entry) => typeof entry.kind === "string" ? entry.kind : "")
+        .filter(Boolean));
     const view = {
         adapterKind,
         adapterConfig,
@@ -26,12 +26,18 @@ function deriveBindingExecutionView(binding) {
         deepAgentParams,
         executionParams: langchainParams ?? deepAgentParams,
         primaryTools,
+        toolCount: primaryTools.length,
         primaryModel: langchainParams?.model ?? deepAgentParams?.model,
         systemPrompt: langchainParams?.systemPrompt ?? deepAgentParams?.systemPrompt,
-        middlewareConfigs: langchainParams?.middleware ?? deepAgentParams?.middleware,
+        middlewareConfigs,
+        middlewareKinds,
         interruptCompatibilityRules: deepAgentParams?.interruptOn ??
             binding.agent.langchainAgentConfig?.interruptOn,
         storeConfig: deepAgentParams?.store ?? binding.harnessRuntime?.store,
+        langChainSubagentSupport: (langchainParams?.subagents?.length ?? 0) > 0 ||
+            langchainParams?.generalPurposeAgent === true ||
+            Boolean(langchainParams?.taskDescription?.trim()),
+        deepAgentSubagentCount: deepAgentParams?.subagents?.length ?? 0,
     };
     bindingExecutionViewCache.set(binding, view);
     return view;
@@ -72,6 +78,15 @@ export function getBindingSystemPrompt(binding) {
 export function getBindingMiddlewareConfigs(binding) {
     return getBindingExecutionView(binding).middlewareConfigs;
 }
+export function getBindingToolCount(binding) {
+    return getBindingExecutionView(binding).toolCount;
+}
+export function bindingHasMiddlewareKind(binding, kind) {
+    return getBindingExecutionView(binding).middlewareKinds.has(kind);
+}
+export function bindingHasLangChainSubagentSupport(binding) {
+    return getBindingExecutionView(binding).langChainSubagentSupport;
+}
 export function getBindingInterruptCompatibilityRules(binding) {
     return getBindingExecutionView(binding).interruptCompatibilityRules;
 }
@@ -82,5 +97,5 @@ export function getBindingStoreConfig(binding) {
     return getBindingExecutionView(binding).storeConfig;
 }
 export function bindingHasSubagents(binding) {
-    return (getBindingDeepAgentParams(binding)?.subagents.length ?? 0) > 0;
+    return getBindingExecutionView(binding).deepAgentSubagentCount > 0;
 }

package/dist/runtime/support/skill-metadata.js

@@ -1,6 +1,7 @@
 import { readFileSync } from "node:fs";
 import path from "node:path";
 import { parse } from "yaml";
+import { isRecord } from "../../utils/object.js";
 const skillMetadataCache = new Map();
 const skillValidationCache = new Map();
 const SKILL_NAME_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
@@ -8,9 +9,6 @@ function parseFrontmatterSource(document) {
     const match = document.match(/^---\s*\n([\s\S]*?)\n---\s*(?:\n|$)/);
     return match?.[1];
 }
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 function isJsonLikeValue(value) {
     if (value === null ||
         typeof value === "string" ||

package/dist/utils/object.d.ts

@@ -0,0 +1,3 @@
+export type UnknownRecord = Record<string, unknown>;
+export declare function isRecord(value: unknown): value is UnknownRecord;
+export declare function asRecord(value: unknown): UnknownRecord | undefined;

package/dist/utils/object.js

@@ -0,0 +1,6 @@
+export function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function asRecord(value) {
+    return isRecord(value) ? value : undefined;
+}

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

@@ -2,6 +2,7 @@ import path from "node:path";
 import { getSkillInheritancePolicy, resolveToolTargets } from "../extensions.js";
 import { compileModel, compileTool } from "./resource-compilers.js";
 import { inferAgentCapabilities } from "./support/agent-capabilities.js";
+import { getAgentExecutionConfigValue, getAgentExecutionObject, getAgentExecutionString } from "./support/agent-execution-config.js";
 import { discoverSkillPaths } from "./support/discovery.js";
 import { compileAgentMemories, getResilienceConfig, getRuntimeDefaults, getRuntimeMemoryDefaults, getRuntimeModelDefaults, getWorkspaceObject, resolvePromptValue, resolveRefId } from "./support/workspace-ref-utils.js";
 const WORKSPACE_BOUNDARY_GUIDANCE = "Keep repository and file exploration bounded to the current workspace root unless the user explicitly asks for broader host or filesystem access. " +
@@ -11,9 +12,7 @@ function requireSkills(pathEntries, workspaceRoot) {
     return Array.from(new Set(discoverSkillPaths(pathEntries, workspaceRoot)));
 }
 function resolveInheritancePolicy(agent) {
-    const langchainPolicy = typeof agent.langchainAgentConfig?.skillInheritancePolicy === "string" ? agent.langchainAgentConfig.skillInheritancePolicy : undefined;
-    const deepagentPolicy = typeof agent.deepAgentConfig?.skillInheritancePolicy === "string" ? agent.deepAgentConfig.skillInheritancePolicy : undefined;
-    return (langchainPolicy ?? deepagentPolicy ?? "default").trim();
+    return getAgentExecutionString(agent, "skillInheritancePolicy") ?? "default";
 }
 export function compileAgentSkills(workspaceRoot, agent, parentSkills = []) {
     const policyName = resolveInheritancePolicy(agent);
@@ -106,40 +105,28 @@ function buildSubagent(agent, workspaceRoot, models, tools, parentSkills, parent
         passthrough: execution.passthrough,
     };
 }
-function resolveDirectPrompt(agent) {
-    return resolvePromptValue(agent.langchainAgentConfig?.systemPrompt);
-}
 function resolveSystemPrompt(agent) {
+    const prompt = resolvePromptValue(getAgentExecutionConfigValue(agent, "systemPrompt"));
     if (agent.executionMode !== "deepagent") {
-        return resolveDirectPrompt(agent);
+        return prompt;
     }
-    const deepagentPrompt = resolvePromptValue(agent.deepAgentConfig?.systemPrompt);
-    return [deepagentPrompt ?? resolveDirectPrompt(agent), WORKSPACE_BOUNDARY_GUIDANCE].filter(Boolean).join("\n\n");
+    return [prompt, WORKSPACE_BOUNDARY_GUIDANCE].filter(Boolean).join("\n\n");
 }
 function resolveInterruptOn(agent) {
-    if (agent.executionMode !== "deepagent") {
-        return undefined;
-    }
-    return (agent.deepAgentConfig?.interruptOn ??
-        agent.langchainAgentConfig?.interruptOn);
+    return getAgentExecutionObject(agent, "interruptOn");
 }
 function resolveResponseFormat(agent) {
-    return agent.deepAgentConfig?.responseFormat ?? agent.langchainAgentConfig?.responseFormat;
+    return getAgentExecutionConfigValue(agent, "responseFormat");
 }
 function resolveContextSchema(agent) {
-    return agent.deepAgentConfig?.contextSchema ?? agent.langchainAgentConfig?.contextSchema;
+    return getAgentExecutionConfigValue(agent, "contextSchema");
 }
 function resolveCompiledMiddleware(agent, models) {
-    const middleware = agent.deepAgentConfig?.middleware ??
-        agent.langchainAgentConfig?.middleware;
+    const middleware = getAgentExecutionConfigValue(agent, "middleware");
     return compileMiddlewareConfigs(middleware, models, agent.id);
 }
 function resolvePassthrough(agent) {
-    const passthrough = typeof agent.deepAgentConfig?.passthrough === "object" && agent.deepAgentConfig.passthrough
-        ? agent.deepAgentConfig.passthrough
-        : typeof agent.langchainAgentConfig?.passthrough === "object" && agent.langchainAgentConfig.passthrough
-            ? agent.langchainAgentConfig.passthrough
-            : undefined;
+    const passthrough = getAgentExecutionObject(agent, "passthrough");
     return passthrough ? { ...passthrough } : undefined;
 }
 function compileSubagents(agent, agents, workspaceRoot, models, tools, compiledAgentSkills, compiledAgentModel, compiledAgentMemory) {
@@ -166,9 +153,7 @@ function resolveBackendConfig(agent, refs) {
     if (agent.executionMode !== "deepagent") {
         return undefined;
     }
-    const backendConfig = typeof agent.deepAgentConfig?.backend === "object" && agent.deepAgentConfig.backend
-        ? agent.deepAgentConfig.backend
-        : undefined;
+    const backendConfig = getAgentExecutionObject(agent, "backend");
     if (!backendConfig) {
         return undefined;
     }
@@ -221,11 +206,7 @@ function materializeWorkspaceObjectConfig(refs, ref, allowedKinds, ownerLabel) {
     return config;
 }
 function resolveStoreConfig(agent, refs) {
-    const inlineStore = typeof agent.deepAgentConfig?.store === "object" && agent.deepAgentConfig.store
-        ? agent.deepAgentConfig.store
-        : typeof agent.langchainAgentConfig?.store === "object" && agent.langchainAgentConfig.store
-            ? agent.langchainAgentConfig.store
-            : undefined;
+    const inlineStore = getAgentExecutionObject(agent, "store");
     if (!inlineStore) {
         return undefined;
     }
@@ -237,15 +218,7 @@ function resolveStoreConfig(agent, refs) {
     return { config: inlineStore };
 }
 function resolveCheckpointerConfig(agent, refs) {
-    const inlineAgentCheckpointer = typeof agent.deepAgentConfig?.checkpointer === "object" && agent.deepAgentConfig.checkpointer
-        ? agent.deepAgentConfig.checkpointer
-        : typeof agent.deepAgentConfig?.checkpointer === "boolean"
-            ? agent.deepAgentConfig.checkpointer
-            : typeof agent.langchainAgentConfig?.checkpointer === "object" && agent.langchainAgentConfig.checkpointer
-                ? agent.langchainAgentConfig.checkpointer
-                : typeof agent.langchainAgentConfig?.checkpointer === "boolean"
-                    ? agent.langchainAgentConfig.checkpointer
-                    : undefined;
+    const inlineAgentCheckpointer = getAgentExecutionConfigValue(agent, "checkpointer");
     if (inlineAgentCheckpointer === undefined) {
         return undefined;
     }
@@ -260,11 +233,7 @@ function resolveCheckpointerConfig(agent, refs) {
     return { config: inlineAgentCheckpointer };
 }
 function resolveRuntimeMemoryConfig(agent, refs) {
-    const inlineRuntimeMemory = typeof agent.deepAgentConfig?.runtimeMemory === "object" && agent.deepAgentConfig.runtimeMemory
-        ? agent.deepAgentConfig.runtimeMemory
-        : typeof agent.langchainAgentConfig?.runtimeMemory === "object" && agent.langchainAgentConfig.runtimeMemory
-            ? agent.langchainAgentConfig.runtimeMemory
-            : undefined;
+    const inlineRuntimeMemory = getAgentExecutionObject(agent, "runtimeMemory");
     if (inlineRuntimeMemory) {
         if (isRefConfig(inlineRuntimeMemory)) {
             return {
@@ -276,34 +245,6 @@ function resolveRuntimeMemoryConfig(agent, refs) {
     const runtimeMemoryDefaults = getRuntimeMemoryDefaults(refs);
     return runtimeMemoryDefaults ? { config: runtimeMemoryDefaults } : undefined;
 }
-function resolveLangGraphWorkflowConfig(agent, refs) {
-    const workflowConfig = typeof agent.langchainAgentConfig?.workflow === "object" && agent.langchainAgentConfig.workflow
-        ? agent.langchainAgentConfig.workflow
-        : typeof agent.langchainAgentConfig?.langgraph === "object" && agent.langchainAgentConfig.langgraph
-            ? agent.langchainAgentConfig.langgraph
-            : typeof agent.langchainAgentConfig?.passthrough === "object" &&
-                agent.langchainAgentConfig.passthrough &&
-                typeof agent.langchainAgentConfig.passthrough.workflow === "object" &&
-                agent.langchainAgentConfig.passthrough.workflow
-                ? agent.langchainAgentConfig.passthrough.workflow
-                : typeof agent.langchainAgentConfig?.passthrough === "object" &&
-                    agent.langchainAgentConfig.passthrough &&
-                    typeof agent.langchainAgentConfig.passthrough.langgraph === "object" &&
-                    agent.langchainAgentConfig.passthrough.langgraph
-                    ? agent.langchainAgentConfig.passthrough.langgraph
-                    : undefined;
-    if (!workflowConfig) {
-        return undefined;
-    }
-    if (isRefConfig(workflowConfig)) {
-        return {
-            config: materializeWorkspaceObjectConfig(refs, workflowConfig.ref, [], `Agent ${agent.id} workflow`),
-        };
-    }
-    return {
-        config: workflowConfig,
-    };
-}
 function resolveRuntimeModelRefs(agent, refs) {
     const merged = {
         ...(getRuntimeModelDefaults(refs) ?? {}),
@@ -365,28 +306,25 @@ export function compileBinding(workspaceRoot, agent, agents, referencedSubagentI
         },
     };
     if (agent.executionMode !== "deepagent") {
+        const langchainVersion = getAgentExecutionConfigValue(agent, "version", { executionMode: "langchain-v1" });
         const langchainAgentParams = {
             model: execution.model,
             tools: execution.tools,
             systemPrompt: execution.systemPrompt,
-            stateSchema: agent.langchainAgentConfig?.stateSchema,
+            stateSchema: getAgentExecutionConfigValue(agent, "stateSchema", { executionMode: "langchain-v1" }),
             responseFormat: execution.responseFormat,
             contextSchema: execution.contextSchema,
-            filesystem: typeof agent.langchainAgentConfig?.filesystem === "object" && agent.langchainAgentConfig.filesystem
-                ? { ...agent.langchainAgentConfig.filesystem }
-                : undefined,
+            filesystem: getAgentExecutionObject(agent, "filesystem", { executionMode: "langchain-v1" }),
             middleware: execution.middleware,
             passthrough: execution.passthrough,
             subagents: compileSubagents(agent, agents, workspaceRoot, models, tools, compiledAgentSkills, compiledAgentModel, compiledAgentMemory),
             memory: compiledAgentMemory,
             skills: compiledAgentSkills,
-            generalPurposeAgent: typeof agent.langchainAgentConfig?.generalPurposeAgent === "boolean" ? agent.langchainAgentConfig.generalPurposeAgent : undefined,
-            taskDescription: typeof agent.langchainAgentConfig?.taskDescription === "string" && agent.langchainAgentConfig.taskDescription.trim()
-                ? agent.langchainAgentConfig.taskDescription
-                : undefined,
-            includeAgentName: agent.langchainAgentConfig?.includeAgentName === "inline" ? "inline" : undefined,
-            version: agent.langchainAgentConfig?.version === "v1" || agent.langchainAgentConfig?.version === "v2"
-                ? agent.langchainAgentConfig.version
+            generalPurposeAgent: getAgentExecutionConfigValue(agent, "generalPurposeAgent", { executionMode: "langchain-v1" }),
+            taskDescription: getAgentExecutionString(agent, "taskDescription", { executionMode: "langchain-v1" }),
+            includeAgentName: getAgentExecutionConfigValue(agent, "includeAgentName", { executionMode: "langchain-v1" }) === "inline" ? "inline" : undefined,
+            version: langchainVersion === "v1" || langchainVersion === "v2"
+                ? langchainVersion
                 : undefined,
             name: resolveAgentRuntimeName(agent),
             description: agent.description,
@@ -418,10 +356,8 @@ export function compileBinding(workspaceRoot, agent, agents, referencedSubagentI
         name: resolveAgentRuntimeName(agent),
         memory: compiledAgentMemory,
         skills: compiledAgentSkills,
-        generalPurposeAgent: typeof agent.deepAgentConfig?.generalPurposeAgent === "boolean" ? agent.deepAgentConfig.generalPurposeAgent : undefined,
-        taskDescription: typeof agent.deepAgentConfig?.taskDescription === "string" && agent.deepAgentConfig.taskDescription.trim()
-            ? agent.deepAgentConfig.taskDescription
-            : undefined,
+        generalPurposeAgent: getAgentExecutionConfigValue(agent, "generalPurposeAgent", { executionMode: "deepagent" }),
+        taskDescription: getAgentExecutionString(agent, "taskDescription", { executionMode: "deepagent" }),
     };
     return {
         ...base,

package/dist/workspace/support/agent-capabilities.js

@@ -1,3 +1,4 @@
+import { getAgentExecutionString } from "./agent-execution-config.js";
 function normalizeCapabilities(capabilities) {
     return {
         delegation: capabilities?.delegation === true,
@@ -29,12 +30,7 @@ export function isMemoryCapableBinding(binding) {
     return inferBindingCapabilities(binding).memory === true;
 }
 export function getAgentSystemPrompt(agent) {
-    const deepagentPrompt = typeof agent.deepAgentConfig?.systemPrompt === "string" ? agent.deepAgentConfig.systemPrompt.trim() : "";
-    if (deepagentPrompt) {
-        return deepagentPrompt;
-    }
-    const langchainPrompt = typeof agent.langchainAgentConfig?.systemPrompt === "string" ? agent.langchainAgentConfig.systemPrompt.trim() : "";
-    return langchainPrompt || undefined;
+    return getAgentExecutionString(agent, "systemPrompt");
 }
 export function hasAgentSystemPrompt(agent) {
     return typeof getAgentSystemPrompt(agent) === "string";

package/dist/workspace/support/agent-execution-config.d.ts

@@ -0,0 +1,18 @@
+import type { ExecutionMode } from "../../contracts/core.js";
+import type { ParsedAgentObject } from "../../contracts/types.js";
+type AgentExecutionConfig = Record<string, unknown>;
+export declare function getAgentExecutionConfigs(agent: ParsedAgentObject, executionMode?: ExecutionMode): AgentExecutionConfig[];
+export declare function getAgentExecutionConfigValue<T = unknown>(agent: ParsedAgentObject, key: string, options?: {
+    aliases?: string[];
+    executionMode?: ExecutionMode;
+}): T | undefined;
+export declare function getAgentExecutionObject(agent: ParsedAgentObject, key: string, options?: {
+    aliases?: string[];
+    executionMode?: ExecutionMode;
+}): AgentExecutionConfig | undefined;
+export declare function getAgentExecutionString(agent: ParsedAgentObject, key: string, options?: {
+    aliases?: string[];
+    executionMode?: ExecutionMode;
+    trim?: boolean;
+}): string | undefined;
+export {};

package/dist/workspace/support/agent-execution-config.js

@@ -0,0 +1,44 @@
+import { asRecord } from "../../utils/object.js";
+const agentExecutionViewsCache = new WeakMap();
+function deriveAgentExecutionViews(agent) {
+    const cached = agentExecutionViewsCache.get(agent);
+    if (cached) {
+        return cached;
+    }
+    const langchainConfig = asRecord(agent.langchainAgentConfig);
+    const deepAgentConfig = asRecord(agent.deepAgentConfig);
+    const views = {
+        "langchain-v1": [langchainConfig, deepAgentConfig].filter((config) => config !== undefined),
+        deepagent: [deepAgentConfig, langchainConfig].filter((config) => config !== undefined),
+    };
+    agentExecutionViewsCache.set(agent, views);
+    return views;
+}
+function getConfigsForMode(agent, executionMode = agent.executionMode) {
+    return deriveAgentExecutionViews(agent)[executionMode];
+}
+export function getAgentExecutionConfigs(agent, executionMode = agent.executionMode) {
+    return getConfigsForMode(agent, executionMode);
+}
+export function getAgentExecutionConfigValue(agent, key, options = {}) {
+    const keys = [key, ...(options.aliases ?? [])];
+    for (const config of getConfigsForMode(agent, options.executionMode)) {
+        for (const candidate of keys) {
+            const value = config[candidate];
+            if (value !== undefined) {
+                return value;
+            }
+        }
+    }
+    return undefined;
+}
+export function getAgentExecutionObject(agent, key, options = {}) {
+    return asRecord(getAgentExecutionConfigValue(agent, key, options));
+}
+export function getAgentExecutionString(agent, key, options = {}) {
+    const value = getAgentExecutionConfigValue(agent, key, options);
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    return options.trim === false ? value : value.trim() || undefined;
+}

package/dist/workspace/validate.js

@@ -1,10 +1,8 @@
 import { hasAgentSystemPrompt, isDelegationCapableAgent, isMemoryCapableAgent, } from "./support/agent-capabilities.js";
+import { getAgentExecutionConfigValue, getAgentExecutionConfigs } from "./support/agent-execution-config.js";
 const allowedExecutionModes = new Set(["deepagent", "langchain-v1"]);
 function validateCheckpointerConfig(agent) {
-    const checkpointer = (typeof agent.deepAgentConfig?.checkpointer === "object" && agent.deepAgentConfig.checkpointer) ||
-        (typeof agent.deepAgentConfig?.checkpointer === "boolean" ? agent.deepAgentConfig.checkpointer : undefined) ||
-        (typeof agent.langchainAgentConfig?.checkpointer === "boolean" ? agent.langchainAgentConfig.checkpointer : undefined) ||
-        (typeof agent.langchainAgentConfig?.checkpointer === "object" && agent.langchainAgentConfig.checkpointer);
+    const checkpointer = getAgentExecutionConfigValue(agent, "checkpointer");
     if (typeof checkpointer === "boolean") {
         return;
     }
@@ -19,10 +17,10 @@ function validateCheckpointerConfig(agent) {
     }
 }
 function validateMiddlewareConfig(agent) {
-    const middlewareConfigs = [
-        ...(agent.langchainAgentConfig?.middleware ?? []),
-        ...(agent.deepAgentConfig?.middleware ?? []),
-    ];
+    const middlewareConfigs = getAgentExecutionConfigs(agent).flatMap((config) => {
+        const middleware = config.middleware;
+        return Array.isArray(middleware) ? middleware : [];
+    });
     for (const config of middlewareConfigs) {
         if (typeof config !== "object" || config === null || Array.isArray(config)) {
             throw new Error(`Agent ${agent.id} middleware entries must be objects`);
@@ -59,9 +57,6 @@ export function validateAgent(agent) {
     if (!agent.description.trim()) {
         throw new Error(`Agent ${agent.id} description must not be empty`);
     }
-    if (!isDelegationCapableAgent(agent) && (agent.subagentRefs.length > 0 || agent.subagentPathRefs.length > 0)) {
-        throw new Error(`Agent ${agent.id} cannot define subagents unless it uses a delegation-capable backend`);
-    }
     if (!isMemoryCapableAgent(agent) && agent.memorySources.length > 0) {
         throw new Error(`Agent ${agent.id} cannot define memory unless it uses a memory-capable backend`);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botbotgo/agent-harness",
-  "version": "0.0.109",
+  "version": "0.0.111",
   "description": "Workspace runtime for multi-agent applications",
   "type": "module",
   "packageManager": "npm@10.9.2",

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

@@ -1,55 +0,0 @@
-import type { CompiledAgentBinding, InternalApprovalRecord, MessageContent, ResumeOptions, RunResult, ThreadSummary, TranscriptMessage, WorkspaceBundle } from "../../../contracts/types.js";
-import type { RuntimePersistence } from "../../../persistence/types.js";
-import type { AgentRuntimeAdapter } from "../../agent-runtime-adapter.js";
-type Binding = WorkspaceBundle["bindings"] extends Map<any, infer T> ? T : never;
-export declare function createResumeRunRuntime(input: {
-    persistence: RuntimePersistence;
-    workspace: WorkspaceBundle;
-    runtimeAdapter: AgentRuntimeAdapter;
-    getSession: (threadId: string) => Promise<ThreadSummary | null>;
-    getRunCancellation: (runId: string) => Promise<{
-        requested: boolean;
-        reason?: string;
-    }>;
-    finalizeCancelledRun: (threadId: string, runId: string, previousState: RunResult["state"] | null, reason?: string) => Promise<RunResult>;
-    acquireRunSlot: (threadId?: string, runId?: string, activeState?: RunResult["state"], priority?: number) => Promise<() => Promise<void>>;
-    resolvePersistedRunPriority: (threadId: string, runId: string) => Promise<number>;
-    emit: (threadId: string, runId: string, sequence: number, eventType: string, payload: Record<string, unknown>) => Promise<unknown>;
-    loadRunInput: (threadId: string, runId: string) => Promise<MessageContent>;
-    recordLlmSuccess: (startedAt: number) => void;
-    recordLlmFailure: (startedAt: number) => void;
-    finalizeContinuedRun: (binding: Binding, threadId: string, runId: string, input: MessageContent, actual: RunResult, options: {
-        previousState: RunResult["state"] | null;
-        stateSequence: number;
-        approvalSequence?: number;
-    }) => Promise<RunResult>;
-}): {
-    getApprovalById: (approvalId: string) => Promise<InternalApprovalRecord | null>;
-    getSession: (threadId: string) => Promise<ThreadSummary | null>;
-    resolveApprovalRecord: (resumeOptions: ResumeOptions, thread: ThreadSummary) => Promise<InternalApprovalRecord>;
-    getBinding: (agentId: string) => CompiledAgentBinding | undefined;
-    buildResumePayload: (binding: CompiledAgentBinding, approval: InternalApprovalRecord, resumeOptions: ResumeOptions) => unknown;
-    getRunCancellation: (runId: string) => Promise<{
-        requested: boolean;
-        reason?: string;
-    }>;
-    finalizeCancelledRun: (threadId: string, runId: string, previousState: RunResult["state"] | null, reason?: string) => Promise<RunResult>;
-    setRunState: (threadId: string, runId: string, state: RunResult["state"], checkpointRef: string | null) => Promise<void>;
-    acquireRunSlot: (threadId?: string, runId?: string, activeState?: RunResult["state"], priority?: number) => Promise<() => Promise<void>>;
-    resolvePersistedRunPriority: (threadId: string, runId: string) => Promise<number>;
-    saveRecoveryIntent: (threadId: string, runId: string, payload: Record<string, unknown>) => Promise<void>;
-    emit: (threadId: string, runId: string, sequence: number, eventType: string, payload: Record<string, unknown>) => Promise<unknown>;
-    resolveApproval: (threadId: string, runId: string, approvalId: string, resolution: "approved" | "edited" | "rejected" | "expired") => Promise<InternalApprovalRecord>;
-    listThreadMessages: (threadId: string) => Promise<TranscriptMessage[]>;
-    loadRunInput: (threadId: string, runId: string) => Promise<MessageContent>;
-    invoke: (binding: CompiledAgentBinding, message: MessageContent, threadId: string, runId: string, resumePayload: unknown, priorHistory: TranscriptMessage[]) => Promise<RunResult>;
-    recordLlmSuccess: (startedAt: number) => void;
-    recordLlmFailure: (startedAt: number) => void;
-    clearRecoveryIntent: (threadId: string, runId: string) => Promise<void>;
-    finalizeContinuedRun: (binding: Binding, threadId: string, runId: string, message: MessageContent, actual: RunResult, options: {
-        previousState: RunResult["state"] | null;
-        stateSequence: number;
-        approvalSequence?: number;
-    }) => Promise<RunResult>;
-};
-export {};

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

@@ -1,26 +0,0 @@
-import { getWorkspaceBinding } from "../bindings.js";
-import { buildResumePayload as buildHarnessResumePayload, resolveApprovalRecord as resolveHarnessApprovalRecord } from "./resume.js";
-export function createResumeRunRuntime(input) {
-    return {
-        getApprovalById: (approvalId) => input.persistence.getApproval(approvalId),
-        getSession: (threadId) => input.getSession(threadId),
-        resolveApprovalRecord: (resumeOptions, thread) => resolveHarnessApprovalRecord(input.persistence, resumeOptions, thread),
-        getBinding: (agentId) => getWorkspaceBinding(input.workspace, agentId),
-        buildResumePayload: (binding, approval, resumeOptions) => buildHarnessResumePayload(binding, approval, resumeOptions),
-        getRunCancellation: (runId) => input.getRunCancellation(runId),
-        finalizeCancelledRun: (threadId, runId, previousState, reason) => input.finalizeCancelledRun(threadId, runId, previousState, reason),
-        setRunState: (threadId, runId, state, checkpointRef) => input.persistence.setRunState(threadId, runId, state, checkpointRef),
-        acquireRunSlot: (threadId, runId, activeState, priority) => input.acquireRunSlot(threadId, runId, activeState, priority),
-        resolvePersistedRunPriority: (threadId, runId) => input.resolvePersistedRunPriority(threadId, runId),
-        saveRecoveryIntent: (threadId, runId, payload) => input.persistence.saveRecoveryIntent(threadId, runId, payload),
-        emit: (threadId, runId, sequence, eventType, payload) => input.emit(threadId, runId, sequence, eventType, payload),
-        resolveApproval: (threadId, runId, approvalId, resolution) => input.persistence.resolveApproval(threadId, runId, approvalId, resolution),
-        listThreadMessages: (threadId) => input.persistence.listThreadMessages(threadId),
-        loadRunInput: (threadId, runId) => input.loadRunInput(threadId, runId),
-        invoke: (binding, message, threadId, runId, resumePayload, priorHistory) => input.runtimeAdapter.invoke(binding, message, threadId, runId, resumePayload, priorHistory),
-        recordLlmSuccess: (startedAt) => input.recordLlmSuccess(startedAt),
-        recordLlmFailure: (startedAt) => input.recordLlmFailure(startedAt),
-        clearRecoveryIntent: (threadId, runId) => input.persistence.clearRecoveryIntent(threadId, runId),
-        finalizeContinuedRun: (binding, threadId, runId, message, actual, options) => input.finalizeContinuedRun(binding, threadId, runId, message, actual, options),
-    };
-}

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

@@ -1,48 +0,0 @@
-import type { CompiledAgentBinding, HarnessEvent, MessageContent, RunResult, TranscriptMessage } from "../../../contracts/types.js";
-import type { RuntimePersistence } from "../../../persistence/types.js";
-import type { AgentRuntimeAdapter } from "../../agent-runtime-adapter.js";
-export declare function createStreamRunRuntime(input: {
-    persistence: RuntimePersistence;
-    runtimeAdapter: AgentRuntimeAdapter;
-    emit: (threadId: string, runId: string, sequence: number, eventType: string, payload: Record<string, unknown>) => Promise<HarnessEvent>;
-    setRunStateAndEmit: (threadId: string, runId: string, sequence: number, state: RunResult["state"], options: {
-        previousState: string | null;
-        checkpointRef?: string | null;
-        error?: string;
-    }) => Promise<HarnessEvent>;
-    requestApprovalAndEmit: (threadId: string, runId: string, input: MessageContent, interruptContent: string | undefined, checkpointRef: string, sequence: number) => Promise<{
-        approval: {
-            approvalId: string;
-            pendingActionId: string;
-        };
-        event: HarnessEvent;
-    }>;
-    loadPriorHistory: (threadId: string, runId: string) => Promise<TranscriptMessage[]>;
-    invokeWithHistory: (binding: CompiledAgentBinding, input: MessageContent, threadId: string, runId: string) => Promise<RunResult>;
-    emitSyntheticFallback: (threadId: string, runId: string, selectedAgentId: string, error: unknown) => Promise<void>;
-}): {
-    loadPriorHistory: (threadId: string, runId: string) => Promise<TranscriptMessage[]>;
-    stream: (binding: CompiledAgentBinding, message: MessageContent, threadId: string, priorHistory: TranscriptMessage[], options: {
-        context?: Record<string, unknown>;
-        state?: Record<string, unknown>;
-        files?: Record<string, unknown>;
-        runId: string;
-    }) => AsyncGenerator<string | import("../../parsing/stream-event-parsing.js").RuntimeStreamChunk, any, any>;
-    invokeWithHistory: (binding: CompiledAgentBinding, message: MessageContent, threadId: string, runId: string) => Promise<RunResult>;
-    emit: (threadId: string, runId: string, sequence: number, eventType: string, payload: Record<string, unknown>) => Promise<HarnessEvent>;
-    setRunStateAndEmit: (threadId: string, runId: string, sequence: number, state: RunResult["state"], options: {
-        previousState: string | null;
-        checkpointRef?: string | null;
-        error?: string;
-    }) => Promise<HarnessEvent>;
-    requestApprovalAndEmit: (threadId: string, runId: string, message: MessageContent, interruptContent: string | undefined, checkpointRef: string, sequence: number) => Promise<{
-        approval: {
-            approvalId: string;
-            pendingActionId: string;
-        };
-        event: HarnessEvent;
-    }>;
-    appendAssistantMessage: (threadId: string, runId: string, content?: string) => Promise<void>;
-    clearRunRequest: (threadId: string, runId: string) => Promise<void>;
-    emitSyntheticFallback: (threadId: string, runId: string, selectedAgentId: string, error: unknown) => Promise<void>;
-};

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

@@ -1,14 +0,0 @@
-import { appendAssistantMessage as appendLifecycleAssistantMessage } from "./run-lifecycle.js";
-export function createStreamRunRuntime(input) {
-    return {
-        loadPriorHistory: (threadId, runId) => input.loadPriorHistory(threadId, runId),
-        stream: (binding, message, threadId, priorHistory, options) => input.runtimeAdapter.stream(binding, message, threadId, priorHistory, options),
-        invokeWithHistory: (binding, message, threadId, runId) => input.invokeWithHistory(binding, message, threadId, runId),
-        emit: (threadId, runId, sequence, eventType, payload) => input.emit(threadId, runId, sequence, eventType, payload),
-        setRunStateAndEmit: (threadId, runId, sequence, state, options) => input.setRunStateAndEmit(threadId, runId, sequence, state, options),
-        requestApprovalAndEmit: (threadId, runId, message, interruptContent, checkpointRef, sequence) => input.requestApprovalAndEmit(threadId, runId, message, interruptContent, checkpointRef, sequence),
-        appendAssistantMessage: (threadId, runId, content) => appendLifecycleAssistantMessage(input.persistence, threadId, runId, content),
-        clearRunRequest: (threadId, runId) => input.persistence.clearRunRequest(threadId, runId),
-        emitSyntheticFallback: (threadId, runId, selectedAgentId, error) => input.emitSyntheticFallback(threadId, runId, selectedAgentId, error),
-    };
-}