Como usar a API Muse Wonder: Python, streaming e preços

TL;DR

Muse Wonder é o modelo em prévia da Meta para codificação complexa, raciocínio e fluxos de trabalho orientados por agentes. Os desenvolvedores podem acessar a API do Muse Wonder na CometAPI com um cliente compatível com OpenAI e model="muse-wonder". Este guia ajuda desenvolvedores familiarizados com Python ou JavaScript a enviar a primeira solicitação, adicionar streaming e avaliar raciocínio, mídias e custo. Em comparação com o Muse Spark, o motivo prático para avaliar o Wonder é seu potencial de concluir tarefas difíceis com mais confiabilidade; uma janela de contexto grande por si só não é motivo para migrar.

Principais pontos

• Integração: use uma chave de API de backend, https://api.cometapi.com/v1 e model="muse-wonder".
• Capacidade: o Muse Wonder tem uma janela de contexto de 1,048,576 tokens; remova contexto repetido para controlar o custo.
• Capacidades: avalie separadamente streaming, chamadas de ferramentas e mídia na rota de gateway selecionada.
• Raciocínio: o Muse Wonder nativo suporta de minimal a max; maior esforço aumenta o uso de tokens e a latência.
• Implantação: faça benchmark com tarefas reais, verifique o faturamento atual e preserve um modelo de rollback antes de ampliar o tráfego.

O que é a API do Muse Wonder?

A Meta apresentou o Muse Wonder em 12 de outubro de 2026. O modelo está disponível em prévia por meio da Meta Model API para codificação complexa, raciocínio e fluxos orientados por ferramentas. A CometAPI usa o identificador de modelo muse-wonder; o identificador nativo da Meta é muse-wonder-1.0.

O modelo nativo foca em raciocínio sustentado, codificação e trabalho orientado por ferramentas. Os aplicativos ainda fornecem ferramentas, estado persistente, condições de parada e verificações de permissão; uma chamada individual ao modelo não cria um ambiente de execução autônomo.

Especificações da API do Muse Wonder

Muse Wonder vs Muse Wonder Full

O Muse Wonder está disponível por meio da Meta Model API; o Muse Wonder Full está disponível apenas nas assinaturas Power Usage e Maximum Usage do Muse Code, e definir reasoning_effort como max não alterna para o Muse Wonder Full. Veja o anúncio de lançamento da Meta.

API do Muse Spark vs API do Muse Wonder

Escolha entre os modelos por sucesso de tarefa medido e custo. O guia do modelo nativo recomenda o Wonder para trabalhos complexos e o Spark para cargas sensíveis a custo; ambos têm janela de contexto de 1,048,576 tokens. Compare uma versão específica do Spark em vez de presumir que todas as versões têm capacidades idênticas.

O Muse Spark é mais adequado a cargas sensíveis a custo; o Muse Wonder tem como alvo codificação complexa e raciocínio sustentado. Verifique o suporte a mídia, controles de raciocínio e faturamento para a versão exata do modelo e a rota do gateway. Mantenha o modelo que atinge suas metas de sucesso de tarefa e custo medidos.

Como usar a API do Muse Wonder com a CometAPI passo a passo

Etapa 1: Crie e proteja sua chave da CometAPI

Crie uma conta, gere uma chave de API de backend e mantenha-a fora de código no navegador e de repositórios públicos. Siga a documentação de integração da CometAPI para autenticação. Estes exemplos exigem uma conta financiada ou elegível, Python 3.10+ ou um ambiente Node.js LTS compatível, e acesso HTTPS de saída. Salve exemplos JavaScript como arquivos .mjs.

Defina a chave de API em uma sessão Bash.

export COMETAPI_KEY="your_cometapi_api_key"

Defina a chave de API em uma sessão do PowerShell.

$env:COMETAPI_KEY="your_cometapi_api_key"

Etapa 2: Configure o endpoint do Muse Wonder

Etapa 3: Envie sua primeira solicitação com cURL

Envie uma solicitação de chat mínima e autenticada.

