@ragable/sdk 0.7.7 → 0.7.8

package/dist/index.mjs

@@ -2269,6 +2269,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) {
@@ -2478,7 +2544,7 @@ var ZERO_USAGE = {
   completionTokens: 0,
   totalTokens: 0
 };
-function buildInferenceRequestBody(params) {
+function buildInferenceRequestBody(params, responseFormat) {
   const body = {
     model: params.model,
     messages: params.messages
@@ -2489,8 +2555,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();
@@ -2741,6 +2817,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
@@ -3603,6 +3863,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) {
@@ -3624,12 +3941,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;
     }
@@ -3866,6 +4204,7 @@ export {
   assertPostgrestSuccess,
   bindFetch,
   buildInferenceRequestBody,
+  buildResponseFormat,
   collectAssistantTextFromUiSegments,
   collectionRecordToRowWithMeta,
   collectionRecordsToRowWithMeta,
@@ -3893,7 +4232,10 @@ export {
   runAgentChatStream,
   runAgentChatStreamForUi,
   runAgentChatStreamLenient,
+  streamObjectFromContext,
   toRagableResult,
-  unwrapPostgrest
+  tryParsePartialJson,
+  unwrapPostgrest,
+  wrapStreamTextAsObject
 };
 //# sourceMappingURL=index.mjs.map