@yourgpt/llm-sdk 2.6.0-beta.3 → 2.6.0

package/dist/providers/openai/index.js

@@ -1,5 +1,7 @@
 'use strict';
 
+var crypto = require('crypto');
+
 // src/core/tool-output.ts
 var imageTypes = /* @__PURE__ */ new Set([
   "image/png",
@@ -103,6 +105,72 @@ function textToolOutput(value, fallback) {
   return toolOutputForProvider(value, "unsupported").map((part) => part.text).join("\n");
 }
 
+// src/core/provider-error.ts
+function invalidProviderResponse(message) {
+  return Object.assign(new Error(message), {
+    name: "InvalidProviderResponseError",
+    status: 502,
+    code: "INVALID_PROVIDER_RESPONSE"
+  });
+}
+function providerErrorEvent(error, code) {
+  const details = error ?? {};
+  const event = {
+    type: "error",
+    message: error instanceof Error ? error.message : String(error),
+    code,
+    ...typeof details.status === "number" ? { status: details.status } : {},
+    ...typeof details.code === "string" ? { providerCode: details.code } : {},
+    ...typeof details.param === "string" ? { param: details.param } : {},
+    ...typeof details.request_id === "string" ? { requestId: details.request_id } : {}
+  };
+  Object.defineProperty(event, "cause", { value: error, enumerable: false });
+  return event;
+}
+function errorFromEvent(event) {
+  if (event.cause instanceof Error) return event.cause;
+  return Object.assign(new Error(event.message), {
+    status: event.status,
+    code: event.providerCode ?? event.code,
+    param: event.param,
+    request_id: event.requestId
+  });
+}
+function throwIfAborted(signal) {
+  if (!signal?.aborted) return;
+  const error = new Error("The operation was aborted");
+  error.name = "AbortError";
+  throw error;
+}
+
+// src/core/tool-validation.ts
+function parseToolArguments(value) {
+  let args = value;
+  if (typeof value === "string") {
+    try {
+      args = JSON.parse(value || "{}");
+    } catch {
+      throw invalidProviderResponse("Tool arguments are not valid JSON");
+    }
+  }
+  if (args === null || typeof args !== "object" || Array.isArray(args))
+    throw invalidProviderResponse("Tool arguments must be a JSON object");
+  return args;
+}
+function validateToolCalls(calls) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const call of calls) {
+    if (!call || typeof call.id !== "string" || !call.id || typeof call.name !== "string" || !call.name || ids.has(call.id))
+      throw invalidProviderResponse(
+        "Tool calls have missing or duplicate identities"
+      );
+    ids.add(call.id);
+    if (typeof call.args === "string")
+      throw invalidProviderResponse("Parsed tool arguments must be an object");
+    parseToolArguments(call.args);
+  }
+}
+
 // src/core/openai-parameters.ts
 function capabilities(model) {
   const gpt = /^gpt-(\d+)(?:\.(\d+))?(?:-(.+))?$/i.exec(model);
@@ -113,6 +181,19 @@ function capabilities(model) {
   const supportsNone = major === 5 && minor >= 1 && !chat || /^gpt-6-(?:sol|luna)(?:-\d{4}-\d{2}-\d{2})?$/i.test(model);
   return { major, minor, reasoning, supportsNone };
 }
+function filterOpenAIResponseInclude(model, include, options = {}) {
+  const c = capabilities(model);
+  let result = include;
+  if (options.parameterPolicy !== "passthrough" && c.reasoning && !(options.reasoningEffort === "none" && c.supportsNone) && include.includes("message.output_text.logprobs")) {
+    result = include.filter(
+      (value) => value !== "message.output_text.logprobs"
+    );
+    (options.onWarning ?? console.warn)(
+      `[llm-sdk] ${model}: omitted message.output_text.logprobs because reasoning is enabled.`
+    );
+  }
+  return result.length ? result : void 0;
+}
 function requiresOpenAIResponses(model, baseUrl, options = {}) {
   if (options.parameterPolicy === "passthrough") return false;
   const c = capabilities(model);
@@ -260,44 +341,6 @@ function getResponseReplay(metadata) {
   return responseReplayMetadata(metadata)?.openai?.response?.output;
 }
 
-// src/core/provider-error.ts
-function invalidProviderResponse(message) {
-  return Object.assign(new Error(message), {
-    name: "InvalidProviderResponseError",
-    status: 502,
-    code: "INVALID_PROVIDER_RESPONSE"
-  });
-}
-function providerErrorEvent(error, code) {
-  const details = error ?? {};
-  const event = {
-    type: "error",
-    message: error instanceof Error ? error.message : String(error),
-    code,
-    ...typeof details.status === "number" ? { status: details.status } : {},
-    ...typeof details.code === "string" ? { providerCode: details.code } : {},
-    ...typeof details.param === "string" ? { param: details.param } : {},
-    ...typeof details.request_id === "string" ? { requestId: details.request_id } : {}
-  };
-  Object.defineProperty(event, "cause", { value: error, enumerable: false });
-  return event;
-}
-function errorFromEvent(event) {
-  if (event.cause instanceof Error) return event.cause;
-  return Object.assign(new Error(event.message), {
-    status: event.status,
-    code: event.providerCode ?? event.code,
-    param: event.param,
-    request_id: event.requestId
-  });
-}
-function throwIfAborted(signal) {
-  if (!signal?.aborted) return;
-  const error = new Error("The operation was aborted");
-  error.name = "AbortError";
-  throw error;
-}
-
 // src/core/utils.ts
 function generateId(prefix = "id") {
   return `${prefix}_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
@@ -305,9 +348,6 @@ function generateId(prefix = "id") {
 function generateMessageId() {
   return generateId("msg");
 }
-function generateToolCallId() {
-  return generateId("call");
-}
 
 // src/adapters/base.ts
 function stringifyForDebug(value) {
@@ -429,6 +469,7 @@ function toOpenAIResponseFormat(rf) {
   };
 }
 function toOpenAIResponsesTextFormat(rf) {
+  if (rf?.type === "json_object") return { type: "json_object" };
   if (!rf || rf.type !== "json_schema") return void 0;
   return {
     type: "json_schema",
@@ -558,6 +599,8 @@ var OpenAIAdapter = class _OpenAIAdapter {
         apiKey: this.config.apiKey,
         baseURL: this.config.baseUrl,
         organization: this.config.organization,
+        project: this.config.project,
+        timeout: this.config.timeout,
         defaultHeaders: this.config.headers
       });
     }
@@ -622,11 +665,11 @@ var OpenAIAdapter = class _OpenAIAdapter {
   }
   buildResponsesInput(request) {
     const sourceMessages = request.rawMessages && request.rawMessages.length > 0 ? this.formatRawMessages(request.rawMessages, true) : formatMessagesForOpenAI(request.messages, void 0, true);
-    const input = [];
+    const input2 = [];
     for (const message of sourceMessages) {
       if (message.role === "system") {
         if (message.content && message.content !== request.systemPrompt) {
-          input.push({
+          input2.push({
             type: "message",
             role: "developer",
             content: this.toResponsesContent(message.content, "developer")
@@ -637,12 +680,12 @@ var OpenAIAdapter = class _OpenAIAdapter {
       if (message.role === "assistant") {
         const replay = getResponseReplay(message.providerMetadata);
         if (replay) {
-          input.push(...replay);
+          input2.push(...replay);
           continue;
         }
         const content = this.toResponsesContent(message.content, "assistant");
         if (typeof content === "string" ? content : Array.isArray(content) && content.length > 0) {
-          input.push({
+          input2.push({
             type: "message",
             role: "assistant",
             content
@@ -650,7 +693,7 @@ var OpenAIAdapter = class _OpenAIAdapter {
         }
         const toolCalls = Array.isArray(message.tool_calls) ? message.tool_calls : [];
         for (const toolCall of toolCalls) {
-          input.push({
+          input2.push({
             type: "function_call",
             call_id: toolCall.id,
             name: toolCall.function?.name,
@@ -660,7 +703,7 @@ var OpenAIAdapter = class _OpenAIAdapter {
         continue;
       }
       if (message.role === "tool") {
-        input.push({
+        input2.push({
           type: "function_call_output",
           call_id: message.tool_call_id,
           output: message.modelOutput ? toolOutputForProvider(message.modelOutput, "responses") : typeof message.content === "string" ? message.content : JSON.stringify(message.content ?? null)
@@ -668,13 +711,13 @@ var OpenAIAdapter = class _OpenAIAdapter {
         continue;
       }
       const role = message.role === "developer" ? "developer" : "user";
-      input.push({
+      input2.push({
         type: "message",
         role,
         content: this.toResponsesContent(message.content, role)
       });
     }
-    return input;
+    return input2;
   }
   /** Preserve Copilot screenshot attachments on every OpenAI transport. */
   formatRawMessages(messages, preserveProviderMetadata = false) {
@@ -839,6 +882,16 @@ var OpenAIAdapter = class _OpenAIAdapter {
       request.config?.responseFormat
     );
     const modelIdForPayload = request.config?.model || this.model;
+    const include = filterOpenAIResponseInclude(
+      modelIdForPayload,
+      [
+        .../* @__PURE__ */ new Set([
+          ...options?.include ?? [],
+          ...options?.store === false ? ["reasoning.encrypted_content"] : []
+        ])
+      ],
+      this.parameterOptions(request)
+    );
     const payload = {
       model: modelIdForPayload,
       instructions: request.systemPrompt,
@@ -862,14 +915,7 @@ var OpenAIAdapter = class _OpenAIAdapter {
       ...options?.promptCacheKey !== void 0 ? { prompt_cache_key: options.promptCacheKey } : {},
       ...options?.promptCacheOptions !== void 0 ? { prompt_cache_options: options.promptCacheOptions } : {},
       ...options?.promptCacheRetention !== void 0 ? { prompt_cache_retention: options.promptCacheRetention } : {},
-      ...options?.store === false || options?.include ? {
-        include: [
-          .../* @__PURE__ */ new Set([
-            ...options?.include ?? [],
-            ...options?.store === false ? ["reasoning.encrypted_content"] : []
-          ])
-        ]
-      } : {},
+      ...include ? { include } : {},
       ...responsesTextFormat ? { text: { format: responsesTextFormat } } : {},
       stream
     };
@@ -1240,15 +1286,20 @@ var OpenAIAdapter = class _OpenAIAdapter {
       }
       throwIfAborted(request.signal);
       if (!finishReason)
-        throw new Error("OpenAI stream ended without a finish reason");
+        throw invalidProviderResponse(
+          "OpenAI stream ended without a finish reason"
+        );
       if (toolCalls.size && !["tool_calls", "function_call"].includes(finishReason)) {
-        throw new Error("OpenAI stream ended with incomplete tool calls");
-      }
-      for (const call of toolCalls.values()) {
-        if (!call.id || !call.name)
-          throw new Error("OpenAI stream contains an incomplete tool call");
-        JSON.parse(call.arguments || "{}");
+        throw invalidProviderResponse(
+          "OpenAI stream ended with incomplete tool calls"
+        );
       }
+      validateToolCalls(
+        [...toolCalls.values()].map((call) => ({
+          ...call,
+          args: parseToolArguments(call.arguments)
+        }))
+      );
       for (const call of toolCalls.values()) {
         yield {
           type: "action:start",
@@ -1332,20 +1383,20 @@ var OpenAIAdapter = class _OpenAIAdapter {
     logProviderPayload("openai", "response payload", response, request.debug);
     const choice = response.choices?.[0];
     const message = choice?.message;
+    const toolCalls = (message?.tool_calls ?? []).map((toolCall) => ({
+      id: toolCall.id,
+      name: toolCall.function?.name,
+      args: parseToolArguments(toolCall.function?.arguments ?? "{}"),
+      ...toolCall.extra_content ? { extra_content: toolCall.extra_content } : {}
+    }));
+    validateToolCalls(toolCalls);
+    if (toolCalls.length && choice?.finish_reason && !["tool_calls", "function_call"].includes(choice.finish_reason))
+      throw invalidProviderResponse(
+        "OpenAI response ended with incomplete tool calls"
+      );
     return {
       content: message?.content ?? "",
-      toolCalls: message?.tool_calls?.map((toolCall) => ({
-        id: toolCall.id ?? generateToolCallId(),
-        name: toolCall.function?.name ?? "",
-        args: (() => {
-          try {
-            return JSON.parse(toolCall.function?.arguments ?? "{}");
-          } catch {
-            return {};
-          }
-        })(),
-        ...toolCall.extra_content ? { extra_content: toolCall.extra_content } : {}
-      })) ?? [],
+      toolCalls,
       usage: response.usage ? {
         promptTokens: response.usage.prompt_tokens,
         completionTokens: response.usage.completion_tokens,
@@ -1566,9 +1617,14 @@ function openai(modelId, options = {}) {
         (tc) => ({
           id: tc.id,
           name: tc.function.name,
-          args: JSON.parse(tc.function.arguments || "{}")
+          args: parseToolArguments(tc.function.arguments)
         })
       );
+      validateToolCalls(toolCalls);
+      if (toolCalls.length && choice.finish_reason && !["tool_calls", "function_call"].includes(choice.finish_reason))
+        throw invalidProviderResponse(
+          "OpenAI response ended with incomplete tool calls"
+        );
       return {
         text: message.content ?? "",
         toolCalls,
@@ -1687,18 +1743,25 @@ function openai(modelId, options = {}) {
       }
       throwIfAborted(params.signal);
       if (!finishReason)
-        throw new Error("OpenAI stream ended without a finish reason");
+        throw invalidProviderResponse(
+          "OpenAI stream ended without a finish reason"
+        );
       const calls = [...toolCalls.values()].map((call) => {
         if (!call.id || !call.name)
-          throw new Error("OpenAI stream contains an incomplete tool call");
+          throw invalidProviderResponse(
+            "OpenAI stream contains an incomplete tool call"
+          );
         return {
           id: call.id,
           name: call.name,
-          args: JSON.parse(call.arguments || "{}")
+          args: parseToolArguments(call.arguments)
         };
       });
       if (calls.length && finishReason !== "tool-calls")
-        throw new Error("OpenAI stream ended with incomplete tool calls");
+        throw invalidProviderResponse(
+          "OpenAI stream ended with incomplete tool calls"
+        );
+      validateToolCalls(calls);
       for (const toolCall of calls) yield { type: "tool-call", toolCall };
       yield { type: "finish", finishReason, usage };
     }
@@ -1783,6 +1846,739 @@ function formatMessagesForOpenAI2(messages, responses = false) {
   });
 }
 
+// src/core/decisions.ts
+var decisionErrorMarker = /* @__PURE__ */ Symbol.for("yourgpt.llm-sdk.DecisionAPIError");
+var _a, _b;
+var DecisionAPIError = class extends (_b = Error, _a = decisionErrorMarker, _b) {
+  constructor(message, code, status, requestId) {
+    super(message);
+    this.code = code;
+    this.status = status;
+    this.requestId = requestId;
+    this.name = "DecisionAPIError";
+    this[_a] = true;
+  }
+  /** Works across CJS/ESM and separately bundled provider entry points. */
+  static isInstance(error) {
+    return typeof error === "object" && error !== null && /* @__PURE__ */ Symbol.for("yourgpt.llm-sdk.DecisionAPIError") in error;
+  }
+  /** Advisory only: this SDK does not retry Decisions automatically. */
+  get retryable() {
+    return this.code === "network_error" || this.code === "http_error" && (this.status === 408 || this.status === 429 || this.status != null && this.status >= 500);
+  }
+};
+
+// src/core/decision-validation.ts
+function decisionInputError(message) {
+  throw new DecisionAPIError(message, "invalid_input");
+}
+function decisionResponseError(message) {
+  throw new DecisionAPIError(message, "invalid_response");
+}
+function isDecisionRecord(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value))
+    return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+function json(value, seen = /* @__PURE__ */ new Set(), depth = 0) {
+  if (depth > 64) return false;
+  if (value === null || typeof value === "string" || typeof value === "boolean")
+    return true;
+  if (typeof value === "number") return Number.isFinite(value);
+  if (typeof value !== "object" || !Array.isArray(value) && !isDecisionRecord(value) || seen.has(value))
+    return false;
+  seen.add(value);
+  const valid = Object.getOwnPropertySymbols(value).length === 0 && (Array.isArray(value) ? Array.from(value) : Object.values(value)).every(
+    (item) => json(item, seen, depth + 1)
+  );
+  seen.delete(value);
+  return valid;
+}
+function input(value) {
+  return (typeof value === "string" || Array.isArray(value) || isDecisionRecord(value)) && json(value);
+}
+function assertDecisionKeys(value, allowed, label) {
+  if (Object.keys(value).some((key) => !allowed.includes(key)))
+    decisionInputError(`${label} contains an unsupported field`);
+}
+function validateDecisionInput(options) {
+  if (!isDecisionRecord(options))
+    decisionInputError("Decisions options must be an object");
+  assertDecisionKeys(
+    options,
+    ["state", "questions", "images", "signal", "timeoutMs", "providerOptions"],
+    "Decisions options"
+  );
+  if (!input(options.state))
+    decisionInputError(
+      "state must be finite, acyclic JSON text, object, or array (maximum depth 64)"
+    );
+  if (!isDecisionRecord(options.questions) || Object.keys(options.questions).length === 0)
+    decisionInputError("questions must be a nonempty map");
+  for (const [id, question] of Object.entries(options.questions)) {
+    if (!id.length || !isDecisionRecord(question) || !input(question.instructions))
+      decisionInputError(
+        "Every question needs a nonempty ID and JSON-compatible instructions"
+      );
+    assertDecisionKeys(
+      question,
+      ["type", "instructions", "criteria"],
+      "Question"
+    );
+    if (question.type === "boolean") {
+      if (question.criteria !== void 0 && (!isDecisionRecord(question.criteria) || Object.entries(question.criteria).some(
+        ([key, value]) => !["true", "false"].includes(key) || !input(value)
+      )))
+        decisionInputError("Boolean criteria may describe only true and false");
+    } else if (question.type === "choice") {
+      if (!isDecisionRecord(question.criteria) || Object.keys(question.criteria).length < 2 || Object.keys(question.criteria).length > 255 || Object.entries(question.criteria).some(
+        ([key, value]) => !key.length || value !== null && !input(value)
+      ))
+        decisionInputError(
+          "Choice criteria require 2\u2013255 named options with JSON descriptions or null"
+        );
+    } else if (question.type === "score") {
+      if (!Array.isArray(question.criteria) || question.criteria.length < 2 || !Array.from(question.criteria).every(input))
+        decisionInputError(
+          "Score criteria require at least two ordered JSON descriptions"
+        );
+    } else
+      decisionInputError("Question type must be boolean, choice, or score");
+  }
+  if (options.timeoutMs !== void 0 && (!Number.isInteger(options.timeoutMs) || options.timeoutMs < 1 || options.timeoutMs > 2147483647))
+    decisionInputError("timeoutMs must be a positive 32-bit integer");
+  if (options.providerOptions !== void 0 && (!isDecisionRecord(options.providerOptions) || !json(options.providerOptions)))
+    decisionInputError("providerOptions must be a JSON object");
+  if (options.images !== void 0 && (!Array.isArray(options.images) || !Array.from(options.images).every(
+    (image) => isDecisionRecord(image) && image.data instanceof Uint8Array
+  )))
+    decisionInputError(
+      "Decision images must contain encoded bytes; hosted image URLs are unsupported"
+    );
+}
+function probability(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= 1;
+}
+function exactKeys(value, keys) {
+  return Object.keys(value).length === keys.length && keys.every((key) => Object.prototype.hasOwnProperty.call(value, key));
+}
+function validateDecisionResult(questions, result) {
+  if (!isDecisionRecord(result) || !isDecisionRecord(result.answers) || !exactKeys(result.answers, Object.keys(questions)))
+    decisionResponseError(
+      "Decisions must return exactly one answer per question"
+    );
+  const rounding = result.rounding;
+  let pError = 0, sError = 0;
+  if (rounding !== void 0) {
+    if (!isDecisionRecord(rounding) || ![rounding.probabilityDecimals, rounding.scoreDecimals].every(
+      (v) => typeof v === "number" && Number.isInteger(v) && v >= 0 && v <= 15
+    ))
+      decisionResponseError("Invalid decision rounding precision");
+    pError = 0.5 * 10 ** -rounding.probabilityDecimals;
+    sError = 0.5 * 10 ** -rounding.scoreDecimals;
+  }
+  const epsilon = 1e-6;
+  for (const [id, question] of Object.entries(questions)) {
+    const answer = result.answers[id];
+    if (!isDecisionRecord(answer))
+      decisionResponseError("Invalid decision answer");
+    if (answer.type === "refusal") continue;
+    if (answer.type !== question.type)
+      decisionResponseError("Decision answer type does not match its question");
+    if (answer.confidence !== void 0 && !probability(answer.confidence))
+      decisionResponseError(
+        "Confidence must be finite and between zero and one"
+      );
+    if (question.type === "boolean") {
+      if (!probability(answer.probability))
+        decisionResponseError(
+          "Boolean probability must be between zero and one"
+        );
+      continue;
+    }
+    const keys = question.type === "choice" ? Object.keys(question.criteria) : question.criteria.map((_, index) => String(index));
+    if (question.type === "choice" && (typeof answer.choice !== "string" || !keys.includes(answer.choice)))
+      decisionResponseError("Decision selected an unknown choice");
+    if (question.type === "score" && (typeof answer.score !== "number" || !Number.isFinite(answer.score) || answer.score < 0 || answer.score > keys.length - 1))
+      decisionResponseError("Decision score is outside its ordered levels");
+    if (answer.probabilities === void 0) continue;
+    const distribution2 = answer.probabilities;
+    if (!isDecisionRecord(distribution2) || !exactKeys(distribution2, keys) || !Object.values(distribution2).every(probability))
+      decisionResponseError(
+        "Decision distribution must contain every option exactly once with finite probabilities"
+      );
+    const values = Object.values(distribution2);
+    if (Math.abs(values.reduce((a, b) => a + b, 0) - 1) > epsilon + keys.length * pError)
+      decisionResponseError("Decision probabilities do not sum to one");
+    if (question.type === "choice") {
+      if (values.some(
+        (v) => v > distribution2[answer.choice] + epsilon + 2 * pError
+      ))
+        decisionResponseError(
+          "Decision choice is not a highest-probability option"
+        );
+    } else {
+      const mean = keys.reduce(
+        (sum, key) => sum + Number(key) * distribution2[key],
+        0
+      );
+      const tolerance = epsilon + sError + pError * keys.reduce((sum, key) => sum + Number(key), 0);
+      if (Math.abs(answer.score - mean) > tolerance)
+        decisionResponseError(
+          "Decision score does not match its probability-weighted levels"
+        );
+    }
+  }
+}
+
+// src/providers/decisions/http.ts
+async function postDecision(url, headers, body, options, fetchFn, maxBytes) {
+  const encoded = JSON.stringify(body);
+  if (Buffer.byteLength(encoded, "utf8") > maxBytes)
+    decisionInputError("Decision request exceeds the provider's byte limit");
+  options.signal?.throwIfAborted();
+  const controller = new AbortController();
+  const relay = () => controller.abort(options.signal?.reason);
+  options.signal?.addEventListener("abort", relay, { once: true });
+  const timer = setTimeout(
+    () => controller.abort(
+      new DOMException("Decision request timed out", "TimeoutError")
+    ),
+    options.timeoutMs ?? 6e4
+  );
+  let rejectAbort = () => {
+  };
+  const aborted = new Promise((_, reject) => {
+    rejectAbort = () => reject(controller.signal.reason);
+    controller.signal.addEventListener("abort", rejectAbort, { once: true });
+  });
+  const perform = async () => {
+    let response;
+    try {
+      response = await fetchFn(url, {
+        method: "POST",
+        headers,
+        body: encoded,
+        signal: controller.signal,
+        redirect: "error"
+      });
+    } catch {
+      controller.signal.throwIfAborted();
+      throw new DecisionAPIError(
+        "Decision request failed before receiving a response",
+        "network_error"
+      );
+    }
+    const requestId = response.headers.get("x-request-id") ?? response.headers.get("cf-ray") ?? void 0;
+    if (controller.signal.aborted) {
+      void response.body?.cancel().catch(() => {
+      });
+      controller.signal.throwIfAborted();
+    }
+    if (!response.ok) {
+      void response.body?.cancel().catch(() => {
+      });
+      throw new DecisionAPIError(
+        `Decision API returned HTTP ${response.status}`,
+        "http_error",
+        response.status,
+        requestId
+      );
+    }
+    if (!response.body)
+      decisionResponseError("Decision API returned an empty body");
+    const reader = response.body.getReader();
+    const cancel = () => {
+      void reader.cancel().catch(() => {
+      });
+    };
+    controller.signal.addEventListener("abort", cancel, { once: true });
+    const chunks = [];
+    let size = 0;
+    try {
+      while (true) {
+        controller.signal.throwIfAborted();
+        const { value: value2, done } = await reader.read();
+        if (done) break;
+        size += value2.byteLength;
+        if (size > 8 * 1024 * 1024) {
+          cancel();
+          decisionResponseError("Decision API response exceeds 8 MiB");
+        }
+        chunks.push(value2);
+      }
+    } catch (error) {
+      controller.signal.throwIfAborted();
+      if (error instanceof DecisionAPIError) throw error;
+      throw new DecisionAPIError(
+        "Decision response could not be read",
+        "network_error",
+        response.status,
+        requestId
+      );
+    } finally {
+      controller.signal.removeEventListener("abort", cancel);
+      reader.releaseLock();
+    }
+    controller.signal.throwIfAborted();
+    let value;
+    try {
+      value = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+    } catch {
+      decisionResponseError("Decision API did not return valid JSON");
+    }
+    return { value, status: response.status, requestId };
+  };
+  try {
+    return await Promise.race([perform(), aborted]);
+  } finally {
+    clearTimeout(timer);
+    options.signal?.removeEventListener("abort", relay);
+    controller.signal.removeEventListener("abort", rejectAbort);
+  }
+}
+
+// src/providers/decisions/images.ts
+function unsupportedDecision(message) {
+  throw new DecisionAPIError(message, "unsupported_option");
+}
+function prepareDecisionImages(images, provider) {
+  if (provider === "openrouter" && images.length)
+    unsupportedDecision(
+      "OpenRouter's native Decisions schema does not support image inputs"
+    );
+  if (provider === "cloudflare" && images.length > 4)
+    decisionInputError("Cloudflare Decisions supports at most four images");
+  if (provider === "openai" && images.length > 128)
+    decisionInputError("OpenAI Decisions supports at most 128 images");
+  let total = 0;
+  return images.map((image) => {
+    assertDecisionKeys(
+      image,
+      ["data", "mediaType", "detail"],
+      "Decision image"
+    );
+    if (image.detail !== void 0) {
+      if (provider !== "openai")
+        unsupportedDecision(
+          "Image detail is only supported by OpenAI Decisions"
+        );
+      if (!["auto", "low", "high", "original"].includes(image.detail))
+        decisionInputError("Invalid image detail");
+    }
+    const data = Buffer.from(image.data);
+    const signature = data.subarray(0, 12).toString("latin1");
+    const mediaType = signature.startsWith("\x89PNG\r\n\n") ? "image/png" : data[0] === 255 && data[1] === 216 && data[2] === 255 ? "image/jpeg" : signature.startsWith("RIFF") && signature.slice(8) === "WEBP" ? "image/webp" : /^GIF8[79]a/.test(signature) ? "image/gif" : void 0;
+    if (!mediaType || image.mediaType !== void 0 && image.mediaType !== mediaType)
+      decisionInputError(
+        "Decision image bytes must match a supported encoded image format"
+      );
+    if (provider === "typesafe" && !["image/png", "image/jpeg"].includes(mediaType))
+      unsupportedDecision("Jev images must be PNG or JPEG");
+    if (provider === "cloudflare" && mediaType === "image/gif")
+      unsupportedDecision("Cloudflare Decisions does not accept GIF images");
+    const limit = provider === "cloudflare" ? 4 : provider === "typesafe" ? 16 : 20;
+    if (data.length > limit * 1024 * 1024)
+      decisionInputError("Decision image exceeds this provider's file limit");
+    total += data.length;
+    if (provider === "cloudflare" && total > 8 * 1024 * 1024)
+      decisionInputError("Cloudflare Decisions images exceed 8 MiB total");
+    const base64 = data.toString("base64");
+    return {
+      url: `data:${mediaType};base64,${base64}`,
+      base64,
+      mediaType,
+      detail: image.detail
+    };
+  });
+}
+
+// src/providers/decisions/response.ts
+function distribution(value, score) {
+  if (!Array.isArray(value))
+    decisionResponseError(
+      "OpenAI Decisions omitted its probability distribution"
+    );
+  const entries = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const item of value) {
+    if (!isDecisionRecord(item) || (score ? typeof item.value !== "number" || !Number.isInteger(item.value) || item.value < 0 : typeof item.value !== "string"))
+      decisionResponseError("Invalid decision probability option");
+    const key = String(item.value);
+    if (seen.has(key))
+      decisionResponseError("Duplicate option in decision probabilities");
+    seen.add(key);
+    entries.push([key, item.probability]);
+  }
+  return Object.fromEntries(entries);
+}
+function parseDecisionResponse(raw, provider, questions, status, requestId) {
+  if (!isDecisionRecord(raw))
+    decisionResponseError("Decision response must be an object");
+  let payload = raw;
+  if (provider === "cloudflare") {
+    if (raw.success === false)
+      throw new DecisionAPIError(
+        "Cloudflare reported an unsuccessful decision request",
+        "http_error",
+        status,
+        requestId
+      );
+    if (raw.success !== true || !isDecisionRecord(raw.result))
+      decisionResponseError(
+        "Cloudflare Decisions returned an invalid result envelope"
+      );
+    payload = raw.result;
+  }
+  if (typeof payload.model !== "string" || !payload.model)
+    decisionResponseError("Decision response omitted its model identity");
+  const entries = [];
+  if (provider === "openai") {
+    if (!Array.isArray(payload.answers))
+      decisionResponseError("OpenAI Decisions answers must be an array");
+    const seen = /* @__PURE__ */ new Set();
+    for (const answer of payload.answers) {
+      if (!isDecisionRecord(answer))
+        decisionResponseError("Invalid OpenAI decision answer");
+      if (answer.type === "refusal" && answer.name == null)
+        throw new DecisionAPIError(
+          "OpenAI refused an unnamed decision question",
+          "refusal",
+          status,
+          requestId
+        );
+      if (typeof answer.name !== "string" || seen.has(answer.name))
+        decisionResponseError(
+          "OpenAI decision answers have missing or duplicate question identities"
+        );
+      seen.add(answer.name);
+      entries.push([answer.name, answer]);
+    }
+  } else {
+    if (!isDecisionRecord(payload.answers))
+      decisionResponseError("Decisions answers must be a named map");
+    entries.push(...Object.entries(payload.answers));
+  }
+  const answers = Object.fromEntries(
+    entries.map(([id, value]) => {
+      if (!isDecisionRecord(value))
+        decisionResponseError("Invalid decision answer");
+      if (value.type === "refusal" && provider === "openai")
+        return [id, { type: "refusal" }];
+      const booleanType = provider === "openai" ? "predicate" : "noul";
+      if (value.type === booleanType)
+        return [
+          id,
+          {
+            type: "boolean",
+            probability: provider === "openai" ? value.probability : value.noul
+          }
+        ];
+      if (value.type !== "choice" && value.type !== "score")
+        decisionResponseError(
+          "Provider returned an unsupported decision answer type"
+        );
+      if (provider !== "openrouter" && value.probabilities == null)
+        decisionResponseError(
+          "Provider omitted a required decision distribution"
+        );
+      const probabilities = provider === "openai" ? distribution(value.probabilities, value.type === "score") : value.probabilities;
+      const fields = {
+        ...probabilities !== void 0 && {
+          probabilities
+        },
+        ...value.confidence != null && {
+          confidence: value.confidence
+        }
+      };
+      return [
+        id,
+        value.type === "choice" ? { type: "choice", choice: value.choice, ...fields } : { type: "score", score: value.score, ...fields }
+      ];
+    })
+  );
+  const result = {
+    answers,
+    response: {
+      provider,
+      modelId: payload.model,
+      status,
+      requestId: requestId ?? (typeof payload.id === "string" ? payload.id : void 0),
+      body: raw
+    }
+  };
+  const typesafe = provider === "typesafe" || provider === "openrouter" && (payload.model.startsWith("typesafe/") || payload.provider === "TypeSafe");
+  if (typesafe) result.rounding = { probabilityDecimals: 2, scoreDecimals: 2 };
+  if (payload.usage != null) {
+    if (!isDecisionRecord(payload.usage))
+      decisionResponseError("Invalid decision usage");
+    const usage = payload.usage;
+    const details = isDecisionRecord(usage.input_tokens_details) ? usage.input_tokens_details : {};
+    result.usage = {};
+    const mapped = {
+      inputTokens: usage.input_tokens,
+      outputTokens: usage.output_tokens,
+      totalTokens: usage.total_tokens,
+      cachedInputTokens: details.cached_tokens,
+      cacheWriteTokens: details.cache_write_tokens,
+      costUsd: usage.cost
+    };
+    for (const [key, value] of Object.entries(mapped)) {
+      if (value == null) continue;
+      if (typeof value !== "number" || !Number.isFinite(value) || value < 0 || key !== "costUsd" && !Number.isInteger(value))
+        decisionResponseError("Invalid decision usage count");
+      result.usage[key] = value;
+    }
+  }
+  validateDecisionResult(questions, result);
+  return result;
+}
+
+// src/providers/decisions/model.ts
+function asText(value) {
+  return typeof value === "string" ? value : JSON.stringify(value);
+}
+function requestOptions(options, provider) {
+  for (const key of Object.keys(options.providerOptions ?? {})) {
+    if (key !== provider)
+      unsupportedDecision(
+        "Decision providerOptions must match the selected provider"
+      );
+  }
+  const opts = options.providerOptions?.[provider] ?? {};
+  if (!isDecisionRecord(opts))
+    decisionInputError("Decision provider options must be an object");
+  const allowed = provider === "openai" ? ["safetyIdentifier", "promptCacheKey"] : provider === "typesafe" ? ["longContext"] : provider === "openrouter" ? ["sessionId", "provider"] : [];
+  assertDecisionKeys(opts, allowed, "Decision provider options");
+  for (const [key, limit] of [
+    ["safetyIdentifier", 128],
+    ["promptCacheKey", 64],
+    ["sessionId", 256]
+  ]) {
+    if (opts[key] !== void 0 && (typeof opts[key] !== "string" || opts[key].length > limit))
+      decisionInputError("Invalid decision identifier or cache key");
+  }
+  if (opts.longContext !== void 0 && typeof opts.longContext !== "boolean")
+    decisionInputError("longContext must be boolean");
+  if (opts.provider !== void 0) {
+    if (!isDecisionRecord(opts.provider))
+      decisionInputError("OpenRouter routing preferences must be an object");
+    assertDecisionKeys(
+      opts.provider,
+      ["order", "allowFallbacks"],
+      "OpenRouter routing preferences"
+    );
+    if (opts.provider.allowFallbacks !== void 0 && typeof opts.provider.allowFallbacks !== "boolean")
+      decisionInputError("allowFallbacks must be boolean");
+    if (opts.provider.order !== void 0 && (!Array.isArray(opts.provider.order) || !opts.provider.order.every(
+      (value) => typeof value === "string" && value.length
+    )))
+      decisionInputError("Provider order must be an array of provider names");
+  }
+  return opts;
+}
+function nativeDecisionModel(modelId, config) {
+  if (typeof modelId !== "string" || !modelId.trim())
+    decisionInputError("Decision model ID is required");
+  const provider = config.provider;
+  return {
+    provider,
+    modelId,
+    async doDecide(options) {
+      validateDecisionInput(options);
+      options.signal?.throwIfAborted();
+      const opts = requestOptions(options, provider);
+      const questions = Object.entries(options.questions);
+      if (provider === "openai" && questions.length > 200)
+        decisionInputError("OpenAI Decisions supports at most 200 questions");
+      if (provider === "cloudflare" && (questions.length > 64 || questions.some(([id]) => !/^[A-Za-z0-9_.-]{1,100}$/.test(id))))
+        decisionInputError(
+          "Cloudflare supports 1\u201364 questions with IDs of 1\u2013100 letters, digits, underscores, dots, or hyphens"
+        );
+      for (const [, question] of questions) {
+        if (provider !== "openai" && question.type === "score" && question.criteria.length > 10)
+          decisionInputError(
+            "System One adapters support at most ten score levels"
+          );
+        if (provider === "cloudflare" && typeof question.instructions === "string" && !question.instructions.trim())
+          decisionInputError("Cloudflare requires nonempty instructions");
+        if (provider === "openrouter" && question.type === "boolean" && question.criteria !== void 0 && (question.criteria.true === void 0 || question.criteria.false === void 0))
+          decisionInputError(
+            "OpenRouter boolean criteria must describe both true and false when supplied"
+          );
+      }
+      const images = prepareDecisionImages(options.images ?? [], provider);
+      const headers = Object.fromEntries(
+        Object.entries(config.headers ?? {}).filter(
+          ([name]) => !["authorization", "content-type"].includes(name.toLowerCase())
+        )
+      );
+      headers["Content-Type"] = "application/json";
+      const key = config.apiKey ?? process.env[config.keyEnv];
+      if (!key?.trim())
+        decisionInputError(`Missing ${config.keyEnv} for Decisions`);
+      headers.Authorization = `Bearer ${key}`;
+      let body;
+      if (provider === "openai") {
+        body = {
+          model: modelId,
+          input: [
+            {
+              role: "user",
+              content: [
+                { type: "input_text", text: asText(options.state) },
+                ...images.map((image) => ({
+                  type: "input_image",
+                  image_url: image.url,
+                  ...image.detail !== void 0 && { detail: image.detail }
+                }))
+              ]
+            }
+          ],
+          questions: questions.map(([name, question]) => {
+            const instructions = asText(question.instructions);
+            if (question.type === "boolean")
+              return {
+                type: "predicate",
+                name,
+                instructions: [
+                  instructions,
+                  ...Object.entries(question.criteria ?? {}).map(
+                    ([key2, value]) => `Criteria for ${key2}:
+${asText(value)}`
+                  )
+                ].join("\n\n")
+              };
+            if (question.type === "choice")
+              return {
+                type: "choice",
+                name,
+                instructions,
+                choices: Object.entries(question.criteria).map(
+                  ([value, description]) => ({
+                    value,
+                    ...description !== null && {
+                      description: asText(description)
+                    }
+                  })
+                )
+              };
+            return {
+              type: "score",
+              name,
+              instructions,
+              levels: question.criteria.map((description, index) => ({
+                label: String(index),
+                description: asText(description)
+              }))
+            };
+          }),
+          ...opts.safetyIdentifier !== void 0 && {
+            safety_identifier: opts.safetyIdentifier
+          },
+          ...opts.promptCacheKey !== void 0 && {
+            prompt_cache_key: opts.promptCacheKey
+          }
+        };
+      } else {
+        body = {
+          model: config.bodyModel ?? modelId,
+          state: options.state,
+          questions: Object.fromEntries(
+            questions.map(([id, question]) => [
+              id,
+              {
+                ...question,
+                type: question.type === "boolean" ? "noul" : question.type
+              }
+            ])
+          )
+        };
+        if (provider === "typesafe") {
+          if (opts.longContext)
+            headers["TypeSafe-Danger-Zone-Long-Context"] = "true";
+          if (images.length) {
+            const refs = images.map(() => crypto.randomUUID());
+            body.state = { state: options.state, images: refs };
+            body.assets = Object.fromEntries(
+              images.map((image, index) => [
+                refs[index],
+                {
+                  type: "image",
+                  data_base64: image.base64,
+                  format: image.mediaType === "image/png" ? "png" : "jpeg"
+                }
+              ])
+            );
+            headers["TypeSafe-Danger-Zone-Images"] = "true";
+          }
+        } else if (provider === "cloudflare" && images.length) {
+          body.images = images.map((image) => ({
+            content_type: image.mediaType,
+            base64: image.base64
+          }));
+        } else if (provider === "openrouter") {
+          if (opts.sessionId !== void 0) body.session_id = opts.sessionId;
+          if (isDecisionRecord(opts.provider))
+            body.provider = {
+              ...opts.provider.order !== void 0 && {
+                order: opts.provider.order
+              },
+              ...opts.provider.allowFallbacks !== void 0 && {
+                allow_fallbacks: opts.provider.allowFallbacks
+              }
+            };
+        }
+      }
+      const base = config.baseUrl ?? config.defaultBaseUrl;
+      let url;
+      try {
+        url = new URL(`${base.replace(/\/+$/, "")}${config.path}`);
+      } catch {
+        decisionInputError("Invalid Decisions base URL");
+      }
+      if (!["https:", "http:"].includes(url.protocol) || url.username || url.password || url.search || url.hash)
+        decisionInputError(
+          "Decisions base URL must be an HTTP(S) API root without credentials, query, or fragment"
+        );
+      const response = await postDecision(
+        url.href,
+        headers,
+        body,
+        options,
+        config.fetch ?? globalThis.fetch,
+        (provider === "cloudflare" ? 13 : 32) * 1024 * 1024
+      );
+      return parseDecisionResponse(
+        response.value,
+        provider,
+        options.questions,
+        response.status,
+        response.requestId
+      );
+    }
+  };
+}
+
+// src/providers/openai/decisions.ts
+function openaiDecision(modelId = "gpt-6-luna", options = {}) {
+  return nativeDecisionModel(modelId, {
+    ...options,
+    headers: {
+      ...options.headers,
+      ...options.organization && {
+        "OpenAI-Organization": options.organization
+      },
+      ...options.project && { "OpenAI-Project": options.project }
+    },
+    provider: "openai",
+    keyEnv: "OPENAI_API_KEY",
+    defaultBaseUrl: "https://api.openai.com/v1",
+    path: "/decisions"
+  });
+}
+
 // src/providers/types.ts
 function createCallableProvider(providerFn, properties) {
   Object.defineProperty(providerFn, "name", {
@@ -1801,17 +2597,17 @@ function createCallableProvider(providerFn, properties) {
 
 // src/core/audio.ts
 var audioErrorMarker = /* @__PURE__ */ Symbol.for("@yourgpt/llm-sdk/AudioAPIError");
-var _a;
+var _a2;
 var AudioAPIError = class extends Error {
   constructor(message, code, status, requestId) {
     super(message);
     this.code = code;
     this.status = status;
     this.requestId = requestId;
-    this[_a] = true;
+    this[_a2] = true;
     this.name = "AudioAPIError";
   }
-  static [(_a = audioErrorMarker, Symbol.hasInstance)](value) {
+  static [(_a2 = audioErrorMarker, Symbol.hasInstance)](value) {
     return !!value && typeof value === "object" && value[audioErrorMarker] === true;
   }
 };
@@ -2187,6 +2983,497 @@ function openaiTranscription(modelId = "gpt-4o-mini-transcribe", config = {}) {
   };
 }
 
+// src/core/image.ts
+var marker = /* @__PURE__ */ Symbol.for("@yourgpt/llm-sdk/MediaAPIError");
+var _a3;
+var MediaAPIError = class extends Error {
+  constructor(message, code, status, requestId) {
+    super(message);
+    this.code = code;
+    this.status = status;
+    this.requestId = requestId;
+    this[_a3] = true;
+    this.name = "MediaAPIError";
+  }
+  static [(_a3 = marker, Symbol.hasInstance)](value) {
+    return !!value && typeof value === "object" && value[marker] === true;
+  }
+};
+
+// src/providers/openai/media-http.ts
+function invalidMedia(message) {
+  throw new MediaAPIError(message, "invalid_input");
+}
+async function postMedia(config, path, body, options = {}) {
+  options.signal?.throwIfAborted();
+  const timeout = options.timeoutMs ?? 12e4;
+  if (!Number.isFinite(timeout) || timeout <= 0 || timeout > 6e5)
+    invalidMedia("timeoutMs must be between 1 and 600000");
+  const key = config.apiKey ?? process.env.OPENAI_API_KEY;
+  if (!key) invalidMedia("An OpenAI API key is required on the server");
+  const headers = { Authorization: `Bearer ${key}` };
+  if (typeof body === "string") headers["Content-Type"] = "application/json";
+  if (config.organization) headers["OpenAI-Organization"] = config.organization;
+  if (config.project) headers["OpenAI-Project"] = config.project;
+  if (options.safetyIdentifier)
+    headers["OpenAI-Safety-Identifier"] = options.safetyIdentifier;
+  const controller = new AbortController();
+  const relay = () => controller.abort(options.signal?.reason);
+  options.signal?.addEventListener("abort", relay, { once: true });
+  const timer = setTimeout(
+    () => controller.abort(
+      new DOMException("Media request timed out", "TimeoutError")
+    ),
+    timeout
+  );
+  let rejectAbort = () => {
+  };
+  const aborted = new Promise((_, reject) => {
+    rejectAbort = () => reject(controller.signal.reason);
+    controller.signal.addEventListener("abort", rejectAbort, { once: true });
+  });
+  const perform = async () => {
+    let response;
+    try {
+      response = await (config.fetch ?? globalThis.fetch)(
+        `${(config.baseUrl ?? "https://api.openai.com/v1").replace(/\/$/, "")}${path}`,
+        {
+          method: "POST",
+          headers,
+          body,
+          signal: controller.signal,
+          redirect: "error"
+        }
+      );
+    } catch {
+      controller.signal.throwIfAborted();
+      throw new MediaAPIError(
+        "OpenAI media connection failed",
+        "network_error"
+      );
+    }
+    const requestId = response.headers.get("x-request-id") ?? void 0;
+    if (controller.signal.aborted || !response.ok) {
+      void response.body?.cancel().catch(() => {
+      });
+      controller.signal.throwIfAborted();
+      throw new MediaAPIError(
+        `OpenAI media returned HTTP ${response.status}`,
+        "http_error",
+        response.status,
+        requestId
+      );
+    }
+    const limit = options.maxResponseBytes ?? 1024 * 1024;
+    if (Number(response.headers.get("content-length")) > limit) {
+      void response.body?.cancel().catch(() => {
+      });
+      throw new MediaAPIError(
+        "Media response exceeds size limit",
+        "invalid_response"
+      );
+    }
+    const reader = response.body?.getReader();
+    if (!reader)
+      throw new MediaAPIError("Media response is empty", "invalid_response");
+    const cancel = () => {
+      void reader.cancel().catch(() => {
+      });
+    };
+    controller.signal.addEventListener("abort", cancel, { once: true });
+    const chunks = [];
+    let size = 0;
+    try {
+      while (true) {
+        controller.signal.throwIfAborted();
+        const { done, value } = await reader.read();
+        if (done) break;
+        size += value.byteLength;
+        if (size > limit) {
+          cancel();
+          throw new MediaAPIError(
+            "Media response exceeds size limit",
+            "invalid_response"
+          );
+        }
+        chunks.push(value);
+      }
+    } catch (error) {
+      controller.signal.throwIfAborted();
+      if (error instanceof MediaAPIError) throw error;
+      throw new MediaAPIError(
+        "Media response could not be read",
+        "network_error"
+      );
+    } finally {
+      controller.signal.removeEventListener("abort", cancel);
+      reader.releaseLock();
+    }
+    controller.signal.throwIfAborted();
+    return {
+      text: Buffer.concat(chunks).toString("utf8"),
+      status: response.status,
+      requestId
+    };
+  };
+  try {
+    return await Promise.race([perform(), aborted]);
+  } finally {
+    clearTimeout(timer);
+    options.signal?.removeEventListener("abort", relay);
+    controller.signal.removeEventListener("abort", rejectAbort);
+  }
+}
+function mediaJSON(text) {
+  try {
+    const data = JSON.parse(text);
+    if (data && typeof data === "object" && !Array.isArray(data)) return data;
+  } catch {
+  }
+  throw new MediaAPIError(
+    "Media API returned invalid JSON",
+    "invalid_response"
+  );
+}
+
+// src/providers/openai/image.ts
+var mimes = {
+  png: "image/png",
+  jpeg: "image/jpeg",
+  webp: "image/webp"
+};
+function imageFormat(data) {
+  if (Buffer.from(data.subarray(0, 8)).equals(
+    Buffer.from([137, 80, 78, 71, 13, 10, 26, 10])
+  ))
+    return "image/png";
+  if (data[0] === 255 && data[1] === 216 && data[2] === 255)
+    return "image/jpeg";
+  if (Buffer.from(data.subarray(0, 4)).toString() === "RIFF" && Buffer.from(data.subarray(8, 12)).toString() === "WEBP")
+    return "image/webp";
+}
+async function fileBlob(file, mask = false) {
+  if (!file || !Object.values(mimes).includes(file.mediaType) || mask && file.mediaType !== "image/png")
+    invalidMedia("Images must be PNG, JPEG or WebP; masks must be PNG");
+  const size = file.data instanceof Blob ? file.data.size : file.data?.byteLength;
+  if (!size || size >= 5e7)
+    invalidMedia("Each input image must be smaller than 50 MB");
+  const bytes = file.data instanceof Blob ? new Uint8Array(await file.data.arrayBuffer()) : file.data instanceof Uint8Array ? file.data : file.data instanceof ArrayBuffer ? new Uint8Array(file.data) : invalidMedia("Image data must be bytes or a Blob");
+  if (imageFormat(bytes) !== file.mediaType)
+    invalidMedia("Image bytes do not match the media type");
+  return new Blob([new Uint8Array(bytes)], { type: file.mediaType });
+}
+function optionsFor(model, options) {
+  const allowed = [
+    "quality",
+    "background",
+    "outputFormat",
+    "outputCompression",
+    "moderation",
+    "inputFidelity",
+    "safetyIdentifier"
+  ];
+  for (const [provider, value] of Object.entries(
+    options.providerOptions ?? {}
+  )) {
+    if (provider !== "openai" || !value || typeof value !== "object" || Object.keys(value).some((k) => !allowed.includes(k)))
+      throw new MediaAPIError(
+        "Unsupported image provider option",
+        "unsupported_option"
+      );
+  }
+  const o = options.providerOptions?.openai ?? {};
+  for (const [key, values] of Object.entries({
+    quality: ["auto", "low", "medium", "high", "xhigh", "max"],
+    background: ["auto", "opaque", "transparent"],
+    outputFormat: ["png", "jpeg", "webp"],
+    moderation: ["auto", "low"],
+    inputFidelity: ["high", "low"]
+  })) {
+    const value = o[key];
+    if (value !== void 0 && !values.includes(value))
+      invalidMedia(`Invalid image ${key}`);
+  }
+  if ((o.quality === "xhigh" || o.quality === "max") && !model.startsWith("gpt-image-2.5"))
+    invalidMedia("xhigh/max quality requires a GPT Image 2.5 model");
+  if (o.background === "transparent" && o.outputFormat === "jpeg")
+    invalidMedia("JPEG does not support transparency");
+  if (o.outputCompression !== void 0 && (!Number.isInteger(o.outputCompression) || o.outputCompression < 0 || o.outputCompression > 100 || !["jpeg", "webp"].includes(o.outputFormat ?? "png")))
+    invalidMedia("Compression must be 0\u2013100 and requires JPEG or WebP");
+  if (o.inputFidelity !== void 0 && !options.images)
+    invalidMedia("inputFidelity requires image inputs");
+  if (o.moderation !== void 0 && options.images)
+    throw new MediaAPIError(
+      "moderation is supported for generation only",
+      "unsupported_option"
+    );
+  if (o.safetyIdentifier !== void 0 && (typeof o.safetyIdentifier !== "string" || !o.safetyIdentifier.length || o.safetyIdentifier.length > 128))
+    invalidMedia("safetyIdentifier must contain 1\u2013128 characters");
+  return o;
+}
+function openaiImage(modelId = "gpt-image-2.5-flare", config = {}) {
+  if (!/^(gpt-image-|chatgpt-image-)/.test(modelId))
+    invalidMedia(
+      "Use a GPT Image model; retired DALL-E models are not supported"
+    );
+  return {
+    provider: "openai",
+    modelId,
+    async doGenerate(options) {
+      options.signal?.throwIfAborted();
+      if (typeof options.prompt !== "string" || !options.prompt.trim() || options.prompt.length > 32e3)
+        invalidMedia("Image prompt must contain 1\u201332000 characters");
+      const n = options.n ?? 1;
+      if (!Number.isInteger(n) || n < 1 || n > 10)
+        invalidMedia("n must be an integer from 1 to 10");
+      if (options.size !== void 0 && options.size !== "auto") {
+        const match = /^(\d+)x(\d+)$/.exec(options.size);
+        if (!match) invalidMedia("Image size must be auto or WIDTHxHEIGHT");
+        const w = Number(match[1]), h = Number(match[2]);
+        if (modelId.startsWith("gpt-image-2")) {
+          if (w % 16 || h % 16 || w > 3840 || h > 3840 || w / h > 3 || h / w > 3 || w * h < 655360 || w * h > 8294400)
+            invalidMedia(
+              "Image size exceeds GPT Image dimensions or pixel limits"
+            );
+        } else if (!["1024x1024", "1536x1024", "1024x1536"].includes(options.size))
+          invalidMedia("This model requires a standard GPT Image size");
+      }
+      if (options.images && (!Array.isArray(options.images) || !options.images.length || options.images.length > 16))
+        invalidMedia("Editing requires 1\u201316 input images");
+      if (options.mask && !options.images)
+        invalidMedia("A mask requires image inputs");
+      const o = optionsFor(modelId, options);
+      const format = o.outputFormat ?? "png";
+      const fields = {
+        model: modelId,
+        prompt: options.prompt,
+        n,
+        size: options.size,
+        quality: o.quality,
+        background: o.background,
+        output_format: format,
+        output_compression: o.outputCompression,
+        moderation: o.moderation,
+        input_fidelity: o.inputFidelity,
+        safety_identifier: o.safetyIdentifier
+      };
+      let body = JSON.stringify(fields);
+      if (options.images) {
+        const form = new FormData();
+        for (const [key, value] of Object.entries(fields))
+          if (value !== void 0) form.set(key, String(value));
+        let total = 0;
+        for (const [i, input2] of options.images.entries()) {
+          const blob = await fileBlob(input2);
+          total += blob.size;
+          if (total > 1e8)
+            invalidMedia("Total image input exceeds the SDK's 100 MB limit");
+          form.append(
+            "image[]",
+            blob,
+            `image-${i}.${input2.mediaType.split("/")[1]}`
+          );
+        }
+        if (options.mask) {
+          const mask = await fileBlob(options.mask, true);
+          total += mask.size;
+          if (total > 1e8)
+            invalidMedia("Total image input exceeds the SDK's 100 MB limit");
+          form.set("mask", mask, "mask.png");
+        }
+        body = form;
+      }
+      const response = await postMedia(
+        config,
+        options.images ? "/images/edits" : "/images/generations",
+        body,
+        { ...options, maxResponseBytes: 128 * 1024 * 1024 }
+      );
+      const data = mediaJSON(response.text);
+      if (!Array.isArray(data.data) || data.data.length !== n)
+        throw new MediaAPIError(
+          "Images API returned an unexpected image count",
+          "invalid_response"
+        );
+      const images = data.data.map((item) => {
+        const encoded = item?.b64_json;
+        if (typeof encoded !== "string" || !encoded.length || encoded.length % 4 || !/^[A-Za-z0-9+/]+={0,2}$/.test(encoded))
+          throw new MediaAPIError(
+            "Images API returned invalid base64",
+            "invalid_response"
+          );
+        const bytes = new Uint8Array(Buffer.from(encoded, "base64"));
+        if (imageFormat(bytes) !== mimes[format])
+          throw new MediaAPIError(
+            "Images API returned an unexpected image format",
+            "invalid_response"
+          );
+        return {
+          uint8Array: bytes,
+          get base64() {
+            return Buffer.from(bytes).toString("base64");
+          },
+          mediaType: mimes[format],
+          ...typeof item.revised_prompt === "string" ? { revisedPrompt: item.revised_prompt } : {}
+        };
+      });
+      return {
+        image: images[0],
+        images,
+        usage: data.usage,
+        response: {
+          provider: "openai",
+          modelId,
+          status: response.status,
+          requestId: response.requestId
+        },
+        providerMetadata: {
+          created: data.created,
+          size: data.size,
+          quality: data.quality,
+          background: data.background
+        }
+      };
+    }
+  };
+}
+
+// src/providers/openai/realtime.ts
+function buildSession(model, o) {
+  if (o.instructions !== void 0 && (typeof o.instructions !== "string" || o.instructions.length > 1e5))
+    invalidMedia(
+      "Realtime instructions must be a string up to 100000 characters"
+    );
+  for (const value of [o.voice, o.transcriptionModel])
+    if (value !== void 0 && (typeof value !== "string" || !value.trim() || value.length > 100))
+      invalidMedia("Invalid realtime voice or transcription model");
+  if (o.language !== void 0 && !/^[a-z]{2}$/.test(o.language))
+    invalidMedia("Realtime language must be a two-letter code");
+  if (o.language && !o.transcriptionModel)
+    invalidMedia("language requires a transcription model");
+  if (o.outputModality !== void 0 && !["audio", "text"].includes(o.outputModality))
+    invalidMedia("Invalid realtime output modality");
+  if (o.maxOutputTokens !== void 0 && o.maxOutputTokens !== "inf" && (!Number.isInteger(o.maxOutputTokens) || o.maxOutputTokens < 1 || o.maxOutputTokens > 4096))
+    invalidMedia("maxOutputTokens must be 1\u20134096 or inf");
+  if (o.safetyIdentifier !== void 0 && (typeof o.safetyIdentifier !== "string" || !/^[\x21-\x7e]{1,128}$/.test(o.safetyIdentifier)))
+    invalidMedia(
+      "safetyIdentifier must contain 1\u2013128 printable ASCII characters"
+    );
+  const names = /* @__PURE__ */ new Set();
+  if (o.tools && (!Array.isArray(o.tools) || o.tools.length > 128))
+    invalidMedia("Realtime supports up to 128 tools");
+  const tools = o.tools?.map((tool) => {
+    if (!tool || !/^[a-zA-Z0-9_-]{1,64}$/.test(tool.name) || names.has(tool.name) || !tool.parameters || tool.parameters.type !== "object")
+      invalidMedia(
+        "Realtime tools require unique names and object parameter schemas"
+      );
+    names.add(tool.name);
+    return {
+      type: "function",
+      name: tool.name,
+      description: tool.description,
+      parameters: tool.parameters
+    };
+  });
+  let turn;
+  const td = o.turnDetection;
+  if (td === null) turn = null;
+  else if (td?.type === "semantic_vad") {
+    if (td.eagerness !== void 0 && !["auto", "low", "medium", "high"].includes(td.eagerness))
+      invalidMedia("Invalid semantic VAD eagerness");
+    turn = {
+      type: td.type,
+      eagerness: td.eagerness,
+      create_response: true,
+      interrupt_response: true
+    };
+  } else {
+    if (td && td.type !== "server_vad")
+      invalidMedia("Invalid realtime turn detection");
+    if (td?.threshold !== void 0 && (!Number.isFinite(td.threshold) || td.threshold < 0 || td.threshold > 1))
+      invalidMedia("VAD threshold must be 0\u20131");
+    for (const value of [td?.silenceDurationMs, td?.prefixPaddingMs])
+      if (value !== void 0 && (!Number.isInteger(value) || value < 0 || value > 1e4))
+        invalidMedia("VAD durations must be 0\u201310000 milliseconds");
+    turn = {
+      type: "server_vad",
+      threshold: td?.threshold,
+      silence_duration_ms: td?.silenceDurationMs,
+      prefix_padding_ms: td?.prefixPaddingMs,
+      create_response: true,
+      interrupt_response: true
+    };
+  }
+  return {
+    type: "realtime",
+    model,
+    instructions: o.instructions,
+    output_modalities: [o.outputModality ?? "audio"],
+    max_output_tokens: o.maxOutputTokens,
+    audio: {
+      input: {
+        turn_detection: turn,
+        ...o.transcriptionModel ? {
+          transcription: {
+            model: o.transcriptionModel,
+            language: o.language
+          }
+        } : {}
+      },
+      output: { voice: o.voice ?? "marin" }
+    },
+    tools
+  };
+}
+function openaiRealtime(modelId = "gpt-realtime-2.1", config = {}) {
+  if (!modelId.startsWith("gpt-realtime"))
+    invalidMedia("openaiRealtime requires a gpt-realtime model");
+  return {
+    provider: "openai",
+    modelId,
+    async createClientSecret(options = {}) {
+      const ttl = options.expiresAfterSeconds ?? 60;
+      if (!Number.isInteger(ttl) || ttl < 10 || ttl > 7200)
+        invalidMedia("Client secret lifetime must be 10\u20137200 seconds");
+      const session = buildSession(modelId, options);
+      const response = await postMedia(
+        config,
+        "/realtime/client_secrets",
+        JSON.stringify({
+          session,
+          expires_after: { anchor: "created_at", seconds: ttl }
+        }),
+        { ...options, timeoutMs: options.timeoutMs ?? 3e4 }
+      );
+      const data = mediaJSON(response.text);
+      if (typeof data.value !== "string" || !data.value.startsWith("ek_") || !Number.isFinite(data.expires_at) || data.expires_at <= Date.now() / 1e3)
+        throw new MediaAPIError(
+          "Realtime returned an invalid or expired client secret",
+          "invalid_response"
+        );
+      return { value: data.value, expiresAt: data.expires_at, modelId };
+    },
+    async createCall(options) {
+      if (typeof options.sdp !== "string" || !options.sdp.startsWith("v=0") || options.sdp.length > 65536)
+        invalidMedia("A valid SDP offer up to 64 KiB is required");
+      const form = new FormData();
+      form.set("sdp", options.sdp);
+      form.set("session", JSON.stringify(buildSession(modelId, options)));
+      const response = await postMedia(config, "/realtime/calls", form, {
+        ...options,
+        timeoutMs: options.timeoutMs ?? 3e4,
+        maxResponseBytes: 65536
+      });
+      if (!response.text.startsWith("v=0"))
+        throw new MediaAPIError(
+          "Realtime returned an invalid SDP answer",
+          "invalid_response"
+        );
+      return { sdp: response.text };
+    }
+  };
+}
+
 // src/providers/openai/index.ts
 var OPENAI_MODELS2 = {
   // GPT-4o series
@@ -2302,6 +3589,10 @@ function createOpenAI(config = {}) {
       apiKey,
       model: modelId,
       baseUrl: config.baseUrl,
+      organization: config.organization,
+      project: config.project,
+      timeout: config.timeout,
+      headers: config.headers,
       reasoningEffort: config.reasoningEffort,
       api: config.api,
       responses: config.responses,
@@ -2338,6 +3629,9 @@ exports.createOpenAI = createOpenAI;
 exports.createOpenAIModel = openai;
 exports.createOpenAIProvider = createOpenAIProvider;
 exports.openai = openai;
+exports.openaiDecision = openaiDecision;
+exports.openaiImage = openaiImage;
+exports.openaiRealtime = openaiRealtime;
 exports.openaiSpeech = openaiSpeech;
 exports.openaiTranscription = openaiTranscription;
 //# sourceMappingURL=index.js.map