@synapcores/sdk 0.1.0 → 0.2.1

package/dist/index.mjs

@@ -30,13 +30,14 @@ var Subscription = class extends EventEmitter {
   }
   async createConnection() {
     const client = this.collection.client;
-    const protocol = client.config.useHttps ? "wss" : "ws";
-    const url = `${protocol}://${client.config.host}:${client.config.port}/v1/ws`;
-    const headers = {};
-    if (client.config.apiKey) {
-      headers["Authorization"] = `Bearer ${client.config.apiKey}`;
-    }
-    this.ws = new WebSocket(url, { headers });
+    const { token } = await client.createWsTicket();
+    const wsBase = client._getWsBaseUrl ? client._getWsBaseUrl() : (() => {
+      const cfg = client.config ?? client._getConfig();
+      const protocol = cfg.useHttps ? "wss" : "ws";
+      return `${protocol}://${cfg.host}:${cfg.port}`;
+    })();
+    const url = `${wsBase}/ws?token=${encodeURIComponent(token)}`;
+    this.ws = new WebSocket(url);
     this.ws.on("open", () => {
       this.reconnectAttempts = 0;
       this.subscribe();
@@ -347,19 +348,14 @@ var AutoMLModel = class {
     const isSingle = !Array.isArray(data);
     const inputs = isSingle ? [data] : data;
     const response = await this.client.synapCores._getHttpClient().post(
-      "/ai/predict",
-      {
-        model_id: this.id,
-        inputs
-      }
+      `/automl/models/${this.id}/predict`,
+      { inputs }
     );
-    const predictions = response.data.predictions;
+    const predictions = response.data.predictions ?? response.data;
     return isSingle ? predictions[0] : predictions;
   }
   async evaluate(testData, target) {
-    const payload = {
-      model_id: this.id
-    };
+    const payload = {};
     if (typeof testData === "string") {
       payload.collection = testData;
     } else {
@@ -369,14 +365,14 @@ var AutoMLModel = class {
       }
     }
     const { data } = await this.client.synapCores._getHttpClient().post(
-      "/ai/evaluate",
+      `/automl/models/${this.id}/evaluate`,
       payload
     );
     return data;
   }
   async delete() {
     await this.client.synapCores._getHttpClient().delete(
-      `/ai/models/${this.id}`
+      `/automl/models/${this.id}`
     );
   }
 };
@@ -385,7 +381,7 @@ var AutoMLClient = class {
     this.synapCores = synapCores;
   }
   async train(options) {
-    const { data } = await this.synapCores._getHttpClient().post("/ai/train", {
+    const { data } = await this.synapCores._getHttpClient().post("/automl/train", {
       collection: options.collection,
       target: options.target,
       features: options.features,
@@ -402,15 +398,15 @@ var AutoMLClient = class {
       task: data.task,
       status: data.status,
       accuracy: data.accuracy,
-      createdAt: new Date(data.created_at),
+      createdAt: new Date(data.created_at ?? Date.now()),
       updatedAt: data.updated_at ? new Date(data.updated_at) : void 0,
-      config: data.config
+      config: data.config ?? {}
     };
     return new AutoMLModel(this, modelInfo);
   }
   async getModel(modelId) {
     const { data } = await this.synapCores._getHttpClient().get(
-      `/ai/models/${modelId}`
+      `/automl/models/${modelId}`
     );
     const modelInfo = {
       id: data.id,
@@ -418,32 +414,35 @@ var AutoMLClient = class {
       task: data.task,
       status: data.status,
       accuracy: data.accuracy,
-      createdAt: new Date(data.created_at),
+      createdAt: new Date(data.created_at ?? Date.now()),
       updatedAt: data.updated_at ? new Date(data.updated_at) : void 0,
-      config: data.config
+      config: data.config ?? {}
     };
     return new AutoMLModel(this, modelInfo);
   }
   async listModels(filters) {
-    const { data } = await this.synapCores._getHttpClient().get("/ai/models", {
+    const { data } = await this.synapCores._getHttpClient().get("/automl/models", {
       params: filters
     });
-    return data.models.map((model) => ({
+    return (data.models ?? data ?? []).map((model) => ({
       id: model.id,
       name: model.name,
       task: model.task,
       status: model.status,
       accuracy: model.accuracy,
-      createdAt: new Date(model.created_at),
+      createdAt: new Date(model.created_at ?? Date.now()),
       updatedAt: model.updated_at ? new Date(model.updated_at) : void 0,
-      config: model.config
+      config: model.config ?? {}
     }));
   }
   /**
-   * Start async training job
+   * Start async training job.
+   *
+   * In v1.5.0-ce there is no separate /train/async endpoint — /automl/train
+   * itself returns a job descriptor when the training is long-running.
    */
   async trainAsync(options) {
-    const { data } = await this.synapCores._getHttpClient().post("/ai/train/async", {
+    const { data } = await this.synapCores._getHttpClient().post("/automl/train", {
       collection: options.collection,
       target: options.target,
       features: options.features,
@@ -453,49 +452,20 @@ var AutoMLClient = class {
       validation_split: options.validationSplit || 0.2,
       max_trials: options.maxTrials || 10,
       timeout_minutes: options.timeoutMinutes || 60,
+      async: true,
       callback_url: options.callback_url,
       webhook_url: options.webhook_url
     });
-    return {
-      id: data.id || data.job_id,
-      name: data.name,
-      status: data.status,
-      progress: data.progress || 0,
-      phase: data.phase,
-      task: data.task,
-      current_trial: data.current_trial,
-      total_trials: data.total_trials || options.maxTrials || 10,
-      best_accuracy: data.best_accuracy,
-      eta_ms: data.eta_ms || data.estimated_time_remaining_ms,
-      error: data.error,
-      started_at: new Date(data.started_at || Date.now()),
-      completed_at: data.completed_at ? new Date(data.completed_at) : void 0,
-      model_id: data.model_id
-    };
+    return this.mapTrainingJob(data, options.maxTrials || 10);
   }
   /**
    * Get training job status
    */
   async getTrainingJob(jobId) {
     const { data } = await this.synapCores._getHttpClient().get(
-      `/ai/train/jobs/${jobId}`
+      `/automl/jobs/${jobId}`
     );
-    return {
-      id: data.id || jobId,
-      name: data.name,
-      status: data.status,
-      progress: data.progress || 0,
-      phase: data.phase,
-      task: data.task,
-      current_trial: data.current_trial,
-      total_trials: data.total_trials,
-      best_accuracy: data.best_accuracy,
-      eta_ms: data.eta_ms || data.estimated_time_remaining_ms,
-      error: data.error,
-      started_at: new Date(data.started_at),
-      completed_at: data.completed_at ? new Date(data.completed_at) : void 0,
-      model_id: data.model_id
-    };
+    return this.mapTrainingJob(data);
   }
   /**
    * List training jobs
@@ -505,45 +475,36 @@ var AutoMLClient = class {
     if (options.status) params.append("status", options.status);
     if (options.page) params.append("page", options.page.toString());
     if (options.page_size) params.append("page_size", options.page_size.toString());
+    const qs = params.toString();
     const { data } = await this.synapCores._getHttpClient().get(
-      `/ai/train/jobs?${params.toString()}`
+      `/automl/jobs${qs ? `?${qs}` : ""}`
     );
-    return (data.jobs || data).map((job) => ({
-      id: job.id,
-      name: job.name,
-      status: job.status,
-      progress: job.progress || 0,
-      phase: job.phase,
-      task: job.task,
-      current_trial: job.current_trial,
-      total_trials: job.total_trials,
-      best_accuracy: job.best_accuracy,
-      eta_ms: job.eta_ms || job.estimated_time_remaining_ms,
-      error: job.error,
-      started_at: new Date(job.started_at),
-      completed_at: job.completed_at ? new Date(job.completed_at) : void 0,
-      model_id: job.model_id
-    }));
+    return (data.jobs ?? data ?? []).map((job) => this.mapTrainingJob(job));
   }
   /**
-   * Cancel a training job
+   * Cancel/stop a training job
    */
   async cancelTrainingJob(jobId) {
-    await this.synapCores._getHttpClient().post(`/ai/train/jobs/${jobId}/cancel`);
+    await this.synapCores._getHttpClient().post(`/automl/jobs/${jobId}/stop`);
   }
   /**
-   * Get training metrics for a job
+   * Get training metrics for a job.
+   *
+   * v1.5.0-ce: gateway no longer has a dedicated /metrics route — metrics
+   * (when available) ship inside the /automl/jobs/:id payload as
+   * `metrics` or `trial_metrics`. We just unwrap that field here.
    */
   async getTrainingMetrics(jobId) {
     const { data } = await this.synapCores._getHttpClient().get(
-      `/ai/train/jobs/${jobId}/metrics`
+      `/automl/jobs/${jobId}`
     );
-    return (data.metrics || data).map((metric) => ({
+    const metrics = data.metrics ?? data.trial_metrics ?? [];
+    return metrics.map((metric) => ({
       trial: metric.trial,
       accuracy: metric.accuracy,
       loss: metric.loss,
       metrics: metric.metrics,
-      timestamp: new Date(metric.timestamp)
+      timestamp: new Date(metric.timestamp ?? Date.now())
     }));
   }
   /**
@@ -576,6 +537,24 @@ var AutoMLClient = class {
       await new Promise((resolve) => setTimeout(resolve, pollInterval));
     }
   }
+  mapTrainingJob(data, fallbackMaxTrials) {
+    return {
+      id: data.id ?? data.job_id,
+      name: data.name,
+      status: data.status,
+      progress: data.progress ?? 0,
+      phase: data.phase,
+      task: data.task,
+      current_trial: data.current_trial,
+      total_trials: data.total_trials ?? fallbackMaxTrials,
+      best_accuracy: data.best_accuracy,
+      eta_ms: data.eta_ms ?? data.estimated_time_remaining_ms,
+      error: data.error,
+      started_at: new Date(data.started_at ?? Date.now()),
+      completed_at: data.completed_at ? new Date(data.completed_at) : void 0,
+      model_id: data.model_id
+    };
+  }
 };
 
 // src/nlp.ts
@@ -583,32 +562,67 @@ var NLPClient = class {
   constructor(synapCores) {
     this.synapCores = synapCores;
   }
+  /**
+   * Run multiple NLP tasks in parallel and stitch them into a single
+   * NLPAnalysis (or array of them, matching the input shape).
+   */
   async analyze(options) {
     const isBatch = Array.isArray(options.text);
     const texts = isBatch ? options.text : [options.text];
-    const { data } = await this.synapCores._getHttpClient().post("/ai/analyze", {
-      texts,
-      tasks: options.tasks || ["sentiment", "entities", "keywords"],
-      language: options.language
-    });
-    const results = data.results.map((r) => ({
-      sentiment: r.sentiment ? {
-        label: r.sentiment.label,
-        score: r.sentiment.score,
-        confidence: r.sentiment.confidence
-      } : void 0,
-      entities: r.entities ? r.entities.map((e) => ({
-        text: e.text,
-        type: e.type,
-        start: e.start,
-        end: e.end,
-        score: e.score
-      })) : void 0,
-      summary: r.summary,
-      keywords: r.keywords,
-      language: r.language
-    }));
-    return isBatch ? results : results[0];
+    const tasks = options.tasks || ["sentiment", "entities", "summarize"];
+    const http = this.synapCores._getHttpClient();
+    const wantSentiment = tasks.includes("sentiment");
+    const wantEntities = tasks.includes("entities");
+    const wantSummarize = tasks.includes("summarize") || tasks.includes("summary");
+    const wantKeywords = tasks.includes("keywords");
+    const results = await Promise.all(
+      texts.map(async (text) => {
+        const out = {};
+        const calls = [];
+        if (wantSentiment) {
+          calls.push(
+            http.post("/ai/sentiment", { texts: [text], language: options.language }).then(({ data }) => {
+              const s = (data.sentiments ?? [])[0] ?? data.sentiment ?? data;
+              if (s) {
+                out.sentiment = {
+                  label: s.label,
+                  score: s.score,
+                  confidence: s.confidence
+                };
+              }
+            }).catch(() => void 0)
+          );
+        }
+        if (wantEntities) {
+          calls.push(
+            http.post("/ai/entities", { text, language: options.language }).then(({ data }) => {
+              const arr = data.entities ?? [];
+              out.entities = arr.map((e) => ({
+                text: e.text,
+                type: e.type,
+                start: e.start,
+                end: e.end,
+                score: e.score
+              }));
+            }).catch(() => void 0)
+          );
+        }
+        if (wantSummarize) {
+          calls.push(
+            http.post("/ai/summarize", { text }).then(({ data }) => {
+              out.summary = data.summary;
+            }).catch(() => void 0)
+          );
+        }
+        if (wantKeywords) {
+          out.keywords = void 0;
+        }
+        await Promise.all(calls);
+        return out;
+      })
+    );
+    if (isBatch) return results;
+    return results[0] ?? {};
   }
   async summarize(options) {
     const { data } = await this.synapCores._getHttpClient().post("/ai/summarize", {
@@ -623,7 +637,7 @@ var NLPClient = class {
       text,
       entity_types: entityTypes
     });
-    return data.entities.map((e) => ({
+    return (data.entities ?? []).map((e) => ({
       text: e.text,
       type: e.type,
       start: e.start,
@@ -637,7 +651,7 @@ var NLPClient = class {
     const { data } = await this.synapCores._getHttpClient().post("/ai/sentiment", {
       texts
     });
-    const results = data.sentiments.map((s) => ({
+    const results = (data.sentiments ?? []).map((s) => ({
       label: s.label,
       score: s.score,
       confidence: s.confidence
@@ -654,6 +668,22 @@ var NLPClient = class {
     });
     return isBatch ? data.classifications : data.classifications[0];
   }
+  /**
+   * Question-answering against an optional context window.
+   */
+  async qa(question, context, opts = {}) {
+    const { data } = await this.synapCores._getHttpClient().post("/ai/qa", {
+      question,
+      context,
+      max_answer_tokens: opts.maxAnswerTokens
+    });
+    return {
+      answer: data.answer ?? data.text ?? "",
+      score: data.score ?? data.confidence,
+      start: data.start,
+      end: data.end
+    };
+  }
 };
 
 // src/recipes.ts
@@ -797,11 +827,142 @@ var RecipeClient = class {
     };
   }
   /**
-   * List available recipe categories
+   * List available recipe categories with counts.
+   *
+   * v0.2.0: gateway path is /recipes/categories/counts.
+   * Returns the array of category names; for the {category, count}
+   * payload use `listCategoriesWithCounts`.
    */
   async listCategories() {
-    const { data } = await this.synapCores._getHttpClient().get("/recipes/categories");
-    return data.categories || [];
+    const data = await this.listCategoriesWithCounts();
+    return data.map((c) => c.category);
+  }
+  async listCategoriesWithCounts() {
+    const { data } = await this.synapCores._getHttpClient().get(
+      "/recipes/categories/counts"
+    );
+    const arr = data.categories ?? data ?? [];
+    return arr.map((c) => ({
+      category: c.category ?? c.name ?? c,
+      count: c.count ?? c.recipe_count ?? 0
+    }));
+  }
+  /**
+   * Validate a recipe payload before saving/executing.
+   */
+  async validate(body) {
+    const { data } = await this.synapCores._getHttpClient().post("/recipes/validate", body);
+    return {
+      is_valid: data.is_valid ?? data.valid ?? false,
+      errors: data.errors ?? [],
+      warnings: data.warnings ?? []
+    };
+  }
+  /**
+   * Get execution history for a specific recipe.
+   */
+  async getHistory(id) {
+    const { data } = await this.synapCores._getHttpClient().get(`/recipes/${id}/history`);
+    const arr = data.history ?? data.executions ?? data ?? [];
+    return arr.map((row) => ({
+      id: row.id ?? row.execution_id ?? "",
+      success: row.success ?? row.status === "completed",
+      results: row.results,
+      error: row.error,
+      execution_time_ms: row.execution_time_ms ?? row.took_ms ?? 0,
+      statements_executed: row.statements_executed ?? 0
+    }));
+  }
+  /**
+   * List built-in / shared recipe templates.
+   */
+  async listTemplates() {
+    const { data } = await this.synapCores._getHttpClient().get("/recipes/templates");
+    return (data.templates ?? data ?? []).map((t) => ({
+      id: t.id,
+      name: t.name,
+      description: t.description ?? "",
+      category: t.category ?? "template",
+      tags: t.tags ?? [],
+      created_at: new Date(t.created_at ?? Date.now()),
+      updated_at: new Date(t.updated_at ?? t.created_at ?? Date.now()),
+      author: t.author,
+      execution_count: t.execution_count
+    }));
+  }
+  /**
+   * Get a specific recipe template.
+   */
+  async getTemplate(id) {
+    const { data } = await this.synapCores._getHttpClient().get(`/recipes/templates/${id}`);
+    return {
+      id: data.id,
+      name: data.name,
+      description: data.description ?? "",
+      category: data.category ?? "template",
+      content: data.content ?? "",
+      tags: data.tags ?? [],
+      parameters: data.parameters ?? [],
+      created_at: new Date(data.created_at ?? Date.now()),
+      updated_at: new Date(data.updated_at ?? data.created_at ?? Date.now()),
+      author: data.author,
+      execution_count: data.execution_count,
+      version: data.version
+    };
+  }
+  /**
+   * Execute a recipe template with a parameter set.
+   */
+  async executeTemplate(id, params = {}) {
+    const { data } = await this.synapCores._getHttpClient().post(
+      `/recipes/templates/${id}/execute`,
+      { parameters: params }
+    );
+    return {
+      id: data.id ?? data.execution_id ?? "",
+      success: data.success ?? false,
+      results: data.results,
+      error: data.error,
+      execution_time_ms: data.execution_time_ms ?? data.took_ms ?? 0,
+      statements_executed: data.statements_executed ?? 0
+    };
+  }
+  /**
+   * List all recipe executions across recipes.
+   */
+  async listExecutions(options = {}) {
+    const params = new URLSearchParams();
+    if (options.limit) params.append("limit", options.limit.toString());
+    if (options.status) params.append("status", options.status);
+    const qs = params.toString();
+    const { data } = await this.synapCores._getHttpClient().get(
+      `/recipes/executions${qs ? `?${qs}` : ""}`
+    );
+    const arr = data.executions ?? data ?? [];
+    return arr.map((row) => ({
+      id: row.id ?? row.execution_id ?? "",
+      success: row.success ?? row.status === "completed",
+      results: row.results,
+      error: row.error,
+      execution_time_ms: row.execution_time_ms ?? row.took_ms ?? 0,
+      statements_executed: row.statements_executed ?? 0
+    }));
+  }
+  /**
+   * Get a single execution by ID.
+   */
+  async getExecution(id) {
+    const { data } = await this.synapCores._getHttpClient().get(
+      `/recipes/executions/${id}`
+    );
+    return {
+      id: data.id ?? id,
+      success: data.success ?? data.status === "completed",
+      results: data.results,
+      error: data.error,
+      execution_time_ms: data.execution_time_ms ?? data.took_ms ?? 0,
+      statements_executed: data.statements_executed ?? 0
+    };
   }
 };
 
@@ -811,17 +972,30 @@ var SchemaClient = class {
     this.synapCores = synapCores;
   }
   /**
-   * List all tables in the database
+   * List all databases visible to the current authentication context.
+   */
+  async listDatabases() {
+    const { data } = await this.synapCores._getHttpClient().get("/schema/databases");
+    return (data.databases ?? data ?? []).map((db) => ({
+      name: db.name,
+      table_count: db.table_count,
+      size_bytes: db.size_bytes,
+      is_default: db.is_default
+    }));
+  }
+  /**
+   * List all tables in the current database.
    */
   async listTables(options = {}) {
     const params = new URLSearchParams();
     if (options.includeSystem) {
       params.append("include_system", "true");
     }
+    const qs = params.toString();
     const { data } = await this.synapCores._getHttpClient().get(
-      `/schema/tables?${params.toString()}`
+      `/schema/tables${qs ? `?${qs}` : ""}`
     );
-    return (data.tables || data).map((table) => ({
+    return (data.tables || data || []).map((table) => ({
       name: table.name,
       type: table.type || "table",
       column_count: table.column_count || 0,
@@ -833,24 +1007,33 @@ var SchemaClient = class {
     }));
   }
   /**
-   * Get complete schema for a specific table
+   * Get complete schema for a specific table.
+   *
+   * Combines /schema/tables/:t with /schema/tables/:t/columns and
+   * /schema/tables/:t/indexes side-channels because the table-only payload
+   * does not always include columns and indexes inline.
    */
   async getTable(tableName) {
-    const { data } = await this.synapCores._getHttpClient().get(
-      `/schema/tables/${tableName}`
-    );
+    const [tableRes, colsRes, idxRes] = await Promise.all([
+      this.synapCores._getHttpClient().get(`/schema/tables/${tableName}`),
+      this.synapCores._getHttpClient().get(`/schema/tables/${tableName}/columns`),
+      this.synapCores._getHttpClient().get(`/schema/tables/${tableName}/indexes`)
+    ]);
+    const table = tableRes.data ?? {};
+    const columns = colsRes.data?.columns ?? colsRes.data ?? [];
+    const indexes = idxRes.data?.indexes ?? idxRes.data ?? [];
     return {
       table: {
-        name: data.name,
-        type: data.type || "table",
-        column_count: data.columns?.length || 0,
-        row_count: data.row_count,
-        size_bytes: data.size_bytes,
-        created_at: data.created_at ? new Date(data.created_at) : void 0,
-        updated_at: data.updated_at ? new Date(data.updated_at) : void 0,
-        comment: data.comment
+        name: table.name ?? tableName,
+        type: table.type || "table",
+        column_count: columns.length,
+        row_count: table.row_count,
+        size_bytes: table.size_bytes,
+        created_at: table.created_at ? new Date(table.created_at) : void 0,
+        updated_at: table.updated_at ? new Date(table.updated_at) : void 0,
+        comment: table.comment
       },
-      columns: (data.columns || []).map((col) => ({
+      columns: columns.map((col) => ({
         name: col.name,
         data_type: col.data_type || col.type,
         nullable: col.nullable !== false,
@@ -862,7 +1045,7 @@ var SchemaClient = class {
         comment: col.comment,
         ordinal_position: col.ordinal_position || col.position
       })),
-      indexes: (data.indexes || []).map((idx) => ({
+      indexes: indexes.map((idx) => ({
         name: idx.name,
         table: idx.table || tableName,
         type: idx.type || "btree",
@@ -872,8 +1055,8 @@ var SchemaClient = class {
         size_bytes: idx.size_bytes,
         created_at: idx.created_at ? new Date(idx.created_at) : void 0
       })),
-      constraints: data.constraints || [],
-      relationships: (data.relationships || []).map((rel) => ({
+      constraints: table.constraints || [],
+      relationships: (table.relationships || []).map((rel) => ({
         type: rel.type,
         from_table: rel.from_table || rel.source_table,
         from_column: rel.from_column || rel.source_column,
@@ -884,106 +1067,186 @@ var SchemaClient = class {
     };
   }
   /**
-   * Get columns for a specific table
+   * Get columns for a specific table.
    */
   async getColumns(tableName) {
-    const schema = await this.getTable(tableName);
-    return schema.columns;
+    const { data } = await this.synapCores._getHttpClient().get(
+      `/schema/tables/${tableName}/columns`
+    );
+    const cols = data.columns ?? data ?? [];
+    return cols.map((col) => ({
+      name: col.name,
+      data_type: col.data_type || col.type,
+      nullable: col.nullable !== false,
+      default_value: col.default_value || col.default,
+      is_primary_key: col.is_primary_key || col.primary_key,
+      is_unique: col.is_unique || col.unique,
+      is_indexed: col.is_indexed || col.indexed,
+      foreign_key: col.foreign_key,
+      comment: col.comment,
+      ordinal_position: col.ordinal_position || col.position
+    }));
   }
   /**
-   * Get indexes for a specific table
+   * Get indexes for a specific table.
    */
   async getIndexes(tableName) {
-    const schema = await this.getTable(tableName);
-    return schema.indexes;
-  }
-  /**
-   * Get all relationships in the database
-   */
-  async getRelationships() {
-    const { data } = await this.synapCores._getHttpClient().get("/schema/relationships");
-    return (data.relationships || data).map((rel) => ({
-      type: rel.type,
-      from_table: rel.from_table || rel.source_table,
-      from_column: rel.from_column || rel.source_column,
-      to_table: rel.to_table || rel.target_table,
-      to_column: rel.to_column || rel.target_column,
-      name: rel.name
+    const { data } = await this.synapCores._getHttpClient().get(
+      `/schema/tables/${tableName}/indexes`
+    );
+    const idxs = data.indexes ?? data ?? [];
+    return idxs.map((idx) => ({
+      name: idx.name,
+      table: idx.table || tableName,
+      type: idx.type || "btree",
+      columns: idx.columns || [],
+      is_unique: idx.is_unique || idx.unique || false,
+      is_primary: idx.is_primary || idx.primary || false,
+      size_bytes: idx.size_bytes,
+      created_at: idx.created_at ? new Date(idx.created_at) : void 0
     }));
   }
   /**
-   * Get schema statistics
+   * Preview rows from a table without writing SQL.
+   *
+   * GET /schema/tables/:t/data?limit=&offset=
    */
-  async getStatistics() {
-    const { data } = await this.synapCores._getHttpClient().get("/schema/statistics");
+  async previewTable(tableName, opts = {}) {
+    const params = new URLSearchParams();
+    if (opts.limit !== void 0) params.append("limit", String(opts.limit));
+    if (opts.offset !== void 0) params.append("offset", String(opts.offset));
+    const qs = params.toString();
+    const { data } = await this.synapCores._getHttpClient().get(
+      `/schema/tables/${tableName}/data${qs ? `?${qs}` : ""}`
+    );
     return {
-      table_count: data.table_count || 0,
-      view_count: data.view_count || 0,
-      index_count: data.index_count || 0,
-      relationship_count: data.relationship_count || 0,
-      total_size_bytes: data.total_size_bytes || 0,
-      total_rows: data.total_rows || 0,
-      version: data.version,
-      analyzed_at: data.analyzed_at ? new Date(data.analyzed_at) : void 0
+      columns: data.columns ?? [],
+      rows: data.rows ?? data.data ?? [],
+      total_rows: data.total_rows ?? data.total
     };
   }
-  /**
-   * Validate a schema definition
-   */
-  async validateSchema(schema) {
-    const { data } = await this.synapCores._getHttpClient().post("/schema/validate", {
-      schema
-    });
-    return {
-      is_valid: data.is_valid || data.valid,
-      errors: data.errors || [],
-      warnings: data.warnings || []
-    };
+};
+
+// src/errors.ts
+var SynapCoresError = class _SynapCoresError extends Error {
+  constructor(message, code, details) {
+    super(message);
+    this.name = "SynapCoresError";
+    this.code = code;
+    this.details = details;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _SynapCoresError);
+    }
   }
-  /**
-   * Compare two schemas
-   */
-  async compareSchemas(schema1, schema2) {
-    const { data } = await this.synapCores._getHttpClient().post("/schema/compare", {
-      schema1,
-      schema2
-    });
-    return {
-      differences: data.differences || [],
-      added: data.added || [],
-      removed: data.removed || [],
-      modified: data.modified || []
-    };
+};
+var ConnectionError = class extends SynapCoresError {
+  constructor(message, details) {
+    super(message, "CONNECTION_ERROR", details);
+    this.name = "ConnectionError";
   }
-  /**
-   * Generate SQL DDL for a table
-   */
-  async generateDDL(tableName) {
-    const { data } = await this.synapCores._getHttpClient().get(
-      `/schema/tables/${tableName}/ddl`
-    );
-    return data.ddl || data.sql;
+};
+var AuthenticationError = class extends SynapCoresError {
+  constructor(message, details) {
+    super(message, "AUTH_ERROR", details);
+    this.name = "AuthenticationError";
   }
-  /**
-   * Analyze table and update statistics
-   */
-  async analyzeTable(tableName) {
-    await this.synapCores._getHttpClient().post(`/schema/tables/${tableName}/analyze`);
+};
+var ValidationError = class extends SynapCoresError {
+  constructor(message, details) {
+    super(message, "VALIDATION_ERROR", details);
+    this.name = "ValidationError";
+  }
+};
+var NotFoundError = class extends SynapCoresError {
+  constructor(message, details) {
+    super(message, "NOT_FOUND", details);
+    this.name = "NotFoundError";
+  }
+};
+var ServerError = class extends SynapCoresError {
+  constructor(message, details) {
+    super(message, "SERVER_ERROR", details);
+    this.name = "ServerError";
+  }
+};
+var TimeoutError = class extends SynapCoresError {
+  constructor(message, details) {
+    super(message, "TIMEOUT_ERROR", details);
+    this.name = "TimeoutError";
+  }
+};
+var RateLimitError = class extends SynapCoresError {
+  constructor(message, retryAfter, details) {
+    super(message, "RATE_LIMIT_ERROR", details);
+    this.name = "RateLimitError";
+    this.retryAfter = retryAfter;
+  }
+};
+var SQLError = class extends SynapCoresError {
+  constructor(message, code, severity = "ERROR", position, hint, detail, details) {
+    super(message, code, details);
+    this.name = "SQLError";
+    this.severity = severity;
+    this.position = position;
+    this.hint = hint;
+    this.detail = detail;
+  }
+};
+var VectorError = class extends SynapCoresError {
+  constructor(message, code, vectorDimensions, expectedDimensions, operation, details) {
+    super(message, code, details);
+    this.name = "VectorError";
+    this.vectorDimensions = vectorDimensions;
+    this.expectedDimensions = expectedDimensions;
+    this.operation = operation;
+  }
+};
+var TransactionError = class extends SynapCoresError {
+  constructor(message, code, transactionId, transactionState, details) {
+    super(message, code, details);
+    this.name = "TransactionError";
+    this.transactionId = transactionId;
+    this.transactionState = transactionState;
+  }
+};
+var BatchOperationError = class extends SynapCoresError {
+  constructor(message, code, failedItems, totalProcessed, successfulCount, details) {
+    super(message, code, details);
+    this.name = "BatchOperationError";
+    this.failedItems = failedItems;
+    this.totalProcessed = totalProcessed;
+    this.successfulCount = successfulCount;
   }
 };
 
 // src/import.ts
+var NOT_SUPPORTED_MSG = "not supported in v1.5.0-ce \u2014 use SynapCores.executeQuery with COPY ... or process locally";
 var ImportExportClient = class {
   constructor(synapCores) {
     this.synapCores = synapCores;
   }
   /**
-   * Import data into a table
+   * Import data into a table.
+   *
+   * Routes to /v1/data/import/csv or /v1/data/import/json based on
+   * `options.format`. NDJSON falls under the JSON endpoint.
    */
   async import(options) {
-    const formData = new FormData();
+    const fmt = options.format;
+    if (fmt !== "csv" && fmt !== "json" && fmt !== "ndjson") {
+      throw new ValidationError(
+        `Unsupported import format '${fmt}' \u2014 gateway v1.5.0-ce only accepts csv or json`
+      );
+    }
+    const path = fmt === "csv" ? "/data/import/csv" : "/data/import/json";
+    let FormDataClass;
+    try {
+      FormDataClass = __require("form-data");
+    } catch {
+      FormDataClass = globalThis.FormData;
+    }
+    const formData = new FormDataClass();
     formData.append("table", options.table);
-    formData.append("format", options.format);
     if (options.mode) formData.append("mode", options.mode);
     if (options.column_mapping) {
       formData.append("column_mapping", JSON.stringify(options.column_mapping));
@@ -992,7 +1255,9 @@ var ImportExportClient = class {
       formData.append("skip_header", options.skip_header.toString());
     }
     if (options.delimiter) formData.append("delimiter", options.delimiter);
-    if (options.batch_size) formData.append("batch_size", options.batch_size.toString());
+    if (options.batch_size) {
+      formData.append("batch_size", options.batch_size.toString());
+    }
     if (options.continue_on_error !== void 0) {
       formData.append("continue_on_error", options.continue_on_error.toString());
     }
@@ -1000,228 +1265,88 @@ var ImportExportClient = class {
       formData.append("primary_keys", JSON.stringify(options.primary_keys));
     }
     if (Buffer.isBuffer(options.data)) {
-      formData.append("file", new Blob([options.data]), "data");
+      formData.append("file", options.data, { filename: `data.${fmt}` });
     } else {
-      formData.append("data", options.data);
+      formData.append("file", Buffer.from(String(options.data)), {
+        filename: `data.${fmt}`
+      });
     }
-    const { data } = await this.synapCores._getHttpClient().post("/import", formData, {
-      headers: {
-        "Content-Type": "multipart/form-data"
-      }
+    const headers = {};
+    if (typeof formData.getHeaders === "function") {
+      Object.assign(headers, formData.getHeaders());
+    } else {
+      headers["Content-Type"] = "multipart/form-data";
+    }
+    const { data } = await this.synapCores._getHttpClient().post(path, formData, {
+      headers,
+      maxBodyLength: Infinity,
+      maxContentLength: Infinity
     });
     return {
-      id: data.id || data.job_id,
-      success: data.success,
-      rows_processed: data.rows_processed || 0,
-      rows_imported: data.rows_imported || 0,
-      rows_failed: data.rows_failed || 0,
-      duration_ms: data.duration_ms || data.took_ms || 0,
-      errors: data.errors || [],
-      warnings: data.warnings || []
+      id: data.id ?? data.job_id ?? "",
+      success: data.success ?? true,
+      rows_processed: data.rows_processed ?? 0,
+      rows_imported: data.rows_imported ?? data.rows_processed ?? 0,
+      rows_failed: data.rows_failed ?? 0,
+      duration_ms: data.duration_ms ?? data.took_ms ?? 0,
+      errors: data.errors ?? [],
+      warnings: data.warnings ?? []
     };
   }
-  /**
-   * Export data from a table or query
-   */
-  async export(options) {
-    const { data } = await this.synapCores._getHttpClient().post("/export", {
-      source: options.source,
-      format: options.format,
-      destination: options.destination || "response",
-      columns: options.columns,
-      filter: options.filter,
-      order_by: options.order_by,
-      limit: options.limit,
-      include_header: options.include_header,
-      delimiter: options.delimiter,
-      compress: options.compress
-    });
-    return {
-      id: data.id || data.job_id,
-      success: data.success,
-      rows_exported: data.rows_exported || 0,
-      duration_ms: data.duration_ms || data.took_ms || 0,
-      file_path: data.file_path,
-      data: data.data,
-      size_bytes: data.size_bytes,
-      download_url: data.download_url,
-      expires_at: data.expires_at ? new Date(data.expires_at) : void 0
-    };
+  // ---------------------------------------------------------------------
+  // Removed methods: every export route, every job-tracking route, bulk
+  // import, validate, template — none of those endpoints exist in the
+  // v1.5.0-ce gateway. We keep the shape so old callers get a clear error
+  // instead of a silent 404.
+  // ---------------------------------------------------------------------
+  async export(_options) {
+    throw new ValidationError(`export() ${NOT_SUPPORTED_MSG}`);
   }
-  /**
-   * Get import job status
-   */
-  async getImportStatus(jobId) {
-    const { data } = await this.synapCores._getHttpClient().get(`/import/${jobId}/status`);
-    return {
-      id: data.id || jobId,
-      status: data.status,
-      progress: data.progress || 0,
-      phase: data.phase,
-      rows_processed: data.rows_processed,
-      eta_ms: data.eta_ms || data.estimated_time_remaining_ms,
-      error: data.error,
-      started_at: data.started_at ? new Date(data.started_at) : void 0,
-      completed_at: data.completed_at ? new Date(data.completed_at) : void 0
-    };
+  async getImportStatus(_jobId) {
+    throw new ValidationError(`getImportStatus() ${NOT_SUPPORTED_MSG}`);
   }
-  /**
-   * Get export job status
-   */
-  async getExportStatus(jobId) {
-    const { data } = await this.synapCores._getHttpClient().get(`/export/${jobId}/status`);
-    return {
-      id: data.id || jobId,
-      status: data.status,
-      progress: data.progress || 0,
-      phase: data.phase,
-      rows_exported: data.rows_exported,
-      eta_ms: data.eta_ms || data.estimated_time_remaining_ms,
-      error: data.error,
-      started_at: data.started_at ? new Date(data.started_at) : void 0,
-      completed_at: data.completed_at ? new Date(data.completed_at) : void 0
-    };
+  async getExportStatus(_jobId) {
+    throw new ValidationError(`getExportStatus() ${NOT_SUPPORTED_MSG}`);
   }
-  /**
-   * Cancel an import job
-   */
-  async cancelImport(jobId) {
-    await this.synapCores._getHttpClient().post(`/import/${jobId}/cancel`);
+  async cancelImport(_jobId) {
+    throw new ValidationError(`cancelImport() ${NOT_SUPPORTED_MSG}`);
   }
-  /**
-   * Cancel an export job
-   */
-  async cancelExport(jobId) {
-    await this.synapCores._getHttpClient().post(`/export/${jobId}/cancel`);
+  async cancelExport(_jobId) {
+    throw new ValidationError(`cancelExport() ${NOT_SUPPORTED_MSG}`);
   }
-  /**
-   * Import data from multiple sources in bulk
-   */
-  async bulkImport(options) {
-    const { data } = await this.synapCores._getHttpClient().post("/import/bulk", {
-      jobs: options.jobs,
-      parallel: options.parallel || false,
-      stop_on_error: options.stop_on_error || false
-    });
-    return {
-      id: data.id || data.bulk_id,
-      success: data.success,
-      results: data.results || [],
-      total_rows_imported: data.total_rows_imported || 0,
-      total_duration_ms: data.total_duration_ms || data.took_ms || 0
-    };
+  async bulkImport(_options) {
+    throw new ValidationError(`bulkImport() ${NOT_SUPPORTED_MSG}`);
   }
-  /**
-   * Validate data before import
-   */
-  async validateData(options) {
-    const { data } = await this.synapCores._getHttpClient().post("/import/validate", {
-      table: options.table,
-      data: options.data,
-      mode: options.mode || "strict",
-      check_foreign_keys: options.check_foreign_keys,
-      check_unique: options.check_unique
-    });
-    return {
-      is_valid: data.is_valid || data.valid,
-      errors: data.errors || [],
-      warnings: data.warnings || [],
-      rows_validated: data.rows_validated || options.data.length
-    };
+  async validateData(_options) {
+    throw new ValidationError(`validateData() ${NOT_SUPPORTED_MSG}`);
   }
-  /**
-   * Get import template for a table
-   */
-  async getImportTemplate(tableName, format = "csv") {
-    const { data } = await this.synapCores._getHttpClient().get(
-      `/import/template/${tableName}?format=${format}`
-    );
-    return data.template || data.content || data;
+  async getImportTemplate(_tableName, _format = "csv") {
+    throw new ValidationError(`getImportTemplate() ${NOT_SUPPORTED_MSG}`);
   }
-  /**
-   * List import/export jobs
-   */
-  async listJobs(options = {}) {
-    const params = new URLSearchParams();
-    if (options.type) params.append("type", options.type);
-    if (options.status) params.append("status", options.status);
-    if (options.limit) params.append("limit", options.limit.toString());
-    const { data } = await this.synapCores._getHttpClient().get(
-      `/import/jobs?${params.toString()}`
-    );
-    return (data.jobs || data).map((job) => ({
-      id: job.id,
-      status: job.status,
-      progress: job.progress || 0,
-      phase: job.phase,
-      rows_processed: job.rows_processed,
-      rows_exported: job.rows_exported,
-      eta_ms: job.eta_ms,
-      error: job.error,
-      started_at: job.started_at ? new Date(job.started_at) : void 0,
-      completed_at: job.completed_at ? new Date(job.completed_at) : void 0
-    }));
+  async listJobs(_options = {}) {
+    throw new ValidationError(`listJobs() ${NOT_SUPPORTED_MSG}`);
   }
-  /**
-   * Download exported data
-   */
-  async downloadExport(jobId) {
-    const { data } = await this.synapCores._getHttpClient().get(`/export/${jobId}/download`, {
-      responseType: "arraybuffer"
-    });
-    return Buffer.from(data);
+  async downloadExport(_jobId) {
+    throw new ValidationError(`downloadExport() ${NOT_SUPPORTED_MSG}`);
   }
-  /**
-   * Stream import data (for large files)
-   */
-  async streamImport(options, onProgress) {
-    const result = await this.import(options);
-    const jobId = result.id;
-    if (onProgress) {
-      const pollInterval = setInterval(async () => {
-        try {
-          const status = await this.getImportStatus(jobId);
-          onProgress(status);
-          if (status.status === "completed" || status.status === "failed" || status.status === "cancelled") {
-            clearInterval(pollInterval);
-          }
-        } catch (error) {
-          clearInterval(pollInterval);
-        }
-      }, 1e3);
-    }
-    return result;
+  async streamImport(options, _onProgress) {
+    return this.import(options);
   }
-  /**
-   * Stream export data (for large datasets)
-   */
-  async streamExport(options, onProgress) {
-    const result = await this.export(options);
-    const jobId = result.id;
-    if (onProgress) {
-      const pollInterval = setInterval(async () => {
-        try {
-          const status = await this.getExportStatus(jobId);
-          onProgress(status);
-          if (status.status === "completed" || status.status === "failed" || status.status === "cancelled") {
-            clearInterval(pollInterval);
-          }
-        } catch (error) {
-          clearInterval(pollInterval);
-        }
-      }, 1e3);
-    }
-    return result;
+  async streamExport(_options, _onProgress) {
+    throw new ValidationError(`streamExport() ${NOT_SUPPORTED_MSG}`);
   }
 };
 
 // src/integrations.ts
+var NOT_SUPPORTED = "not supported in v1.5.0-ce \u2014 see SynapCores integrations API";
 var IntegrationClient = class {
   constructor(synapCores) {
     this.synapCores = synapCores;
   }
   /**
-   * Create a new integration
+   * Create a new integration. Gateway v1.5.0-ce keys integrations by
+   * `type` (slug). The body still carries the type so old call sites
+   * remain backwards compatible.
    */
   async create(options) {
     const { data } = await this.synapCores._getHttpClient().post("/integrations", {
@@ -1235,7 +1360,7 @@ var IntegrationClient = class {
     return this.mapIntegration(data);
   }
   /**
-   * List integrations with optional filters
+   * List integrations (optional filters).
    */
   async list(options = {}) {
     const params = new URLSearchParams();
@@ -1247,79 +1372,41 @@ var IntegrationClient = class {
     if (options.tags && options.tags.length > 0) {
       params.append("tags", options.tags.join(","));
     }
+    const qs = params.toString();
     const { data } = await this.synapCores._getHttpClient().get(
-      `/integrations?${params.toString()}`
+      `/integrations${qs ? `?${qs}` : ""}`
     );
-    return (data.integrations || data).map(
+    return (data.integrations || data || []).map(
       (integration) => this.mapIntegration(integration)
     );
   }
   /**
-   * Get a specific integration by ID
+   * Get a specific integration by type-slug.
    */
-  async get(id) {
-    const { data } = await this.synapCores._getHttpClient().get(`/integrations/${id}`);
+  async get(type) {
+    const { data } = await this.synapCores._getHttpClient().get(
+      `/integrations/${type}`
+    );
     return this.mapIntegration(data);
   }
   /**
-   * Update an existing integration
+   * Update an existing integration by type-slug.
    */
-  async update(id, updates) {
+  async update(type, updates) {
     const { data } = await this.synapCores._getHttpClient().put(
-      `/integrations/${id}`,
+      `/integrations/${type}`,
       updates
     );
     return this.mapIntegration(data);
   }
   /**
-   * Delete an integration
-   */
-  async delete(id) {
-    await this.synapCores._getHttpClient().delete(`/integrations/${id}`);
-  }
-  /**
-   * Activate an integration
-   */
-  async activate(id) {
-    const { data } = await this.synapCores._getHttpClient().post(
-      `/integrations/${id}/activate`
-    );
-    return this.mapIntegration(data);
-  }
-  /**
-   * Deactivate an integration
-   */
-  async deactivate(id) {
-    const { data } = await this.synapCores._getHttpClient().post(
-      `/integrations/${id}/deactivate`
-    );
-    return this.mapIntegration(data);
-  }
-  /**
-   * Execute an integration
+   * Delete an integration by type-slug.
    */
-  async execute(options) {
-    const { data } = await this.synapCores._getHttpClient().post(
-      `/integrations/${options.integration}/execute`,
-      {
-        payload: options.payload,
-        config_override: options.config_override,
-        sync: options.sync !== false
-      }
-    );
-    return {
-      id: data.id || data.execution_id,
-      success: data.success,
-      response: data.response,
-      status_code: data.status_code,
-      error: data.error,
-      execution_time_ms: data.execution_time_ms || data.took_ms || 0,
-      retry_count: data.retry_count || 0,
-      executed_at: data.executed_at ? new Date(data.executed_at) : /* @__PURE__ */ new Date()
-    };
+  async delete(type) {
+    await this.synapCores._getHttpClient().delete(`/integrations/${type}`);
   }
   /**
-   * Test an integration without executing
+   * Test an integration connection.
    */
   async test(options) {
     const { data } = await this.synapCores._getHttpClient().post(
@@ -1338,160 +1425,88 @@ var IntegrationClient = class {
     };
   }
   /**
-   * Get integration execution history
+   * List supported integration types and their config schemas.
    */
-  async getExecutionHistory(integrationId, options = {}) {
-    const params = new URLSearchParams();
-    if (options.limit) params.append("limit", options.limit.toString());
-    if (options.offset) params.append("offset", options.offset.toString());
-    const { data } = await this.synapCores._getHttpClient().get(
-      `/integrations/${integrationId}/executions?${params.toString()}`
-    );
-    return (data.executions || data).map((exec) => ({
-      id: exec.id || exec.execution_id,
-      success: exec.success,
-      response: exec.response,
-      status_code: exec.status_code,
-      error: exec.error,
-      execution_time_ms: exec.execution_time_ms || exec.took_ms || 0,
-      retry_count: exec.retry_count || 0,
-      executed_at: exec.executed_at ? new Date(exec.executed_at) : /* @__PURE__ */ new Date()
+  async listTypes() {
+    const { data } = await this.synapCores._getHttpClient().get("/integrations/types");
+    return (data.types ?? data ?? []).map((t) => ({
+      type: t.type ?? t.name,
+      display_name: t.display_name ?? t.label,
+      description: t.description,
+      config_schema: t.config_schema ?? t.schema
     }));
   }
   /**
-   * Get integration statistics
+   * Get the integrations audit trail.
    */
-  async getStats(integrationId) {
+  async audit(options = {}) {
+    const params = new URLSearchParams();
+    if (options.limit) params.append("limit", options.limit.toString());
+    if (options.type) params.append("type", options.type);
+    const qs = params.toString();
     const { data } = await this.synapCores._getHttpClient().get(
-      `/integrations/${integrationId}/stats`
+      `/integrations/audit${qs ? `?${qs}` : ""}`
     );
-    return {
-      integration_id: integrationId,
-      total_executions: data.total_executions || 0,
-      successful_executions: data.successful_executions || 0,
-      failed_executions: data.failed_executions || 0,
-      avg_execution_time_ms: data.avg_execution_time_ms || 0,
-      executions_24h: data.executions_24h || 0,
-      uptime_percentage: data.uptime_percentage || 0,
-      last_success_at: data.last_success_at ? new Date(data.last_success_at) : void 0,
-      last_error_at: data.last_error_at ? new Date(data.last_error_at) : void 0
-    };
+    return (data.entries ?? data.audit ?? data ?? []).map((row) => ({
+      id: row.id,
+      type: row.type ?? row.integration_type,
+      action: row.action ?? row.event,
+      user: row.user ?? row.actor,
+      timestamp: new Date(row.timestamp ?? row.created_at ?? Date.now()),
+      details: row.details ?? row.data
+    }));
   }
-  /**
-   * Create a webhook for an integration
-   */
-  async createWebhook(options) {
-    const { data } = await this.synapCores._getHttpClient().post("/integrations/webhooks", {
-      integration_id: options.integration_id,
-      event: options.event,
-      url: options.url,
-      secret: options.secret,
-      activate: options.activate !== false
-    });
-    return {
-      id: data.id,
-      integration_id: data.integration_id,
-      event: data.event,
-      url: data.url,
-      active: data.active,
-      secret: data.secret,
-      created_at: new Date(data.created_at)
-    };
+  // -------------------------------------------------------------------
+  // Methods removed from v1.5.0-ce (gateway has no matching route).
+  // We keep the names for backwards-compat but throw a clear error.
+  // -------------------------------------------------------------------
+  async activate(_type) {
+    throw new ValidationError(`integrations.activate() ${NOT_SUPPORTED} \u2014 use update() with {activate:true}`);
   }
-  /**
-   * List webhooks for an integration
-   */
-  async listWebhooks(integrationId) {
-    const { data } = await this.synapCores._getHttpClient().get(
-      `/integrations/${integrationId}/webhooks`
-    );
-    return (data.webhooks || data).map((webhook) => ({
-      id: webhook.id,
-      integration_id: webhook.integration_id,
-      event: webhook.event,
-      url: webhook.url,
-      active: webhook.active,
-      secret: webhook.secret,
-      created_at: new Date(webhook.created_at)
-    }));
+  async deactivate(_type) {
+    throw new ValidationError(`integrations.deactivate() ${NOT_SUPPORTED} \u2014 use update() with {activate:false}`);
   }
-  /**
-   * Delete a webhook
-   */
-  async deleteWebhook(webhookId) {
-    await this.synapCores._getHttpClient().delete(`/integrations/webhooks/${webhookId}`);
+  async execute(_options) {
+    throw new ValidationError(`integrations.execute() ${NOT_SUPPORTED}`);
   }
-  /**
-   * Get integration events
-   */
-  async getEvents(integrationId, options = {}) {
-    const params = new URLSearchParams();
-    if (options.limit) params.append("limit", options.limit.toString());
-    if (options.status) params.append("status", options.status);
-    const { data } = await this.synapCores._getHttpClient().get(
-      `/integrations/${integrationId}/events?${params.toString()}`
-    );
-    return (data.events || data).map((event) => ({
-      id: event.id,
-      integration_id: event.integration_id,
-      event: event.event,
-      data: event.data,
-      timestamp: new Date(event.timestamp),
-      status: event.status,
-      error: event.error
-    }));
+  async getExecutionHistory(_type, _options = {}) {
+    throw new ValidationError(`integrations.getExecutionHistory() ${NOT_SUPPORTED}`);
   }
-  /**
-   * Get integration logs
-   */
-  async getLogs(integrationId, options = {}) {
-    const params = new URLSearchParams();
-    if (options.limit) params.append("limit", options.limit.toString());
-    if (options.level) params.append("level", options.level);
-    const { data } = await this.synapCores._getHttpClient().get(
-      `/integrations/${integrationId}/logs?${params.toString()}`
-    );
-    return (data.logs || data).map((log) => ({
-      id: log.id,
-      integration_id: log.integration_id,
-      level: log.level,
-      message: log.message,
-      data: log.data,
-      timestamp: new Date(log.timestamp)
-    }));
+  async getStats(_type) {
+    throw new ValidationError(`integrations.getStats() ${NOT_SUPPORTED}`);
   }
-  /**
-   * Retry a failed execution
-   */
-  async retryExecution(executionId) {
-    const { data } = await this.synapCores._getHttpClient().post(
-      `/integrations/executions/${executionId}/retry`
-    );
-    return {
-      id: data.id || data.execution_id,
-      success: data.success,
-      response: data.response,
-      status_code: data.status_code,
-      error: data.error,
-      execution_time_ms: data.execution_time_ms || data.took_ms || 0,
-      retry_count: data.retry_count || 0,
-      executed_at: data.executed_at ? new Date(data.executed_at) : /* @__PURE__ */ new Date()
-    };
+  async createWebhook(_options) {
+    throw new ValidationError(`integrations.createWebhook() ${NOT_SUPPORTED}`);
+  }
+  async listWebhooks(_type) {
+    throw new ValidationError(`integrations.listWebhooks() ${NOT_SUPPORTED}`);
+  }
+  async deleteWebhook(_webhookId) {
+    throw new ValidationError(`integrations.deleteWebhook() ${NOT_SUPPORTED}`);
+  }
+  async getEvents(_type, _options = {}) {
+    throw new ValidationError(`integrations.getEvents() ${NOT_SUPPORTED}`);
+  }
+  async getLogs(_type, _options = {}) {
+    throw new ValidationError(`integrations.getLogs() ${NOT_SUPPORTED}`);
+  }
+  async retryExecution(_executionId) {
+    throw new ValidationError(`integrations.retryExecution() ${NOT_SUPPORTED}`);
   }
   /**
-   * Map raw integration data to Integration type
+   * Map raw integration data to Integration type.
    */
   mapIntegration(data) {
     return {
-      id: data.id,
-      name: data.name,
+      id: data.id ?? data.type,
+      name: data.name ?? data.type,
       type: data.type,
-      status: data.status,
-      config: data.config,
+      status: data.status ?? (data.active ? "active" : "inactive"),
+      config: data.config ?? {},
       description: data.description,
       tags: data.tags || [],
-      created_at: new Date(data.created_at),
-      updated_at: new Date(data.updated_at),
+      created_at: new Date(data.created_at ?? Date.now()),
+      updated_at: new Date(data.updated_at ?? data.created_at ?? Date.now()),
       last_success_at: data.last_success_at ? new Date(data.last_success_at) : void 0,
       last_error: data.last_error,
       execution_count: data.execution_count
@@ -1624,18 +1639,9 @@ var BackupClient = class {
       completed_at: data.completed_at ? new Date(data.completed_at) : void 0
     };
   }
-  /**
-   * Cancel a backup in progress
-   */
-  async cancelBackup(backupId) {
-    await this.synapCores._getHttpClient().post(`/backups/${backupId}/cancel`);
-  }
-  /**
-   * Cancel a restore in progress
-   */
-  async cancelRestore(restoreId) {
-    await this.synapCores._getHttpClient().post(`/backups/restore/${restoreId}/cancel`);
-  }
+  // cancelBackup() / cancelRestore() removed — gateway v1.5.0-ce has no
+  // /backups/:id/cancel or /backups/restore/:id/cancel routes. Use
+  // delete() to clean up an aborted backup record.
   /**
    * Download a backup file
    */
@@ -1770,155 +1776,972 @@ var BackupClient = class {
     };
   }
   /**
-   * Deactivate a schedule
+   * Deactivate a schedule
+   */
+  async deactivateSchedule(scheduleId) {
+    const { data } = await this.synapCores._getHttpClient().post(
+      `/backups/schedules/${scheduleId}/deactivate`
+    );
+    return {
+      id: data.id,
+      name: data.name,
+      cron: data.cron,
+      backup_options: data.backup_options,
+      active: data.active,
+      last_run_at: data.last_run_at ? new Date(data.last_run_at) : void 0,
+      next_run_at: data.next_run_at ? new Date(data.next_run_at) : void 0,
+      created_at: new Date(data.created_at),
+      tags: data.tags || []
+    };
+  }
+  // getMetrics() removed — gateway v1.5.0-ce has no /backups/metrics route.
+  // Aggregate metrics can be derived client-side from list().
+  /**
+   * Map raw backup data to Backup type
+   */
+  mapBackup(data) {
+    return {
+      id: data.id,
+      name: data.name,
+      description: data.description,
+      type: data.type,
+      status: data.status,
+      size_bytes: data.size_bytes,
+      compressed_size_bytes: data.compressed_size_bytes,
+      table_count: data.table_count,
+      created_at: new Date(data.created_at),
+      completed_at: data.completed_at ? new Date(data.completed_at) : void 0,
+      duration_ms: data.duration_ms || data.took_ms,
+      storage: data.storage,
+      storage_path: data.storage_path,
+      encrypted: data.encrypted || false,
+      tags: data.tags || [],
+      parent_backup_id: data.parent_backup_id,
+      error: data.error
+    };
+  }
+};
+
+// src/graph.ts
+var GraphNodeApi = class {
+  constructor(synapCores) {
+    this.synapCores = synapCores;
+  }
+  async create(label, props = {}) {
+    const { data } = await this.synapCores._getHttpClient().post("/graph/nodes", {
+      label,
+      properties: props
+    });
+    return this.normalize(data);
+  }
+  async get(id) {
+    const { data } = await this.synapCores._getHttpClient().get(`/graph/nodes/${id}`);
+    return this.normalize(data);
+  }
+  async update(id, patch) {
+    const { data } = await this.synapCores._getHttpClient().patch(
+      `/graph/nodes/${id}`,
+      { properties: patch }
+    );
+    return this.normalize(data);
+  }
+  async delete(id) {
+    await this.synapCores._getHttpClient().delete(`/graph/nodes/${id}`);
+  }
+  async neighbors(id, opts = {}) {
+    const params = new URLSearchParams();
+    if (opts.direction) params.append("direction", opts.direction);
+    if (opts.limit !== void 0) params.append("limit", String(opts.limit));
+    if (opts.type) params.append("type", opts.type);
+    const qs = params.toString();
+    const { data } = await this.synapCores._getHttpClient().get(
+      `/graph/nodes/${id}/neighbors${qs ? `?${qs}` : ""}`
+    );
+    return {
+      nodes: (data.nodes ?? []).map((n) => this.normalize(n)),
+      edges: (data.edges ?? []).map((e) => this.normalizeEdge(e))
+    };
+  }
+  normalize(data) {
+    return {
+      id: String(data.id ?? data.node_id ?? ""),
+      label: data.label,
+      labels: data.labels,
+      properties: data.properties ?? data.props ?? {}
+    };
+  }
+  normalizeEdge(data) {
+    return {
+      id: data.id !== void 0 ? String(data.id) : void 0,
+      from: String(data.from ?? data.source ?? ""),
+      to: String(data.to ?? data.target ?? ""),
+      type: data.type ?? data.label ?? "",
+      properties: data.properties ?? data.props ?? {}
+    };
+  }
+};
+var GraphEdgeApi = class {
+  constructor(synapCores) {
+    this.synapCores = synapCores;
+  }
+  async create(from, to, type, props = {}) {
+    const { data } = await this.synapCores._getHttpClient().post("/graph/edges", {
+      from,
+      to,
+      type,
+      properties: props
+    });
+    return {
+      id: data.id !== void 0 ? String(data.id) : void 0,
+      from: String(data.from ?? from),
+      to: String(data.to ?? to),
+      type: data.type ?? type,
+      properties: data.properties ?? props
+    };
+  }
+};
+var GraphIndexesApi = class {
+  constructor(synapCores) {
+    this.synapCores = synapCores;
+  }
+  /**
+   * Create a graph index (label/property index, fulltext, or vector
+   * depending on the gateway's accepted DDL strings).
+   */
+  async create(stmt) {
+    const { data } = await this.synapCores._getHttpClient().post("/graph/indexes", {
+      statement: stmt
+    });
+    return { name: data.name ?? data.index_name, raw: data };
+  }
+};
+var GraphAlgorithmsApi = class {
+  constructor(synapCores) {
+    this.synapCores = synapCores;
+  }
+  async run(name, opts = {}) {
+    const { data } = await this.synapCores._getHttpClient().post("/graph/algorithms", {
+      algorithm: name,
+      ...opts
+    });
+    return {
+      algorithm: name,
+      results: data.results ?? data.result ?? data,
+      stats: data.stats,
+      execution_time_ms: data.execution_time_ms ?? data.took_ms
+    };
+  }
+};
+var GraphsApi = class {
+  constructor(synapCores) {
+    this.synapCores = synapCores;
+  }
+  async list() {
+    const { data } = await this.synapCores._getHttpClient().get("/graphs");
+    return (data.graphs ?? data ?? []).map((g) => this.normalize(g));
+  }
+  async create(name, opts = {}) {
+    const { data } = await this.synapCores._getHttpClient().post("/graphs", {
+      name,
+      description: opts.description
+    });
+    return this.normalize(data);
+  }
+  async get(name) {
+    const { data } = await this.synapCores._getHttpClient().get(`/graphs/${name}`);
+    return this.normalize(data);
+  }
+  async delete(name) {
+    await this.synapCores._getHttpClient().delete(`/graphs/${name}`);
+  }
+  normalize(data) {
+    return {
+      name: data.name,
+      node_count: data.node_count ?? data.nodes,
+      edge_count: data.edge_count ?? data.edges,
+      created_at: data.created_at ? new Date(data.created_at) : void 0,
+      description: data.description
+    };
+  }
+};
+var GraphClient = class {
+  constructor(synapCores) {
+    this.synapCores = synapCores;
+    this.nodes = new GraphNodeApi(synapCores);
+    this.edges = new GraphEdgeApi(synapCores);
+    this.indexes = new GraphIndexesApi(synapCores);
+    this.algorithms = new GraphAlgorithmsApi(synapCores);
+    this.graphs = new GraphsApi(synapCores);
+  }
+  /**
+   * Run a Cypher / MATCH query.
+   *
+   * The gateway's MatchRequest expects `sql: String` (see
+   * crates/aidb-gateway/src/routes/graph.rs MatchRequest); we keep the
+   * SDK-facing parameter named `query` because every caller writes
+   * Cypher, not SQL — the gateway's field name is a historical artifact.
+   */
+  async cypher(query, params = {}, graph) {
+    const { data } = await this.synapCores._getHttpClient().post("/graph/match", {
+      sql: query,
+      params,
+      graph
+    });
+    return this.normalizeCypher(data);
+  }
+  /**
+   * Profile a Cypher / MATCH query (returns plan/profile metadata).
+   */
+  async cypherProfile(query, params = {}, graph) {
+    const { data } = await this.synapCores._getHttpClient().post("/graph/match/profile", {
+      sql: query,
+      params,
+      graph
+    });
+    return {
+      ...this.normalizeCypher(data),
+      plan: data.plan,
+      profile: data.profile ?? data.profile_data
+    };
+  }
+  /**
+   * Run LLM-based extraction over text into the given graph.
+   */
+  async extract(req, graphName) {
+    const body = typeof req === "string" ? { text: req, graph: graphName } : req;
+    const { data } = await this.synapCores._getHttpClient().post("/graph/extract", body);
+    return {
+      nodes: (data.nodes ?? []).map((n) => ({
+        id: String(n.id ?? ""),
+        label: n.label,
+        labels: n.labels,
+        properties: n.properties ?? n.props ?? {}
+      })),
+      edges: (data.edges ?? []).map((e) => ({
+        id: e.id !== void 0 ? String(e.id) : void 0,
+        from: String(e.from ?? e.source ?? ""),
+        to: String(e.to ?? e.target ?? ""),
+        type: e.type ?? e.label ?? "",
+        properties: e.properties ?? e.props ?? {}
+      })),
+      spans: data.spans
+    };
+  }
+  normalizeCypher(data) {
+    return {
+      columns: data.columns ?? data.fields,
+      rows: data.rows ?? data.values ?? [],
+      records: data.records ?? data.results,
+      stats: data.stats,
+      execution_time_ms: data.execution_time_ms ?? data.took_ms
+    };
+  }
+};
+
+// src/nl2sql.ts
+var NL2SqlClient = class {
+  constructor(synapCores) {
+    this.synapCores = synapCores;
+  }
+  /**
+   * Ask a question in natural language. The gateway returns the
+   * generated SQL and optionally the executed result set when
+   * `execute=true`.
+   */
+  async ask(question, opts = {}) {
+    const { data } = await this.synapCores._getHttpClient().post("/nl2sql/query", {
+      question,
+      ...opts
+    });
+    return {
+      sql: data.sql ?? data.generated_sql ?? "",
+      confidence: data.confidence,
+      rows: data.rows ?? data.data,
+      columns: data.columns,
+      execution_time_ms: data.execution_time_ms ?? data.took_ms,
+      trace: data.trace ?? data.plan,
+      question
+    };
+  }
+  /**
+   * Push schema context the model should use for subsequent ask() calls.
+   */
+  async updateSchemaContext(payload) {
+    const { data } = await this.synapCores._getHttpClient().post(
+      "/nl2sql/schema/context",
+      payload
+    );
+    return { accepted: data.accepted ?? data.success ?? true, raw: data };
+  }
+  /**
+   * Retrieve recent NL2SQL history for the current authenticated user.
+   */
+  async history(opts = {}) {
+    const params = new URLSearchParams();
+    if (opts.limit) params.append("limit", String(opts.limit));
+    if (opts.session_id) params.append("session_id", opts.session_id);
+    const qs = params.toString();
+    const { data } = await this.synapCores._getHttpClient().get(
+      `/nl2sql/history${qs ? `?${qs}` : ""}`
+    );
+    return (data.history ?? data.entries ?? data ?? []).map((row) => ({
+      id: String(row.id ?? row.entry_id ?? ""),
+      question: row.question ?? row.prompt ?? "",
+      sql: row.sql ?? row.generated_sql ?? "",
+      created_at: new Date(row.created_at ?? row.timestamp ?? Date.now()),
+      executed: row.executed,
+      success: row.success
+    }));
+  }
+  /**
+   * Validate a SQL string against the current schema and policies.
+   */
+  async validate(sql) {
+    const { data } = await this.synapCores._getHttpClient().post("/nl2sql/validate", {
+      sql
+    });
+    return {
+      is_valid: data.is_valid ?? data.valid ?? false,
+      errors: data.errors ?? [],
+      warnings: data.warnings ?? [],
+      rewritten_sql: data.rewritten_sql ?? data.sql
+    };
+  }
+};
+
+// src/filesystem.ts
+import WebSocket2 from "ws";
+var FsCollectionsApi = class {
+  constructor(synapCores) {
+    this.synapCores = synapCores;
+  }
+  async create(opts) {
+    const { data } = await this.synapCores._getHttpClient().post(
+      "/filesystem-collections",
+      opts
+    );
+    return this.normalize(data);
+  }
+  async list() {
+    const { data } = await this.synapCores._getHttpClient().get("/filesystem-collections");
+    return (data.collections ?? data ?? []).map((c) => this.normalize(c));
+  }
+  async get(id) {
+    const { data } = await this.synapCores._getHttpClient().get(
+      `/filesystem-collections/${id}`
+    );
+    return this.normalize(data);
+  }
+  async patch(id, p) {
+    const { data } = await this.synapCores._getHttpClient().patch(
+      `/filesystem-collections/${id}`,
+      p
+    );
+    return this.normalize(data);
+  }
+  async delete(id) {
+    await this.synapCores._getHttpClient().delete(`/filesystem-collections/${id}`);
+  }
+  async documents(id, opts = {}) {
+    const params = new URLSearchParams();
+    if (opts.page) params.append("page", String(opts.page));
+    if (opts.page_size) params.append("page_size", String(opts.page_size));
+    const qs = params.toString();
+    const { data } = await this.synapCores._getHttpClient().get(
+      `/filesystem-collections/${id}/documents${qs ? `?${qs}` : ""}`
+    );
+    return (data.documents ?? data ?? []).map((d) => ({
+      id: String(d.id ?? d.document_id ?? ""),
+      collection_id: d.collection_id !== void 0 ? String(d.collection_id) : id,
+      filename: d.filename ?? d.name,
+      path: d.path,
+      status: d.status,
+      size_bytes: d.size_bytes,
+      created_at: d.created_at ? new Date(d.created_at) : void 0,
+      updated_at: d.updated_at ? new Date(d.updated_at) : void 0
+    }));
+  }
+  async reprocess(id, fileId) {
+    const body = fileId ? { document_id: fileId } : {};
+    const { data } = await this.synapCores._getHttpClient().post(
+      `/filesystem-collections/${id}/reprocess`,
+      body
+    );
+    return { accepted: data.accepted ?? data.success ?? true, raw: data };
+  }
+  /**
+   * Stream progress events for an in-flight ingestion. Each tick maps to
+   * a JSON payload broadcast by the gateway over the WS channel. The
+   * iterator ends when the server closes the socket or the consumer
+   * breaks out of the for-await loop.
+   */
+  async *subscribeProgress(id, opts = {}) {
+    const { token } = await this.synapCores.createWsTicket();
+    const wsBase = this.synapCores._getWsBaseUrl();
+    const url = `${wsBase}/ws/filesystem-collections/${id}/progress?token=${encodeURIComponent(token)}`;
+    const ws = new WebSocket2(url);
+    const queue = [];
+    let resolver = null;
+    const push = (p) => {
+      if (resolver) {
+        const r = resolver;
+        resolver = null;
+        r(p);
+      } else {
+        queue.push(p);
+      }
+    };
+    ws.on("message", (raw) => {
+      try {
+        const obj = JSON.parse(raw.toString());
+        push({
+          kind: "value",
+          value: {
+            type: obj.type ?? obj.event ?? "progress",
+            collection_id: obj.collection_id !== void 0 ? String(obj.collection_id) : id,
+            document_id: obj.document_id !== void 0 ? String(obj.document_id) : void 0,
+            filename: obj.filename ?? obj.path,
+            status: obj.status,
+            progress: obj.progress,
+            message: obj.message,
+            error: obj.error,
+            timestamp: obj.timestamp ? new Date(obj.timestamp) : void 0,
+            raw: obj
+          }
+        });
+      } catch (e) {
+        push({ kind: "error", error: e });
+      }
+    });
+    ws.on("error", (err) => push({ kind: "error", error: err }));
+    ws.on("close", () => push({ kind: "done" }));
+    const onAbort = () => {
+      try {
+        ws.close();
+      } catch {
+      }
+    };
+    if (opts.signal) {
+      if (opts.signal.aborted) onAbort();
+      else opts.signal.addEventListener("abort", onAbort);
+    }
+    try {
+      while (true) {
+        const next = await new Promise((resolve) => {
+          if (queue.length > 0) {
+            resolve(queue.shift());
+          } else {
+            resolver = resolve;
+          }
+        });
+        if (next.kind === "value") yield next.value;
+        else if (next.kind === "error") throw next.error;
+        else return;
+      }
+    } finally {
+      try {
+        ws.close();
+      } catch {
+      }
+      if (opts.signal) opts.signal.removeEventListener("abort", onAbort);
+    }
+  }
+  normalize(data) {
+    return {
+      id: String(data.id ?? data.collection_id ?? ""),
+      name: data.name,
+      description: data.description,
+      path: data.path,
+      status: data.status,
+      document_count: data.document_count ?? data.documents,
+      created_at: data.created_at ? new Date(data.created_at) : void 0,
+      updated_at: data.updated_at ? new Date(data.updated_at) : void 0,
+      config: data.config
+    };
+  }
+};
+var FilesystemCollectionsClient = class {
+  constructor(synapCores) {
+    this.collections = new FsCollectionsApi(synapCores);
+  }
+};
+
+// src/chat.ts
+var ChatSessionsApi = class {
+  constructor(synapCores) {
+    this.synapCores = synapCores;
+  }
+  async create(opts = {}) {
+    const { data } = await this.synapCores._getHttpClient().post("/ai/sessions", opts);
+    return this.normalize(data);
+  }
+  async list(opts = {}) {
+    const params = new URLSearchParams();
+    if (opts.limit) params.append("limit", String(opts.limit));
+    if (opts.offset) params.append("offset", String(opts.offset));
+    const qs = params.toString();
+    const { data } = await this.synapCores._getHttpClient().get(
+      `/ai/sessions${qs ? `?${qs}` : ""}`
+    );
+    return (data.sessions ?? data ?? []).map((s) => this.normalize(s));
+  }
+  async get(id) {
+    const { data } = await this.synapCores._getHttpClient().get(`/ai/sessions/${id}`);
+    return this.normalize(data);
+  }
+  async delete(id) {
+    await this.synapCores._getHttpClient().delete(`/ai/sessions/${id}`);
+  }
+  async messages(id, opts = {}) {
+    const params = new URLSearchParams();
+    if (opts.limit) params.append("limit", String(opts.limit));
+    if (opts.offset) params.append("offset", String(opts.offset));
+    const qs = params.toString();
+    const { data } = await this.synapCores._getHttpClient().get(
+      `/ai/sessions/${id}/messages${qs ? `?${qs}` : ""}`
+    );
+    return (data.messages ?? data ?? []).map((m) => this.normalizeMessage(m, id));
+  }
+  normalize(data) {
+    return {
+      id: String(data.id ?? data.session_id ?? ""),
+      title: data.title,
+      model: data.model,
+      system_prompt: data.system_prompt,
+      created_at: new Date(data.created_at ?? Date.now()),
+      updated_at: data.updated_at ? new Date(data.updated_at) : void 0,
+      message_count: data.message_count ?? data.messages,
+      metadata: data.metadata
+    };
+  }
+  normalizeMessage(m, sessionId) {
+    return {
+      id: String(m.id ?? m.message_id ?? ""),
+      session_id: m.session_id !== void 0 ? String(m.session_id) : sessionId,
+      role: m.role,
+      content: m.content ?? m.text ?? "",
+      created_at: new Date(m.created_at ?? Date.now()),
+      metadata: m.metadata
+    };
+  }
+};
+var ChatToolsApi = class {
+  constructor(synapCores) {
+    this.synapCores = synapCores;
+  }
+  async list() {
+    const { data } = await this.synapCores._getHttpClient().get("/ai/tools");
+    return (data.tools ?? data ?? []).map((t) => ({
+      name: t.name,
+      description: t.description,
+      parameters: t.parameters ?? t.schema
+    }));
+  }
+  async execute(name, args = {}) {
+    const { data } = await this.synapCores._getHttpClient().post("/ai/tools/execute", {
+      tool: name,
+      arguments: args
+    });
+    return data;
+  }
+  async sql(sql, params = []) {
+    const { data } = await this.synapCores._getHttpClient().post("/ai/tools/sql", {
+      sql,
+      parameters: params
+    });
+    return data;
+  }
+};
+var ChatCacheApi = class {
+  constructor(synapCores) {
+    this.synapCores = synapCores;
+  }
+  async stats() {
+    const { data } = await this.synapCores._getHttpClient().get("/ai/cache/stats");
+    return {
+      size_bytes: data.size_bytes ?? data.bytes,
+      hit_count: data.hit_count ?? data.hits,
+      miss_count: data.miss_count ?? data.misses,
+      entries: data.entries ?? data.count,
+      raw: data
+    };
+  }
+  async clear() {
+    await this.synapCores._getHttpClient().post("/ai/cache/clear", {});
+  }
+};
+var ChatClient = class {
+  constructor(synapCores) {
+    this.synapCores = synapCores;
+    this.sessions = new ChatSessionsApi(synapCores);
+    this.tools = new ChatToolsApi(synapCores);
+    this.cache = new ChatCacheApi(synapCores);
+  }
+  /**
+   * Send a one-shot chat message. The gateway accepts both /ai/chat and
+   * the alias /ai/ — we use /ai/chat for clarity.
+   */
+  async send(sessionId, content, opts = {}) {
+    const { data } = await this.synapCores._getHttpClient().post("/ai/chat", {
+      session_id: sessionId,
+      content,
+      ...opts
+    });
+    const messageData = data.message ?? data;
+    return {
+      message: {
+        id: String(messageData.id ?? messageData.message_id ?? ""),
+        session_id: sessionId,
+        role: messageData.role ?? "assistant",
+        content: messageData.content ?? messageData.text ?? "",
+        created_at: new Date(messageData.created_at ?? Date.now()),
+        metadata: messageData.metadata
+      },
+      tool_calls: data.tool_calls,
+      usage: data.usage
+    };
+  }
+  /**
+   * Stream a chat completion. Returns an async iterator over SSE chunks.
+   */
+  async *stream(sessionId, content, opts = {}) {
+    const http = this.synapCores._getHttpClient();
+    const response = await http.post(
+      "/ai/chat/stream",
+      {
+        session_id: sessionId,
+        content,
+        ...opts
+      },
+      { responseType: "stream" }
+    );
+    const stream = response.data;
+    let buffer = "";
+    for await (const chunk of stream) {
+      buffer += chunk.toString();
+      const frames = buffer.split(/\n\n/);
+      buffer = frames.pop() ?? "";
+      for (const frame of frames) {
+        const trimmed = frame.trim();
+        if (!trimmed) continue;
+        const line = trimmed.startsWith("data:") ? trimmed.slice(5).trim() : trimmed;
+        if (line === "[DONE]") {
+          yield { done: true };
+          return;
+        }
+        try {
+          const obj = JSON.parse(line);
+          yield {
+            delta: obj.delta ?? obj.choices?.[0]?.delta?.content ?? obj.text ?? void 0,
+            content: obj.content ?? obj.message?.content,
+            type: obj.type ?? obj.event,
+            done: obj.done ?? obj.finished,
+            raw: obj
+          };
+        } catch {
+          yield { delta: line, raw: line };
+        }
+      }
+    }
+    if (buffer.trim()) {
+      try {
+        yield { raw: JSON.parse(buffer) };
+      } catch {
+        yield { delta: buffer };
+      }
+    }
+  }
+  /**
+   * Get prompt suggestions, e.g. for an empty session UI.
+   */
+  async suggestions(opts = {}) {
+    const { data } = await this.synapCores._getHttpClient().post("/ai/suggestions", opts);
+    return (data.suggestions ?? data ?? []).map((s) => ({
+      prompt: s.prompt ?? s.text ?? "",
+      category: s.category,
+      meta: s.meta ?? s.metadata
+    }));
+  }
+  /**
+   * List configured chat models.
    */
-  async deactivateSchedule(scheduleId) {
-    const { data } = await this.synapCores._getHttpClient().post(
-      `/backups/schedules/${scheduleId}/deactivate`
-    );
-    return {
-      id: data.id,
-      name: data.name,
-      cron: data.cron,
-      backup_options: data.backup_options,
-      active: data.active,
-      last_run_at: data.last_run_at ? new Date(data.last_run_at) : void 0,
-      next_run_at: data.next_run_at ? new Date(data.next_run_at) : void 0,
-      created_at: new Date(data.created_at),
-      tags: data.tags || []
-    };
+  async models() {
+    const { data } = await this.synapCores._getHttpClient().get("/ai/models");
+    return (data.models ?? data ?? []).map((m) => ({
+      id: m.id ?? m.name,
+      name: m.name,
+      provider: m.provider,
+      context_window: m.context_window ?? m.max_context,
+      capabilities: m.capabilities
+    }));
   }
   /**
-   * Get backup metrics
+   * List the available system prompts library.
    */
-  async getMetrics() {
-    const { data } = await this.synapCores._getHttpClient().get("/backups/metrics");
+  async systemPrompts() {
+    const { data } = await this.synapCores._getHttpClient().get("/ai/system-prompts");
+    return (data.prompts ?? data.system_prompts ?? data ?? []).map((p) => ({
+      id: String(p.id ?? p.name ?? ""),
+      name: p.name,
+      content: p.content ?? p.text ?? "",
+      description: p.description,
+      category: p.category
+    }));
+  }
+};
+
+// src/multimodal.ts
+var MultimodalClient = class {
+  constructor(synapCores) {
+    this.synapCores = synapCores;
+  }
+  async similarity(a, b, opts = {}) {
+    const { data } = await this.synapCores._getHttpClient().post("/multimodal/similarity", {
+      a: typeof a === "string" ? { type: "text", text: a } : a,
+      b: typeof b === "string" ? { type: "text", text: b } : b,
+      ...opts
+    });
     return {
-      total_backups: data.total_backups || 0,
-      total_size_bytes: data.total_size_bytes || 0,
-      successful_backups: data.successful_backups || 0,
-      failed_backups: data.failed_backups || 0,
-      avg_backup_size_bytes: data.avg_backup_size_bytes || 0,
-      avg_duration_ms: data.avg_duration_ms || 0,
-      last_backup_at: data.last_backup_at ? new Date(data.last_backup_at) : void 0,
-      next_scheduled_at: data.next_scheduled_at ? new Date(data.next_scheduled_at) : void 0
+      similarity: data.similarity ?? data.score ?? 0,
+      metric: data.metric ?? opts.metric,
+      raw: data
     };
   }
-  /**
-   * Map raw backup data to Backup type
-   */
-  mapBackup(data) {
+  async search(query, opts = {}) {
+    const { data } = await this.synapCores._getHttpClient().post("/multimodal/search", {
+      query: typeof query === "string" ? { type: "text", text: query } : query,
+      ...opts
+    });
+    return (data.results ?? data.hits ?? data ?? []).map((r) => ({
+      id: String(r.id ?? r.document_id ?? ""),
+      score: r.score ?? r.similarity ?? 0,
+      modality: r.modality,
+      metadata: r.metadata
+    }));
+  }
+  async join(left, right, opts = {}) {
+    const normalize = (side) => Array.isArray(side) ? side.map((s) => typeof s === "string" ? { type: "text", text: s } : s) : side;
+    const { data } = await this.synapCores._getHttpClient().post("/multimodal/join", {
+      left: normalize(left),
+      right: normalize(right),
+      ...opts
+    });
     return {
-      id: data.id,
-      name: data.name,
-      description: data.description,
-      type: data.type,
-      status: data.status,
-      size_bytes: data.size_bytes,
-      compressed_size_bytes: data.compressed_size_bytes,
-      table_count: data.table_count,
-      created_at: new Date(data.created_at),
-      completed_at: data.completed_at ? new Date(data.completed_at) : void 0,
-      duration_ms: data.duration_ms || data.took_ms,
-      storage: data.storage,
-      storage_path: data.storage_path,
-      encrypted: data.encrypted || false,
-      tags: data.tags || [],
-      parent_backup_id: data.parent_backup_id,
-      error: data.error
+      pairs: (data.pairs ?? data.results ?? []).map((p) => ({
+        left: p.left,
+        right: p.right,
+        score: p.score ?? p.similarity ?? 0
+      }))
+    };
+  }
+  async embed(input, model) {
+    const { data } = await this.synapCores._getHttpClient().post("/multimodal/embed", {
+      input: typeof input === "string" ? { type: "text", text: input } : input,
+      model
+    });
+    const embedding = data.embedding ?? data.vector ?? [];
+    return {
+      embedding,
+      modality: data.modality,
+      model: data.model ?? model,
+      dimensions: data.dimensions ?? embedding.length
     };
   }
 };
 
-// src/errors.ts
-var SynapCoresError = class _SynapCoresError extends Error {
-  constructor(message, code, details) {
-    super(message);
-    this.name = "SynapCoresError";
-    this.code = code;
-    this.details = details;
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, _SynapCoresError);
+// src/system.ts
+var VisionApi = class {
+  constructor(synapCores) {
+    this.synapCores = synapCores;
+  }
+  async get() {
+    try {
+      const { data } = await this.synapCores._getHttpClient().get("/system/vision");
+      if (!data || Object.keys(data).length === 0) return null;
+      return data;
+    } catch (e) {
+      if (e?.statusCode === 404 || e?.code === "NOT_FOUND") return null;
+      throw e;
     }
   }
-};
-var ConnectionError = class extends SynapCoresError {
-  constructor(message, details) {
-    super(message, "CONNECTION_ERROR", details);
-    this.name = "ConnectionError";
+  async set(cfg) {
+    const { data } = await this.synapCores._getHttpClient().put("/system/vision", cfg);
+    return data;
   }
-};
-var AuthenticationError = class extends SynapCoresError {
-  constructor(message, details) {
-    super(message, "AUTH_ERROR", details);
-    this.name = "AuthenticationError";
+  async delete() {
+    await this.synapCores._getHttpClient().delete("/system/vision");
   }
-};
-var ValidationError = class extends SynapCoresError {
-  constructor(message, details) {
-    super(message, "VALIDATION_ERROR", details);
-    this.name = "ValidationError";
+  async test(payload = {}) {
+    const { data } = await this.synapCores._getHttpClient().post("/system/vision/test", payload);
+    return {
+      success: data.success ?? false,
+      latency_ms: data.latency_ms,
+      response: data.response,
+      error: data.error
+    };
   }
 };
-var NotFoundError = class extends SynapCoresError {
-  constructor(message, details) {
-    super(message, "NOT_FOUND", details);
-    this.name = "NotFoundError";
+var SystemClient = class {
+  constructor(synapCores) {
+    this.vision = new VisionApi(synapCores);
   }
 };
-var ServerError = class extends SynapCoresError {
-  constructor(message, details) {
-    super(message, "SERVER_ERROR", details);
-    this.name = "ServerError";
+
+// src/transactions.ts
+var Tx = class {
+  constructor(http, id, options) {
+    this.http = http;
+    this.id = id;
+    this.options = options;
+    this.active = true;
   }
-};
-var TimeoutError = class extends SynapCoresError {
-  constructor(message, details) {
-    super(message, "TIMEOUT_ERROR", details);
-    this.name = "TimeoutError";
+  isActive() {
+    return this.active;
   }
-};
-var RateLimitError = class extends SynapCoresError {
-  constructor(message, retryAfter, details) {
-    super(message, "RATE_LIMIT_ERROR", details);
-    this.name = "RateLimitError";
-    this.retryAfter = retryAfter;
+  async execute(sql, params = []) {
+    this.assertActive();
+    const { data } = await this.http.post(`/transactions/${this.id}/execute`, {
+      sql,
+      parameters: params
+    });
+    return {
+      columns: data.columns ?? [],
+      rows: data.rows ?? [],
+      rows_affected: data.rows_affected,
+      execution_time_ms: data.execution_time_ms ?? data.took_ms
+    };
   }
-};
-var SQLError = class extends SynapCoresError {
-  constructor(message, code, severity = "ERROR", position, hint, detail, details) {
-    super(message, code, details);
-    this.name = "SQLError";
-    this.severity = severity;
-    this.position = position;
-    this.hint = hint;
-    this.detail = detail;
+  async commit() {
+    this.assertActive();
+    await this.http.post(`/transactions/${this.id}/commit`, {});
+    this.active = false;
+  }
+  async rollback() {
+    this.assertActive();
+    await this.http.post(`/transactions/${this.id}/rollback`, {});
+    this.active = false;
+  }
+  async savepoint(name) {
+    this.assertActive();
+    await this.http.post(`/transactions/${this.id}/savepoint`, { name });
+  }
+  async rollbackTo(name) {
+    this.assertActive();
+    await this.http.post(`/transactions/${this.id}/savepoint/${name}/rollback`, {});
+  }
+  assertActive() {
+    if (!this.active) {
+      throw new Error(`Transaction ${this.id} has already been committed/rolled back`);
+    }
   }
 };
-var VectorError = class extends SynapCoresError {
-  constructor(message, code, vectorDimensions, expectedDimensions, operation, details) {
-    super(message, code, details);
-    this.name = "VectorError";
-    this.vectorDimensions = vectorDimensions;
-    this.expectedDimensions = expectedDimensions;
-    this.operation = operation;
+var TxHistoryApi = class {
+  constructor(synapCores) {
+    this.synapCores = synapCores;
+  }
+  async list(opts = {}) {
+    const params = new URLSearchParams();
+    if (opts.limit) params.append("limit", String(opts.limit));
+    if (opts.status) params.append("status", opts.status);
+    const qs = params.toString();
+    const { data } = await this.synapCores._getHttpClient().get(
+      `/transactions/history${qs ? `?${qs}` : ""}`
+    );
+    return (data.transactions ?? data.history ?? data ?? []).map((row) => ({
+      id: String(row.id ?? row.transaction_id ?? ""),
+      status: row.status ?? "unknown",
+      started_at: new Date(row.started_at ?? row.created_at ?? Date.now()),
+      completed_at: row.completed_at ? new Date(row.completed_at) : void 0,
+      isolation_level: row.isolation_level,
+      read_only: row.read_only,
+      statement_count: row.statement_count ?? row.statements,
+      metrics: row.metrics
+    }));
+  }
+  async get(id) {
+    const { data } = await this.synapCores._getHttpClient().get(
+      `/transactions/history/${id}`
+    );
+    return {
+      id: String(data.id ?? id),
+      status: data.status ?? "unknown",
+      started_at: new Date(data.started_at ?? data.created_at ?? Date.now()),
+      completed_at: data.completed_at ? new Date(data.completed_at) : void 0,
+      isolation_level: data.isolation_level,
+      read_only: data.read_only,
+      statement_count: data.statement_count ?? data.statements,
+      metrics: data.metrics
+    };
   }
 };
-var TransactionError = class extends SynapCoresError {
-  constructor(message, code, transactionId, transactionState, details) {
-    super(message, code, details);
-    this.name = "TransactionError";
-    this.transactionId = transactionId;
-    this.transactionState = transactionState;
+var TransactionsClient = class {
+  constructor(synapCores) {
+    this.synapCores = synapCores;
+    this.history = new TxHistoryApi(synapCores);
+  }
+  /**
+   * Begin a new server-side transaction.
+   */
+  async begin(opts = {}) {
+    const { data } = await this.synapCores._getHttpClient().post("/transactions", opts);
+    const id = String(data.id ?? data.transaction_id ?? "");
+    if (!id) {
+      throw new Error("begin(): server did not return a transaction id");
+    }
+    return new Tx(this.synapCores._getHttpClient(), id, opts);
   }
 };
-var BatchOperationError = class extends SynapCoresError {
-  constructor(message, code, failedItems, totalProcessed, successfulCount, details) {
-    super(message, code, details);
-    this.name = "BatchOperationError";
-    this.failedItems = failedItems;
-    this.totalProcessed = totalProcessed;
-    this.successfulCount = successfulCount;
+
+// src/mcp.ts
+var mcpRequestCounter = 0;
+function withId(req) {
+  if (req.id !== void 0 && req.id !== null) return req;
+  mcpRequestCounter += 1;
+  return { ...req, id: `mcp-${Date.now()}-${mcpRequestCounter}` };
+}
+var McpClient = class {
+  constructor(synapCores) {
+    this.synapCores = synapCores;
+  }
+  /**
+   * Invoke a single MCP method.
+   */
+  async invoke(req) {
+    const body = withId(req);
+    const { data } = await this.synapCores._getHttpClient().post("/mcp", body);
+    return {
+      id: data.id ?? body.id,
+      result: data.result,
+      error: data.error,
+      raw: data
+    };
+  }
+  /**
+   * Send an array of MCP invocations and resolve to the matching array
+   * of responses (in the order returned by the gateway).
+   */
+  async batch(reqs) {
+    const body = reqs.map(withId);
+    const { data } = await this.synapCores._getHttpClient().post("/mcp/batch", body);
+    const arr = Array.isArray(data) ? data : data.responses ?? data.results ?? [];
+    return arr.map((r) => ({
+      id: r.id,
+      result: r.result,
+      error: r.error,
+      raw: r
+    }));
+  }
+  /**
+   * Discover the server's MCP capabilities and tools.
+   */
+  async info() {
+    const { data } = await this.synapCores._getHttpClient().get("/mcp/info");
+    return {
+      version: data.version ?? data.mcp_version ?? "0",
+      capabilities: data.capabilities,
+      tools: data.tools,
+      meta: data.meta ?? data.metadata
+    };
   }
 };
 
@@ -1957,7 +2780,7 @@ var SynapCores = class {
       timeout: this.config.timeout,
       headers: {
         "Content-Type": "application/json",
-        "User-Agent": "synapcores-nodejs/0.1.0",
+        "User-Agent": "synapcores-nodejs/0.2.0",
         ...authHeader
       },
       ...httpsAgent && { httpsAgent }
@@ -1973,6 +2796,44 @@ var SynapCores = class {
     this.import = new ImportExportClient(this);
     this.integrations = new IntegrationClient(this);
     this.backup = new BackupClient(this);
+    this.graph = new GraphClient(this);
+    this.nl2sql = new NL2SqlClient(this);
+    this.filesystem = new FilesystemCollectionsClient(this);
+    this.chat = new ChatClient(this);
+    this.multimodal = new MultimodalClient(this);
+    this.system = new SystemClient(this);
+    this.transactions = new TransactionsClient(this);
+    this.mcp = new McpClient(this);
+  }
+  /**
+   * Build the WebSocket base URL (ws:// or wss://).
+   */
+  _getWsBaseUrl() {
+    const protocol = this.config.useHttps ? "wss" : "ws";
+    return `${protocol}://${this.config.host}:${this.config.port}`;
+  }
+  /**
+   * Read-only access to the configured host/port for WS-clients.
+   */
+  _getConfig() {
+    return this.config;
+  }
+  /**
+   * Exchange the current credentials (JWT or API key) for a short-lived
+   * WebSocket ticket. Use the returned token as the `?token=` query
+   * param when opening any /ws endpoint.
+   */
+  async createWsTicket() {
+    const { data } = await this.httpClient.post("/ws/ticket", {});
+    const token = data.token ?? data.ticket;
+    const expiresAt = typeof data.expiresAt === "number" ? data.expiresAt : data.expires_at ? Date.parse(data.expires_at) : Date.now() + 6e4;
+    return { token, expiresAt };
+  }
+  /**
+   * Revoke a previously-issued ticket (best-effort).
+   */
+  async revokeWsTicket(token) {
+    await this.httpClient.post("/ws/ticket/revoke", { token });
   }
   handleError(error) {
     if (!error.response) {
@@ -2161,11 +3022,11 @@ var SynapCores = class {
   async embed(text, options = {}) {
     const isBatch = Array.isArray(text);
     const texts = isBatch ? text : [text];
-    const { data } = await this.httpClient.post("/ai/embed", {
-      texts,
-      model: options.model || "default"
-    });
-    return isBatch ? data.embeddings : data.embeddings[0];
+    const path = isBatch ? "/ai/embeddings/batch" : "/ai/embeddings";
+    const body = isBatch ? { texts, model: options.model } : { text: texts[0], model: options.model };
+    const { data } = await this.httpClient.post(path, body);
+    if (isBatch) return data.embeddings ?? data;
+    return data.embedding ?? data.embeddings?.[0] ?? data;
   }
   // Internal method for HTTP client access
   _getHttpClient() {
@@ -2292,8 +3153,16 @@ var SynapCores = class {
    * @returns Promise resolving to table information
    */
   async describeTable(tableName) {
-    const { data } = await this.httpClient.get(`/table/${tableName}/info`);
-    return data;
+    const [tableRes, colsRes, idxRes] = await Promise.all([
+      this.httpClient.get(`/schema/tables/${tableName}`),
+      this.httpClient.get(`/schema/tables/${tableName}/columns`),
+      this.httpClient.get(`/schema/tables/${tableName}/indexes`)
+    ]);
+    return {
+      ...tableRes.data,
+      columns: colsRes.data?.columns ?? colsRes.data ?? [],
+      indexes: idxRes.data?.indexes ?? idxRes.data ?? []
+    };
   }
   /**
    * Lists all tables in the current database
@@ -2426,19 +3295,26 @@ var SynapCores = class {
    * @returns Promise resolving to batch operation result
    */
   async batchInsert(options) {
-    const { data } = await this.httpClient.post("/batch/insert", {
-      table_name: options.tableName,
-      columns: options.columns,
-      rows: options.rows,
-      on_conflict: options.onConflict,
-      batch_size: options.batchSize || 1e3
-    });
-    return {
-      totalProcessed: data.total_processed,
-      successful: data.successful,
-      failed: data.failed,
-      errors: data.errors,
-      tookMs: data.took_ms
+    const cols = options.columns ?? [];
+    const queries = options.rows.map((row) => {
+      const values = Array.isArray(row) ? row : cols.map((c) => row[c]);
+      return {
+        sql: `INSERT INTO ${options.tableName} (${cols.join(", ")}) VALUES (${values.map((_, i) => "$" + (i + 1)).join(", ")})`,
+        parameters: values
+      };
+    });
+    const { data } = await this.httpClient.post("/query/execute/batch", {
+      queries,
+      transactional: false
+    });
+    const results = data.results ?? [];
+    const successful = results.filter((r) => !r.error).length;
+    return {
+      totalProcessed: results.length,
+      successful,
+      failed: results.length - successful,
+      errors: results.filter((r) => r.error).map((r) => r.error),
+      tookMs: data.total_execution_time_ms ?? 0
     };
   }
   /**
@@ -2447,17 +3323,27 @@ var SynapCores = class {
    * @returns Promise resolving to batch operation result
    */
   async batchUpdate(options) {
-    const { data } = await this.httpClient.post("/batch/update", {
-      table_name: options.tableName,
-      updates: options.updates,
-      batch_size: options.batchSize || 1e3
+    const queries = options.updates.map((u) => {
+      const setClause = Object.keys(u.set ?? {}).map((k, i) => `${k} = $${i + 1}`).join(", ");
+      const setVals = Object.values(u.set ?? {});
+      const whereStr = u.where ?? "1=1";
+      return {
+        sql: `UPDATE ${options.tableName} SET ${setClause} WHERE ${whereStr}`,
+        parameters: setVals
+      };
     });
+    const { data } = await this.httpClient.post("/query/execute/batch", {
+      queries,
+      transactional: false
+    });
+    const results = data.results ?? [];
+    const successful = results.filter((r) => !r.error).length;
     return {
-      totalProcessed: data.total_processed,
-      successful: data.successful,
-      failed: data.failed,
-      errors: data.errors,
-      tookMs: data.took_ms
+      totalProcessed: results.length,
+      successful,
+      failed: results.length - successful,
+      errors: results.filter((r) => r.error).map((r) => r.error),
+      tookMs: data.total_execution_time_ms ?? 0
     };
   }
   /**
@@ -2466,17 +3352,22 @@ var SynapCores = class {
    * @returns Promise resolving to batch operation result
    */
   async batchDelete(options) {
-    const { data } = await this.httpClient.post("/batch/delete", {
-      table_name: options.tableName,
-      where_conditions: options.whereConditions,
-      batch_size: options.batchSize || 1e3
+    const queries = (options.whereConditions ?? []).map((cond) => ({
+      sql: `DELETE FROM ${options.tableName} WHERE ${typeof cond === "string" ? cond : JSON.stringify(cond)}`,
+      parameters: []
+    }));
+    const { data } = await this.httpClient.post("/query/execute/batch", {
+      queries,
+      transactional: false
     });
+    const results = data.results ?? [];
+    const successful = results.filter((r) => !r.error).length;
     return {
-      totalProcessed: data.total_processed,
-      successful: data.successful,
-      failed: data.failed,
-      errors: data.errors,
-      tookMs: data.took_ms
+      totalProcessed: results.length,
+      successful,
+      failed: results.length - successful,
+      errors: results.filter((r) => r.error).map((r) => r.error),
+      tookMs: data.total_execution_time_ms ?? 0
     };
   }
   // =================================================================
@@ -2489,15 +3380,15 @@ var SynapCores = class {
    * @returns Promise resolving to prepared statement
    */
   async prepareStatement(sql, options = {}) {
-    const { data } = await this.httpClient.post("/prepare", {
+    const { data } = await this.httpClient.post("/query/prepare", {
       sql,
       name: options.name,
       parameter_types: options.parameterTypes
     });
     const prepared = {
-      id: data.statement_id,
+      id: data.statement_id ?? data.id,
       sql,
-      parameterCount: data.parameter_count
+      parameterCount: data.parameter_count ?? data.parameters_count ?? 0
     };
     if (options.name) {
       this.preparedStatements.set(options.name, prepared);
@@ -2514,7 +3405,7 @@ var SynapCores = class {
     if (this.preparedStatements.has(statementId)) {
       statementId = this.preparedStatements.get(statementId).id;
     }
-    const { data } = await this.httpClient.post("/execute-prepared", {
+    const { data } = await this.httpClient.post("/query/exec", {
       statement_id: statementId,
       parameters: params
     });
@@ -2534,10 +3425,10 @@ var SynapCores = class {
   async deallocatePrepared(statementId) {
     if (this.preparedStatements.has(statementId)) {
       const prepared = this.preparedStatements.get(statementId);
-      await this.httpClient.delete(`/prepare/${prepared.id}`);
+      await this.httpClient.post("/query/close", { statement_id: prepared.id });
       this.preparedStatements.delete(statementId);
     } else {
-      await this.httpClient.delete(`/prepare/${statementId}`);
+      await this.httpClient.post("/query/close", { statement_id: statementId });
     }
   }
   /**
@@ -2628,231 +3519,198 @@ var SynapCores = class {
     if (vector1.length !== vector2.length) {
       throw new VectorError("Vector dimensions must match", "DIMENSION_MISMATCH");
     }
-    const { data } = await this.httpClient.post("/vectors/add", {
-      vector1,
-      vector2
+    const { data } = await this.httpClient.post("/vector-algebra/operation", {
+      op: "add",
+      a: vector1,
+      b: vector2
     });
+    const result = data.result ?? data.vector ?? [];
     return {
-      result: { values: data.result, dimensions: data.result.length },
+      result: { values: result, dimensions: result.length },
       operation: "addition",
       tookMs: data.took_ms
     };
   }
   /**
    * Performs vector subtraction
-   * @param vector1 - First vector (minuend)
-   * @param vector2 - Second vector (subtrahend)
-   * @returns Promise resolving to vector subtraction result
    */
   async vectorSubtract(vector1, vector2) {
     if (vector1.length !== vector2.length) {
       throw new VectorError("Vector dimensions must match", "DIMENSION_MISMATCH");
     }
-    const { data } = await this.httpClient.post("/vectors/subtract", {
-      vector1,
-      vector2
+    const { data } = await this.httpClient.post("/vector-algebra/operation", {
+      op: "subtract",
+      a: vector1,
+      b: vector2
     });
+    const result = data.result ?? data.vector ?? [];
     return {
-      result: { values: data.result, dimensions: data.result.length },
+      result: { values: result, dimensions: result.length },
       operation: "subtraction",
       tookMs: data.took_ms
     };
   }
   /**
    * Performs scalar multiplication on a vector
-   * @param vector - Input vector
-   * @param scalar - Scalar value to multiply by
-   * @returns Promise resolving to scalar multiplication result
    */
   async vectorScalarMultiply(vector, scalar) {
-    const { data } = await this.httpClient.post("/vectors/scalar-multiply", {
-      vector,
+    const { data } = await this.httpClient.post("/vector-algebra/operation", {
+      op: "scalar_multiply",
+      a: vector,
       scalar
     });
+    const result = data.result ?? data.vector ?? [];
     return {
-      result: { values: data.result, dimensions: data.result.length },
+      result: { values: result, dimensions: result.length },
       operation: "scalar_multiplication",
       tookMs: data.took_ms
     };
   }
   /**
    * Calculates the dot product of two vectors
-   * @param vector1 - First vector
-   * @param vector2 - Second vector
-   * @returns Promise resolving to dot product result
    */
   async vectorDotProduct(vector1, vector2) {
     if (vector1.length !== vector2.length) {
       throw new VectorError("Vector dimensions must match", "DIMENSION_MISMATCH");
     }
-    const { data } = await this.httpClient.post("/vectors/dot-product", {
-      vector1,
-      vector2
+    const { data } = await this.httpClient.post("/vector-algebra/operation", {
+      op: "dot_product",
+      a: vector1,
+      b: vector2
     });
-    return {
-      dotProduct: data.dot_product,
-      tookMs: data.took_ms
-    };
+    return { dotProduct: data.scalar ?? data.dot_product ?? 0, tookMs: data.took_ms };
   }
   /**
    * Calculates cosine similarity between two vectors
-   * @param vector1 - First vector
-   * @param vector2 - Second vector
-   * @returns Promise resolving to cosine similarity result
    */
   async cosineSimilarity(vector1, vector2) {
     if (vector1.length !== vector2.length) {
       throw new VectorError("Vector dimensions must match", "DIMENSION_MISMATCH");
     }
-    const { data } = await this.httpClient.post("/vectors/cosine-similarity", {
-      vector1,
-      vector2
+    const { data } = await this.httpClient.post("/vector-algebra/operation", {
+      op: "cosine_similarity",
+      a: vector1,
+      b: vector2
     });
-    return {
-      similarity: data.similarity,
-      function: "cosine",
-      tookMs: data.took_ms
-    };
+    return { similarity: data.scalar ?? data.similarity ?? 0, function: "cosine", tookMs: data.took_ms };
   }
   /**
    * Calculates L2 (Euclidean) distance between two vectors
-   * @param vector1 - First vector
-   * @param vector2 - Second vector
-   * @returns Promise resolving to L2 distance result
    */
   async l2Distance(vector1, vector2) {
     if (vector1.length !== vector2.length) {
       throw new VectorError("Vector dimensions must match", "DIMENSION_MISMATCH");
     }
-    const { data } = await this.httpClient.post("/vectors/l2-distance", {
-      vector1,
-      vector2
+    const { data } = await this.httpClient.post("/vector-algebra/operation", {
+      op: "l2_distance",
+      a: vector1,
+      b: vector2
     });
-    return {
-      distance: data.distance,
-      similarity: data.distance,
-      // Include similarity for compatibility
-      function: "l2",
-      tookMs: data.took_ms
-    };
+    const distance = data.scalar ?? data.distance ?? 0;
+    return { distance, similarity: distance, function: "l2", tookMs: data.took_ms };
   }
   /**
    * Calculates inner product between two vectors
-   * @param vector1 - First vector
-   * @param vector2 - Second vector
-   * @returns Promise resolving to inner product result
    */
   async innerProduct(vector1, vector2) {
     if (vector1.length !== vector2.length) {
       throw new VectorError("Vector dimensions must match", "DIMENSION_MISMATCH");
     }
-    const { data } = await this.httpClient.post("/vectors/inner-product", {
-      vector1,
-      vector2
+    const { data } = await this.httpClient.post("/vector-algebra/operation", {
+      op: "inner_product",
+      a: vector1,
+      b: vector2
     });
-    return {
-      similarity: data.inner_product,
-      function: "inner_product",
-      tookMs: data.took_ms
-    };
+    return { similarity: data.scalar ?? data.inner_product ?? 0, function: "inner_product", tookMs: data.took_ms };
   }
   /**
-   * Performs K-nearest neighbors vector search
-   * @param options - KNN search options
-   * @returns Promise resolving to KNN search results
+   * Performs K-nearest neighbors vector search.
+   * v0.2.0: routes through /vectors/collections/:c/search with mode discriminator.
    */
   async knnSearch(options) {
-    const { data } = await this.httpClient.post("/vectors/knn-search", {
-      query_vector: options.queryVector,
-      k: options.k,
-      table_name: options.tableName,
-      vector_column: options.vectorColumn,
-      metadata_columns: options.metadataColumns,
+    const collection = options.collectionName ?? options.tableName;
+    const { data } = await this.httpClient.post(`/vectors/collections/${collection}/search`, {
+      mode: "knn",
+      vector: options.queryVector,
+      limit: options.k,
       filter: options.filter
     });
-    return data.results.map((result) => ({
-      id: result.id,
-      vector: result.vector,
-      similarity: result.similarity,
-      distance: result.distance,
-      metadata: result.metadata
+    return (data.matches ?? data.results ?? []).map((r) => ({
+      id: r.id,
+      vector: r.vector,
+      similarity: r.similarity,
+      distance: r.distance,
+      metadata: r.metadata
     }));
   }
   /**
-   * Performs range-based vector similarity search
-   * @param options - Range search options
-   * @returns Promise resolving to range search results
+   * Performs range-based vector similarity search.
    */
   async rangeSearch(options) {
-    const { data } = await this.httpClient.post("/vectors/range-search", {
-      query_vector: options.queryVector,
+    const collection = options.collectionName ?? options.tableName;
+    const { data } = await this.httpClient.post(`/vectors/collections/${collection}/search`, {
+      mode: "range",
+      vector: options.queryVector,
       threshold: options.threshold,
-      table_name: options.tableName,
-      vector_column: options.vectorColumn,
-      metadata_columns: options.metadataColumns,
-      filter: options.filter,
-      max_results: options.maxResults
-    });
-    return data.results.map((result) => ({
-      id: result.id,
-      vector: result.vector,
-      similarity: result.similarity,
-      distance: result.distance,
-      metadata: result.metadata
+      max_results: options.maxResults,
+      filter: options.filter
+    });
+    return (data.matches ?? data.results ?? []).map((r) => ({
+      id: r.id,
+      vector: r.vector,
+      similarity: r.similarity,
+      distance: r.distance,
+      metadata: r.metadata
     }));
   }
   /**
-   * Performs hybrid search combining vector similarity and SQL filtering
-   * @param options - Hybrid search options
-   * @returns Promise resolving to hybrid search results
+   * Performs hybrid search combining vector similarity and SQL filtering.
    */
   async hybridSearch(options) {
-    const { data } = await this.httpClient.post("/vectors/hybrid-search", {
+    const collection = options.collectionName ?? options.tableName;
+    const { data } = await this.httpClient.post(`/vectors/collections/${collection}/search`, {
+      mode: "hybrid",
       vector: options.vector,
       text_query: options.textQuery,
       sql_filter: options.sqlFilter,
-      k: options.k,
+      limit: options.k,
       threshold: options.threshold,
       metric: options.metric,
       filter: options.filter,
       weights: options.weights
     });
-    return data.results.map((result) => ({
-      id: result.id,
-      vector: result.vector,
-      similarity: result.similarity,
-      distance: result.distance,
-      metadata: result.metadata
+    return (data.matches ?? data.results ?? []).map((r) => ({
+      id: r.id,
+      vector: r.vector,
+      similarity: r.similarity,
+      distance: r.distance,
+      metadata: r.metadata
     }));
   }
   /**
    * Normalizes a vector to unit length
-   * @param vector - Input vector to normalize
-   * @returns Promise resolving to normalized vector
    */
   async normalizeVector(vector) {
-    const { data } = await this.httpClient.post("/vectors/normalize", {
-      vector
+    const { data } = await this.httpClient.post("/vector-algebra/operation", {
+      op: "normalize",
+      a: vector
     });
+    const result = data.result ?? data.vector ?? [];
     return {
-      result: { values: data.result, dimensions: data.result.length },
+      result: { values: result, dimensions: result.length },
       operation: "normalization",
       tookMs: data.took_ms
     };
   }
   /**
    * Calculates the magnitude (length) of a vector
-   * @param vector - Input vector
-   * @returns Promise resolving to vector magnitude
    */
   async vectorMagnitude(vector) {
-    const { data } = await this.httpClient.post("/vectors/magnitude", {
-      vector
+    const { data } = await this.httpClient.post("/vector-algebra/operation", {
+      op: "magnitude",
+      a: vector
     });
-    return {
-      magnitude: data.magnitude,
-      tookMs: data.took_ms
-    };
+    return { magnitude: data.scalar ?? data.magnitude ?? 0, tookMs: data.took_ms };
   }
   // =================================================================
   // AUTHENTICATION & USER MANAGEMENT
@@ -2884,16 +3742,26 @@ var SynapCores = class {
     return data;
   }
   /**
-   * Refresh JWT token
+   * Refresh JWT token.
+   *
+   * v0.2.0: the gateway does not currently expose a refresh endpoint —
+   * this method now re-runs login() with the same credentials. Pass
+   * the credentials in the call site (or supply them at SDK construction
+   * time and we'll re-use the cached pair).
    */
-  async refreshToken() {
-    const { data } = await this.httpClient.post("/auth/refresh");
-    if (data.access_token) {
-      this.config.jwtToken = data.access_token;
-      this.httpClient.defaults.headers["Authorization"] = `Bearer ${data.access_token}`;
-      delete this.httpClient.defaults.headers["X-API-Key"];
+  async refreshToken(credentials) {
+    if (credentials?.username && credentials?.password) {
+      const login = await this.login({ username: credentials.username, password: credentials.password });
+      return {
+        access_token: login.access_token,
+        refresh_token: "",
+        token_type: "Bearer",
+        expires_in: login.expires_in
+      };
     }
-    return data;
+    throw new ValidationError(
+      "refreshToken now requires credentials \u2014 the gateway has no /auth/refresh endpoint in v1.5.0-ce. Pass {username, password} or call login() again."
+    );
   }
   /**
    * Set JWT token manually (useful after login)
@@ -3024,17 +3892,23 @@ var SynapCores = class {
 
 // src/index.ts
 import { z } from "zod";
-var VERSION = "0.1.0";
+var VERSION = "0.2.0";
 export {
   AuthenticationError,
   AutoMLClient,
   AutoMLModel,
   BackupClient,
   BatchOperationError,
+  ChatClient,
   Collection,
   ConnectionError,
+  FilesystemCollectionsClient,
+  GraphClient,
   ImportExportClient,
   IntegrationClient,
+  McpClient,
+  MultimodalClient,
+  NL2SqlClient,
   NLPClient,
   NotFoundError,
   RateLimitError,
@@ -3045,8 +3919,11 @@ export {
   Subscription,
   SynapCores,
   SynapCoresError,
+  SystemClient,
   TimeoutError,
   TransactionError,
+  TransactionsClient,
+  Tx,
   VERSION,
   ValidationError,
   VectorError,