@botbotgo/agent-harness 0.0.96 → 0.0.98

package/dist/contracts/workspace.d.ts

@@ -0,0 +1,229 @@
+import type { ExecutionMode, RuntimeCapabilities, RuntimeModelRefMap, RuntimeModelSlot } from "./core.js";
+export type ParsedAgentObject = {
+    id: string;
+    executionMode: ExecutionMode;
+    runtimeModelRefs?: RuntimeModelRefMap;
+    capabilities?: RuntimeCapabilities;
+    description: string;
+    modelRef: string;
+    runRoot?: string;
+    toolRefs: string[];
+    mcpServers?: Array<Record<string, unknown>>;
+    skillPathRefs: string[];
+    memorySources: string[];
+    subagentRefs: string[];
+    subagentPathRefs: string[];
+    langchainAgentConfig?: Record<string, unknown>;
+    deepAgentConfig?: Record<string, unknown>;
+    sourcePath: string;
+};
+export type WorkspaceObject = {
+    id: string;
+    kind: string;
+    sourcePath: string;
+    value: Record<string, unknown>;
+};
+export type ParsedModelObject = {
+    id: string;
+    provider: string;
+    model: string;
+    init: Record<string, unknown>;
+    clientRef?: string;
+    fallbacks: string[];
+    metadata?: Record<string, unknown>;
+    sourcePath: string;
+};
+export type ParsedEmbeddingModelObject = {
+    id: string;
+    provider: string;
+    model: string;
+    init: Record<string, unknown>;
+    clientRef?: string;
+    metadata?: Record<string, unknown>;
+    sourcePath: string;
+};
+export type ParsedVectorStoreObject = {
+    id: string;
+    kind: string;
+    url?: string;
+    authToken?: string;
+    table?: string;
+    column?: string;
+    embeddingModelRef?: string;
+    metadata?: Record<string, unknown>;
+    sourcePath: string;
+};
+export type ParsedMcpServerObject = {
+    id: string;
+    transport: "stdio" | "http" | "sse" | "websocket";
+    url?: string;
+    command?: string;
+    args?: string[];
+    env?: Record<string, string>;
+    cwd?: string;
+    token?: string;
+    headers?: Record<string, string>;
+    sourcePath: string;
+};
+export type ParsedToolObject = {
+    id: string;
+    type: string;
+    name: string;
+    description: string;
+    implementationName?: string;
+    config?: Record<string, unknown>;
+    inputSchemaRef?: string;
+    backendOperation?: string;
+    mcpRef?: string;
+    bundleRefs: string[];
+    hitl?: {
+        enabled: boolean;
+        allow?: Array<"approve" | "edit" | "reject">;
+    };
+    retryable?: boolean;
+    sourcePath: string;
+};
+export type CompiledModel = {
+    id: string;
+    provider: string;
+    model: string;
+    init: Record<string, unknown>;
+    clientRef?: string;
+    fallbacks: string[];
+    runtimeValue: string;
+};
+export type CompiledEmbeddingModel = {
+    id: string;
+    provider: string;
+    model: string;
+    init: Record<string, unknown>;
+    clientRef?: string;
+    runtimeValue: string;
+};
+export type CompiledVectorStore = {
+    id: string;
+    kind: string;
+    url?: string;
+    authToken?: string;
+    table?: string;
+    column?: string;
+    embeddingModelRef?: string;
+    runtimeValue: string;
+};
+export type CompiledTool = {
+    id: string;
+    type: string;
+    name: string;
+    description: string;
+    config?: Record<string, unknown>;
+    inputSchemaRef?: string;
+    backendOperation?: string;
+    mcpRef?: string;
+    bundleRefs: string[];
+    hitl?: {
+        enabled: boolean;
+        allow: Array<"approve" | "edit" | "reject">;
+    };
+    retryable?: boolean;
+    runtimeValue: {
+        name: string;
+        description: string;
+        type: string;
+    };
+};
+export type CompiledSubAgent = {
+    name: string;
+    description: string;
+    systemPrompt: string;
+    tools?: CompiledTool[];
+    model?: CompiledModel;
+    interruptOn?: Record<string, boolean | object>;
+    skills?: string[];
+    memory?: string[];
+    responseFormat?: unknown;
+    contextSchema?: unknown;
+    middleware?: Array<Record<string, unknown>>;
+    passthrough?: Record<string, unknown>;
+};
+export type LangChainAgentParams = {
+    model: CompiledModel;
+    tools: CompiledTool[];
+    systemPrompt?: string;
+    stateSchema?: unknown;
+    responseFormat?: unknown;
+    contextSchema?: unknown;
+    filesystem?: Record<string, unknown>;
+    middleware?: Array<Record<string, unknown>>;
+    passthrough?: Record<string, unknown>;
+    subagents?: CompiledSubAgent[];
+    memory?: string[];
+    skills?: string[];
+    generalPurposeAgent?: boolean;
+    taskDescription?: string;
+    includeAgentName?: "inline";
+    version?: "v1" | "v2";
+    name?: string;
+    description: string;
+};
+export type DeepAgentParams = {
+    model: CompiledModel;
+    tools: CompiledTool[];
+    systemPrompt?: string;
+    responseFormat?: unknown;
+    contextSchema?: unknown;
+    middleware?: Array<Record<string, unknown>>;
+    passthrough?: Record<string, unknown>;
+    description: string;
+    subagents: CompiledSubAgent[];
+    interruptOn?: Record<string, boolean | object>;
+    backend?: Record<string, unknown>;
+    store?: Record<string, unknown>;
+    name: string;
+    memory: string[];
+    skills: string[];
+    generalPurposeAgent?: boolean;
+    taskDescription?: string;
+};
+export type RuntimeModelMap = Partial<Record<RuntimeModelSlot, CompiledModel>>;
+export type CompiledAgentBinding = {
+    agent: ParsedAgentObject;
+    adapter?: {
+        kind: string;
+        config: Record<string, unknown>;
+    };
+    langchainAgentParams?: LangChainAgentParams;
+    deepAgentParams?: DeepAgentParams;
+    harnessRuntime: {
+        runRoot: string;
+        workspaceRoot?: string;
+        modelRefs?: RuntimeModelRefMap;
+        models?: RuntimeModelMap;
+        capabilities?: RuntimeCapabilities;
+        resilience?: Record<string, unknown>;
+        checkpointer?: Record<string, unknown> | boolean;
+        store?: Record<string, unknown>;
+        runtimeMemory?: Record<string, unknown>;
+    };
+};
+export type WorkspaceBundle = {
+    workspaceRoot: string;
+    resourceSources: string[];
+    refs: Map<string, WorkspaceObject | ParsedAgentObject>;
+    models: Map<string, ParsedModelObject>;
+    embeddings: Map<string, ParsedEmbeddingModelObject>;
+    vectorStores: Map<string, ParsedVectorStoreObject>;
+    mcpServers: Map<string, ParsedMcpServerObject>;
+    tools: Map<string, ParsedToolObject>;
+    agents: Map<string, ParsedAgentObject>;
+    bindings: Map<string, CompiledAgentBinding>;
+};
+export type WorkspaceLoadOptions = {
+    /**
+     * Additional workspace roots to load before the runtime workspace root.
+     * Merge order is deterministic:
+     * framework defaults -> each overlayRoot (in order) -> workspaceRoot.
+     * Later values always override earlier values.
+     */
+    overlayRoots?: string[];
+    resourceSources?: string[];
+};

