@botbotgo/agent-harness 0.0.99 → 0.0.101

package/README.md

@@ -79,7 +79,7 @@ Boundary documents live in:
 - `docs/model-layering.md`
 - `docs/coding-agent-guide.md`
 
-ACP is the intended future client protocol direction when external tools need a standard runtime boundary. The harness should become ACP-capable while keeping runtime lifecycle, persistence, recovery, and governance harness-owned.
+`deepagents-acp` is the required external protocol direction when external tools need a standard runtime boundary. The harness should conform to `deepagents-acp` semantics at that boundary while keeping runtime lifecycle, persistence, recovery, and governance harness-owned.
 
 Recommended orchestration shape for long-running flows:
 
@@ -262,7 +262,7 @@ const result = await run(runtime, {
 });
 ```
 
-`agentId: "auto"` evaluates ordered routing rules in `config/runtime/workspace.yaml`, then `routing.defaultAgentId`, and only falls back to model routing when `routing.modelRouting: true`.
+`agentId: "auto"` evaluates ordered routing rules in `config/runtime/workspace.yaml`, then `routing.defaultAgentId`, and otherwise falls back to the default runtime entry host.
 
 ### Stream Output And Events
 
@@ -416,8 +416,6 @@ Important fields:
 - `concurrency.maxConcurrentRuns`
 - `routing.defaultAgentId`
 - `routing.rules`
-- `routing.systemPrompt`
-- `routing.modelRouting`
 - `maintenance.checkpoints`
 - `maintenance.records`
 - `recovery.enabled`
@@ -444,7 +442,6 @@ spec:
     maxConcurrentRuns: 3
   routing:
     defaultAgentId: orchestra
-    modelRouting: false
   maintenance:
     checkpoints:
       enabled: true
@@ -639,7 +636,7 @@ For backend-specific options, prefer the upstream concept directly inside `spec.
 - `agent-harness` is not a third agent framework
 - public runtime contract stays generic and small
 - application-level orchestration and lifecycle management stays in the harness
-- ACP should be the preferred future external client protocol instead of a parallel harness-only protocol
+- the external protocol boundary should strictly conform to `deepagents-acp` instead of a parallel harness-only protocol
 - upstream LangChain v1 and DeepAgents concepts should be expressed as directly as possible in YAML
 - when a feature can be expressed in YAML, prefer YAML over expanding the public API
 - recovery, approvals, threads, runs, and events are runtime concepts, not backend escape hatches

package/README.zh.md

@@ -79,7 +79,7 @@
 - `docs/model-layering.md`
 - `docs/coding-agent-guide.md`
 
-当外部工具需要标准运行时边界时，ACP 是预期的未来客户端协议方向。`agent-harness` 应该具备 ACP 能力，同时继续把运行时生命周期、持久化、恢复与治理保留在 harness 内部。
+当外部工具需要标准运行时边界时，`deepagents-acp` 是必须遵循的外部协议方向。`agent-harness` 应在该边界上严格契合 `deepagents-acp` 语义，同时继续把运行时生命周期、持久化、恢复与治理保留在 harness 内部。
 
 长链路编排的推荐形态：
 
@@ -633,7 +633,7 @@ spec:
 - `agent-harness` 不是第三个 agent 框架
 - 公共运行时契约保持通用且精简
 - 应用级编排与生命周期管理留在 harness 中
-- ACP 应作为优先对齐的未来外部客户端协议，而不是再做一套并行的 harness 私有协议
+- 外部协议边界应严格契合 `deepagents-acp`，而不是再做一套并行的 harness 私有协议
 - 应尽量在 YAML 中直接表达 LangChain v1 与 DeepAgents 的概念
 - 能用 YAML 表达的能力，优先 YAML 而非扩张公共 API
 - 恢复、审批、线程、运行与事件是运行时概念，不是后端逃生舱

package/dist/benchmark/upstream-runtime-ab-benchmark.d.ts

@@ -1,4 +1,4 @@
-export declare const DEFAULT_UPSTREAM_BENCHMARK_PATHS: readonly ["harness", "raw-langchain-v1", "raw-langgraph", "raw-deepagent"];
+export declare const DEFAULT_UPSTREAM_BENCHMARK_PATHS: readonly ["harness", "raw-langchain-v1", "raw-deepagent"];
 export declare const DEFAULT_UPSTREAM_BENCHMARK_WORKLOAD: "tool";
 export type UpstreamBenchmarkPath = (typeof DEFAULT_UPSTREAM_BENCHMARK_PATHS)[number];
 export type UpstreamBenchmarkWorkload = "tool" | "no-tool";

