@core-ai/mistral 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Omnifact (https://omnifact.ai)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,26 @@
+# @core-ai/mistral
+
+Mistral provider package for `@core-ai/core-ai`.
+
+## Installation
+
+```bash
+npm install @core-ai/core-ai @core-ai/mistral zod
+```
+
+## Usage
+
+```ts
+import { generate } from '@core-ai/core-ai';
+import { createMistral } from '@core-ai/mistral';
+
+const mistral = createMistral({ apiKey: process.env.MISTRAL_API_KEY });
+const model = mistral.chatModel('mistral-large-latest');
+
+const result = await generate({
+    model,
+    messages: [{ role: 'user', content: 'Hello!' }],
+});
+
+console.log(result.content);
+```

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+import { Mistral } from '@mistralai/mistralai';
+import { ChatModel, EmbeddingModel } from '@core-ai/core-ai';
+
+type MistralProviderOptions = {
+    apiKey?: string;
+    baseURL?: string;
+    client?: Mistral;
+};
+type MistralProvider = {
+    chatModel(modelId: string): ChatModel;
+    embeddingModel(modelId: string): EmbeddingModel;
+};
+declare function createMistral(options?: MistralProviderOptions): MistralProvider;
+
+export { type MistralProvider, type MistralProviderOptions, createMistral };

package/dist/index.js

@@ -0,0 +1,416 @@
+// src/provider.ts
+import { Mistral } from "@mistralai/mistralai";
+
+// src/chat-model.ts
+import { createStreamResult } from "@core-ai/core-ai";
+
+// src/chat-adapter.ts
+import { MistralError } from "@mistralai/mistralai/models/errors";
+import { zodToJsonSchema } from "zod-to-json-schema";
+import { ProviderError } from "@core-ai/core-ai";
+function convertMessages(messages) {
+  return messages.map(convertMessage);
+}
+function convertMessage(message) {
+  if (message.role === "system") {
+    return {
+      role: "system",
+      content: message.content
+    };
+  }
+  if (message.role === "user") {
+    return {
+      role: "user",
+      content: typeof message.content === "string" ? message.content : message.content.map(convertUserContentPart)
+    };
+  }
+  if (message.role === "assistant") {
+    return {
+      role: "assistant",
+      content: message.content,
+      ...message.toolCalls && message.toolCalls.length > 0 ? {
+        toolCalls: message.toolCalls.map((toolCall) => ({
+          id: toolCall.id,
+          type: "function",
+          function: {
+            name: toolCall.name,
+            arguments: toolCall.arguments
+          }
+        }))
+      } : {}
+    };
+  }
+  return {
+    role: "tool",
+    toolCallId: message.toolCallId,
+    content: message.content
+  };
+}
+function convertUserContentPart(part) {
+  if (part.type === "text") {
+    return {
+      type: "text",
+      text: part.text
+    };
+  }
+  if (part.type === "image") {
+    const url = part.source.type === "url" ? part.source.url : `data:${part.source.mediaType};base64,${part.source.data}`;
+    return {
+      type: "image_url",
+      imageUrl: {
+        url
+      }
+    };
+  }
+  return {
+    type: "document_url",
+    documentUrl: `data:${part.mimeType};base64,${part.data}`,
+    ...part.filename ? { documentName: part.filename } : {}
+  };
+}
+function convertTools(tools) {
+  return Object.values(tools).map((tool) => ({
+    type: "function",
+    function: {
+      name: tool.name,
+      description: tool.description,
+      parameters: zodToJsonSchema(tool.parameters)
+    }
+  }));
+}
+function convertToolChoice(choice) {
+  if (typeof choice === "string") {
+    return choice;
+  }
+  return {
+    type: "function",
+    function: {
+      name: choice.toolName
+    }
+  };
+}
+function createGenerateRequest(modelId, options) {
+  const baseRequest = {
+    model: modelId,
+    messages: convertMessages(options.messages),
+    ...options.tools && Object.keys(options.tools).length > 0 ? { tools: convertTools(options.tools) } : {},
+    ...options.toolChoice ? { toolChoice: convertToolChoice(options.toolChoice) } : {},
+    ...options.config?.temperature !== void 0 ? { temperature: options.config.temperature } : {},
+    ...options.config?.maxTokens !== void 0 ? { maxTokens: options.config.maxTokens } : {},
+    ...options.config?.topP !== void 0 ? { topP: options.config.topP } : {},
+    ...options.config?.stopSequences ? { stop: options.config.stopSequences } : {},
+    ...options.config?.frequencyPenalty !== void 0 ? { frequencyPenalty: options.config.frequencyPenalty } : {},
+    ...options.config?.presencePenalty !== void 0 ? { presencePenalty: options.config.presencePenalty } : {}
+  };
+  return options.providerOptions ? {
+    ...baseRequest,
+    ...options.providerOptions
+  } : baseRequest;
+}
+function createStreamRequest(modelId, options) {
+  const baseRequest = {
+    model: modelId,
+    messages: convertMessages(options.messages),
+    stream: true,
+    ...options.tools && Object.keys(options.tools).length > 0 ? { tools: convertTools(options.tools) } : {},
+    ...options.toolChoice ? { toolChoice: convertToolChoice(options.toolChoice) } : {},
+    ...options.config?.temperature !== void 0 ? { temperature: options.config.temperature } : {},
+    ...options.config?.maxTokens !== void 0 ? { maxTokens: options.config.maxTokens } : {},
+    ...options.config?.topP !== void 0 ? { topP: options.config.topP } : {},
+    ...options.config?.stopSequences ? { stop: options.config.stopSequences } : {},
+    ...options.config?.frequencyPenalty !== void 0 ? { frequencyPenalty: options.config.frequencyPenalty } : {},
+    ...options.config?.presencePenalty !== void 0 ? { presencePenalty: options.config.presencePenalty } : {}
+  };
+  return options.providerOptions ? {
+    ...baseRequest,
+    ...options.providerOptions
+  } : baseRequest;
+}
+function mapGenerateResponse(response) {
+  const firstChoice = response.choices[0];
+  if (!firstChoice) {
+    return {
+      content: null,
+      toolCalls: [],
+      finishReason: "unknown",
+      usage: mapUsage(response.usage)
+    };
+  }
+  const toolCalls = parseToolCalls(firstChoice.message.toolCalls);
+  const mappedFinishReason = mapFinishReason(firstChoice.finishReason);
+  return {
+    content: extractTextContent(firstChoice.message.content),
+    toolCalls,
+    finishReason: toolCalls.length > 0 && mappedFinishReason !== "content-filter" ? "tool-calls" : mappedFinishReason,
+    usage: mapUsage(response.usage)
+  };
+}
+async function* transformStream(stream) {
+  const bufferedToolCalls = /* @__PURE__ */ new Map();
+  const emittedToolCalls = /* @__PURE__ */ new Set();
+  let finishReason = "unknown";
+  let usage = {
+    inputTokens: 0,
+    outputTokens: 0,
+    reasoningTokens: 0,
+    totalTokens: 0
+  };
+  for await (const event of stream) {
+    const chunk = event.data;
+    if (chunk.usage) {
+      usage = mapUsage(chunk.usage);
+    }
+    const choice = chunk.choices[0];
+    if (!choice) {
+      continue;
+    }
+    for (const textDelta of extractTextDeltas(choice.delta.content)) {
+      yield {
+        type: "content-delta",
+        text: textDelta
+      };
+    }
+    if (choice.delta.toolCalls) {
+      for (const [position, partialToolCall] of choice.delta.toolCalls.entries()) {
+        const streamIndex = partialToolCall.index ?? position;
+        const current = bufferedToolCalls.get(streamIndex) ?? {
+          id: partialToolCall.id ?? `tool-${streamIndex}`,
+          name: partialToolCall.function.name,
+          arguments: ""
+        };
+        const isNew = !bufferedToolCalls.has(streamIndex);
+        if (partialToolCall.id) {
+          current.id = partialToolCall.id;
+        }
+        if (partialToolCall.function.name) {
+          current.name = partialToolCall.function.name;
+        }
+        const argumentDelta = partialToolCall.function.arguments;
+        if (typeof argumentDelta === "string") {
+          current.arguments += argumentDelta;
+          yield {
+            type: "tool-call-delta",
+            toolCallId: current.id,
+            argumentsDelta: argumentDelta
+          };
+        } else {
+          const serializedArguments = serializeJsonObject(argumentDelta);
+          if (serializedArguments.length > 0) {
+            current.arguments = serializedArguments;
+            yield {
+              type: "tool-call-delta",
+              toolCallId: current.id,
+              argumentsDelta: serializedArguments
+            };
+          }
+        }
+        bufferedToolCalls.set(streamIndex, current);
+        if (isNew) {
+          yield {
+            type: "tool-call-start",
+            toolCallId: current.id,
+            toolName: current.name
+          };
+        }
+      }
+    }
+    if (choice.finishReason) {
+      finishReason = mapFinishReason(choice.finishReason);
+    }
+    if (finishReason === "tool-calls") {
+      yield* emitBufferedToolCalls(bufferedToolCalls, emittedToolCalls);
+    }
+  }
+  yield* emitBufferedToolCalls(bufferedToolCalls, emittedToolCalls);
+  yield {
+    type: "finish",
+    finishReason,
+    usage
+  };
+}
+function* emitBufferedToolCalls(bufferedToolCalls, emittedToolCalls) {
+  for (const [toolCallIndex, toolCall] of bufferedToolCalls.entries()) {
+    if (emittedToolCalls.has(toolCallIndex)) {
+      continue;
+    }
+    emittedToolCalls.add(toolCallIndex);
+    yield {
+      type: "tool-call-end",
+      toolCall: {
+        id: toolCall.id,
+        name: toolCall.name,
+        arguments: safeParseJsonObject(toolCall.arguments)
+      }
+    };
+  }
+}
+function parseToolCalls(calls) {
+  if (!calls || calls.length === 0) {
+    return [];
+  }
+  return calls.map((toolCall, index) => ({
+    id: toolCall.id ?? `tool-${index}`,
+    name: toolCall.function.name,
+    arguments: toObject(toolCall.function.arguments)
+  }));
+}
+function mapFinishReason(reason) {
+  if (reason === "stop") {
+    return "stop";
+  }
+  if (reason === "length" || reason === "model_length") {
+    return "length";
+  }
+  if (reason === "tool_calls") {
+    return "tool-calls";
+  }
+  return "unknown";
+}
+function mapUsage(usage) {
+  return {
+    inputTokens: usage?.promptTokens ?? 0,
+    outputTokens: usage?.completionTokens ?? 0,
+    reasoningTokens: 0,
+    totalTokens: usage?.totalTokens ?? 0
+  };
+}
+function extractTextContent(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  if (!content || content.length === 0) {
+    return null;
+  }
+  const text = content.flatMap((chunk) => chunk.type === "text" ? [chunk.text] : []).join("");
+  return text.length > 0 ? text : null;
+}
+function extractTextDeltas(content) {
+  if (typeof content === "string") {
+    return [content];
+  }
+  if (!content || content.length === 0) {
+    return [];
+  }
+  return content.flatMap((chunk) => chunk.type === "text" ? [chunk.text] : []);
+}
+function serializeJsonObject(value) {
+  const objectValue = asObject(value);
+  return Object.keys(objectValue).length > 0 ? JSON.stringify(objectValue) : "";
+}
+function toObject(value) {
+  if (typeof value === "string") {
+    return safeParseJsonObject(value);
+  }
+  return asObject(value);
+}
+function safeParseJsonObject(json) {
+  try {
+    const parsed = JSON.parse(json);
+    return asObject(parsed);
+  } catch {
+    return {};
+  }
+}
+function asObject(value) {
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    return value;
+  }
+  return {};
+}
+function wrapError(error) {
+  if (error instanceof MistralError) {
+    return new ProviderError(error.message, "mistral", error.statusCode, error);
+  }
+  return new ProviderError(
+    error instanceof Error ? error.message : String(error),
+    "mistral",
+    void 0,
+    error
+  );
+}
+
+// src/chat-model.ts
+function createMistralChatModel(client, modelId) {
+  return {
+    provider: "mistral",
+    modelId,
+    async generate(options) {
+      try {
+        const request = createGenerateRequest(modelId, options);
+        const response = await client.chat.complete(request);
+        return mapGenerateResponse(response);
+      } catch (error) {
+        throw wrapError(error);
+      }
+    },
+    async stream(options) {
+      try {
+        const request = createStreamRequest(modelId, options);
+        const stream = await client.chat.stream(
+          request
+        );
+        return createStreamResult(transformStream(stream));
+      } catch (error) {
+        throw wrapError(error);
+      }
+    }
+  };
+}
+
+// src/embedding-model.ts
+import { MistralError as MistralError2 } from "@mistralai/mistralai/models/errors";
+import { ProviderError as ProviderError2 } from "@core-ai/core-ai";
+function createMistralEmbeddingModel(client, modelId) {
+  return {
+    provider: "mistral",
+    modelId,
+    async embed(options) {
+      try {
+        const baseRequest = {
+          model: modelId,
+          inputs: options.input,
+          ...options.dimensions !== void 0 ? { outputDimension: options.dimensions } : {}
+        };
+        const request = options.providerOptions ? {
+          ...baseRequest,
+          ...options.providerOptions
+        } : baseRequest;
+        const response = await client.embeddings.create(request);
+        return {
+          embeddings: response.data.slice().sort((a, b) => (a.index ?? 0) - (b.index ?? 0)).map((item) => item.embedding ?? []),
+          usage: {
+            inputTokens: response.usage.promptTokens ?? 0
+          }
+        };
+      } catch (error) {
+        throw wrapError2(error);
+      }
+    }
+  };
+}
+function wrapError2(error) {
+  if (error instanceof MistralError2) {
+    return new ProviderError2(error.message, "mistral", error.statusCode, error);
+  }
+  return new ProviderError2(
+    error instanceof Error ? error.message : String(error),
+    "mistral",
+    void 0,
+    error
+  );
+}
+
+// src/provider.ts
+function createMistral(options = {}) {
+  const client = options.client ?? new Mistral({
+    apiKey: options.apiKey,
+    ...options.baseURL ? { serverURL: options.baseURL } : {}
+  });
+  return {
+    chatModel: (modelId) => createMistralChatModel(client, modelId),
+    embeddingModel: (modelId) => createMistralEmbeddingModel(client, modelId)
+  };
+}
+export {
+  createMistral
+};

