Build on Lornos

Authorization: Bearer lrn_…

{
  "messages": [
    {
      "id": "q1",
      "role": "user",
      "parts": [
        {
          "type": "text",
          "text": "How do I record a sale?"
        }
      ]
    }
  ]
}

curl -N "$LORNOS_URL/api/chat" \
  -H "Authorization: Bearer $LORNOS_KEY" \
  -H "Content-Type: application/json" \
  -d '{"messages":[{"id":"q1","role":"user","parts":[{"type":"text","text":"How do I record a sale?"}]}]}'

data: {"type":"start"}

data: {"type":"start-step"}

data: {"type":"text-start","id":"0"}

data: {"type":"text-delta","id":"0","delta":"Open Sales and choose New sale "}

data: {"type":"text-delta","id":"0","delta":"[record-a-sale.md#1.0]."}

data: {"type":"text-end","id":"0"}

data: {"type":"finish-step"}

data: {"type":"finish","finishReason":"stop"}

data: [DONE]

type UIMessage = {
  id: string
  role: 'user' | 'assistant'
  parts: { type: 'text'; text: string }[]
}

// Sends the conversation and returns the answer text and the chunk IDs it cites.
export async function ask(messages: UIMessage[]) {
  const response = await fetch(`${process.env.LORNOS_URL}/api/chat`, {
    method: 'POST',
    headers: {
      Authorization: `Bearer ${process.env.LORNOS_KEY}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({ messages }),
  })
  if (!response.ok) throw new Error(`Lornos answered ${response.status}: ${await response.text()}`)

  const reader = response.body!.pipeThrough(new TextDecoderStream()).getReader()
  let buffer = ''
  let answer = ''
  for (;;) {
    const { value, done } = await reader.read()
    if (done) break
    buffer += value
    const lines = buffer.split('\n')
    buffer = lines.pop() ?? ''
    for (const line of lines) {
      if (!line.startsWith('data: ') || line === 'data: [DONE]') continue
      const event = JSON.parse(line.slice('data: '.length))
      if (event.type === 'text-delta') answer += event.delta
      if (event.type === 'error') throw new Error(event.errorText)
    }
  }

  const citations = [...new Set(answer.match(/[A-Za-z0-9][A-Za-z0-9._-]*#[A-Za-z0-9](?:[A-Za-z0-9._-]*[A-Za-z0-9])?/g) ?? [])]
  return { answer, citations }
}

{
  "messages": [
    {
      "id": "q1",
      "role": "user",
      "parts": [
        {
          "type": "text",
          "text": "How do I record a sale?"
        }
      ]
    },
    {
      "id": "a1",
      "role": "assistant",
      "parts": [
        {
          "type": "text",
          "text": "Open Sales and choose New sale. [record-a-sale.md#1.0]"
        }
      ]
    },
    {
      "id": "q2",
      "role": "user",
      "parts": [
        {
          "type": "text",
          "text": "Can I undo it afterwards?"
        }
      ]
    }
  ]
}

{
  "id": "6f1c2d3e-8a4b-4c5d-9e6f-7a8b9c0d1e2f",
  "filename": "returns-policy.pdf",
  "status": "pending_upload",
  "upload": {
    "url": "https://…signed upload URL…",
    "method": "PUT",
    "headers": { "Content-Type": "application/pdf" }
  },
  "expiresAt": "2026-11-02T18:40:00.000Z"
}

# 1. Create the source and get an upload URL
curl "$LORNOS_URL/api/v1/sources" \
  -H "Authorization: Bearer $LORNOS_KEY" \
  -H "Content-Type: application/json" \
  -d '{"filename":"returns-policy.pdf","contentType":"application/pdf","size":482113}'

# 2. PUT the file to upload.url, with exactly the headers in upload.headers
curl -X PUT "<upload.url>" \
  -H "Content-Type: application/pdf" \
  --data-binary @returns-policy.pdf

# 3. Tell Lornos the upload finished; indexing starts
curl -X POST "$LORNOS_URL/api/v1/sources/<id>/complete" \
  -H "Authorization: Bearer $LORNOS_KEY"

import { readFile, stat } from 'node:fs/promises'
import path from 'node:path'

const base = process.env.LORNOS_URL
const auth = { Authorization: `Bearer ${process.env.LORNOS_KEY}` }

async function lornos(pathname: string, init: RequestInit = {}) {
  const response = await fetch(`${base}${pathname}`, { ...init, headers: { ...auth, ...init.headers } })
  if (!response.ok) {
    const { error } = await response.json()
    throw new Error(`${response.status} ${error.code}: ${error.message}`)
  }
  return response.status === 204 ? null : response.json()
}

export async function uploadDocument(file: string, contentType: string) {
  const { size } = await stat(file)

  // 1. Create the source.
  const source = await lornos('/api/v1/sources', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ filename: path.basename(file), contentType, size }),
  })

  // 2. Upload the bytes to the signed URL (valid until source.expiresAt).
  const put = await fetch(source.upload.url, {
    method: source.upload.method,
    headers: source.upload.headers,
    body: await readFile(file),
  })
  if (!put.ok) throw new Error(`Upload failed with ${put.status}`)

  // 3. Complete: Lornos checks the file and starts indexing.
  await lornos(`/api/v1/sources/${source.id}/complete`, { method: 'POST' })
  return source.id as string
}

// Poll until the source is searchable or has failed.
export async function waitForIndexing(id: string) {
  for (;;) {
    const source = await lornos(`/api/v1/sources/${id}`)
    if (source.status === 'indexed') return source
    if (source.status === 'failed') throw new Error(source.error ?? 'Indexing failed')
    await new Promise((resolve) => setTimeout(resolve, 3000))
  }
}

{
  "id": "6f1c2d3e-8a4b-4c5d-9e6f-7a8b9c0d1e2f",
  "filename": "returns-policy.pdf",
  "title": "Returns policy",
  "status": "indexed",
  "error": null,
  "passages": 14,
  "embedded": 14,
  "createdAt": "2026-11-02T18:30:00.000Z",
  "indexedAt": "2026-11-02T18:30:21.000Z"
}

# All sources (newest first)
curl "$LORNOS_URL/api/v1/sources" -H "Authorization: Bearer $LORNOS_KEY"

# One source
curl "$LORNOS_URL/api/v1/sources/<id>" -H "Authorization: Bearer $LORNOS_KEY"

# Index again
curl -X POST "$LORNOS_URL/api/v1/sources/<id>/reindex" -H "Authorization: Bearer $LORNOS_KEY"

# Delete the file and its passages
curl -X DELETE "$LORNOS_URL/api/v1/sources/<id>" -H "Authorization: Bearer $LORNOS_KEY"

{
  "error": {
    "code": "file_too_large",
    "message": "Files can be up to 25 MB."
  }
}

{ "error": { "code": "rate_limited", "message": "…" } }