@tanstack/ai 0.20.0 → 0.21.0

package/dist/esm/activities/chat/index.js

@@ -14,24 +14,62 @@ function createChatOptions(options) {
   return options;
 }
 class TextEngine {
+  adapter;
+  params;
+  systemPrompts;
+  tools;
+  loopStrategy;
+  toolCallManager;
+  lazyToolManager;
+  initialMessageCount;
+  requestId;
+  streamId;
+  effectiveRequest;
+  effectiveSignal;
+  messages;
+  iterationCount = 0;
+  lastFinishReason = null;
+  streamStartTime = 0;
+  totalChunkCount = 0;
+  currentMessageId = null;
+  accumulatedContent = "";
+  accumulatedThinking = [];
+  currentThinkingContent = "";
+  currentThinkingSignature = "";
+  eventOptions;
+  eventToolNames;
+  finishedEvent = null;
+  earlyTermination = false;
+  toolPhase = "continue";
+  cyclePhase = "processText";
+  // Client state extracted from initial messages (before conversion to ModelMessage)
+  initialApprovals;
+  initialClientToolResults;
+  // AG-UI protocol IDs
+  threadId;
+  runIdOverride;
+  parentRunIdOverride;
+  // Middleware support
+  middlewareRunner;
+  middlewareCtx;
+  deferredPromises = [];
+  abortReason;
+  middlewareAbortController;
+  terminalHookCalled = false;
+  logger;
+  // Structured-output finalization state (populated by runStructuredFinalization)
+  structuredOutputResult = null;
+  // Holds the validated value when `finalStructuredOutput.validate` is provided
+  // and succeeds. Distinct from `structuredOutputResult.data` (the raw,
+  // unvalidated payload from the structured-output.complete chunk).
+  validatedStructuredOutput = void 0;
+  hasValidatedStructuredOutput = false;
+  finalizationError = null;
+  finalStructuredOutput;
   constructor(config, logger) {
-    this.iterationCount = 0;
-    this.lastFinishReason = null;
-    this.streamStartTime = 0;
-    this.totalChunkCount = 0;
-    this.currentMessageId = null;
-    this.accumulatedContent = "";
-    this.accumulatedThinking = [];
-    this.currentThinkingContent = "";
-    this.currentThinkingSignature = "";
-    this.finishedEvent = null;
-    this.earlyTermination = false;
-    this.toolPhase = "continue";
-    this.cyclePhase = "processText";
-    this.deferredPromises = [];
-    this.terminalHookCalled = false;
     this.logger = logger;
     this.adapter = config.adapter;
+    this.finalStructuredOutput = config.finalStructuredOutput;
     this.params = config.params;
     this.systemPrompts = config.params.systemPrompts || [];
     this.loopStrategy = config.params.agentLoopStrategy || maxIterations(5);
@@ -41,9 +79,7 @@ class TextEngine {
     );
     this.initialApprovals = approvals;
     this.initialClientToolResults = clientToolResults;
-    this.messages = convertMessagesToModelMessages(
-      config.params.messages
-    );
+    this.messages = convertMessagesToModelMessages(config.params.messages);
     this.lazyToolManager = new LazyToolManager(
       config.params.tools || [],
       this.messages
@@ -112,6 +148,24 @@ class TextEngine {
   getMessages() {
     return this.messages;
   }
+  /** Returns the structured-output result if finalization ran successfully. */
+  getStructuredOutputResult() {
+    return this.structuredOutputResult;
+  }
+  /**
+   * Returns the validated structured-output value (the result of running
+   * `finalStructuredOutput.validate` against the raw structured-output data)
+   * wrapped in a `{ value }` object so callers can distinguish "no validation
+   * happened" from "validation produced undefined". Returns `null` when no
+   * validator was configured or validation hasn't been performed yet.
+   */
+  getValidatedStructuredOutput() {
+    return this.hasValidatedStructuredOutput ? { value: this.validatedStructuredOutput } : null;
+  }
+  /** Returns the recorded finalization error, if any. */
+  getFinalizationError() {
+    return this.finalizationError;
+  }
   async *run() {
     this.beforeRun();
     this.logger.agentLoop("run started", {
@@ -130,40 +184,64 @@ class TextEngine {
       if (pendingPhase === "wait") {
         return;
       }
-      do {
-        if (this.earlyTermination || this.isCancelled()) {
-          return;
-        }
-        this.logger.agentLoop(`iteration=${this.middlewareCtx.iteration}`, {
-          iteration: this.middlewareCtx.iteration
-        });
-        await this.beginCycle();
-        if (this.cyclePhase === "processText") {
-          this.middlewareCtx.phase = "beforeModel";
-          this.middlewareCtx.iteration = this.iterationCount;
-          const iterConfig = this.buildMiddlewareConfig();
-          const transformedConfig2 = await this.middlewareRunner.runOnConfig(
-            this.middlewareCtx,
-            iterConfig
-          );
-          this.applyMiddlewareConfig(transformedConfig2);
-          yield* this.streamModelResponse();
-        } else {
-          yield* this.processToolCalls();
-        }
-        this.endCycle();
-      } while (this.shouldContinue());
+      const skipAgentLoop = !!this.finalStructuredOutput && this.tools.length === 0;
+      if (!skipAgentLoop) {
+        do {
+          if (this.earlyTermination || this.isCancelled()) {
+            return;
+          }
+          this.logger.agentLoop(`iteration=${this.middlewareCtx.iteration}`, {
+            iteration: this.middlewareCtx.iteration
+          });
+          await this.beginCycle();
+          if (this.cyclePhase === "processText") {
+            this.middlewareCtx.phase = "beforeModel";
+            this.middlewareCtx.iteration = this.iterationCount;
+            const iterConfig = this.buildMiddlewareConfig();
+            const transformedConfig2 = await this.middlewareRunner.runOnConfig(
+              this.middlewareCtx,
+              iterConfig
+            );
+            this.applyMiddlewareConfig(transformedConfig2);
+            yield* this.streamModelResponse();
+          } else {
+            yield* this.processToolCalls();
+          }
+          this.endCycle();
+        } while (this.shouldContinue());
+      }
       this.logger.agentLoop("run finished", {
         finishReason: this.lastFinishReason
       });
-      if (!this.terminalHookCalled && this.toolPhase !== "wait") {
-        this.terminalHookCalled = true;
-        await this.middlewareRunner.runOnFinish(this.middlewareCtx, {
-          finishReason: this.lastFinishReason,
-          duration: Date.now() - this.streamStartTime,
-          content: this.accumulatedContent,
-          usage: this.finishedEvent?.usage
-        });
+      if (this.finalStructuredOutput && !this.isCancelled() && !this.finalizationError) {
+        yield* this.runStructuredFinalization();
+      }
+      if (!this.terminalHookCalled && this.toolPhase !== "wait" && !this.isCancelled()) {
+        if (this.finalizationError) {
+          this.terminalHookCalled = true;
+          const errForHook = new Error(
+            this.finalizationError.message,
+            this.finalizationError.cause !== void 0 ? { cause: this.finalizationError.cause } : void 0
+          );
+          if (this.finalizationError.code !== void 0) {
+            Object.defineProperty(errForHook, "code", {
+              value: this.finalizationError.code,
+              enumerable: true
+            });
+          }
+          await this.middlewareRunner.runOnError(this.middlewareCtx, {
+            error: errForHook,
+            duration: Date.now() - this.streamStartTime
+          });
+        } else {
+          this.terminalHookCalled = true;
+          await this.middlewareRunner.runOnFinish(this.middlewareCtx, {
+            finishReason: this.lastFinishReason,
+            duration: Date.now() - this.streamStartTime,
+            content: this.accumulatedContent,
+            usage: this.finishedEvent?.usage
+          });
+        }
       }
     } catch (error) {
       if (!this.terminalHookCalled) {
@@ -285,7 +363,11 @@ class TextEngine {
         this.middlewareCtx,
         chunk
       );
+      const suppressAgentLifecycle = !!this.finalStructuredOutput && this.finalStructuredOutput.yieldChunks;
       for (const outputChunk of outputChunks) {
+        if (suppressAgentLifecycle && (outputChunk.type === EventType.RUN_STARTED || outputChunk.type === EventType.RUN_FINISHED)) {
+          continue;
+        }
         this.logger.output(`type=${outputChunk.type}`, { chunk: outputChunk });
         yield outputChunk;
         this.middlewareCtx.chunkIndex++;
@@ -527,11 +609,10 @@ class TextEngine {
       }
       return true;
     });
-    if (undiscoveredLazyResults.length > 0) {
-      const finishEvt = this.finishedEvent;
+    if (undiscoveredLazyResults.length > 0 && this.finishedEvent) {
       for (const chunk of this.buildToolResultChunks(
         undiscoveredLazyResults,
-        finishEvt
+        this.finishedEvent
       )) {
         yield* this.pipeThroughMiddleware(chunk);
       }
@@ -858,6 +939,212 @@ class TextEngine {
   isCancelled() {
     return this.isAborted() || this.isMiddlewareAborted();
   }
+  /**
+   * Run the final structured-output adapter call through the middleware
+   * pipeline. Yields chunks to the caller only when
+   * `this.finalStructuredOutput.yieldChunks` is true; otherwise consumes
+   * silently while still piping through middleware.
+   *
+   * On success, populates this.structuredOutputResult.
+   * On failure, populates this.finalizationError.
+   */
+  async *runStructuredFinalization() {
+    if (!this.finalStructuredOutput) {
+      throw new Error(
+        "runStructuredFinalization called without finalStructuredOutput config"
+      );
+    }
+    this.middlewareCtx.phase = "structuredOutput";
+    const baseConfig = this.buildMiddlewareConfig();
+    const { tools: _omitTools, ...baseWithoutTools } = baseConfig;
+    let structuredConfig = {
+      ...baseWithoutTools,
+      outputSchema: this.finalStructuredOutput.jsonSchema
+    };
+    structuredConfig = await this.middlewareRunner.runOnStructuredOutputConfig(
+      this.middlewareCtx,
+      structuredConfig
+    );
+    const { outputSchema: pinnedSchema, ...chatConfigSlice } = structuredConfig;
+    const postOnConfig = await this.middlewareRunner.runOnConfig(
+      this.middlewareCtx,
+      { ...chatConfigSlice, tools: baseConfig.tools }
+    );
+    this.applyMiddlewareConfig(postOnConfig);
+    const structuredCallOptions = {
+      chatOptions: {
+        model: this.params.model,
+        messages: this.messages,
+        temperature: postOnConfig.temperature,
+        topP: postOnConfig.topP,
+        maxTokens: postOnConfig.maxTokens,
+        metadata: postOnConfig.metadata,
+        modelOptions: postOnConfig.modelOptions,
+        systemPrompts: postOnConfig.systemPrompts,
+        logger: this.logger,
+        threadId: this.threadId,
+        runId: this.runIdOverride,
+        parentRunId: this.parentRunIdOverride,
+        ...this.effectiveRequest ? { request: this.effectiveRequest } : {}
+      },
+      outputSchema: pinnedSchema
+    };
+    let fallbackAdapterError = void 0;
+    const providerStream = this.adapter.structuredOutputStream ? this.adapter.structuredOutputStream(structuredCallOptions) : fallbackStructuredOutputStream(
+      this.adapter,
+      structuredCallOptions,
+      (err) => {
+        fallbackAdapterError = err;
+      }
+    );
+    let startEmitted = false;
+    let structuredMessageId = null;
+    const extractMessageId = (c) => {
+      if (c.type === EventType.TEXT_MESSAGE_START || c.type === EventType.TEXT_MESSAGE_CONTENT || c.type === EventType.TEXT_MESSAGE_END) {
+        return typeof c.messageId === "string" && c.messageId !== "" ? c.messageId : null;
+      }
+      return null;
+    };
+    const buildSynthesizedStart = () => {
+      const idForStart = structuredMessageId ?? generateMessageId();
+      structuredMessageId = idForStart;
+      return {
+        type: EventType.CUSTOM,
+        name: "structured-output.start",
+        value: { messageId: idForStart },
+        model: this.params.model,
+        timestamp: Date.now(),
+        threadId: this.threadId,
+        ...this.runIdOverride ? { runId: this.runIdOverride } : {}
+      };
+    };
+    const pipeThroughMiddleware = async (synthChunk) => this.middlewareRunner.runOnChunk(this.middlewareCtx, synthChunk);
+    let runErrorYielded = false;
+    for await (const chunk of providerStream) {
+      if (this.isCancelled()) {
+        break;
+      }
+      if (!startEmitted && chunk.type === EventType.CUSTOM && chunk.name === "structured-output.start") {
+        startEmitted = true;
+      }
+      if (!structuredMessageId) {
+        const extracted = extractMessageId(chunk);
+        if (extracted) structuredMessageId = extracted;
+      }
+      if (this.finalStructuredOutput.yieldChunks) {
+        if (!startEmitted && (chunk.type === EventType.TEXT_MESSAGE_START || chunk.type === EventType.TEXT_MESSAGE_CONTENT || chunk.type === EventType.TEXT_MESSAGE_END)) {
+          startEmitted = true;
+          const synthStart = buildSynthesizedStart();
+          const synthOutputs = await pipeThroughMiddleware(synthStart);
+          for (const outputChunk of synthOutputs) {
+            yield outputChunk;
+            this.middlewareCtx.chunkIndex++;
+          }
+        }
+        if (!startEmitted && chunk.type === EventType.RUN_ERROR) {
+          startEmitted = true;
+          const synthStart = buildSynthesizedStart();
+          const synthOutputs = await pipeThroughMiddleware(synthStart);
+          for (const outputChunk of synthOutputs) {
+            yield outputChunk;
+            this.middlewareCtx.chunkIndex++;
+          }
+        }
+      }
+      if (chunk.type === EventType.CUSTOM && chunk.name === "structured-output.complete") {
+        const parsed = readStructuredOutputCompleteValue(chunk.value);
+        if (parsed) {
+          this.structuredOutputResult = {
+            data: parsed.object,
+            rawText: parsed.raw
+          };
+        }
+      }
+      if (chunk.type === EventType.RUN_FINISHED && chunk.usage) {
+        await this.middlewareRunner.runOnUsage(this.middlewareCtx, chunk.usage);
+      }
+      if (chunk.type === EventType.RUN_ERROR) {
+        this.finalizationError = {
+          message: chunk.message,
+          ...chunk.code ? { code: chunk.code } : {},
+          ...fallbackAdapterError !== void 0 ? { cause: fallbackAdapterError } : {}
+        };
+      }
+      const outputChunks = await this.middlewareRunner.runOnChunk(
+        this.middlewareCtx,
+        chunk
+      );
+      if (this.finalStructuredOutput.yieldChunks) {
+        for (const outputChunk of outputChunks) {
+          if (outputChunk.type === EventType.RUN_ERROR) {
+            runErrorYielded = true;
+          }
+          yield outputChunk;
+          this.middlewareCtx.chunkIndex++;
+        }
+      }
+      if (this.finalizationError) {
+        break;
+      }
+    }
+    if (this.isCancelled()) {
+      return;
+    }
+    if (!this.structuredOutputResult && !this.finalizationError) {
+      this.finalizationError = {
+        message: "missing structured result",
+        code: "structured-output-missing-result"
+      };
+    }
+    if (this.structuredOutputResult && !this.finalizationError && this.finalStructuredOutput.validate) {
+      try {
+        const validated = this.finalStructuredOutput.validate(
+          this.structuredOutputResult.data
+        );
+        this.validatedStructuredOutput = validated;
+        this.hasValidatedStructuredOutput = true;
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        this.finalizationError = {
+          message,
+          code: "structured-output-validation-failed",
+          cause: err
+        };
+      }
+    }
+    if (this.finalizationError && this.finalStructuredOutput.yieldChunks && !runErrorYielded) {
+      if (!startEmitted) {
+        const synthStart = buildSynthesizedStart();
+        const startOutputs = await pipeThroughMiddleware(synthStart);
+        for (const outputChunk of startOutputs) {
+          yield outputChunk;
+          this.middlewareCtx.chunkIndex++;
+        }
+        startEmitted = true;
+      }
+      const errChunk = {
+        type: EventType.RUN_ERROR,
+        runId: this.runIdOverride ?? this.requestId,
+        model: this.params.model,
+        timestamp: Date.now(),
+        threadId: this.threadId,
+        message: this.finalizationError.message,
+        ...this.finalizationError.code ? { code: this.finalizationError.code } : {},
+        error: {
+          message: this.finalizationError.message,
+          ...this.finalizationError.code ? { code: this.finalizationError.code } : {}
+        }
+      };
+      const outputChunks = await this.middlewareRunner.runOnChunk(
+        this.middlewareCtx,
+        errChunk
+      );
+      for (const outputChunk of outputChunks) {
+        yield outputChunk;
+        this.middlewareCtx.chunkIndex++;
+      }
+    }
+  }
   buildMiddlewareConfig() {
     return {
       messages: this.messages,
@@ -977,6 +1264,7 @@ async function* runStreamingText(options) {
 }
 function runNonStreamingText(options) {
   const stream = runStreamingText(
+    // eslint-disable-next-line no-restricted-syntax -- generic-stream remap: caller is non-streaming (false), but runStreamingText is invoked internally to collect text; concrete `false`→`true` literals don't structurally overlap.
     options
   );
   return streamToText(stream);
@@ -988,58 +1276,72 @@ async function runAgenticStructuredOutput(options) {
   if (!outputSchema) {
     throw new Error("outputSchema is required for structured output");
   }
+  const jsonSchema = convertSchemaToJsonSchema(outputSchema, {
+    forStructuredOutput: true
+  });
+  if (!jsonSchema) {
+    throw new Error("Failed to convert output schema to JSON Schema");
+  }
+  const validate = isStandardSchema(outputSchema) ? (data) => parseWithStandardSchema(outputSchema, data) : void 0;
   const engine = new TextEngine(
     {
       adapter,
       params: { ...textOptions, model, logger },
       middleware,
-      context
+      context,
+      finalStructuredOutput: {
+        jsonSchema,
+        yieldChunks: false,
+        ...validate ? { validate } : {}
+      }
     },
     logger
   );
   for await (const _chunk of engine.run()) {
   }
-  const finalMessages = engine.getMessages();
-  const {
-    tools: _tools,
-    agentLoopStrategy: _als,
-    ...structuredTextOptions
-  } = textOptions;
-  const jsonSchema = convertSchemaToJsonSchema(outputSchema);
-  if (!jsonSchema) {
-    throw new Error("Failed to convert output schema to JSON Schema");
-  }
-  const providerName = adapter.provider ?? adapter.name;
-  logger.request(
-    `activity=chat-structured provider=${providerName} model=${model} messages=${finalMessages.length}`,
-    {
-      provider: providerName,
-      model,
-      messageCount: finalMessages.length
-    }
-  );
-  const result = await adapter.structuredOutput({
-    chatOptions: {
-      ...structuredTextOptions,
-      model,
-      messages: finalMessages,
-      logger
-    },
-    outputSchema: jsonSchema
-  });
-  if (isStandardSchema(outputSchema)) {
-    return parseWithStandardSchema(
-      outputSchema,
-      result.data
+  const finalizationError = engine.getFinalizationError();
+  if (finalizationError) {
+    const err = new Error(
+      finalizationError.message,
+      finalizationError.cause !== void 0 ? { cause: finalizationError.cause } : void 0
     );
+    if (finalizationError.code !== void 0) {
+      Object.defineProperty(err, "code", {
+        value: finalizationError.code,
+        enumerable: true
+      });
+    }
+    throw err;
+  }
+  const validated = engine.getValidatedStructuredOutput();
+  if (validated) {
+    return validated.value;
+  }
+  const result = engine.getStructuredOutputResult();
+  if (!result) {
+    throw new Error("structured output finalization produced no result");
   }
   return result.data;
 }
-async function* fallbackStructuredOutputStream(adapter, options) {
+function readStructuredOutputCompleteValue(value) {
+  if (typeof value !== "object" || value === null) return null;
+  if (!("object" in value) || !("raw" in value)) return null;
+  const raw = value.raw;
+  if (typeof raw !== "string") return null;
+  const reasoningField = value.reasoning;
+  const reasoning = typeof reasoningField === "string" ? reasoningField : void 0;
+  return {
+    object: value.object,
+    raw,
+    ...reasoning !== void 0 ? { reasoning } : {}
+  };
+}
+async function* fallbackStructuredOutputStream(adapter, options, onAdapterError) {
   const { chatOptions } = options;
-  const runId = chatOptions.runId ?? `mock-${Date.now()}`;
-  const threadId = chatOptions.threadId ?? `mock-${Date.now()}`;
-  const messageId = `mock-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+  const fallbackRand = Math.random().toString(36).slice(2);
+  const runId = chatOptions.runId ?? `fallback-${Date.now()}-${fallbackRand}`;
+  const threadId = chatOptions.threadId ?? `fallback-${Date.now()}-${fallbackRand}`;
+  const messageId = `fallback-${Date.now()}-${fallbackRand}`;
   const model = chatOptions.model;
   const timestamp = Date.now();
   yield {
@@ -1053,10 +1355,12 @@ async function* fallbackStructuredOutputStream(adapter, options) {
   try {
     result = await adapter.structuredOutput(options);
   } catch (error) {
-    const message = error instanceof Error ? error.message : "Unknown error";
+    onAdapterError?.(error);
+    const message = error instanceof Error ? error.message : String(error);
     yield {
       type: EventType.RUN_ERROR,
       runId,
+      threadId,
       model,
       timestamp,
       message,
@@ -1120,194 +1424,17 @@ async function* runStreamingStructuredOutputImpl(options, jsonSchema) {
   const { adapter, outputSchema, middleware, context, debug, ...textOptions } = options;
   const model = adapter.model;
   const logger = resolveDebugOption(debug);
-  const runId = textOptions.runId;
-  let finalMessages = convertMessagesToModelMessages(textOptions.messages ?? []);
-  if (textOptions.tools?.length) {
-    const engine = new TextEngine(
-      {
-        adapter,
-        params: { ...textOptions, model, logger, messages: finalMessages },
-        middleware,
-        context
-      },
-      logger
-    );
-    let agentLoopErrored = false;
-    try {
-      for await (const chunk of engine.run()) {
-        if (chunk.type === "RUN_STARTED" || chunk.type === "RUN_FINISHED") {
-          continue;
-        }
-        if (chunk.type === "RUN_ERROR") {
-          agentLoopErrored = true;
-          yield chunk;
-          continue;
-        }
-        yield chunk;
-      }
-    } catch (engineError) {
-      const message = engineError.message || "Agent loop failed";
-      logger.errors("runStreamingStructuredOutput agent loop failed", {
-        error: engineError,
-        source: "runStreamingStructuredOutput"
-      });
-      yield {
-        type: EventType.RUN_ERROR,
-        runId,
-        model,
-        timestamp: Date.now(),
-        message,
-        code: "agent-loop-failed",
-        error: { message, code: "agent-loop-failed" }
-      };
-      return;
-    }
-    if (agentLoopErrored) {
-      return;
-    }
-    finalMessages = engine.getMessages();
-  }
-  const {
-    tools: _tools,
-    agentLoopStrategy: _als,
-    ...structuredTextOptions
-  } = textOptions;
-  logger.request(
-    `activity=chat-structured-stream provider=${adapter.name} model=${model} messages=${finalMessages.length}`,
+  const engine = new TextEngine(
     {
-      provider: adapter.name,
-      model,
-      messageCount: finalMessages.length
-    }
+      adapter,
+      params: { ...textOptions, model, logger },
+      middleware,
+      context,
+      finalStructuredOutput: { jsonSchema, yieldChunks: true }
+    },
+    logger
   );
-  const structuredChatOptions = {
-    ...structuredTextOptions,
-    model,
-    messages: finalMessages,
-    logger,
-    request: textOptions.abortController ? { signal: textOptions.abortController.signal } : void 0
-  };
-  const stream = adapter.structuredOutputStream ? adapter.structuredOutputStream({
-    chatOptions: structuredChatOptions,
-    outputSchema: jsonSchema
-  }) : fallbackStructuredOutputStream(adapter, {
-    chatOptions: structuredChatOptions,
-    outputSchema: jsonSchema
-  });
-  let structuredMessageId = null;
-  let startEmitted = false;
-  const extractMessageId = (c) => {
-    const id = c.messageId;
-    return typeof id === "string" && id !== "" ? id : null;
-  };
-  const emitStartIfNeeded = function* (referenceChunk) {
-    if (startEmitted) return;
-    const idForStart = structuredMessageId ?? generateMessageId();
-    structuredMessageId = idForStart;
-    startEmitted = true;
-    yield {
-      type: EventType.CUSTOM,
-      name: "structured-output.start",
-      value: { messageId: idForStart },
-      model: "model" in referenceChunk ? referenceChunk.model ?? model : model,
-      timestamp: "timestamp" in referenceChunk ? referenceChunk.timestamp ?? Date.now() : Date.now(),
-      runId
-    };
-  };
-  for await (const chunk of stream) {
-    if (!structuredMessageId) {
-      if (chunk.type === EventType.TEXT_MESSAGE_START || chunk.type === EventType.TEXT_MESSAGE_CONTENT) {
-        structuredMessageId = extractMessageId(chunk);
-      }
-    }
-    if (chunk.type === EventType.RUN_ERROR && !startEmitted) {
-      yield* emitStartIfNeeded(chunk);
-    }
-    if (!structuredMessageId && chunk.type === EventType.TEXT_MESSAGE_CONTENT) {
-      yield {
-        type: EventType.RUN_ERROR,
-        runId,
-        model,
-        timestamp: Date.now(),
-        message: "Structured-output stream produced text content without a messageId; adapter is not honoring the AG-UI contract.",
-        code: "structured-output-missing-message-id"
-      };
-      return;
-    }
-    if (!startEmitted && structuredMessageId && (chunk.type === EventType.TEXT_MESSAGE_START || chunk.type === EventType.TEXT_MESSAGE_CONTENT)) {
-      startEmitted = true;
-      yield {
-        type: EventType.CUSTOM,
-        name: "structured-output.start",
-        value: { messageId: structuredMessageId },
-        model: "model" in chunk ? chunk.model ?? model : model,
-        timestamp: "timestamp" in chunk ? chunk.timestamp ?? Date.now() : Date.now(),
-        runId
-      };
-    }
-    if (chunk.type === EventType.CUSTOM && chunk.name === "structured-output.complete") {
-      const value = chunk.value;
-      if (isStandardSchema(outputSchema)) {
-        try {
-          const validated = parseWithStandardSchema(
-            outputSchema,
-            value.object
-          );
-          yield {
-            ...chunk,
-            // Forward `reasoning` through schema validation so consumers that
-            // only listen for the terminal event don't lose chain-of-thought.
-            // Tag with messageId so the client processor can snap the right
-            // assistant message's structured-output part.
-            value: {
-              object: validated,
-              raw: value.raw,
-              ...value.reasoning ? { reasoning: value.reasoning } : {},
-              ...structuredMessageId ? { messageId: structuredMessageId } : {}
-            }
-          };
-          continue;
-        } catch (err) {
-          const message = err.message || "Schema validation failed";
-          logger.errors(
-            "runStreamingStructuredOutput schema validation failed",
-            {
-              error: err,
-              source: "runStreamingStructuredOutput",
-              // Include reasoning in error meta so post-mortems can recover
-              // what the model thought through before producing invalid JSON.
-              ...value.reasoning ? { reasoning: value.reasoning } : {}
-            }
-          );
-          yield {
-            type: EventType.RUN_ERROR,
-            runId,
-            model: chunk.model ?? model,
-            timestamp: chunk.timestamp ?? Date.now(),
-            message,
-            code: "schema-validation",
-            error: {
-              message,
-              code: "schema-validation",
-              ...value.reasoning ? { reasoning: value.reasoning } : {}
-            }
-          };
-          return;
-        }
-      }
-      if (structuredMessageId) {
-        yield {
-          ...chunk,
-          value: {
-            ...chunk.value,
-            messageId: structuredMessageId
-          }
-        };
-        continue;
-      }
-      yield chunk;
-      continue;
-    }
+  for await (const chunk of engine.run()) {
     yield chunk;
   }
 }