@effect-uai/ai-sdk 0.10.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Betalyra Sociedade Unipessoal Lda.
+
+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,80 @@
+# @effect-uai/ai-sdk
+
+Vercel AI SDK compatibility for effect-uai. Keep your `@ai-sdk/react`
+`useChat` frontend exactly as it is and serve it from an effect-uai agent
+loop instead of `streamText`.
+
+Two functions bridge the two worlds:
+
+- `Messages.decodeMessages` turns the `UIMessage[]` a `useChat` client POSTs
+  into effect-uai `HistoryItem`s.
+- `UIMessageStream.toUIMessageStream` projects the loop's `InteractionEvent`
+  stream onto the AI SDK UI Message Stream protocol (`v1`), emitting
+  `SSE.Event`s.
+
+The package owns no HTTP layer: it produces a `Stream<SSE.Event>` and the
+required `responseHeaders`, so it drops into any server.
+
+## Install
+
+```sh
+pnpm add @effect-uai/ai-sdk
+```
+
+## A chat route
+
+`decodeMessages` in, run your loop, `toUIMessageStream` out. Provide your
+provider layer so the stream has no remaining requirements, then hand the
+bytes to whatever server you run.
+
+```ts
+import * as Messages from "@effect-uai/ai-sdk/Messages"
+import * as UIMessageStream from "@effect-uai/ai-sdk/UIMessageStream"
+import * as SSE from "@effect-uai/core/SSE"
+import { Stream } from "effect"
+
+export async function POST(request: Request): Promise<Response> {
+  const { messages } = await request.json()
+  const history = Messages.decodeMessages(messages)
+
+  const events = agent(history).pipe(Stream.provide(OpenAILayer)) // your loop, unchanged
+
+  const body = events.pipe(
+    UIMessageStream.toUIMessageStream(crypto.randomUUID()),
+    SSE.toBytes,
+    Stream.toReadableStream,
+  )
+  return new Response(body, { headers: UIMessageStream.responseHeaders })
+}
+```
+
+### With `@effect/platform`
+
+Same stream, wrapped in an `HttpServerResponse` instead of a web `Response`:
+
+```ts
+import { HttpServerResponse } from "@effect/platform"
+
+const body = events.pipe(UIMessageStream.toUIMessageStream(id), SSE.toBytes)
+return HttpServerResponse.stream(body, { headers: UIMessageStream.responseHeaders })
+```
+
+## Coverage
+
+Outbound, text and reasoning deltas, tool calls (input streaming plus
+resolved output), and refusals map to their protocol parts. Alongside the
+loop's `InteractionEvent`s, `toUIMessageStream` also accepts `dataPart` and
+`messageMetadata` emissions, so callers can interleave custom typed data
+(`data-<name>`, optionally `transient`) and settled per-message metadata:
+
+```ts
+events.pipe(
+  Stream.map((e) => (Metrics.isThroughput(e) ? dataPart("metrics", e, { transient: true }) : e)),
+  UIMessageStream.toUIMessageStream(id),
+)
+```
+
+Inbound, `decodeMessages` reconstructs text, image (`file` with an `image/*`
+media type), and tool parts: an assistant tool call becomes a `function_call`
+item plus a `function_call_output` once the client carries its result.
+Non-image files and unresolved tool states are dropped.

package/dist/Messages.d.mts

@@ -0,0 +1,40 @@
+import * as Items from "@effect-uai/core/Items";
+import { Schema } from "effect";
+
+//#region src/Messages.d.ts
+declare namespace Messages_d_exports {
+  export { FilePart, TextPart, ToolPart, UIMessage, UIPart, decodeMessages };
+}
+declare const TextPart: Schema.Struct<{
+  readonly type: Schema.Literal<"text">;
+  readonly text: Schema.String;
+}>;
+type TextPart = typeof TextPart.Type;
+declare const FilePart: Schema.Struct<{
+  readonly type: Schema.Literal<"file">;
+  readonly mediaType: Schema.String;
+  readonly url: Schema.String;
+}>;
+type FilePart = typeof FilePart.Type;
+declare const ToolPart: Schema.Struct<{
+  readonly type: Schema.String;
+  readonly toolCallId: Schema.String;
+  readonly toolName: Schema.optional<Schema.String>;
+  readonly state: Schema.optional<Schema.String>;
+  readonly input: Schema.optional<Schema.Unknown>;
+  readonly output: Schema.optional<Schema.Unknown>;
+}>;
+type ToolPart = typeof ToolPart.Type;
+type UIPart = {
+  readonly type: string;
+  readonly [key: string]: unknown;
+};
+type UIMessage = {
+  readonly id?: string;
+  readonly role: "user" | "assistant" | "system";
+  readonly parts: ReadonlyArray<UIPart>;
+};
+declare const decodeMessages: (messages: ReadonlyArray<UIMessage>) => ReadonlyArray<Items.HistoryItem>;
+//#endregion
+export { FilePart, TextPart, ToolPart, UIMessage, UIPart, decodeMessages, Messages_d_exports as t };
+//# sourceMappingURL=Messages.d.mts.map

