kibi-mcp 0.22.0 → 2.0.0

package/bin/kibi-mcp

@@ -19,11 +19,11 @@
 const args = globalThis.Bun?.argv?.slice(2) ?? process.argv.slice(2);
 
 async function importStartupResolution() {
-  try {
-    return await import("../dist/startup-resolution.js");
-  } catch {
-    return await import("../src/startup-resolution.ts");
-  }
+  // Published packages contain the compiled runtime only. Do not replace a
+  // real dependency/import failure with a source-tree fallback: doing so
+  // hides package contract errors and makes startup depend on an unpackaged
+  // TypeScript tree.
+  return await import("../dist/startup-resolution.js");
 }
 
 async function serverEntrypointUrl() {
@@ -32,7 +32,10 @@ async function serverEntrypointUrl() {
   if (existsSync(distUrl)) {
     return distUrl.href;
   }
-  return new URL("../src/server.ts", import.meta.url).href;
+  throw new Error(
+    `[KIBI-MCP] Missing compiled server entrypoint: ${distUrl.pathname}. ` +
+      "Run the package build before launching kibi-mcp.",
+  );
 }
 
 async function buildResolution() {
@@ -64,11 +67,9 @@ async function importServer(entrypoint) {
     const { pathToFileURL } = await import("node:url");
     return await import(pathToFileURL(entrypoint).href);
   }
-  try {
-    return await import("../dist/server.js");
-  } catch {
-    return await import("../src/server.ts");
-  }
+  // Preserve the original import error. In particular, an incompatible
+  // kibi-cli export must not be replaced with a misleading source fallback.
+  return await import("../dist/server.js");
 }
 
 function printHelp() {

package/dist/diagnostics.js

@@ -140,12 +140,50 @@ function appendMutationFields(fields, args) {
     fields.mutation_target = `${type}:${id}`;
 }
 const RECEIPT_GAP_CODES = new Set([
-    "missing_verification_receipt",
-    "stale_verification_receipt",
-    "failed_verification_receipt",
-    "invalid_verification_receipt",
-    "verification_snapshot_unavailable",
+    "missing_proof_receipt",
+    "stale_proof_receipt",
+    "failed_proof_receipt",
+    "invalid_proof_receipt",
+    "proof_contract_mismatch",
+    "proof_snapshot_unavailable",
 ]);
+const MAX_COVERAGE_RECEIPT_GAPS = 50;
+function coverageReceiptGapDetails(rows) {
+    const details = rows
+        .flatMap((row) => {
+        const codes = [...new Set(stringArray(row.proofGaps))]
+            .filter((code) => RECEIPT_GAP_CODES.has(code))
+            .sort();
+        if (codes.length === 0)
+            return [];
+        const stages = isRecord(row.proofStages) ? row.proofStages : undefined;
+        const passingE2e = isRecord(stages?.passingE2e)
+            ? stages.passingE2e
+            : undefined;
+        const testIds = [
+            "missingReceiptTests",
+            "staleReceiptTests",
+            "failedReceiptTests",
+            "invalidReceiptTests",
+            "contractMismatchReceiptTests",
+            "snapshotUnavailableTests",
+        ].flatMap((key) => stringArray(passingE2e?.[key]));
+        const requirementId = typeof row.id === "string" ? row.id : "unknown";
+        return [
+            {
+                requirementId,
+                testIds: [...new Set(testIds)].sort(),
+                codes,
+            },
+        ];
+    })
+        .sort((left, right) => left.requirementId.localeCompare(right.requirementId));
+    return {
+        details: details.slice(0, MAX_COVERAGE_RECEIPT_GAPS),
+        total: details.length,
+        truncated: details.length > MAX_COVERAGE_RECEIPT_GAPS,
+    };
+}
 function appendCoverageFields(fields, args, structuredContent) {
     const rows = Array.isArray(structuredContent.rows)
         ? structuredContent.rows.filter(isRecord)
@@ -166,14 +204,18 @@ function appendCoverageFields(fields, args, structuredContent) {
     fields.coverage_proof_gap_count = gapCodes.length;
     fields.coverage_gap_codes = uniqueGapCodes;
     fields.coverage_receipt_gap_count = gapCodes.filter((gap) => RECEIPT_GAP_CODES.has(gap)).length;
+    const receiptGaps = coverageReceiptGapDetails(rows);
+    fields.coverage_receipt_gaps = receiptGaps.details;
+    fields.coverage_receipt_gap_total = receiptGaps.total;
+    fields.coverage_receipt_gaps_truncated = receiptGaps.truncated;
     if (typeof scope?.complete === "boolean") {
         fields.coverage_scope_complete = scope.complete;
     }
     const metadata = isRecord(structuredContent.meta)
         ? structuredContent.meta
         : undefined;
-    if (typeof metadata?.verificationSnapshot === "string") {
-        fields.coverage_verification_snapshot = metadata.verificationSnapshot;
+    if (typeof metadata?.proofSnapshot === "string") {
+        fields.coverage_proof_snapshot = metadata.proofSnapshot;
     }
 }
 function appendPredicateSuggestionFields(fields, structuredContent) {
@@ -234,7 +276,25 @@ export function deriveDiagnosticFields(toolName, args, telemetry, result) {
             fields.actor_id = telemetry.actor_id;
         }
     }
-    const structuredContent = structuredContentFrom(result);
+    const envelope = structuredContentFrom(result);
+    const structuredContent = envelope?.kibiProtocol === 1 && isRecord(envelope.data)
+        ? envelope.data
+        : envelope;
+    if (envelope?.kibiProtocol === 1) {
+        fields.protocol_version = envelope.kibiProtocol;
+        fields.result_version = envelope.resultVersion ?? null;
+        fields.result_status = envelope.status ?? null;
+        fields.effect_failures = Array.isArray(envelope.effects)
+            ? envelope.effects.filter((effect) => effect !== null &&
+                typeof effect === "object" &&
+                !Array.isArray(effect) &&
+                effect.status === "failed")
+            : [];
+        fields.followed_next_actions = Array.isArray(telemetry?.followed_next_actions)
+            ? telemetry.followed_next_actions
+            : [];
+        fields.unsafe_original_retry = telemetry?.unsafe_original_retry === true;
+    }
     if (toolName === "kb_query" || toolName === "kb_search") {
         const resultCount = Number(structuredContent?.count ?? 0);
         fields.result_count = resultCount;

package/dist/env.js

@@ -36,7 +36,11 @@ export function isMcpDebugEnabled() {
 }
 export function getBranchOverride() {
     // implements REQ-002
-    return getTrimmedEnvValue("KIBI_BRANCH");
+    // Branch names are identities, not display labels. Preserve the value
+    // exactly so the Git-ref validator can reject whitespace or other invalid
+    // input instead of silently attaching a different branch.
+    const value = getEnvValue("KIBI_BRANCH");
+    return value === undefined || value.length === 0 ? undefined : value;
 }
 export function getKbPlPathOverride() {
     // implements REQ-002

package/dist/runtime/mcp-runtime.js

@@ -1,3 +1,7 @@
+import { resolveBranchAttachment } from "kibi-runtime";
+export function attachedContextWithProlog(withAttachment, prolog) {
+    return { ...withAttachment, prolog };
+}
 // implements REQ-kibi-operation-interface-parity
 export function createMcpRuntime(session) {
     const sessionPrologs = new WeakMap();
@@ -11,18 +15,50 @@ export function createMcpRuntime(session) {
                 signal: options.signal ?? session.signal ?? new AbortController().signal,
                 clock: options.clock ?? session.clock ?? (() => new Date()),
                 ...(fs ? { fs } : {}),
+                ...(fs ? { sourceFirst: true } : {}),
                 ...(git ? { git } : {}),
                 ...(net ? { net } : {}),
             };
+            const attachment = resolveBranchAttachment(context.workspaceRoot);
+            if (!("error" in attachment) && attachment.migrationRequired) {
+                console.warn(`[KIBI-MCP] Legacy branch attachment: Git '${attachment.gitBranch}' is reading KB '${attachment.kbBranch}'. Run 'kibi branch migrate --from ${attachment.kbBranch} --to ${attachment.gitBranch} --apply'; writes are blocked until then.`);
+            }
+            const withAttachment = "error" in attachment
+                ? context
+                : { ...context, branchAttachment: attachment };
             if (!spec.requiresProlog) {
-                return context;
+                // Preserve explicit host/test injection without asking the shared MCP
+                // session to initialise a store merely to report its condition.
+                const providedProlog = options.prolog;
+                let lazyProlog;
+                const lazyContext = {};
+                const ensureProlog = async () => {
+                    if (providedProlog !== undefined)
+                        return providedProlog;
+                    if (lazyProlog !== undefined)
+                        return session.adaptProlog(lazyProlog);
+                    lazyProlog = await session.ensureProlog();
+                    if (lazyContext.current !== undefined)
+                        sessionPrologs.set(lazyContext.current, lazyProlog);
+                    return session.adaptProlog(lazyProlog);
+                };
+                const operationContext = {
+                    ...withAttachment,
+                    ...(options.prolog ? { prolog: options.prolog } : {}),
+                    ensureProlog,
+                };
+                lazyContext.current = operationContext;
+                return operationContext;
+            }
+            if (!("error" in attachment) && attachment.migrationRequired) {
+                throw new Error(`Legacy branch attachment requires explicit migration before '${spec.name}'; run kibi branch migrate --from ${attachment.kbBranch} --to ${attachment.gitBranch} --apply`);
             }
             if (options.prolog) {
-                return { ...context, prolog: options.prolog };
+                return attachedContextWithProlog(withAttachment, options.prolog);
             }
             const sessionProlog = await session.ensureProlog();
             const operationContext = {
-                ...context,
+                ...withAttachment,
                 prolog: session.adaptProlog(sessionProlog),
             };
             sessionPrologs.set(operationContext, sessionProlog);

package/dist/server/docs.js

@@ -16,6 +16,7 @@
  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 import { TOOLS } from "../tools-config.js";
+import { KIBI_ICONS } from "./icons.js";
 const ACTIVE_TOOLS = TOOLS;
 function renderToolsDoc() {
     const lines = [
@@ -41,58 +42,32 @@ function renderToolsDoc() {
 export const PROMPTS = [
     // implements REQ-002, REQ-013, REQ-mcp-search-discovery
     {
-        name: "init-kibi",
-        description: "Activation workflow to populate a new or empty Kibi KB from an existing repository.",
+        name: "kibi-bootstrap",
+        title: "Bootstrap Kibi knowledge",
+        description: "Bootstrap Kibi knowledge for an existing repository through the canonical planner and apply operation.",
         text: [
-            "# Kibi Interactive Activation Workflow",
+            "# Kibi Bootstrap",
             "",
-            "Use this post-hoc workflow to onboard a new or empty repository into Kibi through interactive discovery.",
+            "Route an explicit bootstrap request to the canonical `kibi-bootstrap` skill and planner.",
             "",
-            "## Step 1: Gather Declared Context",
+            "## Route",
             "",
-            "The agent must ask at most 4 bounded questions to gather declared intent from the user:",
-            "1. **Project Summary**: What is the core purpose of this project?",
-            "2. **Source of Truth**: Where is the primary documentation (canonical requirements, ADRs)?",
-            "3. **Priority Root**: In a monorepo, which package should be prioritized?",
-            "4. **Verification Anchors**: Where are the primary tests or verification configs located?",
+            "Inspect `kb_status.bootstrap` and follow its typed `nextAction`. If infrastructure is missing, run `kibi init` before planning.",
             "",
-            "## Step 2: Synthesize Candidates (read-only)",
+            "## Preview and Approval",
             "",
-            "Call `kb_autopilot_generate` with the gathered context to synthesize candidate entities.",
+            "Call `kb_plan_bootstrap` read-only. Ask only the bounded questions returned when its status is `needs_context`; do not invent a questionnaire.",
             "",
-            "This tool is **read-only**. It returns additive `structuredContent` with:",
-            "- `promptBlock`: review text that must be surfaced before writes",
-            "- `recommendedActions`: agent-facing next steps, including any REQ/SCEN/TEST authoring routed for manual handling",
-            "- `declaredContext`: the user-provided bootstrap context",
-            "- `confidence`: confidence summary for the generated output",
-            "- `bootstrapMode`: current KB state (e.g., `root_uninitialized`)",
-            "- `candidates`: synthesized entities grounded in declared context and source evidence",
-            "- `applyPlan`: exact sequential `kb_upsert` payloads for approved candidates",
-            "- `discoverySummary`: source-backed discovery notes",
+            "Show the exact returned `structuredContent.plan`, its actions, and canonical hash. Get explicit user approval, then pass that plan object unchanged to `kb_apply_plan`.",
             "",
-            "## Step 3: Preview and Approval",
+            "## Verify and repair",
             "",
-            "Surface the `promptBlock`, a summary of `candidates`, and the exact `structuredContent.applyPlan` payloads. Wait for explicit user approval before proceeding to writes.",
-            "",
-            "## Step 4: Apply Candidates",
-            "",
-            "Apply candidates sequentially using `kb_upsert`.",
-            "1. Execute `structuredContent.applyPlan` sequentially in listed order.",
-            "2. Confirm success of each `kb_upsert` before moving to the next.",
-            "3. Run `kb_check` after the batch to verify KB integrity.",
-            "",
-            "## Rules",
-            "- Never apply bootstrap writes without user-facing preview and explicit approval.",
-            "- `kb_autopilot_generate` is strictly read-only; synthesis is the backend, not the actor.",
-            "- MCP tools and the trusted project-local CLI are peer surfaces; choose by what is visible and approved here.",
-            "- If Kibi MCP tools are visible and approved, use MCP.",
-            "- Otherwise, in a trusted workspace, use the project-local CLI's dedicated JSON routes with `--input <file|->`.",
-            "- If neither interface is available, Kibi operation is blocked; tell the operator to enable MCP or the trusted project-local CLI. Do not infer MCP availability from config file existence.",
-            "- Do not read or edit `.kb/` files directly. Query before mutate. Run `kb_upsert` sequentially. Run `kb_check` before completion.",
+            "Inspect the typed `kb_apply_plan` result, follow any `nextActions` for recovery, and finish with `kb_check` and `kb_status`. Never read or edit `.kb` directly or reconstruct a plan.",
         ].join("\n"),
     },
     {
         name: "kibi_overview",
+        title: "Kibi usage overview",
         description: "High-level model for using kibi-mcp safely and effectively.",
         text: [
             "# kibi-mcp Overview",
@@ -113,7 +88,7 @@ export const PROMPTS = [
             "Core modeling principles:",
             "- Kibi has eight entity types: common authoring (req, scenario, test, fact) and supporting/system (adr, flag, event, symbol).",
             "- Encode requirements as linked facts: `req --constrains--> fact` plus `req --requires_property--> fact`.",
-            "- High-confidence `kb_model_requirement` output is deterministic; `/init-kibi` bootstrap writes still require preview and explicit approval.",
+            "- High-confidence `kb_model_requirement` output is deterministic; `/kibi-bootstrap` bootstrap writes still require preview and explicit approval.",
             "- Low-confidence claims (< 0.7) are downgraded to `observation` facts to prevent false-positive contradictions.",
             "- Only strict domain facts participate in contradiction inference; observation and meta facts are non-blocking notes.",
             "- v1 contradictions are limited to exact-value, boolean/enum, numeric range, and polarity conflicts.",
@@ -127,6 +102,7 @@ export const PROMPTS = [
     },
     {
         name: "kibi_workflow",
+        title: "Kibi workflow steps",
         description: "Step-by-step call order for discovery, mutation, and verification.",
         text: [
             "# kibi-mcp Workflow",
@@ -149,6 +125,7 @@ export const PROMPTS = [
     },
     {
         name: "kibi_constraints",
+        title: "Kibi constraints",
         description: "Operational limits, validation rules, and mutation gotchas.",
         text: [
             "# kibi-mcp Constraints",
@@ -236,6 +213,7 @@ function registerDocResources() {
         {
             uri: "kibi://docs/overview",
             name: "kibi docs overview",
+            title: "Kibi server overview",
             description: "Full server description, purpose, and scope.",
             mimeType: "text/markdown",
             text: overview,
@@ -243,6 +221,7 @@ function registerDocResources() {
         {
             uri: "kibi://docs/tools",
             name: "kibi docs tools",
+            title: "Kibi tools reference",
             description: "Available tools with summaries and required parameters.",
             mimeType: "text/markdown",
             text: renderToolsDoc(),
@@ -250,6 +229,7 @@ function registerDocResources() {
         {
             uri: "kibi://docs/errors",
             name: "kibi docs errors",
+            title: "Kibi error guide",
             description: "Common error modes and suggested recovery actions.",
             mimeType: "text/markdown",
             text: errors,
@@ -257,6 +237,7 @@ function registerDocResources() {
         {
             uri: "kibi://docs/examples",
             name: "kibi docs examples",
+            title: "Kibi usage examples",
             description: "Concrete tool call sequences for common tasks.",
             mimeType: "text/markdown",
             text: examples,
@@ -266,7 +247,10 @@ function registerDocResources() {
 export const DOC_RESOURCES = registerDocResources();
 export function setupDocsAndPrompts(server) {
     for (const prompt of PROMPTS) {
-        server.prompt(prompt.name, prompt.description, async () => ({
+        server.registerPrompt(prompt.name, {
+            title: prompt.title,
+            description: prompt.description,
+        }, async () => ({
             messages: [
                 {
                     role: "user",
@@ -276,7 +260,12 @@ export function setupDocsAndPrompts(server) {
         }));
     }
     for (const resource of DOC_RESOURCES) {
-        server.resource(resource.name, resource.uri, { description: resource.description, mimeType: resource.mimeType }, async () => ({
+        server.registerResource(resource.name, resource.uri, {
+            title: resource.title,
+            description: resource.description,
+            mimeType: resource.mimeType,
+            icons: KIBI_ICONS,
+        }, async () => ({
             contents: [
                 {
                     uri: resource.uri,

package/dist/server/icons.js

@@ -0,0 +1,27 @@
+/*
+ Kibi — repo-local, per-branch, queryable long-term memory for software projects
+ Copyright (C) 2026 Piotr Franczyk
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Affero General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU Affero General Public License for more details.
+
+ You should have received a copy of the GNU Affero General Public License
+ along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+const KIBI_LOGO_MARK_SVG = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 308 309"><rect width="308" height="309" rx="64" fill="#1D1E23"/><ellipse cx="113.3" cy="150.9" rx="51.3" ry="51.5" fill="#A2D3F4"/><path d="M228.1 197.8L227.6 165.5H156.5L95.4 165.3V135.1H156.5L227.5 135.1V101.2H252.2V197.8Z" fill="#A2D3F4"/></svg>`;
+const KIBI_ICON_SRC = `data:image/svg+xml;base64,${Buffer.from(KIBI_LOGO_MARK_SVG, "utf8").toString("base64")}`;
+export const KIBI_ICONS = [
+    {
+        src: KIBI_ICON_SRC,
+        mimeType: "image/svg+xml",
+        sizes: ["any"],
+        theme: "dark",
+    },
+];

package/dist/server/jobs.js

@@ -0,0 +1,107 @@
+/*
+ Kibi — repo-local, per-branch, queryable long-term memory for software projects
+ Copyright (C) 2026 Piotr Franczyk
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Affero General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU Affero General Public License for more details.
+
+ You should have received a copy of the GNU Affero General Public License
+ along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+import process from "node:process";
+const MAX_FINISHED_JOBS = 32;
+const jobs = new Map();
+let jobCounter = 0;
+function nextJobId(tool) {
+    jobCounter += 1;
+    const random = Math.random().toString(36).slice(2, 10);
+    return `job-${tool}-${jobCounter.toString(36)}-${random}`;
+}
+function evictOldestFinished() {
+    for (const [id, record] of jobs) {
+        if (jobs.size <= MAX_FINISHED_JOBS)
+            break;
+        if (record.status !== "running") {
+            jobs.delete(id);
+        }
+    }
+}
+/**
+ * Start a background job for `tool`. The factory's promise runs detached;
+ * callers return the `kibi.job.v1` receipt immediately so the MCP request is
+ * never held open for the duration of the operation.
+ */
+// implements REQ-002
+export function startJob(tool, factory) {
+    const jobId = nextJobId(tool);
+    const record = {
+        jobId,
+        tool,
+        startedAt: new Date().toISOString(),
+        status: "running",
+    };
+    jobs.set(jobId, record);
+    void (async () => {
+        try {
+            const result = await factory();
+            record.status = "succeeded";
+            record.finishedAt = new Date().toISOString();
+            record.result =
+                result !== null && typeof result === "object"
+                    ? result
+                    : { value: result };
+        }
+        catch (error) {
+            record.status = "failed";
+            record.finishedAt = new Date().toISOString();
+            record.error = error instanceof Error ? error.message : String(error);
+        }
+        finally {
+            evictOldestFinished();
+        }
+    })().catch((error) => {
+        // Defensive: the internal bookkeeping above must never crash the server
+        // process via an unhandled rejection.
+        process.stderr.write(`[kibi-mcp] job bookkeeping error for ${jobId}: ${error instanceof Error ? error.message : String(error)}\n`);
+    });
+    return {
+        kibiProtocol: 1,
+        jobVersion: "kibi.job.v1",
+        jobId,
+        tool,
+        status: "running",
+        pollWith: "kb_job_status",
+    };
+}
+// implements REQ-002
+export function getJob(jobId) {
+    return jobs.get(jobId);
+}
+/** Public JSON shape for kb_job_status responses. */
+// implements REQ-002
+export function jobSnapshot(job) {
+    return {
+        kibiProtocol: 1,
+        jobVersion: "kibi.job.v1",
+        jobId: job.jobId,
+        tool: job.tool,
+        status: job.status,
+        startedAt: job.startedAt,
+        ...(job.finishedAt === undefined ? {} : { finishedAt: job.finishedAt }),
+        ...(job.result === undefined ? {} : { result: job.result }),
+        ...(job.error === undefined ? {} : { error: job.error }),
+    };
+}
+/** Test seam: drop all job state. */
+// implements REQ-002
+export function resetJobsForTests() {
+    jobs.clear();
+    jobCounter = 0;
+}

package/dist/server/json-schema-to-zod.js

@@ -1,4 +1,18 @@
 import { z } from "zod";
+export function firstDefined(items) {
+    return items[0];
+}
+export function describedAnySchema(description) {
+    const anySchema = z.any();
+    return description ? anySchema.describe(description) : anySchema;
+}
+export function singleLiteralOrAny(literalSchemas, description) {
+    const single = firstDefined(literalSchemas);
+    if (!single) {
+        return describedAnySchema(description);
+    }
+    return description ? single.describe(description) : single;
+}
 function hasRequiredProperties(value, schema) {
     if (schema === null || typeof schema !== "object")
         return false;
@@ -64,16 +78,24 @@ export function jsonSchemaToZod(schema) {
         }
         const literalSchemas = literals.map((value) => z.literal(value));
         if (literalSchemas.length === 1) {
-            const single = literalSchemas[0];
-            if (!single) {
-                return description ? z.any().describe(description) : z.any();
-            }
-            return description ? single.describe(description) : single;
+            return singleLiteralOrAny(literalSchemas, description);
         }
         const union = z.union(literalSchemas);
         return description ? union.describe(description) : union;
     }
-    const schemaType = typeof obj.type === "string" ? obj.type : undefined;
+    const schemaTypes = Array.isArray(obj.type)
+        ? obj.type.filter((value) => typeof value === "string")
+        : typeof obj.type === "string"
+            ? [obj.type]
+            : [];
+    // JSON Schema nullable fields are represented as a type union in the
+    // catalog. Build a real Zod union so MCP publishes and validates the same
+    // nullability instead of silently degrading the field to z.any().
+    if (schemaTypes.length > 1) {
+        const variants = schemaTypes.map((type) => jsonSchemaToZod({ ...obj, type }));
+        return z.union(variants);
+    }
+    const schemaType = schemaTypes[0];
     switch (schemaType) {
         case "object": {
             const properties = obj.properties && typeof obj.properties === "object"
@@ -178,10 +200,12 @@ export function jsonSchemaToZod(schema) {
             const description = typeof obj.description === "string" ? obj.description : undefined;
             return description ? b.describe(description) : b;
         }
-        default: {
-            const anySchema = z.any();
+        case "null": {
+            const n = z.null();
             const description = typeof obj.description === "string" ? obj.description : undefined;
-            return description ? anySchema.describe(description) : anySchema;
+            return description ? n.describe(description) : n;
         }
+        default:
+            return describedAnySchema(typeof obj.description === "string" ? obj.description : undefined);
     }
 }