@ai-sdk/policy-opa 1.0.122 → 1.0.124

package/dist/index.js

@@ -1,312 +1,468 @@
-// src/shadow.ts
+//#region src/shadow.ts
+/**
+* Wrap a `toolApproval` in shadow mode so the policy is evaluated and the
+* decision is reported via `onDecision`, but the SDK is told the call is
+* approved regardless of what the policy said.
+*
+* Use this when you are rolling out a new policy and want to see what it
+* *would* deny before letting it actually deny anything in production. Wire
+* `onDecision` to your logger / metrics pipeline, run for a while, inspect
+* the events where `decision.type !== 'approved'`, fix the policy, then
+* flip `enforce: true` to graduate.
+*
+* @example
+* ```ts
+* import { shadow } from '@ai-sdk/policy-opa';
+* import { opaPolicy, wasmPolicyClient } from '@ai-sdk/policy-opa';
+*
+* const client = await wasmPolicyClient({ wasm });
+*
+* const toolApproval = shadow(
+*   opaPolicy({ client, path: 'agent/call/decision' }),
+*   {
+*     enforce: process.env.ENFORCE_POLICY === 'true',
+*     onDecision: (event) => {
+*       logger.info('policy.decision', {
+*         tool: event.toolCall.toolName,
+*         decision: event.decision.type,
+*         enforced: event.enforced,
+*         wouldBlock: event.decision.type === 'denied',
+*       });
+*     },
+*   },
+* );
+* ```
+*/
 function shadow(approval, opts = {}) {
-  const enforce = opts.enforce === true;
-  const { onDecision } = opts;
-  const wrapped = async (args) => {
-    const raw = await evaluateApproval(approval, args);
-    const decision = normalizePolicyDecision(raw);
-    const effective = enforce ? decision : { type: "approved" };
-    if (onDecision) {
-      const event = {
-        toolCall: {
-          toolName: args.toolCall.toolName,
-          toolCallId: args.toolCall.toolCallId,
-          input: args.toolCall.input
-        },
-        decision,
-        enforced: enforce,
-        effective,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      };
-      void (async () => {
-        try {
-          await onDecision(event);
-        } catch {
-        }
-      })();
-    }
-    return effective;
-  };
-  return wrapped;
+	const enforce = opts.enforce === true;
+	const { onDecision } = opts;
+	const wrapped = async (args) => {
+		const decision = normalizePolicyDecision(await evaluateApproval(approval, args));
+		const effective = enforce ? decision : { type: "approved" };
+		if (onDecision) {
+			const event = {
+				toolCall: {
+					toolName: args.toolCall.toolName,
+					toolCallId: args.toolCall.toolCallId,
+					input: args.toolCall.input
+				},
+				decision,
+				enforced: enforce,
+				effective,
+				timestamp: (/* @__PURE__ */ new Date()).toISOString()
+			};
+			(async () => {
+				try {
+					await onDecision(event);
+				} catch {}
+			})();
+		}
+		return effective;
+	};
+	return wrapped;
 }
 async function evaluateApproval(approval, args) {
-  if (typeof approval === "function") {
-    return await approval(args);
-  }
-  const map = approval;
-  const perTool = Object.prototype.hasOwnProperty.call(
-    map,
-    args.toolCall.toolName
-  ) ? map[args.toolCall.toolName] : void 0;
-  if (perTool == null) return void 0;
-  if (typeof perTool === "function") {
-    return await perTool(args.toolCall.input, {
-      toolCallId: args.toolCall.toolCallId,
-      messages: args.messages,
-      toolContext: void 0,
-      runtimeContext: args.runtimeContext
-    });
-  }
-  return perTool;
+	if (typeof approval === "function") return await approval(args);
+	const map = approval;
+	const perTool = Object.prototype.hasOwnProperty.call(map, args.toolCall.toolName) ? map[args.toolCall.toolName] : void 0;
+	if (perTool == null) return void 0;
+	if (typeof perTool === "function") return await perTool(args.toolCall.input, {
+		toolCallId: args.toolCall.toolCallId,
+		messages: args.messages,
+		toolContext: void 0,
+		runtimeContext: args.runtimeContext
+	});
+	return perTool;
 }
 function normalizePolicyDecision(status) {
-  if (status == null) return { type: "not-applicable" };
-  if (typeof status === "string") {
-    if (status === "approved" || status === "denied" || status === "user-approval" || status === "not-applicable") {
-      return { type: status };
-    }
-    return { type: "not-applicable" };
-  }
-  if (typeof status === "object" && "type" in status) {
-    return status;
-  }
-  return { type: "not-applicable" };
+	if (status == null) return { type: "not-applicable" };
+	if (typeof status === "string") {
+		if (status === "approved" || status === "denied" || status === "user-approval" || status === "not-applicable") return { type: status };
+		return { type: "not-applicable" };
+	}
+	if (typeof status === "object" && "type" in status) return status;
+	return { type: "not-applicable" };
 }
