Continua AI API documentation

https://app.askcontinua.com/api/v1

Authorization: Bearer YOUR_CONTINUA_AI_API_TOKEN

export CONTINUA_AI_API_KEY="YOUR_CONTINUA_AI_API_TOKEN"
export CONTINUA_AI_API_BASE_URL="https://app.askcontinua.com/api/v1"

import os
import time
from uuid import uuid4

from openai import OpenAI

client = OpenAI(
    api_key=os.environ["CONTINUA_AI_API_KEY"],
    base_url=os.environ["CONTINUA_AI_API_BASE_URL"].rstrip("/"),
)

uploaded_file = client.files.create(
    file=("hello.txt", b"Hello world.", "text/plain"),
    purpose="user_data",
)

response = client.responses.create(
    model="deepseek-flash",
    background=True,
    input=[
        {
            "role": "user",
            "content": [
                {"type": "input_file", "file_id": uploaded_file.id},
                {"type": "input_text", "text": "Summarize this file in one sentence."},
            ],
        }
    ],
    extra_headers={"Idempotency-Key": f"response-{uuid4().hex}"},
)

terminal_statuses = {"completed", "failed", "cancelled"}

while response.status not in terminal_statuses:
    time.sleep(5)
    response = client.responses.retrieve(response.id)

if response.status != "completed":
    raise RuntimeError(f"Response ended with status={response.status}")

print(response.output_text)

import { randomUUID } from "node:crypto";
import OpenAI, { toFile } from "openai";

const client = new OpenAI({
  apiKey: process.env.CONTINUA_AI_API_KEY!,
  baseURL: process.env.CONTINUA_AI_API_BASE_URL!.replace(/\/$/, ""),
});

const uploadedFile = await client.files.create({
  file: await toFile(Buffer.from("Hello world."), "hello.txt", { type: "text/plain" }),
  purpose: "user_data",
});

let response = await client.responses.create(
  {
    model: "deepseek-flash",
    background: true,
    input: [
      {
        role: "user",
        content: [
          { type: "input_file", file_id: uploadedFile.id },
          { type: "input_text", text: "Summarize this file in one sentence." },
        ],
      },
    ],
  },
  { headers: { "Idempotency-Key": `response-${randomUUID()}` } },
);

const terminalStatuses = new Set(["completed", "failed", "cancelled"]);

while (!terminalStatuses.has(response.status)) {
  await new Promise((resolve) => setTimeout(resolve, 5000));
  response = await client.responses.retrieve(response.id);
}

if (response.status !== "completed") {
  throw new Error(`Response ended with status=${response.status}`);
}

console.log(response.output_text);

.txt, .md, .markdown, .json, .pdf, .docx, .xlsx, .csv,
.eml, .msg, .pptx, .html, .htm, .xhtml

curl --request POST \
  "${CONTINUA_AI_API_BASE_URL}/files" \
  --header "Authorization: Bearer ${CONTINUA_AI_API_KEY}" \
  --form "purpose=user_data" \
  --form "file=@report.pdf"

{
  "id": "file_1234567890abcdef",
  "object": "file",
  "bytes": 24831,
  "created_at": 1789344000,
  "expires_at": 1789430400,
  "filename": "report.pdf",
  "purpose": "user_data",
  "status": "processed"
}

Idempotency-Key: response-7c86b96c5a4d48c58bbdb6bca75e1098

{
  "model": "deepseek-flash",
  "background": true,
  "input": [
    {
      "role": "user",
      "content": [
        { "type": "input_file", "file_id": "file_1234567890abcdef" },
        { "type": "input_text", "text": "Summarize the main risks in this document." }
      ]
    }
  ]
}

{
  "model": "deepseek-flash",
  "background": true,
  "previous_response_id": "resp_1234567890abcdef",
  "input": "Which of these risks should we address first?"
}

from uuid import uuid4

