So verwenden Sie die Muse Wonder API: Python, Streaming & Preisgestaltung

TL;DR

Muse Wonder ist das Vorschau-Modell von Meta für komplexes Coding, Reasoning und agentische Workflows. Entwickler können über einen OpenAI-kompatiblen Client und model="muse-wonder" auf die Muse Wonder API in CometAPI zugreifen. Dieser Leitfaden hilft Entwicklern mit Erfahrung in Python oder JavaScript, eine erste Anfrage zu senden, Streaming hinzuzufügen und Reasoning, Medien und Kosten zu evaluieren. Im Vergleich zu Muse Spark liegt der praktische Grund, Wonder zu evaluieren, in seinem Potenzial, schwierige Aufgaben zuverlässiger abzuschließen; ein großes Kontextfenster allein ist kein Grund für eine Migration.

Key Takeaways

• Integration: Verwenden Sie einen Backend-API-Schlüssel, https://api.cometapi.com/v1, und model="muse-wonder".
• Capacity: Muse Wonder verfügt über ein Kontextfenster mit 1,048,576 Token; kürzen Sie wiederholten Kontext, um die Kosten zu steuern.
• Capabilities: Bewerten Sie Streaming, Tool-Aufrufe und Medien separat auf der gewählten Gateway-Route.
• Reasoning: Das native Muse Wonder unterstützt Stufen von minimal bis max; höherer Aufwand erhöht den Token-Verbrauch und die Latenz.
• Deployment: Führen Sie Benchmarks mit realen Aufgaben durch, verifizieren Sie die aktuelle Abrechnung und behalten Sie ein Rollback-Modell bei, bevor Sie den Traffic ausweiten.

What Is Muse Wonder API?

Meta hat Muse Wonder am 12. Oktober 2026 eingeführt. Das Modell ist in der Vorschau über die Meta Model API für komplexes Coding, Reasoning und toolgetriebene Workflows verfügbar. CometAPI verwendet die Modellkennung muse-wonder; Metas native Kennung lautet muse-wonder-1.0.

Das native Modell konzentriert sich auf langfristiges Reasoning, Coding und toolgetriebene Arbeit. Anwendungen müssen weiterhin Tools, persistenten Zustand, Stoppbedingungen und Berechtigungsprüfungen bereitstellen; ein einzelner Modellaufruf schafft keine autonome Ausführungsumgebung.

Muse Wonder API specifications

Muse Wonder vs Muse Wonder Full

Muse Wonder ist über die Meta Model API verfügbar; Muse Wonder Full ist nur über die Abonnements Power Usage und Maximum Usage in Muse Code verfügbar, und das Setzen von reasoning_effort auf max schaltet nicht auf Muse Wonder Full um. Siehe Metas Ankündigung.

Muse Spark API vs Muse Wonder API

Wählen Sie zwischen den Modellen anhand gemessener Aufgabenerfolge und Kosten. Der native Modellleitfaden empfiehlt Wonder für komplexe Arbeiten und Spark für kostenkritische Workloads; beide haben ein Kontextfenster von 1,048,576 Token. Vergleichen Sie eine konkrete Spark-Version, anstatt anzunehmen, dass alle Versionen identische Fähigkeiten haben.

Muse Spark eignet sich besser für kostenempfindliche Workloads; Muse Wonder zielt auf komplexes Coding und nachhaltiges Reasoning. Verifizieren Sie Medienunterstützung, Reasoning-Steuerung und Abrechnung für die genaue Modellversion und Gateway-Route. Behalten Sie das Modell, das Ihre Zielwerte für Aufgabenerfolg und Kosten erfüllt.

How to Use Muse Wonder API with CometAPI Step by Step

Step 1: Create and secure your CometAPI key

Erstellen Sie ein Konto, generieren Sie einen Backend-API-Schlüssel und halten Sie ihn aus Browsercode und öffentlichen Repositories heraus. Folgen Sie der CometAPI-Integrationsdokumentation für die Authentifizierung. Diese Beispiele erfordern ein finanziertes oder berechtigtes Konto, Python 3.10+ oder eine unterstützte Node.js-LTS-Umgebung sowie ausgehenden HTTPS-Zugriff. Speichern Sie JavaScript-Beispiele als .mjs-Dateien.