-
-// src/wrap-mcp-tools.ts
+//#endregion
+//#region src/wrap-mcp-tools.ts
+/**
+* Apply a fallback approval policy to a discovered tool set so the resulting
+* configuration is total: every tool in `tools` is gated either by the
+* supplied `approval` (when it has an opinion) or by `default` (otherwise).
+*
+* The motivating case is MCP. An MCP server hands you whatever tools it
+* exposes, and the agent's effective permissions become the union of the
+* full server surface. Without a fallback, any tool you forgot to write a
+* rule for is silently allowed. This helper closes that gap by forcing every
+* uncovered tool through `default` (which defaults to `user-approval` so the
+* human is in the loop for anything you didn't think about).
+*
+* Works for any tool set, not just MCP-discovered tools. The name reflects
+* the primary use case rather than a hard constraint.
+*
+* @example
+* ```ts
+* import { wrapMcpTools } from '@ai-sdk/policy-opa';
+* import { opaPolicy, wasmPolicyClient } from '@ai-sdk/policy-opa';
+*
+* const discovered = await mcpClient.tools();
+* const client = await wasmPolicyClient({ wasm });
+*
+* const { tools, toolApproval } = wrapMcpTools(
+*   discovered,
+*   opaPolicy({ client, path: 'agent/call/decision' }),
+*   { default: 'user-approval' }, // anything OPA does not match needs a human
+* );
+*
+* await generateText({ model, tools, toolApproval, prompt });
+* ```
+*/
 function wrapMcpTools(tools, approval, opts) {
-  const fallback = opts?.default ?? "user-approval";
-  if (typeof approval === "function") {
-    const wrapped = async (args) => {
-      const status = await approval(args);
-      return isNotApplicable(status) ? fallback : status;
-    };
-    return { tools, toolApproval: wrapped };
-  }
-  const filled = /* @__PURE__ */ Object.create(null);
-  for (const name of Object.keys(tools)) {
-    const configured = Object.prototype.hasOwnProperty.call(approval, name) ? approval[name] : void 0;
-    if (configured == null) {
-      filled[name] = fallback;
-    } else if (typeof configured === "function") {
-      const original = configured;
-      filled[name] = async (...args) => {
-        const status = await original(...args);
-        return isNotApplicable(status) ? fallback : status;
-      };
-    } else {
-      filled[name] = configured;
-    }
-  }
-  return {
-    tools,
-    toolApproval: filled
-  };
+	const fallback = opts?.default ?? "user-approval";
+	if (typeof approval === "function") {
+		const wrapped = async (args) => {
+			const status = await approval(args);
+			return isNotApplicable(status) ? fallback : status;
+		};
+		return {
+			tools,
+			toolApproval: wrapped
+		};
+	}
+	const filled = Object.create(null);
+	for (const name of Object.keys(tools)) {
+		const configured = Object.prototype.hasOwnProperty.call(approval, name) ? approval[name] : void 0;
+		if (configured == null) filled[name] = fallback;
+		else if (typeof configured === "function") {
+			const original = configured;
+			filled[name] = async (...args) => {
+				const status = await original(...args);
+				return isNotApplicable(status) ? fallback : status;
+			};
+		} else filled[name] = configured;
+	}
+	return {
+		tools,
+		toolApproval: filled
+	};
 }
 function isNotApplicable(status) {
-  if (status == null) return true;
-  if (status === "not-applicable") return true;
-  if (typeof status === "object" && status !== null) {
-    return status.type === "not-applicable";
-  }
-  return false;
+	if (status == null) return true;
+	if (status === "not-applicable") return true;
+	if (typeof status === "object" && status !== null) return status.type === "not-applicable";
+	return false;
 }
