Crear una respuesta de chat

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

Genera el siguiente mensaje de una conversación, en el formato de chat-completions de OpenAI.

Parámetros del cuerpo

messagesarrayobligatorio
La conversación: objetos con un role (system, user, assistant o tool) y un content, ya sea una cadena o un arreglo de partes text e image_url. Máximo 20 imágenes.
modelstring
Un id de ruta de GET /v1/models. auto, o sin valor, usa la ruta predeterminada de tu organización.
streamboolean
true envía la respuesta como eventos enviados por el servidor, terminando con data: [DONE].
stream_optionsobject
Con {"include_usage": true}, un stream termina con un fragmento que incluye el conteo de tokens.
max_tokensinteger
La mayor cantidad de tokens de salida que quieres. Solo puede bajar el tope que fijan tu ruta y tu organización.
max_completion_tokensinteger
Igual que max_tokens, con el nombre más nuevo.
temperaturenumber
Temperatura de muestreo, enviada al modelo.
top_pnumber
Muestreo por núcleo, enviado al modelo.
stopstring | array
Secuencias que terminan la respuesta.
presence_penaltynumber
Penalización por repetir temas, enviada al modelo.
frequency_penaltynumber
Penalización por repetir tokens, enviada al modelo.
logit_biasobject
Sesgos de tokens, enviados al modelo.
logprobsboolean
Solicita las probabilidades logarítmicas de los tokens de salida.
top_logprobsinteger
Cuántas alternativas por token devolver junto con logprobs.
toolsarray
Funciones que el modelo puede llamar. Algunas rutas aceptan un conjunto de campos más reducido y lo rechazan (unsupported_field_for_route).
tool_choicestring | object
Si el modelo debe llamar una herramienta y cuál.
parallel_tool_callsboolean
Si el modelo puede llamar varias herramientas a la vez.
response_formatobject
El formato de salida, por ejemplo {"type": "json_object"}.
seedinteger
Una semilla para un muestreo más repetible.
reasoning_effortstring
Cuánto debe razonar el modelo, en los modelos que lo hacen.
verbositystring
Qué tan extensa debe ser la respuesta del modelo, en los modelos que lo admiten.
userstring
El id de tu usuario final. Antes de salir de Inovacc, se reemplaza por un valor derivado de tu organización.
safety_identifierstring
Un id estable de tu usuario final con fines de seguridad; se deriva de tu organización igual que user.
prompt_cache_keystring
Una clave que agrupa solicitudes para el caché; se deriva de tu organización igual que user.
predictionobject
Contenido de salida previsto, enviado al modelo.
ninteger
Solo se acepta cuando tu organización tiene este campo concedido (de lo contrario, 403 field_not_allowed).
service_tierstring
Solo se acepta cuando tu organización tiene este campo concedido (de lo contrario, 403 field_not_allowed).
storeboolean
Solo se acepta cuando tu organización tiene este campo concedido (de lo contrario, 403 field_not_allowed).
metadataobject
Solo se acepta cuando tu organización tiene este campo concedido (de lo contrario, 403 field_not_allowed).
modalitiesarray
Solo se acepta cuando tu organización tiene este campo concedido (de lo contrario, 403 field_not_allowed).
audioobject
Solo se acepta cuando tu organización tiene este campo concedido (de lo contrario, 403 field_not_allowed).
web_search_optionsobject
Solo se acepta cuando tu organización tiene este campo concedido (de lo contrario, 403 field_not_allowed).

Encabezados

Authorizationstringobligatorio
Bearer <clave de API>
X-Operation-Idstringobligatorio
un id único que tú eliges, en toda llamada excepto GET
Content-Typestringobligatorio
application/json, en una llamada con cuerpo

Ver también

Detalles de la fuente

Entrada del catálogo

Id: identity/component-taxonomy/capabilities#ai.chat
Repositorio: identity
Ruta: contracts/component-taxonomy/catalog/capabilities.json
Commit: 08ef3cd75d82

Sección del contrato

Id: ai/ai/contract#post-v1chatcompletions
Repositorio: ai
Ruta: apps/cloudflare/workers/api/ai/CONTRACT.md
Commit: 972a1c15b9d5
Versión documentada: 2.37.0
Versión en producción: 2.14.0

Solicitud en cURLEjemplo

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))

Ejemplo

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 error: 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 error: missing_credentials invalid_credentials

403

Códigos de error: key_disabled organization_disabled field_not_allowed route_forbidden

409

Códigos de error: operation_in_progress

413

Códigos de error: request_too_large

429

Códigos de error: rate_limited quota_exceeded concurrency_limited budget_exhausted

502

Códigos de error: upstream_error

503

Códigos de error: service_unavailable route_unavailable

504

Códigos de error: timeout_error