@jeffusion/bungee-llms 4.6.0 → 5.1.1

package/dist/index.js

@@ -7053,7 +7053,8 @@ function readNumber(record, key) {
   if (!record) {
     return;
   }
-  return asFiniteNumber(record[key]);
+  const value = record[key];
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : undefined;
 }
 function readRecord(record, key) {
   if (!record) {
@@ -7126,7 +7127,7 @@ function clampTokens(value) {
   if (value === undefined) {
     return;
   }
-  return Math.max(0, Math.round(value));
+  return Number.isFinite(value) ? Math.min(Number.MAX_SAFE_INTEGER, Math.max(0, Math.floor(value))) : undefined;
 }
 function buildBaseEvent(state, overrides) {
   return {
@@ -7193,7 +7194,7 @@ function assertCanonicalTokenAccountingEventV2(event) {
     throw new Error("Canonical token accounting event has invalid outputAuthority.");
   }
   for (const key of ["inputTokens", "outputTokens", "cacheReadTokens", "cacheWriteTokens"]) {
-    if (event[key] !== undefined && asFiniteNumber(event[key]) === undefined) {
+    if (event[key] !== undefined && !(typeof event[key] === "number" && Number.isSafeInteger(event[key]) && event[key] >= 0)) {
       throw new Error(`Canonical token accounting event has invalid numeric field: ${key}`);
     }
   }
@@ -7204,14 +7205,11 @@ function assertCanonicalTokenAccountingEventV2(event) {
     throw new Error("Plugin aggregate fields logicalRequests/upstreamAttempts must not appear on single llms events.");
   }
   if (event.inputAuthority === "official") {
-    if (asFiniteNumber(event.inputTokens) === undefined) {
+    if (!(typeof event.inputTokens === "number" && Number.isSafeInteger(event.inputTokens) && event.inputTokens >= 0)) {
       throw new Error("Official inputAuthority requires inputTokens.");
     }
-    if (event.final && (asFiniteNumber(event.cacheReadTokens) === undefined || asFiniteNumber(event.cacheWriteTokens) === undefined)) {
-      throw new Error("Official inputAuthority requires explicit cacheReadTokens and cacheWriteTokens, even when zero.");
-    }
   }
-  if (event.outputAuthority === "official" && asFiniteNumber(event.outputTokens) === undefined) {
+  if (event.outputAuthority === "official" && !(typeof event.outputTokens === "number" && Number.isSafeInteger(event.outputTokens) && event.outputTokens >= 0)) {
     throw new Error("Official outputAuthority requires outputTokens.");
   }
 }
@@ -7271,6 +7269,444 @@ function getProviderTokenAccountingCapabilities(provider) {
   return capabilities;
 }
 // src/token-accounting/session.ts
+var DEFERRED_MEDIA_KEYS = new Set([
+  "image_url",
+  "imageUrl",
+  "inline_data",
+  "inlineData",
+  "file_data",
+  "fileData",
+  "file_uri",
+  "fileUri",
+  "file_url",
+  "fileUrl",
+  "file_id",
+  "fileId",
+  "input_audio",
+  "inputAudio",
+  "audio_url",
+  "audioUrl",
+  "input_video",
+  "inputVideo",
+  "video_url",
+  "videoUrl"
+]);
+var DEFERRED_MEDIA_TYPES = new Set([
+  "image",
+  "input_image",
+  "image_url",
+  "input_audio",
+  "audio",
+  "input_video",
+  "video",
+  "input_file",
+  "file"
+]);
+var DEFERRED_METADATA_KEYS = new Set([
+  "model",
+  "role",
+  "type",
+  "status",
+  "index",
+  "id",
+  "mime_type",
+  "mimeType",
+  "detail"
+]);
+var MAX_STREAM_ESTIMATE_CHARS = 64 * 1024;
+var MAX_STREAM_ESTIMATE_FRAGMENTS = 4096;
+var MAX_INPUT_ESTIMATE_NODES = 4096;
+var MAX_DEFERRED_MODEL_CHARS = 256;
+function isDeferred(state) {
+  return state.deferFinalization === true;
+}
+function setSessionModel(state, value) {
+  const model = asString2(value) ?? state.model ?? "unknown";
+  if (isDeferred(state) && model.length > MAX_DEFERRED_MODEL_CHARS) {
+    state.model = model.slice(0, MAX_DEFERRED_MODEL_CHARS);
+    state.requestEstimateTruncated = true;
+    return;
+  }
+  state.model = model;
+}
+function observeOutput(state, value) {
+  if (state.outputAuthority === "official")
+    return;
+  if (isDeferred(state) && typeof value === "string" && isMediaDataUri(value)) {
+    state.estimateMediaSeen = true;
+    return;
+  }
+  const text = typeof value === "string" ? value : JSON.stringify(value);
+  if (!text)
+    return;
+  const estimateState = state;
+  const remaining = MAX_STREAM_ESTIMATE_CHARS - (estimateState.estimateChars ?? 0);
+  if (remaining <= 0) {
+    estimateState.estimateTruncated = true;
+    return;
+  }
+  if ((estimateState.estimateFragments?.length ?? 0) >= MAX_STREAM_ESTIMATE_FRAGMENTS) {
+    estimateState.estimateTruncated = true;
+    return;
+  }
+  const fragment = text.slice(0, remaining);
+  (estimateState.estimateFragments ??= []).push(fragment);
+  estimateState.estimateChars = (estimateState.estimateChars ?? 0) + fragment.length;
+  if (fragment.length < text.length)
+    estimateState.estimateTruncated = true;
+}
+function observeBoundedOutput(state, value) {
+  if (state.outputAuthority === "official")
+    return;
+  if (!isDeferred(state)) {
+    if (typeof value === "string") {
+      observeOutput(state, value);
+      return;
+    }
+    const bounded = boundedRequestSnapshot({ value });
+    if (bounded.truncated)
+      state.estimateTruncated = true;
+    observeOutput(state, bounded.value.value);
+    return;
+  }
+  const estimateState = state;
+  const nodesLeft = MAX_INPUT_ESTIMATE_NODES - (estimateState.estimateNodes ?? 0);
+  if (nodesLeft < 3) {
+    estimateState.estimateTruncated = true;
+    return;
+  }
+  const bounded = typeof value === "string" ? { value: { value: value.slice(0, MAX_STREAM_ESTIMATE_CHARS) }, truncated: value.length > MAX_STREAM_ESTIMATE_CHARS, nodesCopied: 0 } : boundedRequestSnapshot({ value }, Math.max(1, Math.floor(nodesLeft / 3)));
+  estimateState.estimateNodes = (estimateState.estimateNodes ?? 0) + bounded.nodesCopied * 3;
+  const filtered = stripDeferredMedia(bounded.value.value);
+  if (bounded.truncated)
+    estimateState.estimateTruncated = true;
+  if (filtered.sawMedia)
+    estimateState.estimateMediaSeen = true;
+  if (filtered.hasContent)
+    observeOutput(state, filtered.value);
+}
+function isMediaDataUri(value) {
+  return /^data:(?:image|audio|video)\//i.test(value);
+}
+function stripDeferredMedia(value, key = "") {
+  if (key === "tools" || key === "tool_calls" || key === "tool_use" || key === "functionCall" || key === "function_call" || key === "arguments" || key === "args") {
+    return { value, sawMedia: false, hasContent: Array.isArray(value) ? value.length > 0 : value !== null && value !== undefined };
+  }
+  if (DEFERRED_MEDIA_KEYS.has(key))
+    return { value: undefined, sawMedia: true, hasContent: false };
+  if (typeof value === "string") {
+    const dataUriPattern = /data:(?:image|audio|video)\/[^\s"'<>)}\]]+/gi;
+    const stripped = value.replace(dataUriPattern, "");
+    const sawMedia = stripped.length !== value.length;
+    return { value: stripped || undefined, sawMedia, hasContent: stripped.length > 0 && !DEFERRED_METADATA_KEYS.has(key) };
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return { value, sawMedia: false, hasContent: !DEFERRED_METADATA_KEYS.has(key) };
+  }
+  if (Array.isArray(value)) {
+    let sawMedia = false;
+    let hasContent = false;
+    const result = [];
+    for (const item of value) {
+      const filtered = stripDeferredMedia(item);
+      sawMedia ||= filtered.sawMedia;
+      hasContent ||= filtered.hasContent;
+      if (filtered.value !== undefined)
+        result.push(filtered.value);
+    }
+    return { value: result, sawMedia, hasContent };
+  }
+  if (!isRecord6(value))
+    return { value, sawMedia: false, hasContent: false };
+  if (asString2(value.type) === "tool_use" || asString2(value.type) === "function_call")
+    return { value, sawMedia: false, hasContent: true };
+  if (DEFERRED_MEDIA_TYPES.has(asString2(value.type) ?? ""))
+    return { value: undefined, sawMedia: true, hasContent: false };
+  const result = {};
+  let sawMedia = false;
+  let hasContent = false;
+  for (const [childKey, child] of Object.entries(value)) {
+    const filtered = stripDeferredMedia(child, childKey);
+    sawMedia ||= filtered.sawMedia;
+    hasContent ||= filtered.hasContent;
+    if (filtered.value !== undefined)
+      result[childKey] = filtered.value;
+  }
+  return { value: result, sawMedia, hasContent };
+}
+function clearObservedOutput(state) {
+  const estimateState = state;
+  estimateState.estimateFragments = undefined;
+  estimateState.estimateChars = undefined;
+  estimateState.estimateTruncated = false;
+  estimateState.estimateMediaSeen = false;
+  estimateState.estimateNodes = 0;
+}
+function estimatedStreamOutput(state) {
+  const estimateState = state;
+  const estimateChars = estimateState.estimateChars ?? 0;
+  if (estimateChars === 0)
+    return { authority: "none" };
+  if (isDeferred(state)) {
+    const tokens = clampTokens(countTextTokens("x".repeat(estimateChars)));
+    return tokens === undefined ? { authority: "none" } : { tokens, authority: estimateState.estimateTruncated || estimateState.estimateMediaSeen ? "partial" : "heuristic" };
+  }
+  const tokens = clampTokens(countModelTextTokens(estimateState.estimateFragments.join(""), state.model));
+  return tokens === undefined ? { authority: "none" } : { tokens, authority: estimateState.estimateTruncated ? "partial" : "local" };
+}
+function finalizeMissingStreamOutput(state, interrupted = false) {
+  if (state.outputAuthority === "official")
+    return;
+  const estimate = estimatedStreamOutput(state);
+  state.outputTokens = estimate.tokens;
+  state.outputAuthority = interrupted && estimate.tokens !== undefined ? "partial" : estimate.authority;
+}
+function boundedRequestSnapshot(body, maxNodes = MAX_INPUT_ESTIMATE_NODES) {
+  let remaining = MAX_STREAM_ESTIMATE_CHARS;
+  let nodes = maxNodes;
+  let truncated = false;
+  const copy = (value) => {
+    if (nodes <= 0 || remaining <= 0) {
+      truncated = true;
+      return;
+    }
+    nodes -= 1;
+    if (typeof value === "string") {
+      if (value.length > remaining) {
+        truncated = true;
+        const clipped = value.slice(0, remaining);
+        remaining = 0;
+        return clipped;
+      }
+      remaining -= value.length;
+      return value;
+    }
+    if (value === null || typeof value === "number" || typeof value === "boolean")
+      return value;
+    if (Array.isArray(value)) {
+      const result = [];
+      for (let index = 0;index < value.length; index += 1) {
+        if (nodes <= 0 || remaining <= 0) {
+          truncated = true;
+          break;
+        }
+        result.push(copy(value[index]));
+      }
+      if (result.length < value.length)
+        truncated = true;
+      return result;
+    }
+    if (!isRecord6(value))
+      return;
+    const result = {};
+    for (const key in value) {
+      if (!Object.prototype.hasOwnProperty.call(value, key))
+        continue;
+      if (nodes <= 0 || remaining <= key.length) {
+        truncated = true;
+        break;
+      }
+      remaining -= key.length;
+      result[key] = copy(value[key]);
+    }
+    return result;
+  };
+  return { value: copy(body), truncated, nodesCopied: maxNodes - nodes };
+}
+function storeRequestForEstimate(state, body, fields) {
+  const relevant = {};
+  if (body.model !== undefined)
+    relevant.model = isDeferred(state) && typeof body.model === "string" ? body.model.slice(0, MAX_DEFERRED_MODEL_CHARS) : body.model;
+  for (const field of fields) {
+    if (Object.prototype.hasOwnProperty.call(body, field))
+      relevant[field] = body[field];
+  }
+  const bounded = boundedRequestSnapshot(relevant);
+  state.requestBody = bounded.value;
+  state.requestEstimateTruncated = bounded.truncated || typeof body.model === "string" && isDeferred(state) && body.model.length > MAX_DEFERRED_MODEL_CHARS;
+}
+function estimateMissingInput(state) {
+  if (state.estimatedInputAuthority === "official")
+    return;
+  const requestBody = state.requestBody;
+  if (!requestBody) {
+    state.estimatedInputTokens = undefined;
+    state.estimatedInputAuthority = "none";
+    return;
+  }
+  const hasInput = state.provider === "openai" ? requestBody.input !== undefined || requestBody.messages !== undefined : state.provider === "anthropic" ? requestBody.system !== undefined || requestBody.messages !== undefined : requestBody.contents !== undefined || requestBody.systemInstruction !== undefined;
+  if (!hasInput) {
+    state.estimatedInputTokens = undefined;
+    state.estimatedInputAuthority = "none";
+    return;
+  }
+  const bounded = isDeferred(state) ? { value: requestBody, truncated: false } : boundedRequestSnapshot(requestBody);
+  if (isDeferred(state)) {
+    const filtered = stripDeferredMedia(bounded.value);
+    const estimateBody = { ...filtered.value };
+    delete estimateBody.model;
+    const hasToolSchema = Array.isArray(estimateBody.tools) && estimateBody.tools.length > 0;
+    const hasContent = filtered.hasContent || hasToolSchema;
+    if (!hasContent) {
+      state.estimatedInputTokens = undefined;
+      state.estimatedInputAuthority = "none";
+      return;
+    }
+    state.estimatedInputTokens = clampTokens(countJsonLikeTokens(estimateBody));
+    state.estimatedInputAuthority = bounded.truncated || state.requestEstimateTruncated || filtered.sawMedia ? "partial" : "heuristic";
+    return;
+  }
+  const estimate = state.provider === "openai" ? estimateOpenAIInputTokens(bounded.value) : state.provider === "anthropic" ? estimateAnthropicInputTokens(bounded.value) : estimateGeminiInputTokens(bounded.value);
+  state.estimatedInputTokens = estimate;
+  state.estimatedInputAuthority = bounded.truncated || state.requestEstimateTruncated ? "partial" : "local";
+}
+function hasOpenAIOutput(body) {
+  if (Array.isArray(body.output) && body.output.length > 0)
+    return true;
+  return Array.isArray(body.choices) && body.choices.some((choice) => {
+    if (!isRecord6(choice))
+      return false;
+    const message = readRecord(choice, "message") ?? readRecord(choice, "delta");
+    return !!message && (message.content !== undefined && message.content !== null || Array.isArray(message.tool_calls) && message.tool_calls.length > 0);
+  });
+}
+function hasAnthropicOutput(body) {
+  return Array.isArray(body.content) && body.content.length > 0;
+}
+function observeAnthropicOutput(state, body) {
+  const blocks = Array.isArray(body.content) ? body.content : [];
+  for (let index = 0;index < blocks.length && index < MAX_INPUT_ESTIMATE_NODES; index += 1) {
+    observeBoundedOutput(state, blocks[index]);
+  }
+  if (blocks.length > MAX_INPUT_ESTIMATE_NODES && isDeferred(state))
+    state.estimateTruncated = true;
+}
+function hasGeminiOutput(body) {
+  return Array.isArray(body.candidates) && body.candidates.some((candidate) => {
+    const parts = readRecord(candidate, "content")?.parts;
+    return Array.isArray(parts) && parts.length > 0;
+  });
+}
+function isErrorResponse(body) {
+  const status = asString2(body.status)?.toLowerCase();
+  const type = asString2(body.type)?.toLowerCase();
+  return body.error !== undefined || status === "error" || status === "failed" || type === "error" || type?.endsWith(".error") === true || type?.endsWith(".failed") === true;
+}
+function isDeferredFailure(body) {
+  const status = asString2(body.status)?.toLowerCase();
+  const type = asString2(body.type)?.toLowerCase();
+  return isErrorResponse(body) || status === "incomplete" || type === "incomplete" || type?.endsWith(".incomplete") === true;
+}
+function observeOpenAIOutput(state, chunk, includeResponseSnapshot = true) {
+  if (state.outputAuthority === "official")
+    return;
+  let nodes = MAX_INPUT_ESTIMATE_NODES;
+  const truncated = () => {
+    if (isDeferred(state))
+      state.estimateTruncated = true;
+  };
+  const type = asString2(chunk.type);
+  if (type === "response.output_text.delta") {
+    if (isDeferred(state))
+      observeBoundedOutput(state, chunk.delta);
+    else
+      observeOutput(state, chunk.delta);
+  }
+  if (type === "response.function_call_arguments.delta") {
+    if (isDeferred(state))
+      observeBoundedOutput(state, chunk.delta);
+    else
+      observeOutput(state, chunk.delta);
+  }
+  if (includeResponseSnapshot) {
+    const response = readRecord(chunk, "response");
+    const responseOutput = Array.isArray(response?.output) ? response.output : Array.isArray(chunk.output) ? chunk.output : undefined;
+    if (responseOutput !== undefined) {
+      if (isDeferred(state)) {
+        const limit = Math.min(responseOutput.length, nodes);
+        for (let index = 0;index < limit; index += 1, nodes -= 1) {
+          observeBoundedOutput(state, responseOutput[index]);
+        }
+        if (responseOutput.length > limit)
+          truncated();
+      } else
+        observeOutput(state, responseOutput);
+    }
+  }
+  const choices = Array.isArray(chunk.choices) ? chunk.choices : [];
+  const choiceLimit = Math.min(choices.length, nodes);
+  for (let index = 0;index < choiceLimit; index += 1, nodes -= 1) {
+    const choice = choices[index];
+    if (!isRecord6(choice))
+      continue;
+    const delta = readRecord(choice, "delta") ?? (isDeferred(state) ? readRecord(choice, "message") : undefined);
+    if (delta?.content !== undefined) {
+      if (isDeferred(state))
+        observeBoundedOutput(state, delta.content);
+      else
+        observeOutput(state, delta.content);
+    }
+    const calls = Array.isArray(delta?.tool_calls) ? delta.tool_calls : [];
+    const callLimit = Math.min(calls.length, nodes);
+    for (let callIndex = 0;callIndex < callLimit; callIndex += 1, nodes -= 1) {
+      const call = calls[callIndex];
+      const fn = readRecord(call, "function");
+      if (fn?.arguments !== undefined) {
+        if (isDeferred(state))
+          observeBoundedOutput(state, fn.arguments);
+        else
+          observeOutput(state, fn.arguments);
+      }
+    }
+    if (calls.length > callLimit)
+      truncated();
+  }
+  if (choices.length > choiceLimit)
+    truncated();
+}
+function replaceObservedOutput(state) {
+  const estimateState = state;
+  estimateState.estimateFragments = [];
+  estimateState.estimateChars = 0;
+  estimateState.estimateTruncated = false;
+  estimateState.estimateMediaSeen = false;
+  estimateState.estimateNodes = 0;
+}
+function observeGeminiOutput(state, chunk) {
+  let nodes = MAX_INPUT_ESTIMATE_NODES;
+  const candidates = Array.isArray(chunk.candidates) ? chunk.candidates : [];
+  const candidateLimit = Math.min(candidates.length, nodes);
+  for (let candidateIndex = 0;candidateIndex < candidateLimit; candidateIndex += 1, nodes -= 1) {
+    const candidate = candidates[candidateIndex];
+    const content = readRecord(candidate, "content");
+    const parts = Array.isArray(content?.parts) ? content.parts : [];
+    const partLimit = Math.min(parts.length, nodes);
+    for (let partIndex = 0;partIndex < partLimit; partIndex += 1, nodes -= 1) {
+      const part = parts[partIndex];
+      if (!isRecord6(part))
+        continue;
+      if (isDeferred(state) && (part.inlineData !== undefined || part.inline_data !== undefined || part.fileData !== undefined || part.file_data !== undefined)) {
+        state.estimateMediaSeen = true;
+      }
+      if (typeof part.text === "string") {
+        if (isDeferred(state))
+          observeBoundedOutput(state, part.text);
+        else
+          observeOutput(state, part.text);
+      }
+      if (part.functionCall !== undefined) {
+        if (isDeferred(state))
+          observeBoundedOutput(state, part.functionCall);
+        else
+          observeOutput(state, part.functionCall);
+      }
+    }
+    if (parts.length > partLimit && isDeferred(state))
+      state.estimateTruncated = true;
+  }
+  if (candidates.length > candidateLimit && isDeferred(state))
+    state.estimateTruncated = true;
+}
 function countOpenAIStringTokens(value, model) {
   return countModelTextTokens(asString2(value) ?? "", model);
 }
@@ -7317,12 +7753,9 @@ function estimateOpenAIMessageTokens(message, model) {
   const toolCalls = Array.isArray(message.tool_calls) ? message.tool_calls : [];
   return 4 + countOpenAIStringTokens(message.role, model) + countOpenAIStringTokens(message.name, model) + countOpenAIStringTokens(message.tool_call_id, model) + estimateOpenAIMessageContent(content, model) + toolCalls.reduce((total, toolCall) => total + estimateOpenAIToolCallTokens(toolCall, model), 0);
 }
-function sum(values) {
-  let total = 0;
-  for (const value of values) {
-    total += value ?? 0;
-  }
-  return total;
+function safeTokenSum(...values) {
+  const total = values.reduce((sum, value) => sum + value, 0);
+  return Number.isSafeInteger(total) && total >= 0 ? total : undefined;
 }
 function estimateGeminiInlineDataTokens(inlineData) {
   const mimeType = asString2(inlineData.mimeType)?.toLowerCase() ?? "";
@@ -7343,53 +7776,6 @@ function estimateGeminiFunctionCallTokens(functionCall) {
 function estimateGeminiFunctionResponseTokens(functionResponse) {
   return 12 + countTextTokens(asString2(functionResponse.name) ?? "") + countJsonLikeTokens(functionResponse.response);
 }
-function getAnthropicSessionState(state) {
-  const anthropicState = state;
-  if (!anthropicState.anthropicContentBlocks) {
-    anthropicState.anthropicContentBlocks = new Map;
-  }
-  return anthropicState;
-}
-function tryParseJsonRecord(value) {
-  if (!value) {
-    return;
-  }
-  try {
-    const parsed = JSON.parse(value);
-    return isRecord6(parsed) ? parsed : undefined;
-  } catch {
-    return;
-  }
-}
-function estimateAnthropicContentBlockTokens(block) {
-  if (block.type === "text") {
-    return countTextTokens(block.text ?? "");
-  }
-  if (block.type === "tool_use") {
-    const parsedInput = tryParseJsonRecord(block.toolInputJson);
-    return countJsonLikeTokens({
-      type: "tool_use",
-      id: block.toolUseId,
-      name: block.toolName,
-      input: parsedInput ?? (block.toolInputJson ? { partial_json: block.toolInputJson } : {})
-    });
-  }
-  if (block.start) {
-    return countJsonLikeTokens(block.start);
-  }
-  return 0;
-}
-function updateAnthropicEstimatedOutput(state) {
-  const anthropicState = getAnthropicSessionState(state);
-  anthropicState.anthropicEstimatedOutputTokens = clampTokens(Array.from(anthropicState.anthropicContentBlocks?.values() ?? []).reduce((total, block) => {
-    return total + estimateAnthropicContentBlockTokens(block);
-  }, 0)) ?? 0;
-  if (state.outputAuthority === "partial" || state.outputAuthority === "official") {
-    return;
-  }
-  state.outputTokens = anthropicState.anthropicEstimatedOutputTokens;
-  state.outputAuthority = anthropicState.anthropicEstimatedOutputTokens > 0 ? "local" : "none";
-}
 function buildAnthropicStreamingEvent(state, overrides = {}) {
   return createPartialTokenAccountingEvent(state, {
     inputTokens: state.estimatedInputTokens,
@@ -7424,6 +7810,9 @@ function estimateOpenAIMessageContent(content, model) {
 }
 function estimateOpenAIInputTokens(body) {
   const model = asString2(body.model);
+  if (body.input !== undefined) {
+    return clampTokens(countOpenAIJsonLikeTokens(body.input, model) + 8) ?? 0;
+  }
   const messages = Array.isArray(body.messages) ? body.messages : [];
   const messageTokens = messages.reduce((total, message) => total + estimateOpenAIMessageTokens(message, model), 0);
   const tools = Array.isArray(body.tools) ? body.tools : [];
@@ -7442,12 +7831,24 @@ function estimateOpenAIResponseOutputTokens(body, model) {
     return total + countOpenAIStringTokens(message?.role ?? delta?.role, model) + countOpenAIStringTokens(message?.tool_call_id, model) + estimateOpenAIMessageContent(message?.content ?? delta?.content, model) + toolCalls.reduce((toolTotal, toolCall) => toolTotal + estimateOpenAIToolCallTokens(toolCall, model), 0) + (asString2(choice.finish_reason) === "tool_calls" ? 4 : 0);
   }, 0)) ?? 0;
 }
-function isOpenAIFinalUsageOnlyChunk(chunk) {
-  if (!readRecord(chunk, "usage")) {
-    return false;
-  }
-  const choices = Array.isArray(chunk.choices) ? chunk.choices : [];
-  return choices.length === 0;
+function openAIUsage(body) {
+  return readRecord(readRecord(body, "response"), "usage") ?? readRecord(body, "usage");
+}
+function estimateOpenAIResponsesOutputTokens(response, model) {
+  const output = Array.isArray(response.output) ? response.output : [];
+  return clampTokens(output.reduce((total, item) => {
+    if (!isRecord6(item))
+      return total + countOpenAIJsonLikeTokens(item, model);
+    const content = Array.isArray(item.content) ? item.content : [];
+    return total + content.reduce((contentTotal, part) => {
+      if (isRecord6(part) && typeof part.text === "string")
+        return contentTotal + countOpenAIStringTokens(part.text, model);
+      return contentTotal + countOpenAIJsonLikeTokens(part, model);
+    }, 0) + countOpenAIStringTokens(item.arguments, model);
+  }, 0)) ?? 0;
+}
+function isDoneSentinel(chunk) {
+  return chunk.data === "[DONE]" || chunk.type === "[DONE]";
 }
 function estimateAnthropicInputTokens(body) {
   const system = asString2(body.system) ?? "";
@@ -7505,71 +7906,193 @@ function createOpenAIAdapter() {
     provider: "openai",
     capabilities: getProviderTokenAccountingCapabilities("openai"),
     consumeRequest(state, body) {
-      state.requestBody = body;
-      state.model = asString2(body.model) ?? state.model ?? "unknown";
-      state.estimatedInputTokens = estimateOpenAIInputTokens(body);
-      state.estimatedInputAuthority = "local";
+      storeRequestForEstimate(state, body, ["input", "messages", "tools"]);
+      setSessionModel(state, body.model);
     },
     consumeResponse(state, body) {
-      const usage = readRecord(body, "usage");
-      const promptTokens = readNumber(usage, "prompt_tokens");
-      const completionTokens = readNumber(usage, "completion_tokens");
-      const promptDetails = readRecord(usage, "prompt_tokens_details");
-      const cacheReadTokens = readNumber(promptDetails, "cached_tokens") ?? 0;
+      const usage = openAIUsage(body);
+      const promptTokens = readNumber(usage, "prompt_tokens") ?? readNumber(usage, "input_tokens");
+      const completionTokens = readNumber(usage, "completion_tokens") ?? readNumber(usage, "output_tokens");
+      const responseStatus = asString2(readRecord(body, "response")?.status) ?? asString2(body.status);
+      const isIncomplete = responseStatus === "incomplete" || asString2(body.type) === "response.incomplete";
+      const isFailed = responseStatus === "failed" || asString2(body.type) === "response.failed";
+      const promptDetails = readRecord(usage, "prompt_tokens_details") ?? readRecord(usage, "input_tokens_details");
+      const cacheReadTokens = readNumber(promptDetails, "cached_tokens");
+      if (isDeferred(state)) {
+        if (promptTokens !== undefined) {
+          state.estimatedInputTokens = promptTokens;
+          state.estimatedInputAuthority = "official";
+        }
+        if (completionTokens !== undefined) {
+          state.outputTokens = completionTokens;
+          state.outputAuthority = "official";
+          clearObservedOutput(state);
+        }
+        if (cacheReadTokens !== undefined)
+          state.cacheReadTokens = cacheReadTokens;
+        if (!isIncomplete && !isFailed && !isErrorResponse(body))
+          observeOpenAIOutput(state, body);
+        state.protocolTerminalSeen = true;
+        state.deferredOutcome = isIncomplete || isFailed || isErrorResponse(body) ? "failed" : "completed";
+        return createPartialTokenAccountingEvent(state, {
+          inputTokens: state.estimatedInputTokens,
+          outputTokens: state.outputTokens,
+          cacheReadTokens: state.cacheReadTokens,
+          cacheWriteTokens: state.cacheWriteTokens,
+          inputAuthority: state.estimatedInputAuthority ?? "none",
+          outputAuthority: state.outputAuthority ?? "none"
+        });
+      }
+      if (promptTokens === undefined)
+        estimateMissingInput(state);
+      const responseHasOutput = hasOpenAIOutput(body) && !isIncomplete && !isFailed && !isErrorResponse(body);
+      const estimatedOutput = completionTokens === undefined && responseHasOutput ? Array.isArray(body.output) ? estimateOpenAIResponsesOutputTokens(body, state.model) : estimateOpenAIResponseOutputTokens(body, state.model) : undefined;
       if (promptTokens !== undefined || completionTokens !== undefined) {
         state.finalReceived = true;
         return finalizeTokenAccountingEvent(state, {
           inputTokens: promptTokens ?? state.estimatedInputTokens,
-          outputTokens: completionTokens ?? estimateOpenAIResponseOutputTokens(body, state.model),
+          outputTokens: completionTokens ?? estimatedOutput,
           cacheReadTokens,
-          cacheWriteTokens: 0,
+          cacheWriteTokens: undefined,
           inputAuthority: promptTokens !== undefined ? "official" : state.estimatedInputAuthority ?? "heuristic",
-          outputAuthority: completionTokens !== undefined ? "official" : "heuristic"
-        });
+          outputAuthority: completionTokens !== undefined ? "official" : estimatedOutput === undefined ? "none" : "local"
+        }, isIncomplete || isFailed ? "failed" : "completed");
       }
-      const outputTokens = estimateOpenAIResponseOutputTokens(body, state.model);
+      const outputTokens = estimatedOutput;
+      state.finalReceived = true;
       state.outputTokens = outputTokens;
-      state.outputAuthority = "local";
+      state.outputAuthority = outputTokens === undefined ? "none" : "local";
       return finalizeTokenAccountingEvent(state, {
         inputTokens: state.estimatedInputTokens,
         outputTokens,
-        inputAuthority: state.estimatedInputAuthority ?? "heuristic",
-        outputAuthority: "local"
-      });
+        inputAuthority: state.estimatedInputAuthority ?? "none",
+        outputAuthority: state.outputAuthority
+      }, isIncomplete || isFailed ? "failed" : "completed");
     },
     consumeStreamChunk(state, chunk) {
-      const usage = readRecord(chunk, "usage");
-      const promptTokens = readNumber(usage, "prompt_tokens");
-      const completionTokens = readNumber(usage, "completion_tokens");
-      if ((promptTokens !== undefined || completionTokens !== undefined) && isOpenAIFinalUsageOnlyChunk(chunk)) {
+      if (state.finalReceived || isDoneSentinel(chunk))
+        return null;
+      const response = readRecord(chunk, "response");
+      const usage = openAIUsage(chunk);
+      const promptTokens = readNumber(usage, "prompt_tokens") ?? readNumber(usage, "input_tokens");
+      const completionTokens = readNumber(usage, "completion_tokens") ?? readNumber(usage, "output_tokens");
+      const promptDetails = readRecord(usage, "prompt_tokens_details") ?? readRecord(usage, "input_tokens_details");
+      if (promptTokens !== undefined) {
+        state.estimatedInputTokens = promptTokens;
+        state.estimatedInputAuthority = "official";
+      }
+      if (completionTokens !== undefined) {
+        state.outputTokens = completionTokens;
+        state.outputAuthority = "official";
+        clearObservedOutput(state);
+      }
+      const reportedCache = readNumber(promptDetails, "cached_tokens");
+      if (reportedCache !== undefined)
+        state.cacheReadTokens = reportedCache;
+      const responseType = asString2(chunk.type);
+      const responseStatus = asString2(response?.status);
+      const responseCompleted = responseType === "response.completed" || responseStatus === "completed";
+      observeOpenAIOutput(state, chunk, !responseCompleted);
+      const choices = Array.isArray(chunk.choices) ? chunk.choices : [];
+      if (choices.some((choice) => isRecord6(choice) && asString2(choice.finish_reason) !== undefined && choice.finish_reason !== null)) {
+        state.protocolTerminalSeen = true;
+        if (isDeferred(state))
+          state.deferredOutcome = "completed";
+      }
+      if (isDeferred(state)) {
+        if (responseCompleted) {
+          state.deferredOutcome = "completed";
+          state.protocolTerminalSeen = true;
+          if (completionTokens === undefined && state.outputAuthority !== "official" && Array.isArray(response?.output)) {
+            replaceObservedOutput(state);
+            observeOpenAIOutput(state, { response });
+          }
+        } else if (responseType === "response.incomplete" || responseType === "response.failed" || responseStatus === "incomplete" || responseStatus === "failed") {
+          state.deferredOutcome = "failed";
+          state.protocolTerminalSeen = true;
+        }
+        return createPartialTokenAccountingEvent(state, {
+          inputTokens: state.estimatedInputTokens,
+          outputTokens: state.outputTokens,
+          cacheReadTokens: state.cacheReadTokens,
+          cacheWriteTokens: state.cacheWriteTokens,
+          inputAuthority: state.estimatedInputAuthority ?? "none",
+          outputAuthority: state.outputAuthority ?? "none"
+        });
+      }
+      if (responseCompleted) {
+        if (completionTokens === undefined && state.outputAuthority !== "official" && Array.isArray(response?.output)) {
+          replaceObservedOutput(state);
+          observeOpenAIOutput(state, { response });
+        }
+        if (completionTokens === undefined)
+          finalizeMissingStreamOutput(state);
+        if (promptTokens === undefined)
+          estimateMissingInput(state);
         state.finalReceived = true;
         return finalizeTokenAccountingEvent(state, {
           inputTokens: promptTokens ?? state.estimatedInputTokens,
-          outputTokens: completionTokens ?? state.outputTokens ?? 0,
-          cacheReadTokens: readNumber(readRecord(usage, "prompt_tokens_details"), "cached_tokens") ?? 0,
-          cacheWriteTokens: 0,
+          outputTokens: completionTokens ?? state.outputTokens,
+          cacheReadTokens: readNumber(readRecord(usage, "input_tokens_details") ?? readRecord(usage, "prompt_tokens_details"), "cached_tokens") ?? state.cacheReadTokens,
+          cacheWriteTokens: state.cacheWriteTokens,
           inputAuthority: promptTokens !== undefined ? "official" : state.estimatedInputAuthority ?? "heuristic",
-          outputAuthority: completionTokens !== undefined ? "official" : "partial"
+          outputAuthority: completionTokens !== undefined ? "official" : state.outputAuthority ?? "none"
         });
       }
-      const incrementalOutput = estimateOpenAIResponseOutputTokens(chunk, state.model);
-      if (incrementalOutput > 0) {
-        state.outputTokens = (state.outputTokens ?? 0) + incrementalOutput;
-        state.outputAuthority = "partial";
+      if (responseType === "response.incomplete" || responseType === "response.failed" || responseStatus === "incomplete" || responseStatus === "failed") {
+        state.finalReceived = true;
+        const promptDetails = readRecord(usage, "input_tokens_details") ?? readRecord(usage, "prompt_tokens_details");
+        const input = promptTokens === undefined ? undefined : promptTokens;
+        const output = completionTokens;
+        state.estimatedInputTokens = input ?? state.estimatedInputTokens;
+        state.outputTokens = output ?? state.outputTokens;
+        state.cacheReadTokens = readNumber(promptDetails, "cached_tokens") ?? state.cacheReadTokens;
+        if (output === undefined)
+          finalizeMissingStreamOutput(state);
+        if (input === undefined)
+          estimateMissingInput(state);
+        return finalizeTokenAccountingEvent(state, {
+          inputTokens: input ?? state.estimatedInputTokens,
+          outputTokens: output ?? state.outputTokens,
+          cacheReadTokens: state.cacheReadTokens,
+          cacheWriteTokens: state.cacheWriteTokens,
+          inputAuthority: input !== undefined ? "official" : state.estimatedInputAuthority ?? "heuristic",
+          outputAuthority: output !== undefined ? "official" : state.outputAuthority ?? "none"
+        }, "failed");
       }
       return createPartialTokenAccountingEvent(state, {
+        inputTokens: state.estimatedInputTokens,
         outputTokens: state.outputTokens,
-        inputAuthority: "none",
-        outputAuthority: state.outputTokens !== undefined ? "partial" : "none"
+        cacheReadTokens: state.cacheReadTokens,
+        cacheWriteTokens: state.cacheWriteTokens,
+        inputAuthority: state.estimatedInputAuthority ?? "none",
+        outputAuthority: state.outputAuthority ?? "none"
       });
     },
     finalizeAbortedStream(state) {
+      finalizeMissingStreamOutput(state, true);
+      estimateMissingInput(state);
       return finalizeTokenAccountingEvent(state, {
         inputTokens: state.estimatedInputTokens,
-        outputTokens: state.outputTokens ?? 0,
-        inputAuthority: state.estimatedInputAuthority ?? "heuristic",
-        outputAuthority: state.outputTokens !== undefined ? state.outputAuthority ?? "partial" : "heuristic"
+        outputTokens: state.outputTokens,
+        inputAuthority: state.estimatedInputAuthority ?? "none",
+        outputAuthority: state.outputAuthority ?? "none"
       }, "aborted");
+    },
+    finalizeCompletedStream(state) {
+      if (state.finalReceived)
+        return createPartialTokenAccountingEvent(state);
+      state.finalReceived = true;
+      finalizeMissingStreamOutput(state);
+      estimateMissingInput(state);
+      return finalizeTokenAccountingEvent(state, {
+        inputTokens: state.estimatedInputTokens,
+        outputTokens: state.outputTokens,
+        cacheReadTokens: state.cacheReadTokens,
+        cacheWriteTokens: state.cacheWriteTokens,
+        inputAuthority: state.estimatedInputAuthority ?? "none",
+        outputAuthority: state.outputAuthority ?? "none"
+      }, state.deferredOutcome ?? (state.protocolTerminalSeen ? "completed" : "failed"));
     }
   };
 }
@@ -7578,126 +8101,207 @@ function createAnthropicAdapter() {
     provider: "anthropic",
     capabilities: getProviderTokenAccountingCapabilities("anthropic"),
     consumeRequest(state, body) {
-      state.requestBody = body;
-      state.model = asString2(body.model) ?? state.model ?? "unknown";
-      state.estimatedInputTokens = estimateAnthropicInputTokens(body);
-      state.estimatedInputAuthority = "local";
+      storeRequestForEstimate(state, body, ["system", "messages", "tools"]);
+      setSessionModel(state, body.model);
     },
     consumeResponse(state, body) {
       const usage = readRecord(body, "usage");
       const inputTokens = readNumber(usage, "input_tokens");
       const outputTokens = readNumber(usage, "output_tokens");
-      const cacheWriteTokens = readNumber(usage, "cache_creation_input_tokens") ?? 0;
-      const cacheReadTokens = readNumber(usage, "cache_read_input_tokens") ?? 0;
-      if (inputTokens !== undefined || outputTokens !== undefined) {
+      const cacheWriteTokens = readNumber(usage, "cache_creation_input_tokens");
+      const cacheReadTokens = readNumber(usage, "cache_read_input_tokens");
+      const totalInputTokens = inputTokens === undefined ? undefined : safeTokenSum(inputTokens, cacheWriteTokens ?? 0, cacheReadTokens ?? 0);
+      if (isDeferred(state)) {
+        if (totalInputTokens !== undefined) {
+          state.estimatedInputTokens = totalInputTokens;
+          state.estimatedInputAuthority = "official";
+        }
+        if (outputTokens !== undefined) {
+          state.outputTokens = outputTokens;
+          state.outputAuthority = "official";
+          clearObservedOutput(state);
+        }
+        if (cacheReadTokens !== undefined)
+          state.cacheReadTokens = cacheReadTokens;
+        if (cacheWriteTokens !== undefined)
+          state.cacheWriteTokens = cacheWriteTokens;
+        const failed = isDeferredFailure(body);
+        if (!failed)
+          observeAnthropicOutput(state, body);
+        state.protocolTerminalSeen = true;
+        state.deferredOutcome = failed ? "failed" : "completed";
+        return createPartialTokenAccountingEvent(state, {
+          inputTokens: state.estimatedInputTokens,
+          outputTokens: state.outputTokens,
+          cacheReadTokens: state.cacheReadTokens,
+          cacheWriteTokens: state.cacheWriteTokens,
+          inputAuthority: state.estimatedInputAuthority ?? "none",
+          outputAuthority: state.outputAuthority ?? "none"
+        });
+      }
+      if (totalInputTokens === undefined)
+        estimateMissingInput(state);
+      const estimatedOutput = outputTokens === undefined && hasAnthropicOutput(body) && !isErrorResponse(body) ? estimateAnthropicOutputTokens(body) : undefined;
+      if (usage && (inputTokens !== undefined || outputTokens !== undefined || readNumber(usage, "cache_creation_input_tokens") !== undefined || readNumber(usage, "cache_read_input_tokens") !== undefined)) {
         state.finalReceived = true;
         return finalizeTokenAccountingEvent(state, {
-          inputTokens: inputTokens ?? state.estimatedInputTokens,
-          outputTokens: outputTokens ?? estimateAnthropicOutputTokens(body),
+          inputTokens: totalInputTokens ?? state.estimatedInputTokens,
+          outputTokens: outputTokens ?? estimatedOutput,
           cacheReadTokens,
           cacheWriteTokens,
-          inputAuthority: inputTokens !== undefined ? "official" : state.estimatedInputAuthority ?? "heuristic",
-          outputAuthority: outputTokens !== undefined ? "official" : "heuristic"
+          inputAuthority: totalInputTokens !== undefined ? "official" : state.estimatedInputAuthority ?? "heuristic",
+          outputAuthority: outputTokens !== undefined ? "official" : estimatedOutput === undefined ? "none" : "local"
         });
       }
       return finalizeTokenAccountingEvent(state, {
         inputTokens: state.estimatedInputTokens,
-        outputTokens: estimateAnthropicOutputTokens(body),
-        inputAuthority: state.estimatedInputAuthority ?? "heuristic",
-        outputAuthority: "local"
+        outputTokens: estimatedOutput,
+        inputAuthority: state.estimatedInputAuthority ?? "none",
+        outputAuthority: estimatedOutput === undefined ? "none" : "local"
       });
     },
     consumeStreamChunk(state, chunk) {
-      const anthropicState = getAnthropicSessionState(state);
+      if (state.finalReceived || isDoneSentinel(chunk))
+        return null;
       const type = asString2(chunk.type);
+      if (isDeferred(state) && type === "error") {
+        state.protocolTerminalSeen = true;
+        state.deferredOutcome = "failed";
+        return createPartialTokenAccountingEvent(state, {
+          inputTokens: state.estimatedInputTokens,
+          outputTokens: state.outputTokens,
+          cacheReadTokens: state.cacheReadTokens,
+          cacheWriteTokens: state.cacheWriteTokens,
+          inputAuthority: state.estimatedInputAuthority ?? "none",
+          outputAuthority: state.outputAuthority ?? "none"
+        });
+      }
       if (type === "message_start") {
         const message = readRecord(chunk, "message");
         const usage = readRecord(message, "usage");
-        state.model = asString2(message?.model) ?? state.model ?? "unknown";
-        state.estimatedInputTokens = readNumber(usage, "input_tokens") ?? state.estimatedInputTokens;
-        state.estimatedInputAuthority = state.estimatedInputTokens !== undefined ? "official" : state.estimatedInputAuthority ?? "local";
-        state.cacheWriteTokens = readNumber(usage, "cache_creation_input_tokens") ?? 0;
-        state.cacheReadTokens = readNumber(usage, "cache_read_input_tokens") ?? 0;
-        state.outputTokens = readNumber(usage, "output_tokens") ?? 0;
-        state.outputAuthority = "none";
-        anthropicState.anthropicEstimatedOutputTokens = 0;
-        anthropicState.anthropicContentBlocks?.clear();
+        setSessionModel(state, message?.model);
+        state.cacheWriteTokens = readNumber(usage, "cache_creation_input_tokens") ?? state.cacheWriteTokens;
+        state.cacheReadTokens = readNumber(usage, "cache_read_input_tokens") ?? state.cacheReadTokens;
+        const rawInputTokens = readNumber(usage, "input_tokens");
+        const totalInputTokens = rawInputTokens === undefined ? undefined : safeTokenSum(rawInputTokens, state.cacheWriteTokens ?? 0, state.cacheReadTokens ?? 0);
+        state.estimatedInputTokens = totalInputTokens ?? state.estimatedInputTokens;
+        if (totalInputTokens !== undefined)
+          state.estimatedInputAuthority = "official";
+        const initialOutputTokens = readNumber(usage, "output_tokens");
+        state.outputTokens = initialOutputTokens ?? state.outputTokens;
+        state.outputAuthority = initialOutputTokens !== undefined ? "official" : "none";
+        if (initialOutputTokens !== undefined)
+          clearObservedOutput(state);
         return buildAnthropicStreamingEvent(state, {
           inputAuthority: state.estimatedInputAuthority ?? "none",
-          outputAuthority: "none"
+          outputAuthority: state.outputAuthority
         });
       }
       if (type === "content_block_start") {
-        const index = readNumber(chunk, "index") ?? 0;
         const contentBlock = readRecord(chunk, "content_block");
-        anthropicState.anthropicContentBlocks?.set(index, {
-          type: asString2(contentBlock?.type),
-          start: contentBlock,
-          text: asString2(contentBlock?.text) ?? "",
-          toolUseId: asString2(contentBlock?.id),
-          toolName: asString2(contentBlock?.name),
-          toolInputJson: ""
-        });
-        updateAnthropicEstimatedOutput(state);
+        if (contentBlock?.text !== undefined) {
+          if (isDeferred(state))
+            observeBoundedOutput(state, contentBlock.text);
+          else
+            observeOutput(state, contentBlock.text);
+        }
         return buildAnthropicStreamingEvent(state);
       }
       if (type === "content_block_delta") {
-        const index = readNumber(chunk, "index") ?? 0;
         const delta = readRecord(chunk, "delta");
-        const block = anthropicState.anthropicContentBlocks?.get(index) ?? {};
         const deltaType = asString2(delta?.type);
         if (deltaType === "text_delta") {
-          block.type = block.type ?? "text";
-          block.text = `${block.text ?? ""}${asString2(delta?.text) ?? ""}`;
-        }
-        if (deltaType === "input_json_delta") {
-          block.type = block.type ?? "tool_use";
-          block.toolInputJson = `${block.toolInputJson ?? ""}${asString2(delta?.partial_json) ?? ""}`;
+          if (isDeferred(state))
+            observeBoundedOutput(state, delta?.text);
+          else
+            observeOutput(state, delta?.text);
         }
-        anthropicState.anthropicContentBlocks?.set(index, block);
-        updateAnthropicEstimatedOutput(state);
+        if (deltaType === "input_json_delta")
+          observeOutput(state, delta?.partial_json);
         return buildAnthropicStreamingEvent(state);
       }
       if (type === "content_block_stop") {
-        updateAnthropicEstimatedOutput(state);
         return buildAnthropicStreamingEvent(state);
       }
       if (type === "message_delta") {
         const usage = readRecord(chunk, "usage");
         const outputTokens = readNumber(usage, "output_tokens");
+        const rawInputTokens = readNumber(usage, "input_tokens");
+        if (rawInputTokens !== undefined) {
+          state.cacheWriteTokens = readNumber(usage, "cache_creation_input_tokens") ?? state.cacheWriteTokens;
+          state.cacheReadTokens = readNumber(usage, "cache_read_input_tokens") ?? state.cacheReadTokens;
+          const totalInput = safeTokenSum(rawInputTokens, state.cacheWriteTokens ?? 0, state.cacheReadTokens ?? 0);
+          state.estimatedInputTokens = totalInput ?? state.estimatedInputTokens;
+          if (totalInput !== undefined)
+            state.estimatedInputAuthority = "official";
+        }
         if (outputTokens !== undefined) {
           state.outputTokens = outputTokens;
-          state.outputAuthority = "partial";
+          state.outputAuthority = "official";
+          clearObservedOutput(state);
         }
+        state.cacheWriteTokens = readNumber(usage, "cache_creation_input_tokens") ?? state.cacheWriteTokens;
+        state.cacheReadTokens = readNumber(usage, "cache_read_input_tokens") ?? state.cacheReadTokens;
         return buildAnthropicStreamingEvent(state, {
-          outputAuthority: state.outputTokens !== undefined ? "partial" : "none"
+          outputAuthority: state.outputTokens !== undefined ? state.outputAuthority ?? "none" : "none"
         });
       }
       if (type === "message_stop") {
         if (state.finalReceived) {
           return null;
         }
+        state.protocolTerminalSeen = true;
+        if (isDeferred(state)) {
+          state.deferredOutcome ??= "completed";
+          return createPartialTokenAccountingEvent(state, {
+            inputTokens: state.estimatedInputTokens,
+            outputTokens: state.outputTokens,
+            cacheReadTokens: state.cacheReadTokens,
+            cacheWriteTokens: state.cacheWriteTokens,
+            inputAuthority: state.estimatedInputAuthority ?? "none",
+            outputAuthority: state.outputAuthority ?? "none"
+          });
+        }
         state.finalReceived = true;
+        finalizeMissingStreamOutput(state);
+        estimateMissingInput(state);
         return finalizeTokenAccountingEvent(state, {
           inputTokens: state.estimatedInputTokens,
           outputTokens: state.outputTokens,
-          cacheReadTokens: state.cacheReadTokens ?? 0,
-          cacheWriteTokens: state.cacheWriteTokens ?? 0,
+          cacheReadTokens: state.cacheReadTokens,
+          cacheWriteTokens: state.cacheWriteTokens,
           inputAuthority: state.estimatedInputAuthority ?? "none",
-          outputAuthority: state.outputAuthority === "partial" || state.outputAuthority === "official" ? "official" : state.outputAuthority ?? "none"
+          outputAuthority: state.outputAuthority ?? "none"
         });
       }
       return null;
     },
     finalizeAbortedStream(state) {
+      finalizeMissingStreamOutput(state, true);
+      estimateMissingInput(state);
       return finalizeTokenAccountingEvent(state, {
         inputTokens: state.estimatedInputTokens,
         outputTokens: state.outputTokens,
-        cacheReadTokens: state.cacheReadTokens ?? 0,
-        cacheWriteTokens: state.cacheWriteTokens ?? 0,
-        inputAuthority: state.estimatedInputAuthority ?? "heuristic",
+        cacheReadTokens: state.cacheReadTokens,
+        cacheWriteTokens: state.cacheWriteTokens,
+        inputAuthority: state.estimatedInputAuthority ?? "none",
         outputAuthority: state.outputTokens !== undefined ? state.outputAuthority ?? "partial" : "none"
       }, "aborted");
+    },
+    finalizeCompletedStream(state) {
+      if (state.finalReceived)
+        return buildAnthropicStreamingEvent(state);
+      state.finalReceived = true;
+      finalizeMissingStreamOutput(state);
+      estimateMissingInput(state);
+      return finalizeTokenAccountingEvent(state, {
+        inputTokens: state.estimatedInputTokens,
+        outputTokens: state.outputTokens,
+        cacheReadTokens: state.cacheReadTokens,
+        cacheWriteTokens: state.cacheWriteTokens,
+        inputAuthority: state.estimatedInputAuthority ?? "none",
+        outputAuthority: state.outputTokens !== undefined ? state.outputAuthority ?? "partial" : "none"
+      }, state.deferredOutcome ?? (state.protocolTerminalSeen ? "completed" : "failed"));
     }
   };
 }
@@ -7706,71 +8310,158 @@ function createGeminiAdapter() {
     provider: "gemini",
     capabilities: getProviderTokenAccountingCapabilities("gemini"),
     consumeRequest(state, body) {
-      state.requestBody = body;
-      state.model = asString2(body.model) ?? state.model ?? "unknown";
-      state.estimatedInputTokens = estimateGeminiInputTokens(body);
-      state.estimatedInputAuthority = "local";
+      storeRequestForEstimate(state, body, ["contents", "systemInstruction"]);
+      setSessionModel(state, body.model);
     },
     consumeResponse(state, body) {
       const usageMetadata = readRecord(body, "usageMetadata");
       const promptTokenCount = readNumber(usageMetadata, "promptTokenCount");
       const candidatesTokenCount = readNumber(usageMetadata, "candidatesTokenCount");
-      const cachedContentTokenCount = readNumber(usageMetadata, "cachedContentTokenCount") ?? 0;
+      const thoughtsTokenCount = readNumber(usageMetadata, "thoughtsTokenCount") ?? 0;
+      const toolUsePromptTokenCount = readNumber(usageMetadata, "toolUsePromptTokenCount") ?? 0;
+      const cachedContentTokenCount = readNumber(usageMetadata, "cachedContentTokenCount");
+      if (isDeferred(state)) {
+        const input = promptTokenCount === undefined ? undefined : safeTokenSum(promptTokenCount, toolUsePromptTokenCount);
+        const output = candidatesTokenCount === undefined ? undefined : safeTokenSum(candidatesTokenCount, thoughtsTokenCount);
+        if (input !== undefined) {
+          state.estimatedInputTokens = input;
+          state.estimatedInputAuthority = "official";
+        }
+        if (output !== undefined) {
+          state.outputTokens = output;
+          state.outputAuthority = "official";
+          clearObservedOutput(state);
+        }
+        if (cachedContentTokenCount !== undefined)
+          state.cacheReadTokens = cachedContentTokenCount;
+        const failed = isDeferredFailure(body);
+        if (!failed)
+          observeGeminiOutput(state, body);
+        state.protocolTerminalSeen = true;
+        state.deferredOutcome = failed ? "failed" : "completed";
+        return createPartialTokenAccountingEvent(state, {
+          inputTokens: state.estimatedInputTokens,
+          outputTokens: state.outputTokens,
+          cacheReadTokens: state.cacheReadTokens,
+          cacheWriteTokens: undefined,
+          inputAuthority: state.estimatedInputAuthority ?? "none",
+          outputAuthority: state.outputAuthority ?? "none"
+        });
+      }
+      if (promptTokenCount === undefined)
+        estimateMissingInput(state);
+      const estimatedOutput = candidatesTokenCount === undefined && hasGeminiOutput(body) && !isErrorResponse(body) ? estimateGeminiOutputTokens(body) : undefined;
       if (promptTokenCount !== undefined || candidatesTokenCount !== undefined) {
         state.finalReceived = true;
         return finalizeTokenAccountingEvent(state, {
-          inputTokens: promptTokenCount ?? state.estimatedInputTokens,
-          outputTokens: candidatesTokenCount ?? estimateGeminiOutputTokens(body),
+          inputTokens: promptTokenCount === undefined ? state.estimatedInputTokens : safeTokenSum(promptTokenCount, toolUsePromptTokenCount) ?? state.estimatedInputTokens,
+          outputTokens: candidatesTokenCount === undefined ? estimatedOutput : safeTokenSum(candidatesTokenCount, thoughtsTokenCount) ?? estimatedOutput,
           cacheReadTokens: cachedContentTokenCount,
-          cacheWriteTokens: 0,
-          inputAuthority: promptTokenCount !== undefined ? "official" : state.estimatedInputAuthority ?? "heuristic",
-          outputAuthority: candidatesTokenCount !== undefined ? "official" : "heuristic"
+          cacheWriteTokens: undefined,
+          inputAuthority: promptTokenCount !== undefined && safeTokenSum(promptTokenCount, toolUsePromptTokenCount) !== undefined ? "official" : state.estimatedInputAuthority ?? "heuristic",
+          outputAuthority: candidatesTokenCount !== undefined && safeTokenSum(candidatesTokenCount, thoughtsTokenCount) !== undefined ? "official" : estimatedOutput === undefined ? "none" : "local"
         });
       }
-      const outputTokens = estimateGeminiOutputTokens(body);
+      const outputTokens = estimatedOutput;
+      state.finalReceived = true;
       state.outputTokens = outputTokens;
-      state.outputAuthority = "local";
+      state.outputAuthority = outputTokens === undefined ? "none" : "local";
       return finalizeTokenAccountingEvent(state, {
         inputTokens: state.estimatedInputTokens,
         outputTokens,
-        inputAuthority: state.estimatedInputAuthority ?? "heuristic",
-        outputAuthority: "local"
+        inputAuthority: state.estimatedInputAuthority ?? "none",
+        outputAuthority: state.outputAuthority
       });
     },
     consumeStreamChunk(state, chunk) {
+      if (state.finalReceived || isDoneSentinel(chunk))
+        return null;
+      observeGeminiOutput(state, chunk);
       const usageMetadata = readRecord(chunk, "usageMetadata");
       const promptTokenCount = readNumber(usageMetadata, "promptTokenCount");
       const candidatesTokenCount = readNumber(usageMetadata, "candidatesTokenCount");
-      if (promptTokenCount !== undefined || candidatesTokenCount !== undefined) {
-        state.finalReceived = true;
-        return finalizeTokenAccountingEvent(state, {
-          inputTokens: promptTokenCount ?? state.estimatedInputTokens,
-          outputTokens: candidatesTokenCount ?? state.outputTokens,
-          cacheReadTokens: readNumber(usageMetadata, "cachedContentTokenCount") ?? 0,
-          cacheWriteTokens: 0,
-          inputAuthority: promptTokenCount !== undefined ? "official" : state.estimatedInputAuthority ?? "heuristic",
-          outputAuthority: candidatesTokenCount !== undefined ? "official" : "partial"
+      const thoughtsTokenCount = readNumber(usageMetadata, "thoughtsTokenCount") ?? 0;
+      const toolUsePromptTokenCount = readNumber(usageMetadata, "toolUsePromptTokenCount") ?? 0;
+      const reportedCacheRead = readNumber(usageMetadata, "cachedContentTokenCount");
+      const candidates = Array.isArray(chunk.candidates) ? chunk.candidates : [];
+      if (candidates.some((candidate) => isRecord6(candidate) && asString2(candidate.finishReason) !== undefined)) {
+        state.protocolTerminalSeen = true;
+        if (isDeferred(state))
+          state.deferredOutcome ??= "completed";
+      }
+      if (isDeferred(state) && isDeferredFailure(chunk)) {
+        state.protocolTerminalSeen = true;
+        state.deferredOutcome = "failed";
+      }
+      if (isDeferred(state) && reportedCacheRead !== undefined && promptTokenCount === undefined && candidatesTokenCount === undefined) {
+        state.cacheReadTokens = reportedCacheRead;
+        return createPartialTokenAccountingEvent(state, {
+          inputTokens: state.estimatedInputTokens,
+          outputTokens: state.outputTokens,
+          cacheReadTokens: state.cacheReadTokens,
+          cacheWriteTokens: undefined,
+          inputAuthority: state.estimatedInputAuthority ?? "none",
+          outputAuthority: state.outputAuthority ?? "none"
         });
       }
-      const incrementalOutput = estimateGeminiOutputTokens(chunk);
-      if (incrementalOutput > 0) {
-        state.outputTokens = sum([state.outputTokens, incrementalOutput]);
-        state.outputAuthority = "partial";
+      if (promptTokenCount !== undefined || candidatesTokenCount !== undefined) {
+        const input = promptTokenCount === undefined ? undefined : safeTokenSum(promptTokenCount, toolUsePromptTokenCount);
+        const output = candidatesTokenCount === undefined ? undefined : safeTokenSum(candidatesTokenCount, thoughtsTokenCount);
+        state.estimatedInputTokens = input ?? state.estimatedInputTokens;
+        if (input !== undefined)
+          state.estimatedInputAuthority = "official";
+        state.outputTokens = output ?? state.outputTokens;
+        if (output !== undefined) {
+          state.outputAuthority = "official";
+          clearObservedOutput(state);
+        }
+        const cacheRead = readNumber(usageMetadata, "cachedContentTokenCount");
+        if (cacheRead !== undefined)
+          state.cacheReadTokens = cacheRead;
+        return createPartialTokenAccountingEvent(state, {
+          inputTokens: state.estimatedInputTokens,
+          outputTokens: state.outputTokens,
+          cacheReadTokens: state.cacheReadTokens,
+          cacheWriteTokens: undefined,
+          inputAuthority: state.estimatedInputAuthority ?? "heuristic",
+          outputAuthority: state.outputAuthority ?? "partial"
+        });
       }
       return createPartialTokenAccountingEvent(state, {
         inputTokens: state.estimatedInputTokens,
         outputTokens: state.outputTokens,
+        cacheReadTokens: state.cacheReadTokens,
+        cacheWriteTokens: state.cacheWriteTokens,
         inputAuthority: state.estimatedInputAuthority ?? "heuristic",
-        outputAuthority: state.outputTokens !== undefined ? "partial" : "none"
+        outputAuthority: state.outputAuthority ?? (state.outputTokens !== undefined ? "partial" : "none")
       });
     },
     finalizeAbortedStream(state) {
+      finalizeMissingStreamOutput(state, true);
+      estimateMissingInput(state);
       return finalizeTokenAccountingEvent(state, {
         inputTokens: state.estimatedInputTokens,
         outputTokens: state.outputTokens,
-        inputAuthority: state.estimatedInputAuthority ?? "heuristic",
-        outputAuthority: state.outputTokens !== undefined ? "local" : "heuristic"
+        cacheReadTokens: state.cacheReadTokens,
+        cacheWriteTokens: state.cacheWriteTokens,
+        inputAuthority: state.estimatedInputAuthority ?? "none",
+        outputAuthority: state.outputAuthority ?? (state.outputTokens !== undefined ? "partial" : "none")
       }, "aborted");
+    },
+    finalizeCompletedStream(state) {
+      if (state.finalReceived)
+        return createPartialTokenAccountingEvent(state);
+      state.finalReceived = true;
+      finalizeMissingStreamOutput(state);
+      estimateMissingInput(state);
+      return finalizeTokenAccountingEvent(state, {
+        inputTokens: state.estimatedInputTokens,
+        outputTokens: state.outputTokens,
+        cacheReadTokens: state.cacheReadTokens,
+        cacheWriteTokens: state.cacheWriteTokens,
+        inputAuthority: state.estimatedInputAuthority ?? "none",
+        outputAuthority: state.outputAuthority ?? (state.outputTokens !== undefined ? "partial" : "none")
+      }, state.deferredOutcome ?? (state.protocolTerminalSeen ? "completed" : "failed"));
     }
   };
 }
@@ -7789,8 +8480,9 @@ function getProviderAdapter(provider) {
   }
   return adapter;
 }
-function createTokenAccountingSession(input) {
+function createTokenAccountingSession(input, options = {}) {
   const adapter = getProviderAdapter(input.provider);
+  let terminalEvent;
   const state = {
     provider: adapter.provider,
     routeId: input.routeId,
@@ -7799,20 +8491,38 @@ function createTokenAccountingSession(input) {
     attemptId: input.attemptId,
     streaming: input.streaming,
     model: input.model,
-    finalReceived: false
+    finalReceived: false,
+    deferFinalization: options.deferFinalization === true
   };
   return {
     consumeRequest({ body }) {
       adapter.consumeRequest(state, body);
     },
     consumeResponse({ body }) {
-      return adapter.consumeResponse(state, body);
+      const event = adapter.consumeResponse(state, body);
+      if (event.final || event.outcome !== "completed")
+        terminalEvent = event;
+      return event;
     },
     consumeStreamChunk({ chunk }) {
-      return adapter.consumeStreamChunk(state, chunk);
+      const event = adapter.consumeStreamChunk(state, chunk);
+      if (event && (event.final || event.outcome !== "completed"))
+        terminalEvent = event;
+      return event;
+    },
+    finalizeCompletedStream() {
+      if (terminalEvent)
+        return terminalEvent;
+      const event = adapter.finalizeCompletedStream(state);
+      terminalEvent = event;
+      return event;
     },
     finalizeAbortedStream() {
-      return adapter.finalizeAbortedStream(state);
+      if (terminalEvent)
+        return terminalEvent;
+      const event = adapter.finalizeAbortedStream(state);
+      terminalEvent = event;
+      return event;
     }
   };
 }