-
-// src/opa/http-policy-client.ts
+//#endregion
+//#region src/opa/http-policy-client.ts
+/**
+* Construct a {@link PolicyClient} that talks to a running OPA server over
+* HTTP using `@open-policy-agent/opa`.
+*
+* The `@open-policy-agent/opa` package is an optional peer dependency; install
+* it before using this client:
+*
+* ```sh
+* pnpm add @open-policy-agent/opa
+* ```
+*
+* The `url` typically points at `http://localhost:8181` for a locally running
+* OPA. `headers` is forwarded for Styra DAS / EOPA authentication.
+*/
 function httpPolicyClient(opts) {
-  const { url, headers } = opts;
-  let underlying;
-  async function getUnderlying() {
-    if (underlying) return underlying;
-    let mod;
-    try {
-      mod = await import("@open-policy-agent/opa");
-    } catch (cause) {
-      throw Object.assign(
-        new Error(
-          'Cannot import "@open-policy-agent/opa". Install it as a peer dependency to use httpPolicyClient().'
-        ),
-        { cause }
-      );
-    }
-    underlying = new mod.OPAClient(url, headers ? { headers } : void 0);
-    return underlying;
-  }
-  return {
-    async evaluate(path, input) {
-      const client = await getUnderlying();
-      return await client.evaluate(path, input);
-    }
-  };
+	const { url, headers } = opts;
+	let underlying;
+	async function getUnderlying() {
+		if (underlying) return underlying;
+		let mod;
+		try {
+			mod = await import("@open-policy-agent/opa");
+		} catch (cause) {
+			throw Object.assign(/* @__PURE__ */ new Error("Cannot import \"@open-policy-agent/opa\". Install it as a peer dependency to use httpPolicyClient()."), { cause });
+		}
+		underlying = new mod.OPAClient(url, headers ? { headers } : void 0);
+		return underlying;
+	}
+	return { async evaluate(path, input) {
+		return await (await getUnderlying()).evaluate(path, input);
+	} };
 }
-
-// src/opa/normalize-opa-decision.ts
+//#endregion
+//#region src/opa/normalize-opa-decision.ts
+/**
+* Normalize an OPA evaluation result into the package's {@link PolicyDecision}
+* shape.
+*
+* Supports two Rego output conventions:
+*
+* - **Recommended (explicit):** `{ "decision": "allow" | "deny" | "requires-approval", "reason": string }`.
+*   Maps to `approved` / `denied` / `user-approval` respectively.
+*
+* - **Legacy (boolean):** `{ "allow": boolean, "reason"?: string }`. `true`
+*   maps to `approved`, `false` to `denied`.
+*
+* `null` and `undefined` are treated as `not-applicable` so that a Rego rule
+* that does not match any branch defaults to "no opinion" rather than
+* blocking. Any other unrecognized result is denied so malformed policy
+* output cannot silently bypass the approval gate.
+*/
 function normalizeOpaDecision(result) {
-  if (result == null) {
-    return { type: "not-applicable" };
-  }
-  if (typeof result !== "object") {
-    return unrecognizedDecision();
-  }
-  const record = result;
-  const reason = typeof record.reason === "string" ? record.reason : void 0;
-  if (typeof record.decision === "string") {
-    switch (record.decision) {
-      case "allow":
-        return withReason("approved", reason);
-      case "deny":
-        return withReason("denied", reason);
-      case "requires-approval":
-        return withReason("user-approval", reason);
-      case "not-applicable":
-        return { type: "not-applicable" };
-    }
-  }
-  if (typeof record.allow === "boolean") {
-    return withReason(record.allow ? "approved" : "denied", reason);
-  }
-  return unrecognizedDecision();
+	if (result == null) return { type: "not-applicable" };
+	if (typeof result !== "object") return unrecognizedDecision();
+	const record = result;
+	const reason = typeof record.reason === "string" ? record.reason : void 0;
+	if (typeof record.decision === "string") switch (record.decision) {
+		case "allow": return withReason("approved", reason);
+		case "deny": return withReason("denied", reason);
+		case "requires-approval": return withReason("user-approval", reason);
+		case "not-applicable": return { type: "not-applicable" };
+	}
+	if (typeof record.allow === "boolean") return withReason(record.allow ? "approved" : "denied", reason);
+	return unrecognizedDecision();
 }
 function unrecognizedDecision() {
-  return {
-    type: "denied",
-    reason: "unrecognized OPA policy decision"
-  };
+	return {
+		type: "denied",
+		reason: "unrecognized OPA policy decision"
+	};
 }
 function withReason(type, reason) {
-  return reason ? { type, reason } : { type };
+	return reason ? {
+		type,
+		reason
+	} : { type };
 }
