Comment utiliser l'API Muse Wonder : Python, streaming et tarification

TL;DR

Muse Wonder est le modèle de préversion de Meta pour le codage complexe, le raisonnement et les flux de travail d’agent. Les développeurs peuvent accéder à l’API Muse Wonder dans CometAPI avec un client compatible OpenAI et model="muse-wonder". Ce guide aide les développeurs familiarisés avec Python ou JavaScript à envoyer une première requête, ajouter le streaming et évaluer le raisonnement, les médias et le coût. Par rapport à Muse Spark, la raison pratique d’évaluer Wonder est son potentiel à accomplir des tâches difficiles plus fiablement ; une grande fenêtre de contexte seule n’est pas une raison de migrer.

Points clés

• Intégration : utilisez une clé API backend, https://api.cometapi.com/v1, et model="muse-wonder".
• Capacité : Muse Wonder possède une fenêtre de contexte de 1,048,576 jetons ; réduisez le contexte répété pour maîtriser le coût.
• Capacités : évaluez séparément le streaming, les appels d’outils et les médias sur la route de passerelle sélectionnée.
• Raisonnement : Muse Wonder natif prend en charge de minimal à max ; un effort plus élevé augmente l’usage de jetons et la latence.
• Déploiement : étalonnez sur des tâches réelles, vérifiez la facturation courante et conservez un modèle de repli avant d’étendre le trafic.

Qu’est-ce que l’API Muse Wonder ?

Meta a introduit Muse Wonder le 12 octobre 2026. Le modèle est disponible en préversion via la Meta Model API pour le codage complexe, le raisonnement et les flux de travail pilotés par des outils. CometAPI utilise l’identifiant de modèle muse-wonder ; l’identifiant natif de Meta est muse-wonder-1.0.

Le modèle natif se concentre sur le raisonnement soutenu, le codage et le travail piloté par des outils. Les applications doivent toujours fournir des outils, un état persistant, des conditions d’arrêt et des contrôles d’autorisations ; un appel de modèle individuel ne crée pas un environnement d’exécution autonome.

Spécifications de l’API Muse Wonder

Muse Wonder vs Muse Wonder Full

Muse Wonder est disponible via la Meta Model API ; Muse Wonder Full n’est disponible qu’avec les abonnements Power Usage et Maximum Usage dans Muse Code, et définir reasoning_effort sur max ne bascule pas vers Muse Wonder Full. Voir l’Annonce de lancement de Meta.

API Muse Spark vs API Muse Wonder

Choisissez entre les modèles selon le succès mesuré des tâches et le coût. Le guide natif du modèle recommande Wonder pour le travail complexe et Spark pour les charges sensibles au coût ; il donne à tous deux une fenêtre de contexte de 1,048,576 jetons. Comparez une version spécifique de Spark plutôt que de supposer que toutes les versions ont des capacités identiques.

Muse Spark convient mieux aux charges sensibles au coût ; Muse Wonder cible le codage complexe et le raisonnement soutenu. Vérifiez la prise en charge des médias, les contrôles de raisonnement et la facturation pour la version exacte du modèle et la route de passerelle. Conservez le modèle qui atteint vos objectifs mesurés de réussite de tâche et de coût.

Comment utiliser l’API Muse Wonder avec CometAPI étape par étape

Étape 1 : Créez et sécurisez votre clé CometAPI

Créez un compte, générez une clé API backend et ne la placez pas dans du code navigateur ni des dépôts publics. Suivez la documentation d’intégration CometAPI pour l’authentification. Ces exemples nécessitent un compte approvisionné ou éligible, Python 3.10+ ou un environnement Node.js LTS pris en charge, et un accès HTTPS sortant. Enregistrez les exemples JavaScript avec l’extension .mjs.

Définissez la clé API dans une session Bash.

export COMETAPI_KEY="your_cometapi_api_key"

Définissez la clé API dans une session PowerShell.

$env:COMETAPI_KEY="your_cometapi_api_key"

Étape 2 : Configurez l’endpoint Muse Wonder

Étape 3 : Envoyez votre première requête avec cURL

Envoyez une requête chat minimale authentifiée.

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": "Vous êtes un ingénieur principal."},
      {"role": "user", "content": "Listez trois façons d’améliorer la fiabilité des API Python."}
    ],
    "stream": false
  }' 

