@zuora/agent-toolkit 0.1.0-alpha.0 → 0.1.0-alpha.1

package/dist/openai-agents/index.d.ts

@@ -1,6 +1,6 @@
 import { tool } from '@openai/agents';
 import { ToolkitCore } from '../shared/toolkit-core.js';
-import { Z as ZuoraToolDefinition, a as ZuoraAgentToolkitConfigInput, T as ToolSelection } from '../async-jobs-DJ_GygII.js';
+import { b as ZuoraToolExecutionResult, Z as ZuoraToolDefinition, a as ZuoraAgentToolkitConfigInput, T as ToolSelection } from '../async-jobs-DJ_GygII.js';
 import { Z as ZuoraOpenAIAgentToolkit } from '../toolkit-Bjw46goJ.js';
 import 'openai/resources/chat/completions';
 
@@ -22,6 +22,35 @@ type AgentsFunctionTool = ReturnType<typeof tool>;
  * automatically inside `convertTools()` — callers do not need to know about it.
  */
 declare class ZuoraOpenAIAgentsToolkit extends ToolkitCore<AgentsFunctionTool> {
+    /** Maps sanitized adapter tool names back to their original ZuoraToolDefinition. */
+    private sanitizedToolMap;
+    /**
+     * Look up a ZuoraToolDefinition by its sanitized adapter tool name.
+     *
+     * The OpenAI Agents SDK registers tools with sanitized names (see convertTools),
+     * but external code may reference tools by their original MCP names. This method
+     * provides resolution in both directions.
+     */
+    private resolveToolName;
+    /**
+     * Resolve a tool name that may be either sanitized or original MCP format.
+     *
+     * This provides additional name normalization to handle cases where:
+     * - A tool name contains unsanitized characters (like dots)
+     * - A tool name was learned from descriptions or logs
+     *
+     * We attempt to find a match with relaxed sanitization rules before giving up.
+     */
+    private normalizeToolName;
+    /**
+     * Override callTool to provide flexible name resolution.
+     *
+     * The OpenAI Agents SDK may receive tool calls with names that were learned
+     * from descriptions or other sources (not directly from tool registration).
+     * This override allows us to handle both sanitized and original tool names
+     * by falling back to name normalization when the direct lookup fails.
+     */
+    callTool(operationName: string, input: Record<string, unknown>): Promise<ZuoraToolExecutionResult>;
     /**
      * Serialises the agent tool response, emits an `agent.tool.response`
      * observability event (with the response in `metadata` when

package/dist/openai-agents/index.js

@@ -4183,8 +4183,17 @@ var createHttpMcpClientConfig = (config) => {
 };
 var isTenantAuthConnection = (connection) => connection?.tenantAuth?.enabled === true;
 var filterCatalogTools = (tools, policy) => tools.filter((tool2) => {
-  if (policy.mode === SafetyMode.ReadOnly && tool2.meta.access === "write") {
-    return false;
+  if (policy.mode === SafetyMode.ReadOnly) {
+    if (tool2.meta.operationAccess) {
+      const hasReadOperation = Object.values(tool2.meta.operationAccess).some(
+        (access) => access === "read"
+      );
+      if (!hasReadOperation) {
+        return false;
+      }
+    } else if (tool2.meta.access === "write") {
+      return false;
+    }
   }
   if (policy.bundles.size > 0 && !policy.bundles.has(tool2.meta.bundle)) {
     return false;
@@ -4346,18 +4355,18 @@ var ToolkitCore = class {
       });
     }
     const mode = this.config.configuration?.mode ?? SafetyMode.ReadOnly;
-    if (mode === SafetyMode.ReadOnly && tool2.meta.access === "write") {
-      throw new ZuoraAgentToolkitError({
-        code: "TOOL_EXECUTION_ERROR",
-        message: `Write tool "${operationName}" is disabled in readOnly mode.`,
-        category: "tool_execution"
-      });
-    }
     const nativeRuntimeTool = this.nativeToolRegistry?.get(operationName);
     const nativeApprovalMetadata = nativeRuntimeTool?.approvalMetadata(input);
     const invokedOperation = tool2.meta.operationSelector ? String(input[tool2.meta.operationSelector] ?? "") : void 0;
     const effectiveAccess = (invokedOperation ? tool2.meta.operationAccess?.[invokedOperation] : void 0) ?? tool2.meta.access;
     const effectiveRiskLevel = (invokedOperation ? tool2.meta.operationRiskLevel?.[invokedOperation] : void 0) ?? tool2.meta.riskLevel;
+    if (mode === SafetyMode.ReadOnly && effectiveAccess === "write") {
+      throw new ZuoraAgentToolkitError({
+        code: "TOOL_EXECUTION_ERROR",
+        message: `Write operation "${invokedOperation ?? operationName}" is disabled in readOnly mode.`,
+        category: "tool_execution"
+      });
+    }
     const effectiveTool = effectiveAccess === tool2.meta.access && effectiveRiskLevel === tool2.meta.riskLevel ? tool2 : { ...tool2, meta: { ...tool2.meta, access: effectiveAccess, riskLevel: effectiveRiskLevel } };
     await enforceApproval(
       effectiveTool,
@@ -4975,6 +4984,79 @@ var strictifySchema = (schema) => {
 
 // src/openai-agents/toolkit.ts
 var ZuoraOpenAIAgentsToolkit = class extends ToolkitCore {
+  /** Maps sanitized adapter tool names back to their original ZuoraToolDefinition. */
+  sanitizedToolMap = /* @__PURE__ */ new Map();
+  /**
+   * Look up a ZuoraToolDefinition by its sanitized adapter tool name.
+   *
+   * The OpenAI Agents SDK registers tools with sanitized names (see convertTools),
+   * but external code may reference tools by their original MCP names. This method
+   * provides resolution in both directions.
+   */
+  resolveToolName(name) {
+    if (this.sanitizedToolMap.has(name)) {
+      return name;
+    }
+    for (const [sanitized, def] of this.sanitizedToolMap) {
+      if (def.name === name) {
+        return sanitized;
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Resolve a tool name that may be either sanitized or original MCP format.
+   *
+   * This provides additional name normalization to handle cases where:
+   * - A tool name contains unsanitized characters (like dots)
+   * - A tool name was learned from descriptions or logs
+   *
+   * We attempt to find a match with relaxed sanitization rules before giving up.
+   */
+  normalizeToolName(name) {
+    const directMatch = this.resolveToolName(name);
+    if (directMatch) {
+      return directMatch;
+    }
+    const normalized = name.replace(/\./g, "_");
+    const normalizedMatch = this.resolveToolName(normalized);
+    if (normalizedMatch) {
+      return normalizedMatch;
+    }
+    for (const [sanitized, def] of this.sanitizedToolMap) {
+      if (def.name === normalized) {
+        return sanitized;
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Override callTool to provide flexible name resolution.
+   *
+   * The OpenAI Agents SDK may receive tool calls with names that were learned
+   * from descriptions or other sources (not directly from tool registration).
+   * This override allows us to handle both sanitized and original tool names
+   * by falling back to name normalization when the direct lookup fails.
+   */
+  async callTool(operationName, input) {
+    try {
+      return await super.callTool(operationName, input);
+    } catch (error) {
+      if (error instanceof Error && (error.message.includes("Unknown Zuora tool") || error.message.includes("TOOL_NOT_FOUND"))) {
+        const sanitized = this.normalizeToolName(operationName);
+        if (sanitized) {
+          const def = this.sanitizedToolMap.get(sanitized);
+          if (def) {
+            console.warn(
+              `[zuora-agent-toolkit] Tool name normalized: "${operationName}" -> "${def.name}" (sanitized: "${sanitized}")`
+            );
+            return await super.callTool(def.name, input);
+          }
+        }
+      }
+      throw error;
+    }
+  }
   /**
    * Serialises the agent tool response, emits an `agent.tool.response`
    * observability event (with the response in `metadata` when
@@ -4998,6 +5080,7 @@ var ZuoraOpenAIAgentsToolkit = class extends ToolkitCore {
   convertTools(tools) {
     return tools.map((def) => {
       const sanitizedName = sanitizeAdapterToolName(def.name);
+      this.sanitizedToolMap.set(sanitizedName, def);
       return tool({
         name: sanitizedName,
         description: def.description,