@effect-uai/core 0.1.0

package/dist/domain/Items.mjs

@@ -0,0 +1,238 @@
+import { t as __exportAll } from "../chunk-CfYAbeIz.mjs";
+import { Schema } from "effect";
+//#region src/domain/Items.ts
+var Items_exports = /* @__PURE__ */ __exportAll({
+	Annotation: () => Annotation,
+	ContainerFileCitation: () => ContainerFileCitation,
+	ContentBlock: () => ContentBlock,
+	FileCitation: () => FileCitation,
+	FilePath: () => FilePath,
+	FunctionCall: () => FunctionCall,
+	FunctionCallOutput: () => FunctionCallOutput,
+	ImageBase64Source: () => ImageBase64Source,
+	ImageSource: () => ImageSource,
+	ImageUrlSource: () => ImageUrlSource,
+	InputImage: () => InputImage,
+	InputText: () => InputText,
+	InputTokensDetails: () => InputTokensDetails,
+	Item: () => Item,
+	Message: () => Message,
+	OutputText: () => OutputText,
+	OutputTokensDetails: () => OutputTokensDetails,
+	Reasoning: () => Reasoning,
+	Refusal: () => Refusal,
+	Role: () => Role,
+	StopReason: () => StopReason,
+	UrlCitation: () => UrlCitation,
+	Usage: () => Usage,
+	assistantText: () => assistantText,
+	functionCallOutput: () => functionCallOutput,
+	isContainerFileCitation: () => isContainerFileCitation,
+	isFileCitation: () => isFileCitation,
+	isFilePath: () => isFilePath,
+	isFunctionCall: () => isFunctionCall,
+	isFunctionCallOutput: () => isFunctionCallOutput,
+	isImageBase64Source: () => isImageBase64Source,
+	isImageUrlSource: () => isImageUrlSource,
+	isInputImage: () => isInputImage,
+	isInputText: () => isInputText,
+	isMessage: () => isMessage,
+	isOutputText: () => isOutputText,
+	isReasoning: () => isReasoning,
+	isRefusal: () => isRefusal,
+	isUrlCitation: () => isUrlCitation,
+	systemText: () => systemText,
+	userText: () => userText
+});
+const InputText = Schema.Struct({
+	type: Schema.Literal("input_text"),
+	text: Schema.String
+});
+/**
+* Where an image lives. `url` covers HTTP(S) URLs (the model fetches
+* them); `base64` covers inline bytes embedded in the request. Provider
+* encoders dispatch on `_tag`. File-id / uploaded-asset references are
+* provider-specific and stay out of this union for now.
+*/
+const ImageUrlSource = Schema.Struct({
+	_tag: Schema.Literal("url"),
+	url: Schema.String
+});
+/**
+* Inline image bytes. `data` is **already base64-encoded** (matches what
+* the wire formats expect; no double-encoding needed downstream).
+* `media_type` is the MIME type, e.g. `"image/png"`.
+*/
+const ImageBase64Source = Schema.Struct({
+	_tag: Schema.Literal("base64"),
+	media_type: Schema.String,
+	data: Schema.String
+});
+const ImageSource = Schema.Union([ImageUrlSource, ImageBase64Source]);
+const isImageUrlSource = (s) => s._tag === "url";
+const isImageBase64Source = (s) => s._tag === "base64";
+/**
+* User-provided image content block. Pair with `InputText` inside a
+* `Message.content` array to ask "what's in this image?" style questions.
+*/
+const InputImage = Schema.Struct({
+	type: Schema.Literal("input_image"),
+	source: ImageSource
+});
+const UrlCitation = Schema.Struct({
+	type: Schema.Literal("url_citation"),
+	url: Schema.String,
+	start_index: Schema.Number,
+	end_index: Schema.Number,
+	title: Schema.String
+});
+const FileCitation = Schema.Struct({
+	type: Schema.Literal("file_citation"),
+	file_id: Schema.String,
+	index: Schema.Number
+});
+const ContainerFileCitation = Schema.Struct({
+	type: Schema.Literal("container_file_citation"),
+	container_id: Schema.String,
+	file_id: Schema.String,
+	start_index: Schema.Number,
+	end_index: Schema.Number
+});
+const FilePath = Schema.Struct({
+	type: Schema.Literal("file_path"),
+	file_id: Schema.String,
+	index: Schema.Number
+});
+const Annotation = Schema.Union([
+	UrlCitation,
+	FileCitation,
+	ContainerFileCitation,
+	FilePath
+]);
+const isUrlCitation = (a) => a.type === "url_citation";
+const isFileCitation = (a) => a.type === "file_citation";
+const isContainerFileCitation = (a) => a.type === "container_file_citation";
+const isFilePath = (a) => a.type === "file_path";
+const OutputText = Schema.Struct({
+	type: Schema.Literal("output_text"),
+	text: Schema.String,
+	annotations: Schema.optional(Schema.Array(Annotation))
+});
+/**
+* Model-emitted refusal. Distinct from `output_text`: the model declined
+* to answer rather than producing normal output. Pair with
+* `stop_reason: "refusal"` on the surrounding `Turn`. Streamed via the
+* `refusal_delta` `TurnEvent`.
+*/
+const Refusal = Schema.Struct({
+	type: Schema.Literal("refusal"),
+	text: Schema.String
+});
+const ContentBlock = Schema.Union([
+	InputText,
+	InputImage,
+	OutputText,
+	Refusal
+]);
+const Role = Schema.Literals([
+	"user",
+	"assistant",
+	"system"
+]);
+const ProviderData = Schema.optional(Schema.Unknown);
+const Message = Schema.Struct({
+	type: Schema.Literal("message"),
+	role: Role,
+	content: Schema.Array(ContentBlock),
+	providerData: ProviderData
+});
+const FunctionCall = Schema.Struct({
+	type: Schema.Literal("function_call"),
+	call_id: Schema.String,
+	name: Schema.String,
+	arguments: Schema.String,
+	providerData: ProviderData
+});
+const FunctionCallOutput = Schema.Struct({
+	type: Schema.Literal("function_call_output"),
+	call_id: Schema.String,
+	output: Schema.String,
+	providerData: ProviderData
+});
+/**
+* Reasoning item - top-level, mirrors OpenAI Responses API. Common shape
+* across providers covers `summary` (human-readable text) and `signature`
+* (opaque round-trip blob - Anthropic's signed thinking, OpenAI's
+* encrypted_content, etc.). Provider-specific fields go in `providerData`.
+*/
+const Reasoning = Schema.Struct({
+	type: Schema.Literal("reasoning"),
+	id: Schema.optional(Schema.String),
+	summary: Schema.optional(Schema.String),
+	signature: Schema.optional(Schema.String),
+	providerData: ProviderData
+});
+const Item = Schema.Union([
+	Message,
+	FunctionCall,
+	FunctionCallOutput,
+	Reasoning
+]);
+const isInputText = (block) => block.type === "input_text";
+const isInputImage = (block) => block.type === "input_image";
+const isOutputText = (block) => block.type === "output_text";
+const isRefusal = (block) => block.type === "refusal";
+const isMessage = (item) => item.type === "message";
+const isFunctionCall = (item) => item.type === "function_call";
+const isFunctionCallOutput = (item) => item.type === "function_call_output";
+const isReasoning = (item) => item.type === "reasoning";
+const InputTokensDetails = Schema.Struct({ cached_tokens: Schema.optional(Schema.Number) });
+const OutputTokensDetails = Schema.Struct({ reasoning_tokens: Schema.optional(Schema.Number) });
+const Usage = Schema.Struct({
+	input_tokens: Schema.optional(Schema.Number),
+	output_tokens: Schema.optional(Schema.Number),
+	total_tokens: Schema.optional(Schema.Number),
+	input_tokens_details: Schema.optional(InputTokensDetails),
+	output_tokens_details: Schema.optional(OutputTokensDetails)
+});
+const StopReason = Schema.Literals([
+	"stop",
+	"tool_calls",
+	"max_tokens",
+	"refusal",
+	"content_filter",
+	"max_tool_calls"
+]);
+const userText = (text) => ({
+	type: "message",
+	role: "user",
+	content: [{
+		type: "input_text",
+		text
+	}]
+});
+const systemText = (text) => ({
+	type: "message",
+	role: "system",
+	content: [{
+		type: "input_text",
+		text
+	}]
+});
+const assistantText = (text) => ({
+	type: "message",
+	role: "assistant",
+	content: [{
+		type: "output_text",
+		text
+	}]
+});
+const functionCallOutput = (call_id, output) => ({
+	type: "function_call_output",
+	call_id,
+	output
+});
+//#endregion
+export { Annotation, ContainerFileCitation, ContentBlock, FileCitation, FilePath, FunctionCall, FunctionCallOutput, ImageBase64Source, ImageSource, ImageUrlSource, InputImage, InputText, InputTokensDetails, Item, Message, OutputText, OutputTokensDetails, Reasoning, Refusal, Role, StopReason, UrlCitation, Usage, assistantText, functionCallOutput, isContainerFileCitation, isFileCitation, isFilePath, isFunctionCall, isFunctionCallOutput, isImageBase64Source, isImageUrlSource, isInputImage, isInputText, isMessage, isOutputText, isReasoning, isRefusal, isUrlCitation, systemText, Items_exports as t, userText };
+
+//# sourceMappingURL=Items.mjs.map

