@botbotgo/agent-harness 0.0.308 → 0.0.310

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

@@ -1,19 +1,16 @@
 import path from "node:path";
-import { MemorySaver } from "@langchain/langgraph";
-import { createDeepAgent, createFilesystemMiddleware, createPatchToolCallsMiddleware, FilesystemBackend, } from "deepagents";
-import { createAgent, todoListMiddleware } from "langchain";
+import { createDeepAgent, FilesystemBackend, } from "deepagents";
+import { createAgent } from "langchain";
 import { wrapResolvedModel, } from "./parsing/output-parsing.js";
-import { UPSTREAM_REQUEST_CONFIG_KEY, UPSTREAM_SESSION_CONFIG_KEY } from "./adapter/upstream-configurable-keys.js";
+import { AGENT_INTERRUPT_SENTINEL_PREFIX, buildDeepAgentCreateParams, buildLangChainCreateParams, buildMinimalDeepAgentCreateParams, materializeModelExposedBuiltinMiddlewareTools, resolveLangChainInvocationConfig, resolveRunnableCheckpointer, resolveRunnableInterruptOn, shouldAttachMinimalDeepAgentBackend, shouldAttachMinimalDeepAgentCheckpointer, shouldAttachMinimalDeepAgentStore, shouldUseMinimalDeepAgentAssembly, } from "./agent-runtime-assembly.js";
 import { resolveDeepAgentSkillSourcePaths, } from "./adapter/compat/deepagent-compat.js";
 import { buildToolNameMapping, } from "./adapter/tool/tool-name-mapping.js";
 import { executeRequestInvocation } from "./adapter/flow/invocation-flow.js";
-import { asStructuredExecutableTool } from "./adapter/tool/resolved-tool.js";
 import { streamRuntimeExecution } from "./adapter/flow/stream-runtime.js";
 import { applyToolRecoveryInstruction as applyToolRecoveryInstructionHelper, applyStrictToolJsonInstruction as applyStrictToolJsonInstructionHelper, callRuntimeWithToolParseRecovery as callRuntimeWithToolParseRecoveryHelper, createModelFallbackRunnable as createModelFallbackRunnableHelper, invokeWithProviderRetry as invokeWithProviderRetryHelper, iterateWithTimeout as iterateWithTimeoutHelper, materializeModelStream as materializeModelStreamHelper, RuntimeOperationTimeoutError, withRuntimeTimeout, } from "./adapter/runtime-shell.js";
 import { invokeBuiltinTaskTool as invokeBuiltinTaskToolHelper, materializeAutomaticSummarizationMiddleware as materializeAutomaticSummarizationMiddlewareHelper, resolveBuiltinMiddlewareBackend as resolveBuiltinMiddlewareBackendHelper, resolveBuiltinMiddlewareTools as resolveBuiltinMiddlewareToolsHelper, resolveLangChainRuntimeExtensionMiddleware as resolveLangChainRuntimeExtensionMiddlewareHelper, resolveMiddleware as resolveMiddlewareHelper, resolveSubagents as resolveSubagentsHelper, } from "./adapter/middleware-assembly.js";
 import { computeRemainingTimeoutMs, resolveBindingTimeout, resolveStreamIdleTimeout, } from "./adapter/resilience.js";
 import { createResolvedModel } from "./adapter/model/model-providers.js";
-import { compileInterruptOn } from "./adapter/tool/interrupt-policy.js";
 import { resolveAdapterTools } from "./adapter/tool-resolution.js";
 import { resolveRuntimeStreamExecutionContext, } from "./adapter/flow/execution-context.js";
 import { isRetryableProviderError } from "./adapter/resilience.js";