Une requête non diffusée (non-streaming) réussie doit renvoyer choices[0].message.content. Inspectez le modèle et l’usage retournés, quand fournis, et confirmez que le texte répond à votre invite. Les échecs d’authentification nécessitent une vérification des identifiants ; une erreur de modèle invalide nécessite une vérification de l’accès au modèle. Les exemples illustrent des schémas de requêtes et ne représentent ni la latence mesurée ni des résultats de benchmark.

Étape 4 : Faites une requête Python

Installez la bibliothèque cliente Python.

pip install --upgrade openai

Envoyez une requête Python et inspectez l’usage de jetons.

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": "Vous êtes ingénieur Python."},
        {"role": "user", "content": "Analyse : def divide(a,b): return a/b"},
    ],
)
print(response.choices[0].message.content)
if response.usage:
    print("Nombre total de jetons :", response.usage.total_tokens)

Étape 5 : Utilisez JavaScript ou Node.js

Installez la bibliothèque cliente JavaScript.

npm install openai

Envoyez une requête 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: "Expliquez async/await."}],
});
console.log(response.choices[0].message.content);

Comment diffuser (stream) les réponses de Muse Wonder avec CometAPI

Le streaming renvoie des fragments de réponse incrémentiels via des événements envoyés par le serveur. Il améliore la réactivité perçue, sans garantir le coût total ni le temps d’achèvement. Affichez uniquement les fragments contenant du contenu et gérez les interruptions et les délais d’expiration.

Exemple de streaming Python

Lisez des fragments de réponse Python incrémentiels.

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": "Concevez un service FastAPI évolutif."}],
    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("\nRéponse terminée.")

Exemple de streaming JavaScript

Lisez des fragments de réponse Node.js incrémentiels.

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: "Proposez l’architecture d’un agent de recherche."}],
  stream: true,
});
for await (const chunk of stream) {
  const text = chunk.choices?.[0]?.delta?.content;
  if (text) process.stdout.write(text);
}

Quels niveaux d’effort de raisonnement Muse Wonder prend-il en charge ?

Valeurs d’effort de raisonnement prises en charge

Le modèle natif accepte minimal, low, medium, high, xhigh et max ; aucun n’est non pris en charge. Commencez avec un réglage modéré et augmentez-le uniquement si vos évaluations justifient la latence supplémentaire et le coût en jetons de sortie. Voir la référence raisonnement de Meta. Testez le routage passerelle séparément.

Comment définir l’effort de raisonnement dans Chat Completions

L’exemple suivant envoie high via la passerelle comme test de capacité. En cas de rejet, inspectez l’erreur avant de supprimer le champ : un statut 400 peut aussi indiquer des messages invalides, un modèle incorrect ou un autre problème de requête. Réessayez avec une requête texte minimale pour isoler la cause.

Testez un effort de raisonnement high sur la passerelle.

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": "Diagnostiquez un timeout distribué."}],
        extra_body={"reasoning_effort": "high"},
    )
    print(response.choices[0].message.content)
except BadRequestError as err:
    print("Ce paramètre de raisonnement peut ne pas être accepté :", err)

Comment définir l’effort de raisonnement dans l’API Responses

L’API Responses native de Meta imbrique le champ en reasoning.effort et utilise muse-wonder-1.0. L’exemple ci-dessous utilise des identifiants Meta et son endpoint natif ; confirmez la prise en charge de Responses indépendamment avant de l’adapter à 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="Diagnostiquez un timeout distribué.",
    reasoning={"effort": "high"},
)
print(response.output_text)

Pourquoi max ne sélectionne pas Muse Wonder Full

max modifie le budget de raisonnement du modèle sélectionné. Il ne change pas l’identifiant du modèle et n’accorde pas l’accès à Full ; la distinction d’accès est expliquée dans l’introduction du modèle.

Comment l’API Muse Wonder peut-elle analyser des images et des PDF

Meta documente l’entrée image, vidéo, audio et PDF pour Wonder natif. La prise en charge native des médias par Meta ne garantit pas que CometAPI accepte le même schéma de contenu, format d’URL, types de fichiers ou limites de taille. Vérifiez ces détails sur la route sélectionnée avant l’utilisation en production. L’exemple image_url ci-dessous est un schéma de compatibilité : utilisez une image accessible que vous contrôlez, confirmez la prise en charge de l’endpoint et comparez la réponse aux détails visibles.

