@botbotgo/agent-harness 0.0.110 → 0.0.112

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

@@ -1,28 +1,23 @@
 import path from "node:path";
-import { Command, MemorySaver } from "@langchain/langgraph";
 import { createDeepAgent, FilesystemBackend, } from "deepagents";
 import { createAgent } from "langchain";
 import { wrapResolvedModel, } from "./parsing/output-parsing.js";
-import { applyDeepAgentDelegationPromptCompatibility, materializeDeepAgentSkillSourcePaths, } from "./adapter/compat/deepagent-compat.js";
+import { assembleDeepAgentRunnable, assembleLangChainRunnable, } from "./adapter/flow/runnable-assembly.js";
 import { buildToolNameMapping, } from "./adapter/tool/tool-name-mapping.js";
-import { finalizeInvocationResult } from "./adapter/invocation-result.js";
-import { invokeRuntimeWithLocalTools } from "./adapter/invoke-runtime.js";
-import { streamRuntimeExecution } from "./adapter/stream-runtime.js";
+import { executeRuntimeInvocation } from "./adapter/flow/invocation-flow.js";
+import { streamRuntimeExecution } from "./adapter/flow/stream-runtime.js";
 import { buildDeepAgentRunnableConfig, buildLangChainRunnableConfig } from "./adapter/runnable-config.js";
 import { applyStrictToolJsonInstruction as applyStrictToolJsonInstructionHelper, callRuntimeWithToolParseRecovery as callRuntimeWithToolParseRecoveryHelper, createModelFallbackRunnable as createModelFallbackRunnableHelper, invokeWithProviderRetry as invokeWithProviderRetryHelper, iterateWithTimeout as iterateWithTimeoutHelper, materializeModelStream as materializeModelStreamHelper, RuntimeOperationTimeoutError, withRuntimeTimeout, } from "./adapter/runtime-shell.js";
 import { invokeBuiltinTaskTool as invokeBuiltinTaskToolHelper, resolveAutomaticSummarizationMiddleware as resolveAutomaticSummarizationMiddlewareHelper, resolveBuiltinMiddlewareBackend as resolveBuiltinMiddlewareBackendHelper, resolveBuiltinMiddlewareTools as resolveBuiltinMiddlewareToolsHelper, resolveLangChainAutomaticMiddleware as resolveLangChainAutomaticMiddlewareHelper, resolveMiddleware as resolveMiddlewareHelper, resolveSubagents as resolveSubagentsHelper, } from "./adapter/middleware-assembly.js";
 import { computeRemainingTimeoutMs, resolveBindingTimeout, resolveStreamIdleTimeout, } from "./adapter/resilience.js";
 import { createResolvedModel } from "./adapter/model/model-providers.js";
-import { buildInvocationRequest, } from "./adapter/model/invocation-request.js";
-import { compileInterruptOn } from "./adapter/tool/interrupt-policy.js";
-import { countConfiguredTools, } from "./adapter/runtime-adapter-support.js";
 import { resolveAdapterTools } from "./adapter/tool-resolution.js";
-import { buildBindingToolCatalog, buildBindingToolExecutionContext, resolveLangChainStreamContext, } from "./adapter/execution-context.js";
-export { applyDeepAgentDelegationPromptCompatibility, materializeDeepAgentSkillSourcePaths, relativizeDeepAgentSkillSourcePaths, shouldRelaxDeepAgentDelegationPrompt, } from "./adapter/compat/deepagent-compat.js";
+import { resolveRuntimeStreamExecutionContext, } from "./adapter/flow/execution-context.js";
+export { applyDeepAgentDelegationPromptCompatibility, materializeDeepAgentSkillSourcePaths, resolveDeepAgentSkillSourcePaths, relativizeDeepAgentSkillSourcePaths, shouldRelaxDeepAgentDelegationPrompt, } from "./adapter/compat/deepagent-compat.js";
 export { buildAuthOmittingFetch, normalizeOpenAICompatibleInit } from "./adapter/compat/openai-compatible.js";
 export { buildToolNameMapping, createModelFacingToolNameCandidates, createModelFacingToolNameLookupCandidates, resolveModelFacingToolName, sanitizeToolNameForModel, } from "./adapter/tool/tool-name-mapping.js";
 export { computeRemainingTimeoutMs, isRetryableProviderError, resolveBindingTimeout, resolveProviderRetryPolicy, resolveStreamIdleTimeout, resolveTimeoutMs, } from "./adapter/resilience.js";
