Chat completions

"tk-cmd">curl https://api.relane.ai/v1/chat/completions \
  "tk-flag">-H "Authorization: Bearer rl_sk_live_YOUR_KEY" \
  "tk-flag">-H "Content-Type: application/json" \
  "tk-flag">-d '{
    "model": "MODEL_ID",
    "messages": [
      { "role": "user", "content": "Summarise this changelog entry in one sentence." }
    ]
  }'

const res = await fetch(class="tk-str">"https:class="tk-commentclass="tk-str">">//api.relane.ai/v1/chat/completions", {
  method: class="tk-str">"POST",
  headers: {
    Authorization: class="tk-str">`Bearer ${process.env.RELANE_API_KEY}`,
    class="tk-str">"Content-Type": class="tk-str">"application/json",
  },
  body: JSON.stringify({
    model: modelId, class=class="tk-str">"tk-comment">// from GET /v1/models
    messages: [{ role: class="tk-str">"user", content: class="tk-str">"Summarise this changelog entry in one sentence." }],
  }),
});

if (!res.ok) {
  const { error } = await res.json();
  throw new Error(class="tk-str">`${error.type} (${error.code}): ${error.message}`);
}

const completion = await res.json();
console.log(completion.choices[0].message.content);

function createSseParser() {
  const decoder = new TextDecoder();
  let buffer = class="tk-str">"";

  function parseEvent(raw) {
    class=class="tk-str">"tk-comment">// An SSE event may carry several data: lines; the spec joins them with a newline.
    const data = raw
      .split(class="tk-str">"\n")
      .filter((line) => line.startsWith(class="tk-str">"data:"))
      .map((line) => line.slice(5).trimStart())
      .join(class="tk-str">"\n");
    if (!data || data === class="tk-str">"[DONE]") return null;
    return JSON.parse(data);
  }

  function drain(flush) {
    class=class="tk-str">"tk-comment">// Normalise framing so a CRLF stream parses identically to an LF one. Safe on the payload:
    class=class="tk-str">"tk-comment">// JSON escapes newlines inside strings, so a raw CR LF here is always framing.
    buffer = buffer.replace(/\r\n/g, class="tk-str">"\n");

    const events = [];
    let sep;
    while ((sep = buffer.indexOf(class="tk-str">"\n\n")) !== -1) {
      const raw = buffer.slice(0, sep);
      buffer = buffer.slice(sep + 2);
      const event = parseEvent(raw);
      if (event) events.push(event);
    }
    class=class="tk-str">"tk-comment">// At end of stream, accept a final event that never got its blank line.
    if (flush && buffer.trim()) {
      const raw = buffer;
      buffer = class="tk-str">"";
      const event = parseEvent(raw);
      if (event) events.push(event);
    }
    return events;
  }

  return {
    class=class="tk-str">"tk-comment">// Feed one network chunk (Uint8Array); returns the events it completed.
    push(chunk) {
      class=class="tk-str">"tk-comment">// stream: true holds a split multi-byte character in the decoder until its remaining
      class=class="tk-str">"tk-comment">// bytes arrive, instead of emitting a replacement character.
      buffer += decoder.decode(chunk, { stream: true });
      return drain(false);
    },
    class=class="tk-str">"tk-comment">// Call once the body ends, to flush the decoder and any trailing event.
    end() {
      buffer += decoder.decode();
      return drain(true);
    },
  };
}

const res = await fetch(class="tk-str">"https:class="tk-commentclass="tk-str">">//api.relane.ai/v1/chat/completions", {
  method: class="tk-str">"POST",
  headers: {
    Authorization: class="tk-str">`Bearer ${process.env.RELANE_API_KEY}`,
    class="tk-str">"Content-Type": class="tk-str">"application/json",
  },
  body: JSON.stringify({ model: modelId, messages, stream: true }),
});

class=class="tk-str">"tk-comment">// A non-200 fails before the stream opens.
if (!res.ok) {
  const { error } = await res.json();
  throw new Error(class="tk-str">`${error.type} (${error.code}): ${error.message}`);
}

const parser = createSseParser();
const reader = res.body.getReader();
let text = class="tk-str">"";

