codai-sdk 0.3.1 → 0.5.0

package/dist/index.js

@@ -669,6 +669,256 @@ var Embeddings = class {
   }
 };
 
+// src/resources/environments.ts
+var envPath = (id, suffix = "") => `/v1/environments/${encodeURIComponent(id)}${suffix}`;
+var EnvironmentMembers = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /** `GET /v1/environments/{id}/members` — any role. */
+  async list(envId, opts = {}) {
+    const raw = await this.http.json(envPath(envId, "/members"), {
+      ext: opts.ext,
+      signal: opts.signal
+    });
+    return [...raw.members ?? []];
+  }
+  /** `POST /v1/environments/{id}/members` — exactly one of `user_id` / `email`. */
+  async add(envId, body, opts = {}) {
+    const raw = await this.http.json(
+      envPath(envId, "/members"),
+      { body, ext: opts.ext, signal: opts.signal }
+    );
+    return raw.member;
+  }
+  /** `PUT /v1/environments/{id}/members/me/ssh-key` — one `authorized_keys` line. */
+  setSshKey(envId, publicKey, opts = {}) {
+    const body = { public_key: publicKey };
+    return this.http.json(envPath(envId, "/members/me/ssh-key"), {
+      method: "PUT",
+      body,
+      ext: opts.ext,
+      signal: opts.signal
+    });
+  }
+  /** `PATCH /v1/environments/{id}/members/{userId}` — 409 `last_owner` on demoting the last owner. */
+  async setRole(envId, userId, role, opts = {}) {
+    const raw = await this.http.json(
+      envPath(envId, `/members/${encodeURIComponent(userId)}`),
+      { method: "PATCH", body: { role }, ext: opts.ext, signal: opts.signal }
+    );
+    return raw.member;
+  }
+  /** `DELETE /v1/environments/{id}/members/{userId}` — pass your own id to leave. */
+  remove(envId, userId, opts = {}) {
+    return this.http.json(
+      envPath(envId, `/members/${encodeURIComponent(userId)}`),
+      { method: "DELETE", ext: opts.ext, signal: opts.signal }
+    );
+  }
+  /** `POST /v1/environments/{id}/members/me/ssh-cert` — 12 h OpenSSH user certificate for your key. */
+  sshCert(envId, body, opts = {}) {
+    return this.http.json(envPath(envId, "/members/me/ssh-cert"), {
+      method: "POST",
+      body,
+      ext: opts.ext,
+      signal: opts.signal,
+      noRetry: true
+    });
+  }
+};
+var EnvironmentTasks = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /** `GET /v1/environments/{id}/tasks` */
+  list(envId, opts = {}) {
+    return this.http.json(envPath(envId, "/tasks"), { ext: opts.ext, signal: opts.signal });
+  }
+  /** `POST /v1/environments/{id}/tasks` — queued; you get a notification when it finishes. */
+  create(envId, body, opts = {}) {
+    return this.http.json(envPath(envId, "/tasks"), {
+      method: "POST",
+      body,
+      ext: opts.ext,
+      signal: opts.signal,
+      noRetry: true
+    });
+  }
+  /** `GET /v1/environments/{id}/tasks/{taskId}` */
+  get(envId, taskId, opts = {}) {
+    return this.http.json(envPath(envId, `/tasks/${encodeURIComponent(taskId)}`), { ext: opts.ext, signal: opts.signal });
+  }
+};
+var EnvironmentPorts = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /** `GET /v1/environments/{id}/ports` — published (forwarded) ports. */
+  async list(envId, opts = {}) {
+    const raw = await this.http.json(envPath(envId, "/ports"), {
+      ext: opts.ext,
+      signal: opts.signal
+    });
+    return [...raw.ports ?? []];
+  }
+  /** `PUT /v1/environments/{id}/ports/{port}` — publish or change visibility (upsert). */
+  async set(envId, port, body, opts = {}) {
+    const raw = await this.http.json(
+      envPath(envId, `/ports/${encodeURIComponent(String(port))}`),
+      { method: "PUT", body, ext: opts.ext, signal: opts.signal }
+    );
+    return raw.port;
+  }
+  /** `DELETE /v1/environments/{id}/ports/{port}` — unpublish. */
+  remove(envId, port, opts = {}) {
+    return this.http.json(
+      envPath(envId, `/ports/${encodeURIComponent(String(port))}`),
+      { method: "DELETE", ext: opts.ext, signal: opts.signal }
+    );
+  }
+};
+var EnvironmentSecrets = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /** `GET /v1/environments/{id}/secrets` — names and timestamps only, never values. */
+  async list(envId, opts = {}) {
+    const raw = await this.http.json(envPath(envId, "/secrets"), {
+      ext: opts.ext,
+      signal: opts.signal
+    });
+    return [...raw.secrets ?? []];
+  }
+  /** `PUT /v1/environments/{id}/secrets/{name}` — upsert; `name` is `ENV_STYLE`. */
+  set(envId, name, value, opts = {}) {
+    const body = { value };
+    return this.http.json(
+      envPath(envId, `/secrets/${encodeURIComponent(name)}`),
+      { method: "PUT", body, ext: opts.ext, signal: opts.signal }
+    );
+  }
+  /** `DELETE /v1/environments/{id}/secrets/{name}` */
+  remove(envId, name, opts = {}) {
+    return this.http.json(
+      envPath(envId, `/secrets/${encodeURIComponent(name)}`),
+      { method: "DELETE", ext: opts.ext, signal: opts.signal }
+    );
+  }
+};
+var Environments = class {
+  constructor(http) {
+    this.http = http;
+    this.members = new EnvironmentMembers(http);
+    this.ports = new EnvironmentPorts(http);
+    this.secrets = new EnvironmentSecrets(http);
+    this.tasks = new EnvironmentTasks(http);
+  }
+  http;
+  members;
+  ports;
+  secrets;
+  tasks;
+  /** `GET /v1/environments/{id}/ssh-ca` — CA public keys to trust (`@cert-authority` lines). */
+  sshCa(envId, opts = {}) {
+    return this.http.json(envPath(envId, "/ssh-ca"), { ext: opts.ext, signal: opts.signal });
+  }
+  /** `GET /v1/environments?project_id=&for_user_id=me` — newest first, every state. */
+  async list(query = {}, opts = {}) {
+    const raw = await this.http.json("/v1/environments", {
+      query: { project_id: query.project_id, for_user_id: query.for_user_id },
+      ext: opts.ext,
+      signal: opts.signal
+    });
+    return [...raw.environments ?? []];
+  }
+  /**
+   * `POST /v1/environments` — `byo` starts `pending`; managed providers start
+   * `creating`. 409 `already_has_env` in a `vm_per_dev` project (the error
+   * body carries the `environment_id` to reuse).
+   */
+  async create(body, opts = {}) {
+    const raw = await this.http.json("/v1/environments", {
+      body,
+      ext: opts.ext,
+      signal: opts.signal,
+      noRetry: true
+    });
+    return raw.environment;
+  }
+  /**
+   * `POST /v1/environments/enroll` — daemon side. The one-time `codai_env_…`
+   * token in the body is the only credential; the client's API key header is
+   * ignored by this route. Managed environments additionally receive a
+   * freshly minted `api_key`, returned exactly once.
+   */
+  enroll(body, opts = {}) {
+    return this.http.json("/v1/environments/enroll", {
+      body,
+      ext: opts.ext,
+      signal: opts.signal,
+      // The token is consumed on success; a retried POST would 401.
+      noRetry: true
+    });
+  }
+  /** `GET /v1/environments/{id}` — environment, your role, members, ports, recent events. */
+  get(envId, opts = {}) {
+    return this.http.json(envPath(envId), {
+      ext: opts.ext,
+      signal: opts.signal
+    });
+  }
+  /** `PATCH /v1/environments/{id}` — `name` and/or `idle_timeout_minutes` (5..1440). */
+  async update(envId, body, opts = {}) {
+    const raw = await this.http.json(envPath(envId), {
+      method: "PATCH",
+      body,
+      ext: opts.ext,
+      signal: opts.signal
+    });
+    return raw.environment;
+  }
+  /** `POST /v1/environments/{id}/start` — managed providers only (`stopped` → `starting`). */
+  start(envId, opts = {}) {
+    return this.transition(envId, "start", opts);
+  }
+  /** `POST /v1/environments/{id}/stop` — managed providers only (`running` → `stopping`). */
+  stop(envId, opts = {}) {
+    return this.transition(envId, "stop", opts);
+  }
+  /** `POST /v1/environments/{id}/archive` — keeps history, releases the machine. */
+  archive(envId, opts = {}) {
+    return this.transition(envId, "archive", opts);
+  }
+  /** `POST /v1/environments/{id}/destroy` — owner only; terminal. */
+  destroy(envId, opts = {}) {
+    return this.transition(envId, "destroy", opts);
+  }
+  /**
+   * `POST /v1/environments/{id}/enroll-token` — `byo` only; a 30-minute
+   * one-time token for `enroll()`. Minting again replaces the previous one.
+   */
+  enrollToken(envId, opts = {}) {
+    return this.http.json(envPath(envId, "/enroll-token"), {
+      method: "POST",
+      ext: opts.ext,
+      signal: opts.signal,
+      noRetry: true
+    });
+  }
+  transition(envId, action, opts) {
+    return this.http.json(envPath(envId, `/${action}`), {
+      method: "POST",
+      ext: opts.ext,
+      signal: opts.signal
+    });
+  }
+};
+
 // src/resources/health.ts
 var Health = class {
   constructor(http) {
@@ -921,6 +1171,221 @@ var Orgs = class {
   }
 };
 
+// src/resources/projects.ts
+var Projects = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /** `GET /v1/projects` — projects you own plus those of your orgs, newest first. */
+  async list(opts = {}) {
+    const raw = await this.http.json("/v1/projects", {
+      ext: opts.ext,
+      signal: opts.signal
+    });
+    return [...raw.projects ?? []];
+  }
+  /** `POST /v1/projects` — 409 `slug_taken` when the slug is already yours. */
+  async create(body, opts = {}) {
+    const raw = await this.http.json("/v1/projects", {
+      body,
+      ext: opts.ext,
+      signal: opts.signal
+    });
+    return raw.project;
+  }
+  /** `GET /v1/projects/{id}` — the project plus every environment in it. */
+  get(projectId, opts = {}) {
+    return this.http.json(`/v1/projects/${encodeURIComponent(projectId)}`, {
+      ext: opts.ext,
+      signal: opts.signal
+    });
+  }
+  /** `PATCH /v1/projects/{id}` — owner or org owner/admin; the slug cannot change. */
+  async update(projectId, body, opts = {}) {
+    const raw = await this.http.json(
+      `/v1/projects/${encodeURIComponent(projectId)}`,
+      { method: "PATCH", body, ext: opts.ext, signal: opts.signal }
+    );
+    return raw.project;
+  }
+  /** `DELETE /v1/projects/{id}` — 409 `project_has_environments` until all are destroyed. */
+  delete(projectId, opts = {}) {
+    return this.http.json(`/v1/projects/${encodeURIComponent(projectId)}`, {
+      method: "DELETE",
+      ext: opts.ext,
+      signal: opts.signal
+    });
+  }
+};
+
+// src/resources/resolve.ts
+var RESOLVE_TERMINAL_STATUSES = /* @__PURE__ */ new Set([
+  "resolved",
+  "failed",
+  "declined",
+  "error"
+]);
+var ResolveError = class extends CodaiError {
+  /** The `error` field of the body: a message, or Zod `flatten()` details on a 400. */
+  detail;
+  constructor(message, status, body, meta = {}) {
+    super(message, status, body, meta);
+    this.name = "ResolveError";
+    this.detail = extractDetail(body);
+  }
+};
+var ResolveInsufficientFundsError = class extends ResolveError {
+  /** Wallet balance, in `currency` units (EUR micros). */
+  balance;
+  /** Amount the hold needs, in `currency` units (EUR micros). */
+  required;
+  currency;
+  /** pay.codai.ro checkout link for the shortfall — open it, then retry `accept()`. */
+  topupUrl;
+  constructor(message, body, meta = {}) {
+    super(message, 402, body, meta);
+    this.name = "ResolveInsufficientFundsError";
+    this.balance = body.balance;
+    this.required = body.required;
+    this.currency = body.currency;
+    this.topupUrl = body.topup_url;
+  }
+};
+var Resolve = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /**
+   * `POST /v1/resolve/jobs` — submit a public GitHub repo + issue for triage.
+   * Returns a quote (`status: 'quoted'`), a free-tier auto-accept
+   * (`status: 'accepted'`) or a decline (`status: 'declined'`). Never retried:
+   * a retry could create a second job.
+   */
+  submit(body, opts = {}) {
+    if (!body.issue_url && !body.issue_text)
+      throw new TypeError("resolve.submit: one of issue_url or issue_text is required");
+    return this.call("/v1/resolve/jobs", {
+      method: "POST",
+      body,
+      noRetry: true,
+      signal: opts.signal
+    });
+  }
+  /** `GET /v1/resolve/jobs/{id}` — status, quote, reasons, cost and attestation pointer. */
+  get(id, opts = {}) {
+    return this.call(`/v1/resolve/jobs/${encodeURIComponent(id)}`, {
+      signal: opts.signal
+    });
+  }
+  /**
+   * `POST /v1/resolve/jobs/{id}/accept` — accept a paid quote and start the job.
+   * Throws `ResolveInsufficientFundsError` (402, carries `topupUrl`) when the
+   * wallet is short, `ResolveError` 409 when the job is not `quoted`.
+   */
+  accept(id, opts = {}) {
+    return this.call(`/v1/resolve/jobs/${encodeURIComponent(id)}/accept`, {
+      method: "POST",
+      rawBody: "",
+      // no body — sent with content-length: 0
+      noRetry: true,
+      signal: opts.signal
+    });
+  }
+  /**
+   * `GET /v1/resolve/attestations/{id}` — public execution proof (no auth needed
+   * server-side). Accepts the attestation id or the job's `attestation_url`.
+   */
+  attestation(idOrUrl, opts = {}) {
+    const id = idOrUrl.replace(/^.*\/v1\/resolve\/attestations\//, "");
+    return this.call(`/v1/resolve/attestations/${encodeURIComponent(id)}`, {
+      signal: opts.signal
+    });
+  }
+  /** `GET /health` — liveness of the Resolve service. */
+  health(opts = {}) {
+    return this.call("/health", { signal: opts.signal });
+  }
+  /**
+   * Poll `get(id)` until the job reaches a terminal status (`resolved`,
+   * `failed`, `declined`, `error`) or one of `opts.until`. A `quoted` job
+   * does not move until you `accept()` it.
+   */
+  async waitFor(id, opts = {}) {
+    const intervalMs = opts.intervalMs ?? 5e3;
+    const timeoutMs = opts.timeoutMs ?? 18e5;
+    const until = new Set(opts.until ?? RESOLVE_TERMINAL_STATUSES);
+    const deadline = Date.now() + timeoutMs;
+    for (; ; ) {
+      const job = await this.get(id, { signal: opts.signal });
+      opts.onPoll?.(job);
+      if (until.has(job.status)) return job;
+      const left = deadline - Date.now();
+      if (left <= 0)
+        throw new ResolveError(
+          `codai-resolve job ${id} still ${job.status} after ${timeoutMs} ms`,
+          0,
+          job
+        );
+      await abortableSleep(Math.min(intervalMs, left), opts.signal);
+    }
+  }
+  async call(path, init) {
+    try {
+      return await this.http.json(path, init);
+    } catch (err) {
+      throw toResolveError(path, err);
+    }
+  }
+};
+function extractDetail(body) {
+  if (body && typeof body === "object" && "error" in body) {
+    const e = body.error;
+    if (typeof e === "string") return e;
+    if (e && typeof e === "object") return e;
+  }
+  return null;
+}
+function isInsufficientFunds(body) {
+  return !!body && typeof body === "object" && body.error === "insufficient_funds" && typeof body.topup_url === "string";
+}
+function toResolveError(path, err) {
+  if (!(err instanceof CodaiError) || err instanceof ResolveError) return err;
+  if (err.status === 0) return err;
+  const meta = { requestId: err.requestId, retryAfter: err.retryAfter };
+  if (err.status === 402 && isInsufficientFunds(err.body)) {
+    const b = err.body;
+    return new ResolveInsufficientFundsError(
+      `codai-resolve ${path} \u2192 402: insufficient funds (balance ${b.balance}, required ${b.required} ${b.currency}); top up at ${b.topup_url}`,
+      b,
+      meta
+    );
+  }
+  const detail = extractDetail(err.body);
+  const text = detail === null ? "" : `: ${typeof detail === "string" ? detail : JSON.stringify(detail)}`;
+  return new ResolveError(
+    `codai-resolve ${path} \u2192 ${err.status}${text}`,
+    err.status,
+    err.body,
+    meta
+  );
+}
+function abortableSleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) return reject(signal.reason);
+    const onAbort = () => {
+      clearTimeout(t);
+      reject(signal?.reason);
+    };
+    const t = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+
 // src/resources/responses.ts
 var Responses = class {
   constructor(http) {
@@ -1215,6 +1680,26 @@ var Sessions = class {
   }
 };
 
+// src/resources/system-one.ts
+var SystemOne = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /**
+   * Ask one or more typed questions about `state`. Throws on 503 `s1_unavailable` like any other
+   * error — keep a local fallback and catch it: the gateway never substitutes a generative model.
+   */
+  async create(body, opts = {}) {
+    const res = await this.http.request("/v1/systemone", {
+      body,
+      ext: opts.ext,
+      signal: opts.signal
+    });
+    return await res.json();
+  }
+};
+
 // src/resources/tasks.ts
 var Tasks = class {
   constructor(http) {
@@ -1262,6 +1747,99 @@ var Tasks = class {
   }
 };
 
+// src/resources/triggers.ts
+var Triggers = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /** `GET /v1/triggers` — never includes the signing secret. */
+  list(opts = {}) {
+    return this.http.json("/v1/triggers", { ext: opts.ext, signal: opts.signal });
+  }
+  /** `POST /v1/triggers` — the response carries the signing `secret` ONCE. */
+  create(body, opts = {}) {
+    return this.http.json("/v1/triggers", { method: "POST", body, ext: opts.ext, signal: opts.signal });
+  }
+  /** `PATCH /v1/triggers/{id}` — name / enabled / policy. */
+  update(id, body, opts = {}) {
+    return this.http.json(`/v1/triggers/${encodeURIComponent(id)}`, { method: "PATCH", body, ext: opts.ext, signal: opts.signal });
+  }
+  /** `DELETE /v1/triggers/{id}` — its hook URL stops working immediately. */
+  delete(id, opts = {}) {
+    return this.http.json(`/v1/triggers/${encodeURIComponent(id)}`, { method: "DELETE", ext: opts.ext, signal: opts.signal });
+  }
+  /** `POST /v1/triggers/{id}/rotate-secret` — new secret, shown once. */
+  rotateSecret(id, opts = {}) {
+    return this.http.json(`/v1/triggers/${encodeURIComponent(id)}/rotate-secret`, { method: "POST", body: {}, ext: opts.ext, signal: opts.signal });
+  }
+  /** `POST /v1/triggers/{id}/test` — manual fire through the full pipeline; returns the decision + reason. */
+  /** `PUT /v1/triggers/{id}/secret` — store a secret issued by the source (e.g. a Sentry integration's client secret). */
+  setSecret(id, secret, opts = {}) {
+    return this.http.json(`/v1/triggers/${encodeURIComponent(id)}/secret`, { method: "PUT", body: { secret }, ext: opts.ext, signal: opts.signal, noRetry: true });
+  }
+  /** `POST /v1/triggers/{id}/test` — manual fire through the full pipeline; returns the decision + reason. */
+  test(id, body = {}, opts = {}) {
+    return this.http.json(`/v1/triggers/${encodeURIComponent(id)}/test`, { method: "POST", body, ext: opts.ext, signal: opts.signal });
+  }
+  /** `GET /v1/triggers/{id}/events?limit=` — recent deliveries with decisions. */
+  events(id, limit, opts = {}) {
+    return this.http.json(`/v1/triggers/${encodeURIComponent(id)}/events`, { query: { limit }, ext: opts.ext, signal: opts.signal });
+  }
+  /**
+   * `POST /v1/hooks/{id}` — send an event to a `generic` / `form` trigger from your own code. Signs the body
+   * (`X-Codai-Signature: t=<unix>,v1=HMAC_SHA256(secret, "<t>.<body>")`, WebCrypto — Node 20+, browsers, Deno,
+   * Workers). `deliveryId` makes retries idempotent. The hook needs no API key (the signature is the auth).
+   */
+  async fireHook(id, secret, event, opts = {}) {
+    const raw = JSON.stringify(event);
+    const t = Math.floor(Date.now() / 1e3);
+    const key = await crypto.subtle.importKey("raw", new TextEncoder().encode(secret), { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
+    const mac = new Uint8Array(await crypto.subtle.sign("HMAC", key, new TextEncoder().encode(`${t}.${raw}`)));
+    const v1 = Array.from(mac, (b) => b.toString(16).padStart(2, "0")).join("");
+    return this.http.json(`/v1/hooks/${encodeURIComponent(id)}`, {
+      method: "POST",
+      rawBody: raw,
+      ext: {
+        ...opts.ext,
+        headers: {
+          ...opts.ext?.headers,
+          "Content-Type": "application/json",
+          "x-codai-signature": `t=${t},v1=${v1}`,
+          ...opts.deliveryId ? { "x-codai-delivery": opts.deliveryId } : {}
+        }
+      },
+      signal: opts.signal
+    });
+  }
+};
+var Notifications = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /** `GET /v1/notifications?unread=1&limit=` — newest first. */
+  list(query = {}, opts = {}) {
+    return this.http.json("/v1/notifications", {
+      query: { unread: query.unread ? "1" : void 0, limit: query.limit },
+      ext: opts.ext,
+      signal: opts.signal
+    });
+  }
+  /** `POST /v1/notifications/read` — `ids` omitted = every unread one. */
+  markRead(ids, opts = {}) {
+    return this.http.json("/v1/notifications/read", { method: "POST", body: ids ? { ids } : {}, ext: opts.ext, signal: opts.signal });
+  }
+  /** `DELETE /v1/notifications/:id` — `{ deleted: 0 }` when the id is missing or not yours. */
+  delete(id, opts = {}) {
+    return this.http.json(`/v1/notifications/${encodeURIComponent(String(id))}`, { method: "DELETE", ext: opts.ext, signal: opts.signal });
+  }
+  /** `POST /v1/notifications/delete` — 1..200 ids; ids of other users are skipped. */
+  deleteMany(ids, opts = {}) {
+    return this.http.json("/v1/notifications/delete", { method: "POST", body: { ids }, ext: opts.ext, signal: opts.signal });
+  }
+};
+
 // src/resources/tokens.ts
 var Tokens = class {
   constructor(http) {
@@ -1314,6 +1892,7 @@ var OPERATION_METHODS = {
   createMessage: "messages.create",
   // Embeddings & Audio
   createEmbeddings: "embeddings.create",
+  createSystemOne: "systemOne.create",
   createTranscription: "audio.transcribe",
   createSpeech: "audio.speech",
   createEphemeralToken: "tokens.create",
@@ -1340,6 +1919,20 @@ var OPERATION_METHODS = {
   getTaskStats: "tasks.stats",
   getTask: "tasks.get",
   confirmTask: "tasks.confirm",
+  // Event triggers + inbox
+  listTriggers: "triggers.list",
+  createTrigger: "triggers.create",
+  updateTrigger: "triggers.update",
+  deleteTrigger: "triggers.delete",
+  rotateTriggerSecret: "triggers.rotateSecret",
+  setTriggerSecret: "triggers.setSecret",
+  testTrigger: "triggers.test",
+  listTriggerEvents: "triggers.events",
+  receiveTriggerHook: "triggers.fireHook",
+  listNotifications: "notifications.list",
+  markNotificationsRead: "notifications.markRead",
+  deleteNotification: "notifications.delete",
+  deleteNotifications: "notifications.deleteMany",
   // Sessions
   createSession: "sessions.create",
   listSessions: "sessions.list",
@@ -1376,6 +1969,39 @@ var OPERATION_METHODS = {
   listOrgMembers: "orgs.members.list",
   addOrgMember: "orgs.members.add",
   removeOrgMember: "orgs.members.remove",
+  // Projects
+  listProjects: "projects.list",
+  createProject: "projects.create",
+  getProject: "projects.get",
+  updateProject: "projects.update",
+  deleteProject: "projects.delete",
+  // Environments
+  listEnvironments: "environments.list",
+  createEnvironment: "environments.create",
+  enrollEnvironment: "environments.enroll",
+  getEnvironment: "environments.get",
+  updateEnvironment: "environments.update",
+  startEnvironment: "environments.start",
+  stopEnvironment: "environments.stop",
+  archiveEnvironment: "environments.archive",
+  destroyEnvironment: "environments.destroy",
+  createEnvironmentEnrollToken: "environments.enrollToken",
+  listEnvironmentMembers: "environments.members.list",
+  addEnvironmentMember: "environments.members.add",
+  setMyEnvironmentSshKey: "environments.members.setSshKey",
+  setEnvironmentMemberRole: "environments.members.setRole",
+  removeEnvironmentMember: "environments.members.remove",
+  issueMyEnvironmentSshCert: "environments.members.sshCert",
+  getEnvironmentSshCa: "environments.sshCa",
+  listEnvironmentTasks: "environments.tasks.list",
+  createEnvironmentTask: "environments.tasks.create",
+  getEnvironmentTask: "environments.tasks.get",
+  listEnvironmentPorts: "environments.ports.list",
+  setEnvironmentPort: "environments.ports.set",
+  removeEnvironmentPort: "environments.ports.remove",
+  listEnvironmentSecrets: "environments.secrets.list",
+  setEnvironmentSecret: "environments.secrets.set",
+  removeEnvironmentSecret: "environments.secrets.remove",
   // Account
   getAccount: "account.get",
   patchAccount: "account.update",
@@ -1388,6 +2014,13 @@ var STREAMING_OPERATIONS = /* @__PURE__ */ new Set([
   "streamSession",
   "streamHost"
 ]);
+var RESOLVE_OPERATION_METHODS = {
+  resolveHealth: "resolve.health",
+  createResolveJob: "resolve.submit",
+  getResolveJob: "resolve.get",
+  acceptResolveJob: "resolve.accept",
+  getResolveAttestation: "resolve.attestation"
+};
 
 // src/index.ts
 var Codai = class {
@@ -1398,20 +2031,30 @@ var Codai = class {
   responses;
   embeddings;
   audio;
+  /** Typed decisions from codai-s1 (`systemOne.create({ state, questions })`). */
+  systemOne;
   tokens;
   models;
   health;
   agents;
   tools;
   tasks;
+  /** Event triggers — webhooks that notify you or start agent sessions. */
+  triggers;
+  /** Inbox of trigger / cloud-task notifications. */
+  notifications;
   sessions;
   devices;
   hosts;
   orgs;
+  projects;
+  environments;
   account;
   receipt;
   feedback;
   phoneModels;
+  /** codai Resolve — execution-verified bug fixes (separate host, `resolveBaseUrl`). */
+  resolve;
   constructor(opts) {
     if (!opts.apiKey) throw new Error("Codai: apiKey is required");
     this.http = new HttpClient({
@@ -1433,18 +2076,33 @@ var Codai = class {
     this.messages = new Messages(http);
     this.responses = new Responses(http);
     this.audio = new Audio(http);
+    this.systemOne = new SystemOne(http);
     this.tokens = new Tokens(http);
     this.health = new Health(http);
     this.agents = new Agents(http);
     this.tools = new Tools(http);
     this.tasks = new Tasks(http);
+    this.triggers = new Triggers(http);
+    this.notifications = new Notifications(http);
     this.sessions = new Sessions(http);
     this.devices = new Devices(http);
     this.hosts = new Hosts(http);
     this.orgs = new Orgs(http);
+    this.projects = new Projects(http);
+    this.environments = new Environments(http);
     this.account = new Account(http);
     this.receipt = new Receipts(http);
     this.phoneModels = new PhoneModels(http);
+    this.resolve = new Resolve(
+      new HttpClient({
+        apiKey: opts.apiKey,
+        baseUrl: opts.resolveBaseUrl ?? "https://resolve.codai.ro",
+        timeoutMs: opts.timeoutMs ?? 12e4,
+        maxRetries: opts.maxRetries ?? 2,
+        fetch: opts.fetch,
+        defaults: opts.client ? { client: opts.client } : {}
+      })
+    );
     this.chat = callable(
       new Chat(http),
       (o) => this.chat.completions.create(this.legacyBody(o), {
@@ -1529,6 +2187,6 @@ function allKeys(obj) {
 }
 var index_default = Codai;
 
-export { Account, AgentRuns, Agents, Audio, Chat, ChatCompletions, Codai, CodaiError, Devices, Embeddings, Feedback, Health, Hosts, HttpClient, Messages, Models, OPERATION_METHODS, OrgMembers, Orgs, PhoneModels, Receipts, Responses, STREAMING_OPERATIONS, SessionControls, SessionEvents, SessionLease, SessionShares, Sessions, Tasks, Tokens, Tools, index_default as default, extensionHeaders, frameJson, mergeToolCall, readSse };
+export { Account, AgentRuns, Agents, Audio, Chat, ChatCompletions, Codai, CodaiError, Devices, Embeddings, EnvironmentMembers, EnvironmentPorts, EnvironmentSecrets, EnvironmentTasks, Environments, Feedback, Health, Hosts, HttpClient, Messages, Models, Notifications, OPERATION_METHODS, OrgMembers, Orgs, PhoneModels, Projects, RESOLVE_OPERATION_METHODS, RESOLVE_TERMINAL_STATUSES, Receipts, Resolve, ResolveError, ResolveInsufficientFundsError, Responses, STREAMING_OPERATIONS, SessionControls, SessionEvents, SessionLease, SessionShares, Sessions, Tasks, Tokens, Tools, Triggers, index_default as default, extensionHeaders, frameJson, mergeToolCall, readSse };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map