package/dist/benchmark/upstream-runtime-ab-benchmark.js

@@ -1,7 +1,6 @@
 export const DEFAULT_UPSTREAM_BENCHMARK_PATHS = Object.freeze([
     "harness",
     "raw-langchain-v1",
-    "raw-langgraph",
     "raw-deepagent",
 ]);
 export const DEFAULT_UPSTREAM_BENCHMARK_WORKLOAD = "tool";
@@ -48,7 +47,7 @@ export function resolveUpstreamBenchmarkPaths(rawValue) {
     const parsed = rawValue
         .split(",")
         .map((value) => value.trim().toLowerCase())
-        .filter((value) => value === "harness" || value === "raw-langchain-v1" || value === "raw-langgraph" || value === "raw-deepagent");
+        .filter((value) => value === "harness" || value === "raw-langchain-v1" || value === "raw-deepagent");
     return parsed.length > 0 ? parsed : [...DEFAULT_UPSTREAM_BENCHMARK_PATHS];
 }
 export function resolveUpstreamBenchmarkWorkload(rawValue) {

package/dist/contracts/core.d.ts

@@ -1,6 +1,6 @@
-export type ExecutionMode = "deepagent" | "langchain-v1" | "langgraph";
+export type ExecutionMode = "deepagent" | "langchain-v1";
 export declare const AUTO_AGENT_ID = "auto";
-export type RuntimeModelSlot = "routing" | "planning" | "execution" | "review" | "final";
+export type RuntimeModelSlot = "planning" | "execution" | "review" | "final";
 export type RuntimeModelRefMap = Partial<Record<RuntimeModelSlot, string>>;
 export type RuntimeCapabilities = {
     delegation?: boolean;

package/dist/contracts/runtime.d.ts

@@ -9,7 +9,7 @@ export type ThreadSummary = {
     status: RunState;
 };
 export type SessionRecord = ThreadSummary;
-export type KnownHarnessEventType = "run.created" | "run.queued" | "run.dequeued" | "run.state.changed" | "run.reviewed" | "run.resumed" | "approval.requested" | "approval.resolved" | "artifact.created" | "output.delta" | "reasoning.delta" | "runtime.health.changed" | "runtime.synthetic_fallback";
+export type KnownHarnessEventType = "run.created" | "run.queued" | "run.dequeued" | "run.state.changed" | "run.resumed" | "approval.requested" | "approval.resolved" | "artifact.created" | "output.delta" | "reasoning.delta" | "runtime.health.changed" | "runtime.synthetic_fallback";
 export type HarnessEventType = KnownHarnessEventType | (string & {});
 export type HarnessEvent = {
     eventId: string;
@@ -190,8 +190,6 @@ export type RunStartOptions = {
     priority?: number;
     invocation?: InvocationEnvelope;
     listeners?: RunListeners;
-    runtimeListeners?: RuntimeListeners;
-    frontendListeners?: FrontendStreamListeners;
 };
 export type RunDecisionOptions = {
     threadId: string;
@@ -200,8 +198,6 @@ export type RunDecisionOptions = {
     decision: "approve" | "edit" | "reject";
     editedInput?: Record<string, unknown>;
     listeners?: RunListeners;
-    runtimeListeners?: RuntimeListeners;
-    frontendListeners?: FrontendStreamListeners;
 };
 export type RunOptions = RunStartOptions | RunDecisionOptions;
 export type HarnessStreamItem = {

package/dist/package-version.d.ts

@@ -1 +1 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.98";
+export declare const AGENT_HARNESS_VERSION = "0.0.100";

package/dist/package-version.js

@@ -1 +1 @@
-export const AGENT_HARNESS_VERSION = "0.0.98";
+export const AGENT_HARNESS_VERSION = "0.0.100";

package/dist/resource/resource-impl.js

@@ -81,13 +81,14 @@ function listProviderTools(provider) {
         toolPath: tool.toolPath ?? tool.builtinPath ?? "",
     }));
 }
+function preferProviderValue(provider, primary, fallback) {
+    return provider ? (primary(provider) ?? fallback(provider)) : undefined;
+}
 function createProviderToolResolver(provider, workspace, options) {
-    return (provider?.createResourceToolResolver?.(workspace, options) ??
-        provider?.createBuiltinToolResolver?.(workspace, options));
+    return preferProviderValue(provider, (candidate) => candidate.createResourceToolResolver?.(workspace, options), (candidate) => candidate.createBuiltinToolResolver?.(workspace, options));
 }
 function createProviderBackendResolver(provider, workspace) {
-    return (provider?.createResourceBackendResolver?.(workspace) ??
-        provider?.createBuiltinBackendResolver?.(workspace));
+    return preferProviderValue(provider, (candidate) => candidate.createResourceBackendResolver?.(workspace), (candidate) => candidate.createBuiltinBackendResolver?.(workspace));
 }
 class CompatibleCompositeBackend {
     id;
@@ -133,69 +134,66 @@ class CompatibleCompositeBackend {
         return this.composite.downloadFiles(paths);
     }
 }
+const INLINE_BACKEND_ERROR = 'Unsupported DeepAgent backend kind "%s". Supported inline kinds: LocalShellBackend, VfsSandbox, StateBackend, StoreBackend, CompositeBackend.';
+function unsupportedInlineBackend(kind) {
+    throw new Error(INLINE_BACKEND_ERROR.replace("%s", kind));
+}
+function resolveInlineBackendRootDir(workspaceRoot, configuredRootDir) {
+    if (typeof configuredRootDir === "string" && configuredRootDir.trim().length > 0) {
+        return path.isAbsolute(configuredRootDir)
+            ? configuredRootDir
+            : path.resolve(workspaceRoot, configuredRootDir);
+    }
+    return workspaceRoot;
+}
+function createLocalShellStyleBackend(workspaceRoot, config, options) {
+    const rootDir = resolveInlineBackendRootDir(workspaceRoot, config?.rootDir);
+    mkdirSync(rootDir, { recursive: true });
+    const inheritedEnv = config?.inheritEnv === false ? {} : process.env;
+    return new LocalShellBackend({
+        rootDir,
+        virtualMode: options.virtualMode,
+        timeout: typeof config?.timeout === "number" ? config.timeout : undefined,
+        maxOutputBytes: typeof config?.maxOutputBytes === "number" ? config.maxOutputBytes : undefined,
+        env: createRuntimeEnv(readStringRecord(config?.env), inheritedEnv),
+        inheritEnv: config?.inheritEnv !== false,
+    });
+}
+function createInlineBackendInstance(workspaceRoot, kind, config, runtimeLike) {
+    switch (kind) {
+        case "LocalShellBackend":
+            return createLocalShellStyleBackend(workspaceRoot, config, {
+                virtualMode: config?.virtualMode === true,
+            });
+        case "VfsSandbox":
+            return createLocalShellStyleBackend(workspaceRoot, config, {
+                virtualMode: config?.virtualMode === false ? false : true,
+            });
+        case "StateBackend":
+            return new StateBackend(runtimeLike);
+        case "StoreBackend":
+            return new StoreBackend(runtimeLike);
+        default:
+            return unsupportedInlineBackend(kind);
+    }
+}
 function createInlineBackendResolver(workspace) {
     return (binding) => {
         const backendConfig = binding.deepAgentParams?.backend;
         if (!backendConfig || typeof backendConfig !== "object") {
             return undefined;
         }
-        const resolveBackendRootDir = (configuredRootDir) => {
-            if (typeof configuredRootDir === "string" && configuredRootDir.trim().length > 0) {
-                return path.isAbsolute(configuredRootDir)
-                    ? configuredRootDir
-                    : path.resolve(workspace.workspaceRoot, configuredRootDir);
-            }
-            return workspace.workspaceRoot;
-        };
-        const createBackend = (kind, config, runtimeLike) => {
-            const configuredEnv = typeof config?.env === "object" && config.env
-                ? Object.fromEntries(Object.entries(config.env).filter((entry) => typeof entry[1] === "string"))
-                : undefined;
-            const inheritedEnv = config?.inheritEnv === false ? {} : process.env;
-            switch (kind) {
-                case "LocalShellBackend": {
-                    const rootDir = resolveBackendRootDir(config?.rootDir);
-                    mkdirSync(rootDir, { recursive: true });
-                    return new LocalShellBackend({
-                        rootDir,
-                        virtualMode: config?.virtualMode === true,
-                        timeout: typeof config?.timeout === "number" ? config.timeout : undefined,
-                        maxOutputBytes: typeof config?.maxOutputBytes === "number" ? config.maxOutputBytes : undefined,
-                        env: createRuntimeEnv(configuredEnv, inheritedEnv),
-                        inheritEnv: config?.inheritEnv !== false,
-                    });
-                }
-                case "VfsSandbox": {
-                    const rootDir = resolveBackendRootDir(config?.rootDir);
-                    mkdirSync(rootDir, { recursive: true });
-                    return new LocalShellBackend({
-                        rootDir,
-                        virtualMode: config?.virtualMode === false ? false : true,
-                        timeout: typeof config?.timeout === "number" ? config.timeout : undefined,
-                        maxOutputBytes: typeof config?.maxOutputBytes === "number" ? config.maxOutputBytes : undefined,
-                        env: createRuntimeEnv(configuredEnv, inheritedEnv),
-                        inheritEnv: config?.inheritEnv !== false,
-                    });
-                }
-                case "StateBackend":
-                    return new StateBackend(runtimeLike);
-                case "StoreBackend":
-                    return new StoreBackend(runtimeLike);
-                default:
-                    throw new Error(`Unsupported DeepAgent backend kind "${kind}". Supported inline kinds: LocalShellBackend, VfsSandbox, StateBackend, StoreBackend, CompositeBackend.`);
-            }
-        };
         return (runtimeLike) => {
             const kind = typeof backendConfig.kind === "string" ? backendConfig.kind : "CompositeBackend";
             switch (kind) {
                 case "LocalShellBackend":
-                    return createBackend("LocalShellBackend", backendConfig, runtimeLike);
+                    return createInlineBackendInstance(workspace.workspaceRoot, "LocalShellBackend", backendConfig, runtimeLike);
                 case "VfsSandbox":
-                    return createBackend("VfsSandbox", backendConfig, runtimeLike);
+                    return createInlineBackendInstance(workspace.workspaceRoot, "VfsSandbox", backendConfig, runtimeLike);
                 case "StateBackend":
-                    return new StateBackend(runtimeLike);
+                    return createInlineBackendInstance(workspace.workspaceRoot, "StateBackend", backendConfig, runtimeLike);
                 case "StoreBackend":
-                    return new StoreBackend(runtimeLike);
+                    return createInlineBackendInstance(workspace.workspaceRoot, "StoreBackend", backendConfig, runtimeLike);
                 case "CompositeBackend": {
                     const stateConfig = typeof backendConfig.state === "object" && backendConfig.state
                         ? backendConfig.state
@@ -206,12 +204,12 @@ function createInlineBackendResolver(workspace) {
                         : { "/memories/": { kind: "StoreBackend" } };
                     const mappedRoutes = Object.fromEntries(Object.entries(routes).map(([route, routeConfig]) => {
                         const routeKind = typeof routeConfig?.kind === "string" ? routeConfig.kind : "StoreBackend";
-                        return [route, createBackend(routeKind, routeConfig, runtimeLike)];
+                        return [route, createInlineBackendInstance(workspace.workspaceRoot, routeKind, routeConfig, runtimeLike)];
                     }));
-                    return new CompatibleCompositeBackend(createBackend(defaultBackendKind, stateConfig, runtimeLike), mappedRoutes);
+                    return new CompatibleCompositeBackend(createInlineBackendInstance(workspace.workspaceRoot, defaultBackendKind, stateConfig, runtimeLike), mappedRoutes);
                 }
                 default:
-                    throw new Error(`Unsupported DeepAgent backend kind "${kind}". Supported inline kinds: LocalShellBackend, VfsSandbox, StateBackend, StoreBackend, CompositeBackend.`);
+                    return unsupportedInlineBackend(kind);
             }
         };
     };
@@ -240,6 +238,23 @@ async function findPackageRoot(startPath) {
 }
 const functionToolModuleCache = new Map();
 const mcpClientCache = new Map();
+function readStringRecord(value) {
+    if (typeof value !== "object" || !value) {
+        return undefined;
+    }
+    const entries = Object.entries(value).filter((entry) => typeof entry[1] === "string");
+    return entries.length > 0 ? Object.fromEntries(entries) : undefined;
+}
+function listWorkspaceResourceProviders(workspace) {
+    return (workspace.resourceSources ?? [])
+        .map((source) => remoteResourceCache.get(source))
+        .filter((provider) => Boolean(provider));
+}
+function createWorkspaceProviderResolvers(workspace, factory) {
+    return listWorkspaceResourceProviders(workspace)
+        .map((provider) => factory(provider))
+        .filter((resolver) => Boolean(resolver));
+}
 async function loadFunctionToolModule(tool) {
     const cacheKey = `${tool.sourcePath}:${tool.implementationName ?? tool.id}`;
     const cached = functionToolModuleCache.get(cacheKey);
@@ -294,20 +309,15 @@ function readMcpServerConfig(workspace, tool) {
     if (!mcpServer) {
         return null;
     }
-    const envRecord = typeof mcpServer.env === "object" && mcpServer.env
-        ? Object.fromEntries(Object.entries(mcpServer.env).filter((entry) => typeof entry[1] === "string"))
-        : undefined;
     return {
         transport: normalizeMcpTransport(mcpServer.transport) ?? ((typeof mcpServer.url === "string" && mcpServer.url.trim()) ? "http" : "stdio"),
         command: typeof mcpServer.command === "string" ? mcpServer.command.trim() : undefined,
         args: Array.isArray(mcpServer.args) ? mcpServer.args.filter((item) => typeof item === "string") : undefined,
-        env: envRecord,
+        env: readStringRecord(mcpServer.env),
         cwd: typeof mcpServer.cwd === "string" ? mcpServer.cwd : undefined,
         url: typeof mcpServer.url === "string" ? mcpServer.url.trim() : undefined,
         token: typeof mcpServer.token === "string" ? mcpServer.token : undefined,
-        headers: typeof mcpServer.headers === "object" && mcpServer.headers
-            ? Object.fromEntries(Object.entries(mcpServer.headers).filter((entry) => typeof entry[1] === "string"))
-            : undefined,
+        headers: readStringRecord(mcpServer.headers),
     };
 }
 function createMcpCacheKey(config) {
@@ -514,11 +524,11 @@ export async function ensureResourceSources(sources = [], workspaceRoot = proces
 }
 export function defaultResourceSkillsRoot() {
     const provider = requireLocalResource("default resource skill resolution");
-    return provider.defaultResourceSkillsRoot?.() ?? provider.builtinSkillsRoot?.() ?? "";
+    return preferProviderValue(provider, (candidate) => candidate.defaultResourceSkillsRoot?.(), (candidate) => candidate.builtinSkillsRoot?.()) ?? "";
 }
 export function defaultResourceConfigRoot() {
     const provider = requireLocalResource("default resource config resolution");
-    return provider.defaultResourceConfigRoot?.() ?? provider.builtinConfigRoot?.() ?? provider.builtinDefaultsRoot?.() ?? "";
+    return (preferProviderValue(provider, (candidate) => candidate.defaultResourceConfigRoot?.(), (candidate) => candidate.builtinConfigRoot?.() ?? candidate.builtinDefaultsRoot?.()) ?? "");
 }
 export async function listResourceTools(sources = [], workspaceRoot = process.cwd()) {
     await ensureResourceSources(sources, workspaceRoot);
@@ -539,11 +549,7 @@ export async function listResourceToolsForSource(source, workspaceRoot = process
 }
 export function createResourceBackendResolver(workspace) {
     const localResolver = createProviderBackendResolver(localResource, workspace);
-    const remoteResolvers = (workspace.resourceSources ?? [])
-        .map((source) => remoteResourceCache.get(source))
-        .filter((provider) => Boolean(provider))
-        .map((provider) => createProviderBackendResolver(provider, workspace))
-        .filter((resolver) => Boolean(resolver));
+    const remoteResolvers = createWorkspaceProviderResolvers(workspace, (provider) => createProviderBackendResolver(provider, workspace));
     const inlineResolver = createInlineBackendResolver(workspace);
     return (binding) => {
         const providerResolved = localResolver?.(binding) ??
@@ -555,11 +561,7 @@ export function createResourceToolResolver(workspace, options = {}) {
     const functionResolver = createFunctionToolResolver(workspace);
     const mcpResolver = createMcpToolResolver(workspace);
     const localResolver = createProviderToolResolver(localResource, workspace, options);
-    const remoteResolvers = (workspace.resourceSources ?? [])
-        .map((source) => remoteResourceCache.get(source))
-        .filter((provider) => Boolean(provider))
-        .map((provider) => createProviderToolResolver(provider, workspace, options))
-        .filter((resolver) => Boolean(resolver));
+    const remoteResolvers = createWorkspaceProviderResolvers(workspace, (provider) => createProviderToolResolver(provider, workspace, options));
     return (toolIds, binding) => {
         const resolved = [
             ...functionResolver(toolIds, binding),

package/dist/runtime/adapter/deepagent-runnable-config.d.ts

@@ -0,0 +1,30 @@
+import type { DeepAgentParams } from "../../contracts/types.js";
+export declare function buildDeepAgentRunnableConfig(params: {
+    compatibleParams: DeepAgentParams;
+    resolvedModel: unknown;
+    resolvedTools: unknown[];
+    resolvedMiddleware: unknown[];
+    resolvedSubagents: unknown[];
+    resolvedCheckpointer: unknown;
+    resolvedStore: unknown;
+    resolvedBackend: unknown;
+    resolvedInterruptOn: unknown;
+    resolvedSkills: string[];
+}): {
+    model: never;
+    tools: never;
+    systemPrompt: string | undefined;
+    responseFormat: never;
+    contextSchema: never;
+    middleware: never;
+    subagents: never;
+    checkpointer: never;
+    store: never;
+    backend: never;
+    interruptOn: never;
+    name: string;
+    memory: string[];
+    skills: string[];
+    generalPurposeAgent: boolean | undefined;
+    taskDescription: string | undefined;
+};

package/dist/runtime/adapter/deepagent-runnable-config.js

@@ -0,0 +1,22 @@
+export function buildDeepAgentRunnableConfig(params) {
+    const { compatibleParams, resolvedModel, resolvedTools, resolvedMiddleware, resolvedSubagents, resolvedCheckpointer, resolvedStore, resolvedBackend, resolvedInterruptOn, resolvedSkills, } = params;
+    return {
+        ...(compatibleParams.passthrough ?? {}),
+        model: resolvedModel,
+        tools: resolvedTools,
+        systemPrompt: compatibleParams.systemPrompt,
+        responseFormat: compatibleParams.responseFormat,
+        contextSchema: compatibleParams.contextSchema,
+        middleware: resolvedMiddleware,
+        subagents: resolvedSubagents,
+        checkpointer: resolvedCheckpointer,
+        store: resolvedStore,
+        backend: resolvedBackend,
+        interruptOn: resolvedInterruptOn,
+        name: compatibleParams.name,
+        memory: compatibleParams.memory,
+        skills: resolvedSkills,
+        generalPurposeAgent: compatibleParams.generalPurposeAgent,
+        taskDescription: compatibleParams.taskDescription,
+    };
+}

package/dist/runtime/adapter/index.d.ts

@@ -2,8 +2,6 @@ export * from "./tool/declared-middleware.js";
 export * from "./compat/deepagent-compat.js";
 export * from "./tool/interrupt-policy.js";
 export * from "./model/invocation-request.js";
-export * from "./langgraph/presets.js";
-export * from "./langgraph/profiles.js";
 export * from "./model/message-assembly.js";
 export * from "./model/model-providers.js";
 export * from "./compat/openai-compatible.js";

package/dist/runtime/adapter/index.js

@@ -2,8 +2,6 @@ export * from "./tool/declared-middleware.js";
 export * from "./compat/deepagent-compat.js";
 export * from "./tool/interrupt-policy.js";
 export * from "./model/invocation-request.js";
-export * from "./langgraph/presets.js";
-export * from "./langgraph/profiles.js";
 export * from "./model/message-assembly.js";
 export * from "./model/model-providers.js";
 export * from "./compat/openai-compatible.js";

package/dist/runtime/adapter/invocation-result.d.ts

@@ -0,0 +1,13 @@
+import type { RunResult } from "../../contracts/types.js";
+export type ExecutedToolResult = {
+    toolName: string;
+    output: unknown;
+    isError?: boolean;
+};
+export declare function finalizeInvocationResult(params: {
+    bindingAgentId: string;
+    threadId: string;
+    runId: string;
+    result: Record<string, unknown>;
+    executedToolResults: ExecutedToolResult[];
+}): RunResult;

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

@@ -0,0 +1,40 @@
+import { extractContentBlocks, extractEmptyAssistantMessageFailure, extractOutputContent, extractToolFallbackContext, extractVisibleOutput, isLikelyToolArgsObject, sanitizeVisibleText, tryParseJson, } from "../parsing/output-parsing.js";
+import { buildStateSnapshot } from "./model/message-assembly.js";
+import { asRecord } from "./tool/resolved-tool.js";
+export function finalizeInvocationResult(params) {
+    const { bindingAgentId, threadId, runId, result, executedToolResults } = params;
+    const interruptContent = Array.isArray(result.__interrupt__) && result.__interrupt__.length > 0 ? JSON.stringify(result.__interrupt__) : undefined;
+    const extractedOutput = extractVisibleOutput(result);
+    const visibleOutput = extractedOutput && !isLikelyToolArgsObject(tryParseJson(extractedOutput)) ? extractedOutput : "";
+    const emptyAssistantMessageFailure = extractEmptyAssistantMessageFailure(result);
+    const toolFallback = extractToolFallbackContext(result);
+    if (!visibleOutput && !toolFallback && emptyAssistantMessageFailure) {
+        throw new Error(emptyAssistantMessageFailure);
+    }
+    const output = visibleOutput || toolFallback || JSON.stringify(result, null, 2);
+    const finalMessageText = sanitizeVisibleText(output);
+    const outputContent = extractOutputContent(result);
+    const contentBlocks = extractContentBlocks(result);
+    const structuredResponse = result.structuredResponse;
+    return {
+        threadId,
+        runId,
+        agentId: bindingAgentId,
+        state: Array.isArray(result.__interrupt__) && result.__interrupt__.length > 0 ? "waiting_for_approval" : "completed",
+        interruptContent,
+        output: finalMessageText,
+        finalMessageText,
+        ...(outputContent !== undefined ? { outputContent } : {}),
+        ...(contentBlocks.length > 0 ? { contentBlocks } : {}),
+        ...(structuredResponse !== undefined ? { structuredResponse } : {}),
+        metadata: {
+            ...(executedToolResults.length > 0 ? { executedToolResults } : {}),
+            ...(structuredResponse !== undefined ? { structuredResponse } : {}),
+            ...(outputContent !== undefined ? { outputContent } : {}),
+            ...(contentBlocks.length > 0 ? { contentBlocks } : {}),
+            ...(asRecord(result.files) ? { files: asRecord(result.files) } : {}),
+            ...(buildStateSnapshot(result) ? { stateSnapshot: buildStateSnapshot(result) } : {}),
+            upstreamResult: result,
+        },
+    };
+}

package/dist/runtime/adapter/langchain-runnable-config.d.ts

@@ -0,0 +1,25 @@
+import type { LangChainAgentParams } from "../../contracts/types.js";
+export declare function buildLangChainRunnableConfig(params: {
+    langchainParams: LangChainAgentParams;
+    resolvedModel: unknown;
+    resolvedTools: unknown[];
+    resolvedMiddleware: unknown[];
+    resolvedCheckpointer: unknown;
+    resolvedStore: unknown;
+    passthroughOverride?: Record<string, unknown>;
+    systemPromptOverride?: string;
+}): {
+    model: never;
+    tools: never;
+    systemPrompt: string | undefined;
+    stateSchema: never;
+    responseFormat: never;
+    contextSchema: never;
+    middleware: never;
+    checkpointer: never;
+    store: never;
+    includeAgentName: "inline" | undefined;
+    version: "v1" | "v2" | undefined;
+    name: string | undefined;
+    description: string;
+};

package/dist/runtime/adapter/langchain-runnable-config.js

@@ -0,0 +1,19 @@
+export function buildLangChainRunnableConfig(params) {
+    const { langchainParams, resolvedModel, resolvedTools, resolvedMiddleware, resolvedCheckpointer, resolvedStore, passthroughOverride, systemPromptOverride, } = params;
+    return {
+        ...(passthroughOverride ?? langchainParams.passthrough ?? {}),
+        model: resolvedModel,
+        tools: resolvedTools,
+        systemPrompt: systemPromptOverride ?? langchainParams.systemPrompt,
+        stateSchema: langchainParams.stateSchema,
+        responseFormat: langchainParams.responseFormat,
+        contextSchema: langchainParams.contextSchema,
+        middleware: resolvedMiddleware,
+        checkpointer: resolvedCheckpointer,
+        store: resolvedStore,
+        includeAgentName: langchainParams.includeAgentName,
+        version: langchainParams.version,
+        name: langchainParams.name,
+        description: langchainParams.description,
+    };
+}

package/dist/runtime/adapter/local-tool-invocation.d.ts

@@ -0,0 +1,23 @@
+import type { CompiledAgentBinding, CompiledTool } from "../../contracts/types.js";
+import { type ToolNameMapping } from "./tool/tool-name-mapping.js";
+import type { ExecutedToolResult } from "./invocation-result.js";
+type ExecutableTool = {
+    name: string;
+    schema: unknown;
+    invoke: (input: unknown) => Promise<unknown>;
+};
+type LocalToolInvocationParams = {
+    binding: CompiledAgentBinding;
+    request: unknown;
+    primaryTools: CompiledTool[];
+    toolNameMapping: ToolNameMapping;
+    executableTools: Map<string, ExecutableTool>;
+    builtinExecutableTools: Map<string, ExecutableTool>;
+    callRuntimeWithToolParseRecovery: (request: unknown) => Promise<Record<string, unknown>>;
+};
+type LocalToolInvocationResult = {
+    result: Record<string, unknown>;
+    executedToolResults: ExecutedToolResult[];
+};
+export declare function runLocalToolInvocationLoop({ binding, request, primaryTools, toolNameMapping, executableTools, builtinExecutableTools, callRuntimeWithToolParseRecovery, }: LocalToolInvocationParams): Promise<LocalToolInvocationResult>;
+export {};

package/dist/runtime/adapter/local-tool-invocation.js

@@ -0,0 +1,64 @@
+import { ToolMessage } from "@langchain/core/messages";
+import { createModelFacingToolNameLookupCandidates, resolveModelFacingToolName } from "./tool/tool-name-mapping.js";
+import { canReplayToolCallsLocally } from "./tool/tool-replay.js";
+import { extractToolCallsFromResult, normalizeToolArgsForSchema, stringifyToolOutput } from "./tool/tool-arguments.js";
+export async function runLocalToolInvocationLoop({ binding, request, primaryTools, toolNameMapping, executableTools, builtinExecutableTools, callRuntimeWithToolParseRecovery, }) {
+    const executedToolResults = [];
+    let activeRequest = request;
+    let currentMessages = Array.isArray(activeRequest.messages) ? [...activeRequest.messages] : [];
+    const maxToolIterations = 8;
+    let pendingResult;
+    let result;
+    for (let iteration = 0; iteration < maxToolIterations; iteration += 1) {
+        result = pendingResult ?? await callRuntimeWithToolParseRecovery(activeRequest);
+        pendingResult = undefined;
+        const toolCalls = extractToolCallsFromResult(result);
+        if (toolCalls.length === 0) {
+            break;
+        }
+        if (!canReplayToolCallsLocally(binding, toolCalls, primaryTools, toolNameMapping, executableTools, builtinExecutableTools)) {
+            break;
+        }
+        if (iteration + 1 === maxToolIterations) {
+            throw new Error(`Tool-calling loop exceeded the maximum of ${maxToolIterations} iterations`);
+        }
+        const resultMessages = result.messages;
+        const nextMessages = Array.isArray(resultMessages)
+            ? [...resultMessages]
+            : [...currentMessages];
+        for (let toolIndex = 0; toolIndex < toolCalls.length; toolIndex += 1) {
+            const toolCall = toolCalls[toolIndex];
+            const resolvedToolName = resolveModelFacingToolName(toolCall.name, toolNameMapping, primaryTools);
+            const executable = executableTools.get(toolCall.name) ?? executableTools.get(resolvedToolName);
+            const builtinExecutable = builtinExecutableTools.get(toolCall.name) ??
+                builtinExecutableTools.get(resolvedToolName) ??
+                createModelFacingToolNameLookupCandidates(toolCall.name)
+                    .map((candidate) => builtinExecutableTools.get(candidate))
+                    .find((candidate) => candidate !== undefined);
+            const activeExecutable = executable ?? builtinExecutable;
+            if (!activeExecutable) {
+                throw new Error(`Tool ${toolCall.name} is not configured for this agent.`);
+            }
+            const normalizedArgs = normalizeToolArgsForSchema(toolCall.args, activeExecutable.schema);
+            const toolResult = await activeExecutable.invoke(normalizedArgs);
+            executedToolResults.push({
+                toolName: activeExecutable.name,
+                output: toolResult,
+            });
+            nextMessages.push(new ToolMessage({
+                name: activeExecutable.name,
+                tool_call_id: toolCall.id ?? `tool-${iteration + 1}-${toolIndex + 1}`,
+                content: stringifyToolOutput(toolResult),
+            }));
+        }
+        currentMessages = nextMessages;
+        activeRequest = {
+            ...activeRequest,
+            messages: currentMessages,
+        };
+    }
+    if (!result) {
+        throw new Error("Agent invocation returned no result");
+    }
+    return { result, executedToolResults };
+}