@oqtopus-team/qdash-client 0.1.1

package/dist/index.js

@@ -0,0 +1,803 @@
+import {
+  QDashApiError,
+  QDashAuthError,
+  QDashClientError,
+  QDashConfigError,
+  QDashNotFoundError,
+  QDashTransportError,
+  QDashValidationError,
+  getQDashAPI
+} from "./chunk-F75WR2JX.js";
+
+// src/client.ts
+import { setTimeout as sleep2 } from "timers/promises";
+
+// src/config.ts
+import { chmod, mkdir, readFile, writeFile } from "fs/promises";
+import { homedir } from "os";
+import { dirname, join } from "path";
+import ini from "ini";
+var DEFAULT_RETRY = {
+  maxAttempts: 3,
+  baseDelaySeconds: 0.2,
+  maxDelaySeconds: 5
+};
+function optional(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function positiveNumber(value, name, fallback) {
+  if (value === void 0 || value === null || value === "") return fallback;
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    throw new QDashConfigError(`${name} must be a positive number`);
+  }
+  return parsed;
+}
+function nonNegativeNumber(value, name, fallback) {
+  if (value === void 0 || value === null || value === "") return fallback;
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed < 0) {
+    throw new QDashConfigError(`${name} must be a non-negative number`);
+  }
+  return parsed;
+}
+function booleanValue(value, name, fallback) {
+  if (value === void 0 || value === null || value === "") return fallback;
+  if (typeof value === "boolean") return value;
+  if (typeof value === "string") {
+    if (["1", "true", "yes", "on"].includes(value.toLowerCase())) return true;
+    if (["0", "false", "no", "off"].includes(value.toLowerCase())) return false;
+  }
+  throw new QDashConfigError(`${name} must be a boolean`);
+}
+function defaultConfigPath(env = process.env) {
+  return env.XDG_CONFIG_HOME ? join(env.XDG_CONFIG_HOME, "qdash", "config.ini") : join(homedir(), ".config", "qdash", "config.ini");
+}
+var QDashConfig = class _QDashConfig {
+  baseUrl;
+  username;
+  passwordEnv;
+  apiToken;
+  projectId;
+  cfAccessClientId;
+  cfAccessClientSecret;
+  timeoutSeconds;
+  verifyTls;
+  proxy;
+  userAgent;
+  retry;
+  constructor(options) {
+    const baseUrl = options.baseUrl?.replace(/\/+$/, "");
+    if (!baseUrl) throw new QDashConfigError("baseUrl is required");
+    try {
+      new URL(baseUrl);
+    } catch (cause) {
+      throw new QDashConfigError("baseUrl must be a valid URL", { cause });
+    }
+    this.baseUrl = baseUrl;
+    this.username = optional(options.username);
+    this.passwordEnv = optional(options.passwordEnv);
+    this.apiToken = optional(options.apiToken);
+    this.projectId = optional(options.projectId);
+    this.cfAccessClientId = optional(options.cfAccessClientId);
+    this.cfAccessClientSecret = optional(options.cfAccessClientSecret);
+    this.timeoutSeconds = positiveNumber(options.timeoutSeconds, "timeoutSeconds", 30);
+    this.verifyTls = options.verifyTls ?? true;
+    this.proxy = optional(options.proxy);
+    this.userAgent = optional(options.userAgent) ?? "qdash-client-ts/dev";
+    this.retry = {
+      maxAttempts: positiveNumber(
+        options.retry?.maxAttempts,
+        "retry.maxAttempts",
+        DEFAULT_RETRY.maxAttempts
+      ),
+      baseDelaySeconds: nonNegativeNumber(
+        options.retry?.baseDelaySeconds,
+        "retry.baseDelaySeconds",
+        DEFAULT_RETRY.baseDelaySeconds
+      ),
+      maxDelaySeconds: nonNegativeNumber(
+        options.retry?.maxDelaySeconds,
+        "retry.maxDelaySeconds",
+        DEFAULT_RETRY.maxDelaySeconds
+      )
+    };
+  }
+  static fromEnv(env = process.env) {
+    const baseUrl = env.QDASH_BASE_URL;
+    if (!baseUrl) {
+      throw new QDashConfigError("Environment variable QDASH_BASE_URL is required");
+    }
+    return new _QDashConfig({
+      baseUrl,
+      ...optional(env.QDASH_USERNAME) ? { username: env.QDASH_USERNAME } : {},
+      passwordEnv: env.QDASH_PASSWORD_ENV ?? "QDASH_PASSWORD",
+      ...optional(env.QDASH_API_TOKEN) ? { apiToken: env.QDASH_API_TOKEN } : {},
+      ...optional(env.QDASH_PROJECT_ID) ? { projectId: env.QDASH_PROJECT_ID } : {},
+      ...optional(env.QDASH_CF_ACCESS_CLIENT_ID) ? { cfAccessClientId: env.QDASH_CF_ACCESS_CLIENT_ID } : {},
+      ...optional(env.QDASH_CF_ACCESS_CLIENT_SECRET) ? { cfAccessClientSecret: env.QDASH_CF_ACCESS_CLIENT_SECRET } : {},
+      timeoutSeconds: positiveNumber(env.QDASH_TIMEOUT_SECONDS, "QDASH_TIMEOUT_SECONDS", 30),
+      verifyTls: booleanValue(env.QDASH_VERIFY_TLS, "QDASH_VERIFY_TLS", true),
+      ...optional(env.QDASH_PROXY) ? { proxy: env.QDASH_PROXY } : {},
+      userAgent: env.QDASH_USER_AGENT ?? "qdash-client-ts/dev",
+      retry: {
+        maxAttempts: positiveNumber(
+          env.QDASH_RETRY_MAX_ATTEMPTS,
+          "QDASH_RETRY_MAX_ATTEMPTS",
+          3
+        ),
+        baseDelaySeconds: nonNegativeNumber(
+          env.QDASH_RETRY_BACKOFF_SECONDS,
+          "QDASH_RETRY_BACKOFF_SECONDS",
+          0.2
+        ),
+        maxDelaySeconds: nonNegativeNumber(
+          env.QDASH_RETRY_MAX_BACKOFF_SECONDS,
+          "QDASH_RETRY_MAX_BACKOFF_SECONDS",
+          5
+        )
+      }
+    });
+  }
+  static async fromFile(profile = "default", path = defaultConfigPath()) {
+    let contents;
+    try {
+      contents = await readFile(path, "utf8");
+    } catch (cause) {
+      throw new QDashConfigError(`Config file not found: ${path}`, { cause });
+    }
+    const section = ini.parse(contents)[profile];
+    if (!section) throw new QDashConfigError(`Config profile not found: ${profile}`);
+    const baseUrl = optional(section.base_url);
+    if (!baseUrl) throw new QDashConfigError(`base_url is required in profile '${profile}'`);
+    return new _QDashConfig({
+      baseUrl,
+      ...optional(section.username) ? { username: String(section.username) } : {},
+      ...optional(section.password_env) ? { passwordEnv: String(section.password_env) } : {},
+      ...optional(section.api_token) ? { apiToken: String(section.api_token) } : {},
+      ...optional(section.project_id) ? { projectId: String(section.project_id) } : {},
+      ...optional(section.cf_access_client_id) ? { cfAccessClientId: String(section.cf_access_client_id) } : {},
+      ...optional(section.cf_access_client_secret) ? { cfAccessClientSecret: String(section.cf_access_client_secret) } : {},
+      timeoutSeconds: positiveNumber(
+        section.timeout_seconds ?? section.timeout_sec,
+        "timeout_seconds",
+        30
+      ),
+      verifyTls: booleanValue(section.verify_tls, "verify_tls", true),
+      ...optional(section.proxy) ? { proxy: String(section.proxy) } : {},
+      userAgent: optional(section.user_agent) ?? "qdash-client-ts/dev",
+      retry: {
+        maxAttempts: positiveNumber(section.retry_max_attempts, "retry_max_attempts", 3),
+        baseDelaySeconds: nonNegativeNumber(
+          section.retry_backoff_seconds ?? section.retry_base_delay_sec,
+          "retry_backoff_seconds",
+          0.2
+        ),
+        maxDelaySeconds: nonNegativeNumber(
+          section.retry_max_backoff_seconds ?? section.retry_max_delay_sec,
+          "retry_max_backoff_seconds",
+          5
+        )
+      }
+    });
+  }
+  async save(profile = "default", path = defaultConfigPath()) {
+    let parsed = {};
+    try {
+      parsed = ini.parse(await readFile(path, "utf8"));
+    } catch (cause) {
+      if (cause.code !== "ENOENT") throw cause;
+    }
+    parsed[profile] = {
+      base_url: this.baseUrl,
+      ...this.username ? { username: this.username } : {},
+      ...this.passwordEnv ? { password_env: this.passwordEnv } : {},
+      ...this.apiToken ? { api_token: this.apiToken } : {},
+      ...this.projectId ? { project_id: this.projectId } : {},
+      ...this.cfAccessClientId ? { cf_access_client_id: this.cfAccessClientId } : {},
+      ...this.cfAccessClientSecret ? { cf_access_client_secret: this.cfAccessClientSecret } : {},
+      timeout_seconds: this.timeoutSeconds,
+      verify_tls: this.verifyTls,
+      ...this.proxy ? { proxy: this.proxy } : {},
+      user_agent: this.userAgent,
+      retry_max_attempts: this.retry.maxAttempts,
+      retry_backoff_seconds: this.retry.baseDelaySeconds,
+      retry_max_backoff_seconds: this.retry.maxDelaySeconds
+    };
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, ini.stringify(parsed), { encoding: "utf8", mode: 384 });
+    await chmod(path, 384);
+    return path;
+  }
+};
+
+// src/transport.ts
+import { setTimeout as sleep } from "timers/promises";
+var RETRYABLE_STATUSES = /* @__PURE__ */ new Set([408, 429, 500, 502, 503, 504]);
+async function responsePayload(response) {
+  if (response.status === 204) return void 0;
+  const text = await response.text();
+  if (!text) return void 0;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+function errorMessage(response, payload) {
+  let detail;
+  if (typeof payload === "object" && payload !== null && "detail" in payload) {
+    detail = payload.detail;
+  } else if (typeof payload === "string") {
+    detail = payload;
+  }
+  const endpoint = response.url ? new URL(response.url).pathname : "<unknown>";
+  return `${response.status} ${endpoint}${detail ? `: ${String(detail)}` : ""}`;
+}
+var QDashTransport = class {
+  constructor(config, options = {}) {
+    this.config = config;
+    if ((config.proxy || !config.verifyTls) && !options.fetch) {
+      throw new QDashTransportError(
+        "proxy and verifyTls overrides require a custom fetch implementation"
+      );
+    }
+    this.baseFetch = options.fetch ?? globalThis.fetch.bind(globalThis);
+    this.defaultHeaders = new Headers(options.defaultHeaders);
+    this.sleep = options.sleep ?? ((milliseconds) => sleep(milliseconds));
+    this.random = options.random ?? Math.random;
+    this.env = options.env ?? process.env;
+    this.token = config.apiToken;
+    this.fetch = this.authorizedFetch.bind(this);
+  }
+  config;
+  fetch;
+  token;
+  baseFetch;
+  defaultHeaders;
+  sleep;
+  random;
+  env;
+  async requestJson(method, path, options = {}) {
+    return this.request({
+      method,
+      url: path,
+      params: options.query,
+      data: options.body,
+      ...options.headers ? { headers: Object.fromEntries(new Headers(options.headers).entries()) } : {}
+    });
+  }
+  async request(config) {
+    const requestUrl = config.url ?? "";
+    const url = new URL(
+      requestUrl.startsWith("http://") || requestUrl.startsWith("https://") ? requestUrl : this.config.baseUrl + (requestUrl.startsWith("/") ? "" : "/") + requestUrl
+    );
+    for (const [key, value] of Object.entries(
+      config.params ?? {}
+    )) {
+      if (value === void 0 || value === null) continue;
+      if (Array.isArray(value)) {
+        for (const item of value) url.searchParams.append(key, item);
+      } else {
+        url.searchParams.set(key, String(value));
+      }
+    }
+    const headers = new Headers(config.headers);
+    let body;
+    if (config.data !== void 0) {
+      if (typeof config.data === "string" || config.data instanceof URLSearchParams || config.data instanceof FormData || config.data instanceof Blob || config.data instanceof ArrayBuffer) {
+        body = config.data;
+      } else {
+        if (!headers.has("Content-Type")) headers.set("Content-Type", "application/json");
+        body = JSON.stringify(config.data);
+      }
+    }
+    const response = await this.fetch(url, {
+      method: config.method ?? "GET",
+      headers,
+      ...body === void 0 ? {} : { body }
+    });
+    let payload;
+    if (config.responseType === "arraybuffer") payload = await response.arrayBuffer();
+    else if (config.responseType === "blob") payload = await response.blob();
+    else if (config.responseType === "text") payload = await response.text();
+    else payload = await responsePayload(response);
+    if (!response.ok) throw this.apiError(response, payload);
+    return payload;
+  }
+  async authorizedFetch(input, init) {
+    const request = new Request(input, init);
+    const headers = new Headers(this.defaultHeaders);
+    request.headers.forEach((value, key) => headers.set(key, value));
+    headers.set("Accept", "application/json");
+    headers.set("User-Agent", this.config.userAgent);
+    headers.set("Authorization", `Bearer ${await this.getToken()}`);
+    this.setGatewayHeaders(headers);
+    const authenticated = new Request(request, { headers });
+    const retryableMethod = authenticated.method === "GET" || authenticated.method === "HEAD";
+    const attempts = retryableMethod ? this.config.retry.maxAttempts : 1;
+    for (let attempt = 1; attempt <= attempts; attempt += 1) {
+      try {
+        const response = await this.fetchWithTimeout(authenticated.clone());
+        if (response.status === 401 && !this.config.apiToken && this.config.username) {
+          this.token = void 0;
+        }
+        if (!RETRYABLE_STATUSES.has(response.status) || attempt === attempts) return response;
+        await this.sleep(this.retryDelayMilliseconds(attempt, response));
+      } catch (cause) {
+        if (cause instanceof QDashApiError) throw cause;
+        if (attempt === attempts) {
+          throw new QDashTransportError("QDash request failed", { cause });
+        }
+        await this.sleep(this.retryDelayMilliseconds(attempt));
+      }
+    }
+    throw new QDashTransportError("QDash request exhausted all retries");
+  }
+  async fetchWithTimeout(request) {
+    const timeout = AbortSignal.timeout(this.config.timeoutSeconds * 1e3);
+    const signal = request.signal.aborted ? request.signal : AbortSignal.any([request.signal, timeout]);
+    return this.baseFetch(new Request(request, { signal }));
+  }
+  async getToken() {
+    if (this.token) return this.token;
+    if (!this.config.username) {
+      throw new QDashAuthError("No authentication method configured", { statusCode: 401 });
+    }
+    const passwordEnv = this.config.passwordEnv;
+    if (!passwordEnv) {
+      throw new QDashAuthError("passwordEnv is required for username/password authentication", {
+        statusCode: 401
+      });
+    }
+    const password = this.env[passwordEnv];
+    if (!password) {
+      throw new QDashAuthError(`Missing password in environment variable ${passwordEnv}`, {
+        statusCode: 401
+      });
+    }
+    const headers = new Headers({
+      Accept: "application/json",
+      "Content-Type": "application/x-www-form-urlencoded",
+      "User-Agent": this.config.userAgent
+    });
+    this.setGatewayHeaders(headers);
+    const response = await this.baseFetch(`${this.config.baseUrl}/auth/login`, {
+      method: "POST",
+      headers,
+      body: new URLSearchParams({ username: this.config.username, password }),
+      signal: AbortSignal.timeout(this.config.timeoutSeconds * 1e3)
+    });
+    const payload = await responsePayload(response);
+    if (!response.ok) throw this.apiError(response, payload);
+    const token = typeof payload === "object" && payload !== null && "access_token" in payload ? payload.access_token : void 0;
+    if (typeof token !== "string" || !token) {
+      throw new QDashAuthError("Login response did not include access_token", {
+        statusCode: 401,
+        payload
+      });
+    }
+    this.token = token;
+    return token;
+  }
+  setGatewayHeaders(headers) {
+    if (this.config.projectId) headers.set("X-Project-Id", this.config.projectId);
+    if (this.config.cfAccessClientId) {
+      headers.set("CF-Access-Client-Id", this.config.cfAccessClientId);
+    }
+    if (this.config.cfAccessClientSecret) {
+      headers.set("CF-Access-Client-Secret", this.config.cfAccessClientSecret);
+    }
+  }
+  retryDelayMilliseconds(attempt, response) {
+    const retryAfter = response?.headers.get("Retry-After");
+    if (retryAfter) {
+      const seconds = Number(retryAfter);
+      if (Number.isFinite(seconds)) return Math.max(0, seconds * 1e3);
+    }
+    const base = this.config.retry.baseDelaySeconds;
+    const cap = this.config.retry.maxDelaySeconds;
+    const delay = Math.min(cap, base * 2 ** (attempt - 1));
+    return (delay + this.random() * delay * 0.1) * 1e3;
+  }
+  apiError(response, payload) {
+    const options = { statusCode: response.status, payload };
+    const message = errorMessage(response, payload);
+    if (response.status === 401 || response.status === 403) {
+      return new QDashAuthError(message, options);
+    }
+    if (response.status === 404) return new QDashNotFoundError(message, options);
+    if (response.status === 422) return new QDashValidationError(message, options);
+    return new QDashTransportError(message, options);
+  }
+};
+
+// src/client.ts
+function pathPart(value) {
+  return encodeURIComponent(value);
+}
+function query(values) {
+  return Object.fromEntries(Object.entries(values).filter(([, value]) => value != null));
+}
+var QDashClient = class _QDashClient {
+  api;
+  config;
+  transport;
+  constructor(config, options = {}) {
+    this.config = config;
+    this.transport = new QDashTransport(config, options);
+    this.api = this.bindGeneratedApi(getQDashAPI());
+  }
+  static fromEnv(env = process.env, options = {}) {
+    return new _QDashClient(QDashConfig.fromEnv(env), { ...options, env });
+  }
+  static async fromProfile(profile = "default", path, options = {}) {
+    const config = path ? await QDashConfig.fromFile(profile, path) : await QDashConfig.fromFile(profile);
+    return new _QDashClient(config, options);
+  }
+  async listChips() {
+    return this.get("/chips");
+  }
+  async getDefaultChip() {
+    const { chips } = await this.listChips();
+    if (chips.length === 0) throw new QDashNotFoundError("No chips are available");
+    const active = chips.filter((chip) => chip.activity_status === "active");
+    const candidates = active.length > 0 ? active : chips;
+    return candidates.reduce((latest, chip) => {
+      const latestTime = latest.installed_at ? Date.parse(latest.installed_at) : 0;
+      const chipTime = chip.installed_at ? Date.parse(chip.installed_at) : 0;
+      return chipTime > latestTime ? chip : latest;
+    });
+  }
+  async getDefaultChipId() {
+    return (await this.getDefaultChip()).chip_id;
+  }
+  async getChipMetrics(chipId) {
+    return this.get(`/metrics/chips/${pathPart(chipId)}/metrics`);
+  }
+  async getMetricsConfig() {
+    return this.get("/metrics/config");
+  }
+  async listChipQubits(chipId, options = {}) {
+    return this.get(`/chips/${pathPart(chipId)}/qubits`, query({ limit: options.limit, offset: options.offset }));
+  }
+  async getChipQubit(chipId, qid) {
+    return this.get(`/chips/${pathPart(chipId)}/qubits/${pathPart(qid)}`);
+  }
+  async listChipCouplings(chipId, options = {}) {
+    return this.get(`/chips/${pathPart(chipId)}/couplings`, query({ limit: options.limit, offset: options.offset }));
+  }
+  async getChipCoupling(chipId, couplingId) {
+    return this.get(`/chips/${pathPart(chipId)}/couplings/${pathPart(couplingId)}`);
+  }
+  async getTaskResultsTimeseries(options) {
+    return this.get(
+      "/task-results/timeseries",
+      query({
+        chip_id: options.chipId,
+        parameter: options.parameter,
+        start_at: options.startAt,
+        end_at: options.endAt,
+        tag: options.tag,
+        qid: options.qid
+      })
+    );
+  }
+  async listTaskResults(options = {}) {
+    return this.get(
+      "/task-results",
+      query({
+        chip_id: options.chipId,
+        task_name: options.taskName,
+        qid: options.qid,
+        coupling_id: options.couplingId,
+        status: options.status,
+        start_at: options.startAt,
+        end_at: options.endAt,
+        limit: options.limit,
+        skip: options.skip
+      })
+    );
+  }
+  async getTaskResult(taskId) {
+    return this.get(`/tasks/${pathPart(taskId)}/result`);
+  }
+  async listTasks(backend) {
+    return this.get("/tasks", query({ backend }));
+  }
+  async listTaskKnowledge() {
+    return this.get("/task-knowledge");
+  }
+  async getTaskKnowledge(taskName) {
+    return this.get(`/tasks/${pathPart(taskName)}/knowledge`);
+  }
+  async getTaskKnowledgeMarkdown(taskName) {
+    return this.get(`/tasks/${pathPart(taskName)}/knowledge/markdown`);
+  }
+  async listProjects() {
+    return this.get("/projects");
+  }
+  async getProject(projectId) {
+    return this.get(`/projects/${pathPart(projectId)}`);
+  }
+  async getFilesTree() {
+    const payload = await this.get(
+      "/files/tree"
+    );
+    return Array.isArray(payload) ? payload : payload.tree ?? [];
+  }
+  async getFileContent(path) {
+    return this.get("/files/content", { path });
+  }
+  async saveFileContent(path, content) {
+    return this.put("/files/content", { path, content });
+  }
+  async getGitStatus() {
+    return this.get("/files/git/status");
+  }
+  async listFlows() {
+    return this.get("/flows");
+  }
+  async getFlow(name) {
+    return this.get(`/flows/${pathPart(name)}`);
+  }
+  async listFlowTemplates() {
+    return this.get("/flows/templates");
+  }
+  async getFlowTemplate(templateId) {
+    return this.get(`/flows/templates/${pathPart(templateId)}`);
+  }
+  async saveFlow(request) {
+    return this.post("/flows", request);
+  }
+  async executeFlow(name, parameters = {}) {
+    return this.post(`/flows/${pathPart(name)}/execute`, { parameters });
+  }
+  async listExecutions(options = {}) {
+    return this.get(
+      "/executions",
+      query({
+        flow_name: options.flowName,
+        status: options.status,
+        skip: options.skip,
+        limit: options.limit
+      })
+    );
+  }
+  async getExecution(executionId) {
+    return this.get(`/executions/${pathPart(executionId)}`);
+  }
+  async waitForExecution(executionId, options = {}) {
+    const timeoutSeconds = options.timeoutSeconds ?? 600;
+    const pollIntervalSeconds = options.pollIntervalSeconds ?? 0.5;
+    this.validatePollOptions(timeoutSeconds, pollIntervalSeconds);
+    const deadline = Date.now() + timeoutSeconds * 1e3;
+    const terminal = /* @__PURE__ */ new Set(["completed", "failed", "cancelled", "canceled", "crashed"]);
+    while (true) {
+      const execution = await this.getExecution(executionId);
+      if (terminal.has(execution.status.toLowerCase())) return execution;
+      if (Date.now() >= deadline) {
+        throw new Error(
+          `Execution '${executionId}' did not reach a terminal state within ${timeoutSeconds} seconds`
+        );
+      }
+      await sleep2(pollIntervalSeconds * 1e3);
+    }
+  }
+  async createAgentSession(options) {
+    return this.post("/agent-sessions", {
+      chip_id: options.chipId,
+      policy: options.policy,
+      expires_in_seconds: options.expiresInSeconds ?? 21600,
+      skill_name: options.skillName ?? "",
+      skill_version: options.skillVersion ?? "",
+      skill_hash: options.skillHash ?? "",
+      model_name: options.modelName ?? ""
+    });
+  }
+  async getAgentSession(sessionId) {
+    return this.get(`/agent-sessions/${pathPart(sessionId)}`);
+  }
+  async evaluateAgentCandidateGate(sessionId, parameterName, value) {
+    return this.post(`/agent-sessions/${pathPart(sessionId)}/candidate-gate`, {
+      parameter_name: parameterName,
+      value
+    });
+  }
+  async submitAgentAction(sessionId, options) {
+    return this.post(`/agent-sessions/${pathPart(sessionId)}/actions`, {
+      idempotency_key: options.idempotencyKey,
+      expected_state_version: options.expectedStateVersion,
+      action_type: options.actionType,
+      task_name: options.taskName ?? null,
+      qids: options.qids ?? [],
+      parameter_overrides: options.parameterOverrides ?? {},
+      diagnosis: options.diagnosis ?? ""
+    });
+  }
+  async executeAgentAction(sessionId, actionId, options) {
+    return this.post(
+      `/agent-sessions/${pathPart(sessionId)}/actions/${pathPart(actionId)}/execute`,
+      {
+        source_execution_id: options.sourceExecutionId,
+        update_params: options.updateParams ?? false,
+        reconfigure: options.reconfigure ?? false
+      }
+    );
+  }
+  async getAgentAction(sessionId, actionId) {
+    return this.get(`/agent-sessions/${pathPart(sessionId)}/actions/${pathPart(actionId)}`);
+  }
+  async listAgentActions(sessionId) {
+    const payload = await this.get(
+      `/agent-sessions/${pathPart(sessionId)}/actions`
+    );
+    return payload.items;
+  }
+  async waitForAgentAction(sessionId, actionId, options = {}) {
+    return this.pollAgentAction(sessionId, actionId, "operation_id", options);
+  }
+  async waitForAgentActionExecution(sessionId, actionId, options = {}) {
+    return this.pollAgentAction(
+      sessionId,
+      actionId,
+      "execution_id",
+      { timeoutSeconds: 600, ...options }
+    );
+  }
+  async listAgentActionCandidates(sessionId, actionId) {
+    const payload = await this.get(
+      `/agent-sessions/${pathPart(sessionId)}/actions/${pathPart(actionId)}/candidates`
+    );
+    return payload.items;
+  }
+  async commitAgentActionCandidate(sessionId, actionId, parameterName, options) {
+    return this.post(
+      `/agent-sessions/${pathPart(sessionId)}/actions/${pathPart(actionId)}/candidates/${pathPart(parameterName)}/commit`,
+      {
+        idempotency_key: options.idempotencyKey,
+        expected_state_version: options.expectedStateVersion,
+        task_id: options.taskId
+      }
+    );
+  }
+  async commitAgentCampaignCandidates(sessionId, candidates, options) {
+    return this.post(`/agent-sessions/${pathPart(sessionId)}/campaign-commits`, {
+      idempotency_key: options.idempotencyKey,
+      expected_state_version: options.expectedStateVersion,
+      candidates
+    });
+  }
+  async getAgentCampaignCommit(sessionId, commitId) {
+    return this.get(
+      `/agent-sessions/${pathPart(sessionId)}/campaign-commits/${pathPart(commitId)}`
+    );
+  }
+  async getAgentCandidateCommit(sessionId, commitId) {
+    return this.get(`/agent-sessions/${pathPart(sessionId)}/commits/${pathPart(commitId)}`);
+  }
+  async applyAgentCandidateCommit(sessionId, commitId, options) {
+    return this.post(
+      `/agent-sessions/${pathPart(sessionId)}/commits/${pathPart(commitId)}/apply`,
+      {
+        idempotency_key: options.idempotencyKey,
+        expected_state_version: options.expectedStateVersion,
+        push_to_github: options.pushToGithub ?? false
+      }
+    );
+  }
+  async waitForAgentCandidateApply(sessionId, commitId, options = {}) {
+    const timeoutSeconds = options.timeoutSeconds ?? 300;
+    const pollIntervalSeconds = options.pollIntervalSeconds ?? 0.5;
+    this.validatePollOptions(timeoutSeconds, pollIntervalSeconds);
+    const deadline = Date.now() + timeoutSeconds * 1e3;
+    while (true) {
+      const commit = await this.getAgentCandidateCommit(sessionId, commitId);
+      if (commit.backend_status === "applied" || commit.backend_status === "failed") return commit;
+      if (Date.now() >= deadline) {
+        throw new Error(
+          `Agent candidate commit '${commitId}' was not applied within ${timeoutSeconds} seconds`
+        );
+      }
+      await sleep2(pollIntervalSeconds * 1e3);
+    }
+  }
+  async listForumPosts(options = {}) {
+    return this.get(
+      "/forum/posts",
+      query({
+        category: options.category,
+        status: options.status,
+        chip_id: options.chipId,
+        target_type: options.targetType,
+        target_id: options.targetId,
+        skip: options.skip,
+        limit: options.limit
+      })
+    );
+  }
+  async createForumPost(request) {
+    return this.post("/forum/posts", request);
+  }
+  async getForumPost(postId) {
+    return this.get(`/forum/posts/${pathPart(postId)}`);
+  }
+  async updateForumPost(postId, request) {
+    return this.patch(`/forum/posts/${pathPart(postId)}`, request);
+  }
+  async getForumPostReplies(postId) {
+    return this.get(`/forum/posts/${pathPart(postId)}/replies`);
+  }
+  async getProvenanceLineage(entityId) {
+    return this.get(`/provenance/lineage/${pathPart(entityId)}`);
+  }
+  async getProvenanceImpact(entityId) {
+    return this.get(`/provenance/impact/${pathPart(entityId)}`);
+  }
+  async getProvenanceStats() {
+    return this.get("/provenance/stats");
+  }
+  bindGeneratedApi(api) {
+    const entries = Object.entries(api).map(([name, method]) => {
+      const generated = method;
+      const bound = (...args) => {
+        const optionIndex = Math.max(0, generated.length - 1);
+        const callArgs = [...args];
+        while (callArgs.length < optionIndex) callArgs.push(void 0);
+        const supplied = callArgs[optionIndex];
+        const options = typeof supplied === "object" && supplied !== null ? supplied : {};
+        callArgs[optionIndex] = { ...options, qdashTransport: this.transport };
+        return generated(...callArgs);
+      };
+      return [name, bound];
+    });
+    return Object.fromEntries(entries);
+  }
+  get(path, requestQuery) {
+    return this.transport.requestJson("GET", path, { query: requestQuery });
+  }
+  post(path, body) {
+    return this.transport.requestJson("POST", path, { body });
+  }
+  put(path, body) {
+    return this.transport.requestJson("PUT", path, { body });
+  }
+  patch(path, body) {
+    return this.transport.requestJson("PATCH", path, { body });
+  }
+  async pollAgentAction(sessionId, actionId, field, options) {
+    const timeoutSeconds = options.timeoutSeconds ?? 120;
+    const pollIntervalSeconds = options.pollIntervalSeconds ?? 0.5;
+    this.validatePollOptions(timeoutSeconds, pollIntervalSeconds);
+    const deadline = Date.now() + timeoutSeconds * 1e3;
+    while (true) {
+      const action = await this.getAgentAction(sessionId, actionId);
+      if (action.execution_status === "failed" || action[field] != null) return action;
+      if (Date.now() >= deadline) {
+        throw new Error(
+          `Agent action '${actionId}' did not produce ${field} within ${timeoutSeconds} seconds`
+        );
+      }
+      await sleep2(pollIntervalSeconds * 1e3);
+    }
+  }
+  validatePollOptions(timeoutSeconds, pollIntervalSeconds) {
+    if (timeoutSeconds < 0 || pollIntervalSeconds < 0) {
+      throw new RangeError("Polling timeout and interval must be non-negative");
+    }
+  }
+};
+export {
+  QDashApiError,
+  QDashAuthError,
+  QDashClient,
+  QDashClientError,
+  QDashConfig,
+  QDashConfigError,
+  QDashNotFoundError,
+  QDashTransportError,
+  QDashValidationError,
+  defaultConfigPath,
+  getQDashAPI
+};
+//# sourceMappingURL=index.js.map