Criar uma resposta de chat

POSThttps://ai.inovacc.dev/v1/chat/completions

Gera a próxima mensagem de uma conversa, no formato chat-completions da OpenAI.

Parâmetros do corpo

messagesarrayobrigatório
A conversa: objetos com um role (system, user, assistant ou tool) e um content, que pode ser uma string ou um array de partes text e image_url. No máximo 20 imagens.
modelstring
Um id de rota de GET /v1/models. auto, ou nenhum valor, usa a rota padrão da sua organização.
streamboolean
true envia a resposta como server-sent events, terminando com data: [DONE].
stream_optionsobject
Com {"include_usage": true}, o stream termina com um chunk que traz a contagem de tokens.
max_tokensinteger
O máximo de tokens de saída que você quer. Ele só pode reduzir o teto definido pela sua rota e pela sua organização.
max_completion_tokensinteger
O mesmo que max_tokens, sob o nome mais novo.
temperaturenumber
Temperatura de amostragem, repassada ao modelo.
top_pnumber
Amostragem nucleus, repassada ao modelo.
stopstring | array
Sequências que encerram a resposta.
presence_penaltynumber
Penalidade por repetir assuntos, repassada ao modelo.
frequency_penaltynumber
Penalidade por repetir tokens, repassada ao modelo.
logit_biasobject
Vieses de tokens, repassados ao modelo.
logprobsboolean
Pede as probabilidades logarítmicas dos tokens de saída.
top_logprobsinteger
Quantas alternativas por token devolver junto com logprobs.
toolsarray
Funções que o modelo pode chamar. Algumas rotas aceitam um conjunto menor de campos e o recusam (unsupported_field_for_route).
tool_choicestring | object
Se o modelo deve chamar uma ferramenta e qual.
parallel_tool_callsboolean
Se o modelo pode chamar várias ferramentas ao mesmo tempo.
response_formatobject
O formato da saída, por exemplo {"type": "json_object"}.
seedinteger
Uma semente para uma amostragem mais repetível.
reasoning_effortstring
Quanto o modelo deve raciocinar, nos modelos que raciocinam.
verbositystring
Quão longa deve ser a resposta do modelo, nos modelos que oferecem suporte.
userstring
O id do seu usuário final. Antes de sair da Inovacc, é substituído por um valor derivado da sua organização.
safety_identifierstring
Um id estável do seu usuário final para fins de segurança; derivado da sua organização como user.
prompt_cache_keystring
Uma chave que agrupa requisições para cache; derivada da sua organização como user.
predictionobject
Conteúdo de saída previsto, repassado ao modelo.
ninteger
Aceito apenas quando sua organização recebeu autorização para este campo (403 field_not_allowed caso contrário).
service_tierstring
Aceito apenas quando sua organização recebeu autorização para este campo (403 field_not_allowed caso contrário).
storeboolean
Aceito apenas quando sua organização recebeu autorização para este campo (403 field_not_allowed caso contrário).
metadataobject
Aceito apenas quando sua organização recebeu autorização para este campo (403 field_not_allowed caso contrário).
modalitiesarray
Aceito apenas quando sua organização recebeu autorização para este campo (403 field_not_allowed caso contrário).
audioobject
Aceito apenas quando sua organização recebeu autorização para este campo (403 field_not_allowed caso contrário).
web_search_optionsobject
Aceito apenas quando sua organização recebeu autorização para este campo (403 field_not_allowed caso contrário).

Cabeçalhos

Authorizationstringobrigatório
Bearer <chave de API>
X-Operation-Idstringobrigatório
um id único que você escolhe, em toda chamada exceto GET
Content-Typestringobrigatório
application/json, em uma chamada com corpo

Veja também

Detalhes da fonte

Entrada do catálogo

Id: identity/component-taxonomy/capabilities#ai.chat
Repositório: identity
Caminho: contracts/component-taxonomy/catalog/capabilities.json
Commit: 08ef3cd75d82

Seção do contrato

Id: ai/ai/contract#post-v1chatcompletions
Repositório: ai
Caminho: apps/cloudflare/workers/api/ai/CONTRACT.md
Commit: 972a1c15b9d5
Versão documentada: 2.37.0
Versão em produção: 2.14.0

Requisição em cURLExemplo

cURL

1
2
3
4
5
6
7
8
9
10
11
12
13curl -X POST "https://ai.inovacc.dev/v1/chat/completions" \
  -H "Authorization: Bearer $INOVACC_API_KEY" \
  -H "X-Operation-Id: $(uuidgen)" \
  -H "Content-Type: application/json" \
  -d '{
  "model": "r00",
  "messages": [
    {
      "role": "user",
      "content": "hello"
    }
  ]
}'

TypeScript

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25import crypto from "node:crypto";