package/dist/Messages.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Messages.d.mts","names":[],"sources":["../src/Messages.ts"],"mappings":";;;;;;;cAmBM,QAAA,EAAQ,MAAA,CAAA,MAAA;EAAA;;;KAIF,QAAA,UAAkB,QAAA,CAAS,IAAA;AAAA,cAEjC,QAAA,EAAQ,MAAA,CAAA,MAAA;EAAA;;;;KAKF,QAAA,UAAkB,QAAA,CAAS,IAAA;AAAA,cAEjC,QAAA,EAAQ,MAAA,CAAA,MAAA;EAAA;;;;;;;KAQF,QAAA,UAAkB,QAAA,CAAS,IAAA;AAAA,KAS3B,MAAA;EAAA,SACD,IAAA;EAAA,UACC,GAAA;AAAA;AAAA,KAGA,SAAA;EAAA,SACD,EAAA;EAAA,SACA,IAAA;EAAA,SACA,KAAA,EAAO,aAAA,CAAc,MAAA;AAAA;AAAA,cA8DnB,cAAA,GACX,QAAA,EAAU,aAAA,CAAc,SAAA,MACvB,aAAA,CAAc,KAAA,CAAM,WAAA"}

package/dist/Messages.mjs

@@ -0,0 +1,76 @@
+import { t as __exportAll } from "./chunk-CfYAbeIz.mjs";
+import * as Image from "@effect-uai/core/Image";
+import * as Items from "@effect-uai/core/Items";
+import { Match, Schema } from "effect";
+//#region src/Messages.ts
+/**
+* Decode the `messages` array a `useChat` client POSTs (Vercel's `UIMessage`
+* shape) back into effect-uai `HistoryItem`s, so an existing loop can run
+* against an unchanged frontend.
+*
+* One `UIMessage` can expand to several history items: an assistant message
+* carrying tool calls becomes an assistant `Message` followed by the
+* `ToolCall` / `ToolCallOutput` items the model needs to see. Text and image
+* (`file` with an `image/*` media type) parts fold into a message's content;
+* non-image files and unresolved tool states are dropped.
+*/
+var Messages_exports = /* @__PURE__ */ __exportAll({ decodeMessages: () => decodeMessages });
+const TextPart = Schema.Struct({
+	type: Schema.Literal("text"),
+	text: Schema.String
+});
+const FilePart = Schema.Struct({
+	type: Schema.Literal("file"),
+	mediaType: Schema.String,
+	url: Schema.String
+});
+const ToolPart = Schema.Struct({
+	type: Schema.String,
+	toolCallId: Schema.String,
+	toolName: Schema.optional(Schema.String),
+	state: Schema.optional(Schema.String),
+	input: Schema.optional(Schema.Unknown),
+	output: Schema.optional(Schema.Unknown)
+});
+const isText = Schema.is(TextPart);
+const isFile = Schema.is(FilePart);
+const isTool = Schema.is(ToolPart);
+const isImageFile = (part) => part.mediaType.startsWith("image");
+const textOf = (message) => message.parts.filter(isText).map((part) => part.text).join("");
+const imageBlocks = (message) => message.parts.filter(isFile).filter(isImageFile).map((part) => ({
+	type: "input_image",
+	source: Image.imageUrl(part.url, part.mediaType)
+}));
+const userMessage = (message) => {
+	const text = textOf(message);
+	return {
+		type: "message",
+		role: "user",
+		content: [...text.length > 0 ? [{
+			type: "input_text",
+			text
+		}] : [], ...imageBlocks(message)]
+	};
+};
+const toolName = (part) => part.type === "dynamic-tool" ? part.toolName ?? "" : part.type.slice(5);
+const toolItems = (part) => {
+	const call = {
+		type: "function_call",
+		call_id: part.toolCallId,
+		name: toolName(part),
+		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)];
+};
+const assistantItems = (message) => {
+	const text = textOf(message);
+	return [...text.length > 0 ? [Items.assistantText(text)] : [], ...message.parts.filter(isTool).flatMap(toolItems)];
+};
+const decodeMessage = (message) => Match.value(message.role).pipe(Match.when("user", () => [userMessage(message)]), Match.when("system", () => [Items.systemText(textOf(message))]), Match.when("assistant", () => assistantItems(message)), Match.exhaustive);
+const decodeMessages = (messages) => messages.flatMap(decodeMessage);
+//#endregion
+export { decodeMessages, Messages_exports as t };
+
+//# sourceMappingURL=Messages.mjs.map

