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

package/README.md

@@ -6,18 +6,38 @@ Zuora billing operations as callable tools for AI agent frameworks.
 
 Built on the [Zuora MCP server](https://developer.zuora.com). Tool inventory is discovered at runtime from your tenant's MCP endpoint — it is not hardcoded in this package.
 
+## Quick start
+
+```ts
+import { Agent, run } from "@openai/agents";
+import { createZuoraOpenAIAgentsToolkit } from "@zuora/agent-toolkit/openai-agents";
+
+const toolkit = await createZuoraOpenAIAgentsToolkit({ env: true });
+try {
+  const agent = new Agent({ name: "Billing Agent", tools: await toolkit.getTools() });
+  const result = await run(agent, "How many active accounts do we have?");
+  console.log(result.finalOutput);
+} finally {
+  await toolkit.close();
+}
+```
+
+Set `ZUORA_BASE_URL`, `ZUORA_CLIENT_ID`, and `ZUORA_CLIENT_SECRET` in your environment. See [Credentials](#credentials) for other auth options.
+
 ## Adapter status
 
 | Subpath | Factory | Status |
 |---|---|---|
 | `@zuora/agent-toolkit/openai` | `createZuoraOpenAIAgentToolkit` | ✅ Implemented |
 | `@zuora/agent-toolkit/openai-agents` | `createZuoraOpenAIAgentsToolkit` | ✅ Implemented |
-| `@zuora/agent-toolkit/langchain` | — | 🚧 Coming soon |
-| `@zuora/agent-toolkit/vercel-ai` | — | 🚧 Coming soon |
+| `@zuora/agent-toolkit/langchain` | `createZuoraLangChainToolkit` | ✅ Implemented |
+| `@zuora/agent-toolkit/vercel-ai` | `createZuoraVercelAIToolkit` | ✅ Implemented |
 | `@zuora/agent-toolkit/mcp` | — | 🚧 Coming soon |
 
 ## Installation
 
+Requires **Node.js 18** or later.
+
 ```bash
 npm install @zuora/agent-toolkit
 ```
@@ -25,52 +45,165 @@ npm install @zuora/agent-toolkit
 Framework packages are peer dependencies — install only what you use:
 
 ```bash
-# OpenAI Chat Completions
+# OpenAI Chat Completions (requires openai >=4)
 npm install openai
 
-# OpenAI Agents SDK
+# OpenAI Agents SDK (requires @openai/agents >=0.13)
 npm install @openai/agents
+
+# LangChain (requires @langchain/core >=1.2.1)
+npm install @langchain/core @langchain/langgraph @langchain/openai
+
+# Vercel AI SDK (requires ai >=7 — v7 is a breaking rewrite from v6)
+npm install ai @ai-sdk/openai
 ```
 
+> **Version notes**
+> - **Vercel AI SDK** — `ai >=7` is required. v7 introduced `ToolSet`, `isStepCount`, and `jsonSchema()`, which this adapter depends on. v6 is **not** compatible.
+> - **LangChain** — `@langchain/core >=1.2.1` is required for `DynamicStructuredTool` and JSON Schema parameter support.
+> - `@langchain/langgraph` and `@langchain/openai` are not direct peer dependencies but are needed to run the agent (see examples).
+
 ## Credentials
 
-The toolkit authenticates against Zuora using OAuth 2.0 client credentials. You need:
+Pass `env: true` to read credentials from the environment automatically:
+
+| Variable | Purpose |
+|---|---|
+| `ZUORA_BASE_URL` | Tenant REST API endpoint (required) |
+| `ZUORA_CLIENT_ID` / `ZUORA_CLIENT_SECRET` | OAuth credentials (required) |
+| `ZUORA_TOOLKIT_MODE` | `readOnly` (default) or `writeEnabled` |
+
+`ZUORA_TOOLKIT_MODE` is only read when `env: true` is set, and is overridden by an explicit `configuration.mode`.
+
+You can also pass credentials explicitly:
 
-- `ZUORA_BASE_URL` — your Zuora tenant REST API base URL (e.g. `https://rest.apisandbox.zuora.com`)
-- `ZUORA_CLIENT_ID` — OAuth client ID
-- `ZUORA_CLIENT_SECRET` — OAuth client secret
+```ts
+import { SafetyMode } from "@zuora/agent-toolkit";
+
+const toolkit = await createZuoraOpenAIAgentToolkit({
+  baseUrl: process.env.ZUORA_BASE_URL!,
+  auth: {
+    clientId: process.env.ZUORA_CLIENT_ID!,
+    clientSecret: process.env.ZUORA_CLIENT_SECRET!,
+  },
+  configuration: { mode: SafetyMode.ReadOnly },
+});
+```
+
+`env: true` reads only credentials and base URL from the environment — all other config fields (`configuration`, `approvalPolicy`, `observability`, etc.) can still be set explicitly alongside it.
 
 **Use a client scoped to the minimum permissions your agent needs.** Never use admin credentials.
 
 ## Usage
 
+> **Which OpenAI adapter should I use?**
+> - Use `@zuora/agent-toolkit/openai-agents` + `createZuoraOpenAIAgentsToolkit` if you are building with the **`@openai/agents` library** (the higher-level agent runtime).
+> - Use `@zuora/agent-toolkit/openai` + `createZuoraOpenAIAgentToolkit` if you are using the **raw `openai` Chat Completions API** and managing the tool-call loop yourself.
+
 ### OpenAI Agents SDK
 
 ```ts
 import { Agent, run } from "@openai/agents";
+import { SafetyMode } from "@zuora/agent-toolkit";
 import { createZuoraOpenAIAgentsToolkit } from "@zuora/agent-toolkit/openai-agents";
 
 const toolkit = await createZuoraOpenAIAgentsToolkit({
   env: true,
-  configuration: { mode: "readOnly", bundles: { query: true } },
+  configuration: { mode: SafetyMode.ReadOnly },
 });
 
-const tools = await toolkit.getTools({ bundles: ["query"] });
+// Scope to specific bundles and cap tool count — improves model accuracy
+const tools = (await toolkit.getTools({ bundles: ["accounts", "query"] })).slice(0, 50);
 const agent = new Agent({ name: "Billing Agent", tools });
 const result = await run(agent, "How many active billing accounts do we have?");
 
 await toolkit.close();
 ```
 
-If you already have a Chat Completions toolkit, you can bridge it with `buildAgentsTools`:
+If you already have a `ZuoraOpenAIAgentToolkit` instance (for example, shared across multiple agents or reused from an existing integration), you can convert its tools to Agents SDK format without opening a second MCP connection:
 
 ```ts
 import { buildAgentsTools } from "@zuora/agent-toolkit/openai-agents";
-import { createZuoraOpenAIAgentToolkit } from "@zuora/agent-toolkit/openai";
 import { tool } from "@openai/agents";
 
-const chatToolkit = await createZuoraOpenAIAgentToolkit({ env: true });
+// `tool` is passed in rather than imported directly so @openai/agents stays
+// an optional peer dependency and the module loads without it installed.
 const tools = await buildAgentsTools(tool, chatToolkit, { bundles: ["query"] });
+const agent = new Agent({ name: "Billing Agent", tools });
+await run(agent, "...");
+// chatToolkit must stay open while tools are in use — close it when done
+```
+
+> If you are starting fresh (no existing toolkit), prefer `createZuoraOpenAIAgentsToolkit` directly — it handles the connection internally.
+
+### LangChain
+
+```ts
+import { ChatOpenAI } from "@langchain/openai";
+import { createReactAgent } from "@langchain/langgraph/prebuilt";
+import { SafetyMode } from "@zuora/agent-toolkit";
+import { createZuoraLangChainToolkit } from "@zuora/agent-toolkit/langchain";
+
+const toolkit = await createZuoraLangChainToolkit({
+  env: true,
+  configuration: { mode: SafetyMode.ReadOnly },
+});
+
+// Scope to specific bundles and cap tool count — improves model accuracy
+const tools = (await toolkit.getTools({ bundles: ["accounts", "query"] })).slice(0, 50);
+
+const agent = createReactAgent({
+  llm: new ChatOpenAI({ model: "gpt-4o" }),
+  tools,
+});
+
+// LangChain owns the tool-call loop — no manual dispatch needed
+const result = await agent.invoke({
+  messages: [{ role: "user", content: "List 3 active accounts" }],
+});
+
+const answer = result.messages.at(-1)?.content;
+console.log(typeof answer === "string" ? answer : JSON.stringify(answer));
+
+await toolkit.close();
+```
+
+### Vercel AI SDK
+
+> `getToolSet()` returns a `ToolSet` (`Record<string, Tool>`) — the format `streamText` and `generateText` require. All other adapters use `getTools()` which returns an array.
+
+```ts
+import { openai } from "@ai-sdk/openai";
+import { streamText, isStepCount } from "ai";
+import { SafetyMode } from "@zuora/agent-toolkit";
+import { createZuoraVercelAIToolkit } from "@zuora/agent-toolkit/vercel-ai";
+
+const toolkit = await createZuoraVercelAIToolkit({
+  env: true,
+  configuration: { mode: SafetyMode.ReadOnly },
+});
+
+// `getToolSet()` returns a ToolSet (`Record<string, Tool>`) rather than an array,
+// so `.slice()` is not available — the second argument is the only way to cap tool count.
+// Omit it to return all matching tools.
+const tools = await toolkit.getToolSet(
+  { bundles: ["accounts", "query"] },
+  50,
+);
+
+const { textStream } = streamText({
+  model: openai("gpt-4o"),
+  tools,
+  stopWhen: isStepCount(20), // SDK drives the tool-call loop — no manual dispatch needed
+  messages: [{ role: "user", content: "List 3 active accounts" }],
+});
+
+for await (const chunk of textStream) {
+  process.stdout.write(chunk);
+}
+console.log();
+
+await toolkit.close();
 ```
 
 ### OpenAI Chat Completions
@@ -81,10 +214,11 @@ import {
   createZuoraOpenAIAgentToolkit,
   handleToolCalls,
 } from "@zuora/agent-toolkit/openai";
+import { SafetyMode } from "@zuora/agent-toolkit";
 
 const toolkit = await createZuoraOpenAIAgentToolkit({
   env: true,
-  configuration: { mode: "readOnly" },
+  configuration: { mode: SafetyMode.ReadOnly },
 });
 
 const client = new OpenAI();
@@ -105,6 +239,8 @@ for (let step = 0; step < 20; step++) {
   messages.push(choice.message);
 
   if (choice.finish_reason === "tool_calls") {
+    // handleToolCalls returns { messages, abortTurn, requireToolOnNextStep, followUpToolNames }.
+    // For basic loops, only `messages` is needed. See examples/openai/hitl.ts for advanced usage.
     const { messages: toolMessages } = await handleToolCalls({ toolkit, response });
     messages.push(...toolMessages);
     continue;
@@ -119,13 +255,33 @@ await toolkit.close();
 
 ## Configuration
 
+Top-level config shape — all fields except credentials are optional:
+
+```ts
+{
+  env: true,                      // reads ZUORA_BASE_URL, ZUORA_CLIENT_ID, ZUORA_CLIENT_SECRET
+  configuration: {                // tool filtering, safety, and routing
+    mode: SafetyMode.ReadOnly,
+    bundles: { accounts: true },
+    context: {                    // scopes operations to the specified entity / org
+      entityIds: "entity-1",     // → Zuora-Entity-Ids header
+      orgIds: "org-1",           // → Zuora-Org-Ids header
+    },
+  },
+  // approvalPolicy: …           // see "Approval policy" section below
+  observability: {                // optional: events and logging
+    onEvent: (event) => { … },
+  },
+}
+```
+
 ### Safety modes
 
 ```ts
 configuration: {
-  mode: "readOnly",      // only read operations (default)
+  mode: SafetyMode.ReadOnly,      // only read operations (default)
   // or
-  mode: "writeEnabled",  // read + write operations
+  mode: SafetyMode.WriteEnabled,  // read + write operations
 }
 ```
 
@@ -143,96 +299,125 @@ configuration: {
 }
 ```
 
-Available bundles: `accounts`, `catalog`, `subscriptions`, `orders`, `billing`, `payments`, `usage`, `revenue`, `finance`, `workflows`, `query`, `admin`, `files`.
+Available bundles: `accounts`, `catalog`, `subscriptions`, `orders`, `billing`, `payments`, `usage`, `revenue`, `finance`, `workflows`, `query`, `admin`, `files`. Which bundles are available depends on your Zuora tenant's MCP endpoint.
+
+You can also filter at call time via `getTools()`. Note that `configuration.bundles` uses an object (`{ accounts: true }`) and is fixed at toolkit creation time; `getTools({ bundles: [...] })` uses an array and filters the already-loaded catalog at call time.
+
+```ts
+// Filter by bundle
+toolkit.getTools({ bundles: ["accounts", "query"] })
 
-You can also filter at call time via `getTools({ bundles, include, exclude, mode })`.
+// Include or exclude specific tools by exact name
+toolkit.getTools({ include: ["get_account", "list_accounts"] })
+toolkit.getTools({ exclude: ["delete_account"] })
+
+// Narrow to write-enabled tools for this call only (per-call mode overrides global config)
+toolkit.getTools({ mode: SafetyMode.WriteEnabled })
+```
 
 ### Exclude / include specific tools
 
+`configuration.bundles.billing.exclude` is evaluated once at toolkit creation and applies permanently to that bundle. `getTools({ exclude })` filters the already-loaded catalog on each call and works across all bundles.
+
+`include` and `exclude` can be combined: `include` acts as an allowlist first, then `exclude` removes from that set. A tool passes if it matches `include` (when set) **and** is not in `exclude`.
+
 ```ts
 configuration: {
   bundles: {
     billing: {
       exclude: ["create_invoice", "delete_invoice"],
-      // or include: ["list_invoices"]
+      // or use include to allowlist specific tools: include: ["list_invoices"]
+      // or combine both: include: ["run_reports", "list_invoices"], exclude: ["delete_billing_run"]
     },
   },
 }
 ```
 
-### Split operations
+### Enabling or disabling individual tools
+
+To enable or disable specific tools without affecting their entire bundle:
 
-Multi-operation MCP tools are split into per-operation tools by default (`splitOperations: true`), producing names like `manage_data_queries__submit_query`. Set `splitOperations: false` to keep merged tools.
+```ts
+configuration: {
+  tools: {
+    "delete_invoice": false,   // disable one tool
+    "run_reports": true,       // explicitly enable (useful when a bundle is partially restricted)
+  },
+}
+```
 
 ### Approval policy
 
 Gate write / high-risk operations before they reach Zuora. `approvalPolicy` is a **top-level** config field (not inside `configuration`):
 
 ```ts
-import { ApprovalPolicyPreset } from "@zuora/agent-toolkit";
+import { ApprovalPolicyPreset, SafetyMode } from "@zuora/agent-toolkit";
 
 const toolkit = await createZuoraOpenAIAgentToolkit({
   env: true,
-  configuration: { mode: "writeEnabled" },
+  configuration: { mode: SafetyMode.WriteEnabled },
   approvalPolicy: ApprovalPolicyPreset.HighRisk,
   // or a custom handler:
   // approvalPolicy: async (request) => {
   //   if (request.tool.meta.riskLevel === "high") return "deny";
-  //   return "not_required";
+  //   return "allow";
   // },
 });
 ```
 
 Presets: `Off`, `AllWrites`, `HighRisk`, `ProductionWrites`, `ProductionHighRisk`.
 
-### Context defaults
+Custom handler return values: `"allow"` (proceed) · `"deny"` (block) · `{ decision: "allow" | "deny", reason?: string }` (with an explanation added to the rejection error).
+
+### Context
 
-Pass optional string context keys (for example tenant or entity identifiers) via `configuration.context`. Connection-level `entityIds` / `orgIds` arrays live on `connection` instead:
+Pass routing and observability identifiers via `configuration.context`. All values are strings — use comma-separation for multiple IDs:
+
+| Key | Effect |
+|---|---|
+| `entityIds` | Forwarded as `Zuora-Entity-Ids` to scope operations to the specified entity |
+| `orgIds` | Forwarded as `Zuora-Org-Ids` to scope operations to the specified org |
 
 ```ts
-configuration: {
-  context: {
-    tenantId: "…",
+const toolkit = await createZuoraOpenAIAgentToolkit({
+  env: true,
+  configuration: {
+    mode: SafetyMode.WriteEnabled,
+    context: {
+      entityIds: "entity-1,entity-2",  // comma-separated for multiple
+      orgIds: "org-1",
+    },
   },
-},
-connection: {
-  entityIds: ["entity-1"],
-  orgIds: ["org-1"],
-},
+});
 ```
 
 ### Observability
 
 ```ts
 observability: {
-  onEvent: (event) => { /* tool.called, tool.completed, approval.*, … */ },
+  onEvent: (event) => { /* synchronous observer */ },
+  emit: async (event) => { /* async sink — await is respected */ },
   logger: { info: console.info, warn: console.warn, error: console.error },
-  includePayloads: false, // default; set true to include sanitized I/O
+  includePayloads: false, // default; set true to include tool input keys and
+                          // truncated values in events — secrets are redacted
 }
 ```
 
-## Environment variable config
-
-Pass `env: true` to read credentials from the environment automatically:
+Emitted event names:
 
-```ts
-const toolkit = await createZuoraOpenAIAgentToolkit({
-  env: true,
-  configuration: { mode: "readOnly" },
-});
-```
-
-| Variable | Purpose |
+| Event | When |
 |---|---|
-| `ZUORA_BASE_URL` or `ZUORA_MCP_URL` | Endpoint (required) |
-| `ZUORA_CLIENT_ID` / `ZUORA_CLIENT_SECRET` | OAuth credentials |
-| `ZUORA_TOOLKIT_MODE` | `readOnly` (default) or `writeEnabled` |
-
-You can still pass `baseUrl` + `auth` explicitly instead of `env: true`.
+| `tool.called` | Tool invocation starts |
+| `tool.completed` | Tool returns successfully |
+| `tool.failed` | Tool throws or returns an error |
+| `approval.requested` | Approval policy triggers before execution |
+| `approval.decided` | Approval decision recorded (approved / denied) |
+| `metadata.loaded` | Tool catalog fetched from MCP on `initialize()` |
+| `async.poll.checked` | A polling iteration completed for an async job |
 
 ## Lifecycle
 
-Always call `close()` when done:
+Always call `close()` when done — it closes the underlying MCP connection and allows the process to exit cleanly:
 
 ```ts
 const toolkit = await createZuoraOpenAIAgentToolkit({ env: true });
@@ -245,19 +430,19 @@ try {
 
 ## Discovery and execution
 
+> `listTools()` returns `ZuoraToolDefinition[]` — framework-agnostic metadata for inspection and logging.  
+> `getTools()` returns framework-native tool objects (e.g. `ChatCompletionTool[]`) ready to pass directly to the LLM.
+
 ```ts
 const tools = await toolkit.listTools();           // ZuoraToolDefinition[]
-const def = await toolkit.describeTool("get_account");
-const bundles = await toolkit.listBundles();
-const bundle = await toolkit.describeBundle("subscriptions");
+const def = await toolkit.describeTool("get_account");  // ZuoraToolDefinition
+const bundles = await toolkit.listBundles();           // ZuoraBundleName[]
+const bundle = await toolkit.describeBundle("subscriptions");  // { name, description, toolCount, tools: ZuoraToolDefinition[] }
 
 const result = await toolkit.callTool("get_account", { accountKey: "…" });
-// For async tools: await toolkit.waitForJob(toolName, asyncResult, options?)
 ```
 
-## Native query / file tools
-
-When the `query` bundle is enabled, the SDK may expose local helpers such as `download_query_result` and `read_downloaded_file` so agents can fetch and preview Data Query artifacts. Artifacts default to `~/.zuora-agent-artifacts`.
+For tools that start async jobs (e.g. Data Query), the tool result automatically includes a follow-up instruction telling the model which tool to call next — the model drives polling on subsequent steps without any extra code.
 
 ## Errors
 
@@ -277,7 +462,7 @@ All SDK errors are `ZuoraAgentToolkitError` with a typed `code`:
 import { ZuoraAgentToolkitError } from "@zuora/agent-toolkit";
 
 try {
-  await handleToolCalls({ toolkit, response });
+  await toolkit.callTool("create_invoice", { accountId: "A-1" });
 } catch (err) {
   if (err instanceof ZuoraAgentToolkitError && err.code === "APPROVAL_REJECTED") {
     // handle rejection
@@ -285,6 +470,21 @@ try {
 }
 ```
 
+When using framework adapters, `ZuoraAgentToolkitError` surfaces from `handleToolCalls()` (OpenAI Chat Completions), `run()` (OpenAI Agents SDK), `agent.invoke()` (LangChain), or during stream consumption with `generateText()` / `streamText()` (Vercel AI SDK).
+
+## Key exported types
+
+```ts
+import type {
+  ZuoraToolDefinition,  // full tool descriptor: name, description, inputSchema, meta
+  ZuoraBundleName,      // union of all valid bundle name strings
+  ToolSelection,        // filter shape passed to getTools() / listTools() — { bundles?, include?, exclude?, mode? }
+  ZuoraToolkitEvent,    // observability event payload
+  ApprovalPolicy,       // type for the approvalPolicy config field
+} from "@zuora/agent-toolkit";
+import { ZuoraAgentToolkitError, ApprovalPolicyPreset, SafetyMode } from "@zuora/agent-toolkit";
+```
+
 ## Examples
 
 Working examples are available in the source repository:
@@ -293,6 +493,8 @@ Working examples are available in the source repository:
 |---|---|
 | `examples/openai/index.ts` | Minimal Chat Completions agent loop |
 | `examples/openai/advanced.ts` | Observability, hooks, async jobs, discovery |
-| `examples/openai/hitl.ts` | Human-in-the-loop via `shouldExecute` |
+| `examples/openai/hitl.ts` | Human-in-the-loop (HITL) approval |
 | `examples/openai-agents/index.ts` | OpenAI Agents SDK agent |
 | `examples/openai-agents-cli/` | Interactive CLI agent + planner |
+| `examples/langchain/index.ts` | LangChain ReactAgent with Zuora tools |
+| `examples/vercel-ai/index.ts` | Vercel AI SDK `streamText` agent |

package/dist/{async-jobs-Dd8Jafv0.d.ts → async-jobs-DJ_GygII.d.ts}

@@ -30,7 +30,11 @@ type EventSanitizerLimits = {
 };
 
 type ZuoraEnvironment = "sandbox" | "production";
-type ZuoraSafetyMode = "readOnly" | "writeEnabled";
+declare const SafetyMode: {
+    readonly ReadOnly: "readOnly";
+    readonly WriteEnabled: "writeEnabled";
+};
+type ZuoraSafetyMode = (typeof SafetyMode)[keyof typeof SafetyMode];
 type ZuoraToolOperation = "read" | "write";
 type ZuoraRiskLevel = "low" | "medium" | "high";
 /**
@@ -164,13 +168,8 @@ type JsonSchema = {
     [key: string]: unknown;
 };
 type ZuoraAuthConfig = {
-    type: "oauthClientCredentials";
     clientId: string;
     clientSecret: string;
-    scope?: string;
-} | {
-    type: "accessToken";
-    accessToken: string;
 };
 type ZuoraTenantAuthConfig = {
     enabled: true;
@@ -226,8 +225,6 @@ type ZuoraMcpClient = {
     close?: () => Promise<void>;
 };
 type ZuoraConnectionConfigBase = {
-    tokenEndpoint?: string;
-    tokenAuthMethod?: "client_secret_post" | "client_secret_basic";
     headers?: Record<string, string | undefined>;
     entityIds?: string | string[];
     orgIds?: string | string[];
@@ -237,10 +234,6 @@ type ZuoraConnectionConfigBase = {
 type ZuoraTenantAuthConnectionConfig = ZuoraConnectionConfigBase & {
     tenantAuth: EnabledZuoraTenantAuthConfig;
 };
-type ZuoraStandardConnectionConfig = ZuoraConnectionConfigBase & {
-    tenantAuth?: Exclude<ZuoraTenantAuthConfig, EnabledZuoraTenantAuthConfig>;
-};
-type ZuoraConnectionConfig = ZuoraStandardConnectionConfig | ZuoraTenantAuthConnectionConfig;
 declare const ApprovalPolicyPreset: {
     readonly Off: "off";
     readonly AllWrites: "all_writes";
@@ -249,8 +242,8 @@ declare const ApprovalPolicyPreset: {
     readonly ProductionHighRisk: "production_high_risk";
 };
 type ApprovalPolicyPresetValue = (typeof ApprovalPolicyPreset)[keyof typeof ApprovalPolicyPreset];
-type ApprovalPolicyResult = "not_required" | "deny" | {
-    decision: "not_required" | "deny";
+type ApprovalPolicyResult = "allow" | "deny" | {
+    decision: "allow" | "deny";
     reason?: string;
 };
 type ApprovalPolicyHandler = (request: ApprovalRequest) => ApprovalPolicyResult | Promise<ApprovalPolicyResult>;
@@ -362,7 +355,6 @@ type ZuoraAgentToolkitEnvConfig = Omit<ZuoraAgentToolkitConfigBase, "baseUrl"> &
 };
 type ZuoraAgentToolkitConfig = (ZuoraAgentToolkitConfigBase & {
     auth: ZuoraAuthConfig;
-    connection?: ZuoraConnectionConfig;
 }) | (ZuoraAgentToolkitConfigBase & {
     auth?: ZuoraAuthConfig;
     connection: ZuoraTenantAuthConnectionConfig;
@@ -529,4 +521,4 @@ declare function resolveAsyncJobPollingToolName(result: ZuoraAsyncJobResult | Zu
  */
 declare function resolveAsyncJobStatusDetails(result: ZuoraToolExecutionResult, statusPath: string, terminalStatuses: ZuoraAsyncJobTerminalStatuses): ZuoraAsyncJobStatusResolution;
 
-export { type ApprovalPolicy as A, resolveAsyncJobId as B, resolveAsyncJobPollingToolName as C, DEFAULT_ASYNC_JOB_TERMINAL_STATUSES as D, resolveAsyncJobStatus as E, resolveAsyncJobStatusDetails as F, resolveAsyncJobTerminalState as G, type NativeFileApprovalMetadata as N, type ToolSelection as T, type ZuoraToolDefinition as Z, type ZuoraAgentToolkitConfigInput as a, type ZuoraToolExecutionResult as b, type ZuoraAsyncJobResult as c, type ZuoraToolkitEvent as d, type ZuoraAgentToolkitConfig as e, type ZuoraMcpClient as f, type ZuoraBundleDefinition as g, type ZuoraBundleName as h, type ZuoraWaitForJobOptions as i, ApprovalPolicyPreset as j, type ApprovalPolicyPresetValue as k, type ApprovalRequest as l, type NativeFileToolsConfig as m, type NativeToolApprovalMetadata as n, type NativeToolMetadataConfig as o, type ToolkitBundleName as p, type ZuoraAsyncJobStatusResolution as q, type ZuoraAsyncJobTerminalState as r, type ZuoraAsyncJobTerminalStatuses as s, type ZuoraSafetyMode as t, type ZuoraToolkitConfiguration as u, type ZuoraToolkitLogger as v, buildAsyncJobResult as w, isAsyncJobResult as x, isAsyncJobTerminal as y, matchesAsyncJobTerminalStatus as z };
+export { type ApprovalPolicy as A, resolveAsyncJobId as B, resolveAsyncJobPollingToolName as C, DEFAULT_ASYNC_JOB_TERMINAL_STATUSES as D, resolveAsyncJobStatus as E, resolveAsyncJobStatusDetails as F, resolveAsyncJobTerminalState as G, type NativeFileApprovalMetadata as N, SafetyMode as S, type ToolSelection as T, type ZuoraToolDefinition as Z, type ZuoraAgentToolkitConfigInput as a, type ZuoraToolExecutionResult as b, type ZuoraAsyncJobResult as c, type ZuoraToolkitEvent as d, type ZuoraAgentToolkitConfig as e, type ZuoraMcpClient as f, type ZuoraBundleDefinition as g, type ZuoraBundleName as h, type ZuoraWaitForJobOptions as i, ApprovalPolicyPreset as j, type ApprovalPolicyPresetValue as k, type ApprovalRequest as l, type NativeFileToolsConfig as m, type NativeToolApprovalMetadata as n, type NativeToolMetadataConfig as o, type ToolkitBundleName as p, type ZuoraAsyncJobStatusResolution as q, type ZuoraAsyncJobTerminalState as r, type ZuoraAsyncJobTerminalStatuses as s, type ZuoraSafetyMode as t, type ZuoraToolkitConfiguration as u, type ZuoraToolkitLogger as v, buildAsyncJobResult as w, isAsyncJobResult as x, isAsyncJobTerminal as y, matchesAsyncJobTerminalStatus as z };

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { b as ZuoraToolExecutionResult, h as ZuoraBundleName } from './async-jobs-Dd8Jafv0.js';
-export { A as ApprovalPolicy, j as ApprovalPolicyPreset, k as ApprovalPolicyPresetValue, l as ApprovalRequest, D as DEFAULT_ASYNC_JOB_TERMINAL_STATUSES, N as NativeFileApprovalMetadata, m as NativeFileToolsConfig, n as NativeToolApprovalMetadata, o as NativeToolMetadataConfig, T as ToolSelection, p as ToolkitBundleName, e as ZuoraAgentToolkitConfig, a as ZuoraAgentToolkitConfigInput, c as ZuoraAsyncJobResult, q as ZuoraAsyncJobStatusResolution, r as ZuoraAsyncJobTerminalState, s as ZuoraAsyncJobTerminalStatuses, g as ZuoraBundleDefinition, t as ZuoraSafetyMode, Z as ZuoraToolDefinition, u as ZuoraToolkitConfiguration, d as ZuoraToolkitEvent, v as ZuoraToolkitLogger, i as ZuoraWaitForJobOptions, w as buildAsyncJobResult, x as isAsyncJobResult, y as isAsyncJobTerminal, z as matchesAsyncJobTerminalStatus, B as resolveAsyncJobId, C as resolveAsyncJobPollingToolName, E as resolveAsyncJobStatus, F as resolveAsyncJobStatusDetails, G as resolveAsyncJobTerminalState } from './async-jobs-Dd8Jafv0.js';
+import { b as ZuoraToolExecutionResult, h as ZuoraBundleName } from './async-jobs-DJ_GygII.js';
+export { A as ApprovalPolicy, j as ApprovalPolicyPreset, k as ApprovalPolicyPresetValue, l as ApprovalRequest, D as DEFAULT_ASYNC_JOB_TERMINAL_STATUSES, N as NativeFileApprovalMetadata, m as NativeFileToolsConfig, n as NativeToolApprovalMetadata, o as NativeToolMetadataConfig, S as SafetyMode, T as ToolSelection, p as ToolkitBundleName, e as ZuoraAgentToolkitConfig, a as ZuoraAgentToolkitConfigInput, c as ZuoraAsyncJobResult, q as ZuoraAsyncJobStatusResolution, r as ZuoraAsyncJobTerminalState, s as ZuoraAsyncJobTerminalStatuses, g as ZuoraBundleDefinition, t as ZuoraSafetyMode, Z as ZuoraToolDefinition, u as ZuoraToolkitConfiguration, d as ZuoraToolkitEvent, v as ZuoraToolkitLogger, i as ZuoraWaitForJobOptions, w as buildAsyncJobResult, x as isAsyncJobResult, y as isAsyncJobTerminal, z as matchesAsyncJobTerminalStatus, B as resolveAsyncJobId, C as resolveAsyncJobPollingToolName, E as resolveAsyncJobStatus, F as resolveAsyncJobStatusDetails, G as resolveAsyncJobTerminalState } from './async-jobs-DJ_GygII.js';
 
 type ZuoraAgentToolkitP0ErrorCode = "TOOL_EXECUTION_ERROR" | "TOOL_NOT_FOUND" | "BUNDLE_NOT_FOUND" | "APPROVAL_REJECTED" | "MALFORMED_METADATA" | "OAUTH_TOKEN_ERROR" | "ASYNC_JOB_TIMEOUT";
 type ZuoraAgentToolkitErrorCode = ZuoraAgentToolkitP0ErrorCode | (string & {});

package/dist/index.js

@@ -236,6 +236,10 @@ var readNonEmptyString = (value) => {
 };
 
 // src/shared/types.ts
+var SafetyMode = {
+  ReadOnly: "readOnly",
+  WriteEnabled: "writeEnabled"
+};
 var ApprovalPolicyPreset = {
   Off: "off",
   AllWrites: "all_writes",
@@ -479,6 +483,7 @@ var ZUORA_BUNDLE_NAME_SET = new Set(ZUORA_BUNDLE_NAMES);
 export {
   ApprovalPolicyPreset,
   DEFAULT_ASYNC_JOB_TERMINAL_STATUSES,
+  SafetyMode,
   ZUORA_BUNDLE_NAME_SET,
   ZuoraAgentToolkitError,
   buildAsyncJobResult,