package/dist/contracts/workspace.js

@@ -0,0 +1 @@
+export {};

package/dist/package-version.d.ts

@@ -1 +1 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.95";
+export declare const AGENT_HARNESS_VERSION = "0.0.97";

package/dist/package-version.js

@@ -1 +1 @@
-export const AGENT_HARNESS_VERSION = "0.0.95";
+export const AGENT_HARNESS_VERSION = "0.0.97";

package/dist/runtime/adapter/compat/deepagent-compat.d.ts

@@ -0,0 +1,16 @@
+import type { CompiledModel, CompiledSubAgent } from "../../../contracts/types.js";
+type DelegationPromptCompatibilityParams = {
+    subagents?: CompiledSubAgent[];
+    generalPurposeAgent?: boolean;
+    taskDescription?: string;
+};
+export declare function relativizeDeepAgentSkillSourcePaths(workspaceRoot: string | undefined, skillPaths: string[] | undefined): string[] | undefined;
+export declare function materializeDeepAgentSkillSourcePaths(options: {
+    workspaceRoot?: string;
+    runRoot?: string;
+    ownerId: string;
+    skillPaths?: string[];
+}): Promise<string[] | undefined>;
+export declare function shouldRelaxDeepAgentDelegationPrompt(model: CompiledModel | undefined, params: DelegationPromptCompatibilityParams): boolean;
+export declare function applyDeepAgentDelegationPromptCompatibility<T extends DelegationPromptCompatibilityParams>(model: CompiledModel | undefined, params: T): T;
+export {};

