@ai-sdk/policy-opa 1.0.120 → 1.0.123

package/CHANGELOG.md

@@ -1,5 +1,39 @@
 # @ai-sdk/policy
 
+## 1.0.123
+
+### Patch Changes
+
+- ede5b89: chore: migrate package builds from tsup to tsdown
+- Updated dependencies [05cdac6]
+- Updated dependencies [4514fc1]
+- Updated dependencies [ede5b89]
+- Updated dependencies [2a625cf]
+- Updated dependencies [50a26d5]
+  - ai@7.0.123
+  - @ai-sdk/provider@4.0.20
+  - @ai-sdk/provider-utils@5.0.52
+
+## 1.0.122
+
+### Patch Changes
+
+- Updated dependencies [f3575f8]
+- Updated dependencies [27ab8d4]
+  - ai@7.0.122
+
+## 1.0.121
+
+### Patch Changes
+
+- Updated dependencies [c5e90bb]
+- Updated dependencies [c2511c1]
+- Updated dependencies [868c475]
+- Updated dependencies [119536f]
+- Updated dependencies [9941f32]
+  - ai@7.0.121
+  - @ai-sdk/provider-utils@5.0.51
+
 ## 1.0.120
 
 ### Patch Changes

package/dist/index.d.ts

@@ -1,7 +1,7 @@
-import { Tool, Context, ToolSet, ModelMessage, InferToolSetContext } from '@ai-sdk/provider-utils';
-import { ToolApprovalConfiguration, ToolApprovalStatus } from 'ai';
-import { LanguageModelV4CallOptions, LanguageModelV4Middleware } from '@ai-sdk/provider';
-
+import { Context, InferToolSetContext, ModelMessage, Tool, ToolSet } from "@ai-sdk/provider-utils";
+import { ToolApprovalConfiguration, ToolApprovalStatus } from "ai";
+import { LanguageModelV4CallOptions, LanguageModelV4Middleware } from "@ai-sdk/provider";
+//#region src/policy-client.d.ts
 /**
  * A generic client for evaluating a policy decision against some external
  * engine (OPA, Cedar, OpenFGA, a remote HTTP rule service, etc.).
@@ -11,15 +11,16 @@ import { LanguageModelV4CallOptions, LanguageModelV4Middleware } from '@ai-sdk/p
  * call sites.
  */
 interface PolicyClient {
-    /**
-     * Evaluate the given input against the policy identified by `path` and
-     * return the decision payload the engine emitted. Adapters are responsible
-     * for interpreting that payload. For OPA, `opaPolicy` normalizes it into
-     * the SDK's `ToolApprovalStatus` shape.
-     */
-    evaluate<TInput = unknown, TResult = unknown>(path: string, input: TInput): Promise<TResult>;
+  /**
+   * Evaluate the given input against the policy identified by `path` and
+   * return the decision payload the engine emitted. Adapters are responsible
+   * for interpreting that payload. For OPA, `opaPolicy` normalizes it into
+   * the SDK's `ToolApprovalStatus` shape.
+   */
+  evaluate<TInput = unknown, TResult = unknown>(path: string, input: TInput): Promise<TResult>;
 }
-
+//#endregion
+//#region src/policy-decision.d.ts
 /**
  * Narrowed object form of the SDK's `ToolApprovalStatus`.
  *
@@ -29,18 +30,19 @@ interface PolicyClient {
  * `shadow` can rely on a single discriminant.
  */
 type PolicyDecision = {
-    type: 'approved';
-    reason?: string;
+  type: 'approved';
+  reason?: string;
 } | {
-    type: 'denied';
-    reason?: string;
+  type: 'denied';
+  reason?: string;
 } | {
-    type: 'user-approval';
-    reason?: string;
+  type: 'user-approval';
+  reason?: string;
 } | {
-    type: 'not-applicable';
+  type: 'not-applicable';
 };
