@pawabase/client 0.1.3 → 0.2.0

package/src/functions.ts

@@ -24,55 +24,6 @@ function pass(options: CallOptions): {
   };
 }
 
-export interface FetchOptions extends CallOptions {
-  method?: string;
-  query?: Record<string, QueryValue | QueryValue[]>;
-  /** An object is sent as JSON; strings, `Blob`, `FormData`, buffers and streams as they are. */
-  body?: unknown;
-  /** Run the function deployed on this branch (`x-pawabase-branch`). */
-  branch?: string;
-}
-
-/** Functions you wrote in your project's code, invoked at `/functions/v1/<name>`. */
-export class FunctionsClient {
-  constructor(private readonly http: HttpClient) {}
-
-  /**
-   * Call a function and return what it returned. The API key needs the
-   * `functions:invoke` scope (an unrestricted key has it).
-   */
-  async invoke<T = unknown>(name: string, input?: unknown, options: CallOptions = {}): Promise<T> {
-    const body = await this.http.request<{ data: T } | undefined>({
-      method: "POST",
-      path: `/functions/v1/${encodePath(name)}`,
-      body: input === undefined ? undefined : input,
-      ...pass(options),
-    });
-    return (body as { data: T } | undefined)?.data as T;
-  }
-
-  /**
-   * Call an HTTP function (`functions/<name>/index.ts`) with any method and path, and get its `Response` as it is — status, headers
-   * and a streaming body. An error status is returned, not thrown; the API key and the signed-in user's token are sent as for any call.
-   *
-   * ```ts
-   * const res = await pawabase.functions.fetch("orders", "/42/items", { method: "POST", body: { sku: "A1" } });
-   * if (res.ok) console.log(await res.json());
-   * ```
-   */
-  fetch(name: string, path = "/", options: FetchOptions = {}): Promise<Response> {
-    const rest = path === "/" || path === "" ? "" : path.startsWith("/") ? path : `/${path}`;
-    return this.http.send({
-      method: options.method ?? (options.body === undefined ? "GET" : "POST"),
-      path: `/functions/v1/${encodePath(name)}${rest}`,
-      ...(options.query ? { query: options.query } : {}),
-      ...(options.body !== undefined ? { body: options.body } : {}),
-      ...pass({ ...options, headers: { ...(options.branch ? { "x-pawabase-branch": options.branch } : {}), ...options.headers } }),
-      throwOnError: false,
-    });
-  }
-}
-
 /**
  * Flows with an HTTP trigger that has no path, invoked at `/flows/v1/<name>`.
  * (Flows bound to a path are reached as routes, see {@link RoutesClient}.)

package/src/index.ts

@@ -1,12 +1,17 @@
 export { PawabaseClient, createClient } from "./client.js";
 export type { ClientOptions, DatabaseShape } from "./client.js";
 
+export { AiClient } from "./ai.js";
+export { AgentsClient, KnowledgeClient } from "./agents.js";
+export type { AgentEvent, AgentRun, AgentRunOptions, AgentRunStatus, KnowledgeDocument, KnowledgeHit } from "./agents.js";
+export type { AiModelInfo, ChatCompletion, ChatMessage, ChatOptions } from "./ai.js";
 export { AuthClient } from "./auth.js";
 export type {
   AuthChangeEvent,
   AuthListener,
   AuthOptions,
   IssuedToken,
+  MachineToken,
   Passkey,
   PasskeyChallenge,
   SignInResult,
@@ -29,7 +34,7 @@ export type {
   ResourceTypes,
 } from "./data.js";
 
-export { FlowsClient, FunctionsClient, RoutesClient } from "./functions.js";
+export { FlowsClient, RoutesClient } from "./functions.js";
 export type { CallOptions, RouteOptions } from "./functions.js";
 
 export { BucketClient, StorageClient } from "./files.js";

package/src/manage/access.ts

@@ -15,8 +15,8 @@ export class Keys extends Service {
   }
 
   /**
-   * Make a key; the key itself is in the answer once. `scopes` limit what it may do (`resource:read`, `functions:invoke`…),
-   * `allowedIps` and `allowedRoutes` (`"GET /rest/v1/orders"`, `"/functions/v1/*"`) limit where and what it may call.
+   * Make a key; the key itself is in the answer once. `scopes` limit what it may do (`resource:read`, `routes:invoke`…),
+   * `allowedIps` and `allowedRoutes` (`"GET /rest/v1/orders"`, `"/flows/v1/*"`) limit where and what it may call.
    */
   create(name: string, options: { role?: "publishable" | "secret"; scopes?: string[]; expiresAt?: When; allowedIps?: string[]; allowedRoutes?: string[] } = {}): Promise<Api> {
     return this.post("/keys", {
@@ -39,7 +39,7 @@ export class Keys extends Service {
   }
 }
 
-/** Secrets functions and flows read (`ctx.runtime.secret(name)`). Values are never returned. */
+/** Secrets flows read (`ctx.runtime.secret(name)`). Values are never returned. */
 export class Secrets extends Service {
   list(): Promise<Api> {
     return this.get("/secrets");
@@ -111,96 +111,3 @@ export interface FirewallRule {
   expiresAt?: When;
   note?: string;
 }
-
-/**
- * The firewall at the gateway: ordered rules (allow, block, log, rate limit), managed attack signatures, bans, and what it did.
- *
- * ```ts
- * await m.firewall.addRule({ name: "Burst", action: "rate_limit",
- *   conditions: [{ field: "path", op: "starts_with", value: "/auth/v1/token" }],
- *   rateLimit: { requests: 10, window_seconds: 60, by: "ip", ban_seconds: 900 } });
- * ```
- */
-export class Firewall extends Service {
-  /** Rules in the order they are tried. */
-  rules(): Promise<Api> {
-    return this.get("/firewall");
-  }
-
-  /** Add a rule at the end. */
-  addRule(rule: FirewallRule): Promise<Api> {
-    return this.post("/firewall", {
-      name: rule.name,
-      action: rule.action ?? "block",
-      conditions: rule.conditions ?? [],
-      logic: rule.logic ?? "all",
-      match: rule.match ?? {},
-      rate_limit: rule.rateLimit,
-      mode: rule.mode ?? "enforce",
-      enabled: rule.enabled ?? true,
-      expires_at: iso(rule.expiresAt),
-      note: rule.note ?? "",
-    });
-  }
-
-  /** Change some fields of a rule, using the server's field names (`clear_expiry: true` removes an expiry). */
-  updateRule(ruleId: string, changes: Body): Promise<Api> {
-    return this.patch(seg("firewall", ruleId), changes);
-  }
-
-  removeRule(ruleId: string): Promise<Api> {
-    return this.del(seg("firewall", ruleId));
-  }
-
-  /** Set the order rules are tried in: every rule exactly once. */
-  order(ruleIds: string[]): Promise<Api> {
-    return this.put("/firewall-order", { ids: ruleIds });
-  }
-
-  /** Managed rule sets (`sqli`, `xss`, `traversal`, `scanners`, `sensitive_files`, `no_user_agent`, `methods`) and automatic bans. */
-  config(): Promise<Api> {
-    return this.get("/firewall-config");
-  }
-
-  /** `managed`: `{ sqli: "block", scanners: "log" }` (`off`, `log`, `block`). `autoBan`: `{ enabled, threshold, window_seconds, ban_seconds, statuses, exempt }`. */
-  setConfig(options: { managed?: Record<string, string>; autoBan?: Body }): Promise<Api> {
-    return this.put("/firewall-config", { managed: options.managed, auto_ban: options.autoBan });
-  }
-
-  bans(options: { includeExpired?: boolean } = {}): Promise<Api> {
-    return this.get("/firewall-bans", { all: options.includeExpired ? 1 : undefined });
-  }
-
-  /** Ban an address or CIDR range for `seconds` (`0`: until lifted). */
-  ban(ip: string, options: { seconds?: number; reason?: string } = {}): Promise<Api> {
-    return this.post("/firewall-bans", { ip, seconds: options.seconds ?? 0, reason: options.reason ?? "" });
-  }
-
-  liftBan(banId: string): Promise<Api> {
-    return this.del(seg("firewall-bans", banId));
-  }
-
-  events(options: { action?: string; source?: string; ip?: string; path?: string; ruleId?: string; limit?: number } = {}): Promise<Api> {
-    const { ruleId, ...rest } = options;
-    return this.get("/firewall-events", { limit: 100, ...rest, rule_id: ruleId });
-  }
-
-  /** Totals, a timeline, and the top addresses, paths, rules and countries. */
-  stats(options: { hours?: number } = {}): Promise<Api> {
-    return this.get("/firewall-stats", { hours: options.hours ?? 24 });
-  }
-
-  /** What the firewall would do with a request, step by step. Nothing is sent or counted. */
-  test(ip: string, options: { path?: string; method?: string; userAgent?: string; query?: string; headers?: Record<string, string>; country?: string; role?: string } = {}): Promise<Api> {
-    return this.post("/firewall-test", {
-      ip,
-      path: options.path ?? "/",
-      method: options.method ?? "GET",
-      user_agent: options.userAgent ?? "",
-      query: options.query ?? "",
-      headers: options.headers ?? {},
-      country: options.country ?? "",
-      role: options.role ?? "none",
-    });
-  }
-}

package/src/manage/agents.ts

@@ -0,0 +1,98 @@
+import { Definitions, Service, seg, type Api, type Body, type Query } from "./base.js";
+
+/**
+ * Agents: a model with instructions, tools and knowledge, run on the server with approvals, limits and threads.
+ *
+ * ```ts
+ * await m.agents.create({ name: "support", model: "chat", instructions: "Answer from the docs.", knowledge: ["docs"] });
+ * const run = await m.agents.run("support", "How do I reset a password?");
+ * ```
+ */
+export class Agents extends Definitions {
+  protected override readonly kind = "agents";
+
+  /** Run an agent as the studio would. `thread` carries a conversation on; `background` returns before it finishes. */
+  run(name: string, input: string, options: { thread?: string; background?: boolean } = {}): Promise<Api> {
+    return this.post(seg(this.kind, name, "runs"), { input, thread: options.thread, background: options.background ?? false });
+  }
+}
+
+/** Agent runs: what each did, step by step, and the ones waiting for someone to approve a tool call. */
+export class AgentRuns extends Service {
+  /** Newest first. Filter by `agent`, `status` or `thread`. */
+  list(options: { agent?: string; status?: string; thread?: string; limit?: number; offset?: number } = {}): Promise<Api> {
+    return this.get("/agent-runs", options as Query);
+  }
+
+  getOne(runId: string): Promise<Api> {
+    return this.get(seg("agent-runs", runId));
+  }
+
+  /** Approve or decline what a run is waiting on: a decision per call id, and `approve` for any not named. */
+  decide(runId: string, options: { decisions?: Record<string, boolean>; approve?: boolean; background?: boolean } = {}): Promise<Api> {
+    return this.post(seg("agent-runs", runId, "decide"), { decisions: options.decisions ?? {}, approve: options.approve, background: options.background ?? false });
+  }
+
+  remove(runId: string): Promise<Api> {
+    return this.del(seg("agent-runs", runId));
+  }
+
+  /** The tools an agent can be given, by kind. */
+  tools(): Promise<Api> {
+    return this.get("/agent-tools");
+  }
+}
+
+/** Knowledge bases: documents split and embedded so agents can search them by meaning and by words. */
+export class KnowledgeBases extends Definitions {
+  protected override readonly kind = "knowledge-bases";
+
+  documents(name: string, options: { limit?: number; offset?: number } = {}): Promise<Api> {
+    return this.get(seg(this.kind, name, "documents"), options);
+  }
+
+  /** Add text, or a web page to read (`url`). Adding the same `source` again replaces it. */
+  addDocument(name: string, input: { text?: string; url?: string; title?: string; source?: string }): Promise<Api> {
+    return this.post(seg(this.kind, name, "documents"), { title: input.title ?? "", source: input.source ?? "", text: input.text, url: input.url });
+  }
+
+  /** Add a file (PDF, Word, HTML or text). */
+  addFile(name: string, file: Blob, options: { title?: string; source?: string; filename?: string } = {}): Promise<Api> {
+    const form = new FormData();
+    form.append("file", file, options.filename ?? (file as File).name ?? "document");
+    if (options.title) form.append("title", options.title);
+    if (options.source) form.append("source", options.source);
+    return this.post(seg(this.kind, name, "documents"), form);
+  }
+
+  removeDocument(name: string, documentId: string): Promise<Api> {
+    return this.del(seg(this.kind, name, "documents", documentId));
+  }
+
+  /** Split and embed a document again, for one that failed or after changing the base's chunk size. */
+  reindexDocument(name: string, documentId: string): Promise<Api> {
+    return this.post(seg(this.kind, name, "documents", documentId, "reindex"));
+  }
+
+  /** What an agent would find. */
+  search(name: string, query: string, options: { limit?: number } = {}): Promise<Api> {
+    return this.post(seg(this.kind, name, "search"), { query, limit: options.limit ?? 5 });
+  }
+
+  /** Bring in pages from a Notion connection; pages unchanged since last time are skipped. */
+  sync(name: string, connection: string): Promise<Api> {
+    return this.post(seg(this.kind, name, "sync"), { connection });
+  }
+}
+
+/** Connections: stored access to outside services (MCP servers, Notion, web search) that agents use as tools. The secret is sealed on arrival. */
+export class Connections extends Definitions {
+  protected override readonly kind = "connections";
+
+  /** Call the service with the stored key and say what was found, or why it could not be reached. */
+  test(name: string): Promise<Api> {
+    return this.post(seg(this.kind, name, "test"));
+  }
+}
+
+export type { Body };

package/src/manage/ai.ts

@@ -0,0 +1,129 @@
+import { Service, seg, type Api, type Body } from "./base.js";
+
+/**
+ * The AI gateway of the environment: connect providers (OpenAI, Anthropic, Gemini, Mistral, Groq, or any OpenAI-compatible server), expose
+ * models by name, try them, and read what they cost. Provider keys are sealed on arrival and never returned.
+ */
+export class Ai extends Service {
+  protected override path(suffix = ""): string {
+    return super.path(`/ai${suffix}`);
+  }
+
+  /** The kinds of provider that can be connected, with suggested models. */
+  catalog(): Promise<Api> {
+    return this.get("/catalog");
+  }
+
+  providers(): Promise<Api> {
+    return this.get("/providers");
+  }
+
+  /** The models a connected provider offers this key, asked live: `{ data: [{ id, kind, label }], source: "provider" | "catalog", error }`. */
+  providerModels(name: string): Promise<Api> {
+    return this.get(seg("providers", name, "models"));
+  }
+
+  /** Connect a provider. `kind` is `openai`, `anthropic`, `gemini`, `mistral`, `groq` or `openai_compatible` (which needs `baseUrl`). */
+  connect(input: { name: string; kind: string; key?: string; baseUrl?: string }): Promise<Api> {
+    return this.post("/providers", { name: input.name, kind: input.kind, key: input.key ?? "", base_url: input.baseUrl ?? "" });
+  }
+
+  updateProvider(name: string, input: { key?: string; baseUrl?: string; enabled?: boolean }): Promise<Api> {
+    return this.patch(seg("providers", name), { key: input.key, base_url: input.baseUrl, enabled: input.enabled });
+  }
+
+  /** Disconnect a provider and every model on it. */
+  disconnect(name: string): Promise<Api> {
+    return this.del(seg("providers", name));
+  }
+
+  models(): Promise<Api> {
+    return this.get("/models");
+  }
+
+  /**
+   * Expose a model under `alias`. `policy` is who may call it: `service` (servers only, the default), `authenticated`, `public`, or a
+   * named policy. `params` are defaults such as `system` and `temperature`; prices are USD per million tokens.
+   */
+  addModel(input: {
+    alias: string;
+    provider: string;
+    upstream: string;
+    kind?: "chat" | "embedding";
+    description?: string;
+    policy?: unknown;
+    params?: Body;
+    dimensions?: number;
+    inputPrice?: number;
+    outputPrice?: number;
+    fallback?: string;
+    enabled?: boolean;
+  }): Promise<Api> {
+    return this.post("/models", {
+      alias: input.alias,
+      provider: input.provider,
+      upstream: input.upstream,
+      kind: input.kind ?? "chat",
+      description: input.description ?? "",
+      policy: input.policy ?? "service",
+      params: input.params ?? {},
+      dimensions: input.dimensions,
+      input_price: input.inputPrice,
+      output_price: input.outputPrice,
+      fallback: input.fallback,
+      enabled: input.enabled ?? true,
+    });
+  }
+
+  updateModel(
+    alias: string,
+    input: { provider?: string; upstream?: string; description?: string; policy?: unknown; params?: Body; dimensions?: number | null; inputPrice?: number | null; outputPrice?: number | null; fallback?: string | null; enabled?: boolean },
+  ): Promise<Api> {
+    return this.patch(seg("models", alias), {
+      provider: input.provider,
+      upstream: input.upstream,
+      description: input.description,
+      policy: input.policy,
+      params: input.params,
+      dimensions: input.dimensions,
+      input_price: input.inputPrice,
+      output_price: input.outputPrice,
+      fallback: input.fallback,
+      enabled: input.enabled,
+    });
+  }
+
+  removeModel(alias: string): Promise<Api> {
+    return this.del(seg("models", alias));
+  }
+
+  /** Send one request to a model, the way Studio's playground does. Returns `{ text, usage, ms }`, or `{ error }`. */
+  tryModel(alias: string, input: { messages?: Body[]; input?: string[]; maxTokens?: number } = {}): Promise<Api> {
+    return this.post(seg("models", alias, "try"), { messages: input.messages, input: input.input, max_tokens: input.maxTokens });
+  }
+
+  /** Calls, tokens, cost and latency over `days` (1 to 90), in all and per model. */
+  usage(options: { days?: number } = {}): Promise<Api> {
+    return this.get("/usage", { days: options.days ?? 7 });
+  }
+
+  /** Recent calls. Never includes what was asked or answered. */
+  requests(options: { alias?: string; failed?: boolean; limit?: number } = {}): Promise<Api> {
+    return this.get("/requests", { alias: options.alias, failed: options.failed ? "true" : undefined, limit: options.limit ?? 50 });
+  }
+
+  /** Vector fields in the environment, and how many records have no vector yet. */
+  vectors(): Promise<Api> {
+    return this.get("/vectors");
+  }
+
+  /** Embed up to `limit` records of a resource that have no vector. Call again while `embedded` is above zero. */
+  backfill(resource: string, options: { limit?: number } = {}): Promise<Api> {
+    return this.post(seg("backfill", resource), undefined, { limit: options.limit ?? 100 });
+  }
+
+  /** Search a resource by meaning, as the Studio does: with `text` or a `vector`. */
+  search(resource: string, input: { text?: string; vector?: number[]; field?: string; metric?: "cosine" | "l2" | "ip"; limit?: number }): Promise<Api> {
+    return this.post(seg("search", resource), { text: input.text, vector: input.vector, field: input.field, metric: input.metric ?? "cosine", limit: input.limit ?? 10 });
+  }
+}

package/src/manage/base.ts

@@ -55,29 +55,29 @@ export class Service {
 
 /**
  * A kind of definition an environment holds (`flows`, `policies`, `webhooks`…): list, get, create, replace, remove.
- * Pass `branch` to work on a feature branch's draft instead of the live environment. A definition is addressed by its name
+ * A definition is addressed by its name
  * (inbound hooks: their slug).
  */
 export class Definitions extends Service {
   protected readonly kind: string = "";
 
-  list(options: { branch?: string } = {}): Promise<Api> {
-    return this.get(seg(this.kind), { branch: options.branch });
+  list(): Promise<Api> {
+    return this.get(seg(this.kind));
   }
 
-  getOne(key: string, options: { branch?: string } = {}): Promise<Api> {
-    return this.get(seg(this.kind, key), { branch: options.branch });
+  getOne(key: string): Promise<Api> {
+    return this.get(seg(this.kind, key));
   }
 
-  create(body: Body, options: { branch?: string } = {}): Promise<Api> {
-    return this.post(seg(this.kind), body, { branch: options.branch });
+  create(body: Body): Promise<Api> {
+    return this.post(seg(this.kind), body);
   }
 
-  replace(key: string, body: Body, options: { branch?: string } = {}): Promise<Api> {
-    return this.put(seg(this.kind, key), body, { branch: options.branch });
+  replace(key: string, body: Body): Promise<Api> {
+    return this.put(seg(this.kind, key), body);
   }
 
-  remove(key: string, options: { branch?: string } = {}): Promise<Api> {
-    return this.del(seg(this.kind, key), { branch: options.branch });
+  remove(key: string): Promise<Api> {
+    return this.del(seg(this.kind, key));
   }
 }

package/src/manage/data.ts

@@ -100,7 +100,7 @@ export class Schema extends Service {
   }
 }
 
-/** Named access policies (conditions) that resources, buckets, channels and functions refer to. */
+/** Named access policies (conditions) that resources, buckets and channels refer to. */
 export class Policies extends Definitions {
   protected override readonly kind = "policies";
 }
@@ -110,11 +110,6 @@ export class Schemas extends Definitions {
   protected override readonly kind = "schemas";
 }
 
-/** Transformers that reshape a field's value on the way out (hide, mask, format). */
-export class Transformers extends Definitions {
-  protected override readonly kind = "transformers";
-}
-
 /** Custom HTTP routes under `/rest` that run a flow. */
 export class Routes extends Definitions {
   protected override readonly kind = "routes";
@@ -135,25 +130,25 @@ export class Database extends Service {
     return this.get(seg("database", "tables", table, "rows"), { limit: options.limit, offset: options.offset, sort: options.sort, ...options.filters });
   }
 
-  /** Run one statement. A write needs `allowWrite`; it is audited and clears the environment's caches. */
-  query(sql: string, params: unknown[] = [], options: { allowWrite?: boolean } = {}): Promise<Api> {
-    return this.post("/database/query", { sql, params, allow_write: options.allowWrite ?? false });
+  /** Saved queries: the SQL console's bookmarks. */
+  savedQueries(): Promise<Api> {
+    return this.get("/database/queries");
   }
-}
 
-/** The runtime capabilities a function sees, called remotely (what `pawabase emulate` uses). */
-export class Runtime extends Service {
-  call(method: string, args: unknown[] = [], kwargs: Body = {}, options: { asUser?: Body; branch?: string } = {}): Promise<Api> {
-    return this.post("/runtime/call", { method, args, kwargs, as_user: options.asUser ?? null, branch: options.branch ?? null });
+  saveQuery(input: { name: string; sql: string; description?: string }): Promise<Api> {
+    return this.post("/database/queries", { name: input.name, sql: input.sql, description: input.description ?? "" });
   }
 
-  /** `fetch`, `insert`, `execute`, `begin`, `commit`…, optionally inside a transaction (`tx`). */
-  sql(op: string, fields: Body = {}): Promise<Api> {
-    return this.post("/runtime/db", { op, ...fields });
+  updateQuery(queryId: string, input: { name: string; sql: string; description?: string }): Promise<Api> {
+    return this.put(seg("database", "queries", queryId), { name: input.name, sql: input.sql, description: input.description ?? "" });
   }
 
-  /** Who a user access token belongs to. */
-  identify(token: string | null): Promise<Api> {
-    return this.post("/runtime/identify", { token });
+  deleteQuery(queryId: string): Promise<Api> {
+    return this.del(seg("database", "queries", queryId));
+  }
+
+  /** Run one statement. A write needs `allowWrite`; it is audited and clears the environment's caches. */
+  query(sql: string, params: unknown[] = [], options: { allowWrite?: boolean } = {}): Promise<Api> {
+    return this.post("/database/query", { sql, params, allow_write: options.allowWrite ?? false });
   }
 }

package/src/manage/files.ts

@@ -64,12 +64,23 @@ export class Buckets extends Definitions {
   revokeShare(bucket: string, shareId: string): Promise<Api> {
     return this.del(seg(this.kind, bucket, "shares", shareId));
   }
+
+  /** Make an empty folder (`prefix` like `reports/2026`). */
+  createFolder(bucket: string, prefix: string): Promise<Api> {
+    return this.post(seg(this.kind, bucket, "folders"), { prefix });
+  }
+
+  /** Remove a folder; it must be empty. */
+  deleteFolder(bucket: string, prefix: string): Promise<Api> {
+    return this.del(`${seg(this.kind, bucket, "folders")}/${prefix.split("/").filter(Boolean).map(encodeURIComponent).join("/")}`);
+  }
 }
 
 /** The environment's response cache. */
 export class Cache extends Service {
+  /** The project's cache statistics (not scoped to one environment). */
   stats(): Promise<Api> {
-    return this.get("/cache");
+    return this.project("GET", "/cache");
   }
 
   /** Drop cached responses by tag (`resource:posts`) or for whole resources. */

package/src/manage/index.ts

@@ -14,12 +14,13 @@
 import type { PawabaseClient } from "../client.js";
 import { ConfigError } from "../errors.js";
 import { isSecretKey } from "../util.js";
-import { Domains, Firewall, Keys, Secrets } from "./access.js";
+import { Domains, Keys, Secrets } from "./access.js";
+import { AgentRuns, Agents, Connections, KnowledgeBases } from "./agents.js";
+import { Ai } from "./ai.js";
 import { Events, Flows, InboundHooks, Jobs, Schedules, Subscriptions, Webhooks } from "./automation.js";
-import { Database, Policies, Resources, Routes, Runtime, Schema, Schemas, Transformers } from "./data.js";
+import { Database, Policies, Resources, Routes, Schema, Schemas } from "./data.js";
 import { Buckets, Cache } from "./files.js";
-import { Functions } from "./functions.js";
-import { Backups, Environments, Releases } from "./lifecycle.js";
+import { Backups, Environments, Versions } from "./lifecycle.js";
 import { Mail, MailTemplates } from "./mail.js";
 import { Alarms, Health, Observability, StatusPage } from "./observe.js";
 import { Dashboards, RealtimeChannels } from "./realtime.js";
@@ -30,10 +31,8 @@ export class Manage {
   readonly schema: Schema;
   readonly policies: Policies;
   readonly schemas: Schemas;
-  readonly transformers: Transformers;
   readonly routes: Routes;
   readonly database: Database;
-  readonly runtime: Runtime;
   // automation
   readonly flows: Flows;
   readonly schedules: Schedules;
@@ -42,7 +41,6 @@ export class Manage {
   readonly webhooks: Webhooks;
   readonly inboundHooks: InboundHooks;
   readonly jobs: Jobs;
-  readonly functions: Functions;
   // files and mail
   readonly buckets: Buckets;
   readonly cache: Cache;
@@ -55,15 +53,20 @@ export class Manage {
   readonly keys: Keys;
   readonly secrets: Secrets;
   readonly domains: Domains;
-  readonly firewall: Firewall;
   // observe
   readonly observability: Observability;
   readonly alarms: Alarms;
   readonly statusPage: StatusPage;
   readonly health: Health;
+  // ai
+  readonly ai: Ai;
+  readonly agents: Agents;
+  readonly agentRuns: AgentRuns;
+  readonly knowledgeBases: KnowledgeBases;
+  readonly connections: Connections;
   // lifecycle
   readonly environments: Environments;
-  readonly releases: Releases;
+  readonly versions: Versions;
   readonly backups: Backups;
 
   constructor(
@@ -75,10 +78,8 @@ export class Manage {
     this.schema = new Schema(http, environment);
     this.policies = new Policies(http, environment);
     this.schemas = new Schemas(http, environment);
-    this.transformers = new Transformers(http, environment);
     this.routes = new Routes(http, environment);
     this.database = new Database(http, environment);
-    this.runtime = new Runtime(http, environment);
     this.flows = new Flows(http, environment);
     this.schedules = new Schedules(http, environment);
     this.subscriptions = new Subscriptions(http, environment);
@@ -86,7 +87,6 @@ export class Manage {
     this.webhooks = new Webhooks(http, environment);
     this.inboundHooks = new InboundHooks(http, environment);
     this.jobs = new Jobs(http, environment);
-    this.functions = new Functions(http, environment);
     this.buckets = new Buckets(http, environment);
     this.cache = new Cache(http, environment);
     this.mail = new Mail(http, environment);
@@ -96,13 +96,17 @@ export class Manage {
     this.keys = new Keys(http, environment);
     this.secrets = new Secrets(http, environment);
     this.domains = new Domains(http, environment);
-    this.firewall = new Firewall(http, environment);
     this.observability = new Observability(http, environment);
     this.alarms = new Alarms(http, environment);
     this.statusPage = new StatusPage(http, environment);
     this.health = new Health(http, environment);
+    this.ai = new Ai(http, environment);
+    this.agents = new Agents(http, environment);
+    this.agentRuns = new AgentRuns(http, environment);
+    this.knowledgeBases = new KnowledgeBases(http, environment);
+    this.connections = new Connections(http, environment);
     this.environments = new Environments(http, environment);
-    this.releases = new Releases(http, environment);
+    this.versions = new Versions(http, environment);
     this.backups = new Backups(http, environment);
   }
 
@@ -125,7 +129,6 @@ export * from "./automation.js";
 export * from "./base.js";
 export * from "./data.js";
 export * from "./files.js";
-export * from "./functions.js";
 export * from "./lifecycle.js";
 export * from "./mail.js";
 export * from "./observe.js";