Testez une URL d’image avec une image connue.

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": "Décrivez les anomalies de ce tableau de bord."},
        {"type": "image_url", "image_url": {
            "url": "https://example.com/dashboard.png"}},
    ]}],
)
print(response.choices[0].message.content)

Pour un flux PDF uniquement texte prévisible, extrayez localement le texte sélectionnable et envoyez des passages sélectionnés en texte. Cela ne teste pas l’entrée PDF native ni ne préserve la mise en page, les figures ou le contenu scanné. L’exemple limite l’entrée à 50 000 caractères pour un petit test ; l’ingestion en production doit sélectionner ou segmenter le contenu et préserver les références de pages au lieu de tronquer silencieusement un rapport.

Extrayez le texte sélectionnable d’un PDF pour un test borné.

# 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":
        "Résumez les risques de ce rapport :\n" + document_text[:50000]}],
)
print(response.choices[0].message.content)

Comment créer un agent avec appels d’outils avec l’API Muse Wonder

Un modèle peut demander un appel de fonction, mais l’application doit l’autoriser et l’exécuter. Cet exemple illustre une consultation bornée, en lecture seule, du statut d’une commande ; en production, validez les entrées et restreignez les outils par autorisations.

Exécutez une requête d’outil bornée de statut de commande.

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": "Rechercher le statut d’une commande",
    "parameters": {"type": "object",
        "properties": {"order_id": {"type": "string"}},
        "required": ["order_id"], "additionalProperties": False}
}}]
messages = [{"role": "user", "content": "Statut de la commande 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("Outil non autorisé")
        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)

Cet exemple pédagogique gère un seul tour d’appel d’outil. Si la réponse de suivi demande un autre appel d’outil, continuez uniquement dans une boucle bornée et validez à nouveau son nom et ses arguments. Conservez les résultats d’outils pour la sécurité des réessais ; un agent de production a aussi besoin d’une limite de temps, d’une limite d’itérations et d’une condition d’achèvement claire.

Combien coûte l’API Muse Wonder

La tarification officielle de Meta indique 4,00 $ par million de jetons d’entrée non mis en cache, 0,20 $ par million de jetons d’entrée mis en cache, et 20,00 $ par million de jetons de sortie.

La capture de tarifs du 14 octobre 2026 dans l’article source liste CometAPI à 3,20 $ par million de jetons d’entrée non mis en cache et 16,00 $ par million de jetons de sortie. Ce sont des tarifs de passerelle, pas un remplacement des prix Meta de 4,00 $ (entrée) et 20,00 $ (sortie). Confirmez vos tarifs de compte et de route actuels avant l’usage ; aucun tarif d’entrée mise en cache CometAPI n’est supposé.

Pour 100,000 jetons d’entrée non mise en cache et 50,000 jetons de sortie facturés, les tarifs Meta listés donnent 0,40 $ + 1,00 $ = 1,40 $. Les tarifs CometAPI listés donnent 0,32 $ + 0,80 $ = 1,12 $. Cet exemple exclut les frais supplémentaires et ne suppose aucune remise de cache.

Pour cet exemple non mis en cache, les tarifs CometAPI affichés donnent une estimation inférieure de 20 %. Les factures réelles dépendent de l’usage de jetons, de la facturation de la route et de tous frais additionnels. Si la mise en cache s’applique, calculez-la avec le tarif de cache vérifié plutôt que d’appliquer le tarif d’entrée non mise en cache à chaque jeton.

Estimez le coût avec les tarifs CometAPI de la capture source ; remplacez-les par vos tarifs de compte vérifiés.

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('Le nombre de jetons doit être non négatif')
    return (input_tokens * input_rate
            + output_tokens * output_rate) / 1_000_000

print(estimate_cost(100000, 50000))  # 1.12

Comment migrer et exécuter Muse Wonder en production

Mettre à jour et valider l’intégration

La plupart des intégrations clientes compatibles OpenAI peuvent conserver leur structure générale. Mettez à jour l’URL de base, l’identifiant et le modèle, puis exécutez une évaluation progressive sur des invites réelles. Les champs spécifiques au protocole pour le raisonnement et le multimodal nécessitent une vérification indépendante.

Définissez COMETAPI_KEY, mettez à jour l’URL de base en https://api.cometapi.com/v1 et sélectionnez muse-wonder. Vérifiez l’authentification et l’accès au modèle avec une requête texte minimale. Testez ensuite séparément les champs de raisonnement, les fragments de streaming, l’exécution d’appels d’outils et tout format média. Inspectez les erreurs et la qualité des réponses : un HTTP 400 peut avoir plusieurs causes, tandis qu’un HTTP réussi seul ne prouve pas la prise en charge des capacités. Enregistrez l’usage retourné et comparez le coût à votre budget. Gardez l’URL de base et le modèle configurables pour pouvoir revenir en arrière.

Configurez une migration et un repli pilotés par l’environnement.

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":"Passez en revue cette conception d’API."}],
)
print(r.choices[0].message.content)