@@ -21,232 +18,7 @@ export { applyDeepAgentDelegationPromptCompatibility, materializeDeepAgentSkillS
 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 { getBindingBackendConfig, getBindingAdapterKind, getBindingDeepAgentSubagents, getBindingExecutionKind, getBindingExecutionParams, getBindingFilesystemConfig, getBindingInterruptCompatibilityRules, getBindingMemorySources, getBindingMiddlewareConfigs, getBindingPrimaryModel, getBindingSkills, getBindingStoreConfig, 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",
-    "read_todos",
-    "ls",
-    "list_files",
-    "read_file",
-    "write_file",
-    "edit_file",
-    "glob",
-    "grep",
-    "search_files",
-    "execute",
-    "run_command",
-    "fetch_url",
-    "http_request",
-    "send_message",
-    "request_approval",
-    "schedule_task",
-    "task",
-    "delegate_task",
-]);
-const BUILTIN_MIDDLEWARE_ALIAS_TOOL_NAMES = new Set([
-    "list_files",
-    "search_files",
-    "run_command",
-    "delegate_task",
-]);
-const MODEL_EXPOSED_BUILTIN_MIDDLEWARE_TOOL_NAMES = new Set([
-    "fetch_url",
-    "http_request",
-    "send_message",
-    "request_approval",
-    "schedule_task",
-]);
-export function materializeModelExposedBuiltinMiddlewareTools(input) {
-    const explicitToolNames = new Set(input.explicitToolNames ?? []);
-    const tools = [];
-    for (const [toolName, tool] of input.builtinTools.entries()) {
-        if (explicitToolNames.has(toolName)
-            || BUILTIN_MIDDLEWARE_ALIAS_TOOL_NAMES.has(toolName)
-            || !MODEL_EXPOSED_BUILTIN_MIDDLEWARE_TOOL_NAMES.has(toolName)) {
-            continue;
-        }
-        tools.push(asStructuredExecutableTool(tool, toolName, tool.name));
-    }
-    return tools;
-}
-export function resolveRunnableCheckpointer(options, binding) {
-    return options.checkpointerResolver ? options.checkpointerResolver(binding) : new MemorySaver();
-}
-export function resolveRunnableInterruptOn(binding) {
-    return compileInterruptOn(getBindingPrimaryTools(binding), getBindingInterruptCompatibilityRules(binding));
-}
-function buildUpstreamCreateBaseParams(binding, supportedFields) {
-    const executionParams = getBindingExecutionParams(binding);
-    if (!executionParams) {
-        throw new Error(`Agent ${binding.agent.id} has no compiled execution params`);
-    }
-    const source = executionParams;
-    const upstreamParams = Object.fromEntries(supportedFields
-        .filter((key) => key in source && source[key] !== undefined)
-        .map((key) => [key, source[key]]));
-    return upstreamParams;
-}
-export function buildLangChainCreateParams(input) {
-    const executionKind = getBindingExecutionKind(input.binding);
-    const executionParams = getBindingExecutionParams(input.binding);
-    if (executionKind !== "langchain-v1" || !executionParams) {
-        throw new Error(`Agent ${input.binding.agent.id} has no langchain params`);
-    }
-    const upstreamParams = buildUpstreamCreateBaseParams(input.binding, [
-        "model",
-        "tools",
-        "systemPrompt",
-        "stateSchema",
-        "contextSchema",
-        "checkpointer",
-        "store",
-        "responseFormat",
-        "middleware",
-        "name",
-        "description",
-        "includeAgentName",
-        "version",
-    ]);
-    const legacyPassthrough = typeof input.binding.langchainAgentParams?.passthrough === "object" &&
-        input.binding.langchainAgentParams?.passthrough
-        ? input.binding.langchainAgentParams.passthrough
-        : undefined;
-    const langchainPassthrough = typeof input.binding.harnessRuntime.langchain?.passthrough === "object" && input.binding.harnessRuntime.langchain?.passthrough
-        ? input.binding.harnessRuntime.langchain.passthrough
-        : undefined;
-    return {
-        ...upstreamParams,
-        ...(legacyPassthrough ?? {}),
-        ...(langchainPassthrough ?? {}),
-        ...(input.passthroughOverride ?? {}),
-        systemPrompt: input.systemPromptOverride ?? executionParams.systemPrompt,
-        model: input.resolvedModel,
-        tools: input.resolvedTools,
-        middleware: input.resolvedMiddleware,
-        checkpointer: input.resolvedCheckpointer,
-        store: input.resolvedStore,
-    };
-}
-export function resolveLangChainInvocationConfig(binding, options) {
-    const langchainPassthrough = typeof binding.harnessRuntime.langchain?.passthrough === "object" && binding.harnessRuntime.langchain?.passthrough
-        ? binding.harnessRuntime.langchain.passthrough
-        : undefined;
-    const config = {
-        configurable: {
-            [UPSTREAM_SESSION_CONFIG_KEY]: options.sessionId,
-            [UPSTREAM_REQUEST_CONFIG_KEY]: options.requestId,
-        },
-    };
-    if (typeof langchainPassthrough?.recursionLimit === "number") {
-        config.recursionLimit = langchainPassthrough.recursionLimit;
-    }
-    if (options.context) {
-        config.context = options.context;
-    }
-    if (options.toolRuntimeContext) {
-        config.toolRuntimeContext = options.toolRuntimeContext;
-    }
-    return config;
-}
-export function buildDeepAgentCreateParams(input) {
-    const executionKind = getBindingExecutionKind(input.binding);
-    if (executionKind !== "deepagent" || !getBindingExecutionParams(input.binding)) {
-        throw new Error(`Agent ${input.binding.agent.id} has no runnable params`);
-    }
-    const upstreamParams = buildUpstreamCreateBaseParams(input.binding, [
-        "model",
-        "tools",
-        "systemPrompt",
-        "middleware",
-        "subagents",
-        "responseFormat",
-        "contextSchema",
-        "checkpointer",
-        "store",
-        "backend",
-        "interruptOn",
-        "name",
-        "memory",
-        "skills",
-    ]);
-    return {
-        ...upstreamParams,
-        skills: input.resolvedSkills,
-        model: input.resolvedModel,
-        tools: input.resolvedTools,
-        middleware: input.resolvedMiddleware,
-        subagents: input.resolvedSubagents,
-        interruptOn: input.resolvedInterruptOn,
-        ...(input.resolvedCheckpointer !== undefined ? { checkpointer: input.resolvedCheckpointer } : {}),
-        ...(input.resolvedStore !== undefined ? { store: input.resolvedStore } : {}),
-        ...(input.resolvedBackend !== undefined ? { backend: input.resolvedBackend } : {}),
-    };
-}
-export function shouldUseMinimalDeepAgentAssembly(input) {
-    const executionKind = getBindingExecutionKind(input.binding);
-    if (executionKind !== "deepagent") {
-        return false;
-    }
-    if (input.resolvedBackend === undefined) {
-        return false;
-    }
-    if (input.resolvedSkills.length > 0) {
-        return false;
-    }
-    if (input.resolvedSubagents.length > 0 || getBindingDeepAgentSubagents(input.binding).length > 0) {
-        return false;
-    }
-    if (getBindingMemorySources(input.binding).length > 0) {
-        return false;
-    }
-    if (input.resolvedMiddleware.length > 0 || (getBindingMiddlewareConfigs(input.binding)?.length ?? 0) > 0) {
-        return false;
-    }
-    return input.resolvedInterruptOn === undefined || Object.keys(input.resolvedInterruptOn).length === 0;
-}
-export function buildMinimalDeepAgentCreateParams(input) {
-    const executionKind = getBindingExecutionKind(input.binding);
-    if (executionKind !== "deepagent" || !getBindingExecutionParams(input.binding)) {
-        throw new Error(`Agent ${input.binding.agent.id} has no runnable params`);
-    }
-    const upstreamParams = buildUpstreamCreateBaseParams(input.binding, [
-        "systemPrompt",
-        "contextSchema",
-        "responseFormat",
-        "name",
-        "description",
-        "includeAgentName",
-        "version",
-    ]);
-    return {
-        ...upstreamParams,
-        model: input.resolvedModel,
-        tools: input.resolvedTools,
-        middleware: [
-            todoListMiddleware(),
-            createFilesystemMiddleware({ backend: input.resolvedBackend }),
-            createPatchToolCallsMiddleware(),
-        ],
-        ...(input.resolvedCheckpointer !== undefined ? { checkpointer: input.resolvedCheckpointer } : {}),
-        ...(input.resolvedStore !== undefined ? { store: input.resolvedStore } : {}),
-    };
-}
-function shouldAttachMinimalDeepAgentCheckpointer(binding, resolvedInterruptOn) {
-    if (binding.harnessRuntime.checkpointer !== undefined) {
-        return true;
-    }
-    return resolvedInterruptOn !== undefined && Object.keys(resolvedInterruptOn).length > 0;
-}
-function shouldAttachMinimalDeepAgentStore(binding) {
-    return getBindingStoreConfig(binding) !== undefined || getBindingMemorySources(binding).length > 0;
-}
-function shouldAttachMinimalDeepAgentBackend(binding) {
-    return (getBindingBackendConfig(binding) !== undefined ||
-        getBindingMemorySources(binding).length > 0 ||
-        getBindingSkills(binding).length > 0 ||
-        (getBindingMiddlewareConfigs(binding)?.length ?? 0) > 0);
-}
+import { getBindingAdapterKind, getBindingDeepAgentSubagents, getBindingExecutionKind, getBindingFilesystemConfig, getBindingPrimaryModel, getBindingSkills, getBindingToolCount, getBindingPrimaryTools, getBindingSystemPrompt, isDeepAgentBinding, isLangChainBinding, } from "./support/compiled-binding.js";
 export class AgentRuntimeAdapter {
     options;
     modelCache = new Map();
@@ -718,4 +490,4 @@ export class AgentRuntimeAdapter {
         });
     }
 }
