@crediolabs/policy-builder-mcp 0.1.6 → 0.1.7

package/dist-cjs/src/transports/http.js

@@ -0,0 +1,140 @@
+"use strict";
+// apps/policy-builder-mcp/src/transports/http.ts
+//
+// Streamable HTTP transport (hosted). Uses the Node http module directly so
+// the package stays thin - no express / hono dep. We run in STATELESS mode
+// (sessionIdGenerator: undefined) so each POST /mcp is its own transaction:
+// this matches the brief's "stateless across calls" invariant.
+//
+// Single endpoint: POST /mcp (the SDK also accepts GET for SSE streaming, but
+// the T1 surface does not emit server-initiated messages so we omit it).
+// Listens on 127.0.0.1 by default; pass `host: '0.0.0.0'` to expose.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startHttpServer = startHttpServer;
+const node_http_1 = require("node:http");
+const streamableHttp_js_1 = require("@modelcontextprotocol/sdk/server/streamableHttp.js");
+const server_ts_1 = require("../server.js");
+/** Stateless Streamable HTTP server. Resolves once the server is listening.
+ *  The returned handle exposes `close()` for tests + clean shutdown. */
+async function startHttpServer(opts) {
+    const host = opts.host ?? '127.0.0.1';
+    const path = opts.path ?? '/mcp';
+    const server = (0, server_ts_1.createMcpServer)();
+    // One transport per server (the SDK reuses the transport for every request
+    // in stateless mode). We connect it once at startup and reuse it.
+    const transport = new streamableHttp_js_1.StreamableHTTPServerTransport({
+        sessionIdGenerator: undefined,
+    });
+    await server.connect(transport);
+    const httpServer = (0, node_http_1.createServer)(async (req, res) => {
+        if (!req.url) {
+            sendJson(res, 400, { error: 'missing url' });
+            return;
+        }
+        const url = new URL(req.url, `http://${host}`);
+        if (url.pathname !== path) {
+            sendJson(res, 404, { error: 'not found', path: url.pathname });
+            return;
+        }
+        if (req.method !== 'POST') {
+            // The SDK ignores non-POST in stateless mode (no GET/SSE needed in T1).
+            sendJson(res, 405, { error: 'method not allowed', method: req.method ?? null });
+            return;
+        }
+        // Reject an over-cap body fast via Content-Length; the streaming reader is
+        // the backstop for chunked/unknown-length requests.
+        const declaredLength = Number(req.headers['content-length']);
+        if (Number.isFinite(declaredLength) && declaredLength > MAX_BODY_BYTES) {
+            sendJson(res, 413, { error: 'request body too large' });
+            return;
+        }
+        // Read the JSON-RPC body. The SDK accepts a pre-parsed body, so we parse
+        // it here rather than the SDK trying to re-stream the raw req.
+        let body;
+        try {
+            body = await readJsonBody(req);
+        }
+        catch (e) {
+            if (e instanceof BodyTooLargeError) {
+                sendJson(res, 413, { error: 'request body too large' });
+            }
+            else {
+                sendJson(res, 400, { error: 'invalid JSON body' });
+            }
+            return;
+        }
+        // The T1 surface is one request per call. A JSON-RPC batch (array) is
+        // rejected explicitly rather than silently dropping the extra calls.
+        if (Array.isArray(body)) {
+            sendJson(res, 400, {
+                error: 'JSON-RPC batch requests are not supported; send one request per call',
+            });
+            return;
+        }
+        try {
+            // `handleRequest` writes the response and returns once the message has
+            // been dispatched. No shared state across calls in stateless mode.
+            await transport.handleRequest(req, res, body);
+        }
+        catch {
+            // The SDK normally writes structured errors itself; this is a belt +
+            // braces guard so a thrown error does not leave the socket hanging.
+            if (!res.headersSent) {
+                const error = {
+                    code: 'SYNTHESIS_ERROR',
+                    message: 'internal server error',
+                    severity: 'error',
+                    retryable: false,
+                };
+                sendJson(res, 500, { error });
+            }
+            else
+                res.end();
+        }
+    });
+    await new Promise((resolve, reject) => {
+        httpServer.once('error', reject);
+        httpServer.listen(opts.port, host, () => {
+            httpServer.off('error', reject);
+            resolve();
+        });
+    });
+    return {
+        port: opts.port,
+        host,
+        path,
+        close: async () => {
+            await new Promise((resolve) => httpServer.close(() => resolve()));
+            await transport.close().catch(() => { });
+            await server.close().catch(() => { });
+        },
+    };
+}
+function sendJson(res, status, body) {
+    res.statusCode = status;
+    res.setHeader('content-type', 'application/json');
+    res.end(JSON.stringify(body));
+}
+/** Reject bodies larger than this before buffering the whole payload - a
+ *  recorded transaction is far smaller, so this only stops abusive requests. */
+const MAX_BODY_BYTES = 1_048_576;
+/** Distinguishes an over-cap body from a malformed one so the handler can send
+ *  a 413 rather than a misleading 400. */
+class BodyTooLargeError extends Error {
+}
+async function readJsonBody(req) {
+    const chunks = [];
+    let total = 0;
+    for await (const chunk of req) {
+        total += chunk.length;
+        if (total > MAX_BODY_BYTES)
+            throw new BodyTooLargeError('request body too large');
+        chunks.push(chunk);
+    }
+    if (chunks.length === 0)
+        return {};
+    const raw = Buffer.concat(chunks).toString('utf8');
+    if (!raw)
+        return {};
+    return JSON.parse(raw);
+}

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