-
-// src/opa/evaluate-policy.ts
+//#endregion
+//#region src/opa/evaluate-policy.ts
+/**
+* Evaluate a policy, capturing a backend error (OPA unreachable, WASM fault,
+* bad path) as a value instead of letting it throw. This is the package's
+* fail-closed invariant in one place: a thrown `client.evaluate` must never
+* escape into the SDK callback or middleware, where it would abort the run.
+* Each caller turns `ok: false` into its own safe fallback (deny / no tools).
+*/
 async function evaluatePolicy(client, path, input) {
-  try {
-    return { ok: true, result: await client.evaluate(path, input) };
-  } catch (error) {
-    return { ok: false, error };
-  }
+	try {
+		return {
+			ok: true,
+			result: await client.evaluate(path, input)
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			error
+		};
+	}
 }
-
-// src/opa/opa-capability-middleware.ts
+//#endregion
+//#region src/opa/opa-capability-middleware.ts
+/**
+* Construct an experimental {@link LanguageModelV4Middleware} that narrows
+* the `tools` field on every model call to an allowlist returned by OPA.
+*
+* Why use this alongside the per-call `toolApproval` gate? Two reasons:
+*
+* 1. **Defense in depth.** If a bug or regression slips through the policy
+*    used by `toolApproval`, the middleware still prevents the model from
+*    seeing the disallowed tools in the first place.
+* 2. **Capability disclosure.** The model does not waste tokens describing
+*    tools it cannot call, and jailbreak attempts get "I don't have access
+*    to that tool" rather than "[approval denied]".
+*
+* The OPA rule at `path` is expected to return either a `string[]` of allowed
+* tool names, or an object `{ tools: string[] }`. Function tools whose `name`
+* matches are kept; provider tools whose dotted `id` or bare `name` matches are
+* kept; everything else is dropped from `params.tools`.
+*
+* On a malformed result (or an OPA error), the middleware **fails closed**:
+* `params.tools` is set to `undefined`, so the model is told it has no tools
+* available. Misconfiguration should not silently widen capabilities.
+*
+* @example
+* ```ts
+* import { wrapLanguageModel } from 'ai';
+* import { wasmPolicyClient, opaCapabilityMiddleware } from '@ai-sdk/policy-opa';
+*
+* const client = await wasmPolicyClient({ wasm });
+*
+* const wrappedModel = wrapLanguageModel({
+*   model: anthropic('claude-sonnet-4-5'),
+*   middleware: opaCapabilityMiddleware({
+*     client,
+*     path: 'agent/tools/allowed',
+*   }),
+* });
+* ```
+*/
 function opaCapabilityMiddleware(opts) {
-  const { client, path, toInput } = opts;
-  return {
-    specificationVersion: "v4",
-    async transformParams({ params }) {
-      if (params.tools == null || params.tools.length === 0) {
-        return params;
-      }
-      const input = toInput?.({
-        messages: params.prompt,
-        providerOptions: params.providerOptions
-      }) ?? {
-        messages: params.prompt,
-        providerOptions: params.providerOptions
-      };
-      const outcome = await evaluatePolicy(client, path, input);
-      if (!outcome.ok) {
-        return { ...params, tools: void 0 };
-      }
-      const allowed = extractAllowedNameSet(outcome.result);
-      if (allowed == null) {
-        return { ...params, tools: void 0 };
-      }
-      let removed = false;
-      const filtered = params.tools.filter((t) => {
-        const keep = t.type === "function" ? allowed.has(t.name) : allowed.has(t.id) || allowed.has(t.name);
-        if (!keep) removed = true;
-        return keep;
-      });
-      if (!removed) return params;
-      return { ...params, tools: filtered };
-    }
-  };
+	const { client, path, toInput } = opts;
+	return {
+		specificationVersion: "v4",
+		async transformParams({ params }) {
+			if (params.tools == null || params.tools.length === 0) return params;
+			const input = toInput?.({
+				messages: params.prompt,
+				providerOptions: params.providerOptions
+			}) ?? {
+				messages: params.prompt,
+				providerOptions: params.providerOptions
+			};
+			const outcome = await evaluatePolicy(client, path, input);
+			if (!outcome.ok) return {
+				...params,
+				tools: void 0
+			};
+			const allowed = extractAllowedNameSet(outcome.result);
+			if (allowed == null) return {
+				...params,
+				tools: void 0
+			};
+			let removed = false;
+			const filtered = params.tools.filter((t) => {
+				const keep = t.type === "function" ? allowed.has(t.name) : allowed.has(t.id) || allowed.has(t.name);
+				if (!keep) removed = true;
+				return keep;
+			});
+			if (!removed) return params;
+			return {
+				...params,
+				tools: filtered
+			};
+		}
+	};
 }
 function extractAllowedNameSet(result) {
-  const list = Array.isArray(result) ? result : result != null && typeof result === "object" ? result.tools : void 0;
-  if (!Array.isArray(list)) return null;
-  const out = /* @__PURE__ */ new Set();
-  for (const item of list) {
-    if (typeof item !== "string") return null;
-    out.add(item);
-  }
-  return out;
+	const list = Array.isArray(result) ? result : result != null && typeof result === "object" ? result.tools : void 0;
+	if (!Array.isArray(list)) return null;
+	const out = /* @__PURE__ */ new Set();
+	for (const item of list) {
+		if (typeof item !== "string") return null;
+		out.add(item);
+	}
+	return out;
 }