package/dist/Messages.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Messages.mjs","names":[],"sources":["../src/Messages.ts"],"sourcesContent":["/**\n * Decode the `messages` array a `useChat` client POSTs (Vercel's `UIMessage`\n * shape) back into effect-uai `HistoryItem`s, so an existing loop can run\n * against an unchanged frontend.\n *\n * One `UIMessage` can expand to several history items: an assistant message\n * carrying tool calls becomes an assistant `Message` followed by the\n * `ToolCall` / `ToolCallOutput` items the model needs to see. Text and image\n * (`file` with an `image/*` media type) parts fold into a message's content;\n * non-image files and unresolved tool states are dropped.\n */\nimport * as Image from \"@effect-uai/core/Image\"\nimport * as Items from \"@effect-uai/core/Items\"\nimport { Match, Schema } from \"effect\"\n\n// The inbound part variants we understand. Tool parts are identified\n// structurally by `toolCallId` - their wire `type` is a dynamic `tool-<name>`\n// (or `dynamic-tool`) rather than a fixed literal - so their schema keeps\n// `type` open and reads the name off it.\nconst TextPart = Schema.Struct({\n  type: Schema.Literal(\"text\"),\n  text: Schema.String,\n})\nexport type TextPart = typeof TextPart.Type\n\nconst FilePart = Schema.Struct({\n  type: Schema.Literal(\"file\"),\n  mediaType: Schema.String,\n  url: Schema.String,\n})\nexport type FilePart = typeof FilePart.Type\n\nconst ToolPart = Schema.Struct({\n  type: Schema.String,\n  toolCallId: Schema.String,\n  toolName: Schema.optional(Schema.String),\n  state: Schema.optional(Schema.String),\n  input: Schema.optional(Schema.Unknown),\n  output: Schema.optional(Schema.Unknown),\n})\nexport type ToolPart = typeof ToolPart.Type\n\nconst isText = Schema.is(TextPart)\nconst isFile = Schema.is(FilePart)\nconst isTool = Schema.is(ToolPart)\nconst isImageFile = (part: FilePart): boolean => part.mediaType.startsWith(\"image\")\n\n// A raw inbound part: a discriminating `type` plus whatever else the client\n// attached. Kept open so the schema guards do the narrowing.\nexport type UIPart = {\n  readonly type: string\n  readonly [key: string]: unknown\n}\n\nexport type UIMessage = {\n  readonly id?: string\n  readonly role: \"user\" | \"assistant\" | \"system\"\n  readonly parts: ReadonlyArray<UIPart>\n}\n\nconst textOf = (message: UIMessage): string =>\n  message.parts\n    .filter(isText)\n    .map((part) => part.text)\n    .join(\"\")\n\nconst imageBlocks = (message: UIMessage): ReadonlyArray<Items.InputImage> =>\n  message.parts\n    .filter(isFile)\n    .filter(isImageFile)\n    .map((part) => ({ type: \"input_image\", source: Image.imageUrl(part.url, part.mediaType) }))\n\n// A user turn: one joined text block (if any) followed by one image block per\n// image file, preserving the model's expectation of text-then-media.\nconst userMessage = (message: UIMessage): Items.Message => {\n  const text = textOf(message)\n  return {\n    type: \"message\",\n    role: \"user\",\n    content: [\n      ...(text.length > 0 ? [{ type: \"input_text\", text } as const] : []),\n      ...imageBlocks(message),\n    ],\n  }\n}\n\nconst toolName = (part: ToolPart): string =>\n  part.type === \"dynamic-tool\" ? (part.toolName ?? \"\") : part.type.slice(\"tool-\".length)\n\n// A resolved tool call becomes a `function_call` item, plus a\n// `function_call_output` once the client carries its output.\nconst toolItems = (part: ToolPart): ReadonlyArray<Items.HistoryItem> => {\n  const call: Items.ToolCall = {\n    type: \"function_call\",\n    call_id: part.toolCallId,\n    name: toolName(part),\n    arguments: JSON.stringify(part.input ?? {}),\n  }\n  if (part.state !== \"output-available\") return [call]\n  const output = typeof part.output === \"string\" ? part.output : JSON.stringify(part.output)\n  return [call, Items.toolCallOutput(part.toolCallId, output)]\n}\n\nconst assistantItems = (message: UIMessage): ReadonlyArray<Items.HistoryItem> => {\n  const text = textOf(message)\n  return [\n    ...(text.length > 0 ? [Items.assistantText(text)] : []),\n    ...message.parts.filter(isTool).flatMap(toolItems),\n  ]\n}\n\nconst decodeMessage = (message: UIMessage): ReadonlyArray<Items.HistoryItem> =>\n  Match.value(message.role).pipe(\n    Match.when(\"user\", () => [userMessage(message)]),\n    Match.when(\"system\", () => [Items.systemText(textOf(message))]),\n    Match.when(\"assistant\", () => assistantItems(message)),\n    Match.exhaustive,\n  )\n\nexport const decodeMessages = (\n  messages: ReadonlyArray<UIMessage>,\n): ReadonlyArray<Items.HistoryItem> => messages.flatMap(decodeMessage)\n"],"mappings":";;;;;;;;;;;;;;;;;AAmBA,MAAM,WAAW,OAAO,OAAO;CAC7B,MAAM,OAAO,QAAQ,OAAO;CAC5B,MAAM,OAAO;CACd,CAAC;AAGF,MAAM,WAAW,OAAO,OAAO;CAC7B,MAAM,OAAO,QAAQ,OAAO;CAC5B,WAAW,OAAO;CAClB,KAAK,OAAO;CACb,CAAC;AAGF,MAAM,WAAW,OAAO,OAAO;CAC7B,MAAM,OAAO;CACb,YAAY,OAAO;CACnB,UAAU,OAAO,SAAS,OAAO,OAAO;CACxC,OAAO,OAAO,SAAS,OAAO,OAAO;CACrC,OAAO,OAAO,SAAS,OAAO,QAAQ;CACtC,QAAQ,OAAO,SAAS,OAAO,QAAQ;CACxC,CAAC;AAGF,MAAM,SAAS,OAAO,GAAG,SAAS;AAClC,MAAM,SAAS,OAAO,GAAG,SAAS;AAClC,MAAM,SAAS,OAAO,GAAG,SAAS;AAClC,MAAM,eAAe,SAA4B,KAAK,UAAU,WAAW,QAAQ;AAenF,MAAM,UAAU,YACd,QAAQ,MACL,OAAO,OAAO,CACd,KAAK,SAAS,KAAK,KAAK,CACxB,KAAK,GAAG;AAEb,MAAM,eAAe,YACnB,QAAQ,MACL,OAAO,OAAO,CACd,OAAO,YAAY,CACnB,KAAK,UAAU;CAAE,MAAM;CAAe,QAAQ,MAAM,SAAS,KAAK,KAAK,KAAK,UAAU;CAAE,EAAE;AAI/F,MAAM,eAAe,YAAsC;CACzD,MAAM,OAAO,OAAO,QAAQ;AAC5B,QAAO;EACL,MAAM;EACN,MAAM;EACN,SAAS,CACP,GAAI,KAAK,SAAS,IAAI,CAAC;GAAE,MAAM;GAAc;GAAM,CAAU,GAAG,EAAE,EAClE,GAAG,YAAY,QAAQ,CACxB;EACF;;AAGH,MAAM,YAAY,SAChB,KAAK,SAAS,iBAAkB,KAAK,YAAY,KAAM,KAAK,KAAK,MAAM,EAAe;AAIxF,MAAM,aAAa,SAAqD;CACtE,MAAM,OAAuB;EAC3B,MAAM;EACN,SAAS,KAAK;EACd,MAAM,SAAS,KAAK;EACpB,WAAW,KAAK,UAAU,KAAK,SAAS,EAAE,CAAC;EAC5C;AACD,KAAI,KAAK,UAAU,mBAAoB,QAAO,CAAC,KAAK;CACpD,MAAM,SAAS,OAAO,KAAK,WAAW,WAAW,KAAK,SAAS,KAAK,UAAU,KAAK,OAAO;AAC1F,QAAO,CAAC,MAAM,MAAM,eAAe,KAAK,YAAY,OAAO,CAAC;;AAG9D,MAAM,kBAAkB,YAAyD;CAC/E,MAAM,OAAO,OAAO,QAAQ;AAC5B,QAAO,CACL,GAAI,KAAK,SAAS,IAAI,CAAC,MAAM,cAAc,KAAK,CAAC,GAAG,EAAE,EACtD,GAAG,QAAQ,MAAM,OAAO,OAAO,CAAC,QAAQ,UAAU,CACnD;;AAGH,MAAM,iBAAiB,YACrB,MAAM,MAAM,QAAQ,KAAK,CAAC,KACxB,MAAM,KAAK,cAAc,CAAC,YAAY,QAAQ,CAAC,CAAC,EAChD,MAAM,KAAK,gBAAgB,CAAC,MAAM,WAAW,OAAO,QAAQ,CAAC,CAAC,CAAC,EAC/D,MAAM,KAAK,mBAAmB,eAAe,QAAQ,CAAC,EACtD,MAAM,WACP;AAEH,MAAa,kBACX,aACqC,SAAS,QAAQ,cAAc"}