package/dist/runtime/adapter/compat/deepagent-compat.js

@@ -0,0 +1,45 @@
+import path from "node:path";
+function isOpenAICompatibleGptOssModel(model) {
+    return model?.provider === "openai-compatible" && model.model.trim().toLowerCase().startsWith("gpt-oss");
+}
+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;
+}
+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());
+}
+export function applyDeepAgentDelegationPromptCompatibility(model, params) {
+    if (!shouldRelaxDeepAgentDelegationPrompt(model, params)) {
+        return params;
+    }
+    return {
+        ...params,
+        generalPurposeAgent: undefined,
+        taskDescription: undefined,
+    };
+}

package/dist/runtime/adapter/compat/openai-compatible.d.ts

@@ -0,0 +1,2 @@
+export declare function buildAuthOmittingFetch(baseFetch?: typeof fetch): typeof fetch;
+export declare function normalizeOpenAICompatibleInit(init: Record<string, unknown>): Record<string, unknown>;

package/dist/runtime/adapter/compat/openai-compatible.js

@@ -0,0 +1,43 @@
+function asObject(value) {
+    return typeof value === "object" && value ? value : undefined;
+}
+function isPlaceholderApiKey(value) {
+    return typeof value === "string" && value.trim().toLowerCase() === "dummy";
+}
+export 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,
+        });
+    };
+}
+export 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;
+}

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

@@ -0,0 +1,15 @@
+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";
+export * from "./tool/provider-tool.js";
+export * from "./resilience.js";
+export * from "./tool/resolved-tool.js";
+export * from "./tool/tool-arguments.js";
+export * from "./tool/tool-hitl.js";
+export * from "./tool/tool-name-mapping.js";

package/dist/runtime/adapter/index.js

@@ -0,0 +1,15 @@
+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";
+export * from "./tool/provider-tool.js";
+export * from "./resilience.js";
+export * from "./tool/resolved-tool.js";
+export * from "./tool/tool-arguments.js";
+export * from "./tool/tool-hitl.js";
+export * from "./tool/tool-name-mapping.js";

package/dist/runtime/{langgraph-profiles.d.ts → adapter/langgraph/profiles.d.ts}

@@ -1,4 +1,4 @@
-import type { LangGraphPresetWorkflow } from "./langgraph-presets.js";
+import type { LangGraphPresetWorkflow } from "./presets.js";
 export type LangGraphProfileName = "coding-runtime" | "personal-assistant" | "research-runtime" | "approval-review-runtime" | "claw-style-assistant" | "chat-operator" | "copilot-sidecar" | "task-delegation-hub";
 type LangGraphProfileOptions = Record<string, unknown>;
 export declare const SUPPORTED_LANGGRAPH_PROFILES: LangGraphProfileName[];

package/dist/runtime/adapter/model/invocation-request.d.ts

@@ -0,0 +1,10 @@
+import type { CompiledAgentBinding, MessageContent, TranscriptMessage } from "../../../contracts/types.js";
+export declare function buildAgentMessages(history: TranscriptMessage[], input: MessageContent): Array<{
+    role: string;
+    content: MessageContent;
+}>;
+export declare function buildSlashCommandSkillInstruction(binding: CompiledAgentBinding, input: MessageContent): string | undefined;
+export declare function buildInvocationRequest(binding: CompiledAgentBinding, history: TranscriptMessage[], input: MessageContent, options?: {
+    state?: Record<string, unknown>;
+    files?: Record<string, unknown>;
+}): Record<string, unknown>;

