@crediolabs/policy-builder-mcp 0.1.6 → 0.1.7

package/dist-cjs/src/schemas.d.ts

@@ -0,0 +1,447 @@
+import { ComposeUserResponsesSchema, InterpreterOptionsSchema, MandateSpecSchema, NetworkSchema, OzAdapterConfigSchema, RecordedTransactionSchema, RecordTransactionInputSchema, SynthesizePolicyInputSchema, ToolErrorSchema } from '@crediolabs/policy-synth/run';
+import { z } from 'zod';
+export { ComposeUserResponsesSchema, InterpreterOptionsSchema, MandateSpecSchema, NetworkSchema, OzAdapterConfigSchema, RecordedTransactionSchema, RecordTransactionInputSchema, 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). */
+export declare const RecordTransactionToolShape: {
+    readonly hash: z.ZodOptional<z.ZodString>;
+    readonly xdr: z.ZodOptional<z.ZodString>;
+    readonly network: z.ZodEnum<["mainnet", "testnet"]>;
+    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. */
+export declare const SynthesizePolicyToolShape: {
+    readonly source: z.ZodOptional<z.ZodEnum<["mandate", "recording"]>>;
+    readonly mandate: z.ZodOptional<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">>>;
+    readonly recordedTx: z.ZodOptional<z.ZodObject<{
+        network: z.ZodEnum<["mainnet", "testnet"]>;
+        signers: z.ZodArray<z.ZodString, "many">;
+        invocations: z.ZodArray<z.ZodType<unknown, z.ZodTypeDef, unknown>, "many">;
+        tokenMovements: z.ZodArray<z.ZodObject<{
+            token: z.ZodString;
+            from: z.ZodString;
+            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;
+        }>, "many">;
+        events: z.ZodArray<z.ZodObject<{
+            contract: z.ZodString;
+            topics: z.ZodArray<z.ZodString, "many">;
+            data: z.ZodType<unknown, z.ZodTypeDef, unknown>;
+        }, "strip", z.ZodTypeAny, {
+            contract: string;
+            topics: string[];
+            data?: unknown;
+        }, {
+            contract: string;
+            topics: string[];
+            data?: unknown;
+        }>, "many">;
+        authEntries: z.ZodArray<z.ZodUnknown, "many">;
+        ledgerSequence: z.ZodNumber;
+        fetchedAt: z.ZodNumber;
+        parseConfidence: z.ZodObject<{
+            overall: z.ZodNumber;
+            knownContracts: z.ZodArray<z.ZodString, "many">;
+            unknownContracts: z.ZodArray<z.ZodObject<{
+                contract: z.ZodString;
+                reason: z.ZodEnum<["no-abi", "version-mismatch", "opaque-result"]>;
+            }, "strip", z.ZodTypeAny, {
+                contract: string;
+                reason: "no-abi" | "version-mismatch" | "opaque-result";
+            }, {
+                contract: string;
+                reason: "no-abi" | "version-mismatch" | "opaque-result";
+            }>, "many">;
+            opaqueScVals: z.ZodArray<z.ZodObject<{
+                path: z.ZodString;
+                type: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                type: string;
+                path: string;
+            }, {
+                type: string;
+                path: string;
+            }>, "many">;
+            thresholdUsed: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            opaqueScVals: {
+                type: string;
+                path: string;
+            }[];
+            unknownContracts: {
+                contract: string;
+                reason: "no-abi" | "version-mismatch" | "opaque-result";
+            }[];
+            overall: number;
+            knownContracts: string[];
+            thresholdUsed: number;
+        }, {
+            opaqueScVals: {
+                type: string;
+                path: string;
+            }[];
+            unknownContracts: {
+                contract: string;
+                reason: "no-abi" | "version-mismatch" | "opaque-result";
+            }[];
+            overall: number;
+            knownContracts: string[];
+            thresholdUsed: number;
+        }>;
+        sourceAccount: z.ZodString;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        network: z.ZodEnum<["mainnet", "testnet"]>;
+        signers: z.ZodArray<z.ZodString, "many">;
+        invocations: z.ZodArray<z.ZodType<unknown, z.ZodTypeDef, unknown>, "many">;
+        tokenMovements: z.ZodArray<z.ZodObject<{
+            token: z.ZodString;
+            from: z.ZodString;
+            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;
+        }>, "many">;
+        events: z.ZodArray<z.ZodObject<{
+            contract: z.ZodString;
+            topics: z.ZodArray<z.ZodString, "many">;
+            data: z.ZodType<unknown, z.ZodTypeDef, unknown>;
+        }, "strip", z.ZodTypeAny, {
+            contract: string;
+            topics: string[];
+            data?: unknown;
+        }, {
+            contract: string;
+            topics: string[];
+            data?: unknown;
+        }>, "many">;
+        authEntries: z.ZodArray<z.ZodUnknown, "many">;
+        ledgerSequence: z.ZodNumber;
+        fetchedAt: z.ZodNumber;
+        parseConfidence: z.ZodObject<{
+            overall: z.ZodNumber;
+            knownContracts: z.ZodArray<z.ZodString, "many">;
+            unknownContracts: z.ZodArray<z.ZodObject<{
+                contract: z.ZodString;
+                reason: z.ZodEnum<["no-abi", "version-mismatch", "opaque-result"]>;
+            }, "strip", z.ZodTypeAny, {
+                contract: string;
+                reason: "no-abi" | "version-mismatch" | "opaque-result";
+            }, {
+                contract: string;
+                reason: "no-abi" | "version-mismatch" | "opaque-result";
+            }>, "many">;
+            opaqueScVals: z.ZodArray<z.ZodObject<{
+                path: z.ZodString;
+                type: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                type: string;
+                path: string;
+            }, {
+                type: string;
+                path: string;
+            }>, "many">;
+            thresholdUsed: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            opaqueScVals: {
+                type: string;
+                path: string;
+            }[];
+            unknownContracts: {
+                contract: string;
+                reason: "no-abi" | "version-mismatch" | "opaque-result";
+            }[];
+            overall: number;
+            knownContracts: string[];
+            thresholdUsed: number;
+        }, {
+            opaqueScVals: {
+                type: string;
+                path: string;
+            }[];
+            unknownContracts: {
+                contract: string;
+                reason: "no-abi" | "version-mismatch" | "opaque-result";
+            }[];
+            overall: number;
+            knownContracts: string[];
+            thresholdUsed: number;
+        }>;
+        sourceAccount: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        network: z.ZodEnum<["mainnet", "testnet"]>;
+        signers: z.ZodArray<z.ZodString, "many">;
+        invocations: z.ZodArray<z.ZodType<unknown, z.ZodTypeDef, unknown>, "many">;
+        tokenMovements: z.ZodArray<z.ZodObject<{
+            token: z.ZodString;
+            from: z.ZodString;
+            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;
+        }>, "many">;
+        events: z.ZodArray<z.ZodObject<{
+            contract: z.ZodString;
+            topics: z.ZodArray<z.ZodString, "many">;
+            data: z.ZodType<unknown, z.ZodTypeDef, unknown>;
+        }, "strip", z.ZodTypeAny, {
+            contract: string;
+            topics: string[];
+            data?: unknown;
+        }, {
+            contract: string;
+            topics: string[];
+            data?: unknown;
+        }>, "many">;
+        authEntries: z.ZodArray<z.ZodUnknown, "many">;
+        ledgerSequence: z.ZodNumber;
+        fetchedAt: z.ZodNumber;
+        parseConfidence: z.ZodObject<{
+            overall: z.ZodNumber;
+            knownContracts: z.ZodArray<z.ZodString, "many">;
+            unknownContracts: z.ZodArray<z.ZodObject<{
+                contract: z.ZodString;
+                reason: z.ZodEnum<["no-abi", "version-mismatch", "opaque-result"]>;
+            }, "strip", z.ZodTypeAny, {
+                contract: string;
+                reason: "no-abi" | "version-mismatch" | "opaque-result";
+            }, {
+                contract: string;
+                reason: "no-abi" | "version-mismatch" | "opaque-result";
+            }>, "many">;
+            opaqueScVals: z.ZodArray<z.ZodObject<{
+                path: z.ZodString;
+                type: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                type: string;
+                path: string;
+            }, {
+                type: string;
+                path: string;
+            }>, "many">;
+            thresholdUsed: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            opaqueScVals: {
+                type: string;
+                path: string;
+            }[];
+            unknownContracts: {
+                contract: string;
+                reason: "no-abi" | "version-mismatch" | "opaque-result";
+            }[];
+            overall: number;
+            knownContracts: string[];
+            thresholdUsed: number;
+        }, {
+            opaqueScVals: {
+                type: string;
+                path: string;
+            }[];
+            unknownContracts: {
+                contract: string;
+                reason: "no-abi" | "version-mismatch" | "opaque-result";
+            }[];
+            overall: number;
+            knownContracts: string[];
+            thresholdUsed: number;
+        }>;
+        sourceAccount: z.ZodString;
+    }, 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>;
+    }, "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>;
+    }, 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>;
+    }, z.ZodTypeAny, "passthrough">>>;
+    readonly confidenceOverride: z.ZodOptional<z.ZodObject<{
+        threshold: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        threshold: number;
+    }, {
+        threshold: number;
+    }>>;
+    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;
+        };
+    }>>;
+};

