@crediolabs/policy-builder-mcp 0.1.6 → 0.1.7

package/dist/src/schemas.js

@@ -1,152 +1,33 @@
 // apps/policy-builder-mcp/src/schemas.ts
 //
-// Zod schemas mirroring the policy-synth core domain types. These are the
-// public input / output shapes exposed over MCP and the CLI. They are kept
-// hand-written (rather than derived) because the MCP SDK needs a runtime
-// Zod object at the transport boundary; a drift test asserts they stay in
-// step with the TS source of truth.
+// 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.
 //
-// i128 amounts and other large integers are carried as base-10 decimal strings
-// end-to-end (no JS number coercion). Networks are pinned to the same closed
-// set the core defines. The discriminated union on `source` exposes BOTH
-// synthesize_policy front-ends through a single tool input.
+// 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.
+import { ComposeUserResponsesSchema, InterpreterOptionsSchema, MandateSpecSchema, NetworkSchema, OzAdapterConfigSchema, RecordedTransactionSchema, RecordTransactionInputSchema, SynthesizePolicyInputSchema, ToolErrorSchema, } from '@crediolabs/policy-synth/run';
 import { z } from 'zod';
-/** Soroban `valid_until` is a u32 ledger sequence; a value above this cannot be
- *  installed on-chain, so reject it at the boundary (fail-closed). */
-const U32_MAX = 4294967295;
-/** Upper bound on top-level invocations in a recorded transaction. A real
- *  Stellar tx caps operations well below this; the bound stops a hand-crafted
- *  payload from turning one request into an unbounded synthesis (DoS). */
-const MAX_INVOCATIONS = 512;
-export const NetworkSchema = z.enum(['mainnet', 'testnet']);
-/** ScVal subset - normalised subset the synth consumes. Mirrors
- *  `ScVal` in packages/policy-synth/src/types.ts. */
-export const ScValSchema = z.lazy(() => z.union([
-    z.object({ type: z.literal('address'), value: z.string() }),
-    // i128 is SIGNED: real events carry negatives (e.g. a fee-adjustment/refund),
-    // so the recorder's own output must round-trip through this schema. u64/u32
-    // are unsigned and stay non-negative.
-    z.object({ type: z.literal('i128'), value: z.string().regex(/^-?[0-9]+$/) }),
-    z.object({ type: z.literal('u64'), value: z.string().regex(/^[0-9]+$/) }),
-    z.object({ type: z.literal('u32'), value: z.string().regex(/^[0-9]+$/) }),
-    z.object({ type: z.literal('symbol'), value: z.string() }),
-    z.object({ type: z.literal('vec'), value: z.array(ScValSchema) }),
-    z.object({ type: z.literal('bytes'), value: z.string() }),
-    z.object({ type: z.literal('other'), value: z.string() }),
-]));
-/** ContractInvocation mirrors the core. Annotated with an explicit
- *  `z.ZodType<unknown>` (like ScValSchema above) so the self-referential
- *  `subInvocations` field does not trip TS's circular type inference. */
-export const ContractInvocationSchema = z.object({
-    contract: z.string(),
-    fn: z.string(),
-    args: z.array(ScValSchema),
-    subInvocations: z.array(z.lazy(() => ContractInvocationSchema)),
-});
-export const TokenMovementSchema = z.object({
-    token: z.string(),
-    from: z.string(),
-    to: z.string(),
-    // The recorder reads the amount straight from the signed i128 event value
-    // (record/movements.ts readAmount), so a non-standard token that emits a
-    // negative transfer/mint/burn amount round-trips as a negative string. Mirror
-    // that here; the synth gate, not the wire schema, decides what to do with it.
-    amount: z.string().regex(/^-?[0-9]+$/),
-});
-export const OnChainEventSchema = z.object({
-    contract: z.string(),
-    topics: z.array(z.string()),
-    data: ScValSchema,
-});
-export const ParseConfidenceSchema = z.object({
-    overall: z.number().min(0).max(1),
-    knownContracts: z.array(z.string()),
-    unknownContracts: z.array(z.object({
-        contract: z.string(),
-        reason: z.enum(['no-abi', 'version-mismatch', 'opaque-result']),
-    })),
-    opaqueScVals: z.array(z.object({ path: z.string(), type: z.string() })),
-    thresholdUsed: z.number().min(0).max(1),
-});
-/** RecordedTransaction mirrors the core RecordedTransaction. The output shape
- *  is referenced by name in the tool result structured content; we deliberately
- *  type it loosely (`z.unknown()`) on the success path so the core remains the
- *  single source of truth for the wire payload. */
-export const RecordedTransactionSchema = z
-    .object({
-    network: NetworkSchema,
-    signers: z.array(z.string()),
-    invocations: z.array(ContractInvocationSchema).max(MAX_INVOCATIONS),
-    tokenMovements: z.array(TokenMovementSchema),
-    events: z.array(OnChainEventSchema),
-    authEntries: z.array(z.unknown()),
-    ledgerSequence: z.number().int().nonnegative(),
-    fetchedAt: z.number().int().nonnegative(),
-    parseConfidence: ParseConfidenceSchema,
-    sourceAccount: z.string(),
-})
-    .passthrough();
-/** MandateSpec mirrors the core MandateSpec. The deterministic Mandate
- *  front-end needs no parseConfidence; the tool adapter injects the full
- *  confidence after synthesis so the orchestrator can compare. */
-export const MandateSpecSchema = z
-    .object({
-    chain: z.literal('stellar'),
-    contract: z.string(),
-    method: z.string().optional(),
-    spendingLimit: z
-        .object({
-        token: z.string(),
-        limit: z.string().regex(/^[0-9]+$/),
-        windowSeconds: z.number().int().positive(),
-    })
-        .optional(),
-    // A threshold of 0 means "0 approvals", which is not a real M-of-N gate.
-    approvalThreshold: z.number().int().positive().optional(),
-    recipients: z.array(z.string()).optional(),
-    expiry: z
-        .object({
-        validUntilLedger: z.number().int().positive().max(U32_MAX).optional(),
-        validUntilUnixSeconds: z.number().int().positive().optional(),
-    })
-        .optional(),
-})
-    .passthrough();
-/** ComposeUserResponses mirrors the core. */
-export const ComposeUserResponsesSchema = z
-    .object({
-    windowSeconds: z.number().int().positive().optional(),
-    validUntilLedger: z.number().int().positive().max(U32_MAX).optional(),
-    limitAmount: z
-        .string()
-        .regex(/^[0-9]+$/)
-        .optional(),
-    invocationLimit: z.number().int().positive().optional(),
-})
-    .passthrough();
-/** OzAdapterConfig - the per-network OZ built-in instance addresses. */
-export const OzAdapterConfigSchema = z.object({
-    network: NetworkSchema,
-    instances: z.object({
-        spending_limit: z.string(),
-        simple_threshold: z.string(),
-        weighted_threshold: z.string(),
-    }),
-});
-// ===== record_transaction =====
-export const RecordTransactionInputSchema = z
-    .object({
-    hash: z.string().min(1).optional(),
-    xdr: z.string().min(1).optional(),
-    network: NetworkSchema,
-    confidenceOverride: z.number().min(0).max(1).optional(),
-})
-    .refine((v) => !(v.hash && v.xdr), {
-    message: 'provide exactly one of `hash` or `xdr`, not both',
-})
-    .refine((v) => Boolean(v.hash) || Boolean(v.xdr), {
-    message: 'one of `hash` or `xdr` is required',
-});
+// 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, };
 /** 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). */