-
-// src/opa/opa-policy.ts
+//#endregion
+//#region src/opa/opa-policy.ts
+/**
+* Construct a {@link ToolApprovalConfiguration} backed by an OPA policy.
+*
+* The returned generic approval function evaluates the supplied Rego entry
+* (`path`) for every tool call and maps the result to the SDK's approval
+* status via {@link normalizeOpaDecision}. Pass the result directly as
+* `toolApproval` on `generateText` / `streamText` / `ToolLoopAgent`.
+*
+* ```ts
+* import { wasmPolicyClient } from '@ai-sdk/policy-opa';
+* import { opaPolicy } from '@ai-sdk/policy-opa';
+*
+* const client = await wasmPolicyClient({ wasm });
+* const toolApproval = opaPolicy({ client, path: 'agent/call/decision' });
+*
+* await generateText({ model, tools, toolApproval, prompt });
+* ```
+*
+* @param opts.client    The OPA client (HTTP or WASM).
+* @param opts.path      The Rego entrypoint that returns the decision object.
+* @param opts.toInput   Optional transformer to shape the OPA input.
+*/
 function opaPolicy(opts) {
-  const { client, path, toInput } = opts;
-  return async ({
-    toolCall,
-    tools,
-    toolsContext,
-    runtimeContext,
-    messages
-  }) => {
-    const opaInput = toInput?.({ toolCall, tools, toolsContext, runtimeContext, messages }) ?? {
-      tool: { name: toolCall.toolName },
-      args: toolCall.input,
-      messages,
-      runtimeContext
-    };
-    const outcome = await evaluatePolicy(client, path, opaInput);
-    if (!outcome.ok) {
-      return {
-        type: "denied",
-        reason: `policy evaluation failed: ${errorMessage(outcome.error)}`
-      };
-    }
-    return normalizeOpaDecision(outcome.result);
-  };
+	const { client, path, toInput } = opts;
+	return async ({ toolCall, tools, toolsContext, runtimeContext, messages }) => {
+		const opaInput = toInput?.({
+			toolCall,
+			tools,
+			toolsContext,
+			runtimeContext,
+			messages
+		}) ?? {
+			tool: { name: toolCall.toolName },
+			args: toolCall.input,
+			messages,
+			runtimeContext
+		};
+		const outcome = await evaluatePolicy(client, path, opaInput);
+		if (!outcome.ok) return {
+			type: "denied",
+			reason: `policy evaluation failed: ${errorMessage(outcome.error)}`
+		};
+		return normalizeOpaDecision(outcome.result);
+	};
 }
 function errorMessage(cause) {
-  if (cause instanceof Error) return cause.message;
-  if (typeof cause === "object" && cause !== null) {
-    try {
-      return JSON.stringify(cause);
-    } catch {
-    }
-  }
-  return String(cause);
+	if (cause instanceof Error) return cause.message;
+	if (typeof cause === "object" && cause !== null) try {
+		return JSON.stringify(cause);
+	} catch {}
+	return String(cause);
 }
