@crediolabs/policy-builder-mcp 0.2.0 → 0.3.0

package/README.md

@@ -1,6 +1,6 @@
 # @crediolabs/policy-builder-mcp
 
-MCP server exposing the OctoGate policy toolchain to agents. It wraps
+MCP server exposing the OZ Policy Builder toolchain to agents. It wraps
 [`@crediolabs/policy-synth`](https://www.npmjs.com/package/@crediolabs/policy-synth):
 an agent records a Soroban transaction, synthesises the minimal policy that
 permits exactly that flow, verifies and simulates it, and receives an
@@ -55,9 +55,9 @@ branch on them.
   embedding caller explicitly opts out (`allowExternalHost: true` via the
   programmatic API), because the surface is unauthenticated by design.
 - See the
-  [architecture document](https://github.com/untangledfinance/octogate/blob/main/docs/architecture.md)
+  [architecture document](https://github.com/untangledfinance/oz-policy-builder/blob/main/docs/architecture.md)
   for what the on-chain interpreter does and does not enforce, and the
-  [repository README](https://github.com/untangledfinance/octogate#readme)
+  [repository README](https://github.com/untangledfinance/oz-policy-builder#readme)
   for the contracts' audit status.
 
 ## License

package/dist/src/schemas.d.ts

@@ -1,6 +1,6 @@
-import { ComposeUserResponsesSchema, GetInterpreterInfoInputSchema, InstallPolicyInputSchema, InterpreterOptionsSchema, MandateSpecSchema, NetworkSchema, OraclePriceFixtureSchema, OzAdapterConfigSchema, PredicateNodeSchema, RecordedTransactionSchema, RecordTransactionInputSchema, RevokePolicyInputSchema, SimulatePolicyInputSchema, SynthesizePolicyInputSchema, ToolErrorSchema, VerifyPolicyInputSchema } from '@crediolabs/policy-synth/run';
+import { ComposeUserResponsesSchema, GetInterpreterInfoInputSchema, InstallPolicyInputSchema, InterpreterOptionsSchema, NetworkSchema, PredicateNodeSchema, RecordedTransactionSchema, RecordTransactionInputSchema, RevokePolicyInputSchema, SynthesizePolicyInputSchema, ToolErrorSchema } from '@crediolabs/policy-synth/run';
 import { z } from 'zod';
-export { ComposeUserResponsesSchema, GetInterpreterInfoInputSchema, InstallPolicyInputSchema, InterpreterOptionsSchema, MandateSpecSchema, NetworkSchema, OraclePriceFixtureSchema, OzAdapterConfigSchema, PredicateNodeSchema, RecordedTransactionSchema, RecordTransactionInputSchema, RevokePolicyInputSchema, SimulatePolicyInputSchema, SynthesizePolicyInputSchema, ToolErrorSchema, VerifyPolicyInputSchema, };
+export { ComposeUserResponsesSchema, GetInterpreterInfoInputSchema, InstallPolicyInputSchema, InterpreterOptionsSchema, NetworkSchema, PredicateNodeSchema, RecordedTransactionSchema, RecordTransactionInputSchema, RevokePolicyInputSchema, SynthesizePolicyInputSchema, ToolErrorSchema, };
 /** Flat ZodRawShape used for the MCP SDK tool registration. The body
  *  re-validates against `RecordTransactionInputSchema` so the mutual-exclusion
  *  rule still fires (the SDK does not invoke `.refine()` at registration time). */
@@ -11,156 +11,10 @@ export declare const RecordTransactionToolShape: {
     readonly confidenceOverride: z.ZodOptional<z.ZodNumber>;
 };
 /** Flat ZodRawShape used for MCP tool registration. Every field is optional
- *  so the JSON-Schema the SDK exposes to clients does not forbid either
- *  front-end; the body re-validates against the discriminated union. */
+ *  so the JSON-Schema the SDK exposes to clients stays permissive; the body
+ *  re-validates against the strict schema. */
 export declare const SynthesizePolicyToolShape: {
-    readonly source: z.ZodOptional<z.ZodEnum<["mandate", "recording"]>>;
-    readonly mandate: z.ZodOptional<z.ZodEffects<z.ZodObject<{
-        chain: z.ZodLiteral<"stellar">;
-        contract: z.ZodString;
-        method: z.ZodOptional<z.ZodString>;
-        spendingLimit: z.ZodOptional<z.ZodObject<{
-            token: z.ZodString;
-            limit: z.ZodString;
-            windowSeconds: z.ZodNumber;
-        }, "strip", z.ZodTypeAny, {
-            token: string;
-            limit: string;
-            windowSeconds: number;
-        }, {
-            token: string;
-            limit: string;
-            windowSeconds: number;
-        }>>;
-        approvalThreshold: z.ZodOptional<z.ZodNumber>;
-        recipients: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        expiry: z.ZodOptional<z.ZodObject<{
-            validUntilLedger: z.ZodOptional<z.ZodNumber>;
-            validUntilUnixSeconds: z.ZodOptional<z.ZodNumber>;
-        }, "strip", z.ZodTypeAny, {
-            validUntilLedger?: number | undefined;
-            validUntilUnixSeconds?: number | undefined;
-        }, {
-            validUntilLedger?: number | undefined;
-            validUntilUnixSeconds?: number | undefined;
-        }>>;
-    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
-        chain: z.ZodLiteral<"stellar">;
-        contract: z.ZodString;
-        method: z.ZodOptional<z.ZodString>;
-        spendingLimit: z.ZodOptional<z.ZodObject<{
-            token: z.ZodString;
-            limit: z.ZodString;
-            windowSeconds: z.ZodNumber;
-        }, "strip", z.ZodTypeAny, {
-            token: string;
-            limit: string;
-            windowSeconds: number;
-        }, {
-            token: string;
-            limit: string;
-            windowSeconds: number;
-        }>>;
-        approvalThreshold: z.ZodOptional<z.ZodNumber>;
-        recipients: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        expiry: z.ZodOptional<z.ZodObject<{
-            validUntilLedger: z.ZodOptional<z.ZodNumber>;
-            validUntilUnixSeconds: z.ZodOptional<z.ZodNumber>;
-        }, "strip", z.ZodTypeAny, {
-            validUntilLedger?: number | undefined;
-            validUntilUnixSeconds?: number | undefined;
-        }, {
-            validUntilLedger?: number | undefined;
-            validUntilUnixSeconds?: number | undefined;
-        }>>;
-    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
-        chain: z.ZodLiteral<"stellar">;
-        contract: z.ZodString;
-        method: z.ZodOptional<z.ZodString>;
-        spendingLimit: z.ZodOptional<z.ZodObject<{
-            token: z.ZodString;
-            limit: z.ZodString;
-            windowSeconds: z.ZodNumber;
-        }, "strip", z.ZodTypeAny, {
-            token: string;
-            limit: string;
-            windowSeconds: number;
-        }, {
-            token: string;
-            limit: string;
-            windowSeconds: number;
-        }>>;
-        approvalThreshold: z.ZodOptional<z.ZodNumber>;
-        recipients: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        expiry: z.ZodOptional<z.ZodObject<{
-            validUntilLedger: z.ZodOptional<z.ZodNumber>;
-            validUntilUnixSeconds: z.ZodOptional<z.ZodNumber>;
-        }, "strip", z.ZodTypeAny, {
-            validUntilLedger?: number | undefined;
-            validUntilUnixSeconds?: number | undefined;
-        }, {
-            validUntilLedger?: number | undefined;
-            validUntilUnixSeconds?: number | undefined;
-        }>>;
-    }, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
-        chain: z.ZodLiteral<"stellar">;
-        contract: z.ZodString;
-        method: z.ZodOptional<z.ZodString>;
-        spendingLimit: z.ZodOptional<z.ZodObject<{
-            token: z.ZodString;
-            limit: z.ZodString;
-            windowSeconds: z.ZodNumber;
-        }, "strip", z.ZodTypeAny, {
-            token: string;
-            limit: string;
-            windowSeconds: number;
-        }, {
-            token: string;
-            limit: string;
-            windowSeconds: number;
-        }>>;
-        approvalThreshold: z.ZodOptional<z.ZodNumber>;
-        recipients: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        expiry: z.ZodOptional<z.ZodObject<{
-            validUntilLedger: z.ZodOptional<z.ZodNumber>;
-            validUntilUnixSeconds: z.ZodOptional<z.ZodNumber>;
-        }, "strip", z.ZodTypeAny, {
-            validUntilLedger?: number | undefined;
-            validUntilUnixSeconds?: number | undefined;
-        }, {
-            validUntilLedger?: number | undefined;
-            validUntilUnixSeconds?: number | undefined;
-        }>>;
-    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
-        chain: z.ZodLiteral<"stellar">;
-        contract: z.ZodString;
-        method: z.ZodOptional<z.ZodString>;
-        spendingLimit: z.ZodOptional<z.ZodObject<{
-            token: z.ZodString;
-            limit: z.ZodString;
-            windowSeconds: z.ZodNumber;
-        }, "strip", z.ZodTypeAny, {
-            token: string;
-            limit: string;
-            windowSeconds: number;
-        }, {
-            token: string;
-            limit: string;
-            windowSeconds: number;
-        }>>;
-        approvalThreshold: z.ZodOptional<z.ZodNumber>;
-        recipients: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        expiry: z.ZodOptional<z.ZodObject<{
-            validUntilLedger: z.ZodOptional<z.ZodNumber>;
-            validUntilUnixSeconds: z.ZodOptional<z.ZodNumber>;
-        }, "strip", z.ZodTypeAny, {
-            validUntilLedger?: number | undefined;
-            validUntilUnixSeconds?: number | undefined;
-        }, {
-            validUntilLedger?: number | undefined;
-            validUntilUnixSeconds?: number | undefined;
-        }>>;
-    }, z.ZodTypeAny, "passthrough">>>;
+    readonly source: z.ZodOptional<z.ZodLiteral<"recording">>;
     readonly recordedTx: z.ZodOptional<z.ZodObject<{
         network: z.ZodEnum<["mainnet", "testnet"]>;
         signers: z.ZodArray<z.ZodString, "many">;
@@ -171,15 +25,15 @@ export declare const SynthesizePolicyToolShape: {
             to: z.ZodString;
             amount: z.ZodString;
         }, "strip", z.ZodTypeAny, {
-            amount: string;
-            token: string;
             from: string;
             to: string;
-        }, {
             amount: string;
             token: string;
+        }, {
             from: string;
             to: string;
+            amount: string;
+            token: string;
         }>, "many">;
         events: z.ZodArray<z.ZodObject<{
             contract: z.ZodString;
@@ -257,15 +111,15 @@ export declare const SynthesizePolicyToolShape: {
             to: z.ZodString;
             amount: z.ZodString;
         }, "strip", z.ZodTypeAny, {
-            amount: string;
-            token: string;
             from: string;
             to: string;
-        }, {
             amount: string;
             token: string;
+        }, {
             from: string;
             to: string;
+            amount: string;
+            token: string;
         }>, "many">;
         events: z.ZodArray<z.ZodObject<{
             contract: z.ZodString;
@@ -343,15 +197,15 @@ export declare const SynthesizePolicyToolShape: {
             to: z.ZodString;
             amount: z.ZodString;
         }, "strip", z.ZodTypeAny, {
-            amount: string;
-            token: string;
             from: string;
             to: string;
-        }, {
             amount: string;
             token: string;
+        }, {
             from: string;
             to: string;
+            amount: string;
+            token: string;
         }>, "many">;
         events: z.ZodArray<z.ZodObject<{
             contract: z.ZodString;
@@ -422,72 +276,18 @@ export declare const SynthesizePolicyToolShape: {
     }, z.ZodTypeAny, "passthrough">>>;
     readonly network: z.ZodOptional<z.ZodEnum<["mainnet", "testnet"]>>;
     readonly userResponses: z.ZodOptional<z.ZodObject<{
-        windowSeconds: z.ZodOptional<z.ZodNumber>;
-        validUntilLedger: z.ZodOptional<z.ZodNumber>;
-        limitAmount: z.ZodOptional<z.ZodString>;
-        invocationLimit: z.ZodOptional<z.ZodNumber>;
-        swapRecipientAllowlist: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">>;
-        oraclePriceBound: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            asset: z.ZodEffects<z.ZodString, string, string>;
-            operator: z.ZodEnum<["eq", "lt", "lte", "gt", "gte"]>;
-            value: z.ZodString;
-            decimals: z.ZodNumber;
-        }, "strip", z.ZodTypeAny, {
-            value: string;
-            operator: "eq" | "lt" | "lte" | "gt" | "gte";
-            asset: string;
-            decimals: number;
-        }, {
-            value: string;
-            operator: "eq" | "lt" | "lte" | "gt" | "gte";
-            asset: string;
-            decimals: number;
-        }>, "many">>;
-    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
-        windowSeconds: z.ZodOptional<z.ZodNumber>;
-        validUntilLedger: z.ZodOptional<z.ZodNumber>;
-        limitAmount: z.ZodOptional<z.ZodString>;
-        invocationLimit: z.ZodOptional<z.ZodNumber>;
-        swapRecipientAllowlist: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">>;
-        oraclePriceBound: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            asset: z.ZodEffects<z.ZodString, string, string>;
-            operator: z.ZodEnum<["eq", "lt", "lte", "gt", "gte"]>;
-            value: z.ZodString;
-            decimals: z.ZodNumber;
-        }, "strip", z.ZodTypeAny, {
-            value: string;
-            operator: "eq" | "lt" | "lte" | "gt" | "gte";
-            asset: string;
-            decimals: number;
-        }, {
-            value: string;
-            operator: "eq" | "lt" | "lte" | "gt" | "gte";
-            asset: string;
-            decimals: number;
-        }>, "many">>;
-    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
-        windowSeconds: z.ZodOptional<z.ZodNumber>;
         validUntilLedger: z.ZodOptional<z.ZodNumber>;
         limitAmount: z.ZodOptional<z.ZodString>;
-        invocationLimit: z.ZodOptional<z.ZodNumber>;
         swapRecipientAllowlist: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">>;
-        oraclePriceBound: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            asset: z.ZodEffects<z.ZodString, string, string>;
-            operator: z.ZodEnum<["eq", "lt", "lte", "gt", "gte"]>;
-            value: z.ZodString;
-            decimals: z.ZodNumber;
-        }, "strip", z.ZodTypeAny, {
-            value: string;
-            operator: "eq" | "lt" | "lte" | "gt" | "gte";
-            asset: string;
-            decimals: number;
-        }, {
-            value: string;
-            operator: "eq" | "lt" | "lte" | "gt" | "gte";
-            asset: string;
-            decimals: number;
-        }>, "many">>;
-    }, z.ZodTypeAny, "passthrough">>>;
+    }, "strict", z.ZodTypeAny, {
+        limitAmount?: string | undefined;
+        validUntilLedger?: number | undefined;
+        swapRecipientAllowlist?: string[] | undefined;
+    }, {
+        limitAmount?: string | undefined;
+        validUntilLedger?: number | undefined;
+        swapRecipientAllowlist?: string[] | undefined;
+    }>>;
     readonly confidenceOverride: z.ZodOptional<z.ZodObject<{
         threshold: z.ZodNumber;
     }, "strip", z.ZodTypeAny, {
@@ -498,73 +298,17 @@ export declare const SynthesizePolicyToolShape: {
     readonly interpreter: z.ZodOptional<z.ZodObject<{
         smartAccountAddress: z.ZodString;
         installNonce: z.ZodOptional<z.ZodNumber>;
-        oracleParams: z.ZodOptional<z.ZodObject<{
-            maxStalenessSeconds: z.ZodOptional<z.ZodNumber>;
-            maxDeviationBps: z.ZodOptional<z.ZodNumber>;
-        }, "strip", z.ZodTypeAny, {
-            maxStalenessSeconds?: number | undefined;
-            maxDeviationBps?: number | undefined;
-        }, {
-            maxStalenessSeconds?: number | undefined;
-            maxDeviationBps?: number | undefined;
-        }>>;
     }, "strip", z.ZodTypeAny, {
         smartAccountAddress: string;
-        oracleParams?: {
-            maxStalenessSeconds?: number | undefined;
-            maxDeviationBps?: number | undefined;
-        } | undefined;
         installNonce?: number | undefined;
     }, {
         smartAccountAddress: string;
-        oracleParams?: {
-            maxStalenessSeconds?: number | undefined;
-            maxDeviationBps?: number | undefined;
-        } | undefined;
         installNonce?: number | undefined;
     }>>;
-    readonly ozConfig: z.ZodOptional<z.ZodObject<{
-        network: z.ZodEnum<["mainnet", "testnet"]>;
-        instances: z.ZodObject<{
-            spending_limit: z.ZodString;
-            simple_threshold: z.ZodString;
-            weighted_threshold: z.ZodString;
-        }, "strip", z.ZodTypeAny, {
-            spending_limit: string;
-            simple_threshold: string;
-            weighted_threshold: string;
-        }, {
-            spending_limit: string;
-            simple_threshold: string;
-            weighted_threshold: string;
-        }>;
-    }, "strip", z.ZodTypeAny, {
-        network: "mainnet" | "testnet";
-        instances: {
-            spending_limit: string;
-            simple_threshold: string;
-            weighted_threshold: string;
-        };
-    }, {
-        network: "mainnet" | "testnet";
-        instances: {
-            spending_limit: string;
-            simple_threshold: string;
-            weighted_threshold: string;
-        };
-    }>>;
     readonly explain: z.ZodOptional<z.ZodBoolean>;
 };
-/** Flat ZodRawShape for `simulate_policy`. The `predicate` is typed as
- *  `z.unknown()` at the tool boundary because the recursive
- *  `PredicateNodeSchema` is a `z.lazy()` union (the SDK does not accept
- *  unions at the tool-registration boundary); the body re-validates
- *  against `SimulatePolicyInputSchema`, which fails closed on a
- *  malformed predicate. `predicate` is nullable here (vs required for
- *  verify_policy) so the SDK-emitted JSON Schema mirrors the engine's
- *  "OZ-only / no interpreter predicate" contract. */
 export declare const SimulatePolicyToolShape: {
-    readonly predicate: z.ZodOptional<z.ZodNullable<z.ZodUnknown>>;
+    readonly predicate: z.ZodType<unknown, z.ZodTypeDef, unknown>;
     readonly permitTx: z.ZodObject<{
         network: z.ZodEnum<["mainnet", "testnet"]>;
         signers: z.ZodArray<z.ZodString, "many">;
@@ -575,15 +319,15 @@ export declare const SimulatePolicyToolShape: {
             to: z.ZodString;
             amount: z.ZodString;
         }, "strip", z.ZodTypeAny, {
-            amount: string;
-            token: string;
             from: string;
             to: string;
-        }, {
             amount: string;
             token: string;
+        }, {
             from: string;
             to: string;
+            amount: string;
+            token: string;
         }>, "many">;
         events: z.ZodArray<z.ZodObject<{
             contract: z.ZodString;
@@ -661,15 +405,15 @@ export declare const SimulatePolicyToolShape: {
             to: z.ZodString;
             amount: z.ZodString;
         }, "strip", z.ZodTypeAny, {
-            amount: string;
-            token: string;
             from: string;
             to: string;
-        }, {
             amount: string;
             token: string;
+        }, {
             from: string;
             to: string;
+            amount: string;
+            token: string;
         }>, "many">;
         events: z.ZodArray<z.ZodObject<{
             contract: z.ZodString;
@@ -747,15 +491,15 @@ export declare const SimulatePolicyToolShape: {
             to: z.ZodString;
             amount: z.ZodString;
         }, "strip", z.ZodTypeAny, {
-            amount: string;
-            token: string;
             from: string;
             to: string;
-        }, {
             amount: string;
             token: string;
+        }, {
             from: string;
             to: string;
+            amount: string;
+            token: string;
         }>, "many">;
         events: z.ZodArray<z.ZodObject<{
             contract: z.ZodString;
@@ -825,29 +569,9 @@ export declare const SimulatePolicyToolShape: {
         sourceAccount: z.ZodString;
     }, z.ZodTypeAny, "passthrough">>;
     readonly validUntilLedger: z.ZodOptional<z.ZodNumber>;
-    readonly oraclePricesByAsset: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodObject<{
-        price: z.ZodString;
-        timestampSeconds: z.ZodNumber;
-    }, "strip", z.ZodTypeAny, {
-        price: string;
-        timestampSeconds: number;
-    }, {
-        price: string;
-        timestampSeconds: number;
-    }>, z.ZodObject<{
-        error: z.ZodEnum<["stale", "missing", "deviation", "paused", "decimals", "fingerprint"]>;
-    }, "strip", z.ZodTypeAny, {
-        error: "stale" | "missing" | "deviation" | "paused" | "decimals" | "fingerprint";
-    }, {
-        error: "stale" | "missing" | "deviation" | "paused" | "decimals" | "fingerprint";
-    }>]>>>;
 };
-/** Flat ZodRawShape for `verify_policy`. Same `z.unknown()` boundary
- *  trick for `predicate` as `SimulatePolicyToolShape`; `predicate` is
- *  required at the strict-schema level (`VerifyPolicyInputSchema`) so
- *  the body fails closed on a missing predicate. */
 export declare const VerifyPolicyToolShape: {
-    readonly predicate: z.ZodUnknown;
+    readonly predicate: z.ZodType<unknown, z.ZodTypeDef, unknown>;
     readonly permitTx: z.ZodObject<{
         network: z.ZodEnum<["mainnet", "testnet"]>;
         signers: z.ZodArray<z.ZodString, "many">;
@@ -858,15 +582,15 @@ export declare const VerifyPolicyToolShape: {
             to: z.ZodString;
             amount: z.ZodString;
         }, "strip", z.ZodTypeAny, {
-            amount: string;
-            token: string;
             from: string;
             to: string;
-        }, {
             amount: string;
             token: string;
+        }, {
             from: string;
             to: string;
+            amount: string;
+            token: string;
         }>, "many">;
         events: z.ZodArray<z.ZodObject<{
             contract: z.ZodString;
@@ -944,15 +668,15 @@ export declare const VerifyPolicyToolShape: {
             to: z.ZodString;
             amount: z.ZodString;
         }, "strip", z.ZodTypeAny, {
-            amount: string;
-            token: string;
             from: string;
             to: string;
-        }, {
             amount: string;
             token: string;
+        }, {
             from: string;
             to: string;
+            amount: string;
+            token: string;
         }>, "many">;
         events: z.ZodArray<z.ZodObject<{
             contract: z.ZodString;
@@ -1030,15 +754,15 @@ export declare const VerifyPolicyToolShape: {
             to: z.ZodString;
             amount: z.ZodString;
         }, "strip", z.ZodTypeAny, {
-            amount: string;
-            token: string;
             from: string;
             to: string;
-        }, {
             amount: string;
             token: string;
+        }, {
             from: string;
             to: string;
+            amount: string;
+            token: string;
         }>, "many">;
         events: z.ZodArray<z.ZodObject<{
             contract: z.ZodString;
@@ -1108,22 +832,6 @@ export declare const VerifyPolicyToolShape: {
         sourceAccount: z.ZodString;
     }, z.ZodTypeAny, "passthrough">>;
     readonly validUntilLedger: z.ZodOptional<z.ZodNumber>;
-    readonly oraclePricesByAsset: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodObject<{
-        price: z.ZodString;
-        timestampSeconds: z.ZodNumber;
-    }, "strip", z.ZodTypeAny, {
-        price: string;
-        timestampSeconds: number;
-    }, {
-        price: string;
-        timestampSeconds: number;
-    }>, z.ZodObject<{
-        error: z.ZodEnum<["stale", "missing", "deviation", "paused", "decimals", "fingerprint"]>;
-    }, "strip", z.ZodTypeAny, {
-        error: "stale" | "missing" | "deviation" | "paused" | "decimals" | "fingerprint";
-    }, {
-        error: "stale" | "missing" | "deviation" | "paused" | "decimals" | "fingerprint";
-    }>]>>>;
 };
 export type { GetInterpreterInfoInput, InstallPolicyInput, RevokePolicyInput, SimulatePolicyInput, VerifyPolicyInput, } from '@crediolabs/policy-synth/run';
 /** Flat ZodRawShape for `install_policy`. `rule` is typed as `z.unknown()`
@@ -1151,17 +859,6 @@ export declare const RevokePolicyToolShape: {
     readonly rpcUrl: z.ZodOptional<z.ZodString>;
     readonly baseFee: z.ZodOptional<z.ZodNumber>;
 };
-/** Flat ZodRawShape for `merge_policy`: the tightening remedy when two rules
- *  our interpreter polices can serve the same calls. Two steps, in order. */
-export declare const MergePolicyToolShape: {
-    readonly ruleId: z.ZodNumber;
-    readonly incomingPredicateBlobBase64: z.ZodString;
-    readonly step: z.ZodEnum<["detach", "reinstall"]>;
-    readonly smartAccount: z.ZodOptional<z.ZodString>;
-    readonly sourceAccount: z.ZodOptional<z.ZodString>;
-    readonly rpcUrl: z.ZodOptional<z.ZodString>;
-    readonly baseFee: z.ZodOptional<z.ZodNumber>;
-};
 /** Flat ZodRawShape for `get_interpreter_info`. `verifyLive` triggers an
  *  optional RPC `grammar_version()` call so the caller can verify the
  *  deployed contract matches the pin. */

package/dist/src/schemas.js

@@ -20,14 +20,14 @@
 // `ZodEffects`, which has no `.shape`). They MUST stay in lockstep with
 // the strict schemas - a drift in field type or optionality breaks the
 // SDK's emitted JSON Schema.
-import { ComposeUserResponsesSchema, GetInterpreterInfoInputSchema, InstallPolicyInputSchema, InterpreterOptionsSchema, MandateSpecSchema, NetworkSchema, OraclePriceFixtureSchema, OzAdapterConfigSchema, PredicateNodeSchema, RecordedTransactionSchema, RecordTransactionInputSchema, RevokePolicyInputSchema, SimulatePolicyInputSchema, SynthesizePolicyInputSchema, ToolErrorSchema, VerifyPolicyInputSchema, } from '@crediolabs/policy-synth/run';
+import { ComposeUserResponsesSchema, GetInterpreterInfoInputSchema, InstallPolicyInputSchema, InterpreterOptionsSchema, NetworkSchema, PredicateNodeSchema, RecordedTransactionSchema, RecordTransactionInputSchema, RevokePolicyInputSchema, SynthesizePolicyInputSchema, ToolErrorSchema, } from '@crediolabs/policy-synth/run';
 import { z } from 'zod';
 // Re-export the strict schemas so MCP package consumers (and existing tests)
 // still get them from this module. The canonical home is
 // `@crediolabs/policy-synth/run`; the re-exports here are a shim kept for
 // backward compatibility with downstream callers that imported from the MCP
 // package directly.
-export { ComposeUserResponsesSchema, GetInterpreterInfoInputSchema, InstallPolicyInputSchema, InterpreterOptionsSchema, MandateSpecSchema, NetworkSchema, OraclePriceFixtureSchema, OzAdapterConfigSchema, PredicateNodeSchema, RecordedTransactionSchema, RecordTransactionInputSchema, RevokePolicyInputSchema, SimulatePolicyInputSchema, SynthesizePolicyInputSchema, ToolErrorSchema, VerifyPolicyInputSchema, };
+export { ComposeUserResponsesSchema, GetInterpreterInfoInputSchema, InstallPolicyInputSchema, InterpreterOptionsSchema, NetworkSchema, PredicateNodeSchema, RecordedTransactionSchema, RecordTransactionInputSchema, RevokePolicyInputSchema, SynthesizePolicyInputSchema, ToolErrorSchema, };
 /** Flat ZodRawShape used for the MCP SDK tool registration. The body
  *  re-validates against `RecordTransactionInputSchema` so the mutual-exclusion
  *  rule still fires (the SDK does not invoke `.refine()` at registration time). */
@@ -38,17 +38,15 @@ export const RecordTransactionToolShape = {
     confidenceOverride: z.number().min(0).max(1).optional(),
 };
 /** Flat ZodRawShape used for MCP tool registration. Every field is optional
- *  so the JSON-Schema the SDK exposes to clients does not forbid either
- *  front-end; the body re-validates against the discriminated union. */
+ *  so the JSON-Schema the SDK exposes to clients stays permissive; the body
+ *  re-validates against the strict schema. */
 export const SynthesizePolicyToolShape = {
-    source: z.enum(['mandate', 'recording']).optional(),
-    mandate: MandateSpecSchema.optional(),
+    source: z.literal('recording').optional(),
     recordedTx: RecordedTransactionSchema.optional(),
     network: NetworkSchema.optional(),
     userResponses: ComposeUserResponsesSchema.optional(),
     confidenceOverride: z.object({ threshold: z.number().min(0).max(1) }).optional(),
     interpreter: InterpreterOptionsSchema.optional(),
-    ozConfig: OzAdapterConfigSchema.optional(),
     // Without this the tool chain has no join. A ProposedPolicy carries
     // `policyDocuments[].encodedPredicate` (canonical ScVal bytes), while
     // `simulate_policy` and `verify_policy` both want the PredicateNode TREE,
@@ -58,30 +56,16 @@ export const SynthesizePolicyToolShape = {
     // which skips the interpreter predicate entirely.
     explain: z.boolean().optional(),
 };
-/** Flat ZodRawShape for `simulate_policy`. The `predicate` is typed as
- *  `z.unknown()` at the tool boundary because the recursive
- *  `PredicateNodeSchema` is a `z.lazy()` union (the SDK does not accept
- *  unions at the tool-registration boundary); the body re-validates
- *  against `SimulatePolicyInputSchema`, which fails closed on a
- *  malformed predicate. `predicate` is nullable here (vs required for
- *  verify_policy) so the SDK-emitted JSON Schema mirrors the engine's
- *  "OZ-only / no interpreter predicate" contract. */
-export const SimulatePolicyToolShape = {
-    predicate: z.unknown().nullable().optional(),
+/** `simulate_policy` and `verify_policy` share their input: the predicate tree
+ *  (from `synthesize_policy` under `explain`) plus the recording it was
+ *  synthesised from. */
+const PolicyCheckToolShape = {
+    predicate: PredicateNodeSchema,
     permitTx: RecordedTransactionSchema,
     validUntilLedger: z.number().int().positive().optional(),
-    oraclePricesByAsset: z.record(z.string(), OraclePriceFixtureSchema).optional(),
-};
-/** Flat ZodRawShape for `verify_policy`. Same `z.unknown()` boundary
- *  trick for `predicate` as `SimulatePolicyToolShape`; `predicate` is
- *  required at the strict-schema level (`VerifyPolicyInputSchema`) so
- *  the body fails closed on a missing predicate. */
-export const VerifyPolicyToolShape = {
-    predicate: z.unknown(),
-    permitTx: RecordedTransactionSchema,
-    validUntilLedger: z.number().int().positive().optional(),
-    oraclePricesByAsset: z.record(z.string(), OraclePriceFixtureSchema).optional(),
 };
+export const SimulatePolicyToolShape = { ...PolicyCheckToolShape };
+export const VerifyPolicyToolShape = { ...PolicyCheckToolShape };
 /** Common base for `install_policy` and `revoke_policy`: smartAccount,
  *  sourceAccount, optional RPC URL, optional base fee. Both share the
  *  same smart-account context, so the SDK-emitted JSON Schema stays
@@ -112,14 +96,6 @@ export const RevokePolicyToolShape = {
     ruleId: z.number().int().nonnegative().optional(),
     interpreterAddress: z.string().optional(),
 };
-/** Flat ZodRawShape for `merge_policy`: the tightening remedy when two rules
- *  our interpreter polices can serve the same calls. Two steps, in order. */
-export const MergePolicyToolShape = {
-    ...SmartAccountToolShape,
-    ruleId: z.number().int().nonnegative(),
-    incomingPredicateBlobBase64: z.string().min(1),
-    step: z.enum(['detach', 'reinstall']),
-};
 /** Flat ZodRawShape for `get_interpreter_info`. `verifyLive` triggers an
  *  optional RPC `grammar_version()` call so the caller can verify the
  *  deployed contract matches the pin. */