@yeaft/webchat-agent 1.0.505 → 1.0.506

package/yeaft/history-window.js

@@ -1,3 +1,4 @@
+import { providerProjectionDigest, providerStateBytes, MAX_PROVIDER_STATE_BYTES, ProviderStateError } from './llm/provider-state.js';
 /**
  * history-window.js — deterministic history shaping for provider requests.
  *
@@ -157,7 +158,19 @@ export function estimateContentTokens(content) {
 export function estimateMessageTokens(message) {
   if (!message || typeof message !== 'object') return 0;
   let total = 2 + estimateContentTokens(message.content);
-  total += estimateThinkingBlocksTokens(message.thinkingBlocks);
+  // Responses ciphertext has a byte budget, not a text-token cost. Anthropic
+  // thinking is plaintext and must be charged, without recounting the native
+  // text/tool items already represented by content/toolCalls below.
+  if (message.providerState && providerStateBytes(message.providerState) > MAX_PROVIDER_STATE_BYTES) {
+    throw new ProviderStateError('state exceeds byte budget');
+  }
+  if (message.providerState?.protocol === 'anthropic') {
+    const thinking = (message.providerState.items || [])
+      .filter(item => ['thinking', 'redacted_thinking'].includes(item?.type));
+    if (thinking.length > 0) total += estimateContentTokens(thinking);
+  } else if (!message.providerState) {
+    total += estimateThinkingBlocksTokens(message.thinkingBlocks);
+  }
   if (Array.isArray(message.toolCalls)) {
     for (const toolCall of message.toolCalls) {
       total += 4;
@@ -242,6 +255,7 @@ export function stripToolNoiseFromOlderTurns(messages, options = {}) {
     const next = { ...message };
     if (Array.isArray(next.toolCalls)) delete next.toolCalls;
     if (Array.isArray(next.thinkingBlocks)) delete next.thinkingBlocks;
+    delete next.providerState;
     if (Array.isArray(next.content)) next.content = stripToolContentParts(next.content);
     if (next.role === 'assistant' && !hasContentAfterToolStrip(next.content)) continue;
     if (next.role === 'user' && Array.isArray(next.content) && next.content.length === 0) continue;
@@ -257,6 +271,7 @@ function stripAllToolNoise(messages) {
     const next = { ...message };
     if (Array.isArray(next.toolCalls)) delete next.toolCalls;
     if (Array.isArray(next.thinkingBlocks)) delete next.thinkingBlocks;
+    delete next.providerState;
     if (Array.isArray(next.content)) next.content = stripToolContentParts(next.content);
     if (next.role === 'assistant' && !hasContentAfterToolStrip(next.content)) continue;
     if (next.role === 'user' && Array.isArray(next.content) && next.content.length === 0) continue;
@@ -374,6 +389,7 @@ function dropEmptyAssistantRows(messages) {
     if (!message || message.role !== 'assistant') return true;
     return hasProviderContent(message.content)
       || (Array.isArray(message.toolCalls) && message.toolCalls.length > 0)
+      || Boolean(message.providerState)
       || (Array.isArray(message.thinkingBlocks) && message.thinkingBlocks.length > 0);
   });
 }
@@ -421,6 +437,13 @@ function shrinkMessageToBudget(message, tokenBudget) {
   if (estimateMessageTokens(next) > tokenBudget && Array.isArray(next.toolCalls)) {
     delete next.toolCalls;
   }
+  if (next.providerState && providerProjectionDigest(next) !== next.providerState.projectionDigest) {
+    // Modified assistant projections must never resurrect removed text/calls.
+    const signed = next.providerState.protocol === 'anthropic'
+      && next.providerState.items?.some(item => ['thinking', 'redacted_thinking'].includes(item?.type));
+    delete next.providerState;
+    if (signed) delete next.toolCalls;
+  }
   return next;
 }
 
@@ -608,6 +631,16 @@ function enrichTextBaselineWithTools(textBaseline, toolSource, selectedCallIds)
       const selectedParts = source.content.filter(part => selectedIds.has(toolContentPartCallId(part)));
       owner.content = [...baselineContent, ...selectedParts];
     }
+    if (source.providerState) {
+      if (providerProjectionDigest(owner) === source.providerState.projectionDigest) {
+        owner.providerState = source.providerState;
+      } else {
+        delete owner.providerState;
+        // A changed text baseline or call subset cannot replay this signed
+        // turn. Leave its text-only baseline and let pairing drop the results.
+        if (hasSignedProviderThinking(source)) continue;
+      }
+    }
     messagesBySourceIndex.set(sourceIndex, owner);
   }
 
@@ -627,19 +660,41 @@ function preservesTextBaseline(textBaseline, enriched) {
   });
 }
 
+function hasSignedProviderThinking(message) {
+  return message.providerState?.protocol === 'anthropic'
+    && message.providerState.items?.some(item => ['thinking', 'redacted_thinking'].includes(item?.type));
+}
+
+function completeToolCallGroups(messages) {
+  const completeIds = new Set(completeToolCallIds(messages));
+  const groups = [];
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    const message = messages[index];
+    if (message?.role !== 'assistant' || !Array.isArray(message.toolCalls)) continue;
+    const ids = message.toolCalls.map(call => call?.id);
+    if (hasSignedProviderThinking(message)) {
+      // A signed assistant projection binds every call, including their order.
+      // A missing result makes the whole group ineligible, not a smaller turn.
+      if (ids.length > 0 && ids.every(id => completeIds.has(id))) groups.push(ids);
+    } else {
+      groups.push(...ids.reverse().filter(id => completeIds.has(id)).map(id => [id]));
+    }
+  }
+  return groups;
+}
+
 function addOptionalRecentToolPairs(textBaseline, toolSource, options) {
   const selectedCallIds = new Set();
   let out = pairSanitize(textBaseline);
-  for (const callId of completeToolCallIds(toolSource)) {
-    const trialIds = new Set(selectedCallIds);
-    trialIds.add(callId);
+  for (const callIds of completeToolCallGroups(toolSource)) {
+    const trialIds = new Set([...selectedCallIds, ...callIds]);
     const trial = enrichTextBaselineWithTools(textBaseline, toolSource, trialIds);
     if (trial.length > options.maxMessageCount) continue;
     const fitted = fitMessagesToBudget(trial, options.messageTokenBudget);
     const fittedCallIds = new Set(completeToolCallIds(fitted));
     if (![...trialIds].every(id => fittedCallIds.has(id))) continue;
     if (!preservesTextBaseline(textBaseline, fitted)) continue;
-    selectedCallIds.add(callId);
+    for (const callId of callIds) selectedCallIds.add(callId);
     out = fitted;
   }
   return out;

package/yeaft/llm/adapter.js

@@ -44,11 +44,12 @@ import { utf8PrefixWithinBytes } from '../utf8.js';
  * @typedef {{ type: 'thinking_delta', text: string }} ThinkingDeltaEvent
  * @typedef {{ type: 'thinking_block_end', thinking: string, signature: string }} ThinkingBlockEndEvent
  * @typedef {{ type: 'tool_call', id: string, name: string, input: object }} ToolCallEvent
- * @typedef {{ type: 'usage', inputTokens: number, outputTokens: number, cacheReadTokens?: number, cacheWriteTokens?: number, cacheTokensAreIncludedInInput?: boolean }} UsageEvent
+ * @typedef {{ type: 'provider_state', providerState: object, providerStateBytes: number }} ProviderStateEvent Internal only; never forward to UI/search.
+ * @typedef {{ type: 'usage', inputTokens: number, outputTokens: number, reasoningTokens?: number, cacheReadTokens?: number, cacheWriteTokens?: number, cacheTokensAreIncludedInInput?: boolean }} UsageEvent
  * @typedef {{ type: 'stop', stopReason: 'end_turn' | 'tool_use' | 'max_tokens' }} StopEvent
  * @typedef {{ type: 'error', error: Error, retryable: boolean }} ErrorEvent
  *
- * @typedef {TextDeltaEvent | ThinkingDeltaEvent | ThinkingBlockEndEvent | ToolCallEvent | UsageEvent | StopEvent | ErrorEvent} StreamEvent
+ * @typedef {TextDeltaEvent | ThinkingDeltaEvent | ThinkingBlockEndEvent | ProviderStateEvent | ToolCallEvent | UsageEvent | StopEvent | ErrorEvent} StreamEvent
  */
 
 // ─── Unified Message Types ─────────────────────────────────────