package/dist/domain/Items.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Items.mjs","names":[],"sources":["../../src/domain/Items.ts"],"sourcesContent":["import { Schema } from \"effect\"\n\n// ---------------------------------------------------------------------------\n// Content blocks (inside Message.content)\n// ---------------------------------------------------------------------------\n\nexport const InputText = Schema.Struct({\n  type: Schema.Literal(\"input_text\"),\n  text: Schema.String,\n})\nexport type InputText = typeof InputText.Type\n\n/**\n * Where an image lives. `url` covers HTTP(S) URLs (the model fetches\n * them); `base64` covers inline bytes embedded in the request. Provider\n * encoders dispatch on `_tag`. File-id / uploaded-asset references are\n * provider-specific and stay out of this union for now.\n */\nexport const ImageUrlSource = Schema.Struct({\n  _tag: Schema.Literal(\"url\"),\n  url: Schema.String,\n})\nexport type ImageUrlSource = typeof ImageUrlSource.Type\n\n/**\n * Inline image bytes. `data` is **already base64-encoded** (matches what\n * the wire formats expect; no double-encoding needed downstream).\n * `media_type` is the MIME type, e.g. `\"image/png\"`.\n */\nexport const ImageBase64Source = Schema.Struct({\n  _tag: Schema.Literal(\"base64\"),\n  media_type: Schema.String,\n  data: Schema.String,\n})\nexport type ImageBase64Source = typeof ImageBase64Source.Type\n\nexport const ImageSource = Schema.Union([ImageUrlSource, ImageBase64Source])\nexport type ImageSource = typeof ImageSource.Type\n\nexport const isImageUrlSource = (s: ImageSource): s is ImageUrlSource => s._tag === \"url\"\nexport const isImageBase64Source = (s: ImageSource): s is ImageBase64Source => s._tag === \"base64\"\n\n/**\n * User-provided image content block. Pair with `InputText` inside a\n * `Message.content` array to ask \"what's in this image?\" style questions.\n */\nexport const InputImage = Schema.Struct({\n  type: Schema.Literal(\"input_image\"),\n  source: ImageSource,\n})\nexport type InputImage = typeof InputImage.Type\n\n// ---------------------------------------------------------------------------\n// Annotations - source / citation pointers attached to `output_text` blocks.\n// Mirrors OpenAI Responses API; other providers can omit or map onto these\n// shapes.\n// ---------------------------------------------------------------------------\n\nexport const UrlCitation = Schema.Struct({\n  type: Schema.Literal(\"url_citation\"),\n  url: Schema.String,\n  start_index: Schema.Number,\n  end_index: Schema.Number,\n  title: Schema.String,\n})\nexport type UrlCitation = typeof UrlCitation.Type\n\nexport const FileCitation = Schema.Struct({\n  type: Schema.Literal(\"file_citation\"),\n  file_id: Schema.String,\n  index: Schema.Number,\n})\nexport type FileCitation = typeof FileCitation.Type\n\nexport const ContainerFileCitation = Schema.Struct({\n  type: Schema.Literal(\"container_file_citation\"),\n  container_id: Schema.String,\n  file_id: Schema.String,\n  start_index: Schema.Number,\n  end_index: Schema.Number,\n})\nexport type ContainerFileCitation = typeof ContainerFileCitation.Type\n\nexport const FilePath = Schema.Struct({\n  type: Schema.Literal(\"file_path\"),\n  file_id: Schema.String,\n  index: Schema.Number,\n})\nexport type FilePath = typeof FilePath.Type\n\nexport const Annotation = Schema.Union([UrlCitation, FileCitation, ContainerFileCitation, FilePath])\nexport type Annotation = typeof Annotation.Type\n\nexport const isUrlCitation = (a: Annotation): a is UrlCitation => a.type === \"url_citation\"\nexport const isFileCitation = (a: Annotation): a is FileCitation => a.type === \"file_citation\"\nexport const isContainerFileCitation = (a: Annotation): a is ContainerFileCitation =>\n  a.type === \"container_file_citation\"\nexport const isFilePath = (a: Annotation): a is FilePath => a.type === \"file_path\"\n\nexport const OutputText = Schema.Struct({\n  type: Schema.Literal(\"output_text\"),\n  text: Schema.String,\n  annotations: Schema.optional(Schema.Array(Annotation)),\n})\nexport type OutputText = typeof OutputText.Type\n\n/**\n * Model-emitted refusal. Distinct from `output_text`: the model declined\n * to answer rather than producing normal output. Pair with\n * `stop_reason: \"refusal\"` on the surrounding `Turn`. Streamed via the\n * `refusal_delta` `TurnEvent`.\n */\nexport const Refusal = Schema.Struct({\n  type: Schema.Literal(\"refusal\"),\n  text: Schema.String,\n})\nexport type Refusal = typeof Refusal.Type\n\nexport const ContentBlock = Schema.Union([InputText, InputImage, OutputText, Refusal])\nexport type ContentBlock = typeof ContentBlock.Type\n\nexport const Role = Schema.Literals([\"user\", \"assistant\", \"system\"])\nexport type Role = typeof Role.Type\n\n// ---------------------------------------------------------------------------\n// Provider passthrough - every Item type carries this opaque slot.\n// The framework never reads or interprets it; provider modules decode\n// their own data via their own typed readers (see e.g.\n// the `@effect-uai/responses` package).\n// ---------------------------------------------------------------------------\n\nconst ProviderData = Schema.optional(Schema.Unknown)\n\n// ---------------------------------------------------------------------------\n// Items\n// ---------------------------------------------------------------------------\n\nexport const Message = Schema.Struct({\n  type: Schema.Literal(\"message\"),\n  role: Role,\n  content: Schema.Array(ContentBlock),\n  providerData: ProviderData,\n})\nexport type Message = typeof Message.Type\n\nexport const FunctionCall = Schema.Struct({\n  type: Schema.Literal(\"function_call\"),\n  call_id: Schema.String,\n  name: Schema.String,\n  // JSON-encoded arguments string, mirroring OpenAI Responses API\n  arguments: Schema.String,\n  providerData: ProviderData,\n})\nexport type FunctionCall = typeof FunctionCall.Type\n\nexport const FunctionCallOutput = Schema.Struct({\n  type: Schema.Literal(\"function_call_output\"),\n  call_id: Schema.String,\n  output: Schema.String,\n  providerData: ProviderData,\n})\nexport type FunctionCallOutput = typeof FunctionCallOutput.Type\n\n/**\n * Reasoning item - top-level, mirrors OpenAI Responses API. Common shape\n * across providers covers `summary` (human-readable text) and `signature`\n * (opaque round-trip blob - Anthropic's signed thinking, OpenAI's\n * encrypted_content, etc.). Provider-specific fields go in `providerData`.\n */\nexport const Reasoning = Schema.Struct({\n  type: Schema.Literal(\"reasoning\"),\n  id: Schema.optional(Schema.String),\n  summary: Schema.optional(Schema.String),\n  signature: Schema.optional(Schema.String),\n  providerData: ProviderData,\n})\nexport type Reasoning = typeof Reasoning.Type\n\nexport const Item = Schema.Union([Message, FunctionCall, FunctionCallOutput, Reasoning])\nexport type Item = typeof Item.Type\n\n// ---------------------------------------------------------------------------\n// Type guards\n// ---------------------------------------------------------------------------\n\nexport const isInputText = (block: ContentBlock): block is InputText => block.type === \"input_text\"\nexport const isInputImage = (block: ContentBlock): block is InputImage =>\n  block.type === \"input_image\"\nexport const isOutputText = (block: ContentBlock): block is OutputText =>\n  block.type === \"output_text\"\nexport const isRefusal = (block: ContentBlock): block is Refusal => block.type === \"refusal\"\n\nexport const isMessage = (item: Item): item is Message => item.type === \"message\"\nexport const isFunctionCall = (item: Item): item is FunctionCall => item.type === \"function_call\"\nexport const isFunctionCallOutput = (item: Item): item is FunctionCallOutput =>\n  item.type === \"function_call_output\"\nexport const isReasoning = (item: Item): item is Reasoning => item.type === \"reasoning\"\n\n// ---------------------------------------------------------------------------\n// Usage and stop reason\n// ---------------------------------------------------------------------------\n\nexport const InputTokensDetails = Schema.Struct({\n  cached_tokens: Schema.optional(Schema.Number),\n})\nexport type InputTokensDetails = typeof InputTokensDetails.Type\n\nexport const OutputTokensDetails = Schema.Struct({\n  reasoning_tokens: Schema.optional(Schema.Number),\n})\nexport type OutputTokensDetails = typeof OutputTokensDetails.Type\n\nexport const Usage = Schema.Struct({\n  input_tokens: Schema.optional(Schema.Number),\n  output_tokens: Schema.optional(Schema.Number),\n  total_tokens: Schema.optional(Schema.Number),\n  input_tokens_details: Schema.optional(InputTokensDetails),\n  output_tokens_details: Schema.optional(OutputTokensDetails),\n})\nexport type Usage = typeof Usage.Type\n\nexport const StopReason = Schema.Literals([\n  \"stop\",\n  \"tool_calls\",\n  \"max_tokens\",\n  \"refusal\",\n  /** Provider-side safety classifier flagged the output. */\n  \"content_filter\",\n  /** Server-enforced cap on tool calls per turn was hit. */\n  \"max_tool_calls\",\n])\nexport type StopReason = typeof StopReason.Type\n\n// ---------------------------------------------------------------------------\n// Helper constructors\n// ---------------------------------------------------------------------------\n\nexport const userText = (text: string): Message => ({\n  type: \"message\",\n  role: \"user\",\n  content: [{ type: \"input_text\", text }],\n})\n\nexport const systemText = (text: string): Message => ({\n  type: \"message\",\n  role: \"system\",\n  content: [{ type: \"input_text\", text }],\n})\n\nexport const assistantText = (text: string): Message => ({\n  type: \"message\",\n  role: \"assistant\",\n  content: [{ type: \"output_text\", text }],\n})\n\nexport const functionCallOutput = (call_id: string, output: string): FunctionCallOutput => ({\n  type: \"function_call_output\",\n  call_id,\n  output,\n})\n"],"mappings":"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"}

