@mastra/ai-sdk 1.1.0 → 1.1.1

package/dist/index.js

@@ -4616,6 +4616,142 @@ function withMastra(model, options = {}) {
     })
   });
 }
+var StreamOutputAccumulator = class {
+  /** Ordered sequence of part placeholders: either a text buffer index or a tool call ID */
+  partOrder = [];
+  textBuffers = [];
+  toolStates = /* @__PURE__ */ new Map();
+  addChunk(chunk) {
+    switch (chunk.type) {
+      case "text-delta":
+        if (chunk.payload.text) {
+          this.appendTextDelta(chunk.payload.text);
+        }
+        return;
+      case "tool-call-input-streaming-start": {
+        const state = this.ensureToolState(chunk.payload.toolCallId);
+        state.toolName = state.toolName || chunk.payload.toolName;
+        state.providerMetadata = chunk.payload.providerMetadata || state.providerMetadata;
+        if (!state.argDeltas) {
+          state.argDeltas = [];
+        }
+        return;
+      }
+      case "tool-call-delta": {
+        const state = this.ensureToolState(chunk.payload.toolCallId);
+        if (chunk.payload.argsTextDelta) {
+          if (!state.argDeltas) state.argDeltas = [];
+          state.argDeltas.push(chunk.payload.argsTextDelta);
+        }
+        return;
+      }
+      case "tool-call-input-streaming-end": {
+        const state = this.ensureToolState(chunk.payload.toolCallId);
+        this.finalizeToolArgs(state);
+        return;
+      }
+      case "tool-call": {
+        const state = this.ensureToolState(chunk.payload.toolCallId);
+        state.toolName = state.toolName || chunk.payload.toolName;
+        if (chunk.payload.args !== void 0) {
+          state.args = chunk.payload.args;
+        } else {
+          this.finalizeToolArgs(state);
+        }
+        state.providerMetadata = chunk.payload.providerMetadata || state.providerMetadata;
+        return;
+      }
+      case "tool-result": {
+        const state = this.ensureToolState(chunk.payload.toolCallId);
+        state.toolName = state.toolName || chunk.payload.toolName;
+        state.result = chunk.payload.result;
+        if (state.args === void 0) {
+          this.finalizeToolArgs(state);
+        }
+        state.providerMetadata = chunk.payload.providerMetadata || state.providerMetadata;
+        return;
+      }
+      default:
+        return;
+    }
+  }
+  buildResponseMessage(memory) {
+    if (this.partOrder.length === 0) {
+      return null;
+    }
+    const parts = [];
+    const textSegments = [];
+    for (const entry of this.partOrder) {
+      if (entry.kind === "text") {
+        const text2 = this.textBuffers[entry.bufferIndex].join("");
+        parts.push({ type: "text", text: text2 });
+        textSegments.push(text2);
+      } else {
+        const state = this.toolStates.get(entry.toolCallId);
+        this.finalizeToolArgs(state);
+        parts.push(this.buildToolPart(state));
+      }
+    }
+    const textContent = textSegments.join("");
+    const content = {
+      format: 2,
+      parts,
+      ...textContent ? { content: textContent } : {}
+    };
+    return {
+      id: crypto.randomUUID(),
+      role: "assistant",
+      content,
+      createdAt: /* @__PURE__ */ new Date(),
+      ...memory?.threadId && { threadId: memory.threadId },
+      ...memory?.resourceId && { resourceId: memory.resourceId }
+    };
+  }
+  ensureToolState(toolCallId) {
+    let state = this.toolStates.get(toolCallId);
+    if (!state) {
+      state = { toolCallId };
+      this.toolStates.set(toolCallId, state);
+      this.partOrder.push({ kind: "tool", toolCallId });
+    }
+    return state;
+  }
+  finalizeToolArgs(state) {
+    if (state.args !== void 0 || !state.argDeltas?.length) {
+      return;
+    }
+    try {
+      state.args = JSON.parse(state.argDeltas.join(""));
+    } catch {
+      return;
+    }
+  }
+  appendTextDelta(text2) {
+    const last = this.partOrder[this.partOrder.length - 1];
+    if (last?.kind === "text") {
+      this.textBuffers[last.bufferIndex].push(text2);
+      return;
+    }
+    const bufferIndex = this.textBuffers.length;
+    this.textBuffers.push([text2]);
+    this.partOrder.push({ kind: "text", bufferIndex });
+  }
+  buildToolPart(state) {
+    const hasResult = state.result !== void 0;
+    const toolInvocation = {
+      state: hasResult ? "result" : "call",
+      toolCallId: state.toolCallId,
+      toolName: state.toolName || "unknown",
+      args: state.args ?? {},
+      ...hasResult ? { result: state.result } : {}
+    };
+    return {
+      type: "tool-invocation",
+      toolInvocation,
+      ...state.providerMetadata ? { providerMetadata: state.providerMetadata } : {}
+    };
+  }
+};
 function createProcessorMiddleware(options) {
   const { inputProcessors = [], outputProcessors = [], memory } = options;
   const requestContext = new RequestContext();
@@ -4737,6 +4873,7 @@ function createProcessorMiddleware(options) {
             await processor.processOutputResult({
               messages: messageList.get.all.db(),
               messageList,
+              state: {},
               requestContext,
               abort: (reason) => {
                 throw new TripWire(reason || "Aborted by processor");
@@ -4774,8 +4911,12 @@ function createProcessorMiddleware(options) {
       }
       const { stream, ...rest } = await doStream();
       if (!outputProcessors.length) return { stream, ...rest };
+      const outputResultProcessors = outputProcessors.filter((processor) => processor.processOutputResult);
+      const streamAccumulator = outputResultProcessors.length ? new StreamOutputAccumulator() : null;
       const processorStates = /* @__PURE__ */ new Map();
       const runId = crypto.randomUUID();
+      let streamAborted = false;
+      let sawFinish = false;
       const transformedStream = stream.pipeThrough(
         new TransformStream$1({
           async transform(chunk, controller) {
@@ -4812,6 +4953,7 @@ function createProcessorMiddleware(options) {
                   }
                 } catch (error) {
                   if (error instanceof TripWire) {
+                    streamAborted = true;
                     controller.enqueue({
                       type: "error",
                       error: new Error(error.message)
@@ -4823,12 +4965,69 @@ function createProcessorMiddleware(options) {
                 }
               }
             }
+            if (mastraChunk) {
+              if (mastraChunk.type === "finish") {
+                sawFinish = true;
+              }
+              if (streamAccumulator) {
+                streamAccumulator.addChunk(mastraChunk);
+              }
+            }
             if (mastraChunk) {
               const aiChunk = convertMastraChunkToAISDKStreamPart(mastraChunk);
               if (aiChunk) {
                 controller.enqueue(aiChunk);
               }
             }
+          },
+          async flush(controller) {
+            if (!streamAccumulator || streamAborted || !sawFinish) {
+              return;
+            }
+            const messageList = new MessageList({
+              threadId: memory?.threadId,
+              resourceId: memory?.resourceId
+            });
+            const flushOriginalInputCount = processorState?.originalInputCount ?? params.prompt.filter((m) => m.role !== "system").length;
+            const flushNonSystemTotal = params.prompt.filter((m) => m.role !== "system").length;
+            const flushMemoryCount = flushNonSystemTotal - flushOriginalInputCount;
+            let flushNonSystemIndex = 0;
+            for (const msg of params.prompt) {
+              if (msg.role === "system") {
+                messageList.addSystem(msg.content);
+              } else {
+                messageList.add(msg, flushNonSystemIndex < flushMemoryCount ? "memory" : "input");
+                flushNonSystemIndex++;
+              }
+            }
+            const responseMessage = streamAccumulator.buildResponseMessage(memory);
+            if (responseMessage) {
+              messageList.add(responseMessage, "response");
+            }
+            for (const processor of outputResultProcessors) {
+              if (!processor.processOutputResult) continue;
+              try {
+                const procState = processorStates.get(processor.id);
+                await processor.processOutputResult({
+                  messages: messageList.get.all.db(),
+                  messageList,
+                  state: procState?.customState ?? {},
+                  requestContext,
+                  abort: (reason) => {
+                    throw new TripWire(reason || "Aborted by processor");
+                  }
+                });
+              } catch (error) {
+                if (error instanceof TripWire) {
+                  controller.enqueue({
+                    type: "error",
+                    error: new Error(error.message)
+                  });
+                  return;
+                }
+                throw error;
+              }
+            }
           }
         })
       );