package/dist/UIMessageStream.d.mts

@@ -0,0 +1,112 @@
+import { Stream } from "effect";
+import * as Turn from "@effect-uai/core/Turn";
+import * as SSE from "@effect-uai/core/SSE";
+
+//#region src/UIMessageStream.d.ts
+declare namespace UIMessageStream_d_exports {
+  export { DataEmission, Emission, MetadataEmission, Part, dataPart, messageMetadata, responseHeaders, toUIMessageStream };
+}
+/**
+ * The stream parts `useChat` consumes. Names and shapes are the wire
+ * contract with the AI SDK client; keep them literal.
+ */
+type Part = {
+  readonly type: "start";
+  readonly messageId: string;
+} | {
+  readonly type: "text-start";
+  readonly id: string;
+} | {
+  readonly type: "text-delta";
+  readonly id: string;
+  readonly delta: string;
+} | {
+  readonly type: "text-end";
+  readonly id: string;
+} | {
+  readonly type: "reasoning-start";
+  readonly id: string;
+} | {
+  readonly type: "reasoning-delta";
+  readonly id: string;
+  readonly delta: string;
+} | {
+  readonly type: "reasoning-end";
+  readonly id: string;
+} | {
+  readonly type: "tool-input-start";
+  readonly toolCallId: string;
+  readonly toolName: string;
+} | {
+  readonly type: "tool-input-delta";
+  readonly toolCallId: string;
+  readonly inputTextDelta: string;
+} | {
+  readonly type: "tool-input-available";
+  readonly toolCallId: string;
+  readonly toolName: string;
+  readonly input: unknown;
+} | {
+  readonly type: "tool-output-available";
+  readonly toolCallId: string;
+  readonly output: unknown;
+} | {
+  readonly type: `data-${string}`;
+  readonly id?: string;
+  readonly data: unknown;
+  readonly transient?: boolean;
+} | {
+  readonly type: "message-metadata";
+  readonly messageMetadata: unknown;
+} | {
+  readonly type: "error";
+  readonly errorText: string;
+} | {
+  readonly type: "finish";
+};
+/**
+ * A custom typed data part (`data-<name>`). `transient: true` delivers it to
+ * the client's `onData` callback only (not persisted into `message.parts`);
+ * reuse an `id` across emissions to reconcile/update one part in place.
+ */
+type DataEmission = {
+  readonly kind: "data";
+  readonly name: string;
+  readonly data: unknown;
+  readonly id?: string;
+  readonly transient?: boolean;
+};
+/** Settled per-message metadata, surfaced as `message.metadata` on the client. */
+type MetadataEmission = {
+  readonly kind: "metadata";
+  readonly metadata: unknown;
+};
+/**
+ * What `toUIMessageStream` encodes: loop `InteractionEvent`s plus optional
+ * data / metadata emissions a caller interleaves into the stream.
+ */
+type Emission = Turn.InteractionEvent | DataEmission | MetadataEmission;
+/** Construct a `data-<name>` emission. See {@link DataEmission}. */
+declare const dataPart: (name: string, data: unknown, options?: {
+  readonly id?: string;
+  readonly transient?: boolean;
+}) => DataEmission;
+/** Construct a message-metadata emission. See {@link MetadataEmission}. */
+declare const messageMetadata: (metadata: unknown) => MetadataEmission;
+/**
+ * Headers the UI Message Stream protocol requires on the HTTP response.
+ * `x-vercel-ai-ui-message-stream: v1` is mandatory; without it the client
+ * falls back to the plain text-stream protocol and ignores non-text parts.
+ * Pure data, so it composes with any server (web `Response`, `@effect/platform`
+ * `HttpServerResponse`, raw Node) - the package deliberately owns no HTTP layer.
+ */
+declare const responseHeaders: Record<string, string>;
+/**
+ * Encode an `InteractionEvent` stream as UI Message Stream `SSE.Event`s,
+ * bracketed by the protocol's `start` and terminal `finish` / `[DONE]`
+ * markers. `messageId` identifies the assistant message on the client.
+ */
+declare const toUIMessageStream: (messageId: string) => <E, R>(self: Stream.Stream<Emission, E, R>) => Stream.Stream<SSE.Event, E, R>;
+//#endregion
+export { DataEmission, Emission, MetadataEmission, Part, dataPart, messageMetadata, responseHeaders, UIMessageStream_d_exports as t, toUIMessageStream };
+//# sourceMappingURL=UIMessageStream.d.mts.map