@@ -0,0 +1 @@
+export declare function startStdioServer(): Promise<void>;

package/dist-cjs/src/transports/stdio.js

@@ -0,0 +1,18 @@
+"use strict";
+// apps/policy-builder-mcp/src/transports/stdio.ts
+//
+// stdio transport (Claude Desktop / local agents). The MCP SDK reads JSON-RPC
+// from stdin and writes to stdout. Each process serves ONE client and exits
+// when the client closes the stream. No key custody, no global state; the
+// per-call state lives entirely in the McpServer instance.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startStdioServer = startStdioServer;
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const server_ts_1 = require("../server.js");
+async function startStdioServer() {
+    const server = (0, server_ts_1.createMcpServer)();
+    const transport = new stdio_js_1.StdioServerTransport();
+    await server.connect(transport);
+    // The transport owns the process from here; no shutdown signal handling -
+    // SIGPIPE / EOF on stdin terminates the loop naturally.
+}

package/package.json

@@ -1,16 +1,43 @@
 {
   "name": "@crediolabs/policy-builder-mcp",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "license": "MIT",
   "description": "MCP server exposing the OZ policy-synth core (record_transaction + synthesize_policy) over stdio and Streamable HTTP transports.",
   "type": "module",
   "main": "./dist/src/index.js",
   "types": "./dist/src/index.d.ts",
+  "engines": {
+    "node": ">=22.12",
+    "bun": ">=1.3.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/untangledfinance/oz-policy-builder.git",
+    "directory": "apps/policy-builder-mcp"
+  },
+  "homepage": "https://github.com/untangledfinance/oz-policy-builder#readme",
+  "bugs": {
+    "url": "https://github.com/untangledfinance/oz-policy-builder/issues"
+  },
+  "keywords": [
+    "stellar",
+    "soroban",
+    "openzeppelin",
+    "policy",
+    "smart-account",
+    "authorization"
+  ],
+  "sideEffects": false,
+  "author": {
+    "name": "Untangled Finance Limited",
+    "url": "https://untangled.finance"
+  },
   "exports": {
     ".": {
       "types": "./dist/src/index.d.ts",
       "bun": "./src/index.ts",
       "import": "./dist/src/index.js",
+      "require": "./dist-cjs/src/index.js",
       "default": "./dist/src/index.js"
     },
     "./package.json": "./package.json"
@@ -20,6 +47,7 @@
   },
   "files": [
     "dist",
+    "dist-cjs",
     "src",
     "!src/**/*.test.ts"
   ],
@@ -28,15 +56,20 @@
   },
   "scripts": {
     "test": "bun test",
-    "build": "tsc -p tsconfig.build.json"
+    "build": "tsc -p tsconfig.build.json && tsc -p tsconfig.build.cjs.json && node scripts/write-cjs-package-json.cjs",
+    "build:esm": "tsc -p tsconfig.build.json",
+    "build:cjs": "tsc -p tsconfig.build.cjs.json && node scripts/write-cjs-package-json.cjs",
+    "prepublishOnly": "bun run build && bun test",
+    "prepack": "bun run build"
   },
   "dependencies": {
-    "@crediolabs/policy-synth": "^0.1.4",
+    "@crediolabs/policy-synth": "0.1.5",
     "@modelcontextprotocol/sdk": "1.18.1",
     "zod": "3.25.76"
   },
   "devDependencies": {
     "@biomejs/biome": "2.5.5",
+    "@types/bun": "^1.3.0",
     "@types/node": "^26.1.1",
     "typescript": "5.9.3"
   }