-
+//#endregion
+//#region src/shadow.d.ts
 /**
  * Event emitted by {@link shadow} every time the wrapped policy is evaluated.
  *
@@ -50,21 +52,21 @@ type PolicyDecision = {
  * have blocked or escalated.
  */
 interface PolicyDecisionEvent {
-    /** Identifying info from the tool call being evaluated. */
-    toolCall: {
-        toolName: string;
-        toolCallId: string;
-        input: unknown;
-    };
-    /** The decision the wrapped policy returned, normalized to the object form. */
-    decision: PolicyDecision;
-    /** Whether the SDK will act on `decision` (true) or override to allow (false). */
-    enforced: boolean;
-    /** The decision the SDK actually acts on. Equals `decision` when enforcing,
-     *  `{ type: 'approved' }` in shadow mode. */
-    effective: PolicyDecision;
-    /** ISO 8601 timestamp of the evaluation. */
-    timestamp: string;
+  /** Identifying info from the tool call being evaluated. */
+  toolCall: {
+    toolName: string;
+    toolCallId: string;
+    input: unknown;
+  };
+  /** The decision the wrapped policy returned, normalized to the object form. */
+  decision: PolicyDecision;
+  /** Whether the SDK will act on `decision` (true) or override to allow (false). */
+  enforced: boolean;
+  /** The decision the SDK actually acts on. Equals `decision` when enforcing,
+   *  `{ type: 'approved' }` in shadow mode. */
+  effective: PolicyDecision;
+  /** ISO 8601 timestamp of the evaluation. */
+  timestamp: string;
 }
 /**
  * Wrap a `toolApproval` in shadow mode so the policy is evaluated and the
@@ -100,14 +102,15 @@ interface PolicyDecisionEvent {
  * );
  * ```
  */