package/dist/UIMessageStream.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UIMessageStream.d.mts","names":[],"sources":["../src/UIMessageStream.ts"],"mappings":";;;;;;;;;;;;KAyBY,IAAA;EAAA,SACG,IAAA;EAAA,SAAwB,SAAA;AAAA;EAAA,SACxB,IAAA;EAAA,SAA6B,EAAA;AAAA;EAAA,SAC7B,IAAA;EAAA,SAA6B,EAAA;EAAA,SAAqB,KAAA;AAAA;EAAA,SAClD,IAAA;EAAA,SAA2B,EAAA;AAAA;EAAA,SAC3B,IAAA;EAAA,SAAkC,EAAA;AAAA;EAAA,SAClC,IAAA;EAAA,SAAkC,EAAA;EAAA,SAAqB,KAAA;AAAA;EAAA,SACvD,IAAA;EAAA,SAAgC,EAAA;AAAA;EAAA,SAChC,IAAA;EAAA,SAAmC,UAAA;EAAA,SAA6B,QAAA;AAAA;EAAA,SAEhE,IAAA;EAAA,SACA,UAAA;EAAA,SACA,cAAA;AAAA;EAAA,SAGA,IAAA;EAAA,SACA,UAAA;EAAA,SACA,QAAA;EAAA,SACA,KAAA;AAAA;EAAA,SAGA,IAAA;EAAA,SACA,UAAA;EAAA,SACA,MAAA;AAAA;EAAA,SAGA,IAAA;EAAA,SACA,EAAA;EAAA,SACA,IAAA;EAAA,SACA,SAAA;AAAA;EAAA,SAEA,IAAA;EAAA,SAAmC,eAAA;AAAA;EAAA,SACnC,IAAA;EAAA,SAAwB,SAAA;AAAA;EAAA,SACxB,IAAA;AAAA;;;;;;KAOH,YAAA;EAAA,SACD,IAAA;EAAA,SACA,IAAA;EAAA,SACA,IAAA;EAAA,SACA,EAAA;EAAA,SACA,SAAA;AAAA;AAgBX;AAAA,KAZY,gBAAA;EAAA,SACD,IAAA;EAAA,SACA,QAAA;AAAA;;;;;KAOC,QAAA,GAAW,IAAA,CAAK,gBAAA,GAAmB,YAAA,GAAe,gBAAA;;cAGjD,QAAA,GACX,IAAA,UACA,IAAA,WACA,OAAA;EAAA,SAAqB,EAAA;EAAA,SAAsB,SAAA;AAAA,MAC1C,YAAA;;cAGU,eAAA,GAAmB,QAAA,cAAoB,gBAAA;AAYpD;;;;;AAgHA;;AAhHA,cAAa,eAAA,EAAiB,MAAA;;;;;;cAgHjB,iBAAA,GACV,SAAA,oBACM,IAAA,EAAM,MAAA,CAAO,MAAA,CAAO,QAAA,EAAU,CAAA,EAAG,CAAA,MAAK,MAAA,CAAO,MAAA,CAAO,GAAA,CAAI,KAAA,EAAO,CAAA,EAAG,CAAA"}

