@core-ai/mistral 0.2.1 → 0.4.0

package/dist/index.js

@@ -2,12 +2,18 @@
 import { Mistral } from "@mistralai/mistralai";
 
 // src/chat-model.ts
-import { createStreamResult } from "@core-ai/core-ai";
+import {
+  StructuredOutputNoObjectGeneratedError,
+  StructuredOutputParseError,
+  StructuredOutputValidationError,
+  createObjectStreamResult,
+  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";
+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);
 }
@@ -89,41 +95,69 @@ function convertToolChoice(choice) {
     }
   };
 }
+function getStructuredOutputToolName(options) {
+  const trimmedName = options.schemaName?.trim();
+  if (trimmedName && trimmedName.length > 0) {
+    return trimmedName;
+  }
+  return DEFAULT_STRUCTURED_OUTPUT_TOOL_NAME;
+}
+function createStructuredOutputOptions(options) {
+  const toolName = getStructuredOutputToolName(options);
+  return {
+    messages: options.messages,
+    tools: {
+      structured_output: {
+        name: toolName,
+        description: options.schemaDescription ?? DEFAULT_STRUCTURED_OUTPUT_TOOL_DESCRIPTION,
+        parameters: options.schema
+      }
+    },
+    toolChoice: {
+      type: "tool",
+      toolName
+    },
+    config: options.config,
+    providerOptions: options.providerOptions,
+    signal: options.signal
+  };
+}
 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 } : {}
+    ...createRequestBase(modelId, options)
   };
-  return options.providerOptions ? {
-    ...baseRequest,
-    ...options.providerOptions
-  } : baseRequest;
+  return mergeProviderOptions(baseRequest, options.providerOptions);
 }
 function createStreamRequest(modelId, options) {
   const baseRequest = {
+    ...createRequestBase(modelId, options),
+    stream: true
+  };
+  return mergeProviderOptions(baseRequest, options.providerOptions);
+}
+function createRequestBase(modelId, options) {
+  return {
     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 } : {}
+    ...mapConfigToRequestFields(options.config)
+  };
+}
+function mapConfigToRequestFields(config) {
+  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 } : {}
   };