const body: Record<string, unknown> = {
  "model": "r00",
  "messages": [
    {
      "role": "user",
      "content": "hello"
    }
  ]
};

const url = "https://ai.inovacc.dev/v1/chat/completions";

const response = await fetch(url, {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.INOVACC_API_KEY}`,
    "X-Operation-Id": crypto.randomUUID(),
    "Content-Type": "application/json",
  },
  body: JSON.stringify(body),
});

console.log(response.status, await response.text());

Python

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29import json
import os
import urllib.request
import uuid

body = {
    "model": "r00",
    "messages": [
        {
            "role": "user",
            "content": "hello",
        },
    ],
}

request = urllib.request.Request(
    "https://ai.inovacc.dev/v1/chat/completions",
    data=json.dumps(body).encode(),
    method="POST",
    headers={
        "User-Agent": "inovacc-python-sample",
        "Authorization": "Bearer " + os.environ["INOVACC_API_KEY"],
        "X-Operation-Id": str(uuid.uuid4()),
        "Content-Type": "application/json",
    },
)

with urllib.request.urlopen(request) as response:
    print(response.status, response.read().decode())

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55package main

import (
	"crypto/rand"
	"fmt"
	"io"
	"net/http"
	"os"
	"strings"
)

const url = "https://ai.inovacc.dev/v1/chat/completions"

const body = `{
  "model": "r00",
  "messages": [
    {
      "role": "user",
      "content": "hello"
    }
  ]
}`

// newUUID returns a random (version 4) UUID, from the standard library alone.
func newUUID() string {
	b := make([]byte, 16)
	if _, err := rand.Read(b); err != nil {
		panic(err)
	}
	b[6] = b[6]&0x0f | 0x40
	b[8] = b[8]&0x3f | 0x80
	return fmt.Sprintf("%x-%x-%x-%x-%x", b[0:4], b[4:6], b[6:8], b[8:10], b[10:])
}

func main() {
	req, err := http.NewRequest("POST", url, strings.NewReader(body))
	if err != nil {
		panic(err)
	}
	req.Header.Set("Authorization", "Bearer "+os.Getenv("INOVACC_API_KEY"))
	req.Header.Set("X-Operation-Id", newUUID())
	req.Header.Set("Content-Type", "application/json")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()

	out, err := io.ReadAll(res.Body)
	if err != nil {
		panic(err)
	}
	fmt.Println(res.Status, string(out))
}

Rust

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24// Cargo.toml: reqwest = { version = "0.12", features = ["blocking", "json"] }
// Cargo.toml: serde_json = "1"
// Cargo.toml: uuid = { version = "1", features = ["v4"] }

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("INOVACC_API_KEY")?;
    let body = serde_json::json!({
        "model": "r00",
        "messages": [
            {
                "role": "user",
                "content": "hello"
            }
        ]
    });
    let response = reqwest::blocking::Client::new()
        .post("https://ai.inovacc.dev/v1/chat/completions")
        .bearer_auth(api_key)
        .header("X-Operation-Id", uuid::Uuid::new_v4().to_string())
        .json(&body)
        .send()?;
    println!("{} {}", response.status(), response.text()?);
    Ok(())
}

JavaScript

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25import crypto from "node:crypto";

const body = {
  "model": "r00",
  "messages": [
    {
      "role": "user",
      "content": "hello"
    }
  ]
};

const url = "https://ai.inovacc.dev/v1/chat/completions";

const response = await fetch(url, {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.INOVACC_API_KEY}`,
    "X-Operation-Id": crypto.randomUUID(),
    "Content-Type": "application/json",
  },
  body: JSON.stringify(body),
});

console.log(response.status, await response.text());

PHP

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37<?php

$body = <<<'JSON'
{
  "model": "r00",
  "messages": [
    {
      "role": "user",
      "content": "hello"
    }
  ]
}
JSON;

function uuid4(): string
{
    $bytes = random_bytes(16);
    $bytes[6] = chr(ord($bytes[6]) & 0x0f | 0x40);
    $bytes[8] = chr(ord($bytes[8]) & 0x3f | 0x80);
    return vsprintf('%s%s-%s-%s-%s-%s%s%s', str_split(bin2hex($bytes), 4));
}

$curl = curl_init('https://ai.inovacc.dev/v1/chat/completions');
curl_setopt_array($curl, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer ' . getenv('INOVACC_API_KEY'),
        'X-Operation-Id: ' . uuid4(),
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => $body,
]);

$response = curl_exec($curl);
echo curl_getinfo($curl, CURLINFO_HTTP_CODE), ' ', $response, "\n";
curl_close($curl);

Ruby

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28require "net/http"
require "securerandom"
require "uri"

uri = URI('https://ai.inovacc.dev/v1/chat/completions')
body = <<~'JSON'
{
  "model": "r00",
  "messages": [
    {
      "role": "user",
      "content": "hello"
    }
  ]
}
JSON

