@crediolabs/policy-builder-mcp 0.1.6 → 0.1.8

package/dist/src/tools/run.js

@@ -1,98 +0,0 @@
-// apps/policy-builder-mcp/src/tools/run.ts
-//
-// Tool bodies for `record_transaction` and `synthesize_policy`. Each body is a
-// THIN adapter over the pure core:
-//
-//   1. Re-validate the parsed input via Zod. This is a defence-in-depth check -
-//      the SDK has already parsed it through the registered schema, but we never
-//      want a tool body to throw on garbage (the SDK treats uncaught throws as
-//      transport errors and the agent loses the machine-readable ToolError).
-//   2. Dispatch to the matching core entry point with the minimum required
-//      inputs.
-//   3. Return the core's ToolResponse<T> unchanged. The server layer maps it
-//      to the MCP envelope; nothing here knows about MCP.
-//
-// No business logic. No retries. No session state. The same call shape can
-// drive the CLI (which calls into the same core directly without MCP).
-import { placeholderOzConfig, recordTransaction, synthesizeFromMandate, synthesizeFromRecording, } from '@crediolabs/policy-synth';
-import { RecordTransactionInputSchema, SynthesizePolicyInputSchema, } from "../schemas.js";
-/** `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 async function runRecordTransaction(raw) {
-    const parsed = RecordTransactionInputSchema.safeParse(raw);
-    if (!parsed.success) {
-        return {
-            ok: false,
-            error: validationError('record_transaction', parsed.error.issues),
-        };
-    }
-    const input = parsed.data;
-    // Strip the wire-only `confidenceOverride` and pass the rest straight through.
-    const coreInput = {
-        network: input.network,
-        ...(input.hash !== undefined ? { hash: input.hash } : {}),
-        ...(input.xdr !== undefined ? { xdr: input.xdr } : {}),
-        ...(input.confidenceOverride !== undefined
-            ? { confidenceOverride: input.confidenceOverride }
-            : {}),
-    };
-    return recordTransaction(coreInput);
-}
-/** `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 async function runSynthesizePolicy(raw) {
-    const parsed = SynthesizePolicyInputSchema.safeParse(raw);
-    if (!parsed.success) {
-        return {
-            ok: false,
-            error: validationError('synthesize_policy', parsed.error.issues),
-        };
-    }
-    const input = parsed.data;
-    const ozConfig = resolveOzConfig(input);
-    if (input.source === 'mandate') {
-        // Zod's optional fields widen to `T | undefined`, which the core's
-        // exact-optional MandateSpec rejects; the schema already validated the
-        // shape, so assert it (same pattern as the recordedTx cast below).
-        return synthesizeFromMandate(input.mandate, ozConfig);
-    }
-    // recording source
-    const recorded = input.recordedTx;
-    return synthesizeFromRecording(recorded, {
-        network: input.network,
-        ...(input.userResponses !== undefined ? { userResponses: input.userResponses } : {}),
-        ...(input.confidenceOverride !== undefined
-            ? { confidenceOverride: input.confidenceOverride }
-            : {}),
-        ...(input.interpreter !== undefined ? { interpreter: input.interpreter } : {}),
-    }, ozConfig);
-}
-function resolveOzConfig(input) {
-    if (input.ozConfig)
-        return input.ozConfig;
-    // The mandate path is network-agnostic; fall back to mainnet so the
-    // placeholder OZ instance addresses are deterministic.
-    return placeholderOzConfig('mainnet');
-}
-/** Build a canonical ToolError for a Zod validation failure. The remediation
- *  hint points the agent back at the right tool with an empty arg bag - the
- *  tool name IS the machine-readable hint. */
-function validationError(toolName, issues) {
-    const code = toolName === 'record_transaction' ? 'RECORDING_FAILED' : 'SYNTHESIS_ERROR';
-    return {
-        code,
-        message: `${toolName}: invalid input: ${issues
-            .map((i) => `${i.path.join('.') || '<root>'}: ${i.message}`)
-            .join('; ')}`,
-        severity: 'error',
-        retryable: false,
-        remediation: {
-            toolCall: { name: toolName, args: {} },
-        },
-    };
-}

package/src/tools/run.ts

