@botbotgo/agent-harness 0.0.95 → 0.0.97

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;