request = Net::HTTP::Post.new(uri)
request["Authorization"] = "Bearer #{ENV.fetch('INOVACC_API_KEY')}"
request["X-Operation-Id"] = SecureRandom.uuid
request["Content-Type"] = "application/json"
request.body = body

response = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https") do |http|
  http.request(request)
end

puts "#{response.code} #{response.body}"

Java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.util.UUID;

public class Main {
    public static void main(String[] args) throws Exception {
        String apiKey = System.getenv("INOVACC_API_KEY");
        String body = "{" +
                "\"model\": \"r00\"," +
                "\"messages\": [" +
                "{" +
                "\"role\": \"user\"," +
                "\"content\": \"hello\"" +
                "}" +
                "]" +
                "}";

        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://ai.inovacc.dev/v1/chat/completions"))
                .header("Authorization", "Bearer " + apiKey)
                .header("X-Operation-Id", UUID.randomUUID().toString())
                .header("Content-Type", "application/json")
                .method("POST", HttpRequest.BodyPublishers.ofString(body))
                .build();

        HttpResponse<String> response = HttpClient.newHttpClient()
                .send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.statusCode() + " " + response.body());
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23using System.Text;

var body = "{" +
    "\"model\": \"r00\"," +
    "\"messages\": [" +
    "{" +
    "\"role\": \"user\"," +
    "\"content\": \"hello\"" +
    "}" +
    "]" +
    "}";

var url = "https://ai.inovacc.dev/v1/chat/completions";
var apiKey = Environment.GetEnvironmentVariable("INOVACC_API_KEY");

using var client = new HttpClient();
using var request = new HttpRequestMessage(HttpMethod.Post, url);
request.Headers.Add("Authorization", $"Bearer {apiKey}");
request.Headers.Add("X-Operation-Id", Guid.NewGuid().ToString());
request.Content = new StringContent(body, Encoding.UTF8, "application/json");

using var response = await client.SendAsync(request);
Console.WriteLine($"{(int)response.StatusCode} {await response.Content.ReadAsStringAsync()}");

Kotlin

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30import java.net.URI
import java.net.http.HttpClient
import java.net.http.HttpRequest
import java.net.http.HttpResponse
import java.util.UUID

fun main() {
    val apiKey = System.getenv("INOVACC_API_KEY")
    val body = "{" +
        "\"model\": \"r00\"," +
        "\"messages\": [" +
        "{" +
        "\"role\": \"user\"," +
        "\"content\": \"hello\"" +
        "}" +
        "]" +
        "}"

    val request = HttpRequest.newBuilder()
        .uri(URI.create("https://ai.inovacc.dev/v1/chat/completions"))
        .header("Authorization", "Bearer " + apiKey)
        .header("X-Operation-Id", UUID.randomUUID().toString())
        .header("Content-Type", "application/json")
        .method("POST", HttpRequest.BodyPublishers.ofString(body))
        .build()

    val response = HttpClient.newHttpClient()
        .send(request, HttpResponse.BodyHandlers.ofString())
    println("${response.statusCode()} ${response.body()}")
}

Swift

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30import Foundation
#if canImport(FoundationNetworking)
import FoundationNetworking
#endif

let body = #"""
{
  "model": "r00",
  "messages": [
    {
      "role": "user",
      "content": "hello"
    }
  ]
}
"""#

let apiKey = ProcessInfo.processInfo.environment["INOVACC_API_KEY"] ?? ""

let url = URL(string: "https://ai.inovacc.dev/v1/chat/completions")!
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")
request.setValue(UUID().uuidString, forHTTPHeaderField: "X-Operation-Id")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = Data(body.utf8)

let (data, response) = try await URLSession.shared.data(for: request)
let status = (response as? HTTPURLResponse)?.statusCode ?? 0
print(status, String(decoding: data, as: UTF8.self))

Exemplo

200

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21{
  "id": "chatcmpl-client_op_00000001",
  "object": "chat.completion",
  "created": 1790000000,
  "model": "r00",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "hi there"
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 10,
    "completion_tokens": 5,
    "total_tokens": 15
  }
}

400

Códigos de erro: missing_operation_id invalid_operation_id invalid_body invalid_messages unsupported_field unsupported_field_for_route model_not_allowed input_too_large

401

Códigos de erro: missing_credentials invalid_credentials

403

Códigos de erro: key_disabled organization_disabled field_not_allowed route_forbidden

409

Códigos de erro: operation_in_progress

413

Códigos de erro: request_too_large

429

Códigos de erro: rate_limited quota_exceeded concurrency_limited budget_exhausted

502

Códigos de erro: upstream_error

503

Códigos de erro: service_unavailable route_unavailable

504

Códigos de erro: timeout_error