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

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

@@ -1,13 +1,29 @@
 import {
-  isSkillTool
-} from "./chunk-YK4WAAS4.js";
+  assertAgentInteractionResponse,
+  parseAgentContinuation,
+  parseAgentInteractionResponse,
+  parseAgentQuestionPrompts
+} from "./chunk-BEU6FCTN.js";
 import {
   isMcpTool
-} from "./chunk-5MK3BISB.js";
+} from "./chunk-7YAH2F3J.js";
+import {
+  MemoryCompactionConflictError,
+  MemoryCompactionError,
+  assertPositiveInteger,
+  createMemoryCompactionSummary,
+  cumulativeCompactedMessageCount
+} from "./chunk-DNQNOHD5.js";
+import {
+  startAgentRunObservers
+} from "./chunk-E5J4OY4K.js";
+import {
+  isSkillTool
+} from "./chunk-YK4WAAS4.js";
 import {
   isQuestionTool,
   isToolIndex
-} from "./chunk-KV6QCRQ4.js";
+} from "./chunk-JXZTTNCR.js";
 import {
   ToolNotFoundError,
   assertFiniteMinScore,
@@ -20,24 +36,15 @@ import {
   retrieveDocuments,
   toolMayRequireApproval,
   toolResultContentToText
-} from "./chunk-3CMWKK32.js";
-import {
-  MemoryCompactionConflictError,
-  MemoryCompactionError,
-  assertPositiveInteger,
-  createMemoryCompactionSummary,
-  cumulativeCompactedMessageCount
-} from "./chunk-KFR4CDGK.js";
-import {
-  startAgentRunObservers
-} from "./chunk-VKYZZXP5.js";
+} from "./chunk-RZDI7B6Z.js";
 import {
   AgentRunBlockedError,
   AgentRunCancelledError,
   AgentStreamClosedError,
+  AgentStructuredOutputError,
   AgentToolSuspensionError,
   MaxTurnsError
-} from "./chunk-TRQ3XRFD.js";
+} from "./chunk-TEV3OB7N.js";
 import {
   mapWithConcurrency
 } from "./chunk-3RM57ZT2.js";
@@ -49,13 +56,15 @@ import {
   isProviderTool,
   isStreamingCompletionModel,
   textFromAssistantContent
-} from "./chunk-D2ECOWN5.js";
+} from "./chunk-HSA6NL2E.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) {
@@ -1387,6 +1247,43 @@ 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.";
+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 +2205,8 @@ var AgentRun = class _AgentRun {
   currentMessages = [];
   cancellationError;
   activeGeneration;
+  validatedStructuredOutput;
+  failedCompletionUsage = Usage.empty();
   abortController = new AbortController();
   removeExternalAbortListener;
   static fromAgent(agent, options) {
@@ -2605,6 +2504,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 +2682,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 +2869,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 +2899,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 +2928,31 @@ 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;
+          currentRequest = structuredOutputRetryRequest(currentRequest, response);
+          await this.scheduleCompletionRetry(
+            error,
+            attempt,
+            turn,
+            false,
+            retryOptions,
+            runObservers
+          );
+          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 +2981,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 +3014,34 @@ 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();
+          currentRequest = structuredOutputRetryRequest(currentRequest, response);
+          await this.scheduleCompletionRetry(
+            error,
+            attempt,
+            args.turn,
+            true,
+            retryOptions,
+            args.runObservers
+          );
+          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);
@@ -3508,16 +3472,55 @@ 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 output = this.parseOutput(text, attempt, usage, { useValidatedOutput: false });
+    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 AgentStructuredOutputError({
+        phase: "parse",
+        attempt,
+        maxAttempts,
+        outputLength: text.length,
+        normalizedLength: normalized.text.length,
+        outputFormat: normalized.format,
+        usage,
+        cause: error
+      });
+    }
+    try {
+      return schema.parse(json);
     } catch (error) {
-      throw new Error("Agent expected the model response to be valid JSON.", { cause: error });
+      throw new AgentStructuredOutputError({
+        phase: "schema",
+        attempt,
+        maxAttempts,
+        outputLength: text.length,
+        normalizedLength: normalized.text.length,
+        outputFormat: normalized.format,
+        usage,
+        cause: error
+      });
     }
-    return schema.parse(json);
   }
   memoryCompactionResult() {
     return this.memoryCompaction === void 0 ? {} : { memoryCompaction: lifecycleSnapshot(this.memoryCompaction) };
@@ -4046,6 +4049,20 @@ function latestAssistantText(messages) {
   }
   return "";
 }
+function structuredOutputRetryRequest(request, response) {
+  const invalidResponse = {
+    role: "assistant",
+    content: [...response.choice]
+  };
+  const correction = {
+    role: "user",
+    content: STRUCTURED_OUTPUT_RETRY_PROMPT
+  };
+  return {
+    ...request,
+    chatHistory: [...request.chatHistory, invalidResponse, correction]
+  };
+}
 function providerMessages(messages) {
   const providerMessages2 = [];
   for (const message of messages) {
@@ -4119,7 +4136,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 +4145,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 +4698,6 @@ var Agent = class {
 };
 
 export {
-  agentInteractionRequestSchema,
-  agentInteractionResponseSchema,
-  agentContinuationSchema,
-  parseAgentInteractionRequest,
-  parseAgentInteractionResponse,
-  parseAgentContinuation,
-  assertAgentInteractionResponse,
   getAgentToolState,
   createHook,
   createVectorContext,
@@ -4696,4 +4706,4 @@ export {
   markResolvedAgentOptions,
   Agent
 };
-//# sourceMappingURL=chunk-BY4OMNIU.js.map
+//# sourceMappingURL=chunk-FCANRQ5Q.js.map