@basaltkit/ai 1.0.1 → 1.1.1

package/dist/provider/factory.js

@@ -1,17 +1,20 @@
 import { AnthropicProvider } from './anthropic.js';
 import { OllamaProvider } from './ollama.js';
 import { OpenAICompatibleProvider } from './openai.js';
-/** Read the provider-relevant vars off `process.env` into a typed {@link ProviderEnv}. */
-export function providerEnvFromProcess() {
-    const e = process.env;
+/** Read the provider-relevant vars off an env record into a typed {@link ProviderEnv}. */
+export function providerEnvFrom(env) {
     return {
-        ...(e.AI_PROVIDER !== undefined ? { AI_PROVIDER: e.AI_PROVIDER } : {}),
-        ...(e.AI_MODEL !== undefined ? { AI_MODEL: e.AI_MODEL } : {}),
-        ...(e.AI_API_KEY !== undefined ? { AI_API_KEY: e.AI_API_KEY } : {}),
-        ...(e.AI_BASE_URL !== undefined ? { AI_BASE_URL: e.AI_BASE_URL } : {}),
-        ...(e.AI_STREAM !== undefined ? { AI_STREAM: e.AI_STREAM } : {}),
+        ...(env.AI_PROVIDER !== undefined ? { AI_PROVIDER: env.AI_PROVIDER } : {}),
+        ...(env.AI_MODEL !== undefined ? { AI_MODEL: env.AI_MODEL } : {}),
+        ...(env.AI_API_KEY !== undefined ? { AI_API_KEY: env.AI_API_KEY } : {}),
+        ...(env.AI_BASE_URL !== undefined ? { AI_BASE_URL: env.AI_BASE_URL } : {}),
+        ...(env.AI_STREAM !== undefined ? { AI_STREAM: env.AI_STREAM } : {}),
     };
 }
+/** Read the provider-relevant vars off `process.env` into a typed {@link ProviderEnv}. */
+export function providerEnvFromProcess() {
+    return providerEnvFrom(process.env);
+}
 /**
  * Build an {@link AIProvider} from environment. `AI_PROVIDER` selects the vendor
  * (default `anthropic`); `AI_MODEL`, `AI_API_KEY`, `AI_BASE_URL` tune it.

package/dist/provider/http.d.ts

@@ -17,6 +17,7 @@ export declare function fetchWithRetry(fetchImpl: FetchLike, url: string, init:
     method?: string;
     headers?: Record<string, string>;
     body?: string;
+    signal?: AbortSignal;
 }, options?: RetryOptions): Promise<{
     ok: boolean;
     status: number;

package/dist/provider/http.js

@@ -1,3 +1,4 @@
+import { throwIfAborted, isAbortError } from './abort.js';
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 /** Transient failures worth retrying: gateway/server errors and rate limits. */
 function isRetryableStatus(status) {
@@ -16,6 +17,7 @@ export async function fetchWithRetry(fetchImpl, url, init, options = {}) {
     const baseDelayMs = options.baseDelayMs ?? 300;
     let lastError;
     for (let attempt = 0; attempt <= retries; attempt++) {
+        throwIfAborted(init.signal);
         try {
             const res = await fetchImpl(url, init);
             if (isRetryableStatus(res.status) && attempt < retries) {
@@ -25,6 +27,9 @@ export async function fetchWithRetry(fetchImpl, url, init, options = {}) {
             return { ok: res.ok, status: res.status, body: await res.text() };
         }
         catch (error) {
+            // A cancelled request must fail immediately — never retried.
+            if (isAbortError(error) || init.signal?.aborted)
+                throw error;
             lastError = error;
             if (attempt >= retries)
                 throw error;

package/dist/provider/ollama.js

@@ -22,6 +22,7 @@ export class OllamaProvider {
         const { ok, status, body } = await fetchWithRetry(this.fetchImpl, this.baseUrl + '/api/chat', {
             method: 'POST',
             headers: { 'content-type': 'application/json' },
+            ...(options.signal ? { signal: options.signal } : {}),
             body: JSON.stringify({
                 model: this.model,
                 stream: false,

package/dist/provider/openai.js

@@ -62,6 +62,7 @@ export class OpenAICompatibleProvider {
             method: 'POST',
             headers: this.headers(),
             body: this.requestBody(options, true),
+            ...(options.signal ? { signal: options.signal } : {}),
         });
         if (!res.ok) {
             throw new Error(`OpenAICompatibleProvider: ${res.status} — ${safeError(await res.text())}`);
@@ -73,6 +74,7 @@ export class OpenAICompatibleProvider {
             method: 'POST',
             headers: this.headers(),
             body: this.requestBody(options, false),
+            ...(options.signal ? { signal: options.signal } : {}),
         });
         if (!ok) {
             const detail = safeError(body);

package/dist/provider/sse.d.ts

@@ -18,6 +18,7 @@ export type SseFetch = (url: string, init: {
     method?: string;
     headers?: Record<string, string>;
     body?: string;
+    signal?: AbortSignal;
 }) => Promise<SseResponse>;
 /** Default {@link SseFetch} backed by the global `fetch` + its streaming body. */
 export declare const globalSseFetch: SseFetch;

package/dist/provider/sse.js

@@ -15,6 +15,7 @@ export const globalSseFetch = async (url, init) => {
         method: init.method,
         headers: init.headers,
         body: init.body,
+        ...(init.signal ? { signal: init.signal } : {}),
     }));
     const stream = res.body;
     const decoder = new TextDecoder();

package/dist/provider/types.d.ts

@@ -15,6 +15,8 @@ export interface GenerateOptions {
     temperature?: number;
     /** Hard cap on output tokens. */
     maxTokens?: number;
+    /** Abort the in-flight request. Providers forward it to the underlying fetch. */
+    signal?: AbortSignal;
 }
 export interface AIProvider {
     /** Stable id, e.g. `'anthropic'`. */
@@ -35,6 +37,7 @@ export type FetchLike = (url: string, init?: {
     method?: string;
     headers?: Record<string, string>;
     body?: string;
+    signal?: AbortSignal;
 }) => Promise<{
     ok: boolean;
     status: number;

package/dist/review/review.d.ts

@@ -1,10 +1,15 @@
 import type { MakeResult } from '../make/types.js';
 import type { ArchitecturePlan } from '../plan/types.js';
 import type { AIProvider } from '../provider/types.js';
+import { type OnProgress } from '../generate.js';
 import type { AgentReview } from './types.js';
 export interface ReviewOptions {
     temperature?: number;
     maxTokens?: number;
+    /** Abort the request. */
+    signal?: AbortSignal;
+    /** Receive streamed progress. When set, a streaming provider streams. */
+    onProgress?: OnProgress;
 }
 /**
  * Compact, relevant-only context for the Review agent: the request, the plan, the

package/dist/review/review.js

@@ -1,3 +1,5 @@
+import { AgentReviewSchema } from '../schema/index.js';
+import { runGeneration } from '../generate.js';
 import { REVIEW_KNOWLEDGE } from './knowledge.js';
 /** Files worth sending to the reviewer — the ones that carry the behaviour. */
 const REVIEWABLE = /\.prisma$|\.(schema|routes|service|repository|permissions)\.ts$/;
@@ -31,14 +33,19 @@ export function buildReviewContext(plan, result) {
 }
 /** Ask the Review agent to critique the generated code. Read-only — it judges, it doesn't edit. */
 export async function reviewImplementation(provider, plan, result, options = {}) {
-    const raw = await provider.generate({
+    const run = {};
+    if (options.signal)
+        run.signal = options.signal;
+    if (options.onProgress)
+        run.onProgress = options.onProgress;
+    const raw = await runGeneration(provider, {
         messages: [
             { role: 'system', content: REVIEW_KNOWLEDGE },
             { role: 'user', content: `${buildReviewContext(plan, result)}\n\nReturn the verdict as a single JSON object.` },
         ],
         temperature: options.temperature ?? 0,
         maxTokens: options.maxTokens ?? 2048,
-    });
+    }, run);
     return parseReview(raw);
 }
 /** Parse the verdict. `approved` is derived from the issues, not trusted from the model. */
@@ -52,11 +59,13 @@ export function parseReview(raw) {
         throw new Error(`ai review — the model did not return valid JSON. Got: ${raw.slice(0, 160)}…`);
     }
     const issues = normalizeIssues(obj['issues']);
-    return {
+    // Coerce first, then validate. `approved` is derived from the issues here, not
+    // trusted from the model.
+    return AgentReviewSchema.parse({
         approved: !issues.some((i) => i.severity === 'error'),
         summary: typeof obj['summary'] === 'string' ? obj['summary'] : '',
         issues,
-    };
+    });
 }
 function normalizeIssues(value) {
     if (!Array.isArray(value))

package/dist/schema/index.d.ts

@@ -0,0 +1,453 @@
+/**
+ * Runtime schemas for the AI layer's public data contracts. `@basaltkit/ai` is a
+ * dev-only package, so taking a `zod` dependency here is acceptable — these
+ * schemas exist so out-of-process consumers (notably the forthcoming dev-only
+ * `@basaltkit/ai-mcp` bridge) can (a) validate tool inputs/outputs and (b) derive
+ * JSON Schema to advertise as MCP `inputSchema`/`outputSchema`.
+ *
+ * The schemas mirror the exported TypeScript interfaces exactly. `parsePlan` and
+ * `parseReview` route their already-coerced output through them (validate *after*
+ * tolerant coercion — the model's raw text is never fed to `.parse()` directly).
+ */
+import { z } from 'zod';
+/** Bump when the serialized shape of a plan changes incompatibly. */
+export declare const PLAN_SCHEMA_VERSION = 1;
+/** Bump when the serialized shape of a make result changes incompatibly. */
+export declare const MAKE_SCHEMA_VERSION = 1;
+export declare const DetectedStackSchema: z.ZodObject<{
+    http: z.ZodNullable<z.ZodEnum<{
+        fastify: "fastify";
+    }>>;
+    orm: z.ZodNullable<z.ZodEnum<{
+        prisma: "prisma";
+    }>>;
+    database: z.ZodNullable<z.ZodEnum<{
+        mysql: "mysql";
+        postgresql: "postgresql";
+        sqlite: "sqlite";
+    }>>;
+    tenancy: z.ZodBoolean;
+    auth: z.ZodBoolean;
+    rbac: z.ZodBoolean;
+    subscriptions: z.ZodBoolean;
+    payments: z.ZodBoolean;
+    storage: z.ZodBoolean;
+    queue: z.ZodBoolean;
+    search: z.ZodBoolean;
+    audit: z.ZodBoolean;
+    events: z.ZodBoolean;
+    scheduler: z.ZodBoolean;
+    logger: z.ZodBoolean;
+    ai: z.ZodBoolean;
+}, z.core.$strip>;
+export declare const PrismaModelSchema: z.ZodObject<{
+    name: z.ZodString;
+    fields: z.ZodArray<z.ZodString>;
+    tenantScoped: z.ZodBoolean;
+}, z.core.$strip>;
+export declare const PrismaInfoSchema: z.ZodObject<{
+    provider: z.ZodNullable<z.ZodEnum<{
+        mysql: "mysql";
+        postgresql: "postgresql";
+        sqlite: "sqlite";
+    }>>;
+    models: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        fields: z.ZodArray<z.ZodString>;
+        tenantScoped: z.ZodBoolean;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const AppFileInfoSchema: z.ZodObject<{
+    path: z.ZodString;
+    plugins: z.ZodArray<z.ZodString>;
+    fastifyLoggerConfigured: z.ZodBoolean;
+    memorySources: z.ZodArray<z.ZodString>;
+    pluginCalls: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export declare const ServerFileInfoSchema: z.ZodObject<{
+    path: z.ZodString;
+    connectsAtBoot: z.ZodBoolean;
+    startsServer: z.ZodBoolean;
+}, z.core.$strip>;
+export declare const EnvFileInfoSchema: z.ZodObject<{
+    path: z.ZodString;
+    appSecretDefault: z.ZodNullable<z.ZodString>;
+    redisUrlDefault: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export declare const ProjectContextSchema: z.ZodObject<{
+    root: z.ZodString;
+    installed: z.ZodArray<z.ZodString>;
+    stack: z.ZodObject<{
+        http: z.ZodNullable<z.ZodEnum<{
+            fastify: "fastify";
+        }>>;
+        orm: z.ZodNullable<z.ZodEnum<{
+            prisma: "prisma";
+        }>>;
+        database: z.ZodNullable<z.ZodEnum<{
+            mysql: "mysql";
+            postgresql: "postgresql";
+            sqlite: "sqlite";
+        }>>;
+        tenancy: z.ZodBoolean;
+        auth: z.ZodBoolean;
+        rbac: z.ZodBoolean;
+        subscriptions: z.ZodBoolean;
+        payments: z.ZodBoolean;
+        storage: z.ZodBoolean;
+        queue: z.ZodBoolean;
+        search: z.ZodBoolean;
+        audit: z.ZodBoolean;
+        events: z.ZodBoolean;
+        scheduler: z.ZodBoolean;
+        logger: z.ZodBoolean;
+        ai: z.ZodBoolean;
+    }, z.core.$strip>;
+    prisma: z.ZodNullable<z.ZodObject<{
+        provider: z.ZodNullable<z.ZodEnum<{
+            mysql: "mysql";
+            postgresql: "postgresql";
+            sqlite: "sqlite";
+        }>>;
+        models: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            fields: z.ZodArray<z.ZodString>;
+            tenantScoped: z.ZodBoolean;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    app: z.ZodNullable<z.ZodObject<{
+        path: z.ZodString;
+        plugins: z.ZodArray<z.ZodString>;
+        fastifyLoggerConfigured: z.ZodBoolean;
+        memorySources: z.ZodArray<z.ZodString>;
+        pluginCalls: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+    server: z.ZodNullable<z.ZodObject<{
+        path: z.ZodString;
+        connectsAtBoot: z.ZodBoolean;
+        startsServer: z.ZodBoolean;
+    }, z.core.$strip>>;
+    env: z.ZodNullable<z.ZodObject<{
+        path: z.ZodString;
+        appSecretDefault: z.ZodNullable<z.ZodString>;
+        redisUrlDefault: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const SeveritySchema: z.ZodEnum<{
+    error: "error";
+    info: "info";
+    warning: "warning";
+}>;
+export declare const DiagnosticCategorySchema: z.ZodEnum<{
+    config: "config";
+    database: "database";
+    durability: "durability";
+    observability: "observability";
+    performance: "performance";
+    security: "security";
+    tenancy: "tenancy";
+}>;
+export declare const DiagnosticSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    severity: z.ZodEnum<{
+        error: "error";
+        info: "info";
+        warning: "warning";
+    }>;
+    category: z.ZodEnum<{
+        config: "config";
+        database: "database";
+        durability: "durability";
+        observability: "observability";
+        performance: "performance";
+        security: "security";
+        tenancy: "tenancy";
+    }>;
+    detected: z.ZodString;
+    recommended: z.ZodString;
+    reason: z.ZodString;
+    fix: z.ZodOptional<z.ZodString>;
+    docs: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const AnalysisReportSchema: z.ZodObject<{
+    root: z.ZodString;
+    capabilities: z.ZodArray<z.ZodString>;
+    installed: z.ZodArray<z.ZodString>;
+    database: z.ZodNullable<z.ZodString>;
+    models: z.ZodArray<z.ZodString>;
+    tenantScopedModels: z.ZodArray<z.ZodString>;
+    unscopedModels: z.ZodArray<z.ZodString>;
+    diagnostics: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        severity: z.ZodEnum<{
+            error: "error";
+            info: "info";
+            warning: "warning";
+        }>;
+        category: z.ZodEnum<{
+            config: "config";
+            database: "database";
+            durability: "durability";
+            observability: "observability";
+            performance: "performance";
+            security: "security";
+            tenancy: "tenancy";
+        }>;
+        detected: z.ZodString;
+        recommended: z.ZodString;
+        reason: z.ZodString;
+        fix: z.ZodOptional<z.ZodString>;
+        docs: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const PlanFieldSchema: z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodString;
+    enum: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export declare const PlanRelationSchema: z.ZodObject<{
+    name: z.ZodString;
+    model: z.ZodString;
+}, z.core.$strip>;
+export declare const PlanEntitySchema: z.ZodObject<{
+    name: z.ZodString;
+    fields: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodString;
+        enum: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    tenantScoped: z.ZodBoolean;
+    relations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        model: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export declare const PlanStepKindSchema: z.ZodEnum<{
+    audit: "audit";
+    docs: "docs";
+    generator: "generator";
+    migration: "migration";
+    other: "other";
+    permissions: "permissions";
+    routes: "routes";
+    schema: "schema";
+    service: "service";
+    test: "test";
+}>;
+export declare const PlanStepSchema: z.ZodObject<{
+    order: z.ZodNumber;
+    title: z.ZodString;
+    kind: z.ZodEnum<{
+        audit: "audit";
+        docs: "docs";
+        generator: "generator";
+        migration: "migration";
+        other: "other";
+        permissions: "permissions";
+        routes: "routes";
+        schema: "schema";
+        service: "service";
+        test: "test";
+    }>;
+    detail: z.ZodString;
+    command: z.ZodOptional<z.ZodString>;
+    files: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export declare const ArchitecturePlanSchema: z.ZodObject<{
+    schemaVersion: z.ZodDefault<z.ZodNumber>;
+    request: z.ZodString;
+    summary: z.ZodString;
+    entities: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        fields: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodString;
+            enum: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+        tenantScoped: z.ZodBoolean;
+        relations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            model: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    steps: z.ZodArray<z.ZodObject<{
+        order: z.ZodNumber;
+        title: z.ZodString;
+        kind: z.ZodEnum<{
+            audit: "audit";
+            docs: "docs";
+            generator: "generator";
+            migration: "migration";
+            other: "other";
+            permissions: "permissions";
+            routes: "routes";
+            schema: "schema";
+            service: "service";
+            test: "test";
+        }>;
+        detail: z.ZodString;
+        command: z.ZodOptional<z.ZodString>;
+        files: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    permissions: z.ZodArray<z.ZodString>;
+    auditEvents: z.ZodArray<z.ZodString>;
+    tenantScoped: z.ZodBoolean;
+    warnings: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export declare const GeneratedFileSchema: z.ZodObject<{
+    path: z.ZodString;
+    content: z.ZodString;
+}, z.core.$strip>;
+export declare const SchemaMergeSchema: z.ZodObject<{
+    path: z.ZodString;
+    found: z.ZodBoolean;
+    merged: z.ZodArray<z.ZodString>;
+    skipped: z.ZodArray<z.ZodString>;
+    written: z.ZodBoolean;
+}, z.core.$strip>;
+export declare const MigrationSchema: z.ZodObject<{
+    ok: z.ZodBoolean;
+    output: z.ZodString;
+}, z.core.$strip>;
+export declare const ResourceBuildSchema: z.ZodObject<{
+    name: z.ZodString;
+    prisma: z.ZodBoolean;
+    softDelete: z.ZodBoolean;
+    files: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        content: z.ZodString;
+    }, z.core.$strip>>;
+    augmented: z.ZodBoolean;
+    guarded: z.ZodBoolean;
+    audited: z.ZodBoolean;
+    written: z.ZodArray<z.ZodString>;
+    registered: z.ZodBoolean;
+    note: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const ReviewStatusSchema: z.ZodEnum<{
+    fail: "fail";
+    pass: "pass";
+    warn: "warn";
+}>;
+export declare const ReviewItemSchema: z.ZodObject<{
+    label: z.ZodString;
+    status: z.ZodEnum<{
+        fail: "fail";
+        pass: "pass";
+        warn: "warn";
+    }>;
+    detail: z.ZodString;
+}, z.core.$strip>;
+export declare const ReviewResultSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        status: z.ZodEnum<{
+            fail: "fail";
+            pass: "pass";
+            warn: "warn";
+        }>;
+        detail: z.ZodString;
+    }, z.core.$strip>>;
+    ok: z.ZodBoolean;
+}, z.core.$strip>;
+export declare const FilePreviewSchema: z.ZodObject<{
+    path: z.ZodString;
+    action: z.ZodEnum<{
+        create: "create";
+        overwrite: "overwrite";
+    }>;
+    diff: z.ZodString;
+}, z.core.$strip>;
+export declare const MakePreviewSchema: z.ZodObject<{
+    perFile: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        action: z.ZodEnum<{
+            create: "create";
+            overwrite: "overwrite";
+        }>;
+        diff: z.ZodString;
+    }, z.core.$strip>>;
+    clashes: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export declare const MakeResultSchema: z.ZodObject<{
+    schemaVersion: z.ZodDefault<z.ZodNumber>;
+    request: z.ZodString;
+    dryRun: z.ZodBoolean;
+    resources: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        prisma: z.ZodBoolean;
+        softDelete: z.ZodBoolean;
+        files: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            content: z.ZodString;
+        }, z.core.$strip>>;
+        augmented: z.ZodBoolean;
+        guarded: z.ZodBoolean;
+        audited: z.ZodBoolean;
+        written: z.ZodArray<z.ZodString>;
+        registered: z.ZodBoolean;
+        note: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    schema: z.ZodOptional<z.ZodObject<{
+        path: z.ZodString;
+        found: z.ZodBoolean;
+        merged: z.ZodArray<z.ZodString>;
+        skipped: z.ZodArray<z.ZodString>;
+        written: z.ZodBoolean;
+    }, z.core.$strip>>;
+    migration: z.ZodOptional<z.ZodObject<{
+        ok: z.ZodBoolean;
+        output: z.ZodString;
+    }, z.core.$strip>>;
+    followUps: z.ZodArray<z.ZodString>;
+    review: z.ZodObject<{
+        items: z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            status: z.ZodEnum<{
+                fail: "fail";
+                pass: "pass";
+                warn: "warn";
+            }>;
+            detail: z.ZodString;
+        }, z.core.$strip>>;
+        ok: z.ZodBoolean;
+    }, z.core.$strip>;
+    preview: z.ZodOptional<z.ZodObject<{
+        perFile: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            action: z.ZodEnum<{
+                create: "create";
+                overwrite: "overwrite";
+            }>;
+            diff: z.ZodString;
+        }, z.core.$strip>>;
+        clashes: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const ReviewIssueSchema: z.ZodObject<{
+    dimension: z.ZodString;
+    severity: z.ZodEnum<{
+        error: "error";
+        warning: "warning";
+    }>;
+    message: z.ZodString;
+}, z.core.$strip>;
+export declare const AgentReviewSchema: z.ZodObject<{
+    approved: z.ZodBoolean;
+    summary: z.ZodString;
+    issues: z.ZodArray<z.ZodObject<{
+        dimension: z.ZodString;
+        severity: z.ZodEnum<{
+            error: "error";
+            warning: "warning";
+        }>;
+        message: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Convert one of the exported zod schemas to JSON Schema (Draft 2020-12), for an
+ * out-of-process consumer to advertise as an MCP tool `inputSchema`/`outputSchema`.
+ */
+export declare function toJsonSchema(schema: z.ZodType): Record<string, unknown>;