-export { AgentRuntimeAdapter as RuntimeAdapter, AGENT_INTERRUPT_SENTINEL_PREFIX, AGENT_INTERRUPT_SENTINEL_PREFIX as INTERRUPT_SENTINEL_PREFIX, RuntimeOperationTimeoutError, };
+export { AgentRuntimeAdapter as RuntimeAdapter, AGENT_INTERRUPT_SENTINEL_PREFIX, AGENT_INTERRUPT_SENTINEL_PREFIX as INTERRUPT_SENTINEL_PREFIX, buildDeepAgentCreateParams, buildLangChainCreateParams, buildMinimalDeepAgentCreateParams, materializeModelExposedBuiltinMiddlewareTools, resolveLangChainInvocationConfig, resolveRunnableCheckpointer, resolveRunnableInterruptOn, shouldUseMinimalDeepAgentAssembly, RuntimeOperationTimeoutError, };

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

@@ -0,0 +1,67 @@
+import type { CompiledAgentBinding, CompiledAsyncSubAgent, RuntimeAdapterOptions } from "../contracts/types.js";
+import type { ExecutableTool } from "./adapter/flow/invoke-runtime.js";
+import type { UpstreamSubagentConfig } from "./adapter/middleware-assembly.js";
+export declare const AGENT_INTERRUPT_SENTINEL_PREFIX = "__agent_harness_interrupt__:";
+export declare function materializeModelExposedBuiltinMiddlewareTools(input: {
+    builtinTools: Map<string, ExecutableTool>;
+    explicitToolNames?: string[];
+}): unknown[];
+export declare function resolveRunnableCheckpointer(options: RuntimeAdapterOptions, binding: CompiledAgentBinding): unknown;
+export declare function resolveRunnableInterruptOn(binding: CompiledAgentBinding): Record<string, {
+    allowedDecisions: import("./adapter/tool/interrupt-policy.js").InterruptDecision[];
+}> | undefined;
+export declare function buildLangChainCreateParams(input: {
+    binding: CompiledAgentBinding;
+    resolvedModel: unknown;
+    resolvedTools: unknown[];
+    resolvedMiddleware: unknown[];
+    resolvedCheckpointer: unknown;
+    resolvedStore: unknown;
+    passthroughOverride?: Record<string, unknown>;
+    systemPromptOverride?: string;
+}): Record<string, unknown>;
+export declare function resolveLangChainInvocationConfig(binding: CompiledAgentBinding, options: {
+    sessionId: string;
+    requestId: string;
+    legacySessionId?: string;
+    legacyRequestId?: string;
+    context?: Record<string, unknown>;
+    toolRuntimeContext?: Record<string, unknown>;
+}): Record<string, unknown>;
+export declare function buildDeepAgentCreateParams(input: {
+    binding: CompiledAgentBinding;
+    resolvedModel: unknown;
+    resolvedTools: unknown[];
+    resolvedMiddleware: unknown[];
+    resolvedSubagents: Array<UpstreamSubagentConfig | CompiledAsyncSubAgent>;
+    resolvedCheckpointer?: unknown;
+    resolvedStore?: unknown;
+    resolvedBackend?: unknown;
+    resolvedInterruptOn?: Record<string, {
+        allowedDecisions: Array<"approve" | "edit" | "reject">;
+    }>;
+    resolvedSkills: string[];
+}): Record<string, unknown>;
+export declare function shouldUseMinimalDeepAgentAssembly(input: {
+    binding: CompiledAgentBinding;
+    resolvedMiddleware: unknown[];
+    resolvedSubagents: Array<UpstreamSubagentConfig | CompiledAsyncSubAgent>;
+    resolvedInterruptOn?: Record<string, {
+        allowedDecisions: Array<"approve" | "edit" | "reject">;
+    }>;
+    resolvedSkills: string[];
+    resolvedBackend?: unknown;
+}): boolean;
+export declare function buildMinimalDeepAgentCreateParams(input: {
+    binding: CompiledAgentBinding;
+    resolvedModel: unknown;
+    resolvedTools: unknown[];
+    resolvedCheckpointer?: unknown;
+    resolvedStore?: unknown;
+    resolvedBackend: unknown;
+}): Record<string, unknown>;
+export declare function shouldAttachMinimalDeepAgentCheckpointer(binding: CompiledAgentBinding, resolvedInterruptOn?: Record<string, {
+    allowedDecisions: Array<"approve" | "edit" | "reject">;
+}>): boolean;
+export declare function shouldAttachMinimalDeepAgentStore(binding: CompiledAgentBinding): boolean;
+export declare function shouldAttachMinimalDeepAgentBackend(binding: CompiledAgentBinding): boolean;

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