for (;;) {
  const { done, value } = await reader.read();
  if (done) break;
  for (const event of parser.push(value)) {
    class=class="tk-str">"tk-comment">// A 200 that later fails is still a failure. Raise rather than returning a truncated answer.
    assertNotStreamError(event);
    text += event.choices[0]?.delta?.content ?? class="tk-str">"";
  }
}

class=class="tk-str">"tk-comment">// Flush anything the stream ended on — including a final error event.
for (const event of parser.end()) {
  assertNotStreamError(event);
  text += event.choices[0]?.delta?.content ?? class="tk-str">"";
}

"tk-cmd">curl https://api.relane.ai/v1/chat/completions \
  "tk-flag">-H "Authorization: Bearer rl_sk_live_YOUR_KEY" \
  "tk-flag">-H "Content-Type: application/json" \
  "tk-flag">-d '{
    "model": "MODEL_ID",
    "messages": [{ "role": "user", "content": "What is the build status?" }],
    "tools": [
      {
        "type": "function",
        "function": {
          "name": "get_build_status",
          "description": "Return the status of the most recent build.",
          "parameters": {
            "type": "object",
            "properties": { "branch": { "type": "string" } },
            "required": ["branch"]
          }
        }
      }
    ],
    "tool_choice": "auto"
  }'

"tk-cmd">curl https://api.relane.ai/v1/chat/completions \
  "tk-flag">-H "Authorization: Bearer rl_sk_live_YOUR_KEY" \
  "tk-flag">-H "Content-Type: application/json" \
  "tk-flag">-d '{
    "model": "MODEL_ID",
    "messages": [
      { "role": "user", "content": "What changed in the TLS 1.3 spec most recently?" }
    ],
    "web_search_options": {
      "search_context_size": "medium",
      "user_location": {
        "type": "approximate",
        "country": "TR",
        "timezone": "Europe/Istanbul"
      }
    }
  }'

class=class="tk-str">"tk-comment">// content becomes an ARRAY of parts when a message carries more than text.
const res = await fetch(class="tk-str">"https:class="tk-commentclass="tk-str">">//api.relane.ai/v1/chat/completions", {
  method: class="tk-str">"POST",
  headers: {
    Authorization: class="tk-str">`Bearer ${process.env.RELANE_API_KEY}`,
    class="tk-str">"Content-Type": class="tk-str">"application/json",
  },
  body: JSON.stringify({
    model: modelId, class=class="tk-str">"tk-comment">// must be an entry whose supports_images is true
    messages: [
      {
        role: class="tk-str">"user",
        content: [
          { type: class="tk-str">"text", text: class="tk-str">"Which library produced this error, and is it patched?" },
          { type: class="tk-str">"image_url", image_url: { url: class="tk-str">"https:class="tk-commentclass="tk-str">">//example.com/screenshot.png" } },
        ],
      },
    ],
    web_search_options: { search_context_size: class="tk-str">"high" },
  }),
});

const completion = await res.json();
const message = completion.choices[0].message;

class=class="tk-str">"tk-comment">// Citations index into the final message text, so slice with them rather than
class=class="tk-str">"tk-comment">// re-searching the string.
const body = typeof message.content === class="tk-str">"string" ? message.content : class="tk-str">"";
for (const a of message.annotations ?? []) {
  if (a.type !== class="tk-str">"url_citation" || !a.url_citation) continue;
  const { url, title, start_index, end_index } = a.url_citation;
  const quoted = body.slice(start_index, end_index);
  console.log(class="tk-str">`class="tk-str">"${quoted}" — ${title ?? url} (${url})`);
}

class=class="tk-str">"tk-comment">// What the model actually did, kept separate from the citations above.
for (const call of message.relane_web_search ?? []) {
  if (call.type === class="tk-str">"search") console.log(class="tk-str">"searched:", call.query ?? call.queries?.join(class="tk-str">", "));
  if (call.type === class="tk-str">"open_page") console.log(class="tk-str">"opened:", call.url);
  if (call.type === class="tk-str">"find_in_page") console.log(class="tk-str">"looked for:", call.pattern, class="tk-str">"in", call.url);
}