feat(ai): add Meta provider (#47826)

2026-10-16 10:30:01 +08:00 · 2026-09-07 15:13:48 -05:00
parent b32d8c3e58
commit 72433f2ed8
40 changed files with 2478 additions and 0 deletions
@@ -69,6 +69,76 @@ M2.x models always think, even when a disabling option is supplied. For tool con
 The default API bases are `https://api.minimax.io/anthropic/v1` for Messages and `https://api.minimax.io/v1` for
 Chat and Responses. `configure({ baseURL })` replaces the selected API's base, including its version prefix.

+## Meta
+
+Use Meta's direct [Model API](https://dev.meta.ai/docs/overview) with `META_API_KEY`:
+
+```ts
+import { Meta } from "@opencode-ai/ai/providers"
+
+const meta = Meta.configure() // or Meta.configure({ apiKey })
+const request = LLM.request({
+  model: meta.responses("muse-spark-1.3"), // meta.model(...) also selects Responses
+  prompt: "What is 173 multiplied by 219? Reply with the integer.",
+  providerOptions: { reasoningEffort: "low" },
+  generation: { maxTokens: 1024 },
+})
+```
+
+`meta.chat("muse-spark-1.3")` selects Chat Completions; `meta.messages("muse-spark-1.3")` selects
+the Anthropic-compatible Messages API. All use `https://api.meta.ai/v1`. The package entrypoints
+`@opencode-ai/ai/providers/meta/responses`, `meta/chat`, and `meta/messages` expose `model(modelID, settings)`.
+
+[Muse Spark](https://dev.meta.ai/docs/models) supports `minimal`, `low`, `medium`, `high`, and
+`xhigh` reasoning effort; standard-tier 1.3 also supports `max`. Omitting effort uses the model's
+default. Muse Spark always reasons and rejects `none`. The output-token budget includes private reasoning.
+
+Responses defaults to `store: false` and `include: ["reasoning.encrypted_content"]`. Preserve
+`response.message` along with matching `Message.tool(...)` results in subsequent requests to replay
+reasoning through tool loops. Optional `reasoningSummary: "auto"` requests a readable summary.
+For server-managed history, override `store: true, include: []` and send the response ID through
+`http: { body: { previous_response_id: responseID } }` with only the new input.
+Chat Completions redacts private reasoning and cannot carry it between calls.
+Responses and Chat support only `toolChoice: "auto"` (the default). Messages also accepts `"none"`;
+its documented forced `"any"` choice currently returns HTTP 400. Messages defaults to adaptive thinking
+with `display: "omitted"`, preserving encrypted `redacted_thinking` in `response.message`. Use
+`providerOptions: { effort: "low" }` for depth or `thinking: { type: "enabled", budgetTokens: 1024 }`
+for budget compatibility (with `generation.maxTokens > 1024`).
+
+Add `tools: [Meta.webSearch()]` to a Spark Responses or Messages request for hosted web search.
+Responses exposes hosted results and URL citations in text-part `providerMetadata.meta.annotations`.
+To include search result lists, set `include: ["reasoning.encrypted_content", "web_search_call.results"]`.
+Messages exposes hosted search calls; the recorded Messages API stream does not supply structured
+citations or separate result blocks. Retain `response.message` for either API's continuation.
+
+Use `Image.generate` for one-off generation or editing:
+
+```ts
+import { Image, ImageInput } from "@opencode-ai/ai"
+
+const generation = Image.generate({
+  model: meta.image("muse-image-1.0"),
+  prompt: "A flat black square on a white background.",
+  options: { n: 1, reasoningStrength: "low" },
+})
+
+const edit = Image.generate({
+  model: meta.image("muse-image-1.0"),
+  prompt: "Make the square purple.",
+  images: [ImageInput.bytes(imageBytes, "image/webp")],
+  options: { outputFormat: "png", reasoningStrength: "low" },
+})
+```
+
+The default image format is WEBP; `outputFormat` also accepts PNG/JPEG and `responseFormat: "url"`
+returns a signed URL. `size` is an aspect-ratio hint. For conversational images, select
+`meta.responses("muse-image-1.0")` with `tools: [Meta.imageGeneration({ reasoningStrength: "low" })]`.
+Generated images are provider-executed tool results with file content. Retain `response.message` to
+replay the signed image handle on the next request. Muse Image accepts only the `image_generation` tool.
+
+Meta Responses is explicitly HTTP/SSE-only and does not use WebSockets, even when a caller supplies
+`StreamOptions.webSocket`. The public `/v1/responses` endpoint rejects WebSocket upgrades with HTTP 405 (`Allow: POST`).
+
 ## Image generation

 Use `Image.generate` with an image model for direct asset generation:
@@ -0,0 +1,133 @@
+import { Effect, Encoding, Schema } from "effect"
+import { Headers, HttpClientRequest } from "effect/unstable/http"
+import { GeneratedImage, ImageModel, ImageResponse, type ImageRequestFor, type ImageRoute } from "../image.js"
+import { Auth } from "../route/auth.js"
+import { Usage, mergeHttpOptions, mergeJsonRecords, type HttpOptions } from "../schema/index.js"
+import { JsonObject, ProviderShared, optionalNull } from "./shared.js"
+import { ImageInputs } from "./utils/image-input.js"
+
+type OpenString<Known extends string> = Known | (string & {})
+export type ImageOptions = {
+  readonly n?: number
+  /** Aspect ratio hint, not an exact output resolution. */
+  readonly size?: string
+  readonly outputFormat?: OpenString<"webp" | "png" | "jpeg">
+  readonly responseFormat?: OpenString<"b64_json" | "url">
+  readonly reasoningStrength?: OpenString<"low" | "high">
+  readonly toolEnablement?: {
+    readonly enable_image_search?: boolean
+    readonly enable_web_search?: boolean
+    readonly enable_shell?: boolean
+  }
+  readonly [key: string]: unknown
+}
+
+const Body = Schema.StructWithRest(
+  Schema.Struct({
+    model: Schema.String,
+    prompt: Schema.String,
+    images: Schema.optional(Schema.Array(JsonObject)),
+    n: Schema.optional(Schema.Number),
+    size: Schema.optional(Schema.String),
+    output_format: Schema.optional(Schema.String),
+    response_format: Schema.optional(Schema.String),
+    reasoning_strength: Schema.optional(Schema.String),
+    tool_enablement: Schema.optional(Schema.Record(Schema.String, Schema.Boolean)),
+  }),
+  [JsonObject],
+)
+
+const Response = Schema.Struct({
+  data: Schema.Array(Schema.Struct({ b64_json: optionalNull(Schema.String), url: optionalNull(Schema.String) })),
+  output_format: Schema.optional(Schema.String),
+  usage: Schema.optional(
+    Schema.Struct({
+      input_tokens: Schema.optional(Schema.Number),
+      output_tokens: Schema.optional(Schema.Number),
+      total_tokens: Schema.optional(Schema.Number),
+    }),
+  ),
+})
+
+export const model = (input: {
+  readonly id: string
+  readonly auth: Auth.Definition
+  readonly baseURL: string
+  readonly headers?: Record<string, string>
+  readonly http?: HttpOptions
+}) => {
+  const route: ImageRoute<ImageOptions> = {
+    id: "meta-images",
+    generate: Effect.fn("MetaImages.generate")(function* (request: ImageRequestFor<ImageOptions>, execute) {
+      const http = mergeHttpOptions(request.model.http, request.http)
+      const images = yield* Effect.forEach(request.images ?? [], (image) => {
+        if (image.type === "bytes") return Effect.succeed({ image_url: ImageInputs.dataUrl(image) })
+        if (image.type === "url") return Effect.succeed({ image_url: image.url })
+        return ImageInputs.invalid("Meta Images accepts image bytes and URLs")
+      })
+      const { outputFormat, responseFormat, reasoningStrength, toolEnablement, ...native } = request.options ?? {}
+      const payload = yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(Body))(
+        mergeJsonRecords(
+          {
+            model: request.model.id,
+            prompt: request.prompt,
+            images: images.length === 0 ? undefined : images,
+            output_format: outputFormat,
+            response_format: responseFormat,
+            reasoning_strength: reasoningStrength,
+            tool_enablement: toolEnablement,
+          },
+          native,
+          http?.body,
+        ),
+      )
+      const body = ProviderShared.encodeJson(payload)
+      const url = new URL(`${input.baseURL.replace(/\/$/, "")}/images/${images.length === 0 ? "generations" : "edits"}`)
+      Object.entries(http?.query ?? {}).forEach(([key, value]) => url.searchParams.set(key, value))
+      const headers = yield* Auth.toEffect(input.auth)({
+        request,
+        method: "POST",
+        url: url.toString(),
+        body,
+        headers: Headers.fromInput({ ...input.headers, ...http?.headers }),
+      })
+      const response = yield* execute(
+        HttpClientRequest.post(url.toString()).pipe(
+          HttpClientRequest.setHeaders(headers),
+          HttpClientRequest.bodyText(body, "application/json"),
+        ),
+      )
+      const output = yield* ProviderShared.imageResponse("meta-images", "Meta Images", response)
+      const decoded = yield* Schema.decodeUnknownEffect(Schema.fromJsonString(Response))(output.body).pipe(
+        Effect.mapError((cause) => output.invalid("Meta Images returned an invalid response", cause)),
+      )
+      const format = decoded.output_format ?? payload.output_format ?? "webp"
+      const generated = yield* Effect.forEach(decoded.data, (item, index) => {
+        if (item.b64_json)
+          return Effect.fromResult(Encoding.decodeBase64(item.b64_json)).pipe(
+            Effect.mapError((cause) => output.invalid(`Meta Images result ${index} contains invalid base64`, cause)),
+            Effect.map((data) => new GeneratedImage({ mediaType: `image/${format}`, data })),
+          )
+        if (item.url) return Effect.succeed(new GeneratedImage({ mediaType: `image/${format}`, data: item.url }))
+        return output.invalid(`Meta Images result ${index} has neither image data nor a URL`)
+      })
+      if (generated.length === 0) return yield* output.invalid("Meta Images returned no images")
+      return new ImageResponse({
+        images: generated,
+        usage:
+          decoded.usage === undefined
+            ? undefined
+            : new Usage({
+                inputTokens: decoded.usage.input_tokens,
+                outputTokens: decoded.usage.output_tokens,
+                totalTokens: decoded.usage.total_tokens,
+                providerMetadata: { meta: decoded.usage },
+              }),
+        providerMetadata: { meta: { outputFormat: format } },
+      })
+    }),
+  }
+  return ImageModel.make<ImageOptions>({ id: input.id, provider: "meta", route, http: input.http })
+}
+
+export * as MetaImages from "./meta-images.js"
@@ -0,0 +1,52 @@
+import { Effect, Schema } from "effect"
+import { Protocol } from "../route/protocol.js"
+import type { LLMRequest } from "../schema/index.js"
+import { AnthropicMessages } from "./anthropic-messages.js"
+import { MetaResponses } from "./meta-responses.js"
+import { JsonObject, optionalArray, ProviderShared } from "./shared.js"
+
+const WebSearch = Schema.Struct({
+  type: Schema.Literal("web_search"),
+  name: Schema.Literal("web_search"),
+  user_location: MetaResponses.WebSearch.fields.user_location,
+})
+const Body = Schema.Struct({
+  ...AnthropicMessages.AnthropicMessagesBody.fields,
+  tools: optionalArray(
+    Schema.Union([
+      Schema.Struct({ name: Schema.String, description: Schema.String, input_schema: JsonObject }),
+      WebSearch,
+    ]),
+  ),
+})
+
+const fromRequest = Effect.fn("MetaMessages.fromRequest")(function* (request: LLMRequest) {
+  const projected = ProviderShared.flattenToolRequest(request)
+  const body = yield* AnthropicMessages.protocol.body.from(projected.request)
+  return {
+    ...body,
+    tools:
+      body.tools === undefined
+        ? undefined
+        : yield* Effect.forEach(body.tools, (tool, index) =>
+            Effect.gen(function* () {
+              const native = projected.tools[index]?.native
+              if (native === undefined) return tool
+              const search = yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(MetaResponses.WebSearch))(
+                native.meta,
+              )
+              if (search.search_context_size !== undefined)
+                return yield* ProviderShared.invalidRequest("Meta Messages does not support searchContextSize")
+              return { type: "web_search" as const, name: "web_search" as const, user_location: search.user_location }
+            }),
+          ),
+  }
+})
+
+export const protocol = Protocol.make({
+  id: "meta-messages",
+  body: { schema: Body, from: fromRequest },
+  stream: AnthropicMessages.protocol.stream,
+})
+
+export * as MetaMessages from "./meta-messages.js"
@@ -0,0 +1,238 @@
+import { Effect, Encoding, Schema } from "effect"
+import { Protocol } from "../route/protocol.js"
+import { HttpTransport } from "../route/transport/index.js"
+import { LLMEvent, LLMRequest, Message, ToolResultPart } from "../schema/index.js"
+import { OpenResponses } from "./open-responses.js"
+import { JsonObject, optionalArray, optionalNull, ProviderShared } from "./shared.js"
+import { ResponsesHostedTools } from "./utils/responses-hosted-tools.js"
+import { ToolSchemaProjection } from "./utils/tool-schema.js"
+import { MetaImage } from "./utils/meta-image.js"
+
+const ADAPTER = "meta-responses"
+const NAME = "Meta Responses"
+
+export const WebSearch = Schema.Struct({
+  type: Schema.Literal("web_search"),
+  search_context_size: Schema.optional(Schema.String),
+  user_location: Schema.optional(
+    Schema.Struct({
+      type: Schema.Literal("approximate"),
+      city: Schema.optional(Schema.String),
+      region: Schema.optional(Schema.String),
+      country: Schema.optional(Schema.String),
+      timezone: Schema.optional(Schema.String),
+    }),
+  ),
+})
+
+export const ImageGeneration = Schema.Struct({
+  type: Schema.Literal("image_generation"),
+  size: Schema.optional(Schema.String),
+  output_format: Schema.optional(Schema.String),
+  reasoning_strength: Schema.optional(Schema.String),
+  enable_image_search: Schema.optional(Schema.Boolean),
+  enable_web_search: Schema.optional(Schema.Boolean),
+  enable_shell: Schema.optional(Schema.Boolean),
+})
+
+const NativeTool = Schema.Union([WebSearch, ImageGeneration])
+const ImageItem = Schema.Struct({
+  type: Schema.Literal("image_generation_call"),
+  id: Schema.String,
+  status: Schema.optional(Schema.String),
+  result: optionalNull(Schema.String),
+  output_format: Schema.optional(Schema.String),
+  error: Schema.optional(Schema.Unknown),
+})
+
+const Body = Schema.Struct({
+  ...OpenResponses.coreFields,
+  input: Schema.Array(Schema.Union([OpenResponses.InputItem, ImageItem])),
+  tools: optionalArray(Schema.Union([OpenResponses.Tool, NativeTool])),
+  stream: Schema.Literal(true),
+})
+
+const MessageAnnotations = Schema.Struct({
+  content: Schema.Array(Schema.Struct({ annotations: optionalArray(JsonObject) })),
+})
+
+interface ParserState extends OpenResponses.ParserState {
+  readonly completedItems: ReadonlySet<string>
+}
+
+const adapter = {
+  id: ADAPTER,
+  name: NAME,
+  restoreHostedToolItem: (item: unknown) => (Schema.is(ImageItem)(item) ? item : undefined),
+} satisfies OpenResponses.ProviderAdapter
+
+const fromRequest = Effect.fn("MetaResponses.fromRequest")(function* (request: LLMRequest) {
+  const key = request.model.route.providerMetadataKey ?? String(request.model.provider)
+  const projected = ProviderShared.flattenToolRequest(
+    LLMRequest.update(request, {
+      messages: request.messages.map((message) =>
+        Message.make({
+          ...message,
+          content: message.content.map((part) => {
+            if (
+              part.type !== "tool-result" ||
+              !part.providerExecuted ||
+              part.name !== "image_generation" ||
+              part.result.type !== "content" ||
+              part.providerMetadata?.[key]?.itemId !== part.id
+            )
+              return part
+            // Meta's signed image ID carries edit state; replay the handle, not the image bytes as a user message.
+            return ToolResultPart.make({
+              ...part,
+              result: {
+                type: "json",
+                value: { type: "image_generation_call", id: part.id, status: "completed", result: null },
+              },
+            })
+          }),
+        }),
+      ),
+    }),
+  )
+  return yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(Body))({
+    ...(yield* OpenResponses.lowerConversation(projected.request, adapter)),
+    ...OpenResponses.lowerGeneration(request),
+    tools:
+      projected.tools.length === 0
+        ? undefined
+        : yield* Effect.forEach(projected.tools, (tool) =>
+            Effect.gen(function* () {
+              if (tool.native === undefined)
+                return yield* OpenResponses.lowerTool(
+                  NAME,
+                  tool,
+                  ToolSchemaProjection.modelCompatibility(tool.inputSchema, request.model.compatibility?.toolSchema),
+                )
+              return yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(NativeTool))(tool.native.meta)
+            }),
+          ),
+    tool_choice:
+      OpenResponses.allowedToolChoice(request) ??
+      (request.toolChoice ? yield* OpenResponses.lowerToolChoice(NAME, request.toolChoice) : undefined),
+  })
+})
+
+const HOSTED_TOOLS = {
+  web_search_call: { name: "web_search", input: (item) => item.action ?? {} },
+  image_generation_call: {
+    name: "image_generation",
+    input: () => ({}),
+    result: Effect.fn("MetaResponses.imageResult")(function* (raw: ResponsesHostedTools.Item) {
+      const item = yield* Schema.decodeUnknownEffect(ImageItem)(raw).pipe(
+        Effect.mapError((cause) =>
+          ProviderShared.eventError(
+            ADAPTER,
+            "Meta returned an invalid image item",
+            ProviderShared.encodeJson(raw),
+            cause,
+          ),
+        ),
+      )
+      if (item.error !== undefined && item.error !== null) return { type: "error" as const, value: item.error }
+      if (!item.result)
+        return yield* ProviderShared.eventError(
+          ADAPTER,
+          "Meta returned an image without data",
+          ProviderShared.encodeJson(raw),
+        )
+      const data = yield* Effect.fromResult(Encoding.decodeBase64(item.result)).pipe(
+        Effect.mapError((cause) =>
+          ProviderShared.eventError(
+            ADAPTER,
+            "Meta returned invalid image base64",
+            ProviderShared.encodeJson(raw),
+            cause,
+          ),
+        ),
+      )
+      const mime = MetaImage.mediaType(data, item.output_format)
+      return {
+        type: "content" as const,
+        value: [{ type: "file" as const, uri: `data:${mime};base64,${item.result}`, mime }],
+      }
+    }),
+  },
+} satisfies ResponsesHostedTools.Definitions
+
+const onEvent = Effect.fn("MetaResponses.onEvent")(function* (
+  state: OpenResponses.ParserState,
+  input: OpenResponses.Event,
+) {
+  const event = OpenResponses.normalize(state, input)
+  if (event.type === "response.output_item.done" && event.item && ResponsesHostedTools.isItem(event.item, HOSTED_TOOLS))
+    return yield* ResponsesHostedTools.onDone(state, event.item, HOSTED_TOOLS)
+  const result = yield* OpenResponses.step(state, event)
+  if (event.type !== "response.output_item.done" || event.item?.type !== "message") return result
+  const message = yield* Schema.decodeUnknownEffect(MessageAnnotations)(event.item).pipe(
+    Effect.mapError((cause) =>
+      ProviderShared.eventError(
+        ADAPTER,
+        "Meta returned invalid message annotations",
+        ProviderShared.encodeJson(event),
+        cause,
+      ),
+    ),
+  )
+  const annotations = message.content.flatMap((part) => part.annotations ?? [])
+  if (annotations.length === 0) return result
+  return [
+    result[0],
+    result[1].map((item) =>
+      LLMEvent.is.textEnd(item)
+        ? LLMEvent.textEnd({
+            ...item,
+            providerMetadata: {
+              ...item.providerMetadata,
+              [state.providerMetadataKey]: { ...item.providerMetadata?.[state.providerMetadataKey], annotations },
+            },
+          })
+        : item,
+    ),
+  ] satisfies OpenResponses.StepResult
+})
+
+const step = Effect.fn("MetaResponses.step")(function* (state: ParserState, input: OpenResponses.Event) {
+  const completedItems = new Set(state.completedItems)
+  const event = OpenResponses.normalize(state, input)
+  if (event.type === "response.output_item.done" && event.item && completedItems.has(event.item.id))
+    return [state, []] as const
+  const events: LLMEvent[] = []
+  let current: OpenResponses.ParserState = state
+  // Muse Image delivers its image and optional summary only in response.completed.
+  // Recover terminal-only items in order, without duplicating Spark's streamed items.
+  if (event.type === "response.completed") {
+    for (const [index, item] of (event.response?.output ?? []).entries()) {
+      const done = OpenResponses.normalize(current, { type: "response.output_item.done", item, output_index: index })
+      // Spark changes reasoning IDs in the terminal snapshot; output indices still identify the streamed items.
+      if (!done.item || completedItems.has(done.item.id) || completedItems.has(state.outputItems[index] ?? "")) continue
+      const result = yield* onEvent(current, done)
+      current = result[0]
+      events.push(...result[1])
+      completedItems.add(done.item.id)
+    }
+  }
+  const result = yield* onEvent(current, event)
+  if (event.type === "response.output_item.done" && event.item) completedItems.add(event.item.id)
+  return [{ ...result[0], completedItems }, [...events, ...result[1]]] as const
+})
+
+export const protocol = Protocol.make({
+  id: ADAPTER,
+  body: { schema: Body, from: fromRequest },
+  stream: {
+    event: OpenResponses.protocol.stream.event,
+    initial: (request): ParserState => ({ ...OpenResponses.initial(request, adapter), completedItems: new Set() }),
+    step,
+    terminal: OpenResponses.terminal,
+  },
+})
+
+export const httpTransport = HttpTransport.sseJson.with<Schema.Schema.Type<typeof Body>>()
+
+export * as MetaResponses from "./meta-responses.js"
@@ -0,0 +1,11 @@
+// Responses image items can omit output_format, including when PNG/JPEG was requested.
+export const mediaType = (data: Uint8Array, format?: string) => {
+  if (format !== undefined) return `image/${format}`
+  if (data[0] === 137 && data[1] === 80 && data[2] === 78 && data[3] === 71) return "image/png"
+  if (data[0] === 255 && data[1] === 216 && data[2] === 255) return "image/jpeg"
+  if (new TextDecoder().decode(data.slice(0, 4)) === "RIFF" && new TextDecoder().decode(data.slice(8, 12)) === "WEBP")
+    return "image/webp"
+  return "application/octet-stream"
+}
+
+export * as MetaImage from "./meta-image.js"
@@ -16,6 +16,7 @@ export * as GoogleVertexChat from "./google-vertex-chat.js"
 export * as GoogleVertexMessages from "./google-vertex-messages.js"
 export * as GoogleVertexResponses from "./google-vertex-responses.js"
 export * as Groq from "./groq.js"