package/dist/domain/Turn.d.mts

@@ -0,0 +1,2 @@
+import { a as TurnEvent, c as cursor, d as reasonings, f as textDeltas, i as Turn, l as functionCalls, n as InteractionEvent, p as toStructured, r as RefusalRejected, s as assistantMessages, t as Cursor, u as isTurnComplete } from "../Turn-rlTfuHaQ.mjs";
+export { Cursor, InteractionEvent, RefusalRejected, Turn, TurnEvent, assistantMessages, cursor, functionCalls, isTurnComplete, reasonings, textDeltas, toStructured };

package/dist/domain/Turn.mjs

@@ -0,0 +1,82 @@
+import { t as __exportAll } from "../chunk-CfYAbeIz.mjs";
+import { Item, StopReason, Usage, isOutputText, isRefusal } from "./Items.mjs";
+import { parseJson } from "../structured-format/StructuredFormat.mjs";
+import { Data, Effect, Result, Schema, Stream, pipe } from "effect";
+//#region src/domain/Turn.ts
+var Turn_exports = /* @__PURE__ */ __exportAll({
+	RefusalRejected: () => RefusalRejected,
+	Turn: () => Turn,
+	assistantMessages: () => assistantMessages,
+	cursor: () => cursor,
+	functionCalls: () => functionCalls,
+	isTurnComplete: () => isTurnComplete,
+	reasonings: () => reasonings,
+	textDeltas: () => textDeltas,
+	toStructured: () => toStructured
+});
+/**
+* The result of a single LLM generation. A turn produces zero or more items
+* (typically one assistant message and zero or more function_call items)
+* and reports usage + a stop reason.
+*/
+const Turn = Schema.Struct({
+	items: Schema.Array(Item),
+	usage: Usage,
+	stop_reason: StopReason
+});
+const isTurnComplete = (d) => d.type === "turn_complete";
+const functionCalls = (turn) => turn.items.filter((i) => i.type === "function_call");
+const reasonings = (turn) => turn.items.filter((i) => i.type === "reasoning");
+const assistantMessages = (turn) => turn.items.filter((i) => i.type === "message" && i.role === "assistant");
+/**
+* Build a `Cursor<S>` from a state record and the just-completed turn.
+* Extends `state.history` with `turn.items` and stamps the turn.
+*/
+const cursor = (state, turn) => ({
+	...state,
+	history: [...state.history, ...turn.items],
+	turn
+});
+/**
+* Project a `TurnEvent` stream onto its `text_delta` payloads. Other
+* variants are dropped. Composes with `Lines.lines` +
+* `decodeJsonLines` for prompted-JSONL streaming.
+*/
+const textDeltas = (self) => self.pipe(Stream.filterMap((ev) => ev.type === "text_delta" ? Result.succeed(ev.text) : Result.failVoid));
+/**
+* The assistant message on the just-completed turn was a refusal block,
+* not an `output_text` payload. Returned by `toStructured` to short-circuit
+* decoding before `JSON.parse` / schema validation runs.
+*/
+var RefusalRejected = class extends Data.TaggedError("RefusalRejected") {};
+const lastAssistantContent = (turn) => {
+	const assistants = assistantMessages(turn);
+	const last = assistants[assistants.length - 1];
+	if (last === void 0) return {
+		text: "",
+		refused: false
+	};
+	if (last.content.some(isRefusal)) return {
+		text: "",
+		refused: true
+	};
+	return {
+		text: last.content.filter(isOutputText).map((b) => b.text).join(""),
+		refused: false
+	};
+};
+/**
+* Validate a completed `Turn` against a `StructuredFormat`. Concatenates
+* `output_text` blocks on the last assistant message, then runs
+* `JSON.parse` + the format's schema validation.
+*
+* Three failure modes:
+* - `RefusalRejected` — the assistant emitted a refusal block.
+* - `JsonParseError` — the assembled text wasn't valid JSON.
+* - `StructuredDecodeError` — the JSON didn't match the schema.
+*/
+const toStructured = (turn, format) => pipe(lastAssistantContent(turn), ({ text, refused }) => refused ? Effect.fail(new RefusalRejected({ turn })) : parseJson(format)(text));
+//#endregion
+export { RefusalRejected, Turn, assistantMessages, cursor, functionCalls, isTurnComplete, reasonings, Turn_exports as t, textDeltas, toStructured };
+
+//# sourceMappingURL=Turn.mjs.map

