@effect-uai/mistral 0.11.0 → 0.12.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect-uai/mistral",
-  "version": "0.11.0",
+  "version": "0.12.1",
   "description": "Mistral provider for @effect-uai/core: chat-completions plus Voxtral speech-to-text and text-to-speech.",
   "keywords": [
     "ai",
@@ -58,16 +58,19 @@
   "publishConfig": {
     "access": "public"
   },
+  "dependencies": {
+    "@effect-uai/chat-completions": "0.12.1"
+  },
   "devDependencies": {
     "@types/ws": "^8.5.13",
-    "effect": "4.0.0-beta.94",
-    "typescript": "^6.0.3",
+    "effect": "4.0.0-rc.111",
+    "typescript": "^7.0.2",
     "ws": "^8.18.0",
-    "@effect-uai/core": "0.11.0"
+    "@effect-uai/core": "0.12.1"
   },
   "peerDependencies": {
     "@effect-uai/core": ">=0.2.0 <1",
-    "effect": ">=4.0.0-beta.94 <5.0.0",
+    "effect": ">=4.0.0-rc.111 <5.0.0",
     "ws": "^8.0.0"
   },
   "peerDependenciesMeta": {

package/src/Mistral.ts

@@ -182,13 +182,10 @@ export const layer = (
   const typed = Layer.effect(Mistral, make(cfg))
   const generic = Layer.effect(
     LanguageModel,
-    Effect.map(
-      make(cfg),
-      (s): LanguageModelService => ({
-        streamTurn: (request) => s.streamTurn(request as MistralRequest),
-        turn: (request) => s.turn(request as MistralRequest),
-      }),
-    ),
+    Effect.map(make(cfg), (s): LanguageModelService => ({
+      streamTurn: (request) => s.streamTurn(request as MistralRequest),
+      turn: (request) => s.turn(request as MistralRequest),
+    })),
   )
   return Layer.merge(typed, generic)
 }

package/src/MistralRealtimeTranscriber.ts

@@ -47,14 +47,10 @@ export const layer = (
     Layer.effect(MistralTranscriber, make(cfg)),
     Layer.effect(
       Transcriber,
-      Effect.map(
-        make(cfg),
-        (s): TranscriberService => ({
-          transcribe: (req: CommonTranscribeRequest) =>
-            s.transcribe(req as MistralTranscribeRequest),
-          streamTranscriptionFrom: s.streamTranscriptionFrom,
-        }),
-      ),
+      Effect.map(make(cfg), (s): TranscriberService => ({
+        transcribe: (req: CommonTranscribeRequest) => s.transcribe(req as MistralTranscribeRequest),
+        streamTranscriptionFrom: s.streamTranscriptionFrom,
+      })),
     ),
     Layer.succeed(SttStreaming, undefined),
   )

package/src/MistralSynthesizer.ts

@@ -268,18 +268,14 @@ export const layer = (
     Layer.effect(MistralSynthesizer, make(cfg)),
     Layer.effect(
       SpeechSynthesizer,
-      Effect.map(
-        make(cfg),
-        (s): SpeechSynthesizerService => ({
-          synthesize: (req: CommonSynthesizeRequest) =>
-            s.synthesize(req as MistralSynthesizeRequest),
-          streamSynthesis: (req: CommonSynthesizeRequest) =>
-            s.streamSynthesis(req as MistralSynthesizeRequest),
-          streamSynthesisFrom: s.streamSynthesisFrom,
-          synthesizeDialogue: s.synthesizeDialogue,
-          streamSynthesizeDialogue: s.streamSynthesizeDialogue,
-        }),
-      ),
+      Effect.map(make(cfg), (s): SpeechSynthesizerService => ({
+        synthesize: (req: CommonSynthesizeRequest) => s.synthesize(req as MistralSynthesizeRequest),
+        streamSynthesis: (req: CommonSynthesizeRequest) =>
+          s.streamSynthesis(req as MistralSynthesizeRequest),
+        streamSynthesisFrom: s.streamSynthesisFrom,
+        synthesizeDialogue: s.synthesizeDialogue,
+        streamSynthesizeDialogue: s.streamSynthesizeDialogue,
+      })),
     ),
     Layer.succeed(TtsIncrementalText, undefined),
   )

package/src/MistralTranscriber.ts

@@ -86,9 +86,11 @@ const buildFormData = (
     const filePart: Part = isAudioUrl(request.audio)
       ? ["file_url", request.audio.url]
       : yield* audioToBlob(request.audio).pipe(
-          Effect.map(
-            (blob): Part => ["file", blob, request.fileName ?? defaultFileName(blob.type)],
-          ),
+          Effect.map((blob): Part => [
+            "file",
+            blob,
+            request.fileName ?? defaultFileName(blob.type),
+          ]),
         )
     const parts: ReadonlyArray<Part> = [
       filePart,
@@ -212,13 +214,9 @@ export const layer = (
     Layer.effect(MistralTranscriber, make(cfg)),
     Layer.effect(
       Transcriber,
-      Effect.map(
-        make(cfg),
-        (s): TranscriberService => ({
-          transcribe: (req: CommonTranscribeRequest) =>
-            s.transcribe(req as MistralTranscribeRequest),
-          streamTranscriptionFrom: s.streamTranscriptionFrom,
-        }),
-      ),
+      Effect.map(make(cfg), (s): TranscriberService => ({
+        transcribe: (req: CommonTranscribeRequest) => s.transcribe(req as MistralTranscribeRequest),
+        streamTranscriptionFrom: s.streamTranscriptionFrom,
+      })),
     ),
   )

package/src/audioCodec.ts

@@ -99,25 +99,30 @@ export const containerToTtsFormat: (
  */
 export const realizedTtsFormat: (rf: MistralTtsFormat) => AudioFormat =
   Match.type<MistralTtsFormat>().pipe(
-    Match.when(
-      "mp3",
-      (): AudioFormat => ({ container: "mp3", encoding: "mp3", sampleRate: 24000 }),
-    ),
-    Match.when(
-      "wav",
-      (): AudioFormat => ({ container: "wav", encoding: "pcm_s16le", sampleRate: 24000 }),
-    ),
-    Match.when(
-      "pcm",
-      (): AudioFormat => ({ container: "raw", encoding: "pcm_f32le", sampleRate: 24000 }),
-    ),
-    Match.when(
-      "flac",
-      (): AudioFormat => ({ container: "flac", encoding: "flac", sampleRate: 24000 }),
-    ),
-    Match.when(
-      "opus",
-      (): AudioFormat => ({ container: "opus", encoding: "opus", sampleRate: 24000 }),
-    ),
+    Match.when("mp3", (): AudioFormat => ({
+      container: "mp3",
+      encoding: "mp3",
+      sampleRate: 24000,
+    })),
+    Match.when("wav", (): AudioFormat => ({
+      container: "wav",
+      encoding: "pcm_s16le",
+      sampleRate: 24000,
+    })),
+    Match.when("pcm", (): AudioFormat => ({
+      container: "raw",
+      encoding: "pcm_f32le",
+      sampleRate: 24000,
+    })),
+    Match.when("flac", (): AudioFormat => ({
+      container: "flac",
+      encoding: "flac",
+      sampleRate: 24000,
+    })),
+    Match.when("opus", (): AudioFormat => ({
+      container: "opus",
+      encoding: "opus",
+      sampleRate: 24000,
+    })),
     Match.exhaustive,
   )

package/src/codec.ts

@@ -1,25 +1,29 @@
-import { Array as Arr, Encoding, Match, Option, Schema } from "effect"
-import type {
-  ContentBlock,
-  HistoryItem,
-  InputImage,
-  StopReason,
-  Usage,
-} from "@effect-uai/core/Items"
-import type { StructuredFormat } from "@effect-uai/core/StructuredFormat"
-import type { ToolDescriptor } from "@effect-uai/core/Tool"
-import type { Turn } from "@effect-uai/core/Turn"
-import { TurnEvent } from "@effect-uai/core/Turn"
+import { Array as Arr, Effect, Encoding, Match, Option } from "effect"
+import type { ContentBlock, HistoryItem, InputImage } from "@effect-uai/core/Items"
+
+// The streaming decoder, tool encoding, and terminal-turn assembly are the
+// generic OpenAI chat-completions codec: Mistral speaks that dialect on the
+// wire, so it reuses them verbatim. Only request encoding diverges (below).
+export {
+  type Accumulator,
+  type WireChunk,
+  accumulatorToTurn,
+  applyChunk,
+  emptyAccumulator,
+  responseFormatWire,
+  toolsWire,
+} from "@effect-uai/chat-completions/codec"
+import {
+  type WireChunk,
+  decodeChunk as decodeChunkShared,
+} from "@effect-uai/chat-completions/codec"
 
 // ---------------------------------------------------------------------------
 // History → Mistral chat `messages`
 //
-// Mistral speaks the OpenAI chat-completions dialect: a flat list of
-// `{ role, content, ... }` objects where an assistant turn's tool calls live
-// on the assistant message (`tool_calls`) and each tool result is its own
-// `{ role: "tool", tool_call_id, content }` message. Our history is a flatter
-// item list (assistant message, then separate `function_call` items), so we
-// fold consecutive `function_call`s onto the preceding assistant message.
+// Same shape as the generic codec, with one wire quirk: Mistral takes a bare
+// `image_url` string, not OpenAI's `image_url: { url }` object. That is the
+// reason this half stays local rather than importing `itemsToMessages`.
 // ---------------------------------------------------------------------------
 
 type WireMessage = {
@@ -42,6 +46,7 @@ const blockToPart = Match.type<ContentBlock>().pipe(
     input_text: (b) => ({ type: "text", text: b.text }),
     output_text: (b) => ({ type: "text", text: b.text }),
     refusal: (b) => ({ type: "text", text: b.text }),
+    // Bare string, not `{ url }`: the Mistral divergence from OpenAI.
     input_image: (b) => ({ type: "image_url", image_url: imageSourceToUrl(b.source) }),
   }),
 )
@@ -102,26 +107,9 @@ export const itemsToMessages = (items: ReadonlyArray<HistoryItem>): ReadonlyArra
   Arr.reduce(items, [] as ReadonlyArray<WireMessage>, foldItem)
 
 // ---------------------------------------------------------------------------
-// tools / tool_choice / response_format
+// tool_choice
 // ---------------------------------------------------------------------------
 
-export const toolsWire = (
-  descriptors: ReadonlyArray<ToolDescriptor>,
-): Option.Option<ReadonlyArray<Record<string, unknown>>> =>
-  descriptors.length > 0
-    ? Option.some(
-        descriptors.map((t) => ({
-          type: "function",
-          function: {
-            name: t.name,
-            description: t.description,
-            parameters: t.inputSchema,
-            ...(t.strict !== undefined && { strict: t.strict }),
-          },
-        })),
-      )
-    : Option.none()
-
 type ToolChoice =
   | "auto"
   | "required"
@@ -137,202 +125,22 @@ export const toolChoiceWire = (choice: ToolChoice): string | Record<string, unkn
     Match.orElse((c) => ({ type: "function", function: { name: c.name } })),
   )
 
-export const responseFormatWire = (
-  structured: StructuredFormat<unknown>,
-): Record<string, unknown> => ({
-  type: "json_schema",
-  json_schema: {
-    name: structured.name,
-    schema: structured.schema["~standard"].jsonSchema.input({ target: "draft-2020-12" }),
-    ...(structured.strict !== undefined && { strict: structured.strict }),
-  },
-})
-
 // ---------------------------------------------------------------------------
-// Streaming decode: chat.completion.chunk → TurnEvent
+// Streaming decode
 // ---------------------------------------------------------------------------
 
-const WireFunction = Schema.Struct({
-  name: Schema.optional(Schema.NullOr(Schema.String)),
-  arguments: Schema.optional(Schema.NullOr(Schema.String)),
-})
-
-const WireToolCall = Schema.Struct({
-  index: Schema.optional(Schema.Number),
-  id: Schema.optional(Schema.NullOr(Schema.String)),
-  function: Schema.optional(WireFunction),
-})
-
-const WireDelta = Schema.Struct({
-  role: Schema.optional(Schema.NullOr(Schema.String)),
-  content: Schema.optional(Schema.NullOr(Schema.String)),
-  tool_calls: Schema.optional(Schema.NullOr(Schema.Array(WireToolCall))),
-})
-
-const WireChoice = Schema.Struct({
-  index: Schema.optional(Schema.Number),
-  delta: Schema.optional(WireDelta),
-  finish_reason: Schema.optional(Schema.NullOr(Schema.String)),
-})
-
-const WireUsage = Schema.Struct({
-  prompt_tokens: Schema.optional(Schema.Number),
-  completion_tokens: Schema.optional(Schema.Number),
-  total_tokens: Schema.optional(Schema.Number),
-})
-
-export const WireChunk = Schema.Struct({
-  choices: Schema.optional(Schema.Array(WireChoice)),
-  usage: Schema.optional(Schema.NullOr(WireUsage)),
-})
-export type WireChunk = typeof WireChunk.Type
-
-export const decodeChunk = Schema.decodeUnknownEffect(WireChunk)
-
-// ---------------------------------------------------------------------------
-// Accumulator
-// ---------------------------------------------------------------------------
-
-type ToolAcc = {
-  readonly call_id: string
-  readonly name: string
-  readonly arguments: string
-}
-
-export type Accumulator = {
-  readonly text: string
-  /** Tool calls keyed by their wire `index` (defaults to position when absent). */
-  readonly tools: ReadonlyMap<number, ToolAcc>
-  readonly order: ReadonlyArray<number>
-  readonly usage: Usage
-  readonly finishReason: Option.Option<string>
-}
-
-export const emptyAccumulator: Accumulator = {
-  text: "",
-  tools: new Map(),
-  order: [],
-  usage: {},
-  finishReason: Option.none(),
-}
-
-/** State threaded through the fold plus the events the step produced. */
-type Step = readonly [Accumulator, ReadonlyArray<TurnEvent>]
-
-const usageFrom = (wire: typeof WireUsage.Type): Usage => ({
-  ...(wire.prompt_tokens !== undefined && { input_tokens: wire.prompt_tokens }),
-  ...(wire.completion_tokens !== undefined && { output_tokens: wire.completion_tokens }),
-  ...(wire.total_tokens !== undefined && { total_tokens: wire.total_tokens }),
-})
-
-const reasonToStop = Match.type<string>().pipe(
-  Match.when("stop", () => "stop" as const),
-  Match.when("length", () => "max_tokens" as const),
-  Match.when("model_length", () => "max_tokens" as const),
-  Match.when("tool_calls", () => "tool_calls" as const),
-  Match.when("content_filter", () => "content_filter" as const),
-  Match.orElse(() => "stop" as const),
-)
-
-const stopReasonOf = (acc: Accumulator): StopReason =>
-  Option.match(acc.finishReason, {
-    onNone: () => (acc.tools.size > 0 ? "tool_calls" : "stop"),
-    onSome: reasonToStop,
-  })
-
-const withTool = (acc: Accumulator, index: number, tool: ToolAcc, isNew: boolean): Accumulator => ({
-  ...acc,
-  tools: new Map(acc.tools).set(index, tool),
-  order: isNew ? [...acc.order, index] : acc.order,
-})
-
-const applyContent = (acc: Accumulator, delta: typeof WireDelta.Type | undefined): Step => {
-  const content = delta?.content
-  return content !== undefined && content !== null && content.length > 0
-    ? [{ ...acc, text: acc.text + content }, [TurnEvent.TextDelta({ text: content })]]
-    : [acc, []]
-}
-
-const applyToolCall = (acc: Accumulator, tc: typeof WireToolCall.Type, position: number): Step => {
-  const index = tc.index ?? position
-  const argsDelta = tc.function?.arguments ?? ""
-  const existing = acc.tools.get(index)
-  if (existing === undefined) {
-    const call_id = tc.id ?? `call_${index}`
-    const name = tc.function?.name ?? ""
-    return [
-      withTool(acc, index, { call_id, name, arguments: argsDelta }, true),
-      [
-        TurnEvent.ToolCallStart({ call_id, name }),
-        ...(argsDelta.length > 0
-          ? [TurnEvent.ToolCallArgsDelta({ call_id, delta: argsDelta })]
-          : []),
-      ],
-    ]
-  }
-  return argsDelta.length > 0
-    ? [
-        withTool(acc, index, { ...existing, arguments: existing.arguments + argsDelta }, false),
-        [TurnEvent.ToolCallArgsDelta({ call_id: existing.call_id, delta: argsDelta })],
-      ]
-    : [acc, []]
-}
-
-const chain = (step: Step, next: (acc: Accumulator) => Step): Step => {
-  const [acc, events] = step
-  const [acc2, more] = next(acc)
-  return [acc2, [...events, ...more]]
-}
-
-const applyChoice = (step: Step, choice: typeof WireChoice.Type): Step => {
-  const withContent = chain(step, (acc) => applyContent(acc, choice.delta))
-  const withTools = Arr.reduce(choice.delta?.tool_calls ?? [], withContent, (s: Step, tc, i) =>
-    chain(s, (acc) => applyToolCall(acc, tc, i)),
-  )
-  const reason = choice.finish_reason
-  return reason !== undefined && reason !== null
-    ? [{ ...withTools[0], finishReason: Option.some(reason) }, withTools[1]]
-    : withTools
-}
-
-/**
- * Fold one decoded chunk into the accumulator, returning the next state and
- * the `TurnEvent`s the chunk produced. Mirrors Anthropic's `deltasFromEvent`,
- * but over chat-completions deltas.
- */
-export const applyChunk = (acc: Accumulator, chunk: WireChunk): Step => {
-  const afterChoices = Arr.reduce(chunk.choices ?? [], [acc, []] as Step, applyChoice)
-  const usage = chunk.usage
-  return usage !== undefined && usage !== null
-    ? chain(afterChoices, (a) => {
-        const u = usageFrom(usage)
-        return [{ ...a, usage: u }, [TurnEvent.UsageUpdate({ usage: u })]]
-      })
-    : afterChoices
-}
-
-/** Assemble the terminal `Turn` from the accumulated state. */
-export const accumulatorToTurn = (acc: Accumulator): Turn => {
-  const message: ReadonlyArray<HistoryItem> =
-    acc.text.length > 0
-      ? [{ type: "message", role: "assistant", content: [{ type: "output_text", text: acc.text }] }]
-      : []
-  const toolCalls: ReadonlyArray<HistoryItem> = acc.order.flatMap((index) => {
-    const t = acc.tools.get(index)
-    return t === undefined
-      ? []
-      : [
-          {
-            type: "function_call" as const,
-            call_id: t.call_id,
-            name: t.name,
-            arguments: t.arguments,
-          },
-        ]
-  })
-  return {
-    items: [...message, ...toolCalls],
-    usage: acc.usage,
-    stop_reason: stopReasonOf(acc),
-  }
-}
+// Mistral emits `model_length` when it truncates on the context window; the
+// shared decoder only knows OpenAI's `length`. Rewrite it before folding so the
+// shared accumulator maps it to `max_tokens` rather than the `stop` fallback.
+const normalizeChunk = (chunk: WireChunk): WireChunk =>
+  chunk.choices === undefined
+    ? chunk
+    : {
+        ...chunk,
+        choices: chunk.choices.map((c) =>
+          c.finish_reason === "model_length" ? { ...c, finish_reason: "length" } : c,
+        ),
+      }
+
+export const decodeChunk = (u: unknown): Effect.Effect<WireChunk, unknown> =>
+  decodeChunkShared(u).pipe(Effect.map(normalizeChunk))

package/dist/models-B1wZuvz5.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"models-B1wZuvz5.d.mts","names":[],"sources":["../src/models.ts"],"mappings":";;AAWA;;;;;AAmBA;;;;;KAnBY,YAAA;;KAmBA,sBAAA;;KAOA,oBAAA;AAMZ;AAAA,KAAY,eAAA"}

package/dist/realtimeStt-BFcctqFC.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"realtimeStt-BFcctqFC.d.mts","names":[],"sources":["../src/realtimeStt.ts"],"mappings":";;;;;;KA8CY,MAAA;EAAA,SACD,MAAA,EAAQ,QAAA,CAAS,QAAA;EAAA,SACjB,OAAA,WA4J+B;EAAA,SA1J/B,oBAAA,GAAuB,QAAA,CAAS,QAAA;EA2J9B;;;;;EAAA,SArJF,gBAAA,GAAmB,QAAA,CAAS,QAAA;AAAA;AAAA,cAiJ1B,mBAAA,GACV,GAAA,EAAK,MAAA,YAEJ,OAAA,EAAS,MAAA,CAAO,MAAA,CAAO,UAAA,EAAY,CAAA,EAAG,CAAA,GACtC,OAAA,EAAS,6BAAA,KACR,MAAA,CAAO,MAAA,CAAO,eAAA,EAAiB,OAAA,CAAQ,OAAA,GAAU,CAAA,EAAG,CAAA"}