@core-ai/mistral 0.5.1 → 0.6.0

package/dist/index.d.ts

@@ -1,7 +1,8 @@
 import { Mistral } from '@mistralai/mistralai';
 import { ChatModel, EmbeddingModel } from '@core-ai/core-ai';
+import { z } from 'zod';
 
-type MistralProviderOptions = {
+type MistralProviderOptions$1 = {
     apiKey?: string;
     baseURL?: string;
     client?: Mistral;
@@ -10,6 +11,81 @@ type MistralProvider = {
     chatModel(modelId: string): ChatModel;
     embeddingModel(modelId: string): EmbeddingModel;
 };
-declare function createMistral(options?: MistralProviderOptions): MistralProvider;
+declare function createMistral(options?: MistralProviderOptions$1): MistralProvider;
 
-export { type MistralProvider, type MistralProviderOptions, createMistral };
+declare const mistralGenerateProviderOptionsSchema: z.ZodObject<{
+    stopSequences: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    frequencyPenalty: z.ZodOptional<z.ZodNumber>;
+    presencePenalty: z.ZodOptional<z.ZodNumber>;
+    randomSeed: z.ZodOptional<z.ZodNumber>;
+    parallelToolCalls: z.ZodOptional<z.ZodBoolean>;
+    promptMode: z.ZodOptional<z.ZodString>;
+    safePrompt: z.ZodOptional<z.ZodBoolean>;
+}, "strict", z.ZodTypeAny, {
+    stopSequences?: string[] | undefined;
+    frequencyPenalty?: number | undefined;
+    presencePenalty?: number | undefined;
+    randomSeed?: number | undefined;
+    parallelToolCalls?: boolean | undefined;
+    promptMode?: string | undefined;
+    safePrompt?: boolean | undefined;
+}, {
+    stopSequences?: string[] | undefined;
+    frequencyPenalty?: number | undefined;
+    presencePenalty?: number | undefined;
+    randomSeed?: number | undefined;
+    parallelToolCalls?: boolean | undefined;
+    promptMode?: string | undefined;
+    safePrompt?: boolean | undefined;
+}>;
+type MistralGenerateProviderOptions = z.infer<typeof mistralGenerateProviderOptionsSchema>;
+declare const mistralEmbedProviderOptionsSchema: z.ZodObject<{
+    outputDtype: z.ZodOptional<z.ZodEnum<["float", "int8", "uint8", "binary", "ubinary"]>>;
+    encodingFormat: z.ZodOptional<z.ZodEnum<["float", "base64"]>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strict", z.ZodTypeAny, {
+    outputDtype?: "float" | "int8" | "uint8" | "binary" | "ubinary" | undefined;
+    encodingFormat?: "float" | "base64" | undefined;
+    metadata?: Record<string, unknown> | undefined;
+}, {
+    outputDtype?: "float" | "int8" | "uint8" | "binary" | "ubinary" | undefined;
+    encodingFormat?: "float" | "base64" | undefined;
+    metadata?: Record<string, unknown> | undefined;
+}>;
+type MistralEmbedProviderOptions = z.infer<typeof mistralEmbedProviderOptionsSchema>;
+declare module '@core-ai/core-ai' {
+    interface GenerateProviderOptions {
+        mistral?: MistralGenerateProviderOptions;
+    }
+    interface EmbedProviderOptions {
+        mistral?: MistralEmbedProviderOptions;
+    }
+}
+declare const mistralProviderOptionsSchema: z.ZodObject<{
+    stopSequences: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    frequencyPenalty: z.ZodOptional<z.ZodNumber>;
+    presencePenalty: z.ZodOptional<z.ZodNumber>;
+    randomSeed: z.ZodOptional<z.ZodNumber>;
+    parallelToolCalls: z.ZodOptional<z.ZodBoolean>;
+    promptMode: z.ZodOptional<z.ZodString>;
+    safePrompt: z.ZodOptional<z.ZodBoolean>;
+}, "strict", z.ZodTypeAny, {
+    stopSequences?: string[] | undefined;
+    frequencyPenalty?: number | undefined;
+    presencePenalty?: number | undefined;
+    randomSeed?: number | undefined;
+    parallelToolCalls?: boolean | undefined;
+    promptMode?: string | undefined;
+    safePrompt?: boolean | undefined;
+}, {
+    stopSequences?: string[] | undefined;
+    frequencyPenalty?: number | undefined;
+    presencePenalty?: number | undefined;
+    randomSeed?: number | undefined;
+    parallelToolCalls?: boolean | undefined;
+    promptMode?: string | undefined;
+    safePrompt?: boolean | undefined;
+}>;
+type MistralProviderOptions = MistralGenerateProviderOptions;
+
+export { type MistralEmbedProviderOptions, type MistralGenerateProviderOptions, type MistralProviderOptions as MistralModelProviderOptions, type MistralProvider, type MistralProviderOptions$1 as MistralProviderOptions, createMistral, mistralEmbedProviderOptionsSchema, mistralGenerateProviderOptionsSchema, mistralProviderOptionsSchema };

package/dist/index.js

@@ -6,12 +6,46 @@ import {
   StructuredOutputNoObjectGeneratedError,
   StructuredOutputParseError,
   StructuredOutputValidationError,
-  createObjectStreamResult,
-  createStreamResult
+  createObjectStream,
+  createChatStream
 } from "@core-ai/core-ai";
 
 // src/chat-adapter.ts
 import { zodToJsonSchema } from "zod-to-json-schema";
+
+// src/provider-options.ts
+import { z } from "zod";
+var mistralGenerateProviderOptionsSchema = z.object({
+  stopSequences: z.array(z.string()).optional(),
+  frequencyPenalty: z.number().optional(),
+  presencePenalty: z.number().optional(),
+  randomSeed: z.number().int().optional(),
+  parallelToolCalls: z.boolean().optional(),
+  promptMode: z.string().optional(),
+  safePrompt: z.boolean().optional()
+}).strict();
+var mistralEmbedProviderOptionsSchema = z.object({
+  outputDtype: z.enum(["float", "int8", "uint8", "binary", "ubinary"]).optional(),
+  encodingFormat: z.enum(["float", "base64"]).optional(),
+  metadata: z.record(z.string(), z.unknown()).optional()
+}).strict();
+function parseMistralGenerateProviderOptions(providerOptions) {
+  const rawOptions = providerOptions?.mistral;
+  if (rawOptions === void 0) {
+    return void 0;
+  }
+  return mistralGenerateProviderOptionsSchema.parse(rawOptions);
+}
+function parseMistralEmbedProviderOptions(providerOptions) {
+  const rawOptions = providerOptions?.mistral;
+  if (rawOptions === void 0) {
+    return void 0;
+  }
+  return mistralEmbedProviderOptionsSchema.parse(rawOptions);
+}
+var mistralProviderOptionsSchema = mistralGenerateProviderOptionsSchema;
+
+// src/chat-adapter.ts
 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) {
@@ -31,13 +65,23 @@ function convertMessage(message) {
     };
   }
   if (message.role === "assistant") {
-    const text = message.parts.flatMap((part) => part.type === "text" ? [part.text] : []).join("");
+    const contentChunks = [];
     const toolCalls = message.parts.flatMap(
       (part) => part.type === "tool-call" ? [part.toolCall] : []
     );
+    for (const part of message.parts) {
+      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 }]
+        });
+      }
+    }
     return {
       role: "assistant",
-      content: text.length > 0 ? text : null,
+      content: contentChunks.length > 0 ? contentChunks : null,
       ...toolCalls.length > 0 ? {
         toolCalls: toolCalls.map((toolCall) => ({
           id: toolCall.id,
@@ -122,23 +166,31 @@ function createStructuredOutputOptions(options) {
       toolName
     },
     reasoning: options.reasoning,
-    config: options.config,
+    temperature: options.temperature,
+    maxTokens: options.maxTokens,
+    topP: options.topP,
     providerOptions: options.providerOptions,
     signal: options.signal
   };
 }
 function createGenerateRequest(modelId, options) {
+  const mistralOptions = parseMistralGenerateProviderOptions(
+    options.providerOptions
+  );
   const baseRequest = {
     ...createRequestBase(modelId, options)
   };
-  return mergeProviderOptions(baseRequest, options.providerOptions);
+  return mapMistralProviderOptionsToRequest(baseRequest, mistralOptions);
 }
 function createStreamRequest(modelId, options) {
+  const mistralOptions = parseMistralGenerateProviderOptions(
+    options.providerOptions
+  );
   const baseRequest = {
     ...createRequestBase(modelId, options),
     stream: true
   };
-  return mergeProviderOptions(baseRequest, options.providerOptions);
+  return mapMistralProviderOptionsToRequest(baseRequest, mistralOptions);
 }
 function createRequestBase(modelId, options) {
   return {
@@ -146,24 +198,31 @@ function createRequestBase(modelId, options) {
     messages: convertMessages(options.messages),
     ...options.tools && Object.keys(options.tools).length > 0 ? { tools: convertTools(options.tools) } : {},
     ...options.toolChoice ? { toolChoice: convertToolChoice(options.toolChoice) } : {},
-    ...mapConfigToRequestFields(options.config)
+    ...mapSamplingToRequestFields(options)
   };
 }
-function mapConfigToRequestFields(config) {
+function mapSamplingToRequestFields(options) {
   return {
-    ...config?.temperature !== void 0 ? { temperature: config.temperature } : {},
-    ...config?.maxTokens !== void 0 ? { maxTokens: config.maxTokens } : {},
-    ...config?.topP !== void 0 ? { topP: config.topP } : {},
-    ...config?.stopSequences ? { stop: config.stopSequences } : {},
-    ...config?.frequencyPenalty !== void 0 ? { frequencyPenalty: config.frequencyPenalty } : {},
-    ...config?.presencePenalty !== void 0 ? { presencePenalty: config.presencePenalty } : {}
+    ...options.temperature !== void 0 ? { temperature: options.temperature } : {},
+    ...options.maxTokens !== void 0 ? { maxTokens: options.maxTokens } : {},
+    ...options.topP !== void 0 ? { topP: options.topP } : {}
   };
 }
-function mergeProviderOptions(baseRequest, providerOptions) {
-  return providerOptions ? {
+function mapMistralProviderOptionsToRequest(baseRequest, providerOptions) {
+  if (!providerOptions) {
+    return baseRequest;
+  }
+  const mergedRequest = {
     ...baseRequest,
-    ...providerOptions
-  } : baseRequest;
+    ...providerOptions.stopSequences ? { stop: providerOptions.stopSequences } : {},
+    ...providerOptions.frequencyPenalty !== void 0 ? { frequencyPenalty: providerOptions.frequencyPenalty } : {},
+    ...providerOptions.presencePenalty !== void 0 ? { presencePenalty: providerOptions.presencePenalty } : {},
+    ...providerOptions.randomSeed !== void 0 ? { randomSeed: providerOptions.randomSeed } : {},
+    ...providerOptions.parallelToolCalls !== void 0 ? { parallelToolCalls: providerOptions.parallelToolCalls } : {},
+    ...providerOptions.promptMode !== void 0 ? { promptMode: providerOptions.promptMode } : {},
+    ...providerOptions.safePrompt !== void 0 ? { safePrompt: providerOptions.safePrompt } : {}
+  };
+  return mergedRequest;
 }
 function mapGenerateResponse(response) {
   const firstChoice = response.choices[0];
@@ -235,7 +294,8 @@ async function* transformStream(stream) {
       if (reasoningOpen) {
         reasoningOpen = false;
         yield {
-          type: "reasoning-end"
+          type: "reasoning-end",
+          providerMetadata: { mistral: {} }
         };
       }
       yield {
@@ -247,7 +307,8 @@ async function* transformStream(stream) {
       if (reasoningOpen) {
         reasoningOpen = false;
         yield {
-          type: "reasoning-end"
+          type: "reasoning-end",
+          providerMetadata: { mistral: {} }
         };
       }
       for (const [
@@ -305,7 +366,8 @@ async function* transformStream(stream) {
   }
   if (reasoningOpen) {
     yield {
-      type: "reasoning-end"
+      type: "reasoning-end",
+      providerMetadata: { mistral: {} }
     };
   }
   yield* emitBufferedToolCalls(bufferedToolCalls, emittedToolCalls);
@@ -386,7 +448,8 @@ function extractAssistantParts(message) {
         const thinkingText = extractThinkingText(chunk.thinking);
         parts.push({
           type: "reasoning",
-          text: thinkingText
+          text: thinkingText,
+          providerMetadata: { mistral: {} }
         });
       }
     }
@@ -498,16 +561,22 @@ function createMistralChatModel(client, modelId) {
   async function generateChat(options) {
     const request = createGenerateRequest(modelId, options);
     const response = await callMistralChatApi(
-      () => client.chat.complete(request)
+      () => client.chat.complete(request, { signal: options.signal })
     );
     return mapGenerateResponse(response);
   }
   async function streamChat(options) {
     const request = createStreamRequest(modelId, options);
-    const stream = await callMistralChatApi(
-      () => client.chat.stream(request)
+    return createChatStream(
+      async () => transformStream(
+        await callMistralChatApi(
+          () => client.chat.stream(request, {
+            signal: options.signal
+          })
+        )
+      ),
+      { signal: options.signal }
     );
-    return createStreamResult(transformStream(stream));
   }
   return {
     provider,
@@ -534,13 +603,16 @@ function createMistralChatModel(client, modelId) {
       const structuredOptions = createStructuredOutputOptions(options);
       const stream = await streamChat(structuredOptions);
       const toolName = getStructuredOutputToolName(options);
-      return createObjectStreamResult(
+      return createObjectStream(
         transformStructuredOutputStream(
           stream,
           options.schema,
           provider,
           toolName
-        )
+        ),
+        {
+          signal: options.signal
+        }
       );
     }
   };
@@ -655,7 +727,12 @@ function validateStructuredToolArguments(schema, toolArguments, provider) {
 }
 function parseAndValidateStructuredPayload(schema, rawPayload, provider) {
   const parsedPayload = parseJson(rawPayload, provider);
-  return validateStructuredObject(schema, parsedPayload, provider, rawPayload);
+  return validateStructuredObject(
+    schema,
+    parsedPayload,
+    provider,
+    rawPayload
+  );
 }
 function parseJson(rawOutput, provider) {
   try {
@@ -704,9 +781,12 @@ function createMistralEmbeddingModel(client, modelId) {
           inputs: options.input,
           ...options.dimensions !== void 0 ? { outputDimension: options.dimensions } : {}
         };
-        const request = options.providerOptions ? {
+        const mistralOptions = parseMistralEmbedProviderOptions(
+          options.providerOptions
+        );
+        const request = mistralOptions ? {
           ...baseRequest,
-          ...options.providerOptions
+          ...mistralOptions
         } : baseRequest;
         const response = await client.embeddings.create(request);
         return {
@@ -734,5 +814,8 @@ function createMistral(options = {}) {
   };
 }
 export {
-  createMistral
+  createMistral,
+  mistralEmbedProviderOptionsSchema,
+  mistralGenerateProviderOptionsSchema,
+  mistralProviderOptionsSchema
 };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@core-ai/mistral",
-    "version": "0.5.1",
+    "version": "0.6.0",
     "description": "Mistral provider package for @core-ai/core-ai",
     "license": "MIT",
     "author": "Omnifact (https://omnifact.ai)",
@@ -41,7 +41,7 @@
         "test:watch": "vitest"
     },
     "dependencies": {
-        "@core-ai/core-ai": "^0.5.1",
+        "@core-ai/core-ai": "^0.6.0",
         "@mistralai/mistralai": "^1.14.0",
         "zod-to-json-schema": "^3.25.1"
     },
@@ -49,8 +49,9 @@
         "zod": "^3.25.0 || ^4.0.0"
     },
     "devDependencies": {
-        "@core-ai/eslint-config": "^0.0.0",
-        "@core-ai/typescript-config": "^0.0.0",
+        "@core-ai/eslint-config": "*",
+        "@core-ai/testing": "*",
+        "@core-ai/typescript-config": "*",
         "typescript": "^5.7.3",
         "vitest": "^3.2.4"
     }