@verial-ai/sdk 0.1.0

package/dist/cli/index.js

@@ -0,0 +1,882 @@
+#!/usr/bin/env node
+
+// src/cli/index.ts
+import { Command as Command13 } from "commander";
+
+// src/cli/commands/auth.ts
+import { Command } from "commander";
+
+// src/cli/config.ts
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+var CONFIG_DIR = path.join(os.homedir(), ".verial");
+var CONFIG_PATH = path.join(CONFIG_DIR, "config.json");
+function readConfig() {
+  if (!fs.existsSync(CONFIG_PATH)) return {};
+  const raw = fs.readFileSync(CONFIG_PATH, "utf-8");
+  return JSON.parse(raw);
+}
+function writeConfig(config) {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+  fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), "utf-8");
+}
+function getApiKey() {
+  return process.env.VERIAL_API_KEY ?? readConfig().apiKey;
+}
+function getBaseUrl() {
+  return process.env.VERIAL_API_URL ?? readConfig().baseUrl ?? "https://api.verial.ai";
+}
+
+// src/cli/commands/auth.ts
+var authCommand = new Command("auth").description(
+  "Manage authentication"
+);
+authCommand.command("set-key <key>").description("Store API key in ~/.verial/config.json").action((key) => {
+  writeConfig({ apiKey: key });
+  console.log("API key saved.");
+});
+authCommand.command("status").description("Check if API key is configured").action(() => {
+  const key = getApiKey();
+  if (key) {
+    console.log(
+      `Authenticated (key: ${key.slice(0, 8)}...${key.slice(-4)})`
+    );
+  } else {
+    console.log("No API key configured. Run: verial auth set-key <key>");
+    process.exitCode = 1;
+  }
+});
+
+// src/cli/commands/benchmarks.ts
+import { Command as Command2 } from "commander";
+
+// src/cli/format.ts
+function output(data, json) {
+  console.log(JSON.stringify(data, null, json || !process.stdout.isTTY ? 2 : 2));
+}
+
+// src/errors.ts
+var VerialError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "VerialError";
+  }
+};
+var VerialApiError = class extends VerialError {
+  status;
+  code;
+  details;
+  constructor(status, code, message, details) {
+    super(message);
+    this.name = "VerialApiError";
+    this.status = status;
+    this.code = code;
+    this.details = details;
+  }
+};
+
+// src/client.ts
+var VerialClient = class {
+  baseUrl;
+  apiKey;
+  constructor(config) {
+    if (!config.apiKey) {
+      throw new VerialError("API key is required");
+    }
+    this.apiKey = config.apiKey;
+    this.baseUrl = config.baseUrl ?? "https://api.verial.ai";
+  }
+  async get(path2, query) {
+    return this.request("GET", path2, void 0, query);
+  }
+  async post(path2, body) {
+    return this.request("POST", path2, body);
+  }
+  async patch(path2, body) {
+    return this.request("PATCH", path2, body);
+  }
+  async delete(path2) {
+    return this.request("DELETE", path2);
+  }
+  async request(method, path2, body, query) {
+    let url = `${this.baseUrl}${path2}`;
+    if (query) {
+      const params = new URLSearchParams();
+      for (const [k, v] of Object.entries(query)) {
+        if (v !== void 0) params.set(k, v);
+      }
+      const qs = params.toString();
+      if (qs) url += `?${qs}`;
+    }
+    const headers = {
+      Authorization: `Bearer ${this.apiKey}`,
+      "Content-Type": "application/json"
+    };
+    const res = await fetch(url, {
+      method,
+      headers,
+      body: body ? JSON.stringify(body) : void 0
+    });
+    if (!res.ok) {
+      const err = await res.json().catch(() => ({}));
+      throw new VerialApiError(
+        res.status,
+        err.code ?? "UNKNOWN",
+        err.error ?? res.statusText,
+        err.details
+      );
+    }
+    return res.json();
+  }
+};
+
+// src/resources/benchmarks.ts
+var Benchmarks = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async list(options = {}) {
+    return this.client.get("/benchmarks", {
+      cursor: options.cursor,
+      limit: options.limit?.toString()
+    });
+  }
+  async create(options) {
+    return this.client.post("/benchmarks", {
+      name: options.name,
+      environment_id: options.environmentId,
+      timeout: options.timeout,
+      concurrency: options.concurrency
+    });
+  }
+  async get(options) {
+    return this.client.get(`/benchmarks/${options.id}`);
+  }
+  async update(options) {
+    const { id, ...body } = options;
+    return this.client.patch(`/benchmarks/${id}`, body);
+  }
+  async delete(options) {
+    return this.client.delete(`/benchmarks/${options.id}`);
+  }
+};
+
+// src/resources/datasets.ts
+var Datasets = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async list(options = {}) {
+    return this.client.get("/datasets", {
+      cursor: options.cursor,
+      limit: options.limit?.toString()
+    });
+  }
+  async create(options) {
+    return this.client.post("/datasets", options);
+  }
+  async get(options) {
+    return this.client.get(`/datasets/${options.id}`);
+  }
+  async update(options) {
+    const { id, ...body } = options;
+    return this.client.patch(`/datasets/${id}`, body);
+  }
+  async delete(options) {
+    return this.client.delete(`/datasets/${options.id}`);
+  }
+  async generate(options) {
+    return this.client.post(`/datasets/${options.id}/generate`, {
+      prompt: options.prompt
+    });
+  }
+};
+
+// src/resources/environments.ts
+var Environments = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async list(options = {}) {
+    return this.client.get("/environments", {
+      cursor: options.cursor,
+      limit: options.limit?.toString()
+    });
+  }
+  async create(options) {
+    return this.client.post("/environments", {
+      name: options.name,
+      template_id: options.templateId
+    });
+  }
+  async get(options) {
+    return this.client.get(`/environments/${options.id}`);
+  }
+  async update(options) {
+    const { id, ...body } = options;
+    return this.client.patch(`/environments/${id}`, body);
+  }
+  async delete(options) {
+    return this.client.delete(`/environments/${options.id}`);
+  }
+  async addSimulator(options) {
+    return this.client.post(
+      `/environments/${options.environmentId}/simulators/${options.simulatorId}`
+    );
+  }
+  async removeSimulator(options) {
+    return this.client.delete(
+      `/environments/${options.environmentId}/simulators/${options.simulatorId}`
+    );
+  }
+};
+
+// src/resources/eval-runs.ts
+var EvalRuns = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async list(options) {
+    return this.client.get("/eval-runs", {
+      taskRunId: options.taskRunId,
+      cursor: options.cursor,
+      limit: options.limit?.toString()
+    });
+  }
+  async get(options) {
+    return this.client.get(`/eval-runs/${options.id}`);
+  }
+};
+
+// src/resources/evals.ts
+var Evals = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async list(options) {
+    return this.client.get("/evals", {
+      taskId: options.taskId,
+      cursor: options.cursor,
+      limit: options.limit?.toString()
+    });
+  }
+  async create(options) {
+    return this.client.post("/evals", {
+      task_id: options.taskId,
+      label: options.label,
+      assert: options.assert,
+      weight: options.weight
+    });
+  }
+  async get(options) {
+    return this.client.get(`/evals/${options.id}`);
+  }
+  async update(options) {
+    const { id, ...body } = options;
+    return this.client.patch(`/evals/${id}`, body);
+  }
+  async delete(options) {
+    return this.client.delete(`/evals/${options.id}`);
+  }
+};
+
+// src/resources/playgrounds.ts
+var Playgrounds = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async list(options = {}) {
+    return this.client.get("/playgrounds", {
+      cursor: options.cursor,
+      limit: options.limit?.toString()
+    });
+  }
+  async create(options) {
+    return this.client.post("/playgrounds", {
+      environment_id: options.environmentId
+    });
+  }
+  async get(options) {
+    return this.client.get(`/playgrounds/${options.id}`);
+  }
+  async teardown(options) {
+    return this.client.post(`/playgrounds/${options.id}/teardown`);
+  }
+};
+
+// src/resources/runs.ts
+var Runs = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async list(options = {}) {
+    return this.client.get("/runs", {
+      cursor: options.cursor,
+      limit: options.limit?.toString()
+    });
+  }
+  async create(options) {
+    return this.client.post("/runs", {
+      benchmark_id: options.benchmarkId
+    });
+  }
+  async get(options) {
+    return this.client.get(`/runs/${options.id}`);
+  }
+  async complete(options) {
+    return this.client.post(`/runs/${options.id}/complete`);
+  }
+  async cancel(options) {
+    return this.client.post(`/runs/${options.id}/cancel`);
+  }
+};
+
+// src/resources/sandboxes.ts
+var Sandboxes = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async list(options = {}) {
+    return this.client.get("/sandboxes", {
+      playgroundId: options.playgroundId,
+      cursor: options.cursor,
+      limit: options.limit?.toString()
+    });
+  }
+  async create(options) {
+    return this.client.post("/sandboxes", {
+      simulator_id: options.simulatorId
+    });
+  }
+  async get(options) {
+    return this.client.get(`/sandboxes/${options.id}`);
+  }
+  async listEvents(options) {
+    return this.client.get(`/sandboxes/${options.id}/events`, {
+      cursor: options.cursor,
+      limit: options.limit?.toString()
+    });
+  }
+  async teardown(options) {
+    return this.client.post(`/sandboxes/${options.id}/teardown`);
+  }
+  async addDataset(options) {
+    return this.client.post(
+      `/sandboxes/${options.sandboxId}/datasets/${options.datasetId}`
+    );
+  }
+  async removeDataset(options) {
+    return this.client.delete(
+      `/sandboxes/${options.sandboxId}/datasets/${options.datasetId}`
+    );
+  }
+};
+
+// src/resources/simulators.ts
+var Simulators = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async list(options = {}) {
+    return this.client.get("/simulators", {
+      environmentId: options.environmentId,
+      cursor: options.cursor,
+      limit: options.limit?.toString()
+    });
+  }
+  async create(options) {
+    return this.client.post("/simulators", options);
+  }
+  async get(options) {
+    return this.client.get(`/simulators/${options.id}`);
+  }
+  async update(options) {
+    const { id, ...body } = options;
+    return this.client.patch(`/simulators/${id}`, body);
+  }
+  async delete(options) {
+    return this.client.delete(`/simulators/${options.id}`);
+  }
+  async generateConfig(options) {
+    return this.client.post(`/simulators/${options.id}/config/generate`, {
+      prompt: options.prompt
+    });
+  }
+  async generateData(options) {
+    return this.client.post(`/simulators/${options.id}/data/generate`, {
+      seed: options.seed
+    });
+  }
+};
+
+// src/resources/task-runs.ts
+var TaskRuns = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async list(options) {
+    return this.client.get("/task-runs", {
+      runId: options.runId,
+      cursor: options.cursor,
+      limit: options.limit?.toString()
+    });
+  }
+  async get(options) {
+    return this.client.get(`/task-runs/${options.id}`);
+  }
+  async complete(options) {
+    return this.client.post(`/task-runs/${options.id}/complete`);
+  }
+  async cancel(options) {
+    return this.client.post(`/task-runs/${options.id}/cancel`);
+  }
+};
+
+// src/resources/tasks.ts
+var Tasks = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async list(options) {
+    return this.client.get("/tasks", {
+      benchmarkId: options.benchmarkId,
+      cursor: options.cursor,
+      limit: options.limit?.toString()
+    });
+  }
+  async create(options) {
+    return this.client.post("/tasks", {
+      benchmark_id: options.benchmarkId,
+      name: options.name,
+      instruction: options.instruction,
+      timeout: options.timeout,
+      trigger: options.trigger,
+      tags: options.tags
+    });
+  }
+  async get(options) {
+    return this.client.get(`/tasks/${options.id}`);
+  }
+  async update(options) {
+    const { id, ...body } = options;
+    return this.client.patch(`/tasks/${id}`, body);
+  }
+  async delete(options) {
+    return this.client.delete(`/tasks/${options.id}`);
+  }
+};
+
+// src/index.ts
+var Verial = class {
+  environments;
+  simulators;
+  datasets;
+  benchmarks;
+  tasks;
+  evals;
+  playgrounds;
+  sandboxes;
+  runs;
+  taskRuns;
+  evalRuns;
+  constructor(config) {
+    const client = new VerialClient(config);
+    this.environments = new Environments(client);
+    this.simulators = new Simulators(client);
+    this.datasets = new Datasets(client);
+    this.benchmarks = new Benchmarks(client);
+    this.tasks = new Tasks(client);
+    this.evals = new Evals(client);
+    this.playgrounds = new Playgrounds(client);
+    this.sandboxes = new Sandboxes(client);
+    this.runs = new Runs(client);
+    this.taskRuns = new TaskRuns(client);
+    this.evalRuns = new EvalRuns(client);
+  }
+};
+
+// src/cli/commands/helpers.ts
+function getClient() {
+  const apiKey = getApiKey();
+  if (!apiKey) {
+    console.error("No API key. Run: verial auth set-key <key>");
+    process.exit(1);
+  }
+  return new Verial({ apiKey, baseUrl: getBaseUrl() });
+}
+
+// src/cli/commands/benchmarks.ts
+var benchmarksCommand = new Command2("benchmarks").description(
+  "Manage benchmarks"
+);
+benchmarksCommand.command("list").option("--json", "Output as JSON").action(async (opts) => {
+  const result = await getClient().benchmarks.list();
+  output(result, opts.json);
+});
+benchmarksCommand.command("create").requiredOption("--name <name>", "Benchmark name").requiredOption("--environment-id <id>", "Environment ID").option("--timeout <seconds>", "Task timeout", parseInt).option("--concurrency <n>", "Max parallel tasks", parseInt).option("--json", "Output as JSON").action(async (opts) => {
+  const result = await getClient().benchmarks.create({
+    name: opts.name,
+    environmentId: opts.environmentId,
+    timeout: opts.timeout,
+    concurrency: opts.concurrency
+  });
+  output(result, opts.json);
+});
+benchmarksCommand.command("get").requiredOption("--id <id>", "Benchmark ID").option("--json", "Output as JSON").action(async (opts) => {
+  const result = await getClient().benchmarks.get({ id: opts.id });
+  output(result, opts.json);
+});
+benchmarksCommand.command("delete").requiredOption("--id <id>", "Benchmark ID").option("--json", "Output as JSON").action(async (opts) => {
+  const result = await getClient().benchmarks.delete({ id: opts.id });
+  output(result, opts.json);
+});
+
+// src/cli/commands/datasets.ts
+import { Command as Command3 } from "commander";
+var datasetsCommand = new Command3("datasets").description(
+  "Manage datasets"
+);
+datasetsCommand.command("list").option("--json", "Output as JSON").action(async (opts) => {
+  const result = await getClient().datasets.list();
+  output(result, opts.json);
+});
+datasetsCommand.command("create").requiredOption("--name <name>", "Dataset name").option("--json", "Output as JSON").action(async (opts) => {
+  const result = await getClient().datasets.create({ name: opts.name });
+  output(result, opts.json);
+});
+datasetsCommand.command("get").requiredOption("--id <id>", "Dataset ID").option("--json", "Output as JSON").action(async (opts) => {
+  const result = await getClient().datasets.get({ id: opts.id });
+  output(result, opts.json);
+});
+datasetsCommand.command("delete").requiredOption("--id <id>", "Dataset ID").option("--json", "Output as JSON").action(async (opts) => {
+  const result = await getClient().datasets.delete({ id: opts.id });
+  output(result, opts.json);
+});
+datasetsCommand.command("generate").requiredOption("--id <id>", "Dataset ID").requiredOption("--prompt <prompt>", "Natural language prompt").option("--json", "Output as JSON").action(async (opts) => {
+  const result = await getClient().datasets.generate({
+    id: opts.id,
+    prompt: opts.prompt
+  });
+  output(result, opts.json);
+});
+
+// src/cli/commands/environments.ts
+import { Command as Command4 } from "commander";
+var environmentsCommand = new Command4("environments").description(
+  "Manage environments"
+);
+environmentsCommand.command("list").option("--json", "Output as JSON").action(async (opts) => {
+  const result = await getClient().environments.list();
+  output(result, opts.json);
+});
+environmentsCommand.command("create").requiredOption("--name <name>", "Environment name").option("--template-id <id>", "Template ID").option("--json", "Output as JSON").action(async (opts) => {
+  const result = await getClient().environments.create({
+    name: opts.name,
+    templateId: opts.templateId
+  });
+  output(result, opts.json);
+});
+environmentsCommand.command("get").requiredOption("--id <id>", "Environment ID").option("--json", "Output as JSON").action(async (opts) => {
+  const result = await getClient().environments.get({ id: opts.id });
+  output(result, opts.json);
+});
+environmentsCommand.command("update").requiredOption("--id <id>", "Environment ID").option("--name <name>", "New name").option("--description <desc>", "New description").option("--json", "Output as JSON").action(async (opts) => {
+  const result = await getClient().environments.update({
+    id: opts.id,
+    name: opts.name,
+    description: opts.description
+  });
+  output(result, opts.json);
+});
+environmentsCommand.command("delete").requiredOption("--id <id>", "Environment ID").option("--json", "Output as JSON").action(async (opts) => {
+  const result = await getClient().environments.delete({ id: opts.id });
+  output(result, opts.json);
+});
+environmentsCommand.command("add-simulator").requiredOption("--environment-id <id>", "Environment ID").requiredOption("--simulator-id <id>", "Simulator ID").option("--json", "Output as JSON").action(async (opts) => {
+  const result = await getClient().environments.addSimulator({
+    environmentId: opts.environmentId,
+    simulatorId: opts.simulatorId
+  });
+  output(result, opts.json);
+});
+environmentsCommand.command("remove-simulator").requiredOption("--environment-id <id>", "Environment ID").requiredOption("--simulator-id <id>", "Simulator ID").option("--json", "Output as JSON").action(async (opts) => {
+  const result = await getClient().environments.removeSimulator({
+    environmentId: opts.environmentId,
+    simulatorId: opts.simulatorId
+  });
+  output(result, opts.json);
+});
+
+// src/cli/commands/eval-runs.ts
+import { Command as Command5 } from "commander";
+var evalRunsCommand = new Command5("eval-runs").description(
+  "View eval runs"
+);
+evalRunsCommand.command("list").requiredOption("--task-run-id <id>", "Task run ID").option("--json", "Output as JSON").action(async (opts) => {
+  const result = await getClient().evalRuns.list({
+    taskRunId: opts.taskRunId
+  });
+  output(result, opts.json);
+});
+evalRunsCommand.command("get").requiredOption("--id <id>", "Eval run ID").option("--json", "Output as JSON").action(async (opts) => {
+  const result = await getClient().evalRuns.get({ id: opts.id });
+  output(result, opts.json);
+});
+
+// src/cli/commands/evals.ts
+import { Command as Command6 } from "commander";
+var evalsCommand = new Command6("evals").description("Manage evals");
+evalsCommand.command("list").requiredOption("--task-id <id>", "Task ID").option("--json", "Output as JSON").action(async (opts) => {
+  const result = await getClient().evals.list({ taskId: opts.taskId });
+  output(result, opts.json);
+});
+evalsCommand.command("create").requiredOption("--task-id <id>", "Task ID").requiredOption("--label <label>", "Eval label").requiredOption("--assert <assert>", "Assertion criteria").option("--weight <n>", "Score weight", parseFloat).option("--json", "Output as JSON").action(async (opts) => {
+  const result = await getClient().evals.create({
+    taskId: opts.taskId,
+    label: opts.label,
+    assert: opts.assert,
+    weight: opts.weight
+  });
+  output(result, opts.json);
+});
+evalsCommand.command("get").requiredOption("--id <id>", "Eval ID").option("--json", "Output as JSON").action(async (opts) => {
+  const result = await getClient().evals.get({ id: opts.id });
+  output(result, opts.json);
+});
+evalsCommand.command("delete").requiredOption("--id <id>", "Eval ID").option("--json", "Output as JSON").action(async (opts) => {
+  const result = await getClient().evals.delete({ id: opts.id });
+  output(result, opts.json);
+});
+
+// src/cli/commands/playgrounds.ts
+import { Command as Command7 } from "commander";
+var playgroundsCommand = new Command7("playgrounds").description(
+  "Manage playgrounds"
+);
+playgroundsCommand.command("list").option("--json", "Output as JSON").action(async (opts) => {
+  const result = await getClient().playgrounds.list();
+  output(result, opts.json);
+});
+playgroundsCommand.command("create").requiredOption("--environment-id <id>", "Environment ID").option("--json", "Output as JSON").action(async (opts) => {
+  const result = await getClient().playgrounds.create({
+    environmentId: opts.environmentId
+  });
+  output(result, opts.json);
+});
+playgroundsCommand.command("get").requiredOption("--id <id>", "Playground ID").option("--json", "Output as JSON").action(async (opts) => {
+  const result = await getClient().playgrounds.get({ id: opts.id });
+  output(result, opts.json);
+});
+playgroundsCommand.command("teardown").requiredOption("--id <id>", "Playground ID").option("--json", "Output as JSON").action(async (opts) => {
+  const result = await getClient().playgrounds.teardown({ id: opts.id });
+  output(result, opts.json);
+});
+
+// src/cli/commands/runs.ts
+import { Command as Command8 } from "commander";
+var runsCommand = new Command8("runs").description(
+  "Manage benchmark runs"
+);
+runsCommand.command("list").option("--json", "Output as JSON").action(async (opts) => {
+  const result = await getClient().runs.list();
+  output(result, opts.json);
+});
+runsCommand.command("create").requiredOption("--benchmark-id <id>", "Benchmark ID").option("--json", "Output as JSON").action(async (opts) => {
+  const result = await getClient().runs.create({
+    benchmarkId: opts.benchmarkId
+  });
+  output(result, opts.json);
+});
+runsCommand.command("get").requiredOption("--id <id>", "Run ID").option("--json", "Output as JSON").action(async (opts) => {
+  const result = await getClient().runs.get({ id: opts.id });
+  output(result, opts.json);
+});
+runsCommand.command("complete").requiredOption("--id <id>", "Run ID").option("--json", "Output as JSON").action(async (opts) => {
+  const result = await getClient().runs.complete({ id: opts.id });
+  output(result, opts.json);
+});
+runsCommand.command("cancel").requiredOption("--id <id>", "Run ID").option("--json", "Output as JSON").action(async (opts) => {
+  const result = await getClient().runs.cancel({ id: opts.id });
+  output(result, opts.json);
+});
+runsCommand.command("wait").requiredOption("--id <id>", "Run ID").option("--interval <seconds>", "Poll interval", "5").option("--timeout <seconds>", "Max wait time", "600").option("--json", "Output as JSON").action(async (opts) => {
+  const client = getClient();
+  const interval = parseInt(opts.interval, 10) * 1e3;
+  const timeout = parseInt(opts.timeout, 10) * 1e3;
+  const start = Date.now();
+  while (Date.now() - start < timeout) {
+    const run = await client.runs.get({ id: opts.id });
+    if (run.status !== "active") {
+      output(run, opts.json);
+      process.exitCode = run.verdict === "pass" ? 0 : 1;
+      return;
+    }
+    await new Promise((r) => setTimeout(r, interval));
+  }
+  console.error("Timeout waiting for run to complete");
+  process.exitCode = 2;
+});
+
+// src/cli/commands/sandboxes.ts
+import { Command as Command9 } from "commander";
+var sandboxesCommand = new Command9("sandboxes").description(
+  "Manage sandboxes"
+);
+sandboxesCommand.command("list").option("--playground-id <id>", "Filter by playground").option("--json", "Output as JSON").action(async (opts) => {
+  const result = await getClient().sandboxes.list({
+    playgroundId: opts.playgroundId
+  });
+  output(result, opts.json);
+});
+sandboxesCommand.command("create").requiredOption("--simulator-id <id>", "Simulator ID").option("--json", "Output as JSON").action(async (opts) => {
+  const result = await getClient().sandboxes.create({
+    simulatorId: opts.simulatorId
+  });
+  output(result, opts.json);
+});
+sandboxesCommand.command("get").requiredOption("--id <id>", "Sandbox ID").option("--json", "Output as JSON").action(async (opts) => {
+  const result = await getClient().sandboxes.get({ id: opts.id });
+  output(result, opts.json);
+});
+sandboxesCommand.command("list-events").requiredOption("--id <id>", "Sandbox ID").option("--json", "Output as JSON").action(async (opts) => {
+  const result = await getClient().sandboxes.listEvents({ id: opts.id });
+  output(result, opts.json);
+});
+sandboxesCommand.command("teardown").requiredOption("--id <id>", "Sandbox ID").option("--json", "Output as JSON").action(async (opts) => {
+  const result = await getClient().sandboxes.teardown({ id: opts.id });
+  output(result, opts.json);
+});
+sandboxesCommand.command("add-dataset").requiredOption("--sandbox-id <id>", "Sandbox ID").requiredOption("--dataset-id <id>", "Dataset ID").option("--json", "Output as JSON").action(async (opts) => {
+  const result = await getClient().sandboxes.addDataset({
+    sandboxId: opts.sandboxId,
+    datasetId: opts.datasetId
+  });
+  output(result, opts.json);
+});
+sandboxesCommand.command("remove-dataset").requiredOption("--sandbox-id <id>", "Sandbox ID").requiredOption("--dataset-id <id>", "Dataset ID").option("--json", "Output as JSON").action(async (opts) => {
+  const result = await getClient().sandboxes.removeDataset({
+    sandboxId: opts.sandboxId,
+    datasetId: opts.datasetId
+  });
+  output(result, opts.json);
+});
+
+// src/cli/commands/simulators.ts
+import { Command as Command10 } from "commander";
+var simulatorsCommand = new Command10("simulators").description(
+  "Manage simulators"
+);
+simulatorsCommand.command("list").option("--environment-id <id>", "Filter by environment").option("--json", "Output as JSON").action(async (opts) => {
+  const result = await getClient().simulators.list({
+    environmentId: opts.environmentId
+  });
+  output(result, opts.json);
+});
+simulatorsCommand.command("create").requiredOption("--type <type>", "Simulator type (FHIR, HL7, Voice, etc.)").requiredOption("--name <name>", "Simulator name").option("--json", "Output as JSON").action(async (opts) => {
+  const result = await getClient().simulators.create({
+    type: opts.type,
+    name: opts.name
+  });
+  output(result, opts.json);
+});
+simulatorsCommand.command("get").requiredOption("--id <id>", "Simulator ID").option("--json", "Output as JSON").action(async (opts) => {
+  const result = await getClient().simulators.get({ id: opts.id });
+  output(result, opts.json);
+});
+simulatorsCommand.command("update").requiredOption("--id <id>", "Simulator ID").option("--name <name>", "New name").option("--json", "Output as JSON").action(async (opts) => {
+  const result = await getClient().simulators.update({
+    id: opts.id,
+    name: opts.name
+  });
+  output(result, opts.json);
+});
+simulatorsCommand.command("delete").requiredOption("--id <id>", "Simulator ID").option("--json", "Output as JSON").action(async (opts) => {
+  const result = await getClient().simulators.delete({ id: opts.id });
+  output(result, opts.json);
+});
+simulatorsCommand.command("generate-config").requiredOption("--id <id>", "Simulator ID").requiredOption("--prompt <prompt>", "Natural language prompt").option("--json", "Output as JSON").action(async (opts) => {
+  const result = await getClient().simulators.generateConfig({
+    id: opts.id,
+    prompt: opts.prompt
+  });
+  output(result, opts.json);
+});
+simulatorsCommand.command("generate-data").requiredOption("--id <id>", "Simulator ID").option("--seed <seed>", "Random seed", parseInt).option("--json", "Output as JSON").action(async (opts) => {
+  const result = await getClient().simulators.generateData({
+    id: opts.id,
+    seed: opts.seed
+  });
+  output(result, opts.json);
+});
+
+// src/cli/commands/task-runs.ts
+import { Command as Command11 } from "commander";
+var taskRunsCommand = new Command11("task-runs").description(
+  "Manage task runs"
+);
+taskRunsCommand.command("list").requiredOption("--run-id <id>", "Run ID").option("--json", "Output as JSON").action(async (opts) => {
+  const result = await getClient().taskRuns.list({ runId: opts.runId });
+  output(result, opts.json);
+});
+taskRunsCommand.command("get").requiredOption("--id <id>", "Task run ID").option("--json", "Output as JSON").action(async (opts) => {
+  const result = await getClient().taskRuns.get({ id: opts.id });
+  output(result, opts.json);
+});
+taskRunsCommand.command("complete").requiredOption("--id <id>", "Task run ID").option("--json", "Output as JSON").action(async (opts) => {
+  const result = await getClient().taskRuns.complete({ id: opts.id });
+  output(result, opts.json);
+});
+taskRunsCommand.command("cancel").requiredOption("--id <id>", "Task run ID").option("--json", "Output as JSON").action(async (opts) => {
+  const result = await getClient().taskRuns.cancel({ id: opts.id });
+  output(result, opts.json);
+});
+
+// src/cli/commands/tasks.ts
+import { Command as Command12 } from "commander";
+var tasksCommand = new Command12("tasks").description("Manage tasks");
+tasksCommand.command("list").requiredOption("--benchmark-id <id>", "Benchmark ID").option("--json", "Output as JSON").action(async (opts) => {
+  const result = await getClient().tasks.list({
+    benchmarkId: opts.benchmarkId
+  });
+  output(result, opts.json);
+});
+tasksCommand.command("create").requiredOption("--benchmark-id <id>", "Benchmark ID").requiredOption("--name <name>", "Task name").option("--instruction <text>", "Task instruction").option("--timeout <seconds>", "Task timeout", parseInt).option("--json", "Output as JSON").action(async (opts) => {
+  const result = await getClient().tasks.create({
+    benchmarkId: opts.benchmarkId,
+    name: opts.name,
+    instruction: opts.instruction,
+    timeout: opts.timeout
+  });
+  output(result, opts.json);
+});
+tasksCommand.command("get").requiredOption("--id <id>", "Task ID").option("--json", "Output as JSON").action(async (opts) => {
+  const result = await getClient().tasks.get({ id: opts.id });
+  output(result, opts.json);
+});
+tasksCommand.command("delete").requiredOption("--id <id>", "Task ID").option("--json", "Output as JSON").action(async (opts) => {
+  const result = await getClient().tasks.delete({ id: opts.id });
+  output(result, opts.json);
+});
+
+// src/cli/index.ts
+var program = new Command13().name("verial").description("Verial CLI - Healthcare agent simulation and testing").version("0.1.0");
+program.addCommand(authCommand);
+program.addCommand(environmentsCommand);
+program.addCommand(simulatorsCommand);
+program.addCommand(datasetsCommand);
+program.addCommand(benchmarksCommand);
+program.addCommand(tasksCommand);
+program.addCommand(evalsCommand);
+program.addCommand(playgroundsCommand);
+program.addCommand(sandboxesCommand);
+program.addCommand(runsCommand);
+program.addCommand(taskRunsCommand);
+program.addCommand(evalRunsCommand);
+program.parseAsync(process.argv).catch((err) => {
+  console.error(err.message);
+  process.exitCode = 2;
+});
+//# sourceMappingURL=index.js.map