@backflow.sdk/client 0.1.0

package/dist/index.js

@@ -0,0 +1,2945 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AgentAnalysisResource: () => AgentAnalysisResource,
+  AnalyticsResource: () => AnalyticsResource,
+  AssetsResource: () => AssetsResource,
+  Backflow: () => BackflowSDK,
+  BackflowClient: () => BackflowClient,
+  BackflowSDK: () => BackflowSDK,
+  BatchResource: () => BatchResource,
+  CACHE_OPERATIONS: () => CACHE_OPERATIONS,
+  CHUNKING_STRATEGIES: () => CHUNKING_STRATEGIES,
+  CLI_PROVIDERS: () => CLI_PROVIDERS,
+  CONDITION_OPERATORS: () => CONDITION_OPERATORS,
+  CacheResource: () => CacheResource,
+  DB_OPERATIONS: () => DB_OPERATIONS,
+  DB_PROVIDERS: () => DB_PROVIDERS,
+  DefaultResource: () => DefaultResource,
+  DeploymentResource: () => DeploymentResource,
+  EmbeddingsResource: () => EmbeddingsResource,
+  FeedbackResource: () => FeedbackResource,
+  FilesResource: () => FilesResource,
+  GithubResource: () => GithubResource,
+  GoalsResource: () => GoalsResource,
+  GoogleDriveResource: () => GoogleDriveResource,
+  HTTP_METHODS: () => HTTP_METHODS,
+  IMAGE_DETAILS: () => IMAGE_DETAILS,
+  JiraResource: () => JiraResource,
+  LLM_PROVIDERS: () => LLM_PROVIDERS,
+  LlmResource: () => LlmResource,
+  McpToolsResource: () => McpToolsResource,
+  NOTIFY_CHANNELS: () => NOTIFY_CHANNELS,
+  NOTIFY_PRIORITIES: () => NOTIFY_PRIORITIES,
+  PolarResource: () => PolarResource,
+  ProjectsResource: () => ProjectsResource,
+  PublishResource: () => PublishResource,
+  QueuesResource: () => QueuesResource,
+  RAG_MODES: () => RAG_MODES,
+  STORAGE_OPERATIONS: () => STORAGE_OPERATIONS,
+  SearchResource: () => SearchResource,
+  StripeResource: () => StripeResource,
+  TOOL_PARAM_CONTEXT: () => TOOL_PARAM_CONTEXT,
+  TOOL_TYPES: () => TOOL_TYPES,
+  TRIGGER_TYPES: () => TRIGGER_TYPES,
+  TeamsResource: () => TeamsResource,
+  TenantWebhookReceiversResource: () => TenantWebhookReceiversResource,
+  TenantWebhooksResource: () => TenantWebhooksResource,
+  ToolDiscoveryResource: () => ToolDiscoveryResource,
+  TrackingResource: () => TrackingResource,
+  TwitterResource: () => TwitterResource,
+  UsageResource: () => UsageResource,
+  WORKFLOW_VALIDATION_SCHEMA: () => WORKFLOW_VALIDATION_SCHEMA,
+  WebsocketResource: () => WebsocketResource,
+  WorkflowsResource: () => WorkflowsResource,
+  WorkspacesResource: () => WorkspacesResource,
+  createBackflow: () => createBackflow,
+  getSDKDocs: () => getSDKDocs,
+  getSDKDocsCompact: () => getSDKDocsCompact,
+  toCompactContext: () => toCompactContext,
+  toPromptContext: () => toPromptContext
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/client.ts
+var DEFAULT_ENDPOINT = "https://api.backflow.dev";
+var BackflowClient = class {
+  constructor(config) {
+    this.tokenCache = null;
+    this.tokenPromise = null;
+    const clientKey = config.clientKey;
+    if (!clientKey && !config.getAuthToken) {
+      throw new Error("Either clientKey or getAuthToken is required");
+    }
+    this.config = {
+      ...config,
+      clientKey,
+      endpoint: config.endpoint?.replace(/\/$/, "") || DEFAULT_ENDPOINT
+    };
+  }
+  async exchangeApiKeyForToken() {
+    const response = await fetch(`${this.config.endpoint}/auth/token`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": this.config.clientKey
+      }
+    });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ error: "Token exchange failed" }));
+      throw new Error(error.error || "Failed to exchange API key for token");
+    }
+    const data = await response.json();
+    const expiresAt = Date.now() + data.expiresIn * 1e3 * 0.8;
+    return { token: data.token, expiresAt };
+  }
+  async getToken() {
+    if (this.config.getAuthToken) {
+      return this.config.getAuthToken();
+    }
+    if (this.tokenCache && Date.now() < this.tokenCache.expiresAt) {
+      return this.tokenCache.token;
+    }
+    if (this.tokenPromise) {
+      const cache = await this.tokenPromise.then(() => this.tokenCache);
+      return cache.token;
+    }
+    this.tokenPromise = this.exchangeApiKeyForToken().then((cache) => {
+      this.tokenCache = cache;
+      this.tokenPromise = null;
+      return cache.token;
+    }).catch((err) => {
+      this.tokenPromise = null;
+      throw err;
+    });
+    return this.tokenPromise;
+  }
+  get endpoint() {
+    return this.config.endpoint;
+  }
+  async request(path, options = {}) {
+    const { params, body, ...fetchOptions } = options;
+    const startTime = Date.now();
+    const debug = this.config.debug ?? false;
+    let ctx = {
+      method: fetchOptions.method || "GET",
+      path,
+      params,
+      body,
+      startTime
+    };
+    if (this.config.middleware?.onRequest) {
+      const result = await this.config.middleware.onRequest(ctx);
+      if (result) ctx = result;
+    }
+    let url = `${this.config.endpoint}${ctx.path}`;
+    if (ctx.params) {
+      const searchParams = new URLSearchParams();
+      Object.entries(ctx.params).forEach(([key, value]) => {
+        if (value !== void 0) {
+          searchParams.append(key, String(value));
+        }
+      });
+      const queryString = searchParams.toString();
+      if (queryString) {
+        url += `?${queryString}`;
+      }
+    }
+    const headers = {
+      "Content-Type": "application/json",
+      ...fetchOptions.headers || {}
+    };
+    const token = await this.getToken();
+    if (token) {
+      headers["Authorization"] = `Bearer ${token}`;
+    }
+    if (debug) {
+      console.log(`[Backflow] \u2192 ${ctx.method} ${url}`);
+      console.log(
+        `[Backflow] clientKey: ${this.config.clientKey ? "***" : "(not set)"}`
+      );
+      if (ctx.body) console.log("[Backflow] Request body:", ctx.body);
+    }
+    let response;
+    let responseData;
+    let error;
+    try {
+      response = await fetch(url, {
+        ...fetchOptions,
+        headers,
+        body: ctx.body ? JSON.stringify(ctx.body) : void 0
+      });
+      if (!response.ok) {
+        error = new Error(
+          `Request failed: ${response.status}`
+        );
+        error.status = response.status;
+        try {
+          const errorBody = await response.json();
+          error.code = errorBody.code;
+          error.details = errorBody;
+          error.message = errorBody.message || errorBody.error || error.message;
+        } catch {
+        }
+      } else {
+        const contentType = response.headers.get("content-type");
+        if (contentType?.includes("application/json")) {
+          responseData = await response.json();
+        } else {
+          responseData = await response.text();
+        }
+      }
+    } catch (e) {
+      error = e;
+      error.status = 0;
+    }
+    const duration = Date.now() - startTime;
+    if (debug) {
+      const status = error?.status ?? response.status;
+      if (error) console.log("[Backflow] Error:", error.message);
+      else console.log("[Backflow] Response:", responseData);
+    }
+    if (this.config.middleware?.onResponse) {
+      const resCtx = {
+        ...ctx,
+        status: error?.status ?? response.status,
+        duration,
+        response: responseData,
+        error
+      };
+      await this.config.middleware.onResponse(resCtx);
+    }
+    if (error) throw error;
+    return responseData;
+  }
+  async get(path, params) {
+    return this.request(path, { method: "GET", params });
+  }
+  async post(path, body, params) {
+    return this.request(path, { method: "POST", body, params });
+  }
+  async put(path, body, params) {
+    return this.request(path, { method: "PUT", body, params });
+  }
+  async patch(path, body, params) {
+    return this.request(path, { method: "PATCH", body, params });
+  }
+  async delete(path, params) {
+    return this.request(path, { method: "DELETE", params });
+  }
+  async upload(path, files, metadata) {
+    const formData = new FormData();
+    const fileArray = Array.isArray(files) ? files : [files];
+    const fieldName = fileArray.length === 1 ? "file" : "files";
+    fileArray.forEach((file) => formData.append(fieldName, file));
+    if (metadata) {
+      Object.entries(metadata).forEach(([key, value]) => {
+        formData.append(key, value);
+      });
+    }
+    const url = `${this.config.endpoint}${path}`;
+    const uploadHeaders = {};
+    const token = await this.getToken();
+    if (token) {
+      uploadHeaders["Authorization"] = `Bearer ${token}`;
+    }
+    const response = await fetch(url, {
+      method: "POST",
+      headers: uploadHeaders,
+      body: formData
+    });
+    if (!response.ok) {
+      const error = new Error(
+        `Upload failed: ${response.status}`
+      );
+      error.status = response.status;
+      try {
+        const errorBody = await response.json();
+        error.code = errorBody.code;
+        error.details = errorBody;
+        error.message = errorBody.message || errorBody.error || error.message;
+      } catch {
+      }
+      throw error;
+    }
+    return response.json();
+  }
+  async getRaw(path, params) {
+    const url = `${this.config.endpoint}${path}`;
+    const queryString = params ? Object.entries(params).filter(([, value]) => value !== void 0).map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`).join("&") : "";
+    const finalUrl = queryString ? `${url}?${queryString}` : url;
+    const headers = {};
+    const token = await this.getToken();
+    if (token) {
+      headers["Authorization"] = `Bearer ${token}`;
+    }
+    return fetch(finalUrl, { headers });
+  }
+  createWebSocket(room) {
+    const wsEndpoint = this.config.endpoint.replace("http", "ws");
+    const ws = new WebSocket(`${wsEndpoint}/ws`);
+    ws.onopen = async () => {
+      const token = await this.getToken();
+      ws.send(JSON.stringify({ type: "auth", token }));
+      ws.send(JSON.stringify({ type: "join_room", room }));
+    };
+    return ws;
+  }
+  subscribeSSE(path, handlers) {
+    const es = new EventSource(`${this.config.endpoint}${path}`);
+    es.addEventListener("connected", () => handlers.onConnected?.());
+    es.addEventListener("completed", (e) => {
+      const data = JSON.parse(e.data);
+      handlers.onComplete?.(data);
+      es.close();
+    });
+    es.addEventListener("failed", (e) => {
+      const data = JSON.parse(e.data);
+      handlers.onFailed?.(data.error || data.message);
+      es.close();
+    });
+    es.addEventListener("progress", (e) => {
+      const data = JSON.parse(e.data);
+      handlers.onProgress?.(data.progress, data.message);
+    });
+    es.addEventListener("warning", (e) => {
+      handlers.onWarning?.(e.data);
+    });
+    es.onerror = (e) => {
+      handlers.onError?.(e);
+      es.close();
+    };
+    return () => es.close();
+  }
+};
+
+// src/generated/agent-analysis.ts
+var AgentAnalysisResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Retrieve cached analysis results from a previous scan */
+  async get(executionId) {
+    return this.client.get(`/agent/analysis/${executionId}`);
+  }
+  /** Apply fixes from cached analysis. In hybrid mode, returns fix instructions for local MCP execution. */
+  async createApply(executionId, data) {
+    return this.client.post(`/agent/analysis/${executionId}/apply`, data);
+  }
+};
+
+// src/generated/analytics.ts
+var AnalyticsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Get high-level analytics overview (tenant-isolated) */
+  async list() {
+    return this.client.get("/analytics/overview");
+  }
+  /** Get endpoint statistics (tenant-isolated) */
+  async listEndpoints() {
+    return this.client.get("/analytics/endpoints");
+  }
+  /** Get recent errors (tenant-isolated) */
+  async listErrors() {
+    return this.client.get("/analytics/errors");
+  }
+  /** Get device type breakdown (tenant-isolated) */
+  async listDevices() {
+    return this.client.get("/analytics/devices");
+  }
+  /** Get geographic distribution of requests (tenant-isolated) */
+  async listGeography() {
+    return this.client.get("/analytics/geography");
+  }
+  /** Get time series data (tenant-isolated) */
+  async listTimeseries() {
+    return this.client.get("/analytics/timeseries");
+  }
+  /** Get endpoints that haven't been called recently (tenant-isolated) */
+  async listUnusedEndpoints() {
+    return this.client.get("/analytics/unused-endpoints");
+  }
+};
+
+// src/generated/batch.ts
+var BatchResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Import records in batch to a specified entity
+   *
+   * @param options - Import options including entity name, records, and mode
+   * @returns Import result with success/failure counts
+   *
+   * @example
+   * // Insert new records
+   * const result = await bf.batch.import({
+   *   entity: 'products',
+   *   records: [
+   *     { name: 'Product 1', price: 100 },
+   *     { name: 'Product 2', price: 200 },
+   *   ],
+   * });
+   *
+   * @example
+   * // Upsert records (update existing, insert new)
+   * const result = await bf.batch.import({
+   *   entity: 'products',
+   *   records: products,
+   *   mode: 'upsert',
+   *   upsertKey: 'sku',
+   * });
+   *
+   * @example
+   * // Large async import (>1000 records or explicit async)
+   * const result = await bf.batch.import({
+   *   entity: 'orders',
+   *   records: largeDataset,
+   *   async: true,
+   * });
+   * // Check status
+   * const status = await bf.batch.getJob(result.jobId!);
+   */
+  async import(options) {
+    return this.client.post("/batch/import", options);
+  }
+  /**
+   * Get status of a batch import job
+   *
+   * @param jobId - The job ID returned from async import
+   * @returns Job status including progress and error details
+   */
+  async getJob(jobId) {
+    return this.client.get(`/batch/jobs/${jobId}`);
+  }
+  /**
+   * List batch jobs for the current tenant
+   *
+   * @returns List of recent batch jobs
+   */
+  async listJobs() {
+    return this.client.get("/batch/jobs");
+  }
+  /**
+   * Export records from an entity
+   *
+   * @param options - Export options including entity name and optional filters
+   * @returns Exported records
+   *
+   * @example
+   * // Export all records
+   * const result = await bf.batch.export({ entity: 'products' });
+   *
+   * @example
+   * // Export with filters
+   * const result = await bf.batch.export({
+   *   entity: 'orders',
+   *   filters: [
+   *     { field: 'status', operator: 'eq', value: 'completed' },
+   *   ],
+   *   select: ['id', 'total', 'created_at'],
+   *   limit: 5000,
+   * });
+   */
+  async export(options) {
+    return this.client.post("/batch/export", options);
+  }
+  /**
+   * Poll job until completion
+   *
+   * @param jobId - The job ID to poll
+   * @param intervalMs - Polling interval in milliseconds (default: 1000)
+   * @param timeoutMs - Timeout in milliseconds (default: 300000 = 5 minutes)
+   * @returns Final job status
+   */
+  async waitForJob(jobId, intervalMs = 1e3, timeoutMs = 3e5) {
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeoutMs) {
+      const job = await this.getJob(jobId);
+      if (job.status === "completed" || job.status === "failed") {
+        return job;
+      }
+      await new Promise((resolve) => setTimeout(resolve, intervalMs));
+    }
+    throw new Error(`Job ${jobId} timed out after ${timeoutMs}ms`);
+  }
+};
+
+// src/generated/assets.ts
+var AssetsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** List tenant assets with optional filtering */
+  async list(params) {
+    return this.client.get("/admin/assets", params);
+  }
+  /** Get asset by ID */
+  async get(id) {
+    return this.client.get(`/admin/assets/${id}`);
+  }
+  /** Delete asset by ID */
+  async delete(id) {
+    return this.client.delete(`/admin/assets/${id}`);
+  }
+  /** Get asset storage statistics */
+  async stats(tenant) {
+    return this.client.get("/admin/assets/stats", tenant ? { tenant } : void 0);
+  }
+};
+
+// src/generated/cache.ts
+var CacheResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Get cache statistics including hit rate, memory usage, and item count */
+  async list() {
+    return this.client.get("/cache/stats");
+  }
+  /** Clear all items from the cache and reset statistics */
+  async delete() {
+    return this.client.delete("/cache/flush");
+  }
+  /** Invalidate all cache entries that match a given pattern */
+  async create(data) {
+    return this.client.post("/cache/invalidate", data);
+  }
+  /** Reset cache hit/miss statistics while preserving cached data */
+  async createResetStats(data) {
+    return this.client.post("/cache/reset-stats", data);
+  }
+};
+
+// src/generated/default.ts
+var DefaultResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** GET /tenant/debug/raw-query */
+  async list() {
+    return this.client.get("/tenant/debug/raw-query");
+  }
+};
+
+// src/generated/deployment.ts
+var DeploymentResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Get deployment information */
+  async list() {
+    return this.client.get("/deployment");
+  }
+  /** Get server information */
+  async listServer() {
+    return this.client.get("/deployment/server");
+  }
+  /** Get full deployment status */
+  async listStatus() {
+    return this.client.get("/deployment/status");
+  }
+  /** Get Cloud Run service URL */
+  async listUrl() {
+    return this.client.get("/deployment/url");
+  }
+  /** Server-Sent Events (SSE) stream for real-time deployment status updates. Sends periodic status updates and heartbeats. */
+  async listStream() {
+    return this.client.get("/deployment/stream");
+  }
+  /** Filtered Server-Sent Events (SSE) stream for specific deployment event types. Filter by status, server, or url events. */
+  async listEvents() {
+    return this.client.get("/deployment/events");
+  }
+};
+
+// src/generated/embeddings.ts
+var EmbeddingsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** List all embedded documents with chunk counts and metadata */
+  async list() {
+    return this.client.get("/agent/embeddings/documents");
+  }
+  /** Upload and process a document for vector embeddings with automatic chunking. Supports various content types (code, documentation, articles) with optimized chunking strategies for RAG. */
+  async create(data) {
+    return this.client.post("/agent/embeddings/document", data);
+  }
+  /** Search within a specific document using semantic similarity. Performs vector search within document chunks. */
+  async search(documentId) {
+    return this.client.get(`/agent/embeddings/document/${documentId}/search`);
+  }
+  /** Search across all embedded documents using semantic similarity */
+  async listSearch() {
+    return this.client.get("/agent/embeddings/search");
+  }
+  /** Delete all chunks and embeddings for a document. Removes the document from the vector store. */
+  async delete(documentId) {
+    return this.client.delete(`/agent/embeddings/document/${documentId}`);
+  }
+  /** Process multiple documents (up to 50) for vector embeddings in a single batch. Supports both raw text and file references (PDF, DOCX, TXT, MD). Uses 3 concurrent processing threads. */
+  async createBatch(data) {
+    return this.client.post("/agent/embeddings/batch", data);
+  }
+};
+
+// src/generated/feedback.ts
+var FeedbackResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Submit feedback for a workflow execution. Used to optimize and improve workflow performance based on user ratings and suggestions. */
+  async create(data) {
+    return this.client.post("/agent/feedback", data);
+  }
+  /** Get feedback trends and analytics. Analyzes workflow feedback to identify patterns and areas for improvement. */
+  async list() {
+    return this.client.get("/agent/feedback/trends");
+  }
+};
+
+// src/generated/files.ts
+var FilesResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Upload a single file with entity association and tenant isolation */
+  async create(data) {
+    return this.client.post("/files/upload", data);
+  }
+  /** Upload multiple files with entity association and tenant isolation */
+  async createUploadMultiple(data) {
+    return this.client.post("/files/upload-multiple", data);
+  }
+  /** List files for an entity with pagination */
+  async get(entityType, entityId) {
+    return this.client.get(`/files/entity/${entityType}/${entityId}`);
+  }
+  /** Delete all files for an entity */
+  async delete(entityType, entityId) {
+    return this.client.delete(`/files/entity/${entityType}/${entityId}`);
+  }
+  /** Download file via secure signed URL redirect (5 minute expiry) */
+  async getDownload(bucket, path) {
+    return this.client.get(`/files/download/${bucket}/${path}`);
+  }
+  /** Get a signed URL for file access (max 30 seconds expiry) */
+  async getSignedUrl(bucket, path) {
+    return this.client.get(`/files/signed-url/${bucket}/${path}`);
+  }
+  /** Delete a file from storage */
+  async deleteDELETE(bucket, path) {
+    return this.client.delete(`/files/${bucket}/${path}`);
+  }
+  /** Upload JSON content to storage */
+  async createUploadJson(data) {
+    return this.client.post("/files/upload-json", data);
+  }
+};
+
+// src/generated/github.ts
+var GithubResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Get GitHub repositories for a user */
+  async get(username) {
+    return this.client.get(`/api/github/repos/${username}`);
+  }
+  /** Get file or directory contents from a GitHub repository */
+  async getContent(owner, repo, path) {
+    return this.client.get(`/api/github/repos/${owner}/${repo}/contents/${path}`);
+  }
+  /** Create or update a file in a GitHub repository */
+  async updateContent(owner, repo, path, data) {
+    return this.client.put(`/api/github/repos/${owner}/${repo}/contents/${path}`, data);
+  }
+  /** Delete a file from a GitHub repository */
+  async deleteContent(owner, repo, path) {
+    return this.client.delete(`/api/github/repos/${owner}/${repo}/contents/${path}`);
+  }
+  /** Compare two commits and view the diff */
+  async getCompare(owner, repo, basehead) {
+    return this.client.get(`/api/github/repos/${owner}/${repo}/compare/${basehead}`);
+  }
+  /** Get a single commit with its changes */
+  async getCommit(owner, repo, ref) {
+    return this.client.get(`/api/github/repos/${owner}/${repo}/commits/${ref}`);
+  }
+  /** List commits in a repository */
+  async commits(owner, repo) {
+    return this.client.get(`/api/github/repos/${owner}/${repo}/commits`);
+  }
+  /** Get pull request details */
+  async getPull(owner, repo, pull_number) {
+    return this.client.get(`/api/github/repos/${owner}/${repo}/pulls/${pull_number}`);
+  }
+  /** List files changed in a pull request with diffs */
+  async files(owner, repo, pull_number) {
+    return this.client.get(`/api/github/repos/${owner}/${repo}/pulls/${pull_number}/files`);
+  }
+};
+
+// src/generated/goals.ts
+var GoalsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Configure goal evaluation rules for a workflow. Sets KPIs, success criteria, and evaluation parameters. */
+  async create(data) {
+    return this.client.post("/agent/goal/configure", data);
+  }
+  /** Manually trigger goal evaluation for a workflow. Evaluates workflow performance against configured KPIs and success criteria. */
+  async createEvaluate(workflowId, data) {
+    return this.client.post(`/agent/goal/evaluate/${workflowId}`, data);
+  }
+  /** Get evaluation history for a workflow. Returns all historical goal evaluation records. */
+  async get(workflowId) {
+    return this.client.get(`/agent/goal/history/${workflowId}`);
+  }
+  /** Start scheduled goal evaluation. Automatically evaluates all active workflows at specified intervals. */
+  async createStart(data) {
+    return this.client.post("/agent/goal/schedule/start", data);
+  }
+  /** Stop scheduled goal evaluation. Cancels automatic workflow evaluations. */
+  async createStop(data) {
+    return this.client.post("/agent/goal/schedule/stop", data);
+  }
+  /** Evaluate all active workflows. Generates evaluation reports for all workflows with configured goals. */
+  async createEvaluateAll(data) {
+    return this.client.post("/agent/goal/evaluate-all", data);
+  }
+};
+
+// src/generated/google-drive.ts
+var GoogleDriveResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** List files in Google Drive */
+  async list() {
+    return this.client.get("/api/google-drive/files");
+  }
+  /** Get file metadata from Google Drive */
+  async get(fileId) {
+    return this.client.get(`/api/google-drive/files/${fileId}`);
+  }
+  /** Update file metadata (rename, move) */
+  async patch(fileId, data) {
+    return this.client.patch(`/api/google-drive/files/${fileId}`, data);
+  }
+  /** Delete a file from Google Drive */
+  async delete(fileId) {
+    return this.client.delete(`/api/google-drive/files/${fileId}`);
+  }
+  /** Download file content from Google Drive */
+  async download(fileId) {
+    return this.client.get(`/api/google-drive/files/${fileId}/download`);
+  }
+  /** Search for PDF files in Google Drive */
+  async listPdfs() {
+    return this.client.get("/api/google-drive/pdfs");
+  }
+};
+
+// src/generated/jira.ts
+var JiraResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Search JIRA issues using JQL */
+  async list() {
+    return this.client.get("/api/jira/issues/search");
+  }
+  /** Get JIRA issue details */
+  async get(issueKey) {
+    return this.client.get(`/api/jira/issues/${issueKey}`);
+  }
+  /** Update a JIRA issue */
+  async update(issueKey, data) {
+    return this.client.put(`/api/jira/issues/${issueKey}`, data);
+  }
+  /** Delete a JIRA issue */
+  async delete(issueKey) {
+    return this.client.delete(`/api/jira/issues/${issueKey}`);
+  }
+  /** Create a new JIRA issue */
+  async create(data) {
+    return this.client.post("/api/jira/issues", data);
+  }
+  /** Get available transitions for a JIRA issue */
+  async transitions(issueKey) {
+    return this.client.get(`/api/jira/issues/${issueKey}/transitions`);
+  }
+  /** Transition a JIRA issue to new status */
+  async createTransition(issueKey, data) {
+    return this.client.post(`/api/jira/issues/${issueKey}/transition`, data);
+  }
+  /** Get comments for a JIRA issue */
+  async comments(issueKey) {
+    return this.client.get(`/api/jira/issues/${issueKey}/comments`);
+  }
+  /** Add comment to a JIRA issue */
+  async createComment(issueKey, data) {
+    return this.client.post(`/api/jira/issues/${issueKey}/comments`, data);
+  }
+  /** Assign a JIRA issue to a user */
+  async updateAssign(issueKey, data) {
+    return this.client.put(`/api/jira/issues/${issueKey}/assign`, data);
+  }
+  /** Get all JIRA projects */
+  async listProjects() {
+    return this.client.get("/api/jira/projects");
+  }
+  /** Get JIRA project details */
+  async getProjects(projectKey) {
+    return this.client.get(`/api/jira/projects/${projectKey}`);
+  }
+  /** Get current authenticated JIRA user */
+  async listMe() {
+    return this.client.get("/api/jira/user/me");
+  }
+  /** Search JIRA users */
+  async listSearch() {
+    return this.client.get("/api/jira/users/search");
+  }
+  /** Get all JIRA issue types */
+  async listIssueTypes() {
+    return this.client.get("/api/jira/metadata/issue-types");
+  }
+  /** Get all JIRA priority levels */
+  async listPriorities() {
+    return this.client.get("/api/jira/metadata/priorities");
+  }
+};
+
+// src/generated/llm.ts
+var LlmResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** POST /llm/stream */
+  async create(data) {
+    return this.client.post("/llm/stream", data);
+  }
+  /** GET /llm/models */
+  async list() {
+    return this.client.get("/llm/models");
+  }
+};
+
+// src/generated/mcptools.ts
+var McpToolsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** List all available MCP tools from connected servers. Returns tools, connection status, and server information. */
+  async list() {
+    return this.client.get("/agent/mcp/tools");
+  }
+  /** Execute a Model Context Protocol (MCP) tool. MCP tools provide external capabilities like file system access, database queries, and API calls to LLM workflows. */
+  async create(data) {
+    return this.client.post("/agent/mcp/execute", data);
+  }
+};
+
+// src/generated/polar.ts
+var PolarResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Create a Polar checkout session */
+  async create(data) {
+    return this.client.post("/integrations/polar/checkouts", data);
+  }
+  /** Retrieve a Polar checkout session */
+  async get(checkoutId) {
+    return this.client.get(`/integrations/polar/checkouts/${checkoutId}`);
+  }
+  /** Create a Polar subscription */
+  async createSubscriptions(data) {
+    return this.client.post("/integrations/polar/subscriptions", data);
+  }
+  /** Cancel a Polar subscription */
+  async delete(subscriptionId) {
+    return this.client.delete(`/integrations/polar/subscriptions/${subscriptionId}`);
+  }
+  /** List Polar products */
+  async list() {
+    return this.client.get("/integrations/polar/products");
+  }
+  /** Create a Polar product */
+  async createProducts(data) {
+    return this.client.post("/integrations/polar/products", data);
+  }
+  /** Retrieve a Polar order */
+  async getOrders(orderId) {
+    return this.client.get(`/integrations/polar/orders/${orderId}`);
+  }
+  /** Create a Polar benefit */
+  async createBenefits(data) {
+    return this.client.post("/integrations/polar/benefits", data);
+  }
+  /** Grant a Polar benefit to a customer */
+  async createGrants(data) {
+    return this.client.post("/integrations/polar/benefits/grants", data);
+  }
+};
+
+// src/generated/projects.ts
+var ProjectsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** List version history for a project with pagination and date range filter */
+  async versions(id) {
+    return this.client.get(`/projects/${id}/versions`);
+  }
+  /** Create a new project version record (Pro tier) */
+  async createVersion(id, data) {
+    return this.client.post(`/projects/${id}/versions`, data);
+  }
+  /** Delete all versions for a project and their R2 files (parallel) */
+  async deleteAllVersions(id) {
+    return this.client.delete(`/projects/${id}/versions`);
+  }
+  /** Get a specific version record */
+  async getVersion(id, versionId) {
+    return this.client.get(`/projects/${id}/versions/${versionId}`);
+  }
+  /** Delete a specific project version and its R2 files */
+  async deleteVersion(id, versionId) {
+    return this.client.delete(`/projects/${id}/versions/${versionId}`);
+  }
+  /** Rollback project to a previous version (Pro tier) */
+  async rollback(id, version, data) {
+    return this.client.post(`/projects/${id}/rollback/${version}`, data);
+  }
+  /** Save project with parallel R2 uploads and Firestore updates */
+  async updateSave(projectId, data) {
+    return this.client.put(`/projects/${projectId}/save`, data);
+  }
+  /** Save project and execute content as workflow */
+  async saveAndRun(projectId, data) {
+    return this.client.post(`/projects/${projectId}/save-and-run`, data);
+  }
+  /** Get project by ID */
+  async get(id) {
+    return this.client.get(`/projects/${id}`);
+  }
+  /** Update project metadata (title, description, etc.) */
+  async patch(id, data) {
+    return this.client.patch(`/projects/${id}`, data);
+  }
+  /** Delete project and all related files/versions (parallel) */
+  async delete(id) {
+    return this.client.delete(`/projects/${id}`);
+  }
+  /** List all shares for a project */
+  async shares(id) {
+    return this.client.get(`/projects/${id}/shares`);
+  }
+  /** Share a project with another user */
+  async share(id, data) {
+    return this.client.post(`/projects/${id}/share`, data);
+  }
+  /** Remove share access from a user */
+  async deleteShare(id, userId) {
+    return this.client.delete(`/projects/${id}/share/${userId}`);
+  }
+  /** Get public project by ID (no auth required) */
+  async public(projectId) {
+    return this.client.get(`/projects/${projectId}/public`);
+  }
+  /** Toggle project public/private status with optional email notification */
+  async patchPublic(id, data) {
+    return this.client.patch(`/projects/${id}/public`, data);
+  }
+  /** List all projects shared with the current user */
+  async list() {
+    return this.client.get("/projects/shared-with-me");
+  }
+  /** Update project files (add/remove attached assets) */
+  async patchFile(id, data) {
+    return this.client.patch(`/projects/${id}/files`, data);
+  }
+};
+
+// src/generated/publish.ts
+var PublishResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Initialize publishing system - checks database setup */
+  async create(data) {
+    return this.client.post("/publish/init", data);
+  }
+  /** Verify database migration was applied */
+  async createVerify(data) {
+    return this.client.post("/publish/verify", data);
+  }
+  /** Publish an entity (checks database readiness automatically) */
+  async createEntity(data) {
+    return this.client.post("/publish/entity", data);
+  }
+};
+
+// src/generated/queues.ts
+var QueuesResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Get all queues and their statistics (tenant-isolated) */
+  async list() {
+    return this.client.get("/queues");
+  }
+  /** Get statistics for a specific queue (tenant-isolated) */
+  async stats(name) {
+    return this.client.get(`/queues/${name}/stats`);
+  }
+  /** Get jobs from a queue (tenant-isolated) */
+  async jobs(name) {
+    return this.client.get(`/queues/${name}/jobs`);
+  }
+  /** Add a job to the queue (with tenant isolation) */
+  async createJob(name, data) {
+    return this.client.post(`/queues/${name}/jobs`, data);
+  }
+  /** Get a specific job (tenant-isolated) */
+  async getJob(name, jobId) {
+    return this.client.get(`/queues/${name}/jobs/${jobId}`);
+  }
+  /** Retry a failed job (tenant-isolated) */
+  async retry(name, jobId, data) {
+    return this.client.post(`/queues/${name}/jobs/${jobId}/retry`, data);
+  }
+  /** Pause a queue (admin only - affects all tenants) */
+  async pause(name, data) {
+    return this.client.post(`/queues/${name}/pause`, data);
+  }
+  /** Resume a paused queue (admin only - affects all tenants) */
+  async resume(name, data) {
+    return this.client.post(`/queues/${name}/resume`, data);
+  }
+  /** Clean old jobs from queue (tenant-isolated) */
+  async createClean(name, data) {
+    return this.client.post(`/queues/${name}/clean`, data);
+  }
+  /** Get detailed performance metrics for a queue */
+  async metrics(name) {
+    return this.client.get(`/queues/${name}/metrics`);
+  }
+};
+
+// src/generated/search.ts
+var SearchResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Fast search across an entity with configurable modes (exact, fuzzy, hybrid) */
+  async get(entity) {
+    return this.client.get(`/search/${entity}`);
+  }
+  /** Index entity records for vector search */
+  async create(data) {
+    return this.client.post("/search/index", data);
+  }
+  /** Delete and reindex all records for an entity */
+  async createReindex(data) {
+    return this.client.post("/search/reindex", data);
+  }
+  /** Delete all indexed records for an entity */
+  async delete(entity) {
+    return this.client.delete(`/search/index/${entity}`);
+  }
+  /** Get search index statistics */
+  async list() {
+    return this.client.get("/search/stats");
+  }
+};
+
+// src/generated/stripe.ts
+var StripeResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Create a Stripe customer */
+  async create(data) {
+    return this.client.post("/integrations/stripe/customers", data);
+  }
+  /** Create a Stripe payment intent */
+  async createPaymentIntents(data) {
+    return this.client.post("/integrations/stripe/payment-intents", data);
+  }
+  /** Create a Stripe subscription */
+  async createSubscriptions(data) {
+    return this.client.post("/integrations/stripe/subscriptions", data);
+  }
+};
+
+// src/generated/teams.ts
+var TeamsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Get all teams */
+  async list() {
+    return this.client.get("/teams");
+  }
+  /** Create a new team */
+  async create(data) {
+    return this.client.post("/teams", data);
+  }
+  /** Get team by ID */
+  async get(id) {
+    return this.client.get(`/teams/${id}`);
+  }
+  /** Update team metadata (name, description, members) */
+  async update(id, data) {
+    return this.client.put(`/teams/${id}`, data);
+  }
+  /** Delete team */
+  async delete(id) {
+    return this.client.delete(`/teams/${id}`);
+  }
+  /** Get all projects for a team */
+  async projects(id) {
+    return this.client.get(`/teams/${id}/projects`);
+  }
+};
+
+// src/generated/tenant-webhook-receivers.ts
+var TenantWebhookReceiversResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** List webhook receivers */
+  async list() {
+    return this.client.get("/tenant/webhook-receivers");
+  }
+  /** Create webhook receiver */
+  async create(data) {
+    return this.client.post("/tenant/webhook-receivers", data);
+  }
+  /** Get webhook receiver */
+  async get(id) {
+    return this.client.get(`/tenant/webhook-receivers/${id}`);
+  }
+  /** Update webhook receiver */
+  async update(id, data) {
+    return this.client.put(`/tenant/webhook-receivers/${id}`, data);
+  }
+  /** Delete webhook receiver */
+  async delete(id) {
+    return this.client.delete(`/tenant/webhook-receivers/${id}`);
+  }
+};
+
+// src/generated/tenant-webhooks.ts
+var TenantWebhooksResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** List webhooks */
+  async list() {
+    return this.client.get("/tenant/webhooks");
+  }
+  /** Create webhook */
+  async create(data) {
+    return this.client.post("/tenant/webhooks", data);
+  }
+  /** Get webhook */
+  async get(id) {
+    return this.client.get(`/tenant/webhooks/${id}`);
+  }
+  /** Update webhook */
+  async update(id, data) {
+    return this.client.put(`/tenant/webhooks/${id}`, data);
+  }
+  /** Delete webhook */
+  async delete(id) {
+    return this.client.delete(`/tenant/webhooks/${id}`);
+  }
+};
+
+// src/generated/tooldiscovery.ts
+var ToolDiscoveryResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Get all registered tools including MCP, user-configured, and built-in tools */
+  async list() {
+    return this.client.get("/agent/tools");
+  }
+  /** Search for tools using text query, category, tags, capabilities, and performance filters */
+  async create(data) {
+    return this.client.post("/agent/tools/search", data);
+  }
+  /** Search for tools using natural language semantic similarity */
+  async createSemanticSearch(data) {
+    return this.client.post("/agent/tools/semantic-search", data);
+  }
+  /** Use AI to automatically select appropriate tools based on a natural language goal */
+  async createSelect(data) {
+    return this.client.post("/agent/tools/select", data);
+  }
+  /** Get tool recommendations based on goal and historical performance data */
+  async createRecommend(data) {
+    return this.client.post("/agent/tools/recommend", data);
+  }
+  /** Get performance metrics (success rate, latency, usage) for a specific tool */
+  async metrics(toolName) {
+    return this.client.get(`/agent/tools/${toolName}/metrics`);
+  }
+  /** Index all registered tools for semantic search using embeddings */
+  async createIndex(data) {
+    return this.client.post("/agent/tools/index", data);
+  }
+};
+
+// src/generated/tracking.ts
+var TrackingResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Get MCP call statistics for the tenant */
+  async list() {
+    return this.client.get("/tracking/mcp/stats");
+  }
+  /** Get field-level change history for an entity */
+  async history(entityType, entityId) {
+    return this.client.get(`/tracking/entity/${entityType}/${entityId}/history`);
+  }
+  /** Get change history for a specific field */
+  async getField(entityType, entityId, fieldName) {
+    return this.client.get(`/tracking/entity/${entityType}/${entityId}/field/${fieldName}`);
+  }
+  /** Get tracking buffer status (AI usage buffer size) */
+  async listStatus() {
+    return this.client.get("/tracking/buffer/status");
+  }
+  /** Manually flush tracking buffers to database */
+  async create(data) {
+    return this.client.post("/tracking/buffer/flush", data);
+  }
+};
+
+// src/generated/twitter.ts
+var TwitterResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Search X (Twitter) tweets by query */
+  async list() {
+    return this.client.get("/api/twitter/search");
+  }
+  /** Get details of a specific tweet */
+  async get(tweetId) {
+    return this.client.get(`/api/twitter/tweets/${tweetId}`);
+  }
+  /** Delete a tweet */
+  async delete(tweetId) {
+    return this.client.delete(`/api/twitter/tweets/${tweetId}`);
+  }
+  /** Post a new tweet */
+  async create(data) {
+    return this.client.post("/api/twitter/tweets", data);
+  }
+  /** Like a tweet */
+  async createLike(userId, data) {
+    return this.client.post(`/api/twitter/users/${userId}/likes`, data);
+  }
+  /** Unlike a tweet */
+  async deleteLike(userId, tweetId) {
+    return this.client.delete(`/api/twitter/users/${userId}/likes/${tweetId}`);
+  }
+  /** Retweet a tweet */
+  async createRetweet(userId, data) {
+    return this.client.post(`/api/twitter/users/${userId}/retweets`, data);
+  }
+  /** Remove a retweet */
+  async deleteRetweet(userId, tweetId) {
+    return this.client.delete(`/api/twitter/users/${userId}/retweets/${tweetId}`);
+  }
+  /** Get user information by username */
+  async getUsername(username) {
+    return this.client.get(`/api/twitter/users/by/username/${username}`);
+  }
+  /** Get user information by user ID */
+  async getUsers(userId) {
+    return this.client.get(`/api/twitter/users/${userId}`);
+  }
+  /** Get authenticated user information */
+  async listMe() {
+    return this.client.get("/api/twitter/user/me");
+  }
+  /** Get recent tweets from a user */
+  async tweets(userId) {
+    return this.client.get(`/api/twitter/users/${userId}/tweets`);
+  }
+  /** Follow a user */
+  async createFollowing(userId, data) {
+    return this.client.post(`/api/twitter/users/${userId}/following`, data);
+  }
+  /** Unfollow a user */
+  async deleteFollowing(userId, targetUserId) {
+    return this.client.delete(`/api/twitter/users/${userId}/following/${targetUserId}`);
+  }
+  /** Get followers of a user */
+  async followers(userId) {
+    return this.client.get(`/api/twitter/users/${userId}/followers`);
+  }
+  /** Get users that a user is following */
+  async followingList(userId) {
+    return this.client.get(`/api/twitter/users/${userId}/following_list`);
+  }
+  /** Get users who liked a tweet */
+  async likedBy(tweetId) {
+    return this.client.get(`/api/twitter/tweets/${tweetId}/liked_by`);
+  }
+  /** Get users who retweeted a tweet */
+  async retweetedBy(tweetId) {
+    return this.client.get(`/api/twitter/tweets/${tweetId}/retweeted_by`);
+  }
+  /** Get tweets in a conversation thread */
+  async getConversations(conversationId) {
+    return this.client.get(`/api/twitter/conversations/${conversationId}`);
+  }
+  /** Get tweets liked by a user */
+  async likedTweets(userId) {
+    return this.client.get(`/api/twitter/users/${userId}/liked_tweets`);
+  }
+};
+
+// src/generated/usage.ts
+var UsageResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Get unified usage metrics for a user across AI, API, and integrations */
+  async get(userId) {
+    return this.client.get(`/usage/user/${userId}`);
+  }
+  /** Get a brief summary of user usage */
+  async summary(userId) {
+    return this.client.get(`/usage/user/${userId}/summary`);
+  }
+  /** Get usage metrics for the authenticated user */
+  async list() {
+    return this.client.get("/usage/me");
+  }
+};
+
+// src/generated/websocket.ts
+var WebsocketResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** WebSocket API Documentation */
+  async list() {
+    return this.client.get("/websocket/info");
+  }
+};
+
+// src/generated/workflows.ts
+var WorkflowsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Orchestrate a task by ID. Executes predefined task orchestration logic. */
+  async create(data) {
+    return this.client.post("/agent/orchestrate", data);
+  }
+  /** Execute an agentic workflow with tools and steps. Workflows define a series of actions that can call LLMs, APIs, shell commands, and MCP tools. */
+  async createWorkflow(data) {
+    return this.client.post("/agent/workflow", data);
+  }
+  /** List all workflow executions with date range filter and pagination. */
+  async list() {
+    return this.client.get("/agent/workflows/executions");
+  }
+  /** Delete all workflow executions and their activity records */
+  async delete() {
+    return this.client.delete("/agent/workflows/executions");
+  }
+  /** Delete a specific workflow execution and all its activity records */
+  async deleteExecutions(workflowId) {
+    return this.client.delete(`/agent/workflows/executions/${workflowId}`);
+  }
+  /** Get execution history for a workflow by ID. Returns all historical execution records. */
+  async history(workflowId) {
+    return this.client.get(`/agent/workflow/${workflowId}/history`);
+  }
+  /** Resume a paused workflow execution. Allows continuing or cancelling execution with optional user input. */
+  async createResume(data) {
+    return this.client.post("/agent/workflow/resume", data);
+  }
+  /** Request pause for a running workflow. The workflow will pause after the current step completes. */
+  async pause(executionId, data) {
+    return this.client.post(`/agent/workflow/${executionId}/pause`, data);
+  }
+  /** Cancel a running workflow. The workflow will stop after the current step completes. */
+  async cancel(executionId, data) {
+    return this.client.post(`/agent/workflow/${executionId}/cancel`, data);
+  }
+  /** Get background execution status for workflows that returned early */
+  async status(executionId) {
+    return this.client.get(`/agent/workflow/${executionId}/status`);
+  }
+  /** Retry a workflow execution. Can restart from beginning or resume from last checkpoint. */
+  async retry(executionId, data) {
+    return this.client.post(`/agent/workflow/${executionId}/retry`, data);
+  }
+  /** Health check endpoint with detailed component status. Returns status of embeddings, vector store, MCP servers, and database. */
+  async listHealth() {
+    return this.client.get("/agent/health");
+  }
+  /** Automatically generate and execute a workflow from a natural language goal using AI */
+  async createDynamic(data) {
+    return this.client.post("/agent/workflow/dynamic", data);
+  }
+};
+
+// src/generated/workspaces.ts
+var WorkspacesResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Get all workspaces */
+  async list() {
+    return this.client.get("/workspaces");
+  }
+  /** Create a new workspace */
+  async create(data) {
+    return this.client.post("/workspaces", data);
+  }
+  /** Get workspace by ID */
+  async get(id) {
+    return this.client.get(`/workspaces/${id}`);
+  }
+  /** Update workspace */
+  async update(id, data) {
+    return this.client.put(`/workspaces/${id}`, data);
+  }
+  /** Delete workspace */
+  async delete(id) {
+    return this.client.delete(`/workspaces/${id}`);
+  }
+};
+
+// src/resources/ai.ts
+var AIResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async chat(options) {
+    return this.client.post("/ai/chat", options);
+  }
+};
+
+// src/resources/collaboration.ts
+var CollaborationResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async presence(data) {
+    return this.client.post("/collaboration/presence", data);
+  }
+};
+
+// src/resources/webhooks.ts
+var WebhooksResource = class {
+  constructor(client, projectId) {
+    this.client = client;
+    this.projectId = projectId;
+  }
+  async trigger(data) {
+    return this.client.post(`/webhooks/${this.projectId}/trigger`, data);
+  }
+};
+var WebhooksFactory = class {
+  constructor(client) {
+    this.client = client;
+  }
+  for(projectId) {
+    return new WebhooksResource(this.client, projectId);
+  }
+};
+
+// src/resources/exports.ts
+var ExportsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async highRes(options) {
+    const contentType = options.contentType || (options.format === "svg" ? "image/svg+xml" : options.format === "pdf" ? "application/pdf" : "image/png");
+    return this.client.post("/exports/high-res", {
+      ...options,
+      contentType
+    });
+  }
+};
+
+// src/resources/user.ts
+var UserResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async createMetrics(metrics) {
+    return this.client.post("/user/metrics", metrics);
+  }
+  async getMetrics() {
+    return this.client.get("/user/metrics");
+  }
+  async updateMetrics(metrics) {
+    return this.client.put("/user/metrics", metrics);
+  }
+  async getProfile() {
+    return this.client.get("/admin/users/me");
+  }
+  async updateProfile(options) {
+    return this.client.put("/admin/users/me/profile", options);
+  }
+};
+
+// src/resources/entities.ts
+var EntitiesResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async listCollections() {
+    const response = await this.client.get("/admin/entities");
+    return response.data || [];
+  }
+  async list(collection, options) {
+    const params = new URLSearchParams();
+    if (options?.limit) params.set("limit", String(options.limit));
+    if (options?.offset) params.set("offset", String(options.offset));
+    if (options?.includeDeleted) params.set("includeDeleted", "true");
+    const query = params.toString();
+    const url = `/admin/entities/${encodeURIComponent(collection)}${query ? `?${query}` : ""}`;
+    return this.client.get(url);
+  }
+  async get(collection, id, options) {
+    const params = new URLSearchParams();
+    if (options?.includeDeleted) params.set("includeDeleted", "true");
+    const query = params.toString();
+    const response = await this.client.get(
+      `/admin/entities/${encodeURIComponent(collection)}/${encodeURIComponent(id)}${query ? `?${query}` : ""}`
+    );
+    return response.data;
+  }
+  async create(collection, data) {
+    const response = await this.client.post(
+      `/admin/entities/${encodeURIComponent(collection)}`,
+      data
+    );
+    return response.data;
+  }
+  async update(collection, id, data) {
+    const response = await this.client.put(
+      `/admin/entities/${encodeURIComponent(collection)}/${encodeURIComponent(id)}`,
+      data
+    );
+    return response.data;
+  }
+  async delete(collection, id, options) {
+    const params = new URLSearchParams();
+    if (options?.hard) params.set("hard", "true");
+    if (options?.softDelete === false) params.set("softDelete", "false");
+    const query = params.toString();
+    const url = `/admin/entities/${encodeURIComponent(collection)}/${encodeURIComponent(id)}${query ? `?${query}` : ""}`;
+    return this.client.delete(url);
+  }
+  async restore(collection, id) {
+    return this.client.post(
+      `/admin/entities/${encodeURIComponent(collection)}/${encodeURIComponent(id)}/restore`,
+      {}
+    );
+  }
+  async getSchema() {
+    const response = await this.client.get("/admin/schema");
+    return response.data || [];
+  }
+  /**
+   * Get schema for a specific collection
+   */
+  async getCollectionSchema(collection) {
+    const schemas = await this.getSchema();
+    return schemas.find((s) => s.collection === collection) || null;
+  }
+  /**
+   * Validate data against a collection's schema (client-side)
+   */
+  async validate(collection, data) {
+    const schema = await this.getCollectionSchema(collection);
+    if (!schema) {
+      return { valid: true };
+    }
+    const errors = [];
+    for (const field of schema.fields) {
+      if (field.source === "builtin") continue;
+      const value = data[field.name];
+      const hasValue = value !== void 0 && value !== null && value !== "";
+      if (field.required && !hasValue) {
+        errors.push({ field: field.name, message: `${field.name} is required` });
+        continue;
+      }
+      if (!hasValue) continue;
+      if (field.type === "integer" || field.type === "bigint") {
+        if (typeof value !== "number" || !Number.isInteger(value)) {
+          errors.push({ field: field.name, message: `${field.name} must be an integer` });
+          continue;
+        }
+      }
+      if (field.type === "decimal") {
+        if (typeof value !== "number") {
+          errors.push({ field: field.name, message: `${field.name} must be a number` });
+          continue;
+        }
+      }
+      if (field.type === "boolean") {
+        if (typeof value !== "boolean") {
+          errors.push({ field: field.name, message: `${field.name} must be a boolean` });
+          continue;
+        }
+      }
+      if (typeof value === "number") {
+        if (field.min !== void 0 && value < field.min) {
+          errors.push({ field: field.name, message: `${field.name} must be at least ${field.min}` });
+        }
+        if (field.max !== void 0 && value > field.max) {
+          errors.push({ field: field.name, message: `${field.name} must be at most ${field.max}` });
+        }
+      }
+      if (typeof value === "string") {
+        if (field.min !== void 0 && value.length < field.min) {
+          errors.push({ field: field.name, message: `${field.name} must be at least ${field.min} characters` });
+        }
+        if (field.max !== void 0 && value.length > field.max) {
+          errors.push({ field: field.name, message: `${field.name} must be at most ${field.max} characters` });
+        }
+      }
+      if (field.enum && field.enum.length > 0) {
+        if (!field.enum.includes(String(value))) {
+          errors.push({ field: field.name, message: `${field.name} must be one of: ${field.enum.join(", ")}` });
+        }
+      }
+      if (field.pattern && typeof value === "string") {
+        const regex = new RegExp(field.pattern);
+        if (!regex.test(value)) {
+          errors.push({ field: field.name, message: `${field.name} has invalid format` });
+        }
+      }
+      if (field.preset && typeof value === "string") {
+        const presetError = this.validatePreset(field.preset, value, field.name);
+        if (presetError) {
+          errors.push(presetError);
+        }
+      }
+    }
+    return errors.length > 0 ? { valid: false, errors } : { valid: true };
+  }
+  validatePreset(preset, value, fieldName) {
+    const patterns = {
+      email: { regex: /^[^\s@]+@[^\s@]+\.[^\s@]+$/, message: "must be a valid email" },
+      url: { regex: /^https?:\/\/[^\s/$.?#].[^\s]*$/i, message: "must be a valid URL" },
+      "phone-us": { regex: /^\+?1?[-.\s]?\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}$/, message: "must be a valid US phone" },
+      "phone-intl": { regex: /^\+?[\d\s\-().]{7,20}$/, message: "must be a valid phone number" },
+      uuid: { regex: /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i, message: "must be a valid UUID" },
+      slug: { regex: /^[a-z0-9]+(?:-[a-z0-9]+)*$/, message: "must be a valid slug" },
+      username: { regex: /^[a-zA-Z0-9_]{3,30}$/, message: "must be 3-30 chars, letters/numbers/underscores" },
+      password: { regex: /^.{8,}$/, message: "must be at least 8 characters" },
+      name: { regex: /^[\p{L}\s\-'.]{1,100}$/u, message: "must be a valid name" },
+      currency: { regex: /^\d+(\.\d{1,2})?$/, message: "must be a valid currency amount" },
+      percentage: { regex: /^(100(\.0{1,2})?|\d{1,2}(\.\d{1,2})?)$/, message: "must be 0-100" },
+      date: { regex: /^\d{4}-\d{2}-\d{2}$/, message: "must be YYYY-MM-DD format" },
+      datetime: { regex: /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/, message: "must be ISO datetime" },
+      time: { regex: /^\d{2}:\d{2}(:\d{2})?$/, message: "must be HH:MM or HH:MM:SS" },
+      ip: { regex: /^(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)$|^([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$/, message: "must be a valid IP" },
+      ipv4: { regex: /^(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)$/, message: "must be a valid IPv4" },
+      ipv6: { regex: /^([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$/, message: "must be a valid IPv6" },
+      "mac-address": { regex: /^([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2})$/, message: "must be a valid MAC address" },
+      "credit-card": { regex: /^\d{13,19}$/, message: "must be a valid card number" },
+      "postal-code-us": { regex: /^\d{5}(-\d{4})?$/, message: "must be a valid US postal code" },
+      ssn: { regex: /^\d{3}-\d{2}-\d{4}$/, message: "must be XXX-XX-XXXX format" },
+      "hex-color": { regex: /^#([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$/, message: "must be #RGB or #RRGGBB" },
+      json: { regex: /^[\s\S]*$/, message: "must be valid JSON" }
+    };
+    const config = patterns[preset];
+    if (!config) return null;
+    if (preset === "json") {
+      try {
+        JSON.parse(value);
+        return null;
+      } catch {
+        return { field: fieldName, message: `${fieldName} ${config.message}` };
+      }
+    }
+    if (!config.regex.test(value)) {
+      return { field: fieldName, message: `${fieldName} ${config.message}` };
+    }
+    return null;
+  }
+  /**
+   * Create with validation (validates before sending to server)
+   */
+  async createValidated(collection, data) {
+    const validation = await this.validate(collection, data);
+    if (!validation.valid) {
+      return { errors: validation.errors };
+    }
+    const result = await this.create(collection, data);
+    return { data: result };
+  }
+  /**
+   * Update with validation (validates before sending to server)
+   */
+  async updateValidated(collection, id, data) {
+    const validation = await this.validate(collection, data);
+    if (!validation.valid) {
+      return { errors: validation.errors };
+    }
+    const result = await this.update(collection, id, data);
+    return { data: result };
+  }
+};
+
+// src/resources/files.ts
+var FilesResource2 = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async upload(file, options = {}) {
+    return this.client.upload("/files/upload", file, {
+      bucket: options.bucket || "squeed-storage",
+      entityType: options.entityType || "project",
+      entityId: options.entityId || "default"
+    });
+  }
+  async uploadMultiple(files, options = {}) {
+    return this.client.upload("/files/upload-multiple", files, {
+      bucket: options.bucket || "squeed-storage",
+      entityType: options.entityType || "project",
+      entityId: options.entityId || "default"
+    });
+  }
+  async list(entityType, entityId, options) {
+    const params = {};
+    if (options?.limit) params.limit = options.limit;
+    if (options?.offset) params.offset = options.offset;
+    const response = await this.client.get(`/files/entity/${entityType}/${entityId}`, params);
+    return response.files || [];
+  }
+  async getSignedUrl(bucket, key, expiresIn = 600) {
+    return this.client.get(`/files/signed-url/${bucket}/${encodeURIComponent(key)}`, { expiresIn });
+  }
+  async download(bucket, key) {
+    const { signedUrl } = await this.getSignedUrl(bucket, key);
+    const response = await fetch(signedUrl);
+    return response.blob();
+  }
+  /**
+   * Stream file download with optional progress tracking
+   * More efficient for large files than standard download()
+   * Streaming must be enabled in backend config (r2.streaming.enabled: true)
+   */
+  async downloadStream(bucket, key, options) {
+    const response = await this.client.getRaw(
+      `/files/stream/${bucket}/${encodeURIComponent(key)}`
+    );
+    if (!response.body) {
+      throw new Error("No response body");
+    }
+    const total = parseInt(response.headers.get("content-length") || "0", 10);
+    const reader = response.body.getReader();
+    const chunks = [];
+    let loaded = 0;
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        chunks.push(new Uint8Array(value));
+        loaded += value.length;
+        if (options?.onProgress) {
+          options.onProgress({
+            loaded,
+            total,
+            percentage: total > 0 ? Math.round(loaded / total * 100) : 0
+          });
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+    const contentType = response.headers.get("content-type") || "application/octet-stream";
+    return new Blob(chunks, { type: contentType });
+  }
+  /**
+   * Get a raw stream for the file
+   * Useful for custom processing or piping to other streams
+   * Streaming must be enabled in backend config (r2.streaming.enabled: true)
+   */
+  async getDownloadStream(bucket, key) {
+    const response = await this.client.getRaw(
+      `/files/stream/${bucket}/${encodeURIComponent(key)}`
+    );
+    if (!response.body) {
+      throw new Error("No response body");
+    }
+    return response.body;
+  }
+  async delete(bucket, key) {
+    return this.client.delete(`/files/${bucket}/${encodeURIComponent(key)}`);
+  }
+  async deleteByEntity(entityType, entityId) {
+    return this.client.delete(`/files/entity/${entityType}/${entityId}`);
+  }
+  async uploadJson(options) {
+    return this.client.post("/files/upload-json", options);
+  }
+};
+
+// src/resources/workflows.ts
+var TOOL_TYPES = [
+  "llm_call",
+  "api_call",
+  "shell_command",
+  "web_search",
+  "file_edit",
+  "git_command",
+  "mcp_tool",
+  "storage",
+  "database",
+  "notification",
+  "workflow",
+  "rag",
+  "cache",
+  "emit_event",
+  "transform"
+];
+var TRIGGER_TYPES = ["manual", "cron", "webhook", "event"];
+var NOTIFY_CHANNELS = ["email", "sms", "whatsapp", "push", "slack"];
+var NOTIFY_PRIORITIES = ["low", "normal", "high", "urgent"];
+var DB_OPERATIONS = ["get", "query", "insert", "update", "upsert", "delete", "deletewhere", "arrayRemove", "updateArrayElement", "count"];
+var STORAGE_OPERATIONS = ["get", "download", "put", "upload", "list", "signedUrl", "delete", "deleteByPrefix", "url", "publicUrl"];
+var CACHE_OPERATIONS = ["get", "set", "delete", "invalidate"];
+var LLM_PROVIDERS = ["openai", "anthropic", "google", "openrouter", "lmstudio", "custom", "claude", "ollama"];
+var CLI_PROVIDERS = ["claude", "openai", "aider", "anthropic", "claude-cli", "openai-cli", "ollama-cli"];
+var DB_PROVIDERS = ["firebase", "supabase", "sqlite", "custom"];
+var HTTP_METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE"];
+var RAG_MODES = ["single", "accumulate", "iterative"];
+var CHUNKING_STRATEGIES = ["fixed_size", "recursive", "token_based", "semantic"];
+var IMAGE_DETAILS = ["auto", "low", "high"];
+var CONDITION_OPERATORS = ["$eq", "$ne", "$gt", "$gte", "$lt", "$lte", "$in", "$exists"];
+var WORKFLOW_VALIDATION_SCHEMA = {
+  root: {
+    id: { type: "string", required: true, description: "Unique workflow identifier" },
+    name: { type: "string", required: true, description: "Human-readable workflow name" },
+    description: { type: "string", required: false, description: "Workflow purpose and details" },
+    tools: { type: "array", required: true, multiselect: true, description: "Tool definitions available to the workflow" },
+    workflows: { type: "array", required: true, multiselect: true, description: "Array of executable workflows" },
+    agent: {
+      type: "object",
+      required: false,
+      description: "Agent configuration with LLM instructions",
+      properties: {
+        id: { type: "string", required: false, description: "Unique agent identifier" },
+        name: { type: "string", required: false, description: "Agent display name" },
+        role: { type: "string", required: false, description: "Agent role/responsibility" },
+        llm_prompt: { type: "string", required: false, description: "System prompt for LLM" }
+      }
+    },
+    monitoring: {
+      type: "object",
+      required: false,
+      description: "KPI and performance tracking",
+      properties: {
+        kpis: {
+          type: "array",
+          required: false,
+          multiselect: true,
+          description: "Key performance indicators",
+          itemType: {
+            type: "object",
+            required: false,
+            properties: {
+              metric: { type: "string", required: true, description: "Metric name" },
+              target: { type: "string", required: false, description: "Target value" },
+              measurement: { type: "string", required: false, description: "Measurement source" }
+            }
+          }
+        }
+      }
+    },
+    working_directory: { type: "string", required: false, description: "Base directory for execution" },
+    context: { type: "object", required: false, description: "Initial context variables for template substitution" },
+    planOnly: { type: "boolean", required: false, default: false, description: "If true, only generate execution plan" },
+    allowPause: { type: "boolean", required: false, default: false, description: "Enable pause/resume capabilities" },
+    subscribable: { type: "boolean", required: false, default: false, description: "Enable real-time WebSocket progress updates" }
+  },
+  tool: {
+    name: { type: "string", required: true, description: "Unique tool identifier" },
+    type: { type: "enum", required: true, options: TOOL_TYPES, description: "Tool type" },
+    description: { type: "string", required: false, description: "What the tool does" },
+    endpoint: { type: "string", required: false, description: "API endpoint URL (for api_call type)" },
+    params: {
+      type: "object",
+      required: false,
+      description: "Configuration parameters",
+      properties: {
+        timeout: { type: "number", required: false, default: 3e4, description: "Timeout in milliseconds" },
+        method: { type: "enum", required: false, options: HTTP_METHODS, description: "HTTP method" },
+        headers: { type: "object", required: false, description: "HTTP headers" },
+        maxBuffer: { type: "number", required: false, description: "Max buffer size for shell commands" },
+        cwd: { type: "string", required: false, description: "Working directory" },
+        env: { type: "object", required: false, description: "Environment variables for shell commands" },
+        provider: { type: "enum", required: false, options: LLM_PROVIDERS, description: "LLM provider" },
+        model: { type: "string", required: false, description: "Model identifier" },
+        baseURL: { type: "string", required: false, description: "Custom API endpoint for LLM" },
+        temperature: { type: "number", required: false, default: 0.7, description: "LLM temperature (0-2)" },
+        max_tokens: { type: "number", required: false, default: 4e3, description: "Max tokens for LLM response" },
+        maxTokens: { type: "number", required: false, default: 4e3, description: "Max tokens (alias)" },
+        stop: { type: "array", required: false, multiselect: true, description: "Stop sequences for LLM" },
+        saveMedia: { type: "boolean", required: false, default: false, description: "Save generated images to storage" },
+        mediaBucket: { type: "string", required: false, description: "Storage bucket for media" },
+        mediaPrefix: { type: "string", required: false, description: "Path prefix for media files" },
+        cliProvider: { type: "enum", required: false, options: CLI_PROVIDERS, description: "CLI provider for shell commands" },
+        requireAuth: { type: "boolean", required: false, description: "Check CLI authentication" },
+        parseJSON: { type: "boolean", required: false, description: "Attempt to parse stdout as JSON" },
+        mcpServer: { type: "string", required: false, description: "MCP server name" },
+        toolName: { type: "string", required: false, description: "MCP tool name" },
+        operation: { type: "enum", required: false, options: [...DB_OPERATIONS, ...STORAGE_OPERATIONS, ...CACHE_OPERATIONS], description: "Database/storage/cache operation" },
+        bucket: { type: "string", required: false, description: "Storage bucket name" },
+        contentKey: { type: "string", required: false, description: "Storage content key/path" },
+        path: { type: "string", required: false, description: "File path (alias for contentKey)" },
+        entityType: { type: "string", required: false, description: "Entity type for storage linking" },
+        entityId: { type: "string", required: false, description: "Entity ID for storage linking" },
+        contentType: { type: "string", required: false, description: "MIME type" },
+        expiresIn: { type: "number", required: false, description: "Expiry in seconds for signed URLs" },
+        prefix: { type: "string", required: false, description: "Prefix for deleteByPrefix operation" },
+        dbProvider: { type: "enum", required: false, options: DB_PROVIDERS, default: "supabase", description: "Database provider" },
+        collection: { type: "string", required: false, description: "Database collection/table name" },
+        table: { type: "string", required: false, description: "Table name (alias for collection)" },
+        id: { type: "string", required: false, description: "Document/record ID" },
+        docId: { type: "string", required: false, description: "Document ID (alias)" },
+        data: { type: "object", required: false, description: "Data for insert/update" },
+        where: { type: "array", required: false, multiselect: true, description: "Query filters" },
+        filters: { type: "array", required: false, multiselect: true, description: "Query filters (alias)" },
+        orderBy: { type: "string", required: false, description: "Sort order" },
+        limit: { type: "number", required: false, description: "Result limit" },
+        offset: { type: "number", required: false, description: "Result offset" },
+        field: { type: "string", required: false, description: "Field name for array operations" },
+        value: { type: "string", required: false, description: "Value for array operations" },
+        arrayField: { type: "string", required: false, description: "Array field name" },
+        matchKey: { type: "string", required: false, description: "Key to match in array" },
+        matchValue: { type: "string", required: false, description: "Value to match in array" },
+        updates: { type: "object", required: false, description: "Partial update data" },
+        channels: { type: "array", required: false, multiselect: true, options: NOTIFY_CHANNELS, description: "Notification channels" },
+        title: { type: "string", required: false, description: "Notification title" },
+        body: { type: "string", required: false, description: "Notification message" },
+        userId: { type: "string", required: false, description: "Recipient user ID" },
+        email: { type: "string", required: false, description: "Recipient email" },
+        phone: { type: "string", required: false, description: "Recipient phone" },
+        priority: { type: "enum", required: false, options: NOTIFY_PRIORITIES, description: "Notification priority" },
+        category: { type: "string", required: false, description: "Notification category" },
+        actionUrl: { type: "string", required: false, description: "Action URL" },
+        actionText: { type: "string", required: false, description: "Action button text" },
+        imageUrl: { type: "string", required: false, description: "Image URL" },
+        respectUserPreferences: { type: "boolean", required: false, default: true, description: "Respect user notification preferences" },
+        silent: { type: "boolean", required: false, default: false, description: "Silent notification" },
+        saveToHistory: { type: "boolean", required: false, default: true, description: "Save to notification history" },
+        pattern: { type: "string", required: false, description: "Cache invalidation pattern" },
+        key: { type: "string", required: false, description: "Cache key" },
+        ttl: { type: "number", required: false, description: "Cache TTL in seconds" },
+        command: { type: "string", required: false, description: "Shell command to execute" }
+      }
+    }
+  },
+  step: {
+    id: { type: "string", required: true, description: "Unique step identifier within workflow" },
+    action: { type: "string", required: true, description: "Name of tool to execute" },
+    type: { type: "enum", required: false, options: TOOL_TYPES, description: "Step type override (e.g., for rag)" },
+    description: { type: "string", required: false, description: "Step purpose" },
+    input: {
+      type: "object",
+      required: false,
+      description: "Data passed to the step",
+      properties: {
+        query: { type: "string", required: false, description: "Search query for RAG" },
+        mode: { type: "enum", required: false, options: RAG_MODES, description: "RAG search mode" },
+        limit: { type: "number", required: false, default: 5, description: "Result limit" },
+        filter: { type: "object", required: false, description: "RAG filter criteria" },
+        contextKey: { type: "string", required: false, description: "Context key for RAG results" },
+        timeout: { type: "number", required: false, default: 3e4, description: "Step timeout" }
+      }
+    },
+    output: { type: "string", required: false, description: "Variable name to store output" },
+    params: { type: "object", required: false, description: "Step-specific parameter overrides (same as tool params)" },
+    conditions: {
+      type: "object",
+      required: false,
+      description: "Conditional execution logic",
+      properties: {
+        if: { type: "string", required: false, description: "Expression-based condition" }
+      }
+    },
+    files: {
+      type: "array",
+      required: false,
+      multiselect: true,
+      description: "File attachments for LLM steps",
+      itemType: {
+        type: "object",
+        required: false,
+        properties: {
+          id: { type: "string", required: false, description: "File ID" },
+          url: { type: "string", required: false, description: "File URL" },
+          data: { type: "string", required: false, description: "Base64 encoded data" },
+          mimeType: { type: "string", required: true, description: "MIME type" },
+          filename: { type: "string", required: false, description: "Original filename" }
+        }
+      }
+    },
+    images: {
+      type: "array",
+      required: false,
+      multiselect: true,
+      description: "Image attachments for vision tasks",
+      itemType: {
+        type: "object",
+        required: false,
+        properties: {
+          url: { type: "string", required: true, description: "Image URL" },
+          detail: { type: "enum", required: false, options: IMAGE_DETAILS, default: "auto", description: "Image detail level" }
+        }
+      }
+    },
+    dependsOn: { type: "array", required: false, multiselect: true, description: "Step IDs this step depends on" },
+    parallel: { type: "boolean", required: false, default: false, description: "Execute in parallel with other steps" },
+    earlyReturn: { type: "boolean", required: false, default: false, description: "Return immediately, continue in background" },
+    queueAsJob: { type: "boolean", required: false, default: false, description: "Queue background execution as a job (requires earlyReturn)" },
+    pausePoint: { type: "object", required: false, description: "Pause/approval control" },
+    retryCount: { type: "number", required: false, default: 0, description: "Current retry count" },
+    maxRetries: { type: "number", required: false, default: 0, description: "Maximum retry attempts" },
+    optional: { type: "boolean", required: false, default: false, description: "If true, step failure won't stop the workflow" },
+    continueOnError: { type: "boolean", required: false, default: false, description: "Alias for optional" },
+    defaultValue: { type: "object", required: false, description: "Value to use if step fails when optional=true" }
+  },
+  trigger: {
+    type: { type: "enum", required: true, options: TRIGGER_TYPES, description: "Trigger type" },
+    cron: { type: "string", required: false, description: "Cron expression for scheduled triggers" },
+    webhook: { type: "object", required: false, description: "Webhook configuration" },
+    event: { type: "string", required: false, description: "Event name or pattern for event triggers (e.g., posts.created, posts.*)" },
+    eventFilter: { type: "object", required: false, description: "Filter criteria for event data" }
+  },
+  pausePoint: {
+    requireApproval: { type: "boolean", required: false, default: false, description: "Manual approval required" },
+    message: { type: "string", required: false, description: "Message shown to user" },
+    metadata: { type: "object", required: false, description: "Custom metadata for pause state" },
+    notify: { type: "object", required: false, description: "Notification settings when paused" }
+  },
+  notify: {
+    enabled: { type: "boolean", required: false, default: false, description: "Enable notifications" },
+    channels: { type: "array", required: false, multiselect: true, options: NOTIFY_CHANNELS, description: "Notification channels" },
+    priority: { type: "enum", required: false, options: NOTIFY_PRIORITIES, default: "normal", description: "Notification priority" },
+    userId: { type: "string", required: false, description: "User ID to notify" }
+  },
+  workflow: {
+    name: { type: "string", required: true, description: "Workflow name" },
+    trigger: { type: "object", required: true, description: "Trigger configuration" },
+    steps: { type: "array", required: true, multiselect: true, description: "Array of workflow steps" },
+    config: {
+      type: "object",
+      required: false,
+      description: "Workflow-specific configuration",
+      properties: {
+        allowPause: { type: "boolean", required: false, description: "Override parent allowPause" },
+        maxAttempts: { type: "number", required: false, description: "Maximum retry attempts" }
+      }
+    }
+  },
+  fileAttachment: {
+    id: { type: "string", required: false, description: "File ID" },
+    url: { type: "string", required: false, description: "File URL" },
+    data: { type: "string", required: false, description: "Base64 encoded file data" },
+    mimeType: { type: "string", required: true, description: "MIME type of the file" },
+    filename: { type: "string", required: false, description: "Original filename" }
+  },
+  imageAttachment: {
+    url: { type: "string", required: true, description: "Image URL" },
+    detail: { type: "enum", required: false, options: IMAGE_DETAILS, default: "auto", description: "Image detail level for vision" }
+  },
+  conditionOperators: {
+    $eq: { type: "string", required: false, description: "Equal to value" },
+    $ne: { type: "string", required: false, description: "Not equal to value" },
+    $gt: { type: "number", required: false, description: "Greater than value" },
+    $gte: { type: "number", required: false, description: "Greater than or equal to value" },
+    $lt: { type: "number", required: false, description: "Less than value" },
+    $lte: { type: "number", required: false, description: "Less than or equal to value" },
+    $in: { type: "array", required: false, multiselect: true, description: "Value is in array" },
+    $exists: { type: "boolean", required: false, description: "Property exists" }
+  }
+};
+var WorkflowsResource2 = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async execute(config) {
+    return this.client.post("/agent/workflow", config);
+  }
+  async get(executionId) {
+    return this.client.get(`/agent/workflow/${executionId}`);
+  }
+  async list(params) {
+    const response = await this.client.get("/agent/workflows/executions", params);
+    return { executions: response.executions || [], pagination: response.pagination };
+  }
+  async getHistory(workflowId) {
+    return this.client.get(`/agent/workflow/${workflowId}/history`);
+  }
+  async pause(executionId) {
+    return this.client.post(`/agent/workflow/${executionId}/pause`);
+  }
+  async resume(executionId, options) {
+    return this.client.post("/agent/workflow/resume", {
+      executionId,
+      continue: options?.continue ?? true,
+      userInput: options?.userInput
+    });
+  }
+  async cancel(executionId) {
+    return this.client.post(`/agent/workflow/${executionId}/cancel`);
+  }
+  async getStatus(executionId) {
+    const response = await this.client.get(`/agent/workflow/${executionId}/status`);
+    return response.execution;
+  }
+  async retry(executionId) {
+    return this.client.post(`/agent/workflow/${executionId}/retry`);
+  }
+  async rerun(workflowId) {
+    return this.client.post(`/agent/workflow/${workflowId}/rerun`);
+  }
+  async delete(workflowId) {
+    return this.client.delete(`/agent/workflows/executions/${workflowId}`);
+  }
+  async deleteAll() {
+    return this.client.delete("/agent/workflows/executions");
+  }
+  subscribe(executionId, handlers) {
+    const ws = this.client.createWebSocket(`workflow:${executionId}`);
+    ws.onmessage = (event) => {
+      try {
+        const data = JSON.parse(event.data);
+        switch (data.type) {
+          case "step_started":
+            handlers.onStepStarted?.(data.step);
+            break;
+          case "step_completed":
+            handlers.onStepCompleted?.(data.step, data.duration);
+            handlers.onProgress?.({ stepId: data.step, status: "success" });
+            break;
+          case "step_failed":
+            handlers.onStepFailed?.(data.step, data.error);
+            handlers.onProgress?.({ stepId: data.step, status: "failed", error: data.error });
+            break;
+          case "step_skipped":
+            handlers.onStepSkipped?.(data.step, data.error);
+            handlers.onProgress?.({ stepId: data.step, status: "skipped", error: data.error });
+            break;
+          case "workflow_completed":
+            handlers.onComplete?.({ id: data.executionId, workflowId: "", status: "completed", startedAt: "" });
+            break;
+          case "workflow_failed":
+            handlers.onError?.(new Error(data.error || "Workflow failed"));
+            break;
+          case "workflow_cancelled":
+            handlers.onComplete?.({ id: data.executionId, workflowId: "", status: "cancelled", startedAt: "" });
+            break;
+        }
+      } catch (error) {
+        handlers.onError?.(error);
+      }
+    };
+    ws.onerror = (error) => handlers.onError?.(error);
+    return () => ws.close();
+  }
+  getValidationSchema() {
+    return WORKFLOW_VALIDATION_SCHEMA;
+  }
+  getSchemaFor(section) {
+    return WORKFLOW_VALIDATION_SCHEMA[section];
+  }
+  getToolTypes() {
+    return TOOL_TYPES;
+  }
+  getTriggerTypes() {
+    return TRIGGER_TYPES;
+  }
+  getNotifyChannels() {
+    return NOTIFY_CHANNELS;
+  }
+  getNotifyPriorities() {
+    return NOTIFY_PRIORITIES;
+  }
+  getDbOperations() {
+    return DB_OPERATIONS;
+  }
+  getStorageOperations() {
+    return STORAGE_OPERATIONS;
+  }
+  validateProperty(section, property, value) {
+    const schema = WORKFLOW_VALIDATION_SCHEMA[section];
+    const propSchema = schema[property];
+    if (!propSchema) {
+      return { valid: false, error: `Unknown property: ${property}` };
+    }
+    if (propSchema.required && (value === void 0 || value === null)) {
+      return { valid: false, error: `${property} is required` };
+    }
+    if (value === void 0 || value === null) {
+      return { valid: true };
+    }
+    if (propSchema.type === "enum" && propSchema.options) {
+      if (!propSchema.options.includes(value)) {
+        return { valid: false, error: `${property} must be one of: ${propSchema.options.join(", ")}` };
+      }
+    }
+    if (propSchema.type === "array" && !Array.isArray(value)) {
+      return { valid: false, error: `${property} must be an array` };
+    }
+    if (propSchema.type === "boolean" && typeof value !== "boolean") {
+      return { valid: false, error: `${property} must be a boolean` };
+    }
+    if (propSchema.type === "number" && typeof value !== "number") {
+      return { valid: false, error: `${property} must be a number` };
+    }
+    if (propSchema.type === "string" && typeof value !== "string") {
+      return { valid: false, error: `${property} must be a string` };
+    }
+    return { valid: true };
+  }
+};
+var TOOL_PARAM_CONTEXT = {
+  llm_call: ["provider", "model", "temperature", "max_tokens", "baseURL", "stop", "saveMedia", "mediaBucket"],
+  api_call: ["method", "headers", "timeout", "endpoint"],
+  shell_command: ["command", "cwd", "timeout", "env", "maxBuffer", "cliProvider", "parseJSON", "requireAuth"],
+  database: ["dbProvider", "operation", "collection", "id", "data", "where", "orderBy", "limit", "offset"],
+  storage: ["operation", "bucket", "contentKey", "path", "data", "contentType", "expiresIn", "prefix"],
+  notification: ["channels", "title", "body", "userId", "email", "phone", "priority", "silent"],
+  cache: ["operation", "key", "pattern", "ttl", "value"],
+  mcp_tool: ["mcpServer", "toolName", "timeout"],
+  rag: ["query", "mode", "limit", "filter", "contextKey"],
+  workflow: ["timeout"],
+  web_search: ["query", "limit"],
+  file_edit: ["path", "content"],
+  git_command: ["command", "cwd"]
+};
+function formatProp(key, val, indent = "") {
+  const req = val.required ? "*" : "";
+  const opts = val.options ? ` [${val.options.slice(0, 6).join("|")}${val.options.length > 6 ? "..." : ""}]` : "";
+  const multi = val.multiselect ? "[]" : "";
+  return `${indent}${key}${req}: ${val.type}${multi}${opts}`;
+}
+function toPromptContext(options = {}) {
+  const { sections, toolType, compact = false } = options;
+  const sectionsToInclude = sections || ["root", "tool", "step", "trigger", "pausePoint", "notify"];
+  let out = "# Workflow Schema\n\n";
+  if (!compact) {
+    out += `Tool types: ${TOOL_TYPES.join(", ")}
+`;
+    out += `Triggers: ${TRIGGER_TYPES.join(", ")}
+`;
+    out += `Notify channels: ${NOTIFY_CHANNELS.join(", ")}
+
+`;
+  }
+  for (const section of sectionsToInclude) {
+    const schema = WORKFLOW_VALIDATION_SCHEMA[section];
+    if (!schema) continue;
+    out += `## ${section}
+`;
+    for (const [key, val] of Object.entries(schema)) {
+      if (key === "params" && toolType && TOOL_PARAM_CONTEXT[toolType]) {
+        out += formatProp(key, val) + "\n";
+        const relevantParams = TOOL_PARAM_CONTEXT[toolType];
+        if (val.properties) {
+          for (const pk of relevantParams) {
+            const pv = val.properties[pk];
+            if (pv) out += formatProp(pk, pv, "  ") + "\n";
+          }
+        }
+      } else {
+        out += formatProp(key, val) + "\n";
+        if (!compact && val.properties) {
+          for (const [pk, pv] of Object.entries(val.properties)) {
+            out += formatProp(pk, pv, "  ") + "\n";
+          }
+        }
+      }
+    }
+    out += "\n";
+  }
+  return out;
+}
+function toCompactContext(toolType) {
+  return toPromptContext({ compact: true, toolType, sections: ["step", "tool"] });
+}
+
+// src/resources/embeddings.ts
+var EmbeddingsResource2 = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async listDocuments(limit = 100) {
+    return this.client.get("/agent/embeddings/documents", { limit });
+  }
+  async embedDocument(options) {
+    return this.client.post("/agent/embeddings/document", options);
+  }
+  async embedBatch(documents, contentType) {
+    return this.client.post("/agent/embeddings/batch", {
+      documents,
+      contentType
+    });
+  }
+  async search(documentId, query, limit = 5) {
+    return this.client.get(`/agent/embeddings/document/${encodeURIComponent(documentId)}/search`, {
+      q: query,
+      limit
+    });
+  }
+  async delete(documentId) {
+    return this.client.delete(`/agent/embeddings/document/${encodeURIComponent(documentId)}`);
+  }
+  async semanticSearch(query, limit = 10) {
+    return this.client.post("/agent/tools/semantic-search", {
+      query,
+      limit
+    });
+  }
+};
+
+// src/resources/usage.ts
+var UsageResource2 = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async getMyUsage() {
+    return this.client.get("/usage/me");
+  }
+  async getUserUsage(userId, options) {
+    return this.client.get(`/usage/user/${userId}`, options);
+  }
+  async getSummary(userId) {
+    return this.client.get(`/usage/user/${userId}/summary`);
+  }
+};
+
+// src/resources/analytics.ts
+var AnalyticsResource2 = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async project(projectId) {
+    return this.client.get(`/analytics/project/${projectId}`);
+  }
+};
+
+// src/resources/github.ts
+var GithubResource2 = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async import(owner, repo, options) {
+    return this.client.post(`/api/github/repos/${owner}/${repo}/import`, options);
+  }
+  async repos() {
+    return this.client.get("/api/github/repos");
+  }
+  async contents(owner, repo, path) {
+    const url = path ? `/api/github/repos/${owner}/${repo}/contents/${path}` : `/api/github/repos/${owner}/${repo}/contents`;
+    return this.client.get(url);
+  }
+  async branches(owner, repo) {
+    return this.client.get(`/api/github/repos/${owner}/${repo}/branches`);
+  }
+  async pulls(owner, repo) {
+    return this.client.get(`/api/github/repos/${owner}/${repo}/pulls`);
+  }
+  async getPull(owner, repo, pullNumber) {
+    return this.client.get(`/api/github/repos/${owner}/${repo}/pulls/${pullNumber}`);
+  }
+  async files(owner, repo, pullNumber) {
+    return this.client.get(`/api/github/repos/${owner}/${repo}/pulls/${pullNumber}/files`);
+  }
+};
+
+// src/resources/queues.ts
+var QueuesResource2 = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Get all queues and their statistics (tenant-isolated) */
+  async list() {
+    return this.client.get("/queues");
+  }
+  /** Get statistics for a specific queue (tenant-isolated) */
+  async stats(name) {
+    return this.client.get(`/queues/${name}/stats`);
+  }
+  /** Get jobs from a queue (tenant-isolated) */
+  async jobs(name) {
+    return this.client.get(`/queues/${name}/jobs`);
+  }
+  /** Add a job to the queue (with tenant isolation) */
+  async createJob(name, data) {
+    return this.client.post(`/queues/${name}/jobs`, data);
+  }
+  /** Get a specific job (tenant-isolated) */
+  async getJob(name, jobId) {
+    return this.client.get(`/queues/${name}/jobs/${jobId}`);
+  }
+  /** Retry a failed job (tenant-isolated) */
+  async retry(name, jobId, data) {
+    return this.client.post(`/queues/${name}/jobs/${jobId}/retry`, data);
+  }
+  /** Pause a queue (admin only - affects all tenants) */
+  async pause(name, data) {
+    return this.client.post(`/queues/${name}/pause`, data);
+  }
+  /** Resume a paused queue (admin only - affects all tenants) */
+  async resume(name, data) {
+    return this.client.post(`/queues/${name}/resume`, data);
+  }
+  /** Clean old jobs from queue (tenant-isolated) */
+  async createClean(name, data) {
+    return this.client.post(`/queues/${name}/clean`, data);
+  }
+  /** Get detailed performance metrics for a queue */
+  async metrics(name) {
+    return this.client.get(`/queues/${name}/metrics`);
+  }
+  /** Subscribe to job updates via SSE. Returns unsubscribe function. */
+  subscribe(sseUrl, handlers) {
+    return this.client.subscribeSSE(sseUrl, handlers);
+  }
+};
+
+// src/resources/search.ts
+var SearchConfigValidator = class {
+  constructor() {
+    this.validOperators = ["eq", "neq", "gt", "gte", "lt", "lte", "like", "ilike", "in", "not_in", "is_null", "not_null"];
+    this.validModes = ["exact", "fuzzy", "hybrid"];
+  }
+  /**
+   * Validate search options for a query
+   */
+  validateSearchOptions(options) {
+    const errors = [];
+    if (!options.q || options.q.trim().length === 0) {
+      errors.push({ field: "q", message: "Search query is required and cannot be empty" });
+    }
+    if (options.mode && !this.validModes.includes(options.mode)) {
+      errors.push({ field: "mode", message: `Invalid mode. Must be one of: ${this.validModes.join(", ")}` });
+    }
+    if (options.limit !== void 0) {
+      if (options.limit < 1 || options.limit > 100) {
+        errors.push({ field: "limit", message: "Limit must be between 1 and 100" });
+      }
+    }
+    if (options.threshold !== void 0) {
+      if (options.threshold < 0 || options.threshold > 1) {
+        errors.push({ field: "threshold", message: "Threshold must be between 0 and 1" });
+      }
+    }
+    return { valid: errors.length === 0, errors };
+  }
+  /**
+   * Validate entity configuration
+   */
+  validateEntityConfig(entity, config) {
+    const errors = [];
+    if (!entity || entity.trim().length === 0) {
+      errors.push({ field: "entity", message: "Entity name is required" });
+    }
+    if (!config.searchFields || config.searchFields.length === 0) {
+      errors.push({ field: "searchFields", message: "At least one search field is required" });
+    } else {
+      config.searchFields.forEach((field, idx) => {
+        if (!field || field.trim().length === 0) {
+          errors.push({ field: `searchFields[${idx}]`, message: "Search field cannot be empty" });
+        }
+      });
+    }
+    if (config.filters) {
+      config.filters.forEach((filter, idx) => {
+        if (!filter.column) {
+          errors.push({ field: `filters[${idx}].column`, message: "Filter column is required" });
+        }
+        if (!filter.operator) {
+          errors.push({ field: `filters[${idx}].operator`, message: "Filter operator is required" });
+        } else if (!this.validOperators.includes(filter.operator)) {
+          errors.push({
+            field: `filters[${idx}].operator`,
+            message: `Invalid operator. Must be one of: ${this.validOperators.join(", ")}`
+          });
+        }
+      });
+    }
+    return { valid: errors.length === 0, errors };
+  }
+  /**
+   * Validate full search configuration
+   */
+  validateConfig(config) {
+    const errors = [];
+    if (config.defaultMode && !this.validModes.includes(config.defaultMode)) {
+      errors.push({ field: "defaultMode", message: `Invalid mode. Must be one of: ${this.validModes.join(", ")}` });
+    }
+    if (config.defaultLimit !== void 0) {
+      if (config.defaultLimit < 1 || config.defaultLimit > 100) {
+        errors.push({ field: "defaultLimit", message: "Default limit must be between 1 and 100" });
+      }
+    }
+    if (config.cacheTTL !== void 0 && config.cacheTTL < 0) {
+      errors.push({ field: "cacheTTL", message: "Cache TTL cannot be negative" });
+    }
+    if (config.threshold !== void 0) {
+      if (config.threshold < 0 || config.threshold > 1) {
+        errors.push({ field: "threshold", message: "Threshold must be between 0 and 1" });
+      }
+    }
+    if (config.entities) {
+      Object.entries(config.entities).forEach(([entity, entityConfig]) => {
+        const entityResult = this.validateEntityConfig(entity, entityConfig);
+        entityResult.errors.forEach((err) => {
+          errors.push({ field: `entities.${entity}.${err.field}`, message: err.message });
+        });
+      });
+    }
+    return { valid: errors.length === 0, errors };
+  }
+};
+var SearchResource2 = class {
+  constructor(client) {
+    this.client = client;
+    this.validator = new SearchConfigValidator();
+  }
+  /**
+   * Search an entity
+   *
+   * @param entity - Entity/table name to search
+   * @param options - Search options
+   * @returns Search results with metadata
+   *
+   * @example
+   * ```typescript
+   * // Basic search
+   * const results = await backflow.search.query('products', { q: 'laptop' });
+   *
+   * // Advanced search with all options
+   * const results = await backflow.search.query('products', {
+   *   q: 'gaming laptop',
+   *   mode: 'hybrid',      // 'exact' | 'fuzzy' | 'hybrid'
+   *   limit: 20,           // max results
+   *   threshold: 0.7       // similarity threshold for fuzzy/hybrid
+   * });
+   *
+   * // Access results
+   * results.results.forEach(product => {
+   *   console.log(product.name, product._score); // _score for fuzzy results
+   * });
+   * ```
+   */
+  async query(entity, options) {
+    const validation = this.validator.validateSearchOptions(options);
+    if (!validation.valid) {
+      throw new Error(`Invalid search options: ${validation.errors.map((e) => e.message).join(", ")}`);
+    }
+    const params = { q: options.q };
+    if (options.mode) params.mode = options.mode;
+    if (options.limit) params.limit = options.limit;
+    if (options.threshold) params.threshold = options.threshold;
+    return this.client.get(`/search/${entity}`, params);
+  }
+  /**
+   * Index entity records for vector search
+   *
+   * @param options - Index options
+   * @returns Index result
+   *
+   * @example
+   * ```typescript
+   * // Index all products
+   * const result = await backflow.search.index({ entity: 'products' });
+   * console.log(`Indexed ${result.indexed} records in ${result.latency}ms`);
+   *
+   * // Index specific records
+   * await backflow.search.index({
+   *   entity: 'products',
+   *   ids: ['prod_123', 'prod_456'],
+   *   batchSize: 50
+   * });
+   * ```
+   */
+  async index(options) {
+    return this.client.post("/search/index", options);
+  }
+  /**
+   * Delete and reindex all records for an entity
+   *
+   * @param options - Reindex options
+   * @returns Reindex result
+   *
+   * @example
+   * ```typescript
+   * // Reindex all products
+   * const result = await backflow.search.reindex({ entity: 'products' });
+   * console.log(`Deleted ${result.deleted}, indexed ${result.indexed}`);
+   * ```
+   */
+  async reindex(options) {
+    return this.client.post("/search/reindex", options);
+  }
+  /**
+   * Delete all indexed records for an entity
+   *
+   * @param entity - Entity name
+   * @returns Delete result
+   *
+   * @example
+   * ```typescript
+   * await backflow.search.delete('products');
+   * ```
+   */
+  async delete(entity) {
+    return this.client.delete(`/search/index/${entity}`);
+  }
+  /**
+   * Get search statistics
+   *
+   * @returns Search configuration stats
+   *
+   * @example
+   * ```typescript
+   * const stats = await backflow.search.stats();
+   * console.log('Configured entities:', stats.configuredEntities);
+   * console.log('Default mode:', stats.defaultMode);
+   * ```
+   */
+  async stats() {
+    return this.client.get("/search/stats");
+  }
+};
+
+// src/resources/tenant.ts
+var TenantResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async getInfo() {
+    return this.client.get("/tenant/info");
+  }
+  async getConfig() {
+    return this.client.get(
+      "/tenant/config"
+    );
+  }
+  async updateConfig(config) {
+    return this.client.put(
+      "/tenant/config",
+      config
+    );
+  }
+  async getUsage() {
+    return this.client.get("/tenant/usage");
+  }
+  async getId() {
+    const info = await this.getInfo();
+    return info.id;
+  }
+};
+
+// src/sdk.ts
+var IntegrationsResource = class {
+  constructor(client) {
+    this.client = client;
+    this.stripe = new StripeResource(client);
+    this.polar = new PolarResource(client);
+  }
+};
+var BackflowSDK = class {
+  constructor(config) {
+    this.client = new BackflowClient(config);
+    this.agentAnalysis = new AgentAnalysisResource(this.client);
+    this.assets = new AssetsResource(this.client);
+    this.batch = new BatchResource(this.client);
+    this.cache = new CacheResource(this.client);
+    this.default = new DefaultResource(this.client);
+    this.deployment = new DeploymentResource(this.client);
+    this.feedback = new FeedbackResource(this.client);
+    this.goals = new GoalsResource(this.client);
+    this.googleDrive = new GoogleDriveResource(this.client);
+    this.jira = new JiraResource(this.client);
+    this.llm = new LlmResource(this.client);
+    this.mcptools = new McpToolsResource(this.client);
+    this.projects = new ProjectsResource(this.client);
+    this.publish = new PublishResource(this.client);
+    this.teams = new TeamsResource(this.client);
+    this.tenantWebhookReceivers = new TenantWebhookReceiversResource(this.client);
+    this.tenantWebhooks = new TenantWebhooksResource(this.client);
+    this.tooldiscovery = new ToolDiscoveryResource(this.client);
+    this.tracking = new TrackingResource(this.client);
+    this.twitter = new TwitterResource(this.client);
+    this.websocket = new WebsocketResource(this.client);
+    this.workspaces = new WorkspacesResource(this.client);
+    this.integrations = new IntegrationsResource(this.client);
+    this.files = new FilesResource2(this.client);
+    this.workflows = new WorkflowsResource2(this.client);
+    this.embeddings = new EmbeddingsResource2(this.client);
+    this.usage = new UsageResource2(this.client);
+    this.analytics = new AnalyticsResource2(this.client);
+    this.github = new GithubResource2(this.client);
+    this.queues = new QueuesResource2(this.client);
+    this.search = new SearchResource2(this.client);
+    this.ai = new AIResource(this.client);
+    this.collaboration = new CollaborationResource(this.client);
+    this.webhooks = (projectId) => new WebhooksFactory(this.client).for(projectId);
+    this.exports = new ExportsResource(this.client);
+    this.user = new UserResource(this.client);
+    this.tenant = new TenantResource(this.client);
+    this.entities = new EntitiesResource(this.client);
+  }
+  get endpoint() {
+    return this.client.endpoint;
+  }
+  get(path, params) {
+    return this.client.get(path, params);
+  }
+  post(path, data, params) {
+    return this.client.post(path, data, params);
+  }
+  put(path, data, params) {
+    return this.client.put(path, data, params);
+  }
+  patch(path, data, params) {
+    return this.client.patch(path, data, params);
+  }
+  delete(path, params) {
+    return this.client.delete(path, params);
+  }
+};
+function createBackflow(config) {
+  return new BackflowSDK(config);
+}
+
+// src/docs.ts
+function getSDKDocs() {
+  return `
+## @backflow/sdk Methods
+
+Use the sdk: prefix in component actions to call SDK methods.
+Example: dataSource: "sdk:entities.list('products')"
+
+### Entities (bf.entities)
+CRUD operations on database collections.
+
+- list(collection, options?) \u2192 Promise<{data: Entity[], count?: number}>
+  Options: { limit?: number, offset?: number, includeDeleted?: boolean }
+  Example: sdk:entities.list('users', {limit: 10})
+
+- get(collection, id) \u2192 Promise<Entity>
+  Example: sdk:entities.get('users', '{{userId}}')
+
+- create(collection, data) \u2192 Promise<Entity>
+  Example: sdk:entities.create('orders', formData)
+
+- update(collection, id, data) \u2192 Promise<Entity>
+  Example: sdk:entities.update('users', '{{userId}}', formData)
+
+- delete(collection, id, options?) \u2192 Promise<{success: boolean}>
+  Options: { hard?: boolean }
+  Example: sdk:entities.delete('orders', '{{orderId}}')
+
+- getSchema() \u2192 Promise<CollectionSchema[]>
+  Get schema for all collections
+
+### WebSocket (bf.websocket)
+Real-time subscriptions and messaging.
+
+- connect(options?) \u2192 Promise<void>
+  Establish WebSocket connection
+
+- subscribe(channel, callback) \u2192 UnsubscribeFn
+  Example: sdk:websocket.subscribe('orders:{{userId}}', onOrderUpdate)
+
+- publish(channel, data) \u2192 void
+  Example: sdk:websocket.publish('notifications', {type: 'alert', message: '...'})
+
+### Workflows (bf.workflows)
+Trigger backend automation.
+
+- trigger(workflowId, input?) \u2192 Promise<{success: boolean, data?: any}>
+  Example: sdk:workflows.trigger('send-welcome-email', {userId: '{{userId}}'})
+
+- list() \u2192 Promise<Workflow[]>
+  Get available workflows
+
+### Files (bf.files)
+File upload and storage.
+
+- upload(file, options?) \u2192 Promise<{url: string, key: string}>
+  Options: { path?: string, public?: boolean }
+
+- list(prefix?) \u2192 Promise<FileInfo[]>
+  List files in storage
+
+- getUrl(key) \u2192 Promise<string>
+  Get download URL for a file
+
+### Cache (bf.cache)
+Key-value caching.
+
+- get(key) \u2192 Promise<any>
+- set(key, value, ttl?) \u2192 Promise<void>
+- delete(key) \u2192 Promise<void>
+
+### Search (bf.search)
+Full-text search across entities.
+
+- query(collection, query, options?) \u2192 Promise<SearchResult[]>
+  Options: { limit?: number, fields?: string[] }
+
+### Queues (bf.queues)
+Background job processing.
+
+- push(queueName, data) \u2192 Promise<{jobId: string}>
+  Example: sdk:queues.push('email-queue', {to: '{{email}}', template: 'welcome'})
+
+### Pagination
+List operations support automatic pagination via limit/offset.
+Response includes count for total items.
+
+Component props:
+- pagination: boolean (default: true) - show Previous/Next controls
+- pageSize: number (default: 10) - items per page
+
+Example:
+  {"type": "list", "dataSource": "sdk:entities.list('orders')", "pageSize": 20}
+  {"type": "table", "dataSource": "sdk:entities.list('users')", "pagination": true}
+`;
+}
+function getSDKDocsCompact() {
+  return `
+SDK METHODS (use sdk: prefix):
+
+ENTITIES:
+  sdk:entities.list('collection', {limit?, offset?})
+  sdk:entities.get('collection', 'id')
+  sdk:entities.create('collection', data)
+  sdk:entities.update('collection', 'id', data)
+  sdk:entities.delete('collection', 'id')
+
+WEBSOCKET:
+  sdk:websocket.subscribe('channel', callback)
+  sdk:websocket.publish('channel', data)
+
+WORKFLOWS:
+  sdk:workflows.trigger('workflowId', input)
+
+FILES:
+  sdk:files.upload(file, {path?, public?})
+
+QUEUES:
+  sdk:queues.push('queueName', data)
+
+PAGINATION (auto-handled by renderer):
+  list/table props: pagination (true), pageSize (10)
+  Response includes count for total items
+`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AgentAnalysisResource,
+  AnalyticsResource,
+  AssetsResource,
+  Backflow,
+  BackflowClient,
+  BackflowSDK,
+  BatchResource,
+  CACHE_OPERATIONS,
+  CHUNKING_STRATEGIES,
+  CLI_PROVIDERS,
+  CONDITION_OPERATORS,
+  CacheResource,
+  DB_OPERATIONS,
+  DB_PROVIDERS,
+  DefaultResource,
+  DeploymentResource,
+  EmbeddingsResource,
+  FeedbackResource,
+  FilesResource,
+  GithubResource,
+  GoalsResource,
+  GoogleDriveResource,
+  HTTP_METHODS,
+  IMAGE_DETAILS,
+  JiraResource,
+  LLM_PROVIDERS,
+  LlmResource,
+  McpToolsResource,
+  NOTIFY_CHANNELS,
+  NOTIFY_PRIORITIES,
+  PolarResource,
+  ProjectsResource,
+  PublishResource,
+  QueuesResource,
+  RAG_MODES,
+  STORAGE_OPERATIONS,
+  SearchResource,
+  StripeResource,
+  TOOL_PARAM_CONTEXT,
+  TOOL_TYPES,
+  TRIGGER_TYPES,
+  TeamsResource,
+  TenantWebhookReceiversResource,
+  TenantWebhooksResource,
+  ToolDiscoveryResource,
+  TrackingResource,
+  TwitterResource,
+  UsageResource,
+  WORKFLOW_VALIDATION_SCHEMA,
+  WebsocketResource,
+  WorkflowsResource,
+  WorkspacesResource,
+  createBackflow,
+  getSDKDocs,
+  getSDKDocsCompact,
+  toCompactContext,
+  toPromptContext
+});