@@ -156,51 +37,6 @@ export const RecordTransactionToolShape = {
     network: NetworkSchema,
     confidenceOverride: z.number().min(0).max(1).optional(),
 };
-// ===== synthesize_policy =====
-//
-// Discriminated union on `source` exposes BOTH front-ends through ONE tool.
-// - `source: 'mandate'` -> calls synthesizeFromMandate
-// - `source: 'recording'` -> calls synthesizeFromRecording
-//
-// The MCP SDK's `tool()` API only accepts a flat ZodRawShape (named
-// properties keyed by Zod schemas), so we ALSO export a flat shape used at
-// the transport boundary. The discriminated union is the strict body-side
-// validator; the tool handler runs BOTH and treats the flat shape as the
-// friendly wire contract.
-export const SynthesizePolicyMandateInputSchema = z.object({
-    source: z.literal('mandate'),
-    mandate: MandateSpecSchema,
-    ozConfig: OzAdapterConfigSchema.optional(),
-});
-/** Interpreter opt-in for the recording path. Present -> constraints OZ cannot
- *  express (per-method scoping, invocation-count windows, oracle bounds, exact
- *  hop paths) lower to a real interpreter predicate document instead of being
- *  surfaced as warnings. The core deep-validates `smartAccountAddress` (a C...
- *  contract, not the recording's G... source) and the tighten-only oracle
- *  bounds; the schema stays light so the core owns the friendly ToolErrors. */
-export const InterpreterOptionsSchema = z.object({
-    smartAccountAddress: z.string(),
-    installNonce: z.number().int().positive().optional(),
-    oracleParams: z
-        .object({
-        maxStalenessSeconds: z.number().int().positive().optional(),
-        maxDeviationBps: z.number().int().positive().optional(),
-    })
-        .optional(),
-});
-export const SynthesizePolicyRecordingInputSchema = z.object({
-    source: z.literal('recording'),
-    recordedTx: RecordedTransactionSchema,
-    network: NetworkSchema,
-    userResponses: ComposeUserResponsesSchema.optional(),
-    confidenceOverride: z.object({ threshold: z.number().min(0).max(1) }).optional(),
-    interpreter: InterpreterOptionsSchema.optional(),
-    ozConfig: OzAdapterConfigSchema.optional(),
-});
-export const SynthesizePolicyInputSchema = z.discriminatedUnion('source', [
-    SynthesizePolicyMandateInputSchema,
-    SynthesizePolicyRecordingInputSchema,
-]);
 /** 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. */