+/**
+* Optional variant of {@link opaPolicy} that gracefully degrades when no
+* policy backend is available.
+*
+* Returns `undefined` when `client` is `undefined`. Pass that directly as
+* `toolApproval` and the SDK falls back to its default allow-all behavior.
+* When `client` is supplied, behaves exactly like {@link opaPolicy}.
+*
+* Use this when the policy file is configured per environment (e.g. loaded
+* in production, absent in local development):
+*
+* ```ts
+* import { readFile } from 'node:fs/promises';
+* import { optionalOpaPolicy, wasmPolicyClient } from '@ai-sdk/policy-opa';
+*
+* const wasm = process.env.POLICY_WASM_PATH
+*   ? await readFile(process.env.POLICY_WASM_PATH)
+*   : undefined;
+* const client = wasm ? await wasmPolicyClient({ wasm }) : undefined;
+*
+* const toolApproval = optionalOpaPolicy({
+*   client,
+*   path: 'agent/call/decision',
+* });
+*
+* await generateText({ model, tools, toolApproval, prompt });
+* ```
+*/
 function optionalOpaPolicy(opts) {
-  if (opts.client == null) return void 0;
-  return opaPolicy({
-    client: opts.client,
-    path: opts.path,
-    toInput: opts.toInput
-  });
+	if (opts.client == null) return void 0;
+	return opaPolicy({
+		client: opts.client,
+		path: opts.path,
+		toInput: opts.toInput
+	});
 }
-
-// src/opa/wasm-policy-client.ts
+//#endregion
+//#region src/opa/wasm-policy-client.ts
+/**
+* Construct a {@link PolicyClient} that evaluates a compiled OPA WASM bundle
+* in-process using `@open-policy-agent/opa-wasm`.
+*
+* The `@open-policy-agent/opa-wasm` package is an optional peer dependency;
+* install it before using this client:
+*
+* ```sh
+* pnpm add @open-policy-agent/opa-wasm
+* ```
+*
+* The `path` argument to `evaluate(path, input)` is informational. The WASM
+* bundle is built around a fixed entrypoint at `opa build` time. The path is
+* recorded for audit logs but does not affect the evaluation.
+*/
 async function wasmPolicyClient(opts) {
-  let mod;
-  try {
-    mod = await import("@open-policy-agent/opa-wasm");
-  } catch (cause) {
-    throw Object.assign(
-      new Error(
-        'Cannot import "@open-policy-agent/opa-wasm". Install it as a peer dependency to use wasmPolicyClient().'
-      ),
-      { cause }
-    );
-  }
-  const policy = await mod.loadPolicy(opts.wasm);
-  if (opts.data !== void 0 && typeof policy.setData === "function") {
-    policy.setData(opts.data);
-  }
-  return {
-    async evaluate(_path, input) {
-      const results = policy.evaluate(input);
-      if (!Array.isArray(results) || results.length === 0) {
-        throw Object.assign(
-          new Error(
-            "OPA WASM policy produced no result. Check that the bundle was built with the correct entrypoint (`opa build -t wasm -e <path>`)."
-          ),
-          { input }
-        );
-      }
-      return results[0].result;
-    }
-  };
+	let mod;
+	try {
+		mod = await import("@open-policy-agent/opa-wasm");
+	} catch (cause) {
+		throw Object.assign(/* @__PURE__ */ new Error("Cannot import \"@open-policy-agent/opa-wasm\". Install it as a peer dependency to use wasmPolicyClient()."), { cause });
+	}
+	const policy = await mod.loadPolicy(opts.wasm);
+	if (opts.data !== void 0 && typeof policy.setData === "function") policy.setData(opts.data);
+	return { async evaluate(_path, input) {
+		const results = policy.evaluate(input);
+		if (!Array.isArray(results) || results.length === 0) throw Object.assign(/* @__PURE__ */ new Error("OPA WASM policy produced no result. Check that the bundle was built with the correct entrypoint (`opa build -t wasm -e <path>`)."), { input });
+		return results[0].result;
+	} };
 }
-export {
-  httpPolicyClient,
-  normalizeOpaDecision,
-  opaCapabilityMiddleware,
-  opaPolicy,
-  optionalOpaPolicy,
-  shadow,
-  wasmPolicyClient,
-  wrapMcpTools
-};
+//#endregion
+export { httpPolicyClient, normalizeOpaDecision, opaCapabilityMiddleware, opaPolicy, optionalOpaPolicy, shadow, wasmPolicyClient, wrapMcpTools };
+
 //# sourceMappingURL=index.js.map