package/yeaft/llm/anthropic.js

@@ -24,6 +24,7 @@ import {
   createBoundedTextAccumulator,
   toWellFormedJson,
 } from './adapter.js';
+import { enforceSubAgentEffortPayload, captureEffortDecision } from '../effort.js';
 import {
   normalizeEffort,
   thinkingBudgetForEffort,
@@ -61,6 +62,8 @@ function applyAnthropicThinking(body, model, effort, effortContext = {}) {
   }
 }
 
+import { ProviderStateError, createProviderContext, createProviderState, replayProviderState, providerStateBytes, applyAnthropicCaching, reasoningUsage } from './provider-state.js';
+
 const DEFAULT_BASE_URL = 'https://api.anthropic.com';
 const API_VERSION = '2023-06-01';
 
@@ -144,7 +147,7 @@ export class AnthropicAdapter extends LLMAdapter {
    * @param {import('./adapter.js').UnifiedMessage[]} messages
    * @returns {object[]}
    */
-  #translateMessages(messages) {
+  #translateMessages(messages, context, identity) {
     const result = [];
     for (const msg of messages) {
       if (msg.role === 'system') continue; // system goes separately
@@ -152,24 +155,13 @@ export class AnthropicAdapter extends LLMAdapter {
         const content = translateUserContent(msg.content);
         if (content) result.push({ role: 'user', content });
       } else if (msg.role === 'assistant') {
+        const native = replayProviderState(msg, context, identity);
+        if (native) { result.push({ role: 'assistant', content: native }); continue; }
         const content = [];
-        // task-327d: Anthropic requires thinking blocks to appear BEFORE
-        // any text / tool_use in the content array on echo-back. When the
-        // previous turn produced thinking blocks (with server-signed
-        // signature), we MUST replay them verbatim or the next request
-        // 400s with "content[].thinking in the thinking mode must be
-        // passed back to the API". Order is mandatory.
-        if (Array.isArray(msg.thinkingBlocks)) {
-          for (const tb of msg.thinkingBlocks) {
-            if (!tb || typeof tb.signature !== 'string' || !tb.signature) continue;
-            if (tb.redacted) {
-              if (typeof tb.data !== 'string') continue;
-              content.push({ type: 'redacted_thinking', data: tb.data, signature: tb.signature });
-            } else {
-              if (typeof tb.thinking !== 'string') continue;
-              content.push({ type: 'thinking', thinking: tb.thinking, signature: tb.signature });
-            }
-          }
+        // Legacy records remain readable, but have no trustworthy wire origin.
+        // Never replay their signatures into an arbitrary current account/model.
+        if (!msg.providerState && msg.thinkingBlocks?.length && msg.toolCalls?.length) {
+          throw new ProviderStateError('legacy signed tool history has no origin; start a new context');
         }
         if (hasNonEmptyText(msg.content)) {
           content.push({ type: 'text', text: msg.content });
@@ -246,14 +238,16 @@ export class AnthropicAdapter extends LLMAdapter {
    * @param {{ model: string, system: string, messages: import('./adapter.js').UnifiedMessage[], tools?: import('./adapter.js').UnifiedToolDef[], maxTokens?: number, effort?: 'low'|'medium'|'high'|'xhigh'|'max', effortSource?: 'user'|'auto', effortContext?: object, signal?: AbortSignal, onRawExchange?: ({rawRequest, rawResponse}) => void }} params
    * @returns {AsyncGenerator<import('./adapter.js').StreamEvent>}
    */
-  async *stream({ model, system, messages, tools, maxTokens = 16384, effort, effortSource, effortContext, signal, onRawExchange, rawExchangeMaxBytes = 512 * 1024, onRequestStart }) {
+  async *stream({ model, system, messages, tools, maxTokens = 16384, effort, effortSource, effortContext, extraBody, providerContext, requestIdentity, onProviderDiagnostics, effortConstraint = null, onEffortDecision = null, signal, onRawExchange, rawExchangeMaxBytes = 512 * 1024, onRequestStart }) {
     if (signal?.aborted) throw new LLMAbortError();
 
+    const context = providerContext || createProviderContext({ protocol: 'anthropic', baseUrl: this.#baseUrl, model });
+    const translatedMessages = this.#translateMessages(messages, context, requestIdentity);
     const body = {
       model,
       max_tokens: maxTokens,
       system,
-      messages: this.#translateMessages(messages),
+      messages: translatedMessages,
       stream: true,
     };
 
@@ -267,6 +261,15 @@ export class AnthropicAdapter extends LLMAdapter {
 
     const translatedTools = this.#translateTools(tools);
     if (translatedTools) body.tools = translatedTools;
+    if (extraBody) Object.assign(body, extraBody);
+    body.model = model; // Do not let extraBody bypass origin/model ownership.
+    body.messages = translatedMessages;
+    body.system = system;
+    applyAnthropicCaching(body, context, onProviderDiagnostics);
+    const effortDecision = effortConstraint
+      ? enforceSubAgentEffortPayload(body, { model, protocol: 'anthropic', effortContext, effortConstraint })
+      : captureEffortDecision({ body, model, protocol: 'anthropic', effortContext, requested: effort, source: effortSource || 'scenario' });
+    onEffortDecision?.(effortDecision);
     const wireBody = toWellFormedJson(body);
 
     const url = `${this.#baseUrl}/v1/messages`;
@@ -308,6 +311,28 @@ export class AnthropicAdapter extends LLMAdapter {
       throw this.#classifyError(response.status, errorBody, response);
     }
 
+    // Some native-compatible gateways return a complete JSON response even
+    // when streaming was requested. Seal exactly the same native blocks.
+    if ((response.headers?.get('content-type') || '').includes('application/json')) {
+      const result = await response.json();
+      const state = createProviderState({ context, identity: requestIdentity, items: result.content, responseId: result.id });
+      for (const block of result.content || []) {
+        if (block.type === 'text') yield { type: 'text_delta', text: block.text };
+        if (block.type === 'tool_use') yield { type: 'tool_call', id: block.id, name: block.name, input: block.input };
+        if (block.type === 'thinking') yield { type: 'thinking_block_end', thinking: block.thinking, signature: block.signature };
+        if (block.type === 'redacted_thinking') yield { type: 'thinking_block_end', redacted: true, data: block.data };
+      }
+      if (state) yield { type: 'provider_state', providerState: state, providerStateBytes: providerStateBytes(state) };
+      yield { type: 'usage', inputTokens: result.usage?.input_tokens || 0, outputTokens: result.usage?.output_tokens || 0,
+        cacheReadTokens: result.usage?.cache_read_input_tokens || 0, cacheWriteTokens: result.usage?.cache_creation_input_tokens || 0,
+        ...reasoningUsage(result.usage, 'anthropic') };
+      yield { type: 'stop', stopReason: this.#mapStopReason(result.stop_reason) };
+      if (onRawExchange) {
+        try { onRawExchange({ rawRequest, rawResponse: { status: response.status, headers: safeHeaders(response), body: result } }); } catch { /* diagnostic only */ }
+      }
+      return;
+    }
+
     // Parse SSE stream
     const reader = response.body.getReader();
     const decoder = new TextDecoder();
@@ -327,6 +352,10 @@ export class AnthropicAdapter extends LLMAdapter {
     // signature → next turn 400s identically).
     /** @type {Map<number, { kind: string, [k: string]: any }>} */
     const blockByIndex = new Map();
+    const completedBlocks = new Map();
+    let responseId;
+    let stateFailed = false;
+    let cumulativeReasoningTokens = 0;
     // Keep raw SSE chunks only until the engine receives the bounded exchange
     // callback. The engine owns the configured byte budget; the adapter avoids
     // quadratic string concatenation by storing chunks separately.
@@ -370,9 +399,13 @@ export class AnthropicAdapter extends LLMAdapter {
           if (type === 'content_block_start') {
             const block = event.content_block;
             const idx = event.index;
-            if (block?.type === 'tool_use') {
+            if (block?.type === 'text') {
+              blockByIndex.set(idx, { kind: 'text', text: block.text || '', native: block });
+              if (block.text) yield { type: 'text_delta', text: block.text };
+            } else if (block?.type === 'tool_use') {
               blockByIndex.set(idx, {
                 kind: 'tool_use',
+                native: block,
                 id: block.id,
                 name: block.name,
                 input: '',
@@ -380,6 +413,7 @@ export class AnthropicAdapter extends LLMAdapter {
             } else if (block?.type === 'thinking') {
               blockByIndex.set(idx, {
                 kind: 'thinking',
+                native: block,
                 thinking: typeof block.thinking === 'string' ? block.thinking : '',
                 signature: typeof block.signature === 'string' ? block.signature : '',
               });
@@ -390,6 +424,7 @@ export class AnthropicAdapter extends LLMAdapter {
               // 400s with the same "must be passed back" error.
               blockByIndex.set(idx, {
                 kind: 'redacted_thinking',
+                native: block,
                 data: typeof block.data === 'string' ? block.data : '',
                 signature: typeof block.signature === 'string' ? block.signature : '',
               });
@@ -399,6 +434,7 @@ export class AnthropicAdapter extends LLMAdapter {
             const idx = event.index;
             const st = blockByIndex.get(idx);
             if (delta?.type === 'text_delta') {
+              if (st?.kind === 'text') st.text += delta.text || '';
               yield { type: 'text_delta', text: delta.text };
             } else if (delta?.type === 'thinking_delta') {
               // Forward delta for live UI; ALSO accumulate for round-trip.
@@ -422,10 +458,12 @@ export class AnthropicAdapter extends LLMAdapter {
             } else if (st.kind === 'tool_use') {
               let parsedInput = {};
               try {
-                parsedInput = st.input ? JSON.parse(st.input) : {};
+                parsedInput = st.input ? JSON.parse(st.input) : st.native.input || {};
               } catch {
                 parsedInput = {};
+                stateFailed = true;
               }
+              completedBlocks.set(idx, { ...st.native, input: parsedInput });
               yield {
                 type: 'tool_call',
                 id: st.id,
@@ -452,11 +490,15 @@ export class AnthropicAdapter extends LLMAdapter {
                 };
               }
             }
+            if (st?.kind === 'text') completedBlocks.set(idx, { ...st.native, text: st.text });
+            if (st?.kind === 'thinking') completedBlocks.set(idx, { ...st.native, thinking: st.thinking, signature: st.signature });
+            if (st?.kind === 'redacted_thinking') completedBlocks.set(idx, { type: 'redacted_thinking', data: st.data });
             blockByIndex.delete(idx);
           } else if (type === 'message_delta') {
             const stopReason = event.delta?.stop_reason;
             if (stopReason) {
-              sawStop = true;
+              // Only message_stop seals native state. EOF after message_delta
+              // must not silently complete a signed tool turn without its state.
               yield {
                 type: 'stop',
                 stopReason: this.#mapStopReason(stopReason),
@@ -469,24 +511,40 @@ export class AnthropicAdapter extends LLMAdapter {
               const nextOutputTokens = Math.max(0, Number(event.usage.output_tokens) || 0);
               const outputTokens = Math.max(0, nextOutputTokens - cumulativeOutputTokens);
               cumulativeOutputTokens = Math.max(cumulativeOutputTokens, nextOutputTokens);
+              const reasoning = reasoningUsage(event.usage, 'anthropic');
+              if (reasoning.reasoningTokens !== undefined) {
+                const next = reasoning.reasoningTokens;
+                reasoning.reasoningTokens = Math.max(0, next - cumulativeReasoningTokens);
+                cumulativeReasoningTokens = Math.max(cumulativeReasoningTokens, next);
+              }
               yield {
                 type: 'usage',
+                ...reasoning,
                 inputTokens: 0, // Only in message_start
                 outputTokens,
               };
             }
           } else if (type === 'message_stop') {
             sawStop = true;
+            if (!stateFailed && blockByIndex.size === 0) {
+              const state = createProviderState({ context, identity: requestIdentity, responseId,
+                items: [...completedBlocks].sort(([a], [b]) => a - b).map(([, block]) => block) });
+              if (state) yield { type: 'provider_state', providerState: state, providerStateBytes: providerStateBytes(state) };
+            }
           } else if (type === 'message_start') {
             sawMessageStart = true;
+            responseId = event.message?.id;
             // Usage from message_start
             if (event.message?.usage) {
               cumulativeOutputTokens = Math.max(
                 cumulativeOutputTokens,
                 Math.max(0, Number(event.message.usage.output_tokens) || 0),
               );
+              const reasoning = reasoningUsage(event.message.usage, 'anthropic');
+              cumulativeReasoningTokens = reasoning.reasoningTokens || 0;
               yield {
                 type: 'usage',
+                ...reasoning,
                 inputTokens: event.message.usage.input_tokens || 0,
                 outputTokens: cumulativeOutputTokens,
                 cacheReadTokens: event.message.usage.cache_read_input_tokens || 0,
@@ -494,6 +552,7 @@ export class AnthropicAdapter extends LLMAdapter {
               };
             }
           } else if (type === 'error') {
+            stateFailed = true;
             yield {
               type: 'error',
               error: new Error(event.error?.message || 'Unknown streaming error'),
@@ -538,14 +597,16 @@ export class AnthropicAdapter extends LLMAdapter {
    * models silently drop the param. max_tokens auto-widens to budget+1024
    * when needed.
    */
-  async call({ model, system, messages, maxTokens = 4096, effort, effortSource, effortContext, signal, onRequestStart }) {
+  async call({ model, system, messages, maxTokens = 4096, effort, effortSource, effortContext, extraBody, providerContext, requestIdentity, onProviderDiagnostics, effortConstraint = null, onEffortDecision = null, signal, onRequestStart }) {
     if (signal?.aborted) throw new LLMAbortError();
 
+    const context = providerContext || createProviderContext({ protocol: 'anthropic', baseUrl: this.#baseUrl, model });
+    const translatedMessages = this.#translateMessages(messages, context, requestIdentity);
     const body = {
       model,
       max_tokens: maxTokens,
       system,
-      messages: this.#translateMessages(messages),
+      messages: translatedMessages,
     };
 
     // task-327c: mirror stream()'s thinking injection for side queries.
@@ -553,6 +614,15 @@ export class AnthropicAdapter extends LLMAdapter {
     if ((thinkingV1Enabled() || effortSource === 'user') && normEffort) {
       applyAnthropicThinking(body, model, normEffort, effortContext);
     }
+    if (extraBody) Object.assign(body, extraBody);
+    body.model = model; // Do not let extraBody bypass origin/model ownership.
+    body.messages = translatedMessages;
+    body.system = system;
+    applyAnthropicCaching(body, context, onProviderDiagnostics);
+    const effortDecision = effortConstraint
+      ? enforceSubAgentEffortPayload(body, { model, protocol: 'anthropic', effortContext, effortConstraint })
+      : captureEffortDecision({ body, model, protocol: 'anthropic', effortContext, requested: effort, source: effortSource || 'scenario' });
+    onEffortDecision?.(effortDecision);
     const wireBody = toWellFormedJson(body);
 
     let response;
@@ -581,8 +651,10 @@ export class AnthropicAdapter extends LLMAdapter {
 
     return {
       text,
+      providerState: createProviderState({ context, identity: requestIdentity, items: result.content, responseId: result.id }),
       stopReason: this.#mapStopReason(result.stop_reason),
       usage: {
+        ...reasoningUsage(result.usage, 'anthropic'),
         inputTokens: result.usage?.input_tokens || 0,
         outputTokens: result.usage?.output_tokens || 0,
         cacheReadTokens: result.usage?.cache_read_input_tokens || 0,

package/yeaft/llm/openai-responses.js

@@ -25,6 +25,7 @@
  *   - tool_result.toolCallId ← → function_call_output.call_id (direct passthrough)
  */
 
+import { enforceSubAgentEffortPayload, captureEffortDecision } from '../effort.js';
 import {
   LLMAdapter,
   LLMRateLimitError,
@@ -50,6 +51,8 @@ import {
   mapEffortToOpenAIReasoning,
 } from '../models.js';
 
+import { createProviderContext, createProviderState, replayProviderState, providerStateBytes, applyResponsesContinuity, reasoningUsage } from './provider-state.js';
+
 const DEFAULT_BASE_URL = 'https://api.openai.com/v1';
 
 /**
@@ -163,7 +166,7 @@ export class OpenAIResponsesAdapter extends LLMAdapter {
    * Assistant tool_calls → separate { type:'function_call', call_id, name, arguments } items
    * Tool message → { type:'function_call_output', call_id, output }
    */
-  #translateInput(messages) {
+  #translateInput(messages, context, identity) {
     const input = [];
     for (const msg of messages) {
       if (msg.role === 'system') {
@@ -177,6 +180,8 @@ export class OpenAIResponsesAdapter extends LLMAdapter {
           content: this.#translateUserContent(msg.content),
         });
       } else if (msg.role === 'assistant') {
+        const native = replayProviderState(msg, context, identity);
+        if (native) { input.push(...native); continue; }
         // Emit a message item if there is text content
         if (msg.content && typeof msg.content === 'string' && msg.content.trim()) {
           input.push({
@@ -263,12 +268,14 @@ export class OpenAIResponsesAdapter extends LLMAdapter {
    * `api-key` headers are auto-redacted (see `redactRawRequest` in
    * `adapter.js`); request-body fields are caller-controlled.
    */
-  async *stream({ model, system, messages, tools, maxTokens = 16384, effort, effortSource, effortContext = {}, extraBody, signal, onRawExchange, rawExchangeMaxBytes = 512 * 1024, onRequestStart }) {
+  async *stream({ model, system, messages, tools, maxTokens = 16384, effort, effortSource, effortContext = {}, extraBody, providerContext, requestIdentity, onProviderDiagnostics, effortConstraint = null, onEffortDecision = null, signal, onRawExchange, rawExchangeMaxBytes = 512 * 1024, onRequestStart }) {
     if (signal?.aborted) throw new LLMAbortError();
 
+    const context = providerContext || createProviderContext({ protocol: 'openai-responses', baseUrl: this.#baseUrl, model });
+    const input = this.#translateInput(messages, context, requestIdentity);
     const body = {
       model,
-      input: this.#translateInput(messages),
+      input,
       stream: true,
       max_output_tokens: maxTokens,
     };
@@ -291,6 +298,12 @@ export class OpenAIResponsesAdapter extends LLMAdapter {
     }
 
     if (extraBody) Object.assign(body, extraBody);
+    body.model = model; // Origin binding must describe the actual dispatched model.
+    applyResponsesContinuity(body, { context, identity: requestIdentity, input, onProviderDiagnostics });
+    const effortDecision = effortConstraint
+      ? enforceSubAgentEffortPayload(body, { model, protocol: 'openai-responses', effortContext, effortConstraint })
+      : captureEffortDecision({ body, model, protocol: 'openai-responses', effortContext, requested: effort, source: effortSource || 'scenario' });
+    onEffortDecision?.(effortDecision);
     const wireBody = toWellFormedJson(body);
 
     const url = `${this.#baseUrl}/responses`;
@@ -334,6 +347,31 @@ export class OpenAIResponsesAdapter extends LLMAdapter {
       throw this.#classifyError(response.status, errorBody, response);
     }
 
+    if (response.headers?.get('content-type')?.includes('application/json')) {
+      const result = await response.json();
+      const items = Array.isArray(result.output) ? result.output : [];
+      for (const item of items) {
+        if (item.type === 'message') {
+          for (const part of item.content || []) if (part.type === 'output_text') yield { type: 'text_delta', text: part.text };
+        } else if (item.type === 'function_call') {
+          let input = {};
+          try { input = JSON.parse(item.arguments); } catch { /* legacy projection */ }
+          yield { type: 'tool_call', id: item.call_id, name: item.name, input };
+        }
+      }
+      if (['completed', 'incomplete'].includes(result.status)) {
+        const state = createProviderState({ context, identity: requestIdentity, items, responseId: result.id });
+        if (state) yield { type: 'provider_state', providerState: state, providerStateBytes: providerStateBytes(state) };
+      }
+      const usage = result.usage || {};
+      yield { type: 'usage', inputTokens: usage.input_tokens || 0, outputTokens: usage.output_tokens || 0,
+        cacheReadTokens: usage.input_tokens_details?.cached_tokens || 0, cacheWriteTokens: 0,
+        cacheTokensAreIncludedInInput: true,
+              ...reasoningUsage(usage, 'openai-responses') };
+      if (result.status === 'failed') throw new LLMServerError('OpenAI JSON response failed', 0);
+      yield { type: 'stop', stopReason: this.#mapStopReason(result, false) };
+      return;
+    }
     const reader = response.body.getReader();
     const decoder = new TextDecoder();
     // Incremental O(n) line splitter (see SseLineBuffer): the old
@@ -349,6 +387,8 @@ export class OpenAIResponsesAdapter extends LLMAdapter {
     /** call_ids already emitted as tool_call events (to avoid duplicating on completed fallback). */
     const emittedToolCallIds = new Set();
     let sawToolCall = false;
+    const completedItems = new Map();
+    let emittedText = false;
 
     // Keep raw SSE chunks only until the engine receives the bounded exchange
     // callback. The engine owns the configured byte budget; the adapter avoids
@@ -389,7 +429,10 @@ export class OpenAIResponsesAdapter extends LLMAdapter {
 
           const type = event.type;
 
-          if (type === 'response.output_item.added') {
+          if (sawTerminalEvent) continue;
+          if (type === 'response.output_item.done') {
+            if (Number.isInteger(event.output_index) && event.item) completedItems.set(event.output_index, event.item);
+          } else if (type === 'response.output_item.added') {
             const item = event.item;
             const idx = event.output_index;
             if (item?.type === 'function_call') {
@@ -401,6 +444,7 @@ export class OpenAIResponsesAdapter extends LLMAdapter {
             }
           } else if (type === 'response.output_text.delta') {
             if (typeof event.delta === 'string' && event.delta.length > 0) {
+              emittedText = true;
               yield { type: 'text_delta', text: event.delta };
             }
           } else if (type === 'response.function_call_arguments.delta') {
@@ -439,7 +483,12 @@ export class OpenAIResponsesAdapter extends LLMAdapter {
 
             // Fallback: flush any function_call items in the final output that we
             // didn't see a .done event for (defensive against partial streams).
-            const outputArr = Array.isArray(respObj.output) ? respObj.output : [];
+            const outputArr = Array.isArray(respObj.output) ? respObj.output : [...completedItems].sort(([a], [b]) => a - b).map(([, item]) => item);
+            if (!emittedText) {
+              for (const item of outputArr) if (item?.type === 'message') {
+                for (const part of item.content || []) if (part?.type === 'output_text') yield { type: 'text_delta', text: part.text };
+              }
+            }
             for (const item of outputArr) {
               if (item?.type !== 'function_call') continue;
               const cid = item.call_id || item.id || '';
@@ -460,6 +509,9 @@ export class OpenAIResponsesAdapter extends LLMAdapter {
               };
             }
 
+            const state = createProviderState({ context, identity: requestIdentity, items: outputArr, responseId: respObj.id });
+            if (state) yield { type: 'provider_state', providerState: state, providerStateBytes: providerStateBytes(state) };
+
             // Usage
             const usage = respObj.usage || {};
             yield {
@@ -469,6 +521,7 @@ export class OpenAIResponsesAdapter extends LLMAdapter {
               cacheReadTokens: usage.input_tokens_details?.cached_tokens || 0,
               cacheWriteTokens: 0,
               cacheTokensAreIncludedInInput: true,
+              ...reasoningUsage(usage, 'openai-responses'),
             };
 
             yield {
@@ -527,12 +580,14 @@ export class OpenAIResponsesAdapter extends LLMAdapter {
    * expose them, mirror the stream() instrumentation. Parity with
    * anthropic.js's `call()`.
    */
-  async call({ model, system, messages, maxTokens = 4096, effort, effortSource, effortContext = {}, extraBody, signal, onRequestStart }) {
+  async call({ model, system, messages, maxTokens = 4096, effort, effortSource, effortContext = {}, extraBody, providerContext, requestIdentity, onProviderDiagnostics, effortConstraint = null, onEffortDecision = null, signal, onRequestStart }) {
     if (signal?.aborted) throw new LLMAbortError();
 
+    const context = providerContext || createProviderContext({ protocol: 'openai-responses', baseUrl: this.#baseUrl, model });
+    const input = this.#translateInput(messages, context, requestIdentity);
     const body = {
       model,
-      input: this.#translateInput(messages),
+      input,
       max_output_tokens: maxTokens,
     };
     if (system) body.instructions = system;
@@ -549,6 +604,12 @@ export class OpenAIResponsesAdapter extends LLMAdapter {
     }
 
     if (extraBody) Object.assign(body, extraBody);
+    body.model = model; // Origin binding must describe the actual dispatched model.
+    applyResponsesContinuity(body, { context, identity: requestIdentity, input, onProviderDiagnostics });
+    const effortDecision = effortConstraint
+      ? enforceSubAgentEffortPayload(body, { model, protocol: 'openai-responses', effortContext, effortConstraint })
+      : captureEffortDecision({ body, model, protocol: 'openai-responses', effortContext, requested: effort, source: effortSource || 'scenario' });
+    onEffortDecision?.(effortDecision);
     const wireBody = toWellFormedJson(body);
 
     let response;
@@ -594,6 +655,8 @@ export class OpenAIResponsesAdapter extends LLMAdapter {
     const usage = result.usage || {};
     return {
       text,
+      providerState: ['completed', 'incomplete'].includes(result.status)
+        ? createProviderState({ context, identity: requestIdentity, items: result.output, responseId: result.id }) : null,
       stopReason: this.#mapStopReason(result, false),
       usage: {
         inputTokens: usage.input_tokens || 0,
@@ -601,6 +664,7 @@ export class OpenAIResponsesAdapter extends LLMAdapter {
         cacheReadTokens: usage.input_tokens_details?.cached_tokens || 0,
         cacheWriteTokens: 0,
         cacheTokensAreIncludedInInput: true,
+              ...reasoningUsage(usage, 'openai-responses'),
       },
     };
   }