@navels/neal 0.1.0 → 0.2.0

package/dist/neal/providers/generic-agentic.js

@@ -44,6 +44,7 @@ import { randomBytes } from 'node:crypto';
 import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
 import { generateText, jsonSchema, NoObjectGeneratedError, Output, stepCountIs, } from 'ai';
 import { getOpenAICompatibleSettings } from '../config.js';
+import { resolveRateCost } from './pricing.js';
 import { createCoderToolset, createPlanAuthorToolset, createReadOnlyToolset, } from './generic-agentic-tools.js';
 import { NealProviderError } from './types.js';
 const GENERIC_AGENTIC_PROVIDER_ID = 'generic-agentic';
@@ -404,6 +405,7 @@ function resolveGenericAgenticSettings(args) {
         apiKey: settings.apiKey,
         model,
         headers: settings.headers,
+        pricing: settings.pricing,
     };
 }
 const CODER_STEP_CAP = {
@@ -617,16 +619,28 @@ async function runAgentModelTurn(ctx, turnOptions) {
                 toolErrors: { ...ctx.state.toolErrors },
                 ...(ctx.includeStepsTelemetry ? { steps: ctx.state.steps } : {}),
             };
+            // Rate-computed cost: config pricing (when present) wins; otherwise a
+            // card-listed model is priced by its resolved slug with no configuration.
+            // When neither yields pricing the cost fields are omitted so the
+            // tokens-only event shape is preserved (resolveRateCost returns null,
+            // matching the prior `computeRateCostUsd`-returns-0-for-empty behavior).
+            const cost = resolveRateCost({
+                usage: result.usage,
+                model: ctx.state.modelSlug,
+                configPricing: ctx.state.pricing,
+            }) ?? {};
             await emitProviderEvent(ctx.events, {
                 type: 'usage_reported',
                 ...base,
                 usage: result.usage,
+                ...cost,
                 providerData,
             });
             await emitProviderEvent(ctx.events, {
                 type: 'turn_completed',
                 ...base,
                 usage: result.usage,
+                ...cost,
                 providerData,
             });
             return {
@@ -974,6 +988,7 @@ class GenericAgenticCoderAdapter {
         });
         const state = {
             model,
+            modelSlug: settings.model,
             // Assigned immediately below; the toolset's event hook needs the state
             // object to update the cumulative per-tool telemetry maps.
             tools: undefined,
@@ -981,6 +996,7 @@ class GenericAgenticCoderAdapter {
             toolCalls: {},
             toolErrors: {},
             steps: 0,
+            pricing: settings.pricing,
         };
         const createToolset = args.toolPolicy?.allowRun === false ? createPlanAuthorToolset : createCoderToolset;
         state.tools = createToolset(args.cwd, {
@@ -1105,6 +1121,7 @@ class GenericAgenticStructuredAdvisorAdapter {
             });
             const state = {
                 model,
+                modelSlug: settings.model,
                 // Assigned immediately below; the toolset's event hook needs the
                 // state object to update the cumulative per-tool telemetry maps.
                 tools: undefined,
@@ -1112,6 +1129,7 @@ class GenericAgenticStructuredAdvisorAdapter {
                 toolCalls: {},
                 toolErrors: {},
                 steps: 0,
+                pricing: settings.pricing,
             };
             // Read-only inspection toolset only: advisor rounds must never gain
             // write or shell access. Tool events forward with the advisor role and

package/dist/neal/providers/openai-codex.js

@@ -1,5 +1,6 @@
 import { Codex } from '@openai/codex-sdk';
 import { runStructuredJsonProtocol } from '../agents/structured-json.js';
+import { resolveRateCost } from './pricing.js';
 import { NealProviderError } from './types.js';
 const OPENAI_CODEX_PROVIDER_ID = 'openai-codex';
 class CodexInactivityTimeoutError extends Error {
@@ -269,7 +270,17 @@ async function emitCodexStreamError(args) {
     });
     return true;
 }
-async function consumeCodexTurn(turn, cwd, inactivityTimeoutMs, events, onSessionStarted, abortController) {
+// Shared turn consumer behind `consumeCodexTurn` (coder) and
+// `consumeCodexAdvisorTurn` (structured advisor). The two paths differ only
+// in the role stamped on emitted events and normalized errors, the
+// advisor-only `label` stamp, and the coder-only `onSessionStarted`
+// callback; everything else is identical.
+async function consumeCodexTurnWithOptions(turn, cwd, inactivityTimeoutMs, options) {
+    const { role, label, events, onSessionStarted, abortController, model } = options;
+    // The advisor path stamps `label` on every emitted event while the coder
+    // path emits events without a `label` property at all — the conditional
+    // spread preserves that own-property distinction exactly.
+    const labelFields = label === undefined ? {} : { label };
     let finalResponse = '';
     let observedFailure = null;
     let sessionHandle = null;
@@ -282,13 +293,13 @@ async function consumeCodexTurn(turn, cwd, inactivityTimeoutMs, events, onSessio
         catch (error) {
             if (observedFailure) {
                 throw createCodexProviderErrorFromObservedFailure(observedFailure, {
-                    role: 'coder',
+                    role,
                     sessionHandle,
                     cause: error,
                 });
             }
             throw normalizeCodexProviderError(error, {
-                role: 'coder',
+                role,
                 sessionHandle,
             });
         }
@@ -302,7 +313,8 @@ async function consumeCodexTurn(turn, cwd, inactivityTimeoutMs, events, onSessio
                 await emitProviderEvent(events, {
                     type: 'session_started',
                     provider: OPENAI_CODEX_PROVIDER_ID,
-                    role: 'coder',
+                    role,
+                    ...labelFields,
                     sessionHandle: event.thread_id,
                     providerData: { sdkEventType: event.type },
                 });
@@ -312,7 +324,8 @@ async function consumeCodexTurn(turn, cwd, inactivityTimeoutMs, events, onSessio
                 await emitProviderEvent(events, {
                     type: 'turn_started',
                     provider: OPENAI_CODEX_PROVIDER_ID,
-                    role: 'coder',
+                    role,
+                    ...labelFields,
                     sessionHandle,
                     providerData: { sdkEventType: event.type },
                 });
@@ -321,7 +334,8 @@ async function consumeCodexTurn(turn, cwd, inactivityTimeoutMs, events, onSessio
                 await emitProviderEvent(events, {
                     type: 'tool_started',
                     provider: OPENAI_CODEX_PROVIDER_ID,
-                    role: 'coder',
+                    role,
+                    ...labelFields,
                     sessionHandle,
                     itemId: summarizeItem(event.item).itemId,
                     toolName: event.item.type,
@@ -332,7 +346,8 @@ async function consumeCodexTurn(turn, cwd, inactivityTimeoutMs, events, onSessio
                 await emitProviderEvent(events, {
                     type: 'tool_progress',
                     provider: OPENAI_CODEX_PROVIDER_ID,
-                    role: 'coder',
+                    role,
+                    ...labelFields,
                     sessionHandle,
                     itemId: summarizeItem(event.item).itemId,
                     toolName: event.item.type,
@@ -344,7 +359,8 @@ async function consumeCodexTurn(turn, cwd, inactivityTimeoutMs, events, onSessio
                     await emitProviderEvent(events, {
                         type: 'command_completed',
                         provider: OPENAI_CODEX_PROVIDER_ID,
-                        role: 'coder',
+                        role,
+                        ...labelFields,
                         sessionHandle,
                         itemId: event.item.id,
                         command: event.item.command,
@@ -361,7 +377,8 @@ async function consumeCodexTurn(turn, cwd, inactivityTimeoutMs, events, onSessio
                     await emitProviderEvent(events, {
                         type: 'file_changed',
                         provider: OPENAI_CODEX_PROVIDER_ID,
-                        role: 'coder',
+                        role,
+                        ...labelFields,
                         sessionHandle,
                         files,
                         providerData: { sdkEventType: event.type, item: summarizeItem(event.item) },
@@ -371,206 +388,41 @@ async function consumeCodexTurn(turn, cwd, inactivityTimeoutMs, events, onSessio
                     finalResponse = event.item.text;
                 }
                 break;
-            case 'turn.completed':
+            case 'turn.completed': {
+                // Card-derived cost only when the turn actually carried usage. Codex
+                // advertises opportunistic usage reporting, and `computeRateCostUsd`
+                // returns 0 for absent usage, so gating on `event.usage !== undefined`
+                // (matching the usage_reported emit) keeps a usage-less turn's
+                // tokens-only shape byte-stable rather than attaching costUsd: 0. Codex
+                // has no config pricing, so cost comes from the card via the configured
+                // model only.
+                const cost = event.usage !== undefined
+                    ? (resolveRateCost({ usage: event.usage, model: model ?? null, configPricing: null }) ?? {})
+                    : {};
                 await emitProviderEvent(events, {
                     type: 'turn_completed',
                     provider: OPENAI_CODEX_PROVIDER_ID,
-                    role: 'coder',
+                    role,
+                    ...labelFields,
                     sessionHandle,
                     usage: event.usage,
+                    ...cost,
                     providerData: { sdkEventType: event.type },
                 });
                 if (event.usage !== undefined) {
                     await emitProviderEvent(events, {
                         type: 'usage_reported',
                         provider: OPENAI_CODEX_PROVIDER_ID,
-                        role: 'coder',
+                        role,
+                        ...labelFields,
                         sessionHandle,
                         usage: event.usage,
+                        ...cost,
                         providerData: { sdkEventType: event.type },
                     });
                 }
                 break;
-            case 'turn.failed':
-                {
-                    const nextFailure = observeCodexFailure({
-                        message: event.error.message,
-                        source: event.type,
-                        cause: event.error,
-                    });
-                    if (shouldReplaceCodexFailure(observedFailure, nextFailure)) {
-                        observedFailure = nextFailure;
-                        await emitProviderEvent(events, {
-                            type: 'provider_error',
-                            provider: OPENAI_CODEX_PROVIDER_ID,
-                            role: 'coder',
-                            sessionHandle,
-                            message: event.error.message,
-                            providerData: { sdkEventType: event.type },
-                        });
-                    }
-                }
-                break;
-            case 'error':
-                {
-                    const nextFailure = observeCodexFailure({
-                        message: event.message,
-                        source: event.type,
-                        cause: event,
-                    });
-                    if (shouldReplaceCodexFailure(observedFailure, nextFailure)) {
-                        if (await emitCodexStreamError({
-                            events,
-                            role: 'coder',
-                            sessionHandle,
-                            message: event.message,
-                        })) {
-                            observedFailure = nextFailure;
-                        }
-                    }
-                }
-                break;
-            default:
-                break;
-        }
-    }
-    if (observedFailure) {
-        throw createCodexProviderErrorFromObservedFailure(observedFailure, {
-            role: 'coder',
-            sessionHandle,
-        });
-    }
-    return { finalResponse, sessionHandle };
-}
-async function consumeCodexAdvisorTurn(turn, cwd, label, inactivityTimeoutMs, events, abortController) {
-    let finalResponse = '';
-    let observedFailure = null;
-    let sessionHandle = null;
-    const iterator = turn.events[Symbol.asyncIterator]();
-    while (true) {
-        let next;
-        try {
-            next = await nextWithTimeout(iterator.next(), inactivityTimeoutMs, () => abortController?.abort());
-        }
-        catch (error) {
-            if (observedFailure) {
-                throw createCodexProviderErrorFromObservedFailure(observedFailure, {
-                    role: 'structured-advisor',
-                    sessionHandle,
-                    cause: error,
-                });
             }
-            throw normalizeCodexProviderError(error, {
-                role: 'structured-advisor',
-                sessionHandle,
-            });
-        }
-        if (next.done) {
-            break;
-        }
-        const event = next.value;
-        switch (event.type) {
-            case 'thread.started':
-                sessionHandle = event.thread_id;
-                await emitProviderEvent(events, {
-                    type: 'session_started',
-                    provider: OPENAI_CODEX_PROVIDER_ID,
-                    role: 'structured-advisor',
-                    label,
-                    sessionHandle: event.thread_id,
-                    providerData: { sdkEventType: event.type },
-                });
-                break;
-            case 'turn.started':
-                await emitProviderEvent(events, {
-                    type: 'turn_started',
-                    provider: OPENAI_CODEX_PROVIDER_ID,
-                    role: 'structured-advisor',
-                    label,
-                    sessionHandle,
-                    providerData: { sdkEventType: event.type },
-                });
-                break;
-            case 'item.started':
-                await emitProviderEvent(events, {
-                    type: 'tool_started',
-                    provider: OPENAI_CODEX_PROVIDER_ID,
-                    role: 'structured-advisor',
-                    label,
-                    sessionHandle,
-                    itemId: summarizeItem(event.item).itemId,
-                    toolName: event.item.type,
-                    providerData: { sdkEventType: event.type, item: summarizeItem(event.item) },
-                });
-                break;
-            case 'item.updated':
-                await emitProviderEvent(events, {
-                    type: 'tool_progress',
-                    provider: OPENAI_CODEX_PROVIDER_ID,
-                    role: 'structured-advisor',
-                    label,
-                    sessionHandle,
-                    itemId: summarizeItem(event.item).itemId,
-                    toolName: event.item.type,
-                    providerData: { sdkEventType: event.type, item: summarizeItem(event.item) },
-                });
-                break;
-            case 'item.completed':
-                if (event.item.type === 'command_execution') {
-                    await emitProviderEvent(events, {
-                        type: 'command_completed',
-                        provider: OPENAI_CODEX_PROVIDER_ID,
-                        role: 'structured-advisor',
-                        label,
-                        sessionHandle,
-                        itemId: event.item.id,
-                        command: event.item.command,
-                        status: event.item.status,
-                        exitCode: event.item.exit_code ?? null,
-                        output: event.item.aggregated_output,
-                        outputLength: event.item.aggregated_output.length,
-                        cwd,
-                        providerData: { sdkEventType: event.type, item: summarizeItem(event.item) },
-                    });
-                }
-                else if (event.item.type === 'file_change' && event.item.changes.length > 0) {
-                    const files = event.item.changes.map((change) => change.path);
-                    await emitProviderEvent(events, {
-                        type: 'file_changed',
-                        provider: OPENAI_CODEX_PROVIDER_ID,
-                        role: 'structured-advisor',
-                        label,
-                        sessionHandle,
-                        files,
-                        providerData: { sdkEventType: event.type, item: summarizeItem(event.item) },
-                    });
-                }
-                else if (event.item.type === 'agent_message') {
-                    finalResponse = event.item.text;
-                }
-                break;
-            case 'turn.completed':
-                await emitProviderEvent(events, {
-                    type: 'turn_completed',
-                    provider: OPENAI_CODEX_PROVIDER_ID,
-                    role: 'structured-advisor',
-                    label,
-                    sessionHandle,
-                    usage: event.usage,
-                    providerData: { sdkEventType: event.type },
-                });
-                if (event.usage !== undefined) {
-                    await emitProviderEvent(events, {
-                        type: 'usage_reported',
-                        provider: OPENAI_CODEX_PROVIDER_ID,
-                        role: 'structured-advisor',
-                        label,
-                        sessionHandle,
-                        usage: event.usage,
-                        providerData: { sdkEventType: event.type },
-                    });
-                }
-                break;
             case 'turn.failed':
                 {
                     const nextFailure = observeCodexFailure({
@@ -583,8 +435,8 @@ async function consumeCodexAdvisorTurn(turn, cwd, label, inactivityTimeoutMs, ev
                         await emitProviderEvent(events, {
                             type: 'provider_error',
                             provider: OPENAI_CODEX_PROVIDER_ID,
-                            role: 'structured-advisor',
-                            label,
+                            role,
+                            ...labelFields,
                             sessionHandle,
                             message: event.error.message,
                             providerData: { sdkEventType: event.type },
@@ -602,7 +454,7 @@ async function consumeCodexAdvisorTurn(turn, cwd, label, inactivityTimeoutMs, ev
                     if (shouldReplaceCodexFailure(observedFailure, nextFailure)) {
                         if (await emitCodexStreamError({
                             events,
-                            role: 'structured-advisor',
+                            role,
                             label,
                             sessionHandle,
                             message: event.message,
@@ -618,12 +470,36 @@ async function consumeCodexAdvisorTurn(turn, cwd, label, inactivityTimeoutMs, ev
     }
     if (observedFailure) {
         throw createCodexProviderErrorFromObservedFailure(observedFailure, {
-            role: 'structured-advisor',
+            role,
             sessionHandle,
         });
     }
     return { finalResponse, sessionHandle };
 }
+async function consumeCodexTurn(turn, cwd, inactivityTimeoutMs, events, onSessionStarted, abortController, 
+// Appended last so existing positional callers (including test hooks) stay
+// valid; forwards the configured slug for card-derived cost.
+model) {
+    return consumeCodexTurnWithOptions(turn, cwd, inactivityTimeoutMs, {
+        role: 'coder',
+        events,
+        onSessionStarted,
+        abortController,
+        model,
+    });
+}
+async function consumeCodexAdvisorTurn(turn, cwd, label, inactivityTimeoutMs, events, abortController, 
+// Appended last so existing positional callers (including test hooks) stay
+// valid; forwards the configured slug for card-derived cost.
+model) {
+    return consumeCodexTurnWithOptions(turn, cwd, inactivityTimeoutMs, {
+        role: 'structured-advisor',
+        label,
+        events,
+        abortController,
+        model,
+    });
+}
 function parseCodexStructuredOutput(finalResponse, label, sessionHandle) {
     try {
         return JSON.parse(finalResponse);
@@ -685,7 +561,7 @@ class OpenAICodexCoderAdapter {
                 ...(args.outputSchema ? { outputSchema: args.outputSchema } : {}),
                 signal: abortController.signal,
             });
-            const result = await consumeCodexTurn(streamedTurn, args.cwd, args.inactivityTimeoutMs, args.events, args.onSessionStarted, abortController);
+            const result = await consumeCodexTurn(streamedTurn, args.cwd, args.inactivityTimeoutMs, args.events, args.onSessionStarted, abortController, this.options.model ?? null);
             if (args.outputSchema) {
                 await emitProviderEvent(args.events, {
                     type: 'structured_output_received',
@@ -745,7 +621,7 @@ class OpenAICodexCoderAdapter {
                         const streamedTurn = await thread.runStreamed(prompt, {
                             signal: abortController.signal,
                         });
-                        const result = await consumeCodexTurn(streamedTurn, args.cwd, args.inactivityTimeoutMs, args.events, args.onSessionStarted, abortController);
+                        const result = await consumeCodexTurn(streamedTurn, args.cwd, args.inactivityTimeoutMs, args.events, args.onSessionStarted, abortController, this.options.model ?? null);
                         return {
                             assistantText: result.finalResponse,
                             sessionHandle: thread.id,
@@ -767,7 +643,7 @@ class OpenAICodexCoderAdapter {
                         const streamedTurn = await repairThread.runStreamed(prompt, {
                             signal: repairAbortController.signal,
                         });
-                        const result = await consumeCodexTurn(streamedTurn, args.cwd, args.inactivityTimeoutMs, args.events, undefined, repairAbortController);
+                        const result = await consumeCodexTurn(streamedTurn, args.cwd, args.inactivityTimeoutMs, args.events, undefined, repairAbortController, this.options.model ?? null);
                         return {
                             assistantText: result.finalResponse,
                             sessionHandle: repairThread.id,
@@ -865,7 +741,7 @@ class OpenAICodexStructuredAdvisorAdapter {
                             const streamedTurn = await thread.runStreamed(prompt, {
                                 signal: abortController.signal,
                             });
-                            const result = await consumeCodexAdvisorTurn(streamedTurn, args.cwd, args.label, args.inactivityTimeoutMs, args.events, abortController);
+                            const result = await consumeCodexAdvisorTurn(streamedTurn, args.cwd, args.label, args.inactivityTimeoutMs, args.events, abortController, this.options.model ?? null);
                             return {
                                 assistantText: result.finalResponse,
                                 sessionHandle: thread.id ?? result.sessionHandle ?? null,
@@ -883,7 +759,7 @@ class OpenAICodexStructuredAdvisorAdapter {
                             const streamedTurn = await repairThread.runStreamed(prompt, {
                                 signal: repairAbortController.signal,
                             });
-                            const result = await consumeCodexAdvisorTurn(streamedTurn, args.cwd, args.label, args.inactivityTimeoutMs, args.events, repairAbortController);
+                            const result = await consumeCodexAdvisorTurn(streamedTurn, args.cwd, args.label, args.inactivityTimeoutMs, args.events, repairAbortController, this.options.model ?? null);
                             return {
                                 assistantText: result.finalResponse,
                                 sessionHandle: repairThread.id ?? result.sessionHandle ?? null,
@@ -900,7 +776,7 @@ class OpenAICodexStructuredAdvisorAdapter {
                     });
                 }
                 const streamedTurn = await thread.runStreamed(args.prompt, buildCodexStructuredAdvisorRunOptions(args, abortController.signal));
-                const result = await consumeCodexAdvisorTurn(streamedTurn, args.cwd, args.label, args.inactivityTimeoutMs, args.events, abortController);
+                const result = await consumeCodexAdvisorTurn(streamedTurn, args.cwd, args.label, args.inactivityTimeoutMs, args.events, abortController, this.options.model ?? null);
                 const structured = parseCodexStructuredOutput(result.finalResponse, args.label, thread.id);
                 await emitProviderEvent(args.events, {
                     type: 'structured_output_received',

package/dist/neal/providers/openai-compatible.js

@@ -31,6 +31,7 @@ import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
 import { generateText } from 'ai';
 import { runStructuredJsonProtocol } from '../agents/structured-json.js';
 import { getOpenAICompatibleSettings } from '../config.js';
+import { resolveRateCost } from './pricing.js';
 import { NealProviderError } from './types.js';
 const OPENAI_COMPATIBLE_PROVIDER_ID = 'openai-compatible';
 const API_RETRY_BASE_DELAY_MS = 500;
@@ -123,7 +124,11 @@ function describeError(error) {
  *   the cancellation; never retried in-round);
  * - abort without a caller abort -> inactivity expiry -> `timeout`,
  *   retryable: true;
- * - HTTP 401/403 -> `permission_denied`, non-retryable;
+ * - HTTP 401 -> `permission_denied`, retryable (OpenAI intermittently
+ *   returns 401 for keys that are valid moments before and after; a
+ *   persistent 401 exhausts the bounded retry budget and still surfaces
+ *   as `permission_denied`);
+ * - HTTP 403 -> `permission_denied`, non-retryable;
  * - HTTP 408/429/5xx -> `api_error`, retryable;
  * - any other HTTP status -> `provider_failed`, non-retryable (Neal's
  *   status table is authoritative for status-bearing errors; the SDK's
@@ -165,7 +170,10 @@ function normalizeOpenAICompatibleError(error, ctx) {
                     message: `OpenAI-compatible ${ctx.label} request was rejected with HTTP ${status}: ${describeError(error)}`,
                     sessionHandle: ctx.sessionHandle,
                     kind: 'permission_denied',
-                    retryable: false,
+                    // 401 gets the bounded api-retry budget: OpenAI intermittently
+                    // rejects otherwise-valid keys with 401, and a single blip must
+                    // not terminate an unattended run. 403 stays terminal.
+                    retryable: status === 401,
                     cause: error,
                 });
             }
@@ -237,7 +245,7 @@ function createEmbeddedResponseError(args) {
             message,
             sessionHandle: args.sessionHandle,
             kind: 'permission_denied',
-            retryable: false,
+            retryable: status === 401,
         });
     }
     if (status === 408 || status === 429 || (status !== null && status >= 500)) {
@@ -415,6 +423,7 @@ function resolveRoundSettings(args) {
         apiKey: settings.apiKey,
         model,
         headers: settings.headers,
+        pricing: settings.pricing,
     };
 }
 class OpenAICompatibleStructuredAdvisorAdapter {
@@ -469,9 +478,11 @@ class OpenAICompatibleStructuredAdvisorAdapter {
                 runInitial: async (prompt) => ({
                     assistantText: await this.runChatTurnWithRetry({
                         model,
+                        modelSlug: settings.model,
                         prompt,
                         roundArgs: args,
                         sessionHandle,
+                        pricing: settings.pricing,
                         // Only the primary turn is wired to external cancellation; repair
                         // turns are short prompt-only turns (matching other adapters).
                         signal: args.signal,
@@ -481,9 +492,11 @@ class OpenAICompatibleStructuredAdvisorAdapter {
                 runRepair: async (prompt) => ({
                     assistantText: await this.runChatTurnWithRetry({
                         model,
+                        modelSlug: settings.model,
                         prompt,
                         roundArgs: args,
                         sessionHandle,
+                        pricing: settings.pricing,
                     }),
                     sessionHandle,
                 }),
@@ -522,7 +535,10 @@ class OpenAICompatibleStructuredAdvisorAdapter {
     /**
      * One chat turn with the bounded transient-retry loop: emits
      * `turn_started`, makes a single tool-less `generateText` call
-     * (`temperature: 0`, `maxRetries: 0`, abort/inactivity signal), applies
+     * (`maxRetries: 0`, abort/inactivity signal; no sampling parameters —
+     * reasoning-family models such as OpenAI's o-series and gpt-5.x reject any
+     * non-default `temperature` with HTTP 400, and the structured-output
+     * protocol, not sampling, is what disciplines the response), applies
      * the reasoning-text fallback, then emits `assistant_text`,
      * `turn_completed`, and `usage_reported` (the latter only when the
      * response body actually carried usage, observed structurally via the AI
@@ -549,7 +565,6 @@ class OpenAICompatibleStructuredAdvisorAdapter {
                 const result = await generateText({
                     model: callArgs.model,
                     prompt: callArgs.prompt,
-                    temperature: 0,
                     maxRetries: 0,
                     abortSignal: composeAbortSignal(callArgs.signal, roundArgs.inactivityTimeoutMs),
                 });
@@ -577,16 +592,29 @@ class OpenAICompatibleStructuredAdvisorAdapter {
                 // marker, matching the bespoke adapter's "only report usage when the
                 // gateway provided it" behavior).
                 const hasUsage = result.usage.raw !== undefined;
+                // Rate-computed cost only when the round has usage. Config pricing (when
+                // present) wins; otherwise a card-listed model is priced by its resolved
+                // slug with no configuration. When neither yields pricing the cost fields
+                // are omitted entirely so the tokens-only event shape stays byte-stable.
+                const cost = hasUsage
+                    ? (resolveRateCost({
+                        usage: result.usage,
+                        model: callArgs.modelSlug,
+                        configPricing: callArgs.pricing,
+                    }) ?? {})
+                    : {};
                 await emitProviderEvent(roundArgs.events, {
                     type: 'turn_completed',
                     ...base,
                     ...(hasUsage ? { usage: result.usage } : {}),
+                    ...cost,
                 });
                 if (hasUsage) {
                     await emitProviderEvent(roundArgs.events, {
                         type: 'usage_reported',
                         ...base,
                         usage: result.usage,
+                        ...cost,
                     });
                 }
                 return assistantText;