@pentoshi/clai 4.0.3 → 4.2.0

package/dist/llm/meta.js

@@ -1,10 +1,13 @@
 import { defaultModels } from "./provider.js";
 import { readJson, ingestOpenAiModelCatalog, ProviderError, createSseFrameAssembler, THINKING_STREAM_IDLE_TIMEOUT_MS, THINKING_STREAM_INITIAL_IDLE_TIMEOUT_MS, STREAM_STALL_MARKER, } from "./http.js";
-import { modelAcceptsImages } from "./capabilities.js";
-import { resolveSampling } from "./sampling.js";
+import { completeGenerationAttempt, generationFetch, runGenerationAttempt, } from "./operation-usage.js";
+import { isOperationPolicyError } from "./operation-ledger.js";
 import { toWireName, fromWireName, parseToolArguments } from "./tool-protocol.js";
 import { normalizeTokenUsage } from "./token-usage.js";
-import { REASONING_CLOSE, REASONING_OPEN, wrapReasoning, } from "./reasoning-marker.js";
+import { createReasoningArtifact, createReasoningArtifactProvenance, reasoningArtifactItems, reasoningArtifactsForMessage, selectReasoningArtifactsForReplay, } from "./reasoning-artifacts.js";
+import { compileRequestPlan } from "./request-plan.js";
+import { emitStreamReasoningArtifacts, emitStreamReasoningDelta, } from "./stream-events.js";
+import { META_STREAM_TERMINAL, requireTerminalProof, } from "./stream-terminal.js";
 const baseUrl = "https://api.meta.ai/v1";
 const modelCache = new Map();
 const CACHE_TTL_MS = 60 * 60 * 1000;
@@ -34,7 +37,32 @@ function metaReasoningPayload(reasoning) {
         summary = "auto";
     return { effort: eff, summary };
 }
