@openephemeris/mcp-server 3.13.10 → 3.14.0

package/dist/tools/apps/chart-wheel-app.js

@@ -20,6 +20,7 @@ import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { registerTool, SERVER_VERSION } from "../index.js";
 import { getActiveClient } from "../../backend/client.js";
+import { OUTPUT_SCHEMA_JSON } from "../output-schemas.js";
 // ── Constants ─────────────────────────────────────────────────────────────
 export const CHART_WHEEL_RESOURCE_URI = "ui://openephemeris/chart-wheel";
 export const CHART_WHEEL_MIME_TYPE = "text/html;profile=mcp-app";
@@ -139,9 +140,18 @@ registerTool({
                 enum: ["placidus", "whole_sign", "equal", "koch", "regiomontanus", "campanus"],
                 description: "House system to use (default: placidus).",
             },
+            bodies: {
+                type: "array",
+                items: { type: "string" },
+                description: "Optional list of body names to include. " +
+                    "Defaults to 13 classical bodies (Sun through Pluto + Chiron + Nodes). " +
+                    "Use 'all' as a single item to include every available body (Lilith, Ceres, Juno, Vesta, Pallas, Vertex, etc.). " +
+                    "Example: ['sun','moon','lilith','vertex'].",
+            },
         },
         required: ["datetime", "latitude", "longitude"],
     },
