@ragable/sdk 0.7.7 → 0.7.9

package/dist/index.js

@@ -47,6 +47,7 @@ __export(index_exports, {
   RagableBrowserAiClient: () => RagableBrowserAiClient,
   RagableBrowserAuthClient: () => RagableBrowserAuthClient,
   RagableBrowserDatabaseClient: () => RagableBrowserDatabaseClient,
+  RagableBrowserMailClient: () => RagableBrowserMailClient,
   RagableBrowserStorageClient: () => RagableBrowserStorageClient,
   RagableError: () => RagableError,
   RagableNetworkError: () => RagableNetworkError,
@@ -58,6 +59,7 @@ __export(index_exports, {
   assertPostgrestSuccess: () => assertPostgrestSuccess,
   bindFetch: () => bindFetch,
   buildInferenceRequestBody: () => buildInferenceRequestBody,
+  buildResponseFormat: () => buildResponseFormat,
   collectAssistantTextFromUiSegments: () => collectAssistantTextFromUiSegments,
   collectionRecordToRowWithMeta: () => collectionRecordToRowWithMeta,
   collectionRecordsToRowWithMeta: () => collectionRecordsToRowWithMeta,
@@ -85,8 +87,11 @@ __export(index_exports, {
   runAgentChatStream: () => runAgentChatStream,
   runAgentChatStreamForUi: () => runAgentChatStreamForUi,
   runAgentChatStreamLenient: () => runAgentChatStreamLenient,
+  streamObjectFromContext: () => streamObjectFromContext,
   toRagableResult: () => toRagableResult,
-  unwrapPostgrest: () => unwrapPostgrest
+  tryParsePartialJson: () => tryParsePartialJson,
+  unwrapPostgrest: () => unwrapPostgrest,
+  wrapStreamTextAsObject: () => wrapStreamTextAsObject
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -2357,6 +2362,72 @@ function decodeJwtExpiry(jwt) {
   }
 }
 
+// src/partial-json.ts
+function tryParsePartialJson(text) {
+  const trimmed = text.trim();
+  if (!trimmed) return void 0;
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+  }
+  const repaired = repairOpenStructures(trimmed);
+  if (!repaired) return void 0;
+  try {
+    return JSON.parse(repaired);
+  } catch {
+    const noTrailingComma = stripTrailingCommas(trimmed);
+    const repaired2 = repairOpenStructures(noTrailingComma);
+    if (!repaired2) return void 0;
+    try {
+      return JSON.parse(repaired2);
+    } catch {
+      return void 0;
+    }
+  }
+}
+function repairOpenStructures(text) {
+  const first = text[0];
+  if (first !== "{" && first !== "[") {
+    return text;
+  }
+  const stack = [];
+  let inString = false;
+  let escaped = false;
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (ch === "\\") {
+      escaped = true;
+      continue;
+    }
+    if (ch === '"') {
+      inString = !inString;
+      continue;
+    }
+    if (inString) continue;
+    if (ch === "{") stack.push("}");
+    else if (ch === "[") stack.push("]");
+    else if (ch === "}" || ch === "]") {
+      if (stack.length === 0) return null;
+      stack.pop();
+    }
+  }
+  let safe = text;
+  if (inString) {
+    safe += '"';
+  }
+  safe = safe.replace(/,\s*$/, "").replace(/:\s*$/, ": null");
+  let suffix = "";
+  for (let i = stack.length - 1; i >= 0; i--) suffix += stack[i];
+  return safe + suffix;
+}
+function stripTrailingCommas(text) {
+  return text.replace(/,(\s*[}\]])/g, "$1").replace(/,\s*$/, "");
+}
+
 // src/stream-parts.ts
 function normalizeFinishReason(raw) {
   switch (raw) {
@@ -2566,7 +2637,7 @@ var ZERO_USAGE = {
   completionTokens: 0,
   totalTokens: 0
 };
-function buildInferenceRequestBody(params) {
+function buildInferenceRequestBody(params, responseFormat) {
   const body = {
     model: params.model,
     messages: params.messages
@@ -2577,8 +2648,18 @@ function buildInferenceRequestBody(params) {
   if (typeof params.maxTokens === "number") body.max_tokens = params.maxTokens;
   if (typeof params.topP === "number") body.top_p = params.topP;
   if (params.reasoningEffort) body.reasoning_effort = params.reasoningEffort;
+  if (responseFormat) body.response_format = responseFormat;
   return body;
 }
+function buildResponseFormat(params) {
+  const json_schema = {
+    name: params.name ?? "Output",
+    schema: params.schema,
+    strict: params.strict ?? true
+  };
+  if (params.description) json_schema.description = params.description;
+  return { type: "json_schema", json_schema };
+}
 async function consumeInferenceStream(body, broadcast, deferreds) {
   const reader = body.getReader();
   const decoder = new TextDecoder();
@@ -2829,6 +2910,190 @@ var RagableBrowserAiClient = class {
     );
     return { text, reasoning, usage, finishReason, toolCalls };
   }
+  /**
+   * Stream a JSON-Schema-constrained response. Matches Vercel AI SDK's
+   * `streamObject` shape — returns a synchronous result with `partialObjectStream`
+   * (best-effort incremental parses) and `object` (the final parsed JSON).
+   *
+   * ```ts
+   * const { partialObjectStream, object } = client.ai.streamObject({
+   *   model: "accounts/fireworks/models/kimi-k2p5",
+   *   schema: {
+   *     type: "object",
+   *     properties: {
+   *       title: { type: "string" },
+   *       tags: { type: "array", items: { type: "string" } },
+   *     },
+   *     required: ["title", "tags"],
+   *   },
+   *   messages: [{ role: "user", content: "Give me a blog post idea about AI." }],
+   * });
+   * for await (const partial of partialObjectStream) renderPreview(partial);
+   * const final = await object;
+   * ```
+   */
+  streamObject(params) {
+    return streamObjectFromContext(this.buildContext(), params);
+  }
+  /**
+   * Non-streaming variant of {@link streamObject}. Resolves once the model
+   * finishes; rejects if the final text isn't valid JSON for the schema.
+   */
+  async generateObject(params) {
+    const result = this.streamObject(params);
+    for await (const _ of result.partialObjectStream) {
+      void _;
+    }
+    const [object, usage, finishReason, toolCalls] = await Promise.all([
+      result.object,
+      result.usage,
+      result.finishReason,
+      result.toolCalls
+    ]);
+    return { object, usage, finishReason, toolCalls };
+  }
+};
+function streamObjectFromContext(ctx, params) {
+  const textParams = {
+    model: params.model,
+    messages: params.messages,
+    ...params.system !== void 0 ? { system: params.system } : {},
+    ...typeof params.temperature === "number" ? { temperature: params.temperature } : {},
+    ...typeof params.maxTokens === "number" ? { maxTokens: params.maxTokens } : {},
+    ...typeof params.topP === "number" ? { topP: params.topP } : {},
+    ...params.signal !== void 0 ? { signal: params.signal } : {}
+  };
+  const responseFormat = buildResponseFormat({
+    schema: params.schema,
+    ...params.schemaName !== void 0 ? { name: params.schemaName } : {},
+    ...params.schemaDescription !== void 0 ? { description: params.schemaDescription } : {}
+  });
+  const overrideCtx = {
+    ...ctx,
+    // Wrap fetch to substitute the body. We can't change buildInferenceRequestBody
+    // signature on the call site cleanly, so intercept here.
+    fetch: ((input, init) => {
+      if (init && typeof init.body === "string") {
+        const parsed = JSON.parse(init.body);
+        parsed.response_format = responseFormat;
+        const newInit = { ...init, body: JSON.stringify(parsed) };
+        return ctx.fetch(input, newInit);
+      }
+      return ctx.fetch(input, init);
+    })
+  };
+  const inner = streamInferenceFromContext(overrideCtx, textParams);
+  return wrapStreamTextAsObject(inner);
+}
+function wrapStreamTextAsObject(inner) {
+  const partialBroadcast = new PartialObjectBroadcast();
+  const objectDeferred = defer();
+  void (async () => {
+    let acc = "";
+    let lastEmitted = /* @__PURE__ */ Symbol("none");
+    try {
+      for await (const delta of inner.textStream) {
+        acc += delta;
+        const candidate = tryParsePartialJson(acc);
+        if (candidate !== void 0 && !sameSnapshot(candidate, lastEmitted)) {
+          lastEmitted = candidate;
+          partialBroadcast.push(candidate);
+        }
+      }
+      const finalText = await inner.text;
+      let finalObj;
+      try {
+        finalObj = JSON.parse(finalText);
+      } catch (e) {
+        const err = new RagableError(
+          `Model output is not valid JSON: ${e.message}`,
+          502,
+          {
+            code: "SDK_OBJECT_PARSE_FAILED",
+            raw: finalText.slice(0, 1e3)
+          }
+        );
+        partialBroadcast.fail(err);
+        objectDeferred.reject(err);
+        return;
+      }
+      if (!sameSnapshot(finalObj, lastEmitted)) {
+        partialBroadcast.push(finalObj);
+      }
+      partialBroadcast.end();
+      objectDeferred.resolve(finalObj);
+    } catch (err) {
+      partialBroadcast.fail(err);
+      objectDeferred.reject(err);
+    }
+  })();
+  return {
+    textStream: inner.textStream,
+    partialObjectStream: partialBroadcast.consume(),
+    object: objectDeferred.promise,
+    text: inner.text,
+    usage: inner.usage,
+    finishReason: inner.finishReason,
+    toolCalls: inner.toolCalls
+  };
+}
+function sameSnapshot(a, b) {
+  if (a === b) return true;
+  try {
+    return JSON.stringify(a) === JSON.stringify(b);
+  } catch {
+    return false;
+  }
+}
+var PartialObjectBroadcast = class {
+  constructor() {
+    __publicField(this, "items", []);
+    __publicField(this, "resolved", false);
+    __publicField(this, "error", null);
+    __publicField(this, "waiters", []);
+  }
+  push(item) {
+    this.items.push(item);
+    this.notify();
+  }
+  end() {
+    if (this.resolved) return;
+    this.resolved = true;
+    this.notify();
+  }
+  fail(error) {
+    if (this.resolved) return;
+    this.error = error;
+    this.resolved = true;
+    this.notify();
+  }
+  notify() {
+    const w = this.waiters;
+    this.waiters = [];
+    for (const fn of w) fn();
+  }
+  consume() {
+    const self = this;
+    return {
+      [Symbol.asyncIterator]: () => {
+        let idx = 0;
+        return {
+          next: async () => {
+            while (true) {
+              if (idx < self.items.length) {
+                return { value: self.items[idx++], done: false };
+              }
+              if (self.resolved) {
+                if (self.error) throw self.error;
+                return { value: void 0, done: true };
+              }
+              await new Promise((res) => self.waiters.push(res));
+            }
+          }
+        };
+      }
+    };
+  }
 };
 
 // src/browser.ts
@@ -3610,6 +3875,120 @@ var RagableBrowserStorageClient = class {
     return new BrowserStorageBucketClient(this.options, this.fetchImpl, bucketId);
   }
 };
+var RagableBrowserMailClient = class {
+  constructor(options, auth) {
+    this.options = options;
+    this.auth = auth;
+    __publicField(this, "fetchImpl");
+    this.fetchImpl = bindFetch(options.fetch);
+  }
+  requireWebsiteId() {
+    const websiteId = this.options.websiteId?.trim();
+    if (!websiteId) {
+      throw new RagableError(
+        "websiteId is required for mail operations. Use createWebsiteRagableClient() or pass createBrowserClient({ websiteId, ... }).",
+        400,
+        { code: "SDK_MISSING_WEBSITE_ID" }
+      );
+    }
+    return websiteId;
+  }
+  pathTo(p) {
+    const websiteId = this.requireWebsiteId();
+    const orgId = this.options.organizationId;
+    return `${normalizeBrowserApiBase()}/public/organizations/${orgId}/websites/${websiteId}/mail${p.startsWith("/") ? p : `/${p}`}`;
+  }
+  /**
+   * Get the Bearer token used to authenticate the call:
+   *  1. End-user access token (preferred when an auth group is configured
+   *     and the user has signed in)
+   *  2. `dataStaticKey` from createBrowserClient options
+   *  3. Caller-supplied `getAccessToken()`
+   *
+   * If none is available, throws — server-side use should pass the
+   * data-admin key as `dataStaticKey`.
+   */
+  async getBearerToken() {
+    if (this.auth) {
+      const token = await this.auth.getValidAccessToken().catch(() => null);
+      if (token) return token;
+    }
+    const callerProvided = await this.options.getAccessToken?.();
+    if (typeof callerProvided === "string" && callerProvided.length > 0) {
+      return callerProvided;
+    }
+    if (this.options.dataStaticKey?.trim()) {
+      return this.options.dataStaticKey.trim();
+    }
+    throw new RagableError(
+      "Mail requests need authentication: either sign in via client.auth.signIn(...) or pass dataStaticKey (the auth group data-admin key) when creating the client.",
+      401,
+      { code: "SDK_MAIL_NOT_AUTHENTICATED" }
+    );
+  }
+  async request(path, init = {}) {
+    const token = await this.getBearerToken();
+    const headers = new Headers(init.headers ?? this.options.headers);
+    headers.set("Authorization", `Bearer ${token}`);
+    if (init.body && !headers.has("Content-Type")) {
+      headers.set("Content-Type", "application/json");
+    }
+    const response = await this.fetchImpl(this.pathTo(path), {
+      ...init,
+      headers
+    });
+    const payload = await parseMaybeJsonBody(response);
+    if (!response.ok) {
+      const message = extractErrorMessage(payload, response.statusText);
+      throw new RagableError(message, response.status, payload);
+    }
+    return payload;
+  }
+  /** Send an email from this website's linked Gmail account. */
+  async send(params) {
+    if (!params.to?.length) {
+      throw new RagableError(
+        "`to` must contain at least one recipient.",
+        400,
+        { code: "SDK_MAIL_NO_RECIPIENTS" }
+      );
+    }
+    if (!params.bodyText && !params.bodyHtml) {
+      throw new RagableError(
+        "Provide at least one of `bodyText` or `bodyHtml`.",
+        400,
+        { code: "SDK_MAIL_NO_BODY" }
+      );
+    }
+    return this.request("/send", {
+      method: "POST",
+      body: JSON.stringify(params)
+    });
+  }
+  /** Search messages with Gmail query syntax. */
+  async search(params = {}) {
+    const qs = new URLSearchParams();
+    if (params.query) qs.set("q", params.query);
+    if (params.maxResults) qs.set("maxResults", String(params.maxResults));
+    if (params.pageToken) qs.set("pageToken", params.pageToken);
+    if (params.labelIds?.length) qs.set("labelIds", params.labelIds.join(","));
+    const suffix = qs.toString() ? `?${qs.toString()}` : "";
+    return this.request(`/search${suffix}`, { method: "GET" });
+  }
+  /** Fetch a single message in full (headers + decoded text/html body). */
+  async getMessage(messageId) {
+    if (!messageId) {
+      throw new RagableError("`messageId` is required.", 400, {
+        code: "SDK_MAIL_NO_MESSAGE_ID"
+      });
+    }
+    const { message } = await this.request(
+      `/messages/${encodeURIComponent(messageId)}`,
+      { method: "GET" }
+    );
+    return message;
+  }
+};
 var RagableBrowserAgentsClient = class {
   constructor(options) {
     this.options = options;
@@ -3691,6 +4070,63 @@ var RagableBrowserAgentsClient = class {
     const source = this.runStreamParts(agentName, params);
     return createStreamResultFromParts(source);
   }
+  /**
+   * Same agent, same tools/instructions/RAG — but constrain the final output
+   * to a JSON Schema. Matches `client.ai.streamObject` exactly so callers can
+   * swap between raw inference and an agent without changing call shape.
+   *
+   * Tool calling and structured output are **compatible**: the model may call
+   * the agent's tools as usual; the final assistant message is the schema-
+   * conformant JSON. The agent's `agents/<name>.json` is unchanged — whether
+   * the run is conversational or structured is decided by the call site.
+   *
+   * ```ts
+   * const { partialObjectStream, object } = client.agents.runObject<Plan>(
+   *   "planner",
+   *   {
+   *     messages: [{ role: "user", content: "Plan a 3-day trip to Kyoto." }],
+   *     schema: {
+   *       type: "object",
+   *       properties: {
+   *         days: {
+   *           type: "array",
+   *           items: { type: "object", properties: { date: { type: "string" }, activities: { type: "array", items: { type: "string" } } } },
+   *         },
+   *       },
+   *       required: ["days"],
+   *     },
+   *   },
+   * );
+   * for await (const p of partialObjectStream) renderPreview(p);
+   * console.log(await object);
+   * ```
+   */
+  runObject(agentName, params) {
+    const responseFormat = buildResponseFormat({
+      schema: params.schema,
+      ...params.schemaName !== void 0 ? { name: params.schemaName } : {},
+      ...params.schemaDescription !== void 0 ? { description: params.schemaDescription } : {}
+    });
+    const sourceParts = this.runStreamParts(agentName, {
+      messages: params.messages,
+      ...params.signal !== void 0 ? { signal: params.signal } : {},
+      responseFormat
+    });
+    const inner = createStreamResultFromParts(sourceParts);
+    return wrapStreamTextAsObject(inner);
+  }
+  /** Non-streaming variant of {@link runObject}. */
+  async generateObject(agentName, params) {
+    const result = this.runObject(agentName, params);
+    for await (const _ of result.partialObjectStream) void _;
+    const [object, usage, finishReason, toolCalls] = await Promise.all([
+      result.object,
+      result.usage,
+      result.finishReason,
+      result.toolCalls
+    ]);
+    return { object, usage, finishReason, toolCalls };
+  }
   async *runStreamParts(agentName, params) {
     const { messages } = params;
     if (!Array.isArray(messages) || messages.length === 0) {
@@ -3712,12 +4148,33 @@ var RagableBrowserAgentsClient = class {
       role: m.role,
       content: m.content
     }));
-    const events = this.chatStreamByName(agentName, {
+    const headers = new Headers(this.options.headers);
+    headers.set("Content-Type", "application/json");
+    const body = {
       message: last.content,
       ...history.length > 0 ? { history } : {},
-      ...params.signal !== void 0 ? { signal: params.signal } : {}
-    });
-    for await (const event of events) {
+      ...params.responseFormat ? { response_format: params.responseFormat } : {}
+    };
+    const response = await this.fetchImpl(
+      this.toUrl(
+        this.websiteAgentPath(
+          `/agents/${encodeURIComponent(agentName)}/chat/stream`
+        )
+      ),
+      {
+        method: "POST",
+        headers,
+        body: JSON.stringify(body),
+        ...params.signal !== void 0 ? { signal: params.signal } : {}
+      }
+    );
+    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;
+    for await (const event of readSseStream(response.body)) {
       const mapped = mapAgentEvent(event);
       if (mapped) yield mapped;
     }
@@ -3858,6 +4315,7 @@ var RagableBrowser = class {
     __publicField(this, "database");
     __publicField(this, "db");
     __publicField(this, "storage");
+    __publicField(this, "mail");
     __publicField(this, "transport");
     __publicField(this, "_ragableAuth");
     /** Delegates to `database.from()`. Kept for back-compat — prefer `database.from()`. */
@@ -3903,6 +4361,7 @@ var RagableBrowser = class {
     this.database._setTransport(this.transport);
     this.db = this.database;
     this.storage = new RagableBrowserStorageClient(options, bindFetch(options.fetch));
+    this.mail = new RagableBrowserMailClient(options, this._ragableAuth);
   }
   destroy() {
     this._ragableAuth?.destroy();
@@ -3944,6 +4403,7 @@ function createClient(options) {
   RagableBrowserAiClient,
   RagableBrowserAuthClient,
   RagableBrowserDatabaseClient,
+  RagableBrowserMailClient,
   RagableBrowserStorageClient,
   RagableError,
   RagableNetworkError,
@@ -3955,6 +4415,7 @@ function createClient(options) {
   assertPostgrestSuccess,
   bindFetch,
   buildInferenceRequestBody,
+  buildResponseFormat,
   collectAssistantTextFromUiSegments,
   collectionRecordToRowWithMeta,
   collectionRecordsToRowWithMeta,
@@ -3982,7 +4443,10 @@ function createClient(options) {
   runAgentChatStream,
   runAgentChatStreamForUi,
   runAgentChatStreamLenient,
+  streamObjectFromContext,
   toRagableResult,
-  unwrapPostgrest
+  tryParsePartialJson,
+  unwrapPostgrest,
+  wrapStreamTextAsObject
 });
 //# sourceMappingURL=index.js.map