'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