## Basic model info

- Model name: meta/meta muse-wonder
- Model description: Meta's frontier reasoning model for complex personal and professional agentic tasks — expert-level work in law, finance and health, frontier coding, and long-horizon multi-step agents with Active Memory and Active Focus. Accepts text, image, video, audio and PDF inputs with a 1M-token context window; reasoning always on.
- Endpoint name: chat/completions


## Model schema

The model schema is defined in the OpenAPI schema: [OpenAPI Schema](https://oapi.sunra.ai/main/llm.json)

### Model input schema

The model input schema is:



```json

```



### Model output schema

The model output schema is:



```json

```



## Example inputs and outputs

Use the following example inputs and outputs to understand the model.

### Input example



```json
{
}
```



### Output example



```json
{
}
```



## Model code examples

### JavaScript



```javascript
import { sunra } from "@sunra/client";

const result = await sunra.subscribe("meta/muse-wonder/chat/completions", {
  input: {},
  logs: true,
  onQueueUpdate: (update) => {
    console.log(`Status Update: ${update.status}, Request ID: ${update.request_id}`);
  },
});
console.log(result.data);
console.log(result.requestId);
```



### Python



```python
import sunra_client

result = sunra_client.subscribe(
    "meta/muse-wonder/chat/completions",
    arguments={
    
    },

    with_logs=True,
    on_enqueue=print,
    on_queue_update=print,
)
print(result)
```



### Java



```java
import ai.sunra.client.*;
import java.util.Map;
import com.google.gson.JsonObject;

var client = SunraClient.withEnvCredentials();

var response = client.subscribe(
    "meta/muse-wonder/chat/completions",
    SubscribeOptions.<JsonObject>builder()
        .input(Map.of(
            ))

        .resultType(JsonObject.class)
        .onQueueUpdate(update -> System.out.printf(
            "\nStatus Update: %s, Request ID: %s%n",
            update.getStatus(),
            update.getRequestId()
        ))
        .logs(true)
        .build()
);

System.out.println("Completed!");
System.out.println(response.getData());
  
```



### Kotlin



```kotlin
import ai.sunra.client.kt.*
import com.google.gson.JsonObject

val client = createSunraClient()

val response = client.subscribe<JsonObject>(
    endpointId = "meta/muse-wonder/chat/completions",
    input = mapOf(
            ),
    options = ai.sunra.client.kt.SubscribeOptions(logs = true),
    onUpdate = { update ->
        println("\nStatus Update: ${update.status}, Request ID: ${update.requestId}")
    }
)

println("Completed!")
println(response.data)
  
```



### Curl



```bash

curl --request POST \
  --url https://api.sunra.ai/v1/queue/meta/muse-wonder/chat/completions \
  --header "Authorization: Key $SUNRA_KEY" \
  --header "Content-Type: application/json" \
  --data '{}'
    
```



## Model readme

> Muse Wonder is available through OpenRouter's official Meta endpoint using `meta/muse-wonder` on `https://api-llm.sunra.ai/v1`.
> 
> ### API compatibility
> 
> - Chat Completions, Responses and Messages support streaming and non-streaming requests, including function tools.
> - Reasoning is always enabled. `reasoning_effort: "none"` is rejected with HTTP 400. The supported low, medium and high levels reach the upstream; actual reasoning token counts depend on the task and are not a fixed budget or guaranteed monotonic sequence.
> - `temperature`, `top_k` and `response_format` with `json_schema` are forwarded. Invalid values return upstream validation errors.
> - Tools currently support `tool_choice: "auto"` only. Meta rejects `none`, `required` and named function choices.
> - Messages accepts `thinking: {"type":"enabled","budget_tokens":1024}`. This does not disable the model's mandatory reasoning.
> - OpenRouter-native `reasoning` objects are forwarded: disabling reasoning and invalid effort values return the upstream's HTTP 400 errors. `include_reasoning: false` hides returned reasoning text, while `true` exposes it when available; reasoning usage is still billed in both cases.
> 
> ### Usage and budget limits
> 
> Reasoning tokens are included in completion tokens and billed once at the output rate. The upstream may occasionally report more completion tokens than the requested limit: production and direct upstream tests with `max_tokens:1100` returned 1147 and 1148 tokens. From October 14, 2026, budget-pool child keys can use Muse Wonder: output reservations include 64 completion tokens above the requested ceiling, while the client body and upstream ceiling remain unchanged. Payment uses actual usage. This fixed reserve covers measured overshoots and is not a provider guarantee for every request.
> 
> Implicit cache reads were observed, including 4454 cached tokens out of a repeated 4524-token prompt. Cache admission is not guaranteed and identical requests can miss. Fresh input costs $4, output costs $20 and cache reads cost $0.20 per million tokens.