@yoryoboy/bi-mcp 1.7.0 → 1.9.0

package/dist/src/tools/mercadolibre/get-shipping-summary.js

@@ -1,10 +1,14 @@
 import { error, object } from "mcp-use/server";
 import { z } from "zod";
-import { formatMercadoLibreError } from "../../services/mercadolibre/mercadolibre-api.js";
 import {
-  getMercadoLibreShipment,
-  getMercadoLibreShipmentCosts,
-  searchMercadoLibreOrders
+  formatMercadoLibreError,
+  normalizeMercadoLibrePaging
+} from "../../services/mercadolibre/mercadolibre-api.js";
+import {
+  getMercadoLibreShipmentBatch,
+  getMercadoLibreShipmentCostsBatch,
+  searchMercadoLibreOrders,
+  searchMercadoLibreOrdersBatch
 } from "../../services/mercadolibre/mercadolibre-orders.js";
 import { stripNulls } from "../../utils/strip-payload.js";
 import {
@@ -12,19 +16,228 @@ import {
   asRecord,
   currencyBucket,
   mercadoLibreDateRegex,
+  normalizeScalarString,
   normalizeString,
   roundMoney,
   toNumber
 } from "./helpers.js";
 import { resolveMercadoLibreProfileOrSelection } from "./profile-resolution.js";
 import { mercadolibreProfileIdSchemaField } from "./write-helpers.js";
+const PAGE_FETCH_CONCURRENCY = 15;
+const PAGE_FETCH_MAX_RETRIES = 2;
+const SHIPPING_DETAIL_MAX_PAGES_PER_CALL = 15;
+const DEFAULT_CALCULATIONS_PAGE_LIMIT = 50;
+const DEFAULT_SHIPPING_DETAIL_PAGE_LIMIT = 50;
+const BUSINESS_TIME_ZONE = "America/Argentina/Buenos_Aires";
+const TOP_LIMIT = 10;
+const shipmentsSchema = [
+  "order_id",
+  "shipment_id",
+  "status",
+  "substatus",
+  "logistic_type",
+  "mode",
+  "currency_id",
+  "cost"
+];
+function safeRate(numerator, denominator) {
+  if (!Number.isFinite(denominator) || denominator <= 0) {
+    return 0;
+  }
+  return Number((numerator / denominator).toFixed(4));
+}
+function topBreakdownFromMap(counts, total, limit = TOP_LIMIT) {
+  const sorted = Array.from(counts.entries()).filter(([, count]) => count > 0).sort((left, right) => right[1] - left[1] || left[0].localeCompare(right[0]));
+  const entries = sorted.slice(0, limit).map(([key, orders]) => ({
+    key,
+    orders,
+    rate: safeRate(orders, total)
+  }));
+  const otherOrders = sorted.slice(limit).reduce((sum, [, count]) => sum + count, 0);
+  return stripNulls({
+    entries,
+    other_orders: otherOrders > 0 ? otherOrders : void 0,
+    other_rate: otherOrders > 0 ? safeRate(otherOrders, total) : void 0
+  });
+}
+function incrementCount(map, key) {
+  if (!key) {
+    return;
+  }
+  map.set(key, (map.get(key) ?? 0) + 1);
+}
+function topSingleValue(counts) {
+  return Array.from(counts.entries()).filter(([key]) => key).sort((left, right) => right[1] - left[1] || left[0].localeCompare(right[0]))[0]?.[0] ?? "";
+}
+function incrementCurrency(map, currencyId, amount) {
+  map[currencyId] = roundMoney((map[currencyId] ?? 0) + amount);
+}
+function sortedCurrencyTotals(input) {
+  return Object.fromEntries(
+    Object.entries(input).filter(([, amount]) => amount !== 0).sort(([left], [right]) => left.localeCompare(right)).map(([currencyId, amount]) => [currencyId, roundMoney(amount)])
+  );
+}
+function formatDateInTimeZone(dateValue, timeZone) {
+  const formatter = new Intl.DateTimeFormat("en-CA", {
+    timeZone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit"
+  });
+  const parts = formatter.formatToParts(dateValue);
+  const year = parts.find((part) => part.type === "year")?.value;
+  const month = parts.find((part) => part.type === "month")?.value;
+  const day = parts.find((part) => part.type === "day")?.value;
+  if (!year || !month || !day) {
+    return "";
+  }
+  return `${year}-${month}-${day}`;
+}
+function getLocalDateBucket(createdAt, timeZone) {
+  if (!createdAt) {
+    return "";
+  }
+  const date = new Date(createdAt);
+  if (Number.isNaN(date.getTime())) {
+    return "";
+  }
+  return formatDateInTimeZone(date, timeZone);
+}
+function buildShippingSummaryMetadata(params) {
+  const requestedWindowEndOffset = params.effectiveOffset + params.effectiveLimit * params.pagesRequested;
+  const nextOffset = params.responseMode === "shipments_chunk" ? requestedWindowEndOffset : params.effectiveOffset + params.returned;
+  const hasMoreOrders = nextOffset < params.total;
+  const hasFailures = params.pagesFailed > 0 || params.shipmentFailures > 0;
+  const universeFullyFetched = params.responseMode === "calculations" && !hasFailures && params.returned >= params.total;
+  let continuation = "No more pages for this query.";
+  if (params.pagesFailed > 0) {
+    const offsets = params.failedOffsets.slice(0, 5).join(", ");
+    const moreOffsets = params.failedOffsets.length > 5 ? ` y ${params.failedOffsets.length - 5} offsets adicionales` : "";
+    continuation = params.responseMode === "shipments_chunk" ? `Se recuperaron paginas parciales. Reintentar primero la misma tool con responseMode="shipments_chunk", offset=${params.failedOffsets[0]} y limit=${params.effectiveLimit}. Offsets fallidos: ${offsets}${moreOffsets}. Luego continuar con offset=${nextOffset} si hace falta.` : `Calculos parciales por paginas fallidas. Reintentar la misma tool con responseMode="calculations". Offsets fallidos: ${offsets}${moreOffsets}.`;
+  } else if (params.shipmentFailures > 0) {
+    continuation = params.responseMode === "shipments_chunk" ? `Se recuperaron shipments parciales. Reintentar la misma tool con responseMode="shipments_chunk", offset=${params.effectiveOffset} y limit=${params.effectiveLimit}${hasMoreOrders ? `. Luego continuar con offset=${nextOffset} si hace falta.` : "."}` : 'Calculos parciales por fallas al consultar shipments o costos. Reintentar la misma tool con responseMode="calculations".';
+  } else if (params.responseMode === "shipments_chunk" && hasMoreOrders) {
+    continuation = `Para continuar trayendo shipments, volver a invocar meli_get_shipping_summary con los mismos filtros, responseMode="shipments_chunk", offset=${nextOffset} y limit=${params.effectiveLimit}. Repetir hasta has_more=false.`;
+  } else if (params.responseMode === "calculations") {
+    continuation = 'Calculos completos. Si el usuario pide detalle de shipments, invocar la misma tool con responseMode="shipments_chunk", offset=0 y limit=50.';
+  }
+  return stripNulls({
+    total: params.total,
+    limit: params.effectiveLimit,
+    offset: params.effectiveOffset,
+    returned: params.returned,
+    has_more: params.responseMode === "shipments_chunk" ? hasMoreOrders || hasFailures : hasFailures,
+    next_offset: params.responseMode === "shipments_chunk" && hasMoreOrders ? nextOffset : void 0,
+    continuation,
+    fetch_mode: params.responseMode === "shipments_chunk" ? "shipments_chunk" : "full_calculations",
+    pages_per_call_limit: params.responseMode === "shipments_chunk" ? SHIPPING_DETAIL_MAX_PAGES_PER_CALL : void 0,
+    pages_requested: params.pagesRequested,
+    pages_succeeded: params.pagesSucceeded,
+    pages_failed: params.pagesFailed,
+    shipment_failures: params.shipmentFailures,
+    universe_fully_fetched: universeFullyFetched
+  });
+}
+function extractShipmentCost(costs) {
+  return toNumber(asRecord(costs.senders).cost) || toNumber(asRecord(costs.receiver).cost) || toNumber(costs.gross_amount) || toNumber(costs.cost);
+}
+function formatCompactShipmentRow(params) {
+  return [
+    params.orderId,
+    params.shipmentId,
+    params.status,
+    params.substatus,
+    params.logisticType,
+    params.mode,
+    params.currencyId,
+    params.cost
+  ];
+}
+function buildShippingCalculations(params) {
+  const costsByCurrency = Object.fromEntries(
+    Object.entries(params.costsByCurrency).sort(([left], [right]) => left.localeCompare(right)).map(([currencyId, bucket]) => [
+      currencyId,
+      {
+        total_shipping_cost: roundMoney(bucket.total_cost),
+        shipments: bucket.shipments,
+        shipments_with_cost: bucket.shipments_with_cost,
+        zero_cost_shipments: bucket.zero_cost_shipments,
+        avg_cost_per_shipment: roundMoney(bucket.total_cost / Math.max(1, bucket.shipments)),
+        avg_cost_per_shipment_with_cost: roundMoney(
+          bucket.total_cost / Math.max(1, bucket.shipments_with_cost)
+        ),
+        shipping_cost_rate_by_shipment: safeRate(bucket.shipments_with_cost, bucket.shipments)
+      }
+    ])
+  );
+  const dailyTrend = Array.from(params.dailyMetrics.entries()).sort(([left], [right]) => left.localeCompare(right)).map(
+    ([, metric]) => stripNulls({
+      date: metric.date,
+      shipments: metric.shipments,
+      delivered_shipments: metric.delivered_shipments,
+      cancelled_shipments: metric.cancelled_shipments,
+      not_delivered_shipments: metric.not_delivered_shipments,
+      shipping_cost_by_currency: sortedCurrencyTotals(metric.shipping_cost_by_currency)
+    })
+  );
+  return {
+    overview: {
+      orders_total: params.ordersTotal,
+      orders_with_shipping: params.ordersWithShipping,
+      shipments_total: params.shipmentsInspected,
+      shipments_requested: params.shipmentsRequested,
+      shipping_attachment_rate: safeRate(params.ordersWithShipping, params.ordersTotal),
+      delivered_shipments: params.deliveredShipments,
+      cancelled_shipments: params.cancelledShipments,
+      not_delivered_shipments: params.notDeliveredShipments
+    },
+    delivery_health: {
+      status_breakdown: topBreakdownFromMap(params.statusCounts, Math.max(1, params.shipmentsInspected)),
+      substatus_breakdown: topBreakdownFromMap(params.substatusCounts, Math.max(1, params.shipmentsInspected)),
+      delivered_rate: safeRate(params.deliveredShipments, params.shipmentsInspected),
+      cancelled_rate: safeRate(params.cancelledShipments, params.shipmentsInspected),
+      not_delivered_rate: safeRate(params.notDeliveredShipments, params.shipmentsInspected)
+    },
+    costs_by_currency: costsByCurrency,
+    logistics_mix: {
+      logistic_type_breakdown: topBreakdownFromMap(
+        params.logisticTypeCounts,
+        Math.max(1, params.shipmentsInspected)
+      ),
+      mode_breakdown: topBreakdownFromMap(params.modeCounts, Math.max(1, params.shipmentsInspected)),
+      top_logistic_type_by_shipments: topSingleValue(params.logisticTypeCounts),
+      top_mode_by_shipments: topSingleValue(params.modeCounts)
+    },
+    daily_trend: dailyTrend,
+    coverage: {
+      fetch_mode: params.metadata.fetch_mode,
+      universe_fully_fetched: params.metadata.universe_fully_fetched,
+      orders_returned: params.metadata.returned,
+      shipments_requested: params.shipmentsRequested,
+      shipments_inspected: params.shipmentsInspected,
+      pages_requested: params.metadata.pages_requested,
+      pages_succeeded: params.metadata.pages_succeeded,
+      pages_failed: params.metadata.pages_failed,
+      failed_pages_count: params.failedPages.length,
+      shipment_failures_count: params.shipmentFailures.length,
+      failed_pages: params.failedPages
+    }
+  };
+}
 const meliGetShippingSummarySchema = z.object({
   profileId: mercadolibreProfileIdSchemaField,
   startDate: z.string().regex(mercadoLibreDateRegex).describe("Start date in YYYY-MM-DD format."),
   endDate: z.string().regex(mercadoLibreDateRegex).describe("End date in YYYY-MM-DD format."),
   status: z.string().trim().min(1).optional().describe("Optional order status filter."),
-  limit: z.number().int().min(1).max(30).optional().describe("Orders page size to inspect for shipping data."),
-  offset: z.number().int().min(0).max(5e3).optional().describe("Orders offset to inspect.")
+  responseMode: z.enum(["calculations", "shipments_chunk"]).optional().default("calculations").describe(
+    "Response mode. calculations (default) fetches all matching orders internally and returns only aggregate shipping KPIs. shipments_chunk returns compact shipment rows for up to 15 MercadoLibre pages and includes continuation metadata."
+  ),
+  limit: z.number().int().min(1).max(50).optional().describe(
+    'MercadoLibre page size for responseMode="shipments_chunk" (1-50). Defaults to 50.'
+  ),
+  offset: z.number().int().min(0).max(5e3).optional().describe(
+    'Starting offset for responseMode="shipments_chunk". Use metadata.next_offset to continue.'
+  )
 });
 async function meliGetShippingSummaryHandler(params) {
   try {
@@ -33,75 +246,255 @@ async function meliGetShippingSummaryHandler(params) {
       return profileResolution.response;
     }
     const profileId = profileResolution.value.profileId;
-    const ordersResponse = await searchMercadoLibreOrders(profileId, {
+    const responseMode = params.responseMode ?? "calculations";
+    const requestedLimit = responseMode === "shipments_chunk" ? params.limit ?? DEFAULT_SHIPPING_DETAIL_PAGE_LIMIT : DEFAULT_CALCULATIONS_PAGE_LIMIT;
+    const requestedOffset = responseMode === "shipments_chunk" ? params.offset ?? 0 : 0;
+    const maxPagesForResponse = responseMode === "shipments_chunk" ? SHIPPING_DETAIL_MAX_PAGES_PER_CALL : Infinity;
+    const response = await searchMercadoLibreOrders(profileId, {
       seller: "",
       from: params.startDate,
       to: params.endDate,
       status: params.status,
-      limit: params.limit ?? 20,
-      offset: params.offset ?? 0
+      limit: requestedLimit,
+      offset: requestedOffset
     });
-    const statusCounts = {};
-    const substatusCounts = {};
+    const paging = normalizeMercadoLibrePaging(asRecord(response.paging));
+    const baseOrders = asArray(response.results);
+    const effectiveLimit = paging.limit || requestedLimit || baseOrders.length;
+    const effectiveOffset = paging.offset || requestedOffset || 0;
+    const allOrders = [...baseOrders];
+    const failedPages = [];
+    let pagesRequested = 1;
+    let pagesSucceeded = 1;
+    if (effectiveLimit > 0 && paging.total > baseOrders.length) {
+      const nextOffsets = [];
+      const maxPagesRemaining = Math.max(0, maxPagesForResponse - 1);
+      let pagesAdded = 0;
+      for (let nextOffset = effectiveOffset + effectiveLimit; nextOffset < paging.total; nextOffset += effectiveLimit) {
+        if (responseMode === "shipments_chunk" && pagesAdded >= maxPagesRemaining) {
+          break;
+        }
+        nextOffsets.push(nextOffset);
+        pagesAdded += 1;
+      }
+      pagesRequested += nextOffsets.length;
+      if (nextOffsets.length > 0) {
+        const batch = await searchMercadoLibreOrdersBatch(
+          profileId,
+          {
+            seller: "",
+            from: params.startDate,
+            to: params.endDate,
+            status: params.status,
+            limit: effectiveLimit
+          },
+          nextOffsets,
+          {
+            maxConcurrency: PAGE_FETCH_CONCURRENCY,
+            maxRetries: PAGE_FETCH_MAX_RETRIES
+          }
+        );
+        pagesSucceeded += batch.successful.length;
+        batch.successful.forEach((entry) => {
+          allOrders.push(...asArray(entry.document.results));
+        });
+        batch.failed.forEach((failure) => {
+          const failedOffset = Number(failure.id);
+          failedPages.push({
+            offset: failedOffset,
+            limit: effectiveLimit,
+            page_number: Math.floor(failedOffset / effectiveLimit) + 1,
+            message: failure.message,
+            status_code: failure.statusCode,
+            attempts: failure.attempts,
+            retryable: failure.retryable
+          });
+        });
+      }
+    }
+    const ordersWithShipping = allOrders.reduce((count, order) => {
+      return normalizeScalarString(asRecord(order.shipping).id) ? count + 1 : count;
+    }, 0);
+    const orderByShipmentId = /* @__PURE__ */ new Map();
+    for (const order of allOrders) {
+      const shipmentId = normalizeScalarString(asRecord(order.shipping).id);
+      if (shipmentId && !orderByShipmentId.has(shipmentId)) {
+        orderByShipmentId.set(shipmentId, order);
+      }
+    }
+    const shipmentIds = [...orderByShipmentId.keys()];
+    const statusCounts = /* @__PURE__ */ new Map();
+    const substatusCounts = /* @__PURE__ */ new Map();
+    const logisticTypeCounts = /* @__PURE__ */ new Map();
+    const modeCounts = /* @__PURE__ */ new Map();
     const costsByCurrency = {};
-    const partialFailures = [];
+    const dailyMetrics = /* @__PURE__ */ new Map();
+    const failures = [];
     const shipmentRows = [];
-    for (const order of asArray(ordersResponse.results)) {
-      const shipping = asRecord(order.shipping);
-      const shipmentId = normalizeString(shipping.id);
-      if (!shipmentId) {
-        continue;
-      }
-      try {
-        const [shipment, costs] = await Promise.all([
-          getMercadoLibreShipment(profileId, shipmentId),
-          getMercadoLibreShipmentCosts(profileId, shipmentId)
-        ]);
+    let shipmentsInspected = 0;
+    let deliveredShipments = 0;
+    let cancelledShipments = 0;
+    let notDeliveredShipments = 0;
+    if (shipmentIds.length > 0) {
+      const [shipmentsBatch, costsBatch] = await Promise.all([
+        getMercadoLibreShipmentBatch(profileId, shipmentIds, {
+          maxConcurrency: PAGE_FETCH_CONCURRENCY,
+          maxRetries: PAGE_FETCH_MAX_RETRIES
+        }),
+        getMercadoLibreShipmentCostsBatch(profileId, shipmentIds, {
+          maxConcurrency: PAGE_FETCH_CONCURRENCY,
+          maxRetries: PAGE_FETCH_MAX_RETRIES
+        })
+      ]);
+      const shipmentById = new Map(
+        shipmentsBatch.successful.map((entry) => [entry.id, entry.document])
+      );
+      const costsByShipmentId = new Map(
+        costsBatch.successful.map((entry) => [entry.id, entry.document])
+      );
+      shipmentsBatch.failed.forEach((failure) => {
+        failures.push({
+          order_id: normalizeScalarString(orderByShipmentId.get(failure.id)?.id),
+          shipment_id: failure.id,
+          stage: "shipment",
+          message: failure.message,
+          status_code: failure.statusCode,
+          attempts: failure.attempts,
+          retryable: failure.retryable
+        });
+      });
+      costsBatch.failed.forEach((failure) => {
+        failures.push({
+          order_id: normalizeScalarString(orderByShipmentId.get(failure.id)?.id),
+          shipment_id: failure.id,
+          stage: "costs",
+          message: failure.message,
+          status_code: failure.statusCode,
+          attempts: failure.attempts,
+          retryable: failure.retryable
+        });
+      });
+      for (const shipmentId of shipmentIds) {
+        const shipment = shipmentById.get(shipmentId);
+        const costs = costsByShipmentId.get(shipmentId);
+        if (!shipment || !costs) {
+          continue;
+        }
+        const order = orderByShipmentId.get(shipmentId);
         const shipmentStatus = normalizeString(shipment.status, "unknown");
         const shipmentSubstatus = normalizeString(shipment.substatus, "unknown");
-        statusCounts[shipmentStatus] = (statusCounts[shipmentStatus] ?? 0) + 1;
-        substatusCounts[shipmentSubstatus] = (substatusCounts[shipmentSubstatus] ?? 0) + 1;
-        const currencyId = normalizeString(order.currency_id, "UNKNOWN");
-        const bucket = currencyBucket(costsByCurrency, currencyId, () => ({ shipments: 0, total_cost: 0 }));
+        const logisticType = normalizeString(shipment.logistic_type);
+        const mode = normalizeString(shipment.mode);
+        const currencyId = normalizeString(order?.currency_id, "UNKNOWN");
+        const shipmentCost = roundMoney(extractShipmentCost(costs));
+        const dayBucket = getLocalDateBucket(normalizeString(order?.date_created), BUSINESS_TIME_ZONE);
+        shipmentsInspected += 1;
+        incrementCount(statusCounts, shipmentStatus);
+        incrementCount(substatusCounts, shipmentSubstatus);
+        incrementCount(logisticTypeCounts, logisticType || "unknown");
+        incrementCount(modeCounts, mode || "unknown");
+        if (shipmentStatus === "delivered") {
+          deliveredShipments += 1;
+        }
+        if (shipmentStatus === "cancelled") {
+          cancelledShipments += 1;
+        }
+        if (shipmentStatus === "not_delivered") {
+          notDeliveredShipments += 1;
+        }
+        const bucket = currencyBucket(costsByCurrency, currencyId, () => ({
+          shipments: 0,
+          shipments_with_cost: 0,
+          zero_cost_shipments: 0,
+          total_cost: 0
+        }));
         bucket.shipments += 1;
-        bucket.total_cost += toNumber(asRecord(costs.senders).cost) || toNumber(asRecord(costs.receiver).cost) || toNumber(costs.gross_amount) || toNumber(costs.cost);
-        shipmentRows.push(
-          stripNulls({
-            order_id: normalizeString(order.id),
-            shipment_id: shipmentId,
-            status: shipmentStatus,
-            substatus: shipmentSubstatus,
-            logistic_type: normalizeString(shipment.logistic_type),
-            mode: normalizeString(shipment.mode),
-            currency_id: currencyId,
-            cost: roundMoney(bucket.total_cost)
-          })
-        );
-      } catch (shipmentError) {
-        partialFailures.push({
-          order_id: normalizeString(order.id),
-          shipment_id: shipmentId,
-          message: formatMercadoLibreError(shipmentError, `Failed to inspect shipment ${shipmentId}`)
-        });
+        bucket.total_cost += shipmentCost;
+        if (shipmentCost > 0) {
+          bucket.shipments_with_cost += 1;
+        } else {
+          bucket.zero_cost_shipments += 1;
+        }
+        if (dayBucket) {
+          const dayMetric = dailyMetrics.get(dayBucket) ?? {
+            date: dayBucket,
+            shipments: 0,
+            delivered_shipments: 0,
+            cancelled_shipments: 0,
+            not_delivered_shipments: 0,
+            shipping_cost_by_currency: {}
+          };
+          dayMetric.shipments += 1;
+          if (shipmentStatus === "delivered") {
+            dayMetric.delivered_shipments += 1;
+          }
+          if (shipmentStatus === "cancelled") {
+            dayMetric.cancelled_shipments += 1;
+          }
+          if (shipmentStatus === "not_delivered") {
+            dayMetric.not_delivered_shipments += 1;
+          }
+          incrementCurrency(dayMetric.shipping_cost_by_currency, currencyId, shipmentCost);
+          dailyMetrics.set(dayBucket, dayMetric);
+        }
+        if (responseMode === "shipments_chunk") {
+          shipmentRows.push(
+            formatCompactShipmentRow({
+              orderId: normalizeScalarString(order?.id),
+              shipmentId,
+              status: shipmentStatus,
+              substatus: shipmentSubstatus,
+              logisticType,
+              mode,
+              currencyId,
+              cost: shipmentCost
+            })
+          );
+        }
       }
     }
     for (const metrics of Object.values(costsByCurrency)) {
       metrics.total_cost = roundMoney(metrics.total_cost);
     }
+    const metadata = buildShippingSummaryMetadata({
+      total: paging.total,
+      effectiveLimit,
+      effectiveOffset,
+      returned: allOrders.length,
+      responseMode,
+      pagesRequested,
+      pagesSucceeded,
+      pagesFailed: failedPages.length,
+      failedOffsets: failedPages.map((failure) => failure.offset),
+      shipmentFailures: failures.length
+    });
+    const calculations = responseMode === "calculations" ? buildShippingCalculations({
+      ordersTotal: allOrders.length,
+      ordersWithShipping,
+      shipmentsRequested: shipmentIds.length,
+      shipmentsInspected,
+      deliveredShipments,
+      cancelledShipments,
+      notDeliveredShipments,
+      statusCounts,
+      substatusCounts,
+      logisticTypeCounts,
+      modeCounts,
+      costsByCurrency,
+      dailyMetrics,
+      metadata,
+      failedPages,
+      shipmentFailures: failures
+    }) : void 0;
     return object(
       stripNulls({
         profile_id: profileId,
-        metadata: {
-          orders_inspected: asArray(ordersResponse.results).length,
-          shipments_inspected: shipmentRows.length,
-          partial_failures: partialFailures.length,
-          has_partial_failures: partialFailures.length > 0
-        },
-        status_counts: statusCounts,
-        substatus_counts: substatusCounts,
-        costs_by_currency: costsByCurrency,
-        shipments: shipmentRows,
-        failures: partialFailures
+        metadata,
+        shipments_schema: responseMode === "shipments_chunk" ? shipmentsSchema : void 0,
+        shipments: responseMode === "shipments_chunk" ? shipmentRows : void 0,
+        calculations,
+        failures: failures.length > 0 ? failures : void 0,
+        failed_pages: failedPages.length > 0 ? failedPages : void 0
       })
     );
   } catch (err) {