@effect-uai/ai-sdk 0.18.0 → 0.19.0-dev-20261109183959

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect-uai/ai-sdk",
-  "version": "0.18.0",
+  "version": "0.19.0-dev-20261109183959",
   "description": "Vercel AI SDK (useChat) UI Message Stream compatibility for @effect-uai/core.",
   "keywords": [
     "agents",
@@ -51,12 +51,12 @@
   "dependencies": {},
   "devDependencies": {
     "ai": "^7.0.3",
-    "effect": "4.0.1",
+    "effect": "4.1.2",
     "typescript": "^7.0.2",
-    "@effect-uai/core": "0.18.0"
+    "@effect-uai/core": "0.19.0-dev-20261109183959"
   },
   "peerDependencies": {
-    "@effect-uai/core": ">=0.5.0 <1",
+    "@effect-uai/core": "0.19.0-dev-20261109183959",
     "effect": ">=4.0.1 <5.0.0"
   },
   "scripts": {

package/src/Messages.ts

@@ -11,7 +11,9 @@
  */
 import * as Image from "@effect-uai/core/Image"
 import * as Items from "@effect-uai/core/Items"
-import { Match, Schema } from "effect"
+import { Match, Option, Predicate, Schema } from "effect"
+
+const asJson = Schema.decodeUnknownOption(Schema.Json)
 
 // The inbound part variants we understand. Tool parts are identified
 // structurally by `toolCallId` - their wire `type` is a dynamic `tool-<name>`
@@ -97,8 +99,17 @@ const toolItems = (part: ToolPart): ReadonlyArray<Items.HistoryItem> => {
     arguments: JSON.stringify(part.input ?? {}),
   }
   if (part.state !== "output-available") return [call]
-  const output = typeof part.output === "string" ? part.output : JSON.stringify(part.output)
-  return [call, Items.toolCallOutput(part.toolCallId, output)]
+  // Text stays text; any other JSON stays a value (the provider codec serializes it).
+  const output: Items.ToolOutputContent = Match.value(part.output).pipe(
+    Match.when(Predicate.isString, (text) => Items.text(text)),
+    Match.orElse((value) =>
+      Option.match(asJson(value), {
+        onNone: () => Items.text(String(value)),
+        onSome: (json) => Items.json(json),
+      }),
+    ),
+  )
+  return [call, { type: "function_call_output", call_id: part.toolCallId, output: [output] }]
 }
 
 const assistantItems = (message: UIMessage): ReadonlyArray<Items.HistoryItem> => {

package/src/UIMessageStream.test.ts

@@ -63,7 +63,7 @@ describe("toUIMessageStream", () => {
         Turn.TurnEvent.ToolCallStart({ call_id: "c1", name: "search" }),
         Turn.TurnEvent.ToolCallArgsDelta({ call_id: "c1", delta: `{"q":"lisbon"}` }),
         Turn.TurnEvent.TurnComplete({ turn: turn([call], "tool_calls") }),
-        Items.toolCallOutput("c1", `{"hits":3}`),
+        { type: "function_call_output", call_id: "c1", output: [Items.json({ hits: 3 })] },
       ])
 
       expect(types(parts)).toEqual([
@@ -90,6 +90,39 @@ describe("toUIMessageStream", () => {
     }),
   )
 
+  it.effect("maps a failed call to tool-output-error and media to a data URL", () =>
+    Effect.gen(function* () {
+      const parts = yield* encode([
+        {
+          type: "function_call_output",
+          call_id: "c1",
+          output: [Items.json({ _tag: "CityNotFound", city: "Atlantis" })],
+          isError: true,
+        },
+        {
+          type: "function_call_output",
+          call_id: "c2",
+          output: [
+            Items.text("Home"),
+            Items.image({ _tag: "bytes", bytes: new Uint8Array([1, 2, 3]), mimeType: "image/png" }),
+          ],
+        },
+      ])
+      expect(parts.slice(1, 3)).toEqual([
+        {
+          type: "tool-output-error",
+          toolCallId: "c1",
+          errorText: '{"_tag":"CityNotFound","city":"Atlantis"}',
+        },
+        {
+          type: "tool-output-available",
+          toolCallId: "c2",
+          output: ["Home", { type: "image", url: "data:image/png;base64,AQID" }],
+        },
+      ])
+    }),
+  )
+
   it.effect("surfaces a refusal as an error part", () =>
     Effect.gen(function* () {
       const parts = yield* encode([Turn.TurnEvent.RefusalDelta({ text: "cannot help" })])
@@ -192,7 +225,8 @@ describe("decodeMessages", () => {
     expect(items).toEqual([
       Items.assistantText("Here"),
       { type: "function_call", call_id: "c1", name: "search", arguments: `{"q":"lisbon"}` },
-      Items.toolCallOutput("c1", `{"hits":3}`),
+      // The output stays a value; the provider codec serializes it.
+      { type: "function_call_output", call_id: "c1", output: [Items.json({ hits: 3 })] },
     ])
   })
 

package/src/UIMessageStream.ts

@@ -15,9 +15,14 @@
  * module synthesizes them: one block id per turn, opened on the first delta
  * and closed on `TurnComplete`.
  */
+import type { FileSource } from "@effect-uai/core/File"
+import type { ImageSource } from "@effect-uai/core/Image"
+import type * as Items from "@effect-uai/core/Items"
 import type * as SSE from "@effect-uai/core/SSE"
+import * as ToolOutput from "@effect-uai/core/ToolOutput"
 import * as Turn from "@effect-uai/core/Turn"
 import { Match, Option, Stream } from "effect"
+import { Base64 } from "effect/encoding"
 
 /**
  * The stream parts `useChat` consumes. Names and shapes are the wire
@@ -48,6 +53,7 @@ export type Part =
       readonly toolCallId: string
       readonly output: unknown
     }
+  | { readonly type: "tool-output-error"; readonly toolCallId: string; readonly errorText: string }
   | {
       readonly type: `data-${string}`
       readonly id?: string
@@ -112,10 +118,45 @@ export const responseHeaders: Record<string, string> = {
 
 const parseJson = Option.liftThrowable(JSON.parse)
 
-// Tool arguments/output cross effect-uai as JSON strings; hand the client the
+// Tool arguments cross effect-uai as a JSON string; hand the client the
 // decoded value, falling back to the raw string when it isn't JSON.
 const decode = (raw: string): unknown => Option.getOrElse(parseJson(raw), () => raw)
 
+// Media goes to the client as a URL; inline bytes as a data URL.
+const sourceUrl = Match.type<ImageSource | FileSource>().pipe(
+  Match.tagsExhaustive({
+    url: (s) => s.url,
+    base64: (s) => `data:${s.mimeType};base64,${s.base64}`,
+    bytes: (s) => `data:${s.mimeType};base64,${Base64.encode(s.bytes)}`,
+  }),
+)
+
+const partJson = Match.type<Items.ToolOutputContent>().pipe(
+  Match.discriminatorsExhaustive("type")({
+    input_text: (p): unknown => p.text,
+    input_json: (p) => p.value,
+    input_image: (p) => ({ type: "image", url: sourceUrl(p.source) }),
+    input_file: (p) => ({
+      type: "file",
+      url: sourceUrl(p.source),
+      ...(p.filename !== undefined && { filename: p.filename }),
+    }),
+  }),
+)
+
+const outputJson = (o: Items.ToolCallOutput): unknown => ToolOutput.single(o.output.map(partJson))
+
+const toolOutputPart = (o: Items.ToolCallOutput): Part => {
+  const output = outputJson(o)
+  return o.isError === true
+    ? {
+        type: "tool-output-error",
+        toolCallId: o.call_id,
+        errorText: typeof output === "string" ? output : JSON.stringify(output),
+      }
+    : { type: "tool-output-available", toolCallId: o.call_id, output }
+}
+
 const event = (part: Part | "[DONE]"): SSE.Event => ({
   data: part === "[DONE]" ? "[DONE]" : JSON.stringify(part),
 })
@@ -199,10 +240,7 @@ const step = (s: State, ev: Emission): Step =>
     }),
     // The non-`_tag` arm of InteractionEvent: a resolved tool result the loop
     // appended after running the tool.
-    Match.when({ type: "function_call_output" }, (o): Step => [
-      s,
-      [{ type: "tool-output-available", toolCallId: o.call_id, output: decode(o.output) }],
-    ]),
+    Match.when({ type: "function_call_output" }, (o): Step => [s, [toolOutputPart(o)]]),
     // Caller-interleaved emissions.
     Match.when({ kind: "data" }, (d): Step => [s, [toDataPart(d)]]),
     Match.when({ kind: "metadata" }, (m): Step => [

package/src/conformance.test.ts

@@ -76,7 +76,7 @@ describe("AI SDK conformance (readUIMessageStream)", () => {
         Turn.TurnEvent.ToolCallStart({ call_id: "c1", name: "search" }),
         Turn.TurnEvent.ToolCallArgsDelta({ call_id: "c1", delta: `{"q":"lisbon"}` }),
         Turn.TurnEvent.TurnComplete({ turn: turn([call], "tool_calls") }),
-        Items.toolCallOutput("c1", `{"hits":3}`),
+        { type: "function_call_output", call_id: "c1", output: [Items.json({ hits: 3 })] },
       ])
 
       const tool = Option.flatMap(message, (m) => Arr.findFirst(m.parts, isToolUIPart))