@@ -1,134 +0,0 @@
-// apps/policy-builder-mcp/src/tools/run.ts
-//
-// Tool bodies for `record_transaction` and `synthesize_policy`. Each body is a
-// THIN adapter over the pure core:
-//
-//   1. Re-validate the parsed input via Zod. This is a defence-in-depth check -
-//      the SDK has already parsed it through the registered schema, but we never
-//      want a tool body to throw on garbage (the SDK treats uncaught throws as
-//      transport errors and the agent loses the machine-readable ToolError).
-//   2. Dispatch to the matching core entry point with the minimum required
-//      inputs.
-//   3. Return the core's ToolResponse<T> unchanged. The server layer maps it
-//      to the MCP envelope; nothing here knows about MCP.
-//
-// No business logic. No retries. No session state. The same call shape can
-// drive the CLI (which calls into the same core directly without MCP).
-
-import {
-  type ErrorCode,
-  type MandateSpec,
-  type OzAdapterConfig,
-  type ProposedPolicy,
-  placeholderOzConfig,
-  type RecordedTransaction,
-  recordTransaction,
-  type SynthesizeFromRecordingOptions,
-  synthesizeFromMandate,
-  synthesizeFromRecording,
-  type ToolError,
-  type ToolResponse,
-} from '@crediolabs/policy-synth'
-import {
-  type RecordTransactionInput,
-  RecordTransactionInputSchema,
-  type SynthesizePolicyInput,
-  SynthesizePolicyInputSchema,
-} 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 async function runRecordTransaction(
-  raw: unknown
-): Promise<ToolResponse<RecordedTransaction>> {
-  const parsed = RecordTransactionInputSchema.safeParse(raw)
-  if (!parsed.success) {
-    return {
-      ok: false,
-      error: validationError('record_transaction', parsed.error.issues),
-    }
-  }
-  const input: RecordTransactionInput = parsed.data
-  // Strip the wire-only `confidenceOverride` and pass the rest straight through.
-  const coreInput = {
-    network: input.network,
-    ...(input.hash !== undefined ? { hash: input.hash } : {}),
-    ...(input.xdr !== undefined ? { xdr: input.xdr } : {}),
-    ...(input.confidenceOverride !== undefined
-      ? { confidenceOverride: input.confidenceOverride }
-      : {}),
-  }
-  return recordTransaction(coreInput)
-}
-
-/** `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 async function runSynthesizePolicy(raw: unknown): Promise<ToolResponse<ProposedPolicy>> {
-  const parsed = SynthesizePolicyInputSchema.safeParse(raw)
-  if (!parsed.success) {
-    return {
-      ok: false,
-      error: validationError('synthesize_policy', parsed.error.issues),
-    }
-  }
-  const input = parsed.data
-  const ozConfig: OzAdapterConfig = resolveOzConfig(input)
-
-  if (input.source === 'mandate') {
-    // Zod's optional fields widen to `T | undefined`, which the core's
-    // exact-optional MandateSpec rejects; the schema already validated the
-    // shape, so assert it (same pattern as the recordedTx cast below).
-    return synthesizeFromMandate(input.mandate as MandateSpec, ozConfig)
-  }
-  // recording source
-  const recorded: RecordedTransaction = input.recordedTx as RecordedTransaction
-  return synthesizeFromRecording(
-    recorded,
-    {
-      network: input.network,
-      ...(input.userResponses !== undefined ? { userResponses: input.userResponses } : {}),
-      ...(input.confidenceOverride !== undefined
-        ? { confidenceOverride: input.confidenceOverride }
-        : {}),
-      ...(input.interpreter !== undefined ? { interpreter: input.interpreter } : {}),
-    } as SynthesizeFromRecordingOptions,
-    ozConfig
-  )
-}
-
-function resolveOzConfig(input: SynthesizePolicyInput): OzAdapterConfig {
-  if (input.ozConfig) return input.ozConfig
-  // The mandate path is network-agnostic; fall back to mainnet so the
-  // placeholder OZ instance addresses are deterministic.
-  return placeholderOzConfig('mainnet')
-}
-
-/** Build a canonical ToolError for a Zod validation failure. The remediation
- *  hint points the agent back at the right tool with an empty arg bag - the
- *  tool name IS the machine-readable hint. */
-function validationError(
-  toolName: 'record_transaction' | 'synthesize_policy',
-  issues: ReadonlyArray<{ path: ReadonlyArray<string | number>; message: string }>
-): ToolError {
-  const code: ErrorCode = toolName === 'record_transaction' ? 'RECORDING_FAILED' : 'SYNTHESIS_ERROR'
-  return {
-    code,
-    message: `${toolName}: invalid input: ${issues
-      .map((i) => `${i.path.join('.') || '<root>'}: ${i.message}`)
-      .join('; ')}`,
-    severity: 'error',
-    retryable: false,
-    remediation: {
-      toolCall: { name: toolName, args: {} },
-    },
-  }
-}