Cómo usar la API de Muse Wonder: Python, Streaming & Precios

TL;DR

Muse Wonder es el modelo en vista previa de Meta para programación compleja, razonamiento y flujos de trabajo agentivos. Los desarrolladores pueden acceder a la API de Muse Wonder en CometAPI con un cliente compatible con OpenAI y model="muse-wonder". Esta guía ayuda a desarrolladores familiarizados con Python o JavaScript a enviar una primera solicitud, añadir streaming y evaluar razonamiento, medios y costes. En comparación con Muse Spark, la razón práctica para evaluar Wonder es su potencial para completar tareas difíciles con mayor fiabilidad; una ventana de contexto grande por sí sola no es motivo para migrar.

Key Takeaways

• Integración: use una clave de API de backend, https://api.cometapi.com/v1 y model="muse-wonder".
• Capacidad: Muse Wonder tiene una ventana de contexto de 1.048.576 tokens; recorte contexto repetido para controlar el coste.
• Capacidades: evalúe por separado streaming, llamadas a herramientas y medios en la ruta de gateway seleccionada.
• Razonamiento: el Muse Wonder nativo admite de minimal a max; mayor esfuerzo incrementa el uso de tokens y la latencia.
• Despliegue: evalúe tareas reales, verifique la facturación actual y preserve un modelo de rollback antes de ampliar el tráfico.

What Is Muse Wonder API?

Meta presentó Muse Wonder el 12 de octubre de 2026. El modelo está disponible en vista previa a través de la Meta Model API para programación compleja, razonamiento y flujos de trabajo impulsados por herramientas. CometAPI usa el identificador de modelo muse-wonder; el identificador nativo de Meta es muse-wonder-1.0.

El modelo nativo se centra en razonamiento sostenido, programación y trabajo impulsado por herramientas. Las aplicaciones siguen aportando herramientas, estado persistente, condiciones de parada y verificaciones de permisos; una llamada individual al modelo no crea un entorno de ejecución autónomo.

Muse Wonder API specifications

Muse Wonder vs Muse Wonder Full

Muse Wonder está disponible a través de Meta Model API; Muse Wonder Full solo está disponible mediante las suscripciones Power Usage y Maximum Usage en Muse Code, y configurar reasoning_effort en max no cambia a Muse Wonder Full. Consulte el anuncio de lanzamiento de Meta.

Muse Spark API vs Muse Wonder API

Elija entre los modelos por éxito medido de la tarea y coste. La guía del modelo nativo recomienda Wonder para trabajo complejo y Spark para cargas sensibles al coste; otorga a ambos una ventana de contexto de 1.048.576 tokens. Compare una versión específica de Spark en lugar de asumir que todas las versiones tienen capacidades idénticas.

Muse Spark se adapta mejor a cargas sensibles al coste; Muse Wonder está orientado a programación compleja y razonamiento sostenido. Verifique soporte de medios, controles de razonamiento y facturación para la versión exacta del modelo y la ruta del gateway. Mantenga el modelo que cumpla sus objetivos medidos de éxito y coste.

How to Use Muse Wonder API with CometAPI Step by Step

Step 1: Create and secure your CometAPI key

Cree una cuenta, genere una clave de API de backend y manténgala fuera del código del navegador y repositorios públicos. Siga la documentación de integración de CometAPI para la autenticación. Estos ejemplos requieren una cuenta financiada o elegible, Python 3.10+ o un entorno Node.js LTS compatible y acceso HTTPS saliente. Guarde los ejemplos de JavaScript como archivos .mjs.

Configure la clave de API en una sesión de Bash.

export COMETAPI_KEY="your_cometapi_api_key"

Configure la clave de API en una sesión de PowerShell.

$env:COMETAPI_KEY="your_cometapi_api_key"

Step 2: Configure the Muse Wonder endpoint

Step 3: Send your first request with cURL

Envíe una solicitud de chat autenticada mínima.

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
  }' 

Una solicitud no streaming exitosa debería devolver choices[0].message.content. Inspeccione el modelo y el uso devueltos, cuando se suministren, y confirme que el texto responde a su prompt. Los fallos de autenticación requieren verificar credenciales; un error de modelo no válido requiere verificar el acceso al modelo. Los ejemplos ilustran patrones de solicitud y no representan latencia medida ni resultados de benchmark.

Step 4: Make a Python request

Instale la biblioteca cliente de Python.

pip install --upgrade openai

Envíe una solicitud en Python e inspeccione el 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)

Step 5: Use JavaScript or Node.js

Instale la biblioteca cliente de JavaScript.

npm install openai

Envíe una solicitud en 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);

