@yoryoboy/bi-mcp 1.19.0 → 1.20.0

package/dist/mcp-use.json

@@ -1,7 +1,10 @@
 {
   "includeInspector": false,
-  "buildTime": "2026-07-31T15:02:12.296Z",
-  "buildId": "8b32be6eea3e9dc2",
+  "buildTime": "2026-08-03T01:50:34.212Z",
+  "buildId": "01bbc68597ae128e",
   "entryPoint": "dist/index.js",
-  "widgets": {}
+  "widgets": {},
+  "tunnel": {
+    "subdomain": "historic-amethyst"
+  }
 }

package/dist/scripts/profile-mercadolibre-billing.js

@@ -0,0 +1,634 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import process from "node:process";
+import {
+  formatMercadoLibreError,
+  getMercadoLibreApiContext,
+  isRetryableMercadoLibreError,
+  MercadoLibreApiError
+} from "../src/services/mercadolibre/mercadolibre-api.js";
+import {
+  buildMercadoLibreBillingPeriodDetailsPath,
+  buildMercadoLibreBillingOrderDetailsPath,
+  clampMercadoLibreBillingOrderIdsBatchSize,
+  MERCADO_LIBRE_BILLING_ORDER_IDS_MAX_PER_REQUEST,
+  scopeToGroupPath
+} from "../src/services/mercadolibre/mercadolibre-billing.js";
+import { loadLocalEnv, parseCliArgs } from "./_helpers.js";
+const HELP = `Mercado Libre billing profiler
+
+Usage:
+  pnpm exec tsx scripts/profile-mercadolibre-billing.ts --profile-id <id> --period-key <key> [options]
+
+Required:
+  --profile-id, MELI_PROFILE_ID, MERCADOLIBRE_PROFILE_ID
+  --period-key, MELI_PERIOD_KEY
+
+Optional:
+  --document-type BILL|CREDIT_NOTE      Default: BILL
+  --mode period|order-ids|both          Default: both
+  --scope ml|mp|flex|full               Default: full
+  --limit <n>                           Default: 1000
+  --max-pages <n>                       Default: 10
+  --batch-size <n>                      Default: 60 (capped at 60 per request)
+  --delay-ms <n>                        Default: 150
+  --max-retries <n>                     Default: 0
+  --order-ids <id,id,...>               Required when mode includes order-ids
+  --output <path>                       Default: /tmp/opencode/mercadolibre-billing-profile-<timestamp>.json
+  --help
+
+Examples:
+  pnpm exec tsx scripts/profile-mercadolibre-billing.ts     --profile-id profile_123     --period-key 2025-01     --mode both     --order-ids 123,456,789
+`;
+function printHelp() {
+  console.log(HELP);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function toPositiveInteger(value, fallback, name) {
+  if (!value || !value.trim()) {
+    return fallback;
+  }
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed < 0) {
+    throw new Error(`Invalid ${name}: expected a non-negative integer, got ${value}`);
+  }
+  return parsed;
+}
+function normalizeMode(value) {
+  const candidate = value?.trim().toLowerCase();
+  if (candidate === "period" || candidate === "order-ids" || candidate === "both") {
+    return candidate;
+  }
+  if (!candidate) {
+    return "both";
+  }
+  throw new Error(`Invalid mode: ${value}`);
+}
+function normalizeScope(value) {
+  const candidate = value?.trim().toLowerCase();
+  if (candidate === "ml" || candidate === "mp" || candidate === "flex" || candidate === "full") {
+    return candidate;
+  }
+  if (!candidate) {
+    return "full";
+  }
+  throw new Error(`Invalid scope: ${value}`);
+}
+function normalizeDocumentType(value) {
+  const candidate = value?.trim().toUpperCase();
+  if (candidate === "BILL" || candidate === "CREDIT_NOTE") {
+    return candidate;
+  }
+  if (!candidate) {
+    return "BILL";
+  }
+  throw new Error(`Invalid document type: ${value}`);
+}
+function parseOrderIds(raw) {
+  if (!raw) {
+    return [];
+  }
+  return raw.split(/[\s,]+/g).map((value) => value.trim()).filter(Boolean);
+}
+function readConfigValue(args, name, ...envNames) {
+  const cliValue = args.values[name]?.trim();
+  if (cliValue) {
+    return cliValue;
+  }
+  for (const envName of envNames) {
+    const envValue = process.env[envName]?.trim();
+    if (envValue) {
+      return envValue;
+    }
+  }
+  return void 0;
+}
+function parseConfig() {
+  const args = parseCliArgs(process.argv.slice(2));
+  if (args.flags.has("help") || args.flags.has("h")) {
+    printHelp();
+    process.exit(0);
+  }
+  const profileId = readConfigValue(args, "profile-id", "MELI_PROFILE_ID", "MERCADOLIBRE_PROFILE_ID");
+  const periodKey = readConfigValue(args, "period-key", "MELI_PERIOD_KEY");
+  const documentType = normalizeDocumentType(readConfigValue(args, "document-type", "MELI_DOCUMENT_TYPE"));
+  const mode = normalizeMode(readConfigValue(args, "mode", "MELI_MODE"));
+  const scope = normalizeScope(readConfigValue(args, "scope", "MELI_SCOPE"));
+  const pageLimit = toPositiveInteger(readConfigValue(args, "limit", "MELI_LIMIT"), 1e3, "limit");
+  const maxPages = toPositiveInteger(readConfigValue(args, "max-pages", "MELI_MAX_PAGES"), 10, "max-pages");
+  const batchSize = toPositiveInteger(readConfigValue(args, "batch-size", "MELI_BATCH_SIZE"), 60, "batch-size");
+  const delayMs = toPositiveInteger(readConfigValue(args, "delay-ms", "MELI_DELAY_MS"), 150, "delay-ms");
+  const maxRetries = toPositiveInteger(readConfigValue(args, "max-retries", "MELI_MAX_RETRIES"), 0, "max-retries");
+  const orderIds = parseOrderIds(readConfigValue(args, "order-ids", "MELI_ORDER_IDS"));
+  const outputPath = readConfigValue(args, "output", "MELI_OUTPUT_PATH") ?? `/tmp/opencode/mercadolibre-billing-profile-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}.json`;
+  if (!profileId) {
+    throw new Error("Missing required profile id. Pass --profile-id or set MELI_PROFILE_ID.");
+  }
+  if (!periodKey) {
+    throw new Error("Missing required period key. Pass --period-key or set MELI_PERIOD_KEY.");
+  }
+  if ((mode === "order-ids" || mode === "both") && orderIds.length === 0) {
+    throw new Error("Order IDs are required when mode includes order-ids. Pass --order-ids or MELI_ORDER_IDS.");
+  }
+  return {
+    profileId,
+    periodKey,
+    documentType,
+    mode,
+    scope,
+    pageLimit,
+    maxPages,
+    batchSize,
+    delayMs,
+    maxRetries,
+    orderIds,
+    outputPath
+  };
+}
+function createStrategyStats() {
+  return {
+    requestsAttempted: 0,
+    requestsSucceeded: 0,
+    requestsFailed: 0,
+    transportAttempts: 0,
+    rateLimit429Count: 0,
+    rowsRecovered: 0,
+    rawRowsRecovered: 0,
+    elapsedMs: 0,
+    totalLatencyMs: 0,
+    rowKeys: /* @__PURE__ */ new Set(),
+    lastIdsSeen: [],
+    requestLogs: [],
+    coverageComplete: null,
+    stopReason: null
+  };
+}
+function getHeaderValue(headers, name) {
+  if (!headers) {
+    return null;
+  }
+  const raw = headers[name.toLowerCase()] ?? headers[name] ?? headers[name.toUpperCase()];
+  if (Array.isArray(raw)) {
+    return raw.length > 0 ? String(raw[0]) : null;
+  }
+  return raw == null ? null : String(raw);
+}
+function parseRetryAfterHeaderMs(value) {
+  if (!value) {
+    return null;
+  }
+  const seconds = Number(value);
+  if (Number.isFinite(seconds) && seconds > 0) {
+    return seconds * 1e3;
+  }
+  const dateMs = new Date(value).getTime();
+  if (Number.isFinite(dateMs)) {
+    return Math.max(0, dateMs - Date.now());
+  }
+  return null;
+}
+function asRecord(value) {
+  return value != null && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function normalizeCursor(value) {
+  if (value == null || value === 0 || value === "0") {
+    return null;
+  }
+  const normalized = String(value).trim();
+  return normalized ? normalized : null;
+}
+function getRowKey(strategy, row) {
+  if (strategy === "period") {
+    const chargeInfo = asRecord(row.charge_info);
+    const detailId2 = String(chargeInfo.detail_id ?? row.detail_id ?? "").trim();
+    if (detailId2) {
+      return `detail:${detailId2}`;
+    }
+  }
+  const orderId = String(row.order_id ?? "").trim();
+  if (orderId) {
+    return `order:${orderId}`;
+  }
+  const detailId = String(row.detail_id ?? "").trim();
+  if (detailId) {
+    return `detail:${detailId}`;
+  }
+  return null;
+}
+function summarizeError(error) {
+  if (error instanceof MercadoLibreApiError) {
+    return {
+      name: error.name,
+      message: error.message,
+      status: error.status ?? null,
+      code: error.code ?? null,
+      retryAfterMs: error.retryAfterMs ?? null,
+      retryable: isRetryableMercadoLibreError(error)
+    };
+  }
+  if (error instanceof Error) {
+    return {
+      name: error.name,
+      message: formatMercadoLibreError(error),
+      status: null,
+      code: null,
+      retryAfterMs: null,
+      retryable: null
+    };
+  }
+  return {
+    name: "UnknownError",
+    message: formatMercadoLibreError(error),
+    status: null,
+    code: null,
+    retryAfterMs: null,
+    retryable: null
+  };
+}
+function logRequest(summary) {
+  console.log(JSON.stringify(summary));
+}
+async function profiledGet(api, config) {
+  const startedAt = nowIso();
+  const startedMs = Date.now();
+  try {
+    const response = await api.get(config.endpoint, { params: config.params });
+    const endedAt = nowIso();
+    const durationMs = Date.now() - startedMs;
+    const data = response.data;
+    const responseRecord = asRecord(data);
+    const results = Array.isArray(responseRecord.results) ? responseRecord.results : [];
+    const lastId = normalizeCursor(responseRecord.last_id);
+    const total = Number.isFinite(Number(responseRecord.total)) ? Number(responseRecord.total) : null;
+    const retryAfterHeader = getHeaderValue(response.headers, "retry-after");
+    const log = {
+      startedAt,
+      endedAt,
+      durationMs,
+      strategy: config.strategy,
+      step: config.step,
+      attempt: config.attempt,
+      endpoint: config.endpoint,
+      scope: config.scope,
+      groupPath: config.groupPath,
+      params: config.params,
+      status: response.status,
+      resultCount: results.length,
+      total,
+      lastId,
+      responseShape: Object.keys(responseRecord).sort(),
+      retryAfterMs: parseRetryAfterHeaderMs(retryAfterHeader),
+      retryAfterHeader
+    };
+    logRequest(log);
+    return { ok: true, data, log };
+  } catch (error) {
+    const endedAt = nowIso();
+    const durationMs = Date.now() - startedMs;
+    const summary = summarizeError(error);
+    const log = {
+      startedAt,
+      endedAt,
+      durationMs,
+      strategy: config.strategy,
+      step: config.step,
+      attempt: config.attempt,
+      endpoint: config.endpoint,
+      scope: config.scope,
+      groupPath: config.groupPath,
+      params: config.params,
+      status: summary.status,
+      resultCount: null,
+      total: null,
+      lastId: null,
+      responseShape: [],
+      retryAfterMs: summary.retryAfterMs,
+      retryAfterHeader: null,
+      error: summary
+    };
+    logRequest(log);
+    return { ok: false, log };
+  }
+}
+async function waitBetweenRequests(delayMs) {
+  if (delayMs > 0) {
+    await sleep(delayMs);
+  }
+}
+async function requestWithRetries(api, config, maxRetries, delayMs) {
+  const logs = [];
+  for (let attempt = 1; attempt <= maxRetries + 1; attempt += 1) {
+    const result = await profiledGet(api, { ...config, attempt });
+    logs.push(result.log);
+    if (result.ok) {
+      return { ok: true, data: result.data, logs };
+    }
+    const error = result.log.error;
+    const retryable = error?.retryable ?? false;
+    const isLastAttempt = attempt >= maxRetries + 1;
+    if (isLastAttempt || !retryable) {
+      return { ok: false, logs };
+    }
+    const backoffMs = Math.max(delayMs, error?.retryAfterMs ?? 0, 200 * attempt);
+    await sleep(backoffMs);
+  }
+  return { ok: false, logs };
+}
+function summarizeResponseRows(strategy, rows, stats) {
+  stats.rawRowsRecovered += rows.length;
+  for (const row of rows) {
+    const key = getRowKey(strategy, row);
+    if (!key) {
+      continue;
+    }
+    stats.rowKeys.add(key);
+  }
+  stats.rowsRecovered = stats.rowKeys.size;
+}
+function buildStrategyReport(stats) {
+  return {
+    requestsAttempted: stats.requestsAttempted,
+    requestsSucceeded: stats.requestsSucceeded,
+    requestsFailed: stats.requestsFailed,
+    transportAttempts: stats.transportAttempts,
+    rateLimit429Count: stats.rateLimit429Count,
+    rowsRecovered: stats.rowsRecovered,
+    rawRowsRecovered: stats.rawRowsRecovered,
+    elapsedMs: stats.elapsedMs,
+    totalLatencyMs: stats.totalLatencyMs,
+    averageLatencyMs: stats.requestsSucceeded > 0 ? Math.round(stats.totalLatencyMs / stats.requestsSucceeded) : 0,
+    coverageComplete: stats.coverageComplete,
+    stopReason: stats.stopReason,
+    lastIdsSeen: stats.lastIdsSeen,
+    requestLogs: stats.requestLogs
+  };
+}
+function recommendStrategy(period, orderIds) {
+  if (!period && !orderIds) {
+    return "No strategy executed.";
+  }
+  if (period && !orderIds) {
+    return period.rateLimit429Count > 0 ? "Period cursor worked, but 429s appeared. Reduce page size or add delay before scaling up." : "Period cursor is the only observed strategy. Use it as the baseline and keep batch size conservative.";
+  }
+  if (!period && orderIds) {
+    return orderIds.rateLimit429Count > 0 ? "Order-ID batches worked, but 429s appeared. Lower the batch size and add more delay." : "Order-ID batches are the only observed strategy. Use them when the report generator already has the target order set.";
+  }
+  if (!period || !orderIds) {
+    return "No recommendation available.";
+  }
+  if (period.rateLimit429Count !== orderIds.rateLimit429Count) {
+    return period.rateLimit429Count < orderIds.rateLimit429Count ? "Prefer period pagination: it produced fewer 429s under the current pacing." : "Prefer order-id batching: it produced fewer 429s under the current pacing.";
+  }
+  const periodThroughput = period.elapsedMs > 0 ? period.rowsRecovered / (period.elapsedMs / 1e3) : 0;
+  const orderThroughput = orderIds.elapsedMs > 0 ? orderIds.rowsRecovered / (orderIds.elapsedMs / 1e3) : 0;
+  if (Math.abs(periodThroughput - orderThroughput) > 0.01) {
+    return periodThroughput > orderThroughput ? "Prefer period pagination: it recovered rows faster with the current pacing." : "Prefer order-id batching: it recovered rows faster with the current pacing.";
+  }
+  if (Boolean(period.coverageComplete) !== Boolean(orderIds.coverageComplete)) {
+    return period.coverageComplete ? "Prefer period pagination: it completed coverage while order-id batching did not." : "Prefer order-id batching: it completed coverage while period pagination did not.";
+  }
+  return "Both strategies behaved similarly. Use period pagination for bulk coverage and order-id batching for targeted subsets.";
+}
+async function profilePeriodStrategy(api, config, startedAtMs) {
+  const stats = createStrategyStats();
+  let fromId = null;
+  let page = 0;
+  let coverageComplete = true;
+  while (page < config.maxPages) {
+    page += 1;
+    stats.requestsAttempted += 1;
+    const groupPath = scopeToGroupPath(config.scope);
+    const endpoint = buildMercadoLibreBillingPeriodDetailsPath(config.periodKey, config.scope);
+    const params = {
+      document_type: config.documentType,
+      limit: config.pageLimit
+    };
+    if (fromId) {
+      params.from_id = fromId;
+    }
+    const result = await requestWithRetries(
+      api,
+      {
+        strategy: "period",
+        step: `page-${page}`,
+        endpoint,
+        scope: config.scope,
+        groupPath,
+        params
+      },
+      config.maxRetries,
+      config.delayMs
+    );
+    stats.requestLogs.push(...result.logs);
+    stats.transportAttempts += result.logs.length;
+    stats.rateLimit429Count += result.logs.filter((log) => log.status === 429).length;
+    if (!result.ok) {
+      stats.requestsFailed += 1;
+      stats.stopReason = `Stopped on page ${page} after a failed request`;
+      coverageComplete = false;
+      break;
+    }
+    stats.requestsSucceeded += 1;
+    const lastLog = result.logs[result.logs.length - 1];
+    stats.totalLatencyMs += lastLog?.durationMs ?? 0;
+    const responseRecord = asRecord(result.data);
+    const rows = Array.isArray(responseRecord.results) ? responseRecord.results.filter((entry) => entry != null && typeof entry === "object" && !Array.isArray(entry)) : [];
+    summarizeResponseRows("period", rows, stats);
+    const nextLastId = normalizeCursor(responseRecord.last_id);
+    if (nextLastId) {
+      stats.lastIdsSeen.push(nextLastId);
+    }
+    if (!nextLastId) {
+      stats.stopReason = "Reached terminal last_id";
+      break;
+    }
+    if (nextLastId === fromId) {
+      stats.stopReason = "Cursor stopped advancing";
+      coverageComplete = false;
+      break;
+    }
+    if (rows.length === 0) {
+      stats.stopReason = "Empty page returned before terminal cursor";
+      coverageComplete = false;
+      break;
+    }
+    fromId = nextLastId;
+    await waitBetweenRequests(config.delayMs);
+  }
+  if (page >= config.maxPages && stats.stopReason == null) {
+    coverageComplete = false;
+    stats.stopReason = `Reached max-pages=${config.maxPages}`;
+  }
+  stats.coverageComplete = coverageComplete;
+  stats.elapsedMs = Date.now() - startedAtMs;
+  return buildStrategyReport(stats);
+}
+function chunkArray(values, size) {
+  const chunks = [];
+  if (size <= 0) {
+    return chunks;
+  }
+  for (let index = 0; index < values.length; index += size) {
+    chunks.push(values.slice(index, index + size));
+  }
+  return chunks;
+}
+async function profileOrderIdsStrategy(api, config, startedAtMs) {
+  const stats = createStrategyStats();
+  const effectiveBatchSize = clampMercadoLibreBillingOrderIdsBatchSize(config.batchSize);
+  const chunks = chunkArray(config.orderIds, effectiveBatchSize);
+  const limitedChunks = chunks.slice(0, config.maxPages);
+  if (effectiveBatchSize !== config.batchSize) {
+    console.log(
+      JSON.stringify({
+        event: "order_ids_batch_size_capped",
+        requested: config.batchSize,
+        effective: effectiveBatchSize,
+        cap: MERCADO_LIBRE_BILLING_ORDER_IDS_MAX_PER_REQUEST
+      })
+    );
+  }
+  for (let index = 0; index < limitedChunks.length; index += 1) {
+    const chunk = limitedChunks[index];
+    stats.requestsAttempted += 1;
+    const groupPath = "ML";
+    const endpoint = buildMercadoLibreBillingOrderDetailsPath();
+    const params = {
+      document_type: config.documentType,
+      order_ids: chunk.join(",")
+    };
+    const result = await requestWithRetries(
+      api,
+      {
+        strategy: "order-ids",
+        step: `batch-${index + 1}`,
+        endpoint,
+        scope: "ml",
+        groupPath,
+        params
+      },
+      config.maxRetries,
+      config.delayMs
+    );
+    stats.requestLogs.push(...result.logs);
+    stats.transportAttempts += result.logs.length;
+    stats.rateLimit429Count += result.logs.filter((log) => log.status === 429).length;
+    if (!result.ok) {
+      stats.requestsFailed += 1;
+      stats.stopReason = `Stopped on order batch ${index + 1} after a failed request`;
+      stats.coverageComplete = false;
+      break;
+    }
+    stats.requestsSucceeded += 1;
+    const lastLog = result.logs[result.logs.length - 1];
+    stats.totalLatencyMs += lastLog?.durationMs ?? 0;
+    const responseRecord = asRecord(result.data);
+    const rows = Array.isArray(responseRecord.results) ? responseRecord.results.filter((entry) => entry != null && typeof entry === "object" && !Array.isArray(entry)) : [];
+    summarizeResponseRows("order-ids", rows, stats);
+    const nextLastId = normalizeCursor(responseRecord.last_id);
+    if (nextLastId) {
+      stats.lastIdsSeen.push(nextLastId);
+    }
+    await waitBetweenRequests(config.delayMs);
+  }
+  if (limitedChunks.length < chunks.length && stats.stopReason == null) {
+    stats.stopReason = `Reached max-pages=${config.maxPages} before exhausting all order-id batches`;
+    stats.coverageComplete = false;
+  } else if (stats.coverageComplete == null) {
+    stats.coverageComplete = stats.requestsFailed === 0;
+  }
+  stats.elapsedMs = Date.now() - startedAtMs;
+  return buildStrategyReport(stats);
+}
+async function main() {
+  loadLocalEnv();
+  const config = parseConfig();
+  const startedAt = nowIso();
+  const startedAtMs = Date.now();
+  const { api } = await getMercadoLibreApiContext(config.profileId);
+  const requestLogs = [];
+  let periodReport;
+  let orderIdsReport;
+  console.log(
+    JSON.stringify({
+      event: "run_start",
+      startedAt,
+      config: {
+        profileId: config.profileId,
+        periodKey: config.periodKey,
+        documentType: config.documentType,
+        mode: config.mode,
+        scope: config.scope,
+        pageLimit: config.pageLimit,
+        maxPages: config.maxPages,
+        batchSize: config.batchSize,
+        orderIdsBatchSizeCap: MERCADO_LIBRE_BILLING_ORDER_IDS_MAX_PER_REQUEST,
+        delayMs: config.delayMs,
+        maxRetries: config.maxRetries,
+        orderIdsCount: config.orderIds.length,
+        outputPath: config.outputPath
+      }
+    })
+  );
+  if (config.mode === "period" || config.mode === "both") {
+    periodReport = await profilePeriodStrategy(api, config, startedAtMs);
+    requestLogs.push(...periodReport.requestLogs);
+  }
+  if (config.mode === "order-ids" || config.mode === "both") {
+    orderIdsReport = await profileOrderIdsStrategy(api, config, startedAtMs);
+    requestLogs.push(...orderIdsReport.requestLogs);
+  }
+  const endedAt = nowIso();
+  const durationMs = Date.now() - startedAtMs;
+  const summary = {
+    requestsAttempted: (periodReport?.requestsAttempted ?? 0) + (orderIdsReport?.requestsAttempted ?? 0),
+    requestsSucceeded: (periodReport?.requestsSucceeded ?? 0) + (orderIdsReport?.requestsSucceeded ?? 0),
+    requestsFailed: (periodReport?.requestsFailed ?? 0) + (orderIdsReport?.requestsFailed ?? 0),
+    transportAttempts: (periodReport?.transportAttempts ?? 0) + (orderIdsReport?.transportAttempts ?? 0),
+    rateLimit429Count: (periodReport?.rateLimit429Count ?? 0) + (orderIdsReport?.rateLimit429Count ?? 0),
+    rowsRecovered: (periodReport?.rowsRecovered ?? 0) + (orderIdsReport?.rowsRecovered ?? 0),
+    averageLatencyMs: requestLogs.length > 0 ? Math.round(requestLogs.reduce((sum, log) => sum + log.durationMs, 0) / requestLogs.length) : 0,
+    estimatedThroughputRowsPerSec: durationMs > 0 ? Math.round(((periodReport?.rowsRecovered ?? 0) + (orderIdsReport?.rowsRecovered ?? 0)) / (durationMs / 1e3) * 100) / 100 : 0,
+    recommendationHint: recommendStrategy(periodReport, orderIdsReport)
+  };
+  const artifact = {
+    run: {
+      startedAt,
+      endedAt,
+      durationMs,
+      config
+    },
+    summary,
+    requestLogs
+  };
+  if (periodReport) {
+    artifact.period = {
+      strategy: "period",
+      stats: periodReport
+    };
+  }
+  if (orderIdsReport) {
+    artifact.orderIds = {
+      strategy: "order-ids",
+      stats: orderIdsReport
+    };
+  }
+  await mkdir("/tmp/opencode", { recursive: true });
+  await writeFile(config.outputPath, `${JSON.stringify(artifact, null, 2)}
+`, "utf8");
+  console.log(JSON.stringify({ event: "artifact_written", path: config.outputPath, durationMs }));
+  console.log(JSON.stringify(artifact, null, 2));
+}
+main().catch((error) => {
+  console.error("Mercado Libre billing profiler failed");
+  console.error(formatMercadoLibreError(error, "Mercado Libre billing profiler failed"));
+  if (error instanceof Error && error.stack) {
+    console.error(error.stack);
+  }
+  process.exitCode = 1;
+});
+//# sourceMappingURL=profile-mercadolibre-billing.js.map