Streaming

import httpx
import json

result = {"steps": [], "message": "", "sources": None, "follow_up_questions": None}

with httpx.stream(
    "POST",
    "https://api.persly.ai/v1/chat/completions",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={
        "model": "persly-chat-v1",
        "messages": [{"role": "user", "text": "Explain hypertension treatment."}],
        "stream": True,
    },
) as response:
    if response.status_code != 200:
        response.read()
        payload = response.json()
        if response.status_code == 422:
            first = (payload.get("detail") or [{}])[0]
            raise RuntimeError(
                f"Validation error [{first.get('type', 'value_error')}]: "
                f"{first.get('msg', 'Invalid request parameters')}"
            )
        error = payload.get("error", {})
        raise RuntimeError(
            f"API error [{error.get('code', 'unknown')}]: "
            f"{error.get('message', 'Request failed')}"
        )

    for line in response.iter_lines():
        if not line or not line.startswith("data: "):
            continue
        data = line[6:]
        if data == "[DONE]":
            break
        chunk = json.loads(data)

        if chunk["type"] == "error":
            raise RuntimeError(
                f"Streaming error [{chunk['error']['code']}]: "
                f"{chunk['error']['message']}"
            )
        elif chunk["type"] == "steps":
            result["steps"] = chunk["steps"]  # snapshot: replace
        elif chunk["type"] == "message":
            result["message"] += chunk["content"]  # delta: append
        elif chunk["type"] == "sources":
            result["sources"] = chunk["sources"] or None
        elif chunk["type"] == "follow_up_questions":
            result["follow_up_questions"] = chunk["follow_up_questions"] or None

# `result` is now identical to a non-streaming response
print(result["message"])
for source in (result["sources"] or []):
    print(f"  Source: {source['title']}: {source['url']}")

const result = { steps: [], message: "", sources: null, follow_up_questions: null };

const response = await fetch("https://api.persly.ai/v1/chat/completions", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    model: "persly-chat-v1",
    messages: [{ role: "user", text: "Explain hypertension treatment." }],
    stream: true,
  }),
});

if (!response.ok) {
  const payload = await response.json();
  if (response.status === 422) {
    const first = payload.detail?.[0];
    throw new Error(
      `Validation error [${first?.type ?? "value_error"}]: ${first?.msg ?? "Invalid request parameters"}`
    );
  } else {
    const error = payload?.error ?? {};
    throw new Error(
      `API error [${error.code ?? "unknown"}]: ${error.message ?? "Request failed"}`
    );
  }
}

const reader = response.body.getReader();
const decoder = new TextDecoder();
let buffer = "";
let streamDone = false;

while (!streamDone) {
  const { done, value } = await reader.read();
  if (done) break;

  buffer += decoder.decode(value, { stream: true });
  const lines = buffer.split("\n");
  buffer = lines.pop();

  for (const line of lines) {
    if (!line.startsWith("data: ")) continue;
    const data = line.slice(6);
    if (data === "[DONE]") {
      streamDone = true;
      break;
    }

    const chunk = JSON.parse(data);

    switch (chunk.type) {
      case "error":
        throw new Error(
          `Streaming error [${chunk.error.code}]: ${chunk.error.message}`
        );
      case "steps":
        result.steps = chunk.steps; // snapshot: replace
        break;
      case "message":
        result.message += chunk.content; // delta: append
        break;
      case "sources":
        result.sources = chunk.sources.length > 0 ? chunk.sources : null;
        break;
      case "follow_up_questions":
        result.follow_up_questions =
          chunk.follow_up_questions.length > 0 ? chunk.follow_up_questions : null;
        break;
    }
  }
}

// `result` is now identical to a non-streaming response
console.log(result.message);
for (const source of result.sources ?? []) {
  console.log(`  Source: ${source.title}: ${source.url}`);
}