@crediolabs/policy-builder-mcp 0.1.12 → 0.1.13

package/dist-cjs/src/schemas.js

@@ -22,17 +22,24 @@
 // the strict schemas - a drift in field type or optionality breaks the
 // SDK's emitted JSON Schema.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SynthesizePolicyToolShape = exports.RecordTransactionToolShape = exports.ToolErrorSchema = exports.SynthesizePolicyInputSchema = exports.RecordTransactionInputSchema = exports.RecordedTransactionSchema = exports.OzAdapterConfigSchema = exports.NetworkSchema = exports.MandateSpecSchema = exports.InterpreterOptionsSchema = exports.ComposeUserResponsesSchema = void 0;
+exports.GetInterpreterInfoToolShape = exports.RevokePolicyToolShape = exports.InstallPolicyToolShape = exports.VerifyPolicyToolShape = exports.SimulatePolicyToolShape = exports.SynthesizePolicyToolShape = exports.RecordTransactionToolShape = exports.VerifyPolicyInputSchema = exports.ToolErrorSchema = exports.SynthesizePolicyInputSchema = exports.SimulatePolicyInputSchema = exports.RevokePolicyInputSchema = exports.RecordTransactionInputSchema = exports.RecordedTransactionSchema = exports.PredicateNodeSchema = exports.OzAdapterConfigSchema = exports.OraclePriceFixtureSchema = exports.NetworkSchema = exports.MandateSpecSchema = exports.InterpreterOptionsSchema = exports.InstallPolicyInputSchema = exports.GetInterpreterInfoInputSchema = exports.ComposeUserResponsesSchema = void 0;
 const run_1 = require("@crediolabs/policy-synth/run");
 Object.defineProperty(exports, "ComposeUserResponsesSchema", { enumerable: true, get: function () { return run_1.ComposeUserResponsesSchema; } });
+Object.defineProperty(exports, "GetInterpreterInfoInputSchema", { enumerable: true, get: function () { return run_1.GetInterpreterInfoInputSchema; } });
+Object.defineProperty(exports, "InstallPolicyInputSchema", { enumerable: true, get: function () { return run_1.InstallPolicyInputSchema; } });
 Object.defineProperty(exports, "InterpreterOptionsSchema", { enumerable: true, get: function () { return run_1.InterpreterOptionsSchema; } });
 Object.defineProperty(exports, "MandateSpecSchema", { enumerable: true, get: function () { return run_1.MandateSpecSchema; } });
 Object.defineProperty(exports, "NetworkSchema", { enumerable: true, get: function () { return run_1.NetworkSchema; } });
+Object.defineProperty(exports, "OraclePriceFixtureSchema", { enumerable: true, get: function () { return run_1.OraclePriceFixtureSchema; } });
 Object.defineProperty(exports, "OzAdapterConfigSchema", { enumerable: true, get: function () { return run_1.OzAdapterConfigSchema; } });
+Object.defineProperty(exports, "PredicateNodeSchema", { enumerable: true, get: function () { return run_1.PredicateNodeSchema; } });
 Object.defineProperty(exports, "RecordedTransactionSchema", { enumerable: true, get: function () { return run_1.RecordedTransactionSchema; } });
 Object.defineProperty(exports, "RecordTransactionInputSchema", { enumerable: true, get: function () { return run_1.RecordTransactionInputSchema; } });
+Object.defineProperty(exports, "RevokePolicyInputSchema", { enumerable: true, get: function () { return run_1.RevokePolicyInputSchema; } });
+Object.defineProperty(exports, "SimulatePolicyInputSchema", { enumerable: true, get: function () { return run_1.SimulatePolicyInputSchema; } });
 Object.defineProperty(exports, "SynthesizePolicyInputSchema", { enumerable: true, get: function () { return run_1.SynthesizePolicyInputSchema; } });
 Object.defineProperty(exports, "ToolErrorSchema", { enumerable: true, get: function () { return run_1.ToolErrorSchema; } });
