@ragable/sdk 0.6.20 → 0.6.22

package/dist/index.js

@@ -56,7 +56,10 @@ __export(index_exports, {
   ShiftClient: () => ShiftClient,
   Transport: () => Transport,
   asPostgrestResponse: () => asPostgrestResponse,
+  assertPostgrestSuccess: () => assertPostgrestSuccess,
   bindFetch: () => bindFetch,
+  collectionRecordToRowWithMeta: () => collectionRecordToRowWithMeta,
+  collectionRecordsToRowWithMeta: () => collectionRecordsToRowWithMeta,
   createBrowserClient: () => createBrowserClient,
   createClient: () => createClient,
   createRagPipeline: () => createRagPipeline,
@@ -72,7 +75,9 @@ __export(index_exports, {
   normalizeBrowserApiBase: () => normalizeBrowserApiBase,
   parseSseDataLine: () => parseSseDataLine,
   parseTransportResponse: () => parseTransportResponse,
-  readSseStream: () => readSseStream
+  readSseStream: () => readSseStream,
+  toRagableResult: () => toRagableResult,
+  unwrapPostgrest: () => unwrapPostgrest
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -701,6 +706,17 @@ async function parseTransportResponse(response) {
 }
 
 // src/browser-postgrest.ts
+function toRagableResult(r) {
+  if (r.error) return { ok: false, error: r.error };
+  return { ok: true, value: r.data };
+}
+function assertPostgrestSuccess(r) {
+  if (r.error) throw r.error;
+}
+function unwrapPostgrest(r) {
+  if (r.error) throw r.error;
+  return r.data;
+}
 async function asPostgrestResponse(fn) {
   try {
     const data = await fn();
@@ -2286,24 +2302,71 @@ var RagableBrowserAuthClient = class {
     return this.auth.getSession();
   }
 };
+function collectionRecordToRowWithMeta(record) {
+  const { data, id, createdAt, updatedAt } = record;
+  return { ...data, meta: { id, createdAt, updatedAt } };
+}
+function collectionRecordsToRowWithMeta(records) {
+  return records.map(collectionRecordToRowWithMeta);
+}
+var FIND_QUERY_KEYS = [
+  "where",
+  "filters",
+  "limit",
+  "offset",
+  "orderBy",
+  "orderDirection",
+  "return"
+];
 var BrowserCollectionApi = class {
   constructor(database, name, databaseInstanceId) {
     this.database = database;
     this.name = name;
     this.databaseInstanceId = databaseInstanceId;
-    __publicField(this, "find", (whereOrParams = {}) => {
-      const hasQueryKeys = ["where", "filters", "limit", "offset", "orderBy", "orderDirection"].some(
-        (key) => Object.prototype.hasOwnProperty.call(whereOrParams, key)
-      );
-      const body = hasQueryKeys ? whereOrParams : { where: whereOrParams };
-      return asPostgrestResponse(
-        () => this.database._requestCollection(
-          "POST",
-          `/${encodeURIComponent(this.name)}/find`,
-          body,
-          this.databaseInstanceId
-        )
-      );
+    __publicField(this, "requestFind", (body) => asPostgrestResponse(
+      () => this.database._requestCollection(
+        "POST",
+        `/${encodeURIComponent(this.name)}/find`,
+        body,
+        this.databaseInstanceId
+      )
+    ));
+    /**
+     * Query collection rows. Prefer this over the deprecated `find` alias.
+     * Use `return: "flat"` to get {@link CollectionRowWithMeta} without nested `.data`.
+     */
+    __publicField(this, "findMany", async (whereOrParams = {}) => {
+      const { returnMode, body } = this.normalizeFindArgs(whereOrParams);
+      const res = await this.requestFind(body);
+      if (res.error) return res;
+      if (returnMode === "flat") {
+        return {
+          data: collectionRecordsToRowWithMeta(res.data),
+          error: null
+        };
+      }
+      return res;
+    });
+    /**
+     * @deprecated Use {@link BrowserCollectionApi.findMany} — same behavior.
+     */
+    __publicField(this, "find", (whereOrParams = {}) => this.findMany(whereOrParams));
+    /**
+     * At most one row, `data` is the record or `null` if none match (not an error).
+     */
+    __publicField(this, "findFirst", async (whereOrParams = {}) => {
+      const { body } = this.normalizeFindArgs(whereOrParams);
+      const withCap = { ...body, limit: 1, offset: body["offset"] ?? 0 };
+      const res = await this.requestFind(withCap);
+      if (res.error) return res;
+      return { data: res.data[0] ?? null, error: null };
+    });
+    /**
+     * Lookup by primary key `id` (envelope). Equivalent to
+     * `findFirst({ where: { id }, limit: 1 })` with a typed `where.id`.
+     */
+    __publicField(this, "findUnique", async (args) => {
+      return this.findFirst({ where: args.where });
     });
     __publicField(this, "insert", (data) => asPostgrestResponse(
       () => this.database._requestCollection(
@@ -2313,6 +2376,9 @@ var BrowserCollectionApi = class {
         this.databaseInstanceId
       )
     ));
+    /**
+     * Update rows matching `where` (JSON fields, plus envelope `id` / `createdAt` / `updatedAt`).
+     */
     __publicField(this, "update", (where, patch, options) => asPostgrestResponse(
       () => this.database._requestCollection(
         "PATCH",
@@ -2321,6 +2387,15 @@ var BrowserCollectionApi = class {
         this.databaseInstanceId
       )
     ));
+    /**
+     * Like {@link BrowserCollectionApi.update} but the success payload includes
+     * `meta.count` (number of rows returned from the update, bounded by `limit`).
+     */
+    __publicField(this, "updateMany", async (where, patch, options) => {
+      const r = await this.update(where, patch, options);
+      if (r.error) return r;
+      return { data: { records: r.data, meta: { count: r.data.length } }, error: null };
+    });
     __publicField(this, "delete", (where, options) => asPostgrestResponse(
       () => this.database._requestCollection(
         "DELETE",
@@ -2330,6 +2405,15 @@ var BrowserCollectionApi = class {
       )
     ));
   }
+  normalizeFindArgs(whereOrParams) {
+    const hasQueryKeys = typeof whereOrParams === "object" && whereOrParams !== null && FIND_QUERY_KEYS.some(
+      (key) => Object.prototype.hasOwnProperty.call(whereOrParams, key)
+    );
+    const raw = hasQueryKeys ? { ...whereOrParams } : { where: whereOrParams };
+    const returnMode = raw["return"] === "flat" ? "flat" : "envelope";
+    delete raw["return"];
+    return { returnMode, body: raw };
+  }
 };
 var RagableBrowserDatabaseClient = class {
   constructor(options, ragableAuth = null) {
@@ -2724,6 +2808,31 @@ var RagableBrowserAgentsClient = class {
   toUrl(path) {
     return `${normalizeBrowserApiBase()}${path.startsWith("/") ? path : `/${path}`}`;
   }
+  requireWebsiteId() {
+    const websiteId = this.options.websiteId?.trim();
+    if (!websiteId) {
+      throw new RagableError(
+        "websiteId is required for project agent conversation APIs. Use the generated createWebsiteRagableClient() or pass createBrowserClient({ websiteId, ... }).",
+        400,
+        { code: "SDK_MISSING_WEBSITE_ID" }
+      );
+    }
+    return websiteId;
+  }
+  websiteAgentPath(path) {
+    const websiteId = this.requireWebsiteId();
+    return `/public/organizations/${this.options.organizationId}/websites/${websiteId}${path}`;
+  }
+  async requestJson(path, init = {}) {
+    const response = await this.fetchImpl(this.toUrl(path), init);
+    const payload = await parseMaybeJsonBody(response);
+    if (!response.ok) {
+      const message = extractErrorMessage(payload, response.statusText);
+      throw new RagableError(message, response.status, payload);
+    }
+    return payload;
+  }
+  /** @deprecated Prefer `chatStreamByName(agentName, params)` for project-local `/agents/*.json` agents. */
   async *chatStream(agentId, params) {
     const orgId = this.options.organizationId;
     const body = {
@@ -2753,6 +2862,107 @@ var RagableBrowserAgentsClient = class {
     }
     yield* readSseStream(streamBody);
   }
+  async *chatStreamByName(agentName, params) {
+    const headers = new Headers(this.options.headers);
+    headers.set("Content-Type", "application/json");
+    const response = await this.fetchImpl(
+      this.toUrl(
+        this.websiteAgentPath(
+          `/agents/${encodeURIComponent(agentName)}/chat/stream`
+        )
+      ),
+      {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          message: params.message,
+          ...params.history !== void 0 ? { history: params.history } : {}
+        })
+      }
+    );
+    if (!response.ok) {
+      const payload = await parseMaybeJsonBody(response);
+      const message = extractErrorMessage(payload, response.statusText);
+      throw new RagableError(message, response.status, payload);
+    }
+    if (!response.body) return;
+    yield* readSseStream(response.body);
+  }
+  createConversation(params) {
+    const headers = new Headers(this.options.headers);
+    headers.set("Content-Type", "application/json");
+    return this.requestJson(
+      this.websiteAgentPath("/agent-conversations"),
+      {
+        method: "POST",
+        headers,
+        body: JSON.stringify(params)
+      }
+    );
+  }
+  listConversations(params = {}) {
+    const agentName = params.agent_name ?? params.agentName;
+    const qs = agentName ? `?agentName=${encodeURIComponent(agentName)}` : "";
+    return this.requestJson(
+      this.websiteAgentPath(`/agent-conversations${qs}`)
+    );
+  }
+  getConversation(conversationId) {
+    return this.requestJson(
+      this.websiteAgentPath(
+        `/agent-conversations/${encodeURIComponent(conversationId)}`
+      )
+    );
+  }
+  updateConversation(conversationId, data) {
+    const headers = new Headers(this.options.headers);
+    headers.set("Content-Type", "application/json");
+    return this.requestJson(
+      this.websiteAgentPath(
+        `/agent-conversations/${encodeURIComponent(conversationId)}`
+      ),
+      {
+        method: "PATCH",
+        headers,
+        body: JSON.stringify(data)
+      }
+    );
+  }
+  addMessage(conversationOrId, message) {
+    const conversationId = typeof conversationOrId === "string" ? conversationOrId : conversationOrId.id;
+    const headers = new Headers(this.options.headers);
+    headers.set("Content-Type", "application/json");
+    return this.requestJson(
+      this.websiteAgentPath(
+        `/agent-conversations/${encodeURIComponent(conversationId)}/messages`
+      ),
+      {
+        method: "POST",
+        headers,
+        body: JSON.stringify(message)
+      }
+    );
+  }
+  subscribeToConversation(conversationId, callback, options = {}) {
+    let stopped = false;
+    let timer = null;
+    const intervalMs = Math.max(500, options.intervalMs ?? 1500);
+    const tick = async () => {
+      if (stopped) return;
+      try {
+        callback(await this.getConversation(conversationId));
+      } finally {
+        if (!stopped) timer = setTimeout(tick, intervalMs);
+      }
+    };
+    void tick();
+    return {
+      unsubscribe: () => {
+        stopped = true;
+        if (timer) clearTimeout(timer);
+      }
+    };
+  }
 };
 var RagableBrowser = class {
   constructor(options) {
@@ -2923,7 +3133,10 @@ function createRagableServerClient(options) {
   ShiftClient,
   Transport,
   asPostgrestResponse,
+  assertPostgrestSuccess,
   bindFetch,
+  collectionRecordToRowWithMeta,
+  collectionRecordsToRowWithMeta,
   createBrowserClient,
   createClient,
   createRagPipeline,
@@ -2939,6 +3152,8 @@ function createRagableServerClient(options) {
   normalizeBrowserApiBase,
   parseSseDataLine,
   parseTransportResponse,
-  readSseStream
+  readSseStream,
+  toRagableResult,
+  unwrapPostgrest
 });
 //# sourceMappingURL=index.js.map