package/dist-cjs/src/schemas.js

@@ -0,0 +1,58 @@
+"use strict";
+// apps/policy-builder-mcp/src/schemas.ts
+//
+// MCP-only tool shapes. The CORE input/output schemas and the MCP server
+// registrations all live on `@crediolabs/policy-synth` (the tool-body glue
+// sits at `@crediolabs/policy-synth/run`; the underlying Zod input schemas
+// live at `@crediolabs/policy-synth/run`). What stays here is just the flat
+// `ZodRawShape` needed by `@modelcontextprotocol/sdk`'s `tool()` registration
+// API, which does not accept the strict discriminated union `synthesize_policy`
+// needs.
+//
+// The body of every tool call re-validates against the strict schemas via
+// `runRecordTransaction` / `runSynthesizePolicy`, so wire inputs still
+// fail closed. The mutual-exclusion rules (e.g. exactly-one-of hash/xdr)
+// live on the strict schemas, NOT on the tool shape; the SDK does not
+// invoke `.refine()` at registration time, so any refined rule must be
+// re-checked in the body.
+//
+// The tool-shape fields below are hand-rolled simple types rather than
+// references into the refined strict schemas (`.refine()` returns
+// `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.
+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;
+const run_1 = require("@crediolabs/policy-synth/run");
+Object.defineProperty(exports, "ComposeUserResponsesSchema", { enumerable: true, get: function () { return run_1.ComposeUserResponsesSchema; } });
+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, "OzAdapterConfigSchema", { enumerable: true, get: function () { return run_1.OzAdapterConfigSchema; } });
+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, "SynthesizePolicyInputSchema", { enumerable: true, get: function () { return run_1.SynthesizePolicyInputSchema; } });
+Object.defineProperty(exports, "ToolErrorSchema", { enumerable: true, get: function () { return run_1.ToolErrorSchema; } });
+const zod_1 = require("zod");
+/** 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). */
+exports.RecordTransactionToolShape = {
+    hash: zod_1.z.string().min(1).optional(),
+    xdr: zod_1.z.string().min(1).optional(),
+    network: run_1.NetworkSchema,
+    confidenceOverride: zod_1.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. */
+exports.SynthesizePolicyToolShape = {
+    source: zod_1.z.enum(['mandate', 'recording']).optional(),
+    mandate: run_1.MandateSpecSchema.optional(),
+    recordedTx: run_1.RecordedTransactionSchema.optional(),
+    network: run_1.NetworkSchema.optional(),
+    userResponses: run_1.ComposeUserResponsesSchema.optional(),
+    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(),
+};

package/dist-cjs/src/server.d.ts

@@ -0,0 +1,6 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+/** Build a fresh, stateless MCP server. The caller owns the returned object
+ *  and connects it to a single transport (stdio or Streamable HTTP). */
+export declare function createMcpServer(): McpServer;
+/** Idempotent registration of the T1 tool set on the given server. */
+export declare function registerTools(server: McpServer): void;

package/dist-cjs/src/server.js

@@ -0,0 +1,42 @@
+"use strict";
+// apps/policy-builder-mcp/src/server.ts
+//
+// Registers the T1 tool surface on a fresh McpServer instance. The
+// registration uses the official MCP SDK's `tool()` API with ZodRawShape
+// schemas (the SDK does not accept ZodEffects / discriminated unions at the
+// tool registration boundary - the known gotcha). The body re-validates
+// against the strict discriminated union in `@crediolabs/policy-synth/run`
+// so wire inputs still fail closed.
+//
+// Stateless: a fresh McpServer is constructed per transport (stdio/HTTP). No
+// shared mutable state across calls; nothing here caches, queues, or holds
+// key material.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMcpServer = createMcpServer;
+exports.registerTools = registerTools;
+const run_1 = require("@crediolabs/policy-synth/run");
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const schemas_ts_1 = require("./schemas.js");
+const result_ts_1 = require("./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). */
+function createMcpServer() {
+    const server = new mcp_js_1.McpServer({ name: 'policy-builder-mcp', version: '0.0.0' }, { capabilities: { tools: {} } });
+    registerTools(server);
+    return server;
+}
+/** Idempotent registration of the T1 tool set on the given server. */
+function registerTools(server) {
+    server.tool('record_transaction', 'Decode a Soroban transaction (on-chain hash OR base64 envelope XDR) into a RecordedTransaction. Returns a machine-readable ToolError on validation failure.', schemas_ts_1.RecordTransactionToolShape, async (args) => {
+        const res = await (0, run_1.runRecordTransaction)(args);
+        // Our envelope types `structuredContent` precisely (T / ToolError); the
+        // SDK's CallToolResult widens it to Record<string, unknown>, so the
+        // nominal types do not overlap. The runtime shapes match, so assert
+        // through `unknown` at this transport boundary.
+        return (0, result_ts_1.mcpResultFromCore)(res);
+    });
+    server.tool('synthesize_policy', 'Synthesize a ProposedPolicy from either a deterministic MandateSpec (`source: mandate`) or a RecordedTransaction (`source: recording`). The discriminated `source` field selects the front-end.', schemas_ts_1.SynthesizePolicyToolShape, async (args) => {
+        const res = await (0, run_1.runSynthesizePolicy)(args);
+        return (0, result_ts_1.mcpResultFromCore)(res);
+    });
+}

package/dist-cjs/src/tools/result.d.ts

@@ -0,0 +1,24 @@
+import type { ToolError, ToolResponse } from '@crediolabs/policy-synth';
+export interface McpToolSuccess<T> {
+    isError: false;
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+    structuredContent: T;
+}
+export interface McpToolError {
+    isError: true;
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+    structuredContent: ToolError;
+}
+export type McpToolResult<T> = McpToolSuccess<T> | McpToolError;
+/** Map a core ToolResponse<T> to the MCP result envelope. The handler in
+ *  src/server.ts wraps this in the SDK's `{ content, isError }` shape. */
+export declare function mcpResultFromCore<T>(res: ToolResponse<T>): McpToolResult<T>;
+/** Map a core ToolError directly (for inputs that already failed validation
+ *  inside the handler). */
+export declare function mcpErrorFromCore(err: ToolError): McpToolError;

package/dist-cjs/src/tools/result.js

@@ -0,0 +1,39 @@
+"use strict";
+// apps/policy-builder-mcp/src/tools/result.ts
+//
+// Transport-layer mapping between the core's ToolResponse<T> envelope and the
+// MCP result envelope. This is the ONLY place the two envelopes meet; no
+// business logic lives here. The shapes follow the MCP spec for the
+// `CallToolResult` type:
+//
+//   success:  { content: [{ type: 'text', text: JSON.stringify(data) }], isError: false }
+//   failure:  { content: [{ type: 'text', text: JSON.stringify(error) }], isError: true }
+//
+// Both branches carry the structured content as a single JSON-encoded text
+// block so clients that do not parse `structuredContent` still see a usable
+// payload. The shape is intentionally tiny - any extra keys belong in the
+// core, not here.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mcpResultFromCore = mcpResultFromCore;
+exports.mcpErrorFromCore = mcpErrorFromCore;
+/** Map a core ToolResponse<T> to the MCP result envelope. The handler in
+ *  src/server.ts wraps this in the SDK's `{ content, isError }` shape. */
+function mcpResultFromCore(res) {
+    if (res.ok) {
+        return {
+            isError: false,
+            content: [{ type: 'text', text: JSON.stringify(res.data) }],
+            structuredContent: res.data,
+        };
+    }
+    return mcpErrorFromCore(res.error);
+}
+/** Map a core ToolError directly (for inputs that already failed validation
+ *  inside the handler). */
+function mcpErrorFromCore(err) {
+    return {
+        isError: true,
+        content: [{ type: 'text', text: JSON.stringify(err) }],
+        structuredContent: err,
+    };
+}

package/dist-cjs/src/transports/http.d.ts

@@ -0,0 +1,15 @@
+export interface StartHttpServerOptions {
+    port: number;
+    host?: string;
+    /** Path the server mounts the MCP endpoint at. Default `/mcp`. */
+    path?: string;
+}
+export interface RunningHttpServer {
+    port: number;
+    host: string;
+    path: string;
+    close: () => Promise<void>;
+}
+/** Stateless Streamable HTTP server. Resolves once the server is listening.
+ *  The returned handle exposes `close()` for tests + clean shutdown. */
+export declare function startHttpServer(opts: StartHttpServerOptions): Promise<RunningHttpServer>;