@idapt/browser-app-sdk 0.2.0 → 0.4.0

package/dist/react.cjs

@@ -345,15 +345,6 @@ async function moveFile(ctx, id, parentId, opts = {}) {
   });
   return res.data;
 }
-async function runFile(ctx, id, input = {}, opts = {}) {
-  const res = await request(ctx, {
-    method: "POST",
-    path: `/api/v1/drive/files/${id}/run`,
-    body: input,
-    signal: opts.signal
-  });
-  return res.data;
-}
 
 // ../sdk/src/api/agents.ts
 var AgentsApi = class {
@@ -519,251 +510,168 @@ var AudioApi = class {
   constructor(ctx) {
     this.ctx = ctx;
   }
-  /** Text-to-speech. Responds HTTP 201 with the written file ref under `data`. */
-  async speak(input, opts = {}) {
+  /** List the available TTS / transcription models. */
+  async listModels(opts = {}) {
     const res = await request(this.ctx, {
-      method: "POST",
-      path: "/api/v1/audio/speech",
-      body: input,
+      method: "GET",
+      path: "/api/v1/audio/models",
       signal: opts.signal
     });
     return res.data;
   }
-  async transcribe(input, opts = {}) {
-    const form = new FormData();
-    const filename = input.filename ?? (input.file instanceof File ? input.file.name : "audio");
-    form.set("file", input.file, filename);
-    if (input.model) form.set("model", input.model);
-    if (input.language) form.set("language", input.language);
+  /** List the TTS voice catalog (filter by language / gender). */
+  async listVoices(input = {}, opts = {}) {
     const res = await request(this.ctx, {
-      method: "POST",
-      path: "/api/v1/audio/transcriptions",
-      bodyRaw: form,
+      method: "GET",
+      path: "/api/v1/audio/voices",
+      query: input,
       signal: opts.signal
     });
     return res.data;
   }
-  async *streamSpeech(input, opts = {}) {
-    const res = await requestRaw(this.ctx, {
-      method: "POST",
-      path: "/api/v1/audio/speech/stream",
-      body: input,
-      signal: opts.signal,
-      expectJson: false
-    });
-    yield* parseSpeechStream(res, opts.signal);
-  }
-  async *streamTranscribe(input, opts = {}) {
-    const form = new FormData();
-    const filename = input.filename ?? (input.file instanceof File ? input.file.name : "audio");
-    form.set("file", input.file, filename);
-    if (input.model) form.set("model", input.model);
-    if (input.language) form.set("language", input.language);
-    const res = await requestRaw(this.ctx, {
-      method: "POST",
-      path: "/api/v1/audio/transcriptions/stream",
-      bodyRaw: form,
-      signal: opts.signal,
-      expectJson: false
-    });
-    yield* parseTranscriptionStream(res, opts.signal);
-  }
 };
-async function* parseSpeechStream(response, signal) {
-  for await (const frame of parseSse(response, signal)) {
-    const payload = safeJson(frame.data);
-    if (frame.event === "chunk") {
-      const audio = payload?.audio;
-      if (typeof audio === "string") yield { type: "chunk", audio };
-    } else if (frame.event === "done") {
-      const event = { type: "done" };
-      const totalBytes = numberOrUndefined(payload?.totalBytes);
-      const durationMs = numberOrUndefined(payload?.durationMs);
-      const charCount = numberOrUndefined(payload?.charCount);
-      if (totalBytes !== void 0) event.total_bytes = totalBytes;
-      if (durationMs !== void 0) event.duration_ms = durationMs;
-      if (charCount !== void 0) event.char_count = charCount;
-      if (typeof payload?.cached === "boolean") event.cached = payload.cached;
-      yield event;
-    } else if (frame.event === "error") {
-      yield errorEvent(payload);
-    }
-  }
-}
-async function* parseTranscriptionStream(response, signal) {
-  for await (const frame of parseSse(response, signal)) {
-    const payload = safeJson(frame.data);
-    if (frame.event === "partial") {
-      const text = payload?.text;
-      if (typeof text === "string") yield { type: "partial", text };
-    } else if (frame.event === "final") {
-      const text = payload?.text;
-      if (typeof text === "string") yield { type: "final", text };
-    } else if (frame.event === "error") {
-      yield errorEvent(payload);
-    }
-  }
-}
-async function* parseSse(response, signal) {
-  if (!response.body) return;
-  const reader = response.body.getReader();
-  const decoder = new TextDecoder();
-  let buffer = "";
-  try {
-    while (true) {
-      if (signal?.aborted) return;
-      const { done, value } = await reader.read();
-      if (done) break;
-      buffer += decoder.decode(value, { stream: true }).replace(/\r\n/g, "\n");
-      while (true) {
-        const boundary = buffer.indexOf("\n\n");
-        if (boundary === -1) break;
-        const block = buffer.slice(0, boundary);
-        buffer = buffer.slice(boundary + 2);
-        const parsed = parseSseBlock(block);
-        if (parsed) yield parsed;
-      }
-    }
-  } finally {
-    try {
-      reader.releaseLock();
-    } catch {
-    }
-  }
-}
-function parseSseBlock(block) {
-  let event = "message";
-  let data = "";
-  for (const line of block.split("\n")) {
-    if (!line) continue;
-    if (line.startsWith("event: ")) event = line.slice(7).trim();
-    else if (line.startsWith("event:")) event = line.slice(6).trim();
-    else if (line.startsWith("data: ")) data += line.slice(6);
-    else if (line.startsWith("data:")) data += line.slice(5);
-  }
-  if (!data && event === "message") return null;
-  return { event, data };
-}
-function safeJson(raw) {
-  try {
-    return JSON.parse(raw);
-  } catch {
-    return null;
-  }
-}
-function numberOrUndefined(value) {
-  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
-}
-function errorEvent(payload) {
-  const event = {
-    type: "error"
-  };
-  const status = numberOrUndefined(payload?.status);
-  const retryAfter = numberOrUndefined(payload?.retryAfter);
-  if (status !== void 0) event.status = status;
-  if (retryAfter !== void 0) event.retry_after = retryAfter;
-  return event;
-}
 
-// ../sdk/src/api/blobs.ts
-var enc = encodeURIComponent;
-var BlobsApi = class {
+// ../sdk/src/api/automations.ts
+var AutomationsApi = class {
   constructor(ctx) {
     this.ctx = ctx;
   }
-  /** List objects in a namespace (prefix-filterable). */
-  async list(namespace, opts = {}) {
-    const q = new URLSearchParams();
-    if (opts.prefix) q.set("prefix", opts.prefix);
-    if (opts.cursor) q.set("cursor", opts.cursor);
-    if (opts.limit) q.set("limit", String(opts.limit));
-    const qs = q.toString() ? `?${q.toString()}` : "";
+  // ---------------------------------------------------------------------------
+  //  CRUD
+  // ---------------------------------------------------------------------------
+  async list(query = {}, opts = {}) {
     const res = await request(this.ctx, {
       method: "GET",
-      path: `/api/v1/blobs/${enc(namespace)}${qs}`,
+      path: "/api/v1/automations",
+      query,
       signal: opts.signal
     });
     return res.data;
   }
   /**
-   * Upload (upsert) an object's bytes. Returns its metadata.
+   * Create an automation. `workspace_id` is passed in the request BODY
+   * alongside the flat automation definition — it is not a query param. The request
+   * body is flat: every scheduling field (`cron_expression`, …) and agent-run
+   * action field (`agent_id`, `prompt_template`, …) sits at the top level —
+   * there are no nested `trigger_config` / `action_config` objects.
    *
-   * Sent as `multipart/form-data` (the bytes ride a `file` part, with an
-   * optional `content_type` field) — the same upload convention as
-   * `client.files.upload`, so it flows through the one multipart transport and
-   * is reachable identically via `client.call("blobs put", …)`. The SDK leaves
-   * `Content-Type` unset so the runtime picks the multipart boundary.
+   * For a webhook automation the response additionally carries a one-time
+   * plaintext `secret` (use `AutomationWithSecret`); other automation types
+   * resolve to a plain `Automation`.
    */
-  async put(namespace, key, content, contentType, opts = {}) {
-    const ct = contentType ?? (content instanceof Blob && content.type ? content.type : "application/octet-stream");
-    const blob = content instanceof Blob ? content : new Blob([content], { type: ct });
-    const form = new FormData();
-    form.set("file", blob, key);
-    form.set("content_type", ct);
+  async create(workspaceId, input, opts = {}) {
     const res = await request(this.ctx, {
       method: "POST",
-      path: `/api/v1/blobs/${enc(namespace)}/${enc(key)}`,
-      // No explicit Content-Type — the runtime sets the multipart boundary.
-      bodyRaw: form,
+      path: "/api/v1/automations",
+      body: { workspace_id: workspaceId, ...input },
       signal: opts.signal
     });
     return res.data;
   }
-  /**
-   * Download an object's raw bytes (preserving its stored Content-Type).
-   *
-   * `GET /blobs/:ns/:key` returns JSON metadata + a signed URL by default (the
-   * agent/CLI form); `?download=true` is the raw-bytes escape hatch this facade
-   * uses. For the JSON reference instead, call `client.call("blobs get", …)`.
-   */
-  async get(namespace, key, opts = {}) {
-    const res = await requestRaw(this.ctx, {
+  async get(id, opts = {}) {
+    const res = await request(this.ctx, {
       method: "GET",
-      path: `/api/v1/blobs/${enc(namespace)}/${enc(key)}?download=true`,
-      signal: opts.signal,
-      expectJson: false
+      path: `/api/v1/automations/${id}`,
+      signal: opts.signal
     });
-    const blob = await res.blob();
-    return {
-      blob,
-      contentType: res.headers.get("content-type") ?? "application/octet-stream"
-    };
+    return res.data;
   }
-  /** Read an object's metadata (no bytes). */
-  async head(namespace, key, opts = {}) {
+  async update(id, input, opts = {}) {
     const res = await request(this.ctx, {
-      method: "GET",
-      path: `/api/v1/blobs/${enc(namespace)}/${enc(key)}/meta`,
+      method: "PATCH",
+      path: `/api/v1/automations/${id}`,
+      body: input,
       signal: opts.signal
     });
     return res.data;
   }
-  /** Delete an object (idempotent). */
-  async delete(namespace, key, opts = {}) {
+  async delete(id, opts = {}) {
     return request(this.ctx, {
       method: "DELETE",
-      path: `/api/v1/blobs/${enc(namespace)}/${enc(key)}`,
+      path: `/api/v1/automations/${id}`,
+      signal: opts.signal
+    });
+  }
+  async archive(id, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "POST",
+      path: `/api/v1/automations/${id}/archive`,
       signal: opts.signal
     });
+    return res.data;
   }
-  /** Mint a time-limited direct-download URL for an object. */
-  async createSignedUrl(namespace, key, expiresIn, opts = {}) {
+  async unarchive(id, opts = {}) {
     const res = await request(this.ctx, {
       method: "POST",
-      path: `/api/v1/blobs/${enc(namespace)}/${enc(key)}/signed-url`,
-      body: { expires_in: expiresIn },
+      path: `/api/v1/automations/${id}/unarchive`,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  // ---------------------------------------------------------------------------
+  //  Fire + rotate-secret + runs
+  // ---------------------------------------------------------------------------
+  /**
+   * Fire an automation via its webhook secret. This endpoint does NOT use the
+   * client's `ap_` key — the bearer is the automation's secret — so we build a
+   * one-off HttpContext for it rather than mutating the shared one.
+   *
+   * Responds HTTP 202. The response identifies the fired automation via `id`
+   * only.
+   */
+  async fire(id, input, opts = {}) {
+    const localCtx = {
+      apiUrl: this.ctx.apiUrl,
+      key: input.secret,
+      fetch: this.ctx.fetch
+    };
+    const res = await request(localCtx, {
+      method: "POST",
+      path: `/api/v1/automations/${id}/fire`,
+      body: input.body ?? {},
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  /**
+   * Rotate the webhook secret. Returns the automation with a fresh one-time
+   * plaintext `secret` populated (`AutomationWithSecret`). The old secret
+   * immediately stops working.
+   */
+  async rotateSecret(id, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "POST",
+      path: `/api/v1/automations/${id}/rotate-secret`,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  /** Recent fires + their success/error outcome. */
+  async listRuns(id, query = {}, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "GET",
+      path: `/api/v1/automations/${id}/runs`,
+      query,
+      signal: opts.signal
+    });
+    return res.data;
+  }
+  async getCostStats(id, opts = {}) {
+    const res = await request(this.ctx, {
+      method: "GET",
+      path: `/api/v1/automations/${id}/cost-stats`,
       signal: opts.signal
     });
     return res.data;
   }
-  /** List the blob namespaces in the workspace. */
-  async listNamespaces(opts = {}) {
+  async getCostStatsMap(query = {}, opts = {}) {
     const res = await request(this.ctx, {
       method: "GET",
-      path: "/api/v1/blobs",
+      path: "/api/v1/automations/cost-stats",
+      query,
       signal: opts.signal
     });
-    return res.data.map((n) => n.namespace);
+    return res.data.by_id;
   }
 };
 function bindPath(binding, args) {
@@ -815,7 +723,7 @@ function buildRequest(binding, path, rest, signal) {
       return base;
   }
 }
-async function* parseSse2(response, signal) {
+async function* parseSse(response, signal) {
   if (!response.body) return;
   const reader = response.body.getReader();
   const decoder = new TextDecoder();
@@ -831,7 +739,7 @@ async function* parseSse2(response, signal) {
         if (boundary === -1) break;
         const block = buffer.slice(0, boundary);
         buffer = buffer.slice(boundary + 2);
-        const frame = parseSseBlock2(block);
+        const frame = parseSseBlock(block);
         if (frame) yield frame;
       }
     }
@@ -842,7 +750,7 @@ async function* parseSse2(response, signal) {
     }
   }
 }
-function parseSseBlock2(block) {
+function parseSseBlock(block) {
   let event = "message";
   let data = "";
   for (const line of block.split("\n")) {
@@ -866,7 +774,7 @@ async function executeCommand(binding, args = {}, ctx, opts = {}) {
   {
     if (isSseBinding(binding) && !opts.bufferBinary) {
       const res = await requestRaw(ctx, { ...req, expectJson: false });
-      return parseSse2(res, opts.signal);
+      return parseSse(res, opts.signal);
     }
     return await request(ctx, { ...req, expectBlob: true });
   }
@@ -1240,7 +1148,7 @@ var ComputersApi = class {
     return res.data;
   }
   // ---------------------------------------------------------------------------
-  //  Exec & tmux
+  //  Exec & terminals
   // ---------------------------------------------------------------------------
   async exec(id, input, opts = {}) {
     const res = await request(this.ctx, {
@@ -1252,56 +1160,57 @@ var ComputersApi = class {
     return res.data;
   }
   /**
-   * tmux dispatcher. Each `op` returns a different shape — see the route
-   * docs for the per-op payload. Common case: `op: "run"` starts a window,
+   * Persistent-terminal dispatcher. Each `op` returns a different shape — see
+   * the route docs for the per-op payload. Common case: `op: "run"` runs a
+   * command to completion in a named window (state persists across runs),
    * `op: "capture"` reads its output.
    */
-  async tmux(id, input, opts = {}) {
+  async terminal(id, input, opts = {}) {
     const res = await request(
       this.ctx,
       {
         method: "POST",
-        path: `/api/v1/computers/${id}/tmux`,
+        path: `/api/v1/computers/${id}/terminal`,
         body: input,
         signal: opts.signal
       }
     );
     return res.data;
   }
-  /** Convenience over `tmux({ op: "list" })`. */
-  async listTmuxWindows(id, opts = {}) {
-    const result = await this.tmux(id, { op: "list" }, opts);
+  /** Convenience over `terminal({ op: "list" })`. */
+  async listTerminals(id, opts = {}) {
+    const result = await this.terminal(id, { op: "list" }, opts);
     return result.windows ?? [];
   }
   // ---------------------------------------------------------------------------
-  //  SFTP
+  //  FS
   // ---------------------------------------------------------------------------
   /**
-   * Unified SFTP dispatcher. Returns op-shaped payload. For streaming
-   * uploads/downloads use `sftpUpload` / `sftpDownload`.
+   * Unified FS dispatcher. Returns op-shaped payload. For streaming
+   * uploads/downloads use `fsUpload` / `fsDownload`.
    */
-  async sftp(id, input, opts = {}) {
+  async fs(id, input, opts = {}) {
     const res = await request(
       this.ctx,
       {
         method: "POST",
-        path: `/api/v1/computers/${id}/sftp`,
+        path: `/api/v1/computers/${id}/fs`,
         body: input,
         signal: opts.signal
       }
     );
     return res.data;
   }
-  /** Convenience: `sftp({op:"list"})` returning the entries array directly. */
-  async sftpList(id, path, opts = {}) {
-    const result = await this.sftp(id, { op: "list", path }, opts);
+  /** Convenience: `fs({op:"list"})` returning the entries array directly. */
+  async fsList(id, path, opts = {}) {
+    const result = await this.fs(id, { op: "list", path }, opts);
     return result;
   }
   /**
    * Multipart upload of a file/folder member. Falls back to single-file mode
    * when `relative_path` is omitted.
    */
-  async sftpUpload(id, input, opts = {}) {
+  async fsUpload(id, input, opts = {}) {
     const form = new FormData();
     form.append("file", input.file);
     form.append("path", input.path);
@@ -1311,7 +1220,7 @@ var ComputersApi = class {
       this.ctx,
       {
         method: "POST",
-        path: `/api/v1/computers/${id}/sftp/upload`,
+        path: `/api/v1/computers/${id}/fs/upload`,
         bodyRaw: form,
         signal: opts.signal
       }
@@ -1322,10 +1231,10 @@ var ComputersApi = class {
    * Stream a remote file (or a folder as `tar.gz`) as a `Blob`. The server
    * sends the real MIME type on `Content-Type`.
    */
-  async sftpDownload(id, remotePath, opts = {}) {
+  async fsDownload(id, remotePath, opts = {}) {
     return request(this.ctx, {
       method: "GET",
-      path: `/api/v1/computers/${id}/sftp/download`,
+      path: `/api/v1/computers/${id}/fs/download`,
       query: { path: remotePath },
       expectBlob: true,
       signal: opts.signal
@@ -1493,59 +1402,85 @@ var ComputersApi = class {
     return res.data;
   }
   // ---------------------------------------------------------------------------
-  //  Workspace links (share LOCAL INFERENCE into other workspaces)
+  //  Workspace exposures (expose an actor-owned machine into a workspace) +
+  //  ownership transfer
   // ---------------------------------------------------------------------------
   /**
-   * List the workspaces a computer's LOCAL INFERENCE is shared into. The home
-   * workspace is never listed (it already has full access). The route returns
-   * the links under a `links` key (not a standard list envelope).
+   * Expose an actor-owned machine INTO a workspace (Layer 2) with a
+   * per-capability grant, so that workspace's members can use it. Requires
+   * machine-admin and membership of the target workspace. Rejects a duplicate
+   * exposure. (CLI verb: `computer add-exposure` — the bare `expose`/`unexpose`
+   * verbs are the tunnel port commands.)
    */
-  async listWorkspaceLinks(id, opts = {}) {
-    const res = await request(this.ctx, {
-      method: "GET",
-      path: `/api/v1/computers/${id}/workspace-links`,
-      signal: opts.signal
-    });
-    return res.data.links;
+  async expose(id, input, opts = {}) {
+    const res = await request(
+      this.ctx,
+      {
+        method: "POST",
+        path: `/api/v1/computers/${id}/expose`,
+        body: input,
+        signal: opts.signal
+      }
+    );
+    return res.data.exposure;
   }
   /**
-   * Share a computer's LOCAL INFERENCE into another workspace (never shell /
-   * files / tunnels). `workspaceId` is the target workspace's `ws_…`
-   * resourceId or slug. Requires EDIT on the computer's home workspace and
-   * membership of the target. Rejects the home workspace and duplicates.
+   * Replace the capability grant on an existing exposure. `workspaceId` is the
+   * exposed workspace's `ws_…` resourceId. Requires machine-admin.
+   * (CLI verb: `computer update-exposure`.)
    */
-  async linkWorkspace(id, workspaceId, opts = {}) {
+  async updateExposure(id, workspaceId, capabilities, opts = {}) {
     const res = await request(
       this.ctx,
       {
-        method: "POST",
-        path: `/api/v1/computers/${id}/workspace-links`,
-        body: { workspace_id: workspaceId },
+        method: "PATCH",
+        path: `/api/v1/computers/${id}/expose/${workspaceId}`,
+        body: { capabilities },
         signal: opts.signal
       }
     );
-    return res.data.link;
+    return res.data.exposure;
   }
   /**
-   * Stop sharing a computer's local inference into a workspace. `workspaceId`
-   * is the target workspace's `ws_…` resourceId. Idempotent — unlinking a
-   * non-existent link still succeeds.
+   * Stop exposing a machine into a workspace. `workspaceId` is the exposed
+   * workspace's `ws_…` resourceId. Allowed for machine-admin OR an admin of the
+   * exposed workspace. Idempotent. (CLI verb: `computer remove-exposure`.)
    */
-  async unlinkWorkspace(id, workspaceId, opts = {}) {
-    const res = await request(this.ctx, {
-      method: "DELETE",
-      path: `/api/v1/computers/${id}/workspace-links/${workspaceId}`,
-      signal: opts.signal
-    });
+  async unexpose(id, workspaceId, opts = {}) {
+    const res = await request(
+      this.ctx,
+      {
+        method: "DELETE",
+        path: `/api/v1/computers/${id}/expose/${workspaceId}`,
+        signal: opts.signal
+      }
+    );
     return res.data;
   }
+  /**
+   * Transfer an actor-owned machine to a new owner (self, or an org the caller
+   * administers). `owner` is the target profile's resourceId; existing workspace
+   * exposures are kept. Requires machine-admin. (CLI verb: `computer transfer`.)
+   */
+  async transfer(id, owner, opts = {}) {
+    const res = await request(
+      this.ctx,
+      {
+        method: "POST",
+        path: `/api/v1/computers/${id}/transfer`,
+        body: { owner },
+        signal: opts.signal
+      }
+    );
+    return res.data.computer;
+  }
   // ---------------------------------------------------------------------------
   //  Pair-token redemption (daemon bootstrap)
   // ---------------------------------------------------------------------------
   /**
    * Redeem a one-time pair token for a long-lived computer identity. The
    * token itself is the auth — we swap the bearer for the token on this
-   * call only (same pattern as `triggers.fire`).
+   * call only (same pattern as `automations.fire`).
    *
    * Used by `idapt up --token` to bootstrap a daemon. The request body is
    * snake_case; the response is wrapped in the standard `{data:{…}}`
@@ -1567,117 +1502,6 @@ var ComputersApi = class {
   }
 };
 
-// ../sdk/src/api/datastore.ts
-var enc2 = encodeURIComponent;
-var DatastoreApi = class {
-  constructor(ctx) {
-    this.ctx = ctx;
-  }
-  /** List keys in a namespace (prefix-filterable). */
-  async list(namespace, opts = {}) {
-    const q = new URLSearchParams();
-    if (opts.prefix) q.set("prefix", opts.prefix);
-    if (opts.cursor) q.set("cursor", opts.cursor);
-    if (opts.limit) q.set("limit", String(opts.limit));
-    const qs = q.toString() ? `?${q.toString()}` : "";
-    const res = await request(this.ctx, {
-      method: "GET",
-      path: `/api/v1/datastore/${enc2(namespace)}${qs}`,
-      signal: opts.signal
-    });
-    return res.data;
-  }
-  /** Read a KV entry. */
-  async get(namespace, key, opts = {}) {
-    const res = await request(this.ctx, {
-      method: "GET",
-      path: `/api/v1/datastore/${enc2(namespace)}/${enc2(key)}`,
-      signal: opts.signal
-    });
-    return res.data;
-  }
-  /** Upsert a KV entry (optionally with a TTL). */
-  async set(namespace, key, value, opts = {}) {
-    const res = await request(this.ctx, {
-      method: "POST",
-      path: `/api/v1/datastore/${enc2(namespace)}/${enc2(key)}`,
-      body: { value, ttl_seconds: opts.ttlSeconds },
-      signal: opts.signal
-    });
-    return res.data;
-  }
-  /** Delete a KV entry (idempotent). */
-  async delete(namespace, key, opts = {}) {
-    return request(this.ctx, {
-      method: "DELETE",
-      path: `/api/v1/datastore/${enc2(namespace)}/${enc2(key)}`,
-      signal: opts.signal
-    });
-  }
-  /** Atomically add `by` (default 1) to a numeric counter. */
-  async increment(namespace, key, by = 1, opts = {}) {
-    const res = await request(
-      this.ctx,
-      {
-        method: "POST",
-        path: `/api/v1/datastore/${enc2(namespace)}/${enc2(key)}/increment`,
-        body: { by },
-        signal: opts.signal
-      }
-    );
-    return res.data;
-  }
-  /** List the namespaces in the workspace. */
-  async listNamespaces(opts = {}) {
-    const res = await request(this.ctx, {
-      method: "GET",
-      path: "/api/v1/datastore",
-      signal: opts.signal
-    });
-    return res.data.map((n) => n.namespace);
-  }
-  /** Read several keys at once. */
-  async batchGet(namespace, keys, opts = {}) {
-    const res = await request(
-      this.ctx,
-      {
-        method: "POST",
-        path: `/api/v1/datastore/${enc2(namespace)}`,
-        body: { op: "get", keys },
-        signal: opts.signal
-      }
-    );
-    return res.data.entries ?? [];
-  }
-  /** Upsert several entries at once. */
-  async batchSet(namespace, entries, opts = {}) {
-    const res = await request(this.ctx, {
-      method: "POST",
-      path: `/api/v1/datastore/${enc2(namespace)}`,
-      body: {
-        op: "set",
-        entries: entries.map((e) => ({
-          key: e.key,
-          value: e.value,
-          ttl_seconds: e.ttlSeconds
-        }))
-      },
-      signal: opts.signal
-    });
-    return res.data.count ?? 0;
-  }
-  /** Delete several keys at once; returns the count removed. */
-  async batchDelete(namespace, keys, opts = {}) {
-    const res = await request(this.ctx, {
-      method: "POST",
-      path: `/api/v1/datastore/${enc2(namespace)}`,
-      body: { op: "delete", keys },
-      signal: opts.signal
-    });
-    return res.data.count ?? 0;
-  }
-};
-
 // ../sdk/src/api/docs.ts
 var DocsApi = class {
   constructor(ctx) {
@@ -1745,7 +1569,7 @@ var FilesApi = class {
     return permanentDeleteFile(this.ctx, id, opts);
   }
   // ---------------------------------------------------------------------------
-  //  Folder / move / run
+  //  Folder / move
   // ---------------------------------------------------------------------------
   /**
    * Idempotent create-or-get a folder. Returns the existing folder (with
@@ -1757,163 +1581,6 @@ var FilesApi = class {
   move(id, parentId, opts = {}) {
     return moveFile(this.ctx, id, parentId, opts);
   }
-  /**
-   * Execute a code file (js/ts/py/sh) in a sandboxed Lambda. Returns the
-   * full `ExecutionRun` record (status, stdout/stderr, exit code, timestamps).
-   */
-  run(id, input = {}, opts = {}) {
-    return runFile(this.ctx, id, input, opts);
-  }
-};
-
-// ../sdk/src/api/functions.ts
-var enc3 = encodeURIComponent;
-var FunctionRunsApi = class {
-  constructor(ctx) {
-    this.ctx = ctx;
-  }
-  /** List one-off function runs (cursor-paginated). */
-  async list(query = {}, opts = {}) {
-    const res = await request(this.ctx, {
-      method: "GET",
-      path: "/api/v1/functions/runs",
-      query,
-      signal: opts.signal
-    });
-    return res.data;
-  }
-  /** Get a single one-off run by id. */
-  async get(id, opts = {}) {
-    const res = await request(this.ctx, {
-      method: "GET",
-      path: `/api/v1/functions/runs/${enc3(id)}`,
-      signal: opts.signal
-    });
-    return res.data;
-  }
-  /**
-   * Interrupt a running run. Only computer-backed runs can be interrupted;
-   * Lambda-backed runs return 409 (`ConflictError`).
-   */
-  async interrupt(id, opts = {}) {
-    const res = await request(this.ctx, {
-      method: "POST",
-      path: `/api/v1/functions/runs/${enc3(id)}/interrupt`,
-      body: {},
-      signal: opts.signal
-    });
-    return res.data;
-  }
-};
-var FunctionsApi = class {
-  constructor(ctx) {
-    this.ctx = ctx;
-    this.runs = new FunctionRunsApi(ctx);
-  }
-  /**
-   * Run a script ONCE in the sandbox. Pass EITHER inline `script` (+ optional
-   * `language`) OR an existing Drive `file_id`. Returns the full `FunctionRun`
-   * row — `id`, `status`, `stdout`, `stderr`, `exit_code`, the run timestamps,
-   * and any `output_files` the script wrote under `/tmp/output/`.
-   */
-  async run(input, opts = {}) {
-    const res = await request(this.ctx, {
-      method: "POST",
-      path: "/api/v1/functions/runs",
-      body: input,
-      signal: opts.signal
-    });
-    return res.data;
-  }
-  /** List deployed functions in the workspace. */
-  async list(query = {}, opts = {}) {
-    const res = await request(this.ctx, {
-      method: "GET",
-      path: "/api/v1/functions",
-      query,
-      signal: opts.signal
-    });
-    return res.data;
-  }
-  /** Get a deployed function by its resourceId. */
-  async get(id, opts = {}) {
-    const res = await request(this.ctx, {
-      method: "GET",
-      path: `/api/v1/functions/${enc3(id)}`,
-      signal: opts.signal
-    });
-    return res.data;
-  }
-  /** Create a deployed function (config only — `deploy` adds a bundle). */
-  async create(input, opts = {}) {
-    const res = await request(this.ctx, {
-      method: "POST",
-      path: "/api/v1/functions",
-      body: input,
-      signal: opts.signal
-    });
-    return res.data;
-  }
-  /** Update a deployed function's config. */
-  async update(id, patch, opts = {}) {
-    const res = await request(this.ctx, {
-      method: "PATCH",
-      path: `/api/v1/functions/${enc3(id)}`,
-      body: patch,
-      signal: opts.signal
-    });
-    return res.data;
-  }
-  /** Delete a deployed function + all its deployments. */
-  async delete(id, opts = {}) {
-    return request(this.ctx, {
-      method: "DELETE",
-      path: `/api/v1/functions/${enc3(id)}`,
-      signal: opts.signal
-    });
-  }
-  /**
-   * Deploy a new bundle (inline base64 files). Promotes the new deployment to
-   * live immediately unless `promote: false`. Returns the new deployment.
-   */
-  async deploy(id, input, opts = {}) {
-    const res = await request(this.ctx, {
-      method: "POST",
-      path: `/api/v1/functions/${enc3(id)}/deploy`,
-      body: input,
-      signal: opts.signal
-    });
-    return res.data;
-  }
-  /** List a function's deployments (newest-first). */
-  async deployments(id, opts = {}) {
-    const res = await request(this.ctx, {
-      method: "GET",
-      path: `/api/v1/functions/${enc3(id)}/deployments`,
-      signal: opts.signal
-    });
-    return res.data;
-  }
-  /** Promote (or roll back to) a deployment — flips the active one. */
-  async promote(id, input, opts = {}) {
-    const res = await request(this.ctx, {
-      method: "POST",
-      path: `/api/v1/functions/${enc3(id)}/promote`,
-      body: input,
-      signal: opts.signal
-    });
-    return res.data;
-  }
-  /** Invoke a deployed function synchronously; returns its response. */
-  async invoke(id, input = {}, opts = {}) {
-    const res = await request(this.ctx, {
-      method: "POST",
-      path: `/api/v1/functions/${enc3(id)}/invoke`,
-      body: input,
-      signal: opts.signal
-    });
-    return res.data;
-  }
 };
 
 // ../sdk/src/api/guide.ts
@@ -1940,20 +1607,11 @@ var ImagesApi = class {
   constructor(ctx) {
     this.ctx = ctx;
   }
+  /** List the available image-generation models. */
   async listModels(opts = {}) {
-    const res = await request(this.ctx, {
-      method: "GET",
-      path: "/api/v1/images/models",
-      signal: opts.signal
-    });
-    return res.data;
-  }
-  /** Generate an image. Responds HTTP 201 with the written file ref under `data`. */
-  async generate(input, opts = {}) {
-    const res = await request(this.ctx, {
-      method: "POST",
-      path: "/api/v1/images/generations",
-      body: input,
+    const res = await request(this.ctx, {
+      method: "GET",
+      path: "/api/v1/images/models",
       signal: opts.signal
     });
     return res.data;
@@ -2218,7 +1876,7 @@ var ProviderEndpointsApi = class {
 };
 
 // ../sdk/src/api/realtime.ts
-var enc4 = encodeURIComponent;
+var enc = encodeURIComponent;
 var RECONNECT_MIN_MS = 1e3;
 var RECONNECT_MAX_MS = 3e4;
 var RealtimeApi = class {
@@ -2229,7 +1887,7 @@ var RealtimeApi = class {
   async broadcast(channel, message, opts = {}) {
     const res = await request(this.ctx, {
       method: "POST",
-      path: `/api/v1/realtime/${enc4(channel)}/broadcast`,
+      path: `/api/v1/realtime/${enc(channel)}/broadcast`,
       body: { message },
       signal: opts.signal
     });
@@ -2239,7 +1897,7 @@ var RealtimeApi = class {
   async heartbeat(channel, opts = {}) {
     const res = await request(this.ctx, {
       method: "POST",
-      path: `/api/v1/realtime/${enc4(channel)}/presence`,
+      path: `/api/v1/realtime/${enc(channel)}/presence`,
       body: { meta: opts.meta, ttl_seconds: opts.ttlSeconds },
       signal: opts.signal
     });
@@ -2249,7 +1907,7 @@ var RealtimeApi = class {
   async presence(channel, opts = {}) {
     const res = await request(this.ctx, {
       method: "GET",
-      path: `/api/v1/realtime/${enc4(channel)}/presence`,
+      path: `/api/v1/realtime/${enc(channel)}/presence`,
       signal: opts.signal
     });
     return res.data;
@@ -2343,7 +2001,7 @@ async function* parseSseStream(response, signal) {
         if (boundary === -1) break;
         const block = buffer.slice(0, boundary);
         buffer = buffer.slice(boundary + 2);
-        const parsed = parseSseBlock3(block);
+        const parsed = parseSseBlock2(block);
         if (parsed) yield parsed;
       }
     }
@@ -2354,7 +2012,7 @@ async function* parseSseStream(response, signal) {
     }
   }
 }
-function parseSseBlock3(block) {
+function parseSseBlock2(block) {
   let id;
   let data = "";
   let isHeartbeat = false;
@@ -2604,42 +2262,6 @@ var SharingApi = class {
   }
 };
 
-// ../sdk/src/api/store.ts
-var StoreApi = class {
-  constructor(ctx) {
-    this.ctx = ctx;
-  }
-  /**
-   * Search the hub. Open envelope — items are heterogeneous (skills carry
-   * version/license, agents carry icons/prompts, computer templates carry
-   * sizing) so we surface them as `StoreItem` with an open index signature.
-   */
-  async search(query = {}, opts = {}) {
-    const res = await request(this.ctx, {
-      method: "GET",
-      path: "/api/v1/store/search",
-      query,
-      signal: opts.signal
-    });
-    return res.data;
-  }
-  /**
-   * Install a hub item into one of the caller's workspaces. Returns whatever
-   * the per-template installer produces (folder ids, agent ids, ...) —
-   * `StoreInstallResult` carries the common fields and leaves the rest
-   * open.
-   */
-  async install(resourceId, input, opts = {}) {
-    const res = await request(this.ctx, {
-      method: "POST",
-      path: `/api/v1/store/${resourceId}/install`,
-      body: input,
-      signal: opts.signal
-    });
-    return res.data;
-  }
-};
-
 // ../sdk/src/api/subscription.ts
 var SubscriptionApi = class {
   constructor(ctx) {
@@ -2655,271 +2277,6 @@ var SubscriptionApi = class {
   }
 };
 
-// ../sdk/src/api/tables.ts
-var enc5 = encodeURIComponent;
-var TablesApi = class {
-  constructor(ctx) {
-    this.ctx = ctx;
-  }
-  async list(opts = {}) {
-    const q = new URLSearchParams();
-    if (opts.workspaceId) q.set("workspace_id", opts.workspaceId);
-    if (opts.cursor) q.set("cursor", opts.cursor);
-    if (opts.limit) q.set("limit", String(opts.limit));
-    const qs = q.toString() ? `?${q.toString()}` : "";
-    const res = await request(this.ctx, {
-      method: "GET",
-      path: `/api/v1/tables${qs}`,
-      signal: opts.signal
-    });
-    return res.data;
-  }
-  async get(id, opts = {}) {
-    const res = await request(this.ctx, {
-      method: "GET",
-      path: `/api/v1/tables/${enc5(id)}`,
-      signal: opts.signal
-    });
-    return res.data;
-  }
-  async create(input, opts = {}) {
-    const res = await request(this.ctx, {
-      method: "POST",
-      path: "/api/v1/tables",
-      body: input,
-      signal: opts.signal
-    });
-    return res.data;
-  }
-  async update(id, input, opts = {}) {
-    const res = await request(this.ctx, {
-      method: "PATCH",
-      path: `/api/v1/tables/${enc5(id)}`,
-      body: input,
-      signal: opts.signal
-    });
-    return res.data;
-  }
-  async delete(id, opts = {}) {
-    return request(this.ctx, {
-      method: "DELETE",
-      path: `/api/v1/tables/${enc5(id)}`,
-      signal: opts.signal
-    });
-  }
-  /** Query a collection's records with the filter/sort/paginate DSL. */
-  async query(id, query = {}, opts = {}) {
-    const res = await request(this.ctx, {
-      method: "POST",
-      path: `/api/v1/tables/${enc5(id)}/query`,
-      body: query,
-      signal: opts.signal
-    });
-    return res.data;
-  }
-  async createRecord(id, values, opts = {}) {
-    const res = await request(this.ctx, {
-      method: "POST",
-      path: `/api/v1/tables/${enc5(id)}/records`,
-      body: { values },
-      signal: opts.signal
-    });
-    return res.data;
-  }
-  async getRecord(id, recordId, opts = {}) {
-    const res = await request(this.ctx, {
-      method: "GET",
-      path: `/api/v1/tables/${enc5(id)}/records/${enc5(recordId)}`,
-      signal: opts.signal
-    });
-    return res.data;
-  }
-  async updateRecord(id, recordId, values, opts = {}) {
-    const res = await request(this.ctx, {
-      method: "PATCH",
-      path: `/api/v1/tables/${enc5(id)}/records/${enc5(recordId)}`,
-      body: { values },
-      signal: opts.signal
-    });
-    return res.data;
-  }
-  async deleteRecord(id, recordId, opts = {}) {
-    return request(this.ctx, {
-      method: "DELETE",
-      path: `/api/v1/tables/${enc5(id)}/records/${enc5(recordId)}`,
-      signal: opts.signal
-    });
-  }
-  /** Export a collection's records as a CSV string (header row = field keys). */
-  async exportCsv(id, opts = {}) {
-    const res = await requestRaw(this.ctx, {
-      method: "GET",
-      path: `/api/v1/tables/${enc5(id)}/export`,
-      signal: opts.signal,
-      expectJson: false
-    });
-    return res.text();
-  }
-  /** Import records into a collection from a CSV string. Returns the count. */
-  async importCsv(id, csv, opts = {}) {
-    const res = await request(this.ctx, {
-      method: "POST",
-      path: `/api/v1/tables/${enc5(id)}/import`,
-      body: { csv },
-      signal: opts.signal
-    });
-    return res.data;
-  }
-};
-
-// ../sdk/src/api/triggers.ts
-var TriggersApi = class {
-  constructor(ctx) {
-    this.ctx = ctx;
-  }
-  // ---------------------------------------------------------------------------
-  //  CRUD
-  // ---------------------------------------------------------------------------
-  async list(query = {}, opts = {}) {
-    const res = await request(this.ctx, {
-      method: "GET",
-      path: "/api/v1/triggers",
-      query,
-      signal: opts.signal
-    });
-    return res.data;
-  }
-  /**
-   * Create a trigger. `workspace_id` is passed in the request BODY (alongside
-   * the flat trigger definition) — it is not a query param. The request
-   * body is flat: every scheduling field (`cron_expression`, …) and every
-   * action field (`agent_id`, `prompt_template`, `file_id`, …) sits at the
-   * top level — there are no nested `trigger_config` / `action_config`
-   * objects any more.
-   *
-   * For a `webhook` trigger the response additionally carries a one-time
-   * plaintext `secret` (use `TriggerWithSecret`); other trigger types
-   * resolve to a plain `Trigger`.
-   */
-  async create(workspaceId, input, opts = {}) {
-    const res = await request(
-      this.ctx,
-      {
-        method: "POST",
-        path: "/api/v1/triggers",
-        body: { workspace_id: workspaceId, ...input },
-        signal: opts.signal
-      }
-    );
-    return res.data;
-  }
-  async get(id, opts = {}) {
-    const res = await request(this.ctx, {
-      method: "GET",
-      path: `/api/v1/triggers/${id}`,
-      signal: opts.signal
-    });
-    return res.data;
-  }
-  async update(id, input, opts = {}) {
-    const res = await request(this.ctx, {
-      method: "PATCH",
-      path: `/api/v1/triggers/${id}`,
-      body: input,
-      signal: opts.signal
-    });
-    return res.data;
-  }
-  async delete(id, opts = {}) {
-    return request(this.ctx, {
-      method: "DELETE",
-      path: `/api/v1/triggers/${id}`,
-      signal: opts.signal
-    });
-  }
-  async archive(id, opts = {}) {
-    const res = await request(this.ctx, {
-      method: "POST",
-      path: `/api/v1/triggers/${id}/archive`,
-      signal: opts.signal
-    });
-    return res.data;
-  }
-  async unarchive(id, opts = {}) {
-    const res = await request(this.ctx, {
-      method: "POST",
-      path: `/api/v1/triggers/${id}/unarchive`,
-      signal: opts.signal
-    });
-    return res.data;
-  }
-  // ---------------------------------------------------------------------------
-  //  Fire + rotate-secret + runs
-  // ---------------------------------------------------------------------------
-  /**
-   * Fire a trigger via its webhook secret. This endpoint does NOT use the
-   * client's `ap_` key — the bearer is the trigger's secret — so we build a
-   * one-off HttpContext for it rather than mutating the shared one.
-   *
-   * Responds HTTP 202. The response identifies the fired trigger via `id`
-   * only.
-   */
-  async fire(id, input, opts = {}) {
-    const localCtx = {
-      apiUrl: this.ctx.apiUrl,
-      key: input.secret,
-      fetch: this.ctx.fetch
-    };
-    const res = await request(localCtx, {
-      method: "POST",
-      path: `/api/v1/triggers/${id}/fire`,
-      body: input.body ?? {},
-      signal: opts.signal
-    });
-    return res.data;
-  }
-  /**
-   * Rotate the webhook secret. Returns the trigger with a fresh one-time
-   * plaintext `secret` populated (`TriggerWithSecret`). The old secret
-   * immediately stops working.
-   */
-  async rotateSecret(id, opts = {}) {
-    const res = await request(this.ctx, {
-      method: "POST",
-      path: `/api/v1/triggers/${id}/rotate-secret`,
-      signal: opts.signal
-    });
-    return res.data;
-  }
-  /** Recent fires + their success/error outcome. */
-  async listRuns(id, query = {}, opts = {}) {
-    const res = await request(this.ctx, {
-      method: "GET",
-      path: `/api/v1/triggers/${id}/runs`,
-      query,
-      signal: opts.signal
-    });
-    return res.data;
-  }
-  async getCostStats(id, opts = {}) {
-    const res = await request(this.ctx, {
-      method: "GET",
-      path: `/api/v1/triggers/${id}/cost-stats`,
-      signal: opts.signal
-    });
-    return res.data;
-  }
-  async getCostStatsMap(query = {}, opts = {}) {
-    const res = await request(this.ctx, {
-      method: "GET",
-      path: "/api/v1/triggers/cost-stats",
-      query,
-      signal: opts.signal
-    });
-    return res.data.by_id;
-  }
-};
-
 // ../sdk/src/api/user.ts
 var UserApi = class {
   constructor(ctx) {
@@ -3616,24 +2973,19 @@ var IdaptClient2 = class {
     this.agents = new AgentsApi(v1Ctx);
     this.chats = new ChatsApi(v1Ctx);
     this.workspaces = new WorkspacesApi(v1Ctx);
-    this.triggers = new TriggersApi(v1Ctx);
+    this.automations = new AutomationsApi(v1Ctx);
     this.computers = new ComputersApi(v1Ctx);
     this.secrets = new SecretsApi(v1Ctx);
-    this.kv = new DatastoreApi(v1Ctx);
-    this.blobs = new BlobsApi(v1Ctx);
-    this.tables = new TablesApi(v1Ctx);
     this.realtime = new RealtimeApi(v1Ctx);
     this.apiKeys = new ApiKeysApi(v1Ctx);
     this.notifications = new NotificationsApi(v1Ctx);
     this.settings = new SettingsApi(v1Ctx);
     this.subscription = new SubscriptionApi(v1Ctx);
     this.sharing = new SharingApi(v1Ctx);
-    this.store = new StoreApi(v1Ctx);
     this.models = new ModelsApi(v1Ctx);
     this.providerEndpoints = new ProviderEndpointsApi(v1Ctx);
     this.images = new ImagesApi(v1Ctx);
     this.audio = new AudioApi(v1Ctx);
-    this.functions = new FunctionsApi(v1Ctx);
     this.search = new SearchApi(v1Ctx);
     this.web = new WebSearchApi(v1Ctx);
     this.guide = new GuideApi(v1Ctx);
@@ -4167,64 +3519,6 @@ function useDataFile(name, options = {}) {
   }, [client, load]);
   return { data, loading, error, save, refresh, remove };
 }
-function useLiveQuery(collectionResId, dsl = {}) {
-  const client = useIdapt();
-  const [records, setRecords] = react.useState([]);
-  const [loading, setLoading] = react.useState(true);
-  const [error, setError] = react.useState(null);
-  const dslKey = JSON.stringify(dsl);
-  const dslRef = react.useRef(dsl);
-  dslRef.current = dsl;
-  const [nonce, setNonce] = react.useState(0);
-  react.useEffect(() => {
-    if (!client || !collectionResId) return;
-    let active = true;
-    let inflight = false;
-    let queued = false;
-    const runQuery = async () => {
-      if (inflight) {
-        queued = true;
-        return;
-      }
-      inflight = true;
-      try {
-        const rows = await client.tables.query(collectionResId, dslRef.current);
-        if (!active) return;
-        setRecords(rows);
-        setError(null);
-      } catch (err) {
-        if (!active) return;
-        setError(err instanceof Error ? err : new Error(String(err)));
-      } finally {
-        inflight = false;
-        if (active) setLoading(false);
-        if (active && queued) {
-          queued = false;
-          void runQuery();
-        }
-      }
-    };
-    setLoading(true);
-    void runQuery();
-    const unsubscribe = client.realtime.subscribe(
-      [`table:${collectionResId}`],
-      (event) => {
-        if (event.type !== "broadcast") void runQuery();
-      },
-      { onError: (err) => active && setError(err) }
-    );
-    return () => {
-      active = false;
-      unsubscribe();
-    };
-  }, [client, collectionResId, dslKey, nonce]);
-  return {
-    records,
-    loading,
-    error,
-    refresh: () => setNonce((n) => n + 1)
-  };
-}
 var DEFAULT_INTERVAL_MS = 1e4;
 function usePresence(key, options = {}) {
   const client = useIdapt();
@@ -4271,7 +3565,6 @@ exports.useChannel = useChannel;
 exports.useDataFile = useDataFile;
 exports.useIdapt = useIdapt;
 exports.useIdaptError = useIdaptError;
-exports.useLiveQuery = useLiveQuery;
 exports.usePresence = usePresence;
 //# sourceMappingURL=react.cjs.map
 //# sourceMappingURL=react.cjs.map