@@ -0,0 +1,211 @@
+import { MemorySaver } from "@langchain/langgraph";
+import { createFilesystemMiddleware, createPatchToolCallsMiddleware } from "deepagents";
+import { todoListMiddleware } from "langchain";
+import { UPSTREAM_REQUEST_CONFIG_KEY, UPSTREAM_SESSION_CONFIG_KEY } from "./adapter/upstream-configurable-keys.js";
+import { asStructuredExecutableTool } from "./adapter/tool/resolved-tool.js";
+import { compileInterruptOn } from "./adapter/tool/interrupt-policy.js";
+import { getBindingBackendConfig, getBindingDeepAgentSubagents, getBindingExecutionKind, getBindingExecutionParams, getBindingInterruptCompatibilityRules, getBindingMemorySources, getBindingMiddlewareConfigs, getBindingPrimaryTools, getBindingSkills, getBindingStoreConfig, } from "./support/compiled-binding.js";
+export const AGENT_INTERRUPT_SENTINEL_PREFIX = "__agent_harness_interrupt__:";
+const BUILTIN_MIDDLEWARE_ALIAS_TOOL_NAMES = new Set([
+    "list_files",
+    "search_files",
+    "run_command",
+    "delegate_task",
+]);
+const MODEL_EXPOSED_BUILTIN_MIDDLEWARE_TOOL_NAMES = new Set([
+    "fetch_url",
+    "http_request",
+    "send_message",
+    "request_approval",
+    "schedule_task",
+]);
+export function materializeModelExposedBuiltinMiddlewareTools(input) {
+    const explicitToolNames = new Set(input.explicitToolNames ?? []);
+    const tools = [];
+    for (const [toolName, tool] of input.builtinTools.entries()) {
+        if (explicitToolNames.has(toolName)
+            || BUILTIN_MIDDLEWARE_ALIAS_TOOL_NAMES.has(toolName)
+            || !MODEL_EXPOSED_BUILTIN_MIDDLEWARE_TOOL_NAMES.has(toolName)) {
+            continue;
+        }
+        tools.push(asStructuredExecutableTool(tool, toolName, tool.name));
+    }
+    return tools;
+}
+export function resolveRunnableCheckpointer(options, binding) {
+    return options.checkpointerResolver ? options.checkpointerResolver(binding) : new MemorySaver();
+}
+export function resolveRunnableInterruptOn(binding) {
+    return compileInterruptOn(getBindingPrimaryTools(binding), getBindingInterruptCompatibilityRules(binding));
+}
+function buildUpstreamCreateBaseParams(binding, supportedFields) {
+    const executionParams = getBindingExecutionParams(binding);
+    if (!executionParams) {
+        throw new Error(`Agent ${binding.agent.id} has no compiled execution params`);
+    }
+    const source = executionParams;
+    const upstreamParams = Object.fromEntries(supportedFields
+        .filter((key) => key in source && source[key] !== undefined)
+        .map((key) => [key, source[key]]));
+    return upstreamParams;
+}
+export function buildLangChainCreateParams(input) {
+    const executionKind = getBindingExecutionKind(input.binding);
+    const executionParams = getBindingExecutionParams(input.binding);
+    if (executionKind !== "langchain-v1" || !executionParams) {
+        throw new Error(`Agent ${input.binding.agent.id} has no langchain params`);
+    }
+    const upstreamParams = buildUpstreamCreateBaseParams(input.binding, [
+        "model",
+        "tools",
+        "systemPrompt",
+        "stateSchema",
+        "contextSchema",
+        "checkpointer",
+        "store",
+        "responseFormat",
+        "middleware",
+        "name",
+        "description",
+        "includeAgentName",
+        "version",
+    ]);
+    const legacyPassthrough = typeof input.binding.langchainAgentParams?.passthrough === "object" &&
+        input.binding.langchainAgentParams?.passthrough
+        ? input.binding.langchainAgentParams.passthrough
+        : undefined;
+    const langchainPassthrough = typeof input.binding.harnessRuntime.langchain?.passthrough === "object" && input.binding.harnessRuntime.langchain?.passthrough
+        ? input.binding.harnessRuntime.langchain.passthrough
+        : undefined;
+    return {
+        ...upstreamParams,
+        ...(legacyPassthrough ?? {}),
+        ...(langchainPassthrough ?? {}),
+        ...(input.passthroughOverride ?? {}),
+        systemPrompt: input.systemPromptOverride ?? executionParams.systemPrompt,
+        model: input.resolvedModel,
+        tools: input.resolvedTools,
+        middleware: input.resolvedMiddleware,
+        checkpointer: input.resolvedCheckpointer,
+        store: input.resolvedStore,
+    };
+}
+export function resolveLangChainInvocationConfig(binding, options) {
+    const langchainPassthrough = typeof binding.harnessRuntime.langchain?.passthrough === "object" && binding.harnessRuntime.langchain?.passthrough
+        ? binding.harnessRuntime.langchain.passthrough
+        : undefined;
+    const config = {
+        configurable: {
+            [UPSTREAM_SESSION_CONFIG_KEY]: options.sessionId,
+            [UPSTREAM_REQUEST_CONFIG_KEY]: options.requestId,
+        },
+    };
+    if (typeof langchainPassthrough?.recursionLimit === "number") {
+        config.recursionLimit = langchainPassthrough.recursionLimit;
+    }
+    if (options.context) {
+        config.context = options.context;
+    }
+    if (options.toolRuntimeContext) {
+        config.toolRuntimeContext = options.toolRuntimeContext;
+    }
+    return config;
+}
+export function buildDeepAgentCreateParams(input) {
+    const executionKind = getBindingExecutionKind(input.binding);
+    if (executionKind !== "deepagent" || !getBindingExecutionParams(input.binding)) {
+        throw new Error(`Agent ${input.binding.agent.id} has no runnable params`);
+    }
+    const upstreamParams = buildUpstreamCreateBaseParams(input.binding, [
+        "model",
+        "tools",
+        "systemPrompt",
+        "middleware",
+        "subagents",
+        "responseFormat",
+        "contextSchema",
+        "checkpointer",
+        "store",
+        "backend",
+        "interruptOn",
+        "name",
+        "memory",
+        "skills",
+    ]);
+    return {
+        ...upstreamParams,
+        skills: input.resolvedSkills,
+        model: input.resolvedModel,
+        tools: input.resolvedTools,
+        middleware: input.resolvedMiddleware,
+        subagents: input.resolvedSubagents,
+        interruptOn: input.resolvedInterruptOn,
+        ...(input.resolvedCheckpointer !== undefined ? { checkpointer: input.resolvedCheckpointer } : {}),
+        ...(input.resolvedStore !== undefined ? { store: input.resolvedStore } : {}),
+        ...(input.resolvedBackend !== undefined ? { backend: input.resolvedBackend } : {}),
+    };
+}
+export function shouldUseMinimalDeepAgentAssembly(input) {
+    const executionKind = getBindingExecutionKind(input.binding);
+    if (executionKind !== "deepagent") {
+        return false;
+    }
+    if (input.resolvedBackend === undefined) {
+        return false;
+    }
+    if (input.resolvedSkills.length > 0) {
+        return false;
+    }
+    if (input.resolvedSubagents.length > 0 || getBindingDeepAgentSubagents(input.binding).length > 0) {
+        return false;
+    }
+    if (getBindingMemorySources(input.binding).length > 0) {
+        return false;
+    }
+    if (input.resolvedMiddleware.length > 0 || (getBindingMiddlewareConfigs(input.binding)?.length ?? 0) > 0) {
+        return false;
+    }
+    return input.resolvedInterruptOn === undefined || Object.keys(input.resolvedInterruptOn).length === 0;
+}
+export function buildMinimalDeepAgentCreateParams(input) {
+    const executionKind = getBindingExecutionKind(input.binding);
+    if (executionKind !== "deepagent" || !getBindingExecutionParams(input.binding)) {
+        throw new Error(`Agent ${input.binding.agent.id} has no runnable params`);
+    }
+    const upstreamParams = buildUpstreamCreateBaseParams(input.binding, [
+        "systemPrompt",
+        "contextSchema",
+        "responseFormat",
+        "name",
+        "description",
+        "includeAgentName",
+        "version",
+    ]);
+    return {
+        ...upstreamParams,
+        model: input.resolvedModel,
+        tools: input.resolvedTools,
+        middleware: [
+            todoListMiddleware(),
+            createFilesystemMiddleware({ backend: input.resolvedBackend }),
+            createPatchToolCallsMiddleware(),
+        ],
+        ...(input.resolvedCheckpointer !== undefined ? { checkpointer: input.resolvedCheckpointer } : {}),
+        ...(input.resolvedStore !== undefined ? { store: input.resolvedStore } : {}),
+    };
+}
+export function shouldAttachMinimalDeepAgentCheckpointer(binding, resolvedInterruptOn) {
+    if (binding.harnessRuntime.checkpointer !== undefined) {
+        return true;
+    }
+    return resolvedInterruptOn !== undefined && Object.keys(resolvedInterruptOn).length > 0;
+}
+export function shouldAttachMinimalDeepAgentStore(binding) {
+    return getBindingStoreConfig(binding) !== undefined || getBindingMemorySources(binding).length > 0;
+}
+export function shouldAttachMinimalDeepAgentBackend(binding) {
+    return (getBindingBackendConfig(binding) !== undefined ||
+        getBindingMemorySources(binding).length > 0 ||
+        getBindingSkills(binding).length > 0 ||
+        (getBindingMiddlewareConfigs(binding)?.length ?? 0) > 0);
+}

