@botbotgo/agent-harness 0.0.2 → 0.0.4

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

@@ -14,6 +14,7 @@ export declare class AgentRuntimeAdapter {
     private applyStrictToolJsonInstruction;
     private synthesizeDeepAgentAnswer;
     private resolveModel;
+    private buildToolNameMapping;
     private resolveTools;
     private normalizeInterruptPolicy;
     private compileInterruptOn;

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

@@ -9,6 +9,7 @@ import { extractReasoningText, extractToolFallbackContext, extractVisibleOutput,
 import { extractAgentStep, extractInterruptPayload, extractReasoningStreamOutput, extractTerminalStreamOutput, extractToolResult, normalizeTerminalOutputKey, readStreamDelta, } from "./parsing/stream-event-parsing.js";
 import { wrapToolForExecution } from "./tool-hitl.js";
 const AGENT_INTERRUPT_SENTINEL_PREFIX = "__agent_harness_interrupt__:";
+const MODEL_SAFE_TOOL_NAME_PATTERN = /^[a-zA-Z0-9_-]+$/;
 function asObject(value) {
     return typeof value === "object" && value ? value : undefined;
 }
@@ -25,6 +26,56 @@ function normalizeOpenAICompatibleInit(init) {
     delete normalized.baseUrl;
     return normalized;
 }
+function sanitizeToolNameForModel(name) {
+    const sanitized = name
+        .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 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 class AgentRuntimeAdapter {
     options;
     constructor(options = {}) {
@@ -143,11 +194,20 @@ export class AgentRuntimeAdapter {
         }
         return wrapResolvedModel(await initChatModel(model.model, { modelProvider: model.provider, ...model.init }));
     }
+    buildToolNameMapping(tools) {
+        return buildToolNameMapping(tools);
+    }
     resolveTools(tools, binding) {
         const resolved = this.options.toolResolver ? this.options.toolResolver(tools.map((tool) => tool.id), binding) : [];
+        const toolNameMapping = this.buildToolNameMapping(tools);
         return resolved.map((resolvedTool, index) => {
             const compiledTool = tools[index];
-            return compiledTool ? wrapToolForExecution(resolvedTool, compiledTool) : resolvedTool;
+            if (!compiledTool) {
+                return resolvedTool;
+            }
+            const wrappedTool = wrapToolForExecution(resolvedTool, compiledTool);
+            const modelFacingName = toolNameMapping.originalToModelFacing.get(compiledTool.name) ?? compiledTool.name;
+            return modelFacingName === compiledTool.name ? wrappedTool : wrapResolvedToolWithModelFacingName(wrappedTool, modelFacingName);
         });
     }
     normalizeInterruptPolicy(rule) {
@@ -168,15 +228,17 @@ export class AgentRuntimeAdapter {
             decisions.push("reject");
         return decisions.length > 0 ? decisions : null;
     }
-    compileInterruptOn(_tools, compatibilityRules) {
+    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(toolName);
+                compiled.delete(modelFacingName);
             }
             else {
-                compiled.set(toolName, { allowedDecisions });
+                compiled.set(modelFacingName, { allowedDecisions });
             }
         }
         return compiled.size > 0 ? Object.fromEntries(compiled.entries()) : undefined;

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "@botbotgo/agent-harness",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "description": "Agent Harness framework package",
   "type": "module",
   "main": "./dist/index.js",
+  "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "files": [
     "dist"
@@ -19,11 +20,12 @@
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
       "default": "./dist/index.js"
     }
   },
   "dependencies": {
-    "@botbotgo/agent-harness-builtin": "0.0.2"
+    "@botbotgo/agent-harness-builtin": "0.0.4"
   },
   "scripts": {
     "build": "rm -rf dist tsconfig.tsbuildinfo && tsc -p tsconfig.json && cp -R config dist/",