privateer-agent 0.15.4 → 0.15.6

package/dist-boot/c-4D5UMWVW.mjs

@@ -0,0 +1,683 @@
+import{createRequire as __pvCR}from"node:module";import{fileURLToPath as __pvF}from"node:url";import{dirname as __pvD}from"node:path";const require=__pvCR(import.meta.url);const __pvUrl=(r)=>new URL(r,import.meta.url).href;const __pvFile=(r)=>__pvF(new URL(r,import.meta.url));
+import {
+  shortHash
+} from "./c-BKF2O6BL.mjs";
+import {
+  appendGrammarToolInputJsonDelta,
+  getGrammarToolInput,
+  getJsonSchemaToolParameters,
+  resolveGrammarConstrainedSampling,
+  resolveJsonSchemaStrictSampling,
+  transformMessages
+} from "./c-C6S2YB53.mjs";
+import {
+  sanitizeSurrogates
+} from "./c-5GV3X3RB.mjs";
+import {
+  parseStreamingJson,
+  parseToolCallArguments
+} from "./c-DEE67DJO.mjs";
+import {
+  calculateCost,
+  getSystemMessageText,
+  renderSystemMessageUpdate,
+  resolveTranscript,
+  resolveTranscriptTools
+} from "./c-WO3QSZUU.mjs";
+import {
+  __name
+} from "./c-CN77DCGF.mjs";
+
+// node_modules/@earendil-works/pi-ai/dist/api/openai-responses-shared.js
+function encodeTextSignatureV1(id, phase) {
+  const payload = { v: 1, id };
+  if (phase)
+    payload.phase = phase;
+  return JSON.stringify(payload);
+}
+__name(encodeTextSignatureV1, "encodeTextSignatureV1");
+function parseTextSignature(signature) {
+  if (!signature)
+    return void 0;
+  if (signature.startsWith("{")) {
+    try {
+      const parsed = JSON.parse(signature);
+      if (parsed.v === 1 && typeof parsed.id === "string") {
+        if (parsed.phase === "commentary" || parsed.phase === "final_answer") {
+          return { id: parsed.id, phase: parsed.phase };
+        }
+        return { id: parsed.id };
+      }
+    } catch {
+    }
+  }
+  return { id: signature };
+}
+__name(parseTextSignature, "parseTextSignature");
+function convertToolResultOutput(model, content) {
+  const textResult = content.filter((c) => c.type === "text").map((c) => c.text).join("\n");
+  const images = content.filter((c) => c.type === "image");
+  const hasText = textResult.length > 0;
+  if (images.length === 0 || !model.input.includes("image")) {
+    return sanitizeSurrogates(hasText ? textResult : images.length > 0 ? "(see attached image)" : "(no tool output)");
+  }
+  const output = [];
+  if (hasText) {
+    output.push({ type: "input_text", text: sanitizeSurrogates(textResult) });
+  }
+  for (const image of images) {
+    output.push({
+      type: "input_image",
+      detail: "auto",
+      image_url: `data:${image.mimeType};base64,${image.data}`
+    });
+  }
+  return output;
+}
+__name(convertToolResultOutput, "convertToolResultOutput");
+function convertResponsesMessages(model, context, allowedToolCallProviders, options) {
+  const normalizedContext = resolveTranscript(context, options?.supportsMidConvoSystemMessages);
+  const messages = [];
+  const normalizeIdPart = /* @__PURE__ */ __name((part) => {
+    const sanitized = part.replace(/[^a-zA-Z0-9_-]/g, "_");
+    const normalized = sanitized.length > 64 ? sanitized.slice(0, 64) : sanitized;
+    return normalized.replace(/_+$/, "");
+  }, "normalizeIdPart");
+  const buildForeignResponsesItemId = /* @__PURE__ */ __name((itemId) => {
+    const normalized = `fc_${shortHash(itemId)}`;
+    return normalized.length > 64 ? normalized.slice(0, 64) : normalized;
+  }, "buildForeignResponsesItemId");
+  const normalizeToolCallId = /* @__PURE__ */ __name((id, _targetModel, source) => {
+    if (!allowedToolCallProviders.has(model.provider))
+      return normalizeIdPart(id);
+    if (!id.includes("|"))
+      return normalizeIdPart(id);
+    const [callId, itemId] = id.split("|");
+    const normalizedCallId = normalizeIdPart(callId);
+    const isForeignToolCall = source.provider !== model.provider || source.api !== model.api;
+    let normalizedItemId = isForeignToolCall ? buildForeignResponsesItemId(itemId) : normalizeIdPart(itemId);
+    if (!normalizedItemId.startsWith("fc_")) {
+      normalizedItemId = normalizeIdPart(`fc_${normalizedItemId}`);
+    }
+    return `${normalizedCallId}|${normalizedItemId}`;
+  }, "normalizeToolCallId");
+  const transformedMessages = transformMessages(normalizedContext.messages, model, normalizeToolCallId);
+  const transcriptTools = resolveTranscriptTools(normalizedContext.messages, (options?.supportsAdditionalTools ?? false) || (options?.supportsToolSearch ?? false));
+  const appendSystemToolAdditions = /* @__PURE__ */ __name((message, seed) => {
+    const tools = transcriptTools.anchorsAdditions ? message.toolsAdded ?? [] : [];
+    if (tools.length === 0)
+      return;
+    if (options?.supportsAdditionalTools) {
+      messages.push({
+        type: "additional_tools",
+        role: "developer",
+        tools: convertResponsesTools(tools, options.toolOptions)
+      });
+      return;
+    }
+    if (!options?.supportsToolSearch)
+      return;
+    const names = tools.map((tool) => tool.name);
+    const callId = `pi_tool_load_${shortHash(`${seed}:${names.join(",")}`)}`;
+    messages.push({
+      type: "tool_search_call",
+      call_id: callId,
+      execution: "client",
+      status: "completed",
+      arguments: { query: names.join(" "), limit: names.length }
+    });
+    messages.push({
+      type: "tool_search_output",
+      call_id: callId,
+      execution: "client",
+      status: "completed",
+      tools: convertResponsesTools(tools, { ...options.toolOptions, toolSearchResult: true })
+    });
+  }, "appendSystemToolAdditions");
+  const includeInitialSystemMessage = options?.includeSystemPrompt ?? true;
+  const pushConfigurationUpdate = /* @__PURE__ */ __name((effort) => {
+    messages.push({
+      type: "configuration_update",
+      reasoning: { effort }
+    });
+  }, "pushConfigurationUpdate");
+  const compat = model.compat;
+  const instructionRole = model.reasoning && compat?.supportsDeveloperRole !== false ? "developer" : "system";
+  let msgIndex = 0;
+  let sourceIndex = 0;
+  for (const msg of transformedMessages) {
+    const isLeadingSystemMessage = sourceIndex++ === 0 && msg.role === "system";
+    if (msg.role === "system") {
+      if (!isLeadingSystemMessage)
+        appendSystemToolAdditions(msg, `system:${msgIndex}`);
+      if (!isLeadingSystemMessage || includeInitialSystemMessage) {
+        const text = isLeadingSystemMessage ? getSystemMessageText(msg) : renderSystemMessageUpdate(msg);
+        if (text.length > 0) {
+          messages.push({ role: instructionRole, content: sanitizeSurrogates(text) });
+        }
+      }
+    } else if (msg.role === "user") {
+      if (typeof msg.content === "string") {
+        messages.push({
+          role: "user",
+          content: [{ type: "input_text", text: sanitizeSurrogates(msg.content) }]
+        });
+      } else {
+        const content = msg.content.map((item) => {
+          if (item.type === "text") {
+            return {
+              type: "input_text",
+              text: sanitizeSurrogates(item.text)
+            };
+          }
+          return {
+            type: "input_image",
+            detail: "auto",
+            image_url: `data:${item.mimeType};base64,${item.data}`
+          };
+        });
+        if (content.length === 0)
+          continue;
+        messages.push({
+          role: "user",
+          content
+        });
+      }
+    } else if (msg.role === "assistant") {
+      const output = [];
+      const assistantMsg = msg;
+      const isSameProviderAndApi = assistantMsg.provider === model.provider && assistantMsg.api === model.api;
+      const isSameModel = isSameProviderAndApi && assistantMsg.model === model.id;
+      const isDifferentModel = isSameProviderAndApi && assistantMsg.model !== model.id;
+      let textBlockIndex = 0;
+      for (const block of msg.content) {
+        if (block.type === "thinking") {
+          if (block.thinkingSignature) {
+            const reasoningItem = JSON.parse(block.thinkingSignature);
+            output.push(reasoningItem);
+          }
+        } else if (block.type === "text") {
+          const textBlock = block;
+          const parsedSignature = parseTextSignature(textBlock.textSignature);
+          const fallbackMessageId = textBlockIndex === 0 ? `msg_pi_${msgIndex}` : `msg_pi_${msgIndex}_${textBlockIndex}`;
+          textBlockIndex++;
+          let msgId = parsedSignature?.id;
+          if (!msgId) {
+            msgId = fallbackMessageId;
+          } else if (msgId.length > 64) {
+            msgId = `msg_${shortHash(msgId)}`;
+          }
+          output.push({
+            type: "message",
+            role: "assistant",
+            content: [{ type: "output_text", text: sanitizeSurrogates(textBlock.text), annotations: [] }],
+            status: "completed",
+            id: msgId,
+            phase: parsedSignature?.phase
+          });
+        } else if (block.type === "toolCall") {
+          const toolCall = block;
+          const [callId, itemIdRaw] = toolCall.id.split("|");
+          const customInputProperty = options?.grammarToolInputProperties?.get(toolCall.name);
+          let itemId = itemIdRaw;
+          const itemIdPrefix = customInputProperty === void 0 ? "fc_" : "ctc_";
+          if (isDifferentModel || !itemId?.startsWith(itemIdPrefix)) {
+            itemId = void 0;
+          }
+          if (customInputProperty !== void 0) {
+            output.push({
+              type: "custom_tool_call",
+              id: itemId,
+              call_id: callId,
+              name: toolCall.name,
+              input: sanitizeSurrogates(getGrammarToolInput(toolCall.name, toolCall.arguments, customInputProperty)),
+              ...isSameModel && toolCall.namespace !== void 0 ? { namespace: toolCall.namespace } : {}
+            });
+          } else {
+            output.push({
+              type: "function_call",
+              id: itemId,
+              call_id: callId,
+              name: toolCall.name,
+              arguments: JSON.stringify(toolCall.arguments),
+              ...isSameModel && toolCall.namespace !== void 0 ? { namespace: toolCall.namespace } : {}
+            });
+          }
+        }
+      }
+      if (output.length === 0)
+        continue;
+      if (options?.configurationUpdateEffort !== void 0 && isSameModel && msg.providerThinkingLevel !== void 0) {
+        pushConfigurationUpdate(msg.providerThinkingLevel);
+      }
+      messages.push(...output);
+    } else if (msg.role === "toolResult") {
+      const [callId] = msg.toolCallId.split("|");
+      const output = convertToolResultOutput(model, msg.content);
+      if (options?.grammarToolInputProperties?.has(msg.toolName)) {
+        messages.push({
+          type: "custom_tool_call_output",
+          call_id: callId,
+          output
+        });
+      } else {
+        messages.push({
+          type: "function_call_output",
+          call_id: callId,
+          output
+        });
+      }
+    }
+    if (!isLeadingSystemMessage)
+      msgIndex++;
+  }
+  if (options?.configurationUpdateEffort !== void 0)
+    pushConfigurationUpdate(options.configurationUpdateEffort);
+  return messages;
+}
+__name(convertResponsesMessages, "convertResponsesMessages");
+function convertResponsesTools(tools, options) {
+  const defaultStrict = options?.strict === void 0 ? false : options.strict;
+  const supportsStrictMode = options?.supportsStrictMode ?? true;
+  const supportsOpenAIGrammarTools = options?.supportsOpenAIGrammarTools ?? false;
+  return tools.map((tool) => {
+    const grammar = resolveGrammarConstrainedSampling(tool, supportsOpenAIGrammarTools);
+    if (grammar) {
+      return {
+        type: "custom",
+        name: tool.name,
+        description: tool.description,
+        format: {
+          type: "grammar",
+          syntax: grammar.format,
+          definition: grammar.definition
+        },
+        ...options?.toolSearchResult ? { defer_loading: true } : {}
+      };
+    }
+    const constrainedStrict = resolveJsonSchemaStrictSampling(tool, supportsStrictMode);
+    const strict = constrainedStrict ?? defaultStrict;
+    const functionTool = {
+      type: "function",
+      name: tool.name,
+      description: tool.description,
+      parameters: getJsonSchemaToolParameters(tool, strict === true),
+      ...options?.toolSearchResult ? { defer_loading: true } : {}
+    };
+    if (supportsStrictMode) {
+      functionTool.strict = strict;
+    }
+    return functionTool;
+  });
+}
+__name(convertResponsesTools, "convertResponsesTools");
+function getCustomToolCallInput(block) {
+  const property = block.customInput?.property;
+  if (property === void 0)
+    return "";
+  const value = block.arguments[property];
+  return typeof value === "string" ? value : "";
+}
+__name(getCustomToolCallInput, "getCustomToolCallInput");
+function appendCustomToolCallInput(block, nextInput, close) {
+  const customInput = block.customInput;
+  if (!customInput)
+    return void 0;
+  const delta = appendGrammarToolInputJsonDelta(customInput.jsonBuffer, customInput.property, nextInput, close);
+  block.arguments = { [customInput.property]: nextInput };
+  return delta;
+}
+__name(appendCustomToolCallInput, "appendCustomToolCallInput");
+async function processResponsesStream(openaiStream, output, stream, model, options) {
+  let sawTerminalResponseEvent = false;
+  const outputSlots = /* @__PURE__ */ new Map();
+  const reasoningBlocksById = /* @__PURE__ */ new Map();
+  const applyMessagePhaseStopReason = /* @__PURE__ */ __name((item) => {
+    if (item.type === "message" && item.phase === "final_answer") {
+      output.stopReason = "stop";
+    }
+  }, "applyMessagePhaseStopReason");
+  const getSlot = /* @__PURE__ */ __name((outputIndex, type) => {
+    const slot = outputSlots.get(outputIndex);
+    return slot?.type === type ? slot : void 0;
+  }, "getSlot");
+  const pushToolCallDelta = /* @__PURE__ */ __name((slot, delta) => {
+    if (delta === void 0)
+      return;
+    stream.push({
+      type: "toolcall_delta",
+      contentIndex: slot.contentIndex,
+      delta,
+      partial: output
+    });
+  }, "pushToolCallDelta");
+  const createSlot = /* @__PURE__ */ __name((outputIndex, item) => {
+    if (item.type === "reasoning") {
+      const block = { type: "thinking", thinking: "" };
+      output.content.push(block);
+      const slot = {
+        type: "thinking",
+        block,
+        contentIndex: output.content.length - 1
+      };
+      outputSlots.set(outputIndex, slot);
+      stream.push({ type: "thinking_start", contentIndex: slot.contentIndex, partial: output });
+      return slot;
+    }
+    if (item.type === "message") {
+      applyMessagePhaseStopReason(item);
+      const block = { type: "text", text: "" };
+      output.content.push(block);
+      const slot = { type: "text", block, contentIndex: output.content.length - 1 };
+      outputSlots.set(outputIndex, slot);
+      stream.push({ type: "text_start", contentIndex: slot.contentIndex, partial: output });
+      return slot;
+    }
+    if (item.type === "function_call") {
+      const block = {
+        type: "toolCall",
+        id: `${item.call_id}|${item.id}`,
+        name: item.name,
+        arguments: {},
+        ...item.namespace !== void 0 ? { namespace: item.namespace } : {},
+        partialJson: item.arguments || ""
+      };
+      output.content.push(block);
+      const slot = {
+        type: "toolCall",
+        block,
+        contentIndex: output.content.length - 1
+      };
+      outputSlots.set(outputIndex, slot);
+      stream.push({ type: "toolcall_start", contentIndex: slot.contentIndex, partial: output });
+      return slot;
+    }
+    if (item.type === "custom_tool_call") {
+      const inputProperty = options?.grammarToolInputProperties?.get(item.name) ?? "input";
+      const input = item.input || "";
+      const block = {
+        type: "toolCall",
+        id: `${item.call_id}|${item.id}`,
+        name: item.name,
+        arguments: { [inputProperty]: input },
+        ...item.namespace !== void 0 ? { namespace: item.namespace } : {},
+        customInput: {
+          property: inputProperty,
+          jsonBuffer: { input: "", started: false, closed: false }
+        }
+      };
+      output.content.push(block);
+      const slot = {
+        type: "toolCall",
+        block,
+        contentIndex: output.content.length - 1
+      };
+      outputSlots.set(outputIndex, slot);
+      stream.push({ type: "toolcall_start", contentIndex: slot.contentIndex, partial: output });
+      return slot;
+    }
+    return void 0;
+  }, "createSlot");
+  const getOrCreateSlot = /* @__PURE__ */ __name((outputIndex, item) => {
+    return outputSlots.get(outputIndex) ?? createSlot(outputIndex, item);
+  }, "getOrCreateSlot");
+  const backfillReasoningSignatures = /* @__PURE__ */ __name((responseOutput) => {
+    for (const item of responseOutput) {
+      if (item.type !== "reasoning" || !item.encrypted_content)
+        continue;
+      const block = reasoningBlocksById.get(item.id);
+      if (!block?.thinkingSignature)
+        continue;
+      const storedItem = JSON.parse(block.thinkingSignature);
+      if (storedItem.encrypted_content)
+        continue;
+      block.thinkingSignature = JSON.stringify({
+        ...storedItem,
+        encrypted_content: item.encrypted_content
+      });
+    }
+  }, "backfillReasoningSignatures");
+  const finalizeResponse = /* @__PURE__ */ __name((response) => {
+    sawTerminalResponseEvent = true;
+    backfillReasoningSignatures(response.output ?? []);
+    if (response?.id) {
+      output.responseId = response.id;
+    }
+    if (response?.usage) {
+      const inputDetails = response.usage.input_tokens_details;
+      const cachedTokens = inputDetails?.cached_tokens || 0;
+      const cacheWriteTokens = inputDetails?.cache_write_tokens || 0;
+      output.usage = {
+        // OpenAI includes cached and cache-write tokens in input_tokens, so subtract both.
+        input: Math.max(0, (response.usage.input_tokens || 0) - cachedTokens - cacheWriteTokens),
+        output: response.usage.output_tokens || 0,
+        cacheRead: cachedTokens,
+        cacheWrite: cacheWriteTokens,
+        reasoning: response.usage.output_tokens_details?.reasoning_tokens || 0,
+        totalTokens: response.usage.total_tokens || 0,
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 }
+      };
+    }
+    calculateCost(model, output.usage);
+    if (options?.applyServiceTierPricing) {
+      const serviceTier = options.resolveServiceTier ? options.resolveServiceTier(response?.service_tier, options.serviceTier) : response?.service_tier ?? options.serviceTier;
+      options.applyServiceTierPricing(output.usage, serviceTier);
+    }
+    const status = response?.status;
+    const incompleteDetails = response?.incomplete_details;
+    const incompleteReason = typeof incompleteDetails?.reason === "string" ? incompleteDetails.reason : void 0;
+    output.rawStopReason = incompleteReason ? `${status}.${incompleteReason}` : status;
+    const mappedStop = mapStopReason(status, incompleteReason);
+    output.stopReason = mappedStop.stopReason;
+    if (mappedStop.errorMessage === void 0)
+      delete output.errorMessage;
+    else
+      output.errorMessage = mappedStop.errorMessage;
+    if (output.content.some((b) => b.type === "toolCall") && output.stopReason === "stop") {
+      output.stopReason = "toolUse";
+    }
+  }, "finalizeResponse");
+  for await (const event of openaiStream) {
+    await options?.onProviderStreamEvent?.(event, model);
+    if (event.type === "response.created") {
+      output.responseId = event.response.id;
+    } else if (event.type === "response.output_item.added") {
+      createSlot(event.output_index, event.item);
+    } else if (event.type === "response.reasoning_summary_text.delta") {
+      const slot = getSlot(event.output_index, "thinking");
+      if (!slot)
+        continue;
+      slot.block.thinking += event.delta;
+      stream.push({
+        type: "thinking_delta",
+        contentIndex: slot.contentIndex,
+        delta: event.delta,
+        partial: output
+      });
+    } else if (event.type === "response.reasoning_summary_part.done") {
+      const slot = getSlot(event.output_index, "thinking");
+      if (!slot)
+        continue;
+      slot.block.thinking += "\n\n";
+      stream.push({
+        type: "thinking_delta",
+        contentIndex: slot.contentIndex,
+        delta: "\n\n",
+        partial: output
+      });
+    } else if (event.type === "response.reasoning_text.delta") {
+      const slot = getSlot(event.output_index, "thinking");
+      if (!slot)
+        continue;
+      slot.block.thinking += event.delta;
+      stream.push({
+        type: "thinking_delta",
+        contentIndex: slot.contentIndex,
+        delta: event.delta,
+        partial: output
+      });
+    } else if (event.type === "response.output_text.delta") {
+      const slot = getSlot(event.output_index, "text");
+      if (!slot)
+        continue;
+      slot.block.text += event.delta;
+      stream.push({
+        type: "text_delta",
+        contentIndex: slot.contentIndex,
+        delta: event.delta,
+        partial: output
+      });
+    } else if (event.type === "response.refusal.delta") {
+      const slot = getSlot(event.output_index, "text");
+      if (!slot)
+        continue;
+      slot.block.text += event.delta;
+      stream.push({
+        type: "text_delta",
+        contentIndex: slot.contentIndex,
+        delta: event.delta,
+        partial: output
+      });
+    } else if (event.type === "response.function_call_arguments.delta") {
+      const slot = getSlot(event.output_index, "toolCall");
+      if (!slot || slot.block.partialJson === void 0)
+        continue;
+      slot.block.partialJson += event.delta;
+      slot.block.arguments = parseStreamingJson(slot.block.partialJson);
+      pushToolCallDelta(slot, event.delta);
+    } else if (event.type === "response.function_call_arguments.done") {
+      const slot = getSlot(event.output_index, "toolCall");
+      if (!slot || slot.block.partialJson === void 0)
+        continue;
+      const previousPartialJson = slot.block.partialJson;
+      slot.block.partialJson = event.arguments;
+      slot.block.arguments = parseStreamingJson(slot.block.partialJson);
+      if (event.arguments.startsWith(previousPartialJson)) {
+        const delta = event.arguments.slice(previousPartialJson.length);
+        if (delta.length > 0)
+          pushToolCallDelta(slot, delta);
+      }
+    } else if (event.type === "response.custom_tool_call_input.delta") {
+      const slot = getSlot(event.output_index, "toolCall");
+      if (!slot || !slot.block.customInput)
+        continue;
+      pushToolCallDelta(slot, appendCustomToolCallInput(slot.block, getCustomToolCallInput(slot.block) + event.delta, false));
+    } else if (event.type === "response.custom_tool_call_input.done") {
+      const slot = getSlot(event.output_index, "toolCall");
+      if (!slot || !slot.block.customInput)
+        continue;
+      pushToolCallDelta(slot, appendCustomToolCallInput(slot.block, event.input, true));
+    } else if (event.type === "response.output_item.done") {
+      const item = event.item;
+      applyMessagePhaseStopReason(item);
+      const slot = getOrCreateSlot(event.output_index, item);
+      if (item.type === "reasoning" && slot?.type === "thinking") {
+        const summaryText = item.summary?.map((s) => s.text).join("\n\n") || "";
+        const contentText = item.content?.map((c) => c.text).join("\n\n") || "";
+        slot.block.thinking = summaryText || contentText || slot.block.thinking;
+        slot.block.thinkingSignature = JSON.stringify(item);
+        reasoningBlocksById.set(item.id, slot.block);
+        stream.push({
+          type: "thinking_end",
+          contentIndex: slot.contentIndex,
+          content: slot.block.thinking,
+          partial: output
+        });
+        outputSlots.delete(event.output_index);
+      } else if (item.type === "message" && slot?.type === "text") {
+        slot.block.text = item.content?.map((c) => c.type === "output_text" ? c.text : c.refusal).join("") || "";
+        slot.block.textSignature = encodeTextSignatureV1(item.id, item.phase ?? void 0);
+        stream.push({
+          type: "text_end",
+          contentIndex: slot.contentIndex,
+          content: slot.block.text,
+          partial: output
+        });
+        outputSlots.delete(event.output_index);
+      } else if (item.type === "function_call" && slot?.type === "toolCall" && slot.block.partialJson !== void 0) {
+        Object.assign(slot.block, parseToolCallArguments(item.arguments || slot.block.partialJson));
+        if (item.namespace !== void 0)
+          slot.block.namespace = item.namespace;
+        delete slot.block.partialJson;
+        stream.push({
+          type: "toolcall_end",
+          contentIndex: slot.contentIndex,
+          toolCall: slot.block,
+          partial: output
+        });
+        outputSlots.delete(event.output_index);
+      } else if (item.type === "custom_tool_call" && slot?.type === "toolCall" && slot.block.customInput) {
+        pushToolCallDelta(slot, appendCustomToolCallInput(slot.block, item.input ?? getCustomToolCallInput(slot.block), true));
+        if (item.namespace !== void 0)
+          slot.block.namespace = item.namespace;
+        delete slot.block.customInput;
+        stream.push({
+          type: "toolcall_end",
+          contentIndex: slot.contentIndex,
+          toolCall: slot.block,
+          partial: output
+        });
+        outputSlots.delete(event.output_index);
+      }
+    } else if (event.type === "response.completed" || event.type === "response.incomplete") {
+      finalizeResponse(event.response);
+    } else if (event.type === "error") {
+      throw new Error(`Error Code ${event.code}: ${event.message}` || "Unknown error");
+    } else if (event.type === "response.failed") {
+      sawTerminalResponseEvent = true;
+      output.rawStopReason = event.response?.status;
+      const error = event.response?.error;
+      const details = event.response?.incomplete_details;
+      const msg = error ? `${error.code || "unknown"}: ${error.message || "no message"}` : details?.reason ? `incomplete: ${details.reason}` : "Unknown error (no error details in response)";
+      throw new Error(msg);
+    }
+  }
+  if (!sawTerminalResponseEvent) {
+    throw new Error("OpenAI Responses stream ended before a terminal response event");
+  }
+  if (output.stopReason === "toolUse") {
+    for (const block of output.content) {
+      if (block.type !== "toolCall")
+        continue;
+      const toolCall = block;
+      if (toolCall.partialJson !== void 0 || toolCall.customInput !== void 0) {
+        throw new Error(`OpenAI Responses stream completed with an unfinished tool call: ${toolCall.name} (${toolCall.id})`);
+      }
+    }
+  }
+}
+__name(processResponsesStream, "processResponsesStream");
+function mapStopReason(status, incompleteReason) {
+  if (!status)
+    return { stopReason: "stop" };
+  switch (status) {
+    case "completed":
+      return { stopReason: "stop" };
+    case "incomplete":
+      if (incompleteReason === "max_output_tokens") {
+        return { stopReason: "length" };
+      }
+      return {
+        stopReason: "error",
+        errorMessage: incompleteReason ? `Response incomplete: ${incompleteReason}` : "Response incomplete without a provider reason"
+      };
+    case "failed":
+    case "cancelled":
+      return { stopReason: "error" };
+    // These two are wonky ...
+    case "in_progress":
+    case "queued":
+      return { stopReason: "stop" };
+    default: {
+      const _exhaustive = status;
+      throw new Error(`Unhandled stop reason: ${_exhaustive}`);
+    }
+  }
+}
+__name(mapStopReason, "mapStopReason");
+
+export {
+  convertResponsesMessages,
+  convertResponsesTools,
+  processResponsesStream
+};