langwatch 0.28.0 → 0.29.1

package/dist/cli/index.mjs

@@ -1,94 +1,452 @@
 #!/usr/bin/env node
+import {
+  formatRelativeTime,
+  formatTable
+} from "../chunk-DTEKJ3UD.mjs";
+import {
+  ExperimentsApiService
+} from "../chunk-4AT4WT56.mjs";
+import {
+  checkApiKey
+} from "../chunk-CTEONB5S.mjs";
+import "../chunk-W3V7II7G.mjs";
+import {
+  failSpinner
+} from "../chunk-Q7AHHFC3.mjs";
+import "../chunk-OKR32MOP.mjs";
+import "../chunk-SIXSSID3.mjs";
+import "../chunk-CHEW6HIM.mjs";
 import {
   parsePromptSpec
 } from "../chunk-BTBSMJTY.mjs";
 import {
   formatApiErrorMessage
 } from "../chunk-J3KM7ZO7.mjs";
-import "../chunk-BAX4W3AY.mjs";
+import {
+  __spreadProps,
+  __spreadValues
+} from "../chunk-BAX4W3AY.mjs";
 
 // src/cli/index.ts
 import { config } from "dotenv";
 import { Command } from "commander";
+
+// src/cli/commands/experiment/list-runs.ts
+import chalk from "chalk";
+import ora from "ora";
+var DEFAULT_LIMIT = 50;
+var MAX_PAGE_SIZE = 200;
+var formatTimestamp = (epochMs) => {
+  if (!epochMs || !Number.isFinite(epochMs)) return chalk.gray("\u2014");
+  return new Date(epochMs).toLocaleString();
+};
+var summarizePassRate = (evaluations) => {
+  const entries = Object.values(evaluations != null ? evaluations : {});
+  if (entries.length === 0) return chalk.gray("\u2014");
+  const passEntries = entries.filter(
+    (e) => typeof e.averagePassed === "number"
+  );
+  if (passEntries.length === 0) {
+    const scoreEntries = entries.filter(
+      (e) => typeof e.averageScore === "number"
+    );
+    if (scoreEntries.length === 0) return chalk.gray("\u2014");
+    const avg2 = scoreEntries.reduce((sum, e) => {
+      var _a;
+      return sum + ((_a = e.averageScore) != null ? _a : 0);
+    }, 0) / scoreEntries.length;
+    return `${avg2.toFixed(2)} avg`;
+  }
+  const avg = passEntries.reduce((sum, e) => {
+    var _a;
+    return sum + ((_a = e.averagePassed) != null ? _a : 0);
+  }, 0) / passEntries.length;
+  return `${(avg * 100).toFixed(0)}% pass`;
+};
+var runStatus = (run) => {
+  if (run.timestamps.stoppedAt) return chalk.gray("stopped");
+  if (run.timestamps.finishedAt) return chalk.green("completed");
+  return chalk.yellow("running");
+};
+var experimentListRunsCommand = async (options = {}) => {
+  var _a;
+  checkApiKey();
+  const experimentSlug = (_a = options.experiment) == null ? void 0 : _a.trim();
+  if (!experimentSlug) {
+    console.error(
+      chalk.red(
+        "Error: --experiment <slug> is required. List experiments first with `langwatch experiment list`."
+      )
+    );
+    process.exit(1);
+  }
+  const format = options.format === "json" ? "json" : "table";
+  const limit = (() => {
+    const parsed = options.limit ? parseInt(options.limit, 10) : DEFAULT_LIMIT;
+    if (!Number.isFinite(parsed) || parsed <= 0) return DEFAULT_LIMIT;
+    return Math.min(parsed, MAX_PAGE_SIZE);
+  })();
+  const service = new ExperimentsApiService();
+  const spinner = ora(
+    `Fetching runs for "${experimentSlug}"...`
+  ).start();
+  try {
+    const result = await service.listRuns({
+      experimentSlug,
+      pageSize: limit
+    });
+    spinner.succeed(
+      `Found ${result.pagination.totalHits} run${result.pagination.totalHits === 1 ? "" : "s"} for ${chalk.cyan(experimentSlug)}`
+    );
+    if (format === "json") {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    if (result.runs.length === 0) {
+      console.log();
+      console.log(chalk.gray("No runs found for this experiment yet."));
+      return;
+    }
+    console.log();
+    const tableData = result.runs.map((run) => {
+      var _a2, _b;
+      return {
+        "Run ID": run.runId,
+        Status: runStatus(run),
+        Progress: typeof run.progress === "number" && typeof run.total === "number" ? `${run.progress}/${run.total}` : chalk.gray("\u2014"),
+        Started: formatTimestamp(run.timestamps.createdAt),
+        Finished: formatTimestamp(run.timestamps.finishedAt),
+        Result: summarizePassRate((_b = (_a2 = run.summary) == null ? void 0 : _a2.evaluations) != null ? _b : {})
+      };
+    });
+    formatTable({
+      data: tableData,
+      headers: ["Run ID", "Status", "Progress", "Started", "Finished", "Result"],
+      colorMap: {
+        "Run ID": chalk.cyan
+      }
+    });
+    if (result.pagination.hasMore) {
+      console.log();
+      console.log(
+        chalk.gray(
+          `Showing ${result.runs.length} of ${result.pagination.totalHits}. Increase with --limit or use --format json for full data.`
+        )
+      );
+    }
+    console.log();
+    console.log(
+      chalk.gray(
+        `Use ${chalk.cyan("langwatch experiment status <runId>")} or ${chalk.cyan("langwatch experiment results <runId>")} to drill into a run.`
+      )
+    );
+  } catch (error) {
+    failSpinner({ spinner, error, action: "list experiment runs" });
+    process.exit(1);
+  }
+};
+
+// src/cli/commands/experiment/results.ts
+import chalk2 from "chalk";
+import ora2 from "ora";
+var DEFAULT_LIMIT2 = 20;
+var rowKey = (index, targetId) => `${index}:${targetId != null ? targetId : ""}`;
+var summarizeEntry = (entry) => {
+  const candidates = ["input", "question", "query", "prompt", "user"];
+  for (const key of candidates) {
+    const value = entry[key];
+    if (typeof value === "string" && value.length > 0) {
+      return value.length > 60 ? `${value.slice(0, 57)}...` : value;
+    }
+  }
+  const firstString = Object.entries(entry).find(
+    ([, v]) => typeof v === "string" && v.length > 0
+  );
+  if (firstString) {
+    const v = firstString[1];
+    return v.length > 60 ? `${v.slice(0, 57)}...` : v;
+  }
+  return chalk2.gray("\u2014");
+};
+var isFailedEvaluation = (evaluation) => {
+  if (evaluation.status === "error") return true;
+  if (evaluation.passed === false) return true;
+  return false;
+};
+var isFailedRow = ({
+  entry,
+  evaluations
+}) => {
+  if (entry.error) return true;
+  return evaluations.some((e) => isFailedEvaluation(e));
+};
+var experimentResultsCommand = async ({
+  runId,
+  options = {}
+}) => {
+  var _a, _b, _c;
+  checkApiKey();
+  const filter = options.filter === "failed" ? "failed" : "all";
+  const format = options.format === "json" ? "json" : "table";
+  const limit = (() => {
+    const parsed = options.limit ? parseInt(options.limit, 10) : DEFAULT_LIMIT2;
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_LIMIT2;
+  })();
+  const evaluatorFilter = (_a = options.evaluator) == null ? void 0 : _a.trim();
+  const experimentSlug = (_b = options.experiment) == null ? void 0 : _b.trim();
+  const service = new ExperimentsApiService();
+  const spinner = ora2(`Fetching results for run "${runId}"...`).start();
+  try {
+    const results = await service.getRunResults({
+      runId,
+      experimentSlug
+    });
+    spinner.succeed(
+      `Loaded results for ${chalk2.cyan(runId)} (${results.dataset.length} rows, ${results.evaluations.length} evaluations)`
+    );
+    const evaluationsByRow = /* @__PURE__ */ new Map();
+    for (const evaluation of results.evaluations) {
+      if (evaluatorFilter && evaluation.evaluator !== evaluatorFilter) continue;
+      const key = rowKey(evaluation.index, evaluation.targetId);
+      const list = (_c = evaluationsByRow.get(key)) != null ? _c : [];
+      list.push(evaluation);
+      evaluationsByRow.set(key, list);
+    }
+    const evaluatorNames = evaluatorFilter ? [evaluatorFilter] : Array.from(
+      new Set(results.evaluations.map((e) => e.evaluator))
+    ).slice(0, 3);
+    let rows = results.dataset.map((entry) => {
+      var _a2;
+      return {
+        entry,
+        evaluations: (_a2 = evaluationsByRow.get(rowKey(entry.index, entry.targetId))) != null ? _a2 : []
+      };
+    });
+    if (filter === "failed") {
+      rows = rows.filter(
+        (r) => isFailedRow({ entry: r.entry, evaluations: r.evaluations })
+      );
+    }
+    const totalMatching = rows.length;
+    const truncated = rows.length > limit;
+    rows = rows.slice(0, limit);
+    if (format === "json") {
+      console.log(
+        JSON.stringify(
+          __spreadProps(__spreadValues({}, results), {
+            dataset: rows.map((row) => row.entry),
+            evaluations: rows.flatMap((row) => row.evaluations),
+            meta: {
+              totalMatching,
+              truncated,
+              limit,
+              filter,
+              evaluator: evaluatorFilter != null ? evaluatorFilter : null
+            }
+          }),
+          null,
+          2
+        )
+      );
+      return;
+    }
+    if (rows.length === 0) {
+      console.log(chalk2.gray("No rows matched the filter."));
+      return;
+    }
+    const headers = ["#", "Target", ...evaluatorNames, "Status"];
+    const tableData = rows.map(({ entry, evaluations }) => {
+      const evaluatorCols = {};
+      for (const name of evaluatorNames) {
+        const e = evaluations.find((x) => x.evaluator === name);
+        if (!e) {
+          evaluatorCols[name] = chalk2.gray("\u2014");
+        } else if (e.status === "error") {
+          evaluatorCols[name] = chalk2.red("error");
+        } else if (typeof e.score === "number") {
+          const passedSuffix = e.passed === false ? chalk2.red(" \u2717") : e.passed === true ? chalk2.green(" \u2713") : "";
+          evaluatorCols[name] = `${e.score.toFixed(2)}${passedSuffix}`;
+        } else if (e.label) {
+          evaluatorCols[name] = e.label;
+        } else if (typeof e.passed === "boolean") {
+          evaluatorCols[name] = e.passed ? chalk2.green("pass") : chalk2.red("fail");
+        } else {
+          evaluatorCols[name] = chalk2.gray("\u2014");
+        }
+      }
+      const status = entry.error ? chalk2.red(
+        entry.error.length > 40 ? `${entry.error.slice(0, 37)}...` : entry.error
+      ) : evaluations.some(isFailedEvaluation) ? chalk2.red("failed") : chalk2.green("ok");
+      return __spreadProps(__spreadValues({
+        "#": String(entry.index),
+        Target: summarizeEntry(entry.entry)
+      }, evaluatorCols), {
+        Status: status
+      });
+    });
+    formatTable({ data: tableData, headers });
+    if (truncated) {
+      console.log();
+      console.log(
+        chalk2.gray(
+          `Showing ${rows.length} of ${totalMatching} rows. Use --limit <n> or --format json for the full payload.`
+        )
+      );
+    }
+  } catch (error) {
+    failSpinner({ spinner, error, action: "fetch experiment results" });
+    process.exit(1);
+  }
+};
+
+// src/cli/commands/experiment/list.ts
+import chalk3 from "chalk";
+import ora3 from "ora";
+var DEFAULT_LIMIT3 = 50;
+var MAX_PAGE_SIZE2 = 200;
+var experimentListCommand = async (options = {}) => {
+  checkApiKey();
+  const format = options.format === "json" ? "json" : "table";
+  const limit = (() => {
+    const parsed = options.limit ? parseInt(options.limit, 10) : DEFAULT_LIMIT3;
+    if (!Number.isFinite(parsed) || parsed <= 0) return DEFAULT_LIMIT3;
+    return Math.min(parsed, MAX_PAGE_SIZE2);
+  })();
+  const service = new ExperimentsApiService();
+  const spinner = ora3("Fetching experiments...").start();
+  try {
+    const result = await service.listExperiments({ pageSize: limit });
+    spinner.succeed(
+      `Found ${result.pagination.totalHits} experiment${result.pagination.totalHits === 1 ? "" : "s"}`
+    );
+    if (format === "json") {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    if (result.experiments.length === 0) {
+      console.log();
+      console.log(chalk3.gray("No experiments found in this project."));
+      return;
+    }
+    console.log();
+    const tableData = result.experiments.map((exp) => {
+      var _a;
+      return {
+        Name: (_a = exp.name) != null ? _a : exp.slug,
+        Slug: exp.slug,
+        "Last Run": exp.lastRunAt ? formatRelativeTime(exp.lastRunAt) : chalk3.gray("\u2014"),
+        Runs: String(exp.runsCount)
+      };
+    });
+    formatTable({
+      data: tableData,
+      headers: ["Name", "Slug", "Last Run", "Runs"],
+      colorMap: {
+        Name: chalk3.cyan,
+        Slug: chalk3.green,
+        Runs: chalk3.yellow
+      }
+    });
+    if (result.pagination.hasMore) {
+      console.log();
+      console.log(
+        chalk3.gray(
+          `Showing ${result.experiments.length} of ${result.pagination.totalHits}. Increase with --limit or use --format json for full data.`
+        )
+      );
+    }
+    console.log();
+    console.log(
+      chalk3.gray(
+        `Use ${chalk3.cyan("langwatch experiment list-runs --experiment <slug>")} to see runs for an experiment.`
+      )
+    );
+  } catch (error) {
+    failSpinner({ spinner, error, action: "fetch experiments" });
+    process.exit(1);
+  }
+};
+
+// src/cli/index.ts
 config();
 var addCommand = async (name, options) => {
-  const { addCommand: addCommandImpl } = await import("../add-3CDKMW3S.mjs");
+  const { addCommand: addCommandImpl } = await import("../add-C2M2WP24.mjs");
   return addCommandImpl(name, options);
 };
 var removeCommand = async (name) => {
-  const { removeCommand: removeCommandImpl } = await import("../remove-IFRSRUGH.mjs");
+  const { removeCommand: removeCommandImpl } = await import("../remove-YQPCKQUV.mjs");
   return removeCommandImpl(name);
 };
 var initCommand = async () => {
-  const { initCommand: initCommandImpl } = await import("../init-NQLD3PTI.mjs");
+  const { initCommand: initCommandImpl } = await import("../init-MKAX64ZI.mjs");
   return initCommandImpl();
 };
 var loginCommand = async (options) => {
-  const { loginCommand: loginCommandImpl } = await import("../login-KMB2XPOV.mjs");
+  const { loginCommand: loginCommandImpl } = await import("../login-G2TZBZAT.mjs");
   return loginCommandImpl(options);
 };
 var listCommand = async (options) => {
-  const { listCommand: listCommandImpl } = await import("../list-3ZIQGCSU.mjs");
+  const { listCommand: listCommandImpl } = await import("../list-EBAKJGFX.mjs");
   return listCommandImpl(options);
 };
 var syncCommand = async () => {
-  const { syncCommand: syncCommandImpl } = await import("../sync-SXI7HIJW.mjs");
+  const { syncCommand: syncCommandImpl } = await import("../sync-ALF3MSXZ.mjs");
   return syncCommandImpl();
 };
 var pullCommand = async (options) => {
-  const { pullCommand: pullCommandImpl } = await import("../pull-7ICWENKU.mjs");
+  const { pullCommand: pullCommandImpl } = await import("../pull-D7OCRPTJ.mjs");
   return pullCommandImpl(options);
 };
 var tagListCommand = async (options) => {
-  const { tagListCommand: impl } = await import("../list-ZZ5GF5MQ.mjs");
+  const { tagListCommand: impl } = await import("../list-URU2LA5S.mjs");
   return impl(options);
 };
 var tagCreateCommand = async (name) => {
-  const { tagCreateCommand: impl } = await import("../create-23VY67VO.mjs");
+  const { tagCreateCommand: impl } = await import("../create-BABU2YFY.mjs");
   return impl(name);
 };
 var tagRenameCommand = async (oldName, newName) => {
-  const { tagRenameCommand: impl } = await import("../rename-NPBMTVXU.mjs");
+  const { tagRenameCommand: impl } = await import("../rename-TH6UNSGF.mjs");
   return impl(oldName, newName);
 };
 var tagAssignCommand = async (promptHandle, tagName, options) => {
-  const { tagAssignCommand: impl } = await import("../assign-6G5ZYKQ5.mjs");
+  const { tagAssignCommand: impl } = await import("../assign-IR5WQAQL.mjs");
   return impl(promptHandle, tagName, options);
 };
 var tagDeleteCommand = async (tagName, options) => {
-  const { tagDeleteCommand: impl } = await import("../delete-ZK4X56MN.mjs");
+  const { tagDeleteCommand: impl } = await import("../delete-47QEGC34.mjs");
   return impl(tagName, options);
 };
 var pushCommand = async (options) => {
-  const { pushCommand: pushCommandImpl } = await import("../push-RX6UT4QL.mjs");
+  const { pushCommand: pushCommandImpl } = await import("../push-V2JOPVQ5.mjs");
   return pushCommandImpl(options);
 };
 var createCommand = async (name, options) => {
-  const { createCommand: createCommandImpl } = await import("../create-6WFTHQMD.mjs");
+  const { createCommand: createCommandImpl } = await import("../create-Y5EPTAQA.mjs");
   return createCommandImpl(name, options);
 };
 var listEvaluatorsCommand = async (options) => {
-  const { listEvaluatorsCommand: impl } = await import("../list-NXN64XJ2.mjs");
+  const { listEvaluatorsCommand: impl } = await import("../list-SHVQIG3R.mjs");
   return impl(options);
 };
 var getEvaluatorCommand = async (idOrSlug, options) => {
-  const { getEvaluatorCommand: impl } = await import("../get-VA37QEJ6.mjs");
+  const { getEvaluatorCommand: impl } = await import("../get-SHDHYKHK.mjs");
   return impl(idOrSlug, options);
 };
 var createEvaluatorCommand = async (name, options) => {
-  const { createEvaluatorCommand: impl } = await import("../create-F7IXC6LY.mjs");
+  const { createEvaluatorCommand: impl } = await import("../create-AEIYCNQY.mjs");
   return impl(name, options);
 };
 var updateEvaluatorCommand = async (idOrSlug, options) => {
-  const { updateEvaluatorCommand: impl } = await import("../update-RPC722BA.mjs");
+  const { updateEvaluatorCommand: impl } = await import("../update-LIOML73C.mjs");
   return impl(idOrSlug, options);
 };
 var deleteEvaluatorCommand = async (idOrSlug, options) => {
-  const { deleteEvaluatorCommand: impl } = await import("../delete-OZBLOHQ6.mjs");
+  const { deleteEvaluatorCommand: impl } = await import("../delete-BABWUHTM.mjs");
   return impl(idOrSlug, options);
 };
 var program = new Command();
-program.name("langwatch").description("LangWatch CLI - Manage prompts, datasets, evaluators, scenarios, suites, and more").version("0.28.0", "-v, --version", "Display the current version").enablePositionalOptions().passThroughOptions().configureHelp({
+program.name("langwatch").description("LangWatch CLI - Manage prompts, datasets, evaluators, scenarios, suites, and more").version("0.29.1", "-v, --version", "Display the current version").enablePositionalOptions().passThroughOptions().configureHelp({
   showGlobalOptions: true
 }).showHelpAfterError().showSuggestionAfterError();
 program.command("login").description("Login to LangWatch and save API key. Get a key from https://app.langwatch.ai/authorize (or ${LANGWATCH_ENDPOINT}/authorize for self-hosted).").option("--api-key <key>", "Set API key non-interactively (for CI/CD and agents)").action(async (options) => {
@@ -170,11 +528,11 @@ promptCmd.command("push").description("Push local prompts to the server").option
   }
 });
 promptCmd.command("versions <handle>").description("List all versions of a prompt").option("-f, --format <format>", "Output format: table (default) or json", "table").action(async (handle, options) => {
-  const { promptVersionsCommand: impl } = await import("../versions-PN7XIEH7.mjs");
+  const { promptVersionsCommand: impl } = await import("../versions-ACMLZ6NH.mjs");
   await impl(handle, options);
 });
 promptCmd.command("restore <handle> <versionId>").description("Restore a prompt to a previous version (creates a new version with that config)").option("-f, --format <format>", "Output format: table (default) or json", "table").action(async (handle, versionId, options) => {
-  const { promptRestoreCommand: impl } = await import("../restore-2SQC7QS4.mjs");
+  const { promptRestoreCommand: impl } = await import("../restore-2GRPBZWH.mjs");
   await impl(handle, versionId, options);
 });
 var tagCmd = promptCmd.command("tag").description("Manage prompt tags");
@@ -219,7 +577,7 @@ tagCmd.command("delete <name>").description("Delete a tag and remove all its ass
   }
 });
 program.command("status").description("Show project resource counts and available commands").option("-f, --format <format>", "Output format: table (default) or json", "table").action(async (options) => {
-  const { statusCommand: impl } = await import("../status-H4I3X5HE.mjs");
+  const { statusCommand: impl } = await import("../status-QSEOS2PK.mjs");
   await impl(options);
 });
 program.command("docs [url]").description(
@@ -285,373 +643,453 @@ evaluatorCmd.command("delete <idOrSlug>").description("Archive (soft-delete) an
     process.exit(1);
   }
 });
