@botbotgo/agent-harness 0.0.95 → 0.0.97

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

@@ -1,32 +1,37 @@
 import path from "node:path";
 import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import { Command, MemorySaver } from "@langchain/langgraph";
-import { tool as createLangChainTool } from "@langchain/core/tools";
 import { HumanMessage, ToolMessage } from "@langchain/core/messages";
 import { DEFAULT_SUBAGENT_PROMPT, createDeepAgent, createMemoryMiddleware, createPatchToolCallsMiddleware, createSkillsMiddleware, createSummarizationMiddleware, createSubAgentMiddleware, FilesystemBackend, StateBackend, isSandboxBackend, } from "deepagents";
-import { ChatAnthropic } from "@langchain/anthropic";
-import { tools as anthropicProviderTools } from "@langchain/anthropic";
-import { ChatGoogle } from "@langchain/google";
-import { ChatOllama } from "@langchain/ollama";
-import { ChatOpenAI } from "@langchain/openai";
-import { tools as openAIProviderTools } from "@langchain/openai";
-import { createAgent, humanInTheLoopMiddleware, initChatModel } from "langchain";
+import { createAgent, humanInTheLoopMiddleware } from "langchain";
 import { z } from "zod";
-import { extractEmptyAssistantMessageFailure, extractContentBlocks, extractOutputContent, extractReasoningText, extractToolFallbackContext, extractVisibleOutput, salvageToolArgs, isLikelyToolArgsObject, isToolCallParseFailure, STRICT_TOOL_JSON_INSTRUCTION, sanitizeVisibleText, tryParseJson, wrapResolvedModel, } from "./parsing/output-parsing.js";
-import { computeIncrementalOutput, extractAgentStep, extractInterruptPayload, extractReasoningStreamOutput, extractStateStreamOutput, extractVisibleStreamOutput, extractTerminalStreamOutput, extractToolResult, normalizeTerminalOutputKey, readStreamDelta, } from "./parsing/stream-event-parsing.js";
-import { wrapToolForExecution } from "./tool-hitl.js";
-import { resolveDeclaredMiddleware } from "./declared-middleware.js";
-import { extractMessageText, normalizeMessageContent } from "../utils/message-content.js";
-import { getBindingAdapterKind, getBindingDeepAgentParams, getBindingAdapterConfig, getBindingInterruptCompatibilityRules, getBindingLangChainParams, getBindingLangGraphPreset, getBindingLangGraphWorkflow, getBindingMiddlewareConfigs, getBindingModelInit, getBindingPrimaryModel, getBindingRuntimeModel, getBindingPrimaryTools, getBindingSystemPrompt, isDeepAgentBinding, isLangChainBinding, } from "./support/compiled-binding.js";
-import { readSkillMetadata } from "./support/skill-metadata.js";
-import { resolveLangGraphProfileWorkflow } from "./langgraph-profiles.js";
-import { resolveLangGraphPresetWorkflow } from "./langgraph-presets.js";
+import { extractEmptyAssistantMessageFailure, extractContentBlocks, extractOutputContent, extractReasoningText, extractToolFallbackContext, extractVisibleOutput, isLikelyToolArgsObject, isToolCallParseFailure, STRICT_TOOL_JSON_INSTRUCTION, sanitizeVisibleText, tryParseJson, wrapResolvedModel, } from "./parsing/output-parsing.js";
+import { computeIncrementalOutput, extractAgentStep, extractInterruptPayload, normalizeUpstreamRuntimeEvent, extractReasoningStreamOutput, extractStateStreamOutput, extractVisibleStreamOutput, extractTerminalStreamOutput, extractToolResult, normalizeTerminalOutputKey, readStreamDelta, } from "./parsing/stream-event-parsing.js";
+import { wrapToolForExecution } from "./adapter/tool/tool-hitl.js";
+import { resolveDeclaredMiddleware } from "./adapter/tool/declared-middleware.js";
+import { extractMessageText } from "../utils/message-content.js";
+import { applyDeepAgentDelegationPromptCompatibility, materializeDeepAgentSkillSourcePaths, } from "./adapter/compat/deepagent-compat.js";
+import { buildToolNameMapping, createModelFacingToolNameLookupCandidates, resolveModelFacingToolName, } from "./adapter/tool/tool-name-mapping.js";
+import { computeRemainingTimeoutMs, isRetryableProviderError, resolveBindingTimeout, resolveProviderRetryPolicy, resolveStreamIdleTimeout, } from "./adapter/resilience.js";
+import { createResolvedModel } from "./adapter/model/model-providers.js";
+import { buildInvocationRequest, buildSlashCommandSkillInstruction, } from "./adapter/model/invocation-request.js";
+import { compileInterruptOn } from "./adapter/tool/interrupt-policy.js";
+import { buildRawModelMessages, buildStateSnapshot } from "./adapter/model/message-assembly.js";
+import { asRecord, asStructuredExecutableTool, hasCallableToolHandler, normalizeResolvedToolSchema, wrapResolvedToolWithModelFacingName, } from "./adapter/tool/resolved-tool.js";
+import { instantiateProviderTool } from "./adapter/tool/provider-tool.js";
+import { extractToolCallsFromResult, normalizeToolArgsForSchema, stringifyToolOutput } from "./adapter/tool/tool-arguments.js";
+export { applyDeepAgentDelegationPromptCompatibility, materializeDeepAgentSkillSourcePaths, 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, getBindingAdapterConfig, getBindingInterruptCompatibilityRules, getBindingLangChainParams, getBindingLangGraphPreset, getBindingLangGraphWorkflow, getBindingMiddlewareConfigs, getBindingPrimaryModel, getBindingRuntimeModel, getBindingPrimaryTools, getBindingSystemPrompt, isDeepAgentBinding, isLangChainBinding, } from "./support/compiled-binding.js";
+import { resolveLangGraphProfileWorkflow } from "./adapter/langgraph/profiles.js";
+import { resolveLangGraphPresetWorkflow } from "./adapter/langgraph/presets.js";
 const SUPPORTED_LANGGRAPH_WORKFLOW_NODE_KINDS = new Set(["llm", "agent", "tool", "approval", "condition"]);
 function countConfiguredTools(binding) {
     return getBindingPrimaryTools(binding).length;
 }
 const AGENT_INTERRUPT_SENTINEL_PREFIX = "__agent_harness_interrupt__:";