@@ -214,26 +50,3 @@ export const SynthesizePolicyToolShape = {
     interpreter: InterpreterOptionsSchema.optional(),
     ozConfig: OzAdapterConfigSchema.optional(),
 };
-// ===== Error envelope (canonical) =====
-//
-// Mirrors ToolError from packages/policy-synth/src/errors.ts. We use a
-// `z.string()` for `code` (not an enum) because the core's ErrorCode union
-// evolves over time; the transport contract only promises a string code the
-// caller can dispatch on. A drift test asserts the canonical codes still
-// pass through unchanged.
-export const ToolErrorSchema = z
-    .object({
-    code: z.string(),
-    message: z.string(),
-    severity: z.enum(['info', 'warning', 'error', 'fatal']),
-    retryable: z.boolean(),
-    remediation: z
-        .object({
-        toolCall: z.object({ name: z.string(), args: z.record(z.unknown()) }).optional(),
-        userQuestion: z.object({ code: z.string(), question: z.string() }).optional(),
-        docsUrl: z.string().optional(),
-    })
-        .optional(),
-    details: z.unknown().optional(),
-})
-    .passthrough();

package/dist/src/server.js

@@ -4,16 +4,16 @@
 // 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 src/tools/run.ts so wire inputs
-// still fail closed.
+// 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.
+import { runRecordTransaction, runSynthesizePolicy } from '@crediolabs/policy-synth/run';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { RecordTransactionToolShape, SynthesizePolicyToolShape } from "./schemas.js";
 import { mcpResultFromCore } from "./tools/result.js";
-import { runRecordTransaction, runSynthesizePolicy } from "./tools/run.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 function createMcpServer() {

package/dist-cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

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

@@ -0,0 +1,7 @@
+export { type RunRecordTransactionInput, type RunSynthesizePolicyInput, runRecordTransaction, runSynthesizePolicy, } from '@crediolabs/policy-synth/run';
+export { RecordTransactionToolShape, SynthesizePolicyToolShape, } from './schemas.ts';
+export { createMcpServer, registerTools } from './server.ts';
+export type { McpToolError, McpToolResult } from './tools/result.ts';
+export { mcpErrorFromCore, mcpResultFromCore } from './tools/result.ts';
+export { startHttpServer } from './transports/http.ts';
+export { startStdioServer } from './transports/stdio.ts';

package/dist-cjs/src/index.js

@@ -0,0 +1,20 @@
+"use strict";
+// apps/policy-builder-mcp/src/index.ts - public re-exports for the MCP server package.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startStdioServer = exports.startHttpServer = exports.mcpResultFromCore = exports.mcpErrorFromCore = exports.registerTools = exports.createMcpServer = exports.SynthesizePolicyToolShape = exports.RecordTransactionToolShape = exports.runSynthesizePolicy = exports.runRecordTransaction = void 0;
+var run_1 = require("@crediolabs/policy-synth/run");
+Object.defineProperty(exports, "runRecordTransaction", { enumerable: true, get: function () { return run_1.runRecordTransaction; } });
+Object.defineProperty(exports, "runSynthesizePolicy", { enumerable: true, get: function () { return run_1.runSynthesizePolicy; } });
+var schemas_ts_1 = require("./schemas.js");
+Object.defineProperty(exports, "RecordTransactionToolShape", { enumerable: true, get: function () { return schemas_ts_1.RecordTransactionToolShape; } });
+Object.defineProperty(exports, "SynthesizePolicyToolShape", { enumerable: true, get: function () { return schemas_ts_1.SynthesizePolicyToolShape; } });
+var server_ts_1 = require("./server.js");
+Object.defineProperty(exports, "createMcpServer", { enumerable: true, get: function () { return server_ts_1.createMcpServer; } });
+Object.defineProperty(exports, "registerTools", { enumerable: true, get: function () { return server_ts_1.registerTools; } });
+var result_ts_1 = require("./tools/result.js");
+Object.defineProperty(exports, "mcpErrorFromCore", { enumerable: true, get: function () { return result_ts_1.mcpErrorFromCore; } });
+Object.defineProperty(exports, "mcpResultFromCore", { enumerable: true, get: function () { return result_ts_1.mcpResultFromCore; } });
+var http_ts_1 = require("./transports/http.js");
+Object.defineProperty(exports, "startHttpServer", { enumerable: true, get: function () { return http_ts_1.startHttpServer; } });
+var stdio_ts_1 = require("./transports/stdio.js");
+Object.defineProperty(exports, "startStdioServer", { enumerable: true, get: function () { return stdio_ts_1.startStdioServer; } });