package/dist/domain/Turn.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Turn.mjs","names":["StructuredFormat.parseJson"],"sources":["../../src/domain/Turn.ts"],"sourcesContent":["import { Data, Effect, Result, Schema, Stream, pipe } from \"effect\"\nimport * as StructuredFormat from \"../structured-format/StructuredFormat.js\"\nimport {\n  FunctionCall,\n  FunctionCallOutput,\n  Item,\n  isOutputText,\n  isRefusal,\n  Message,\n  Reasoning,\n  StopReason,\n  Usage,\n} from \"./Items.js\"\n\n/**\n * The result of a single LLM generation. A turn produces zero or more items\n * (typically one assistant message and zero or more function_call items)\n * and reports usage + a stop reason.\n */\nexport const Turn = Schema.Struct({\n  items: Schema.Array(Item),\n  usage: Usage,\n  stop_reason: StopReason,\n})\nexport type Turn = typeof Turn.Type\n\n/**\n * Canonical events emitted while a single turn is being generated. Most\n * variants are streaming deltas (text, reasoning, tool-call args); the\n * terminal `turn_complete` carries the assembled `Turn`. Lifecycle members\n * aren't deltas, hence the union name.\n */\nexport type TurnEvent =\n  | { readonly type: \"text_delta\"; readonly text: string }\n  | {\n      readonly type: \"reasoning_delta\"\n      readonly text: string\n      /**\n       * `trace` is the model's raw chain-of-thought; `summary` is a\n       * model-written summary intended for display. OpenAI Responses emits\n       * both as separate wire events; Anthropic and Gemini only emit\n       * `trace`. Consumers who just want any reasoning text match once;\n       * those who want only summaries filter `kind === \"summary\"`.\n       */\n      readonly kind: \"trace\" | \"summary\"\n    }\n  /**\n   * The model declined to answer. `text` is the (streamed) explanation.\n   * Distinct from the failure channel: a refusal is normal model output and\n   * the stream still completes with `turn_complete`. OpenAI Responses emits\n   * this; Anthropic surfaces refusals via `stop_reason`, and Gemini collapses\n   * them into `finishReason: SAFETY` - both go without a `refusal_delta`.\n   */\n  | { readonly type: \"refusal_delta\"; readonly text: string }\n  | { readonly type: \"tool_call_start\"; readonly call_id: string; readonly name: string }\n  | { readonly type: \"tool_call_args_delta\"; readonly call_id: string; readonly delta: string }\n  /**\n   * Mid-stream cumulative usage. Carries the full `Usage` (including cache\n   * token fields when the provider surfaces them) so consumers can drive\n   * live budget / cost tracking without waiting for `turn_complete`.\n   * Anthropic emits this on `message_start` and `message_delta`; other\n   * providers may not emit any `usage_update` and only deliver usage via\n   * `turn_complete.turn.usage`.\n   */\n  | { readonly type: \"usage_update\"; readonly usage: Usage }\n  | { readonly type: \"turn_complete\"; readonly turn: Turn }\n\n/**\n * What flows out of an agent loop body to its consumer per turn: every\n * `TurnEvent` the provider emits (including the terminal `turn_complete`\n * carrying the assembled `Turn`), plus the output of any tool the loop ran.\n * Both variants carry a `type` discriminator.\n */\nexport type InteractionEvent = TurnEvent | FunctionCallOutput\n\nexport const isTurnComplete = (d: TurnEvent): d is Extract<TurnEvent, { type: \"turn_complete\" }> =>\n  d.type === \"turn_complete\"\n\nexport const functionCalls = (turn: Turn): ReadonlyArray<FunctionCall> =>\n  turn.items.filter((i): i is FunctionCall => i.type === \"function_call\")\n\nexport const reasonings = (turn: Turn): ReadonlyArray<Reasoning> =>\n  turn.items.filter((i): i is Reasoning => i.type === \"reasoning\")\n\nexport const assistantMessages = (turn: Turn): ReadonlyArray<Message> =>\n  turn.items.filter((i): i is Message => i.type === \"message\" && i.role === \"assistant\")\n\n/**\n * State stamped with the just-completed `Turn`. Recipes use this as the\n * intermediate value between \"turn lands\" and \"compute next state\": extend\n * `state.history` with the turn's items, and keep the assembled turn\n * around for stop-reason / usage / function-call inspection.\n *\n * Generic over the recipe's state shape - any record carrying a\n * `history: ReadonlyArray<Item>` field works.\n */\nexport type Cursor<S> = S & { readonly turn: Turn }\n\n/**\n * Build a `Cursor<S>` from a state record and the just-completed turn.\n * Extends `state.history` with `turn.items` and stamps the turn.\n */\nexport const cursor = <S extends { readonly history: ReadonlyArray<Item> }>(\n  state: S,\n  turn: Turn,\n): Cursor<S> => ({\n  ...state,\n  history: [...state.history, ...turn.items],\n  turn,\n})\n\n// ---------------------------------------------------------------------------\n// Stream operators\n// ---------------------------------------------------------------------------\n\n/**\n * Project a `TurnEvent` stream onto its `text_delta` payloads. Other\n * variants are dropped. Composes with `Lines.lines` +\n * `decodeJsonLines` for prompted-JSONL streaming.\n */\nexport const textDeltas = <E, R>(\n  self: Stream.Stream<TurnEvent, E, R>,\n): Stream.Stream<string, E, R> =>\n  self.pipe(\n    Stream.filterMap((ev) =>\n      ev.type === \"text_delta\" ? Result.succeed(ev.text) : Result.failVoid,\n    ),\n  )\n\n// ---------------------------------------------------------------------------\n// Structured-output integration\n// ---------------------------------------------------------------------------\n\n/**\n * The assistant message on the just-completed turn was a refusal block,\n * not an `output_text` payload. Returned by `toStructured` to short-circuit\n * decoding before `JSON.parse` / schema validation runs.\n */\nexport class RefusalRejected extends Data.TaggedError(\"RefusalRejected\")<{\n  readonly turn: Turn\n}> {}\n\nconst lastAssistantContent = (turn: Turn): { readonly text: string; readonly refused: boolean } => {\n  const assistants = assistantMessages(turn)\n  const last = assistants[assistants.length - 1]\n  if (last === undefined) return { text: \"\", refused: false }\n  if (last.content.some(isRefusal)) return { text: \"\", refused: true }\n  const text = last.content\n    .filter(isOutputText)\n    .map((b) => b.text)\n    .join(\"\")\n  return { text, refused: false }\n}\n\n/**\n * Validate a completed `Turn` against a `StructuredFormat`. Concatenates\n * `output_text` blocks on the last assistant message, then runs\n * `JSON.parse` + the format's schema validation.\n *\n * Three failure modes:\n * - `RefusalRejected` — the assistant emitted a refusal block.\n * - `JsonParseError` — the assembled text wasn't valid JSON.\n * - `StructuredDecodeError` — the JSON didn't match the schema.\n */\nexport const toStructured = <A>(\n  turn: Turn,\n  format: StructuredFormat.StructuredFormat<A>,\n): Effect.Effect<\n  A,\n  RefusalRejected | StructuredFormat.JsonParseError | StructuredFormat.StructuredDecodeError\n> =>\n  pipe(lastAssistantContent(turn), ({ text, refused }) =>\n    refused ? Effect.fail(new RefusalRejected({ turn })) : StructuredFormat.parseJson(format)(text),\n  )\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAmBA,MAAa,OAAO,OAAO,OAAO;CAChC,OAAO,OAAO,MAAM,KAAK;CACzB,OAAO;CACP,aAAa;CACd,CAAC;AAoDF,MAAa,kBAAkB,MAC7B,EAAE,SAAS;AAEb,MAAa,iBAAiB,SAC5B,KAAK,MAAM,QAAQ,MAAyB,EAAE,SAAS,gBAAgB;AAEzE,MAAa,cAAc,SACzB,KAAK,MAAM,QAAQ,MAAsB,EAAE,SAAS,YAAY;AAElE,MAAa,qBAAqB,SAChC,KAAK,MAAM,QAAQ,MAAoB,EAAE,SAAS,aAAa,EAAE,SAAS,YAAY;;;;;AAiBxF,MAAa,UACX,OACA,UACe;CACf,GAAG;CACH,SAAS,CAAC,GAAG,MAAM,SAAS,GAAG,KAAK,MAAM;CAC1C;CACD;;;;;;AAWD,MAAa,cACX,SAEA,KAAK,KACH,OAAO,WAAW,OAChB,GAAG,SAAS,eAAe,OAAO,QAAQ,GAAG,KAAK,GAAG,OAAO,SAC7D,CACF;;;;;;AAWH,IAAa,kBAAb,cAAqC,KAAK,YAAY,kBAAkB,CAErE;AAEH,MAAM,wBAAwB,SAAqE;CACjG,MAAM,aAAa,kBAAkB,KAAK;CAC1C,MAAM,OAAO,WAAW,WAAW,SAAS;AAC5C,KAAI,SAAS,KAAA,EAAW,QAAO;EAAE,MAAM;EAAI,SAAS;EAAO;AAC3D,KAAI,KAAK,QAAQ,KAAK,UAAU,CAAE,QAAO;EAAE,MAAM;EAAI,SAAS;EAAM;AAKpE,QAAO;EAAE,MAJI,KAAK,QACf,OAAO,aAAa,CACpB,KAAK,MAAM,EAAE,KAAK,CAClB,KAAK,GACK;EAAE,SAAS;EAAO;;;;;;;;;;;;AAajC,MAAa,gBACX,MACA,WAKA,KAAK,qBAAqB,KAAK,GAAG,EAAE,MAAM,cACxC,UAAU,OAAO,KAAK,IAAI,gBAAgB,EAAE,MAAM,CAAC,CAAC,GAAGA,UAA2B,OAAO,CAAC,KAAK,CAChG"}

