vercel 59.1.4 → 59.4.0

package/dist/chunks/{query-ZLJZEGZB.js → query-IVVRYMJN.js}

@@ -6,43 +6,43 @@ const __filename = __fileURLToPath(import.meta.url);
 const __dirname = __dirname_(__filename);
 import {
   OBSERVABILITY_METRICS_PATH,
-  fetchCustomMetricCatalog,
+  fetchCatalogMetricDetailOrExit,
   fetchMetricDetailOrExit,
   getDefaultAggregation
-} from "./chunk-QCVKGY2A.js";
+} from "./chunk-KAYSW4CJ.js";
 import {
   computeGranularity,
   formatText,
   getDefaultCustomMetricAggregation,
   isCanonicalAggregation
-} from "./chunk-JYEO6OJS.js";
+} from "./chunk-MWYQ24FO.js";
 import {
   formatErrorJson,
   formatQueryJson,
   getRollupColumnName,
   handleApiError
-} from "./chunk-NM43FFV6.js";
+} from "./chunk-CV4S27SS.js";
 import "./chunk-5AJPMLDV.js";
 import "./chunk-A3NYPUKZ.js";
 import {
   resolveTimeRange,
   validateAllProjectMutualExclusivity
-} from "./chunk-P65EEFTR.js";
+} from "./chunk-KQRVZWJU.js";
 import "./chunk-VDJN4WKH.js";
 import {
   validateJsonOutput
 } from "./chunk-KXDWXXJH.js";
 import {
   metricsCommand
-} from "./chunk-CSJBZKC5.js";
+} from "./chunk-EG5BSAXD.js";
 import "./chunk-VXYGCOKL.js";
 import {
   getLinkedProject,
   getProjectByNameOrId,
   getScope
-} from "./chunk-VE545BR3.js";
-import "./chunk-ECCWJHC6.js";
-import "./chunk-TJLBCLEX.js";
+} from "./chunk-HMJVUXE6.js";
+import "./chunk-CYNB6LL4.js";
+import "./chunk-TH2XUVDP.js";
 import "./chunk-GGP5R3FU.js";
 import {
   printError
@@ -60,8 +60,15 @@ import "./chunk-52QYYTM5.js";
 import {
   output_manager_default
 } from "./chunk-OX7KI3LF.js";
-import "./chunk-S7KYDPEM.js";
-import "./chunk-TZ2YI2VH.js";
+import {
+  require_source
+} from "./chunk-S7KYDPEM.js";
+import {
+  __toESM
+} from "./chunk-TZ2YI2VH.js";
+
+// src/commands/metrics/query.ts
+var import_chalk = __toESM(require_source(), 1);
 
 // src/commands/metrics/validation.ts
 function validateRequiredMetric(metric) {
@@ -104,7 +111,8 @@ function validateOrderBy(orderBy) {
 }
 
 // src/commands/metrics/query.ts
-function handleValidationError(result, jsonOutput, client) {
+function handleValidationError(result, jsonOutput, client, telemetry) {
+  telemetry.trackCliError(result.code);
   if (jsonOutput) {
     client.stdout.write(
       formatErrorJson(result.code, result.message, result.allowedValues)
@@ -120,12 +128,17 @@ Available values: ${result.allowedValues.join(", ")}
   return 1;
 }
 var PRODUCTION_ENVIRONMENT_FILTER = "environment eq 'production'";
+var PRODUCTION_ENVIRONMENT_KQL_FILTER = "environment:production";
 var CUSTOM_METRIC_VALUE_ALIAS = "value";
 var CUSTOM_METRIC_COUNT_ALIAS = "__seriesCount";
-function combineFilters(filters, prod) {
+var SUM_DEFAULT_METRIC_UNITS = /* @__PURE__ */ new Set(["bytes", "count", "usd", "units"]);
+var FILTER_DEPRECATION_WARNING = "OData support in --filter is deprecated and will be removed soon. KQL will be the only supported filter syntax.";
+function combineFilters(filters, prod, syntax = "odata") {
   const nonEmptyFilters = [
     ...filters?.filter((filter) => filter.length > 0) ?? [],
-    ...prod ? [PRODUCTION_ENVIRONMENT_FILTER] : []
+    ...prod ? [
+      syntax === "kql" ? PRODUCTION_ENVIRONMENT_KQL_FILTER : PRODUCTION_ENVIRONMENT_FILTER
+    ] : []
   ];
   if (nonEmptyFilters.length === 0) {
     return void 0;
@@ -133,7 +146,14 @@ function combineFilters(filters, prod) {
   if (nonEmptyFilters.length === 1) {
     return nonEmptyFilters[0];
   }
-  return nonEmptyFilters.map((filter) => `(${filter})`).join(" and ");
+  const conjunction = syntax === "kql" ? " AND " : " and ";
+  return nonEmptyFilters.map((filter) => `(${filter})`).join(conjunction);
+}
+function usesODataSyntax(filters) {
+  return filters?.some((filter) => {
+    const unquoted = filter.replace(/"(?:\\.|[^"\\])*"|'(?:''|[^'])*'/g, "");
+    return /\s(?:eq|ne|gt|ge|lt|le|in)\s/i.test(unquoted) || /\b(?:contains|startswith|endswith)\s*\(/i.test(unquoted);
+  }) ?? false;
 }
 function getRequestOrderBy(metric, aggregation, orderBy) {
   return orderBy === "value" ? getRollupColumnName(metric, aggregation) : void 0;
@@ -152,18 +172,38 @@ function alignTimeRangeToGranularity(startTime, endTime, granularity) {
     endTime: new Date(Math.ceil(endTime.getTime() / bucketMs) * bucketMs)
   };
 }
-function toCanonicalMetricSelection(metric, aggregation) {
+function getCatalogDefaultAggregation(metric, isPlatformMetric) {
+  if (!isPlatformMetric) {
+    return getDefaultCustomMetricAggregation(metric.unit, metric.aggregations);
+  }
+  const defaultAggregation = SUM_DEFAULT_METRIC_UNITS.has(metric.unit) ? "sum" : "avg";
+  if (metric.aggregations.includes(defaultAggregation)) {
+    return defaultAggregation;
+  }
+  if (defaultAggregation === "sum" && metric.aggregations.includes("count")) {
+    return "count";
+  }
+  return metric.aggregations.includes("sum") ? "sum" : metric.aggregations[0];
+}
+function toCanonicalMetricSelection(metric, aggregation, supportedAggregations) {
+  const [aggregationName, ...dimensionParts] = aggregation.split("/");
+  const dimension = dimensionParts.join("/") || void 0;
+  const countOnlyMetric = supportedAggregations?.includes("count") === true && !supportedAggregations.includes("sum");
+  const additiveAggregation = supportedAggregations?.includes("sum") ? "sum" : countOnlyMetric || supportedAggregations === void 0 && metric.endsWith(".count") ? "count" : "sum";
   if (aggregation === "persecond") {
-    return { metric, aggregation: "sum", per: "second" };
+    return { metric, aggregation: additiveAggregation, per: "second" };
   }
   if (aggregation === "percent") {
-    return { metric, aggregation: "sum", normalize: "percent" };
+    return { metric, aggregation: additiveAggregation, normalize: "percent" };
   }
-  if (aggregation === "unique") {
+  if (aggregationName === "unique") {
+    if (dimension) {
+      return { metric, aggregation: "unique", dimensions: [dimension] };
+    }
     return {
       valid: false,
       code: "UNSUPPORTED_AGGREGATION",
-      message: "The unique aggregation for custom metrics requires an explicit distinct dimension, which vc metrics does not support yet."
+      message: 'The unique aggregation requires a dimension, for example "unique/visitorId".'
     };
   }
   if (isCanonicalAggregation(aggregation)) {
@@ -172,15 +212,33 @@ function toCanonicalMetricSelection(metric, aggregation) {
   return {
     valid: false,
     code: "INVALID_AGGREGATION",
-    message: `Aggregation "${aggregation}" is not supported for custom metrics.`
+    message: `Aggregation "${aggregation}" is not supported by the Observability query API.`
   };
 }
+function getCanonicalOrderBy(orderBy, selection, supportedAggregations) {
+  if (orderBy === "value") {
+    return "value";
+  }
+  const supportsCount = supportedAggregations === void 0 || supportedAggregations.includes("count");
+  if (selection.aggregation === "count" || supportsCount) {
+    return "count";
+  }
+  if (orderBy === "count") {
+    return {
+      valid: false,
+      code: "INVALID_ORDER_BY",
+      message: "--order-by count is not available because this metric does not support the count aggregation. Use --order-by value.",
+      allowedValues: ["value"]
+    };
+  }
+  return "value";
+}
 function createCanonicalMetricsRequest(options) {
   const metrics = {
     [CUSTOM_METRIC_VALUE_ALIAS]: options.selection
   };
   let rankMetric = CUSTOM_METRIC_VALUE_ALIAS;
-  if (options.groupBy.length > 0 && options.orderBy !== "value" && options.selection.aggregation !== "count") {
+  if (options.groupBy.length > 0 && options.orderBy === "count" && options.selection.aggregation !== "count") {
     metrics[CUSTOM_METRIC_COUNT_ALIAS] = {
       metric: options.metric,
       aggregation: "count"
@@ -239,17 +297,17 @@ function canonicalResponseToMetricsResponse(response, rollupColumn, orderBy, ord
     ...orderDirection ? { orderDirection } : {}
   };
 }
-async function resolveQueryScope(client, opts) {
+async function resolveQueryScope(client, telemetry, opts) {
   if (opts.project || opts.all) {
     const { team } = await getScope(client);
     if (!team) {
       const errMsg = "No team context found. Run `vercel switch` to select a team, or use `vercel link` in a project directory.";
-      if (opts.jsonOutput) {
-        client.stdout.write(formatErrorJson("NO_TEAM", errMsg));
-      } else {
-        output_manager_default.error(errMsg);
-      }
-      return 1;
+      return handleValidationError(
+        { valid: false, code: "NO_TEAM", message: errMsg },
+        opts.jsonOutput,
+        client,
+        telemetry
+      );
     }
     if (opts.all) {
       return {
@@ -261,12 +319,12 @@ async function resolveQueryScope(client, opts) {
     const project = await getProjectByNameOrId(client, opts.project, team.id);
     if (project instanceof ProjectNotFound) {
       const errMsg = `Project "${opts.project}" was not found in team "${team.slug}".`;
-      if (opts.jsonOutput) {
-        client.stdout.write(formatErrorJson("PROJECT_NOT_FOUND", errMsg));
-      } else {
-        output_manager_default.error(errMsg);
-      }
-      return 1;
+      return handleValidationError(
+        { valid: false, code: "PROJECT_NOT_FOUND", message: errMsg },
+        opts.jsonOutput,
+        client,
+        telemetry
+      );
     }
     return {
       scope: {
@@ -281,16 +339,17 @@ async function resolveQueryScope(client, opts) {
   }
   const linkedProject = await getLinkedProject(client);
   if (linkedProject.status === "error") {
+    telemetry.trackCliError("LINK_ERROR");
     return linkedProject.exitCode;
   }
   if (linkedProject.status === "not_linked") {
     const errMsg = "No linked project found. Run `vercel link` to link a project, or use --project <name-or-id> or --all.";
-    if (opts.jsonOutput) {
-      client.stdout.write(formatErrorJson("NOT_LINKED", errMsg));
-    } else {
-      output_manager_default.error(errMsg);
-    }
-    return 1;
+    return handleValidationError(
+      { valid: false, code: "NOT_LINKED", message: errMsg },
+      opts.jsonOutput,
+      client,
+      telemetry
+    );
   }
   return {
     scope: {
@@ -309,6 +368,7 @@ async function query(client, telemetry) {
   try {
     parsedArgs = parseArguments(client.argv.slice(2), flagsSpecification);
   } catch (err) {
+    telemetry.trackCliError("INVALID_ARGUMENTS");
     printError(err);
     return 1;
   }
@@ -317,6 +377,7 @@ async function query(client, telemetry) {
   const positionalMetric = positionalArgs[0] === "query" ? positionalArgs[1] : positionalArgs[0];
   const formatResult = validateJsonOutput(flags);
   if (!formatResult.valid) {
+    telemetry.trackCliError("INVALID_OUTPUT_FORMAT");
     output_manager_default.error(formatResult.error);
     return 1;
   }
@@ -329,7 +390,6 @@ async function query(client, telemetry) {
   const orderInput = typeof flags["--order"] === "string" ? flags["--order"].trim().toLowerCase() : void 0;
   const filters = flags["--filter"];
   const prod = flags["--prod"];
-  const filter = combineFilters(filters, prod);
   const since = flags["--since"];
   const until = flags["--until"];
   const granularity = flags["--granularity"];
@@ -353,24 +413,29 @@ async function query(client, telemetry) {
   telemetry.trackCliOptionFormat(flags["--format"]);
   const orderByResult = validateOrderBy(orderByInput);
   if (!orderByResult.valid) {
-    return handleValidationError(orderByResult, jsonOutput, client);
+    return handleValidationError(orderByResult, jsonOutput, client, telemetry);
   }
   const orderByMode = orderByResult.value;
   const requiredMetric = validateRequiredMetric(metricFlag);
   if (!requiredMetric.valid) {
-    return handleValidationError(requiredMetric, jsonOutput, client);
+    return handleValidationError(requiredMetric, jsonOutput, client, telemetry);
   }
   const metric = requiredMetric.value;
   const mutualResult = validateAllProjectMutualExclusivity(all, project);
   if (!mutualResult.valid) {
-    return handleValidationError(mutualResult, jsonOutput, client);
+    return handleValidationError(mutualResult, jsonOutput, client, telemetry);
   }
   const orderDirectionResult = validateOrderDirection(orderInput);
   if (!orderDirectionResult.valid) {
-    return handleValidationError(orderDirectionResult, jsonOutput, client);
+    return handleValidationError(
+      orderDirectionResult,
+      jsonOutput,
+      client,
+      telemetry
+    );
   }
   const orderDirection = orderDirectionResult.value;
-  const scopeResult = await resolveQueryScope(client, {
+  const scopeResult = await resolveQueryScope(client, telemetry, {
     project,
     all,
     jsonOutput
@@ -379,24 +444,85 @@ async function query(client, telemetry) {
     return scopeResult;
   }
   const { scope, accountId, teamName, projectName } = scopeResult;
+  const isPlatformMetric = metric.startsWith("vercel.");
+  const useCanonicalQuery = !isPlatformMetric || Boolean(process.env.FF_METRICS);
+  const filterUsesOData = usesODataSyntax(filters);
+  if (useCanonicalQuery && filterUsesOData) {
+    output_manager_default.print(`${import_chalk.default.yellow("!")} ${FILTER_DEPRECATION_WARNING}
+`);
+  }
+  const filter = combineFilters(
+    filters,
+    prod,
+    useCanonicalQuery && !filterUsesOData ? "kql" : "odata"
+  );
   let startTime;
   let endTime;
   try {
     ({ startTime, endTime } = resolveTimeRange(since, until));
   } catch (err) {
     const errMsg = err instanceof Error ? err.message : String(err);
-    if (jsonOutput) {
-      client.stdout.write(formatErrorJson("INVALID_TIME", errMsg));
-    } else {
-      output_manager_default.error(errMsg);
-    }
-    return 1;
+    return handleValidationError(
+      { valid: false, code: "INVALID_TIME", message: errMsg },
+      jsonOutput,
+      client,
+      telemetry
+    );
   }
-  const isPlatformMetric = metric.startsWith("vercel.");
   let metricUnit;
   let aggregationInput;
-  let customMetricAggregations;
-  if (isPlatformMetric) {
+  let canonicalAggregations;
+  if (useCanonicalQuery) {
+    const catalogOrExitCode = await fetchCatalogMetricDetailOrExit(
+      client,
+      accountId,
+      jsonOutput,
+      metric,
+      isPlatformMetric ? "system" : "custom",
+      startTime.toISOString()
+    );
+    if (typeof catalogOrExitCode === "number") {
+      telemetry.trackCliError("SCHEMA_FETCH_FAILED");
+      return catalogOrExitCode;
+    }
+    const catalogMetric = catalogOrExitCode.find((item) => item.id === metric);
+    if (!catalogMetric) {
+      return handleValidationError(
+        {
+          valid: false,
+          code: "UNKNOWN_METRIC",
+          message: `Unknown metric "${metric}".`,
+          allowedValues: catalogOrExitCode.map((item) => item.id)
+        },
+        jsonOutput,
+        client,
+        telemetry
+      );
+    }
+    metricUnit = catalogMetric.unit;
+    canonicalAggregations = catalogMetric.aggregations;
+    if (aggregationFlag) {
+      aggregationInput = aggregationFlag;
+    } else {
+      const defaultAggregation = getCatalogDefaultAggregation(
+        catalogMetric,
+        isPlatformMetric
+      );
+      if (!defaultAggregation) {
+        return handleValidationError(
+          {
+            valid: false,
+            code: "INVALID_AGGREGATION",
+            message: `Metric "${metric}" does not support any query aggregations.`
+          },
+          jsonOutput,
+          client,
+          telemetry
+        );
+      }
+      aggregationInput = defaultAggregation;
+    }
+  } else {
     const detailOrExitCode = await fetchMetricDetailOrExit(
       client,
       accountId,
@@ -404,31 +530,23 @@ async function query(client, telemetry) {
       jsonOutput
     );
     if (typeof detailOrExitCode === "number") {
+      telemetry.trackCliError("SCHEMA_FETCH_FAILED");
       return detailOrExitCode;
     }
     aggregationInput = aggregationFlag ?? getDefaultAggregation(detailOrExitCode, metric) ?? "sum";
     metricUnit = detailOrExitCode.find((item) => item.id === metric)?.unit ?? "count";
-  } else {
-    const customMetric = await fetchCustomMetricCatalog(
-      client,
-      accountId,
-      metric,
-      startTime.toISOString()
-    ).then((metrics) => metrics.find((item) => item.id === metric)).catch(() => void 0);
-    metricUnit = customMetric?.unit ?? "units";
-    customMetricAggregations = customMetric?.aggregations;
-    aggregationInput = aggregationFlag ?? getDefaultCustomMetricAggregation(metricUnit, customMetricAggregations);
   }
   const aggregation = aggregationInput;
   const orderBy = getRequestOrderBy(metric, aggregation, orderByMode);
   const rangeMs = endTime.getTime() - startTime.getTime();
   const granResult = computeGranularity(rangeMs, granularity);
-  const queryTimeRange = isPlatformMetric ? { startTime, endTime } : alignTimeRangeToGranularity(startTime, endTime, granResult.duration);
+  const queryTimeRange = useCanonicalQuery ? alignTimeRangeToGranularity(startTime, endTime, granResult.duration) : { startTime, endTime };
   if (!jsonOutput && granResult.adjusted && granResult.notice) {
     output_manager_default.log(`Notice: ${granResult.notice}`);
   }
   let body;
-  if (isPlatformMetric) {
+  let canonicalOrderBy;
+  if (!useCanonicalQuery) {
     body = {
       scope,
       metric,
@@ -449,29 +567,45 @@ async function query(client, telemetry) {
         {
           valid: false,
           code: "UNSUPPORTED_BUCKET_TIMEZONE",
-          message: "--bucket-timezone is not supported for custom metrics yet."
+          message: "--bucket-timezone is not supported by the new Observability query API yet."
         },
         jsonOutput,
-        client
+        client,
+        telemetry
       );
     }
-    const selection = toCanonicalMetricSelection(metric, aggregation);
+    const selection = toCanonicalMetricSelection(
+      metric,
+      aggregation,
+      canonicalAggregations
+    );
     if ("valid" in selection) {
-      return handleValidationError(selection, jsonOutput, client);
+      return handleValidationError(selection, jsonOutput, client, telemetry);
     }
     const supportedAggregation = selection.aggregation;
-    if (customMetricAggregations && !customMetricAggregations.includes(supportedAggregation)) {
+    if (canonicalAggregations && !canonicalAggregations.includes(supportedAggregation)) {
       return handleValidationError(
         {
           valid: false,
           code: "INVALID_AGGREGATION",
-          message: `Aggregation "${aggregation}" is not valid for custom metric "${metric}".`,
-          allowedValues: [...customMetricAggregations]
+          message: `Aggregation "${aggregation}" is not valid for metric "${metric}".`,
+          allowedValues: [...canonicalAggregations]
         },
         jsonOutput,
-        client
+        client,
+        telemetry
+      );
+    }
+    const canonicalOrderByResult = groupBy.length > 0 ? getCanonicalOrderBy(orderByMode, selection, canonicalAggregations) : void 0;
+    if (canonicalOrderByResult && typeof canonicalOrderByResult !== "string") {
+      return handleValidationError(
+        canonicalOrderByResult,
+        jsonOutput,
+        client,
+        telemetry
       );
     }
+    canonicalOrderBy = canonicalOrderByResult;
     body = createCanonicalMetricsRequest({
       scope,
       metric,
@@ -482,16 +616,17 @@ async function query(client, telemetry) {
       groupBy,
       filter,
       limit: limit ?? 10,
-      orderBy: orderByMode,
+      orderBy: canonicalOrderBy,
       orderDirection
     });
   }
+  const resolvedOrderBy = canonicalOrderBy ?? orderByMode;
   if (!jsonOutput) {
     output_manager_default.spinner("Querying metrics...");
   }
   let response;
   try {
-    if (isPlatformMetric) {
+    if (!useCanonicalQuery) {
       response = await client.fetch(
         "/v2/observability/query",
         {
@@ -516,15 +651,17 @@ async function query(client, telemetry) {
       response = canonicalResponseToMetricsResponse(
         canonicalResponse,
         getRollupColumnName(metric, aggregation),
-        groupBy.length > 0 ? orderByMode ?? "count" : void 0,
+        canonicalOrderBy,
         groupBy.length > 0 ? orderDirection ?? "desc" : void 0
       );
     }
   } catch (err) {
     if (isAPIError(err)) {
+      telemetry.trackCliError(err.code ?? "API_ERROR", err.status);
       return handleApiError(err, jsonOutput, client);
     }
     const errMsg = err instanceof Error ? err.message : String(err);
+    telemetry.trackCliError("NETWORK_ERROR");
     if (jsonOutput) {
       client.stdout.write(formatErrorJson("NETWORK_ERROR", errMsg));
     } else {
@@ -548,7 +685,7 @@ async function query(client, telemetry) {
           endTime: queryTimeRange.endTime.toISOString(),
           granularity: granResult.duration,
           ...bucketTimezone ? { bucketTimezone } : {},
-          ...orderByMode ? { orderBy: orderByMode } : {},
+          ...resolvedOrderBy ? { orderBy: resolvedOrderBy } : {},
           ...orderDirection ? { orderDirection } : {}
         },
         response
@@ -569,7 +706,7 @@ async function query(client, telemetry) {
         periodEnd: queryTimeRange.endTime.toISOString(),
         granularity: granResult.duration,
         bucketTimezone,
-        orderBy: orderByMode,
+        orderBy: resolvedOrderBy,
         orderDirection
       })
     );

package/dist/chunks/{reorder-NVHDWMRU.js → reorder-LJ2RBZM2.js}

@@ -16,7 +16,7 @@ import {
   resolveRoute,
   shellQuoteRouteIdentifierForSuggestion,
   withGlobalFlags
-} from "./chunk-ZUVJISHS.js";
+} from "./chunk-HJVTLJHO.js";
 import {
   reorderSubcommand
 } from "./chunk-M22O6CYY.js";
@@ -24,11 +24,11 @@ import {
   stamp_default
 } from "./chunk-64IF634X.js";
 import "./chunk-VXYGCOKL.js";
-import "./chunk-VE545BR3.js";
-import "./chunk-ECCWJHC6.js";
+import "./chunk-HMJVUXE6.js";
+import "./chunk-CYNB6LL4.js";
 import {
   outputAgentError
-} from "./chunk-TJLBCLEX.js";
+} from "./chunk-TH2XUVDP.js";
 import "./chunk-GGP5R3FU.js";
 import "./chunk-VAFU7DXZ.js";
 import "./chunk-XLKFJPMT.js";

package/dist/chunks/{reply-PUUPUQ3V.js → reply-USAISZYC.js}

@@ -6,7 +6,7 @@ const __filename = __fileURLToPath(import.meta.url);
 const __dirname = __dirname_(__filename);
 import {
   resolveMessageContent
-} from "./chunk-3BU2UCGV.js";
+} from "./chunk-PIMIKY4X.js";
 import {
   parseThreadArg
 } from "./chunk-E336ZXPP.js";
@@ -16,20 +16,20 @@ import {
   resolveCommentsScope,
   threadNotFoundMessage,
   toApiErrorParts
-} from "./chunk-5DVMXOFT.js";
+} from "./chunk-DDIZGOCK.js";
 import "./chunk-2473DUBR.js";
 import {
   outputError
-} from "./chunk-P65EEFTR.js";
+} from "./chunk-KQRVZWJU.js";
 import {
   validateJsonOutput
 } from "./chunk-KXDWXXJH.js";
 import {
   replySubcommand
 } from "./chunk-GMWRTZVZ.js";
-import "./chunk-VE545BR3.js";
-import "./chunk-ECCWJHC6.js";
-import "./chunk-TJLBCLEX.js";
+import "./chunk-HMJVUXE6.js";
+import "./chunk-CYNB6LL4.js";
+import "./chunk-TH2XUVDP.js";
 import "./chunk-GGP5R3FU.js";
 import "./chunk-VAFU7DXZ.js";
 import {

package/dist/chunks/{resolve-5U2LJVE6.js → resolve-CRCJYVS5.js}

@@ -14,13 +14,13 @@ import {
   threadNotFoundMessage,
   toApiErrorParts,
   updateThread
-} from "./chunk-5DVMXOFT.js";
+} from "./chunk-DDIZGOCK.js";
 import {
   canPrompt
 } from "./chunk-2473DUBR.js";
 import {
   outputError
-} from "./chunk-P65EEFTR.js";
+} from "./chunk-KQRVZWJU.js";
 import {
   validateJsonOutput
 } from "./chunk-KXDWXXJH.js";
@@ -28,9 +28,9 @@ import {
   reopenSubcommand,
   resolveSubcommand
 } from "./chunk-GMWRTZVZ.js";
-import "./chunk-VE545BR3.js";
-import "./chunk-ECCWJHC6.js";
-import "./chunk-TJLBCLEX.js";
+import "./chunk-HMJVUXE6.js";
+import "./chunk-CYNB6LL4.js";
+import "./chunk-TH2XUVDP.js";
 import "./chunk-GGP5R3FU.js";
 import "./chunk-VAFU7DXZ.js";
 import {

package/dist/chunks/{restore-OXIUY2UI.js → restore-6PBPEAMU.js}

@@ -19,7 +19,7 @@ import {
   requireProjectContext,
   validateRequiredArguments,
   withGlobalFlags
-} from "./chunk-ZUVJISHS.js";
+} from "./chunk-HJVTLJHO.js";
 import {
   restoreSubcommand
 } from "./chunk-M22O6CYY.js";
@@ -27,11 +27,11 @@ import {
   stamp_default
 } from "./chunk-64IF634X.js";
 import "./chunk-VXYGCOKL.js";
-import "./chunk-VE545BR3.js";
-import "./chunk-ECCWJHC6.js";
+import "./chunk-HMJVUXE6.js";
+import "./chunk-CYNB6LL4.js";
 import {
   outputAgentError
-} from "./chunk-TJLBCLEX.js";
+} from "./chunk-TH2XUVDP.js";
 import "./chunk-GGP5R3FU.js";
 import "./chunk-VAFU7DXZ.js";
 import "./chunk-XLKFJPMT.js";