Setzen Sie den API-Schlüssel in einer Bash-Sitzung.

export COMETAPI_KEY="your_cometapi_api_key"

Setzen Sie den API-Schlüssel in einer PowerShell-Sitzung.

$env:COMETAPI_KEY="your_cometapi_api_key"

Step 2: Configure the Muse Wonder endpoint

Step 3: Send your first request with cURL

Senden Sie eine minimale authentifizierte Chat-Anfrage.

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

Eine erfolgreiche Nicht-Streaming-Anfrage sollte choices[0].message.content zurückgeben. Prüfen Sie das zurückgegebene Modell und die Nutzung, sofern geliefert, und bestätigen Sie, dass der Text Ihre Eingabe beantwortet. Bei Authentifizierungsfehlern prüfen Sie die Zugangsdaten; ein Fehler wegen eines ungültigen Modells erfordert eine Prüfung des Modellzugriffs. Beispiele veranschaulichen Anfrage-Muster und stellen keine gemessene Latenz oder Benchmark-Ergebnisse dar.

Step 4: Make a Python request

Installieren Sie die Python-Clientbibliothek.

pip install --upgrade openai

Senden Sie eine Python-Anfrage und prüfen Sie die Token-Nutzung.

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

Installieren Sie die JavaScript-Clientbibliothek.

npm install openai

Senden Sie eine Node.js-Anfrage.

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

Streaming liefert inkrementelle Antwortstücke über Server-Sent Events. Es verbessert die wahrgenommene Reaktionsfähigkeit, nicht zwingend die Gesamtkosten oder die Abschlusszeit. Zeigen Sie nur Chunks mit Inhalt an und behandeln Sie Unterbrechungen und Timeouts.

Python streaming example

Inkrementelle Python-Antwort-Chunks lesen.

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

Inkrementelle Node.js-Antwort-Chunks lesen.

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

Das native Modell akzeptiert minimal, low, medium, high, xhigh und max; keine davon ist nicht unterstützt. Beginnen Sie mit einer moderaten Einstellung und erhöhen Sie sie nur, wenn Ihre Evaluierungen den zusätzlichen Latenz- und Ausgabe-Token-Aufwand rechtfertigen. Siehe die Meta-Referenz zur Reasoning-Funktion. Testen Sie Gateway-Weiterleitungen separat.

How to Set Reasoning Effort in Chat Completions

Das folgende Beispiel sendet high über das Gateway als Fähigkeitstest. Falls abgelehnt, prüfen Sie den Fehler, bevor Sie das Feld entfernen: Ein 400 kann auch auf ungültige Nachrichten, ein falsches Modell oder ein anderes Anfragenproblem hinweisen. Versuchen Sie es mit der minimalen Textanfrage erneut, um die Ursache einzugrenzen.

Hohen Reasoning-Effort auf dem Gateway testen.

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

Metas native Responses-API verschachtelt das Feld als reasoning.effort und verwendet muse-wonder-1.0. Das folgende Beispiel nutzt Meta-Zugangsdaten und den nativen Endpunkt; bestätigen Sie die Responses-Unterstützung separat, bevor Sie es für CometAPI anpassen.

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 ändert das Reasoning-Budget des ausgewählten Modells. Es ändert nicht die Modellkennung und gewährt keinen Zugriff auf Full; die Zugangsunterscheidung wird in der Modelleinführung erklärt.

How Can Muse Wonder API Analyze Images and PDFs

Meta dokumentiert Bild-, Video-, Audio- und PDF-Eingaben für das native Wonder. Metas native Medienunterstützung garantiert nicht, dass CometAPI dasselbe Inhaltsschema, dieselbe URL-Form, Dateitypen oder Größenlimits akzeptiert. Verifizieren Sie diese Details auf der gewählten Route vor dem Produktionseinsatz. Das folgende image_url-Beispiel ist ein Kompatibilitätsmuster: Verwenden Sie ein zugängliches Bild unter Ihrer Kontrolle, bestätigen Sie die Endpunktunterstützung und prüfen Sie die Antwort anhand sichtbarer Details.

Testen Sie eine Bild-URL mit einem bekannten Bild.

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)

