@effect-uai/mistral 0.10.0 → 0.12.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect-uai/mistral",
-  "version": "0.10.0",
+  "version": "0.12.0",
   "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.0"
+  },
   "devDependencies": {
     "@types/ws": "^8.5.13",
-    "effect": "4.0.0-beta.57",
+    "effect": "4.0.0-beta.94",
     "typescript": "^6.0.3",
     "ws": "^8.18.0",
-    "@effect-uai/core": "0.10.0"
+    "@effect-uai/core": "0.12.0"
   },
   "peerDependencies": {
     "@effect-uai/core": ">=0.2.0 <1",
-    "effect": "4.0.0-beta.57",
+    "effect": ">=4.0.0-beta.94 <5.0.0",
     "ws": "^8.0.0"
   },
   "peerDependenciesMeta": {

package/src/Mistral.ts

@@ -145,7 +145,12 @@ const buildStream = (cfg: Config) => {
             Option.isSome(chunk) ? Result.succeed(chunk.value) : Result.failVoid,
           ),
           Stream.mapAccum((): Accumulator => emptyAccumulator, applyChunk, {
-            onHalt: (acc) => [TurnEvent.TurnComplete({ turn: accumulatorToTurn(acc) })],
+            // `onHalt` also fires on upstream failure and truncated streams,
+            // so only emit `TurnComplete` once a `finish_reason` was observed
+            onHalt: (acc) =>
+              Option.isSome(acc.finishReason)
+                ? [TurnEvent.TurnComplete({ turn: accumulatorToTurn(acc) })]
+                : [],
           }),
         )
       }),
@@ -158,7 +163,7 @@ const buildStream = (cfg: Config) => {
 
 /** Build a `MistralService` value. For Layer-based setup, prefer `layer`. */
 export const make = (cfg: Config): Effect.Effect<MistralService, never, HttpClient.HttpClient> =>
-  Effect.map(HttpClient.HttpClient.asEffect(), (client) => {
+  Effect.map(HttpClient.HttpClient, (client) => {
     const streamTurn: MistralService["streamTurn"] = (request) =>
       buildStream(cfg)(request).pipe(Stream.provideService(HttpClient.HttpClient, client))
     return {

package/src/MistralRealtimeTranscriber.ts

@@ -34,7 +34,7 @@ export {
 export const make = (
   cfg: Config,
 ): Effect.Effect<MistralTranscriberService, never, HttpClient.HttpClient> =>
-  Effect.map(HttpClient.HttpClient.asEffect(), (client) => ({
+  Effect.map(HttpClient.HttpClient, (client) => ({
     transcribe: (request) =>
       transcribeImpl(cfg)(request).pipe(Effect.provideService(HttpClient.HttpClient, client)),
     streamTranscriptionFrom: streamTranscription(cfg),

package/src/MistralSynthesizer.ts

@@ -226,7 +226,7 @@ const streamSynthesizeDialogueUnsupported: SpeechSynthesizerService["streamSynth
 export const make = (
   cfg: Config,
 ): Effect.Effect<MistralSynthesizerService, never, HttpClient.HttpClient> =>
-  Effect.map(HttpClient.HttpClient.asEffect(), (client) => ({
+  Effect.map(HttpClient.HttpClient, (client) => ({
     synthesize: (request) =>
       synthesizeImpl(cfg)(request).pipe(Effect.provideService(HttpClient.HttpClient, client)),
     streamSynthesis: (request) =>

package/src/MistralTranscriber.ts

@@ -194,7 +194,7 @@ const streamUnsupported = <E, R>(
 export const make = (
   cfg: Config,
 ): Effect.Effect<MistralTranscriberService, never, HttpClient.HttpClient> =>
-  Effect.map(HttpClient.HttpClient.asEffect(), (client) => ({
+  Effect.map(HttpClient.HttpClient, (client) => ({
     transcribe: (request) =>
       transcribeImpl(cfg)(request).pipe(Effect.provideService(HttpClient.HttpClient, client)),
     streamTranscriptionFrom: streamUnsupported,

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/src/onHalt.test.ts

@@ -0,0 +1,75 @@
+import { Effect, Exit, Redacted, Stream } from "effect"
+import { HttpClient, HttpClientResponse } from "effect/unstable/http"
+import { describe, expect, it } from "vitest"
+import { TurnEvent } from "@effect-uai/core/Turn"
+import { make as makeMistral } from "./Mistral.js"
+
+// An HttpClient backed by a scripted SSE body
+const clientWithBody = (makeBody: () => ReadableStream<Uint8Array>): HttpClient.HttpClient =>
+  HttpClient.make((request) =>
+    Effect.succeed(
+      HttpClientResponse.fromWeb(
+        request,
+        new Response(makeBody(), {
+          status: 200,
+          headers: { "content-type": "text/event-stream" },
+        }),
+      ),
+    ),
+  )
+
+const enc = new TextEncoder()
+const sse = (obj: unknown) => enc.encode(`data: ${JSON.stringify(obj)}\n\n`)
+
+const runStream = (client: HttpClient.HttpClient) =>
+  Effect.gen(function* () {
+    const svc = yield* makeMistral({ apiKey: Redacted.make("k") })
+    const events: Array<TurnEvent> = []
+    const exit = yield* svc.streamTurn({ model: "mistral-small-latest", history: [] }).pipe(
+      Stream.runForEach((e) => Effect.sync(() => events.push(e))),
+      Effect.exit,
+    )
+    return { tags: events.map((e) => e._tag), events, exit }
+  }).pipe(Effect.provideService(HttpClient.HttpClient, client))
+
+describe("Mistral streamTurn: truncated turn presented as complete", () => {
+  it("truncated EOF (no finish_reason) must not synthesize a complete turn", async () => {
+    const body = () =>
+      new ReadableStream<Uint8Array>({
+        start(controller) {
+          controller.enqueue(sse({ choices: [{ delta: { content: "Hel" } }] }))
+          controller.close() // no finish_reason, no [DONE]
+        },
+      })
+    const { tags } = await Effect.runPromise(runStream(clientWithBody(body)))
+    expect(tags).toContain("TextDelta")
+    expect(tags).not.toContain("TurnComplete")
+  })
+
+  it("mid-stream error must surface as a failure, not a fake TurnComplete", async () => {
+    const body = () =>
+      new ReadableStream<Uint8Array>({
+        start(controller) {
+          controller.enqueue(sse({ choices: [{ delta: { content: "Hel" } }] }))
+          controller.error(new Error("connection reset"))
+        },
+      })
+    const { tags, exit } = await Effect.runPromise(runStream(clientWithBody(body)))
+    expect(Exit.isFailure(exit)).toBe(true)
+    expect(tags).not.toContain("TurnComplete")
+  })
+
+  it("a well-formed stream (finish_reason present) still completes", async () => {
+    const body = () =>
+      new ReadableStream<Uint8Array>({
+        start(controller) {
+          controller.enqueue(sse({ choices: [{ delta: { content: "Hel" } }] }))
+          controller.enqueue(sse({ choices: [{ delta: {}, finish_reason: "stop" }] }))
+          controller.enqueue(enc.encode("data: [DONE]\n\n"))
+          controller.close()
+        },
+      })
+    const { tags } = await Effect.runPromise(runStream(clientWithBody(body)))
+    expect(tags).toContain("TurnComplete")
+  })
+})

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

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