@ragable/sdk 0.7.6 → 0.7.8

package/dist/index.mjs

@@ -131,201 +131,6 @@ function extractErrorMessage(payload, fallback) {
   }
   return fallback || "Request failed";
 }
-var RagableRequestClient = class {
-  constructor(options) {
-    __publicField(this, "apiKey");
-    __publicField(this, "baseUrl");
-    __publicField(this, "fetchImpl");
-    __publicField(this, "defaultHeaders");
-    this.apiKey = options.apiKey;
-    this.baseUrl = DEFAULT_RAGABLE_API_BASE.replace(/\/+$/, "");
-    this.fetchImpl = bindFetch(options.fetch);
-    this.defaultHeaders = options.headers;
-  }
-  toUrl(path) {
-    const normalizedBase = this.baseUrl.replace(/\/+$/, "");
-    const normalizedPath = path.startsWith("/") ? path : `/${path}`;
-    return `${normalizedBase}${normalizedPath}`;
-  }
-  async request(path, options = {}) {
-    const response = await this.rawFetch(path, options);
-    const payload = await this.parseResponseBody(response);
-    if (!response.ok) {
-      const message = extractErrorMessage(payload, response.statusText);
-      throw new RagableError(message, response.status, payload);
-    }
-    return payload;
-  }
-  /**
-   * Low-level fetch with API key and JSON body encoding. Caller handles status and body.
-   */
-  async rawFetch(path, options = {}) {
-    const headers = new Headers(this.defaultHeaders);
-    headers.set("Authorization", `Bearer ${this.apiKey}`);
-    let body = options.body;
-    if (body !== void 0 && !isBodyInit(body)) {
-      headers.set("Content-Type", "application/json");
-      body = JSON.stringify(body);
-    }
-    return this.fetchImpl(this.toUrl(path), {
-      ...options,
-      headers,
-      body
-    });
-  }
-  async parseResponseBody(response) {
-    if (response.status === 204) {
-      return null;
-    }
-    const contentType = response.headers.get("content-type") ?? "";
-    if (contentType.includes("application/json")) {
-      return response.json();
-    }
-    return response.text();
-  }
-};
-function isBodyInit(value) {
-  return typeof value === "string" || value instanceof Blob || value instanceof FormData || value instanceof URLSearchParams || value instanceof ArrayBuffer || ArrayBuffer.isView(value);
-}
-
-// src/shift.ts
-var ShiftClient = class {
-  constructor(client) {
-    this.client = client;
-    __publicField(this, "indexes");
-    __publicField(this, "documents");
-    __publicField(this, "entries");
-    this.indexes = {
-      list: async () => {
-        return this.client.request("/v1/shift/indexes");
-      },
-      create: async (params) => {
-        return this.client.request("/v1/shift/indexes", {
-          method: "POST",
-          body: params
-        });
-      },
-      get: async (indexId) => {
-        return this.client.request(`/v1/shift/indexes/${indexId}`);
-      },
-      update: async (indexId, params) => {
-        return this.client.request(`/v1/shift/indexes/${indexId}`, {
-          method: "PUT",
-          body: params
-        });
-      },
-      delete: async (indexId) => {
-        return this.client.request(
-          `/v1/shift/indexes/${indexId}`,
-          {
-            method: "DELETE"
-          }
-        );
-      }
-    };
-    this.documents = {
-      create: async (indexId, params) => {
-        return this.client.request(
-          `/v1/shift/indexes/${indexId}/documents`,
-          {
-            method: "POST",
-            body: params
-          }
-        );
-      },
-      upload: async (indexId, params) => {
-        const formData = new FormData();
-        const fileName = resolveUploadFileName(params);
-        const contentType = resolveUploadContentType(params);
-        const file = normalizeUploadFile(params.file, contentType);
-        formData.set("file", file, fileName);
-        if (params.metadata) {
-          formData.set("metadata", JSON.stringify(params.metadata));
-        }
-        if (typeof params.chunkSize === "number") {
-          formData.set("chunkSize", String(params.chunkSize));
-        }
-        if (typeof params.chunkOverlap === "number") {
-          formData.set("chunkOverlap", String(params.chunkOverlap));
-        }
-        return this.client.request(
-          `/v1/shift/indexes/${indexId}/files`,
-          {
-            method: "POST",
-            body: formData
-          }
-        );
-      }
-    };
-    this.entries = {
-      list: async (indexId, params = {}) => {
-        const search = new URLSearchParams();
-        if (typeof params.take === "number") {
-          search.set("take", String(params.take));
-        }
-        if (typeof params.skip === "number") {
-          search.set("skip", String(params.skip));
-        }
-        const suffix = search.size > 0 ? `?${search.toString()}` : "";
-        return this.client.request(
-          `/v1/shift/indexes/${indexId}/entries${suffix}`
-        );
-      },
-      delete: async (indexId, entryId) => {
-        return this.client.request(
-          `/v1/shift/indexes/${indexId}/entries/${entryId}`,
-          {
-            method: "DELETE"
-          }
-        );
-      }
-    };
-  }
-  async search(indexId, params) {
-    return this.client.request(
-      `/v1/shift/indexes/${indexId}/search`,
-      {
-        method: "POST",
-        body: params
-      }
-    );
-  }
-};
-function resolveUploadFileName(params) {
-  if (params.fileName) {
-    return params.fileName;
-  }
-  if (isNamedBlob(params.file)) {
-    return params.file.name;
-  }
-  return "upload.bin";
-}
-function resolveUploadContentType(params) {
-  if (params.contentType) {
-    return params.contentType;
-  }
-  if (params.file instanceof Blob && params.file.type) {
-    return params.file.type;
-  }
-  return "application/octet-stream";
-}
-function normalizeUploadFile(file, contentType) {
-  if (file instanceof Blob) {
-    return file;
-  }
-  if (file instanceof Uint8Array) {
-    return new Blob([toArrayBuffer(file)], { type: contentType });
-  }
-  return new Blob([file], { type: contentType });
-}
-function isNamedBlob(value) {
-  return value instanceof Blob && "name" in value && typeof value.name === "string";
-}
-function toArrayBuffer(value) {
-  const copy = new Uint8Array(value.byteLength);
-  copy.set(value);
-  return copy.buffer;
-}
 
 // src/agent-stream.ts
 function assertAborted(signal) {
@@ -831,72 +636,6 @@ async function* readSseStream(body) {
   }
 }
 