package/dist/runtime/adapter/model/invocation-request.js

@@ -0,0 +1,46 @@
+import { extractMessageText, normalizeMessageContent } from "../../../utils/message-content.js";
+import { readSkillMetadata } from "../../support/skill-metadata.js";
+export function buildAgentMessages(history, input) {
+    return [
+        ...history.map((item) => ({ role: item.role, content: normalizeMessageContent(item.content) })),
+        { role: "user", content: normalizeMessageContent(input) },
+    ];
+}
+export function 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");
+}
+export function buildInvocationRequest(binding, history, input, options = {}) {
+    const userInvocableInstruction = buildSlashCommandSkillInstruction(binding, input);
+    const messages = buildAgentMessages(history, input);
+    return {
+        ...(options.state ?? {}),
+        ...(options.files ? { files: options.files } : {}),
+        messages: userInvocableInstruction
+            ? [{ role: "system", content: userInvocableInstruction }, ...messages]
+            : messages,
+    };
+}

package/dist/runtime/adapter/model/message-assembly.d.ts

@@ -0,0 +1,6 @@
+import type { CompiledAgentBinding, MessageContent, TranscriptMessage } from "../../../contracts/types.js";
+export declare function buildStateSnapshot(result: Record<string, unknown>): Record<string, unknown> | undefined;
+export declare function buildRawModelMessages(binding: CompiledAgentBinding, systemPrompt: string | undefined, history: TranscriptMessage[], input: MessageContent): Array<{
+    role: string;
+    content: MessageContent;
+}>;

package/dist/runtime/adapter/model/message-assembly.js

@@ -0,0 +1,21 @@
+import { buildAgentMessages, buildSlashCommandSkillInstruction } from "./invocation-request.js";
+export function 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;
+}
+export function buildRawModelMessages(binding, systemPrompt, history, input) {
+    const messages = [];
+    if (systemPrompt) {
+        messages.push({ role: "system", content: systemPrompt });
+    }
+    const userInvocableInstruction = buildSlashCommandSkillInstruction(binding, input);
+    if (userInvocableInstruction) {
+        messages.push({ role: "system", content: userInvocableInstruction });
+    }
+    messages.push(...buildAgentMessages(history, input));
+    return messages;
+}

package/dist/runtime/adapter/model/model-providers.d.ts

@@ -0,0 +1,2 @@
+import type { CompiledModel, RuntimeAdapterOptions } from "../../../contracts/types.js";
+export declare function createResolvedModel(model: CompiledModel, modelResolver: RuntimeAdapterOptions["modelResolver"]): Promise<unknown>;

package/dist/runtime/adapter/model/model-providers.js

@@ -0,0 +1,27 @@
+import { ChatAnthropic } from "@langchain/anthropic";
+import { ChatGoogle } from "@langchain/google";
+import { ChatOllama } from "@langchain/ollama";
+import { ChatOpenAI } from "@langchain/openai";
+import { initChatModel } from "langchain";
+import { normalizeOpenAICompatibleInit } from "../compat/openai-compatible.js";
+export async function createResolvedModel(model, modelResolver) {
+    if (modelResolver) {
+        return modelResolver(model.id);
+    }
+    if (model.provider === "ollama") {
+        return new ChatOllama({ model: model.model, ...model.init });
+    }
+    if (model.provider === "openai-compatible") {
+        return new ChatOpenAI({ model: model.model, ...normalizeOpenAICompatibleInit(model.init) });
+    }
+    if (model.provider === "openai") {
+        return new ChatOpenAI({ model: model.model, ...model.init });
+    }
+    if (model.provider === "anthropic") {
+        return new ChatAnthropic({ model: model.model, ...model.init });
+    }
+    if (model.provider === "google" || model.provider === "google-genai" || model.provider === "gemini") {
+        return new ChatGoogle({ model: model.model, ...model.init });
+    }
+    return initChatModel(model.model, { modelProvider: model.provider, ...model.init });
+}

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