package/dist/runtime/harness/background-runtime.d.ts

@@ -9,5 +9,5 @@ export declare function createBackgroundEventRuntime(input: {
     persistence: RuntimePersistence;
     publishEvent: (event: HarnessEvent) => void;
     trackBackgroundTask: (task: Promise<void>) => void;
-    backgroundEventTypes: ReadonlySet<import("../../contracts/runtime.js").HarnessEventType>;
+    backgroundEventTypes: ReadonlySet<import("../../contracts/runtime-observability.js").HarnessEventType>;
 };

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

@@ -1,5 +1,5 @@
 import { EventEmitter } from "node:events";
-import { getEventSubscribers } from "../../../extensions.js";
+import { getEventSubscribers } from "../../../tooling/extensions.js";
 function dispatchListener(listener, event) {
     void Promise.resolve(listener(event));
 }

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

@@ -9,7 +9,7 @@ export declare function createRuntimeEventOperations(runtime: EventRuntime): {
         error?: string;
     }) => Promise<HarnessEvent>;
     requestApprovalAndEmit: (sessionId: string, requestId: string, input: MessageContent, interruptContent: string | undefined, checkpointRef: string, sequence: number) => Promise<{
-        approval: import("../../../contracts/runtime.js").InternalApprovalRecord;
+        approval: import("../../../contracts/runtime-requests.js").InternalApprovalRecord;
         event: HarnessEvent;
     }>;
     emitSyntheticFallback: (sessionId: string, requestId: string, selectedAgentId: string, error: unknown, sequence?: number) => Promise<void>;

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