package/src/index.ts

@@ -1,21 +1,17 @@
 // apps/policy-builder-mcp/src/index.ts - public re-exports for the MCP server package.
 
 export {
-  RecordTransactionInputSchema,
+  type RunRecordTransactionInput,
+  type RunSynthesizePolicyInput,
+  runRecordTransaction,
+  runSynthesizePolicy,
+} from '@crediolabs/policy-synth/run'
+export {
   RecordTransactionToolShape,
-  SynthesizePolicyInputSchema,
-  SynthesizePolicyMandateInputSchema,
-  SynthesizePolicyRecordingInputSchema,
   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 {
-  type RunRecordTransactionInput,
-  type RunSynthesizePolicyInput,
-  runRecordTransaction,
-  runSynthesizePolicy,
-} from './tools/run.ts'
 export { startHttpServer } from './transports/http.ts'
 export { startStdioServer } from './transports/stdio.ts'

package/src/schemas.ts

@@ -1,172 +1,55 @@
 // 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'])
-export type Network = z.infer<typeof NetworkSchema>
-
-/** ScVal subset - normalised subset the synth consumes. Mirrors
- *  `ScVal` in packages/policy-synth/src/types.ts. */
-export const ScValSchema: z.ZodType<unknown> = 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.ZodType<unknown> = 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',
-  })
-export type RecordTransactionInput = z.infer<typeof RecordTransactionInputSchema>
+// 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
@@ -178,57 +61,6 @@ export const RecordTransactionToolShape = {
   confidenceOverride: z.number().min(0).max(1).optional(),
 } as const
 
-// ===== 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,
-])
-export type SynthesizePolicyInput = z.infer<typeof SynthesizePolicyInputSchema>
-
 /** 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. */
@@ -242,27 +74,3 @@ export const SynthesizePolicyToolShape = {
   interpreter: InterpreterOptionsSchema.optional(),
   ozConfig: OzAdapterConfigSchema.optional(),
 } as const
-
-// ===== 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/src/server.ts

@@ -4,18 +4,18 @@
 // 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 type { CallToolResult } from '@modelcontextprotocol/sdk/types.js'
 import { RecordTransactionToolShape, SynthesizePolicyToolShape } from './schemas.ts'
 import { mcpResultFromCore } from './tools/result.ts'
-import { runRecordTransaction, runSynthesizePolicy } from './tools/run.ts'
 
 /** Build a fresh, stateless MCP server. The caller owns the returned object
  *  and connects it to a single transport (stdio or Streamable HTTP). */

package/dist/src/tools/run.d.ts

@@ -1,15 +0,0 @@
-import { type ProposedPolicy, type RecordedTransaction, type ToolResponse } from '@crediolabs/policy-synth';
-import { type RecordTransactionInput, type SynthesizePolicyInput } from '../schemas.ts';
-export type RunRecordTransactionInput = RecordTransactionInput;
-export type RunSynthesizePolicyInput = SynthesizePolicyInput;
-/** `record_transaction` body - wraps `recordTransaction`. The tool input
- *  matches the core RecordInput minus the injected `fetcher` (the transport
- *  layer does not own the RPC). Returns the core ToolResponse unchanged. */
-export declare function runRecordTransaction(raw: unknown): Promise<ToolResponse<RecordedTransaction>>;
-/** `synthesize_policy` body - discriminated union on `source`:
- *    - `mandate`   -> synthesizeFromMandate
- *    - `recording` -> synthesizeFromRecording
- *  Exposing BOTH front-ends through ONE tool keeps the MCP surface tiny while
- *  letting the agent pick the deterministic or the inferred path. The CLI
- *  routes the same way. */
-export declare function runSynthesizePolicy(raw: unknown): Promise<ToolResponse<ProposedPolicy>>;