@@ -0,0 +1,12 @@
+import type { CompiledAgentBinding } from "../../contracts/types.js";
+export declare function resolveTimeoutMs(value: unknown): number | undefined;
+export declare function computeRemainingTimeoutMs(deadlineAt: number | undefined, fallbackTimeoutMs: number | undefined): number | undefined;
+export declare function resolveBindingTimeout(binding: CompiledAgentBinding): number | undefined;
+export declare function resolveStreamIdleTimeout(binding: CompiledAgentBinding): number | undefined;
+export type ProviderRetryPolicy = {
+    maxAttempts: number;
+    backoffMs: number;
+    retryableMessages: string[];
+};
+export declare function resolveProviderRetryPolicy(binding: CompiledAgentBinding): ProviderRetryPolicy;
+export declare function isRetryableProviderError(binding: CompiledAgentBinding, error: unknown): boolean;

package/dist/runtime/adapter/resilience.js

@@ -0,0 +1,60 @@
+import { getBindingModelInit } from "../support/compiled-binding.js";
+export function resolveTimeoutMs(value) {
+    return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : undefined;
+}
+export 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;
+}
+export function resolveBindingTimeout(binding) {
+    return resolveTimeoutMs(getBindingModelInit(binding)?.timeout);
+}
+export function resolveStreamIdleTimeout(binding) {
+    const configuredIdleTimeout = resolveTimeoutMs(getBindingModelInit(binding)?.streamIdleTimeout);
+    if (configuredIdleTimeout) {
+        return configuredIdleTimeout;
+    }
+    const invokeTimeout = resolveBindingTimeout(binding);
+    if (invokeTimeout) {
+        return Math.min(invokeTimeout, 15_000);
+    }
+    return 15_000;
+}
+export function 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,
+    };
+}
+export function isRetryableProviderError(binding, error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const normalized = message.toLowerCase();
+    const { retryableMessages } = resolveProviderRetryPolicy(binding);
+    return retryableMessages.some((candidate) => normalized.includes(candidate.toLowerCase()));
+}

package/dist/runtime/{declared-middleware.d.ts → adapter/tool/declared-middleware.d.ts}

@@ -1,4 +1,4 @@
-import type { CompiledAgentBinding, CompiledModel } from "../contracts/types.js";
+import type { CompiledAgentBinding, CompiledModel } from "../../../contracts/types.js";
 type MiddlewareConfig = Record<string, unknown>;
 type MiddlewareFactoryContext = {
     config: MiddlewareConfig;

package/dist/runtime/adapter/tool/interrupt-policy.d.ts

@@ -0,0 +1,8 @@
+import type { CompiledTool } from "../../../contracts/types.js";
+export type InterruptDecision = "approve" | "edit" | "reject";
+export declare function normalizeInterruptPolicy(rule: boolean | object | undefined): InterruptDecision[] | null;
+export declare function compileInterruptOn(tools: Array<Pick<CompiledTool, "name">> | Array<{
+    name: string;
+}>, compatibilityRules?: Record<string, boolean | object>): Record<string, {
+    allowedDecisions: InterruptDecision[];
+}> | undefined;

package/dist/runtime/adapter/tool/interrupt-policy.js

@@ -0,0 +1,34 @@
+import { buildToolNameMapping } from "./tool-name-mapping.js";
+export function 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;
+}
+export function compileInterruptOn(tools, compatibilityRules) {
+    const toolNameMapping = buildToolNameMapping(tools);
+    const compiled = new Map();
+    for (const [toolName, rule] of Object.entries(compatibilityRules ?? {})) {
+        const modelFacingName = toolNameMapping.originalToModelFacing.get(toolName) ?? toolName;
+        const allowedDecisions = normalizeInterruptPolicy(rule);
+        if (!allowedDecisions) {
+            compiled.delete(modelFacingName);
+        }
+        else {
+            compiled.set(modelFacingName, { allowedDecisions });
+        }
+    }
+    return compiled.size > 0 ? Object.fromEntries(compiled.entries()) : undefined;
+}

package/dist/runtime/adapter/tool/provider-tool.d.ts

@@ -0,0 +1,2 @@
+import type { CompiledTool } from "../../../contracts/types.js";
+export declare function instantiateProviderTool(compiledTool: CompiledTool): unknown;