Come usare l'API di Muse Wonder: Python, streaming & prezzi

TL;DR

Muse Wonder è il modello in anteprima di Meta per coding complesso, ragionamento e workflow basati su agenti. Gli sviluppatori possono accedere alla Muse Wonder API in CometAPI con un client compatibile con OpenAI e model="muse-wonder". Questa guida aiuta gli sviluppatori che conoscono Python o JavaScript a inviare una prima richiesta, aggiungere lo streaming e valutare ragionamento, media e costi. Rispetto a Muse Spark, il motivo pratico per valutare Wonder è il suo potenziale di completare compiti difficili in modo più affidabile; una grande finestra di contesto da sola non è un motivo per migrare.

Key Takeaways

• Integrazione: usa una chiave API lato backend, https://api.cometapi.com/v1, e model="muse-wonder".
• Capacità: Muse Wonder ha una finestra di contesto da 1.048.576 token; riduci il contesto ripetuto per controllare i costi.
• Funzionalità: valuta separatamente streaming, chiamate agli strumenti e media sul percorso di gateway selezionato.
• Ragionamento: il Muse Wonder nativo supporta da minimal a max; uno sforzo più alto aumenta l’uso di token e la latenza.
• Distribuzione: esegui benchmark su compiti reali, verifica la fatturazione corrente e conserva un modello di rollback prima di aumentare il traffico.

What Is Muse Wonder API?

Meta ha introdotto Muse Wonder il 12 ottobre 2026. Il modello è disponibile in anteprima tramite la Meta Model API per coding complesso, ragionamento e workflow guidati da strumenti. CometAPI usa l’identificatore del modello muse-wonder; l’identificatore nativo di Meta è muse-wonder-1.0.

Il modello nativo è focalizzato su ragionamento sostenuto, coding e lavoro guidato da strumenti. Le applicazioni devono comunque fornire strumenti, stato persistente, condizioni di arresto e controlli di autorizzazione; una singola chiamata di modello non crea un ambiente di esecuzione autonomo.

Muse Wonder API specifications

Muse Wonder vs Muse Wonder Full

Muse Wonder è disponibile tramite la Meta Model API; Muse Wonder Full è disponibile solo tramite gli abbonamenti Power Usage e Maximum Usage in Muse Code, e impostare reasoning_effort su max non passa a Muse Wonder Full. Vedi l’annuncio di lancio di Meta.

Muse Spark API vs Muse Wonder API

Scegli tra i modelli sulla base del successo misurato dei compiti e dei costi. La guida del modello nativo raccomanda Wonder per lavori complessi e Spark per carichi sensibili ai costi; attribuisce a entrambi una finestra di contesto da 1.048.576 token. Confronta una specifica versione di Spark invece di presumere che tutte le versioni abbiano capacità identiche.

Muse Spark è più adatto a carichi sensibili ai costi; Muse Wonder è pensato per coding complesso e ragionamento sostenuto. Verifica supporto media, controlli del ragionamento e fatturazione per l’esatta versione del modello e percorso di gateway. Mantieni il modello che soddisfa gli obiettivi misurati di successo del compito e costo.

How to Use Muse Wonder API with CometAPI Step by Step

Step 1: Create and secure your CometAPI key

Crea un account, genera una chiave API lato backend e tienila fuori dal codice del browser e dai repository pubblici. Segui la documentazione di integrazione di CometAPI per l’autenticazione. Questi esempi richiedono un account finanziato o idoneo, Python 3.10+ o un ambiente Node.js LTS supportato, e accesso HTTPS in uscita. Salva gli esempi JavaScript come file .mjs.

Imposta la chiave API in una sessione Bash.

export COMETAPI_KEY="your_cometapi_api_key"

Imposta la chiave API in una sessione PowerShell.

$env:COMETAPI_KEY="your_cometapi_api_key"

Step 2: Configure the Muse Wonder endpoint

Step 3: Send your first request with cURL

Invia una richiesta chat minima autenticata.

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 richiesta non in streaming andata a buon fine dovrebbe restituire choices[0].message.content. Ispeziona il modello e l’uso restituiti, quando forniti, e conferma che il testo risponde al tuo prompt. Gli errori di autenticazione richiedono verifiche delle credenziali; un errore di modello non valido richiede verifiche dell’accesso al modello. Gli esempi illustrano i pattern di richiesta e non rappresentano latenze misurate o risultati di benchmark.

Step 4: Make a Python request

Installa la libreria client Python.

pip install --upgrade openai