-declare function shadow<TOOLS extends Record<string, Tool>, RUNTIME_CONTEXT extends Context | unknown | never = unknown>(approval: ToolApprovalConfiguration<TOOLS & ToolSet, RUNTIME_CONTEXT>, opts?: {
-    /** When true, the SDK acts on the policy's decision. When false (default),
-     *  the SDK is told every call is approved. */
-    enforce?: boolean;
-    /** Invoked once per evaluated tool call with the captured decision. */
-    onDecision?: (event: PolicyDecisionEvent) => void | Promise<void>;
+export declare function shadow<TOOLS extends Record<string, Tool>, RUNTIME_CONTEXT extends Context | unknown | never = unknown>(approval: ToolApprovalConfiguration<TOOLS & ToolSet, RUNTIME_CONTEXT>, opts?: {
+  /** When true, the SDK acts on the policy's decision. When false (default),
+   *  the SDK is told every call is approved. */
+  enforce?: boolean;
+  /** Invoked once per evaluated tool call with the captured decision. */
+  onDecision?: (event: PolicyDecisionEvent) => void | Promise<void>;
 }): ToolApprovalConfiguration<TOOLS & ToolSet, RUNTIME_CONTEXT>;
-
+//#endregion
+//#region src/wrap-mcp-tools.d.ts
 type ApprovalLiteralStatus = Extract<ToolApprovalStatus, string>;
 /**
  * Result returned by {@link wrapMcpTools}: the original tool set plus a
@@ -115,8 +118,8 @@ type ApprovalLiteralStatus = Extract<ToolApprovalStatus, string>;
  * supplied approval does not explicitly handle.
  */
 interface WrappedMcpTools<TOOLS extends Record<string, Tool>, RUNTIME_CONTEXT extends Context | unknown | never> {
-    tools: TOOLS;
-    toolApproval: ToolApprovalConfiguration<TOOLS, RUNTIME_CONTEXT>;
+  tools: TOOLS;
+  toolApproval: ToolApprovalConfiguration<TOOLS, RUNTIME_CONTEXT>;
 }
 /**
  * Apply a fallback approval policy to a discovered tool set so the resulting
@@ -150,10 +153,11 @@ interface WrappedMcpTools<TOOLS extends Record<string, Tool>, RUNTIME_CONTEXT ex
  * await generateText({ model, tools, toolApproval, prompt });
  * ```
  */
-declare function wrapMcpTools<TOOLS extends Record<string, Tool>, RUNTIME_CONTEXT extends Context | unknown | never = unknown>(tools: TOOLS, approval: ToolApprovalConfiguration<TOOLS, RUNTIME_CONTEXT>, opts?: {
-    default?: ApprovalLiteralStatus;
+export declare function wrapMcpTools<TOOLS extends Record<string, Tool>, RUNTIME_CONTEXT extends Context | unknown | never = unknown>(tools: TOOLS, approval: ToolApprovalConfiguration<TOOLS, RUNTIME_CONTEXT>, opts?: {
+  default?: ApprovalLiteralStatus;
 }): WrappedMcpTools<TOOLS, RUNTIME_CONTEXT>;
-
+//#endregion
+//#region src/opa/http-policy-client.d.ts
 /**
  * Construct a {@link PolicyClient} that talks to a running OPA server over
  * HTTP using `@open-policy-agent/opa`.
@@ -168,11 +172,12 @@ declare function wrapMcpTools<TOOLS extends Record<string, Tool>, RUNTIME_CONTEX
  * The `url` typically points at `http://localhost:8181` for a locally running
  * OPA. `headers` is forwarded for Styra DAS / EOPA authentication.
  */
-declare function httpPolicyClient(opts: {
-    url: string;
-    headers?: Record<string, string>;
+export declare function httpPolicyClient(opts: {
+  url: string;
+  headers?: Record<string, string>;
 }): PolicyClient;
-
+//#endregion
+//#region src/opa/normalize-opa-decision.d.ts
 /**
  * Normalize an OPA evaluation result into the package's {@link PolicyDecision}
  * shape.
@@ -190,15 +195,16 @@ declare function httpPolicyClient(opts: {
  * blocking. Any other unrecognized result is denied so malformed policy
  * output cannot silently bypass the approval gate.
  */
-declare function normalizeOpaDecision(result: unknown): PolicyDecision;
-
+export declare function normalizeOpaDecision(result: unknown): PolicyDecision;
+//#endregion
+//#region src/opa/opa-capability-middleware.d.ts
 /**
  * Default OPA input shape passed to the capability-scoping rule.
  * Override with `toInput` if your Rego expects a different schema.
  */
 interface DefaultOpaCapabilityInput {
-    messages: LanguageModelV4CallOptions['prompt'];
-    providerOptions: LanguageModelV4CallOptions['providerOptions'];
+  messages: LanguageModelV4CallOptions['prompt'];
+  providerOptions: LanguageModelV4CallOptions['providerOptions'];
 }
 /**
  * Construct an experimental {@link LanguageModelV4Middleware} that narrows
@@ -238,26 +244,27 @@ interface DefaultOpaCapabilityInput {
  * });
  * ```
  */
-declare function opaCapabilityMiddleware(opts: {
-    client: PolicyClient;
-    path: string;
-    toInput?: (args: {
-        messages: LanguageModelV4CallOptions['prompt'];
-        providerOptions: LanguageModelV4CallOptions['providerOptions'];
-    }) => unknown;
+export declare function opaCapabilityMiddleware(opts: {
+  client: PolicyClient;
+  path: string;
+  toInput?: (args: {
+    messages: LanguageModelV4CallOptions['prompt'];
+    providerOptions: LanguageModelV4CallOptions['providerOptions'];
+  }) => unknown;
 }): LanguageModelV4Middleware;
-
+//#endregion
+//#region src/opa/opa-policy.d.ts
 /**
  * The default shape passed to the OPA rule as `input` when no `toInput` is
  * supplied. Rego rules can read `input.tool.name`, `input.args`, and so on.
  */
 interface DefaultOpaInput {
-    tool: {
-        name: string;
-    };
-    args: unknown;
-    messages: ReadonlyArray<ModelMessage>;
-    runtimeContext: unknown;
+  tool: {
+    name: string;
+  };
+  args: unknown;
+  messages: ReadonlyArray<ModelMessage>;
+  runtimeContext: unknown;
 }
 /**
  * Construct a {@link ToolApprovalConfiguration} backed by an OPA policy.
@@ -281,20 +288,20 @@ interface DefaultOpaInput {
  * @param opts.path      The Rego entrypoint that returns the decision object.
  * @param opts.toInput   Optional transformer to shape the OPA input.
  */
-declare function opaPolicy<TOOLS extends ToolSet = ToolSet, RUNTIME_CONTEXT extends Context | unknown | never = unknown>(opts: {
-    client: PolicyClient;
-    path: string;
-    toInput?: (args: {
-        toolCall: {
-            toolName: string;
-            toolCallId: string;
-            input: unknown;
-        };
-        tools: TOOLS | undefined;
-        toolsContext: InferToolSetContext<TOOLS>;
-        runtimeContext: RUNTIME_CONTEXT;
-        messages: ModelMessage[];
-    }) => unknown;
+export declare function opaPolicy<TOOLS extends ToolSet = ToolSet, RUNTIME_CONTEXT extends Context | unknown | never = unknown>(opts: {
+  client: PolicyClient;
+  path: string;
+  toInput?: (args: {
+    toolCall: {
+      toolName: string;
+      toolCallId: string;
+      input: unknown;
+    };
+    tools: TOOLS | undefined;
+    toolsContext: InferToolSetContext<TOOLS>;
+    runtimeContext: RUNTIME_CONTEXT;
+    messages: ModelMessage[];
+  }) => unknown;
 }): ToolApprovalConfiguration<TOOLS, RUNTIME_CONTEXT>;
 /**
  * Optional variant of {@link opaPolicy} that gracefully degrades when no
@@ -324,22 +331,23 @@ declare function opaPolicy<TOOLS extends ToolSet = ToolSet, RUNTIME_CONTEXT exte
  * await generateText({ model, tools, toolApproval, prompt });
  * ```
  */
-declare function optionalOpaPolicy<TOOLS extends ToolSet = ToolSet, RUNTIME_CONTEXT extends Context | unknown | never = unknown>(opts: {
-    client: PolicyClient | undefined;
-    path: string;
-    toInput?: (args: {
-        toolCall: {
-            toolName: string;
-            toolCallId: string;
-            input: unknown;
-        };
-        tools: TOOLS | undefined;
-        toolsContext: InferToolSetContext<TOOLS>;
-        runtimeContext: RUNTIME_CONTEXT;
-        messages: ModelMessage[];
-    }) => unknown;
+export declare function optionalOpaPolicy<TOOLS extends ToolSet = ToolSet, RUNTIME_CONTEXT extends Context | unknown | never = unknown>(opts: {
+  client: PolicyClient | undefined;
+  path: string;
+  toInput?: (args: {
+    toolCall: {
+      toolName: string;
+      toolCallId: string;
+      input: unknown;
+    };
+    tools: TOOLS | undefined;
+    toolsContext: InferToolSetContext<TOOLS>;
+    runtimeContext: RUNTIME_CONTEXT;
+    messages: ModelMessage[];
+  }) => unknown;
 }): ToolApprovalConfiguration<TOOLS, RUNTIME_CONTEXT> | undefined;
-
+//#endregion
+//#region src/opa/wasm-policy-client.d.ts
 /**
  * Construct a {@link PolicyClient} that evaluates a compiled OPA WASM bundle
  * in-process using `@open-policy-agent/opa-wasm`.
@@ -355,10 +363,11 @@ declare function optionalOpaPolicy<TOOLS extends ToolSet = ToolSet, RUNTIME_CONT
  * bundle is built around a fixed entrypoint at `opa build` time. The path is
  * recorded for audit logs but does not affect the evaluation.
  */
-declare function wasmPolicyClient(opts: {
-    wasm: Uint8Array | ArrayBuffer;
-    /** Optional data document bundled into the policy (passed to `setData`). */
-    data?: unknown;
+export declare function wasmPolicyClient(opts: {
+  wasm: Uint8Array | ArrayBuffer;
+  /** Optional data document bundled into the policy (passed to `setData`). */
+  data?: unknown;
 }): Promise<PolicyClient>;
-
-export { type DefaultOpaCapabilityInput, type DefaultOpaInput, type PolicyClient, type PolicyDecision, type PolicyDecisionEvent, type WrappedMcpTools, httpPolicyClient, normalizeOpaDecision, opaCapabilityMiddleware, opaPolicy, optionalOpaPolicy, shadow, wasmPolicyClient, wrapMcpTools };
+//#endregion
+export type { DefaultOpaCapabilityInput, DefaultOpaInput, PolicyClient, PolicyDecision, PolicyDecisionEvent, WrappedMcpTools };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/policy-client.ts","../src/policy-decision.ts","../src/shadow.ts","../src/wrap-mcp-tools.ts","../src/opa/http-policy-client.ts","../src/opa/normalize-opa-decision.ts","../src/opa/opa-capability-middleware.ts","../src/opa/opa-policy.ts","../src/opa/wasm-policy-client.ts"],"mappings":";;;;;;;;;;;;UAQiB;;;;;;;EAOf,SAAS,kBAAkB,mBACzB,cACA,OAAO,SACN,QAAQ;;;;;;;;;;;;KCVD;EACN;EAAkB;;EAClB;EAAgB;;EAChB;EAAuB;;EACvB;;;;;;;;;;;;UCaW;;EAEf;IAAY;IAAkB;IAAoB;;;EAElD,UAAU;;EAEV;;;EAGA,WAAW;;EAEX;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAqCc,OACd,cAAc,eAAe,OAC7B,wBAAwB,qCAExB,UAAU,0BAA0B,QAAQ,SAAS,kBACrD;;;EAGE;;EAEA,cAAc,OAAO,+BAA+B;IAErD,0BAA0B,QAAQ,SAAS;;;KClFzC,wBAAwB,QAAQ;;;;;;UAOpB,gBACf,cAAc,eAAe,OAC7B,wBAAwB;EAExB,OAAO;EACP,cAAc,0BAA0B,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAmCjC,aACd,cAAc,eAAe,OAC7B,wBAAwB,qCAExB,OAAO,OACP,UAAU,0BAA0B,OAAO,kBAC3C;EAAS,UAAU;IAClB,gBAAgB,OAAO;;;;;;;;;;;;;;;;;wBCzCV,iBAAiB;EAC/B;EACA,UAAU;IACR;;;;;;;;;;;;;;;;;;;;wBCAY,qBAAqB,kBAAkB;;;;;;;UCRtC;EACf,UAAU;EACV,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAyCH,wBAAwB;EACtC,QAAQ;EACR;EACA,WAAW;IACT,UAAU;IACV,iBAAiB;;IAEjB;;;;;;;UC9Ca;EACf;IAAQ;;EACR;EACA,UAAU,cAAc;EACxB;;;;;;;;;;;;;;;;;;;;;;;;wBAyBc,UACd,cAAc,UAAU,SACxB,wBAAwB,qCACxB;EACA,QAAQ;EACR;EACA,WAAW;IACT;MAAY;MAAkB;MAAoB;;IAClD,OAAO;IACP,cAAc,oBAAoB;IAClC,gBAAgB;IAChB,UAAU;;IAEV,0BAA0B,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA0ErB,kBACd,cAAc,UAAU,SACxB,wBAAwB,qCACxB;EACA,QAAQ;EACR;EACA,WAAW;IACT;MAAY;MAAkB;MAAoB;;IAClD,OAAO;IACP,cAAc,oBAAoB;IAClC,gBAAgB;IAChB,UAAU;;IAEV,0BAA0B,OAAO;;;;;;;;;;;;;;;;;;wBCrHf,iBAAiB;EACrC,MAAM,aAAa;;EAEnB;IACE,QAAQ"}