How to Stream Muse Wonder Responses with CometAPI

El streaming devuelve fragmentos de respuesta incrementales a través de eventos enviados por el servidor. Mejora la capacidad de respuesta percibida, aunque no necesariamente el coste total ni el tiempo de finalización. Muestre solo los fragmentos que contienen contenido y maneje casos de interrupción y timeout.

Python streaming example

Lea fragmentos incrementales de respuesta en 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.")

JavaScript streaming example

Lea fragmentos incrementales de respuesta en 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);
}

What Reasoning Effort Levels Does Muse Wonder Support?

Supported Reasoning Effort Values

El modelo nativo acepta minimal, low, medium, high, xhigh y max; ninguno carece de soporte. Comience con una configuración moderada y aumente solo cuando sus evaluaciones justifiquen la latencia adicional y el coste de tokens de salida. Consulte la referencia de razonamiento de Meta. Pruebe el reenvío del gateway por separado.

How to Set Reasoning Effort in Chat Completions

El siguiente ejemplo envía high a través del gateway como prueba de capacidad. Si se rechaza, inspeccione el error antes de eliminar el campo: un 400 también puede indicar mensajes no válidos, un modelo incorrecto u otro problema de solicitud. Reintente con la solicitud mínima de texto para aislar la causa.

Pruebe high reasoning effort en el 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)

How to Set Reasoning Effort in the Responses API

La Responses API nativa de Meta anida el campo como reasoning.effort y utiliza muse-wonder-1.0. El siguiente ejemplo usa credenciales de Meta y su endpoint nativo; confirme el soporte de Responses de forma independiente antes de adaptarlo a 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)

Why max Does Not Select Muse Wonder Full

max cambia el presupuesto de razonamiento del modelo seleccionado. No cambia el identificador del modelo ni concede acceso a Full; la distinción de acceso se explica en la introducción del modelo.

How Can Muse Wonder API Analyze Images and PDFs

Meta documenta entrada de imagen, video, audio y PDF para Wonder nativo. El soporte de medios nativo de Meta no garantiza que CometAPI acepte el mismo esquema de contenido, formato de URL, tipos de archivo o límites de tamaño. Verifique esos detalles en la ruta seleccionada antes de uso en producción. El ejemplo de image_url a continuación es un patrón de compatibilidad: use una imagen accesible que controle, confirme el soporte del endpoint y compare la respuesta con los detalles visibles.

Pruebe una URL de imagen con una imagen conocida.

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 un flujo de trabajo predecible y solo texto con PDF, extraiga texto seleccionable localmente y envíe pasajes seleccionados como texto. Esto no prueba la entrada nativa de PDF ni preserva el diseño de página, figuras o contenido escaneado. El ejemplo limita la entrada a 50.000 caracteres para una prueba pequeña; la ingesta en producción debe seleccionar o fragmentar contenido y preservar referencias de página en lugar de truncar silenciosamente un informe.

Extraiga texto seleccionable de un PDF para una prueba acotada.

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

How Can You Build a Tool-Calling Agent With Muse Wonder API

Un modelo puede solicitar una llamada de función, pero la aplicación debe autorizarla y ejecutarla. Este ejemplo demuestra una consulta acotada y de solo lectura del estado de un pedido; las implementaciones de producción deben validar entradas y restringir herramientas por permiso.

Ejecute una solicitud acotada de herramienta para estado 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 ejemplo didáctico maneja una ronda de llamada a herramienta. Si la respuesta posterior solicita otra llamada a herramienta, continúe solo dentro de un bucle acotado y valide nuevamente su nombre y argumentos. Persista los resultados de herramientas para seguridad en reintentos; un agente de producción también necesita un límite de tiempo, un límite de iteraciones y una condición clara de finalización.

How Much Does Muse Wonder API Cost

La tarifa oficial de Meta indica $4,00 por millón de tokens de entrada no cacheados, $0,20 por millón de tokens de entrada cacheados y $20,00 por millón de tokens de salida.

La instantánea de precios del artículo fuente del 14 de octubre de 2026 lista CometAPI en $3,20 por millón de tokens de entrada no cacheados y $16,00 por millón de tokens de salida. Estas son tarifas del gateway, no un reemplazo de los $4,00 de entrada y $20,00 de salida de Meta. Confirme sus tarifas actuales de cuenta y ruta antes de usar; no se asume tarifa de entrada cacheada en CometAPI.

Para 100.000 tokens de entrada no cacheados y 50.000 tokens de salida facturados, las tarifas de Meta listadas dan $0,40 + $1,00 = $1,40. Las tarifas de CometAPI listadas dan $0,32 + $0,80 = $1,12. Este ejemplo excluye cargos adicionales y no asume ningún descuento por caché.