package/dist/index.d.mts

@@ -0,0 +1,14 @@
+import { n as AiError_d_exports } from "./AiError-CqmYjXyx.mjs";
+import { h as Items_d_exports } from "./Items-D1C2686t.mjs";
+import { a as StructuredFormat_d_exports } from "./StructuredFormat-B5ueioNr.mjs";
+import { o as Turn_d_exports } from "./Turn-rlTfuHaQ.mjs";
+import { l as Tool_d_exports } from "./Tool-5wxOCuOh.mjs";
+import { t as LanguageModel_d_exports } from "./language-model/LanguageModel.mjs";
+import { n as Loop_d_exports } from "./Loop-CzSJo1h8.mjs";
+import { t as Match_d_exports } from "./match/Match.mjs";
+import { t as Toolkit_d_exports } from "./tool/Toolkit.mjs";
+import { t as JSONL_d_exports } from "./streaming/JSONL.mjs";
+import { t as Lines_d_exports } from "./streaming/Lines.mjs";
+import { t as SSE_d_exports } from "./streaming/SSE.mjs";
+import { t as Metrics_d_exports } from "./observability/Metrics.mjs";
+export { AiError_d_exports as AiError, Items_d_exports as Items, JSONL_d_exports as JSONL, LanguageModel_d_exports as LanguageModel, Lines_d_exports as Lines, Loop_d_exports as Loop, Match_d_exports as Match, Metrics_d_exports as Metrics, SSE_d_exports as SSE, StructuredFormat_d_exports as StructuredFormat, Tool_d_exports as Tool, Toolkit_d_exports as Toolkit, Turn_d_exports as Turn };

