API Responses

POST https://api.floopy.ai/v1/responses aceita o formato nativo de Responses da OpenAI. Escolha responses.create para usar itens de Responses, reasoning com function tools ou eventos tipados de streaming. As chamadas existentes de Chat Completions continuam em /v1/chat/completions.

import { Floopy } from "floopy-sdk";

const floopy = new Floopy({
  apiKey: process.env.FLOOPY_API_KEY!,
  options: { llmSecurityEnabled: true },
});
const response = await floopy.responses.create({
  model: "gpt-6-luna",
  input: "Explain how an AI gateway works.",
  reasoning: { effort: "medium" },
  store: false,
});
console.log(response.output_text);

A autenticação usa sua API key Floopy. A organização configura a credencial do provider OpenAI no Floopy. O cliente oficial OpenAI também funciona com baseURL: "https://api.floopy.ai/v1".

Responses passa pela mesma orquestração de Chat Completions: validação de API key e plano, rate limits, overrides de modelo, prompts e templates, estratégias de roteamento, experimentos, Smart Cost e roteamento por feedback, firewall, guardrails, retries, circuit breakers, fallback, logs de uso e custo e reconstrução de sessões. Os headers Floopy-* existentes se aplicam. O firewall LLM exige a funcionalidade no plano e floopy-llm-security-enabled: true.

Inicialmente, Responses nativo atende OpenAI. Roteamento e fallback consideram os destinos OpenAI compatíveis; providers incompatíveis são ignorados. Sem destino compatível, a chamada falha explicitamente. A escolha de Responses mantém as decisões de modelo, e o gateway não desativa reasoning silenciosamente. Chat Completions continua sendo o endpoint compatível com múltiplos providers.

O output nativo retorna object: "response", itens em output e usage.input_tokens / usage.output_tokens, incluindo tokens de cache e reasoning. Campos nativos desconhecidos são preservados. Cada capacidade depende do suporte e da validação do modelo no provider.

const response = await floopy.responses.create({
  model: "gpt-6-luna",
  input: "What is the weather in Fortaleza?",
  reasoning: { effort: "medium" },
  tools: [{
    type: "function",
    name: "get_weather",
    description: "Get the weather for a city",
    strict: false,
    parameters: { type: "object", properties: { city: { type: "string" } }, required: ["city"] },
  }],
  store: false,
});
for (const item of response.output) {
  if (item.type === "function_call") console.log(item.name, item.arguments, item.call_id);
}

Para executar ferramentas no cliente, reenvie os itens de output retornados (incluindo reasoning) junto com seu function_call_output. Quando o agente MCP Floopy estiver habilitado, seu loop de ferramentas continua pela mesma orquestração e retorna output Responses.

const stream = await floopy.responses.create({
  model: "gpt-6-luna", input: "Tell a short story.", stream: true, store: false,
});
for await (const event of stream) {
  if (event.type === "response.output_text.delta") process.stdout.write(event.delta);
}

O gateway preserva eventos do provider como response.created, response.output_text.delta, deltas de argumentos de funções e eventos finais response.completed / response.incomplete. O uso é registrado após o evento final. Streams interrompidos são registrados como falhas.

Use previous_response_id ou conversation, nunca ambos. O gateway recupera o histórico referenciado com a credencial OpenAI da organização antes da inspeção. A seleção de modelo e o fallback continuam aplicáveis entre destinos OpenAI compatíveis; o modelo selecionado precisa suportar os itens nativos referenciados. A inspeção do histórico é limitada a 10 MiB e 30 segundos e falha explicitamente se o histórico não puder ser resolvido.

Somente chamadas de texto com store: false, sem tools e sem histórico gerenciado pelo provider podem usar cache. Os campos nativos entram na chave de cache, e Responses tem um namespace separado de Chat Completions. IDs de respostas em cache não podem ser usados como histórico persistido na OpenAI.

Esta versão suporta criação síncrona e streaming SSE. background: true é rejeitado porque jobs assíncronos exigem contabilização de uso específica. Rotas públicas de consulta, cancelamento, exclusão e gerenciamento de conversas ainda não estão expostas pelo gateway, embora os SDKs upstream exponham esses métodos.

from floopy import Floopy
import os
with Floopy(api_key=os.environ["FLOOPY_API_KEY"]) as client:
    response = client.responses.create(model="gpt-6-luna", input="Hello!", store=False)
    print(response.output_text)
# AsyncFloopy exposes the same client.responses surface.

import (
  "context"
  "os"
  floopy "github.com/FloopyAI/floopy-go"
  "github.com/openai/openai-go/v3"
  "github.com/openai/openai-go/v3/responses"
)
client, err := floopy.NewClient(os.Getenv("FLOOPY_API_KEY"))
if err != nil { panic(err) }
response, err := client.Responses().New(context.Background(), responses.ResponseNewParams{
  Model: "gpt-6-luna",
  Input: responses.ResponseNewParamsInputUnion{OfString: openai.String("Hello!")},
})
if err != nil { panic(err) }
println(response.OutputText())

use floopy::Floopy;
use floopy::async_openai::types::responses::CreateResponse;
let client = Floopy::new(std::env::var("FLOOPY_API_KEY")?)?;
let request: CreateResponse = serde_json::from_value(serde_json::json!({
    "model": "gpt-6-luna", "input": "Hello!", "store": false
}))?;
let response = client.responses().create(request).await?;
println!("{}", response.id);

Os SDKs atualizados usam OpenAI Node 7.28+, Python 3.25+, Go v3.72+ (Go 1.25+) e Rust async-openai 0.42.1+.