package/dist/UIMessageStream.mjs

@@ -0,0 +1,160 @@
+import { t as __exportAll } from "./chunk-CfYAbeIz.mjs";
+import { Match, Option, Stream } from "effect";
+import * as Turn from "@effect-uai/core/Turn";
+//#region src/UIMessageStream.ts
+var UIMessageStream_exports = /* @__PURE__ */ __exportAll({
+	dataPart: () => dataPart,
+	messageMetadata: () => messageMetadata,
+	responseHeaders: () => responseHeaders,
+	toUIMessageStream: () => toUIMessageStream
+});
+/** Construct a `data-<name>` emission. See {@link DataEmission}. */
+const dataPart = (name, data, options) => ({
+	kind: "data",
+	name,
+	data,
+	...options
+});
+/** Construct a message-metadata emission. See {@link MetadataEmission}. */
+const messageMetadata = (metadata) => ({
+	kind: "metadata",
+	metadata
+});
+/**
+* Headers the UI Message Stream protocol requires on the HTTP response.
+* `x-vercel-ai-ui-message-stream: v1` is mandatory; without it the client
+* falls back to the plain text-stream protocol and ignores non-text parts.
+* Pure data, so it composes with any server (web `Response`, `@effect/platform`
+* `HttpServerResponse`, raw Node) - the package deliberately owns no HTTP layer.
+*/
+const responseHeaders = {
+	"content-type": "text/event-stream",
+	"cache-control": "no-cache",
+	connection: "keep-alive",
+	"x-vercel-ai-ui-message-stream": "v1"
+};
+const parseJson = Option.liftThrowable(JSON.parse);
+const decode = (raw) => Option.getOrElse(parseJson(raw), () => raw);
+const event = (part) => ({ data: part === "[DONE]" ? "[DONE]" : JSON.stringify(part) });
+const toDataPart = (d) => {
+	const base = {
+		type: `data-${d.name}`,
+		data: d.data
+	};
+	const withId = d.id !== void 0 ? {
+		...base,
+		id: d.id
+	} : base;
+	return d.transient !== void 0 ? {
+		...withId,
+		transient: d.transient
+	} : withId;
+};
+const step = (s, ev) => Match.value(ev).pipe(Match.tags({
+	TextDelta: (e) => {
+		if (s.textId !== null) return [s, [{
+			type: "text-delta",
+			id: s.textId,
+			delta: e.text
+		}]];
+		const id = `${s.messageId}:t${s.seq}`;
+		return [{
+			...s,
+			textId: id,
+			seq: s.seq + 1
+		}, [{
+			type: "text-start",
+			id
+		}, {
+			type: "text-delta",
+			id,
+			delta: e.text
+		}]];
+	},
+	ReasoningDelta: (e) => {
+		if (s.reasoningId !== null) return [s, [{
+			type: "reasoning-delta",
+			id: s.reasoningId,
+			delta: e.text
+		}]];
+		const id = `${s.messageId}:r${s.seq}`;
+		return [{
+			...s,
+			reasoningId: id,
+			seq: s.seq + 1
+		}, [{
+			type: "reasoning-start",
+			id
+		}, {
+			type: "reasoning-delta",
+			id,
+			delta: e.text
+		}]];
+	},
+	ToolCallStart: (e) => [s, [{
+		type: "tool-input-start",
+		toolCallId: e.call_id,
+		toolName: e.name
+	}]],
+	ToolCallArgsDelta: (e) => [s, [{
+		type: "tool-input-delta",
+		toolCallId: e.call_id,
+		inputTextDelta: e.delta
+	}]],
+	RefusalDelta: (e) => [s, [{
+		type: "error",
+		errorText: e.text
+	}]],
+	UsageUpdate: () => [s, []],
+	TurnComplete: (e) => {
+		const closing = [
+			...s.textId !== null ? [{
+				type: "text-end",
+				id: s.textId
+			}] : [],
+			...s.reasoningId !== null ? [{
+				type: "reasoning-end",
+				id: s.reasoningId
+			}] : [],
+			...Turn.getToolCalls(e.turn).map((call) => ({
+				type: "tool-input-available",
+				toolCallId: call.call_id,
+				toolName: call.name,
+				input: decode(call.arguments)
+			}))
+		];
+		return [{
+			...s,
+			textId: null,
+			reasoningId: null
+		}, closing];
+	}
+}), Match.when({ type: "function_call_output" }, (o) => [s, [{
+	type: "tool-output-available",
+	toolCallId: o.call_id,
+	output: decode(o.output)
+}]]), Match.when({ kind: "data" }, (d) => [s, [toDataPart(d)]]), Match.when({ kind: "metadata" }, (m) => [s, [{
+	type: "message-metadata",
+	messageMetadata: m.metadata
+}]]), Match.exhaustive);
+/**
+* Encode an `InteractionEvent` stream as UI Message Stream `SSE.Event`s,
+* bracketed by the protocol's `start` and terminal `finish` / `[DONE]`
+* markers. `messageId` identifies the assistant message on the client.
+*/
+const toUIMessageStream = (messageId) => (self) => Stream.make(event({
+	type: "start",
+	messageId
+})).pipe(Stream.concat(Stream.mapAccum(self, () => ({
+	messageId,
+	textId: null,
+	reasoningId: null,
+	seq: 0
+}), (s, ev) => {
+	const [next, parts] = step(s, ev);
+	return [next, parts.map(event)];
+})), Stream.concat(Stream.make(event({ type: "finish" }), event("[DONE]"))));
+//#endregion
+export { dataPart, messageMetadata, responseHeaders, UIMessageStream_exports as t, toUIMessageStream };
+
+//# sourceMappingURL=UIMessageStream.mjs.map