curl -X POST "https://api.cometapi.com/v1/chat/completions" \
  -H "Authorization: Bearer $COMETAPI_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "muse-wonder",
    "messages": [
      {"role": "system", "content": "You are a senior engineer."},
      {"role": "user", "content": "List three ways to improve Python API reliability."}
    ],
    "stream": false
  }' 

Uma solicitação não contínua bem-sucedida deve retornar choices[0].message.content. Inspecione o modelo e o uso retornados, quando fornecidos, e confirme que o texto responde ao seu prompt. Falhas de autenticação exigem verificação de credenciais; um erro de modelo inválido exige verificação de acesso ao modelo. Os exemplos ilustram padrões de solicitação e não representam latência medida ou resultados de benchmark.

Etapa 4: Faça uma solicitação em Python

Instale a biblioteca cliente do Python.

pip install --upgrade openai

Envie uma solicitação em Python e inspecione o uso de tokens.

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["COMETAPI_KEY"],
    base_url="https://api.cometapi.com/v1",
    timeout=120.0,
)
response = client.chat.completions.create(
    model="muse-wonder",
    messages=[
        {"role": "system", "content": "You are a Python engineer."},
        {"role": "user", "content": "Review: def divide(a,b): return a/b"},
    ],
)
print(response.choices[0].message.content)
if response.usage:
    print("Total tokens:", response.usage.total_tokens)

Etapa 5: Use JavaScript ou Node.js

Instale a biblioteca cliente de JavaScript.

npm install openai

Envie uma solicitação em Node.js.

import OpenAI from "openai";
const client = new OpenAI({
  apiKey: process.env.COMETAPI_KEY,
  baseURL: "https://api.cometapi.com/v1",
});
const response = await client.chat.completions.create({
  model: "muse-wonder",
  messages: [{role: "user", content: "Explain async/await."}],
});
console.log(response.choices[0].message.content);

Como fazer streaming das respostas do Muse Wonder com a CometAPI

O streaming retorna partes incrementais da resposta por Server-Sent Events. Ele melhora a responsividade percebida, embora não necessariamente o custo total ou o tempo de conclusão. Exiba apenas partes que contenham conteúdo e trate casos de interrupção e timeout.

Exemplo de streaming em Python

Leia partes incrementais da resposta em Python.

import os
from openai import OpenAI
client = OpenAI(api_key=os.environ["COMETAPI_KEY"],
                base_url="https://api.cometapi.com/v1", timeout=180.0)
stream = client.chat.completions.create(
    model="muse-wonder",
    messages=[{"role": "user", "content": "Design a scalable FastAPI service."}],
    stream=True,
)
parts = []
for chunk in stream:
    if not chunk.choices:
        continue
    content = chunk.choices[0].delta.content
    if content:
        print(content, end="", flush=True)
        parts.append(content)
print("\nResponse complete.")

Exemplo de streaming em JavaScript

Leia partes incrementais da resposta em Node.js.

import OpenAI from "openai";
const client = new OpenAI({
  apiKey: process.env.COMETAPI_KEY,
  baseURL: "https://api.cometapi.com/v1",
});
const stream = await client.chat.completions.create({
  model: "muse-wonder",
  messages: [{role: "user", content: "Outline a research agent."}],
  stream: true,
});
for await (const chunk of stream) {
  const text = chunk.choices?.[0]?.delta?.content;
  if (text) process.stdout.write(text);
}

Quais níveis de esforço de raciocínio o Muse Wonder suporta?

Valores de esforço de raciocínio suportados

O modelo nativo aceita minimal, low, medium, high, xhigh e max; nenhum é incompatível. Comece com uma configuração moderada e aumente-a apenas quando suas avaliações justificarem a latência extra e o custo de tokens de saída. Consulte a referência de raciocínio da Meta. Teste o encaminhamento do gateway separadamente.

Como definir o esforço de raciocínio em Chat Completions

O exemplo a seguir envia high pelo gateway como um teste de capacidade. Se houver rejeição, inspecione o erro antes de remover o campo: um 400 também pode indicar mensagens inválidas, um modelo incorreto ou outro problema na solicitação. Tente novamente com a solicitação mínima de texto para isolar a causa.

Teste high de esforço de raciocínio no gateway.

