@anvia/core 1.0.0-rc.4 → 1.0.0-rc.6

package/dist/{chunk-5GXSQYQT.js → chunk-QXSVVYQK.js}

@@ -1,23 +1,29 @@
+import {
+  assertAgentInteractionResponse,
+  parseAgentContinuation,
+  parseAgentInteractionResponse,
+  parseAgentQuestionPrompts
+} from "./chunk-BEU6FCTN.js";
 import {
   isMcpTool
-} from "./chunk-FXAIYTRE.js";
+} from "./chunk-7YAH2F3J.js";
 import {
   MemoryCompactionConflictError,
   MemoryCompactionError,
   assertPositiveInteger,
   createMemoryCompactionSummary,
   cumulativeCompactedMessageCount
-} from "./chunk-KFR4CDGK.js";
+} from "./chunk-QXQQ2DBM.js";
 import {
   startAgentRunObservers
-} from "./chunk-VKYZZXP5.js";
+} from "./chunk-7O45T5F2.js";
 import {
   isSkillTool
 } from "./chunk-YK4WAAS4.js";
 import {
   isQuestionTool,
   isToolIndex
-} from "./chunk-J2W63PJI.js";
+} from "./chunk-JXZTTNCR.js";
 import {
   ToolNotFoundError,
   assertFiniteMinScore,
@@ -30,14 +36,15 @@ import {
   retrieveDocuments,
   toolMayRequireApproval,
   toolResultContentToText
-} from "./chunk-XYTPYUGB.js";
+} from "./chunk-RZDI7B6Z.js";
 import {
   AgentRunBlockedError,
   AgentRunCancelledError,
   AgentStreamClosedError,
+  AgentStructuredOutputError,
   AgentToolSuspensionError,
   MaxTurnsError
-} from "./chunk-TRQ3XRFD.js";
+} from "./chunk-VGJRXUPT.js";
 import {
   mapWithConcurrency
 } from "./chunk-3RM57ZT2.js";
