@mastra/server 1.33.0-alpha.6 → 1.33.0-alpha.8

package/dist/chunk-F3HP5HM6.cjs

@@ -0,0 +1,998 @@
+'use strict';
+
+var crypto = require('crypto');
+var tools = require('@mastra/core/tools');
+var zodToJson = require('@mastra/core/utils/zod-to-json');
+
+// src/server/handlers/responses.adapter.ts
+function normalizeMessageContent(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  return content.map((part) => part.text).join("");
+}
+function getMessageText(message) {
+  const parts = Array.isArray(message.content?.parts) ? message.content.parts : [];
+  return parts.flatMap((part) => part.type === "text" ? [part.text] : []).filter((text) => typeof text === "string").join("");
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function getMessageRole(message) {
+  return message.role ?? "";
+}
+function getToolKey(toolCallId, messageId, partIndex) {
+  return `${messageId}:${partIndex}`;
+}
+function getFunctionCallOutputItemId(toolCallId) {
+  return `${toolCallId}:output`;
+}
+function normalizeToolParameters(schema) {
+  if (!isRecord(schema)) {
+    return schema;
+  }
+  if (isRecord(schema.json) && Object.keys(schema).length === 1) {
+    return schema.json;
+  }
+  return schema;
+}
+function mapMastraToolsToResponseTools(tools$1) {
+  if (!tools$1) {
+    return [];
+  }
+  return Object.values(tools$1).flatMap((tool) => {
+    if (!isRecord(tool)) {
+      return [];
+    }
+    const name = typeof tool.id === "string" ? tool.id : typeof tool.name === "string" ? tool.name : null;
+    if (!name) {
+      return [];
+    }
+    const description = typeof tool.description === "string" ? tool.description : void 0;
+    let parameters;
+    if (tools.isProviderDefinedTool(tool)) {
+      const resolvedSchema = typeof tool.inputSchema === "function" ? tool.inputSchema() : tool.inputSchema;
+      parameters = isRecord(resolvedSchema) && "jsonSchema" in resolvedSchema ? normalizeToolParameters(resolvedSchema.jsonSchema) : void 0;
+    } else if ("inputSchema" in tool && tool.inputSchema) {
+      parameters = normalizeToolParameters(zodToJson.zodToJsonSchema(tool.inputSchema));
+    }
+    return [
+      {
+        type: "function",
+        name,
+        ...description ? { description } : {},
+        ...parameters !== void 0 ? { parameters: JSON.parse(JSON.stringify(parameters)) } : {}
+      }
+    ];
+  });
+}
+function stringifyToolPayload(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  return JSON.stringify(value === void 0 ? {} : value);
+}
+function stringifyToolArguments(value) {
+  if (isRecord(value) && typeof value.__raw === "string") {
+    return value.__raw;
+  }
+  return stringifyToolPayload(value === null ? void 0 : value);
+}
+function createOutputMessage({
+  messageId,
+  status,
+  text
+}) {
+  const responseStatus = status === "completed" ? "completed" : "incomplete";
+  return {
+    id: messageId,
+    type: "message",
+    role: "assistant",
+    status: responseStatus,
+    content: [createOutputTextPart(text)]
+  };
+}
+function createConversationMessage({
+  messageId,
+  role,
+  text
+}) {
+  return {
+    id: messageId,
+    type: "message",
+    role,
+    status: "completed",
+    content: [
+      role === "assistant" ? createOutputTextPart(text) : {
+        type: "input_text",
+        text
+      }
+    ]
+  };
+}
+function createFunctionCallItem({
+  itemId,
+  callId,
+  name,
+  args
+}) {
+  return {
+    id: itemId,
+    type: "function_call",
+    call_id: callId,
+    name,
+    arguments: stringifyToolArguments(args),
+    status: "completed"
+  };
+}
+function createFunctionCallOutputItem({ itemId, callId, output }) {
+  return {
+    id: itemId,
+    type: "function_call_output",
+    call_id: callId,
+    output: stringifyToolPayload(output)
+  };
+}
+function collectToolResultCallIds(messages) {
+  const toolResultCallIds = /* @__PURE__ */ new Set();
+  for (const message of messages) {
+    const parts = Array.isArray(message.content?.parts) ? message.content.parts : [];
+    for (const [partIndex, part] of parts.entries()) {
+      if (!isRecord(part) || part.type !== "tool-invocation" || !isRecord(part.toolInvocation)) {
+        continue;
+      }
+      const toolInvocation = part.toolInvocation;
+      const toolCallId = typeof toolInvocation.toolCallId === "string" ? toolInvocation.toolCallId : getToolKey(null, message.id, partIndex);
+      if (getMessageRole(message) === "tool" && toolInvocation.result !== void 0) {
+        toolResultCallIds.add(toolCallId);
+      }
+    }
+  }
+  return toolResultCallIds;
+}
+function mapMastraMessageToResponseToolItems({
+  message,
+  toolResultCallIds,
+  emittedCallIds,
+  emittedResultCallIds
+}) {
+  const items = [];
+  const parts = Array.isArray(message.content?.parts) ? message.content.parts : [];
+  for (const [partIndex, part] of parts.entries()) {
+    if (!isRecord(part) || part.type !== "tool-invocation" || !isRecord(part.toolInvocation)) {
+      continue;
+    }
+    const toolInvocation = part.toolInvocation;
+    const toolName = typeof toolInvocation.toolName === "string" ? toolInvocation.toolName : null;
+    const toolCallId = typeof toolInvocation.toolCallId === "string" ? toolInvocation.toolCallId : getToolKey(null, message.id, partIndex);
+    if (getMessageRole(message) === "assistant" && toolName && !emittedCallIds.has(toolCallId)) {
+      items.push(
+        createFunctionCallItem({
+          itemId: toolCallId,
+          callId: toolCallId,
+          name: toolName,
+          args: toolInvocation.args
+        })
+      );
+      emittedCallIds.add(toolCallId);
+    }
+    if (toolInvocation.result !== void 0 && !emittedResultCallIds.has(toolCallId) && (getMessageRole(message) === "tool" || !toolResultCallIds.has(toolCallId))) {
+      items.push(
+        createFunctionCallOutputItem({
+          itemId: getFunctionCallOutputItemId(toolCallId),
+          callId: toolCallId,
+          output: toolInvocation.result
+        })
+      );
+      emittedResultCallIds.add(toolCallId);
+    }
+  }
+  return items;
+}
+function mapMastraMessagesToConversationItems(messages) {
+  if (!messages.length) {
+    return [];
+  }
+  const items = [];
+  const toolResultCallIds = collectToolResultCallIds(messages);
+  const emittedCallIds = /* @__PURE__ */ new Set();
+  const emittedResultCallIds = /* @__PURE__ */ new Set();
+  for (const message of messages) {
+    items.push(
+      ...mapMastraMessageToResponseToolItems({
+        message,
+        toolResultCallIds,
+        emittedCallIds,
+        emittedResultCallIds
+      })
+    );
+    const role = getMessageRole(message);
+    const text = getMessageText(message);
+    if ((role === "user" || role === "system" || role === "assistant") && text) {
+      items.push(
+        createConversationMessage({
+          messageId: message.id,
+          role,
+          text
+        })
+      );
+      continue;
+    }
+    if (role === "assistant" && !text) {
+      const parts = Array.isArray(message.content?.parts) ? message.content.parts : [];
+      const hasOnlyToolInvocations = parts.every(
+        (part) => isRecord(part) && part.type === "tool-invocation" && isRecord(part.toolInvocation)
+      );
+      if (hasOnlyToolInvocations) {
+        continue;
+      }
+    }
+    if (role === "tool") {
+      continue;
+    }
+  }
+  return items;
+}
+function mergeFallbackOutputItems({
+  output,
+  fallbackOutputItems
+}) {
+  if (!fallbackOutputItems.length) {
+    return output;
+  }
+  const outputById = new Map(output.map((item) => [item.id, item]));
+  const fallbackIds = new Set(fallbackOutputItems.map((item) => item.id));
+  return [
+    ...fallbackOutputItems.map((item) => outputById.get(item.id) ?? item),
+    ...output.filter((item) => !fallbackIds.has(item.id))
+  ];
+}
+function getOutputMessageText(item) {
+  return item.content.map((part) => part.text).join("");
+}
+function mapMastraMessagesToResponseOutputItems({
+  messages,
+  outputMessageId,
+  status,
+  fallbackText,
+  fallbackOutputItems = []
+}) {
+  if (!messages?.length) {
+    if (fallbackOutputItems.length) {
+      return fallbackOutputItems;
+    }
+    return [createOutputMessage({ messageId: outputMessageId, status, text: fallbackText })];
+  }
+  const output = [];
+  const lastAssistantIndex = [...messages].map((message) => message.role).lastIndexOf("assistant");
+  const outputMessageIndex = [...messages].map((message, index) => ({ index, message })).reverse().find(({ message }) => getMessageRole(message) === "assistant" && getMessageText(message))?.index ?? lastAssistantIndex;
+  const toolResultCallIds = collectToolResultCallIds(messages);
+  const emittedCallIds = /* @__PURE__ */ new Set();
+  const emittedResultCallIds = /* @__PURE__ */ new Set();
+  const fallbackMessageItems = fallbackOutputItems.filter(
+    (item) => item.type === "message"
+  );
+  const emittedFallbackMessageIds = /* @__PURE__ */ new Set();
+  const getOutputMessageId = ({
+    message,
+    text,
+    useOutputMessageId
+  }) => {
+    const directFallbackItem = fallbackMessageItems.find((item) => item.id === message.id);
+    if (directFallbackItem) {
+      emittedFallbackMessageIds.add(directFallbackItem.id);
+      return directFallbackItem.id;
+    }
+    if (useOutputMessageId) {
+      const matchingFallbackItem = fallbackMessageItems.find(
+        (item) => item.id !== outputMessageId && !emittedFallbackMessageIds.has(item.id) && getOutputMessageText(item) === text
+      );
+      if (matchingFallbackItem) {
+        emittedFallbackMessageIds.add(matchingFallbackItem.id);
+        return matchingFallbackItem.id;
+      }
+    }
+    return useOutputMessageId ? outputMessageId : message.id;
+  };
+  for (const [messageIndex, message] of messages.entries()) {
+    output.push(
+      ...mapMastraMessageToResponseToolItems({
+        message,
+        toolResultCallIds,
+        emittedCallIds,
+        emittedResultCallIds
+      })
+    );
+    const text = getMessageText(message);
+    if (getMessageRole(message) === "assistant" && text) {
+      const useOutputMessageId = messageIndex === outputMessageIndex;
+      output.push(
+        createOutputMessage({
+          messageId: getOutputMessageId({ message, text, useOutputMessageId }),
+          status,
+          text
+        })
+      );
+    }
+  }
+  if (!output.some((item) => item.type === "message") && fallbackText) {
+    output.push(createOutputMessage({ messageId: outputMessageId, status, text: fallbackText }));
+  }
+  return mergeFallbackOutputItems({ output, fallbackOutputItems });
+}
+function createMessageId() {
+  return `msg_${crypto.randomUUID()}`;
+}
+function mapResponseInputToExecutionMessages(input) {
+  if (typeof input === "string") {
+    return [{ role: "user", content: input }];
+  }
+  return input.map((message) => ({
+    role: message.role === "developer" ? "system" : message.role,
+    content: normalizeMessageContent(message.content)
+  }));
+}
+function toResponseUsage(usage) {
+  if (!usage) {
+    return null;
+  }
+  const inputTokens = usage.inputTokens ?? usage.promptTokens ?? 0;
+  const outputTokens = usage.outputTokens ?? usage.completionTokens ?? 0;
+  const totalTokens = usage.totalTokens ?? inputTokens + outputTokens;
+  return {
+    input_tokens: inputTokens,
+    output_tokens: outputTokens,
+    total_tokens: totalTokens,
+    input_tokens_details: {
+      cached_tokens: 0
+    },
+    output_tokens_details: {
+      reasoning_tokens: 0
+    }
+  };
+}
+function toResponseStatus(finishReason) {
+  if (finishReason === "suspended" || finishReason === "error") {
+    return "incomplete";
+  }
+  return "completed";
+}
+function createOutputTextPart(text) {
+  return {
+    type: "output_text",
+    text,
+    annotations: [],
+    logprobs: []
+  };
+}
+function buildCompletedResponse({
+  responseId,
+  outputMessageId,
+  model,
+  createdAt,
+  completedAt,
+  status,
+  text,
+  usage,
+  instructions,
+  textConfig,
+  previousResponseId,
+  conversationId,
+  providerOptions,
+  tools,
+  store,
+  messages,
+  fallbackOutputItems
+}) {
+  return {
+    id: responseId,
+    object: "response",
+    created_at: createdAt,
+    completed_at: completedAt,
+    model,
+    status,
+    output: mapMastraMessagesToResponseOutputItems({
+      messages,
+      outputMessageId,
+      status,
+      fallbackText: text,
+      fallbackOutputItems
+    }),
+    usage: toResponseUsage(usage),
+    error: null,
+    incomplete_details: null,
+    instructions: instructions ?? null,
+    text: textConfig ?? null,
+    previous_response_id: previousResponseId ?? null,
+    conversation_id: conversationId ?? null,
+    providerOptions,
+    tools,
+    store
+  };
+}
+function buildInProgressResponse({
+  responseId,
+  model,
+  createdAt,
+  instructions,
+  textConfig,
+  previousResponseId,
+  conversationId,
+  tools,
+  store
+}) {
+  return {
+    id: responseId,
+    object: "response",
+    created_at: createdAt,
+    completed_at: null,
+    model,
+    status: "in_progress",
+    output: [],
+    usage: null,
+    error: null,
+    incomplete_details: null,
+    instructions: instructions ?? null,
+    text: textConfig ?? null,
+    previous_response_id: previousResponseId ?? null,
+    conversation_id: conversationId ?? null,
+    tools: tools ?? [],
+    store
+  };
+}
+function mapResponseTurnRecordToResponse(match) {
+  return {
+    id: match.message.id,
+    object: "response",
+    created_at: match.metadata.createdAt,
+    completed_at: match.metadata.completedAt,
+    model: match.metadata.model,
+    status: match.metadata.status,
+    output: mapMastraMessagesToResponseOutputItems({
+      messages: match.messages,
+      outputMessageId: match.message.id,
+      status: match.metadata.status,
+      fallbackText: getMessageText(match.message),
+      fallbackOutputItems: match.metadata.outputItems
+    }),
+    usage: match.metadata.usage,
+    error: null,
+    incomplete_details: null,
+    instructions: match.metadata.instructions ?? null,
+    text: match.metadata.text ?? null,
+    previous_response_id: match.metadata.previousResponseId ?? null,
+    conversation_id: match.thread.id,
+    providerOptions: match.metadata.providerOptions,
+    tools: match.metadata.tools,
+    store: match.metadata.store
+  };
+}
+function formatSseEvent(event, data) {
+  return new TextEncoder().encode(`event: ${event}
+data: ${JSON.stringify(data)}
+
+`);
+}
+function extractTextDelta(value) {
+  if (typeof value !== "object" || value === null || !("type" in value)) {
+    return null;
+  }
+  const chunk = value;
+  switch (chunk.type) {
+    case "text-delta":
+      if (typeof chunk.payload?.text === "string") {
+        return chunk.payload.text;
+      }
+      if (typeof chunk.textDelta === "string") {
+        return chunk.textDelta;
+      }
+      if (typeof chunk.text === "string") {
+        return chunk.text;
+      }
+      return null;
+    default:
+      return null;
+  }
+}
+function createResponseSseEvent(payload) {
+  return { event: payload.type, payload };
+}
+function getChunkPayload(value) {
+  if (!isRecord(value)) {
+    return null;
+  }
+  return isRecord(value.payload) ? value.payload : value;
+}
+function stringifyResponsePayload(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  return JSON.stringify(value === void 0 ? {} : value);
+}
+function stringifyFunctionCallArguments(value, fallback = "") {
+  const serialized = value === void 0 || value === null ? fallback : stringifyResponsePayload(value);
+  return serialized || fallback || "{}";
+}
+function removeWhitespaceOutsideJsonStrings(value) {
+  let inString = false;
+  let escaped = false;
+  let result = "";
+  for (const char of value) {
+    if (escaped) {
+      escaped = false;
+      result += char;
+      continue;
+    }
+    if (char === "\\" && inString) {
+      escaped = true;
+      result += char;
+      continue;
+    }
+    if (char === '"') {
+      inString = !inString;
+      result += char;
+      continue;
+    }
+    if (!inString && /\s/.test(char)) {
+      continue;
+    }
+    result += char;
+  }
+  return result;
+}
+function getRemainingArgumentsDelta(current, canonical) {
+  if (!current) {
+    return canonical;
+  }
+  if (canonical.startsWith(current)) {
+    return canonical.slice(current.length);
+  }
+  const compactCurrent = removeWhitespaceOutsideJsonStrings(current);
+  const compactCanonical = removeWhitespaceOutsideJsonStrings(canonical);
+  if (compactCurrent && compactCanonical.startsWith(compactCurrent)) {
+    return compactCanonical.slice(compactCurrent.length);
+  }
+  return null;
+}
+function isCompleteJsonString(value) {
+  if (!value) {
+    return true;
+  }
+  try {
+    JSON.parse(value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function serializeToolError(error) {
+  if (error instanceof Error) {
+    return { error: error.message };
+  }
+  return { error };
+}
+function getToolCallStart(value) {
+  if (!isRecord(value) || value.type !== "tool-call-input-streaming-start") {
+    return null;
+  }
+  const payload = getChunkPayload(value);
+  const toolCallId = payload?.toolCallId;
+  const toolName = payload?.toolName;
+  if (typeof toolCallId !== "string" || typeof toolName !== "string") {
+    return null;
+  }
+  return { toolCallId, toolName };
+}
+function getToolCallDelta(value) {
+  if (!isRecord(value) || value.type !== "tool-call-delta") {
+    return null;
+  }
+  const payload = getChunkPayload(value);
+  const toolCallId = payload?.toolCallId;
+  const delta = payload?.argsTextDelta ?? payload?.inputTextDelta ?? payload?.argsDelta ?? payload?.delta;
+  if (!payload || typeof toolCallId !== "string" || typeof delta !== "string") {
+    return null;
+  }
+  return {
+    toolCallId,
+    toolName: typeof payload.toolName === "string" ? payload.toolName : void 0,
+    delta
+  };
+}
+function getToolCall(value) {
+  if (!isRecord(value) || value.type !== "tool-call") {
+    return null;
+  }
+  const payload = getChunkPayload(value);
+  const toolCallId = payload?.toolCallId;
+  const toolName = payload?.toolName;
+  const args = payload?.args ?? payload?.input;
+  if (typeof toolCallId !== "string" || typeof toolName !== "string") {
+    return null;
+  }
+  return { toolCallId, toolName, args };
+}
+function getToolCallEnd(value) {
+  if (!isRecord(value) || value.type !== "tool-call-input-streaming-end") {
+    return null;
+  }
+  const payload = getChunkPayload(value);
+  const toolCallId = payload?.toolCallId;
+  if (typeof toolCallId !== "string") {
+    return null;
+  }
+  return { toolCallId };
+}
+function getToolResult(value) {
+  if (!isRecord(value) || value.type !== "tool-result" && value.type !== "tool-error") {
+    return null;
+  }
+  const payload = getChunkPayload(value);
+  const toolCallId = payload?.toolCallId;
+  if (!payload || typeof toolCallId !== "string") {
+    return null;
+  }
+  const toolName = typeof payload.toolName === "string" ? payload.toolName : void 0;
+  const args = payload.args ?? payload.input;
+  if (value.type === "tool-error") {
+    return { toolCallId, toolName, args, result: serializeToolError(payload.error) };
+  }
+  const outputValue = payload.result !== void 0 ? payload.result : payload.output;
+  const result = payload.isError ? serializeToolError(outputValue) : outputValue;
+  return { toolCallId, toolName, args, result };
+}
+function createResponseStreamEventTranslator(responseId) {
+  let text = "";
+  let nextOutputIndex = 0;
+  let textOutputIndex = null;
+  const completedToolResultCallIds = /* @__PURE__ */ new Set();
+  const pendingToolResults = /* @__PURE__ */ new Map();
+  const toolCalls = /* @__PURE__ */ new Map();
+  const outputItems = /* @__PURE__ */ new Map();
+  const ensureTextOutputItem = () => {
+    if (textOutputIndex !== null) {
+      return { events: [], outputIndex: textOutputIndex };
+    }
+    textOutputIndex = nextOutputIndex++;
+    return {
+      outputIndex: textOutputIndex,
+      events: [
+        createResponseSseEvent({
+          type: "response.output_item.added",
+          output_index: textOutputIndex,
+          item: {
+            id: responseId,
+            type: "message",
+            role: "assistant",
+            status: "in_progress",
+            content: []
+          }
+        }),
+        createResponseSseEvent({
+          type: "response.content_part.added",
+          output_index: textOutputIndex,
+          content_index: 0,
+          item_id: responseId,
+          part: createOutputTextPart("")
+        })
+      ]
+    };
+  };
+  const ensureToolCallItem = ({
+    toolCallId,
+    toolName
+  }) => {
+    const existing = toolCalls.get(toolCallId);
+    if (existing) {
+      if (!existing.completed && toolName && existing.name !== toolName) {
+        existing.name = toolName;
+      }
+      return { events: [], state: existing };
+    }
+    const state = {
+      argumentsText: "",
+      completed: false,
+      itemId: toolCallId,
+      name: toolName,
+      outputIndex: nextOutputIndex++,
+      zeroArgumentInputEnded: false
+    };
+    toolCalls.set(toolCallId, state);
+    return {
+      state,
+      events: [
+        createResponseSseEvent({
+          type: "response.output_item.added",
+          output_index: state.outputIndex,
+          item: {
+            id: state.itemId,
+            type: "function_call",
+            call_id: toolCallId,
+            name: toolName,
+            arguments: "",
+            status: "in_progress"
+          }
+        })
+      ]
+    };
+  };
+  const completeToolCallItem = ({
+    events,
+    state,
+    toolCallId,
+    toolName,
+    args
+  }) => {
+    if (state.completed) {
+      return events;
+    }
+    const item = {
+      id: state.itemId,
+      type: "function_call",
+      call_id: toolCallId,
+      name: toolName,
+      arguments: args,
+      status: "completed"
+    };
+    state.argumentsText = args;
+    state.completed = true;
+    outputItems.set(state.outputIndex, item);
+    return [
+      ...events,
+      createResponseSseEvent({
+        type: "response.function_call_arguments.done",
+        item_id: state.itemId,
+        output_index: state.outputIndex,
+        name: toolName,
+        arguments: args
+      }),
+      createResponseSseEvent({
+        type: "response.output_item.done",
+        output_index: state.outputIndex,
+        item
+      })
+    ];
+  };
+  const completeToolResultItem = ({
+    events,
+    toolResult
+  }) => {
+    if (completedToolResultCallIds.has(toolResult.toolCallId)) {
+      return events;
+    }
+    completedToolResultCallIds.add(toolResult.toolCallId);
+    pendingToolResults.delete(toolResult.toolCallId);
+    const outputIndex = nextOutputIndex++;
+    const item = {
+      id: getFunctionCallOutputItemId(toolResult.toolCallId),
+      type: "function_call_output",
+      call_id: toolResult.toolCallId,
+      output: stringifyResponsePayload(toolResult.result)
+    };
+    outputItems.set(outputIndex, item);
+    return [
+      ...events,
+      createResponseSseEvent({
+        type: "response.output_item.added",
+        output_index: outputIndex,
+        item
+      }),
+      createResponseSseEvent({
+        type: "response.output_item.done",
+        output_index: outputIndex,
+        item
+      })
+    ];
+  };
+  return {
+    get text() {
+      return text;
+    },
+    getOutputItems({ text: text2, status }) {
+      const items = new Map(outputItems);
+      if (text2) {
+        const messageOutputIndex = textOutputIndex ?? nextOutputIndex;
+        items.set(messageOutputIndex, createOutputMessage({ messageId: responseId, status, text: text2 }));
+      }
+      return [...items.entries()].sort(([left], [right]) => left - right).map(([, item]) => item);
+    },
+    consume(value) {
+      const textDelta = extractTextDelta(value);
+      if (textDelta) {
+        const { events, outputIndex } = ensureTextOutputItem();
+        text += textDelta;
+        return [
+          ...events,
+          createResponseSseEvent({
+            type: "response.output_text.delta",
+            output_index: outputIndex,
+            content_index: 0,
+            item_id: responseId,
+            delta: textDelta
+          })
+        ];
+      }
+      const toolCallStart = getToolCallStart(value);
+      if (toolCallStart) {
+        return ensureToolCallItem(toolCallStart).events;
+      }
+      const toolCallDelta = getToolCallDelta(value);
+      if (toolCallDelta) {
+        const existing = toolCalls.get(toolCallDelta.toolCallId);
+        if (!existing && !toolCallDelta.toolName) {
+          return [];
+        }
+        if (existing?.completed) {
+          return [];
+        }
+        const ensured = ensureToolCallItem({
+          toolCallId: toolCallDelta.toolCallId,
+          toolName: toolCallDelta.toolName ?? existing.name
+        });
+        ensured.state.argumentsText += toolCallDelta.delta;
+        ensured.state.zeroArgumentInputEnded = false;
+        return [
+          ...ensured.events,
+          createResponseSseEvent({
+            type: "response.function_call_arguments.delta",
+            item_id: ensured.state.itemId,
+            output_index: ensured.state.outputIndex,
+            delta: toolCallDelta.delta
+          })
+        ];
+      }
+      const toolCallEnd = getToolCallEnd(value);
+      if (toolCallEnd) {
+        const state = toolCalls.get(toolCallEnd.toolCallId);
+        if (!state || state.completed) {
+          return [];
+        }
+        state.zeroArgumentInputEnded = !state.argumentsText;
+        return [];
+      }
+      const toolCall = getToolCall(value);
+      if (toolCall) {
+        const { events, state } = ensureToolCallItem(toolCall);
+        const canonicalArgs = stringifyFunctionCallArguments(toolCall.args, state.argumentsText);
+        if (state.completed) {
+          const nextEvents2 = completeToolCallItem({
+            events,
+            state,
+            toolCallId: toolCall.toolCallId,
+            toolName: toolCall.toolName,
+            args: canonicalArgs
+          });
+          const pendingToolResult2 = pendingToolResults.get(toolCall.toolCallId);
+          return pendingToolResult2 ? completeToolResultItem({ events: nextEvents2, toolResult: pendingToolResult2 }) : nextEvents2;
+        }
+        const remainingArgsDelta = getRemainingArgumentsDelta(state.argumentsText, canonicalArgs);
+        const args = remainingArgsDelta === null ? (
+          // If both strings are valid but disagree, keep the bytes already emitted
+          // as deltas so arguments.done and response.output stay consistent.
+          isCompleteJsonString(state.argumentsText) ? state.argumentsText : canonicalArgs
+        ) : state.argumentsText + remainingArgsDelta;
+        const nextEvents = remainingArgsDelta ? [
+          ...events,
+          createResponseSseEvent({
+            type: "response.function_call_arguments.delta",
+            item_id: state.itemId,
+            output_index: state.outputIndex,
+            delta: remainingArgsDelta
+          })
+        ] : events;
+        const completedEvents = completeToolCallItem({
+          events: nextEvents,
+          state,
+          toolCallId: toolCall.toolCallId,
+          toolName: toolCall.toolName,
+          args
+        });
+        const pendingToolResult = pendingToolResults.get(toolCall.toolCallId);
+        return pendingToolResult ? completeToolResultItem({ events: completedEvents, toolResult: pendingToolResult }) : completedEvents;
+      }
+      const toolResult = getToolResult(value);
+      if (toolResult) {
+        const existingToolCallState = toolCalls.get(toolResult.toolCallId);
+        if (!existingToolCallState && !toolResult.toolName) {
+          return [];
+        }
+        const { events: toolCallEvents, state: toolCallState } = ensureToolCallItem({
+          toolCallId: toolResult.toolCallId,
+          toolName: toolResult.toolName ?? existingToolCallState.name
+        });
+        if (completedToolResultCallIds.has(toolResult.toolCallId)) {
+          return [];
+        }
+        const events = [...toolCallEvents];
+        if (!toolCallState.completed) {
+          const args = stringifyFunctionCallArguments(toolResult.args, toolCallState.argumentsText || "{}");
+          const hasZeroArgumentHint = toolCallState.zeroArgumentInputEnded && !toolCallState.argumentsText;
+          if (toolResult.args === void 0 && !hasZeroArgumentHint && (!toolCallState.argumentsText || !isCompleteJsonString(toolCallState.argumentsText))) {
+            pendingToolResults.set(toolResult.toolCallId, toolResult);
+            return events;
+          }
+          events.push(
+            ...completeToolCallItem({
+              events: [],
+              state: toolCallState,
+              toolCallId: toolResult.toolCallId,
+              toolName: toolResult.toolName ?? toolCallState.name,
+              args
+            })
+          );
+        }
+        return completeToolResultItem({ events, toolResult });
+      }
+      return [];
+    },
+    flushPendingToolResults() {
+      const events = [];
+      for (const toolResult of pendingToolResults.values()) {
+        const toolCallState = toolCalls.get(toolResult.toolCallId);
+        if (!toolCallState) {
+          continue;
+        }
+        if (!toolCallState.completed) {
+          const safeFallbackArgs = isCompleteJsonString(toolCallState.argumentsText) ? toolCallState.argumentsText : "{}";
+          events.push(
+            ...completeToolCallItem({
+              events: [],
+              state: toolCallState,
+              toolCallId: toolResult.toolCallId,
+              toolName: toolResult.toolName ?? toolCallState.name,
+              args: stringifyFunctionCallArguments(toolResult.args, safeFallbackArgs)
+            })
+          );
+        }
+        events.push(...completeToolResultItem({ events: [], toolResult }));
+      }
+      return events;
+    },
+    completeText(text2, completedItem) {
+      const { events, outputIndex } = ensureTextOutputItem();
+      const completedTextItem = {
+        ...completedItem,
+        content: [createOutputTextPart(text2)]
+      };
+      return [
+        ...events,
+        createResponseSseEvent({
+          type: "response.output_text.done",
+          output_index: outputIndex,
+          content_index: 0,
+          item_id: responseId,
+          text: text2
+        }),
+        createResponseSseEvent({
+          type: "response.content_part.done",
+          output_index: outputIndex,
+          content_index: 0,
+          item_id: responseId,
+          part: createOutputTextPart(text2)
+        }),
+        createResponseSseEvent({
+          type: "response.output_item.done",
+          output_index: outputIndex,
+          item: completedTextItem
+        })
+      ];
+    }
+  };
+}
+
+exports.buildCompletedResponse = buildCompletedResponse;
+exports.buildInProgressResponse = buildInProgressResponse;
+exports.createMessageId = createMessageId;
+exports.createOutputTextPart = createOutputTextPart;
+exports.createResponseStreamEventTranslator = createResponseStreamEventTranslator;
+exports.extractTextDelta = extractTextDelta;
+exports.formatSseEvent = formatSseEvent;
+exports.mapMastraMessagesToConversationItems = mapMastraMessagesToConversationItems;
+exports.mapMastraMessagesToResponseOutputItems = mapMastraMessagesToResponseOutputItems;
+exports.mapMastraToolsToResponseTools = mapMastraToolsToResponseTools;
+exports.mapResponseInputToExecutionMessages = mapResponseInputToExecutionMessages;
+exports.mapResponseTurnRecordToResponse = mapResponseTurnRecordToResponse;
+exports.toResponseStatus = toResponseStatus;
+exports.toResponseUsage = toResponseUsage;
+//# sourceMappingURL=chunk-F3HP5HM6.cjs.map
+//# sourceMappingURL=chunk-F3HP5HM6.cjs.map