import os
from openai import OpenAI, BadRequestError
client = OpenAI(api_key=os.environ["COMETAPI_KEY"],
                base_url="https://api.cometapi.com/v1")
try:
    response = client.chat.completions.create(
        model="muse-wonder",
        messages=[{"role": "user", "content": "Diagnose a distributed timeout."}],
        extra_body={"reasoning_effort": "high"},
    )
    print(response.choices[0].message.content)
except BadRequestError as err:
    print("This reasoning parameter may not be accepted:", err)

Como definir o esforço de raciocínio na Responses API

A Responses API nativa da Meta aninha o campo como reasoning.effort e usa muse-wonder-1.0. O exemplo abaixo usa credenciais da Meta e seu endpoint nativo; confirme o suporte da Responses API de forma independente antes de adaptá-lo à CometAPI.

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["META_API_KEY"],
    base_url="https://api.meta.ai/v1",
)
response = client.responses.create(
    model="muse-wonder-1.0",
    input="Diagnose a distributed timeout.",
    reasoning={"effort": "high"},
)
print(response.output_text)

Por que max não seleciona o Muse Wonder Full

max altera o orçamento de raciocínio do modelo selecionado. Não altera o identificador do modelo nem concede acesso ao Full; a distinção de acesso é explicada na introdução do modelo.

Como a API do Muse Wonder pode analisar imagens e PDFs

A Meta documenta entrada de imagem, vídeo, áudio e PDF para o Wonder nativo. O suporte nativo a mídias da Meta não garante que a CometAPI aceite o mesmo esquema de conteúdo, formato de URL, tipos de arquivo ou limites de tamanho. Verifique esses detalhes na rota selecionada antes do uso em produção. O exemplo image_url abaixo é um padrão de compatibilidade: use uma imagem acessível sob seu controle, confirme o suporte do endpoint e confira a resposta em relação aos detalhes visíveis.

Teste uma URL de imagem com uma imagem conhecida.

import os
from openai import OpenAI
client = OpenAI(api_key=os.environ["COMETAPI_KEY"],
                base_url="https://api.cometapi.com/v1")
response = client.chat.completions.create(
    model="muse-wonder",
    messages=[{"role": "user", "content": [
        {"type": "text", "text": "Describe anomalies in this dashboard."},
        {"type": "image_url", "image_url": {
            "url": "https://example.com/dashboard.png"}},
    ]}],
)
print(response.choices[0].message.content)

Para um fluxo previsível de PDF somente texto, extraia localmente o texto selecionável e envie trechos selecionados como texto. Isso não testa a entrada nativa de PDF nem preserva o layout de página, figuras ou conteúdo escaneado. O exemplo limita a entrada a 50.000 caracteres para um teste pequeno; a ingestão em produção deve selecionar ou dividir o conteúdo e preservar referências de página em vez de truncar silenciosamente um relatório.

Extraia texto selecionável de PDF para um teste delimitado.

# pip install pymupdf openai
import os
import fitz
from openai import OpenAI
client = OpenAI(api_key=os.environ["COMETAPI_KEY"],
                base_url="https://api.cometapi.com/v1")
with fitz.open("report.pdf") as doc:
    document_text = "\n".join(p.get_text() for p in doc)
response = client.chat.completions.create(
    model="muse-wonder",
    messages=[{"role": "user", "content":
        "Summarize the risks in this report:\n" + document_text[:50000]}],
)
print(response.choices[0].message.content)

Como criar um agente com chamadas de ferramentas com a API do Muse Wonder

Um modelo pode solicitar uma chamada de função, mas o aplicativo deve autorizá-la e executá-la. Este exemplo demonstra uma consulta delimitada, somente leitura, do status de um pedido; implementações de produção devem validar entradas e restringir ferramentas por permissão.

Execute uma chamada delimitada de ferramenta de status de pedido.

import json, os
from openai import OpenAI
client = OpenAI(api_key=os.environ["COMETAPI_KEY"],
                base_url="https://api.cometapi.com/v1")
tools = [{"type": "function", "function": {
    "name": "get_order_status",
    "description": "Look up an order status",
    "parameters": {"type": "object",
        "properties": {"order_id": {"type": "string"}},
        "required": ["order_id"], "additionalProperties": False}
}}]
messages = [{"role": "user", "content": "Status of order A1001?"}]
r = client.chat.completions.create(model="muse-wonder",
    messages=messages, tools=tools, tool_choice="auto")