+export * as Meta from "./meta.js"
 export * as MiniMax from "./minimax.js"
 export * as Mistral from "./mistral.js"
 export * as OpenAI from "./openai.js"
@@ -0,0 +1,182 @@
+import type { ProviderPackage } from "../provider-package.js"
+import { OpenAIChat } from "../protocols/openai-chat.js"
+import { AnthropicMessages } from "../protocols/anthropic-messages.js"
+import { MetaResponses } from "../protocols/meta-responses.js"
+import { MetaMessages } from "../protocols/meta-messages.js"
+import { MetaImages } from "../protocols/meta-images.js"
+import { AuthOptions, type ProviderAuthOption } from "../route/auth-options.js"
+import { Route, type RouteDefaultsInput } from "../route/client.js"
+import { Endpoint } from "../route/endpoint.js"
+import { HttpOptions, ProviderID, ToolDefinition, type ModelID } from "../schema/index.js"
+import type { OpenResponsesProviderOptionsInput } from "./open-responses-options.js"
+
+export const id = ProviderID.make("meta")
+const baseURL = "https://api.meta.ai/v1"
+
+export type ProviderOptionsInput = OpenResponsesProviderOptionsInput &
+  Pick<AnthropicMessages.OptionsInput, "thinking" | "effort">
+export type MessagesOptionsInput = Pick<
+  AnthropicMessages.OptionsInput,
+  "thinking" | "effort" | "outputConfig" | "output_config" | "serviceTier" | "service_tier" | "metadata"
+> & { readonly [key: string]: unknown }
+export type ImageOptions = MetaImages.ImageOptions
+
+export interface WebSearchOptions {
+  readonly searchContextSize?: "low" | "medium" | "high" | (string & {})
+  readonly userLocation?: {
+    readonly city?: string
+    readonly region?: string
+    readonly country?: string
+    readonly timezone?: string
+  }
+}
+
+export const webSearch = (options: WebSearchOptions = {}) =>
+  ToolDefinition.make({
+    name: "web_search",
+    description: "Search the web with Meta's hosted search tool.",
+    inputSchema: { type: "object", properties: {}, additionalProperties: false },
+    native: {
+      meta: {
+        type: "web_search",
+        search_context_size: options.searchContextSize,
+        user_location:
+          options.userLocation === undefined ? undefined : { type: "approximate", ...options.userLocation },
+      },
+    },
+  })
+
+export interface ImageGenerationOptions {
+  readonly size?: string
+  readonly outputFormat?: "webp" | "png" | "jpeg" | (string & {})
+  readonly reasoningStrength?: "low" | "high" | (string & {})
+  readonly enableImageSearch?: boolean
+  readonly enableWebSearch?: boolean
+  readonly enableShell?: boolean
+}
+
+export const imageGeneration = (options: ImageGenerationOptions = {}) =>
+  ToolDefinition.make({
+    name: "image_generation",
+    description: "Generate or edit an image with Muse Image.",
+    inputSchema: { type: "object", properties: {}, additionalProperties: false },
+    native: {
+      meta: {
+        type: "image_generation",
+        size: options.size,
+        output_format: options.outputFormat,
+        reasoning_strength: options.reasoningStrength,
+        enable_image_search: options.enableImageSearch,
+        enable_web_search: options.enableWebSearch,
+        enable_shell: options.enableShell,
+      },
+    },
+  })
+
+export type LanguageModelOptions = Omit<RouteDefaultsInput, "providerOptions"> &
+  ProviderAuthOption<"optional"> & {
+    readonly baseURL?: string
+    readonly providerOptions?: ProviderOptionsInput
+  }
+
+export interface Settings extends ProviderPackage.Settings {
+  readonly apiKey?: string
+  readonly baseURL?: string
+  readonly providerOptions?: ProviderOptionsInput
+}
+
+const responsesRoute = Route.make({
+  id: "meta-responses",
+  provider: id,
+  providerMetadataKey: "meta",
+  protocol: MetaResponses.protocol,
+  endpoint: Endpoint.path("/responses", { baseURL }),
+  // Meta Responses does not support WebSocket upgrades; always use HTTP/SSE.
+  transport: MetaResponses.httpTransport,
+  defaults: { providerOptions: { store: false, include: ["reasoning.encrypted_content"] } },
+})
+
+const chatRoute = Route.make({
+  id: "meta-chat",
+  provider: id,
+  providerMetadataKey: "meta",
+  protocol: OpenAIChat.protocol,
+  endpoint: Endpoint.path("/chat/completions", { baseURL }),
+  framing: OpenAIChat.framing,
+})
+
+const messagesRoute = Route.make({
+  id: "meta-messages",
+  provider: id,
+  providerMetadataKey: "meta",
+  protocol: MetaMessages.protocol,
+  endpoint: Endpoint.path("/messages", { baseURL }),
+  framing: AnthropicMessages.framing,
+  defaults: { providerOptions: { thinking: { type: "adaptive", display: "omitted" } } },
+})
+
+export const routes = [responsesRoute, chatRoute, messagesRoute]
+
+export const configure = (input: LanguageModelOptions = {}) => {
+  const { apiKey: _apiKey, auth: _auth, baseURL: endpoint, ...defaults } = input
+  const options = {
+    ...defaults,
+    endpoint: { baseURL: endpoint ?? baseURL },
+    auth: AuthOptions.bearer(input, "META_API_KEY"),
+  }
+  const configuredResponses = responsesRoute.with(options)
+  const configuredChat = chatRoute.with(options)
+  const configuredMessages = messagesRoute.with(options)
+  const responses = (modelID: string | ModelID) =>
+    configuredResponses.model<OpenResponsesProviderOptionsInput>({ id: modelID })
+  const chat = (modelID: string | ModelID) =>
+    configuredChat.model<OpenResponsesProviderOptionsInput>({
+      id: modelID,
+      compatibility: { maxTokensField: "max_completion_tokens", supportsStore: false },
+    })
+  const messages = (modelID: string | ModelID) =>
+    configuredMessages.model<MessagesOptionsInput>({
+      id: modelID,
+      compatibility: { requireSignature: false },
+    })
+  const image = (modelID: string | ModelID) =>
+    MetaImages.model({
+      id: modelID,
+      baseURL: endpoint ?? baseURL,
+      auth: options.auth,
+      headers: input.headers,
+      http: input.http === undefined ? undefined : HttpOptions.make(input.http),
+    })
+  return { id, model: responses, responses, chat, messages, image, configure }
+}
+
+export const provider = configure()
+export const responses = provider.responses
+export const chat = provider.chat
+export const messages = provider.messages
+export const image = provider.image
+
+export const model: ProviderPackage.Definition<Settings, OpenResponsesProviderOptionsInput>["model"] = (
+  modelID,
+  settings,
+) => fromSettings(settings).responses(modelID)
+
+export const chatModel: ProviderPackage.Definition<Settings, OpenResponsesProviderOptionsInput>["model"] = (
+  modelID,
+  settings,
+) => fromSettings(settings).chat(modelID)
+
+export const messagesModel: ProviderPackage.Definition<Settings, MessagesOptionsInput>["model"] = (modelID, settings) =>
+  fromSettings(settings).messages(modelID)
+
+function fromSettings(settings: Settings) {
+  return configure({
+    apiKey: settings.apiKey,
+    baseURL: settings.baseURL,
+    headers: settings.headers,
+    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
+    providerOptions: settings.providerOptions,
+  })
+}
+
+export * as Meta from "./meta.js"
@@ -0,0 +1,2 @@
+export { chatModel as model } from "../meta.js"
+export type { Settings } from "../meta.js"
@@ -0,0 +1,2 @@
+export { messagesModel as model } from "../meta.js"
+export type { Settings } from "../meta.js"
@@ -0,0 +1,2 @@
+export { model } from "../meta.js"
+export type { Settings } from "../meta.js"
@@ -0,0 +1,56 @@
+{
+  "version": 1,
+  "metadata": {
+    "model": "muse-spark-1.3",
+    "tags": [
+      "prefix:meta-chat",
+      "provider:meta",
+      "protocol:openai-chat",
+      "tool",
+      "tool-loop",
+      "reasoning",
+      "usage",
+      "effort:low"
+    ],
+    "name": "meta-chat/continues-a-generated-tool-call",
+    "recordedAt": "2026-09-07T16:54:19.772Z"
+  },
+  "interactions": [
+    {
+      "transport": "http",
+      "request": {
+        "method": "POST",
+        "url": "https://api.meta.ai/v1/chat/completions",
+        "headers": {
+          "content-type": "application/json"
+        },
+        "body": "{\"model\":\"muse-spark-1.3\",\"messages\":[{\"role\":\"user\",\"content\":\"Look up the current weather in Paris using lookup_weather before answering. After receiving the result, report Paris's weather in one short sentence.\"}],\"tools\":[{\"type\":\"function\",\"function\":{\"name\":\"lookup_weather\",\"description\":\"Look up the current weather for a city\",\"parameters\":{\"type\":\"object\",\"properties\":{\"city\":{\"type\":\"string\",\"enum\":[\"Paris\"]}},\"required\":[\"city\"],\"additionalProperties\":false},\"strict\":false}}],\"tool_choice\":\"auto\",\"stream\":true,\"stream_options\":{\"include_usage\":true},\"reasoning_effort\":\"low\",\"max_completion_tokens\":1024}"
+      },
+      "response": {
+        "status": 200,
+        "headers": {
+          "content-type": "text/event-stream"
+        },
+        "body": "data: {\"id\":\"chatcmpl-01a07cca-c092-7423-880d-204c05dc6645\",\"choices\":[{\"delta\":{\"content\":\"I'll look up the current weather in Paris now.\",\"role\":\"assistant\"},\"finish_reason\":null,\"index\":0}],\"created\":1788800057,\"model\":\"muse-spark-1.3\",\"object\":\"chat.completion.chunk\"}\n\ndata: {\"id\":\"chatcmpl-01a07cca-c092-7423-880d-204c05dc6645\",\"choices\":[{\"delta\":{\"tool_calls\":[{\"index\":0,\"id\":\"call_01a07ccac34671129bd9ef9a66fd3266\",\"type\":\"function\",\"function\":{\"name\":\"lookup_weather\",\"arguments\":\"\"}}]},\"finish_reason\":null,\"index\":0}],\"created\":1788800057,\"model\":\"muse-spark-1.3\",\"object\":\"chat.completion.chunk\"}\n\ndata: {\"id\":\"chatcmpl-01a07cca-c092-7423-880d-204c05dc6645\",\"choices\":[{\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"{\\\"city\\\":\\\"Paris\\\"}\"}}]},\"finish_reason\":null,\"index\":0}],\"created\":1788800057,\"model\":\"muse-spark-1.3\",\"object\":\"chat.completion.chunk\"}\n\ndata: {\"id\":\"chatcmpl-01a07cca-c092-7423-880d-204c05dc6645\",\"choices\":[{\"delta\":{},\"finish_reason\":\"tool_calls\",\"index\":0}],\"created\":1788800057,\"model\":\"muse-spark-1.3\",\"object\":\"chat.completion.chunk\",\"usage\":{\"completion_tokens\":139,\"prompt_tokens\":570,\"total_tokens\":709,\"completion_tokens_details\":{\"reasoning_tokens\":70},\"prompt_tokens_details\":{\"cached_tokens\":497}}}\n\ndata: [DONE]\n\n"
+      }
+    },
+    {
+      "transport": "http",
+      "request": {
+        "method": "POST",
+        "url": "https://api.meta.ai/v1/chat/completions",
+        "headers": {
+          "content-type": "application/json"
+        },
+        "body": "{\"model\":\"muse-spark-1.3\",\"messages\":[{\"role\":\"user\",\"content\":\"Look up the current weather in Paris using lookup_weather before answering. After receiving the result, report Paris's weather in one short sentence.\"},{\"role\":\"assistant\",\"content\":\"I'll look up the current weather in Paris now.\",\"tool_calls\":[{\"id\":\"call_01a07ccac34671129bd9ef9a66fd3266\",\"type\":\"function\",\"function\":{\"name\":\"lookup_weather\",\"arguments\":\"{\\\"city\\\":\\\"Paris\\\"}\"}}]},{\"role\":\"tool\",\"tool_call_id\":\"call_01a07ccac34671129bd9ef9a66fd3266\",\"content\":\"{\\\"condition\\\":\\\"sunny\\\",\\\"temperature\\\":\\\"18C\\\"}\"}],\"tools\":[{\"type\":\"function\",\"function\":{\"name\":\"lookup_weather\",\"description\":\"Look up the current weather for a city\",\"parameters\":{\"type\":\"object\",\"properties\":{\"city\":{\"type\":\"string\",\"enum\":[\"Paris\"]}},\"required\":[\"city\"],\"additionalProperties\":false},\"strict\":false}}],\"tool_choice\":\"auto\",\"stream\":true,\"stream_options\":{\"include_usage\":true},\"reasoning_effort\":\"low\",\"max_completion_tokens\":1024}"
+      },
+      "response": {
+        "status": 200,
+        "headers": {
+          "content-type": "text/event-stream"
+        },
+        "body": "data: {\"id\":\"chatcmpl-01a07cca-c622-77e3-8e2c-9c52bac9acb5\",\"choices\":[{\"delta\":{\"content\":\"Paris is currently sunny with a\",\"role\":\"assistant\"},\"finish_reason\":null,\"index\":0}],\"created\":1788800058,\"model\":\"muse-spark-1.3\",\"object\":\"chat.completion.chunk\"}\n\ndata: {\"id\":\"chatcmpl-01a07cca-c622-77e3-8e2c-9c52bac9acb5\",\"choices\":[{\"delta\":{\"content\":\" temperature of 18°C\"},\"finish_reason\":null,\"index\":0}],\"created\":1788800058,\"model\":\"muse-spark-1.3\",\"object\":\"chat.completion.chunk\"}\n\ndata: {\"id\":\"chatcmpl-01a07cca-c622-77e3-8e2c-9c52bac9acb5\",\"choices\":[{\"delta\":{\"content\":\".\"},\"finish_reason\":null,\"index\":0}],\"created\":1788800058,\"model\":\"muse-spark-1.3\",\"object\":\"chat.completion.chunk\"}\n\ndata: {\"id\":\"chatcmpl-01a07cca-c622-77e3-8e2c-9c52bac9acb5\",\"choices\":[{\"delta\":{},\"finish_reason\":\"stop\",\"index\":0}],\"created\":1788800058,\"model\":\"muse-spark-1.3\",\"object\":\"chat.completion.chunk\",\"usage\":{\"completion_tokens\":91,\"prompt_tokens\":666,\"total_tokens\":757,\"completion_tokens_details\":{\"reasoning_tokens\":69},\"prompt_tokens_details\":{\"cached_tokens\":497}}}\n\ndata: [DONE]\n\n"
+      }
+    }
+  ]
+}
@@ -0,0 +1,37 @@
+{
+  "version": 1,
+  "metadata": {
+    "model": "muse-spark-1.3",
+    "tags": [
+      "prefix:meta-chat",
+      "provider:meta",
+      "protocol:openai-chat",
+      "text",
+      "reasoning",
+      "usage",
+      "effort:default"
+    ],
+    "name": "meta-chat/streams-text-with-default-reasoning",
+    "recordedAt": "2026-09-07T16:55:12.540Z"
+  },
+  "interactions": [
+    {
+      "transport": "http",
+      "request": {
+        "method": "POST",
+        "url": "https://api.meta.ai/v1/chat/completions",
+        "headers": {
+          "content-type": "application/json"
+        },
+        "body": "{\"model\":\"muse-spark-1.3\",\"messages\":[{\"role\":\"user\",\"content\":\"What is 173 multiplied by 219? Reply with only the final integer.\"}],\"stream\":true,\"stream_options\":{\"include_usage\":true},\"max_completion_tokens\":1024}"
+      },
+      "response": {
+        "status": 200,
+        "headers": {
+          "content-type": "text/event-stream"
+        },
+        "body": "data: {\"id\":\"chatcmpl-01a07ccb-8ae3-72b3-b321-b5163dda0714\",\"choices\":[{\"delta\":{\"content\":\"37887\",\"role\":\"assistant\"},\"finish_reason\":null,\"index\":0}],\"created\":1788800109,\"model\":\"muse-spark-1.3\",\"object\":\"chat.completion.chunk\"}\n\ndata: {\"id\":\"chatcmpl-01a07ccb-8ae3-72b3-b321-b5163dda0714\",\"choices\":[{\"delta\":{},\"finish_reason\":\"stop\",\"index\":0}],\"created\":1788800109,\"model\":\"muse-spark-1.3\",\"object\":\"chat.completion.chunk\",\"usage\":{\"completion_tokens\":363,\"prompt_tokens\":23,\"total_tokens\":386,\"completion_tokens_details\":{\"reasoning_tokens\":351},\"prompt_tokens_details\":{\"cached_tokens\":0}}}\n\ndata: [DONE]\n\n"
+      }
+    }
+  ]
+}
@@ -0,0 +1,29 @@
+{
+  "version": 1,
+  "metadata": {
+    "model": "muse-spark-1.3",
+    "tags": ["prefix:meta-chat", "provider:meta", "protocol:openai-chat", "text", "reasoning", "usage", "effort:high"],
+    "name": "meta-chat/streams-text-with-high-reasoning",
+    "recordedAt": "2026-09-07T16:53:30.276Z"
+  },
+  "interactions": [
+    {
+      "transport": "http",
+      "request": {
+        "method": "POST",
+        "url": "https://api.meta.ai/v1/chat/completions",
+        "headers": {
+          "content-type": "application/json"
+        },
+        "body": "{\"model\":\"muse-spark-1.3\",\"messages\":[{\"role\":\"user\",\"content\":\"What is 173 multiplied by 219? Reply with only the final integer.\"}],\"stream\":true,\"stream_options\":{\"include_usage\":true},\"reasoning_effort\":\"high\",\"max_completion_tokens\":1024}"
+      },
+      "response": {
+        "status": 200,
+        "headers": {
+          "content-type": "text/event-stream"
+        },
+        "body": "data: {\"id\":\"chatcmpl-01a07cc9-fe49-7773-b7f3-0be27454d3c3\",\"choices\":[{\"delta\":{\"content\":\"37887\",\"role\":\"assistant\"},\"finish_reason\":null,\"index\":0}],\"created\":1788800007,\"model\":\"muse-spark-1.3\",\"object\":\"chat.completion.chunk\"}\n\ndata: {\"id\":\"chatcmpl-01a07cc9-fe49-7773-b7f3-0be27454d3c3\",\"choices\":[{\"delta\":{},\"finish_reason\":\"stop\",\"index\":0}],\"created\":1788800007,\"model\":\"muse-spark-1.3\",\"object\":\"chat.completion.chunk\",\"usage\":{\"completion_tokens\":324,\"prompt_tokens\":23,\"total_tokens\":347,\"completion_tokens_details\":{\"reasoning_tokens\":312},\"prompt_tokens_details\":{\"cached_tokens\":0}}}\n\ndata: [DONE]\n\n"
+      }
+    }
+  ]
+}
@@ -0,0 +1,29 @@
+{
+  "version": 1,
+  "metadata": {
+    "model": "muse-spark-1.3",
+    "tags": ["prefix:meta-chat", "provider:meta", "protocol:openai-chat", "text", "reasoning", "usage", "effort:low"],
+    "name": "meta-chat/streams-text-with-low-reasoning",
+    "recordedAt": "2026-09-07T16:53:23.751Z"
+  },
+  "interactions": [
+    {
+      "transport": "http",
+      "request": {
+        "method": "POST",
+        "url": "https://api.meta.ai/v1/chat/completions",
+        "headers": {
+          "content-type": "application/json"
+        },
+        "body": "{\"model\":\"muse-spark-1.3\",\"messages\":[{\"role\":\"user\",\"content\":\"What is 173 multiplied by 219? Reply with only the final integer.\"}],\"stream\":true,\"stream_options\":{\"include_usage\":true},\"reasoning_effort\":\"low\",\"max_completion_tokens\":1024}"
+      },
+      "response": {
+        "status": 200,
+        "headers": {
+          "content-type": "text/event-stream"
+        },
+        "body": "data: {\"id\":\"chatcmpl-01a07cc9-eb39-7ef3-b886-5d4215128b1d\",\"choices\":[{\"delta\":{\"content\":\"37887\",\"role\":\"assistant\"},\"finish_reason\":null,\"index\":0}],\"created\":1788800002,\"model\":\"muse-spark-1.3\",\"object\":\"chat.completion.chunk\"}\n\ndata: {\"id\":\"chatcmpl-01a07cc9-eb39-7ef3-b886-5d4215128b1d\",\"choices\":[{\"delta\":{},\"finish_reason\":\"stop\",\"index\":0}],\"created\":1788800002,\"model\":\"muse-spark-1.3\",\"object\":\"chat.completion.chunk\",\"usage\":{\"completion_tokens\":157,\"prompt_tokens\":23,\"total_tokens\":180,\"completion_tokens_details\":{\"reasoning_tokens\":145},\"prompt_tokens_details\":{\"cached_tokens\":0}}}\n\ndata: [DONE]\n\n"
+      }
+    }
+  ]
+}
@@ -0,0 +1,29 @@
+{
+  "version": 1,
+  "metadata": {
+    "model": "muse-spark-1.3",
+    "tags": ["prefix:meta-chat", "provider:meta", "protocol:openai-chat", "text", "reasoning", "usage", "effort:max"],
+    "name": "meta-chat/streams-text-with-max-reasoning",
+    "recordedAt": "2026-09-07T16:53:33.749Z"
+  },
+  "interactions": [
+    {
+      "transport": "http",
+      "request": {
+        "method": "POST",
+        "url": "https://api.meta.ai/v1/chat/completions",
+        "headers": {
+          "content-type": "application/json"
+        },
+        "body": "{\"model\":\"muse-spark-1.3\",\"messages\":[{\"role\":\"user\",\"content\":\"What is 173 multiplied by 219? Reply with only the final integer.\"}],\"stream\":true,\"stream_options\":{\"include_usage\":true},\"reasoning_effort\":\"max\",\"max_completion_tokens\":1024}"
+      },
+      "response": {
+        "status": 200,
+        "headers": {
+          "content-type": "text/event-stream"
+        },
+        "body": "data: {\"id\":\"chatcmpl-01a07cca-10dd-7793-999d-e037320a91de\",\"choices\":[{\"delta\":{\"content\":\"37887\",\"role\":\"assistant\"},\"finish_reason\":null,\"index\":0}],\"created\":1788800012,\"model\":\"muse-spark-1.3\",\"object\":\"chat.completion.chunk\"}\n\ndata: {\"id\":\"chatcmpl-01a07cca-10dd-7793-999d-e037320a91de\",\"choices\":[{\"delta\":{},\"finish_reason\":\"stop\",\"index\":0}],\"created\":1788800012,\"model\":\"muse-spark-1.3\",\"object\":\"chat.completion.chunk\",\"usage\":{\"completion_tokens\":195,\"prompt_tokens\":23,\"total_tokens\":218,\"completion_tokens_details\":{\"reasoning_tokens\":183},\"prompt_tokens_details\":{\"cached_tokens\":0}}}\n\ndata: [DONE]\n\n"
+      }
+    }
+  ]
+}
@@ -0,0 +1,37 @@
+{
+  "version": 1,
+  "metadata": {
+    "model": "muse-spark-1.3",
+    "tags": [
+      "prefix:meta-chat",
+      "provider:meta",
+      "protocol:openai-chat",
+      "text",
+      "reasoning",
+      "usage",
+      "effort:medium"
+    ],
+    "name": "meta-chat/streams-text-with-medium-reasoning",
+    "recordedAt": "2026-09-07T16:53:27.292Z"
+  },
+  "interactions": [
+    {
+      "transport": "http",
+      "request": {
+        "method": "POST",
+        "url": "https://api.meta.ai/v1/chat/completions",
+        "headers": {
+          "content-type": "application/json"
+        },
+        "body": "{\"model\":\"muse-spark-1.3\",\"messages\":[{\"role\":\"user\",\"content\":\"What is 173 multiplied by 219? Reply with only the final integer.\"}],\"stream\":true,\"stream_options\":{\"include_usage\":true},\"reasoning_effort\":\"medium\",\"max_completion_tokens\":1024}"
+      },
+      "response": {
+        "status": 200,
+        "headers": {
+          "content-type": "text/event-stream"
+        },
+        "body": "data: {\"id\":\"chatcmpl-01a07cc9-f131-7fb0-8895-9f0c3e79220c\",\"choices\":[{\"delta\":{\"content\":\"37887\",\"role\":\"assistant\"},\"finish_reason\":null,\"index\":0}],\"created\":1788800004,\"model\":\"muse-spark-1.3\",\"object\":\"chat.completion.chunk\"}\n\ndata: {\"id\":\"chatcmpl-01a07cc9-f131-7fb0-8895-9f0c3e79220c\",\"choices\":[{\"delta\":{},\"finish_reason\":\"stop\",\"index\":0}],\"created\":1788800004,\"model\":\"muse-spark-1.3\",\"object\":\"chat.completion.chunk\",\"usage\":{\"completion_tokens\":273,\"prompt_tokens\":23,\"total_tokens\":296,\"completion_tokens_details\":{\"reasoning_tokens\":261},\"prompt_tokens_details\":{\"cached_tokens\":0}}}\n\ndata: [DONE]\n\n"
+      }
+    }
+  ]
+}
@@ -0,0 +1,37 @@
+{
+  "version": 1,
+  "metadata": {
+    "model": "muse-spark-1.3",
+    "tags": [
+      "prefix:meta-chat",
+      "provider:meta",
+      "protocol:openai-chat",
+      "text",
+      "reasoning",
+      "usage",
+      "effort:minimal"
+    ],
+    "name": "meta-chat/streams-text-with-minimal-reasoning",
+    "recordedAt": "2026-09-07T16:53:22.460Z"
+  },
+  "interactions": [
+    {
+      "transport": "http",
+      "request": {
+        "method": "POST",
+        "url": "https://api.meta.ai/v1/chat/completions",
+        "headers": {
+          "content-type": "application/json"
+        },
+        "body": "{\"model\":\"muse-spark-1.3\",\"messages\":[{\"role\":\"user\",\"content\":\"What is 173 multiplied by 219? Reply with only the final integer.\"}],\"stream\":true,\"stream_options\":{\"include_usage\":true},\"reasoning_effort\":\"minimal\",\"max_completion_tokens\":1024}"
+      },
+      "response": {
+        "status": 200,
+        "headers": {
+          "content-type": "text/event-stream"
+        },
+        "body": "data: {\"id\":\"chatcmpl-01a07cc9-e817-7bb1-8dc5-5197d9a4c73e\",\"choices\":[{\"delta\":{\"content\":\"37887\",\"role\":\"assistant\"},\"finish_reason\":null,\"index\":0}],\"created\":1788800002,\"model\":\"muse-spark-1.3\",\"object\":\"chat.completion.chunk\"}\n\ndata: {\"id\":\"chatcmpl-01a07cc9-e817-7bb1-8dc5-5197d9a4c73e\",\"choices\":[{\"delta\":{},\"finish_reason\":\"stop\",\"index\":0}],\"created\":1788800002,\"model\":\"muse-spark-1.3\",\"object\":\"chat.completion.chunk\",\"usage\":{\"completion_tokens\":75,\"prompt_tokens\":23,\"total_tokens\":98,\"completion_tokens_details\":{\"reasoning_tokens\":63},\"prompt_tokens_details\":{\"cached_tokens\":0}}}\n\ndata: [DONE]\n\n"
+      }
+    }
+  ]
+}
@@ -0,0 +1,29 @@
+{
+  "version": 1,
+  "metadata": {
+    "model": "muse-spark-1.3",
+    "tags": ["prefix:meta-chat", "provider:meta", "protocol:openai-chat", "text", "reasoning", "usage", "effort:xhigh"],
+    "name": "meta-chat/streams-text-with-xhigh-reasoning",
+    "recordedAt": "2026-09-07T16:53:32.103Z"
+  },
+  "interactions": [
+    {
+      "transport": "http",
+      "request": {
+        "method": "POST",
+        "url": "https://api.meta.ai/v1/chat/completions",
+        "headers": {
+          "content-type": "application/json"
+        },
+        "body": "{\"model\":\"muse-spark-1.3\",\"messages\":[{\"role\":\"user\",\"content\":\"What is 173 multiplied by 219? Reply with only the final integer.\"}],\"stream\":true,\"stream_options\":{\"include_usage\":true},\"reasoning_effort\":\"xhigh\",\"max_completion_tokens\":1024}"
+      },
+      "response": {
+        "status": 200,
+        "headers": {
+          "content-type": "text/event-stream"
+        },
+        "body": "data: {\"id\":\"chatcmpl-01a07cca-09de-7083-a0cc-2100de752456\",\"choices\":[{\"delta\":{\"content\":\"37887\",\"role\":\"assistant\"},\"finish_reason\":null,\"index\":0}],\"created\":1788800010,\"model\":\"muse-spark-1.3\",\"object\":\"chat.completion.chunk\"}\n\ndata: {\"id\":\"chatcmpl-01a07cca-09de-7083-a0cc-2100de752456\",\"choices\":[{\"delta\":{},\"finish_reason\":\"stop\",\"index\":0}],\"created\":1788800010,\"model\":\"muse-spark-1.3\",\"object\":\"chat.completion.chunk\",\"usage\":{\"completion_tokens\":253,\"prompt_tokens\":23,\"total_tokens\":276,\"completion_tokens_details\":{\"reasoning_tokens\":241},\"prompt_tokens_details\":{\"cached_tokens\":0}}}\n\ndata: [DONE]\n\n"
+      }
+    }
+  ]
+}
@@ -0,0 +1,47 @@
+{
+  "version": 1,
+  "metadata": {
+    "model": "muse-spark-1.3",
+    "tags": ["prefix:meta-messages", "provider:meta", "protocol:meta-messages", "tool", "tool-loop", "reasoning"],
+    "name": "meta-messages/replays-encrypted-thinking-through-a-tool-loop",
+    "recordedAt": "2026-09-07T17:27:03.540Z"
+  },
+  "interactions": [
+    {
+      "transport": "http",
+      "request": {
+        "method": "POST",
+        "url": "https://api.meta.ai/v1/messages",
+        "headers": {
+          "content-type": "application/json"
+        },
+        "body": "{\"model\":\"muse-spark-1.3\",\"messages\":[{\"role\":\"user\",\"content\":[{\"type\":\"text\",\"text\":\"Look up the current weather in Paris using lookup_weather. After receiving the result, report Paris's weather in one short sentence.\"}]}],\"tools\":[{\"name\":\"lookup_weather\",\"description\":\"Look up current weather\",\"input_schema\":{\"type\":\"object\",\"properties\":{\"city\":{\"type\":\"string\",\"enum\":[\"Paris\"]}},\"required\":[\"city\"],\"additionalProperties\":false}}],\"tool_choice\":{\"type\":\"auto\"},\"stream\":true,\"max_tokens\":1024,\"thinking\":{\"type\":\"adaptive\",\"display\":\"omitted\"},\"output_config\":{\"effort\":\"low\"}}"
+      },
+      "response": {
+        "status": 200,
+        "headers": {
+          "content-type": "text/event-stream"
+        },
+        "body": "event: message_start\ndata: {\"message\":{\"content\":[],\"id\":\"msg_6a9ef3e5a96d9a155dd4463b\",\"model\":\"muse-spark-1.3\",\"role\":\"assistant\",\"stop_reason\":null,\"stop_sequence\":null,\"type\":\"message\",\"usage\":{\"input_tokens\":0,\"output_tokens\":0}},\"type\":\"message_start\"}\n\nevent: content_block_start\ndata: {\"content_block\":{\"data\":\"Q-PaDgGyJ4hIKk41uslnSV0PGvrTkwJ5D-t5skfjtkIt-ABXsehMcLKJJ8RJHRKW2-XhkpPrex0aOkIdqWl99vpCgtOHIFFaSc4b3oGxA8XDx4T_2aKANfYrR1DYwYzGe6ZZ-DQnU0bnpVUzCcXkghkLdyTcJr2p8cvVo1rymFpB0wZsbQRBhxCMR6PrY4i0aOTe8_waq_Po1a4l3YzKnzZIIvYP090o5kltv7MAwqChXjQeTJlKq7ECFa6HVeoTa43oiLmoD2Bzih0VfvBvQfbSh2uDypRM7-f65sp35-VuZfwsM33ZTvefzDbd8zd0D50I6wcybsj8gulDhWWpY7cxoN1Xasy-ImvisACGeppIN66maIFq5dMT2s8_CQ8a2EQ0hw9kwJaIiygZCdRofs-T1yaGWvnQxL6MpNh6SXux9T1ZfuexNrXOhz5cR3_s1euhq3-hI3GDCUDLAtkjiigSE3w6PExrwHTHnvkuAOTP0Lw7DH4NtKv-RFFeZaQOk_0Bi2EV43tR0Hq_chtEDiSpoezDjexPWfdZvhRIaO6PwyJaQ8jVOaLUr6bh6jQ3IM19lv6R7lY4Neno8fLxMwTbf7v7q02lfhOaZe3jR1fqOFUq8e4VXV76_rJBgzThqPNqO8OI_betgX5d2KMcwWAkaZjmrP3rxA7g5xp_Q7bkFiBaaTd3HbYIk_cKbtLOS6TIIphb4SX6ADA2qJ0zoo98P2NOceZODT2WrLjKCHl5dT6b9l2feH9m21pW576ULfKhVSMzuy0cmmWI7rv2P4q-2Fw2klsDVJAc6q22bFjfDgzhybKuhuM_p1SYb8aswNrgggV-cqHWDpF1FdVpL5fHMO74l1uD8Sj_9wuuD0asMQustuvsnYq2EdI0lLvONFMApWCU0s3QA8_P0Iyf0YoCZOm5QGnA7l3O5nAPkFF4kxLSsgRe9zuP6A4oKBDLN8EHwZ3pB4WZGWpUT12cJxplmT3_n8xKaMgaz13qs27uvUm3wMI1seyfpkMwUPHmt1ftpk9f_1OAg3fvQgIkWPTp6K9NzVzEry6SP7zbPfls8yn529Qrbki7ZM_oz3xEvDg367ZCe97eVnjiqRrYsYM2MmDsQq9lUwkgXb84kpK6a4pEzX9NDvhTqhw7RI6RL9E-2Ki4ciUfHv5LVTZ0rNweCo6SYXC11f8FCeObIW_Esr2mqYpORFS4SDMU-4I1HQfD9z6cPjL22APpv9a7Pp1phI8x_aQZkPU7LkyBWyVNDeusI7wq_LC0UgJ0vCAguKcAvN7gxwpCo5MEEZivRuYBldEMwRo4he2WQQke9KEokqREdlPF3Lvaav0fqPfXqhJyHAq8bYBHWdzMjDJ_dJwhdbLQ-iNLmrK5JNg2vPDglWSznBXbrSX4iyMFk1Ni2Y1SQUIOOxS_InIwCg\",\"type\":\"redacted_thinking\"},\"index\":0,\"type\":\"content_block_start\"}\n\nevent: content_block_stop\ndata: {\"index\":0,\"type\":\"content_block_stop\"}\n\nevent: content_block_start\ndata: {\"content_block\":{\"text\":\"\",\"type\":\"text\"},\"index\":1,\"type\":\"content_block_start\"}\n\nevent: content_block_delta\ndata: {\"delta\":{\"text\":\"I'll look up the current weather in Paris.\",\"type\":\"text_delta\"},\"index\":1,\"type\":\"content_block_delta\"}\n\nevent: content_block_stop\ndata: {\"index\":1,\"type\":\"content_block_stop\"}\n\nevent: content_block_start\ndata: {\"content_block\":{\"id\":\"call_01a07ce8bb767c109c12f0a202e2ac19\",\"input\":{},\"name\":\"lookup_weather\",\"type\":\"tool_use\"},\"index\":2,\"type\":\"content_block_start\"}\n\nevent: content_block_delta\ndata: {\"delta\":{\"partial_json\":\"{\\\"city\\\":\\\"Paris\\\"}\",\"type\":\"input_json_delta\"},\"index\":2,\"type\":\"content_block_delta\"}\n\nevent: content_block_stop\ndata: {\"index\":2,\"type\":\"content_block_stop\"}\n\nevent: message_delta\ndata: {\"delta\":{\"stop_reason\":\"tool_use\",\"stop_sequence\":null},\"type\":\"message_delta\",\"usage\":{\"cache_creation_input_tokens\":0,\"cache_read_input_tokens\":113,\"input_tokens\":451,\"output_tokens\":155,\"output_tokens_details\":{\"thinking_tokens\":87}}}\n\nevent: message_stop\ndata: {\"type\":\"message_stop\"}\n\n"
+      }
+    },
+    {
+      "transport": "http",
+      "request": {
+        "method": "POST",
+        "url": "https://api.meta.ai/v1/messages",
+        "headers": {
+          "content-type": "application/json"
+        },
+        "body": "{\"model\":\"muse-spark-1.3\",\"messages\":[{\"role\":\"user\",\"content\":[{\"type\":\"text\",\"text\":\"Look up the current weather in Paris using lookup_weather. After receiving the result, report Paris's weather in one short sentence.\"}]},{\"role\":\"assistant\",\"content\":[{\"type\":\"redacted_thinking\",\"data\":\"Q-PaDgGyJ4hIKk41uslnSV0PGvrTkwJ5D-t5skfjtkIt-ABXsehMcLKJJ8RJHRKW2-XhkpPrex0aOkIdqWl99vpCgtOHIFFaSc4b3oGxA8XDx4T_2aKANfYrR1DYwYzGe6ZZ-DQnU0bnpVUzCcXkghkLdyTcJr2p8cvVo1rymFpB0wZsbQRBhxCMR6PrY4i0aOTe8_waq_Po1a4l3YzKnzZIIvYP090o5kltv7MAwqChXjQeTJlKq7ECFa6HVeoTa43oiLmoD2Bzih0VfvBvQfbSh2uDypRM7-f65sp35-VuZfwsM33ZTvefzDbd8zd0D50I6wcybsj8gulDhWWpY7cxoN1Xasy-ImvisACGeppIN66maIFq5dMT2s8_CQ8a2EQ0hw9kwJaIiygZCdRofs-T1yaGWvnQxL6MpNh6SXux9T1ZfuexNrXOhz5cR3_s1euhq3-hI3GDCUDLAtkjiigSE3w6PExrwHTHnvkuAOTP0Lw7DH4NtKv-RFFeZaQOk_0Bi2EV43tR0Hq_chtEDiSpoezDjexPWfdZvhRIaO6PwyJaQ8jVOaLUr6bh6jQ3IM19lv6R7lY4Neno8fLxMwTbf7v7q02lfhOaZe3jR1fqOFUq8e4VXV76_rJBgzThqPNqO8OI_betgX5d2KMcwWAkaZjmrP3rxA7g5xp_Q7bkFiBaaTd3HbYIk_cKbtLOS6TIIphb4SX6ADA2qJ0zoo98P2NOceZODT2WrLjKCHl5dT6b9l2feH9m21pW576ULfKhVSMzuy0cmmWI7rv2P4q-2Fw2klsDVJAc6q22bFjfDgzhybKuhuM_p1SYb8aswNrgggV-cqHWDpF1FdVpL5fHMO74l1uD8Sj_9wuuD0asMQustuvsnYq2EdI0lLvONFMApWCU0s3QA8_P0Iyf0YoCZOm5QGnA7l3O5nAPkFF4kxLSsgRe9zuP6A4oKBDLN8EHwZ3pB4WZGWpUT12cJxplmT3_n8xKaMgaz13qs27uvUm3wMI1seyfpkMwUPHmt1ftpk9f_1OAg3fvQgIkWPTp6K9NzVzEry6SP7zbPfls8yn529Qrbki7ZM_oz3xEvDg367ZCe97eVnjiqRrYsYM2MmDsQq9lUwkgXb84kpK6a4pEzX9NDvhTqhw7RI6RL9E-2Ki4ciUfHv5LVTZ0rNweCo6SYXC11f8FCeObIW_Esr2mqYpORFS4SDMU-4I1HQfD9z6cPjL22APpv9a7Pp1phI8x_aQZkPU7LkyBWyVNDeusI7wq_LC0UgJ0vCAguKcAvN7gxwpCo5MEEZivRuYBldEMwRo4he2WQQke9KEokqREdlPF3Lvaav0fqPfXqhJyHAq8bYBHWdzMjDJ_dJwhdbLQ-iNLmrK5JNg2vPDglWSznBXbrSX4iyMFk1Ni2Y1SQUIOOxS_InIwCg\"},{\"type\":\"text\",\"text\":\"I'll look up the current weather in Paris.\"},{\"type\":\"tool_use\",\"id\":\"call_01a07ce8bb767c109c12f0a202e2ac19\",\"name\":\"lookup_weather\",\"input\":{\"city\":\"Paris\"}}]},{\"role\":\"user\",\"content\":[{\"type\":\"tool_result\",\"tool_use_id\":\"call_01a07ce8bb767c109c12f0a202e2ac19\",\"content\":\"{\\\"condition\\\":\\\"sunny\\\"}\"}]}],\"tools\":[{\"name\":\"lookup_weather\",\"description\":\"Look up current weather\",\"input_schema\":{\"type\":\"object\",\"properties\":{\"city\":{\"type\":\"string\",\"enum\":[\"Paris\"]}},\"required\":[\"city\"],\"additionalProperties\":false}}],\"tool_choice\":{\"type\":\"none\"},\"stream\":true,\"max_tokens\":1024,\"thinking\":{\"type\":\"adaptive\",\"display\":\"omitted\"},\"output_config\":{\"effort\":\"low\"}}"
+      },
+      "response": {
+        "status": 200,
+        "headers": {
+          "content-type": "text/event-stream"
+        },
+        "body": "event: message_start\ndata: {\"message\":{\"content\":[],\"id\":\"msg_6a9ef3e77f6ef36fdd8f4925\",\"model\":\"muse-spark-1.3\",\"role\":\"assistant\",\"stop_reason\":null,\"stop_sequence\":null,\"type\":\"message\",\"usage\":{\"input_tokens\":0,\"output_tokens\":0}},\"type\":\"message_start\"}\n\nevent: content_block_start\ndata: {\"content_block\":{\"data\":\"Q-PaDgH-GUZkiqnb_seFaP70it_GxAEIUjt2BLllpyzfckiBOUVwr72xGQsSnj0y9aOhoaQ24A_HB0MHh4XWyYziVdRgq6lDPLHkJlmMzbusZxUZUx7D7B8kD8HrBbiTeIFbFlHaM9MiZW_PpYY9fpkdc7aeuX0mORdK8XTT3JPjvW1HPp4Qqp_iEOl9G2iM2Y6xno8SqeTcbc4EQs1LePaKrq86dBPmXBjkgQbYfvIw57o0SBEyelcudtnzJnaluOyOQdV2Ytk_r_xrYSCoBwgbf2KBCOFjdeQyruuwVZZ32JJdVOpWLw8eopUwAo2xYOZP0g8S8hTmOFvDKuzXipm1OoAXwD8Swm6ED3IIo0hHA5xSfMygDCee47nd-EpShNPamkCKodfX1QvePEJsIQK2iTgkh8IGUeEEne5dxgLuXvEAbeqGDvEy6T7IoSgZnc-KPtH6SoWM_kgc_eF_oN73Nxg2prMyCqTUNg5Qs2WLPjA9wSLmmnCoiDr1bYNIuQyn6adgv0-nZZXETJoRAHJBj65Asa8kbLyCYesb192178xCj2aBSdwyj-jc0i328sa9STS7mUSI7KvOt0Yi3kllLs1aSnHW-ogsUJUM7tTf83VO9fRRU_aW4H6qr4OAr8jbBKSD3bxE0AekDd24ZS-8YIjiP1tMOAPZ2JGQrNqbxnaeqhCZzD2nl-E8TMXaAJIk4L3oZtV80xJiUW7mLEf_jQBPAWhph4ujbkDaufGvNrl4FXyBJ-XpKMIA5z0jAYU2b3ul5-Qn5Km7Oc8fPu1M_0XGAOKG-pF9ppr4y-an4B4mKDYoAiSHp3cjv-fW57D87wBfQPaJRjOzWhzqENO-5MlB0CEsnDtrLveE2ui8wSECszParUNk5SEaeSYvrXLY0QkaE7CTK9ljwTKjJM34r1a8o16KFxGuzMrloNlxIYIaO_suM9CDuf8wNwe8KkAV2Kt28g9LwkL5b3mtI7ZSjTdHYOOhFFMzs-sjXboQoGAJGOhMnCQNc3E5-goSzvOzEIXehSTs8Mzyq8d3C2k5F9PSgdO6ZouHVURDgbEXTqWqoqjQ8huk5AbrUX16QwhJambd6P-3i--Idz9CbIVuWIqiMm80TvYlMttobYxTyFDIJrKJTrVA0PkAOFvOMfYt27d7z2ZMrTf6Vtm_DNniuhVbvVU3ZcWbb4LO-XkwH3bfHB-sckpwURP34KzOMvogaqWaMAZlabdd-lQKCc7tMhmo9BrYwHHvLxAELD2qQnyym43Yo1iJNAyrqoUAFk6K029fDon7h9ybmKZdBxRtS3arUesY_91Xep0tA0Y1UYUKo8zKjK3Op_DbVyC5OoR8rxpumKiqk2PtG7RPf-WjEXGkleGqZtxix7ILSkQXxW6McY1r_6LAh2Nv0nUzqS019tTb7mx2OLyt2g\",\"type\":\"redacted_thinking\"},\"index\":0,\"type\":\"content_block_start\"}\n\nevent: content_block_stop\ndata: {\"index\":0,\"type\":\"content_block_stop\"}\n\nevent: content_block_start\ndata: {\"content_block\":{\"text\":\"\",\"type\":\"text\"},\"index\":1,\"type\":\"content_block_start\"}\n\nevent: content_block_delta\ndata: {\"delta\":{\"text\":\"It's sunny in Paris.\",\"type\":\"text_delta\"},\"index\":1,\"type\":\"content_block_delta\"}\n\nevent: content_block_stop\ndata: {\"index\":1,\"type\":\"content_block_stop\"}\n\nevent: message_delta\ndata: {\"delta\":{\"stop_reason\":\"end_turn\",\"stop_sequence\":null},\"type\":\"message_delta\",\"usage\":{\"cache_creation_input_tokens\":0,\"cache_read_input_tokens\":0,\"input_tokens\":210,\"output_tokens\":50,\"output_tokens_details\":{\"thinking_tokens\":35}}}\n\nevent: message_stop\ndata: {\"type\":\"message_stop\"}\n\n"
+      }
+    }
+  ]
+}
@@ -0,0 +1,29 @@
+{
+  "version": 1,
+  "metadata": {
+    "model": "muse-spark-1.3",
+    "tags": ["prefix:meta-messages", "provider:meta", "protocol:meta-messages", "text", "reasoning", "adaptive"],
+    "name": "meta-messages/streams-text-with-adaptive-thinking",
+    "recordedAt": "2026-09-07T17:26:18.565Z"
+  },
+  "interactions": [
+    {
+      "transport": "http",
+      "request": {
+        "method": "POST",
+        "url": "https://api.meta.ai/v1/messages",
+        "headers": {
+          "content-type": "application/json"
+        },
+        "body": "{\"model\":\"muse-spark-1.3\",\"messages\":[{\"role\":\"user\",\"content\":[{\"type\":\"text\",\"text\":\"What is 173 multiplied by 219? Reply with only the final integer.\"}]}],\"stream\":true,\"max_tokens\":2048,\"thinking\":{\"type\":\"adaptive\",\"display\":\"omitted\"},\"output_config\":{\"effort\":\"low\"}}"
+      },
+      "response": {
+        "status": 200,
+        "headers": {
+          "content-type": "text/event-stream"
+        },
+        "body": "event: message_start\ndata: {\"message\":{\"content\":[],\"id\":\"msg_6a9ef3b8e46a777cfdc94a93\",\"model\":\"muse-spark-1.3\",\"role\":\"assistant\",\"stop_reason\":null,\"stop_sequence\":null,\"type\":\"message\",\"usage\":{\"input_tokens\":0,\"output_tokens\":0}},\"type\":\"message_start\"}\n\nevent: content_block_start\ndata: {\"content_block\":{\"data\":\"Q-PaDgFtwwNGqSqKxPk9Zj-j9xogYigpDsDHrLKPV-DxmXcbhtXDPrGPuj5qB4l1FslhuEQFCA8zIRyNGaCmzM0JG4GOZe3LpFYM2iegBbi24l4V7souryAwUs_7PrInxObuguMwh2S66ML6PwlfVRVTAwPsgDSCl6Y9tkoDHr2KBRY2fzJhmjkotuFRK2LYvNp9pKi89JxnoIKK8B_UJc_B2r4vU_Txq9_rWTmo2eXFoGOSMZNaHpVrvACRQKC1jc6-8Pj5JkJN11_Cs2fHqlaCwOoPDVJxHXUXP1AMHU1mG0jR4qf9wUaz8kMmyCBBijlfQJ4G7nsQs7LJO9gS2ropmynDoO5IEIAFf7ekxLw54Fx3JigC0_qz4Jx4a04Ey8JBzWRlZNdqggpq2_I_VoT3S0zhCYDp8ZAJQs2JqvvF-ZmLcMPH1PmpkgRySqXl5TDxERIpdL3aOUzTl-PTHVMIGEcSAz84fFwU4p1kS5llGEGC6jHlClscEEto1Y-qthL6BoeDALzk7GHEMVQD0bfC4E5yGCh0_xlWqsG3XPj0wpYKBc0hfh7vjO1NpzPxCtaDjnRwR6TzSo6x_HrEL3VELArHhpYAXl30fNO-EepduZ3Hd_kWqWj_GhdIM4dRh2zoytbhIesVD7OvBqU47urKFnpXw4kswJ-NoVVNk00ysMMHwobT9BdJL9UCoXlNzyErPe8LkA9f0VrKkuLCg5FDr_DCEYXHXr7fdRmC3JTKuzvxffvPYppUt3hs5gbdXWgT2iZzunt4bSfFne7BPkj9OGREyfLcukvGAh_oqPLXuu0lert9wbTAqRUTyM5Y1nSjw3h2B3jv91mH78mGvhy8LeVNLkrSMxEa4GtrrUvlzkPnZayc_LE2Sr7JnQjhwylVNWvkcIAjstOZShjPKe4pUJwj-cUXmXZB7Zwr-Q9WLtprFgQoBvadd5DHD4aynsYEabKZVcOqhV8l2zyaUCGobUzdPqBC5kk5-VPmNTqm6Qs91mb1y_5ydmHjTWmSW6qtN_op-Xfwqr_hllvOjhnAvvDJWUOKH-YIgZw_k_db2mzW1hO093jSDMYv6wpiy_5XWMNJBjcH8hvR_pFjXIqScUnKPranEZvCyGfHR-UBNJ89s_JEE49chcIt8LiukBeXQ_TOe29kzWnT1tYtfGQXP8FY2Wukw5yhvP3coGp1-LPZRuw3BLP2tWmiijmyj5lMikp8MIeqOztN8zgsArZ9jq21EtDSNfpO_0C4GEOtCZQYvZHRpDeY966XDnN7Blenn_8FZ95M-M-1My8hsmF__JrnY4ZFZr2274f_FbyJaSqGj6H-YRuzawO2TVLWHxAr6v2LCiB_QX01PwUI1yaJmP0mI-Qz5zXgSHzfVzhF7l1zEnM8qIYcSXzD1Gp3rjpn2sq-rR-JLqeHq080Hl0X9c8lzozw3qCpvcTfA-4ZTdXU9ax3nt7emcPVFo9N_JBjYashC7KvjkIWjMhQoTbIRlO18gjEa-Dvtsmo4_xE1ApYRoylbhxg3_fQJjKLfCBv32V6BM8qWKINL7d1nYP7PtAKnglCdnT_dK0_pCK6ejGfmdWZgVj0DhVZUCXf2kN530Y0hoCb1jBgwJ16a5gUqJMtnWScarIGSVrsYMA_uEt7DwQzGYAGESVIgi8JVATkxoq4EbyOLCHX7MIKmAPGV2WWTjWAWLnE2ITjlXtBkUAwjq2v957BMgIqxSNxEjG75Gd0i1XjZAujCSCXMrywZ72-VdQy4cD6kzH9mv04fZ7_dqn9eKPHBY7_T7V6myRDj_ImkffXcygmd7F-_-kHMExI6ABas1WtfDjkYgbRM0jMtIHYL-W9xT8vCSLSdvHcb5Y8XSXT5GTwI7eIlBHnCvFrgunbCo9bJJlT2Gc1RcgeZ4rg3yu1MNF4Mfk6DBwDhduGh5l7nypL00B0HokLfF4H7N1oSKL9jdVE3oMyJuA9NV1SJiyqcneSVHBzqjFZ5sszFXPlBKEz31izxFToAF4tDYMR507zYLcxyLA4AmHlkmn0qeozPb5qk-qZB6yLywtewv8O1KqxieAEJnEmyiqGnoKBdkjpeYmplErSxJyzoRX4fXb9mOdb-izJgvqSQ5uLm0_EXf3OklpMoAJ2CPJ6cxpg_5bhiwbgEtafCuDyXVL9Zzi872yUb_Z-ATlqU1M2Ai67f1piHIUDzMn4kulXQhPMb_R4eznMbX_aRigQh92-t1USoFtX2vmyCUQageFcrHHK524gPQ7rkOfDvZ8GHPXi3YZFnzGkSKjQD0jumFtzDiRqYkkMECep0zgY8MjuWLMjlMuigpkzSm8GPZ2aFeIMxJCYR8iMf7fH9NyHAJnicx4wdW_UqqgY5jfVtDvPSL0SRScyyK0jNdmofDHjWp4Tehih5OOw81E3BYLCiIv2p2zTMRSTZxFyG3HI91tIEaJu_RnIMFxzCilaP1LcbMrjyFzBtLJiXXJ--eFYyIMYKgfbWIOTsjLLJGC8NS2wuzaXB-C6GLsuSEHci5a8f5KGqaXK99LvHtY4k36WhEoVUjQEGY7HNJrtdjBUlqDgnT9iO06gGd2QCGvlP4us-Z3q2Bcyhf0LzOgn_Bpjc6YBk4TNF1AMxG15qmhnsrWcGElkpk3Vh9npC8--vkvhh7pOPfTZlNjQQh900OemY9gwxHyCBbt1096g4qkYOntGJmw-wVjyWxOt9K9CaM9WxY3wFyOmwqiFL1PK4CMeKMZk54iZ1ZiyXDOvsO7qUa9XQGDy3W8ic6R3DUzdkxEEBFYHAjDy3qE\",\"type\":\"redacted_thinking\"},\"index\":0,\"type\":\"content_block_start\"}\n\nevent: content_block_stop\ndata: {\"index\":0,\"type\":\"content_block_stop\"}\n\nevent: content_block_start\ndata: {\"content_block\":{\"text\":\"\",\"type\":\"text\"},\"index\":1,\"type\":\"content_block_start\"}\n\nevent: content_block_delta\ndata: {\"delta\":{\"text\":\"37887\",\"type\":\"text_delta\"},\"index\":1,\"type\":\"content_block_delta\"}\n\nevent: content_block_stop\ndata: {\"index\":1,\"type\":\"content_block_stop\"}\n\nevent: message_delta\ndata: {\"delta\":{\"stop_reason\":\"end_turn\",\"stop_sequence\":null},\"type\":\"message_delta\",\"usage\":{\"cache_creation_input_tokens\":0,\"cache_read_input_tokens\":0,\"input_tokens\":23,\"output_tokens\":266,\"output_tokens_details\":{\"thinking_tokens\":254}}}\n\nevent: message_stop\ndata: {\"type\":\"message_stop\"}\n\n"
+      }
+    }
+  ]
+}
@@ -0,0 +1,29 @@
+{
+  "version": 1,
+  "metadata": {
+    "model": "muse-spark-1.3",
+    "tags": ["prefix:meta-messages", "provider:meta", "protocol:meta-messages", "text", "reasoning", "enabled"],
+    "name": "meta-messages/streams-text-with-enabled-thinking",
+    "recordedAt": "2026-09-07T17:26:20.464Z"
+  },
+  "interactions": [
+    {
+      "transport": "http",
+      "request": {
+        "method": "POST",
+        "url": "https://api.meta.ai/v1/messages",
+        "headers": {
+          "content-type": "application/json"
+        },
+        "body": "{\"model\":\"muse-spark-1.3\",\"messages\":[{\"role\":\"user\",\"content\":[{\"type\":\"text\",\"text\":\"What is 173 multiplied by 219? Reply with only the final integer.\"}]}],\"stream\":true,\"max_tokens\":2048,\"thinking\":{\"type\":\"enabled\",\"budget_tokens\":1024,\"display\":\"omitted\"},\"output_config\":{\"effort\":\"low\"}}"
+      },
+      "response": {
+        "status": 200,
+        "headers": {
+          "content-type": "text/event-stream"
+        },
+        "body": "event: message_start\ndata: {\"message\":{\"content\":[],\"id\":\"msg_6a9ef3bbb7e691b3ea26427b\",\"model\":\"muse-spark-1.3\",\"role\":\"assistant\",\"stop_reason\":null,\"stop_sequence\":null,\"type\":\"message\",\"usage\":{\"input_tokens\":0,\"output_tokens\":0}},\"type\":\"message_start\"}\n\nevent: content_block_start\ndata: {\"content_block\":{\"data\":\"Q-PaDgEpowvGua1C8z2RSICyyeSLruZ1JBUhrhLhgqf_XauiaESRHyHgIPVF0Cfxp7eLB_ESNObq7vJNDLdffE-RaN5nEauXhRxH6fJErC-4H_KELZFGF-qNnGu2DWl-gEojkwwkq1HtTtT3rOEk5isGjdribnDvR7a1zkpG3I0BxE_UyseISDSbkev5tyV7DkiH4xyv2ZmwuO3HHGgmAztEek9vm0ZTElZ8PIPvHG6P38aYGTGKrTjyOhmN3LBa_NFvtQQkUMKRB3n7L_N5KB1NbYkPzLEJ6L5dL9DJZBSsZms0O62QZ2zs2oWZ-ekQWL4oIuiRozWVpmwzjtkJl9WXtyvdL-4MACucXMSN9V7hWzC50g-DgdeFPSslsA9gy619wTNPPIxPymGWeD9LYKR3iwTRLNYzuycHakNqikhiwz9MweMod5GLTdbtypZJcV7ourz58jmK4YKsqleVPVvXM6bIoNuT2yGj23-tAYxQszGXQMHxSTnaLAHl6sUdiwTqX4wbFYfX-ogkIZsrca9mv5E2gkH1wJl19GPCxFaSDCHxh3QAW0RIExKUJly9Ydpoegmojfo0F4Hjt13zDm03fLEQ0eY8GjxIIHDt_zVRQGTW8d4tgZpTt4K9H1TTefG34EerN7jl7L-WNUe_gKorN4aSYBS6S6ma4Vb91NlUQ4cEGBKVQvumYe16p9Xj6Te-tCuiBmTOCq6iDsTH-eMlip_Bc18MD2BCGr2NdF4PB2vqHGSPIvSHDRXBjoPNtm18opAsUnOBu7-tysb8-EKFd5z7JbWgegQWNs11FdX0uFtC-U9ROwbHLJ3IHk4m2UHc2USwi7v4Xe6FtnkJ0VCZTajFUTXW33lwO3UsHuqEbxVnU_Rzuj6Ryjb08bpXpJBjIEGf2wBS3_I78cuXKOChHu-evtnjezc77joRUP8_I8pWsQbQ6bHABD95p8q6ZdQpDr9XQALbVg3ZvD5_QgF59rIxkW9a2L78oQpu0O3UT7-jxNFe38-OXuEr3VTv7RzISu1zjvBZD0k9-2q-T9BAJmsK6oPajJQWKwHBYF3w6vbsQ8tRDdh2uerhlAIWU0YL92gPCmT3mR6HxSGjAx08t-gib_YrzvWn0oTfLNk_BNfAMpG7Mj2GYNbyTkd_tjNZ2fOwVKbygsoFIUEvh2B-xyHOYuhXfxzI8-Gt55FMGDLLKcHfgmOZAUz1xVkIdm6bcuRFuQppgTzYIr66GN6tsr9KxTN2GZ2NHCwexe0hSAGfKVyLr8QBxTDRlzubBqe-osgQJrJtS7uM1MuWK_8grkZrNsn6g3ami0JboEmM_Ct3gVhkXo6lhCCcjn1gnGX-HOLczT3Xty1wYkeayUpi9x326nrSmypxzbzCRS3bOaPvSoBCszri0uTfUnVQK5kTVuRD30fGxauPhA\",\"type\":\"redacted_thinking\"},\"index\":0,\"type\":\"content_block_start\"}\n\nevent: content_block_stop\ndata: {\"index\":0,\"type\":\"content_block_stop\"}\n\nevent: content_block_start\ndata: {\"content_block\":{\"text\":\"\",\"type\":\"text\"},\"index\":1,\"type\":\"content_block_start\"}\n\nevent: content_block_delta\ndata: {\"delta\":{\"text\":\"37887\",\"type\":\"text_delta\"},\"index\":1,\"type\":\"content_block_delta\"}\n\nevent: content_block_stop\ndata: {\"index\":1,\"type\":\"content_block_stop\"}\n\nevent: message_delta\ndata: {\"delta\":{\"stop_reason\":\"end_turn\",\"stop_sequence\":null},\"type\":\"message_delta\",\"usage\":{\"cache_creation_input_tokens\":0,\"cache_read_input_tokens\":0,\"input_tokens\":23,\"output_tokens\":143,\"output_tokens_details\":{\"thinking_tokens\":131}}}\n\nevent: message_stop\ndata: {\"type\":\"message_stop\"}\n\n"
+      }
+    }
+  ]
+}
@@ -0,0 +1,202 @@
+import { expect } from "bun:test"
+import { Effect, Layer } from "effect"
+import { HttpClientRequest } from "effect/unstable/http"
+import { Image, ImageClient, ImageInput, LLM, LLMEvent, LLMRequest, Message, ToolDefinition } from "../../src/index.js"
+import { Meta } from "../../src/providers/meta.js"
+import { MetaMessages } from "../../src/protocols/meta-messages.js"
+import { AnthropicMessages } from "../../src/protocols/anthropic-messages.js"
+import { compileRequest } from "../../src/route/client.js"
+import { it } from "../lib/effect.js"
+import { dynamicResponse, fixedResponse } from "../lib/http.js"
+import { sseEvents } from "../lib/sse.js"
+
+it.effect("Meta selects Messages and lowers native search alongside ordinary functions", () =>
+  Effect.gen(function* () {
+    const model = Meta.messagesModel("muse-spark-1.3", { apiKey: "fixture", baseURL: "https://gateway.example/v1" })
+    expect(model.route.endpoint).toMatchObject({ baseURL: "https://gateway.example/v1", path: "/messages" })
+    expect(MetaMessages.protocol.stream).toBe(AnthropicMessages.protocol.stream)
+    const compiled = yield* compileRequest(
+      LLM.request({
+        model,
+        prompt: "Search",
+        tools: [
+          Meta.webSearch({ userLocation: { country: "US" } }),
+          ToolDefinition.make({ name: "lookup", description: "Lookup", inputSchema: { type: "object" } }),
+        ],
+        providerOptions: { effort: "low" },
+        generation: { maxTokens: 1024 },
+      }),
+    )
+    expect(compiled.body).toMatchObject({
+      max_tokens: 1024,
+      thinking: { type: "adaptive", display: "omitted" },
+      output_config: { effort: "low" },
+      tools: [
+        { type: "web_search", name: "web_search", user_location: { type: "approximate", country: "US" } },
+        { name: "lookup", description: "Lookup", input_schema: { type: "object" } },
+      ],
+    })
+    const entrypoint = yield* Effect.promise(() => import("@opencode-ai/ai/providers/meta/messages"))
+    expect(entrypoint.model("muse-spark-1.3", {}).route.id).toBe("meta-messages")
+  }),
+)
+
+it.effect("Meta rejects unsupported native tools instead of sending them as local functions", () =>
+  Effect.gen(function* () {
+    for (const input of [
+      {
+        model: Meta.responses("muse-spark-1.3"),
+        tool: ToolDefinition.make({
+          name: "foreign",
+          description: "Foreign tool",
+          inputSchema: {},
+          native: { other: { type: "web_search" } },
+        }),
+      },
+      { model: Meta.messages("muse-spark-1.3"), tool: Meta.imageGeneration() },
+      { model: Meta.messages("muse-spark-1.3"), tool: Meta.webSearch({ searchContextSize: "low" }) },
+    ]) {
+      const error = yield* compileRequest(
+        LLM.request({ model: input.model, prompt: "Hello", tools: [input.tool] }),
+      ).pipe(Effect.flip)
+      expect(error.reason._tag).toBe("InvalidRequest")
+    }
+  }),
+)
+
+it.effect("Meta Images preserves request overlays, bearer auth, JSON edit inputs and URL output formats", () =>
+  Effect.gen(function* () {
+    const response = yield* Image.generate({
+      model: Meta.configure({
+        apiKey: "fixture",
+        baseURL: "https://gateway.example/v1",
+        headers: { "x-client": "test" },
+      }).image("muse-image-1.0"),
+      prompt: "Edit",
+      images: [ImageInput.bytes(Uint8Array.from([1, 2, 3]), "image/png")],
+      options: {
+        outputFormat: "webp",
+        responseFormat: "url",
+        reasoningStrength: "low",
+        toolEnablement: { enable_web_search: false },
+        output_format: "png",
+      },
+      http: { body: { output_format: "jpeg", future_option: true }, query: { trace: "1" } },
+    })
+    expect(response.image?.mediaType).toBe("image/jpeg")
+    expect(response.image?.data).toBe("https://images.example/result.jpg")
+  }).pipe(
+    Effect.provide(
+      ImageClient.layer.pipe(
+        Layer.provide(
+          dynamicResponse((input) =>
+            Effect.gen(function* () {
+              const request = yield* HttpClientRequest.toWeb(input.request).pipe(Effect.orDie)
+              expect(request.url).toBe("https://gateway.example/v1/images/edits?trace=1")
+              expect(input.request.headers.authorization).toBe("Bearer fixture")
+              expect(input.request.headers["x-client"]).toBe("test")
+              expect(JSON.parse(input.text)).toEqual({
+                model: "muse-image-1.0",
+                prompt: "Edit",
+                images: [{ image_url: "data:image/png;base64,AQID" }],
+                output_format: "jpeg",
+                response_format: "url",
+                reasoning_strength: "low",
+                tool_enablement: { enable_web_search: false },
+                future_option: true,
+              })
+              return input.respond(JSON.stringify({ data: [{ url: "https://images.example/result.jpg" }] }), {
+                headers: { "content-type": "application/json" },
+              })
+            }),
+          ),
+        ),
+      ),
+    ),
+  ),
+)
+
+it.effect("Meta Images validates the final output format before sending the request", () =>
+  Effect.gen(function* () {
+    const error = yield* Image.generate({
+      model: Meta.configure({ apiKey: "fixture" }).image("muse-image-1.0"),
+      prompt: "Draw",
+      options: { outputFormat: "png" },
+      http: { body: { output_format: 42 } },
+    }).pipe(Effect.flip)
+    expect(error.reason._tag).toBe("InvalidRequest")
+  }).pipe(
+    Effect.provide(
+      ImageClient.layer.pipe(
+        Layer.provide(dynamicResponse(() => Effect.die("Invalid image requests must not reach HTTP"))),
+      ),
+    ),
+  ),
+)
+
+for (const streamed of [false, true]) {
+  it.effect(
+    `Meta recovers terminal image output ${streamed ? "without duplicating streamed items" : "with its signed replay handle"}`,
+    () =>
+      Effect.gen(function* () {
+        const item = { type: "image_generation_call", id: "ig_signed", status: "completed", result: "iVBORw0KGgo=" }
+        const request = LLM.request({
+          model: Meta.configure({ apiKey: "fixture" }).responses("muse-image-1.0"),
+          prompt: "Draw",
+        })
+        const response = yield* LLM.generate(request).pipe(
+          Effect.provide(
+            fixedResponse(
+              sseEvents(
+                { type: "response.created", response: { id: "resp_image" } },
+                ...(streamed
+                  ? [
+                      { type: "response.output_item.added", output_index: 0, item },
+                      { type: "response.output_item.done", output_index: 0, item },
+                    ]
+                  : []),
+                { type: "response.completed", response: { id: "resp_image", output: [item] } },
+              ),
+            ),
+          ),
+        )
+        expect(response.events.filter(LLMEvent.is.toolResult)).toHaveLength(1)
+        expect(response.events.filter(LLMEvent.is.finish)).toHaveLength(1)
+        expect(response.events.filter(LLMEvent.is.toolResult)[0]?.result).toEqual({
+          type: "content",
+          value: [{ type: "file", mime: "image/png", uri: "data:image/png;base64,iVBORw0KGgo=" }],
+        })
+        const replay = yield* compileRequest(
+          LLMRequest.update(request, { messages: [...request.messages, response.message, Message.user("Edit")] }),
+        )
+        expect(replay.body.input).toContainEqual({
+          type: "image_generation_call",
+          id: "ig_signed",
+          status: "completed",
+          result: null,
+        })
+      }),
+  )
+}
+
+it.effect("Meta rejects malformed image data from terminal-only Responses output", () =>
+  Effect.gen(function* () {
+    const error = yield* LLM.generate(
+      LLM.request({ model: Meta.configure({ apiKey: "fixture" }).responses("muse-image-1.0"), prompt: "Draw" }),
+    ).pipe(
+      Effect.provide(
+        fixedResponse(
+          sseEvents({
+            type: "response.completed",
+            response: {
+              id: "resp_invalid",
+              output: [{ type: "image_generation_call", id: "ig_invalid", result: "!not-base64!" }],
+            },
+          }),
+        ),
+      ),
+      Effect.flip,
+    )
+    expect(error.reason._tag).toBe("InvalidProviderOutput")
+  }),
+)
@@ -0,0 +1,118 @@
+import { expect } from "bun:test"
+import { Effect } from "effect"
+import { Image, ImageInput, LLM, LLMEvent, LLMRequest, Message } from "../../src/index.js"
+import { Meta } from "../../src/providers/meta.js"
+import { LLMClient } from "../../src/route.js"
+import { compileRequest } from "../../src/route/client.js"
+import { recordedTests } from "../recorded-test.js"
+
+const meta = Meta.configure({ apiKey: process.env.META_API_KEY ?? "fixture" })
+const modelID = "muse-image-1.0"
+const recorded = recordedTests({
+  prefix: "meta-images",
+  provider: "meta",
+  requires: ["META_API_KEY"],
+  tags: ["image"],
+  metadata: { model: modelID },
+})
+const controls = {
+  reasoningStrength: "low",
+  toolEnablement: { enable_image_search: false, enable_web_search: false, enable_shell: false },
+} as const
+
+recorded.effect.with(
+  "generates default WEBP bytes",
+  { protocol: "meta-images", tags: ["generation", "webp"] },
+  () =>
+    Effect.gen(function* () {
+      const response = yield* Image.generate({
+        model: meta.image(modelID),
+        prompt: "A flat black square centered on a plain white background. No text.",
+        options: { ...controls, n: 1, size: "256x256" },
+      })
+      expect(response.images).toHaveLength(1)
+      expect(response.image?.mediaType).toBe("image/webp")
+      expect(response.image?.data).toBeInstanceOf(Uint8Array)
+      if (!(response.image?.data instanceof Uint8Array)) throw new Error("Expected image bytes")
+      expect(new TextDecoder().decode(response.image.data.slice(0, 4))).toBe("RIFF")
+      expect(new TextDecoder().decode(response.image.data.slice(8, 12))).toBe("WEBP")
+      expect(response.usage?.outputTokens).toBeGreaterThan(0)
+    }),
+  180_000,
+)
+
+recorded.effect.with(
+  "edits image bytes and returns PNG",
+  { protocol: "meta-images", tags: ["editing", "png"] },
+  () =>
+    Effect.gen(function* () {
+      const response = yield* Image.generate({
+        model: meta.image(modelID),
+        prompt: "Change the shape to bright purple. Keep the plain white background.",
+        images: [
+          ImageInput.bytes(
+            yield* Effect.promise(() => Bun.file("test/fixtures/images/edit-source.jpg").bytes()),
+            "image/jpeg",
+          ),
+        ],
+        options: { ...controls, n: 1, outputFormat: "png", size: "256x256" },
+      })
+      expect(response.image?.mediaType).toBe("image/png")
+      if (!(response.image?.data instanceof Uint8Array)) throw new Error("Expected image bytes")
+      expect(Array.from(response.image.data.slice(0, 8))).toEqual([137, 80, 78, 71, 13, 10, 26, 10])
+    }),
+  180_000,
+)
+
+recorded.effect.with(
+  "replays a signed image handle for a Responses edit",
+  { protocol: "meta-responses", tags: ["hosted", "continuation", "editing"] },
+  () =>
+    Effect.gen(function* () {
+      const request = LLM.request({
+        model: meta.responses(modelID),
+        prompt: "A simple flat black square centered on a plain white background. No text.",
+        tools: [
+          Meta.imageGeneration({
+            reasoningStrength: "low",
+            enableImageSearch: false,
+            enableWebSearch: false,
+            enableShell: false,
+            size: "1024x1024",
+          }),
+        ],
+        generation: { maxTokens: 4096 },
+      })
+      const compiled = yield* compileRequest(request)
+      expect(compiled.body.tools).toMatchObject([
+        { type: "image_generation", reasoning_strength: "low", enable_web_search: false, size: "1024x1024" },
+      ])
+      const first = yield* LLMClient.generate(request)
+      const image = first.events.filter(LLMEvent.is.toolResult).find((event) => event.name === "image_generation")
+      expect(image?.providerExecuted).toBe(true)
+      expect(structuredClone(image?.result)).toMatchObject({
+        type: "content",
+        value: [{ type: "file", mime: "image/webp", uri: expect.stringMatching(/^data:image\/webp;base64,/) }],
+      })
+      const next = LLMRequest.update(request, {
+        messages: [
+          ...request.messages,
+          first.message,
+          Message.user("Change the square to blue. Keep the white background."),
+        ],
+      })
+      const replay = yield* compileRequest(next)
+      expect(replay.body.input).toEqual(
+        expect.arrayContaining([{ type: "image_generation_call", id: image?.id, status: "completed", result: null }]),
+      )
+      expect(JSON.stringify(replay.body.input)).not.toContain("data:image")
+      const second = yield* LLMClient.generate(next)
+      expect(
+        second.events.some(
+          (event) => LLMEvent.is.toolResult(event) && event.name === "image_generation" && event.providerExecuted,
+        ),
+      ).toBe(true)
+      expect(second.finishReason.normalized).toBe("stop")
+    }),
+  240_000,
+)
@@ -0,0 +1,120 @@
+import { expect } from "bun:test"
+import { Effect } from "effect"
+import { LLM, LLMEvent, LLMRequest, Message, ToolChoice, ToolDefinition } from "../../src/index.js"
+import { Meta } from "../../src/providers/meta.js"
+import { LLMClient } from "../../src/route.js"
+import { compileRequest } from "../../src/route/client.js"
+import { recordedTests } from "../recorded-test.js"
+
+const model = Meta.configure({ apiKey: process.env.META_API_KEY ?? "fixture" }).messages("muse-spark-1.3")
+const recorded = recordedTests({
+  prefix: "meta-messages",
+  provider: "meta",
+  protocol: "meta-messages",
+  requires: ["META_API_KEY"],
+  metadata: { model: model.id },
+})
+
+for (const mode of ["adaptive", "enabled"] as const) {
+  recorded.effect.with(
+    `streams text with ${mode} thinking`,
+    { tags: ["text", "reasoning", mode] },
+    () =>
+      Effect.gen(function* () {
+        const request = LLM.request({
+          model,
+          prompt: "What is 173 multiplied by 219? Reply with only the final integer.",
+          generation: { maxTokens: 2048 },
+          providerOptions: {
+            thinking:
+              mode === "adaptive"
+                ? { type: "adaptive", display: "omitted" }
+                : { type: "enabled", budgetTokens: 1024, display: "omitted" },
+            effort: "low",
+          },
+        })
+        const compiled = yield* compileRequest(request)
+        expect(compiled.body).toMatchObject({
+          stream: true,
+          max_tokens: 2048,
+          thinking: { type: mode, display: "omitted" },
+          output_config: { effort: "low" },
+        })
+        if (mode === "enabled") expect(compiled.body.thinking.budget_tokens).toBe(1024)
+        const response = yield* LLMClient.generate(request)
+        expect(response.text.replaceAll(",", "").trim()).toBe("37887")
+        expect(response.finishReason.normalized).toBe("stop")
+        expect(response.events.some(LLMEvent.is.textDelta)).toBe(true)
+        expect(response.events.filter(LLMEvent.is.finish)).toHaveLength(1)
+        expect(
+          response.message.content.find((part) => part.type === "reasoning")?.providerMetadata?.meta?.redactedData,
+        ).toEqual(expect.stringMatching(/\S/))
+        expect(response.usage?.reasoningTokens).toBeGreaterThan(0)
+      }),
+    90_000,
+  )
+}
+
+recorded.effect.with(
+  "replays encrypted thinking through a tool loop",
+  { tags: ["tool", "tool-loop", "reasoning"] },
+  () =>
+    Effect.gen(function* () {
+      const request = LLM.request({
+        model,
+        prompt:
+          "Look up the current weather in Paris using lookup_weather. After receiving the result, report Paris's weather in one short sentence.",
+        tools: [
+          ToolDefinition.make({
+            name: "lookup_weather",
+            description: "Look up current weather",
+            inputSchema: {
+              type: "object",
+              properties: { city: { type: "string", enum: ["Paris"] } },
+              required: ["city"],
+              additionalProperties: false,
+            },
+          }),
+        ],
+        toolChoice: "auto",
+        generation: { maxTokens: 1024 },
+        providerOptions: { effort: "low" },
+      })
+      const compiled = yield* compileRequest(request)
+      expect(compiled.body.tool_choice).toEqual({ type: "auto" })
+      const first = yield* LLMClient.generate(request)
+      expect(first.finishReason.normalized).toBe("tool-calls")
+      expect(first.toolCalls).toHaveLength(1)
+      expect(first.toolCalls[0]).toMatchObject({ name: "lookup_weather", input: { city: "Paris" } })
+      expect(first.events.some(LLMEvent.is.toolInputDelta)).toBe(true)
+      const encrypted = first.message.content.find((part) => part.type === "reasoning")?.providerMetadata?.meta
+        ?.redactedData
+      expect(encrypted).toEqual(expect.stringMatching(/\S/))
+      const next = LLMRequest.update(request, {
+        toolChoice: ToolChoice.make("none"),
+        messages: [
+          ...request.messages,
+          first.message,
+          ...first.toolCalls.map((call) =>
+            Message.tool({ id: call.id, name: call.name, result: { condition: "sunny" } }),
+          ),
+        ],
+      })
+      const replay = yield* compileRequest(next)
+      expect(replay.body.messages[1].content).toEqual(
+        expect.arrayContaining([
+          { type: "redacted_thinking", data: encrypted },
+          expect.objectContaining({ type: "tool_use", id: first.toolCalls[0]?.id }),
+        ]),
+      )
+      expect(replay.body.messages[2].content).toMatchObject([
+        { type: "tool_result", tool_use_id: first.toolCalls[0]?.id, content: '{"condition":"sunny"}' },
+      ])
+      expect(replay.body.tool_choice).toEqual({ type: "none" })
+      const second = yield* LLMClient.generate(next)
+      expect(second.text.toLowerCase()).toContain("sunny")
+      expect(second.toolCalls).toHaveLength(0)
+      expect(second.finishReason.normalized).toBe("stop")
+    }),
+  90_000,
+)
@@ -0,0 +1,96 @@
+import { expect } from "bun:test"
+import { Effect } from "effect"
+import { LLM, LLMEvent, LLMRequest, Message } from "../../src/index.js"
+import { Meta } from "../../src/providers/meta.js"
+import { LLMClient } from "../../src/route.js"
+import { compileRequest } from "../../src/route/client.js"
+import { recordedTests } from "../recorded-test.js"
+
+const meta = Meta.configure({ apiKey: process.env.META_API_KEY ?? "fixture" })
+const recorded = recordedTests({
+  prefix: "meta-search",
+  provider: "meta",
+  requires: ["META_API_KEY"],
+  tags: ["tool", "hosted", "web-search", "citation", "continuation"],
+  metadata: { model: "muse-spark-1.3" },
+})
+
+for (const api of ["responses", "messages"] as const) {
+  recorded.effect.with(
+    `searches and replays grounded ${api}`,
+    { protocol: `meta-${api}` },
+    () =>
+      Effect.gen(function* () {
+        const request = LLM.request({
+          model: meta[api]("muse-spark-1.3"),
+          prompt:
+            "Use web search to find NASA's page identifying the first person to walk on the Moon. Answer in one sentence with a source citation.",
+          tools: [Meta.webSearch()],
+          generation: { maxTokens: 2048 },
+          providerOptions:
+            api === "responses"
+              ? { reasoningEffort: "low", include: ["reasoning.encrypted_content", "web_search_call.results"] }
+              : { effort: "low" },
+        })
+        const compiled = yield* compileRequest(request)
+        expect(compiled.body.tools).toEqual([
+          api === "responses" ? { type: "web_search" } : { type: "web_search", name: "web_search" },
+        ])
+        const first = yield* LLMClient.generate(request)
+        expect(first.text.toLowerCase()).toContain("armstrong")
+        expect(
+          first.events.some(
+            (event) => LLMEvent.is.toolCall(event) && event.providerExecuted && event.name === "web_search",
+          ),
+        ).toBe(true)
+        expect(first.finishReason.normalized).toBe("stop")
+        if (api === "responses") {
+          const results = first.events
+            .filter(LLMEvent.is.toolResult)
+            .filter((event) => event.providerExecuted && event.name === "web_search")
+          expect(results.length).toBeGreaterThan(0)
+          expect(structuredClone(results[0]?.result)).toMatchObject({
+            type: "json",
+            value: {
+              type: "web_search_call",
+              results: expect.arrayContaining([
+                expect.objectContaining({ url: expect.any(String), title: expect.any(String) }),
+              ]),
+            },
+          })
+          const annotations = first.message.content
+            .filter((part) => part.type === "text")
+            .flatMap((part) => part.providerMetadata?.meta?.annotations ?? [])
+          expect(annotations).toEqual(
+            expect.arrayContaining([
+              expect.objectContaining({ type: "url_citation", url: expect.stringMatching(/^https?:\/\//) }),
+            ]),
+          )
+        }
+        const next = LLMRequest.update(request, {
+          tools: [],
+          messages: [
+            ...request.messages,
+            first.message,
+            Message.user("Using the information already found, reply with just that person's surname."),
+          ],
+        })
+        const replay = yield* compileRequest(next)
+        if (api === "responses")
+          expect(replay.body.input).toEqual(
+            expect.arrayContaining([
+              expect.objectContaining({ type: "web_search_call", results: expect.any(Array) }),
+              expect.objectContaining({ type: "reasoning", encrypted_content: expect.any(String) }),
+            ]),
+          )
+        if (api === "messages")
+          expect(replay.body.messages[1].content).toEqual(
+            expect.arrayContaining([expect.objectContaining({ type: "server_tool_use", name: "web_search" })]),
+          )
+        const second = yield* LLMClient.generate(next)
+        expect(second.text.toLowerCase()).toContain("armstrong")
+        expect(second.finishReason.normalized).toBe("stop")
+      }),
+    120_000,
+  )
+}
@@ -0,0 +1,181 @@
+import { describe, expect } from "bun:test"
+import { Effect } from "effect"
+import { LLM, LLMEvent, LLMRequest, LLMResponse, Message, ToolDefinition } from "../../src/index.js"
+import { Meta } from "../../src/providers/meta.js"
+import { LLMClient } from "../../src/route.js"
+import { compileRequest } from "../../src/route/client.js"
+import { recordedTests } from "../recorded-test.js"
+
+const meta = Meta.configure({ apiKey: process.env.META_API_KEY ?? "fixture" })
+const modelID = "muse-spark-1.3"
+const weather = ToolDefinition.make({
+  name: "lookup_weather",
+  description: "Look up the current weather for a city",
+  inputSchema: {
+    type: "object",
+    properties: { city: { type: "string", enum: ["Paris"] } },
+    required: ["city"],
+    additionalProperties: false,
+  },
+})
+
+for (const api of ["responses", "chat"] as const) {
+  const recorded = recordedTests({
+    prefix: `meta-${api}`,
+    provider: "meta",
+    protocol: api === "responses" ? "open-responses" : "openai-chat",
+    requires: ["META_API_KEY"],
+    metadata: { model: modelID },
+  })
+
+  describe(`Meta ${api} recorded`, () => {
+    for (const effort of [undefined, "minimal", "low", "medium", "high", "xhigh", "max"]) {
+      recorded.effect.with(
+        `streams text with ${effort ?? "default"} reasoning`,
+        { tags: ["text", "reasoning", "usage", `effort:${effort ?? "default"}`] },
+        () =>
+          Effect.gen(function* () {
+            const request = LLM.request({
+              model: meta[api](modelID),
+              prompt: "What is 173 multiplied by 219? Reply with only the final integer.",
+              generation: { maxTokens: 1024 },
+              providerOptions: {
+                reasoningEffort: effort,
+                ...(api === "responses" && effort === "high" ? { reasoningSummary: "auto" } : {}),
+              },
+            })
+            const compiled = yield* compileRequest(request)
+            expect(compiled.body).toMatchObject({ model: modelID, stream: true })
+            if (api === "responses") {
+              expect(compiled.body).toMatchObject({
+                max_output_tokens: 1024,
+                store: false,
+                include: ["reasoning.encrypted_content"],
+              })
+              expect(compiled.body.reasoning?.effort).toBe(effort)
+              if (effort === "high") expect(compiled.body.reasoning.summary).toBe("auto")
+            }
+            if (api === "chat") {
+              expect(compiled.body).toMatchObject({
+                max_completion_tokens: 1024,
+                stream_options: { include_usage: true },
+              })
+              expect(compiled.body.reasoning_effort).toBe(effort)
+              expect(compiled.body.max_tokens).toBeUndefined()
+              expect(compiled.body.store).toBeUndefined()
+            }
+
+            const response = yield* LLMClient.generate(request)
+            expect(response.text.replaceAll(",", "").trim()).toBe("37887")
+            expect(response.finishReason.normalized).toBe("stop")
+            expect(response.events.some(LLMEvent.is.textDelta)).toBe(true)
+            expectUsage(response)
+            if (api === "chat") expect(response.reasoning).toBe("")
+            if (api === "responses") {
+              const reasoning = response.message.content.find((part) => part.type === "reasoning")
+              expect(reasoning?.providerMetadata?.meta?.reasoningEncryptedContent).toEqual(expect.stringMatching(/\S/))
+            }
+          }),
+        90_000,
+      )
+    }
+
+    recorded.effect.with(
+      api === "responses" ? "replays encrypted reasoning through a tool loop" : "continues a generated tool call",
+      { tags: ["tool", "tool-loop", "reasoning", "usage", "effort:low"] },
+      () =>
+        Effect.gen(function* () {
+          const request = LLM.request({
+            model: meta[api](modelID),
+            prompt:
+              "Look up the current weather in Paris using lookup_weather before answering. After receiving the result, report Paris's weather in one short sentence.",
+            tools: [weather],
+            toolChoice: "auto",
+            providerOptions: { reasoningEffort: "low" },
+            generation: { maxTokens: 1024 },
+          })
+          const compiled = yield* compileRequest(request)
+          expect(compiled.body.tool_choice).toBe("auto")
+          expect(compiled.body.tools).toHaveLength(1)
+          const first = yield* LLMClient.generate(request)
+          expect(first.finishReason.normalized).toBe("tool-calls")
+          expect(first.toolCalls).toHaveLength(1)
+          expect(first.toolCalls[0]).toMatchObject({ name: "lookup_weather", input: { city: "Paris" } })
+          expect(first.events.some(LLMEvent.is.toolInputDelta)).toBe(true)
+          expectUsage(first)
+
+          const followUp = LLMRequest.update(request, {
+            messages: [
+              ...request.messages,
+              first.message,
+              ...first.toolCalls.map((call) =>
+                Message.tool({ id: call.id, name: call.name, result: { condition: "sunny", temperature: "18C" } }),
+              ),
+            ],
+          })
+          const replay = yield* compileRequest(followUp)
+          if (api === "responses") {
+            const reasoning = first.message.content.find((part) => part.type === "reasoning")
+            expect(reasoning?.providerMetadata?.meta?.reasoningEncryptedContent).toEqual(expect.stringMatching(/\S/))
+            expect(replay.body.input).toEqual(
+              expect.arrayContaining([
+                expect.objectContaining({
+                  type: "reasoning",
+                  summary: [],
+                  encrypted_content: reasoning?.providerMetadata?.meta?.reasoningEncryptedContent,
+                }),
+                expect.objectContaining({
+                  type: "function_call",
+                  call_id: first.toolCalls[0]?.id,
+                  name: "lookup_weather",
+                  arguments: '{"city":"Paris"}',
+                }),
+                expect.objectContaining({
+                  type: "function_call_output",
+                  call_id: first.toolCalls[0]?.id,
+                  output: '{"condition":"sunny","temperature":"18C"}',
+                }),
+              ]),
+            )
+          }
+          if (api === "chat") {
+            expect(first.reasoning).toBe("")
+            expect(replay.body.messages).toEqual(
+              expect.arrayContaining([
+                expect.objectContaining({
+                  role: "assistant",
+                  tool_calls: [
+                    expect.objectContaining({
+                      id: first.toolCalls[0]?.id,
+                      function: { name: "lookup_weather", arguments: '{"city":"Paris"}' },
+                    }),
+                  ],
+                }),
+                {
+                  role: "tool",
+                  tool_call_id: first.toolCalls[0]?.id,
+                  content: '{"condition":"sunny","temperature":"18C"}',
+                },
+              ]),
+            )
+          }
+
+          const second = yield* LLMClient.generate(followUp)
+          expect(second.finishReason.normalized).toBe("stop")
+          expect(second.toolCalls).toHaveLength(0)
+          expect(second.text).toContain("Paris")
+          expect(second.text.toLowerCase()).toContain("sunny")
+          expectUsage(second)
+        }),
+      90_000,
+    )
+  })
+}
+
+function expectUsage(response: LLMResponse) {
+  expect(response.usage?.inputTokens).toBeGreaterThan(0)
+  expect(response.usage?.outputTokens).toBeGreaterThan(0)
+  expect(response.usage?.reasoningTokens).toBeGreaterThan(0)
+  expect(response.events.filter(LLMEvent.is.finish)).toHaveLength(1)
+  expect(response.events.filter(LLMEvent.is.stepFinish)).toHaveLength(1)
+}
@@ -0,0 +1,140 @@
+import { expect } from "bun:test"
+import { ConfigProvider, Effect } from "effect"
+import { Headers } from "effect/unstable/http"
+import { Auth, LLM, LLMClient } from "../../src/index.js"
+import { Meta } from "../../src/providers/index.js"
+import { OpenAIChat } from "../../src/protocols/openai-chat.js"
+import { OpenResponses } from "../../src/protocols/open-responses.js"
+import { MetaResponses } from "../../src/protocols/meta-responses.js"
+import { compileRequest } from "../../src/route/client.js"
+import { it } from "../lib/effect.js"
+import { dynamicResponse } from "../lib/http.js"
+import { sseEvents } from "../lib/sse.js"
+
+it.effect("Meta composes baseline protocols with provider-owned endpoints and defaults", () =>
+  Effect.gen(function* () {
+    const meta = Meta.configure({ apiKey: "fixture" })
+    const responses = meta.model("muse-spark-1.3")
+    const chat = meta.chat("muse-spark-1.3")
+    expect(responses.route.body).toBe(MetaResponses.protocol.body)
+    expect(MetaResponses.protocol.stream.event).toBe(OpenResponses.protocol.stream.event)
+    expect(chat.route.body).toBe(OpenAIChat.protocol.body)
+    expect(meta.model).toBe(meta.responses)
+    for (const model of [responses, chat]) {
+      expect(model.provider).toBe("meta")
+      expect(model.route.providerMetadataKey).toBe("meta")
+      expect(model.route.endpoint.baseURL).toBe("https://api.meta.ai/v1")
+    }
+    expect(responses.route.endpoint.path).toBe("/responses")
+    expect(chat.route.endpoint.path).toBe("/chat/completions")
+    const compiled = yield* compileRequest(LLM.request({ model: responses, prompt: "Hello" }))
+    expect(compiled.protocol).toBe("meta-responses")
+    expect(compiled.body).toMatchObject({ store: false, include: ["reasoning.encrypted_content"] })
+    expect(compiled.body.reasoning).toBeUndefined()
+  }),
+)
+
+it.effect("Meta Responses stays on HTTP when a WebSocket executor is supplied", () =>
+  Effect.gen(function* () {
+    for (const baseURL of ["https://api.meta.ai/v1", "https://gateway.example/v1"]) {
+      const response = yield* LLMClient.generate(
+        LLM.request({
+          model: Meta.configure({ apiKey: "fixture", baseURL }).responses("muse-spark-1.3"),
+          prompt: "Hello",
+        }),
+        { webSocket: { execute: () => Effect.die("Meta must not execute WebSocket requests") } },
+      ).pipe(
+        Effect.provide(
+          dynamicResponse((input) =>
+            Effect.sync(() => {
+              expect(input.request.method).toBe("POST")
+              expect(input.request.url).toBe(`${baseURL}/responses`)
+              expect(input.request.headers.authorization).toBe("Bearer fixture")
+              expect(input.request.headers["openai-beta"]).toBeUndefined()
+              expect(JSON.parse(input.text)).toMatchObject({ model: "muse-spark-1.3", stream: true })
+              return input.respond(
+                sseEvents(
+                  { type: "response.created", response: { id: "resp_http" } },
+                  {
+                    type: "response.output_item.done",
+                    output_index: 0,
+                    item: {
+                      id: "msg_http",
+                      type: "message",
+                      role: "assistant",
+                      content: [{ type: "output_text", text: "Hello" }],
+                    },
+                  },
+                  { type: "response.completed", response: { id: "resp_http" } },
+                ),
+                { headers: { "content-type": "text/event-stream" } },
+              )
+            }),
+          ),
+        ),
+      )
+      expect(response.text).toBe("Hello")
+      expect(response.finishReason.normalized).toBe("stop")
+    }
+  }),
+)
+
+it.effect("Meta package selectors preserve overrides and Chat token policy on custom endpoints", () =>
+  Effect.gen(function* () {
+    for (const select of [Meta.model, Meta.chatModel]) {
+      const model = select("future-model", {
+        apiKey: "fixture",
+        baseURL: "https://gateway.example/v1",
+        headers: { "x-client": "test" },
+        body: { custom: "value" },
+        providerOptions: { reasoningEffort: "future-effort" },
+      })
+      expect(model.route.endpoint.baseURL).toBe("https://gateway.example/v1")
+      expect(model.route.defaults.headers).toEqual({ "x-client": "test" })
+      expect(model.route.defaults.http?.body).toEqual({ custom: "value" })
+      const compiled = yield* compileRequest(
+        LLM.request({
+          model,
+          prompt: "Hello",
+          generation: { maxTokens: 64 },
+          providerOptions: { store: true, include: [] },
+        }),
+      )
+      if (select === Meta.model) {
+        expect(compiled.body).toMatchObject({
+          store: true,
+          max_output_tokens: 64,
+          reasoning: { effort: "future-effort" },
+        })
+        expect(compiled.body.include).toBeUndefined()
+      }
+      if (select === Meta.chatModel) {
+        expect(compiled.body).toMatchObject({ max_completion_tokens: 64, reasoning_effort: "future-effort" })
+        expect(compiled.body.max_tokens).toBeUndefined()
+        expect(compiled.body.store).toBeUndefined()
+      }
+    }
+  }),
+)
+
+it.effect("Meta resolves environment credentials and accepts explicit auth overrides", () =>
+  Effect.gen(function* () {
+    for (const api of ["responses", "chat"] as const) {
+      for (const scenario of [
+        { provider: Meta.configure(), authorization: "Bearer environment-key" },
+        { provider: Meta.configure({ apiKey: "explicit-key" }), authorization: "Bearer explicit-key" },
+        { provider: Meta.configure({ auth: Auth.none }), authorization: undefined },
+      ]) {
+        const model = scenario.provider[api]("muse-spark-1.3")
+        const headers = yield* model.route.auth.apply({
+          request: LLM.request({ model, prompt: "Hello" }),
+          method: "POST",
+          url: "https://api.meta.ai/v1/responses",
+          body: "{}",
+          headers: Headers.empty,
+        })
+        expect(headers.authorization).toBe(scenario.authorization)
+      }
+    }
+  }).pipe(Effect.provide(ConfigProvider.layer(ConfigProvider.fromEnv({ env: { META_API_KEY: "environment-key" } })))),
+)