-function toResponsesInput(messages, supportsVision) {
+function metaReplayArtifacts(message, replay) {
+    return selectReasoningArtifactsForReplay({
+        artifacts: reasoningArtifactsForMessage(message),
+        target: replay.target,
+        context: { hasToolCalls: Boolean(message.toolCalls?.length) },
+        observe: replay.observe,
+    })
+        .filter((artifact) => artifact.kind === "encrypted")
+        .sort((left, right) => left.position.sequence - right.position.sequence)
+        .map((artifact) => {
+        const byId = artifact.position.toolCallId
+            ? message.toolCalls?.findIndex((toolCall) => toolCall.id === artifact.position.toolCallId)
+            : undefined;
+        const toolCallIndex = artifact.position.toolCallIndex ??
+            (byId !== undefined && byId >= 0 ? byId : undefined);
+        return {
+            items: reasoningArtifactItems(artifact),
+            ...(toolCallIndex === undefined ? {} : { toolCallIndex }),
+        };
+    });
+}
+function appendMetaReplayItems(input, entries) {
+    for (const entry of entries)
+        input.push(...entry.items);
+}
+function toResponsesInput(messages, supportsVision, replay) {
     const input = [];
     for (const m of messages) {
         if (m.role === "system") {
@@ -74,13 +102,19 @@ function toResponsesInput(messages, supportsVision) {
             continue;
         }
         if (m.role === "assistant") {
-            const replayItems = m.reasoningBlock?.items;
-            if (Array.isArray(replayItems) && replayItems.length > 0) {
-                for (const item of replayItems)
-                    input.push(item);
+            const replayArtifacts = metaReplayArtifacts(m, replay);
+            const leadingArtifacts = replayArtifacts.filter((artifact) => artifact.toolCallIndex === undefined);
+            const artifactsByTool = new Map();
+            for (const artifact of replayArtifacts) {
+                if (artifact.toolCallIndex === undefined)
+                    continue;
+                const current = artifactsByTool.get(artifact.toolCallIndex) ?? [];
+                current.push(artifact);
+                artifactsByTool.set(artifact.toolCallIndex, current);
             }
             const hasTools = m.toolCalls && m.toolCalls.length > 0;
             if (hasTools) {
+                appendMetaReplayItems(input, leadingArtifacts);
                 if (m.content && m.content.trim()) {
                     input.push({
                         type: "message",
@@ -89,7 +123,8 @@ function toResponsesInput(messages, supportsVision) {
                         content: [{ type: "output_text", text: m.content }],
                     });
                 }
-                for (const tc of m.toolCalls) {
+                for (const [toolCallIndex, tc] of m.toolCalls.entries()) {
+                    appendMetaReplayItems(input, artifactsByTool.get(toolCallIndex) ?? []);
                     const wire = toWireName(tc.name);
                     input.push({
                         type: "function_call",
@@ -100,6 +135,7 @@ function toResponsesInput(messages, supportsVision) {
                 }
                 continue;
             }
+            appendMetaReplayItems(input, replayArtifacts);
             if (m.content !== undefined && m.content !== null) {
                 input.push({
                     type: "message",
@@ -130,7 +166,7 @@ function toResponsesTools(tools) {
         parameters: t.parameters,
     }));
 }
-function parseMetaUsage(raw) {
+export function parseMetaUsage(raw) {
     if (!raw || typeof raw !== "object" || Array.isArray(raw))
         return undefined;
     const u = raw;
@@ -140,16 +176,27 @@ function parseMetaUsage(raw) {
     const outputTokens = u.output_tokens ??
         u.completion_tokens ??
         u.outputTokens;
-    const totalTokens = u.total_tokens ?? u.totalTokens;
-    const cached = u.input_tokens_details?.cached_tokens ??
-        u.prompt_tokens_details?.cached_tokens;
-    const reasoning = u.output_tokens_details?.reasoning_tokens ??
-        u.completion_tokens_details?.reasoning_tokens;
+    const totalTokens = u.total_tokens ??
+        u.totalTokens;
+    const inputDetails = u.input_tokens_details;
+    const promptDetails = u.prompt_tokens_details;
+    const outputDetails = u.output_tokens_details;
+    const completionDetails = u.completion_tokens_details;
+    const cached = inputDetails?.cached_tokens ?? promptDetails?.cached_tokens;
+    const cacheCreation = inputDetails?.cache_creation_tokens ??
+        promptDetails?.cache_creation_tokens ??
+        u.cache_creation_input_tokens;
+    const uncached = inputDetails?.uncached_tokens ??
+        promptDetails?.uncached_tokens ??
+        u.prompt_cache_miss_tokens;
+    const reasoning = outputDetails?.reasoning_tokens ?? completionDetails?.reasoning_tokens;
     return normalizeTokenUsage({
         promptTokens: inputTokens,
         completionTokens: outputTokens,
         totalTokens,
         cachedPromptTokens: typeof cached === "number" ? cached : undefined,
+        cacheCreationTokens: typeof cacheCreation === "number" ? cacheCreation : undefined,
+        uncachedPromptTokens: typeof uncached === "number" ? uncached : undefined,
         reasoningTokens: typeof reasoning === "number" ? reasoning : undefined,
         exact: true,
     });
@@ -170,29 +217,42 @@ function extractReasoningSummary(item) {
     return out;
 }
 function buildResponsesBody(options) {
-    const reasoning = metaReasoningPayload(options.reasoning);
-    const input = toResponsesInput(options.messages, options.supportsVision);
-    const tools = toResponsesTools(options.tools);
-    const reasoningOn = Boolean(options.reasoning?.enabled);
-    const defaultMax = reasoningOn ? 8192 : 4096;
-    const effectiveMax = Math.max(16, options.maxTokens ?? defaultMax);
-    const sampling = resolveSampling({
+    const plan = compileRequestPlan({
+        provider: "meta",
         model: options.model,
-        reasoningEnabled: reasoningOn,
-        requestedTemperature: options.temperature,
+        messages: options.messages,
+        stream: options.stream,
+        endpoint: baseUrl,
+        reasoning: options.reasoning,
+        tools: options.tools,
+        parallelToolCalls: options.parallelToolCalls,
+        temperature: options.temperature,
+        maxTokens: options.maxTokens,
     });
+    const reasoning = metaReasoningPayload(plan.controls.reasoning);
+    const input = toResponsesInput([...plan.timeline.messages], plan.images.visionAccepted, {
+        target: plan.replay.target,
+        observe: options.reasoningArtifactReplayObserver,
+    });
+    const tools = toResponsesTools(plan.tools.definitions.length ? [...plan.tools.definitions] : undefined);
+    const reasoningOn = Boolean(plan.controls.reasoning?.enabled);
+    const defaultMax = reasoningOn ? 8192 : 4096;
+    const effectiveMax = Math.max(16, plan.controls.requestedMaxTokens ?? defaultMax);
     const body = {
         model: options.model,
         input,
         store: false,
-        prompt_cache_key: "clai",
+        // Turn and compaction requests share one bucket on purpose so a compaction
+        // prompt can reuse the turn's cached prefix. Auxiliary requests get their
+        // own bucket so their unrelated short prefix cannot evict it.
+        prompt_cache_key: options.purpose === "auxiliary" ? "clai-auxiliary" : "clai",
         prompt_cache_retention: "24h",
         include: ["reasoning.encrypted_content"],
         max_output_tokens: effectiveMax,
-        temperature: sampling.temperature,
+        temperature: plan.controls.temperature,
     };
-    if (sampling.topP !== undefined)
-        body.top_p = sampling.topP;
+    if (plan.controls.topP !== undefined)
+        body.top_p = plan.controls.topP;
     if (reasoning)
         body.reasoning = reasoning;
     if (options.stream)
@@ -204,13 +264,34 @@ function buildResponsesBody(options) {
     }
     return JSON.stringify(body);
 }
+const META_MAX_OUTPUT_TOKENS_CAP = 65536;
+const MAX_INCOMPLETE_BUDGET_RETRIES = 2;
+const incompleteBudgetRetries = new WeakMap();
+function incompleteBudgetRetry(request, reasoningOn) {
+    const used = incompleteBudgetRetries.get(request) ?? 0;
+    const currentBudget = Math.max(16, request.maxTokens ?? (reasoningOn ? 8192 : 4096));
+    const nextBudget = Math.min(currentBudget * 2, META_MAX_OUTPUT_TOKENS_CAP);
+    if (used >= MAX_INCOMPLETE_BUDGET_RETRIES || nextBudget <= currentBudget)
+        return undefined;
+    const retryRequest = { ...request, maxTokens: nextBudget };
+    incompleteBudgetRetries.set(retryRequest, used + 1);
+    return retryRequest;
+}
+function budgetExhaustedError(request, reasoningOn, payload) {
+    const currentBudget = Math.max(16, request.maxTokens ?? (reasoningOn ? 8192 : 4096));
+    const effort = metaReasoningPayload(request.thinking)?.effort;
+    const retried = (incompleteBudgetRetries.get(request) ?? 0) > 0;
+    return new ProviderError(`Meta Model API spent the entire output budget (${currentBudget} tokens${effort ? `, mostly on reasoning at ${effort} effort` : ""}) without producing an answer${retried ? ", even after raising max_output_tokens" : ""}. Lower the effort with /effort high or raise max_tokens.`, undefined, payload.slice(0, 1000));
+}
 function parseResponsesOutput(data) {
     const output = Array.isArray(data.output) ? data.output : [];
     let text = "";
     let reasoningSummary = "";
     const toolCalls = [];
     const reasoningItems = [];
-    for (const item of output) {
+    const reasoningItemSequences = [];
+    const toolCallSequences = [];
+    for (const [sequence, item] of output.entries()) {
         if (!item || typeof item !== "object")
             continue;
         const obj = item;
@@ -229,12 +310,8 @@ function parseResponsesOutput(data) {
             if (s)
                 reasoningSummary += s;
             if (typeof obj.encrypted_content === "string" && obj.encrypted_content) {
-                reasoningItems.push({
-                    type: "reasoning",
-                    ...(typeof obj.id === "string" ? { id: obj.id } : {}),
-                    summary: Array.isArray(obj.summary) ? obj.summary : [],
-                    encrypted_content: obj.encrypted_content,
-                });
+                reasoningItems.push({ ...obj });
+                reasoningItemSequences.push(sequence);
             }
         }
         else if (obj.type === "function_call") {
@@ -253,23 +330,52 @@ function parseResponsesOutput(data) {
             catch {
                 args = parseToolArguments(rawArgs);
             }
+            const toolCallIndex = toolCalls.length;
             toolCalls.push({ id: callId, name: canonical, args, rawArguments: rawArgs });
+            toolCallSequences.push({ sequence, toolCallIndex });
         }
     }
+    const reasoningItemPositions = reasoningItemSequences.map((sequence) => {
+        const followingTool = toolCallSequences.find((toolCall) => toolCall.sequence > sequence);
+        return followingTool
+            ? { sequence, toolCallIndex: followingTool.toolCallIndex }
+            : { sequence };
+    });
     const usage = parseMetaUsage(data.usage);
-    return { text, toolCalls, usage, reasoningSummary, reasoningItems };
+    return {
+        text,
+        toolCalls,
+        usage,
+        reasoningSummary,
+        reasoningItems,
+        reasoningItemPositions,
+    };
 }
-function foldResponsesReasoning(text, reasoningSummary, usage, effort) {
-    if (reasoningSummary && reasoningSummary.trim()) {
-        return `${wrapReasoning(reasoningSummary)}${text}`;
-    }
-    const tokens = usage?.reasoningTokens ?? 0;
-    if (tokens > 0) {
-        const effortText = effort ? ` at ${effort} effort` : "";
-        const note = `Reasoning is private on Meta Model API: the model reasoned${effortText} and used ${tokens.toLocaleString("en-US")} reasoning tokens, but the API returns no reasoning text to display.`;
-        return `${wrapReasoning(note)}${text}`;
-    }
-    return text;
+function metaReasoningArtifacts(model, items, positions) {
+    const provenance = createReasoningArtifactProvenance({
+        provider: "meta",
+        model,
+        dialect: "meta-responses",
+        endpoint: baseUrl,
+    });
+    const artifacts = items.map((item, index) => {
+        const position = positions[index] ?? { sequence: index };
+        const replayable = position.toolCallIndex !== undefined;
+        return createReasoningArtifact({
+            kind: "encrypted",
+            raw: item,
+            provenance,
+            replay: replayable
+                ? { scope: "tool-turn", persistence: "tool-turn" }
+                : { scope: "none", persistence: "never" },
+            position: {
+                sequence: position.sequence,
+                placement: replayable ? "before-tool-call" : "assistant",
+                ...(replayable ? { toolCallIndex: position.toolCallIndex } : {}),
+            },
+        });
+    });
+    return artifacts.length ? artifacts : undefined;
 }
 function readWithAbort(reader, signal) {
     if (signal.aborted) {
@@ -306,6 +412,7 @@ function readWithAbort(reader, signal) {
 }
 export const metaProvider = {
     id: "meta",
+    reasoningStyle: "meta",
     displayName: "Meta Model API",
     defaultModel: defaultModels.meta,
     envVar: "MODEL_API_KEY",
@@ -345,187 +452,49 @@ export const metaProvider = {
         if (!auth.apiKey)
             throw new Error("Meta Model API key is required");
         const model = request.model ?? defaultModels.meta;
-        const supportsVision = modelAcceptsImages("meta", model);
-        const body = buildResponsesBody({
-            model,
-            messages: request.messages,
-            maxTokens: request.maxTokens,
-            temperature: request.temperature,
-            stream: false,
-            reasoning: request.thinking,
-            supportsVision,
-            tools: request.tools,
-            parallelToolCalls: request.parallelToolCalls,
-        });
-        let response;
-        try {
-            response = await fetch(`${baseUrl}/responses`, {
-                method: "POST",
-                signal: request.signal ?? null,
-                headers: {
-                    "content-type": "application/json",
-                    accept: "application/json",
-                    authorization: `Bearer ${auth.apiKey}`,
-                },
-                body,
-                verbose: process.env.CLAI_VERBOSE === "true",
-            });
-        }
-        catch (error) {
-            if (error instanceof Error && error.name === "AbortError")
-                throw error;
-            const msg = error instanceof Error ? error.message : String(error);
-            throw new ProviderError(`Meta Model API request could not be sent (${msg}). Check connectivity to ${baseUrl}.`);
-        }
-        let data;
-        try {
-            data = await readJson(response);
-        }
-        catch (error) {
-            if (error instanceof ProviderError) {
-                throw new ProviderError(`Meta Model API (model=${model}): ${error.message}`, error.status, error.body, error.retryAfterSeconds);
-            }
-            throw error;
-        }
-        const parsed = parseResponsesOutput(data);
-        const usage = parsed.usage ?? parseMetaUsage(data.usage);
-        const effort = metaReasoningPayload(request.thinking)?.effort;
-        const full = foldResponsesReasoning(parsed.text, parsed.reasoningSummary, usage, effort);
-        if (!full.trim() && parsed.toolCalls.length === 0) {
-            throw new ProviderError(`Meta Model API returned no completion text (model=${model}). The response was empty — try /effort off, raise max_tokens, or pick another model with /model.`);
-        }
-        return {
-            text: full,
+        return runGenerationAttempt(request, {
             provider: "meta",
             model,
-            ...(parsed.toolCalls.length ? { toolCalls: parsed.toolCalls } : {}),
-            ...(parsed.toolCalls.length ? { finishReason: "tool_calls" } : { finishReason: "stop" }),
-            ...(usage ? { usage } : {}),
-            ...(parsed.reasoningItems.length
-                ? { reasoningBlock: { text: parsed.reasoningSummary, items: parsed.reasoningItems } }
-                : {}),
-        };
-    },
-    async stream(request, auth, onToken) {
-        if (!auth.apiKey)
-            throw new Error("Meta Model API key is required");
-        const model = request.model ?? defaultModels.meta;
-        const supportsVision = modelAcceptsImages("meta", model);
-        const reasoningOn = Boolean(request.thinking?.enabled);
-        const idleTimeoutMs = THINKING_STREAM_IDLE_TIMEOUT_MS;
-        const initialIdleTimeoutMs = THINKING_STREAM_INITIAL_IDLE_TIMEOUT_MS;
-        const outputIdleTimeoutMs = Math.round(Math.max(idleTimeoutMs, initialIdleTimeoutMs) * 1.5);
-        const idleController = new AbortController();
-        let transportTimer;
-        let outputTimer;
-        let idleFired = false;
-        let firedWatchdog;
-        let firedBudgetMs = initialIdleTimeoutMs;
-        let sawTransportActivity = false;
-        let sawStreamProgress = false;
-        const fireStall = (watchdog, budgetMs) => {
-            if (idleFired)
-                return;
-            idleFired = true;
-            firedWatchdog = watchdog;
-            firedBudgetMs = budgetMs;
-            idleController.abort();
-        };
-        const armTransportTimer = (budgetMs) => {
-            if (transportTimer)
-                clearTimeout(transportTimer);
-            transportTimer = setTimeout(() => fireStall("transport", budgetMs), budgetMs);
-        };
-        const noteTransportActivity = () => {
-            sawTransportActivity = true;
-            armTransportTimer(idleTimeoutMs);
-        };
-        const resetIdleTimer = () => {
-            sawStreamProgress = true;
-            noteTransportActivity();
-            if (outputTimer)
-                clearTimeout(outputTimer);
-            outputTimer = setTimeout(() => fireStall("output", outputIdleTimeoutMs), outputIdleTimeoutMs);
-        };
-        armTransportTimer(initialIdleTimeoutMs);
-        outputTimer = setTimeout(() => fireStall("output", outputIdleTimeoutMs), outputIdleTimeoutMs);
-        const clearIdleTimers = () => {
-            if (transportTimer)
-                clearTimeout(transportTimer);
-            if (outputTimer)
-                clearTimeout(outputTimer);
-            transportTimer = undefined;
-            outputTimer = undefined;
-        };
-        const onCallerAbort = () => idleController.abort(request.signal?.reason);
-        request.signal?.addEventListener("abort", onCallerAbort, { once: true });
-        const body = buildResponsesBody({
-            model,
-            messages: request.messages,
-            maxTokens: request.maxTokens,
-            temperature: request.temperature,
-            stream: true,
-            reasoning: request.thinking,
-            supportsVision,
-            tools: request.tools,
-            parallelToolCalls: request.parallelToolCalls,
-        });
-        let response;
-        let lastFetchError;
-        for (let fetchAttempt = 0; fetchAttempt < 2; fetchAttempt++) {
-            if (fetchAttempt > 0) {
-                await new Promise((r) => setTimeout(r, 1000));
-                if (request.signal?.aborted)
-                    throw request.signal.reason;
-                if (idleFired)
-                    break;
-                armTransportTimer(initialIdleTimeoutMs);
-                if (outputTimer) {
-                    clearTimeout(outputTimer);
-                    outputTimer = setTimeout(() => fireStall("output", outputIdleTimeoutMs), outputIdleTimeoutMs);
-                }
-            }
+            mode: "complete",
+            reason: request.attemptReason ?? "initial",
+        }, async () => {
+            const body = buildResponsesBody({
+                model,
+                messages: request.messages,
+                maxTokens: request.maxTokens,
+                temperature: request.temperature,
+                stream: false,
+                reasoning: request.thinking,
+                tools: request.tools,
+                parallelToolCalls: request.parallelToolCalls,
+                purpose: request.purpose,
+                reasoningArtifactReplayObserver: request.onReasoningArtifactReplayDecision,
+            });
+            let response;
             try {
-                response = await fetch(`${baseUrl}/responses`, {
+                response = await generationFetch(`${baseUrl}/responses`, {
                     method: "POST",
-                    signal: idleController.signal,
+                    signal: request.signal ?? null,
                     headers: {
                         "content-type": "application/json",
-                        accept: "text/event-stream",
+                        accept: "application/json",
                         authorization: `Bearer ${auth.apiKey}`,
                     },
                     body,
                     verbose: process.env.CLAI_VERBOSE === "true",
                 });
-                lastFetchError = undefined;
-                break;
             }
             catch (error) {
-                lastFetchError = error;
-                if (idleFired) {
-                    clearIdleTimers();
-                    request.signal?.removeEventListener("abort", onCallerAbort);
-                    throw new ProviderError(`Meta Model API request timed out before any response (${Math.round(firedBudgetMs / 1000)}s) — no data arrived on the connection.`);
-                }
-                const msg = error instanceof Error ? error.message : String(error);
-                const transient = /fetch failed|network error|etimedout|enotfound|econnreset|premature close|socket.*closed|aborted without reason/i.test(msg);
-                if (!transient || sawStreamProgress)
+                if (error instanceof Error && error.name === "AbortError")
                     throw error;
-                continue;
+                if (isOperationPolicyError(error))
+                    throw error;
+                const msg = error instanceof Error ? error.message : String(error);
+                throw new ProviderError(`Meta Model API request could not be sent (${msg}). Check connectivity to ${baseUrl}.`);
             }
-        }
-        if (!response) {
-            clearIdleTimers();
-            request.signal?.removeEventListener("abort", onCallerAbort);
-            if (lastFetchError)
-                throw lastFetchError;
-            throw new ProviderError(`Meta Model API request failed before a response was received.`);
-        }
-        if (!response.ok) {
-            clearIdleTimers();
-            request.signal?.removeEventListener("abort", onCallerAbort);
+            let data;
             try {
-                await readJson(response);
+                data = await readJson(response);
             }
             catch (error) {
                 if (error instanceof ProviderError) {
@@ -533,470 +502,716 @@ export const metaProvider = {
                 }
                 throw error;
             }
-        }
-        if (!response.body) {
-            clearIdleTimers();
-            request.signal?.removeEventListener("abort", onCallerAbort);
-            throw new ProviderError(`Meta Model API returned no stream body`);
-        }
-        const contentType = response.headers.get("content-type") ?? "";
-        if (response.status === 202 || /\bapplication\/json\b/i.test(contentType)) {
-            clearIdleTimers();
-            request.signal?.removeEventListener("abort", onCallerAbort);
-            const data = await readJson(response);
-            if (response.status === 202) {
-                const requestId = data.requestId ?? data.id;
-                throw new ProviderError(`Meta Model API returned a pending async response${requestId ? ` (${requestId})` : ""}; streaming did not start.`, response.status, JSON.stringify(data).slice(0, 1_000));
-            }
             const parsed = parseResponsesOutput(data);
-            const usageTmp = parsed.usage ?? parseMetaUsage(data.usage);
-            const effortTmp = metaReasoningPayload(request.thinking)?.effort;
-            const full = foldResponsesReasoning(parsed.text, parsed.reasoningSummary, usageTmp, effortTmp);
-            if (full.trim() || parsed.toolCalls.length > 0) {
-                if (full.trim())
-                    onToken(full);
-                return {
-                    text: full,
-                    provider: "meta",
-                    model,
-                    ...(parsed.toolCalls.length ? { toolCalls: parsed.toolCalls } : {}),
-                    ...(parsed.toolCalls.length ? { finishReason: "tool_calls" } : { finishReason: "stop" }),
-                    ...(usageTmp ? { usage: usageTmp } : {}),
-                    ...(parsed.reasoningItems.length
-                        ? { reasoningBlock: { text: parsed.reasoningSummary, items: parsed.reasoningItems } }
-                        : {}),
-                };
+            const reasoningArtifacts = metaReasoningArtifacts(model, parsed.reasoningItems, parsed.reasoningItemPositions);
+            const usage = parsed.usage ?? parseMetaUsage(data.usage);
+            if (!parsed.text.trim() && parsed.toolCalls.length === 0) {
+                const respStatus = data.status;
+                const details = data.incomplete_details;
+                if (respStatus === "incomplete" && details?.reason === "max_output_tokens") {
+                    const retryRequest = incompleteBudgetRetry(request, Boolean(request.thinking?.enabled));
+                    if (retryRequest) {
+                        completeGenerationAttempt("failure", usage);
+                        retryRequest.attemptReason = "provider-retry";
+                        return metaProvider.complete(retryRequest, auth);
+                    }
+                    throw budgetExhaustedError(request, Boolean(request.thinking?.enabled), JSON.stringify(data));
+                }
             }
-            throw new ProviderError(`Meta Model API returned JSON instead of an SSE stream, but no completion text was present.`, response.status, JSON.stringify(data).slice(0, 1_000));
-        }
-        const decoder = new TextDecoder();
-        const reader = response.body.getReader();
-        let buffer = "";
-        let full = "";
-        let visible = "";
-        let reasoningSeen = "";
-        let inReasoning = false;
-        let finishReason;
-        let streamUsage;
-        const toolCallState = new Map();
-        const outputIndexToItemId = new Map();
-        let responseId;
-        const reasoningItems = [];
-        const reasoningItemKeys = new Set();
-        const noteReasoningItem = (item) => {
-            const encrypted = typeof item.encrypted_content === "string" ? item.encrypted_content : "";
-            if (!encrypted)
-                return;
-            const id = typeof item.id === "string" ? item.id : undefined;
-            const key = id ?? encrypted.slice(0, 64);
-            if (reasoningItemKeys.has(key))
-                return;
-            reasoningItemKeys.add(key);
-            reasoningItems.push({
-                type: "reasoning",
-                ...(id ? { id } : {}),
-                summary: Array.isArray(item.summary) ? item.summary : [],
-                encrypted_content: encrypted,
+            if (!parsed.text.trim() &&
+                parsed.toolCalls.length === 0 &&
+                !parsed.reasoningSummary.trim()) {
+                throw new ProviderError(`Meta Model API returned no completion text (model=${model}). The response was empty — try /effort off, raise max_tokens, or pick another model with /model.`);
+            }
+            return {
+                text: parsed.text,
+                provider: "meta",
+                model,
+                ...(parsed.toolCalls.length ? { toolCalls: parsed.toolCalls } : {}),
+                ...(parsed.toolCalls.length ? { finishReason: "tool_calls" } : { finishReason: "stop" }),
+                ...(usage ? { usage } : {}),
+                ...(parsed.reasoningItems.length
+                    ? { reasoningBlock: { text: parsed.reasoningSummary, items: parsed.reasoningItems } }
+                    : {}),
+                ...(reasoningArtifacts ? { reasoningArtifacts } : {}),
+            };
+        });
+    },
+    async stream(request, auth, onToken) {
+        if (!auth.apiKey)
+            throw new Error("Meta Model API key is required");
+        const model = request.model ?? defaultModels.meta;
+        return runGenerationAttempt(request, {
+            provider: "meta",
+            model,
+            mode: "stream",
+            reason: request.attemptReason ?? "initial",
+        }, async () => {
+            const reasoningOn = Boolean(request.thinking?.enabled);
+            const idleTimeoutMs = THINKING_STREAM_IDLE_TIMEOUT_MS;
+            const initialIdleTimeoutMs = THINKING_STREAM_INITIAL_IDLE_TIMEOUT_MS;
+            const outputIdleTimeoutMs = Math.round(Math.max(idleTimeoutMs, initialIdleTimeoutMs) * 1.5);
+            const idleController = new AbortController();
+            let transportTimer;
+            let outputTimer;
+            let idleFired = false;
+            let firedWatchdog;
+            let firedBudgetMs = initialIdleTimeoutMs;
+            let sawTransportActivity = false;
+            let sawStreamProgress = false;
+            const fireStall = (watchdog, budgetMs) => {
+                if (idleFired)
+                    return;
+                idleFired = true;
+                firedWatchdog = watchdog;
+                firedBudgetMs = budgetMs;
+                idleController.abort();
+            };
+            const armTransportTimer = (budgetMs) => {
+                if (transportTimer)
+                    clearTimeout(transportTimer);
+                transportTimer = setTimeout(() => fireStall("transport", budgetMs), budgetMs);
+            };
+            const noteTransportActivity = () => {
+                sawTransportActivity = true;
+                armTransportTimer(idleTimeoutMs);
+            };
+            const resetIdleTimer = () => {
+                sawStreamProgress = true;
+                noteTransportActivity();
+                if (outputTimer)
+                    clearTimeout(outputTimer);
+                outputTimer = setTimeout(() => fireStall("output", outputIdleTimeoutMs), outputIdleTimeoutMs);
+            };
+            armTransportTimer(initialIdleTimeoutMs);
+            outputTimer = setTimeout(() => fireStall("output", outputIdleTimeoutMs), outputIdleTimeoutMs);
+            const clearIdleTimers = () => {
+                if (transportTimer)
+                    clearTimeout(transportTimer);
+                if (outputTimer)
+                    clearTimeout(outputTimer);
+                transportTimer = undefined;
+                outputTimer = undefined;
+            };
+            const onCallerAbort = () => idleController.abort(request.signal?.reason);
+            request.signal?.addEventListener("abort", onCallerAbort, { once: true });
+            const body = buildResponsesBody({
+                model,
+                messages: request.messages,
+                maxTokens: request.maxTokens,
+                temperature: request.temperature,
+                stream: true,
+                reasoning: request.thinking,
+                tools: request.tools,
+                parallelToolCalls: request.parallelToolCalls,
+                purpose: request.purpose,
+                reasoningArtifactReplayObserver: request.onReasoningArtifactReplayDecision,
             });
-        };
-        const reasoningReplay = () => reasoningItems.length ? { reasoningBlock: { text: reasoningSeen, items: reasoningItems } } : {};
-        const enterReasoning = () => {
-            if (inReasoning)
-                return;
-            inReasoning = true;
-            full += REASONING_OPEN;
-            onToken(REASONING_OPEN);
-        };
-        const exitReasoning = () => {
-            if (!inReasoning)
-                return;
-            inReasoning = false;
-            full += REASONING_CLOSE;
-            onToken(REASONING_CLOSE);
-        };
-        const emitVisible = (text) => {
-            if (!text)
-                return;
-            if (inReasoning)
-                exitReasoning();
-            visible += text;
-            full += text;
-            onToken(text);
-        };
-        const emitReasoningDelta = (text) => {
-            if (!text)
-                return;
-            enterReasoning();
-            reasoningSeen += text;
-            full += text;
-            onToken(text);
-        };
-        const cleanup = () => {
-            clearIdleTimers();
-            request.signal?.removeEventListener("abort", onCallerAbort);
-            idleController.signal.removeEventListener("abort", cancelReaderOnAbort);
-        };
-        const cancelReaderOnAbort = () => {
-            reader.cancel().catch(() => undefined);
-        };
-        idleController.signal.addEventListener("abort", cancelReaderOnAbort, { once: true });
-        const sseFrames = createSseFrameAssembler();
-        try {
-            while (true) {
-                request.signal?.throwIfAborted();
-                if (idleController.signal.aborted)
-                    throw new Error("Stream aborted");
-                const { done, value } = await readWithAbort(reader, idleController.signal);
-                request.signal?.throwIfAborted();
-                if (idleController.signal.aborted)
-                    throw new Error("Stream aborted");
-                if (done)
+            let response;
+            let lastFetchError;
+            for (let fetchAttempt = 0; fetchAttempt < 2; fetchAttempt++) {
+                if (fetchAttempt > 0) {
+                    await new Promise((r) => setTimeout(r, 1000));
+                    if (request.signal?.aborted)
+                        throw request.signal.reason;
+                    if (idleFired)
+                        break;
+                    armTransportTimer(initialIdleTimeoutMs);
+                    if (outputTimer) {
+                        clearTimeout(outputTimer);
+                        outputTimer = setTimeout(() => fireStall("output", outputIdleTimeoutMs), outputIdleTimeoutMs);
+                    }
+                }
+                try {
+                    response = await generationFetch(`${baseUrl}/responses`, {
+                        method: "POST",
+                        signal: idleController.signal,
+                        headers: {
+                            "content-type": "application/json",
+                            accept: "text/event-stream",
+                            authorization: `Bearer ${auth.apiKey}`,
+                        },
+                        body,
+                        verbose: process.env.CLAI_VERBOSE === "true",
+                    });
+                    lastFetchError = undefined;
                     break;
-                if (value && value.byteLength > 0)
-                    noteTransportActivity();
-                buffer += decoder.decode(value, { stream: true });
-                const lines = buffer.split("\n");
-                buffer = lines.pop() ?? "";
-                for (const line of lines) {
-                    const payload = sseFrames.pushLine(line);
-                    if (payload === undefined)
-                        continue;
-                    if (payload === "[DONE]") {
-                        if (!reasoningSeen.trim() && streamUsage?.reasoningTokens && streamUsage.reasoningTokens > 0 && (visible.trim() || toolCallState.size > 0)) {
-                            const effort = metaReasoningPayload(request.thinking)?.effort;
-                            const effortText = effort ? ` at ${effort} effort` : "";
-                            const note = `Reasoning is private on Meta Model API: the model reasoned${effortText} and used ${streamUsage.reasoningTokens.toLocaleString("en-US")} reasoning tokens, but the API returns no reasoning text to display.`;
-                            emitReasoningDelta(note);
-                            exitReasoning();
-                        }
-                        else {
-                            exitReasoning();
-                        }
-                        cleanup();
-                        const toolCalls = [];
-                        for (const [, state] of toolCallState) {
-                            if (!state.name)
-                                continue;
-                            const canonical = state.name ? fromWireName(state.name) ?? state.name : state.name ?? "";
-                            const raw = state.arguments;
-                            let args;
-                            try {
-                                const parsed = JSON.parse(raw);
-                                if (parsed && typeof parsed === "object" && !Array.isArray(parsed))
-                                    args = parsed;
-                                else
-                                    args = {};
-                            }
-                            catch {
-                                args = parseToolArguments(raw);
-                            }
-                            toolCalls.push({ id: state.callId ?? state.id ?? `call_${toolCalls.length}`, name: canonical, args, rawArguments: raw });
-                        }
-                        if (!visible.trim() && toolCalls.length === 0) {
-                            if (reasoningSeen.trim()) {
-                                return { text: full, provider: "meta", model, finishReason: finishReason ?? "stop", ...(streamUsage ? { usage: streamUsage } : {}), ...reasoningReplay() };
-                            }
-                            throw new ProviderError(`Meta Model API completed without a visible answer.`);
+                }
+                catch (error) {
+                    lastFetchError = error;
+                    if (idleFired) {
+                        clearIdleTimers();
+                        request.signal?.removeEventListener("abort", onCallerAbort);
+                        throw new ProviderError(`Meta Model API request timed out before any response (${Math.round(firedBudgetMs / 1000)}s) — no data arrived on the connection.`);
+                    }
+                    const msg = error instanceof Error ? error.message : String(error);
+                    const transient = /fetch failed|network error|etimedout|enotfound|econnreset|premature close|socket.*closed|aborted without reason/i.test(msg);
+                    if (!transient || sawStreamProgress)
+                        throw error;
+                    continue;
+                }
+            }
+            if (!response) {
+                clearIdleTimers();
+                request.signal?.removeEventListener("abort", onCallerAbort);
+                if (lastFetchError)
+                    throw lastFetchError;
+                throw new ProviderError(`Meta Model API request failed before a response was received.`);
+            }
+            if (!response.ok) {
+                clearIdleTimers();
+                request.signal?.removeEventListener("abort", onCallerAbort);
+                try {
+                    await readJson(response);
+                }
+                catch (error) {
+                    if (error instanceof ProviderError) {
+                        throw new ProviderError(`Meta Model API (model=${model}): ${error.message}`, error.status, error.body, error.retryAfterSeconds);
+                    }
+                    throw error;
+                }
+            }
+            if (!response.body) {
+                clearIdleTimers();
+                request.signal?.removeEventListener("abort", onCallerAbort);
+                throw new ProviderError(`Meta Model API returned no stream body`);
+            }
+            const contentType = response.headers.get("content-type") ?? "";
+            if (response.status === 202 || /\bapplication\/json\b/i.test(contentType)) {
+                try {
+                    const data = await readJson(response, idleController.signal);
+                    if (response.status === 202) {
+                        const requestId = data.requestId ?? data.id;
+                        throw new ProviderError(`Meta Model API returned a pending async response${requestId ? ` (${requestId})` : ""}; streaming did not start.`, response.status, JSON.stringify(data).slice(0, 1_000));
+                    }
+                    const parsed = parseResponsesOutput(data);
+                    const reasoningArtifacts = metaReasoningArtifacts(model, parsed.reasoningItems, parsed.reasoningItemPositions);
+                    const usageTmp = parsed.usage ?? parseMetaUsage(data.usage);
+                    const jsonStatus = data.status;
+                    const jsonDetails = data.incomplete_details;
+                    if (!parsed.text.trim() && parsed.toolCalls.length === 0 && jsonStatus === "incomplete" && jsonDetails?.reason === "max_output_tokens") {
+                        const retryRequest = incompleteBudgetRetry(request, reasoningOn);
+                        const streamMethod = metaProvider.stream;
+                        if (retryRequest && streamMethod) {
+                            completeGenerationAttempt("failure", usageTmp);
+                            retryRequest.attemptReason = "provider-retry";
+                            return streamMethod(retryRequest, auth, onToken);
                         }
+                        completeGenerationAttempt("failure", usageTmp);
+                        throw budgetExhaustedError(request, reasoningOn, JSON.stringify(data));
+                    }
+                    if (parsed.text.trim() ||
+                        parsed.toolCalls.length > 0 ||
+                        parsed.reasoningSummary.trim()) {
+                        emitStreamReasoningArtifacts(request.onStreamEvent, reasoningArtifacts);
+                        if (parsed.text)
+                            onToken(parsed.text);
                         return {
-                            text: full,
+                            text: parsed.text,
                             provider: "meta",
                             model,
-                            ...(toolCalls.length ? { toolCalls } : {}),
-                            ...(finishReason ? { finishReason } : toolCalls.length ? { finishReason: "tool_calls" } : {}),
-                            ...(streamUsage ? { usage: streamUsage } : {}),
-                            ...reasoningReplay(),
+                            ...(parsed.toolCalls.length ? { toolCalls: parsed.toolCalls } : {}),
+                            ...(parsed.toolCalls.length ? { finishReason: "tool_calls" } : { finishReason: "stop" }),
+                            ...(usageTmp ? { usage: usageTmp } : {}),
+                            ...(parsed.reasoningItems.length
+                                ? { reasoningBlock: { text: parsed.reasoningSummary, items: parsed.reasoningItems } }
+                                : {}),
+                            ...(reasoningArtifacts ? { reasoningArtifacts } : {}),
                         };
                     }
-                    let parsed;
-                    try {
-                        parsed = JSON.parse(payload);
-                    }
-                    catch {
-                        continue;
+                    throw new ProviderError(`Meta Model API returned JSON instead of an SSE stream, but no completion text was present.`, response.status, JSON.stringify(data).slice(0, 1_000));
+                }
+                catch (error) {
+                    if (idleFired) {
+                        const seconds = Math.round(firedBudgetMs / 1000);
+                        if (firedWatchdog === "transport" || !sawTransportActivity) {
+                            if (!sawTransportActivity) {
+                                throw new ProviderError(`Meta Model API request timed out before any response (${seconds}s) — no data arrived on the connection.`);
+                            }
+                            throw new ProviderError(`Meta Model API stream transport timeout (${seconds}s) — no data arrived on the connection after it had started.`);
+                        }
+                        throw new ProviderError(`Meta Model API stream stalled — ${STREAM_STALL_MARKER} for ${seconds}s`);
                     }
-                    if (parsed.error) {
-                        const rawDetail = typeof parsed.error === "string"
-                            ? parsed.error
-                            : parsed.error.message ?? parsed.error.type ?? "unknown error";
-                        const detail = rawDetail.trim().length <= 2 ? `${rawDetail} — ${payload.slice(0, 300)}` : rawDetail;
-                        throw new ProviderError(`Meta Model API stream error: ${detail}`, undefined, payload.slice(0, 1000));
+                    throw error;
+                }
+                finally {
+                    clearIdleTimers();
+                    request.signal?.removeEventListener("abort", onCallerAbort);
+                }
+            }
+            const decoder = new TextDecoder();
+            const reader = response.body.getReader();
+            let buffer = "";
+            let full = "";
+            let visible = "";
+            let reasoningSeen = "";
+            let finishReason;
+            let sawTerminalProof;
+            let streamUsage;
+            const toolCallState = new Map();
+            const outputIndexToItemId = new Map();
+            const outputIndexToToolCallIndex = new Map();
+            let responseId;
+            const reasoningItems = [];
+            const reasoningItemSequences = [];
+            const reasoningItemToolCallIndices = [];
+            const reasoningItemIndexes = new Map();
+            const noteReasoningItem = (item, sequence, toolCallIndex) => {
+                const encrypted = typeof item.encrypted_content === "string" ? item.encrypted_content : "";
+                if (!encrypted)
+                    return;
+                const id = typeof item.id === "string" ? item.id : undefined;
+                const key = id ?? encrypted.slice(0, 64);
+                const existingIndex = reasoningItemIndexes.get(key);
+                if (existingIndex !== undefined) {
+                    reasoningItems[existingIndex] = { ...item };
+                    if (sequence !== undefined)
+                        reasoningItemSequences[existingIndex] = sequence;
+                    if (toolCallIndex !== undefined) {
+                        reasoningItemToolCallIndices[existingIndex] = toolCallIndex;
                     }
-                    const type = parsed.type;
-                    if (type === "response.created" || type === "response.in_progress") {
-                        const resp = (parsed.response ?? parsed);
-                        if (typeof resp.id === "string")
-                            responseId = resp.id;
-                        continue;
+                    return;
+                }
+                reasoningItemIndexes.set(key, reasoningItems.length);
+                reasoningItems.push({ ...item });
+                reasoningItemSequences.push(sequence ?? Number.MAX_SAFE_INTEGER);
+                reasoningItemToolCallIndices.push(toolCallIndex);
+            };
+            const reasoningReplay = () => {
+                if (!reasoningItems.length) {
+                    return reasoningSeen ? { reasoningBlock: { text: reasoningSeen } } : {};
+                }
+                const toolCallSequences = [...outputIndexToToolCallIndex.entries()]
+                    .map(([sequence, toolCallIndex]) => ({ sequence, toolCallIndex }))
+                    .sort((left, right) => left.sequence - right.sequence);
+                const positions = reasoningItemSequences.map((sequence, index) => {
+                    const storedToolCallIndex = reasoningItemToolCallIndices[index];
+                    if (storedToolCallIndex !== undefined) {
+                        return { sequence, toolCallIndex: storedToolCallIndex };
                     }
-                    if (type === "response.output_item.added") {
-                        const item = parsed.item;
-                        if (!item)
+                    const followingTool = toolCallSequences.find((toolCall) => toolCall.sequence > sequence);
+                    return followingTool
+                        ? { sequence, toolCallIndex: followingTool.toolCallIndex }
+                        : { sequence };
+                });
+                const reasoningArtifacts = metaReasoningArtifacts(model, reasoningItems, positions);
+                emitStreamReasoningArtifacts(request.onStreamEvent, reasoningArtifacts);
+                return {
+                    reasoningBlock: { text: reasoningSeen, items: reasoningItems },
+                    ...(reasoningArtifacts ? { reasoningArtifacts } : {}),
+                };
+            };
+            const emitVisible = (text) => {
+                if (!text)
+                    return;
+                visible += text;
+                full += text;
+                onToken(text);
+            };
+            const emitReasoningDelta = (text) => {
+                if (!text)
+                    return;
+                reasoningSeen += text;
+                emitStreamReasoningDelta(request.onStreamEvent, text);
+            };
+            const cleanup = () => {
+                clearIdleTimers();
+                request.signal?.removeEventListener("abort", onCallerAbort);
+                idleController.signal.removeEventListener("abort", cancelReaderOnAbort);
+            };
+            const cancelReaderOnAbort = () => {
+                reader.cancel().catch(() => undefined);
+            };
+            idleController.signal.addEventListener("abort", cancelReaderOnAbort, { once: true });
+            const sseFrames = createSseFrameAssembler();
+            try {
+                while (true) {
+                    request.signal?.throwIfAborted();
+                    if (idleController.signal.aborted)
+                        throw new Error("Stream aborted");
+                    const { done, value } = await readWithAbort(reader, idleController.signal);
+                    request.signal?.throwIfAborted();
+                    if (idleController.signal.aborted)
+                        throw new Error("Stream aborted");
+                    if (done)
+                        break;
+                    if (value && value.byteLength > 0)
+                        noteTransportActivity();
+                    buffer += decoder.decode(value, { stream: true });
+                    const lines = buffer.split("\n");
+                    buffer = lines.pop() ?? "";
+                    for (const line of lines) {
+                        const payload = sseFrames.pushLine(line);
+                        if (payload === undefined)
                             continue;
-                        const outputIndex = typeof parsed.output_index === "number" ? parsed.output_index : undefined;
-                        const itemId = typeof item.id === "string" ? item.id : typeof parsed.item_id === "string" ? parsed.item_id : undefined;
-                        if (outputIndex !== undefined && itemId)
-                            outputIndexToItemId.set(outputIndex, itemId);
-                        if (item.type === "function_call") {
-                            const id = typeof item.id === "string" ? item.id : typeof item.call_id === "string" ? item.call_id : itemId ?? `call_${toolCallState.size}`;
-                            const callId = typeof item.call_id === "string" ? item.call_id : id;
-                            const name = typeof item.name === "string" ? item.name : "";
-                            const args = typeof item.arguments === "string" ? item.arguments : "";
-                            toolCallState.set(id, { id, callId, name, arguments: args });
-                            resetIdleTimer();
-                            if (request.onToolCallDelta) {
-                                const canonical = name ? fromWireName(name) ?? name : undefined;
-                                request.onToolCallDelta({ index: toolCallState.size - 1, ...(callId ? { id: callId } : {}), ...(canonical ? { name: canonical } : {}), argumentsBytes: args.length });
+                        if (payload === "[DONE]") {
+                            if (!reasoningSeen.trim() && streamUsage?.reasoningTokens && streamUsage.reasoningTokens > 0 && (visible.trim() || toolCallState.size > 0)) {
+                                const effort = metaReasoningPayload(request.thinking)?.effort;
+                                const effortText = effort ? ` at ${effort} effort` : "";
+                                const note = `Reasoning is private on Meta Model API: the model reasoned${effortText} and used ${streamUsage.reasoningTokens.toLocaleString("en-US")} reasoning tokens, but the API returns no reasoning text to display.`;
+                                emitReasoningDelta(note);
                             }
-                        }
-                        else if (item.type === "reasoning") {
-                            const s = extractReasoningSummary(item);
-                            if (s) {
-                                resetIdleTimer();
-                                emitReasoningDelta(s);
+                            cleanup();
+                            const toolCalls = [];
+                            for (const [, state] of toolCallState) {
+                                if (!state.name)
+                                    continue;
+                                const canonical = state.name ? fromWireName(state.name) ?? state.name : state.name ?? "";
+                                const raw = state.arguments;
+                                let args;
+                                try {
+                                    const parsed = JSON.parse(raw);
+                                    if (parsed && typeof parsed === "object" && !Array.isArray(parsed))
+                                        args = parsed;
+                                    else
+                                        args = {};
+                                }
+                                catch {
+                                    args = parseToolArguments(raw);
+                                }
+                                toolCalls.push({ id: state.callId ?? state.id ?? `call_${toolCalls.length}`, name: canonical, args, rawArguments: raw });
                             }
-                        }
-                        else if (item.type === "message") {
-                            resetIdleTimer();
-                        }
-                        continue;
-                    }
-                    if (type === "response.output_item.done") {
-                        const item = parsed.item;
-                        if (item?.type === "reasoning")
-                            noteReasoningItem(item);
-                        if (item?.type === "function_call") {
-                            const id = typeof item.id === "string" ? item.id : typeof parsed.item_id === "string" ? parsed.item_id : undefined;
-                            if (id && toolCallState.has(id)) {
-                                const state = toolCallState.get(id);
-                                if (typeof item.arguments === "string" && item.arguments.length > state.arguments.length)
-                                    state.arguments = item.arguments;
-                                if (typeof item.name === "string" && !state.name)
-                                    state.name = item.name;
-                                if (typeof item.call_id === "string" && !state.callId)
-                                    state.callId = item.call_id;
+                            if (!visible.trim() && toolCalls.length === 0) {
+                                if (reasoningSeen.trim()) {
+                                    return { text: full, provider: "meta", model, finishReason: finishReason ?? "stop", ...(streamUsage ? { usage: streamUsage } : {}), ...reasoningReplay() };
+                                }
+                                throw new ProviderError(`Meta Model API completed without a visible answer.`);
                             }
-                            resetIdleTimer();
+                            return {
+                                text: full,
+                                provider: "meta",
+                                model,
+                                ...(toolCalls.length ? { toolCalls } : {}),
+                                ...(finishReason ? { finishReason } : toolCalls.length ? { finishReason: "tool_calls" } : {}),
+                                ...(streamUsage ? { usage: streamUsage } : {}),
+                                ...reasoningReplay(),
+                            };
                         }
-                        if (item && typeof item.status === "string")
-                            finishReason = item.status;
-                        continue;
-                    }
-                    if (type === "response.content_part.added" || type === "response.content_part.done") {
-                        continue;
-                    }
-                    if (type === "response.output_text.delta") {
-                        const delta = typeof parsed.delta === "string" ? parsed.delta : "";
-                        if (delta) {
-                            resetIdleTimer();
-                            emitVisible(delta);
+                        let parsed;
+                        try {
+                            parsed = JSON.parse(payload);
                         }
-                        continue;
-                    }
-                    if (type === "response.reasoning_summary_text.delta") {
-                        const delta = typeof parsed.delta === "string" ? parsed.delta : "";
-                        if (delta) {
-                            resetIdleTimer();
-                            emitReasoningDelta(delta);
+                        catch {
+                            continue;
                         }
-                        continue;
-                    }
-                    if (type === "response.reasoning_summary_text.done") {
-                        const textVal = typeof parsed.text === "string" ? parsed.text : "";
-                        if (textVal && !reasoningSeen.includes(textVal)) {
-                            const remaining = textVal.slice(reasoningSeen.length);
-                            if (remaining) {
-                                resetIdleTimer();
-                                emitReasoningDelta(remaining);
-                            }
+                        if (parsed.error) {
+                            const rawDetail = typeof parsed.error === "string"
+                                ? parsed.error
+                                : parsed.error.message ?? parsed.error.type ?? "unknown error";
+                            const detail = rawDetail.trim().length <= 2 ? `${rawDetail} — ${payload.slice(0, 300)}` : rawDetail;
+                            throw new ProviderError(`Meta Model API stream error: ${detail}`, undefined, payload.slice(0, 1000));
                         }
-                        exitReasoning();
-                        continue;
-                    }
-                    if (type === "response.function_call_arguments.delta") {
-                        const delta = typeof parsed.delta === "string" ? parsed.delta : "";
-                        const itemId = typeof parsed.item_id === "string" ? parsed.item_id : typeof parsed.itemId === "string" ? parsed.itemId : undefined;
-                        let targetId = itemId;
-                        if (!targetId && typeof parsed.output_index === "number")
-                            targetId = outputIndexToItemId.get(parsed.output_index);
-                        if (targetId) {
-                            const state = toolCallState.get(targetId);
-                            if (state) {
-                                state.arguments += delta;
+                        const type = parsed.type;
+                        if (type === "response.created" || type === "response.in_progress") {
+                            const resp = (parsed.response ?? parsed);
+                            if (typeof resp.id === "string")
+                                responseId = resp.id;
+                            continue;
+                        }
+                        if (type === "response.output_item.added") {
+                            const item = parsed.item;
+                            if (!item)
+                                continue;
+                            const outputIndex = typeof parsed.output_index === "number" ? parsed.output_index : undefined;
+                            const itemId = typeof item.id === "string" ? item.id : typeof parsed.item_id === "string" ? parsed.item_id : undefined;
+                            if (outputIndex !== undefined && itemId)
+                                outputIndexToItemId.set(outputIndex, itemId);
+                            if (item.type === "function_call") {
+                                const id = typeof item.id === "string" ? item.id : typeof item.call_id === "string" ? item.call_id : itemId ?? `call_${toolCallState.size}`;
+                                const callId = typeof item.call_id === "string" ? item.call_id : id;
+                                const name = typeof item.name === "string" ? item.name : "";
+                                const args = typeof item.arguments === "string" ? item.arguments : "";
+                                const toolCallIndex = toolCallState.size;
+                                toolCallState.set(id, { id, callId, name, arguments: args });
+                                if (outputIndex !== undefined) {
+                                    outputIndexToToolCallIndex.set(outputIndex, toolCallIndex);
+                                }
                                 resetIdleTimer();
                                 if (request.onToolCallDelta) {
-                                    const canonical = state.name ? fromWireName(state.name) ?? state.name : undefined;
-                                    request.onToolCallDelta({ index: Array.from(toolCallState.keys()).indexOf(targetId), ...(state.callId ? { id: state.callId } : {}), ...(canonical ? { name: canonical } : {}), argumentsBytes: state.arguments.length });
+                                    const canonical = name ? fromWireName(name) ?? name : undefined;
+                                    request.onToolCallDelta({ index: toolCallState.size - 1, ...(callId ? { id: callId } : {}), ...(canonical ? { name: canonical } : {}), argumentsBytes: args.length });
+                                }
+                            }
+                            else if (item.type === "reasoning") {
+                                noteReasoningItem(item, outputIndex);
+                                const s = extractReasoningSummary(item);
+                                if (s) {
+                                    resetIdleTimer();
+                                    emitReasoningDelta(s);
                                 }
                             }
-                            else {
-                                toolCallState.set(targetId, { id: targetId, callId: targetId, name: "", arguments: delta });
+                            else if (item.type === "message") {
                                 resetIdleTimer();
                             }
+                            continue;
                         }
-                        else if (delta) {
-                            const anyKey = Array.from(toolCallState.keys()).pop();
-                            if (anyKey) {
-                                const state = toolCallState.get(anyKey);
-                                state.arguments += delta;
+                        if (type === "response.output_item.done") {
+                            const item = parsed.item;
+                            if (item?.type === "reasoning") {
+                                noteReasoningItem(item, typeof parsed.output_index === "number"
+                                    ? parsed.output_index
+                                    : undefined);
+                            }
+                            if (item?.type === "function_call") {
+                                const id = typeof item.id === "string" ? item.id : typeof parsed.item_id === "string" ? parsed.item_id : undefined;
+                                if (id && toolCallState.has(id)) {
+                                    const state = toolCallState.get(id);
+                                    if (typeof item.arguments === "string" && item.arguments.length > state.arguments.length)
+                                        state.arguments = item.arguments;
+                                    if (typeof item.name === "string" && !state.name)
+                                        state.name = item.name;
+                                    if (typeof item.call_id === "string" && !state.callId)
+                                        state.callId = item.call_id;
+                                }
                                 resetIdleTimer();
                             }
+                            if (item && typeof item.status === "string")
+                                finishReason = item.status;
+                            continue;
                         }
-                        continue;
-                    }
-                    if (type === "response.function_call_arguments.done") {
-                        const args = typeof parsed.arguments === "string" ? parsed.arguments : typeof parsed.argument === "string" ? parsed.argument : "";
-                        const itemId = typeof parsed.item_id === "string" ? parsed.item_id : undefined;
-                        let targetId = itemId;
-                        if (!targetId && typeof parsed.output_index === "number")
-                            targetId = outputIndexToItemId.get(parsed.output_index);
-                        if (targetId && toolCallState.has(targetId) && args) {
-                            toolCallState.get(targetId).arguments = args;
+                        if (type === "response.content_part.added" || type === "response.content_part.done") {
+                            continue;
                         }
-                        else if (args && toolCallState.size > 0) {
-                            const lastKey = Array.from(toolCallState.keys()).pop();
-                            if (!toolCallState.get(lastKey).arguments)
-                                toolCallState.get(lastKey).arguments = args;
+                        if (type === "response.output_text.delta") {
+                            const delta = typeof parsed.delta === "string" ? parsed.delta : "";
+                            if (delta) {
+                                resetIdleTimer();
+                                emitVisible(delta);
+                            }
+                            continue;
                         }
-                        resetIdleTimer();
-                        continue;
-                    }
-                    if (type === "response.completed") {
-                        const resp = (parsed.response ?? parsed);
-                        if (resp.usage) {
-                            const u = parseMetaUsage(resp.usage);
-                            if (u)
-                                streamUsage = u;
+                        if (type === "response.reasoning_summary_text.delta") {
+                            const delta = typeof parsed.delta === "string" ? parsed.delta : "";
+                            if (delta) {
+                                resetIdleTimer();
+                                emitReasoningDelta(delta);
+                            }
+                            continue;
                         }
-                        if (typeof resp.status === "string")
-                            finishReason = resp.status;
-                        if (Array.isArray(resp.output)) {
-                            const out = parseResponsesOutput(resp);
-                            for (const item of out.reasoningItems)
-                                noteReasoningItem(item);
-                            if (out.reasoningSummary && !reasoningSeen.trim()) {
-                                emitReasoningDelta(out.reasoningSummary);
-                                exitReasoning();
+                        if (type === "response.reasoning_summary_text.done") {
+                            const textVal = typeof parsed.text === "string" ? parsed.text : "";
+                            if (textVal && !reasoningSeen.includes(textVal)) {
+                                const remaining = textVal.slice(reasoningSeen.length);
+                                if (remaining) {
+                                    resetIdleTimer();
+                                    emitReasoningDelta(remaining);
+                                }
                             }
-                            if (out.text && !visible.trim()) {
-                                emitVisible(out.text);
+                            continue;
+                        }
+                        if (type === "response.function_call_arguments.delta") {
+                            const delta = typeof parsed.delta === "string" ? parsed.delta : "";
+                            const itemId = typeof parsed.item_id === "string" ? parsed.item_id : typeof parsed.itemId === "string" ? parsed.itemId : undefined;
+                            let targetId = itemId;
+                            if (!targetId && typeof parsed.output_index === "number")
+                                targetId = outputIndexToItemId.get(parsed.output_index);
+                            if (targetId) {
+                                const state = toolCallState.get(targetId);
+                                if (state) {
+                                    state.arguments += delta;
+                                    resetIdleTimer();
+                                    if (request.onToolCallDelta) {
+                                        const canonical = state.name ? fromWireName(state.name) ?? state.name : undefined;
+                                        request.onToolCallDelta({ index: Array.from(toolCallState.keys()).indexOf(targetId), ...(state.callId ? { id: state.callId } : {}), ...(canonical ? { name: canonical } : {}), argumentsBytes: state.arguments.length });
+                                    }
+                                }
+                                else {
+                                    toolCallState.set(targetId, { id: targetId, callId: targetId, name: "", arguments: delta });
+                                    resetIdleTimer();
+                                }
                             }
-                            for (const tc of out.toolCalls) {
-                                const exists = Array.from(toolCallState.values()).some((s) => s.callId === tc.id);
-                                if (!exists) {
-                                    const id = tc.id;
-                                    toolCallState.set(id, { id, callId: tc.id, name: toWireName(tc.name), arguments: tc.rawArguments ?? JSON.stringify(tc.args) });
+                            else if (delta) {
+                                const anyKey = Array.from(toolCallState.keys()).pop();
+                                if (anyKey) {
+                                    const state = toolCallState.get(anyKey);
+                                    state.arguments += delta;
+                                    resetIdleTimer();
                                 }
                             }
+                            continue;
                         }
-                        continue;
-                    }
-                    if (type === "response.failed" || type === "response.incomplete") {
-                        const resp = (parsed.response ?? parsed);
-                        const err = resp.error;
-                        const rawDetail = err?.message ?? err?.code ?? type;
-                        const rawStr = String(rawDetail);
-                        const detail = rawStr.trim().length <= 2 ? `${rawStr} — ${payload.slice(0, 300)}` : rawStr;
-                        throw new ProviderError(`Meta Model API stream error: ${detail}`, undefined, payload.slice(0, 1000));
-                    }
-                    const usageField = parsed.usage;
-                    if (usageField) {
-                        const u = parseMetaUsage(usageField);
-                        if (u) {
-                            streamUsage = u;
+                        if (type === "response.function_call_arguments.done") {
+                            const args = typeof parsed.arguments === "string" ? parsed.arguments : typeof parsed.argument === "string" ? parsed.argument : "";
+                            const itemId = typeof parsed.item_id === "string" ? parsed.item_id : undefined;
+                            let targetId = itemId;
+                            if (!targetId && typeof parsed.output_index === "number")
+                                targetId = outputIndexToItemId.get(parsed.output_index);
+                            if (targetId && toolCallState.has(targetId) && args) {
+                                toolCallState.get(targetId).arguments = args;
+                            }
+                            else if (args && toolCallState.size > 0) {
+                                const lastKey = Array.from(toolCallState.keys()).pop();
+                                if (!toolCallState.get(lastKey).arguments)
+                                    toolCallState.get(lastKey).arguments = args;
+                            }
                             resetIdleTimer();
+                            continue;
+                        }
+                        if (type === "response.completed") {
+                            sawTerminalProof = "response-completed";
+                            const resp = (parsed.response ?? parsed);
+                            if (resp.usage) {
+                                const u = parseMetaUsage(resp.usage);
+                                if (u)
+                                    streamUsage = u;
+                            }
+                            if (typeof resp.status === "string")
+                                finishReason = resp.status;
+                            if (Array.isArray(resp.output)) {
+                                const out = parseResponsesOutput(resp);
+                                for (const [index, item] of out.reasoningItems.entries()) {
+                                    const position = out.reasoningItemPositions[index];
+                                    noteReasoningItem(item, position?.sequence, position?.toolCallIndex);
+                                }
+                                if (out.reasoningSummary && !reasoningSeen.trim()) {
+                                    emitReasoningDelta(out.reasoningSummary);
+                                }
+                                if (out.text && !visible.trim()) {
+                                    emitVisible(out.text);
+                                }
+                                for (const tc of out.toolCalls) {
+                                    const exists = Array.from(toolCallState.values()).some((s) => s.callId === tc.id);
+                                    if (!exists) {
+                                        const id = tc.id;
+                                        toolCallState.set(id, { id, callId: tc.id, name: toWireName(tc.name), arguments: tc.rawArguments ?? JSON.stringify(tc.args) });
+                                    }
+                                }
+                            }
+                            continue;
+                        }
+                        if (type === "response.failed" || type === "response.incomplete") {
+                            const resp = (parsed.response ?? parsed);
+                            if (type === "response.incomplete") {
+                                const details = resp.incomplete_details;
+                                const reason = typeof details?.reason === "string" ? details.reason : "";
+                                if (resp.usage) {
+                                    const u = parseMetaUsage(resp.usage);
+                                    if (u)
+                                        streamUsage = u;
+                                }
+                                if (reason === "max_output_tokens" && !visible.trim() && toolCallState.size === 0) {
+                                    const retryRequest = reasoningSeen.trim()
+                                        ? undefined
+                                        : incompleteBudgetRetry(request, reasoningOn);
+                                    const streamMethod = metaProvider.stream;
+                                    if (retryRequest && streamMethod && !request.signal?.aborted) {
+                                        cleanup();
+                                        completeGenerationAttempt("failure", streamUsage);
+                                        retryRequest.attemptReason = "provider-retry";
+                                        return streamMethod(retryRequest, auth, onToken);
+                                    }
+                                    completeGenerationAttempt("failure", streamUsage);
+                                    throw budgetExhaustedError(request, reasoningOn, payload);
+                                }
+                                finishReason = "incomplete";
+                                sawTerminalProof = "response-incomplete";
+                                continue;
+                            }
+                            const err = resp.error;
+                            const rawDetail = err?.message ?? err?.code ?? type;
+                            const rawStr = String(rawDetail);
+                            const detail = rawStr.trim().length <= 2 ? `${rawStr} — ${payload.slice(0, 300)}` : rawStr;
+                            throw new ProviderError(`Meta Model API stream error: ${detail}`, undefined, payload.slice(0, 1000));
+                        }
+                        const usageField = parsed.usage;
+                        if (usageField) {
+                            const u = parseMetaUsage(usageField);
+                            if (u) {
+                                streamUsage = u;
+                                resetIdleTimer();
+                            }
+                        }
+                        const choice = parsed.choices;
+                        if (choice) {
+                            const chunkUsage = parseMetaUsage(parsed.usage);
+                            if (chunkUsage)
+                                streamUsage = chunkUsage;
                         }
-                    }
-                    const choice = parsed.choices;
-                    if (choice) {
-                        const chunkUsage = parseMetaUsage(parsed.usage);
-                        if (chunkUsage)
-                            streamUsage = chunkUsage;
                     }
                 }
-            }
-            if (!reasoningSeen.trim() && streamUsage?.reasoningTokens && streamUsage.reasoningTokens > 0 && (visible.trim() || toolCallState.size > 0)) {
-                const effort = metaReasoningPayload(request.thinking)?.effort;
-                const effortText = effort ? ` at ${effort} effort` : "";
-                const note = `Reasoning is private on Meta Model API: the model reasoned${effortText} and used ${streamUsage.reasoningTokens.toLocaleString("en-US")} reasoning tokens, but the API returns no reasoning text to display.`;
-                if (!inReasoning) {
-                    full += REASONING_OPEN;
-                    visible = full;
-                    onToken(REASONING_OPEN);
+                if (!reasoningSeen.trim() && streamUsage?.reasoningTokens && streamUsage.reasoningTokens > 0 && (visible.trim() || toolCallState.size > 0)) {
+                    const effort = metaReasoningPayload(request.thinking)?.effort;
+                    const effortText = effort ? ` at ${effort} effort` : "";
+                    const note = `Reasoning is private on Meta Model API: the model reasoned${effortText} and used ${streamUsage.reasoningTokens.toLocaleString("en-US")} reasoning tokens, but the API returns no reasoning text to display.`;
+                    reasoningSeen += note;
+                    emitStreamReasoningDelta(request.onStreamEvent, note);
                 }
-                full += note;
-                reasoningSeen += note;
-                onToken(note);
-                full += REASONING_CLOSE;
-                onToken(REASONING_CLOSE);
-                inReasoning = false;
-            }
-            else {
-                exitReasoning();
-            }
-            cleanup();
-            const toolCalls = [];
-            for (const [, state] of toolCallState) {
-                if (!state.name && !state.arguments)
-                    continue;
-                const name = state.name || "";
-                const canonical = name ? fromWireName(name) ?? name : "";
-                if (!canonical)
-                    continue;
-                const raw = state.arguments;
-                let args;
-                try {
-                    const parsed = JSON.parse(raw || "{}");
-                    if (parsed && typeof parsed === "object" && !Array.isArray(parsed))
-                        args = parsed;
-                    else
-                        args = {};
+                cleanup();
+                let metaToolArgumentBytes = 0;
+                for (const state of toolCallState.values()) {
+                    metaToolArgumentBytes += state.arguments.length;
                 }
-                catch {
-                    args = parseToolArguments(raw);
+                requireTerminalProof({
+                    provider: "Meta Model API",
+                    policy: META_STREAM_TERMINAL,
+                    signal: sawTerminalProof,
+                    answerBytes: full.length,
+                    reasoningBytes: reasoningSeen.length,
+                    toolArgumentBytes: metaToolArgumentBytes,
+                });
+                const toolCalls = [];
+                for (const [, state] of toolCallState) {
+                    if (!state.name && !state.arguments)
+                        continue;
+                    const name = state.name || "";
+                    const canonical = name ? fromWireName(name) ?? name : "";
+                    if (!canonical)
+                        continue;
+                    const raw = state.arguments;
+                    let args;
+                    try {
+                        const parsed = JSON.parse(raw || "{}");
+                        if (parsed && typeof parsed === "object" && !Array.isArray(parsed))
+                            args = parsed;
+                        else
+                            args = {};
+                    }
+                    catch {
+                        args = parseToolArguments(raw);
+                    }
+                    toolCalls.push({ id: state.callId ?? state.id ?? `call_${toolCalls.length}`, name: canonical, args, rawArguments: raw });
                 }
-                toolCalls.push({ id: state.callId ?? state.id ?? `call_${toolCalls.length}`, name: canonical, args, rawArguments: raw });
-            }
-            if (!visible.trim() && toolCalls.length === 0) {
-                if (reasoningSeen.trim()) {
-                    return { text: full, provider: "meta", model, finishReason: finishReason ?? "stop", ...(streamUsage ? { usage: streamUsage } : {}), ...reasoningReplay() };
+                if (!visible.trim() && toolCalls.length === 0) {
+                    if (reasoningSeen.trim()) {
+                        return { text: full, provider: "meta", model, finishReason: finishReason ?? "stop", ...(streamUsage ? { usage: streamUsage } : {}), ...reasoningReplay() };
+                    }
+                    throw new ProviderError(`Meta Model API completed without a visible answer.`);
                 }
-                throw new ProviderError(`Meta Model API completed without a visible answer.`);
+                return {
+                    text: full,
+                    provider: "meta",
+                    model,
+                    ...(toolCalls.length ? { toolCalls } : {}),
+                    ...(finishReason ? { finishReason } : toolCalls.length ? { finishReason: "tool_calls" } : {}),
+                    ...(streamUsage ? { usage: streamUsage } : {}),
+                    ...reasoningReplay(),
+                };
             }
-            return {
-                text: full,
-                provider: "meta",
-                model,
-                ...(toolCalls.length ? { toolCalls } : {}),
-                ...(finishReason ? { finishReason } : toolCalls.length ? { finishReason: "tool_calls" } : {}),
-                ...(streamUsage ? { usage: streamUsage } : {}),
-                ...reasoningReplay(),
-            };
-        }
-        catch (error) {
-            if (idleFired) {
-                const seconds = Math.round(firedBudgetMs / 1000);
-                if (firedWatchdog === "transport" || !sawTransportActivity) {
-                    if (!sawTransportActivity) {
-                        throw new ProviderError(`Meta Model API request timed out before any response (${seconds}s) — no data arrived on the connection.`);
+            catch (error) {
+                if (idleFired) {
+                    const seconds = Math.round(firedBudgetMs / 1000);
+                    if (firedWatchdog === "transport" || !sawTransportActivity) {
+                        if (!sawTransportActivity) {
+                            throw new ProviderError(`Meta Model API request timed out before any response (${seconds}s) — no data arrived on the connection.`);
+                        }
+                        throw new ProviderError(`Meta Model API stream transport timeout (${seconds}s) — no data arrived on the connection after it had started.`);
                     }
-                    throw new ProviderError(`Meta Model API stream transport timeout (${seconds}s) — no data arrived on the connection after it had started.`);
+                    throw new ProviderError(`Meta Model API stream stalled — ${STREAM_STALL_MARKER} for ${seconds}s` +
+                        (sawStreamProgress
+                            ? " after it had already started producing output. The connection stayed open, so the model was most likely buffering one very large tool call. Split large writes into smaller sequential calls, or try a smaller model / disable thinking with /effort off."
+                            : " — the connection stayed open but the model never produced anything. Try another model, or disable thinking with /effort off."));
                 }
-                throw new ProviderError(`Meta Model API stream stalled — ${STREAM_STALL_MARKER} for ${seconds}s` +
-                    (sawStreamProgress
-                        ? " after it had already started producing output. The connection stayed open, so the model was most likely buffering one very large tool call. Split large writes into smaller sequential calls, or try a smaller model / disable thinking with /effort off."
-                        : " — the connection stayed open but the model never produced anything. Try another model, or disable thinking with /effort off."));
+                throw error;
             }
-            throw error;
-        }
-        finally {
-            cleanup();
-            void reader.cancel().catch(() => undefined);
-            try {
-                reader.releaseLock();
+            finally {
+                cleanup();
+                void reader.cancel().catch(() => undefined);
+                try {
+                    reader.releaseLock();
+                }
+                catch { }
             }
-            catch { }
-        }
+        });
     },
 };
 //# sourceMappingURL=meta.js.map