@@ -49,13 +56,15 @@ import {
   isProviderTool,
   isStreamingCompletionModel,
   textFromAssistantContent
-} from "./chunk-D2ECOWN5.js";
+} from "./chunk-HT4P3SSG.js";
 import {
-  isJsonValue,
   parseMessage,
   parseMessages,
   toProviderJsonSchema
-} from "./chunk-PK5LKOFL.js";
+} from "./chunk-G5OACQEI.js";
+import {
+  isJsonValue
+} from "./chunk-SROQA7I7.js";
 import {
   abortError,
   resolveRetryOptions,
@@ -64,7 +73,7 @@ import {
   retryOptionsForFailure,
   throwIfAborted,
   waitForRetry
-} from "./chunk-FN7HLLAZ.js";
+} from "./chunk-UBE4WH6G.js";
 import {
   appendGuardrailPolicies,
   hasEnforcedOutputGuardrails,
@@ -72,155 +81,6 @@ import {
   runOutputGuardrails
 } from "./chunk-AZB6N7P4.js";
 
-// src/agent/interactions.ts
-import { z } from "zod";
-var nonblank = z.string().trim().min(1);
-var jsonValueSchema = z.custom(isJsonValue, {
-  message: "Expected a strict JSON value"
-});
-var jsonObjectSchema = z.custom(
-  (value) => typeof value === "object" && value !== null && !Array.isArray(value) && isJsonValue(value),
-  { message: "Expected a strict JSON object" }
-);
-var questionChoiceSchema = z.object({
-  label: nonblank,
-  value: nonblank
-}).strict();
-var questionPromptSchema = z.object({
-  id: nonblank,
-  text: nonblank,
-  choices: z.array(questionChoiceSchema).min(1).optional(),
-  allowCustom: z.boolean().optional()
-}).strict().superRefine((question, context) => {
-  if (question.choices === void 0 && question.allowCustom === false) {
-    context.addIssue({
-      code: "custom",
-      message: "A free-text question cannot disable custom answers.",
-      path: ["allowCustom"]
-    });
-  }
-  const values = /* @__PURE__ */ new Set();
-  for (const [index, choice] of (question.choices ?? []).entries()) {
-    if (values.has(choice.value)) {
-      context.addIssue({
-        code: "custom",
-        message: "Question choice values must be unique.",
-        path: ["choices", index, "value"]
-      });
-    }
-    values.add(choice.value);
-  }
-});
-var questionAnswerSchema = z.object({
-  questionId: nonblank,
-  value: nonblank
-}).strict();
-var interactionBase = {
-  id: nonblank,
-  toolName: nonblank,
-  toolCallId: nonblank,
-  callId: z.string().optional(),
-  internalCallId: nonblank
-};
-var approvalRequestSchema = z.object({
-  type: z.literal("tool-approval"),
-  ...interactionBase,
-  input: jsonValueSchema,
-  reason: z.string().optional()
-}).strict();
-var questionRequestSchema = z.object({
-  type: z.literal("tool-question"),
-  ...interactionBase,
-  questions: z.array(questionPromptSchema).min(1)
-}).strict().superRefine((request, context) => {
-  const ids = /* @__PURE__ */ new Set();
-  for (const [index, question] of request.questions.entries()) {
-    if (ids.has(question.id)) {
-      context.addIssue({
-        code: "custom",
-        message: "Question IDs must be unique.",
-        path: ["questions", index, "id"]
-      });
-    }
-    ids.add(question.id);
-  }
-});
-var agentInteractionRequestSchema = z.discriminatedUnion("type", [
-  approvalRequestSchema,
-  questionRequestSchema
-]);
-var agentInteractionResponseSchema = z.discriminatedUnion("type", [
-  z.object({
-    type: z.literal("tool-approval"),
-    approved: z.boolean(),
-    reason: z.string().optional()
-  }).strict(),
-  z.object({
-    type: z.literal("tool-question"),
-    answers: z.array(questionAnswerSchema)
-  }).strict()
-]);
-var agentContinuationSchema = z.object({
-  version: z.literal(1),
-  agentId: nonblank,
-  sourceRunId: nonblank,
-  interaction: agentInteractionRequestSchema,
-  state: jsonObjectSchema
-}).strict();
-function parseAgentInteractionRequest(value) {
-  return freeze(agentInteractionRequestSchema.parse(value));
-}
-function parseAgentInteractionResponse(value) {
-  return freeze(agentInteractionResponseSchema.parse(value));
-}
-function parseAgentQuestionPrompts(value) {
-  const request = questionRequestSchema.parse({
-    type: "tool-question",
-    id: "validation",
-    toolName: "validation",
-    toolCallId: "validation",
-    internalCallId: "validation",
-    questions: value
-  });
-  return freeze(request.questions);
-}
-function parseAgentContinuation(value) {
-  return freeze(agentContinuationSchema.parse(value));
-}
-function assertAgentInteractionResponse(request, response) {
-  if (request.type !== response.type) {
-    throw new TypeError("Interaction response type does not match the pending request.");
-  }
-  if (request.type === "tool-question" && response.type === "tool-question") {
-    assertQuestionAnswers(request, response.answers);
-  }
-}
-function assertQuestionAnswers(request, answers) {
-  const parsed = answers.map((answer) => questionAnswerSchema.parse(answer));
-  const byId = new Map(parsed.map((answer) => [answer.questionId, answer]));
-  if (byId.size !== parsed.length) {
-    throw new TypeError("Question answers must not contain duplicate question IDs.");
-  }
-  if (byId.size !== request.questions.length) {
-    throw new TypeError("Question responses must answer every question exactly once.");
-  }
-  for (const question of request.questions) {
-    const answer = byId.get(question.id);
-    if (answer === void 0) {
-      throw new TypeError(`Question response is missing an answer for "${question.id}".`);
-    }
-    const choices = question.choices;
-    if (choices !== void 0 && question.allowCustom !== true && !choices.some((choice) => choice.value === answer.value)) {
-      throw new TypeError(`Question "${question.id}" requires one of its configured choices.`);
-    }
-  }
-}
-function freeze(value) {
-  if (typeof value !== "object" || value === null || Object.isFrozen(value)) return value;
-  for (const child of Object.values(value)) freeze(child);
-  return Object.freeze(value);
-}
-
 // src/agent/tool-state.ts
 var agentToolStates = /* @__PURE__ */ new WeakMap();
 function registerAgentToolState(agent, publicState, toolsByName) {
@@ -1103,6 +963,12 @@ var CompletionStreamAccumulator = class {
         usage: finalResponse.usage,
         rawResponse: finalResponse.rawResponse
       };
+      if (finalResponse.finishReason !== void 0) {
+        mergedResponse.finishReason = finalResponse.finishReason;
+      }
+      if (finalResponse.providerFinishReason !== void 0) {
+        mergedResponse.providerFinishReason = finalResponse.providerFinishReason;
+      }
       if (finalResponse.messageId !== void 0) {
         mergedResponse.messageId = finalResponse.messageId;
       }
@@ -1387,6 +1253,58 @@ function isGenerationDeltaEvent(type) {
   return type === "text_delta" || type === "reasoning_delta" || type === "tool_call_delta" || type === "tool_call" || type === "source" || type === "provider_tool_call";
 }
 
+// src/internal/agent-runtime/structured-output.ts
+var JSON_FENCE_START = "```json\n";
+var JSON_FENCE_CRLF_START = "```json\r\n";
+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);
+  if (opening === void 0 || !trimmed.endsWith(FENCE_END)) {
+    return { text: trimmed, format: "raw" };
+  }
+  const closingStart = trimmed.length - 3;
+  const precedingNewline = closingStart - 1;
+  const contentEnd = trimmed[precedingNewline - 1] === "\r" ? precedingNewline - 1 : precedingNewline;
+  return {
+    text: trimmed.slice(opening.length, contentEnd).trim(),
+    format: opening.format
+  };
+}
+function fenceOpening(text) {
+  if (text.startsWith(JSON_FENCE_START)) {
+    return { length: JSON_FENCE_START.length, format: "json-fence" };
+  }
+  if (text.startsWith(JSON_FENCE_CRLF_START)) {
+    return { length: JSON_FENCE_CRLF_START.length, format: "json-fence" };
+  }
+  if (text.startsWith(UNLABELED_FENCE_START)) {
+    return { length: UNLABELED_FENCE_START.length, format: "unlabeled-fence" };
+  }
+  if (text.startsWith(UNLABELED_FENCE_CRLF_START)) {
+    return { length: UNLABELED_FENCE_CRLF_START.length, format: "unlabeled-fence" };
+  }
+  return void 0;
+}
+
 // src/internal/agent-runtime/tool-execution.ts
 var ToolCallExecutor = class {
   constructor(agent, activeHook, approvalHandler, lifecycle, runContext, concurrency, requestMiddlewares, abortSignal, cancel) {
@@ -2308,6 +2226,8 @@ var AgentRun = class _AgentRun {
   currentMessages = [];
   cancellationError;
   activeGeneration;
+  validatedStructuredOutput;
+  failedCompletionUsage = Usage.empty();
   abortController = new AbortController();
   removeExternalAbortListener;
   static fromAgent(agent, options) {
@@ -2605,6 +2525,12 @@ var AgentRun = class _AgentRun {
       if (error instanceof MemoryCompactionError && error.usage !== void 0) {
         usage = Usage.add(usage, error.usage);
       }
+      const failedCompletionUsage = this.takeFailedCompletionUsage();
+      if (error instanceof AgentStructuredOutputError) {
+        usage = Usage.add(usage, error.usage);
+      } else {
+        usage = Usage.add(usage, failedCompletionUsage);
+      }
       this.runState = "closing";
       const runError = this.normalizeRunError(error);
       const reportedError = await this.reportRunFailure(
@@ -2777,7 +2703,7 @@ var AgentRun = class _AgentRun {
           request,
           modelInfo: generationStartArgs.modelInfo
         };
-        const bufferResponseEvents = this.shouldBufferStreamResponseEvents();
+        const bufferResponseEvents = this.shouldBufferStreamResponseEvents() || this.agent.outputSchema !== void 0;
         const completionState = {
           response: void 0,
           firstDeltaMs: void 0,
@@ -2964,6 +2890,9 @@ var AgentRun = class _AgentRun {
       if (error instanceof MemoryCompactionError && error.usage !== void 0) {
         usage = Usage.add(usage, error.usage);
       }
+      if (error instanceof AgentStructuredOutputError) {
+        usage = Usage.add(usage, error.usage);
+      }
       this.runState = "closing";
       const runError = this.normalizeRunError(error);
       const reportedError = await this.reportRunFailure(
@@ -2991,16 +2920,20 @@ var AgentRun = class _AgentRun {
   }
   async runCompletion(request, turn, runObservers) {
     assertCompletionRequestSupported(this.agent.model, request);
+    this.validatedStructuredOutput = void 0;
+    this.failedCompletionUsage = Usage.empty();
     const providerRequest = this.providerTraceRequest(request);
     const generationObservers = await runObservers.startGeneration(
       this.generationStartArgs(turn, request, providerRequest)
     );
+    let currentRequest = request;
+    let structuredRetryUsage = Usage.empty();
     try {
       for (let attempt = 1; ; attempt += 1) {
         let response;
         try {
           this.throwIfCancelled();
-          response = await this.agent.model.completion(request, this.modelCallOptions());
+          response = await this.agent.model.completion(currentRequest, this.modelCallOptions());
         } catch (error) {
           const retryOptions = this.retryOptionsForFailure(error, attempt, turn, false);
           if (retryOptions === void 0) {
@@ -3016,8 +2949,33 @@ var AgentRun = class _AgentRun {
           );
           continue;
         }
-        await generationObservers.end({ turn, response });
-        return response;
+        const cumulativeUsage = Usage.add(structuredRetryUsage, response.usage);
+        try {
+          this.validateStructuredResponse(response, attempt, cumulativeUsage);
+        } catch (error) {
+          const retryOptions = this.retryOptionsForFailure(error, attempt, turn, false);
+          if (retryOptions === void 0) {
+            throw error;
+          }
+          structuredRetryUsage = cumulativeUsage;
+          this.failedCompletionUsage = structuredRetryUsage;
+          const retryRequest = structuredOutputRetryRequest(request, response, error);
+          currentRequest = retryRequest.request;
+          await this.scheduleCompletionRetry(
+            error,
+            attempt,
+            turn,
+            false,
+            retryOptions,
+            runObservers,
+            structuredOutputRetryEventAttributes(error, retryRequest)
+          );
+          continue;
+        }
+        const finalResponse = structuredRetryUsage.totalTokens === 0 ? response : { ...response, usage: cumulativeUsage };
+        await generationObservers.end({ turn, response: finalResponse });
+        this.failedCompletionUsage = Usage.empty();
+        return finalResponse;
       }
     } catch (error) {
       await settleFailureCleanup([() => generationObservers.error({ turn, error })]);
@@ -3046,12 +3004,14 @@ var AgentRun = class _AgentRun {
     if (!isStreamingCompletionModel(model)) {
       throw new TypeError("Streaming completion requires a streaming-capable model.");
     }
-    const accumulator = new CompletionStreamAccumulator();
+    this.validatedStructuredOutput = void 0;
+    let currentRequest = args.request;
     for (let attempt = 1; ; attempt += 1) {
+      const accumulator = new CompletionStreamAccumulator();
       let hasProviderProgress = false;
       try {
         this.throwIfCancelled();
-        for await (const event of model.streamCompletion(args.request, this.modelCallOptions())) {
+        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);
@@ -3077,7 +3037,36 @@ var AgentRun = class _AgentRun {
             }
           }
         }
-        args.state.response = accumulator.response();
+        const response = accumulator.response();
+        const cumulativeStructuredUsage = Usage.add(args.state.providerErrorUsage, response.usage);
+        try {
+          this.validateStructuredResponse(response, attempt, cumulativeStructuredUsage);
+        } catch (error) {
+          const retryOptions = this.retryOptionsForFailure(error, attempt, args.turn, true);
+          if (retryOptions === void 0) {
+            if (error instanceof AgentStructuredOutputError) {
+              args.state.providerErrorUsage = Usage.empty();
+            }
+            throw error;
+          }
+          args.state.providerErrorUsage = Usage.add(args.state.providerErrorUsage, response.usage);
+          args.state.firstDeltaMs = void 0;
+          args.state.emittedToolCallIds.clear();
+          const retryRequest = structuredOutputRetryRequest(args.request, response, error);
+          currentRequest = retryRequest.request;
+          await this.scheduleCompletionRetry(
+            error,
+            attempt,
+            args.turn,
+            true,
+            retryOptions,
+            args.runObservers,
+            structuredOutputRetryEventAttributes(error, retryRequest)
+          );
+          continue;
+        }
+        args.state.response = args.state.providerErrorUsage.totalTokens === 0 ? response : { ...response, usage: cumulativeStructuredUsage };
+        args.state.providerErrorUsage = Usage.empty();
         return;
       } catch (error) {
         const retryOptions = hasProviderProgress ? void 0 : this.retryOptionsForFailure(error, attempt, args.turn, true);
@@ -3216,6 +3205,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) {
@@ -3261,20 +3254,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);
   }
@@ -3508,16 +3505,81 @@ var AgentRun = class _AgentRun {
       output: this.parseOutput(text)
     };
   }
-  parseOutput(text) {
+  validateStructuredResponse(response, attempt, usage) {
+    if (this.agent.outputSchema === void 0) return;
+    if (response.choice.some((item) => item.type === "tool-call")) return;
+    const text = textFromAssistantContent(response.choice);
+    const normalized = normalizeStructuredOutput(text);
+    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() {
+    const usage = this.failedCompletionUsage;
+    this.failedCompletionUsage = Usage.empty();
+    return usage;
+  }
+  parseOutput(text, attempt = 1, usage = Usage.empty(), options = {}) {
     const schema = this.agent.outputSchema;
     if (schema === void 0) return text;
+    if (options.useValidatedOutput !== false && this.validatedStructuredOutput?.text === text) {
+      return this.validatedStructuredOutput.output;
+    }
+    const normalized = normalizeStructuredOutput(text);
+    const maxAttempts = this.completionRetryOptions?.maxAttempts ?? 1;
     let json;
     try {
-      json = JSON.parse(text);
+      json = JSON.parse(normalized.text);
     } catch (error) {
-      throw new Error("Agent expected the model response to be valid JSON.", { cause: error });
+      throw new AgentStructuredOutputError({
+        phase: "parse",
+        attempt,
+        maxAttempts,
+        outputLength: text.length,
+        normalizedLength: normalized.text.length,
+        outputFormat: normalized.format,
+        attemptUsage: options.attemptUsage ?? usage,
+        usage,
+        finishReason: options.finishReason,
+        providerFinishReason: options.providerFinishReason,
+        cause: error
+      });
+    }
+    try {
+      return schema.parse(json);
+    } catch (error) {
+      throw new AgentStructuredOutputError({
+        phase: "schema",
+        attempt,
+        maxAttempts,
+        outputLength: text.length,
+        normalizedLength: normalized.text.length,
+        outputFormat: normalized.format,
+        attemptUsage: options.attemptUsage ?? usage,
+        usage,
+        finishReason: options.finishReason,
+        providerFinishReason: options.providerFinishReason,
+        cause: error
+      });
     }
-    return schema.parse(json);
   }
   memoryCompactionResult() {
     return this.memoryCompaction === void 0 ? {} : { memoryCompaction: lifecycleSnapshot(this.memoryCompaction) };
@@ -3981,10 +4043,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 ?? []) {
@@ -4000,6 +4066,10 @@ 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;
 }
@@ -4046,6 +4116,76 @@ function latestAssistantText(messages) {
   }
   return "";
 }
+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: [{ type: "text", text: preview.text }]
+  };
+  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 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 = [];
   for (const message of messages) {
@@ -4119,7 +4259,7 @@ var DefaultAgentStream = class {
 };
 
 // src/agent/agent-tool.ts
-import { z as z2 } from "zod";
+import { z } from "zod";
 function createAgentTool(agent, options) {
   if (options.suspension !== "reject") {
     throw new TypeError('Agent.asTool() requires suspension: "reject".');
@@ -4128,8 +4268,8 @@ function createAgentTool(agent, options) {
   return createTool({
     name: options.name,
     description,
-    inputSchema: z2.object({
-      prompt: z2.string().describe("The prompt to send to the agent.")
+    inputSchema: z.object({
+      prompt: z.string().describe("The prompt to send to the agent.")
     }),
     execute: async ({ prompt }, context) => {
       if (options.stream === true && context.emitStreamEvent !== void 0 && agent.model.capabilities.streaming && isStreamingCompletionModel(agent.model)) {
@@ -4681,13 +4821,6 @@ var Agent = class {
 };
 
 export {
-  agentInteractionRequestSchema,
-  agentInteractionResponseSchema,
-  agentContinuationSchema,
-  parseAgentInteractionRequest,
-  parseAgentInteractionResponse,
-  parseAgentContinuation,
-  assertAgentInteractionResponse,
   getAgentToolState,
   createHook,
   createVectorContext,
@@ -4696,4 +4829,4 @@ export {
   markResolvedAgentOptions,
   Agent
 };
-//# sourceMappingURL=chunk-5GXSQYQT.js.map
+//# sourceMappingURL=chunk-QXSVVYQK.js.map