Commencez avec une petite fraction « canari » du trafic en direct. Comparez la justesse, la réussite des outils, la latence du premier jeton, la latence totale, le taux de réessai et le coût total par tâche menée à bien avant d’élargir le déploiement.

Ajoutez des délais, des limites de réessai et de la supervision

Définissez des délais d’expiration de requête et des limites explicites ; journalisez des identifiants de requête et l’usage de jetons non sensibles ; rédigez les informations personnelles si possible ; ne réessayez que les échecs transitoires ; et exigez une autorisation pour les actions d’outil irréversibles. Un appel de modèle moins cher n’est pas nécessairement une tâche moins chère s’il entraîne des réessais.

Réessayez les erreurs transitoires avec un backoff exponentiel borné.

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étrique d’exploitation suggérée : coût par tâche réussie = coût total du modèle et des outils / nombre de tâches réussies. Suivez les garde-fous de sécurité et de justesse ainsi que les coûts agrégés.

FAQ

Pourquoi l’API Muse Wonder peut-elle s’arrêter avant sa réponse finale ?

Le raisonnement et le texte visible partagent un budget d’achèvement sur l’API native. Un long passage de raisonnement peut laisser moins de place à la réponse finale. Vérifiez la raison de fin et l’usage, réduisez l’effort ou resserrez la tâche, et n’augmentez la limite d’achèvement prise en charge par la route que dans votre budget. Un flux interrompu nécessite un diagnostic de transport séparé.

Dois-je relancer un flux de l’API Muse Wonder depuis le début ?

Une nouvelle requête est une nouvelle génération, pas une continuation automatique de la réponse interrompue. Enregistrez la sortie partielle et l’identifiant de requête, marquez la réponse incomplète, et décidez de redémarrer ou de demander une continuation avec un contexte explicite. Pour les flux d’outils, conservez les actions réalisées afin qu’un réessai ne puisse pas les exécuter deux fois.

Comment valider les réponses média de l’API Muse Wonder ?

Utilisez une petite image ou un document de test avec des faits connus et posez des questions dont les réponses exigent ces faits. Comparez la réponse à l’original, y compris les nombres et les références de page. Un statut HTTP réussi seul ne prouve pas que l’endpoint a accepté ou interprété correctement le média ; inspectez les erreurs et les formats de requête avant d’augmenter l’ingestion.

Comment auditer un écart de coût de l’API Muse Wonder ?

Enregistrez l’usage retourné, le modèle, la route, l’heure de la requête et le tarif du compte à ce moment-là. Séparez l’entrée non mise en cache, les lectures de cache vérifiées et le total de sortie facturé, raisonnement inclus le cas échéant. Comparez ces quantités au relevé de facturation ; vérifiez la devise, les changements de tarif et les frais supplémentaires avant de supposer une erreur de comptage de jetons.

Conclusion

Commencez par une requête CometAPI authentifiée, confirmez la réponse retournée, puis ajoutez le streaming et les capacités dont votre application a besoin. Avant le déploiement en production, validez la route sélectionnée, vérifiez la facturation, imposez des autorisations pour les outils et gardez un modèle de repli. Étendez le trafic uniquement lorsque la réussite mesurée des tâches, la latence et le coût respectent vos critères d’acceptation.