package/dist/index.mjs

@@ -0,0 +1,14 @@
+import { t as AiError_exports } from "./domain/AiError.mjs";
+import { t as Items_exports } from "./domain/Items.mjs";
+import { t as StructuredFormat_exports } from "./structured-format/StructuredFormat.mjs";
+import { t as Turn_exports } from "./domain/Turn.mjs";
+import { t as LanguageModel_exports } from "./language-model/LanguageModel.mjs";
+import { t as Loop_exports } from "./loop/Loop.mjs";
+import { t as Match_exports } from "./match/Match.mjs";
+import { t as Tool_exports } from "./tool/Tool.mjs";
+import { t as Toolkit_exports } from "./tool/Toolkit.mjs";
+import { t as JSONL_exports } from "./streaming/JSONL.mjs";
+import { t as Lines_exports } from "./streaming/Lines.mjs";
+import { t as SSE_exports } from "./streaming/SSE.mjs";
+import { t as Metrics_exports } from "./observability/Metrics.mjs";
+export { AiError_exports as AiError, Items_exports as Items, JSONL_exports as JSONL, LanguageModel_exports as LanguageModel, Lines_exports as Lines, Loop_exports as Loop, Match_exports as Match, Metrics_exports as Metrics, SSE_exports as SSE, StructuredFormat_exports as StructuredFormat, Tool_exports as Tool, Toolkit_exports as Toolkit, Turn_exports as Turn };