package/package.json

@@ -0,0 +1,58 @@
+{
+    "name": "@core-ai/mistral",
+    "version": "0.2.0",
+    "description": "Mistral provider package for @core-ai/core-ai",
+    "license": "MIT",
+    "author": "Omnifact (https://omnifact.ai)",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/agdevhq/ai-core.git",
+        "directory": "packages/mistral"
+    },
+    "keywords": [
+        "llm",
+        "ai",
+        "mistral",
+        "provider",
+        "sdk"
+    ],
+    "type": "module",
+    "main": "./dist/index.js",
+    "types": "./dist/index.d.ts",
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "import": "./dist/index.js"
+        }
+    },
+    "files": [
+        "dist",
+        "README.md",
+        "LICENSE"
+    ],
+    "publishConfig": {
+        "access": "public"
+    },
+    "scripts": {
+        "build": "tsup",
+        "lint": "eslint src/ --max-warnings 0",
+        "check-types": "tsc --noEmit",
+        "prepublishOnly": "npm run build",
+        "test": "vitest run",
+        "test:watch": "vitest"
+    },
+    "dependencies": {
+        "@core-ai/core-ai": "^0.2.0",
+        "@mistralai/mistralai": "^1.14.0",
+        "zod-to-json-schema": "^3.25.1"
+    },
+    "peerDependencies": {
+        "zod": "^3.25.76"
+    },
+    "devDependencies": {
+        "@core-ai/eslint-config": "^0.0.0",
+        "@core-ai/typescript-config": "^0.0.0",
+        "typescript": "^5.7.3",
+        "vitest": "^3.2.4"
+    }
+}