Imagens

POST /images/generations gera uma imagem a partir de um prompt. model e prompt são obrigatórios.

Prompt para o seu agenteCopia as instruções de configuração desta página, para colar no seu agente de código.

Ver o prompt

Me ajude a configurar isto para usar a Bayle AI, uma API compatível com a OpenAI. Guia completo: https://docs.bayle.ai/pt-br/guides/images/

Objetivo: gerar uma imagem pela Bayle a partir deste projeto e salvá-la em um arquivo.

1. Ache ou crie o client da OpenAI deste projeto (Python ou Node, o que ele já usar) e aponte-o para a Bayle:
   Python: OpenAI(api_key=os.environ["BAYLE_API_KEY"], base_url="https://api.bayle.ai")
   Node: new OpenAI({ apiKey: process.env.BAYLE_API_KEY, baseURL: 'https://api.bayle.ai' })
2. Escolha um modelo de imagem: curl -s "https://api.bayle.ai/models?type=image" | jq -r '.data[].id'
   Me mostre a lista e deixe eu escolher o IMAGE_MODEL_ID.
3. Gere com client.images.generate(model=IMAGE_MODEL_ID, prompt="A lighthouse in heavy fog, painted in oils.", response_format="b64_json") e grave result.data[0].b64_json decodificado de base64 em lighthouse.png.
4. Três comportamentos diferem da API de imagens da OpenAI, então escreva o código de acordo:
   - Uma requisição gera no máximo uma imagem. `n` maior que 1 é rejeitado, então para várias imagens envie várias requisições (elas podem rodar em paralelo).
   - Sempre passe `response_format` explicitamente. Omiti-lo devolve `b64_json`, não `url`, e não existe nenhuma chave `url`, então `data[0].url` fica ausente.
   - `response_format: "url"` devolve um `data:` URI em base64 em `url`, não um link baixável. Não o baixe por HTTP; decodifique-o, ou simplesmente peça `b64_json`.
5. `size`, `quality` e `style` são enviados ao modelo como estão; o que eles aceitam depende do modelo.
6. Teste: rode o script e confirme que lighthouse.png existe e é uma imagem válida (por exemplo com `file lighthouse.png`). Me mostre o resultado.

Regras:
1. A base URL é https://api.bayle.ai exatamente como está escrita. Não acrescente nenhum caminho a ela.
2. Leia a key da variável de ambiente BAYLE_API_KEY. Nunca escreva a key em um arquivo que você criar, em um comando, em um commit nem no chat. Onde a ferramenta guarda a key na própria tela de configurações, me diga onde colar. Se BAYLE_API_KEY não estiver definida, pare e peça que eu crie uma key em https://chat.bayle.ai/developers e a exporte.
3. Pegue os ids de modelo só de GET https://api.bayle.ai/models (sem key). Nunca chute um.
4. Termine com uma requisição de teste de verdade, me mostre o resultado e liste os arquivos que você alterou.

Leia isto antes de debugar um url ausente

Três comportamentos aqui diferem da API de imagens da OpenAI, e um client escrito contra os padrões da OpenAI vai esbarrar nos três. Eles estão cobertos abaixo, e cada um é uma diferença deliberada, não um bug.

Gerando uma imagem

O padrão seguro: peça b64_json explicitamente e decodifique-o.

Python

import base64, pathlib

result = client.images.generate(
    model="IMAGE_MODEL_ID",
    prompt="A lighthouse in heavy fog, painted in oils.",
    response_format="b64_json",
)
pathlib.Path("lighthouse.png").write_bytes(base64.b64decode(result.data[0].b64_json))

JavaScript

import { writeFile } from 'node:fs/promises'

const result = await client.images.generate({
  model: 'IMAGE_MODEL_ID',
  prompt: 'A lighthouse in heavy fog, painted in oils.',
  response_format: 'b64_json',
})
await writeFile('lighthouse.png', Buffer.from(result.data[0].b64_json, 'base64'))

curl

curl https://api.bayle.ai/images/generations \
  -H "Authorization: Bearer $BAYLE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "IMAGE_MODEL_ID",
    "prompt": "A lighthouse in heavy fog, painted in oils.",
    "response_format": "b64_json"
  }' | jq -r '.data[0].b64_json' | base64 -d > lighthouse.png

Uma imagem por requisição

Uma requisição gera no máximo uma imagem. Pedir mais através de n é rejeitado em vez de silenciosamente truncado, então você descobre na hora em vez de ficar imaginando para onde foram as outras imagens.

Para gerar várias, envie várias requisições. Elas são independentes, então rode-as concorrentemente.

response_format: "url" retorna dados inline, não um link

Pedir url te dá um campo url, mas ele carrega uma data: URI em base64 em vez de um link acessível:

{
  "data": [
    { "url": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUg..." }
  ]
}

Passar isso para um client HTTP esperando baixar algo não vai funcionar. Decodifique-o em vez disso, ou melhor, peça b64_json e pule o prefixo data: inteiramente.

Omitir response_format não assume url por padrão

Este é o que mais custa tempo às pessoas. A API da OpenAI define response_format como url por padrão, então isto funciona lá:

# Works against OpenAI. Finds nothing here.
result = client.images.generate(model="...", prompt="...")
print(result.data[0].url)

Contra a Bayle, omitir response_format retorna b64_json, sem nenhuma chave url presente, então data[0].url fica ausente em vez de vazio.

O que você envia	O que volta
response_format: "b64_json"	b64_json, bytes em base64 puros
response_format: "url"	url, carregando uma data: URI em base64
nada	b64_json. Não url.

Seja explícito e a ambiguidade desaparece.

Outras opções

size, quality e style são enviados ao modelo como estão, e o que eles aceitam depende do modelo. O mesmo vale para qualquer campo não listado aqui, então um parâmetro que seu modelo suporta e que esta documentação ainda não cobriu chega até ele normalmente.

Respostas grandes

Uma imagem grande o suficiente para exceder o limite de tamanho de resposta da Bayle é recusada antes que qualquer status seja comprometido, então ela chega como uma resposta de erro normal em vez de um corpo truncado.