+Object.defineProperty(exports, "VerifyPolicyInputSchema", { enumerable: true, get: function () { return run_1.VerifyPolicyInputSchema; } });
 const zod_1 = require("zod");
 /** Flat ZodRawShape used for the MCP SDK tool registration. The body
  *  re-validates against `RecordTransactionInputSchema` so the mutual-exclusion
@@ -55,4 +62,69 @@ exports.SynthesizePolicyToolShape = {
     confidenceOverride: zod_1.z.object({ threshold: zod_1.z.number().min(0).max(1) }).optional(),
     interpreter: run_1.InterpreterOptionsSchema.optional(),
     ozConfig: run_1.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,
+    // and the tree is only returned under `explain`. Omitting it here left an
+    // MCP client able to synthesize a policy and then unable to prove anything
+    // about it - the two checks were reachable only with `predicate: null`,
+    // which skips the interpreter predicate entirely.
+    explain: zod_1.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. */
+exports.SimulatePolicyToolShape = {
+    predicate: zod_1.z.unknown().nullable().optional(),
+    permitTx: run_1.RecordedTransactionSchema,
+    validUntilLedger: zod_1.z.number().int().positive().optional(),
+    oraclePricesByAsset: zod_1.z.record(zod_1.z.string(), run_1.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. */
+exports.VerifyPolicyToolShape = {
+    predicate: zod_1.z.unknown(),
+    permitTx: run_1.RecordedTransactionSchema,
+    validUntilLedger: zod_1.z.number().int().positive().optional(),
+    oraclePricesByAsset: zod_1.z.record(zod_1.z.string(), run_1.OraclePriceFixtureSchema).optional(),
+};
+/** Flat ZodRawShape for `install_policy`. `rule` is typed as `z.unknown()`
+ *  at the tool boundary because the rule schema is a discriminated union
+ *  the SDK does not accept at registration; the body re-validates
+ *  against `InstallPolicyInputSchema`. `encodedPredicate` /
+ *  `predicateHash` live INSIDE `rule.policies[].predicateBlobBase64`
+ *  (the policy already carries the encoded predicate); the run-layer
+ *  extracts them from there. */
+exports.InstallPolicyToolShape = {
+    smartAccount: zod_1.z.string().min(1).optional(),
+    sourceAccount: zod_1.z.string().min(1).optional(),
+    rule: zod_1.z.unknown().optional(),
+    installNonce: zod_1.z.number().int().positive().optional(),
+    interpreterAddress: zod_1.z.string().optional(),
+    rpcUrl: zod_1.z.string().url().optional(),
+    baseFee: zod_1.z.number().int().positive().optional(),
+};
+/** Flat ZodRawShape for `revoke_policy`. */
+exports.RevokePolicyToolShape = {
+    smartAccount: zod_1.z.string().min(1).optional(),
+    sourceAccount: zod_1.z.string().min(1).optional(),
+    ruleId: zod_1.z.number().int().nonnegative().optional(),
+    interpreterAddress: zod_1.z.string().optional(),
+    rpcUrl: zod_1.z.string().url().optional(),
+    baseFee: zod_1.z.number().int().positive().optional(),
+};
+/** 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. */
+exports.GetInterpreterInfoToolShape = {
+    network: zod_1.z.enum(['mainnet', 'testnet']).optional(),
+    verifyLive: zod_1.z.boolean().optional(),
+    rpcUrl: zod_1.z.string().url().optional(),
 };

package/dist-cjs/src/server.js

@@ -39,4 +39,24 @@ function registerTools(server) {
         const res = await (0, run_1.runSynthesizePolicy)(args);
         return (0, result_ts_1.mcpResultFromCore)(res);
     });
+    server.tool('simulate_policy', 'Replay a RecordedTransaction against a proposed PredicateNode (or null for an OZ-only policy) and emit the SimulationResult envelope (permit verdict + deny-case battery). Returns a SIMULATION_ERROR ToolError on runtime evaluation failure.', schemas_ts_1.SimulatePolicyToolShape, async (args) => {
+        const res = await (0, run_1.runSimulatePolicy)(args);
+        return (0, result_ts_1.mcpResultFromCore)(res);
+    });
+    server.tool('verify_policy', 'Run the static minimality check on a proposed PredicateNode against a RecordedTransaction (no conjunct is load-bearing-free). Returns VERIFICATION_FAILED with the dropped-constraint fingerprints when the predicate is over-broad.', schemas_ts_1.VerifyPolicyToolShape, async (args) => {
+        const res = await (0, run_1.runVerifyPolicy)(args);
+        return (0, result_ts_1.mcpResultFromCore)(res);
+    });
+    server.tool('install_policy', 'Build an UNSIGNED Soroban transaction XDR for `account.add_context_rule(...)` that installs a new policy rule on the given smart account. The wallet signs the returned XDR - the signature IS the user-confirmation step (this server is stateless and holds no key material, so there is no two-call confirm pair). Only CALL 1 is emitted; the interpreter `install` follow-up needs the rule id the account assigns in call 1 and is documented in `followUp` in the response.', schemas_ts_1.InstallPolicyToolShape, async (args) => {
+        const res = await (0, run_1.runInstallPolicy)(args);
+        return (0, result_ts_1.mcpResultFromCore)(res);
+    });
+    server.tool('revoke_policy', 'Build an UNSIGNED Soroban transaction XDR for `account.remove_context_rule(ruleId)` that removes a policy rule from the given smart account. The smart account handles uninstalling each attached policy itself. Auth is master-only - the source account MUST be the master signer set; delegated signers cannot uninstall.', schemas_ts_1.RevokePolicyToolShape, async (args) => {
+        const res = await (0, run_1.runRevokePolicy)(args);
+        return (0, result_ts_1.mcpResultFromCore)(res);
+    });
+    server.tool('get_interpreter_info', 'Read-only fingerprint lookup for the policy interpreter contract: returns the pinned address, grammar version, and wasm sha256 (from DEPLOYMENTS.md + SELF_VERSION). When `verifyLive=true`, performs an additional `grammar_version()` RPC call against the pinned address and reports whether the deployed contract matches the pin - a live mismatch check is more useful than a fabricated audit field.', schemas_ts_1.GetInterpreterInfoToolShape, async (args) => {
+        const res = await (0, run_1.runGetInterpreterInfo)(args);
+        return (0, result_ts_1.mcpResultFromCore)(res);
+    });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@crediolabs/policy-builder-mcp",
-  "version": "0.1.12",
+  "version": "0.1.13",
   "license": "MIT",
   "description": "MCP server exposing the OZ policy-synth core (record_transaction + synthesize_policy) over stdio and Streamable HTTP transports.",
   "type": "module",
@@ -63,8 +63,9 @@
     "prepack": "bun run build"
   },
   "dependencies": {
-    "@crediolabs/policy-synth": "0.1.10",
+    "@crediolabs/policy-synth": "workspace:*",
     "@modelcontextprotocol/sdk": "1.18.1",
+    "@stellar/stellar-sdk": "14.4.0",
     "zod": "3.25.76"
   },
   "devDependencies": {

package/src/schemas.ts

@@ -23,14 +23,21 @@
 
 import {
   ComposeUserResponsesSchema,
+  GetInterpreterInfoInputSchema,
+  InstallPolicyInputSchema,
   InterpreterOptionsSchema,
   MandateSpecSchema,
   NetworkSchema,
+  OraclePriceFixtureSchema,
   OzAdapterConfigSchema,
+  PredicateNodeSchema,
   RecordedTransactionSchema,
   RecordTransactionInputSchema,
+  RevokePolicyInputSchema,
+  SimulatePolicyInputSchema,
   SynthesizePolicyInputSchema,
   ToolErrorSchema,
+  VerifyPolicyInputSchema,
 } from '@crediolabs/policy-synth/run'
 import { z } from 'zod'
 
@@ -41,14 +48,21 @@ import { z } from 'zod'
 // package directly.
 export {
   ComposeUserResponsesSchema,
+  GetInterpreterInfoInputSchema,
+  InstallPolicyInputSchema,
   InterpreterOptionsSchema,
   MandateSpecSchema,
   NetworkSchema,
+  OraclePriceFixtureSchema,
   OzAdapterConfigSchema,
+  PredicateNodeSchema,
   RecordedTransactionSchema,
   RecordTransactionInputSchema,
+  RevokePolicyInputSchema,
+  SimulatePolicyInputSchema,
   SynthesizePolicyInputSchema,
   ToolErrorSchema,
+  VerifyPolicyInputSchema,
 }
 
 /** Flat ZodRawShape used for the MCP SDK tool registration. The body
@@ -73,4 +87,85 @@ export const SynthesizePolicyToolShape = {
   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,
+  // and the tree is only returned under `explain`. Omitting it here left an
+  // MCP client able to synthesize a policy and then unable to prove anything
+  // about it - the two checks were reachable only with `predicate: null`,
+  // which skips the interpreter predicate entirely.
+  explain: z.boolean().optional(),
+} as const
+
+/** 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(),
+  permitTx: RecordedTransactionSchema,
+  validUntilLedger: z.number().int().positive().optional(),
+  oraclePricesByAsset: z.record(z.string(), OraclePriceFixtureSchema).optional(),
+} as const
+
+/** 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(),
+} as const
+
+// Re-export the strict input schemas so MCP consumers (and downstream
+// tests) can import the canonical wire shapes from the same module
+// that owns the tool-shape glue.
+export type {
+  GetInterpreterInfoInput,
+  InstallPolicyInput,
+  RevokePolicyInput,
+  SimulatePolicyInput,
+  VerifyPolicyInput,
+} from '@crediolabs/policy-synth/run'
+
+/** Flat ZodRawShape for `install_policy`. `rule` is typed as `z.unknown()`
+ *  at the tool boundary because the rule schema is a discriminated union
+ *  the SDK does not accept at registration; the body re-validates
+ *  against `InstallPolicyInputSchema`. `encodedPredicate` /
+ *  `predicateHash` live INSIDE `rule.policies[].predicateBlobBase64`
+ *  (the policy already carries the encoded predicate); the run-layer
+ *  extracts them from there. */
+export const InstallPolicyToolShape = {
+  smartAccount: z.string().min(1).optional(),
+  sourceAccount: z.string().min(1).optional(),
+  rule: z.unknown().optional(),
+  installNonce: z.number().int().positive().optional(),
+  interpreterAddress: z.string().optional(),
+  rpcUrl: z.string().url().optional(),
+  baseFee: z.number().int().positive().optional(),
+} as const
+
+/** Flat ZodRawShape for `revoke_policy`. */
+export const RevokePolicyToolShape = {
+  smartAccount: z.string().min(1).optional(),
+  sourceAccount: z.string().min(1).optional(),
+  ruleId: z.number().int().nonnegative().optional(),
+  interpreterAddress: z.string().optional(),
+  rpcUrl: z.string().url().optional(),
+  baseFee: z.number().int().positive().optional(),
+} as const
+
+/** 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. */
+export const GetInterpreterInfoToolShape = {
+  network: z.enum(['mainnet', 'testnet']).optional(),
+  verifyLive: z.boolean().optional(),
+  rpcUrl: z.string().url().optional(),
 } as const

package/src/server.ts

@@ -11,10 +11,26 @@
 // shared mutable state across calls; nothing here caches, queues, or holds
 // key material.
 
-import { runRecordTransaction, runSynthesizePolicy } from '@crediolabs/policy-synth/run'
+import {
+  runGetInterpreterInfo,
+  runInstallPolicy,
+  runRecordTransaction,
+  runRevokePolicy,
+  runSimulatePolicy,
+  runSynthesizePolicy,
+  runVerifyPolicy,
+} from '@crediolabs/policy-synth/run'
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
 import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js'
-import { RecordTransactionToolShape, SynthesizePolicyToolShape } from './schemas.ts'
+import {
+  GetInterpreterInfoToolShape,
+  InstallPolicyToolShape,
+  RecordTransactionToolShape,
+  RevokePolicyToolShape,
+  SimulatePolicyToolShape,
+  SynthesizePolicyToolShape,
+  VerifyPolicyToolShape,
+} from './schemas.ts'
 import { mcpResultFromCore } from './tools/result.ts'
 
 /** Build a fresh, stateless MCP server. The caller owns the returned object
@@ -53,4 +69,54 @@ export function registerTools(server: McpServer): void {
       return mcpResultFromCore(res) as unknown as CallToolResult
     }
   )
+
+  server.tool(
+    'simulate_policy',
+    'Replay a RecordedTransaction against a proposed PredicateNode (or null for an OZ-only policy) and emit the SimulationResult envelope (permit verdict + deny-case battery). Returns a SIMULATION_ERROR ToolError on runtime evaluation failure.',
+    SimulatePolicyToolShape,
+    async (args) => {
+      const res = await runSimulatePolicy(args)
+      return mcpResultFromCore(res) as unknown as CallToolResult
+    }
+  )
+
+  server.tool(
+    'verify_policy',
+    'Run the static minimality check on a proposed PredicateNode against a RecordedTransaction (no conjunct is load-bearing-free). Returns VERIFICATION_FAILED with the dropped-constraint fingerprints when the predicate is over-broad.',
+    VerifyPolicyToolShape,
+    async (args) => {
+      const res = await runVerifyPolicy(args)
+      return mcpResultFromCore(res) as unknown as CallToolResult
+    }
+  )
+
+  server.tool(
+    'install_policy',
+    'Build an UNSIGNED Soroban transaction XDR for `account.add_context_rule(...)` that installs a new policy rule on the given smart account. The wallet signs the returned XDR - the signature IS the user-confirmation step (this server is stateless and holds no key material, so there is no two-call confirm pair). Only CALL 1 is emitted; the interpreter `install` follow-up needs the rule id the account assigns in call 1 and is documented in `followUp` in the response.',
+    InstallPolicyToolShape,
+    async (args) => {
+      const res = await runInstallPolicy(args)
+      return mcpResultFromCore(res) as unknown as CallToolResult
+    }
+  )
+
+  server.tool(
+    'revoke_policy',
+    'Build an UNSIGNED Soroban transaction XDR for `account.remove_context_rule(ruleId)` that removes a policy rule from the given smart account. The smart account handles uninstalling each attached policy itself. Auth is master-only - the source account MUST be the master signer set; delegated signers cannot uninstall.',
+    RevokePolicyToolShape,
+    async (args) => {
+      const res = await runRevokePolicy(args)
+      return mcpResultFromCore(res) as unknown as CallToolResult
+    }
+  )
+
+  server.tool(
+    'get_interpreter_info',
+    'Read-only fingerprint lookup for the policy interpreter contract: returns the pinned address, grammar version, and wasm sha256 (from DEPLOYMENTS.md + SELF_VERSION). When `verifyLive=true`, performs an additional `grammar_version()` RPC call against the pinned address and reports whether the deployed contract matches the pin - a live mismatch check is more useful than a fabricated audit field.',
+    GetInterpreterInfoToolShape,
+    async (args) => {
+      const res = await runGetInterpreterInfo(args)
+      return mcpResultFromCore(res) as unknown as CallToolResult
+    }
+  )
 }