Para este ejemplo no cacheado, las tarifas de CometAPI mostradas dan una estimación un 20% menor. Las facturas reales dependen del uso de tokens, la facturación de la ruta y cualquier cargo adicional. Si aplica caché, calcúlelo usando la tarifa cacheada verificada en lugar de aplicar la tarifa de entrada no cacheada a cada token.

Estime el coste con las tarifas de CometAPI de la instantánea fuente; reemplácelas con las tarifas verificadas de su cuenta.

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

How to Migrate and Run Muse Wonder in Production

Update and Validate the Integration

La mayoría de integraciones de clientes compatibles con OpenAI pueden mantener su estructura general. Actualice la base URL, credencial e ID de modelo, luego ejecute una evaluación escalonada con prompts reales. Los campos de razonamiento y multimodales específicos del protocolo necesitan verificación independiente.

Configure COMETAPI_KEY, actualice la base URL a https://api.cometapi.com/v1 y seleccione muse-wonder. Verifique autenticación y acceso al modelo con una solicitud mínima de texto. Luego pruebe campos de razonamiento, fragmentos de streaming, ejecución de llamadas a herramientas y cualquier formato de medios por separado. Inspeccione errores y calidad de respuesta: un HTTP 400 puede tener varias causas, mientras que una respuesta HTTP exitosa por sí sola no prueba el soporte de capacidades. Registre el uso devuelto y compare el coste con su presupuesto. Mantenga configurable la base URL y el modelo para poder revertir.

Configure una migración y rollback impulsados por entorno.

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)

Comience con una pequeña fracción canary del tráfico en vivo. Compare corrección, éxito de herramientas, latencia del primer token, latencia total, tasa de reintentos y coste total por tarea completada con éxito antes de ampliar el despliegue.

Add Timeouts, Retry Limits and Monitoring

Defina timeouts de solicitud y límites explícitos; registre IDs de solicitud no sensibles y uso de tokens; redacte información personal cuando sea posible; reintente solo fallos transitorios; y requiera autorización para acciones irreversibles de herramientas. Una llamada de modelo más barata no es necesariamente una tarea más barata si provoca reintentos.

Reintente errores transitorios con backoff exponencial acotado.

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 operativa sugerida: coste por tarea exitosa = costes totales de modelo y herramientas / número de tareas exitosas. Haga seguimiento de barreras de seguridad y corrección, así como de costes agregados.

FAQ

Why can Muse Wonder API stop before its final answer?

El razonamiento y el texto visible comparten un presupuesto de finalización en la API nativa. Un razonamiento largo puede dejar menos espacio para la respuesta final. Revise la razón de finalización y el uso, reduzca el esfuerzo o acote la tarea, e incremente el límite de finalización admitido por la ruta solo dentro de su presupuesto. Un stream interrumpido requiere un diagnóstico de transporte por separado.

Should I retry a Muse Wonder API stream from the beginning?

Una nueva solicitud es una nueva generación, no una continuación automática de la respuesta interrumpida. Guarde la salida parcial y el identificador de la solicitud, marque la respuesta como incompleta y decida si reiniciar o pedir una continuación usando contexto explícito. Para flujos con herramientas, persista acciones completadas para que un reintento no las ejecute dos veces.

How do I validate Muse Wonder API media answers?

Use una imagen o documento de prueba pequeño con hechos conocidos y haga preguntas cuyas respuestas requieran esos hechos. Compare la respuesta con el original, incluidos números y referencias de página. Un estado HTTP exitoso por sí solo no prueba que el endpoint aceptó o interpretó correctamente los medios; inspeccione errores y formatos de solicitud antes de escalar la ingesta.

How can I audit a Muse Wonder API cost discrepancy?

Registre el uso devuelto, modelo, ruta, hora de la solicitud y la tarifa de la cuenta en ese momento. Separe entrada no cacheada, lecturas de caché verificadas y salida total facturada, incluyendo razonamiento cuando corresponda. Compare esas cantidades con el registro de facturación; verifique moneda, cambios de tarifa y cargos adicionales antes de suponer un error de contabilización de tokens.

Conclusion

Comience con una solicitud autenticada en CometAPI, confirme la respuesta devuelta y luego añada streaming y las capacidades que su aplicación necesite. Antes del despliegue en producción, valide la ruta seleccionada, verifique la facturación, haga cumplir permisos de herramientas y mantenga un modelo de rollback. Amplíe el tráfico solo cuando el éxito medido de tareas, la latencia y el coste cumplan sus criterios de aceptación.