+    outputSchema: OUTPUT_SCHEMA_JSON,
     annotations: {
         title: "Interactive Chart Wheel Explorer",
         readOnlyHint: true,
@@ -162,6 +172,17 @@ registerTool({
         const lat = args.latitude;
         const lon = args.longitude;
         const natalBody = buildNatalBody(datetime, lat, lon, houseSystem, args.timezone);
+        // Determine which bodies are requested
+        const requestedBodies = args.bodies;
+        const wantsAll = requestedBodies?.some(b => b.toLowerCase() === "all");
+        const wantsExtended = wantsAll || requestedBodies?.some(b => EXTENDED_BODIES.has(b.toLowerCase()));
+        // Enable extended body computation on the API side when needed
+        if (wantsExtended) {
+            const config = natalBody.configuration;
+            config.include_asteroids = true;
+            config.include_lilith = true;
+            config.include_chiron = true;
+        }
         // Fetch natal chart JSON. The chart is rendered client-side in the UI iframe,
         // so we do NOT call the /visualization/chart-wheel endpoint — that was the
         // source of the ~90 second blocking delay.
@@ -175,7 +196,7 @@ registerTool({
             latitude: lat ?? null,
             longitude: lon ?? null,
             location: args.location ?? null,
-        }, houseSystem);
+        }, houseSystem, undefined, requestedBodies);
         const bundleAvailable = Boolean(getChartWheelBundle());
         if (bundleAvailable) {
             return {
@@ -216,6 +237,7 @@ registerTool({
         },
         required: ["planet", "longitude"],
     },
+    outputSchema: OUTPUT_SCHEMA_JSON,
     annotations: { title: "Planet Interpretation", readOnlyHint: true, openWorldHint: false },
     _meta: { ui: { resourceUri: CHART_WHEEL_RESOURCE_URI, visibility: ["app"] } },
     handler: async (args) => {
@@ -250,6 +272,7 @@ registerTool({
         },
         required: ["house_number"],
     },
+    outputSchema: OUTPUT_SCHEMA_JSON,
     annotations: { title: "House Interpretation", readOnlyHint: true, openWorldHint: false },
     _meta: { ui: { resourceUri: CHART_WHEEL_RESOURCE_URI, visibility: ["app"] } },
     handler: async (args) => {
@@ -285,6 +308,7 @@ registerTool({
         },
         required: ["planet1", "planet2"],
     },
+    outputSchema: OUTPUT_SCHEMA_JSON,
     annotations: { title: "Aspect Interpretation", readOnlyHint: true, openWorldHint: false },
     _meta: { ui: { resourceUri: CHART_WHEEL_RESOURCE_URI, visibility: ["app"] } },
     handler: async (args) => {
@@ -333,6 +357,7 @@ registerTool({
         },
         required: ["datetime", "latitude", "longitude", "house_system"],
     },
+    outputSchema: OUTPUT_SCHEMA_JSON,
     annotations: { title: "Recalculate Chart", readOnlyHint: true, openWorldHint: false },
     _meta: { ui: { resourceUri: CHART_WHEEL_RESOURCE_URI, visibility: ["app"] } },
     handler: async (args) => {
@@ -391,6 +416,13 @@ const CLASSICAL_PLANETS = new Set([
     "jupiter", "saturn", "uranus", "neptune", "pluto",
     "chiron", "north_node", "south_node", "true_node", "asc", "mc",
 ]);
+const EXTENDED_BODIES = new Set([
+    "mean_lilith", "lilith", "true_lilith",
+    "ceres", "juno", "vesta", "pallas", "pholus",
+    "vertex", "part_of_fortune",
+    "eris", "sedna",
+]);
+const ALL_KNOWN_BODIES = new Set([...CLASSICAL_PLANETS, ...EXTENDED_BODIES]);
 /**
  * Build a lean, SVG-free payload for Claude's text context.
  * Strips SVG, filters to classical planets only, and packages birth params.
@@ -422,7 +454,13 @@ function computeAspects(planets) {
                 diff = 360 - diff;
             for (const asp of ASPECTS) {
                 const orb = Math.abs(diff - asp.angle);
-                if (orb <= asp.orb) {
+                // Tighten orbs when one or both bodies are extended (asteroids, etc.)
+                const p1Extended = EXTENDED_BODIES.has(p1.name.toLowerCase());
+                const p2Extended = EXTENDED_BODIES.has(p2.name.toLowerCase());
+                const effectiveOrb = (p1Extended || p2Extended)
+                    ? Math.min(asp.orb * 0.5, 3) // half standard, capped at 3°
+                    : asp.orb;
+                if (orb <= effectiveOrb) {
                     // Applying: combined longitudinal speed closing the orb
                     const applying = ((p1.speed ?? 1) - (p2.speed ?? 0)) < 0 ? diff < asp.angle : diff > asp.angle;
                     results.push({
@@ -440,7 +478,7 @@ function computeAspects(planets) {
     }
     return results;
 }
-function buildModelPayload(chartData, birthParams, houseSystem, svgBase) {
+function buildModelPayload(chartData, birthParams, houseSystem, svgBase, bodyFilter) {
     // ── 1. Normalize planets: keyed object → typed PlanetData array ──────────
     // The natal API returns { sun: { longitude, sign_name, is_retrograde, ... }, moon: {...} }.
     // The chart wheel UI expects PlanetData[] with canonical field names.
@@ -448,7 +486,18 @@ function buildModelPayload(chartData, birthParams, houseSystem, svgBase) {
     let planetsArray = [];
     if (rawPlanets && typeof rawPlanets === "object" && !Array.isArray(rawPlanets)) {
         planetsArray = Object.entries(rawPlanets)
-            .filter(([k]) => CLASSICAL_PLANETS.has(k.toLowerCase()))
+            .filter(([k]) => {
+            const key = k.toLowerCase();
+            // If specific bodies were requested, use that filter
+            if (bodyFilter) {
+                const wantsAll = bodyFilter.some(b => b.toLowerCase() === "all");
+                if (wantsAll)
+                    return ALL_KNOWN_BODIES.has(key);
+                return bodyFilter.some(b => b.toLowerCase() === key);
+            }
+            // Default: classical planets only
+            return CLASSICAL_PLANETS.has(key);
+        })
             .map(([name, p]) => ({
             name: name.toLowerCase(),
             longitude: (p.longitude ?? p.lon ?? 0),

package/dist/tools/apps/location-tools.js

@@ -1,5 +1,6 @@
 import { registerTool, validateRequired } from "../index.js";
 import { getActiveClient } from "../../backend/client.js";
+import { OUTPUT_SCHEMA_JSON } from "../output-schemas.js";
 registerTool({
     name: "location_search",
     description: "App-only tool for getting location autocomplete suggestions. Returns latitude, longitude, and IANA timezone.",
@@ -14,6 +15,7 @@ registerTool({
         required: ["query"],
         additionalProperties: false,
     },
+    outputSchema: OUTPUT_SCHEMA_JSON,
     _meta: {
         ui: {
             visibility: ["app"],
@@ -38,6 +40,7 @@ registerTool({
         required: ["latitude", "longitude"],
         additionalProperties: false,
     },
+    outputSchema: OUTPUT_SCHEMA_JSON,
     _meta: {
         ui: {
             visibility: ["app"],

package/dist/tools/apps/moon-phase-app.js

@@ -16,6 +16,7 @@ import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { registerTool, validateCoordinates, SERVER_VERSION } from "../index.js";
 import { getActiveClient } from "../../backend/client.js";
+import { OUTPUT_SCHEMA_JSON } from "../output-schemas.js";
 // ── Constants ─────────────────────────────────────────────────────────────────
 export const MOON_PHASE_RESOURCE_URI = "ui://openephemeris/moon-phase";
 export const MOON_PHASE_MIME_TYPE = "text/html;profile=mcp-app";
@@ -54,15 +55,26 @@ export function clearMoonPhaseBundleCache() {
 function buildMoonSummary(data) {
     const phase = data.phase;
     const voc = data.void_of_course;
-    const phaseName = String(phase?.phase_name ?? phase?.name ?? "Unknown");
-    const illumination = typeof phase?.illumination === "number" ? Math.round(phase.illumination * 100) : "?";
-    const moonSign = String(phase?.moon_sign ?? phase?.sign ?? "");
+    const meta = (phase?.metadata ?? {});
+    const phaseName = String(phase?.phase_name ?? phase?.name ?? "Unknown").replace(/_/g, " ").replace(/\b\w/g, c => c.toUpperCase());
+    const illumination = typeof phase?.illumination === "number" ? Math.round(phase.illumination) : "?";
+    const moonSign = String(meta?.moon_sign ?? phase?.moon_sign ?? phase?.sign ?? voc?.current_sign ?? "");
     const isVoc = Boolean(voc?.is_void ?? voc?.is_void_of_course ?? false);
+    const speed = typeof meta?.longitude_speed === "number" ? meta.longitude_speed : null;
+    const daysToFull = typeof meta?.days_to_full === "number" ? meta.days_to_full :
+        typeof phase?.days_to_full === "number" ? phase.days_to_full : null;
     let summary = "**Moon Phase** — " + phaseName + "\n\n" +
         "Illumination: **" + illumination + "%**\n";
     if (moonSign) {
         summary += "Moon Sign: **" + moonSign + "**\n";
     }
+    if (speed !== null) {
+        const tempo = speed > 14.5 ? "fast" : speed < 12.0 ? "slow" : "average";
+        summary += "Speed: **" + speed.toFixed(2) + "°/day** (" + tempo + ")\n";
+    }
+    if (daysToFull !== null) {
+        summary += "Full Moon in: **" + daysToFull.toFixed(1) + " days**\n";
+    }
     if (isVoc) {
         summary += "\n⚠️ **Void of Course** — The Moon is currently VOC.";
         if (voc?.ends)
@@ -107,6 +119,7 @@ registerTool({
         required: [],
         additionalProperties: false,
     },
+    outputSchema: OUTPUT_SCHEMA_JSON,
     annotations: {
         title: "Interactive Moon Phase Explorer",
         readOnlyHint: true,
@@ -129,38 +142,79 @@ registerTool({
             params.latitude = args.latitude;
         if (args.longitude != null)
             params.longitude = args.longitude;
-        // Fetch phase and VOC in parallel
-        const [phase, voc] = await Promise.allSettled([
+        // Fetch phase, VOC, and moon aspects in parallel
+        const [phase, voc, aspects] = await Promise.allSettled([
             client.request("GET", "/ephemeris/moon/phase", { params }),
             client.request("GET", "/ephemeris/moon/void-of-course", { params }),
+            client.request("GET", "/ephemeris/moon/aspects", { params }),
         ]);
         const mergedData = {
             phase: phase.status === "fulfilled" ? phase.value : { error: phase.reason?.message },
             void_of_course: voc.status === "fulfilled" ? voc.value : { error: voc.reason?.message },
+            aspects: aspects.status === "fulfilled" ? aspects.value : null,
         };
         // Flatten for the UI — merge phase fields to top level
         const phaseData = mergedData.phase;
         const vocData = mergedData.void_of_course;
+        const aspectsData = mergedData.aspects;
+        // Extract enriched metadata fields from the GET response
+        const meta = (phaseData?.metadata ?? {});
+        const moonSign = String(meta?.moon_sign ?? phaseData?.moon_sign ?? phaseData?.sign ?? vocData?.current_sign ?? "");
+        const moonSpeedRaw = meta?.longitude_speed;
+        const moonSpeed = typeof moonSpeedRaw === "number" ? moonSpeedRaw : null;
+        const angularDiameter = typeof meta?.angular_diameter === "number" ? meta.angular_diameter : null;
+        const distanceKm = typeof meta?.moon_distance_km === "number" ? meta.moon_distance_km : null;
+        const moonLat = typeof meta?.moon_lat === "number" ? meta.moon_lat : null;
+        const ageDays = typeof meta?.age_days === "number" ? meta.age_days :
+            (typeof phaseData?.age_days === "number" ? phaseData.age_days : null);
+        // days_to_new / days_to_full can come as the union value or from the top-level field
+        const extractDays = (field) => {
+            if (typeof field === "number")
+                return field;
+            if (field && typeof field === "object") {
+                const v = Object.values(field)[0];
+                if (typeof v === "number")
+                    return v;
+            }
+            return null;
+        };
+        const daysToNew = extractDays(phaseData?.days_to_new);
+        const daysToFull = extractDays(phaseData?.days_to_full);
+        // Top 3 applying aspects by tightest orb
+        const rawAspects = (aspectsData?.aspects ?? aspectsData?.data ?? []);
+        const applyingAspects = Array.isArray(rawAspects)
+            ? rawAspects
+                .filter((a) => a.applying === true || a.type === "applying")
+                .sort((a, b) => Math.abs(a.orb ?? 99) - Math.abs(b.orb ?? 99))
+                .slice(0, 3)
+                .map((a) => ({
+                planet: a.planet ?? a.body ?? a.planet_name ?? "",
+                aspect: a.aspect ?? a.aspect_name ?? a.type_name ?? "",
+                orb: typeof a.orb === "number" ? Math.abs(a.orb) : null,
+            }))
+            : [];
         const uiPayload = {
-            phase_name: phaseData?.phase_name ?? phaseData?.name ?? "Unknown",
-            illumination: phaseData?.illumination ?? 0,
-            age_days: phaseData?.age_days ?? phaseData?.age ?? null,
+            phase_name: String(phaseData?.phase_name ?? phaseData?.name ?? "Unknown").replace(/_/g, " ").replace(/\b\w/g, c => c.toUpperCase()),
+            illumination: typeof phaseData?.illumination === "number" ? phaseData.illumination / 100.0 : 0,
+            phase_angle: typeof phaseData?.phase_angle === "number" ? phaseData.phase_angle : null,
+            age_days: ageDays,
+            days_to_new: daysToNew,
+            days_to_full: daysToFull,
             waxing: phaseData?.waxing ??
                 // Fallback chain: elongation < 180° = waxing, else age_days < 14.75 = waxing.
-                // Never use illumination alone — it's identical for mirror-symmetric waxing/waning phases.
-                (typeof phaseData?.elongation === "number"
-                    ? phaseData.elongation < 180
-                    : typeof phaseData?.age_days === "number"
-                        ? phaseData.age_days < 14.75
+                (typeof phaseData?.phase_angle === "number"
+                    ? phaseData.phase_angle < 180
+                    : typeof ageDays === "number"
+                        ? ageDays < 14.75
                         : true), // safe default: assume waxing
-            moon_sign: phaseData?.moon_sign ?? phaseData?.sign ?? "",
-            moon_longitude: phaseData?.moon_longitude ?? phaseData?.longitude ?? null,
-            sun_longitude: phaseData?.sun_longitude ?? null,
-            elongation: phaseData?.elongation ?? null,
-            moon_latitude: phaseData?.moon_latitude ?? null,
-            moon_distance_km: phaseData?.moon_distance_km ?? phaseData?.distance_km ?? null,
-            next_new_moon: phaseData?.next_new_moon ?? null,
-            next_full_moon: phaseData?.next_full_moon ?? null,
+            moon_sign: moonSign,
+            moon_longitude: meta?.moon_lon ?? phaseData?.moon_longitude ?? phaseData?.longitude ?? null,
+            moon_latitude: moonLat,
+            moon_distance_km: distanceKm,
+            angular_diameter: angularDiameter,
+            moon_speed: moonSpeed,
+            sun_longitude: meta?.sun_lon ?? phaseData?.sun_longitude ?? null,
+            applying_aspects: applyingAspects,
             voc_status: {
                 is_void: Boolean(vocData?.is_void ?? vocData?.is_void_of_course ?? false),
                 started: vocData?.started ?? vocData?.start ?? null,

package/dist/tools/apps/transit-timeline-app.js

@@ -17,6 +17,7 @@ import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { registerTool, validateRequired, SERVER_VERSION } from "../index.js";
 import { getActiveClient } from "../../backend/client.js";
+import { OUTPUT_SCHEMA_JSON } from "../output-schemas.js";
 // ── Constants ─────────────────────────────────────────────────────────────────
 export const TRANSIT_TIMELINE_RESOURCE_URI = "ui://openephemeris/transit-timeline";
 export const TRANSIT_TIMELINE_MIME_TYPE = "text/html;profile=mcp-app";
@@ -129,6 +130,7 @@ registerTool({
         required: ["natal_datetime", "natal_latitude", "natal_longitude", "start_date", "end_date"],
         additionalProperties: false,
     },
+    outputSchema: OUTPUT_SCHEMA_JSON,
     annotations: {
         title: "Interactive Transit Timeline Explorer",
         readOnlyHint: true,
@@ -145,6 +147,19 @@ registerTool({
     handler: async (args) => {
         validateRequired(args, ["natal_datetime", "natal_latitude", "natal_longitude", "start_date", "end_date"]);
         const client = getActiveClient();
+        // Guard: reject excessively wide date ranges before hitting the backend.
+        // The Go backend clamps Explorer tier to 1 year, but larger tiers can still
+        // trigger compute-bound 45-second timeouts on very wide windows.
+        const startMs = new Date(args.start_date).getTime();
+        const endMs = new Date(args.end_date).getTime();
+        if (!isNaN(startMs) && !isNaN(endMs)) {
+            const spanDays = (endMs - startMs) / (1000 * 60 * 60 * 24);
+            if (spanDays > 5 * 365) {
+                throw new Error(`Date range too wide (${Math.round(spanDays / 365)} years). ` +
+                    `The transit timeline works best with windows under 2 years — try narrowing ` +
+                    `start_date and end_date to a 1–2 year window and re-run.`);
+            }
+        }
         // Step 1: Compute natal chart to extract planetary longitudes
         const natalBody = {
             subject: {
@@ -161,32 +176,57 @@ registerTool({
         const natalPositionMap = {};
         const planets = natalResult?.planets || natalResult?.data?.planets || [];
         const planetArray = Array.isArray(planets) ? planets : Object.values(planets);
+        // ── Core natal points to target (conjunction search) ─────────────────────
+        // When no natal_points filter is given, we limit to 7 core bodies to keep
+        // target_degrees count manageable. 4 outer planets × 10+ targets creates a
+        // combinatoric explosion (40+ serial SearchTransit calls on the backend).
+        const CORE_BODIES_DEFAULT = new Set([
+            "sun", "moon", "mercury", "venus", "mars", "jupiter", "saturn",
+        ]);
         const wantedPoints = args.natal_points
             ? new Set(args.natal_points.map((p) => p.toLowerCase()))
-            : null;
+            : CORE_BODIES_DEFAULT;
         for (const planet of planetArray) {
             const name = (planet.name || planet.id || "").toLowerCase();
             const lon = planet.longitude ?? planet.ecliptic_longitude ?? planet.lon;
             if (typeof lon !== "number" || !isFinite(lon))
                 continue;
-            if (wantedPoints && !wantedPoints.has(name))
+            if (!wantedPoints.has(name))
                 continue;
             targetDegrees.push(Math.round(lon * 100) / 100);
             natalPositionMap[name] = lon;
         }
-        // Extract angles (ASC, MC)
-        const angles = natalResult?.angles || natalResult?.data?.angles;
-        if (angles) {
-            const angleEntries = Array.isArray(angles) ? angles : Object.entries(angles).map(([k, v]) => ({ name: k, ...(typeof v === 'object' ? v : { longitude: v }) }));
-            for (const angle of angleEntries) {
-                const name = (angle.name || angle.id || "").toLowerCase();
-                const lon = angle.longitude ?? angle.ecliptic_longitude ?? angle.lon;
-                if (typeof lon !== "number" || !isFinite(lon))
-                    continue;
-                if (wantedPoints && !wantedPoints.has(name))
-                    continue;
-                targetDegrees.push(Math.round(lon * 100) / 100);
-                natalPositionMap[name] = lon;
+        // Extract angles (ASC, MC) — only if explicitly requested via natal_points
+        if (args.natal_points) {
+            const angles = natalResult?.angles || natalResult?.data?.angles;
+            if (angles) {
+                const angleEntries = Array.isArray(angles)
+                    ? angles
+                    : Object.entries(angles).map(([k, v]) => ({ name: k, ...(typeof v === "object" ? v : { longitude: v }) }));
+                for (const angle of angleEntries) {
+                    const name = (angle.name || angle.id || "").toLowerCase();
+                    const lon = angle.longitude ?? angle.ecliptic_longitude ?? angle.lon;
+                    if (typeof lon !== "number" || !isFinite(lon))
+                        continue;
+                    if (!wantedPoints.has(name))
+                        continue;
+                    targetDegrees.push(Math.round(lon * 100) / 100);
+                    natalPositionMap[name] = lon;
+                }
+            }
+        }
+        // Safety cap: never send more than 12 target degrees to the backend
+        // (prevents combinatoric timeouts when many planets + many targets overlap).
+        const MAX_TARGETS = 12;
+        if (targetDegrees.length > MAX_TARGETS) {
+            targetDegrees.splice(MAX_TARGETS);
+            // Prune natalPositionMap to match
+            const keepNames = new Set(Object.entries(natalPositionMap)
+                .filter(([, v]) => targetDegrees.includes(Math.round(v * 100) / 100))
+                .map(([k]) => k));
+            for (const k of Object.keys(natalPositionMap)) {
+                if (!keepNames.has(k))
+                    delete natalPositionMap[k];
             }
         }
         if (targetDegrees.length === 0) {
@@ -199,31 +239,43 @@ registerTool({
         let endStr = args.end_date;
         if (/^\d{4}-\d{2}-\d{2}$/.test(endStr))
             endStr += "T23:59:59Z";
+        const aspectAngle = typeof args.aspect_angle === "number" ? args.aspect_angle : 0;
+        let effectiveTargets = targetDegrees;
+        if (aspectAngle !== 0) {
+            effectiveTargets = targetDegrees.map((deg) => ((deg + aspectAngle) % 360 + 360) % 360);
+        }
         const transitBody = {
             start_date: startStr,
             end_date: endStr,
-            target_degrees: targetDegrees,
+            target_degrees: effectiveTargets,
         };
         if (args.transiting_planets)
             transitBody.planet_names = args.transiting_planets;
-        let effectiveTargets = targetDegrees;
-        const aspectAngle = typeof args.aspect_angle === "number" ? args.aspect_angle : 0;
         if (aspectAngle !== 0) {
-            effectiveTargets = targetDegrees.map((deg) => ((deg + aspectAngle) % 360 + 360) % 360);
-            transitBody.target_degrees = effectiveTargets;
             transitBody.search_criteria = { aspect_angle: aspectAngle };
         }
-        const transitResult = await client.request("POST", "/predictive/transits/search", { data: transitBody });
+        // Give the backend a 90s window — explorer tier allows 30s Go compute
+        // timeout, but the node-to-Fly round-trip including queuing can extend this.
+        const transitResult = await client.request("POST", "/predictive/transits/search", { data: transitBody, timeoutMs: 90_000 });
+        // Normalize the API response into a flat array so the iframe UI always
+        // receives an iterable — some backend response shapes wrap events in a
+        // container object rather than returning a bare array.
+        const transitArray = Array.isArray(transitResult)
+            ? transitResult
+            : (transitResult?.events ??
+                transitResult?.transits ??
+                transitResult?.results ??
+                []);
         // Build payload
         const payload = {
             natal_positions: natalPositionMap,
             target_degrees_used: effectiveTargets,
             aspect_angle: aspectAngle,
-            transit_results: transitResult,
+            transit_results: transitArray,
             search_window: { start_date: args.start_date, end_date: args.end_date },
             server_version: SERVER_VERSION,
         };
-        const summary = buildTransitSummary(natalPositionMap, transitResult, aspectAngle, args.start_date, args.end_date);
+        const summary = buildTransitSummary(natalPositionMap, transitArray, aspectAngle, args.start_date, args.end_date);
         const bundleAvailable = Boolean(getTransitTimelineBundle());
         if (bundleAvailable) {
             return {

package/dist/tools/apps/vedic-chart-app.js

@@ -14,6 +14,7 @@ import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { registerTool, SERVER_VERSION } from "../index.js";
 import { getActiveClient } from "../../backend/client.js";
+import { OUTPUT_SCHEMA_JSON } from "../output-schemas.js";
 // ── Constants ─────────────────────────────────────────────────────────────────
 export const VEDIC_CHART_RESOURCE_URI = "ui://openephemeris/vedic-chart";
 export const VEDIC_CHART_MIME_TYPE = "text/html;profile=mcp-app";
@@ -149,6 +150,7 @@ registerTool({
         required: ["datetime", "latitude", "longitude"],
         additionalProperties: false,
     },
+    outputSchema: OUTPUT_SCHEMA_JSON,
     annotations: {
         title: "Interactive Vedic Jyotish Chart",
         readOnlyHint: true,

package/dist/tools/auth.js

@@ -1,6 +1,7 @@
 import { registerTool } from "./index.js";
 import { CredentialManager } from "../auth/credentials.js";
 import { DeviceAuthFlow } from "../auth/device-auth.js";
+import { OUTPUT_SCHEMA_AUTH } from "./output-schemas.js";
 const credentialManager = new CredentialManager();
 // ────────────────────────────────────────────────────────
 // auth.login — Start the device authorization flow
@@ -17,6 +18,7 @@ registerTool({
         properties: {},
         additionalProperties: false,
     },
+    outputSchema: OUTPUT_SCHEMA_AUTH,
     annotations: {
         title: "Connect Account",
         readOnlyHint: false,
@@ -95,6 +97,7 @@ registerTool({
         properties: {},
         additionalProperties: false,
     },
+    outputSchema: OUTPUT_SCHEMA_AUTH,
     annotations: {
         title: "Auth Status",
         readOnlyHint: true,
@@ -179,6 +182,7 @@ registerTool({
         properties: {},
         additionalProperties: false,
     },
+    outputSchema: OUTPUT_SCHEMA_AUTH,
     annotations: {
         title: "Disconnect Account",
         readOnlyHint: false,

package/dist/tools/dev.js

@@ -1,5 +1,6 @@
 import { registerTool, validateRequired } from "./index.js";
 import { getActiveClient } from "../backend/client.js";
+import { OUTPUT_SCHEMA_JSON } from "./output-schemas.js";
 import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
@@ -123,6 +124,7 @@ registerTool({
         required: ["method", "path"],
         additionalProperties: false,
     },
+    outputSchema: OUTPUT_SCHEMA_JSON,
     handler: async (args) => {
         validateRequired(args, ["path"]);
         const methodStr = String(args.method || "GET").toUpperCase();
@@ -189,6 +191,7 @@ registerTool({
         properties: {},
         additionalProperties: false,
     },
+    outputSchema: OUTPUT_SCHEMA_JSON,
     handler: async () => {
         const allowlist = loadAllowlist();
         return {

package/dist/tools/index.d.ts

@@ -5,6 +5,12 @@ export interface ToolDefinition {
     name: string;
     description: string;
     inputSchema: z.ZodType<any> | Record<string, unknown>;
+    /**
+     * MCP spec 2025-11-25 — JSON Schema describing the structured output of this tool.
+     * Smithery uses this to score "Output schemas" in the quality rubric.
+     * All tools return MCP content block arrays; specialized tools declare richer shapes.
+     */
+    outputSchema?: Record<string, unknown>;
     annotations?: {
         title?: string;
         readOnlyHint?: boolean;

package/dist/tools/index.js

@@ -47,7 +47,11 @@ export async function initTools(profile) {
     // Always register the generic proxy tools (dev.call + dev.list_allowed).
     await import("./dev.js");
     if (resolvedProfile === "dev") {
-        // Register all specialized domain tools.
+        // ── FULL BUILD: all specialized tools ───────────────────────────
+        // Payload size theory was disproven. The "Failed to call tool" 
+        // bug was caused by Claude Desktop's MCP App iframe handler 
+        // corruption. Iframe tools are purged; all specialized tools are restored.
+        // ────────────────────────────────────────────────────────────────
         await import("./specialized/natal.js");
         await import("./specialized/transits.js");
         await import("./specialized/moon.js");
@@ -70,15 +74,12 @@ export async function initTools(profile) {
         await import("./specialized/ephemeris_extended.js");
         await import("./specialized/venus_star_points.js");
         await import("./specialized/acg.js");
-        // MCP App tools (interactive UI)
+        await import("./apps/location-tools.js");
+        // Re-enable requested MCP apps (iframes)
         await import("./apps/chart-wheel-app.js");
-        await import("./apps/bodygraph-app.js");
         await import("./apps/bi-wheel-app.js");
-        await import("./apps/transit-timeline-app.js");
+        await import("./apps/bodygraph-app.js");
         await import("./apps/moon-phase-app.js");
-        await import("./apps/bazi-app.js");
-        await import("./apps/vedic-chart-app.js");
-        await import("./apps/location-tools.js");
     }
 }
 /**

package/dist/tools/output-schemas.d.ts

@@ -0,0 +1,37 @@
+/**
+ * output-schemas.ts — Shared JSON Schema output schema definitions for MCP tools.
+ *
+ * MCP spec 2025-11-25 supports `outputSchema` on tool definitions. Smithery
+ * uses this field to score the "Output schemas" quality criterion (10.37pt / 57 tools).
+ *
+ * All tools return an MCP content block response. Most return a single JSON text
+ * block; visual tools return an image block or an image + text block.
+ *
+ * Usage:
+ *   import { OUTPUT_SCHEMA_JSON, OUTPUT_SCHEMA_IMAGE } from "../output-schemas.js";
+ *   registerTool({ ..., outputSchema: OUTPUT_SCHEMA_JSON });
+ */
+/**
+ * Standard tool output schema: a single JSON text block.
+ * Used by all data-returning tools (natal chart, transits, synastry, etc.).
+ */
+export declare const OUTPUT_SCHEMA_JSON: Record<string, unknown>;
+/**
+ * Visual tool output schema: a single SVG or PNG image block.
+ * Used by chart wheel (direct image), BaZi chart, Vedic chart, etc.
+ */
+export declare const OUTPUT_SCHEMA_IMAGE: Record<string, unknown>;
+/**
+ * Dual output schema: an image block followed by a JSON text block.
+ * Used by tools with include_visual=true (natal chart SVG + data, bi-wheel, etc.).
+ */
+export declare const OUTPUT_SCHEMA_IMAGE_AND_JSON: Record<string, unknown>;
+/**
+ * Interactive app tool output schema: a text block containing MCP App metadata.
+ * Used by explore_* tools that return an embedded UI resource reference.
+ */
+export declare const OUTPUT_SCHEMA_APP: Record<string, unknown>;
+/**
+ * Auth tool output schema: a JSON text block confirming auth status or credentials.
+ */
+export declare const OUTPUT_SCHEMA_AUTH: Record<string, unknown>;