Für einen vorhersagbaren, rein textbasierten PDF-Workflow extrahieren Sie lokal auswählbaren Text und senden ausgewählte Passagen als Text. Dies testet keine native PDF-Eingabe und bewahrt nicht Seitenlayout, Abbildungen oder gescannte Inhalte. Das Beispiel begrenzt die Eingabe auf 50.000 Zeichen für einen kleinen Test; die Produktion sollte Inhalte selektieren oder in Blöcke teilen und Seitenreferenzen beibehalten, statt einen Bericht stillschweigend zu kürzen.

Auswählbaren PDF-Text für einen begrenzten Test extrahieren.

# 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

Ein Modell kann einen Funktionsaufruf anfordern, aber die Anwendung muss ihn autorisieren und ausführen. Dieses Beispiel demonstriert eine begrenzte, schreibgeschützte Bestellabfrage; Produktionsimplementierungen sollten Eingaben validieren und Tools anhand von Berechtigungen einschränken.

Eine begrenzte Tool-Anfrage zum Bestellstatus ausführen.

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)

Dieses Lehrbeispiel verarbeitet eine Runde von Tool-Aufrufen. Falls die Folgeantwort einen weiteren Tool-Aufruf anfordert, fahren Sie nur innerhalb einer begrenzten Schleife fort und validieren Sie erneut Namen und Argumente. Persistieren Sie Tool-Ergebnisse für Wiederholsicherheit; ein Produktionsagent benötigt außerdem ein Zeitlimit, ein Iterationslimit und eine klare Abschlussbedingung.

How Much Does Muse Wonder API Cost

Metas offizielle Preise nennen $4.00 pro eine Million nicht gecachter Eingabe-Token, $0.20 pro eine Million gecachter Eingabe-Token und $20.00 pro eine Million Ausgabe-Token.

Die Preisübersicht des Ausgangsartikels vom 14. Oktober 2026 listet CometAPI mit $3.20 pro eine Million nicht gecachter Eingabe-Token und $16.00 pro eine Million Ausgabe-Token. Dies sind Gateway-Tarife und kein Ersatz für Metas $4.00 (Input) und $20.00 (Output). Bestätigen Sie Ihre aktuellen Konto- und Routenpreise vor der Nutzung; ein CometAPI-Tarif für gecachte Eingaben wird nicht vorausgesetzt.

Für 100,000 nicht gecachte Eingabe-Token und 50,000 berechnete Ausgabe-Token ergeben die aufgeführten Meta-Raten $0.40 + $1.00 = $1.40. Die aufgeführten CometAPI-Raten ergeben $0.32 + $0.80 = $1.12. Dieses Beispiel schließt Zusatzkosten aus und nimmt keinen Cache-Rabatt an.

Für dieses nicht gecachte Beispiel liefern die angezeigten CometAPI-Raten eine um 20% niedrigere Schätzung. Reale Rechnungen hängen von der Token-Nutzung, der Routenabrechnung und etwaigen Zusatzkosten ab. Wenn Caching gilt, berechnen Sie es mit dem verifizierten Cache-Tarif, statt den nicht gecachten Input-Tarif auf jeden Token anzuwenden.

Schätzen Sie die Kosten mit den CometAPI-Raten aus der Quellaufnahme; ersetzen Sie sie durch Ihre verifizierten Kontoraten.

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

Die meisten OpenAI-kompatiblen Clientintegrationen können ihre Grundstruktur beibehalten. Aktualisieren Sie die Base-URL, die Zugangsdaten und die Modell-ID und führen Sie dann eine gestufte Evaluierung mit realen Prompts durch. Protokollspezifische Reasoning- und Multimodal-Felder benötigen eine separate Verifizierung.

Setzen Sie COMETAPI_KEY, aktualisieren Sie die Base-URL auf https://api.cometapi.com/v1 und wählen Sie muse-wonder. Verifizieren Sie Authentifizierung und Modellzugriff mit einer minimalen Textanfrage. Testen Sie dann Reasoning-Felder, Streaming-Chunks, Tool-Aufrufausführung und etwaige Medienformate jeweils separat. Untersuchen Sie Fehler und Antwortqualität: Ein HTTP 400 kann mehrere Ursachen haben, während ein erfolgreicher HTTP-Status allein die Fähigkeitsunterstützung nicht beweist. Protokollieren Sie zurückgegebene Nutzung und vergleichen Sie die Kosten mit Ihrem Budget. Halten Sie Base-URL und Modell konfigurierbar, um zurückrollen zu können.