package/dist/language-model/LanguageModel.d.mts

@@ -0,0 +1,60 @@
+import { t as AiError } from "../AiError-CqmYjXyx.mjs";
+import { m as Item } from "../Items-D1C2686t.mjs";
+import { i as StructuredFormat } from "../StructuredFormat-B5ueioNr.mjs";
+import { a as TurnEvent, i as Turn } from "../Turn-rlTfuHaQ.mjs";
+import { o as ToolDescriptor } from "../Tool-5wxOCuOh.mjs";
+import { Context, Effect, Stream } from "effect";
+
+//#region src/language-model/LanguageModel.d.ts
+declare namespace LanguageModel_d_exports {
+  export { CommonRequest, LanguageModel, LanguageModelService, streamTurn, turn };
+}
+/**
+ * Cross-provider request shape. Every call carries its own `history` and
+ * `model` - models are not bound at layer construction. Anything specific
+ * to a single provider (reasoning effort, prompt caching, store flags,
+ * ...) lives in that provider's own request interface, which extends this.
+ */
+interface CommonRequest {
+  readonly history: ReadonlyArray<Item>;
+  /**
+   * Model identifier. Each provider narrows this to its typed literal union,
+   * so code that yields a typed provider tag gets autocompletion.
+   */
+  readonly model: string;
+  readonly tools?: ReadonlyArray<ToolDescriptor>;
+  readonly toolChoice?: "auto" | "required" | "none" | {
+    readonly type: "function";
+    readonly name: string;
+  };
+  readonly temperature?: number;
+  readonly topP?: number;
+  readonly maxOutputTokens?: number;
+  /**
+   * Schema-bound JSON output. The provider constrains the wire to match the
+   * schema; pair with `Turn.toStructured` for runtime validation. Supported
+   * across all current providers (OpenAI Responses json_schema, Anthropic
+   * `output_config`, Gemini `responseJsonSchema`).
+   */
+  readonly structured?: StructuredFormat<unknown>;
+}
+interface LanguageModelService {
+  readonly streamTurn: (request: CommonRequest) => Stream.Stream<TurnEvent, AiError>;
+}
+declare const LanguageModel_base: Context.ServiceClass<LanguageModel, "@betalyra/effect-uai/LanguageModel", LanguageModelService>;
+declare class LanguageModel extends LanguageModel_base {}
+/**
+ * Stream the deltas of a single turn.
+ */
+declare const streamTurn: (request: CommonRequest) => Stream.Stream<TurnEvent, AiError, LanguageModel>;
+/**
+ * Run a single turn to completion and return the assembled `Turn`.
+ *
+ * Implementation: drain the delta stream and pluck the terminal
+ * `turn_complete` event. The provider is contractually required to emit
+ * exactly one such event as the last delta.
+ */
+declare const turn: (request: CommonRequest) => Effect.Effect<Turn, AiError, LanguageModel>;
+//#endregion
+export { CommonRequest, LanguageModel, LanguageModelService, streamTurn, LanguageModel_d_exports as t, turn };
+//# sourceMappingURL=LanguageModel.d.mts.map

package/dist/language-model/LanguageModel.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LanguageModel.d.mts","names":[],"sources":["../../src/language-model/LanguageModel.ts"],"mappings":";;;;;;;;;;;;;;;;;UAaiB,aAAA;EAAA,SACN,OAAA,EAAS,aAAA,CAAc,IAAA;;;AADlC;;WAMW,KAAA;EAAA,SACA,KAAA,GAAQ,aAAA,CAAc,cAAA;EAAA,SACtB,UAAA;IAAA,SAIM,IAAA;IAAA,SAA2B,IAAA;EAAA;EAAA,SACjC,WAAA;EAAA,SACA,IAAA;EAAA,SACA,eAAA;EAdS;;;;;;EAAA,SAqBT,UAAA,GAAa,gBAAA;AAAA;AAAA,UAGP,oBAAA;EAAA,SACN,UAAA,GAAa,OAAA,EAAS,aAAA,KAAkB,MAAA,CAAO,MAAA,CAAO,SAAA,EAAW,OAAA;AAAA;AAAA,cAC3E,kBAAA;cAEY,aAAA,SAAsB,kBAAA;;;;cAOtB,UAAA,GACX,OAAA,EAAS,aAAA,KACR,MAAA,CAAO,MAAA,CAAO,SAAA,EAAW,OAAA,EAAiB,aAAA;;;;;;;;cAUhC,IAAA,GAAQ,OAAA,EAAS,aAAA,KAAgB,MAAA,CAAO,MAAA,CAAO,IAAA,EAAM,OAAA,EAAiB,aAAA"}

package/dist/language-model/LanguageModel.mjs