-const MODEL_SAFE_TOOL_NAME_PATTERN = /^[a-zA-Z0-9_-]+$/;
 const UPSTREAM_BUILTIN_MIDDLEWARE_TOOL_NAMES = Object.freeze([
     "write_todos",
     "ls",
@@ -53,111 +58,9 @@ class RuntimeOperationTimeoutError extends Error {
 function asObject(value) {
     return typeof value === "object" && value ? value : undefined;
 }
-function resolveTimeoutMs(value) {
-    return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : undefined;
-}
-function computeRemainingTimeoutMs(deadlineAt, fallbackTimeoutMs) {
-    if (!deadlineAt) {
-        return fallbackTimeoutMs;
-    }
-    const remaining = deadlineAt - Date.now();
-    if (remaining <= 0) {
-        return 0;
-    }
-    return fallbackTimeoutMs ? Math.min(fallbackTimeoutMs, remaining) : remaining;
-}
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
-function isPlaceholderApiKey(value) {
-    return typeof value === "string" && value.trim().toLowerCase() === "dummy";
-}
-export function relativizeDeepAgentSkillSourcePaths(workspaceRoot, skillPaths) {
-    if (!workspaceRoot || !skillPaths) {
-        return skillPaths;
-    }
-    return skillPaths.map((skillPath) => {
-        if (!path.isAbsolute(skillPath)) {
-            return skillPath;
-        }
-        const relative = path.relative(workspaceRoot, skillPath);
-        if (!relative || relative.startsWith("..")) {
-            return skillPath;
-        }
-        return relative.split(path.sep).join("/");
-    });
-}
-export async function materializeDeepAgentSkillSourcePaths(options) {
-    const { workspaceRoot, skillPaths } = options;
-    if (!skillPaths) {
-        return skillPaths;
-    }
-    return relativizeDeepAgentSkillSourcePaths(workspaceRoot, skillPaths) ?? skillPaths;
-}
-function buildAuthOmittingFetch(baseFetch = fetch) {
-    return async (input, init) => {
-        const sanitizedHeaders = new Headers(input instanceof Request ? input.headers : undefined);
-        const initHeaders = new Headers(init?.headers);
-        initHeaders.forEach((value, key) => {
-            sanitizedHeaders.set(key, value);
-        });
-        sanitizedHeaders.delete("authorization");
-        if (input instanceof Request) {
-            return baseFetch(new Request(input, {
-                ...init,
-                headers: sanitizedHeaders,
-            }));
-        }
-        return baseFetch(input, {
-            ...init,
-            headers: sanitizedHeaders,
-        });
-    };
-}
-function normalizeOpenAICompatibleInit(init) {
-    const normalized = { ...init };
-    const configuration = asObject(init.configuration) ?? {};
-    const baseUrl = typeof init.baseUrl === "string" && init.baseUrl.trim() ? init.baseUrl.trim() : undefined;
-    const omitAuthHeader = init.omitAuthHeader === true || isPlaceholderApiKey(init.apiKey);
-    const nextConfiguration = { ...configuration };
-    if (baseUrl && typeof nextConfiguration.baseURL !== "string") {
-        nextConfiguration.baseURL = baseUrl;
-    }
-    if (omitAuthHeader) {
-        nextConfiguration.fetch = buildAuthOmittingFetch(typeof configuration.fetch === "function" ? configuration.fetch : fetch);
-    }
-    normalized.configuration = nextConfiguration;
-    delete normalized.baseUrl;
-    delete normalized.omitAuthHeader;
-    return normalized;
-}
-function sanitizeToolNameForModel(name) {
-    const withoutNamespace = name.includes(".") ? name.split(".").at(-1) ?? name : name;
-    const sanitized = withoutNamespace
-        .replaceAll(".", "__")
-        .replace(/[^a-zA-Z0-9_-]+/g, "_")
-        .replace(/^_+|_+$/g, "");
-    return sanitized || "tool";
-}
-function buildToolNameMapping(tools) {
-    const originalToModelFacing = new Map();
-    const modelFacingToOriginal = new Map();
-    const seen = new Set();
-    for (const tool of tools) {
-        const originalName = tool.name;
-        const baseName = MODEL_SAFE_TOOL_NAME_PATTERN.test(originalName) ? originalName : sanitizeToolNameForModel(originalName);
-        let candidate = baseName;
-        let suffix = 2;
-        while (seen.has(candidate)) {
-            candidate = `${baseName}_${suffix}`;
-            suffix += 1;
-        }
-        seen.add(candidate);
-        originalToModelFacing.set(originalName, candidate);
-        modelFacingToOriginal.set(candidate, originalName);
-    }
-    return { originalToModelFacing, modelFacingToOriginal };
-}
 function hasConfiguredSubagentSupport(binding) {
     const params = getBindingLangChainParams(binding);
     if (!params) {
@@ -165,185 +68,15 @@ function hasConfiguredSubagentSupport(binding) {
     }
     return (params.subagents?.length ?? 0) > 0 || params.generalPurposeAgent === true || Boolean(params.taskDescription?.trim());
 }
-function isOpenAICompatibleGptOssModel(model) {
-    return model?.provider === "openai-compatible" && model.model.trim().toLowerCase().startsWith("gpt-oss");
-}
-export function shouldRelaxDeepAgentDelegationPrompt(model, params) {
-    if (!isOpenAICompatibleGptOssModel(model)) {
-        return false;
-    }
-    if ((params.subagents?.length ?? 0) === 0) {
-        return false;
-    }
-    return params.generalPurposeAgent === true || Boolean(params.taskDescription?.trim());
-}
-function applyDeepAgentDelegationPromptCompatibility(model, params) {
-    if (!shouldRelaxDeepAgentDelegationPrompt(model, params)) {
-        return params;
-    }
-    return {
-        ...params,
-        generalPurposeAgent: undefined,
-        taskDescription: undefined,
-    };
-}
 function hasConfiguredMiddlewareKind(binding, kind) {
     return getBindingMiddlewareConfigs(binding)?.some((entry) => entry.kind === kind) ?? false;
 }
-function instantiateProviderTool(compiledTool) {
-    const providerTool = asRecord(compiledTool.config?.providerTool);
-    const provider = typeof providerTool?.provider === "string" ? providerTool.provider.trim().toLowerCase() : "";
-    const toolName = typeof providerTool?.tool === "string" ? providerTool.tool.trim() : "";
-    const args = asRecord(providerTool?.args) ?? {};
-    if (!provider || !toolName) {
-        throw new Error(`Provider tool ${compiledTool.id} must define providerTool.provider and providerTool.tool`);
-    }
-    const registry = provider === "openai"
-        ? openAIProviderTools
-        : provider === "anthropic"
-            ? anthropicProviderTools
-            : undefined;
-    if (!registry) {
-        throw new Error(`Provider tool ${compiledTool.id} uses unsupported provider ${provider}`);
-    }
-    const factory = registry[toolName];
-    if (typeof factory !== "function") {
-        throw new Error(`Provider tool ${compiledTool.id} references unknown ${provider} tool ${toolName}`);
-    }
-    return factory(args);
-}
-function wrapResolvedToolWithModelFacingName(resolvedTool, modelFacingName) {
-    if (typeof resolvedTool !== "object" || resolvedTool === null) {
-        return resolvedTool;
-    }
-    return new Proxy(resolvedTool, {
-        get(target, prop, receiver) {
-            if (prop === "name") {
-                return modelFacingName;
-            }
-            return Reflect.get(target, prop, receiver);
-        },
-        getOwnPropertyDescriptor(target, prop) {
-            if (prop === "name") {
-                return {
-                    configurable: true,
-                    enumerable: true,
-                    writable: false,
-                    value: modelFacingName,
-                };
-            }
-            return Reflect.getOwnPropertyDescriptor(target, prop);
-        },
-    });
-}
-function hasCallableToolHandler(value) {
-    if (typeof value !== "object" || value === null) {
-        return false;
-    }
-    const typed = value;
-    return typeof typed.invoke === "function" || typeof typed.call === "function" || typeof typed.func === "function";
-}
-function asRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value)
-        ? { ...value }
-        : undefined;
-}
-function normalizeResolvedToolSchema(resolvedTool) {
-    const schema = resolvedTool.schema;
-    if (schema && typeof schema.parse === "function" && "_def" in schema) {
-        return resolvedTool.schema;
-    }
-    if (schema && (schema.type === "object" || typeof schema.properties === "object")) {
-        return schema;
-    }
-    return z.object({}).passthrough();
-}
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isObject(value) {
     return isRecord(value);
 }
-function stringifyToolOutput(output) {
-    if (typeof output === "string") {
-        return output;
-    }
-    try {
-        return JSON.stringify(output);
-    }
-    catch {
-        return `${String(output)}`;
-    }
-}
-function normalizeToolArgsForSchema(args, schema) {
-    const schemaDef = isObject(schema) ? schema._def : undefined;
-    const shape = schemaDef
-        ? isRecord(schemaDef.shape)
-            ? schemaDef.shape
-            : typeof schemaDef.shape === "function"
-                ? schemaDef.shape()
-                : undefined
-        : undefined;
-    if (!shape || !isRecord(shape)) {
-        return args;
-    }
-    const keys = Object.keys(shape);
-    if (keys.length !== 1) {
-        return args;
-    }
-    const [expectedKey] = keys;
-    if (expectedKey in args) {
-        return args;
-    }
-    const aliasesByExpected = {
-        city: ["location", "locality", "place"],
-        location: ["city", "city_name"],
-    };
-    const aliases = aliasesByExpected[expectedKey] ?? [];
-    const aliasKey = aliases.find((candidate) => candidate in args);
-    if (!aliasKey || !(aliasKey in args)) {
-        return args;
-    }
-    return {
-        ...args,
-        [expectedKey]: args[aliasKey],
-    };
-}
-function extractToolCallsFromResult(result) {
-    const messages = isRecord(result) && Array.isArray(result.messages) ? result.messages : [];
-    const lastMessage = messages.at(-1);
-    if (!isObject(lastMessage)) {
-        return [];
-    }
-    const messageKwargs = isObject(lastMessage.kwargs) ? lastMessage.kwargs : undefined;
-    const rawToolCalls = Array.isArray(lastMessage.tool_calls)
-        ? (lastMessage.tool_calls ?? [])
-        : Array.isArray(messageKwargs?.tool_calls)
-            ? messageKwargs.tool_calls
-            : [];
-    return rawToolCalls
-        .map((toolCall) => {
-        if (!isObject(toolCall)) {
-            return null;
-        }
-        const functionPayload = isObject(toolCall.function) ? toolCall.function : undefined;
-        const name = typeof toolCall.name === "string"
-            ? toolCall.name
-            : typeof functionPayload?.name === "string"
-                ? functionPayload.name
-                : null;
-        if (!name) {
-            return null;
-        }
-        const rawArgs = salvageToolArgs(toolCall.args ?? functionPayload?.arguments) ?? {};
-        if (!isObject(rawArgs)) {
-            return null;
-        }
-        const id = typeof toolCall.id === "string" ? toolCall.id : undefined;
-        return { id, name, args: rawArgs };
-    })
-        .filter((item) => item !== null);
-}
 function truncateLines(lines, maxChars = 12_000) {
     const joined = lines.join("\n");
     if (joined.length <= maxChars) {
@@ -372,93 +105,6 @@ function summarizeBuiltinWriteTodosArgs(args) {
         items,
     };
 }
-function createModelFacingToolNameCandidates(toolName) {
-    const trimmed = toolName.trim();
-    if (!trimmed) {
-        return [];
-    }
-    const lastSegment = trimmed.split(".").at(-1) ?? "";
-    const candidates = new Set([
-        trimmed,
-        sanitizeToolNameForModel(trimmed),
-        lastSegment,
-        lastSegment.trim() ? sanitizeToolNameForModel(lastSegment) : "",
-        trimmed.replace(/[^a-zA-Z0-9_]+/g, ""),
-    ]);
-    candidates.delete("");
-    return [...candidates];
-}
-function createModelFacingToolNameLookupCandidates(toolName) {
-    const trimmed = toolName.trim();
-    if (!trimmed) {
-        return [];
-    }
-    const candidates = new Set();
-    const add = (value) => {
-        for (const candidate of createModelFacingToolNameCandidates(value)) {
-            candidates.add(candidate);
-        }
-    };
-    const addSuffixStripped = (value) => {
-        const stripped = value.includes(".") ? value.split(".").at(-1) ?? value : value;
-        if (stripped !== value) {
-            add(stripped);
-        }
-    };
-    add(trimmed);
-    if (trimmed.startsWith("functions.")) {
-        const stripped = trimmed.substring("functions.".length);
-        add(stripped);
-        addSuffixStripped(stripped);
-    }
-    else if (trimmed.startsWith("function.")) {
-        const stripped = trimmed.substring("function.".length);
-        add(stripped);
-        addSuffixStripped(stripped);
-    }
-    else {
-        addSuffixStripped(trimmed);
-    }
-    return [...candidates];
-}
-function resolveModelFacingToolName(toolName, mapping, tools) {
-    const candidateNames = createModelFacingToolNameLookupCandidates(toolName);
-    const candidateSet = new Set(candidateNames);
-    for (const candidate of candidateNames) {
-        const mappedToolName = mapping.modelFacingToOriginal.get(candidate);
-        if (mappedToolName) {
-            return mappedToolName;
-        }
-    }
-    for (const candidate of candidateNames) {
-        const directMatch = tools.find((tool) => tool.name === candidate);
-        if (directMatch) {
-            return directMatch.name;
-        }
-    }
-    const candidateMatches = tools.filter((tool) => {
-        const modelFacingCandidates = createModelFacingToolNameCandidates(tool.name);
-        return modelFacingCandidates.some((candidate) => candidateSet.has(candidate));
-    });
-    if (candidateMatches.length === 1) {
-        return candidateMatches[0].name;
-    }
-    return toolName;
-}
-function asStructuredExecutableTool(resolvedTool, modelFacingName, description) {
-    if (!hasCallableToolHandler(resolvedTool)) {
-        return resolvedTool;
-    }
-    const handler = resolvedTool.invoke ?? resolvedTool.call ?? resolvedTool.func;
-    if (typeof handler !== "function") {
-        return resolvedTool;
-    }
-    return createLangChainTool(async (input, config) => handler(input, config), {
-        name: modelFacingName,
-        description,
-        schema: normalizeResolvedToolSchema(resolvedTool),
-    });
-}
 export class AgentRuntimeAdapter {
     options;
     modelCache = new Map();
@@ -475,54 +121,8 @@ export class AgentRuntimeAdapter {
             clientRef: model.clientRef,
         });
     }
-    resolveBindingTimeout(binding) {
-        return resolveTimeoutMs(getBindingModelInit(binding)?.timeout);
-    }
-    resolveStreamIdleTimeout(binding) {
-        const configuredIdleTimeout = resolveTimeoutMs(getBindingModelInit(binding)?.streamIdleTimeout);
-        if (configuredIdleTimeout) {
-            return configuredIdleTimeout;
-        }
-        const invokeTimeout = this.resolveBindingTimeout(binding);
-        if (invokeTimeout) {
-            return Math.min(invokeTimeout, 15_000);
-        }
-        return 15_000;
-    }
-    resolveProviderRetryPolicy(binding) {
-        const resilience = typeof binding.harnessRuntime.resilience === "object" && binding.harnessRuntime.resilience
-            ? binding.harnessRuntime.resilience
-            : {};
-        const providerRetries = typeof resilience.providerRetries === "object" && resilience.providerRetries
-            ? resilience.providerRetries
-            : {};
-        const maxAttempts = typeof providerRetries.maxAttempts === "number" &&
-            Number.isFinite(providerRetries.maxAttempts) &&
-            providerRetries.maxAttempts > 0
-            ? Math.floor(providerRetries.maxAttempts)
-            : 2;
-        const backoffMs = typeof providerRetries.backoffMs === "number" &&
-            Number.isFinite(providerRetries.backoffMs) &&
-            providerRetries.backoffMs >= 0
-            ? Math.floor(providerRetries.backoffMs)
-            : 1_000;
-        const retryableMessages = Array.isArray(providerRetries.retryableMessages)
-            ? providerRetries.retryableMessages.filter((value) => typeof value === "string" && value.trim().length > 0)
-            : [];
-        return {
-            maxAttempts,
-            backoffMs,
-            retryableMessages,
-        };
-    }
-    isRetryableProviderError(binding, error) {
-        const message = error instanceof Error ? error.message : String(error);
-        const normalized = message.toLowerCase();
-        const { retryableMessages } = this.resolveProviderRetryPolicy(binding);
-        return retryableMessages.some((candidate) => normalized.includes(candidate.toLowerCase()));
-    }
     async invokeWithProviderRetry(binding, operation) {
-        const retryPolicy = this.resolveProviderRetryPolicy(binding);
+        const retryPolicy = resolveProviderRetryPolicy(binding);
         let lastError;
         for (let attempt = 1; attempt <= retryPolicy.maxAttempts; attempt += 1) {
             try {
@@ -530,7 +130,7 @@ export class AgentRuntimeAdapter {
             }
             catch (error) {
                 lastError = error;
-                if (attempt >= retryPolicy.maxAttempts || !this.isRetryableProviderError(binding, error)) {
+                if (attempt >= retryPolicy.maxAttempts || !isRetryableProviderError(binding, error)) {
                     throw error;
                 }
                 if (retryPolicy.backoffMs > 0) {
@@ -668,25 +268,7 @@ export class AgentRuntimeAdapter {
             return cached;
         }
         const pending = (async () => {
-            if (this.options.modelResolver) {
-                return wrapResolvedModel(await this.options.modelResolver(model.id));
-            }
-            if (model.provider === "ollama") {
-                return wrapResolvedModel(new ChatOllama({ model: model.model, ...model.init }));
-            }
-            if (model.provider === "openai-compatible") {
-                return wrapResolvedModel(new ChatOpenAI({ model: model.model, ...normalizeOpenAICompatibleInit(model.init) }));
-            }
-            if (model.provider === "openai") {
-                return wrapResolvedModel(new ChatOpenAI({ model: model.model, ...model.init }));
-            }
-            if (model.provider === "anthropic") {
-                return wrapResolvedModel(new ChatAnthropic({ model: model.model, ...model.init }));
-            }
-            if (model.provider === "google" || model.provider === "google-genai" || model.provider === "gemini") {
-                return wrapResolvedModel(new ChatGoogle({ model: model.model, ...model.init }));
-            }
-            return wrapResolvedModel(await initChatModel(model.model, { modelProvider: model.provider, ...model.init }));
+            return wrapResolvedModel(await createResolvedModel(model, this.options.modelResolver));
         })();
         this.modelCache.set(cacheKey, pending);
         try {
@@ -700,69 +282,14 @@ export class AgentRuntimeAdapter {
     buildToolNameMapping(tools) {
         return buildToolNameMapping(tools);
     }
-    buildAgentMessages(history, input) {
-        return [
-            ...history.map((item) => ({ role: item.role, content: normalizeMessageContent(item.content) })),
-            { role: "user", content: normalizeMessageContent(input) },
-        ];
-    }
     buildSlashCommandSkillInstruction(binding, input) {
-        const inputText = extractMessageText(input).trim();
-        const match = inputText.match(/^\/([a-z0-9]+(?:-[a-z0-9]+)*)(?:\s+([\s\S]*))?$/i);
-        if (!match) {
-            return undefined;
-        }
-        const invokedName = match[1].toLowerCase();
-        const argumentText = match[2]?.trim() ?? "";
-        const skillPaths = binding.deepAgentParams?.skills ?? binding.langchainAgentParams?.skills ?? [];
-        const matchedSkillPath = skillPaths.find((skillPath) => readSkillMetadata(skillPath).name.toLowerCase() === invokedName);
-        if (!matchedSkillPath) {
-            return undefined;
-        }
-        const metadata = readSkillMetadata(matchedSkillPath);
-        const skillQualifier = metadata.userInvocable === true ? "user-invocable skill" : "skill";
-        const dryRunHint = /\s--dry-run(?:\s|$)/.test(` ${argumentText} `)
-            ? "This invocation includes `--dry-run`. Perform the real fetch or inspection steps needed for dry-run output. Do not return hypothetical or mock results."
-            : undefined;
-        return [
-            `This user message is an explicit command-style invocation of the ${skillQualifier} \`${metadata.name}\`.`,
-            `Read the skill file for \`${metadata.name}\` before taking action, then follow its documented phases and constraints exactly.`,
-            `You must use the \`${metadata.name}\` skill for this request and follow its documented workflow.`,
-            `Treat everything after \`/${metadata.name}\` as the skill argument string: ${argumentText ? JSON.stringify(argumentText) : '""'}.`,
-            "Do not answer with a generic explanation of what the skill would do. Execute the skill workflow using the available tools unless the skill instructions explicitly require confirmation before acting.",
-            dryRunHint,
-        ].filter((line) => typeof line === "string" && line.length > 0).join("\n");
+        return buildSlashCommandSkillInstruction(binding, input);
     }
     buildInvocationRequest(binding, history, input, options = {}) {
-        const userInvocableInstruction = this.buildSlashCommandSkillInstruction(binding, input);
-        const messages = this.buildAgentMessages(history, input);
-        return {
-            ...(options.state ?? {}),
-            ...(options.files ? { files: options.files } : {}),
-            messages: userInvocableInstruction
-                ? [{ role: "system", content: userInvocableInstruction }, ...messages]
-                : messages,
-        };
-    }
-    buildStateSnapshot(result) {
-        const snapshot = { ...result };
-        delete snapshot.messages;
-        delete snapshot.__interrupt__;
-        delete snapshot.structuredResponse;
-        delete snapshot.files;
-        return Object.keys(snapshot).length > 0 ? snapshot : undefined;
+        return buildInvocationRequest(binding, history, input, options);
     }
     buildRawModelMessages(binding, systemPrompt, history, input) {
-        const messages = [];
-        if (systemPrompt) {
-            messages.push({ role: "system", content: systemPrompt });
-        }
-        const userInvocableInstruction = this.buildSlashCommandSkillInstruction(binding, input);
-        if (userInvocableInstruction) {
-            messages.push({ role: "system", content: userInvocableInstruction });
-        }
-        messages.push(...this.buildAgentMessages(history, input));
-        return messages;
+        return buildRawModelMessages(binding, systemPrompt, history, input);
     }
     resolveTools(tools, binding) {
         const resolved = this.options.toolResolver ? this.options.toolResolver(tools.map((tool) => tool.id), binding) : [];
@@ -781,38 +308,8 @@ export class AgentRuntimeAdapter {
             return modelFacingName === compiledTool.name ? wrappedTool : wrapResolvedToolWithModelFacingName(wrappedTool, modelFacingName);
         });
     }
-    normalizeInterruptPolicy(rule) {
-        if (!rule)
-            return null;
-        if (rule === true)
-            return ["approve", "edit", "reject"];
-        const typed = rule;
-        if (Array.isArray(typed.allowedDecisions)) {
-            return typed.allowedDecisions.filter((item) => item === "approve" || item === "edit" || item === "reject");
-        }
-        const decisions = [];
-        if (typed.allowAccept !== false)
-            decisions.push("approve");
-        if (typed.allowEdit !== false)
-            decisions.push("edit");
-        if (typed.allowReject !== false)
-            decisions.push("reject");
-        return decisions.length > 0 ? decisions : null;
-    }
     compileInterruptOn(tools, compatibilityRules) {
-        const toolNameMapping = this.buildToolNameMapping(tools);
-        const compiled = new Map();
-        for (const [toolName, rule] of Object.entries(compatibilityRules ?? {})) {
-            const modelFacingName = toolNameMapping.originalToModelFacing.get(toolName) ?? toolName;
-            const allowedDecisions = this.normalizeInterruptPolicy(rule);
-            if (!allowedDecisions) {
-                compiled.delete(modelFacingName);
-            }
-            else {
-                compiled.set(modelFacingName, { allowedDecisions });
-            }
-        }
-        return compiled.size > 0 ? Object.fromEntries(compiled.entries()) : undefined;
+        return compileInterruptOn(tools, compatibilityRules);
     }
     resolveInterruptOn(binding) {
         return this.compileInterruptOn(getBindingPrimaryTools(binding), getBindingInterruptCompatibilityRules(binding));
@@ -1333,13 +830,13 @@ export class AgentRuntimeAdapter {
             .map((edge) => this.normalizeLangGraphWorkflowEdge(edge))
             .filter((edge) => edge !== null);
     }
-    shouldFollowLangGraphEdge(edge, state, executorResult) {
+    shouldFollowLangGraphEdge(edge, state, currentResult) {
         const condition = edge.when?.toLowerCase().trim();
         if (!condition || condition === "always") {
             return true;
         }
         const review = state.review?.toLowerCase() ?? "";
-        const hasResult = Boolean(executorResult);
+        const hasResult = Boolean(currentResult);
         switch (condition) {
             case "has_plan":
                 return Boolean(state.plan?.trim());
@@ -1365,9 +862,9 @@ export class AgentRuntimeAdapter {
                 return false;
         }
     }
-    listLangGraphWorkflowNextNodes(workflow, nodeId, state, executorResult) {
+    listLangGraphWorkflowNextNodes(workflow, nodeId, state, currentResult) {
         return this.listLangGraphWorkflowEdges(workflow)
-            .filter((edge) => edge.from === nodeId && this.shouldFollowLangGraphEdge(edge, state, executorResult))
+            .filter((edge) => edge.from === nodeId && this.shouldFollowLangGraphEdge(edge, state, currentResult))
             .map((edge) => edge.to);
     }
     extractInvocationRequestText(request) {
@@ -1631,7 +1128,7 @@ export class AgentRuntimeAdapter {
             `User request:\n${userInputText}`,
             ...(workflowState.plan ? ["", `Workflow plan:\n${workflowState.plan}`] : []),
             ...(workflowState.review ? ["", `Workflow review:\n${workflowState.review}`] : []),
-            ...(activeResult ? ["", `Current executor result:\n${extractVisibleOutput(activeResult) || JSON.stringify(activeResult, null, 2)}`] : []),
+            ...(activeResult ? ["", `Current result:\n${extractVisibleOutput(activeResult) || JSON.stringify(activeResult, null, 2)}`] : []),
             "",
             "Complete the delegated subagent work and return concise results.",
         ].join("\n");
@@ -1746,7 +1243,7 @@ export class AgentRuntimeAdapter {
                             workflowState.review = await this.invokeWorkflowNodeModel(reviewerModel, reviewerPrompt, [
                                 `User request:\n${userInputText}`,
                                 "",
-                                `Executor result:\n${extractVisibleOutput(activeResult) || JSON.stringify(activeResult, null, 2)}`,
+                                `Current result:\n${extractVisibleOutput(activeResult) || JSON.stringify(activeResult, null, 2)}`,
                             ].join("\n"));
                         }
                         else if ((nodeRole === "finalizer" || nodeRole === "final") && activeResult) {
@@ -1988,7 +1485,7 @@ export class AgentRuntimeAdapter {
                     workflowState.review = await this.invokeWorkflowNodeModel(reviewerModel, reviewerPrompt, [
                         `User request:\n${userInputText}`,
                         "",
-                        `Executor result:\n${extractVisibleOutput(activeResult) || JSON.stringify(activeResult, null, 2)}`,
+                        `Current result:\n${extractVisibleOutput(activeResult) || JSON.stringify(activeResult, null, 2)}`,
                     ].join("\n"));
                     if (workflowState.review) {
                         yield { kind: "reasoning", content: workflowState.review };
@@ -2329,7 +1826,7 @@ export class AgentRuntimeAdapter {
         const callRuntime = async (activeBinding, activeRequest) => {
             return this.invokeWithProviderRetry(activeBinding, async () => {
                 const runnable = await this.create(activeBinding);
-                return (await this.withTimeout(() => runnable.invoke(activeRequest, { configurable: { thread_id: threadId, run_id: runId }, ...(options.context ? { context: options.context } : {}) }), this.resolveBindingTimeout(activeBinding), "agent invoke", "invoke"));
+                return (await this.withTimeout(() => runnable.invoke(activeRequest, { configurable: { thread_id: threadId, run_id: runId }, ...(options.context ? { context: options.context } : {}) }), resolveBindingTimeout(activeBinding), "agent invoke", "invoke"));
             });
         };
         const callRuntimeWithToolParseRecovery = async (activeRequest) => {
@@ -2475,7 +1972,7 @@ export class AgentRuntimeAdapter {
                 ...(outputContent !== undefined ? { outputContent } : {}),
                 ...(contentBlocks.length > 0 ? { contentBlocks } : {}),
                 ...(asRecord(result.files) ? { files: asRecord(result.files) } : {}),
-                ...(this.buildStateSnapshot(result) ? { stateSnapshot: this.buildStateSnapshot(result) } : {}),
+                ...(buildStateSnapshot(result) ? { stateSnapshot: buildStateSnapshot(result) } : {}),
                 upstreamResult: result,
             },
         };
@@ -2483,8 +1980,8 @@ export class AgentRuntimeAdapter {
     async *stream(binding, input, threadId, history = [], options = {}) {
         try {
             const adapterKind = getBindingAdapterKind(binding);
-            const invokeTimeoutMs = this.resolveBindingTimeout(binding);
-            const streamIdleTimeoutMs = this.resolveStreamIdleTimeout(binding);
+            const invokeTimeoutMs = resolveBindingTimeout(binding);
+            const streamIdleTimeoutMs = resolveStreamIdleTimeout(binding);
             const streamDeadlineAt = invokeTimeoutMs ? Date.now() + invokeTimeoutMs : undefined;
             const primaryTools = getBindingPrimaryTools(binding);
             const toolNameMapping = this.buildToolNameMapping(primaryTools);
@@ -2541,6 +2038,7 @@ export class AgentRuntimeAdapter {
                 const seenTerminalOutputs = new Set();
                 let lastStep = "";
                 for await (const event of this.iterateWithTimeout(events, streamIdleTimeoutMs, "agent streamEvents", streamDeadlineAt, invokeTimeoutMs)) {
+                    yield { kind: "upstream-event", event: normalizeUpstreamRuntimeEvent(event) };
                     const interruptPayload = extractInterruptPayload(event);
                     if (interruptPayload) {
                         yield { kind: "interrupt", content: interruptPayload };