response = client.responses.create(
    model="deepseek-flash",
    background=True,
    input="Identify the most material risks in this project.",
    extra_body={
        "report": {
            "project_ids": ["project_1234567890abcdef"],
            "findings_criteria": "Material risks supported by source evidence",
            "composition_criteria": "Present a concise, prioritized report",
            "guardrail_mode": "lite",
        }
    },
    extra_headers={"Idempotency-Key": f"project-{uuid4().hex}"},
)

{
  "id": "resp_1234567890abcdef",
  "object": "response",
  "created_at": 1789344000,
  "status": "queued",
  "previous_response_id": null,
  "background": true,
  "output_text": "",
  "output": [],
  "error": null
}

curl \
  "${CONTINUA_AI_API_BASE_URL}/responses/${RESPONSE_ID}" \
  --header "Authorization: Bearer ${CONTINUA_AI_API_KEY}"

{
  "id": "resp_1234567890abcdef",
  "object": "response",
  "created_at": 1789344000,
  "status": "completed",
  "previous_response_id": null,
  "background": true,
  "output_text": "The document identifies supplier concentration as its primary risk.",
  "output": [
    {
      "id": "msg_1234567890abcdef",
      "type": "message",
      "role": "assistant",
      "status": "completed",
      "content": [
        {
          "type": "output_text",
          "text": "The document identifies supplier concentration as its primary risk.",
          "annotations": [],
          "logprobs": []
        }
      ]
    }
  ],
  "report": {
    "findings": [
      {
        "finding_index": 1,
        "record_id": "record_1234567890abcdef",
        "claim": "The company relies on one supplier for most critical components.",
        "quote": "Our primary supplier provides most critical components.",
        "document": "report.pdf",
        "position": "p.12",
        "relevance": 0.97,
        "confidence": 0.94,
        "evidence": 0.91,
        "materiality": 0.89
      }
    ],
    "billing": {
      "billing": "charged",
      "charged": 0.42,
      "metered": 0.42,
      "llm_cost": 0.31,
      "platform_fee": 0.11
    }
  },
  "error": null
}

import time
from uuid import uuid4

follow_up = client.responses.create(
    model="deepseek-flash",
    background=True,
    previous_response_id=response.id,
    input="Give me one concise recommendation based on the findings.",
    extra_headers={"Idempotency-Key": f"follow-up-{uuid4().hex}"},
)

while follow_up.status not in {"completed", "failed", "cancelled"}:
    time.sleep(5)
    follow_up = client.responses.retrieve(follow_up.id)

if follow_up.status != "completed":
    raise RuntimeError(f"Follow-up ended with status={follow_up.status}")

print(follow_up.output_text)

import { randomUUID } from "node:crypto";

let followUp = await client.responses.create(
  {
    model: "deepseek-flash",
    background: true,
    previous_response_id: response.id,
    input: "Give me one concise recommendation based on the findings.",
  },
  { headers: { "Idempotency-Key": `follow-up-${randomUUID()}` } },
);

while (!["completed", "failed", "cancelled"].includes(followUp.status)) {
  await new Promise((resolve) => setTimeout(resolve, 5000));
  followUp = await client.responses.retrieve(followUp.id);
}

if (followUp.status !== "completed") {
  throw new Error(`Follow-up ended with status=${followUp.status}`);
}

console.log(followUp.output_text);

curl \
  "${CONTINUA_AI_API_BASE_URL}/responses?limit=10&status=completed,failed" \
  --header "Authorization: Bearer ${CONTINUA_AI_API_KEY}"

{
  "responses": [
    {
      "id": "resp_1234567890abcdef",
      "object": "response",
      "status": "completed",
      "created_at": 1789344000,
      "last_updated_at": 1789344060
    }
  ],
  "next_cursor": "eyJzY2hlbWEiOiIuLi4ifQ"
}

{
  "error": {
    "message": "The response is not complete.",
    "type": "invalid_request_error",
    "param": "previous_response_id",
    "code": "response_not_complete"
  }
}