@botbotgo/agent-harness 0.0.96 → 0.0.97

package/dist/runtime/adapter/tool/provider-tool.js

@@ -0,0 +1,25 @@
+import { tools as anthropicProviderTools } from "@langchain/anthropic";
+import { tools as openAIProviderTools } from "@langchain/openai";
+import { asRecord } from "./resolved-tool.js";
+export 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);
+}

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

@@ -0,0 +1,18 @@
+import { z } from "zod";
+export type ResolvedToolLike = {
+    name?: string;
+    description?: string;
+    schema?: {
+        parse?: (input: unknown) => unknown;
+    };
+    invoke?: (input: unknown, config?: Record<string, unknown>) => Promise<unknown> | unknown;
+    call?: (input: unknown, config?: Record<string, unknown>) => Promise<unknown> | unknown;
+    func?: (input: unknown, config?: Record<string, unknown>) => Promise<unknown> | unknown;
+};
+export declare function asRecord(value: unknown): Record<string, unknown> | undefined;
+export declare function wrapResolvedToolWithModelFacingName<T>(resolvedTool: T, modelFacingName: string): T;
+export declare function hasCallableToolHandler(value: unknown): value is ResolvedToolLike;
+export declare function normalizeResolvedToolSchema(resolvedTool: ResolvedToolLike): Record<string, unknown> | {
+    parse?: (input: unknown) => unknown;
+} | z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">> | undefined;
+export declare function asStructuredExecutableTool(resolvedTool: unknown, modelFacingName: string, description: string): unknown;

package/dist/runtime/adapter/tool/resolved-tool.js

@@ -0,0 +1,62 @@
+import { z } from "zod";
+import { tool as createLangChainTool } from "@langchain/core/tools";
+export function asRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        ? { ...value }
+        : undefined;
+}
+export 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);
+        },
+    });
+}
+export 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";
+}
+export 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();
+}
+export 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),
+    });
+}

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

@@ -0,0 +1,7 @@
+export declare function stringifyToolOutput(output: unknown): string;
+export declare function normalizeToolArgsForSchema(args: Record<string, unknown>, schema: unknown): Record<string, unknown>;
+export declare function extractToolCallsFromResult(result: unknown): Array<{
+    id?: string;
+    name: string;
+    args: Record<string, unknown>;
+}>;

package/dist/runtime/adapter/tool/tool-arguments.js

@@ -0,0 +1,87 @@
+import { salvageToolArgs } from "../../parsing/output-parsing.js";
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isObject(value) {
+    return isRecord(value);
+}
+export function stringifyToolOutput(output) {
+    if (typeof output === "string") {
+        return output;
+    }
+    try {
+        return JSON.stringify(output);
+    }
+    catch {
+        return `${String(output)}`;
+    }
+}
+export 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],
+    };
+}
+export 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);
+}

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

@@ -1,5 +1,5 @@
-import type { CompiledTool } from "../contracts/types.js";
-import type { CompiledAgentBinding } from "../contracts/types.js";
+import type { CompiledTool } from "../../../contracts/types.js";
+import type { CompiledAgentBinding } from "../../../contracts/types.js";
 type InterruptFn = <I = unknown, R = unknown>(value: I) => R;
 export declare function wrapToolForHumanInTheLoop<T>(resolvedTool: T, compiledTool: CompiledTool, interruptFn?: InterruptFn): T;
 export declare function wrapToolForExecution<T>(resolvedTool: T, compiledTool: CompiledTool, binding?: CompiledAgentBinding, interruptFn?: InterruptFn): T;

package/dist/runtime/adapter/tool/tool-name-mapping.d.ts

@@ -0,0 +1,13 @@
+export type ToolNameMapping = {
+    originalToModelFacing: Map<string, string>;
+    modelFacingToOriginal: Map<string, string>;
+};
+export declare function sanitizeToolNameForModel(name: string): string;
+export declare function buildToolNameMapping(tools: Array<{
+    name: string;
+}>): ToolNameMapping;
+export declare function createModelFacingToolNameCandidates(toolName: string): string[];
+export declare function createModelFacingToolNameLookupCandidates(toolName: string): string[];
+export declare function resolveModelFacingToolName(toolName: string, mapping: ToolNameMapping, tools: Array<{
+    name: string;
+}>): string;

package/dist/runtime/adapter/tool/tool-name-mapping.js

@@ -0,0 +1,101 @@
+const MODEL_SAFE_TOOL_NAME_PATTERN = /^[a-zA-Z0-9_-]+$/;
+export 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";
+}
+export 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 };
+}
+export 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];
+}
+export 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];
+}
+export 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;
+}

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

@@ -1,5 +1,9 @@
-import type { CompiledAgentBinding, CompiledModel, CompiledSubAgent, MessageContent, RunResult, RuntimeAdapterOptions, TranscriptMessage } from "../contracts/types.js";
+import type { CompiledAgentBinding, MessageContent, RunResult, RuntimeAdapterOptions, TranscriptMessage } from "../contracts/types.js";
 import { type RuntimeStreamChunk } from "./parsing/stream-event-parsing.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";
 type RunnableLike = {
     invoke: (input: unknown, config?: Record<string, unknown>) => Promise<unknown>;
     stream?: (input: unknown, config?: Record<string, unknown>) => Promise<AsyncIterable<unknown>>;
@@ -12,18 +16,6 @@ declare class RuntimeOperationTimeoutError extends Error {
     readonly stage: "stream" | "invoke";
     constructor(operation: string, timeoutMs: number, stage?: "stream" | "invoke");
 }
-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: {
-    subagents?: CompiledSubAgent[];
-    generalPurposeAgent?: boolean;
-    taskDescription?: string;
-}): boolean;
 export declare class AgentRuntimeAdapter {
     private readonly options;
     private readonly modelCache;
@@ -31,10 +23,6 @@ export declare class AgentRuntimeAdapter {
     private readonly langGraphSessions;
     constructor(options?: RuntimeAdapterOptions);
     private getModelCacheKey;
-    private resolveBindingTimeout;
-    private resolveStreamIdleTimeout;
-    private resolveProviderRetryPolicy;
-    private isRetryableProviderError;
     private invokeWithProviderRetry;
     private withTimeout;
     private iterateWithTimeout;
@@ -43,13 +31,10 @@ export declare class AgentRuntimeAdapter {
     private applyStrictToolJsonInstruction;
     private resolveModel;
     private buildToolNameMapping;
-    private buildAgentMessages;
     private buildSlashCommandSkillInstruction;
     private buildInvocationRequest;
-    private buildStateSnapshot;
     private buildRawModelMessages;
     private resolveTools;
-    private normalizeInterruptPolicy;
     private compileInterruptOn;
     private resolveInterruptOn;
     private resolveFilesystemBackend;