msg = r.choices[0].message
messages.append(msg)
if msg.tool_calls:
    for call in msg.tool_calls:
        if call.function.name != "get_order_status":
            raise ValueError("Tool not permitted")
        args = json.loads(call.function.arguments)
        status = {"A1001": "Shipped"}.get(args["order_id"], "Not found")
        messages.append({"role": "tool", "tool_call_id": call.id,
                         "content": json.dumps({"status": status})})
    r = client.chat.completions.create(model="muse-wonder",
        messages=messages, tools=tools)
    print(r.choices[0].message.content)
else:
    print(msg.content)

Este exemplo didático trata uma rodada de chamada de ferramenta. Se a resposta de acompanhamento solicitar outra chamada de ferramenta, continue apenas dentro de um loop delimitado e valide novamente o nome e os argumentos. Persista os resultados das ferramentas para segurança de repetição; um agente de produção também precisa de limite de tempo, limite de iterações e uma condição clara de conclusão.

Quanto custa a API do Muse Wonder

O preço oficial da Meta indica US$ 4,00 por milhão de tokens de entrada sem cache, US$ 0,20 por milhão de tokens de entrada em cache e US$ 20,00 por milhão de tokens de saída.

A fotografia de preços de 14 de outubro de 2026 do artigo-fonte lista a CometAPI em US$ 3,20 por milhão de tokens de entrada sem cache e US$ 16,00 por milhão de tokens de saída. Essas são tarifas do gateway, não um substituto para os preços de US$ 4,00 (entrada) e US$ 20,00 (saída) da Meta. Confirme suas tarifas atuais de conta e rota antes do uso; nenhuma tarifa de entrada em cache da CometAPI é assumida.

Para 100.000 tokens de entrada sem cache e 50.000 tokens de saída faturados, as tarifas da Meta listadas resultam em $0.40 + $1.00 = $1.40. As tarifas listadas da CometAPI resultam em $0.32 + $0.80 = $1.12. Este exemplo exclui encargos extras e não presume qualquer desconto de cache.

Para este exemplo sem cache, as tarifas exibidas da CometAPI fornecem uma estimativa 20% menor. Faturas reais dependem do uso de tokens, do faturamento da rota e de quaisquer cobranças adicionais. Se houver cache, calcule usando a tarifa de cache verificada, em vez de aplicar a tarifa de entrada sem cache a todos os tokens.

Estime o custo com as tarifas da CometAPI no retrato da fonte; substitua-as pelas tarifas verificadas da sua conta.

def estimate_cost(input_tokens, output_tokens,
                  input_rate=3.20, output_rate=16.00):
    if input_tokens < 0 or output_tokens < 0:
        raise ValueError('Token counts must be non-negative')
    return (input_tokens * input_rate
            + output_tokens * output_rate) / 1_000_000

print(estimate_cost(100000, 50000))  # 1.12

Como migrar e executar o Muse Wonder em produção

Atualize e valide a integração

A maioria das integrações com clientes compatíveis com OpenAI pode manter sua estrutura geral. Atualize a base URL, a credencial e o ID do modelo, depois execute uma avaliação em etapas com prompts reais. Campos específicos de protocolo para raciocínio e multimídia precisam de verificação independente.

Defina COMETAPI_KEY, atualize a base URL para https://api.cometapi.com/v1 e selecione muse-wonder. Verifique a autenticação e o acesso ao modelo com uma solicitação mínima de texto. Em seguida, teste separadamente campos de raciocínio, partes de streaming, execução de chamadas de ferramenta e quaisquer formatos de mídia. Inspecione erros e a qualidade das respostas: um HTTP 400 pode ter várias causas, enquanto uma resposta HTTP bem-sucedida por si só não comprova suporte de capacidade. Registre o uso retornado e compare o custo com seu orçamento. Mantenha a base URL e o modelo configuráveis para permitir rollback.

Configure uma migração guiada por ambiente e rollback.