-  return options.providerOptions ? {
+}
+function mergeProviderOptions(baseRequest, providerOptions) {
+  return providerOptions ? {
     ...baseRequest,
-    ...options.providerOptions
+    ...providerOptions
   } : baseRequest;
 }
 function mapGenerateResponse(response) {
@@ -152,8 +186,13 @@ async function* transformStream(stream) {
   let usage = {
     inputTokens: 0,
     outputTokens: 0,
-    reasoningTokens: 0,
-    totalTokens: 0
+    inputTokenDetails: {
+      cacheReadTokens: 0,
+      cacheWriteTokens: 0
+    },
+    outputTokenDetails: {
+      reasoningTokens: 0
+    }
   };
   for await (const event of stream) {
     const chunk = event.data;
@@ -171,7 +210,10 @@ async function* transformStream(stream) {
       };
     }
     if (choice.delta.toolCalls) {
-      for (const [position, partialToolCall] of choice.delta.toolCalls.entries()) {
+      for (const [
+        position,
+        partialToolCall
+      ] of choice.delta.toolCalls.entries()) {
         const streamIndex = partialToolCall.index ?? position;
         const current = bufferedToolCalls.get(streamIndex) ?? {
           id: partialToolCall.id ?? `tool-${streamIndex}`,
@@ -270,8 +312,13 @@ function mapUsage(usage) {
   return {
     inputTokens: usage?.promptTokens ?? 0,
     outputTokens: usage?.completionTokens ?? 0,
-    reasoningTokens: 0,
-    totalTokens: usage?.totalTokens ?? 0
+    inputTokenDetails: {
+      cacheReadTokens: 0,
+      cacheWriteTokens: 0
+    },
+    outputTokenDetails: {
+      reasoningTokens: 0
+    }
   };
 }
 function extractTextContent(content) {
@@ -291,7 +338,9 @@ function extractTextDeltas(content) {
   if (!content || content.length === 0) {
     return [];
   }
-  return content.flatMap((chunk) => chunk.type === "text" ? [chunk.text] : []);
+  return content.flatMap(
+    (chunk) => chunk.type === "text" ? [chunk.text] : []
+  );
 }
 function serializeJsonObject(value) {
   const objectValue = asObject(value);
@@ -317,9 +366,18 @@ function asObject(value) {
   }
   return {};
 }
-function wrapError(error) {
+
+// src/mistral-error.ts
+import { MistralError } from "@mistralai/mistralai/models/errors";
+import { ProviderError } from "@core-ai/core-ai";
+function wrapMistralError(error) {
   if (error instanceof MistralError) {
-    return new ProviderError(error.message, "mistral", error.statusCode, error);
+    return new ProviderError(
+      error.message,
+      "mistral",
+      error.statusCode,
+      error
+    );
   }
   return new ProviderError(
     error instanceof Error ? error.message : String(error),
@@ -331,35 +389,212 @@ function wrapError(error) {
 
 // src/chat-model.ts
 function createMistralChatModel(client, modelId) {
+  const provider = "mistral";
+  async function callMistralChatApi(call) {
+    try {
+      return await call();
+    } catch (error) {
+      throw wrapMistralError(error);
+    }
+  }
+  async function generateChat(options) {
+    const request = createGenerateRequest(modelId, options);
+    const response = await callMistralChatApi(
+      () => client.chat.complete(request)
+    );
+    return mapGenerateResponse(response);
+  }
+  async function streamChat(options) {
+    const request = createStreamRequest(modelId, options);
+    const stream = await callMistralChatApi(
+      () => client.chat.stream(request)
+    );
+    return createStreamResult(transformStream(stream));
+  }
   return {
-    provider: "mistral",
+    provider,
     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);
-      }
+    generate: generateChat,
+    stream: streamChat,
+    async generateObject(options) {
+      const structuredOptions = createStructuredOutputOptions(options);
+      const result = await generateChat(structuredOptions);
+      const toolName = getStructuredOutputToolName(options);
+      const object = extractStructuredObject(
+        result,
+        options.schema,
+        provider,
+        toolName
+      );
+      return {
+        object,
+        finishReason: result.finishReason,
+        usage: result.usage
+      };
     },
-    async stream(options) {
-      try {
-        const request = createStreamRequest(modelId, options);
-        const stream = await client.chat.stream(
-          request
+    async streamObject(options) {
+      const structuredOptions = createStructuredOutputOptions(options);
+      const stream = await streamChat(structuredOptions);
+      const toolName = getStructuredOutputToolName(options);
+      return createObjectStreamResult(
+        transformStructuredOutputStream(
+          stream,
+          options.schema,
+          provider,
+          toolName
+        )
+      );
+    }
+  };
+}
+function extractStructuredObject(result, schema, provider, toolName) {
+  const structuredToolCall = result.toolCalls.find(
+    (toolCall) => toolCall.name === toolName
+  );
+  if (structuredToolCall) {
+    return validateStructuredToolArguments(
+      schema,
+      structuredToolCall.arguments,
+      provider
+    );
+  }
+  const rawOutput = result.content?.trim();
+  if (rawOutput && rawOutput.length > 0) {
+    return parseAndValidateStructuredPayload(schema, rawOutput, provider);
+  }
+  throw new StructuredOutputNoObjectGeneratedError(
+    "model did not emit a structured object payload",
+    provider
+  );
+}
+async function* transformStructuredOutputStream(stream, schema, provider, toolName) {
+  let validatedObject;
+  let contentBuffer = "";
+  const toolArgumentDeltas = /* @__PURE__ */ new Map();
+  for await (const event of stream) {
+    if (event.type === "content-delta") {
+      contentBuffer += event.text;
+      yield {
+        type: "object-delta",
+        text: event.text
+      };
+      continue;
+    }
+    if (event.type === "tool-call-delta") {
+      const previous = toolArgumentDeltas.get(event.toolCallId) ?? "";
+      toolArgumentDeltas.set(
+        event.toolCallId,
+        `${previous}${event.argumentsDelta}`
+      );
+      yield {
+        type: "object-delta",
+        text: event.argumentsDelta
+      };
+      continue;
+    }
+    if (event.type === "tool-call-end" && event.toolCall.name === toolName) {
+      validatedObject = validateStructuredToolArguments(
+        schema,
+        event.toolCall.arguments,
+        provider
+      );
+      yield {
+        type: "object",
+        object: validatedObject
+      };
+      continue;
+    }
+    if (event.type === "finish") {
+      if (validatedObject === void 0) {
+        const fallbackPayload = getFallbackStructuredPayload(
+          contentBuffer,
+          toolArgumentDeltas
         );
-        return createStreamResult(transformStream(stream));
-      } catch (error) {
-        throw wrapError(error);
+        if (!fallbackPayload) {
+          throw new StructuredOutputNoObjectGeneratedError(
+            "structured output stream ended without an object payload",
+            provider
+          );
+        }
+        validatedObject = parseAndValidateStructuredPayload(
+          schema,
+          fallbackPayload,
+          provider
+        );
+        yield {
+          type: "object",
+          object: validatedObject
+        };
       }
+      yield {
+        type: "finish",
+        finishReason: event.finishReason,
+        usage: event.usage
+      };
     }
-  };
+  }
+}
+function getFallbackStructuredPayload(contentBuffer, toolArgumentDeltas) {
+  for (const delta of toolArgumentDeltas.values()) {
+    const trimmed = delta.trim();
+    if (trimmed.length > 0) {
+      return trimmed;
+    }
+  }
+  const trimmedContent = contentBuffer.trim();
+  if (trimmedContent.length > 0) {
+    return trimmedContent;
+  }
+  return void 0;
+}
+function validateStructuredToolArguments(schema, toolArguments, provider) {
+  return validateStructuredObject(
+    schema,
+    toolArguments,
+    provider,
+    JSON.stringify(toolArguments)
+  );
+}
+function parseAndValidateStructuredPayload(schema, rawPayload, provider) {
+  const parsedPayload = parseJson(rawPayload, provider);
+  return validateStructuredObject(schema, parsedPayload, provider, rawPayload);
+}
+function parseJson(rawOutput, provider) {
+  try {
+    return JSON.parse(rawOutput);
+  } catch (error) {
+    throw new StructuredOutputParseError(
+      "failed to parse structured output as JSON",
+      provider,
+      {
+        rawOutput,
+        cause: error
+      }
+    );
+  }
+}
+function validateStructuredObject(schema, value, provider, rawOutput) {
+  const parsed = schema.safeParse(value);
+  if (parsed.success) {
+    return parsed.data;
+  }
+  throw new StructuredOutputValidationError(
+    "structured output does not match schema",
+    provider,
+    formatZodIssues(parsed.error.issues),
+    {
+      rawOutput
+    }
+  );
+}
+function formatZodIssues(issues) {
+  return issues.map((issue) => {
+    const path = issue.path.length > 0 ? issue.path.map((segment) => String(segment)).join(".") : "<root>";
+    return `${path}: ${issue.message}`;
+  });
 }
 
 // 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",
@@ -383,22 +618,11 @@ function createMistralEmbeddingModel(client, modelId) {
           }
         };
       } catch (error) {
-        throw wrapError2(error);
+        throw wrapMistralError(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 = {}) {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@core-ai/mistral",
-    "version": "0.2.1",
+    "version": "0.4.0",
     "description": "Mistral provider package for @core-ai/core-ai",
     "license": "MIT",
     "author": "Omnifact (https://omnifact.ai)",
@@ -42,7 +42,7 @@
         "test:watch": "vitest"
     },
     "dependencies": {
-        "@core-ai/core-ai": "^0.2.1",
+        "@core-ai/core-ai": "^0.4.0",
         "@mistralai/mistralai": "^1.14.0",
         "zod-to-json-schema": "^3.25.1"
     },