-import { getBindingAdapterKind, getBindingDeepAgentParams, getBindingInterruptCompatibilityRules, getBindingLangChainParams, getBindingPrimaryTools, getBindingSystemPrompt, isDeepAgentBinding, isLangChainBinding, } from "./support/compiled-binding.js";
+import { getBindingAdapterKind, getBindingLangChainParams, getBindingToolCount, getBindingPrimaryTools, getBindingSystemPrompt, isDeepAgentBinding, isLangChainBinding, } from "./support/compiled-binding.js";
 const AGENT_INTERRUPT_SENTINEL_PREFIX = "__agent_harness_interrupt__:";
 const UPSTREAM_BUILTIN_MIDDLEWARE_TOOL_NAMES = Object.freeze([
     "write_todos",
@@ -35,12 +30,6 @@ const UPSTREAM_BUILTIN_MIDDLEWARE_TOOL_NAMES = Object.freeze([
     "execute",
     "task",
 ]);
-function resolveBindingCheckpointer(options, binding) {
-    return options.checkpointerResolver ? options.checkpointerResolver(binding) : new MemorySaver();
-}
-function resolveBindingInterruptOn(binding) {
-    return compileInterruptOn(getBindingPrimaryTools(binding), getBindingInterruptCompatibilityRules(binding));
-}
 export class AgentRuntimeAdapter {
     options;
     modelCache = new Map();
@@ -222,22 +211,29 @@ export class AgentRuntimeAdapter {
         });
     }
     async createLangChainRunnable(binding, options = {}) {
-        const params = getBindingLangChainParams(binding);
-        const interruptOn = resolveBindingInterruptOn(binding);
-        const model = (await this.resolveModel(params.model));
-        const tools = this.resolveTools(params.tools, binding);
+        const assembly = await assembleLangChainRunnable({
+            binding,
+            runtimeAdapterOptions: this.options,
+            resolveModel: (model) => this.resolveModel(model),
+            resolveTools: (tools, currentBinding) => this.resolveTools(tools, currentBinding),
+            resolveMiddleware: (currentBinding, interruptOn) => this.resolveMiddleware(currentBinding, interruptOn),
+            passthroughOverride: options.passthroughOverride,
+            systemPromptOverride: options.systemPromptOverride,
+        });
+        const model = assembly.resolvedModel;
+        const tools = assembly.resolvedTools;
         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.`);
+            throw new Error(`Agent ${binding.agent.id} configures ${tools.length} tool(s), but resolved model ${assembly.langchainParams.model.id} does not support tool binding.`);
         }
         return createAgent(buildLangChainRunnableConfig({
-            langchainParams: params,
+            langchainParams: assembly.langchainParams,
             resolvedModel: model,
             resolvedTools: tools,
-            resolvedMiddleware: await this.resolveMiddleware(binding, interruptOn),
-            resolvedCheckpointer: resolveBindingCheckpointer(this.options, binding),
-            resolvedStore: this.options.storeResolver?.(binding),
-            passthroughOverride: options.passthroughOverride,
-            systemPromptOverride: options.systemPromptOverride,
+            resolvedMiddleware: assembly.resolvedMiddleware,
+            resolvedCheckpointer: assembly.resolvedCheckpointer,
+            resolvedStore: assembly.resolvedStore,
+            passthroughOverride: assembly.passthroughOverride,
+            systemPromptOverride: assembly.systemPromptOverride,
         }));
     }
     async createRunnable(binding) {
@@ -250,27 +246,25 @@ export class AgentRuntimeAdapter {
         return this.createDeepAgentRunnable(binding);
     }
     async createDeepAgentRunnable(binding) {
-        const params = getBindingDeepAgentParams(binding);
-        if (!params) {
-            throw new Error(`Agent ${binding.agent.id} has no runnable params`);
-        }
-        const compatibleParams = applyDeepAgentDelegationPromptCompatibility(params.model, params);
+        const assembly = await assembleDeepAgentRunnable({
+            binding,
+            runtimeAdapterOptions: this.options,
+            resolveModel: (model) => this.resolveModel(model),
+            resolveTools: (tools, currentBinding) => this.resolveTools(tools, currentBinding),
+            resolveMiddleware: (currentBinding, interruptOn) => this.resolveMiddleware(currentBinding, interruptOn),
+            resolveSubagents: (subagents, currentBinding) => this.resolveSubagents(subagents, currentBinding),
+        });
         const deepAgentConfig = buildDeepAgentRunnableConfig({
-            compatibleParams,
-            resolvedModel: await this.resolveModel(compatibleParams.model),
-            resolvedTools: this.resolveTools(compatibleParams.tools, binding),
-            resolvedMiddleware: await this.resolveMiddleware(binding),
-            resolvedSubagents: await this.resolveSubagents(compatibleParams.subagents, binding),
-            resolvedCheckpointer: resolveBindingCheckpointer(this.options, binding),
-            resolvedStore: this.options.storeResolver?.(binding),
-            resolvedBackend: this.options.backendResolver?.(binding),
-            resolvedInterruptOn: resolveBindingInterruptOn(binding),
-            resolvedSkills: (await materializeDeepAgentSkillSourcePaths({
-                workspaceRoot: binding.harnessRuntime.workspaceRoot,
-                runRoot: binding.harnessRuntime.runRoot,
-                ownerId: binding.agent.id,
-                skillPaths: compatibleParams.skills,
-            })) ?? [],
+            compatibleParams: assembly.compatibleParams,
+            resolvedModel: assembly.resolvedModel,
+            resolvedTools: assembly.resolvedTools,
+            resolvedMiddleware: assembly.resolvedMiddleware,
+            resolvedSubagents: assembly.resolvedSubagents,
+            resolvedCheckpointer: assembly.resolvedCheckpointer,
+            resolvedStore: assembly.resolvedStore,
+            resolvedBackend: assembly.resolvedBackend,
+            resolvedInterruptOn: assembly.resolvedInterruptOn,
+            resolvedSkills: assembly.resolvedSkills,
         });
         return createDeepAgent(deepAgentConfig);
     }
@@ -290,9 +284,6 @@ export class AgentRuntimeAdapter {
         }
     }
     async invoke(binding, input, threadId, runId, resumePayload, history = [], options = {}) {
-        const request = resumePayload === undefined
-            ? buildInvocationRequest(binding, history, input, options)
-            : new Command({ resume: resumePayload });
         const callRuntime = async (activeBinding, activeRequest) => {
             return this.invokeWithProviderRetry(activeBinding, async () => {
                 const runnable = await this.create(activeBinding);
@@ -307,47 +298,27 @@ export class AgentRuntimeAdapter {
                 callRuntime,
             });
         };
-        const { primaryTools, toolNameMapping, executableTools, defersToUpstreamHitlExecution, } = buildBindingToolExecutionContext({
+        return executeRuntimeInvocation({
             binding,
+            input,
+            threadId,
+            runId,
+            resumePayload,
+            history,
+            invokeOptions: options,
             resolveTools: (tools, currentBinding) => this.resolveTools(tools, currentBinding),
             getToolNameMapping: (currentBinding) => this.getToolNameMapping(currentBinding),
-            context: options.context,
-        });
-        const builtinExecutableTools = await this.resolveBuiltinMiddlewareTools(binding, options);
-        const localOrUpstreamInvocation = await invokeRuntimeWithLocalTools({
-            binding,
-            request,
-            resumePayload,
-            primaryTools,
-            defersToUpstreamHitlExecution,
-            toolNameMapping,
-            executableTools,
-            builtinExecutableTools: builtinExecutableTools,
+            resolveBuiltinMiddlewareTools: (currentBinding, currentOptions) => this.resolveBuiltinMiddlewareTools(currentBinding, currentOptions),
             callRuntimeWithToolParseRecovery,
         });
-        const result = localOrUpstreamInvocation.result;
-        const executedToolResults = [...localOrUpstreamInvocation.executedToolResults];
-        if (!result) {
-            throw new Error("Agent invocation returned no result");
-        }
-        return finalizeInvocationResult({
-            bindingAgentId: binding.agent.id,
-            threadId,
-            runId,
-            result,
-            executedToolResults,
-        });
     }
     async *stream(binding, input, threadId, history = [], options = {}) {
         const invokeTimeoutMs = resolveBindingTimeout(binding);
         const streamIdleTimeoutMs = resolveStreamIdleTimeout(binding);
         const streamDeadlineAt = invokeTimeoutMs ? Date.now() + invokeTimeoutMs : undefined;
-        const { primaryTools, toolNameMapping } = buildBindingToolCatalog({
+        const { primaryTools, toolNameMapping, forceInvokeFallback, canUseDirectModelStream, langChainStreamModel, } = await resolveRuntimeStreamExecutionContext({
             binding,
             getToolNameMapping: (currentBinding) => this.getToolNameMapping(currentBinding),
-        });
-        const { forceInvokeFallback, canUseDirectModelStream, langChainStreamModel, } = await resolveLangChainStreamContext({
-            binding,
             resolveModel: (model) => this.resolveModel(model),
             resolveTools: (tools, currentBinding) => this.resolveTools(tools, currentBinding),
         });
@@ -373,7 +344,7 @@ export class AgentRuntimeAdapter {
             getSystemPrompt: (activeBinding) => getBindingSystemPrompt(activeBinding),
             isLangChainBinding,
             isDeepAgentBinding,
-            countConfiguredTools,
+            countConfiguredTools: getBindingToolCount,
         });
     }
 }

package/dist/runtime/harness/system/inventory.d.ts

@@ -20,14 +20,14 @@ export type InventorySkillRecord = {
 export type InventoryAgentRecord = {
     id: string;
     description: string;
-    role: "agent" | "specialist";
+    parentAgentId?: string;
     tools: InventoryToolRecord[];
     skills: InventorySkillRecord[];
 };
 export declare function findAgentBinding(workspace: WorkspaceBundle, agentId: string): CompiledAgentBinding | undefined;
 export declare function listAgentTools(workspace: WorkspaceBundle, agentId: string): InventoryToolRecord[];
 export declare function listAgentSkills(workspace: WorkspaceBundle, agentId: string, options?: RequirementAssessmentOptions): InventorySkillRecord[];
-export declare function listSpecialists(workspace: WorkspaceBundle, options?: RequirementAssessmentOptions): InventoryAgentRecord[];
+export declare function listSubagents(workspace: WorkspaceBundle, options?: RequirementAssessmentOptions): InventoryAgentRecord[];
 export declare function listAvailableAgents(workspace: WorkspaceBundle, options?: RequirementAssessmentOptions): InventoryAgentRecord[];
 export declare function describeWorkspaceInventory(workspace: WorkspaceBundle, options?: RequirementAssessmentOptions): {
     workspaceRoot: string;

package/dist/runtime/harness/system/inventory.js

@@ -77,30 +77,29 @@ export function listAgentSkills(workspace, agentId, options = {}) {
     const resolvedOptions = mergeRequirementOptions(binding, options);
     return toSkillRecords(binding.deepAgentParams?.skills ?? binding.langchainAgentParams?.skills ?? [], resolvedOptions);
 }
-function describeSubagent(subagent, options = {}) {
+function describeSubagent(subagent, parentAgentId, options = {}) {
     return {
         id: subagent.name,
         description: subagent.description,
-        role: "specialist",
+        parentAgentId,
         tools: dedupeTools(subagent.tools ?? []),
         skills: toSkillRecords(subagent.skills ?? [], options),
     };
 }
-export function listSpecialists(workspace, options = {}) {
+export function listSubagents(workspace, options = {}) {
     return listHostBindings(workspace).flatMap((binding) => {
         const resolvedOptions = mergeRequirementOptions(binding, options);
-        return (binding.deepAgentParams?.subagents ?? []).map((subagent) => describeSubagent(subagent, resolvedOptions));
+        return (binding.deepAgentParams?.subagents ?? []).map((subagent) => describeSubagent(subagent, binding.agent.id, resolvedOptions));
     });
 }
 export function listAvailableAgents(workspace, options = {}) {
     const topLevel = listHostBindings(workspace).map((binding) => ({
         id: binding.agent.id,
         description: binding.agent.description,
-        role: "agent",
         tools: listAgentTools(workspace, binding.agent.id),
         skills: listAgentSkills(workspace, binding.agent.id, options),
     }));
-    return [...topLevel, ...listSpecialists(workspace, options)];
+    return [...topLevel, ...listSubagents(workspace, options)];
 }
 export function describeWorkspaceInventory(workspace, options = {}) {
     return {

package/dist/runtime/parsing/stream-event-parsing.js

@@ -390,13 +390,13 @@ export function extractAgentStep(event) {
             return "preparing model request…";
         if (/RunnableLambda/i.test(name) || /^__start__$/.test(name))
             return null;
-        if (/specialist/i.test(name))
+        if (/(subagent|specialist)/i.test(name))
             return `starting ${humanizeEventName(name)}…`;
         if (/agent$/i.test(name))
             return `running ${humanizeEventName(name)}…`;
     }
     if (typed.event === "on_chain_end") {
-        if (/specialist/i.test(name))
+        if (/(subagent|specialist)/i.test(name))
             return `${humanizeEventName(name)} done`;
         if (/agent$/i.test(name) && !/^__start__$/.test(name))
             return `${humanizeEventName(name)} done`;

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

@@ -1,4 +1,4 @@
-import type { CompiledAgentBinding, CompiledModel, CompiledTool, DeepAgentParams, LangChainAgentParams, RuntimeModelSlot } from "../../contracts/types.js";
+import type { CompiledAgentBinding, CompiledModel, CompiledTool, DeepAgentParams, LangChainAgentParams } from "../../contracts/types.js";
 export type BindingExecutionView = {
     adapterKind: string;
     adapterConfig: Record<string, unknown>;
@@ -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;
@@ -21,9 +25,11 @@ export declare function isLangChainBinding(binding: CompiledAgentBinding): boole
 export declare function isDeepAgentBinding(binding: CompiledAgentBinding): boolean;
 export declare function getBindingPrimaryTools(binding: CompiledAgentBinding): CompiledTool[];
 export declare function getBindingPrimaryModel(binding: CompiledAgentBinding): CompiledModel | undefined;
-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;
@@ -63,15 +69,21 @@ export function getBindingPrimaryTools(binding) {
 export function getBindingPrimaryModel(binding) {
     return getBindingExecutionView(binding).primaryModel;
 }
-export function getBindingRuntimeModel(binding, slot) {
-    return binding.harnessRuntime.models?.[slot];
-}
 export function getBindingSystemPrompt(binding) {
     return getBindingExecutionView(binding).systemPrompt;
 }
 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 +94,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

@@ -4,7 +4,7 @@ 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";
+import { compileAgentMemories, getResilienceConfig, getRuntimeDefaults, getRuntimeMemoryDefaults, 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. " +
     "Do not inspect absolute paths outside the workspace, system directories, or unrelated repos by default. " +
     "Prefer workspace-local tools, relative paths, and the current repository checkout when analyzing code.";
@@ -233,7 +233,7 @@ function resolveCheckpointerConfig(agent, refs) {
     return { config: inlineAgentCheckpointer };
 }
 function resolveRuntimeMemoryConfig(agent, refs) {
-    const inlineRuntimeMemory = getAgentExecutionObject(agent, "runtimeMemory");
+    const inlineRuntimeMemory = agent.runtimeMemory ?? getAgentExecutionObject(agent, "runtimeMemory");
     if (inlineRuntimeMemory) {
         if (isRefConfig(inlineRuntimeMemory)) {
             return {
@@ -245,20 +245,6 @@ function resolveRuntimeMemoryConfig(agent, refs) {
     const runtimeMemoryDefaults = getRuntimeMemoryDefaults(refs);
     return runtimeMemoryDefaults ? { config: runtimeMemoryDefaults } : undefined;
 }
-function resolveRuntimeModelRefs(agent, refs) {
-    const merged = {
-        ...(getRuntimeModelDefaults(refs) ?? {}),
-        ...(agent.runtimeModelRefs ?? {}),
-    };
-    return Object.keys(merged).length > 0 ? merged : undefined;
-}
-function compileRuntimeModels(modelRefs, models, ownerId) {
-    if (!modelRefs) {
-        return undefined;
-    }
-    const compiled = Object.fromEntries(Object.entries(modelRefs).map(([slot, modelRef]) => [slot, requireModel(models, modelRef, ownerId)]));
-    return Object.keys(compiled).length > 0 ? compiled : undefined;
-}
 export function compileBinding(workspaceRoot, agent, agents, referencedSubagentIds, refs, models, tools) {
     const internalSubagent = referencedSubagentIds.has(agent.id);
     const runtimeDefaults = getRuntimeDefaults(refs);
@@ -274,8 +260,6 @@ export function compileBinding(workspaceRoot, agent, agents, referencedSubagentI
     const store = resolveStoreConfig(agent, refs);
     const checkpointer = resolveCheckpointerConfig(agent, refs);
     const runtimeMemory = resolveRuntimeMemoryConfig(agent, refs);
-    const runtimeModelRefs = resolveRuntimeModelRefs(agent, refs);
-    const runtimeModels = compileRuntimeModels(runtimeModelRefs, models, agent.id);
     const runRoot = typeof agent.runRoot === "string" && agent.runRoot.trim().length > 0
         ? path.resolve(workspaceRoot, agent.runRoot)
         : typeof runtimeDefaults?.runRoot === "string" && runtimeDefaults.runRoot.trim().length > 0
@@ -296,8 +280,6 @@ export function compileBinding(workspaceRoot, agent, agents, referencedSubagentI
         harnessRuntime: {
             runRoot,
             workspaceRoot,
-            ...(runtimeModelRefs ? { modelRefs: runtimeModelRefs } : {}),
-            ...(runtimeModels ? { models: runtimeModels } : {}),
             capabilities: inferAgentCapabilities(agent),
             resilience,
             ...(checkpointer ? { checkpointer: checkpointer.config } : {}),
@@ -356,8 +338,6 @@ export function compileBinding(workspaceRoot, agent, agents, referencedSubagentI
         name: resolveAgentRuntimeName(agent),
         memory: compiledAgentMemory,
         skills: compiledAgentSkills,
-        generalPurposeAgent: getAgentExecutionConfigValue(agent, "generalPurposeAgent", { executionMode: "deepagent" }),
-        taskDescription: getAgentExecutionString(agent, "taskDescription", { executionMode: "deepagent" }),
     };
     return {
         ...base,