Umgebungsgetriebene Migration und Rollback konfigurieren.

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)

Beginnen Sie mit einem kleinen Canary-Anteil des Live-Traffics. Vergleichen Sie Korrektheit, Tool-Erfolg, First-Token-Latenz, Gesamtlatenz, Retrieversuche/Retry-Rate und Gesamtkosten pro erfolgreich abgeschlossener Aufgabe, bevor Sie den Rollout ausweiten.

Add Timeouts, Retry Limits and Monitoring

Setzen Sie Anfrage-Timeouts und explizite Limits; protokollieren Sie nicht sensible Request-IDs und Token-Nutzung; reduzieren Sie nach Möglichkeit personenbezogene Daten; wiederholen Sie nur transiente Fehler; und verlangen Sie Autorisierung für irreversible Tool-Aktionen. Ein günstigerer Modellaufruf ist nicht zwingend eine günstigere Aufgabe, wenn er zu Retries führt.

Transiente Fehler mit begrenztem exponentiellem Backoff wiederholen.

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

Vorgeschlagene Betriebsmetrik: Kosten pro erfolgreicher Aufgabe = Gesamtkosten für Modell und Tools / Anzahl der erfolgreichen Aufgaben. Verfolgen Sie Sicherheits- und Korrektheitsleitplanken ebenso wie aggregierte Kosten.

FAQ

Why can Muse Wonder API stop before its final answer?

Reasoning und sichtbarer Text teilen sich ein Abschlussbudget in der nativen API. Eine lange Reasoning-Phase kann weniger Raum für die finale Antwort lassen. Prüfen Sie den Abschlussgrund und die Nutzung, reduzieren Sie den Aufwand oder engen Sie die Aufgabe ein und erhöhen Sie die route-unterstützte Abschlussgrenze nur innerhalb Ihres Budgets. Ein unterbrochenes Streaming erfordert eine separate Transportdiagnose.

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

Eine neue Anfrage ist eine neue Generierung und keine automatische Fortsetzung der unterbrochenen Antwort. Speichern Sie Teilausgaben und die Anfragekennung, markieren Sie die Antwort als unvollständig und entscheiden Sie, ob Sie neu starten oder mit explizitem Kontext um eine Fortsetzung bitten. Persistieren Sie bei Tool-Workflows abgeschlossene Aktionen, damit ein Retry sie nicht doppelt ausführt.

How do I validate Muse Wonder API media answers?

Verwenden Sie ein kleines Testbild oder Dokument mit bekannten Fakten und stellen Sie Fragen, deren Antworten diese Fakten erfordern. Vergleichen Sie die Antwort mit dem Original, einschließlich Zahlen und Seitenverweisen. Ein erfolgreicher HTTP-Status allein beweist nicht, dass der Endpunkt die Medien korrekt akzeptiert oder interpretiert hat; prüfen Sie Fehler und Anforderungsformate, bevor Sie die Ingestion skalieren.

How can I audit a Muse Wonder API cost discrepancy?

Protokollieren Sie zurückgegebene Nutzung, Modell, Route, Anfragezeit und den zum jeweiligen Zeitpunkt geltenden Kontotarif. Trennen Sie nicht gecachte Eingaben, verifizierte Cache-Lesezugriffe und die insgesamt berechneten Ausgaben, einschließlich Reasoning, wo zutreffend. Vergleichen Sie diese Größen mit dem Abrechnungsdatensatz; prüfen Sie Währung, Tarifänderungen und Zusatzgebühren, bevor Sie von einem Token-Abrechnungsfehler ausgehen.

Conclusion

Beginnen Sie mit einer authentifizierten CometAPI-Anfrage, bestätigen Sie die zurückgegebene Antwort und fügen Sie dann Streaming und die für Ihre Anwendung benötigten Fähigkeiten hinzu. Validieren Sie vor dem Produktionseinsatz die gewählte Route, verifizieren Sie die Abrechnung, erzwingen Sie Tool-Berechtigungen und halten Sie ein Rollback-Modell bereit. Weiten Sie den Traffic erst aus, wenn gemessener Aufgabenerfolg, Latenz und Kosten Ihre Akzeptanzkriterien erfüllen.