@@ -1,5 +1,5 @@
 import { createFallbackRequestResultFromLatestEvent, mergeRequestResultOutput } from "../run/helpers.js";
-import { applyRequestStreamItemToSnapshot, createInitialRequestEventSnapshot, toRequestDataEvent, } from "../../../request-events.js";
+import { applyRequestStreamItemToSnapshot, createInitialRequestEventSnapshot, toRequestDataEvent, } from "../../../projections/request-events.js";
 export async function emitOutputDeltaAndCreateItem(emit, sessionId, requestId, agentId, content) {
     await emit(sessionId, requestId, 3, "output.delta", {
         content,

package/dist/runtime/harness/public-shapes.d.ts

@@ -0,0 +1,43 @@
+import type { ApprovalRecord, HarnessStreamItem, InvocationEnvelope, MemoryRecord, MessageContent, RequestRecord, RequestResult, RequestSummary, SessionListSummary, SessionRecord, TranscriptMessage } from "../../contracts/types.js";
+import type { PersistedSessionListSummary } from "../../persistence/types.js";
+import type { InternalHarnessStreamItem } from "./events/streaming.js";
+export declare function toPublicRequestResultShape(result: {
+    sessionId?: string;
+    requestId?: string;
+    legacySessionId?: string;
+    legacyRequestId?: string;
+    state: RequestResult["state"];
+    output: string;
+    finalMessageText?: string;
+    outputContent?: unknown;
+    contentBlocks?: unknown[];
+    structuredResponse?: unknown;
+    interruptContent?: string;
+    agentId?: string;
+    approvalId?: string;
+    pendingActionId?: string;
+    delegationId?: string;
+    artifacts?: RequestResult["artifacts"];
+    metadata?: Record<string, unknown>;
+}): RequestResult;
+export declare function toPublicHarnessStreamItem(item: InternalHarnessStreamItem): HarnessStreamItem;
+export declare function mergeMemoryItems(...groups: MemoryRecord[][]): MemoryRecord[];
+export declare function toSessionListSummary(session: PersistedSessionListSummary): SessionListSummary;
+export declare function summarizeApprovalEvidence(approvals: ApprovalRecord[]): {
+    total: number;
+    pending: number;
+    approved: number;
+    edited: number;
+    rejected: number;
+    expired: number;
+    toolNames: string[];
+    approvalReasons: string[];
+};
+export declare function toRequestSummary(summary: RequestRecord): RequestSummary;
+export declare function cloneRequestRecord(record: RequestRecord): RequestRecord;
+export declare function cloneSessionRecord(record: SessionRecord): SessionRecord;
+export declare function deriveRequestInputFromTranscript(transcript: TranscriptMessage[], requestId: string | undefined): {
+    input: MessageContent;
+    invocation?: InvocationEnvelope;
+    priority?: number;
+} | null;