@anvia/core 1.0.0-rc.5 → 1.0.0-rc.8

package/dist/{chunk-FCANRQ5Q.js → chunk-YA2655FX.js}

@@ -3,40 +3,42 @@ import {
   parseAgentContinuation,
   parseAgentInteractionResponse,
   parseAgentQuestionPrompts
-} from "./chunk-BEU6FCTN.js";
+} from "./chunk-OJBFDBLG.js";
 import {
   isMcpTool
-} from "./chunk-7YAH2F3J.js";
+} from "./chunk-76JLMBVT.js";
 import {
   MemoryCompactionConflictError,
   MemoryCompactionError,
   assertPositiveInteger,
   createMemoryCompactionSummary,
   cumulativeCompactedMessageCount
-} from "./chunk-DNQNOHD5.js";
+} from "./chunk-5C6B6ZRH.js";
 import {
   startAgentRunObservers
-} from "./chunk-E5J4OY4K.js";
+} from "./chunk-6BBOCFHV.js";
 import {
   isSkillTool
 } from "./chunk-YK4WAAS4.js";
 import {
   isQuestionTool,
   isToolIndex
-} from "./chunk-JXZTTNCR.js";
+} from "./chunk-SJMSS5SI.js";
 import {
   ToolNotFoundError,
+  ToolOutput,
   assertFiniteMinScore,
   assertPositiveSearchLimit,
   assertToolApprovalRequirement,
   createTool,
+  normalizeToolResultOutput,
   parseToolArgs,
   prepareToolCall,
   prepareToolCallFromInput,
   retrieveDocuments,
   toolMayRequireApproval,
   toolResultContentToText
-} from "./chunk-RZDI7B6Z.js";
+} from "./chunk-EMZKPRE6.js";
 import {
   AgentRunBlockedError,
   AgentRunCancelledError,
@@ -44,36 +46,42 @@ import {
   AgentStructuredOutputError,
   AgentToolSuspensionError,
   MaxTurnsError
-} from "./chunk-TEV3OB7N.js";
+} from "./chunk-X4LK4ODN.js";
 import {
   mapWithConcurrency
 } from "./chunk-3RM57ZT2.js";
 import {
+  CompletionStreamAccumulator,
   Usage,
   assertCompletionRequestSupported,
+  assertCompletionResponseIntegrity,
   createCompletionRequest,
   getAssistantGenerationMetadata,
   isProviderTool,
   isStreamingCompletionModel,
   textFromAssistantContent
-} from "./chunk-HSA6NL2E.js";
+} from "./chunk-7PHMK7W4.js";
+import {
+  assertJsonObject
+} from "./chunk-7JLAIN6E.js";
 import {
   parseMessage,
   parseMessages,
   toProviderJsonSchema
-} from "./chunk-G5OACQEI.js";
+} from "./chunk-QGX73TSQ.js";
 import {
   isJsonValue
-} from "./chunk-SROQA7I7.js";
+} from "./chunk-3XQGVDU5.js";
 import {
   abortError,
+  completionProviderOutputErrorUsage,
   resolveRetryOptions,
   retryDelayMs,
   retryErrorAttributes,
   retryOptionsForFailure,
   throwIfAborted,
   waitForRetry
-} from "./chunk-UBE4WH6G.js";
+} from "./chunk-3RWESPUG.js";
 import {
   appendGuardrailPolicies,
   hasEnforcedOutputGuardrails,
@@ -828,388 +836,6 @@ function assertPositiveSafeInteger(value, name) {
   return value;
 }
 
-// src/internal/agent-runtime/stream-accumulator.ts
-var CompletionStreamAccumulator = class {
-  orderedParts = [];
-  textParts = /* @__PURE__ */ new Map();
-  reasoningByKey = /* @__PURE__ */ new Map();
-  reasoningKeyById = /* @__PURE__ */ new Map();
-  toolCalls = /* @__PURE__ */ new Map();
-  sources = /* @__PURE__ */ new Map();
-  providerToolCalls = /* @__PURE__ */ new Map();
-  finalResponse;
-  messageId;
-  nextTextKey = 0;
-  nextReasoningKey = 0;
-  accept(event) {
-    if (event.type === "text_delta") {
-      this.appendText(event.delta);
-      return { type: "text_delta", delta: event.delta };
-    }
-    if (event.type === "reasoning_delta") {
-      const reasoning = this.reasoningStateForEvent(event);
-      this.appendReasoning(reasoning, event);
-      return reasoningDeltaEvent(event);
-    }
-    if (event.type === "tool_call_delta") {
-      const toolCall = this.toolCallStateForId(event.id);
-      if (event.callId !== void 0 && event.callId.length > 0) toolCall.callId = event.callId;
-      if (event.name !== void 0 && event.name.length > 0) toolCall.name = event.name;
-      if (event.signature !== void 0) toolCall.signature = event.signature;
-      if (event.argumentsDelta !== void 0) {
-        if (event.argumentsMode === "replace") {
-          toolCall.argumentsText = event.argumentsDelta;
-        } else {
-          toolCall.argumentsText += event.argumentsDelta;
-        }
-      }
-      return void 0;
-    }
-    if (event.type === "tool_call") {
-      this.upsertToolCall(event.toolCall);
-      return { type: "tool_call", toolCall: event.toolCall };
-    }
-    if (event.type === "source") {
-      this.sources.set(sourceKey(event.source), event.source);
-      return { type: "source", source: event.source };
-    }
-    if (event.type === "provider_tool_call") {
-      this.providerToolCalls.set(event.toolCall.id, event.toolCall);
-      return { type: "provider_tool_call", toolCall: event.toolCall };
-    }
-    if (event.type === "message_id") {
-      this.messageId = event.id;
-      return void 0;
-    }
-    if (event.type === "final") {
-      this.finalResponse = event.response;
-      return void 0;
-    }
-    return void 0;
-  }
-  response() {
-    const accumulatedResponse = this.buildAccumulatedResponse();
-    if (this.finalResponse !== void 0) {
-      if (accumulatedResponse.choice.length === 0) {
-        return this.withAccumulatedArtifacts(this.finalResponse, accumulatedResponse);
-      }
-      return this.mergeFinalResponse(accumulatedResponse, this.finalResponse);
-    }
-    return accumulatedResponse;
-  }
-  buildAccumulatedResponse() {
-    const choice = [];
-    for (const part of this.orderedParts) {
-      if (part.type === "text") {
-        const text = this.textParts.get(part.key) ?? "";
-        if (text.length > 0) {
-          choice.push({ type: "text", text });
-        }
-        continue;
-      }
-      if (part.type === "reasoning") {
-        const reasoning = this.reasoningByKey.get(part.key);
-        if (reasoning !== void 0) {
-          choice.push(reasoningContent(reasoning));
-        }
-        continue;
-      }
-      const toolCall = this.toolCalls.get(part.key);
-      if (toolCall !== void 0) {
-        choice.push(
-          toolCallContent(toolCall, matchingFinalToolCall(toolCall, this.finalResponse?.choice))
-        );
-      }
-    }
-    const response = {
-      choice,
-      usage: Usage.empty(),
-      rawResponse: void 0
-    };
-    if (this.messageId !== void 0) {
-      response.messageId = this.messageId;
-    }
-    const sources = [...this.sources.values()];
-    if (sources.length > 0) {
-      response.sources = sources;
-    }
-    const providerToolCalls = [...this.providerToolCalls.values()];
-    if (providerToolCalls.length > 0) {
-      response.providerToolCalls = providerToolCalls;
-    }
-    return response;
-  }
-  upsertToolCall(toolCall) {
-    if (!this.toolCalls.has(toolCall.toolCallId)) {
-      this.orderedParts.push({ type: "tool_call", key: toolCall.toolCallId });
-    }
-    const partial = {
-      id: toolCall.toolCallId,
-      name: toolCall.toolName,
-      argumentsText: JSON.stringify(toolCall.input ?? {})
-    };
-    if (toolCall.callId !== void 0) {
-      partial.callId = toolCall.callId;
-    }
-    if (toolCall.signature !== void 0) {
-      partial.signature = toolCall.signature;
-    }
-    this.toolCalls.set(toolCall.toolCallId, partial);
-  }
-  mergeFinalResponse(accumulatedResponse, finalResponse) {
-    if (finalResponse.choice.length === 0) {
-      const mergedResponse = {
-        ...accumulatedResponse,
-        usage: finalResponse.usage,
-        rawResponse: finalResponse.rawResponse
-      };
-      if (finalResponse.messageId !== void 0) {
-        mergedResponse.messageId = finalResponse.messageId;
-      }
-      return this.withAccumulatedArtifacts(mergedResponse, accumulatedResponse);
-    }
-    const finalById = /* @__PURE__ */ new Map();
-    const finalByCallId = /* @__PURE__ */ new Map();
-    for (const content of finalResponse.choice) {
-      if (content.type !== "tool-call") {
-        continue;
-      }
-      finalById.set(content.toolCallId, content);
-      if (content.callId !== void 0) {
-        finalByCallId.set(content.callId, content);
-      }
-    }
-    const matchedFinalToolCalls = /* @__PURE__ */ new Set();
-    const choice = accumulatedResponse.choice.map((content) => {
-      if (content.type !== "tool-call") {
-        return content;
-      }
-      const finalToolCall = finalById.get(content.toolCallId) ?? (content.callId === void 0 ? void 0 : finalByCallId.get(content.callId));
-      if (finalToolCall === void 0) {
-        return content;
-      }
-      matchedFinalToolCalls.add(finalToolCall);
-      return mergeFinalToolCall(content, finalToolCall);
-    });
-    for (const content of finalResponse.choice) {
-      if (content.type !== "tool-call") {
-        continue;
-      }
-      if (!matchedFinalToolCalls.has(content)) {
-        choice.push(content);
-      }
-    }
-    return this.withAccumulatedArtifacts({ ...finalResponse, choice }, accumulatedResponse);
-  }
-  appendText(delta) {
-    const lastPart = this.orderedParts.at(-1);
-    const key = lastPart?.type === "text" ? lastPart.key : this.createTextKey();
-    if (lastPart?.type !== "text") {
-      this.orderedParts.push({ type: "text", key });
-    }
-    this.textParts.set(key, `${this.textParts.get(key) ?? ""}${delta}`);
-  }
-  reasoningStateForEvent(event) {
-    if (event.id !== void 0) {
-      const existingKey = this.reasoningKeyById.get(event.id);
-      if (existingKey !== void 0) {
-        const existing = this.reasoningByKey.get(existingKey);
-        if (existing !== void 0) {
-          return existing;
-        }
-      }
-      const key2 = this.createReasoningKey();
-      const reasoning2 = { id: event.id, text: "" };
-      this.reasoningKeyById.set(event.id, key2);
-      this.reasoningByKey.set(key2, reasoning2);
-      this.orderedParts.push({ type: "reasoning", key: key2 });
-      return reasoning2;
-    }
-    const lastPart = this.orderedParts.at(-1);
-    if (lastPart?.type === "reasoning") {
-      const lastReasoning = this.reasoningByKey.get(lastPart.key);
-      if (lastReasoning !== void 0 && lastReasoning.id === void 0) {
-        return lastReasoning;
-      }
-    }
-    const key = this.createReasoningKey();
-    const reasoning = { text: "" };
-    this.reasoningByKey.set(key, reasoning);
-    this.orderedParts.push({ type: "reasoning", key });
-    return reasoning;
-  }
-  toolCallStateForId(id) {
-    const existing = this.toolCalls.get(id);
-    if (existing !== void 0) {
-      return existing;
-    }
-    const toolCall = {
-      id,
-      name: "",
-      argumentsText: ""
-    };
-    this.toolCalls.set(id, toolCall);
-    this.orderedParts.push({ type: "tool_call", key: id });
-    return toolCall;
-  }
-  withMessageIdFallback(response, accumulatedResponse) {
-    if (response.messageId !== void 0 || accumulatedResponse.messageId === void 0) {
-      return response;
-    }
-    return { ...response, messageId: accumulatedResponse.messageId };
-  }
-  withAccumulatedArtifacts(response, accumulatedResponse) {
-    const withMessageId = this.withMessageIdFallback(response, accumulatedResponse);
-    const sources = mergeSources(accumulatedResponse.sources, response.sources);
-    const providerToolCalls = mergeProviderToolCalls(
-      accumulatedResponse.providerToolCalls,
-      response.providerToolCalls
-    );
-    let accumulated = { ...withMessageId };
-    if (sources.length > 0) accumulated = { ...accumulated, sources };
-    if (providerToolCalls.length > 0) {
-      accumulated = { ...accumulated, providerToolCalls };
-    }
-    return accumulated;
-  }
-  createTextKey() {
-    this.nextTextKey += 1;
-    return `text_${this.nextTextKey.toString()}`;
-  }
-  createReasoningKey() {
-    this.nextReasoningKey += 1;
-    return `reasoning_${this.nextReasoningKey.toString()}`;
-  }
-  appendReasoning(reasoning, event) {
-    const contentType = event.contentType ?? "text";
-    if (contentType === "text" || contentType === "summary") {
-      reasoning.text += event.delta;
-    }
-    if (event.contentType === void 0 && event.signature === void 0) {
-      return;
-    }
-    reasoning.details ??= [];
-    const last = reasoning.details.at(-1);
-    if (contentType === "text") {
-      if (last?.type === "text") {
-        let detail = {
-          ...last,
-          text: `${last.text}${event.delta}`
-        };
-        if (event.signature !== void 0) detail = { ...detail, signature: event.signature };
-        reasoning.details[reasoning.details.length - 1] = detail;
-      } else {
-        reasoning.details.push(
-          event.signature === void 0 ? { type: "text", text: event.delta } : { type: "text", text: event.delta, signature: event.signature }
-        );
-      }
-      return;
-    }
-    if (contentType === "summary") {
-      if (last?.type === "summary") {
-        reasoning.details[reasoning.details.length - 1] = {
-          ...last,
-          text: `${last.text}${event.delta}`
-        };
-      } else {
-        reasoning.details.push({ type: "summary", text: event.delta });
-      }
-      return;
-    }
-    if (contentType === "encrypted") {
-      reasoning.details.push({ type: "encrypted", data: event.delta });
-      return;
-    }
-    reasoning.details.push({ type: "redacted", data: event.delta });
-  }
-};
-function sourceKey(source) {
-  return `${source.url}\0${source.startIndex ?? ""}\0${source.endIndex ?? ""}`;
-}
-function mergeSources(accumulated, final) {
-  const sources = /* @__PURE__ */ new Map();
-  for (const source of [...accumulated ?? [], ...final ?? []]) {
-    sources.set(sourceKey(source), source);
-  }
-  return [...sources.values()];
-}
-function mergeProviderToolCalls(accumulated, final) {
-  const toolCalls = /* @__PURE__ */ new Map();
-  for (const toolCall of [...accumulated ?? [], ...final ?? []]) {
-    toolCalls.set(toolCall.id, toolCall);
-  }
-  return [...toolCalls.values()];
-}
-function reasoningContent(reasoning) {
-  const content = reasoning.details === void 0 ? { type: "reasoning", text: reasoning.text } : { type: "reasoning", text: reasoning.text, details: reasoning.details };
-  return reasoning.id === void 0 ? content : { ...content, id: reasoning.id };
-}
-function toolCallContent(toolCall, finalToolCall) {
-  const argumentsValue = finalToolCall !== void 0 && !isEmptyToolArguments(finalToolCall.input) ? finalToolCall.input : parseToolArguments(toolCall.id, toolCall.argumentsText);
-  let content = {
-    type: "tool-call",
-    toolCallId: toolCall.id,
-    toolName: toolCall.name,
-    input: argumentsValue
-  };
-  if (toolCall.callId !== void 0) content = { ...content, callId: toolCall.callId };
-  if (toolCall.signature !== void 0) content = { ...content, signature: toolCall.signature };
-  return content;
-}
-function matchingFinalToolCall(accumulated, finalChoice) {
-  const byId = finalChoice?.find(
-    (content) => content.type === "tool-call" && content.toolCallId === accumulated.id
-  );
-  if (byId !== void 0 || accumulated.callId === void 0) {
-    return byId;
-  }
-  return finalChoice?.find(
-    (content) => content.type === "tool-call" && content.callId === accumulated.callId
-  );
-}
-function mergeFinalToolCall(accumulated, finalToolCall) {
-  const input = isEmptyToolArguments(finalToolCall.input) ? accumulated.input : finalToolCall.input;
-  return {
-    ...accumulated,
-    ...finalToolCall,
-    input
-  };
-}
-function reasoningDeltaEvent(event) {
-  const mapped = { type: "reasoning_delta", delta: event.delta };
-  if (event.id !== void 0) mapped.id = event.id;
-  if (event.contentType !== void 0) mapped.contentType = event.contentType;
-  if (event.signature !== void 0) mapped.signature = event.signature;
-  return mapped;
-}
-function isEmptyToolArguments(value) {
-  if (value === void 0 || value === null) {
-    return true;
-  }
-  if (typeof value === "string") {
-    return value.trim().length === 0;
-  }
-  if (Array.isArray(value)) {
-    return value.length === 0;
-  }
-  if (typeof value === "object") {
-    return Object.values(value).every((item) => item === void 0);
-  }
-  return false;
-}
-function parseToolArguments(toolCallId, text) {
-  if (text.trim().length === 0) {
-    return {};
-  }
-  try {
-    return JSON.parse(text);
-  } catch {
-    throw new Error(
-      `Completion returned tool call "${toolCallId}" with malformed JSON arguments; this indicates invalid provider output or incomplete stream assembly.`
-    );
-  }
-}
-
 // src/internal/agent-runtime/stream-events.ts
 function addTurn(turn, event) {
   if (event.type === "text_delta") {
@@ -1254,6 +880,21 @@ var UNLABELED_FENCE_START = "```\n";
 var UNLABELED_FENCE_CRLF_START = "```\r\n";
 var FENCE_END = "\n```";
 var STRUCTURED_OUTPUT_RETRY_PROMPT = "Your previous response was invalid structured output. Return only raw JSON that matches the supplied JSON schema. Do not use Markdown fences or include commentary.";
+var STRUCTURED_OUTPUT_TRUNCATED_RETRY_PROMPT = "Your previous response exceeded the provider output limit. Return substantially shorter raw JSON that matches the supplied JSON schema. Do not use Markdown fences or include commentary.";
+var STRUCTURED_OUTPUT_REPAIR_PREVIEW_MAX_LENGTH = 8192;
+var STRUCTURED_OUTPUT_REPAIR_PREVIEW_MARKER = "\n...[output omitted]...\n";
+function structuredOutputRepairPreview(text) {
+  if (text.length <= STRUCTURED_OUTPUT_REPAIR_PREVIEW_MAX_LENGTH) {
+    return { text, includedOutputLength: text.length };
+  }
+  const availableLength = STRUCTURED_OUTPUT_REPAIR_PREVIEW_MAX_LENGTH - STRUCTURED_OUTPUT_REPAIR_PREVIEW_MARKER.length;
+  const headLength = Math.ceil(availableLength / 2);
+  const tailLength = availableLength - headLength;
+  return {
+    text: `${text.slice(0, headLength)}${STRUCTURED_OUTPUT_REPAIR_PREVIEW_MARKER}${text.slice(-tailLength)}`,
+    includedOutputLength: headLength + tailLength
+  };
+}
 function normalizeStructuredOutput(text) {
   const trimmed = text.trim();
   const opening = fenceOpening(trimmed);
@@ -1307,13 +948,13 @@ var ToolCallExecutor = class {
   abortSignal;
   cancel;
   async execute(toolCalls, onResult, onStreamEvent, observation) {
-    for (const toolCall of toolCalls) {
-      if (toolCall.toolName.length === 0) {
-        throw new Error(
-          `Completion returned tool call "${toolCall.toolCallId}" with an empty tool name; this indicates invalid provider output or provider mapping.`
-        );
+    assertCompletionResponseIntegrity({
+      response: {
+        choice: [...toolCalls],
+        usage: Usage.empty(),
+        rawResponse: void 0
       }
-    }
+    });
     const executeOne = async (toolCall) => {
       throwIfAborted(this.abortSignal);
       const args = JSON.stringify(toolCall.input);
@@ -1932,7 +1573,14 @@ var ToolCallExecutor = class {
         args: current
       });
       if (replacement?.args !== void 0) {
-        current = typeof replacement.args === "string" ? replacement.args : JSON.stringify(replacement.args);
+        if (typeof replacement.args === "string") {
+          current = replacement.args;
+        } else {
+          if (!isJsonValue(replacement.args)) {
+            throw new TypeError("Tool input middleware args must be a strict JSON value.");
+          }
+          current = JSON.stringify(replacement.args);
+        }
       }
     }
     return current;
@@ -2024,20 +1672,51 @@ function createApprovalContext(input, hookArgs, agent, run) {
   return context;
 }
 function approvalEventAttributes(request, turn) {
-  return {
+  const attributes = {
     turn,
     approvalId: request.id,
     toolName: request.toolName,
-    toolCallId: request.toolCallId,
-    internalCallId: request.internalCallId,
-    reason: request.reason
+    internalCallId: request.internalCallId
   };
+  if (request.toolCallId !== void 0) attributes.toolCallId = request.toolCallId;
+  if (request.reason !== void 0) attributes.reason = request.reason;
+  return attributes;
 }
 function normalizeToolOutputMiddlewareResult(result) {
   if (typeof result === "string") {
     return { result };
   }
-  return result ?? {};
+  if (typeof result !== "object" || result === null) {
+    throw new TypeError("Tool output middleware must return text or structured content.");
+  }
+  const prototype = Object.getPrototypeOf(result);
+  if (prototype !== Object.prototype && prototype !== null) {
+    throw new TypeError("Tool output middleware must return text or structured content.");
+  }
+  const keys = Reflect.ownKeys(result);
+  const hasResult = keys.includes("result");
+  const hasStructuredResult = keys.includes("structuredResult");
+  if (hasResult === hasStructuredResult || keys.some((key) => key !== "result" && key !== "structuredResult")) {
+    throw new TypeError(
+      "Tool output middleware must return exactly one of result or structuredResult."
+    );
+  }
+  if (hasResult) {
+    const descriptor2 = Object.getOwnPropertyDescriptor(result, "result");
+    if (descriptor2 === void 0 || !("value" in descriptor2) || typeof descriptor2.value !== "string") {
+      throw new TypeError("Tool output middleware result must be a string.");
+    }
+    return { result: descriptor2.value };
+  }
+  const descriptor = Object.getOwnPropertyDescriptor(result, "structuredResult");
+  if (descriptor === void 0 || !("value" in descriptor)) {
+    throw new TypeError("Tool output middleware structuredResult must be valid tool content.");
+  }
+  const normalized = normalizeToolResultOutput(ToolOutput.content(descriptor.value));
+  if (normalized.type !== "content") {
+    throw new TypeError("Tool output middleware structuredResult must be valid tool content.");
+  }
+  return { structuredResult: normalized.value };
 }
 function toolTraceMetadata(tool) {
   if (tool === void 0) {
@@ -2317,13 +1996,19 @@ var AgentRun = class _AgentRun {
       pendingTurnMessages = this.memoryRecorder.pendingTurnMessages(newMessages);
       await this.runRunStartHook(newMessages);
       if (this.continuationState !== void 0) {
+        const interactionAttributes = {};
+        if (this.resumedFrom?.runId !== void 0) {
+          interactionAttributes.sourceRunId = this.resumedFrom.runId;
+        }
+        if (this.resumedFrom?.interactionId !== void 0) {
+          interactionAttributes.interactionId = this.resumedFrom.interactionId;
+        }
+        if (this.interactionResponse?.type !== void 0) {
+          interactionAttributes.interactionType = this.interactionResponse.type;
+        }
         await runObservers.event({
           name: "agent.interaction_response",
-          attributes: {
-            sourceRunId: this.resumedFrom?.runId,
-            interactionId: this.resumedFrom?.interactionId,
-            interactionType: this.interactionResponse?.type
-          }
+          attributes: interactionAttributes
         });
         try {
           const toolResults = await this.resolveContinuationTools(
@@ -2378,6 +2063,13 @@ var AgentRun = class _AgentRun {
           throw error;
         }
         response = await this.runCompletionResponseMiddlewares(request, response, currentTurns);
+        try {
+          assertCompletionResponseIntegrity({ response });
+        } catch (error) {
+          const providerOutputUsage = completionProviderOutputErrorUsage(error);
+          if (providerOutputUsage !== void 0) usage = Usage.add(usage, providerOutputUsage);
+          throw error;
+        }
         usage = Usage.add(usage, response.usage);
         this.updateRunProgress(newMessages);
         await this.runCompletionResponseHook(prompt, response, newMessages);
@@ -2729,6 +2421,13 @@ var AgentRun = class _AgentRun {
         this.activeGeneration = void 0;
         await generationObservers.end(generationEndArgs);
         response = await this.runCompletionResponseMiddlewares(request, response, currentTurns);
+        try {
+          assertCompletionResponseIntegrity({ response });
+        } catch (error) {
+          const providerOutputUsage = completionProviderOutputErrorUsage(error);
+          if (providerOutputUsage !== void 0) usage = Usage.add(usage, providerOutputUsage);
+          throw error;
+        }
         usage = Usage.add(usage, response.usage);
         this.updateRunProgress(newMessages);
         await this.runCompletionResponseHook(prompt, response, newMessages);
@@ -2906,14 +2605,20 @@ var AgentRun = class _AgentRun {
       this.generationStartArgs(turn, request, providerRequest)
     );
     let currentRequest = request;
-    let structuredRetryUsage = Usage.empty();
+    let failedAttemptUsage = Usage.empty();
     try {
       for (let attempt = 1; ; attempt += 1) {
         let response;
         try {
           this.throwIfCancelled();
           response = await this.agent.model.completion(currentRequest, this.modelCallOptions());
+          assertCompletionResponseIntegrity({ response });
         } catch (error) {
+          const attemptUsage = completionProviderOutputErrorUsage(error);
+          if (attemptUsage !== void 0) {
+            failedAttemptUsage = Usage.add(failedAttemptUsage, attemptUsage);
+            this.failedCompletionUsage = failedAttemptUsage;
+          }
           const retryOptions = this.retryOptionsForFailure(error, attempt, turn, false);
           if (retryOptions === void 0) {
             throw error;
@@ -2924,11 +2629,12 @@ var AgentRun = class _AgentRun {
             turn,
             false,
             retryOptions,
-            runObservers
+            runObservers,
+            providerOutputRetryEventAttributes(error, failedAttemptUsage)
           );
           continue;
         }
-        const cumulativeUsage = Usage.add(structuredRetryUsage, response.usage);
+        const cumulativeUsage = Usage.add(failedAttemptUsage, response.usage);
         try {
           this.validateStructuredResponse(response, attempt, cumulativeUsage);
         } catch (error) {
@@ -2936,20 +2642,22 @@ var AgentRun = class _AgentRun {
           if (retryOptions === void 0) {
             throw error;
           }
-          structuredRetryUsage = cumulativeUsage;
-          this.failedCompletionUsage = structuredRetryUsage;
-          currentRequest = structuredOutputRetryRequest(currentRequest, response);
+          failedAttemptUsage = cumulativeUsage;
+          this.failedCompletionUsage = failedAttemptUsage;
+          const retryRequest = structuredOutputRetryRequest(request, response, error);
+          currentRequest = retryRequest.request;
           await this.scheduleCompletionRetry(
             error,
             attempt,
             turn,
             false,
             retryOptions,
-            runObservers
+            runObservers,
+            structuredOutputRetryEventAttributes(error, retryRequest)
           );
           continue;
         }
-        const finalResponse = structuredRetryUsage.totalTokens === 0 ? response : { ...response, usage: cumulativeUsage };
+        const finalResponse = Usage.isEmpty(failedAttemptUsage) ? response : { ...response, usage: cumulativeUsage };
         await generationObservers.end({ turn, response: finalResponse });
         this.failedCompletionUsage = Usage.empty();
         return finalResponse;
@@ -2986,20 +2694,28 @@ var AgentRun = class _AgentRun {
     for (let attempt = 1; ; attempt += 1) {
       const accumulator = new CompletionStreamAccumulator();
       let hasProviderProgress = false;
+      let recordedErrorUsage = false;
+      let attemptErrorUsage;
       try {
         this.throwIfCancelled();
         for await (const event of model.streamCompletion(currentRequest, this.modelCallOptions())) {
           if (event.type === "error") {
-            if (event.usage !== void 0) {
-              args.state.providerErrorUsage = Usage.add(args.state.providerErrorUsage, event.usage);
+            const eventUsage = event.usage ?? completionProviderOutputErrorUsage(event.error);
+            if (eventUsage !== void 0) {
+              args.state.providerErrorUsage = Usage.add(args.state.providerErrorUsage, eventUsage);
+              recordedErrorUsage = true;
+              attemptErrorUsage = eventUsage;
             }
             throw event.error;
           }
-          hasProviderProgress = true;
+          const mapped = accumulator.accept(event);
+          if (event.type === "final") break;
+          if (event.type === "tool_call_delta" || mapped !== void 0) {
+            hasProviderProgress = true;
+          }
           if (args.state.firstDeltaMs === void 0 && isGenerationDeltaEvent(event.type)) {
             args.state.firstDeltaMs = Date.now() - args.generationStartedAt;
           }
-          const mapped = accumulator.accept(event);
           if (event.type === "tool_call_delta") {
             yield addTurnToToolCallDelta(args.turn, event);
           }
@@ -3015,6 +2731,7 @@ var AgentRun = class _AgentRun {
           }
         }
         const response = accumulator.response();
+        assertCompletionResponseIntegrity({ response });
         const cumulativeStructuredUsage = Usage.add(args.state.providerErrorUsage, response.usage);
         try {
           this.validateStructuredResponse(response, attempt, cumulativeStructuredUsage);
@@ -3029,21 +2746,30 @@ var AgentRun = class _AgentRun {
           args.state.providerErrorUsage = Usage.add(args.state.providerErrorUsage, response.usage);
           args.state.firstDeltaMs = void 0;
           args.state.emittedToolCallIds.clear();
-          currentRequest = structuredOutputRetryRequest(currentRequest, response);
+          const retryRequest = structuredOutputRetryRequest(args.request, response, error);
+          currentRequest = retryRequest.request;
           await this.scheduleCompletionRetry(
             error,
             attempt,
             args.turn,
             true,
             retryOptions,
-            args.runObservers
+            args.runObservers,
+            structuredOutputRetryEventAttributes(error, retryRequest)
           );
           continue;
         }
-        args.state.response = args.state.providerErrorUsage.totalTokens === 0 ? response : { ...response, usage: cumulativeStructuredUsage };
+        args.state.response = Usage.isEmpty(args.state.providerErrorUsage) ? response : { ...response, usage: cumulativeStructuredUsage };
         args.state.providerErrorUsage = Usage.empty();
         return;
       } catch (error) {
+        if (!recordedErrorUsage) {
+          const attemptUsage = completionProviderOutputErrorUsage(error);
+          if (attemptUsage !== void 0) {
+            args.state.providerErrorUsage = Usage.add(args.state.providerErrorUsage, attemptUsage);
+            attemptErrorUsage = attemptUsage;
+          }
+        }
         const retryOptions = hasProviderProgress ? void 0 : this.retryOptionsForFailure(error, attempt, args.turn, true);
         if (retryOptions === void 0) {
           throw error;
@@ -3054,7 +2780,12 @@ var AgentRun = class _AgentRun {
           args.turn,
           true,
           retryOptions,
-          args.runObservers
+          args.runObservers,
+          providerOutputRetryEventAttributes(
+            error,
+            args.state.providerErrorUsage,
+            attemptErrorUsage
+          )
         );
       }
     }
@@ -3180,6 +2911,10 @@ var AgentRun = class _AgentRun {
       modelId: this.agent.model.modelId,
       usage: { ...response.usage }
     };
+    if (response.finishReason !== void 0) generation.finishReason = response.finishReason;
+    if (response.providerFinishReason !== void 0) {
+      generation.providerFinishReason = response.providerFinishReason;
+    }
     if (response.contextUsage !== void 0) generation.contextUsage = response.contextUsage;
     if (response.sources !== void 0) generation.sources = response.sources;
     if (response.providerToolCalls !== void 0) {
@@ -3225,20 +2960,24 @@ var AgentRun = class _AgentRun {
       streaming
     });
   }
-  async scheduleCompletionRetry(error, attempt, turn, streaming, options, runObservers) {
+  async scheduleCompletionRetry(error, attempt, turn, streaming, options, runObservers, additionalAttributes) {
     const delayMs = retryDelayMs(options, attempt);
+    const attributes = {
+      turn,
+      attempt,
+      nextAttempt: attempt + 1,
+      maxAttempts: options.maxAttempts,
+      delayMs,
+      streaming,
+      ...retryErrorAttributes(error)
+    };
+    if (additionalAttributes !== void 0) {
+      Object.assign(attributes, additionalAttributes);
+    }
     await runObservers.event({
       name: "completion.retry",
       level: "WARNING",
-      attributes: {
-        turn,
-        attempt,
-        nextAttempt: attempt + 1,
-        maxAttempts: options.maxAttempts,
-        delayMs,
-        streaming,
-        ...retryErrorAttributes(error)
-      }
+      attributes
     });
     await waitForRetry(delayMs, this.abortController.signal);
   }
@@ -3476,7 +3215,41 @@ var AgentRun = class _AgentRun {
     if (this.agent.outputSchema === void 0) return;
     if (response.choice.some((item) => item.type === "tool-call")) return;
     const text = textFromAssistantContent(response.choice);
-    const output = this.parseOutput(text, attempt, usage, { useValidatedOutput: false });
+    const normalized = normalizeStructuredOutput(text);
+    if (response.finishReason === "content-filter") {
+      throw new AgentStructuredOutputError({
+        phase: "content-filter",
+        attempt,
+        maxAttempts: this.completionRetryOptions?.maxAttempts ?? 1,
+        outputLength: text.length,
+        normalizedLength: normalized.text.length,
+        outputFormat: normalized.format,
+        attemptUsage: response.usage,
+        usage,
+        finishReason: response.finishReason,
+        providerFinishReason: response.providerFinishReason
+      });
+    }
+    if (response.finishReason === "length") {
+      throw new AgentStructuredOutputError({
+        phase: "truncated",
+        attempt,
+        maxAttempts: this.completionRetryOptions?.maxAttempts ?? 1,
+        outputLength: text.length,
+        normalizedLength: normalized.text.length,
+        outputFormat: normalized.format,
+        attemptUsage: response.usage,
+        usage,
+        finishReason: response.finishReason,
+        providerFinishReason: response.providerFinishReason
+      });
+    }
+    const output = this.parseOutput(text, attempt, usage, {
+      useValidatedOutput: false,
+      attemptUsage: response.usage,
+      finishReason: response.finishReason,
+      providerFinishReason: response.providerFinishReason
+    });
     this.validatedStructuredOutput = { text, output };
   }
   takeFailedCompletionUsage() {
@@ -3495,6 +3268,9 @@ var AgentRun = class _AgentRun {
     let json;
     try {
       json = JSON.parse(normalized.text);
+      if (!isJsonValue(json)) {
+        throw new TypeError("Agent structured output is not a JSON value.");
+      }
     } catch (error) {
       throw new AgentStructuredOutputError({
         phase: "parse",
@@ -3503,7 +3279,10 @@ var AgentRun = class _AgentRun {
         outputLength: text.length,
         normalizedLength: normalized.text.length,
         outputFormat: normalized.format,
+        attemptUsage: options.attemptUsage ?? usage,
         usage,
+        finishReason: options.finishReason,
+        providerFinishReason: options.providerFinishReason,
         cause: error
       });
     }
@@ -3517,7 +3296,10 @@ var AgentRun = class _AgentRun {
         outputLength: text.length,
         normalizedLength: normalized.text.length,
         outputFormat: normalized.format,
+        attemptUsage: options.attemptUsage ?? usage,
         usage,
+        finishReason: options.finishReason,
+        providerFinishReason: options.providerFinishReason,
         cause: error
       });
     }
@@ -3667,6 +3449,9 @@ var AgentRun = class _AgentRun {
       });
       if (replacement?.request !== void 0) {
         current = replacement.request;
+        if (current.providerOptions !== void 0) {
+          assertJsonObject(current.providerOptions, "providerOptions");
+        }
       }
     }
     return current;
@@ -3951,14 +3736,14 @@ function responseStreamEvents(turn, response, includeProviderArtifacts = true) {
     if (item.type === "reasoning") {
       if (item.details === void 0) {
         if (item.text.length > 0) {
-          events.push(reasoningDeltaEvent2(turn, item.text, { id: item.id }));
+          events.push(reasoningDeltaEvent(turn, item.text, { id: item.id }));
         }
         continue;
       }
       for (const content of item.details) {
         const delta = content.type === "encrypted" || content.type === "redacted" ? content.data : content.text;
         events.push(
-          reasoningDeltaEvent2(turn, delta, {
+          reasoningDeltaEvent(turn, delta, {
             id: item.id,
             contentType: content.type,
             signature: content.type === "text" ? content.signature : void 0
@@ -3984,10 +3769,14 @@ function responseStreamEvents(turn, response, includeProviderArtifacts = true) {
 function generationArtifacts(messages) {
   const sources = /* @__PURE__ */ new Map();
   const providerToolCalls = /* @__PURE__ */ new Map();
+  let finishReason;
+  let providerFinishReason;
   let contextUsage;
   for (const message of messages) {
     const metadata = getAssistantGenerationMetadata(message);
     if (metadata !== void 0) {
+      finishReason = metadata.finishReason;
+      providerFinishReason = metadata.providerFinishReason;
       contextUsage = metadata.contextUsage;
     }
     for (const source of metadata?.sources ?? []) {
@@ -4003,10 +3792,14 @@ function generationArtifacts(messages) {
   if (providerToolCalls.size > 0) {
     artifacts.providerToolCalls = [...providerToolCalls.values()];
   }
+  if (finishReason !== void 0) artifacts.finishReason = finishReason;
+  if (providerFinishReason !== void 0) {
+    artifacts.providerFinishReason = providerFinishReason;
+  }
   if (contextUsage !== void 0) artifacts.contextUsage = contextUsage;
   return artifacts;
 }
-function reasoningDeltaEvent2(turn, delta, details = {}) {
+function reasoningDeltaEvent(turn, delta, details = {}) {
   const event = {
     type: "reasoning_delta",
     turn,
@@ -4049,19 +3842,83 @@ function latestAssistantText(messages) {
   }
   return "";
 }
-function structuredOutputRetryRequest(request, response) {
+function structuredOutputRetryRequest(request, response, error) {
+  const truncated = error instanceof AgentStructuredOutputError && error.phase === "truncated";
+  const correction = {
+    role: "user",
+    content: truncated ? STRUCTURED_OUTPUT_TRUNCATED_RETRY_PROMPT : STRUCTURED_OUTPUT_RETRY_PROMPT
+  };
+  if (truncated) {
+    return {
+      request: {
+        ...request,
+        chatHistory: [...request.chatHistory, correction]
+      },
+      previousResponse: "omitted",
+      includedOutputLength: 0
+    };
+  }
+  const preview = structuredOutputRepairPreview(textFromAssistantContent(response.choice));
+  if (preview.includedOutputLength === 0) {
+    return {
+      request: {
+        ...request,
+        chatHistory: [...request.chatHistory, correction]
+      },
+      previousResponse: "omitted",
+      includedOutputLength: 0
+    };
+  }
   const invalidResponse = {
     role: "assistant",
-    content: [...response.choice]
+    content: [{ type: "text", text: preview.text }]
   };
-  const correction = {
-    role: "user",
-    content: STRUCTURED_OUTPUT_RETRY_PROMPT
+  return {
+    request: {
+      ...request,
+      chatHistory: [...request.chatHistory, invalidResponse, correction]
+    },
+    previousResponse: "preview",
+    includedOutputLength: preview.includedOutputLength
   };
+}
+function structuredOutputRetryEventAttributes(error, retryRequest) {
+  const attributes = {
+    previousResponse: retryRequest.previousResponse,
+    includedOutputLength: retryRequest.includedOutputLength
+  };
+  if (!(error instanceof AgentStructuredOutputError)) return attributes;
+  Object.assign(attributes, {
+    failurePhase: error.phase,
+    outputLength: error.outputLength,
+    normalizedLength: error.normalizedLength,
+    attemptUsage: usageEventValue(error.attemptUsage),
+    cumulativeUsage: usageEventValue(error.usage)
+  });
+  if (error.finishReason !== void 0) attributes.finishReason = error.finishReason;
+  if (error.providerFinishReason !== void 0) {
+    attributes.providerFinishReason = error.providerFinishReason;
+  }
+  return attributes;
+}
+function providerOutputRetryEventAttributes(error, cumulativeUsage, attemptUsage) {
+  const resolvedAttemptUsage = attemptUsage ?? completionProviderOutputErrorUsage(error);
+  if (resolvedAttemptUsage === void 0) return void 0;
   return {
-    ...request,
-    chatHistory: [...request.chatHistory, invalidResponse, correction]
+    attemptUsage: usageEventValue(resolvedAttemptUsage),
+    cumulativeUsage: usageEventValue(cumulativeUsage)
+  };
+}
+function usageEventValue(usage) {
+  const value = {
+    inputTokens: usage.inputTokens,
+    outputTokens: usage.outputTokens,
+    totalTokens: usage.totalTokens,
+    cachedInputTokens: usage.cachedInputTokens,
+    cacheCreationInputTokens: usage.cacheCreationInputTokens
   };
+  if (usage.details !== void 0) value.details = { ...usage.details };
+  return value;
 }
 function providerMessages(messages) {
   const providerMessages2 = [];
@@ -4653,6 +4510,9 @@ var Agent = class {
     this.context = snapshotAgentContext(resolved.context);
     this.temperature = resolved.temperature;
     this.maxTokens = resolved.maxTokens;
+    if (resolved.providerOptions !== void 0) {
+      assertJsonObject(resolved.providerOptions, "Agent providerOptions");
+    }
     this.providerOptions = cloneFrozenPlainData(resolved.providerOptions);
     this.retries = cloneFrozenPlainData(resolved.retries);
     const preparedTools = prepareAgentTools(resolved);
@@ -4706,4 +4566,4 @@ export {
   markResolvedAgentOptions,
   Agent
 };
-//# sourceMappingURL=chunk-FCANRQ5Q.js.map
+//# sourceMappingURL=chunk-YA2655FX.js.map