@nyte-ai/ai 0.0.0-stage → 0.0.18

package/dist/chunks/account-limits-cache-53e64mhx.js

@@ -0,0 +1,417 @@
+import {
+  calculateCost2
+} from "./account-limits-cache-zgzptd0z.js";
+import {
+  parseStreamingJson2,
+  parseToolCallArguments2,
+  unfinishedToolCallArguments2
+} from "./account-limits-cache-fbkaq46e.js";
+import {
+  appendGrammarToolInputJsonDelta2
+} from "./account-limits-cache-h92bzz1j.js";
+import {
+  emptyCost2,
+  stripStreamingScratchState2
+} from "./account-limits-cache-fsktnetm.js";
+import {
+  TokenCount2
+} from "./account-limits-cache-736tdyme.js";
+import {
+  encodeTextSignatureV12
+} from "./account-limits-cache-n3yk6g5c.js";
+import {
+  TerminalReasoningItemSchema2,
+  StoredReasoningItemSchema2,
+  ServiceTierSchema2,
+  ResponsesStreamEventCheck2
+} from "./account-limits-cache-a558rjbg.js";
+
+// src/api/openai-responses-stream.ts
+import { Type } from "typebox";
+import { Value } from "typebox/value";
+function withPriorityTier2(options) {
+  return options?.fast === true && options.serviceTier === undefined ? { ...options, serviceTier: "priority" } : options;
+}
+
+class ResponsesUsageError2 extends Error {
+}
+var responseUsage = Type.Object({
+  input_tokens: Type.Optional(TokenCount2),
+  output_tokens: Type.Optional(TokenCount2),
+  total_tokens: Type.Optional(TokenCount2),
+  input_tokens_details: Type.Optional(Type.Object({
+    cached_tokens: Type.Optional(TokenCount2),
+    cache_write_tokens: Type.Optional(TokenCount2)
+  })),
+  output_tokens_details: Type.Optional(Type.Object({ reasoning_tokens: Type.Optional(TokenCount2) }))
+});
+function appendCustomToolCallInput(block, nextInput, close) {
+  const customInput = block.customInput;
+  if (!customInput)
+    return;
+  const delta = appendGrammarToolInputJsonDelta2(customInput.jsonBuffer, customInput.property, nextInput, close);
+  customInput.input = nextInput;
+  block.arguments = { [customInput.property]: nextInput };
+  return delta;
+}
+async function processResponsesStream2(openaiStream, output, stream, model, options) {
+  let sawTerminalResponseEvent = false;
+  const outputSlots = new Map;
+  const unfinishedToolCalls = new Set;
+  const reasoningBlocksById = new Map;
+  const applyMessagePhaseStopReason = (item) => {
+    if (item.type === "message" && item.phase === "final_answer") {
+      output.stopReason = "stop";
+    }
+  };
+  const pushToolCallDelta = (slot, delta) => {
+    if (delta === undefined)
+      return;
+    stream.push({
+      type: "toolcall_delta",
+      contentIndex: slot.contentIndex,
+      delta,
+      partial: output
+    });
+  };
+  const createSlot = (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: {},
+        partialJson: item.arguments || ""
+      };
+      if (item.namespace !== undefined)
+        block.namespace = item.namespace;
+      output.content.push(block);
+      const slot = {
+        type: "toolCall",
+        block,
+        contentIndex: output.content.length - 1
+      };
+      outputSlots.set(outputIndex, slot);
+      unfinishedToolCalls.add(block);
+      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 },
+        customInput: {
+          property: inputProperty,
+          input,
+          jsonBuffer: { input: "", started: false, closed: false }
+        }
+      };
+      if (item.namespace !== undefined)
+        block.namespace = item.namespace;
+      output.content.push(block);
+      const slot = {
+        type: "toolCall",
+        block,
+        contentIndex: output.content.length - 1
+      };
+      outputSlots.set(outputIndex, slot);
+      unfinishedToolCalls.add(block);
+      stream.push({ type: "toolcall_start", contentIndex: slot.contentIndex, partial: output });
+      return slot;
+    }
+    return;
+  };
+  const getOrCreateSlot = (outputIndex, item) => {
+    return outputSlots.get(outputIndex) ?? createSlot(outputIndex, item);
+  };
+  const backfillReasoningSignatures = (responseOutput) => {
+    for (const item of responseOutput) {
+      if (!Value.Check(TerminalReasoningItemSchema2, item) || !item.encrypted_content)
+        continue;
+      const block = reasoningBlocksById.get(item.id);
+      if (!block?.thinkingSignature)
+        continue;
+      const storedItem = JSON.parse(block.thinkingSignature);
+      if (!Value.Check(StoredReasoningItemSchema2, storedItem) || storedItem.encrypted_content) {
+        continue;
+      }
+      block.thinkingSignature = JSON.stringify({
+        ...storedItem,
+        encrypted_content: item.encrypted_content
+      });
+    }
+  };
+  const finalizeResponse = (response) => {
+    sawTerminalResponseEvent = true;
+    backfillReasoningSignatures(response.output ?? []);
+    if (response?.id) {
+      output.responseId = response.id;
+    }
+    const usage = response.usage;
+    if (usage !== undefined && usage !== null) {
+      if (!Value.Check(responseUsage, usage)) {
+        throw new ResponsesUsageError2("Invalid OpenAI Responses usage: expected finite non-negative integer token counts");
+      }
+      const cachedTokens = usage.input_tokens_details?.cached_tokens ?? 0;
+      const cacheWriteTokens = usage.input_tokens_details?.cache_write_tokens ?? 0;
+      output.usage = {
+        input: Math.max(0, (usage.input_tokens ?? 0) - cachedTokens - cacheWriteTokens),
+        output: usage.output_tokens ?? 0,
+        cacheRead: cachedTokens,
+        cacheWrite: cacheWriteTokens,
+        reasoning: usage.output_tokens_details?.reasoning_tokens ?? 0,
+        totalTokens: usage.total_tokens ?? 0,
+        cost: emptyCost2()
+      };
+    }
+    calculateCost2(model, output.usage);
+    if (options?.applyServiceTierPricing) {
+      const responseTier = Value.Check(ServiceTierSchema2, response.service_tier) ? response.service_tier : undefined;
+      const serviceTier = options.resolveServiceTier ? options.resolveServiceTier(responseTier, options.serviceTier) : responseTier ?? options.serviceTier;
+      options.applyServiceTierPricing(output.usage, serviceTier);
+    }
+    const status = response?.status;
+    const incompleteReason = response.incomplete_details?.reason;
+    output.rawStopReason = incompleteReason ? `${status}.${incompleteReason}` : status;
+    const mappedStop = mapStopReason(status, incompleteReason);
+    output.stopReason = mappedStop.stopReason;
+    output.errorMessage = mappedStop.errorMessage;
+    if (output.content.some((b) => b.type === "toolCall") && output.stopReason === "stop") {
+      output.stopReason = "toolUse";
+    }
+  };
+  for await (const event of openaiStream) {
+    if (!ResponsesStreamEventCheck2.Check(event))
+      continue;
+    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 = outputSlots.get(event.output_index);
+      if (slot?.type !== "thinking")
+        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 = outputSlots.get(event.output_index);
+      if (slot?.type !== "thinking")
+        continue;
+      slot.block.thinking += `
+
+`;
+      stream.push({
+        type: "thinking_delta",
+        contentIndex: slot.contentIndex,
+        delta: `
+
+`,
+        partial: output
+      });
+    } else if (event.type === "response.reasoning_text.delta") {
+      const slot = outputSlots.get(event.output_index);
+      if (slot?.type !== "thinking")
+        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 = outputSlots.get(event.output_index);
+      if (slot?.type !== "text")
+        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 = outputSlots.get(event.output_index);
+      if (slot?.type !== "text")
+        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 = outputSlots.get(event.output_index);
+      if (slot?.type !== "toolCall" || slot.block.partialJson === undefined)
+        continue;
+      slot.block.partialJson += event.delta;
+      slot.block.arguments = parseStreamingJson2(slot.block.partialJson);
+      pushToolCallDelta(slot, event.delta);
+    } else if (event.type === "response.function_call_arguments.done") {
+      const slot = outputSlots.get(event.output_index);
+      if (slot?.type !== "toolCall" || slot.block.partialJson === undefined)
+        continue;
+      const previousPartialJson = slot.block.partialJson;
+      slot.block.partialJson = event.arguments;
+      slot.block.arguments = parseStreamingJson2(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 = outputSlots.get(event.output_index);
+      if (slot?.type !== "toolCall" || !slot.block.customInput)
+        continue;
+      pushToolCallDelta(slot, appendCustomToolCallInput(slot.block, slot.block.customInput.input + event.delta, false));
+    } else if (event.type === "response.custom_tool_call_input.done") {
+      const slot = outputSlots.get(event.output_index);
+      if (slot?.type !== "toolCall" || !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(`
+
+`) || "";
+        const contentText = item.content?.map((c) => c.text).join(`
+
+`) || "";
+        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("") || "";
+        if (item.id !== undefined) {
+          slot.block.textSignature = encodeTextSignatureV12(item.id, item.phase ?? undefined);
+        }
+        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 !== undefined) {
+        Object.assign(slot.block, parseToolCallArguments2(item.arguments || slot.block.partialJson));
+        if (item.namespace !== undefined)
+          slot.block.namespace = item.namespace;
+        delete slot.block.partialJson;
+        unfinishedToolCalls.delete(slot.block);
+        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 ?? slot.block.customInput.input, true));
+        if (item.namespace !== undefined)
+          slot.block.namespace = item.namespace;
+        delete slot.block.customInput;
+        unfinishedToolCalls.delete(slot.block);
+        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") {
+      finalizeResponse(event.response);
+      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");
+  }
+  for (const block of unfinishedToolCalls) {
+    if (output.stopReason === "toolUse") {
+      throw new Error(`OpenAI Responses stream completed with an unfinished tool call: ${block.name} (${block.id})`);
+    }
+    Object.assign(block, unfinishedToolCallArguments2(block.partialJson ?? block.customInput?.input ?? ""));
+    stripStreamingScratchState2([block]);
+  }
+}
+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" };
+    case "in_progress":
+    case "queued":
+      return { stopReason: "stop" };
+    default: {
+      const _exhaustive = status;
+      throw new Error(`Unhandled stop reason: ${_exhaustive}`);
+    }
+  }
+}
+
+export { withPriorityTier2, ResponsesUsageError2, processResponsesStream2 };