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

package/dist/providers/openrouter/index.mjs

@@ -1,3 +1,5 @@
+import { randomUUID } from 'crypto';
+
 // src/core/tool-output.ts
 var imageTypes = /* @__PURE__ */ new Set([
   "image/png",
@@ -111,6 +113,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);
@@ -272,6 +287,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",
@@ -387,6 +403,30 @@ var DEFAULT_MODEL_CONFIG = {
   maxTokens: 128e3
 };
 function openrouter(modelId, options = {}) {
+  function reasoning(params) {
+    const configured = options.reasoning;
+    if (!configured && params.reasoningEffort === void 0) return {};
+    const effort = params.reasoningEffort ?? configured?.effort;
+    const budget = configured?.maxTokens;
+    if (effort !== void 0 && budget !== void 0) {
+      throw new Error(
+        "OpenRouter reasoning accepts effort or maxTokens, not both"
+      );
+    }
+    if (budget !== void 0 && (!Number.isSafeInteger(budget) || budget <= 0)) {
+      throw new Error(
+        "OpenRouter reasoning maxTokens must be a positive integer"
+      );
+    }
+    return {
+      reasoning: {
+        ...effort !== void 0 ? { effort } : {},
+        ...budget !== void 0 ? { max_tokens: budget } : {},
+        ...configured?.enabled !== void 0 ? { enabled: configured.enabled } : {},
+        ...configured?.exclude !== void 0 ? { exclude: configured.exclude } : {}
+      }
+    };
+  }
   const apiKey = options.apiKey ?? process.env.OPENROUTER_API_KEY;
   const baseURL = options.baseURL ?? "https://openrouter.ai/api/v1";
   const headers = {};
@@ -417,7 +457,7 @@ function openrouter(modelId, options = {}) {
       supportsTools: modelConfig.tools,
       supportsStreaming: true,
       supportsJsonMode: modelConfig.jsonMode,
-      supportsThinking: false,
+      supportsThinking: options.reasoning !== void 0,
       supportsPDF: false,
       maxTokens: modelConfig.maxTokens,
       supportedImageTypes: modelConfig.vision ? ["image/png", "image/jpeg", "image/gif", "image/webp"] : []
@@ -429,7 +469,8 @@ function openrouter(modelId, options = {}) {
         model: modelId,
         messages,
         temperature: params.temperature,
-        max_tokens: params.maxTokens
+        max_tokens: params.maxTokens,
+        ...reasoning(params)
       };
       if (params.tools) {
         requestBody.tools = params.tools;
@@ -441,7 +482,9 @@ function openrouter(modelId, options = {}) {
       if (responseFormat) {
         requestBody.response_format = responseFormat;
       }
-      const response = await client2.chat.completions.create(requestBody);
+      const response = await client2.chat.completions.create(requestBody, {
+        signal: params.signal
+      });
       const choice = response.choices[0];
       const message = choice.message;
       const toolCalls = (message.tool_calls ?? []).map(
@@ -453,6 +496,8 @@ function openrouter(modelId, options = {}) {
       );
       return {
         text: message.content ?? "",
+        ...reasoningTextFor(message) ? { reasoningText: reasoningTextFor(message) } : {},
+        ...reasoningMetadata(message.reasoning_details),
         toolCalls,
         finishReason: mapFinishReason(choice.finish_reason),
         usage: {
@@ -471,7 +516,9 @@ function openrouter(modelId, options = {}) {
         messages,
         temperature: params.temperature,
         max_tokens: params.maxTokens,
-        stream: true
+        ...reasoning(params),
+        stream: true,
+        stream_options: { include_usage: true }
       };
       if (params.tools) {
         requestBody.tools = params.tools;
@@ -483,70 +530,61 @@ function openrouter(modelId, options = {}) {
       if (responseFormat) {
         requestBody.response_format = responseFormat;
       }
-      const stream = await client2.chat.completions.create(requestBody);
-      let currentToolCall = null;
-      let totalPromptTokens = 0;
-      let totalCompletionTokens = 0;
+      const stream = await client2.chat.completions.create(requestBody, {
+        signal: params.signal
+      });
+      const calls = /* @__PURE__ */ new Map();
+      const details = [];
+      let finishReason = "unknown";
+      let usage = { promptTokens: 0, completionTokens: 0, totalTokens: 0 };
       for await (const chunk of stream) {
-        if (params.signal?.aborted) {
-          yield { type: "error", error: new Error("Aborted") };
-          return;
-        }
-        const choice = chunk.choices[0];
+        if (params.signal?.aborted)
+          throw params.signal.reason ?? new Error("Aborted");
+        const choice = chunk.choices?.[0];
         const delta = choice?.delta;
-        if (delta?.content) {
-          yield { type: "text-delta", text: delta.content };
+        if (chunk.usage)
+          usage = {
+            promptTokens: chunk.usage.prompt_tokens ?? 0,
+            completionTokens: chunk.usage.completion_tokens ?? 0,
+            totalTokens: chunk.usage.total_tokens ?? (chunk.usage.prompt_tokens ?? 0) + (chunk.usage.completion_tokens ?? 0)
+          };
+        const reasoningText = reasoningTextFor(delta);
+        if (typeof reasoningText === "string" && reasoningText) {
+          yield { type: "reasoning-delta", text: reasoningText };
         }
-        if (delta?.tool_calls) {
-          for (const tc of delta.tool_calls) {
-            if (tc.id) {
-              if (currentToolCall) {
-                yield {
-                  type: "tool-call",
-                  toolCall: {
-                    id: currentToolCall.id,
-                    name: currentToolCall.name,
-                    args: JSON.parse(currentToolCall.arguments || "{}")
-                  }
-                };
-              }
-              currentToolCall = {
-                id: tc.id,
-                name: tc.function?.name ?? "",
-                arguments: tc.function?.arguments ?? ""
-              };
-            } else if (currentToolCall && tc.function?.arguments) {
-              currentToolCall.arguments += tc.function.arguments;
-            }
-          }
+        for (const detail of delta?.reasoning_details ?? []) {
+          const last = details.at(-1);
+          const field = detail.type === "reasoning.text" ? "text" : detail.type === "reasoning.summary" ? "summary" : void 0;
+          if (field && last && last.type === detail.type && (!detail.id || !last.id || detail.id === last.id)) {
+            last[field] = (last[field] ?? "") + (detail[field] ?? "");
+            last.signature ?? (last.signature = detail.signature);
+            last.format ?? (last.format = detail.format);
+          } else details.push({ ...detail });
         }
-        if (choice?.finish_reason) {
-          if (currentToolCall) {
-            yield {
-              type: "tool-call",
-              toolCall: {
-                id: currentToolCall.id,
-                name: currentToolCall.name,
-                args: JSON.parse(currentToolCall.arguments || "{}")
-              }
-            };
-            currentToolCall = null;
-          }
-          if (chunk.usage) {
-            totalPromptTokens = chunk.usage.prompt_tokens;
-            totalCompletionTokens = chunk.usage.completion_tokens;
-          }
-          yield {
-            type: "finish",
-            finishReason: mapFinishReason(choice.finish_reason),
-            usage: {
-              promptTokens: totalPromptTokens,
-              completionTokens: totalCompletionTokens,
-              totalTokens: totalPromptTokens + totalCompletionTokens
-            }
-          };
+        if (delta?.content) yield { type: "text-delta", text: delta.content };
+        for (const tc of delta?.tool_calls ?? []) {
+          const index = tc.index ?? 0;
+          const call = calls.get(index) ?? { id: "", name: "", arguments: "" };
+          if (tc.id) call.id = tc.id;
+          if (tc.function?.name) call.name = tc.function.name;
+          if (tc.function?.arguments) call.arguments += tc.function.arguments;
+          calls.set(index, call);
         }
+        if (choice?.finish_reason)
+          finishReason = mapFinishReason(choice.finish_reason);
       }
+      const parsed = [...calls.values()].map((call) => ({
+        id: call.id,
+        name: call.name,
+        args: JSON.parse(call.arguments || "{}")
+      }));
+      for (const toolCall of parsed) yield { type: "tool-call", toolCall };
+      yield {
+        type: "finish",
+        finishReason,
+        usage,
+        ...reasoningMetadata(details)
+      };
     }
   };
 }
@@ -582,7 +620,7 @@ function formatMessagesForOpenRouter(messages) {
             }
             if (part.type === "image") {
               const imageData = typeof part.image === "string" ? part.image : Buffer.from(part.image).toString("base64");
-              const url = imageData.startsWith("data:") ? imageData : `data:${part.mimeType ?? "image/png"};base64,${imageData}`;
+              const url = /^(data:|https?:\/\/)/.test(imageData) ? imageData : `data:${part.mimeType ?? "image/png"};base64,${imageData}`;
               return { type: "image_url", image_url: { url, detail: "auto" } };
             }
             return { type: "text", text: "" };
@@ -593,6 +631,9 @@ function formatMessagesForOpenRouter(messages) {
           role: "assistant",
           content: msg.content
         };
+        const details = msg.providerMetadata?.openrouter?.reasoningDetails;
+        if (Array.isArray(details) && details.length)
+          assistantMsg.reasoning_details = details;
         if (msg.toolCalls && msg.toolCalls.length > 0) {
           assistantMsg.tool_calls = msg.toolCalls.map((tc) => ({
             id: tc.id,
@@ -638,6 +679,92 @@ async function searchOpenRouterModels(query, apiKey) {
     (model) => model.id.toLowerCase().includes(lowerQuery) || model.name.toLowerCase().includes(lowerQuery)
   );
 }
+function reasoningMetadata(details) {
+  if (!Array.isArray(details) || !details.length) return {};
+  const fields = [
+    "type",
+    "text",
+    "summary",
+    "data",
+    "signature",
+    "id",
+    "format",
+    "index"
+  ];
+  const reasoningDetails = details.filter((detail) => detail && typeof detail === "object").map(
+    (detail) => Object.fromEntries(
+      fields.filter((key) => detail[key] !== void 0).map((key) => [key, structuredClone(detail[key])])
+    )
+  );
+  return { providerMetadata: { openrouter: { reasoningDetails } } };
+}
+function reasoningTextFor(message) {
+  const text = message?.reasoning ?? message?.reasoning_content;
+  if (typeof text === "string" && text) return text;
+  if (!Array.isArray(message?.reasoning_details)) return void 0;
+  const parts = message.reasoning_details.flatMap((detail) => {
+    const value = detail?.type === "reasoning.text" ? detail.text : detail?.type === "reasoning.summary" ? detail.summary : void 0;
+    return typeof value === "string" ? [value] : [];
+  });
+  return parts.length ? parts.join("") : void 0;
+}
+
+// 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 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-responses.ts
 function resolveOpenAITransport(defaults, overrides) {
@@ -686,6 +813,54 @@ function responseMetadata(response) {
     }
   };
 }
+function responseReplayMetadata(metadata) {
+  const response = metadata?.openai?.response;
+  if (!response) return metadata;
+  const output = response.output.map((item) => {
+    const fields = ["type", "id", "status"];
+    switch (item.type) {
+      case "reasoning":
+        fields.push("encrypted_content");
+        break;
+      case "message":
+        fields.push("role", "phase");
+        break;
+      case "function_call":
+        fields.push("call_id", "name", "namespace", "arguments");
+        break;
+      case "tool_search_call":
+        fields.push("call_id", "execution", "arguments");
+        break;
+      case "tool_search_output":
+        fields.push("call_id", "tools");
+        break;
+      case "web_search_call":
+        fields.push("action");
+        break;
+      default:
+        return stripItemDiagnostics(item);
+    }
+    const replay = Object.fromEntries(
+      fields.filter((key) => item[key] !== void 0).map((key) => [key, item[key]])
+    );
+    if (item.type === "reasoning") replay.summary = [];
+    if (item.type === "message")
+      replay.content = Array.isArray(item.content) ? item.content.flatMap(
+        (part) => part?.type === "output_text" && typeof part.text === "string" ? [{ type: "output_text", text: part.text, annotations: [] }] : part?.type === "refusal" && typeof part.refusal === "string" ? [{ type: "refusal", refusal: part.refusal }] : []
+      ) : [];
+    return stripItemDiagnostics(replay);
+  });
+  return { openai: { response: { output, refusals: [] } } };
+}
+function stripItemDiagnostics(item) {
+  const {
+    usage: _usage,
+    logprobs: _logprobs,
+    metadata: _metadata,
+    ...state
+  } = item;
+  return state;
+}
 function getResponseReplay(metadata) {
   const response = metadata?.openai?.response;
   if (response === void 0) return void 0;
@@ -694,29 +869,7 @@ function getResponseReplay(metadata) {
       "Invalid OpenAI Responses replay metadata: output must contain typed items"
     );
   }
-  return response.output;
-}
-
-// src/core/provider-error.ts
-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 throwIfAborted(signal) {
-  if (!signal?.aborted) return;
-  const error = new Error("The operation was aborted");
-  error.name = "AbortError";
-  throw error;
+  return responseReplayMetadata(metadata)?.openai?.response?.output;
 }
 
 // src/core/utils.ts
@@ -726,9 +879,6 @@ function generateId(prefix = "id") {
 function generateMessageId() {
   return generateId("msg");
 }
-function generateToolCallId() {
-  return generateId("call");
-}
 
 // src/adapters/openai.ts
 var OpenAIAdapter = class _OpenAIAdapter {
@@ -752,6 +902,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
       });
     }
@@ -816,11 +968,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")
@@ -831,12 +983,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
@@ -844,7 +996,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,
@@ -854,7 +1006,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)
@@ -862,19 +1014,19 @@ 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) {
     return messages.map((message) => {
       const { attachments, providerMetadata, modelOutput, ...rest } = message;
-      let content = message.role === "tool" && !preserveProviderMetadata ? textToolOutput(modelOutput, String(message.content ?? "")) : message.content;
+      let content = message.role === "tool" && !preserveProviderMetadata && modelOutput !== void 0 ? textToolOutput(modelOutput, "") : message.content;
       if (preserveProviderMetadata && modelOutput)
         rest.modelOutput = modelOutput;
       if (message.role === "assistant" && Array.isArray(message.tool_calls) && message.tool_calls.length > 0 && content === "") {
@@ -977,17 +1129,32 @@ var OpenAIAdapter = class _OpenAIAdapter {
     const seenCallIds = /* @__PURE__ */ new Set();
     const toolCalls = Array.isArray(response?.output) ? response.output.filter((item) => item?.type === "function_call").map((item) => {
       if (typeof item.call_id !== "string" || !item.call_id || typeof item.name !== "string" || !item.name || typeof item.arguments !== "string" || item.status && item.status !== "completed") {
-        throw new Error("Responses contains an incomplete function call");
+        throw invalidProviderResponse(
+          "Responses contains an incomplete function call"
+        );
       }
       if (seenCallIds.has(item.call_id))
-        throw new Error("Responses contains duplicate function call IDs");
+        throw invalidProviderResponse(
+          "Responses contains duplicate function call IDs"
+        );
       seenCallIds.add(item.call_id);
-      const args = JSON.parse(item.arguments);
+      let args;
+      try {
+        args = JSON.parse(item.arguments);
+      } catch {
+        throw invalidProviderResponse(
+          "Responses function arguments must be valid JSON"
+        );
+      }
       if (!args || typeof args !== "object" || Array.isArray(args))
-        throw new Error(
+        throw invalidProviderResponse(
           "Responses function arguments must be a JSON object"
         );
-      return { id: item.call_id, name: item.name, args };
+      return {
+        id: item.call_id,
+        name: item.name,
+        args
+      };
     }) : [];
     return {
       content,
@@ -1018,6 +1185,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,
@@ -1041,14 +1218,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
     };
@@ -1230,7 +1400,9 @@ var OpenAIAdapter = class _OpenAIAdapter {
     const uniqueCalls = /* @__PURE__ */ new Map();
     for (const call of toolCalls.values()) {
       if (!call.id || !call.name)
-        throw new Error("Responses stream contains an incomplete tool call");
+        throw invalidProviderResponse(
+          "Responses stream contains an incomplete tool call"
+        );
       uniqueCalls.set(call.id, call);
     }
     toolCalls.clear();
@@ -1417,15 +1589,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",
@@ -1509,20 +1686,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,
@@ -1571,6 +1748,737 @@ function createCallableProvider(providerFn, properties) {
   return providerFn;
 }
 
+// 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(() => 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/openrouter/decisions.ts
+function openrouterDecision(modelId = "typesafe/jev-1.13", options = {}) {
+  return nativeDecisionModel(modelId, {
+    ...options,
+    headers: {
+      ...options.headers,
+      ...options.siteUrl && { "HTTP-Referer": options.siteUrl },
+      ...options.appName && { "X-Title": options.appName }
+    },
+    provider: "openrouter",
+    keyEnv: "OPENROUTER_API_KEY",
+    defaultBaseUrl: "https://openrouter.ai/api/alpha",
+    path: "/decisions"
+  });
+}
+
 // src/providers/openrouter/index.ts
 var DEFAULT_CAPABILITIES = {
   vision: true,
@@ -1612,6 +2520,6 @@ function createOpenRouter(config = {}) {
 }
 var createOpenRouterProvider = createOpenRouter;
 
-export { createOpenRouter, openrouter as createOpenRouterModel, createOpenRouterProvider, fetchOpenRouterModels, openrouter, searchOpenRouterModels };
+export { createOpenRouter, openrouter as createOpenRouterModel, createOpenRouterProvider, fetchOpenRouterModels, openrouter, openrouterDecision, searchOpenRouterModels };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map