import os
from openai import OpenAI
client = OpenAI(
    api_key=os.environ["COMETAPI_KEY"],
    base_url=os.getenv("AI_BASE_URL", "https://api.cometapi.com/v1"),
)
model = os.getenv("AI_MODEL", "muse-wonder")
r = client.chat.completions.create(
    model=model,
    messages=[{"role":"user", "content":"Review this API design."}],
)
print(r.choices[0].message.content)

Comece com uma pequena implantação canário do tráfego ao vivo. Compare correção, sucesso de ferramentas, latência do primeiro token, latência total, taxa de novas tentativas e custo total por tarefa concluída com sucesso antes de ampliar a distribuição.

Adicione timeouts, limites de repetição e monitoramento

Defina timeouts de solicitação e limites explícitos; registre IDs de solicitação não sensíveis e uso de tokens; reduza informações pessoais quando possível; repita apenas falhas transitórias; e exija autorização para ações de ferramenta irreversíveis. Uma chamada de modelo mais barata não é necessariamente uma tarefa mais barata se causar novas tentativas.

Repita erros transitórios com backoff exponencial delimitado.

import os, time, random
from openai import (OpenAI, APIConnectionError, APITimeoutError,
    RateLimitError, InternalServerError)
client = OpenAI(api_key=os.environ["COMETAPI_KEY"],
    base_url="https://api.cometapi.com/v1", timeout=60, max_retries=0)
def complete_with_retry(prompt, attempts=4):
    for i in range(attempts):
        try:
            r = client.chat.completions.create(
                model="muse-wonder",
                messages=[{"role": "user", "content": prompt}])
            return r.choices[0].message.content
        except (RateLimitError, APIConnectionError,
                APITimeoutError, InternalServerError):
            if i == attempts-1:
                raise
            time.sleep(min(2**i, 16) + random.uniform(0, 0.5))

Métrica operacional sugerida: custo por tarefa concluída = custos totais de modelo e ferramentas / número de tarefas concluídas com sucesso. Acompanhe proteções de segurança e correção, bem como custos agregados.

Perguntas frequentes

Por que a API do Muse Wonder pode parar antes da resposta final?

Raciocínio e texto visível compartilham um orçamento de conclusão na API nativa. Um percurso longo de raciocínio pode deixar menos espaço para a resposta final. Verifique o motivo de finalização e o uso, reduza o esforço ou restrinja a tarefa, e aumente o limite de conclusão suportado pela rota apenas dentro do seu orçamento. Um stream interrompido requer diagnóstico de transporte separado.

Devo reiniciar do começo um stream da API do Muse Wonder?

Uma nova solicitação é uma nova geração, não uma continuação automática da resposta interrompida. Salve a saída parcial e o identificador da solicitação, marque a resposta como incompleta e decida se reinicia ou pede uma continuação usando contexto explícito. Para fluxos com ferramentas, persista ações concluídas para que uma repetição não as execute duas vezes.

Como valido respostas de mídia da API do Muse Wonder?

Use uma imagem ou documento pequeno com fatos conhecidos e faça perguntas cujas respostas exijam esses fatos. Compare a resposta com o original, incluindo números e referências de página. Status HTTP bem-sucedido por si só não comprova que o endpoint aceitou ou interpretou a mídia corretamente; inspecione erros e formatos de solicitação antes de escalar a ingestão.

Como posso auditar uma discrepância de custo da API do Muse Wonder?

Registre uso retornado, modelo, rota, horário da solicitação e a tarifa da conta naquele momento. Separe entrada sem cache, leituras de cache verificadas e total de saída faturada, incluindo raciocínio quando aplicável. Compare essas quantidades com o registro de faturamento; verifique moeda, mudanças de tarifa e cobranças adicionais antes de assumir erro na contagem de tokens.

Conclusão

Comece com uma solicitação autenticada na CometAPI, confirme a resposta retornada e depois adicione streaming e os recursos de que seu aplicativo precisa. Antes do rollout em produção, valide a rota selecionada, verifique o faturamento, aplique permissões de ferramentas e mantenha um modelo de rollback. Amplie o tráfego apenas quando sucesso de tarefa, latência e custo medidos atenderem aos seus critérios de aceitação.