@crediolabs/policy-builder-mcp 0.1.11 → 0.1.13

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, InterpreterOptionsSchema, MandateSpecSchema, NetworkSchema, OzAdapterConfigSchema, RecordedTransactionSchema, RecordTransactionInputSchema, SynthesizePolicyInputSchema, ToolErrorSchema, } from '@crediolabs/policy-synth/run';
+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';
 // 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, InterpreterOptionsSchema, MandateSpecSchema, NetworkSchema, OzAdapterConfigSchema, RecordedTransactionSchema, RecordTransactionInputSchema, SynthesizePolicyInputSchema, ToolErrorSchema, };
+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
  *  re-validates against `RecordTransactionInputSchema` so the mutual-exclusion
  *  rule still fires (the SDK does not invoke `.refine()` at registration time). */
@@ -49,4 +49,69 @@ 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(),
+};
+/** 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(),
+};
+/** 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(),
+};
+/** 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(),
+};
+/** 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(),
+};
+/** 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(),
 };

package/dist/src/server.js

@@ -10,9 +10,9 @@
 // Stateless: a fresh McpServer is constructed per transport (stdio/HTTP). No
 // 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 { RecordTransactionToolShape, SynthesizePolicyToolShape } from "./schemas.js";
+import { GetInterpreterInfoToolShape, InstallPolicyToolShape, RecordTransactionToolShape, RevokePolicyToolShape, SimulatePolicyToolShape, SynthesizePolicyToolShape, VerifyPolicyToolShape, } from "./schemas.js";
 import { mcpResultFromCore } from "./tools/result.js";
 /** Build a fresh, stateless MCP server. The caller owns the returned object
  *  and connects it to a single transport (stdio or Streamable HTTP). */
@@ -35,4 +35,24 @@ export function registerTools(server) {
         const res = await runSynthesizePolicy(args);
         return 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.', SimulatePolicyToolShape, async (args) => {
+        const res = await runSimulatePolicy(args);
+        return 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.', VerifyPolicyToolShape, async (args) => {
+        const res = await runVerifyPolicy(args);
+        return 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.', InstallPolicyToolShape, async (args) => {
+        const res = await runInstallPolicy(args);
+        return 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.', RevokePolicyToolShape, async (args) => {
+        const res = await runRevokePolicy(args);
+        return 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.', GetInterpreterInfoToolShape, async (args) => {
+        const res = await runGetInterpreterInfo(args);
+        return mcpResultFromCore(res);
+    });
 }