-var evaluationCmd = program.command("evaluation").description("Run and monitor evaluations");
-evaluationCmd.command("run <slug>").description("Start an evaluation run by slug").option("--wait", "Wait for the evaluation to complete before returning").option("-f, --format <format>", "Output format: table (default) or json", "table").action(async (slug, options) => {
-  const { runEvaluationCommand: impl } = await import("../run-AFR4S7D6.mjs");
+var experimentCmd = program.command("experiment").description("Run, monitor, list, and inspect experiments");
+experimentCmd.command("list").description("List experiments in the project").option("-f, --format <format>", "Output format: table (default) or json", "table").option("--limit <n>", "Maximum experiments to fetch (default 50, max 200)", "50").action(async (options) => {
+  await experimentListCommand(options);
+});
+experimentCmd.command("run <slug>").description("Start an experiment run by slug").option("--wait", "Wait for the experiment to complete before returning").option("-f, --format <format>", "Output format: table (default) or json", "table").action(async (slug, options) => {
+  const { runExperimentCommand: impl } = await import("../run-2VWYDGSD.mjs");
   await impl(slug, options);
 });
-evaluationCmd.command("status <runId>").description("Check the status of an evaluation run").option("-f, --format <format>", "Output format: table (default) or json", "table").action(async (runId, options) => {
-  const { evaluationStatusCommand: impl } = await import("../status-7RJK27HR.mjs");
+experimentCmd.command("status <runId>").description("Check the status of an experiment run").option("-f, --format <format>", "Output format: table (default) or json", "table").action(async (runId, options) => {
+  const { experimentStatusCommand: impl } = await import("../status-ZCR6IMH2.mjs");
   await impl(runId, options);
 });
+experimentCmd.command("list-runs").description("List experiment runs for an experiment by slug").requiredOption("--experiment <slug>", "Experiment slug to list runs for").option("-f, --format <format>", "Output format: table (default) or json", "table").option("--limit <n>", "Maximum runs to fetch (default 50, max 200)", "50").action(
+  async (options) => {
+    await experimentListRunsCommand(options);
+  }
+);
+experimentCmd.command("results <runId>").description(
+  "Fetch per-row results for a completed experiment run (debug evaluator scores and missed rows)"
+).option("--filter <filter>", "Filter rows: failed | all (default)", "all").option("--evaluator <name>", "Show only this evaluator's column").option("-f, --format <format>", "Output format: table (default) or json", "table").option("--limit <n>", "Maximum rows to print in table mode (default 20)", "20").option("--experiment <slug>", "Experiment slug \u2014 required for runs older than 24h").action(
+  async (runId, options) => {
+    await experimentResultsCommand({ runId, options });
+  }
+);
 var workflowCmd = program.command("workflow").description("Manage workflows");
 workflowCmd.command("list").description("List all workflows in the project").option("-f, --format <format>", "Output format: table (default) or json", "table").action(async (options) => {
-  const { listWorkflowsCommand: impl } = await import("../list-OFPK6RW7.mjs");
+  const { listWorkflowsCommand: impl } = await import("../list-FDTSCUIN.mjs");
   await impl(options);
 });
 workflowCmd.command("get <id>").description("Get workflow details by ID").option("-f, --format <format>", "Output format: table (default) or json", "table").action(async (id, options) => {
-  const { getWorkflowCommand: impl } = await import("../get-POYXEXYJ.mjs");
+  const { getWorkflowCommand: impl } = await import("../get-UJS3RI4G.mjs");
   await impl(id, options);
 });
 workflowCmd.command("update <id>").description("Update a workflow's metadata (name, icon, description)").option("--name <name>", "New workflow name").option("--icon <icon>", "New workflow icon").option("--description <desc>", "New workflow description").option("-f, --format <format>", "Output format: table (default) or json", "table").action(async (id, options) => {
-  const { updateWorkflowCommand: impl } = await import("../update-LRAX5MVX.mjs");
+  const { updateWorkflowCommand: impl } = await import("../update-DMMDBSF6.mjs");
   await impl(id, options);
 });
 workflowCmd.command("run <id>").description("Execute a workflow with JSON input").option("--input <json>", "Input data as JSON string").option("-f, --format <format>", "Output format: table (default) or json", "table").action(async (id, options) => {
-  const { runWorkflowCommand: impl } = await import("../run-VE7AKQHN.mjs");
+  const { runWorkflowCommand: impl } = await import("../run-S3DQKR6S.mjs");
   await impl(id, options);
 });
 workflowCmd.command("delete <id>").description("Archive (soft-delete) a workflow").option("-f, --format <format>", "Output format: table (default) or json", "table").action(async (id, options) => {
-  const { deleteWorkflowCommand: impl } = await import("../delete-I7TDBX4N.mjs");
+  const { deleteWorkflowCommand: impl } = await import("../delete-MS4V2N5U.mjs");
   await impl(id, options);
 });
 var agentCmd = program.command("agent").description("Manage agent definitions");
 agentCmd.command("list").description("List all agents in the project").option("-f, --format <format>", "Output format: table (default) or json", "table").action(async (options) => {
-  const { listAgentsCommand: impl } = await import("../list-3KZSXM4S.mjs");
+  const { listAgentsCommand: impl } = await import("../list-R2P53YSJ.mjs");
   await impl(options);
 });
 agentCmd.command("get <id>").description("Get agent details by ID").option("-f, --format <format>", "Output format: table (default) or json", "table").action(async (id, options) => {
-  const { getAgentCommand: impl } = await import("../get-OOBPNKDJ.mjs");
+  const { getAgentCommand: impl } = await import("../get-N6UUMRGN.mjs");
   await impl(id, options);
 });
 agentCmd.command("create <name>").description("Create a new agent").requiredOption("--type <type>", "Agent type: signature, code, workflow, or http").option("--config <json>", "Agent config as JSON").option("-f, --format <format>", "Output format: table (default) or json", "table").action(async (name, options) => {
-  const { createAgentCommand: impl } = await import("../create-LVAEPDXJ.mjs");
+  const { createAgentCommand: impl } = await import("../create-76TPO7XM.mjs");
   await impl(name, options);
 });
 agentCmd.command("run <id>").description("Execute an agent with JSON input (HTTP agents call URL directly, others use workflow engine)").option("--input <json>", "Input data as JSON string").option("-f, --format <format>", "Output format: table (default) or json", "table").action(async (id, options) => {
-  const { runAgentCommand: impl } = await import("../run-CG6MEL6Z.mjs");
+  const { runAgentCommand: impl } = await import("../run-HBC6WH74.mjs");
   await impl(id, options);
 });
 agentCmd.command("update <id>").description("Update an agent name, type, or configuration").option("--name <name>", "New agent name").option("--type <type>", "New agent type: signature, code, workflow, or http").option("--config <json>", "Updated configuration as JSON").option("-f, --format <format>", "Output format: table (default) or json", "table").action(async (id, options) => {
-  const { updateAgentCommand: impl } = await import("../update-E34GVN5D.mjs");
+  const { updateAgentCommand: impl } = await import("../update-UF2PKCDF.mjs");
   await impl(id, options);
 });
 agentCmd.command("delete <id>").description("Archive (soft-delete) an agent").option("-f, --format <format>", "Output format: table (default) or json", "table").action(async (id, options) => {
-  const { deleteAgentCommand: impl } = await import("../delete-KM43ETJP.mjs");
+  const { deleteAgentCommand: impl } = await import("../delete-EEOGOTLN.mjs");
   await impl(id, options);
 });
 var dashboardCmd = program.command("dashboard").description("Manage analytics dashboards");
 dashboardCmd.command("list").description("List all dashboards in the project").option("-f, --format <format>", "Output format: table (default) or json", "table").action(async (options) => {
-  const { listDashboardsCommand: impl } = await import("../list-SL4UGZ3E.mjs");
+  const { listDashboardsCommand: impl } = await import("../list-UCDMDBFA.mjs");
   await impl(options);
 });
 dashboardCmd.command("get <id>").description("Get dashboard details by ID").option("-f, --format <format>", "Output format: table (default) or json", "table").action(async (id, options) => {
-  const { getDashboardCommand: impl } = await import("../get-E6CPQCQD.mjs");
+  const { getDashboardCommand: impl } = await import("../get-CXJUQ2U2.mjs");
   await impl(id, options);
 });
 dashboardCmd.command("update <id>").description("Rename a dashboard").requiredOption("--name <name>", "New dashboard name").option("-f, --format <format>", "Output format: table (default) or json", "table").action(async (id, options) => {
-  const { updateDashboardCommand: impl } = await import("../update-SBFQQPO5.mjs");
+  const { updateDashboardCommand: impl } = await import("../update-2PC23OZN.mjs");
   await impl(id, options);
 });
 dashboardCmd.command("create <name>").description("Create a new dashboard").option("-f, --format <format>", "Output format: table (default) or json", "table").action(async (name, options) => {
-  const { createDashboardCommand: impl } = await import("../create-S56FEJQC.mjs");
+  const { createDashboardCommand: impl } = await import("../create-6BP5RIXR.mjs");
   await impl(name, options);
 });
 dashboardCmd.command("delete <id>").description("Delete a dashboard and its graphs").option("-f, --format <format>", "Output format: table (default) or json", "table").action(async (id, options) => {
-  const { deleteDashboardCommand: impl } = await import("../delete-GL2ECGNY.mjs");
+  const { deleteDashboardCommand: impl } = await import("../delete-65PA2XFX.mjs");
   await impl(id, options);
 });
 var modelProviderCmd = program.command("model-provider").description("Manage LLM model provider configurations");
 modelProviderCmd.command("list").description("List all configured model providers").option("-f, --format <format>", "Output format: table (default) or json", "table").action(async (options) => {
-  const { listModelProvidersCommand: impl } = await import("../list-HIIB3K73.mjs");
+  const { listModelProvidersCommand: impl } = await import("../list-ST737MVR.mjs");
   await impl(options);
 });
 modelProviderCmd.command("set <provider>").description("Configure a model provider (e.g. openai, anthropic)").option("--enabled <boolean>", "Enable or disable the provider", (v) => v === "true").option("--api-key <key>", "API key for the provider").option("--default-model <model>", "Default model to use (e.g. gpt-4o)").option("-f, --format <format>", "Output format: table (default) or json", "table").action(async (provider, options) => {
-  const { setModelProviderCommand: impl } = await import("../set-RQK3AJF5.mjs");
+  const { setModelProviderCommand: impl } = await import("../set-UO5W7IO4.mjs");
   await impl(provider, options);
 });
+var modelDefaultCmd = program.command("model-default").description(
+  "Manage cascading default models (per role/feature, per scope: project/team/organization)"
+);
+modelDefaultCmd.command("list").description("Show the effective resolution + every config you can read").option("-f, --format <format>", "Output format: table (default) or json", "table").action(async (options) => {
+  const { listModelDefaultsCommand: impl } = await import("../list-EURMVFOH.mjs");
+  await impl(options);
+});
+modelDefaultCmd.command("set <key> <model>").description(
+  "Set a default model for a role (DEFAULT|FAST|EMBEDDINGS) or registered feature key. Defaults to project scope; pass --scope team|organization for higher tiers."
+).option("--scope <scope>", "Scope tier: project (default), team, or organization", "project").option(
+  "--scope-id <id>",
+  "Explicit scope id. Defaults to the API key's project / its team / its organization."
+).option("-f, --format <format>", "Output format: text (default) or json", "text").action(
+  async (key, model, options) => {
+    const { setModelDefaultCommand: impl } = await import("../set-GZLLMGRR.mjs");
+    await impl(key, model, options);
+  }
+);
+modelDefaultCmd.command("unset <key>").description("Remove a default model for a role or feature key at the chosen scope").option("--scope <scope>", "Scope tier: project (default), team, or organization", "project").option(
+  "--scope-id <id>",
+  "Explicit scope id. Defaults to the API key's project / its team / its organization."
+).option("-f, --format <format>", "Output format: text (default) or json", "text").action(
+  async (key, options) => {
+    const { unsetModelDefaultCommand: impl } = await import("../unset-4XAATHVE.mjs");
+    await impl(key, options);
+  }
+);
 var virtualKeysCmd = program.command("virtual-keys").alias("vk").description("Manage AI Gateway virtual keys (list, create, rotate, revoke)");
 virtualKeysCmd.command("list").description("List all virtual keys for the current project").option("-f, --format <format>", "Output format: table (default) or json", "table").action(async (options) => {
-  const { listVirtualKeysCommand: impl } = await import("../list-I7DTOCQK.mjs");
+  const { listVirtualKeysCommand: impl } = await import("../list-JSU7Q26B.mjs");
   await impl(options);
 });
 virtualKeysCmd.command("get <id>").description("Show details for a single virtual key").option("-f, --format <format>", "Output format: text (default) or json", "text").action(async (id, options) => {
-  const { getVirtualKeyCommand: impl } = await import("../get-VW4ZNCTM.mjs");
+  const { getVirtualKeyCommand: impl } = await import("../get-LPD6B5S6.mjs");
   await impl(id, options);
 });
 virtualKeysCmd.command("create").description("Create a new virtual key (secret is shown once)").requiredOption("--name <name>", "Human-readable name for the key").option("--description <desc>", "Optional description").option("--env <env>", "Environment: live or test", "live").option("--provider <id...>", "Provider credential id(s) to bind (repeatable)").option("--principal <userId>", "Bind to a specific principal user id").option("-f, --format <format>", "Output format: text (default) or json", "text").action(async (options) => {
-  const { createVirtualKeyCommand: impl } = await import("../create-RKD5NN22.mjs");
+  const { createVirtualKeyCommand: impl } = await import("../create-UUAHAFBF.mjs");
   await impl(options);
 });
 virtualKeysCmd.command("update <id>").description("Update a virtual key's name/description/providers/config (requires VK edit drawer-level changes)").option("--name <name>", "New display name").option("--description <desc>", "New description").option("--clear-description", "Clear the description").option("--provider <id...>", "Replace the bound provider credential ids (repeatable; supplies the full set)").option("--config-json <json>", "Inline partial config JSON (model_aliases/cache/fallback/rate_limits/policy_rules). Merges with existing config").option("--config-file <path>", "Read partial config JSON from a file").option("-f, --format <format>", "Output format: text (default) or json", "text").action(async (id, options) => {
-  const { updateVirtualKeyCommand: impl } = await import("../update-ICDYLWKF.mjs");
+  const { updateVirtualKeyCommand: impl } = await import("../update-6IVXFEUD.mjs");
   await impl(id, options);
 });
 virtualKeysCmd.command("rotate <id>").description("Rotate a virtual key's secret (old secret stops working immediately)").option("-f, --format <format>", "Output format: text (default) or json", "text").action(async (id, options) => {
-  const { rotateVirtualKeyCommand: impl } = await import("../rotate-EFHXMEB4.mjs");
+  const { rotateVirtualKeyCommand: impl } = await import("../rotate-XHGB6AOX.mjs");
   await impl(id, options);
 });
 virtualKeysCmd.command("revoke <id>").description("Revoke a virtual key (cannot be reactivated)").option("-f, --format <format>", "Output format: text (default) or json", "text").action(async (id, options) => {
-  const { revokeVirtualKeyCommand: impl } = await import("../revoke-22ZBQYW2.mjs");
+  const { revokeVirtualKeyCommand: impl } = await import("../revoke-4KVTQF7O.mjs");
   await impl(id, options);
 });
 var gatewayBudgetsCmd = program.command("gateway-budgets").description("Manage AI Gateway spend budgets (hierarchical scopes)");
 gatewayBudgetsCmd.command("list").description("List all budgets across scopes").option("-f, --format <format>", "Output format: table (default) or json", "table").action(async (options) => {
-  const { listGatewayBudgetsCommand: impl } = await import("../list-M2CUXUU5.mjs");
+  const { listGatewayBudgetsCommand: impl } = await import("../list-HLW673TU.mjs");
   await impl(options);
 });
 gatewayBudgetsCmd.command("create").description("Create a new budget (scope + window + limit)").requiredOption("--name <name>", "Human-readable budget name").option("--description <desc>", "Optional description").requiredOption("--scope <kind>", "Budget scope: organization|team|project|virtual-key|principal").option("--organization <id>", "Organization id (for scope=organization)").option("--team <id>", "Team id (for scope=team)").option("--project <id>", "Project id (for scope=project)").option("--virtual-key <id>", "Virtual key id (for scope=virtual-key)").option("--principal <id>", "Principal user id (for scope=principal)").requiredOption("--window <w>", "Budget window: minute|hour|day|week|month|total").requiredOption("--limit <usd>", "Hard cap in USD (e.g. 100 or 49.99)").option("--on-breach <action>", "block (default) or warn", "block").option("--timezone <tz>", "IANA timezone for window boundaries (e.g. Europe/Amsterdam)").option("-f, --format <format>", "Output format: text (default) or json", "text").action(async (options) => {
-  const { createGatewayBudgetCommand: impl } = await import("../create-AULDFYQS.mjs");
+  const { createGatewayBudgetCommand: impl } = await import("../create-BJLMIXMK.mjs");
   await impl(options);
 });
 gatewayBudgetsCmd.command("update <id>").description("Update a budget's name/description/limit/on-breach/timezone").option("--name <name>", "New display name").option("--description <desc>", "New description").option("--clear-description", "Clear the description").option("--limit <usd>", "New hard-cap in USD").option("--on-breach <action>", "block or warn").option("--timezone <tz>", "New IANA timezone").option("--clear-timezone", "Clear the timezone override").option("-f, --format <format>", "Output format: text (default) or json", "text").action(async (id, options) => {
-  const { updateGatewayBudgetCommand: impl } = await import("../update-ZHLIAJY6.mjs");
+  const { updateGatewayBudgetCommand: impl } = await import("../update-DCCJDNQD.mjs");
   await impl(id, options);
 });
 gatewayBudgetsCmd.command("archive <id>").description("Archive a budget (stops enforcement; does not delete history)").option("-f, --format <format>", "Output format: text (default) or json", "text").action(async (id, options) => {
-  const { archiveGatewayBudgetCommand: impl } = await import("../archive-HJKGZZYD.mjs");
+  const { archiveGatewayBudgetCommand: impl } = await import("../archive-RQFBSRMZ.mjs");
   await impl(id, options);
 });
 var gatewayProvidersCmd = program.command("gateway-providers").description("Manage AI Gateway provider credential bindings");
 gatewayProvidersCmd.command("list").description("List provider bindings attached to the current project's gateway").option("-f, --format <format>", "Output format: table (default) or json", "table").action(async (options) => {
-  const { listGatewayProvidersCommand: impl } = await import("../list-7UPPINR7.mjs");
+  const { listGatewayProvidersCommand: impl } = await import("../list-N7WY3KF4.mjs");
   await impl(options);
 });
 gatewayProvidersCmd.command("create").description("Bind an existing model-provider to the gateway with optional rate limits").requiredOption("--model-provider <id>", "Existing model-provider id to bind").option("--slot <slot>", "Optional free-text slot tag (e.g. 'primary', 'eu-region')").option("--rate-limit-rpm <rpm>", "Requests per minute").option("--rate-limit-tpm <tpm>", "Tokens per minute").option("--rate-limit-rpd <rpd>", "Requests per day").option("--rotation-policy <p>", "auto|manual|external_secret_store").option("--fallback-priority <n>", "Global fallback priority (lower = earlier)").option("-f, --format <format>", "Output format: text (default) or json", "text").action(async (options) => {
-  const { createGatewayProviderCommand: impl } = await import("../create-WQH5CT7J.mjs");
+  const { createGatewayProviderCommand: impl } = await import("../create-THLMUHJR.mjs");
   await impl(options);
 });
 gatewayProvidersCmd.command("disable <id>").description("Disable a provider binding (stops routing traffic to it)").option("-f, --format <format>", "Output format: text (default) or json", "text").action(async (id, options) => {
-  const { disableGatewayProviderCommand: impl } = await import("../disable-BEYLSXEX.mjs");
+  const { disableGatewayProviderCommand: impl } = await import("../disable-EEOAE5SU.mjs");
   await impl(id, options);
 });
 var annotationCmd = program.command("annotation").description("Manage trace annotations");
 annotationCmd.command("list").description("List all annotations (optionally filtered by trace)").option("--trace-id <traceId>", "Filter by trace ID").option("-f, --format <format>", "Output format: table (default) or json", "table").action(async (options) => {
-  const { listAnnotationsCommand: impl } = await import("../list-WSNVLZVO.mjs");
+  const { listAnnotationsCommand: impl } = await import("../list-H7OILQEK.mjs");
   await impl(options);
 });
 annotationCmd.command("get <id>").description("Get annotation details by ID").option("-f, --format <format>", "Output format: table (default) or json", "table").action(async (id, options) => {
-  const { getAnnotationCommand: impl } = await import("../get-3CUYSH5L.mjs");
+  const { getAnnotationCommand: impl } = await import("../get-ZIP2VLKS.mjs");
   await impl(id, options);
 });
 annotationCmd.command("create <traceId>").description("Create an annotation for a trace").option("--comment <comment>", "Annotation comment").option("--thumbs-up", "Mark as thumbs up").option("--thumbs-down", "Mark as thumbs down").option("--email <email>", "Email of the annotator").option("-f, --format <format>", "Output format: table (default) or json", "table").action(async (traceId, options) => {
-  const { createAnnotationCommand: impl } = await import("../create-2DAUVMAB.mjs");
+  const { createAnnotationCommand: impl } = await import("../create-2LDBGJAV.mjs");
   await impl(traceId, options);
 });
 annotationCmd.command("delete <id>").description("Delete an annotation").option("-f, --format <format>", "Output format: table (default) or json", "table").action(async (id, options) => {
-  const { deleteAnnotationCommand: impl } = await import("../delete-YCFRGZ2B.mjs");
+  const { deleteAnnotationCommand: impl } = await import("../delete-RFKQDFLV.mjs");
   await impl(id, options);
 });
 var analyticsCmd = program.command("analytics").description("Query analytics and metrics");
 analyticsCmd.command("query").description("Query timeseries analytics (costs, latency, token usage, etc.)").option("-m, --metric <metric>", "Metric to query (preset name or raw metric path, default: trace-count)").option("-a, --aggregation <aggregation>", "Aggregation type: cardinality, avg, sum, min, max, p95, p99").option("--start-date <date>", "Start date (ISO string, default: 7 days ago)").option("--end-date <date>", "End date (ISO string, default: now)").option("--group-by <field>", "Group by field (e.g. metadata.model)").option("--time-scale <scale>", "Time scale: 'full' for aggregate, or interval in seconds").option("-f, --format <format>", "Output format: table (default) or json", "table").action(async (options) => {
-  const { queryAnalyticsCommand: impl } = await import("../query-KX5L5KIX.mjs");
+  const { queryAnalyticsCommand: impl } = await import("../query-IUJRH3CE.mjs");
   await impl(options);
 });
 var traceCmd = program.command("trace").description("Search and inspect traces");
 traceCmd.command("search").description("Search traces with optional text query and date range").option("-q, --query <query>", "Text search query").option("--start-date <date>", "Start date (ISO string or epoch ms, default: 24h ago)").option("--end-date <date>", "End date (ISO string or epoch ms, default: now)").option("--limit <n>", "Max results to return (default: 25)").option("-f, --format <format>", "Output format: table (default) or json", "table").action(async (options) => {
-  const { searchTracesCommand: impl } = await import("../search-ITC5GC3G.mjs");
+  const { searchTracesCommand: impl } = await import("../search-VEY2FDMR.mjs");
   await impl(options);
 });
 traceCmd.command("export").description("Export traces as CSV, JSONL, or JSON").option("--start-date <date>", "Start date (ISO string, default: 7 days ago)").option("--end-date <date>", "End date (ISO string, default: now)").option("-q, --query <query>", "Text search query to filter traces").option("-f, --format <format>", "Output format: jsonl (default), csv, or json", "jsonl").option("-o, --output <file>", "Write output to file instead of stdout").option("--limit <n>", "Max traces to export (default: 1000)").action(async (options) => {
-  const { exportTracesCommand: impl } = await import("../export-SASNDV5L.mjs");
+  const { exportTracesCommand: impl } = await import("../export-KXXYJTPU.mjs");
   await impl(options);
 });
 traceCmd.command("get <traceId>").description("Get full trace details by ID").option("-f, --format <format>", "Output format: digest (default, human-readable) or json", "digest").action(async (traceId, options) => {
-  const { getTraceCommand: impl } = await import("../get-A2FFLA5X.mjs");
+  const { getTraceCommand: impl } = await import("../get-HDNIYTZY.mjs");
   await impl(traceId, options);
 });
 var scenarioCmd = program.command("scenario").description("Manage scenarios");
 scenarioCmd.command("list").description("List all scenarios in the project").option("-f, --format <format>", "Output format: table (default) or json", "table").action(async (options) => {
-  const { listScenariosCommand: impl } = await import("../list-422ZYGGM.mjs");
+  const { listScenariosCommand: impl } = await import("../list-NEYDQSPM.mjs");
   await impl(options);
 });
 scenarioCmd.command("get <id>").description("Get scenario details by ID").option("-f, --format <format>", "Output format: table (default) or json", "table").action(async (id, options) => {
-  const { getScenarioCommand: impl } = await import("../get-W6PYTHLK.mjs");
+  const { getScenarioCommand: impl } = await import("../get-REF24SE4.mjs");
   await impl(id, options);
 });
 scenarioCmd.command("create <name>").description("Create a new scenario").requiredOption("--situation <situation>", "The situation/context for the scenario").option("--criteria <criteria>", "Comma-separated list of evaluation criteria").option("--labels <labels>", "Comma-separated list of labels").option("-f, --format <format>", "Output format: table (default) or json", "table").action(async (name, options) => {
-  const { createScenarioCommand: impl } = await import("../create-O3JUSS6U.mjs");
+  const { createScenarioCommand: impl } = await import("../create-PM6I4C7T.mjs");
   await impl(name, options);
 });
 scenarioCmd.command("update <id>").description("Update an existing scenario").option("--name <name>", "New scenario name").option("--situation <situation>", "New situation/context").option("--criteria <criteria>", "New comma-separated list of criteria (replaces existing)").option("--labels <labels>", "New comma-separated list of labels (replaces existing)").option("-f, --format <format>", "Output format: table (default) or json", "table").action(async (id, options) => {
-  const { updateScenarioCommand: impl } = await import("../update-WM2VXMPJ.mjs");
+  const { updateScenarioCommand: impl } = await import("../update-HQG6R73E.mjs");
   await impl(id, options);
 });
 scenarioCmd.command("run <id>").description("Run a scenario against a target (agent or prompt)").requiredOption("--target <target>", "Target to run against, as <type>:<referenceId> (e.g., http:agent_abc123)").option("--wait", "Wait for the scenario run to complete").option("-f, --format <format>", "Output format: table (default) or json", "table").action(async (id, options) => {
-  const { runScenarioCommand: impl } = await import("../run-JDOMLKLP.mjs");
+  const { runScenarioCommand: impl } = await import("../run-BDTTVSPQ.mjs");
   await impl(id, options);
 });
 scenarioCmd.command("delete <id>").description("Archive (soft-delete) a scenario").option("-f, --format <format>", "Output format: table (default) or json", "table").action(async (id, options) => {
-  const { deleteScenarioCommand: impl } = await import("../delete-X4UDKMCL.mjs");
+  const { deleteScenarioCommand: impl } = await import("../delete-4MBVZO7R.mjs");
   await impl(id, options);
 });
 var suiteCmd = program.command("suite").description("Manage suites (run plans) \u2014 scenario \xD7 target execution plans");
 suiteCmd.command("list").description("List all suites in the project").option("-f, --format <format>", "Output format: table (default) or json", "table").action(async (options) => {
-  const { listSuitesCommand: impl } = await import("../list-PK7B4BBM.mjs");
+  const { listSuitesCommand: impl } = await import("../list-SZQX2YEG.mjs");
   await impl(options);
 });
 suiteCmd.command("get <id>").description("Get suite details by ID").option("-f, --format <format>", "Output format: table (default) or json", "table").action(async (id, options) => {
-  const { getSuiteCommand: impl } = await import("../get-ZLPB2C6P.mjs");
+  const { getSuiteCommand: impl } = await import("../get-QAEXEJFO.mjs");
   await impl(id, options);
 });
 suiteCmd.command("create <name>").description("Create a new suite (run plan)").requiredOption("--scenarios <ids>", "Comma-separated scenario IDs").requiredOption("--targets <targets...>", "Targets as <type>:<referenceId> (e.g., http:agent_abc)").option("--repeat-count <n>", "Number of times to repeat each scenario-target pair", "1").option("--labels <labels>", "Comma-separated labels").option("--description <desc>", "Suite description").option("-f, --format <format>", "Output format: table (default) or json", "table").action(async (name, options) => {
-  const { createSuiteCommand: impl } = await import("../create-K5O4F4MJ.mjs");
+  const { createSuiteCommand: impl } = await import("../create-XA6GN7IF.mjs");
   await impl(name, options);
 });
 suiteCmd.command("update <id>").description("Update a suite (run plan)").option("--name <name>", "New suite name").option("--scenarios <ids>", "New comma-separated scenario IDs").option("--targets <targets...>", "New targets as <type>:<referenceId>").option("--repeat-count <n>", "New repeat count").option("--labels <labels>", "New comma-separated labels").option("--description <desc>", "New description").option("-f, --format <format>", "Output format: table (default) or json", "table").action(async (id, options) => {
-  const { updateSuiteCommand: impl } = await import("../update-FHZ2DVRB.mjs");
+  const { updateSuiteCommand: impl } = await import("../update-VJ63FBSK.mjs");
   await impl(id, options);
 });
 suiteCmd.command("duplicate <id>").description("Duplicate a suite").option("-f, --format <format>", "Output format: table (default) or json", "table").action(async (id, options) => {
-  const { duplicateSuiteCommand: impl } = await import("../duplicate-7OV5ABPH.mjs");
+  const { duplicateSuiteCommand: impl } = await import("../duplicate-EB54YPB7.mjs");
   await impl(id, options);
 });
 suiteCmd.command("run <id>").description("Execute a suite run \u2014 schedules all scenario \xD7 target \xD7 repeat jobs").option("--wait", "Wait for the suite run to complete before returning").option("-f, --format <format>", "Output format: table (default) or json", "table").action(async (id, options) => {
-  const { runSuiteCommand: impl } = await import("../run-3A2UXVTP.mjs");
+  const { runSuiteCommand: impl } = await import("../run-EMLBSL4K.mjs");
   await impl(id, options);
 });
 suiteCmd.command("delete <id>").description("Archive (soft-delete) a suite").option("-f, --format <format>", "Output format: table (default) or json", "table").action(async (id, options) => {
-  const { deleteSuiteCommand: impl } = await import("../delete-CKSBQKE5.mjs");
+  const { deleteSuiteCommand: impl } = await import("../delete-GJR3UV2E.mjs");
   await impl(id, options);
 });
 var graphCmd = program.command("graph").description("Manage custom graphs on dashboards");
 graphCmd.command("list").description("List all custom graphs (optionally filter by dashboard)").option("--dashboard-id <id>", "Filter by dashboard ID").option("-f, --format <format>", "Output format: table (default) or json", "table").action(async (options) => {
-  const { listGraphsCommand: impl } = await import("../list-URUAIPJ7.mjs");
+  const { listGraphsCommand: impl } = await import("../list-OPRHYUVY.mjs");
   await impl(options);
 });
 graphCmd.command("get <id>").description("Get a custom graph by ID").option("-f, --format <format>", "Output format: table (default) or json", "table").action(async (id, options) => {
-  const { getGraphCommand: impl } = await import("../get-USUJHXGC.mjs");
+  const { getGraphCommand: impl } = await import("../get-7AEN3EIR.mjs");
   await impl(id, options);
 });
 graphCmd.command("create <name>").description("Create a custom graph").option("--dashboard-id <id>", "Dashboard to add the graph to").option("--graph <json>", "Graph definition as JSON").option("--filters <json>", "Filter conditions as JSON").option("--col-span <n>", "Column span (1-2)").option("--row-span <n>", "Row span (1-2)").option("-f, --format <format>", "Output format: table (default) or json", "table").action(async (name, options) => {
-  const { createGraphCommand: impl } = await import("../create-V7I5MZQH.mjs");
+  const { createGraphCommand: impl } = await import("../create-L46KYLBG.mjs");
   await impl(name, options);
 });
 graphCmd.command("update <id>").description("Update a custom graph").option("--name <name>", "New graph name").option("--graph <json>", "New graph definition as JSON").option("--filters <json>", "New filter conditions as JSON").option("-f, --format <format>", "Output format: table (default) or json", "table").action(async (id, options) => {
-  const { updateGraphCommand: impl } = await import("../update-XRNF3AWL.mjs");
+  const { updateGraphCommand: impl } = await import("../update-F7OARGUN.mjs");
   await impl(id, options);
 });
 graphCmd.command("delete <id>").description("Delete a custom graph").option("-f, --format <format>", "Output format: table (default) or json", "table").action(async (id, options) => {
-  const { deleteGraphCommand: impl } = await import("../delete-EFJKA2XB.mjs");
+  const { deleteGraphCommand: impl } = await import("../delete-7LN2LX6S.mjs");
   await impl(id, options);
 });
 var triggerCmd = program.command("trigger").description("Manage triggers (automations) \u2014 alerts, webhooks, and dataset actions");
 triggerCmd.command("list").description("List all triggers in the project").option("-f, --format <format>", "Output format: table (default) or json", "table").action(async (options) => {
-  const { listTriggersCommand: impl } = await import("../list-AKEZJPVQ.mjs");
+  const { listTriggersCommand: impl } = await import("../list-QFN5VXYX.mjs");
   await impl(options);
 });
 triggerCmd.command("get <id>").description("Get trigger details by ID").option("-f, --format <format>", "Output format: table (default) or json", "table").action(async (id, options) => {
-  const { getTriggerCommand: impl } = await import("../get-P6HMLM5Q.mjs");
+  const { getTriggerCommand: impl } = await import("../get-MDOZ72G7.mjs");
   await impl(id, options);
 });
 triggerCmd.command("create <name>").description("Create a new trigger (automation)").requiredOption("--action <action>", "Trigger action: SEND_EMAIL, ADD_TO_DATASET, ADD_TO_ANNOTATION_QUEUE, SEND_SLACK_MESSAGE").option("--filters <json>", "Trigger filter conditions as JSON").option("--message <text>", "Custom alert message").option("--alert-type <type>", "Alert severity: CRITICAL, WARNING, INFO").option("--slack-webhook <url>", "Slack webhook URL (for SEND_SLACK_MESSAGE action)").option("-f, --format <format>", "Output format: table (default) or json", "table").action(async (name, options) => {
-  const { createTriggerCommand: impl } = await import("../create-3L6JZRHP.mjs");
+  const { createTriggerCommand: impl } = await import("../create-M4XW6SPJ.mjs");
   await impl(name, options);
 });
 triggerCmd.command("update <id>").description("Update a trigger").option("--name <name>", "New trigger name").option("--active <boolean>", "Enable or disable the trigger (true/false)").option("--message <text>", "New alert message").option("--alert-type <type>", "New alert severity").option("-f, --format <format>", "Output format: table (default) or json", "table").action(async (id, options) => {
-  const { updateTriggerCommand: impl } = await import("../update-QVBHCTC4.mjs");
+  const { updateTriggerCommand: impl } = await import("../update-UJK2KJQ7.mjs");
   await impl(id, options);
 });
 triggerCmd.command("delete <id>").description("Delete a trigger").option("-f, --format <format>", "Output format: table (default) or json", "table").action(async (id, options) => {
-  const { deleteTriggerCommand: impl } = await import("../delete-YSQS6OG2.mjs");
+  const { deleteTriggerCommand: impl } = await import("../delete-LIXJTZDY.mjs");
   await impl(id, options);
 });
 var secretCmd = program.command("secret").description("Manage project secrets \u2014 encrypted environment variables for agents");
 secretCmd.command("list").description("List all secrets in the project (values are never shown)").option("-f, --format <format>", "Output format: table (default) or json", "table").action(async (options) => {
-  const { listSecretsCommand: impl } = await import("../list-25XQ644X.mjs");
+  const { listSecretsCommand: impl } = await import("../list-5G5SPFNM.mjs");
   await impl(options);
 });
 secretCmd.command("get <id>").description("Get secret metadata by ID (value is never shown)").option("-f, --format <format>", "Output format: table (default) or json", "table").action(async (id, options) => {
-  const { getSecretCommand: impl } = await import("../get-NUX6KUE4.mjs");
+  const { getSecretCommand: impl } = await import("../get-ZI2B4R73.mjs");
   await impl(id, options);
 });
 secretCmd.command("create <name>").description("Create a new secret (name must be UPPER_SNAKE_CASE)").requiredOption("--value <value>", "The secret value (will be encrypted)").option("-f, --format <format>", "Output format: table (default) or json", "table").action(async (name, options) => {
-  const { createSecretCommand: impl } = await import("../create-7SMTEVKG.mjs");
+  const { createSecretCommand: impl } = await import("../create-7CPKNXMZ.mjs");
   await impl(name, options);
 });
 secretCmd.command("update <id>").description("Update a secret's value").requiredOption("--value <value>", "The new secret value (will be encrypted)").option("-f, --format <format>", "Output format: table (default) or json", "table").action(async (id, options) => {
-  const { updateSecretCommand: impl } = await import("../update-WOVSATBM.mjs");
+  const { updateSecretCommand: impl } = await import("../update-A4ZZX4TW.mjs");
   await impl(id, options);
 });
 secretCmd.command("delete <id>").description("Delete a secret").option("-f, --format <format>", "Output format: table (default) or json", "table").action(async (id, options) => {
-  const { deleteSecretCommand: impl } = await import("../delete-KOIZBKC7.mjs");
+  const { deleteSecretCommand: impl } = await import("../delete-TZ5QYWQM.mjs");
   await impl(id, options);
 });
 var monitorCmd = program.command("monitor").description("Manage online evaluation monitors \u2014 evaluators running on incoming traces");
 monitorCmd.command("list").description("List all monitors in the project").option("-f, --format <format>", "Output format: table (default) or json", "table").action(async (options) => {
-  const { listMonitorsCommand: impl } = await import("../list-ZUOZWVYD.mjs");
+  const { listMonitorsCommand: impl } = await import("../list-4E6YUD3X.mjs");
   await impl(options);
 });
 monitorCmd.command("get <id>").description("Get monitor details by ID").option("-f, --format <format>", "Output format: table (default) or json", "table").action(async (id, options) => {
-  const { getMonitorCommand: impl } = await import("../get-5AXW735G.mjs");
+  const { getMonitorCommand: impl } = await import("../get-WPZLVTPC.mjs");
   await impl(id, options);
 });
 monitorCmd.command("create <name>").description("Create a new online evaluation monitor").requiredOption("--check-type <type>", "Evaluator check type (e.g. ragas/toxicity, custom/my-eval)").option("--execution-mode <mode>", "Execution mode: ON_MESSAGE (default), AS_GUARDRAIL, MANUALLY", "ON_MESSAGE").option("--sample <rate>", "Sampling rate 0.0-1.0 (default: 1.0)").option("--evaluator-id <id>", "Link to a saved evaluator").option("--level <level>", "Evaluation level: trace (default) or thread").option("--parameters <json>", "Evaluator settings as JSON").option("-f, --format <format>", "Output format: table (default) or json", "table").action(async (name, options) => {
-  const { createMonitorCommand: impl } = await import("../create-4FZA3Q5Z.mjs");
+  const { createMonitorCommand: impl } = await import("../create-NCOXUSMQ.mjs");
   await impl(name, options);
 });
 monitorCmd.command("update <id>").description("Update a monitor").option("--name <name>", "New monitor name").option("--enabled <boolean>", "Enable or disable the monitor (true/false)").option("--execution-mode <mode>", "Execution mode: ON_MESSAGE, AS_GUARDRAIL, MANUALLY").option("--sample <rate>", "Sampling rate 0.0-1.0").option("--parameters <json>", "Updated evaluator settings as JSON").option("-f, --format <format>", "Output format: table (default) or json", "table").action(async (id, options) => {
-  const { updateMonitorCommand: impl } = await import("../update-TIAR7QGJ.mjs");
+  const { updateMonitorCommand: impl } = await import("../update-JCEVPGGP.mjs");
   await impl(id, options);
 });
 monitorCmd.command("delete <id>").description("Delete a monitor").option("-f, --format <format>", "Output format: table (default) or json", "table").action(async (id, options) => {
-  const { deleteMonitorCommand: impl } = await import("../delete-5GJ24SOX.mjs");
+  const { deleteMonitorCommand: impl } = await import("../delete-F4DUHDEW.mjs");
   await impl(id, options);
 });
 var simulationRunCmd = program.command("simulation-run").description("View simulation run results");
 simulationRunCmd.command("list").description("List simulation runs (optionally filter by scenario set or batch)").option("--scenario-set-id <id>", "Filter by scenario set ID").option("--batch-run-id <id>", "Filter by batch run ID (requires --scenario-set-id)").option("--status <status>", "Filter by status (e.g. SUCCESS, FAILED, ERROR, IN_PROGRESS)").option("--name <substring>", "Filter by run name substring (case-insensitive)").option("--limit <n>", "Max results (default: 20)").option("-f, --format <format>", "Output format: table (default) or json", "table").action(async (options) => {
-  const { listSimulationRunsCommand: impl } = await import("../list-Y63426YQ.mjs");
+  const { listSimulationRunsCommand: impl } = await import("../list-YWEY3VNW.mjs");
   await impl(options);
 });
 simulationRunCmd.command("get <runId>").description("Get full details of a simulation run (messages, results, costs)").option("--full", "Show full message content instead of truncating long lines").option("-f, --format <format>", "Output format: table (default) or json", "table").action(async (runId, options) => {
-  const { getSimulationRunCommand: impl } = await import("../get-FTY7OHAJ.mjs");
+  const { getSimulationRunCommand: impl } = await import("../get-RHUT3PZR.mjs");
   await impl(runId, options);
 });
 var datasetCmd = program.command("dataset").description("Manage datasets");
 datasetCmd.command("list").description("List all datasets").option("-f, --format <format>", "Output format: table (default) or json", "table").action(async (options) => {
-  const { listCommand: listDatasetsImpl } = await import("../list-NF2VPZII.mjs");
+  const { listCommand: listDatasetsImpl } = await import("../list-X664TBW6.mjs");
   await listDatasetsImpl(options);
 });
 datasetCmd.command("create <name>").description("Create a new dataset").option("-c, --columns <columns>", "Column definitions (e.g. input:string,output:string)").option("-f, --format <format>", "Output format: table (default) or json", "table").action(async (name, options) => {
-  const { createCommand: createDatasetImpl } = await import("../create-ONRE7BVU.mjs");
+  const { createCommand: createDatasetImpl } = await import("../create-YWCBEGUP.mjs");
   await createDatasetImpl(name, options);
 });
 datasetCmd.command("get <slugOrId>").description("Get dataset details and preview records").option("-f, --format <format>", "Output format: table (default) or json", "table").action(async (slugOrId, options) => {
-  const { getCommand: getDatasetImpl } = await import("../get-7EOUTEVW.mjs");
+  const { getCommand: getDatasetImpl } = await import("../get-RZRPAZ5J.mjs");
   await getDatasetImpl(slugOrId, options);
 });
 datasetCmd.command("delete <slugOrId>").description("Delete (archive) a dataset").option("-f, --format <format>", "Output format: table (default) or json", "table").action(async (slugOrId, options) => {
-  const { deleteCommand: deleteDatasetImpl } = await import("../delete-FBNVDBFA.mjs");
+  const { deleteCommand: deleteDatasetImpl } = await import("../delete-ZXD6F6GH.mjs");
   await deleteDatasetImpl(slugOrId, options);
 });
 datasetCmd.command("upload <slug> <file>").description("Upload a file to a dataset (creates if not found)").option("--if-exists <strategy>", "Strategy when dataset exists: append (default), replace, error").action(async (slug, file, options) => {
-  const { uploadCommand: uploadDatasetImpl } = await import("../upload-D45XX4PT.mjs");
+  const { uploadCommand: uploadDatasetImpl } = await import("../upload-DNND4YCX.mjs");
   await uploadDatasetImpl(slug, file, options);
 });
 datasetCmd.command("download <slugOrId>").description("Download dataset records as CSV or JSONL").option("-f, --format <format>", "Output format: csv or jsonl", "csv").action(async (slugOrId, options) => {
-  const { downloadCommand: downloadDatasetImpl } = await import("../download-F354BSIZ.mjs");
+  const { downloadCommand: downloadDatasetImpl } = await import("../download-H23O5O3X.mjs");
   await downloadDatasetImpl(slugOrId, options);
 });
 datasetCmd.command("update <slugOrId>").description("Update a dataset name or columns").option("--name <name>", "New dataset name").option("--columns <columns>", "New column definitions (e.g. input:string,output:string)").option("-f, --format <format>", "Output format: table (default) or json", "table").action(async (slugOrId, options) => {
-  const { updateCommand: updateDatasetImpl } = await import("../update-5X2C6ERA.mjs");
+  const { updateCommand: updateDatasetImpl } = await import("../update-PJ6GMMIK.mjs");
   await updateDatasetImpl(slugOrId, options);
 });
 var recordsCmd = datasetCmd.command("records").description("Manage dataset records");
 recordsCmd.command("list <slugOrId>").description("List records in a dataset").option("--page <n>", "Page number (default: 1)").option("--limit <n>", "Records per page (default: 20)").option("-f, --format <format>", "Output format: table (default) or json", "table").action(async (slugOrId, options) => {
-  const { recordsListCommand } = await import("../records-list-6MRQEEFW.mjs");
+  const { recordsListCommand } = await import("../records-list-VT3CTM5S.mjs");
   await recordsListCommand(slugOrId, options);
 });
 recordsCmd.command("add <slugOrId>").description("Add records to a dataset").option("--json <json>", "JSON array of records (inline)").option("--file <path>", "Read JSON array of records from a file").option("--stdin", "Read JSON array from stdin").action(async (slugOrId, options) => {
-  const { recordsAddCommand } = await import("../records-add-PVWEVBU3.mjs");
+  const { recordsAddCommand } = await import("../records-add-LHL6YBOK.mjs");
   await recordsAddCommand(slugOrId, options);
 });
 recordsCmd.command("update <slugOrId> <recordId>").description("Update a single record in a dataset").requiredOption("--json <json>", "JSON object with updated fields").action(async (slugOrId, recordId, options) => {
-  const { recordsUpdateCommand } = await import("../records-update-3SRICHV3.mjs");
+  const { recordsUpdateCommand } = await import("../records-update-OFFWG6GP.mjs");
   await recordsUpdateCommand(slugOrId, recordId, options);
 });
 recordsCmd.command("delete <slugOrId> <recordIds...>").description("Delete records from a dataset").action(async (slugOrId, recordIds) => {
-  const { recordsDeleteCommand } = await import("../records-delete-OE5ZB6B2.mjs");
+  const { recordsDeleteCommand } = await import("../records-delete-YBEWFWHP.mjs");
   await recordsDeleteCommand(slugOrId, recordIds);
 });
+var projectsCmd = program.command("projects").description("Manage organization projects");
+projectsCmd.command("list").description("List all projects in the organization").option("--page <page>", "Page number", "1").option("--limit <limit>", "Items per page", "50").option("-f, --format <format>", "Output format: table (default) or json", "table").action(async (options) => {
+  const { listProjectsCommand: impl } = await import("../list-7FA4HYSW.mjs");
+  await impl({
+    page: options.page ? Number(options.page) : void 0,
+    limit: options.limit ? Number(options.limit) : void 0,
+    format: options.format
+  });
+});
+projectsCmd.command("get <id>").description("Show details for a project").option("-f, --format <format>", "Output format: text (default) or json", "text").action(async (id, options) => {
+  const { getProjectCommand: impl } = await import("../get-AOIBMSZP.mjs");
+  await impl(id, options);
+});
+projectsCmd.command("create").description("Create a new project (returns a one-time service API key)").requiredOption("--name <name>", "Project name").requiredOption("--language <lang>", "Programming language (e.g. python, typescript)").requiredOption("--framework <fw>", "Framework (e.g. langchain, openai, vercel-ai)").option("--team-id <id>", "Existing team ID to assign the project to").option("--new-team-name <name>", "Create a new team with this name").option("-f, --format <format>", "Output format: text (default) or json", "text").action(async (options) => {
+  const { createProjectCommand: impl } = await import("../create-J7D7TF24.mjs");
+  await impl(options);
+});
+projectsCmd.command("update <id>").description("Update a project's metadata").option("--name <name>", "New project name").option("--language <lang>", "New language").option("--framework <fw>", "New framework").option("--pii-redaction-level <level>", "PII redaction: STRICT, ESSENTIAL, or DISABLED").option("-f, --format <format>", "Output format: text (default) or json", "text").action(async (id, options) => {
+  const { updateProjectCommand: impl } = await import("../update-AJERVKOF.mjs");
+  await impl(id, options);
+});
+projectsCmd.command("delete <id>").description("Archive a project (soft-delete)").option("-f, --format <format>", "Output format: text (default) or json", "text").action(async (id, options) => {
+  const { deleteProjectCommand: impl } = await import("../delete-NYQXHJYH.mjs");
+  await impl(id, options);
+});
+var apiKeysCmd = program.command("api-keys").description("Manage organization API keys");
+apiKeysCmd.command("list").description("List all API keys in the organization").option("-f, --format <format>", "Output format: table (default) or json", "table").action(async (options) => {
+  const { listApiKeysCommand: impl } = await import("../list-BKJVXJOJ.mjs");
+  await impl(options);
+});
+apiKeysCmd.command("create").description("Create a new API key (token is shown once)").requiredOption("--name <name>", "Human-readable name for the key").option("--key-type <type>", "Key type: personal or service", "service").option("--description <desc>", "Optional description").option("--expires-at <date>", "Expiration date (ISO 8601)").option("--project-id <id...>", "Project IDs to scope the key to (service keys only, repeatable)").option("-f, --format <format>", "Output format: text (default) or json", "text").action(async (options) => {
+  const { createApiKeyCommand: impl } = await import("../create-TLGM2IT3.mjs");
+  await impl(options);
+});
+apiKeysCmd.command("revoke <id>").description("Revoke an API key (cannot be reactivated)").option("-f, --format <format>", "Output format: text (default) or json", "text").action(async (id, options) => {
+  const { revokeApiKeyCommand: impl } = await import("../revoke-EMI3JKYB.mjs");
+  await impl(id, options);
+});
 program.parse(process.argv);
 //# sourceMappingURL=index.mjs.map