@kortyx/openrouter 0.2.5 → 0.2.6

package/dist/index.js

@@ -1,7 +1,7 @@
 // src/index.ts
 import {
   ProviderConfigurationError as ProviderConfigurationError3,
-  ProviderRequestError as ProviderRequestError2
+  ProviderRequestError as ProviderRequestError3
 } from "@kortyx/core/errors";
 
 // src/jev.ts
@@ -5374,13 +5374,27 @@ function createOpenRouterClient(settings, apiKey) {
 
 // src/errors.ts
 import {
+  errorProperty,
+  FAILURE_LIMITS,
+  isControlFlowError,
   normalizeProviderError,
-  ProviderConfigurationError
+  ProviderConfigurationError,
+  ProviderRequestError
 } from "@kortyx/core/errors";
 import {
   ProviderConfigurationError as ProviderConfigurationError2,
-  ProviderRequestError
+  ProviderRequestError as ProviderRequestError2
 } from "@kortyx/core/errors";
+var rawEnvelope = (error) => {
+  const raw = errorProperty(error, "rawValue");
+  if (typeof raw !== "string") return raw;
+  if (raw.length > FAILURE_LIMITS.bytes) return void 0;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+};
 var requireApiKey = (apiKey) => {
   if (!apiKey || apiKey.trim().length === 0) {
     throw new ProviderConfigurationError(
@@ -5389,7 +5403,115 @@ var requireApiKey = (apiKey) => {
   }
   return apiKey;
 };
-var toProviderRequestError = (action, error) => normalizeProviderError("openrouter", action, error);
+var parameterNames = (request) => {
+  const parameters = {
+    temperature: request.temperature,
+    top_p: request.topP,
+    top_k: request.topK,
+    frequency_penalty: request.frequencyPenalty,
+    presence_penalty: request.presencePenalty,
+    repetition_penalty: request.repetitionPenalty,
+    min_p: request.minP,
+    top_a: request.topA,
+    stop: request.stop,
+    seed: request.seed,
+    max_tokens: request.maxTokens,
+    max_completion_tokens: request.maxCompletionTokens,
+    reasoning: request.reasoning,
+    response_format: request.responseFormat,
+    tools: request.tools,
+    tool_choice: request.toolChoice,
+    logprobs: request.logprobs,
+    top_logprobs: request.topLogprobs,
+    logit_bias: request.logitBias,
+    parallel_tool_calls: request.parallelToolCalls,
+    prediction: request.prediction,
+    modalities: request.modalities,
+    image_config: request.imageConfig,
+    reasoning_effort: request.reasoningEffort
+  };
+  return Object.entries(parameters).filter(([, value]) => value !== void 0).map(([name]) => name);
+};
+var toProviderRequestError = (action, error, request, context) => {
+  if (request && !isControlFlowError(error)) {
+    const envelope = rawEnvelope(error);
+    const detail = errorProperty(error, "error") ?? errorProperty(envelope, "error") ?? error;
+    const metadata2 = errorProperty(detail, "metadata");
+    const routing = errorProperty(metadata2, "routing_funnel") ?? errorProperty(
+      errorProperty(error, "openrouterMetadata") ?? errorProperty(error, "openrouter_metadata") ?? errorProperty(envelope, "openrouter_metadata"),
+      "routing_funnel"
+    );
+    const failedRoutingStep = errorProperty(routing, "failed_routing_step") ?? errorProperty(metadata2, "failed_routing_step");
+    const rawStatus = errorProperty(error, "statusCode") ?? errorProperty(detail, "code");
+    const status = typeof rawStatus === "number" || typeof rawStatus === "string" ? Number(rawStatus) : void 0;
+    const message = errorProperty(detail, "message") ?? errorProperty(error, "message");
+    const parameterFilter = typeof failedRoutingStep === "string" && failedRoutingStep.trim().toLowerCase() === "filter by parameters";
+    const parameterMessage = typeof message === "string" && /^no endpoints found that can handle the requested parameters\.?$/i.test(
+      message.trim()
+    );
+    if (status === 404 && (parameterFilter || failedRoutingStep === void 0 && parameterMessage)) {
+      const requestedParameters = parameterNames(request);
+      const requireParameters = request.provider?.requireParameters ?? false;
+      const requireParametersSource = context?.requireParametersSource ?? "unknown";
+      const featureNames = /* @__PURE__ */ new Set(["response_format", "tools", "tool_choice"]);
+      const featureParameters = requestedParameters.filter(
+        (name2) => featureNames.has(name2)
+      );
+      const otherParameters = requestedParameters.filter(
+        (name2) => !featureNames.has(name2)
+      );
+      const usesPreset = Boolean(
+        request.model?.includes("@preset/") || request.models?.some((model) => model.includes("@preset/"))
+      );
+      const automaticFeatures = [
+        ...request.tools?.length ? ["tool calling"] : [],
+        ...request.responseFormat?.type === "json_schema" ? ["structured output"] : []
+      ];
+      const origin = requireParametersSource === "automatic" ? `enabled automatically by Kortyx for ${automaticFeatures.join(" and ")}` : requireParametersSource === "explicit" ? "configured explicitly by the caller" : requireParametersSource === "default" ? "not explicitly set; provider default" : "setting origin unavailable";
+      const guidance = "Remove unsupported optional parameters only if your application can omit them, or select a compatible model/provider route.";
+      const override = requireParametersSource === "automatic" ? " To override strict parameter routing, set providerOptions.openrouter.provider.requireParameters=false; unsupported controls, including tools/structured output, may then be ignored." : "";
+      const preset = usesPreset ? " Preset settings may also affect routing; this list only covers parameters sent by Kortyx." : "";
+      const diagnostic = `OpenRouter found no endpoint supporting the requested parameters. require_parameters=${requireParameters} (${origin}). Tool/output parameters: ${featureParameters.join(", ") || "none"}. Other requested parameters: ${otherParameters.join(", ") || "none"}. ${guidance}${override}${preset}`;
+      return new ProviderRequestError(
+        typeof message === "string" ? message : diagnostic,
+        {
+          code: "PROVIDER_PARAMETER_UNSUPPORTED",
+          source: "openrouter",
+          operation: action,
+          status: 404,
+          retryable: false,
+          safeMessage: diagnostic,
+          details: {
+            requestedParameters,
+            requireParameters,
+            requireParametersSource,
+            featureParameters,
+            otherParameters,
+            usesPreset,
+            ...parameterFilter ? { failedRoutingStep: "Filter by Parameters" } : {}
+          },
+          cause: error
+        }
+      );
+    }
+  }
+  const name = errorProperty(error, "name");
+  const originalMessage = errorProperty(error, "message");
+  if (name === "ResponseValidationError" || context?.streamStarted && (name === "SDKValidationError" || name === "ZodError")) {
+    return new ProviderRequestError(
+      typeof originalMessage === "string" ? originalMessage : "OpenRouter SDK response validation failed.",
+      {
+        code: "PROVIDER_INVALID_RESPONSE",
+        source: "openrouter",
+        operation: action,
+        retryable: false,
+        safeMessage: "OpenRouter returned a response that did not match its SDK schema. Inspect the original SDK error for details.",
+        cause: error
+      }
+    );
+  }
+  return normalizeProviderError("openrouter", action, error);
+};
 
 // src/messages.ts
 var isRecord = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
@@ -5454,9 +5576,10 @@ var toTool = (tool) => ({
     strict: false
   }
 });
-var createChatRequest = (modelId, messages, options, stream) => {
+var prepareChatRequest = (modelId, messages, options, stream) => {
   const extra = getOpenRouterOptions(options);
   const needsRequiredParameters = Boolean(options.tools?.length) || options.responseFormat?.type === "json" && options.responseFormat.schema !== void 0;
+  const requireParametersSource = extra.provider?.requireParameters !== void 0 ? "explicit" : needsRequiredParameters ? "automatic" : "default";
   const provider = {
     ...extra.provider,
     ...needsRequiredParameters && extra.provider?.requireParameters === void 0 ? { requireParameters: true } : {}
@@ -5468,7 +5591,7 @@ var createChatRequest = (modelId, messages, options, stream) => {
     } : {},
     ...options.reasoning.includeThoughts ? { summary: "auto" } : {}
   } : extra.reasoning;
-  return {
+  const request = {
     ...extra,
     model: modelId,
     messages: toMessages(messages),
@@ -5490,6 +5613,7 @@ var createChatRequest = (modelId, messages, options, stream) => {
     ...options.tools?.length ? { tools: options.tools.map(toTool) } : {},
     ...Object.keys(provider).length > 0 ? { provider } : {}
   };
+  return { request, context: { requireParametersSource } };
 };
 
 // src/models.ts
@@ -5589,7 +5713,7 @@ var toOutput = (questions, response) => {
   for (const [name, question] of Object.entries(questions)) {
     const answer = response.answers[name];
     if (!answer || answer.type !== question.type)
-      throw new ProviderRequestError(
+      throw new ProviderRequestError2(
         `OpenRouter returned no compatible Jev answer for question "${name}".`
       );
     switch (answer.type) {
@@ -5603,7 +5727,7 @@ var toOutput = (questions, response) => {
         output[name] = answer.noul;
         break;
       default:
-        throw new ProviderRequestError(
+        throw new ProviderRequestError2(
           `OpenRouter returned an unsupported Jev answer for question "${name}".`
         );
     }
@@ -5779,7 +5903,7 @@ var warningsFor = (options) => {
 var resultFrom = (modelId, response, warnings) => {
   const choice = response.choices[0];
   if (!choice)
-    throw new ProviderRequestError(
+    throw new ProviderRequestError2(
       "OpenRouter returned a chat completion without a choice."
     );
   const toolCalls = mapToolCalls(choice.message.toolCalls);
@@ -5818,18 +5942,23 @@ var createChatModel = (modelId, settings, options) => {
   return {
     supportsToolStreaming: true,
     async invoke(messages) {
+      let request;
+      let context;
       try {
-        const response = await getClient().chat(
-          createChatRequest(modelId, messages, options, false),
-          options.abortSignal
-        );
+        ({ request, context } = prepareChatRequest(
+          modelId,
+          messages,
+          options,
+          false
+        ));
+        const response = await getClient().chat(request, options.abortSignal);
         if (isAsyncIterable(response))
-          throw new ProviderRequestError(
+          throw new ProviderRequestError2(
             "OpenRouter unexpectedly returned a stream for a non-streaming request."
           );
         return resultFrom(modelId, response, warnings);
       } catch (error) {
-        throw toProviderRequestError("invoke content", error);
+        throw toProviderRequestError("invoke content", error, request, context);
       }
     },
     async *stream(messages) {
@@ -5850,15 +5979,21 @@ var createChatModel = (modelId, settings, options) => {
       }
       let lastChunk;
       let partialUsage;
+      let request;
+      let context;
       try {
-        const response = await getClient().chat(
-          createChatRequest(modelId, messages, options, true),
-          options.abortSignal
-        );
+        ({ request, context } = prepareChatRequest(
+          modelId,
+          messages,
+          options,
+          true
+        ));
+        const response = await getClient().chat(request, options.abortSignal);
         if (!isAsyncIterable(response))
-          throw new ProviderRequestError(
+          throw new ProviderRequestError2(
             "OpenRouter unexpectedly returned a non-streaming response for a streaming request."
           );
+        context.streamStarted = true;
         const calls = /* @__PURE__ */ new Map();
         const reasoningDetails = [];
         let finishReason;
@@ -5866,9 +6001,12 @@ var createChatModel = (modelId, settings, options) => {
           lastChunk = chunk;
           partialUsage = mapUsage2(chunk.usage) ?? partialUsage;
           if (chunk.error)
-            throw new ProviderRequestError(chunk.error.message, {
-              ...chunk.error.metadata ? { details: chunk.error.metadata } : {}
-            });
+            throw toProviderRequestError(
+              "stream content",
+              chunk.error,
+              request,
+              context
+            );
           for (const choice of chunk.choices) {
             finishReason = choice.finishReason ?? finishReason;
             if (choice.delta.content)
@@ -5895,12 +6033,12 @@ var createChatModel = (modelId, settings, options) => {
           }
         }
         if (!lastChunk || !finishReason)
-          throw new ProviderRequestError(
+          throw new ProviderRequestError2(
             "OpenRouter stream ended without a finish reason."
           );
         const toolCalls = calls.size ? [...calls.entries()].sort(([left], [right]) => left - right).map(([, call]) => {
           if (!call.id || !call.name)
-            throw new ProviderRequestError(
+            throw new ProviderRequestError2(
               "OpenRouter returned an incomplete streamed tool call."
             );
           return {
@@ -5931,7 +6069,7 @@ var createChatModel = (modelId, settings, options) => {
         yield {
           type: "error",
           error: Object.assign(
-            toProviderRequestError("stream content", error),
+            toProviderRequestError("stream content", error, request, context),
             {
               usage: partialUsage
             }
@@ -5980,7 +6118,7 @@ export {
   MODELS,
   PROVIDER_ID,
   ProviderConfigurationError3 as ProviderConfigurationError,
-  ProviderRequestError2 as ProviderRequestError,
+  ProviderRequestError3 as ProviderRequestError,
   createOpenRouter,
   createOpenRouter as createProvider,
   jevOutputSchema,