-// src/agents.ts
-var AgentsClient = class {
-  constructor(client) {
-    this.client = client;
-  }
-  async list() {
-    return this.client.request("/v1/agents");
-  }
-  async get(agentId) {
-    return this.client.request(`/v1/agents/${agentId}`);
-  }
-  async chat(agentId, params) {
-    return this.client.request(`/v1/agents/${agentId}/chat`, {
-      method: "POST",
-      body: {
-        message: params.message,
-        ...params.history !== void 0 ? { history: params.history } : {}
-      }
-    });
-  }
-  /**
-   * Stream agent execution as SSE (`data: {json}` lines). Yields parsed JSON objects.
-   */
-  async *chatStream(agentId, params) {
-    const response = await this.client.rawFetch(
-      `/v1/agents/${agentId}/chat/stream`,
-      {
-        method: "POST",
-        body: {
-          message: params.message,
-          ...params.history !== void 0 ? { history: params.history } : {}
-        },
-        ...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);
-    }
-    const body = response.body;
-    if (!body) {
-      return;
-    }
-    yield* readSseStream(body);
-  }
-  /**
-   * Stream an agent turn with callbacks; returns the final `done` payload plus streamed text.
-   * Prefer this over manual iteration when building chat UIs against the server API key client.
-   */
-  async runChatStream(agentId, params, handlers = {}) {
-    return runAgentChatStream(this.chatStream(agentId, params), handlers, {
-      signal: params.signal
-    });
-  }
-  /**
-   * Stream with dashboard-style `AgentChat` ergonomics: {@link AgentChatStreamUiHandlers.onSegments}
-   * / `onStreamingText` for live UI; returns a persisted-shaped assistant message on `done`.
-   */
-  async runChatUi(agentId, params, handlers = {}) {
-    return runAgentChatStreamForUi(this.chatStream(agentId, params), handlers, {
-      signal: params.signal
-    });
-  }
-};
-
 // src/transport.ts
 var DEFAULT_RETRY = {
   maxRetries: 3,
@@ -2125,8 +1864,8 @@ function parseExpiresInSeconds(raw) {
     const mult = u === "s" ? 1 : u === "m" ? 60 : u === "h" ? 3600 : u === "d" ? 86400 : 1;
     return n * mult;
   }
-  const asNum = Number(s);
-  return Number.isFinite(asNum) ? asNum : 0;
+  const asNum2 = Number(s);
+  return Number.isFinite(asNum2) ? asNum2 : 0;
 }
 async function parseJsonOrThrow(response) {
   const text = await response.text();
@@ -2530,6 +2269,740 @@ 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) {
+    case "stop":
+    case "length":
+    case "content-filter":
+    case "error":
+      return raw;
+    case "tool_calls":
+      return "tool-calls";
+    case null:
+    case void 0:
+    case "":
+      return "unknown";
+    default:
+      return "unknown";
+  }
+}
+function chunkUsage(chunk) {
+  const u = chunk.usage ?? {};
+  const cached = u.prompt_tokens_details?.cached_tokens ?? u.cache_read_input_tokens;
+  return {
+    promptTokens: typeof u.prompt_tokens === "number" ? u.prompt_tokens : 0,
+    completionTokens: typeof u.completion_tokens === "number" ? u.completion_tokens : 0,
+    totalTokens: typeof u.total_tokens === "number" ? u.total_tokens : 0,
+    ...typeof cached === "number" ? { cachedPromptTokens: cached } : {}
+  };
+}
+function createToolCallAccumulator() {
+  return { byIndex: /* @__PURE__ */ new Map() };
+}
+function parseJsonOrRaw(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return raw;
+  }
+}
+function mapFireworksChunk(chunk, acc) {
+  const out = [];
+  if (chunk.error?.message) {
+    out.push({ type: "error", error: chunk.error.message });
+    return out;
+  }
+  const choice = chunk.choices?.[0];
+  const delta = choice?.delta;
+  if (delta?.content) {
+    out.push({ type: "text-delta", textDelta: delta.content });
+  }
+  const reasoning = delta?.reasoning_content ?? delta?.reasoning;
+  if (typeof reasoning === "string" && reasoning.length > 0) {
+    out.push({ type: "reasoning", textDelta: reasoning });
+  }
+  if (Array.isArray(delta?.tool_calls)) {
+    for (const tc of delta.tool_calls) {
+      const idx = typeof tc.index === "number" ? tc.index : 0;
+      let entry = acc.byIndex.get(idx);
+      if (!entry) {
+        entry = { id: "", name: "", argsBuffer: "", emitted: false };
+        acc.byIndex.set(idx, entry);
+      }
+      if (tc.id) entry.id = tc.id;
+      if (tc.function?.name) entry.name = tc.function.name;
+      if (typeof tc.function?.arguments === "string") {
+        entry.argsBuffer += tc.function.arguments;
+      }
+    }
+  }
+  if (choice?.finish_reason) {
+    for (const entry of acc.byIndex.values()) {
+      if (entry.emitted || !entry.name) continue;
+      entry.emitted = true;
+      out.push({
+        type: "tool-call",
+        toolCallId: entry.id || `call_${entry.name}_${Date.now()}`,
+        toolName: entry.name,
+        args: entry.argsBuffer ? parseJsonOrRaw(entry.argsBuffer) : {}
+      });
+    }
+    out.push({
+      type: "finish",
+      finishReason: normalizeFinishReason(choice.finish_reason),
+      usage: chunkUsage(chunk)
+    });
+  } else if (chunk.usage) {
+    out.push({
+      type: "finish",
+      finishReason: "unknown",
+      usage: chunkUsage(chunk)
+    });
+  }
+  return out;
+}
+function asStr(v, fallback = "") {
+  return typeof v === "string" ? v : fallback;
+}
+function asNum(v, fallback = 0) {
+  return typeof v === "number" && Number.isFinite(v) ? v : fallback;
+}
+function mapAgentEvent(event) {
+  switch (event.type) {
+    case "token":
+      return { type: "text-delta", textDelta: asStr(event.token) };
+    case "reasoning_token":
+      return { type: "reasoning", textDelta: asStr(event.token) };
+    case "tool:call":
+      return {
+        type: "tool-call",
+        toolCallId: asStr(event.nodeId),
+        toolName: asStr(event.toolName),
+        args: event.args
+      };
+    case "tool:result":
+      return {
+        type: "tool-result",
+        toolCallId: asStr(event.nodeId),
+        toolName: asStr(event.toolName),
+        result: event.result,
+        ...typeof event.durationMs === "number" ? { durationMs: event.durationMs } : {}
+      };
+    case "done": {
+      const usage = {
+        promptTokens: asNum(event.inputTokens),
+        completionTokens: asNum(event.outputTokens),
+        totalTokens: asNum(event.inputTokens) + asNum(event.outputTokens),
+        ...typeof event.cachedPromptTokens === "number" ? { cachedPromptTokens: event.cachedPromptTokens } : {}
+      };
+      return {
+        type: "finish",
+        finishReason: normalizeFinishReason(
+          asStr(event.finishReason) || asStr(event.stopReason) || null
+        ),
+        usage
+      };
+    }
+    default:
+      return null;
+  }
+}
+
+// src/ai.ts
+var PartBroadcast = class {
+  constructor() {
+    __publicField(this, "state", {
+      parts: [],
+      resolved: false,
+      error: null,
+      waiters: []
+    });
+  }
+  push(part) {
+    this.state.parts.push(part);
+    this.notify();
+  }
+  end() {
+    if (this.state.resolved) return;
+    this.state.resolved = true;
+    this.notify();
+  }
+  fail(error) {
+    if (this.state.resolved) return;
+    this.state.error = error;
+    this.state.resolved = true;
+    this.notify();
+  }
+  notify() {
+    const waiters = this.state.waiters;
+    this.state.waiters = [];
+    for (const w of waiters) w();
+  }
+  consume() {
+    const state = this.state;
+    return {
+      [Symbol.asyncIterator]: () => {
+        let idx = 0;
+        return {
+          next: async () => {
+            while (true) {
+              if (idx < state.parts.length) {
+                return { value: state.parts[idx++], done: false };
+              }
+              if (state.resolved) {
+                if (state.error) throw state.error;
+                return { value: void 0, done: true };
+              }
+              await new Promise((resolve) => {
+                state.waiters.push(resolve);
+              });
+            }
+          }
+        };
+      }
+    };
+  }
+};
+function defer() {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve, reject };
+}
+var ZERO_USAGE = {
+  promptTokens: 0,
+  completionTokens: 0,
+  totalTokens: 0
+};
+function buildInferenceRequestBody(params, responseFormat) {
+  const body = {
+    model: params.model,
+    messages: params.messages
+  };
+  if (params.system !== void 0) body.system = params.system;
+  if (typeof params.temperature === "number")
+    body.temperature = params.temperature;
+  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();
+  const acc = createToolCallAccumulator();
+  let textBuffer = "";
+  let reasoningBuffer = "";
+  let lastUsage = ZERO_USAGE;
+  let lastFinish = "unknown";
+  const toolCallsArr = [];
+  let buffer = "";
+  const dispatch = (rawLine) => {
+    const parsed = parseSseDataLine(rawLine);
+    if (!parsed) return;
+    const chunk = parsed;
+    const parts = mapFireworksChunk(chunk, acc);
+    for (const part of parts) {
+      if (part.type === "text-delta") textBuffer += part.textDelta;
+      else if (part.type === "reasoning") reasoningBuffer += part.textDelta;
+      else if (part.type === "tool-call") {
+        toolCallsArr.push({
+          toolCallId: part.toolCallId,
+          toolName: part.toolName,
+          args: part.args
+        });
+      } else if (part.type === "finish") {
+        lastFinish = part.finishReason;
+        lastUsage = part.usage;
+      }
+      broadcast.push(part);
+    }
+  };
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      let boundary = buffer.indexOf("\n\n");
+      while (boundary !== -1) {
+        const block = buffer.slice(0, boundary);
+        buffer = buffer.slice(boundary + 2);
+        for (const line of block.split("\n")) dispatch(line);
+        boundary = buffer.indexOf("\n\n");
+      }
+    }
+    if (buffer.trim().length > 0) {
+      for (const line of buffer.split("\n")) dispatch(line);
+    }
+    broadcast.end();
+    deferreds.text.resolve(textBuffer);
+    deferreds.reasoning.resolve(reasoningBuffer);
+    deferreds.usage.resolve(lastUsage);
+    deferreds.finishReason.resolve(lastFinish);
+    deferreds.toolCalls.resolve(toolCallsArr);
+  } catch (error) {
+    broadcast.fail(error);
+    deferreds.text.reject(error);
+    deferreds.reasoning.reject(error);
+    deferreds.usage.reject(error);
+    deferreds.finishReason.reject(error);
+    deferreds.toolCalls.reject(error);
+  } finally {
+    try {
+      reader.releaseLock();
+    } catch {
+    }
+  }
+}
+function createStreamResultFromParts(source) {
+  const broadcast = new PartBroadcast();
+  const text = defer();
+  const reasoning = defer();
+  const usage = defer();
+  const finishReason = defer();
+  const toolCalls = defer();
+  void (async () => {
+    let textBuffer = "";
+    let reasoningBuffer = "";
+    let lastUsage = ZERO_USAGE;
+    let lastFinish = "unknown";
+    const toolCallsArr = [];
+    try {
+      for await (const part of source) {
+        if (part.type === "text-delta") textBuffer += part.textDelta;
+        else if (part.type === "reasoning")
+          reasoningBuffer += part.textDelta;
+        else if (part.type === "tool-call") {
+          toolCallsArr.push({
+            toolCallId: part.toolCallId,
+            toolName: part.toolName,
+            args: part.args
+          });
+        } else if (part.type === "finish") {
+          lastFinish = part.finishReason;
+          lastUsage = part.usage;
+        }
+        broadcast.push(part);
+      }
+      broadcast.end();
+      text.resolve(textBuffer);
+      reasoning.resolve(reasoningBuffer);
+      usage.resolve(lastUsage);
+      finishReason.resolve(lastFinish);
+      toolCalls.resolve(toolCallsArr);
+    } catch (error) {
+      broadcast.fail(error);
+      text.reject(error);
+      reasoning.reject(error);
+      usage.reject(error);
+      finishReason.reject(error);
+      toolCalls.reject(error);
+    }
+  })();
+  return {
+    fullStream: broadcast.consume(),
+    textStream: {
+      [Symbol.asyncIterator]: () => {
+        const inner = broadcast.consume()[Symbol.asyncIterator]();
+        return {
+          next: async () => {
+            while (true) {
+              const r = await inner.next();
+              if (r.done)
+                return { value: void 0, done: true };
+              if (r.value.type === "text-delta") {
+                return { value: r.value.textDelta, done: false };
+              }
+            }
+          }
+        };
+      }
+    },
+    text: text.promise,
+    reasoning: reasoning.promise,
+    usage: usage.promise,
+    finishReason: finishReason.promise,
+    toolCalls: toolCalls.promise
+  };
+}
+function streamInferenceFromContext(ctx, params) {
+  const broadcast = new PartBroadcast();
+  const text = defer();
+  const reasoning = defer();
+  const usage = defer();
+  const finishReason = defer();
+  const toolCalls = defer();
+  const start = async () => {
+    const response = await ctx.fetch(ctx.url, {
+      method: "POST",
+      headers: ctx.headers,
+      body: JSON.stringify(buildInferenceRequestBody(params)),
+      ...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) {
+      throw new RagableError("Inference stream has no body", 502, {
+        code: "SDK_INFERENCE_STREAM_NO_BODY"
+      });
+    }
+    await consumeInferenceStream(response.body, broadcast, {
+      text,
+      reasoning,
+      usage,
+      finishReason,
+      toolCalls
+    });
+  };
+  start().catch((err) => {
+    broadcast.fail(err);
+    text.reject(err);
+    reasoning.reject(err);
+    usage.reject(err);
+    finishReason.reject(err);
+    toolCalls.reject(err);
+  });
+  return {
+    fullStream: broadcast.consume(),
+    textStream: {
+      [Symbol.asyncIterator]: () => {
+        const inner = broadcast.consume()[Symbol.asyncIterator]();
+        return {
+          next: async () => {
+            while (true) {
+              const r = await inner.next();
+              if (r.done) return { value: void 0, done: true };
+              if (r.value.type === "text-delta") {
+                return { value: r.value.textDelta, done: false };
+              }
+            }
+          }
+        };
+      }
+    },
+    text: text.promise,
+    reasoning: reasoning.promise,
+    usage: usage.promise,
+    finishReason: finishReason.promise,
+    toolCalls: toolCalls.promise
+  };
+}
+var RagableBrowserAiClient = class {
+  constructor(options) {
+    this.options = options;
+    __publicField(this, "fetchImpl");
+    this.fetchImpl = bindFetch(options.fetch);
+  }
+  requireWebsiteId() {
+    const id = this.options.websiteId?.trim();
+    if (!id) {
+      throw new RagableError(
+        "client.ai.streamText requires websiteId on the client. Pass createBrowserClient({ websiteId, organizationId, ... }).",
+        400,
+        { code: "SDK_MISSING_WEBSITE_ID" }
+      );
+    }
+    return id;
+  }
+  buildContext() {
+    const url = `${this.options.apiBase}/public/organizations/${encodeURIComponent(
+      this.options.organizationId
+    )}/websites/${encodeURIComponent(
+      this.requireWebsiteId()
+    )}/inference/stream`;
+    const headers = new Headers(this.options.headers);
+    headers.set("Content-Type", "application/json");
+    headers.set("Accept", "text/event-stream");
+    return { url, headers, fetch: this.fetchImpl };
+  }
+  streamText(params) {
+    return streamInferenceFromContext(this.buildContext(), params);
+  }
+  async generateText(params) {
+    const result = this.streamText(params);
+    for await (const _ of result.fullStream) {
+      void _;
+    }
+    const [text, reasoning, usage, finishReason, toolCalls] = await Promise.all(
+      [
+        result.text,
+        result.reasoning,
+        result.usage,
+        result.finishReason,
+        result.toolCalls
+      ]
+    );
+    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
 function normalizeBrowserApiBase() {
   return DEFAULT_RAGABLE_API_BASE.replace(/\/+$/, "");
@@ -3373,6 +3846,136 @@ var RagableBrowserAgentsClient = class {
     }
     yield* readSseStream(streamBody);
   }
+  /**
+   * Stream a project agent defined in `agents/*.json` using the same result
+   * shape as `client.ai.streamText`. Preferred over {@link chatStreamByName}
+   * and {@link runChatStreamByName} — those remain for back-compat only.
+   *
+   * ```ts
+   * const { textStream, text } = client.agents.run("support", {
+   *   messages: [{ role: "user", content: "I can't log in" }],
+   * });
+   * for await (const delta of textStream) process.stdout.write(delta);
+   * console.log(await text);
+   * ```
+   */
+  run(agentName, params) {
+    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) {
+      throw new RagableError(
+        "agents.run requires at least one message",
+        400,
+        { code: "SDK_AGENTS_RUN_EMPTY_MESSAGES" }
+      );
+    }
+    const last = messages[messages.length - 1];
+    if (!last || last.role !== "user") {
+      throw new RagableError(
+        'agents.run: the final message must have role "user"',
+        400,
+        { code: "SDK_AGENTS_RUN_INVALID_LAST_MESSAGE" }
+      );
+    }
+    const history = messages.slice(0, -1).filter((m) => m.role === "user" || m.role === "assistant").map((m) => ({
+      role: m.role,
+      content: m.content
+    }));
+    const headers = new Headers(this.options.headers);
+    headers.set("Content-Type", "application/json");
+    const body = {
+      message: last.content,
+      ...history.length > 0 ? { history } : {},
+      ...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;
+    }
+  }
+  /**
+   * @deprecated Use {@link run} for new code. This method is kept for
+   *   back-compat with the original chat-stream DX.
+   */
   async *chatStreamByName(agentName, params) {
     const headers = new Headers(this.options.headers);
     headers.set("Content-Type", "application/json");
@@ -3401,8 +4004,9 @@ var RagableBrowserAgentsClient = class {
     yield* readSseStream(response.body);
   }
   /**
-   * Stream a project agent (`/agents/*.json`) with callbacks; returns the final `done` payload
-   * plus streamed assistant text. Prefer this over manual `for await` when building chat UIs.
+   * @deprecated Use {@link run} for new code. Returns the legacy callback-based
+   *   result type leaking server internals; the new Vercel-style API exposes
+   *   `textStream` / `fullStream` / promises for `text`, `usage`, `finishReason`.
    */
   async runChatStreamByName(agentName, params, handlers = {}) {
     return runAgentChatStream(this.chatStreamByName(agentName, params), handlers, {
@@ -3499,6 +4103,7 @@ var RagableBrowserAgentsClient = class {
 var RagableBrowser = class {
   constructor(options) {
     __publicField(this, "agents");
+    __publicField(this, "ai");
     __publicField(this, "auth");
     __publicField(this, "database");
     __publicField(this, "db");
@@ -3533,6 +4138,13 @@ var RagableBrowser = class {
       this._ragableAuth = null;
     }
     this.agents = new RagableBrowserAgentsClient(options);
+    this.ai = new RagableBrowserAiClient({
+      organizationId: options.organizationId,
+      ...options.websiteId !== void 0 ? { websiteId: options.websiteId } : {},
+      ...options.fetch !== void 0 ? { fetch: options.fetch } : {},
+      ...options.headers !== void 0 ? { headers: options.headers } : {},
+      apiBase: normalizeBrowserApiBase()
+    });
     this.auth = new RagableBrowserAuthClient(options, this._ragableAuth);
     this.database = new RagableBrowserDatabaseClient(
       options,
@@ -3551,245 +4163,13 @@ function createBrowserClient(options) {
 }
 var createRagableBrowserClient = createBrowserClient;
 
-// src/rag.ts
-function formatRetrievalContext(results, options = {}) {
-  const header = options.header ?? "Relevant passages:\n";
-  const separator = options.separator ?? "\n\n";
-  const minScore = options.minScore;
-  let filtered = results;
-  if (typeof minScore === "number") {
-    filtered = results.filter((r) => r.score >= minScore);
-  }
-  const blocks = filtered.map((r, i) => {
-    const scoreSuffix = options.includeScores === true ? ` (score: ${r.score.toFixed(4)})` : "";
-    return `[${i + 1}]${scoreSuffix}
-${r.content.trim()}`;
-  });
-  let text = (blocks.length > 0 ? header : "") + blocks.join(separator);
-  if (typeof options.maxChars === "number" && text.length > options.maxChars) {
-    text = text.slice(0, options.maxChars).trimEnd() + "\n\u2026";
-  }
-  return text;
-}
-function createRagPipeline(client, options) {
-  const { indexId } = options;
-  return {
-    indexId,
-    ingestText(params) {
-      return client.shift.documents.create(indexId, params);
-    },
-    ingestFile(params) {
-      return client.shift.documents.upload(indexId, params);
-    },
-    search(params) {
-      return client.shift.search(indexId, params);
-    },
-    async retrieve(params) {
-      const { format: formatOpts, ...searchParams } = params;
-      const { results } = await client.shift.search(indexId, searchParams);
-      const context = formatRetrievalContext(results, formatOpts ?? {});
-      return { results, context };
-    }
-  };
-}
-
-// src/storage.ts
-function normalizeUploadFile2(file, contentType) {
-  if (file instanceof Blob) return file;
-  const u8 = file instanceof ArrayBuffer ? new Uint8Array(file) : new Uint8Array(file);
-  return new Blob([u8.buffer], contentType ? { type: contentType } : {});
-}
-var StorageClient = class {
-  constructor(client) {
-    this.client = client;
-    /**
-     * Bucket-level CRUD — list, create and delete buckets for this organisation.
-     */
-    __publicField(this, "buckets");
-    this.buckets = {
-      list: async (params) => {
-        const qs = new URLSearchParams();
-        if (params?.q) qs.set("q", params.q);
-        if (params?.status) qs.set("status", params.status);
-        if (params?.sort) qs.set("sort", params.sort);
-        const query = qs.toString();
-        return this.client.request(
-          `/v1/storage/buckets${query ? `?${query}` : ""}`
-        );
-      },
-      create: async (name) => {
-        return this.client.request("/v1/storage/buckets", {
-          method: "POST",
-          body: { name }
-        });
-      },
-      delete: async (bucketId) => {
-        return this.client.request(
-          `/v1/storage/buckets/${encodeURIComponent(bucketId)}`,
-          { method: "DELETE" }
-        );
-      }
-    };
-  }
-  /**
-   * Returns a {@link StorageBucketClient} scoped to the given bucket ID.
-   *
-   * All object operations (upload, download, list, copy, move, signed URLs, …)
-   * are performed through the returned client.
-   *
-   * @param bucketId The Ragable bucket ID obtained from `buckets.list()` or `buckets.create()`.
-   */
-  from(bucketId) {
-    const { client } = this;
-    const base = `/v1/storage/buckets/${encodeURIComponent(bucketId)}`;
-    return {
-      list: async (params) => {
-        const qs = new URLSearchParams();
-        if (params?.prefix) qs.set("prefix", params.prefix);
-        if (params?.delimiter) qs.set("delimiter", params.delimiter);
-        if (params?.maxResults != null)
-          qs.set("maxResults", String(params.maxResults));
-        if (params?.pageToken) qs.set("pageToken", params.pageToken);
-        const query = qs.toString();
-        return client.request(
-          `${base}/contents${query ? `?${query}` : ""}`
-        );
-      },
-      createFolder: async (folderPath) => {
-        return client.request(
-          `${base}/folders`,
-          { method: "POST", body: { folderPath } }
-        );
-      },
-      deleteFolder: async (folderPath) => {
-        return client.request(
-          `${base}/folders`,
-          { method: "DELETE", body: { folderPath } }
-        );
-      },
-      upload: async (params) => {
-        const formData = new FormData();
-        const blob = normalizeUploadFile2(params.file, params.contentType);
-        const fileName = params.fileName ?? "upload";
-        formData.set("file", blob, fileName);
-        formData.set("objectPath", params.objectPath);
-        if (params.cacheControl) {
-          formData.set("cacheControl", params.cacheControl);
-        }
-        return client.request(`${base}/upload`, {
-          method: "POST",
-          body: formData
-        });
-      },
-      delete: async (objectPath) => {
-        return client.request(
-          `${base}/objects`,
-          { method: "DELETE", body: { objectPath } }
-        );
-      },
-      bulkDelete: async (objectPaths) => {
-        return client.request(
-          `${base}/objects/delete-bulk`,
-          { method: "POST", body: { objectPaths } }
-        );
-      },
-      getMetadata: async (objectPath) => {
-        const qs = new URLSearchParams({ objectPath });
-        return client.request(
-          `${base}/objects/metadata?${qs}`
-        );
-      },
-      updateMetadata: async (params) => {
-        return client.request(
-          `${base}/objects/metadata`,
-          { method: "PATCH", body: params }
-        );
-      },
-      download: async (params) => {
-        const qs = new URLSearchParams({ objectPath: params.objectPath });
-        if (params.asText != null) qs.set("asText", String(params.asText));
-        if (params.maxTextBytes != null)
-          qs.set("maxTextBytes", String(params.maxTextBytes));
-        return client.request(
-          `${base}/objects/download?${qs}`
-        );
-      },
-      copy: async (params) => {
-        return client.request(`${base}/objects/copy`, { method: "POST", body: params });
-      },
-      move: async (params) => {
-        return client.request(`${base}/objects/move`, { method: "POST", body: params });
-      },
-      getSignedUploadUrl: async (params) => {
-        return client.request(
-          `${base}/signed-upload-url`,
-          { method: "POST", body: params }
-        );
-      },
-      getSignedDownloadUrl: async (params) => {
-        const qs = new URLSearchParams({ objectPath: params.objectPath });
-        if (params.expiresInSeconds != null)
-          qs.set("expiresInSeconds", String(params.expiresInSeconds));
-        return client.request(
-          `${base}/signed-download-url?${qs}`
-        );
-      },
-      getSettings: async () => {
-        return client.request(`${base}/settings`);
-      },
-      updateSettings: async (params) => {
-        return client.request(`${base}/settings`, {
-          method: "PATCH",
-          body: params
-        });
-      }
-    };
-  }
-};
-
 // src/index.ts
-var Ragable = class {
-  constructor(options) {
-    __publicField(this, "shift");
-    __publicField(this, "agents");
-    __publicField(this, "storage");
-    __publicField(this, "infrastructure");
-    const client = new RagableRequestClient(options);
-    this.shift = new ShiftClient(client);
-    this.agents = new AgentsClient(client);
-    this.storage = new StorageClient(client);
-    this.infrastructure = {
-      shift: this.shift
-    };
-  }
-};
-function isServerClientOptions(o) {
-  return typeof o === "object" && o !== null && "apiKey" in o && typeof o.apiKey === "string" && o.apiKey.length > 0;
-}
 function createClient(options) {
-  if (isServerClientOptions(options)) {
-    if (typeof options === "object" && options !== null && "organizationId" in options && typeof options.organizationId === "string") {
-      console.warn(
-        "[@ragable/sdk] createClient: `apiKey` is set, so the server client is returned. It has no `database` or `auth` \u2014 only `agents` and `shift`. For `db.collections.<name>` / `database.from()` / `auth.*`, use the browser client without `apiKey` (e.g. createClient({ organizationId, authGroupId, databaseInstanceId, ... }))."
-      );
-    }
-    return new Ragable(options);
-  }
-  if (typeof options === "object" && options !== null && "organizationId" in options && typeof options.organizationId === "string") {
-    return createBrowserClient(
-      options
-    );
-  }
-  throw new Error(
-    "createClient(options) requires apiKey (server) or organizationId (browser)"
-  );
-}
-function createRagableServerClient(options) {
-  return new Ragable(options);
+  return createBrowserClient(options);
 }
 export {
-  AgentsClient,
   AuthBroadcastChannel,
+  BrowserStorageBucketClient,
   CookieStorageAdapter,
   DEFAULT_RAGABLE_API_BASE,
   LocalStorageAdapter,
@@ -3806,43 +4186,43 @@ export {
   PostgrestUpdateRootBuilder,
   PostgrestUpsertReturningBuilder,
   PostgrestUpsertRootBuilder,
-  Ragable,
   RagableAbortError,
   RagableAuth,
   RagableBrowser,
   RagableBrowserAgentsClient,
+  RagableBrowserAiClient,
   RagableBrowserAuthClient,
   RagableBrowserDatabaseClient,
+  RagableBrowserStorageClient,
   RagableError,
   RagableNetworkError,
-  RagableRequestClient,
   RagableSdkError,
   RagableTimeoutError,
   SessionStorageAdapter,
-  ShiftClient,
-  StorageClient,
   Transport,
   asPostgrestResponse,
   assertPostgrestSuccess,
   bindFetch,
+  buildInferenceRequestBody,
+  buildResponseFormat,
   collectAssistantTextFromUiSegments,
   collectionRecordToRowWithMeta,
   collectionRecordsToRowWithMeta,
   createBrowserClient,
   createClient,
-  createRagPipeline,
   createRagableBrowserClient,
-  createRagableServerClient,
+  createStreamResultFromParts,
   detectStorage,
   effectiveDataAuth,
   extractErrorMessage,
   finalizeAgentChatUiTurn,
   foldAgentStreamIntoUiSegments,
   formatPostgrestError,
-  formatRetrievalContext,
   formatSdkError,
   generateIdempotencyKey,
   isIncompleteAgentStreamError,
+  mapAgentEvent,
+  mapFireworksChunk,
   normalizeBrowserApiBase,
   parseAgentStreamAgentInfo,
   parseAgentStreamDone,
@@ -3852,7 +4232,10 @@ export {
   runAgentChatStream,
   runAgentChatStreamForUi,
   runAgentChatStreamLenient,
+  streamObjectFromContext,
   toRagableResult,
-  unwrapPostgrest
+  tryParsePartialJson,
+  unwrapPostgrest,
+  wrapStreamTextAsObject
 };
 //# sourceMappingURL=index.mjs.map