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

package/dist/openai/index.d.ts

@@ -1,7 +1,7 @@
-import { Z as ZuoraOpenAIAgentToolkit } from '../toolkit-CafRZuAV.js';
-export { c as createZuoraOpenAIAgentToolkit } from '../toolkit-CafRZuAV.js';
+import { Z as ZuoraOpenAIAgentToolkit } from '../toolkit-Bjw46goJ.js';
+export { c as createZuoraOpenAIAgentToolkit } from '../toolkit-Bjw46goJ.js';
 import { ChatCompletion, ChatCompletionToolMessageParam } from 'openai/resources/chat/completions';
-import { b as ZuoraToolExecutionResult, Z as ZuoraToolDefinition, c as ZuoraAsyncJobResult } from '../async-jobs-Dd8Jafv0.js';
+import { b as ZuoraToolExecutionResult, Z as ZuoraToolDefinition, c as ZuoraAsyncJobResult } from '../async-jobs-DJ_GygII.js';
 import '../shared/toolkit-core.js';
 
 type ZuoraOpenAIToolExecutionContext = {

package/dist/openai/index.js

@@ -19,6 +19,10 @@ var ZuoraAgentToolkitError = class extends Error {
 };
 
 // src/shared/types.ts
+var SafetyMode = {
+  ReadOnly: "readOnly",
+  WriteEnabled: "writeEnabled"
+};
 var ApprovalPolicyPreset = {
   Off: "off",
   AllWrites: "all_writes",
@@ -114,15 +118,15 @@ var evaluatePreset = (preset, request) => {
   const isProduction = environment === "production";
   switch (preset) {
     case ApprovalPolicyPreset.Off:
-      return "not_required";
+      return "allow";
     case ApprovalPolicyPreset.AllWrites:
-      return isWrite ? "deny" : "not_required";
+      return isWrite ? "deny" : "allow";
     case ApprovalPolicyPreset.HighRisk:
-      return isHighRisk ? "deny" : "not_required";
+      return isHighRisk ? "deny" : "allow";
     case ApprovalPolicyPreset.ProductionWrites:
-      return isProduction && isWrite ? "deny" : "not_required";
+      return isProduction && isWrite ? "deny" : "allow";
     case ApprovalPolicyPreset.ProductionHighRisk:
-      return isProduction && isHighRisk ? "deny" : "not_required";
+      return isProduction && isHighRisk ? "deny" : "allow";
   }
 };
 var throwApprovalRejected = (tool) => {
@@ -2590,26 +2594,11 @@ var readEnvAllowedHosts = () => {
   const hosts = raw.split(",").map((host) => host.trim()).filter(Boolean);
   return hosts.length > 0 ? hosts : void 0;
 };
-var isQueryBundleConfigured = (configuration) => {
-  const bundles = configuration?.bundles;
-  if (!bundles) {
-    return false;
-  }
-  const query = bundles.query;
-  if (query === true) {
-    return true;
-  }
-  return typeof query === "object" && query !== null;
-};
 var resolveNativeFileToolsInput = (config) => {
   const explicit = config.nativeFileTools;
   if (explicit?.enabled === false) {
     return { enabled: false };
   }
-  const autoEnable = isQueryBundleConfigured(config.configuration);
-  if (!autoEnable && explicit?.enabled !== true) {
-    return explicit;
-  }
   const rootDir = nonEmptyString(explicit?.rootDir) ?? nonEmptyString(process.env["ZUORA_NATIVE_FILE_ROOT"]) ?? DEFAULT_NATIVE_ARTIFACT_ROOT;
   const allowedHosts = explicit?.allowedHosts ?? readEnvAllowedHosts() ?? DEFAULT_NATIVE_ALLOWED_HOSTS;
   return {
@@ -3480,21 +3469,10 @@ var OAuthTokenProvider = class {
         category: "auth"
       });
     }
-    if (this.config.auth.type === "accessToken" && this.config.auth.accessToken) {
-      this.accessToken = this.config.auth.accessToken;
-      return this.config.auth.accessToken;
-    }
     const now = Date.now();
     if (this.accessToken && this.isAccessTokenFresh(now)) {
       return this.accessToken;
     }
-    if (this.config.auth.type !== "oauthClientCredentials") {
-      throw new ZuoraAgentToolkitError({
-        code: "UNSUPPORTED_AUTH",
-        message: "Unsupported auth configuration for Zuora HTTP MCP client.",
-        category: "auth"
-      });
-    }
     const token = await this.fetchOAuthToken();
     this.accessToken = token.access_token;
     this.tokenIssuedAt = now;
@@ -3513,10 +3491,8 @@ var OAuthTokenProvider = class {
   sensitiveValues() {
     const values = [this.accessToken];
     const auth = this.config.auth;
-    if (auth?.type === "oauthClientCredentials") {
+    if (auth?.clientSecret) {
       values.push(auth.clientSecret);
-    } else if (auth?.type === "accessToken") {
-      values.push(auth.accessToken);
     }
     return values.filter(
       (value) => typeof value === "string" && value.length > 0
@@ -3580,11 +3556,8 @@ var OAuthTokenProvider = class {
     });
   }
   async resolveTokenEndpoints() {
-    if (this.config.tokenEndpoint) {
-      return [this.config.tokenEndpoint];
-    }
     const restEndpoint = `${this.restBaseUrl}/oauth/token`;
-    const oneIdEndpoint = await this.resolveOneIdTokenEndpoint();
+    const oneIdEndpoint = isStagingZuoraBaseUrl(this.restBaseUrl) ? "https://one.stg.na.zuora.com/oauth2/token" : "https://one.zuora.com/oauth2/token";
     const endpoints = [restEndpoint, oneIdEndpoint];
     const uniqueEndpoints = [...new Set(endpoints)];
     if (!this.preferredTokenEndpoint) {
@@ -3597,29 +3570,8 @@ var OAuthTokenProvider = class {
       )
     ];
   }
-  async resolveOneIdTokenEndpoint() {
-    const fallback = isStagingZuoraBaseUrl(this.restBaseUrl) ? "https://one.stg.na.zuora.com/oauth2/token" : "https://one.zuora.com/oauth2/token";
-    try {
-      return await this.discoverTokenEndpoint() ?? fallback;
-    } catch {
-      return fallback;
-    }
-  }
-  async discoverTokenEndpoint() {
-    const metadataUrl = new URL(this.restBaseUrl);
-    metadataUrl.pathname = "/.well-known/oauth-authorization-server";
-    metadataUrl.search = "";
-    const response = await fetch(metadataUrl, {
-      headers: { accept: "application/json" }
-    });
-    if (!response.ok) {
-      return void 0;
-    }
-    const metadata = await response.json().catch(() => ({}));
-    return metadata.token_endpoint;
-  }
   async requestOAuthToken(tokenEndpoint) {
-    if (!this.config.auth || this.config.auth.type !== "oauthClientCredentials") {
+    if (!this.config.auth) {
       throw new ZuoraAgentToolkitError({
         code: "UNSUPPORTED_AUTH",
         message: "Unsupported auth configuration for Zuora HTTP MCP client.",
@@ -3632,17 +3584,8 @@ var OAuthTokenProvider = class {
       accept: "application/json"
     };
     const auth = this.config.auth;
-    if (this.config.tokenAuthMethod === "client_secret_basic") {
-      headers.authorization = `Basic ${base64Encode(
-        `${auth.clientId}:${auth.clientSecret}`
-      )}`;
-    } else {
-      body.set("client_id", auth.clientId);
-      body.set("client_secret", auth.clientSecret);
-    }
-    if (auth.scope) {
-      body.set("scope", auth.scope);
-    }
+    body.set("client_id", auth.clientId);
+    body.set("client_secret", auth.clientSecret);
     const response = await fetch(tokenEndpoint, {
       method: "POST",
       headers,
@@ -3684,7 +3627,6 @@ var extractTenantId = (scope) => {
   const tenantMatch = scope?.match(/tenant\.(\d+)/);
   return tenantMatch?.[1];
 };
-var base64Encode = (value) => Buffer.from(value).toString("base64");
 
 // src/shared/transport/request-headers.ts
 var RESERVED_HEADER_NAMES = /* @__PURE__ */ new Set([
@@ -3756,10 +3698,8 @@ var resolveZuoraConnectionConfig = (config, mcpUrl) => ({
   clientName: config.clientName ?? "zuora-agent-toolkit",
   clientVersion: config.clientVersion ?? "0.1.0",
   protocolVersion: config.protocolVersion ?? "2025-03-26",
-  tokenAuthMethod: config.tokenAuthMethod ?? "client_secret_post",
   url: mcpUrl,
   ...config.auth ? { auth: config.auth } : {},
-  ...config.tokenEndpoint ? { tokenEndpoint: config.tokenEndpoint } : {},
   ...config.headers ? { headers: config.headers } : {},
   ...config.tenantAuth ? { tenantAuth: config.tenantAuth } : {},
   ...config.entityIds ? { entityIds: config.entityIds } : {},
@@ -3940,7 +3880,7 @@ var resolveToolSelectionPolicy = (configuration, selection) => ({
     ...selection?.exclude ?? []
   ])
 });
-var resolveToolMode = (configuration, selection) => selection?.mode ?? configuration?.mode ?? "readOnly";
+var resolveToolMode = (configuration, selection) => selection?.mode ?? configuration?.mode ?? SafetyMode.ReadOnly;
 var resolveExcludedToolNames = (configuration) => /* @__PURE__ */ new Set([
   ...resolveConfiguredExcludedToolNames(configuration),
   ...resolveBundleExcludedToolNames(configuration)
@@ -4202,11 +4142,19 @@ var ZuoraHttpMcpClient = class _ZuoraHttpMcpClient extends ZuoraClient {
 
 // src/shared/toolkit-core.ts
 var createHttpMcpClientConfig = (config) => {
-  if (isTenantAuthConnection(config.connection)) {
+  const contextEntityIds = config.configuration?.context?.entityIds;
+  const contextOrgIds = config.configuration?.context?.orgIds;
+  const contextOverrides = {
+    ...contextEntityIds ? { entityIds: contextEntityIds } : {},
+    ...contextOrgIds ? { orgIds: contextOrgIds } : {}
+  };
+  const connection = "connection" in config ? config.connection : void 0;
+  if (isTenantAuthConnection(connection)) {
     return {
       url: config.baseUrl,
       ...config.auth ? { auth: config.auth } : {},
-      ...config.connection
+      ...connection,
+      ...contextOverrides
     };
   }
   if (!config.auth) {
@@ -4219,13 +4167,23 @@ var createHttpMcpClientConfig = (config) => {
   return {
     url: config.baseUrl,
     auth: config.auth,
-    ...config.connection
+    ...connection ?? {},
+    ...contextOverrides
   };
 };
 var isTenantAuthConnection = (connection) => connection?.tenantAuth?.enabled === true;
 var filterCatalogTools = (tools, policy) => tools.filter((tool) => {
-  if (policy.mode === "readOnly" && tool.meta.access === "write") {
-    return false;
+  if (policy.mode === SafetyMode.ReadOnly) {
+    if (tool.meta.operationAccess) {
+      const hasReadOperation = Object.values(tool.meta.operationAccess).some(
+        (access) => access === "read"
+      );
+      if (!hasReadOperation) {
+        return false;
+      }
+    } else if (tool.meta.access === "write") {
+      return false;
+    }
   }
   if (policy.bundles.size > 0 && !policy.bundles.has(tool.meta.bundle)) {
     return false;
@@ -4386,19 +4344,19 @@ var ToolkitCore = class {
         category: "configuration"
       });
     }
-    const mode = this.config.configuration?.mode ?? "readOnly";
-    if (mode === "readOnly" && tool.meta.access === "write") {
-      throw new ZuoraAgentToolkitError({
-        code: "TOOL_EXECUTION_ERROR",
-        message: `Write tool "${operationName}" is disabled in readOnly mode.`,
-        category: "tool_execution"
-      });
-    }
+    const mode = this.config.configuration?.mode ?? SafetyMode.ReadOnly;
     const nativeRuntimeTool = this.nativeToolRegistry?.get(operationName);
     const nativeApprovalMetadata = nativeRuntimeTool?.approvalMetadata(input);
     const invokedOperation = tool.meta.operationSelector ? String(input[tool.meta.operationSelector] ?? "") : void 0;
     const effectiveAccess = (invokedOperation ? tool.meta.operationAccess?.[invokedOperation] : void 0) ?? tool.meta.access;
     const effectiveRiskLevel = (invokedOperation ? tool.meta.operationRiskLevel?.[invokedOperation] : void 0) ?? tool.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 === tool.meta.access && effectiveRiskLevel === tool.meta.riskLevel ? tool : { ...tool, meta: { ...tool.meta, access: effectiveAccess, riskLevel: effectiveRiskLevel } };
     await enforceApproval(
       effectiveTool,
@@ -4632,7 +4590,7 @@ var ToolkitCore = class {
     return this.catalogTools ?? [];
   }
   resolveSplitOperations() {
-    return this.config.configuration?.splitOperations ?? true;
+    return this.config.configuration?.splitOperations ?? false;
   }
   warnIfNotInitialized() {
     if (!this._initialized) {
@@ -4701,13 +4659,11 @@ var ToolkitCore = class {
   }
   createEventContext() {
     const configurationContext = this.config.configuration?.context ?? {};
-    const tenantId = nonEmptyString(configurationContext.tenantId) ?? nonEmptyString(configurationContext.tenant_id);
     const entityIds = normalizeIdList(configurationContext.entityIds) ?? normalizeIdList(configurationContext.entityId);
     const orgIds = normalizeIdList(configurationContext.orgIds) ?? normalizeIdList(configurationContext.orgId);
     const environment = inferZuoraEnvironment(this.config.baseUrl) ?? "sandbox";
     return {
       environment,
-      ...tenantId ? { tenantId } : {},
       ...entityIds ? { entityIds } : {},
       ...orgIds ? { orgIds } : {}
     };
@@ -4799,51 +4755,21 @@ var readBooleanEnvValue = (name, rawValue) => {
 var readBooleanEnv = (env, name) => readBooleanEnvValue(name, env[name]);
 var readZuoraEndpoint = (env) => readTrimmedEnv(env, "ZUORA_BASE_URL") ?? readTrimmedEnv(env, "ZUORA_MCP_URL");
 var readToolkitMode = (env) => {
-  const mode = env.ZUORA_TOOLKIT_MODE?.trim() ?? "readOnly";
-  if (mode === "readOnly" || mode === "writeEnabled") {
+  const mode = env.ZUORA_TOOLKIT_MODE?.trim() ?? SafetyMode.ReadOnly;
+  if (mode === SafetyMode.ReadOnly || mode === SafetyMode.WriteEnabled) {
     return mode;
   }
   throw new Error(
-    `Invalid ZUORA_TOOLKIT_MODE: ${mode}. Expected readOnly or writeEnabled.`
-  );
-};
-var readOptionalUrlEnv = (env, name) => {
-  const value = readTrimmedEnv(env, name);
-  if (!value) {
-    return void 0;
-  }
-  try {
-    const url = new URL(value);
-    if (url.protocol === "http:" || url.protocol === "https:") {
-      return url.toString();
-    }
-  } catch {
-  }
-  throw new Error(`${name} must be an absolute HTTP(S) URL.`);
-};
-var readTokenAuthMethodEnv = (env) => {
-  const value = readTrimmedEnv(env, "ZUORA_TOKEN_AUTH_METHOD");
-  if (!value) {
-    return void 0;
-  }
-  if (value === "client_secret_post" || value === "client_secret_basic") {
-    return value;
-  }
-  throw new Error(
-    "Invalid ZUORA_TOKEN_AUTH_METHOD: expected client_secret_post or client_secret_basic."
+    `Invalid ZUORA_TOOLKIT_MODE: ${mode}. Expected ${SafetyMode.ReadOnly} or ${SafetyMode.WriteEnabled}.`
   );
 };
 var readConnectionOptions = (env) => {
-  const tokenEndpoint = readOptionalUrlEnv(env, "ZUORA_TOKEN_ENDPOINT");
-  const tokenAuthMethod = readTokenAuthMethodEnv(env);
   const entityIds = readTrimmedEnv(env, "ZUORA_ENTITY_IDS");
   const orgIds = readTrimmedEnv(env, "ZUORA_ORG_IDS");
   const zuoraVersion = readTrimmedEnv(env, "ZUORA_VERSION");
   return {
     ...entityIds ? { entityIds } : {},
     ...orgIds ? { orgIds } : {},
-    ...tokenEndpoint ? { tokenEndpoint } : {},
-    ...tokenAuthMethod ? { tokenAuthMethod } : {},
     ...zuoraVersion ? { zuoraVersion } : {}
   };
 };
@@ -4868,28 +4794,19 @@ var zuoraAgentToolkitConfigFromEnv = (env = process.env) => {
         }
       },
       configuration: {
-        mode,
-        context: {
-          tenantId
-        }
+        mode
       }
     };
   }
   return {
     baseUrl,
     auth: {
-      type: "oauthClientCredentials",
       clientId: requiredEnv(env, "ZUORA_CLIENT_ID"),
       clientSecret: requiredEnv(env, "ZUORA_CLIENT_SECRET")
     },
     ...Object.keys(connection).length > 0 ? { connection } : {},
     configuration: {
-      mode,
-      ...readTrimmedEnv(env, "ZUORA_TENANT_ID") ? {
-        context: {
-          tenantId: readTrimmedEnv(env, "ZUORA_TENANT_ID")
-        }
-      } : {}
+      mode
     }
   };
 };