Invia una richiesta Python e ispeziona l’uso dei token.

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

Installa la libreria client JavaScript.

npm install openai

Invia una richiesta 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

Lo streaming restituisce frammenti di risposta incrementali tramite server-sent events. Migliora la reattività percepita, anche se non necessariamente il costo totale o il tempo di completamento. Mostra solo i frammenti contenenti contenuto e gestisci i casi di interruzione e timeout.

Python streaming example

Leggi frammenti incrementali di risposta in 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

Leggi frammenti incrementali di risposta in 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

Il modello nativo accetta minimal, low, medium, high, xhigh e max; nessuno è non supportato. Inizia con un’impostazione moderata e aumentala solo quando le tue valutazioni giustificano la latenza extra e il costo di token in uscita. Vedi il riferimento al ragionamento di Meta. Testa separatamente l’inoltro del gateway.

How to Set Reasoning Effort in Chat Completions

L’esempio seguente invia high tramite il gateway come test di capacità. Se rifiutato, esamina l’errore prima di rimuovere il campo: un 400 può anche indicare messaggi non validi, un modello errato o un altro problema di richiesta. Ritenta con la richiesta testuale minima per isolare la causa.

Testa un alto sforzo di ragionamento sul 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 di Meta annida il campo come reasoning.effort e usa muse-wonder-1.0. L’esempio seguente usa le credenziali Meta e il suo endpoint nativo; conferma separatamente il supporto Responses prima di adattarlo 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 modifica il budget di ragionamento del modello selezionato. Non cambia l’identificatore del modello né concede accesso alla versione Full; la distinzione di accesso è spiegata nell’introduzione del modello.

How Can Muse Wonder API Analyze Images and PDFs

Meta documenta input di immagini, video, audio e PDF per Wonder nativo. Il supporto media nativo di Meta non garantisce che CometAPI accetti lo stesso schema di contenuto, formato URL, tipi di file o limiti di dimensione. Verifica questi dettagli sul percorso selezionato prima dell’uso in produzione. L’esempio image_url seguente è un pattern di compatibilità: usa un’immagine accessibile che controlli, conferma il supporto dell’endpoint e confronta la risposta con i dettagli visibili.

Testa un URL di immagine con un’immagine nota.

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)

Per un workflow prevedibile solo testo con PDF, estrai localmente il testo selezionabile e invia passaggi selezionati come testo. Questo non testa l’input PDF nativo né preserva l’impaginazione, le figure o i contenuti scansionati. L’esempio limita l’input a 50.000 caratteri per un piccolo test; l’ingestione in produzione dovrebbe selezionare o suddividere il contenuto e preservare i riferimenti di pagina invece di troncare silenziosamente un report.

Estrai testo selezionabile da PDF per un test limitato.

# 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 modello può richiedere una chiamata di funzione, ma l’applicazione deve autorizzarla ed eseguirla. Questo esempio dimostra una ricerca limitata e in sola lettura dello stato di un ordine; le implementazioni in produzione dovrebbero validare gli input e vincolare gli strumenti in base alle autorizzazioni.

Esegui una richiesta di strumento limitata allo stato dell’ordine.

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)

Questo esempio didattico gestisce un solo giro di chiamate a strumenti. Se la risposta successiva richiede un’altra chiamata a strumenti, prosegui solo entro un ciclo limitato e valida di nuovo nome e argomenti. Conserva i risultati degli strumenti per sicurezza in caso di retry; un agente in produzione ha anche bisogno di un limite di tempo, un limite di iterazioni e una chiara condizione di completamento.

How Much Does Muse Wonder API Cost

Il prezzo ufficiale di Meta indica $4,00 per milione di token di input non in cache, $0,20 per milione di token di input in cache e $20,00 per milione di token di output.

L’istantanea dei prezzi dell’articolo di origine del 14 ottobre 2026 elenca CometAPI a $3,20 per milione di token di input non in cache e $16,00 per milione di token di output. Queste sono tariffe di gateway, non una sostituzione dei prezzi Meta di $4,00 per l’input e $20,00 per l’output. Conferma le tariffe correnti del tuo account e del percorso prima dell’uso; non si presume alcuna tariffa per input in cache su CometAPI.

Per 100.000 token di input non in cache e 50.000 token di output fatturati, le tariffe Meta indicate danno $0,40 + $1,00 = $1,40. Le tariffe CometAPI indicate danno $0,32 + $0,80 = $1,12. Questo esempio esclude costi aggiuntivi e non presume alcuno sconto cache.