@@ -0,0 +1,33 @@
+import { t as __exportAll } from "../chunk-CfYAbeIz.mjs";
+import { Unavailable } from "../domain/AiError.mjs";
+import { isTurnComplete } from "../domain/Turn.mjs";
+import { Context, Effect, Stream } from "effect";
+//#region src/language-model/LanguageModel.ts
+var LanguageModel_exports = /* @__PURE__ */ __exportAll({
+	LanguageModel: () => LanguageModel,
+	streamTurn: () => streamTurn,
+	turn: () => turn
+});
+var LanguageModel = class extends Context.Service()("@betalyra/effect-uai/LanguageModel") {};
+/**
+* Stream the deltas of a single turn.
+*/
+const streamTurn = (request) => Stream.unwrap(Effect.map(LanguageModel.asEffect(), (m) => m.streamTurn(request)));
+/**
+* Run a single turn to completion and return the assembled `Turn`.
+*
+* Implementation: drain the delta stream and pluck the terminal
+* `turn_complete` event. The provider is contractually required to emit
+* exactly one such event as the last delta.
+*/
+const turn = (request) => Effect.flatMap(Stream.runCollect(streamTurn(request)), (deltas) => {
+	const last = deltas[deltas.length - 1];
+	return last !== void 0 && isTurnComplete(last) ? Effect.succeed(last.turn) : Effect.fail(new Unavailable({
+		provider: "unknown",
+		raw: "Provider stream ended without a turn_complete event"
+	}));
+});
+//#endregion
+export { LanguageModel, streamTurn, LanguageModel_exports as t, turn };
+
+//# sourceMappingURL=LanguageModel.mjs.map

package/dist/language-model/LanguageModel.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"LanguageModel.mjs","names":["AiError.Unavailable"],"sources":["../../src/language-model/LanguageModel.ts"],"sourcesContent":["import { Context, Effect, Stream } from \"effect\"\nimport * as AiError from \"../domain/AiError.js\"\nimport type { Item } from \"../domain/Items.js\"\nimport type * as StructuredFormat from \"../structured-format/StructuredFormat.js\"\nimport type { ToolDescriptor } from \"../tool/Tool.js\"\nimport { isTurnComplete, type Turn, type TurnEvent } from \"../domain/Turn.js\"\n\n/**\n * Cross-provider request shape. Every call carries its own `history` and\n * `model` - models are not bound at layer construction. Anything specific\n * to a single provider (reasoning effort, prompt caching, store flags,\n * ...) lives in that provider's own request interface, which extends this.\n */\nexport interface CommonRequest {\n  readonly history: ReadonlyArray<Item>\n  /**\n   * Model identifier. Each provider narrows this to its typed literal union,\n   * so code that yields a typed provider tag gets autocompletion.\n   */\n  readonly model: string\n  readonly tools?: ReadonlyArray<ToolDescriptor>\n  readonly toolChoice?:\n    | \"auto\"\n    | \"required\"\n    | \"none\"\n    | { readonly type: \"function\"; readonly name: string }\n  readonly temperature?: number\n  readonly topP?: number\n  readonly maxOutputTokens?: number\n  /**\n   * Schema-bound JSON output. The provider constrains the wire to match the\n   * schema; pair with `Turn.toStructured` for runtime validation. Supported\n   * across all current providers (OpenAI Responses json_schema, Anthropic\n   * `output_config`, Gemini `responseJsonSchema`).\n   */\n  readonly structured?: StructuredFormat.StructuredFormat<unknown>\n}\n\nexport interface LanguageModelService {\n  readonly streamTurn: (request: CommonRequest) => Stream.Stream<TurnEvent, AiError.AiError>\n}\n\nexport class LanguageModel extends Context.Service<LanguageModel, LanguageModelService>()(\n  \"@betalyra/effect-uai/LanguageModel\",\n) {}\n\n/**\n * Stream the deltas of a single turn.\n */\nexport const streamTurn = (\n  request: CommonRequest,\n): Stream.Stream<TurnEvent, AiError.AiError, LanguageModel> =>\n  Stream.unwrap(Effect.map(LanguageModel.asEffect(), (m) => m.streamTurn(request)))\n\n/**\n * Run a single turn to completion and return the assembled `Turn`.\n *\n * Implementation: drain the delta stream and pluck the terminal\n * `turn_complete` event. The provider is contractually required to emit\n * exactly one such event as the last delta.\n */\nexport const turn = (request: CommonRequest): Effect.Effect<Turn, AiError.AiError, LanguageModel> =>\n  Effect.flatMap(Stream.runCollect(streamTurn(request)), (deltas) => {\n    const last = deltas[deltas.length - 1]\n    return last !== undefined && isTurnComplete(last)\n      ? Effect.succeed(last.turn)\n      : Effect.fail(\n          new AiError.Unavailable({\n            provider: \"unknown\",\n            raw: \"Provider stream ended without a turn_complete event\",\n          }),\n        )\n  })\n"],"mappings":";;;;;;;;;;AA0CA,IAAa,gBAAb,cAAmC,QAAQ,SAA8C,CACvF,qCACD,CAAC;;;;AAKF,MAAa,cACX,YAEA,OAAO,OAAO,OAAO,IAAI,cAAc,UAAU,GAAG,MAAM,EAAE,WAAW,QAAQ,CAAC,CAAC;;;;;;;;AASnF,MAAa,QAAQ,YACnB,OAAO,QAAQ,OAAO,WAAW,WAAW,QAAQ,CAAC,GAAG,WAAW;CACjE,MAAM,OAAO,OAAO,OAAO,SAAS;AACpC,QAAO,SAAS,KAAA,KAAa,eAAe,KAAK,GAC7C,OAAO,QAAQ,KAAK,KAAK,GACzB,OAAO,KACL,IAAIA,YAAoB;EACtB,UAAU;EACV,KAAK;EACN,CAAC,CACH;EACL"}

package/dist/loop/Loop.d.mts

@@ -0,0 +1,2 @@
+import { a as nextAfter, c as stopAfter, d as value, i as next, l as stopEvent, o as nextAfterFold, r as loop, s as stop, t as Event, u as streamUntilComplete } from "../Loop-CzSJo1h8.mjs";
+export { Event, loop, next, nextAfter, nextAfterFold, stop, stopAfter, stopEvent, streamUntilComplete, value };