@core-ai/mistral 0.16.0 → 0.18.0

package/dist/index.js

@@ -13,6 +13,7 @@ import {
 // src/chat-adapter.ts
 import {
   asObject,
+  getProviderMetadata,
   safeParseJsonObject,
   zodSchemaToJsonSchema
 } from "@core-ai/core-ai";
@@ -49,13 +50,31 @@ function parseMistralEmbedProviderOptions(providerOptions) {
 }
 var mistralProviderOptionsSchema = mistralGenerateProviderOptionsSchema;
 
+// src/model-capabilities.ts
+var NO_REASONING_CAPABILITIES = {
+  reasoning: {
+    mode: "unsupported",
+    supportedEfforts: [],
+    restrictsSamplingParams: false,
+    supportedToolChoices: ["auto", "none", "required", "tool"]
+  }
+};
+function getMistralModelCapabilities(_modelId) {
+  return NO_REASONING_CAPABILITIES;
+}
+
 // src/chat-adapter.ts
+var MISTRAL_REASONING_METADATA_NAMESPACE = "mistral";
 var DEFAULT_STRUCTURED_OUTPUT_TOOL_NAME = "core_ai_generate_object";
 var DEFAULT_STRUCTURED_OUTPUT_TOOL_DESCRIPTION = "Return a JSON object that matches the requested schema.";
-function convertMessages(messages) {
-  return messages.map(convertMessage);
+function convertMessages(messages, options = {}) {
+  const includeReasoning = options.includeReasoning ?? true;
+  return messages.flatMap((message) => {
+    const convertedMessage = convertMessage(message, includeReasoning);
+    return convertedMessage ? [convertedMessage] : [];
+  });
 }
-function convertMessage(message) {
+function convertMessage(message, includeReasoning) {
   if (message.role === "system") {
     return {
       role: "system",
@@ -77,12 +96,26 @@ function convertMessage(message) {
       if (part.type === "text") {
         contentChunks.push({ type: "text", text: part.text });
       } else if (part.type === "reasoning" && part.text.length > 0) {
-        contentChunks.push({
-          type: "thinking",
-          thinking: [{ type: "text", text: part.text }]
-        });
+        const isNativeMistralReasoning = getProviderMetadata(
+          part.providerMetadata,
+          MISTRAL_REASONING_METADATA_NAMESPACE
+        ) != null;
+        if (includeReasoning && isNativeMistralReasoning) {
+          contentChunks.push({
+            type: "thinking",
+            thinking: [{ type: "text", text: part.text }]
+          });
+        } else {
+          contentChunks.push({
+            type: "text",
+            text: `<thinking>${part.text}</thinking>`
+          });
+        }
       }
     }
+    if (contentChunks.length === 0 && toolCalls.length === 0) {
+      return void 0;
+    }
     return {
       role: "assistant",
       content: contentChunks.length > 0 ? contentChunks : null,
@@ -195,9 +228,12 @@ function createStreamRequest(modelId, options) {
   return mapMistralProviderOptionsToRequest(baseRequest, mistralOptions);
 }
 function createRequestBase(modelId, options) {
+  const capabilities = getMistralModelCapabilities(modelId);
   return {
     model: modelId,
-    messages: convertMessages(options.messages),
+    messages: convertMessages(options.messages, {
+      includeReasoning: capabilities.reasoning.mode !== "unsupported"
+    }),
     ...options.tools && Object.keys(options.tools).length > 0 ? { tools: convertTools(options.tools) } : {},
     ...options.toolChoice ? { toolChoice: convertToolChoice(options.toolChoice) } : {},
     ...mapSamplingToRequestFields(options)
@@ -549,39 +585,163 @@ function toObject(value) {
 // src/mistral-error.ts
 import {
   RequestAbortedError,
+  RequestTimeoutError,
   MistralError
 } from "@mistralai/mistralai/models/errors";
-import { AbortedError, ProviderError } from "@core-ai/core-ai";
+import {
+  AbortedError,
+  ContextLengthExceededError,
+  ModelOverloadedError,
+  ProviderError,
+  RateLimitError,
+  ServiceUnavailableError,
+  asRecord,
+  getErrorMessage,
+  getHttpStatusCode,
+  getRetryAfterSecondsFromError,
+  getString,
+  isAbortErrorByName,
+  isRateLimitStatus,
+  isTransientUnavailableStatus
+} from "@core-ai/core-ai";
+var OVERLOAD_MESSAGE_ELIGIBLE_STATUS_CODES = /* @__PURE__ */ new Set([500, 502, 503, 504]);
 function wrapMistralError(error) {
-  if (error instanceof RequestAbortedError || error instanceof Error && error.name === "AbortError") {
+  if (isMistralAbortError(error)) {
     return new AbortedError(error, "mistral");
   }
-  if (error instanceof MistralError) {
-    return new ProviderError(
-      error.message,
-      "mistral",
-      error.statusCode,
-      error
-    );
+  if (isMistralTimeoutError(error)) {
+    return new ServiceUnavailableError(getErrorMessage(error), "mistral", {
+      cause: error
+    });
+  }
+  const message = getErrorMessage(error);
+  const statusCode = error instanceof MistralError ? error.statusCode : getHttpStatusCode(error, ["statusCode", "status"]);
+  const body = parseErrorBody(error);
+  const options = { statusCode, cause: error };
+  const contextLength = getContextLengthDetails(body, message);
+  if (contextLength) {
+    return new ContextLengthExceededError(message, "mistral", {
+      ...options,
+      ...contextLength
+    });
+  }
+  if (indicatesMistralOverload(message, statusCode)) {
+    return new ModelOverloadedError(message, "mistral", options);
+  }
+  if (isMistralRateLimit(statusCode, body?.type)) {
+    return new RateLimitError(message, "mistral", {
+      ...options,
+      retryAfterSeconds: getRetryAfterSecondsFromError(error)
+    });
+  }
+  if (isTransientUnavailableStatus(statusCode)) {
+    return new ServiceUnavailableError(message, "mistral", options);
+  }
+  return new ProviderError(message, "mistral", options);
+}
+function isMistralAbortError(error) {
+  return error instanceof RequestAbortedError || isAbortErrorByName(error);
+}
+function isMistralTimeoutError(error) {
+  return error instanceof RequestTimeoutError || error instanceof Error && error.name === "RequestTimeoutError";
+}
+function isMistralRateLimit(statusCode, errorType) {
+  return isRateLimitStatus(statusCode) || errorType === "rate_limit_error";
+}
+function indicatesMistralOverload(text, statusCode) {
+  if (statusCode !== void 0 && !OVERLOAD_MESSAGE_ELIGIBLE_STATUS_CODES.has(statusCode)) {
+    return false;
+  }
+  return /\boverloaded\b/i.test(text);
+}
+function getContextLengthDetails(body, message) {
+  const errorMessage = resolveMistralMessageText(body?.message ?? message);
+  const errorType = body?.type;
+  const isContextType = errorType === "invalid_request_error" || errorType === "invalid_request_invalid_args" || errorType === void 0;
+  if (!isContextType) {
+    return void 0;
+  }
+  const lower = errorMessage.toLowerCase();
+  const isContextWording = lower.includes("too large for model") || /exceeds the model's maximum context length/i.test(errorMessage);
+  if (!isContextWording) {
+    return void 0;
   }
-  return new ProviderError(
-    error instanceof Error ? error.message : String(error),
-    "mistral",
-    void 0,
-    error
+  const match = errorMessage.match(
+    /(\d+)\s*tokens.*too large for model with (\d+) maximum context length/
   );
+  if (!match) {
+    const alternate = errorMessage.match(
+      /exceeds the model's maximum context length of (\d+)/i
+    );
+    if (alternate?.[1]) {
+      return { maxTokens: parseInt(alternate[1], 10) };
+    }
+    return {};
+  }
+  const actualTokens = match[1];
+  const maxTokens = match[2];
+  if (actualTokens === void 0 || maxTokens === void 0) {
+    return {};
+  }
+  return {
+    maxTokens: parseInt(maxTokens, 10),
+    actualTokens: parseInt(actualTokens, 10)
+  };
 }
-
-// src/model-capabilities.ts
-var NO_REASONING_CAPABILITIES = {
-  reasoning: {
-    supported: false,
-    supportedEfforts: [],
-    restrictsSamplingParams: false
+function resolveMistralMessageText(message) {
+  const trimmed = message.trim();
+  if (!trimmed.startsWith("{")) {
+    return message;
   }
-};
-function getMistralModelCapabilities(_modelId) {
-  return NO_REASONING_CAPABILITIES;
+  try {
+    const parsed = JSON.parse(trimmed);
+    const record = asRecord(parsed);
+    const nestedMessage = getString(record, "message");
+    if (nestedMessage) {
+      return nestedMessage;
+    }
+  } catch {
+  }
+  return message;
+}
+function parseErrorBody(error) {
+  const record = asRecord(error);
+  if (!record || !("body" in record)) {
+    const type = getString(record, "type");
+    const message = getString(record, "message");
+    if (type || message) {
+      return {
+        type,
+        message: message ? resolveMistralMessageText(message) : void 0
+      };
+    }
+    return void 0;
+  }
+  const body = record.body;
+  if (typeof body !== "string") {
+    if (body && typeof body === "object") {
+      const bodyRecord = asRecord(body);
+      const message = getString(bodyRecord, "message");
+      return {
+        message: message ? resolveMistralMessageText(message) : void 0,
+        type: getString(bodyRecord, "type")
+      };
+    }
+    return void 0;
+  }
+  try {
+    const parsed = JSON.parse(body);
+    const parsedRecord = asRecord(parsed);
+    if (parsedRecord) {
+      const message = getString(parsedRecord, "message");
+      return {
+        message: message ? resolveMistralMessageText(message) : void 0,
+        type: getString(parsedRecord, "type")
+      };
+    }
+  } catch {
+  }
+  return void 0;
 }
 
 // src/chat-model.ts

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@core-ai/mistral",
-    "version": "0.16.0",
+    "version": "0.18.0",
     "description": "Mistral provider package for @core-ai/core-ai",
     "license": "MIT",
     "author": "Omnifact (https://omnifact.ai)",
@@ -43,7 +43,7 @@
         "test:watch": "vitest"
     },
     "dependencies": {
-        "@core-ai/core-ai": "^0.16.0",
+        "@core-ai/core-ai": "^0.18.0",
         "@mistralai/mistralai": "^2.4.1"
     },
     "peerDependencies": {