Per questo esempio non in cache, le tariffe CometAPI mostrate danno una stima inferiore del 20%. Le fatture reali dipendono dall’uso dei token, dalla fatturazione del percorso e da eventuali costi aggiuntivi. Se si applica la cache, calcola utilizzando la tariffa in cache verificata invece di applicare la tariffa di input non in cache a ogni token.

Stima il costo con le tariffe CometAPI dell’istantanea di origine; sostituiscile con le tariffe verificate del tuo account.

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 maggior parte delle integrazioni client compatibili con OpenAI può mantenere la propria struttura complessiva. Aggiorna base URL, credenziali e ID modello, quindi esegui una valutazione a tappe su prompt reali. I campi specifici del protocollo per ragionamento e multimodale richiedono una verifica indipendente.

Imposta COMETAPI_KEY, aggiorna la base URL a https://api.cometapi.com/v1 e seleziona muse-wonder. Verifica autenticazione e accesso al modello con una richiesta testuale minima. Poi testa separatamente i campi di ragionamento, i frammenti in streaming, l’esecuzione delle chiamate agli strumenti e qualsiasi formato media. Ispeziona errori e qualità della risposta: un HTTP 400 può avere diverse cause, mentre una risposta HTTP riuscita da sola non prova il supporto della funzionalità. Registra l’uso restituito e confronta i costi con il tuo budget. Mantieni base URL e modello configurabili così da poter tornare indietro.

Configura una migrazione e un rollback guidati da variabili d’ambiente.

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)

Inizia con una piccola frazione canary del traffico live. Confronta correttezza, successo degli strumenti, latenza del primo token, latenza totale, tasso di retry e costo totale per compito completato con successo prima di ampliare il rollout.

Add Timeouts, Retry Limits and Monitoring

Imposta timeout di richiesta e limiti espliciti; registra ID richiesta non sensibili e uso dei token; oscura le informazioni personali quando possibile; ripeti solo guasti transitori; e richiedi autorizzazioni per azioni irreversibili degli strumenti. Una chiamata a un modello più economica non è necessariamente un compito più economico se causa retry.

Ritenta gli errori transitori con backoff esponenziale limitato.

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

Metrica operativa suggerita: costo per compito riuscito = costi totali del modello e degli strumenti / numero di compiti riusciti. Traccia i guardrail di sicurezza e correttezza oltre ai costi aggregati.

FAQ

Why can Muse Wonder API stop before its final answer?

Ragionamento e testo visibile condividono un budget di completamento sull’API nativa. Un passaggio di ragionamento lungo può lasciare meno spazio per la risposta finale. Controlla la finish reason e l’uso, riduci lo sforzo o restringi il compito e aumenta il limite di completamento supportato dal percorso solo entro il tuo budget. Uno stream interrotto richiede una diagnosi separata del trasporto.

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

Una nuova richiesta è una nuova generazione, non una continuazione automatica della risposta interrotta. Salva l’output parziale e l’identificatore della richiesta, contrassegna la risposta come incompleta e decidi se ricominciare o chiedere una continuazione usando contesto esplicito. Per i workflow con strumenti, conserva le azioni completate così che un retry non possa eseguirle due volte.

How do I validate Muse Wonder API media answers?

Usa una piccola immagine o documento con fatti noti e poni domande le cui risposte richiedono quei fatti. Confronta la risposta con l’originale, inclusi numeri e riferimenti di pagina. Uno status HTTP di successo da solo non dimostra che l’endpoint abbia accettato o interpretato correttamente i media; ispeziona errori e formati di richiesta prima di scalare l’ingestione.

How can I audit a Muse Wonder API cost discrepancy?

Registra uso restituito, modello, percorso, orario della richiesta e la tariffa dell’account in quel momento. Separa input non in cache, letture cache verificate e output totale fatturato, incluso il ragionamento quando applicabile. Confronta tali quantità con il record di fatturazione; verifica valuta, variazioni delle tariffe e addebiti aggiuntivi prima di presumere un errore di contabilizzazione dei token.

Conclusion

Inizia con una richiesta CometAPI autenticata, conferma la risposta restituita, quindi aggiungi lo streaming e le funzionalità necessarie alla tua applicazione. Prima del rollout in produzione, valida il percorso selezionato, verifica la fatturazione, applica autorizzazioni agli strumenti e mantieni un modello di rollback. Amplia il traffico solo quando successo del compito misurato, latenza e costo soddisfano i tuoi criteri di accettazione.