package/dist/UIMessageStream.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"UIMessageStream.mjs","names":[],"sources":["../src/UIMessageStream.ts"],"sourcesContent":["/**\n * Project an effect-uai loop onto the Vercel AI SDK \"UI Message Stream\"\n * protocol (the `v1` wire format, stable across AI SDK v5–v7). The output is a\n * `Stream<SSE.Event>` ready for `SSE.toBytes`; a `useChat` client on the other\n * end consumes it with no frontend changes.\n *\n * The encoder input is an `Emission`: every `InteractionEvent` the loop\n * produces, plus optional `dataPart` and `messageMetadata` emissions a caller\n * interleaves to stream custom typed data (e.g. live metrics) and settled\n * per-message metadata (e.g. usage). A plain `Stream<InteractionEvent>` is a\n * valid `Stream<Emission>`, so existing callers are unaffected.\n *\n * The protocol wants a stable id and explicit start/end lifecycle around each\n * text and reasoning block, which effect-uai's delta events don't carry. This\n * module synthesizes them: one block id per turn, opened on the first delta\n * and closed on `TurnComplete`.\n */\nimport type * as SSE from \"@effect-uai/core/SSE\"\nimport * as Turn from \"@effect-uai/core/Turn\"\nimport { Match, Option, Stream } from \"effect\"\n\n/**\n * The stream parts `useChat` consumes. Names and shapes are the wire\n * contract with the AI SDK client; keep them literal.\n */\nexport type Part =\n  | { readonly type: \"start\"; readonly messageId: string }\n  | { readonly type: \"text-start\"; readonly id: string }\n  | { readonly type: \"text-delta\"; readonly id: string; readonly delta: string }\n  | { readonly type: \"text-end\"; readonly id: string }\n  | { readonly type: \"reasoning-start\"; readonly id: string }\n  | { readonly type: \"reasoning-delta\"; readonly id: string; readonly delta: string }\n  | { readonly type: \"reasoning-end\"; readonly id: string }\n  | { readonly type: \"tool-input-start\"; readonly toolCallId: string; readonly toolName: string }\n  | {\n      readonly type: \"tool-input-delta\"\n      readonly toolCallId: string\n      readonly inputTextDelta: string\n    }\n  | {\n      readonly type: \"tool-input-available\"\n      readonly toolCallId: string\n      readonly toolName: string\n      readonly input: unknown\n    }\n  | {\n      readonly type: \"tool-output-available\"\n      readonly toolCallId: string\n      readonly output: unknown\n    }\n  | {\n      readonly type: `data-${string}`\n      readonly id?: string\n      readonly data: unknown\n      readonly transient?: boolean\n    }\n  | { readonly type: \"message-metadata\"; readonly messageMetadata: unknown }\n  | { readonly type: \"error\"; readonly errorText: string }\n  | { readonly type: \"finish\" }\n\n/**\n * A custom typed data part (`data-<name>`). `transient: true` delivers it to\n * the client's `onData` callback only (not persisted into `message.parts`);\n * reuse an `id` across emissions to reconcile/update one part in place.\n */\nexport type DataEmission = {\n  readonly kind: \"data\"\n  readonly name: string\n  readonly data: unknown\n  readonly id?: string\n  readonly transient?: boolean\n}\n\n/** Settled per-message metadata, surfaced as `message.metadata` on the client. */\nexport type MetadataEmission = {\n  readonly kind: \"metadata\"\n  readonly metadata: unknown\n}\n\n/**\n * What `toUIMessageStream` encodes: loop `InteractionEvent`s plus optional\n * data / metadata emissions a caller interleaves into the stream.\n */\nexport type Emission = Turn.InteractionEvent | DataEmission | MetadataEmission\n\n/** Construct a `data-<name>` emission. See {@link DataEmission}. */\nexport const dataPart = (\n  name: string,\n  data: unknown,\n  options?: { readonly id?: string; readonly transient?: boolean },\n): DataEmission => ({ kind: \"data\", name, data, ...options })\n\n/** Construct a message-metadata emission. See {@link MetadataEmission}. */\nexport const messageMetadata = (metadata: unknown): MetadataEmission => ({\n  kind: \"metadata\",\n  metadata,\n})\n\n/**\n * Headers the UI Message Stream protocol requires on the HTTP response.\n * `x-vercel-ai-ui-message-stream: v1` is mandatory; without it the client\n * falls back to the plain text-stream protocol and ignores non-text parts.\n * Pure data, so it composes with any server (web `Response`, `@effect/platform`\n * `HttpServerResponse`, raw Node) - the package deliberately owns no HTTP layer.\n */\nexport const responseHeaders: Record<string, string> = {\n  \"content-type\": \"text/event-stream\",\n  \"cache-control\": \"no-cache\",\n  connection: \"keep-alive\",\n  \"x-vercel-ai-ui-message-stream\": \"v1\",\n}\n\nconst parseJson = Option.liftThrowable(JSON.parse)\n\n// Tool arguments/output cross effect-uai as JSON strings; hand the client the\n// decoded value, falling back to the raw string when it isn't JSON.\nconst decode = (raw: string): unknown => Option.getOrElse(parseJson(raw), () => raw)\n\nconst event = (part: Part | \"[DONE]\"): SSE.Event => ({\n  data: part === \"[DONE]\" ? \"[DONE]\" : JSON.stringify(part),\n})\n\ntype State = {\n  readonly messageId: string\n  readonly textId: string | null\n  readonly reasoningId: string | null\n  readonly seq: number\n}\n\ntype Step = readonly [State, ReadonlyArray<Part>]\n\nconst toDataPart = (d: DataEmission): Part => {\n  const base: Part = { type: `data-${d.name}`, data: d.data }\n  const withId = d.id !== undefined ? { ...base, id: d.id } : base\n  return d.transient !== undefined ? { ...withId, transient: d.transient } : withId\n}\n\n// One emission fans out to zero or more parts (a first TextDelta opens a block\n// *and* emits its delta), so each step yields an array.\nconst step = (s: State, ev: Emission): Step =>\n  Match.value(ev).pipe(\n    Match.tags({\n      TextDelta: (e): Step => {\n        if (s.textId !== null) return [s, [{ type: \"text-delta\", id: s.textId, delta: e.text }]]\n        const id = `${s.messageId}:t${s.seq}`\n        return [\n          { ...s, textId: id, seq: s.seq + 1 },\n          [\n            { type: \"text-start\", id },\n            { type: \"text-delta\", id, delta: e.text },\n          ],\n        ]\n      },\n      ReasoningDelta: (e): Step => {\n        if (s.reasoningId !== null)\n          return [s, [{ type: \"reasoning-delta\", id: s.reasoningId, delta: e.text }]]\n        const id = `${s.messageId}:r${s.seq}`\n        return [\n          { ...s, reasoningId: id, seq: s.seq + 1 },\n          [\n            { type: \"reasoning-start\", id },\n            { type: \"reasoning-delta\", id, delta: e.text },\n          ],\n        ]\n      },\n      ToolCallStart: (e): Step => [\n        s,\n        [{ type: \"tool-input-start\", toolCallId: e.call_id, toolName: e.name }],\n      ],\n      ToolCallArgsDelta: (e): Step => [\n        s,\n        [{ type: \"tool-input-delta\", toolCallId: e.call_id, inputTextDelta: e.delta }],\n      ],\n      RefusalDelta: (e): Step => [s, [{ type: \"error\", errorText: e.text }]],\n      UsageUpdate: (): Step => [s, []],\n      TurnComplete: (e): Step => {\n        const closing: ReadonlyArray<Part> = [\n          ...(s.textId !== null ? [{ type: \"text-end\", id: s.textId } as const] : []),\n          ...(s.reasoningId !== null\n            ? [{ type: \"reasoning-end\", id: s.reasoningId } as const]\n            : []),\n          ...Turn.getToolCalls(e.turn).map(\n            (call): Part => ({\n              type: \"tool-input-available\",\n              toolCallId: call.call_id,\n              toolName: call.name,\n              input: decode(call.arguments),\n            }),\n          ),\n        ]\n        // Reset block ids; the loop may run further turns after tools resolve.\n        return [{ ...s, textId: null, reasoningId: null }, closing]\n      },\n    }),\n    // The non-`_tag` arm of InteractionEvent: a resolved tool result the loop\n    // appended after running the tool.\n    Match.when(\n      { type: \"function_call_output\" },\n      (o): Step => [\n        s,\n        [{ type: \"tool-output-available\", toolCallId: o.call_id, output: decode(o.output) }],\n      ],\n    ),\n    // Caller-interleaved emissions.\n    Match.when({ kind: \"data\" }, (d): Step => [s, [toDataPart(d)]]),\n    Match.when(\n      { kind: \"metadata\" },\n      (m): Step => [s, [{ type: \"message-metadata\", messageMetadata: m.metadata }]],\n    ),\n    Match.exhaustive,\n  )\n\n/**\n * Encode an `InteractionEvent` stream as UI Message Stream `SSE.Event`s,\n * bracketed by the protocol's `start` and terminal `finish` / `[DONE]`\n * markers. `messageId` identifies the assistant message on the client.\n */\nexport const toUIMessageStream =\n  (messageId: string) =>\n  <E, R>(self: Stream.Stream<Emission, E, R>): Stream.Stream<SSE.Event, E, R> =>\n    Stream.make(event({ type: \"start\", messageId })).pipe(\n      Stream.concat(\n        Stream.mapAccum(\n          self,\n          (): State => ({ messageId, textId: null, reasoningId: null, seq: 0 }),\n          (s, ev: Emission): readonly [State, ReadonlyArray<SSE.Event>] => {\n            const [next, parts] = step(s, ev)\n            return [next, parts.map(event)]\n          },\n        ),\n      ),\n      Stream.concat(Stream.make(event({ type: \"finish\" }), event(\"[DONE]\"))),\n    )\n"],"mappings":"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"}

package/dist/UIMessageStream.test.d.mts

@@ -0,0 +1 @@
+export { };