@effect-uai/core 0.1.0

package/dist/Outcome-C2JYknCu.d.mts

@@ -0,0 +1,40 @@
+import { o as FunctionCall, s as FunctionCallOutput } from "./Items-D1C2686t.mjs";
+
+//#region src/tool/Outcome.d.ts
+type ToolResult = {
+  readonly _tag: "Value";
+  readonly call_id: string;
+  readonly tool: string;
+  readonly value: unknown;
+} | {
+  readonly _tag: "Failure";
+  readonly call_id: string;
+  readonly tool: string;
+  readonly kind: string;
+  readonly reason?: string;
+};
+declare const isValue: (r: ToolResult) => r is Extract<ToolResult, {
+  _tag: "Value";
+}>;
+declare const isFailure: (r: ToolResult) => r is Extract<ToolResult, {
+  _tag: "Failure";
+}>;
+type ToolDecision = {
+  readonly _tag: "Execute";
+} | {
+  readonly _tag: "Reject";
+  readonly result: ToolResult;
+};
+declare const execute: ToolDecision;
+declare const reject: (result: ToolResult) => ToolDecision;
+declare const rejected: (call: FunctionCall, kind: string, reason?: string) => ToolResult;
+/** Explicit user/policy rejection. */
+declare const denied: (call: FunctionCall, reason?: string) => ToolResult;
+/** Implicit non-answer (follow-up, inactivity, abort). */
+declare const cancelled: (call: FunctionCall, reason?: string) => ToolResult;
+/** Tool's own execution failed (parse error, schema, runtime crash). */
+declare const executionError: (call: FunctionCall, reason: string) => ToolResult;
+declare const toFunctionCallOutput: (r: ToolResult) => FunctionCallOutput;
+//#endregion
+export { execute as a, isValue as c, toFunctionCallOutput as d, denied as i, reject as l, ToolResult as n, executionError as o, cancelled as r, isFailure as s, ToolDecision as t, rejected as u };
+//# sourceMappingURL=Outcome-C2JYknCu.d.mts.map

package/dist/Outcome-C2JYknCu.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Outcome-C2JYknCu.d.mts","names":[],"sources":["../src/tool/Outcome.ts"],"mappings":";;;KAsBY,UAAA;EAAA,SAEG,IAAA;EAAA,SACA,OAAA;EAAA,SACA,IAAA;EAAA,SACA,KAAA;AAAA;EAAA,SAGA,IAAA;EAAA,SACA,OAAA;EAAA,SACA,IAAA;EAAA,SACA,IAAA;EAAA,SACA,MAAA;AAAA;AAAA,cAGF,OAAA,GAAW,CAAA,EAAG,UAAA,KAAa,CAAA,IAAK,OAAA,CAAQ,UAAA;EAAc,IAAA;AAAA;AAAA,cAGtD,SAAA,GAAa,CAAA,EAAG,UAAA,KAAa,CAAA,IAAK,OAAA,CAAQ,UAAA;EAAc,IAAA;AAAA;AAAA,KAOzD,YAAA;EAAA,SACG,IAAA;AAAA;EAAA,SACA,IAAA;EAAA,SAAyB,MAAA,EAAQ,UAAA;AAAA;AAAA,cAEnC,OAAA,EAAS,YAAA;AAAA,cAET,MAAA,GAAU,MAAA,EAAQ,UAAA,KAAa,YAAA;AAAA,cAO/B,QAAA,GACX,IAAA,EAAM,YAAA,EACN,IAAA,UACA,MAAA,cACC,UAAA;;cASU,MAAA,GAAU,IAAA,EAAM,YAAA,EAAc,MAAA,cAAkB,UAAA;;cAIhD,SAAA,GAAa,IAAA,EAAM,YAAA,EAAc,MAAA,cAAkB,UAAA;;cAInD,cAAA,GAAkB,IAAA,EAAM,YAAA,EAAc,MAAA,aAAiB,UAAA;AAAA,cAOvD,oBAAA,GAAwB,CAAA,EAAG,UAAA,KAAa,kBAAA"}

package/dist/StructuredFormat-B5ueioNr.d.mts

@@ -0,0 +1,88 @@
+import { Effect, Schema, Stream } from "effect";
+import * as _$effect_Types0 from "effect/Types";
+import * as _$effect_Cause0 from "effect/Cause";
+import { StandardJSONSchemaV1, StandardSchemaV1 } from "@standard-schema/spec";
+
+//#region src/structured-format/StructuredFormat.d.ts
+declare namespace StructuredFormat_d_exports {
+  export { DecodeIssue, JsonParseError, StructuredDecodeError, StructuredFormat, StructuredSchema, decode, decodeJsonLines, fromEffectSchema, parseJson };
+}
+/**
+ * Cross-validator schema constraint for structured outputs. Any schema
+ * implementing both Standard Schema (runtime validation) and Standard
+ * JSON Schema (wire encoding) works directly: Zod 4+, Valibot, ArkType,
+ * and Effect Schema after `fromEffectSchema`.
+ */
+type StructuredSchema<Output = unknown> = StandardSchemaV1<unknown, Output> & StandardJSONSchemaV1<unknown, Output>;
+/**
+ * A schema-bound output the user wants the model to produce. Pairs the
+ * cross-validator schema with metadata providers need (name, description,
+ * strict-mode flag).
+ */
+interface StructuredFormat<A> {
+  readonly name: string;
+  readonly description?: string;
+  readonly schema: StructuredSchema<A>;
+  /**
+   * Provider strict-mode flag. OpenAI, Anthropic, and Mistral honour it
+   * (constrained decoding); other providers ignore.
+   */
+  readonly strict?: boolean;
+}
+/** A single path-scoped validation problem. Library-agnostic shape. */
+interface DecodeIssue {
+  readonly path: ReadonlyArray<string | number>;
+  readonly message: string;
+}
+declare const StructuredDecodeError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
+  readonly _tag: "StructuredDecodeError";
+} & Readonly<A>;
+/**
+ * Schema validation failed. `raw` is the original text (or stringified
+ * value) that failed; `issues` is a flat list of per-field problems.
+ */
+declare class StructuredDecodeError extends StructuredDecodeError_base<{
+  readonly raw: string;
+  readonly issues: ReadonlyArray<DecodeIssue>;
+}> {}
+declare const JsonParseError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
+  readonly _tag: "StructuredJsonParseError";
+} & Readonly<A>;
+/**
+ * `JSON.parse` threw on a string that was supposed to be JSON. Distinct
+ * from `StructuredDecodeError`: the bytes weren't even JSON.
+ */
+declare class JsonParseError extends JsonParseError_base<{
+  readonly raw: string;
+  readonly cause: unknown;
+}> {}
+/**
+ * Wrap an Effect `Schema` as a `StructuredFormat`. Effect Schema doesn't
+ * natively implement Standard Schema; this helper installs the
+ * `~standard` and JSON Schema interfaces.
+ */
+declare const fromEffectSchema: <S extends Schema.Codec<any, any, never, any>>(schema: S, options?: {
+  readonly name?: string;
+  readonly description?: string;
+  readonly strict?: boolean;
+}) => StructuredFormat<S["Type"]>;
+/**
+ * Validate an `unknown` against the format's schema. Returns the typed
+ * value or a `StructuredDecodeError`. Standard Schema's `validate` may
+ * be async; this function handles both sync and async results.
+ */
+declare const decode: <A>(format: StructuredFormat<A>) => (raw: unknown) => Effect.Effect<A, StructuredDecodeError>;
+/**
+ * Parse a JSON string then validate against the format's schema. Two
+ * failure modes: `JsonParseError` (bytes weren't JSON) and
+ * `StructuredDecodeError` (JSON didn't match the schema).
+ */
+declare const parseJson: <A>(format: StructuredFormat<A>) => (raw: string) => Effect.Effect<A, JsonParseError | StructuredDecodeError>;
+/**
+ * Stream operator: each input string is JSON-parsed and validated.
+ * Failures surface in the stream's failure channel, distinguished by tag.
+ */
+declare const decodeJsonLines: <A>(format: StructuredFormat<A>) => <E, R>(self: Stream.Stream<string, E, R>) => Stream.Stream<A, E | JsonParseError | StructuredDecodeError, R>;
+//#endregion
+export { StructuredFormat_d_exports as a, decodeJsonLines as c, StructuredFormat as i, fromEffectSchema as l, JsonParseError as n, StructuredSchema as o, StructuredDecodeError as r, decode as s, DecodeIssue as t, parseJson as u };
+//# sourceMappingURL=StructuredFormat-B5ueioNr.d.mts.map

package/dist/StructuredFormat-B5ueioNr.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StructuredFormat-B5ueioNr.d.mts","names":[],"sources":["../src/structured-format/StructuredFormat.ts"],"mappings":";;;;;;;;;;;;;;;KAaY,gBAAA,qBAAqC,gBAAA,UAA0B,MAAA,IACzE,oBAAA,UAA8B,MAAA;;;;;;UAOf,gBAAA;EAAA,SACN,IAAA;EAAA,SACA,WAAA;EAAA,SACA,MAAA,EAAQ,gBAAA,CAAiB,CAAA;EAXxB;;;;EAAA,SAgBD,MAAA;AAAA;;UAIM,WAAA;EAAA,SACN,IAAA,EAAM,aAAA;EAAA,SACN,OAAA;AAAA;AAAA,cACV,0BAAA;;;;;AAfD;;cAyBa,qBAAA,SAA8B,0BAAA;EAAA,SAChC,GAAA;EAAA,SACA,MAAA,EAAQ,aAAA,CAAc,WAAA;AAAA;AAAA,cAC5B,mBAAA;;;;;;AAhBL;cAsBa,cAAA,SAAuB,mBAAA;EAAA,SACzB,GAAA;EAAA,SACA,KAAA;AAAA;;;;AArBV;;cAiCY,gBAAA,aAA8B,MAAA,CAAO,KAAA,wBAChD,MAAA,EAAQ,CAAA,EACR,OAAA;EAAA,SACW,IAAA;EAAA,SACA,WAAA;EAAA,SACA,MAAA;AAAA,MAEV,gBAAA,CAAiB,CAAA;;;;;;cAyCP,MAAA,MACP,MAAA,EAAQ,gBAAA,CAAiB,CAAA,OAC5B,GAAA,cAAe,MAAA,CAAO,MAAA,CAAO,CAAA,EAAG,qBAAA;;;;;;cAoBtB,SAAA,MACP,MAAA,EAAQ,gBAAA,CAAiB,CAAA,OAC5B,GAAA,aAAc,MAAA,CAAO,MAAA,CAAO,CAAA,EAAG,cAAA,GAAiB,qBAAA;;;;;cAatC,eAAA,MACP,MAAA,EAAQ,gBAAA,CAAiB,CAAA,aAE3B,IAAA,EAAM,MAAA,CAAO,MAAA,SAAe,CAAA,EAAG,CAAA,MAC9B,MAAA,CAAO,MAAA,CAAO,CAAA,EAAG,CAAA,GAAI,cAAA,GAAiB,qBAAA,EAAuB,CAAA"}

package/dist/Tool-5wxOCuOh.d.mts

@@ -0,0 +1,86 @@
+import { o as FunctionCall, s as FunctionCallOutput } from "./Items-D1C2686t.mjs";
+import { Effect, Schema, Stream } from "effect";
+import * as _$effect_Cause0 from "effect/Cause";
+import { StandardJSONSchemaV1, StandardSchemaV1 } from "@standard-schema/spec";
+
+//#region src/tool/Tool.d.ts
+declare namespace Tool_d_exports {
+  export { AnyKindTool, AnyPlainTool, AnyStreamingTool, StreamingTool, Tool, ToolDescriptor, ToolError, ToolInputSchema, execute, fromEffectSchema, isStreamingTool, make, streaming, toDescriptors };
+}
+declare const ToolError_base: Schema.Class<ToolError, Schema.TaggedStruct<"ToolError", {
+  readonly call_id: Schema.String;
+  readonly tool: Schema.String;
+  readonly message: Schema.String;
+  readonly cause: Schema.optional<Schema.Unknown>;
+}>, _$effect_Cause0.YieldableError>;
+declare class ToolError extends ToolError_base {}
+/**
+ * Schemas accepted on `Tool.inputSchema`. Must implement both Standard
+ * Schema validation and JSON Schema conversion (for rendering tool
+ * descriptors to provider request bodies).
+ *
+ * Any Standard-Schema-compliant library that exposes both interfaces
+ * works directly: Zod 4+, Valibot, ArkType, Effect Schema (after
+ * `fromEffectSchema`), etc.
+ */
+type ToolInputSchema<Input = unknown> = StandardSchemaV1<unknown, Input> & StandardJSONSchemaV1<unknown, Input>;
+/**
+ * Convenience wrapper for Effect Schema users - adds both the
+ * `validate` and `jsonSchema` extensions to a plain Effect Schema so it
+ * can be used as a `Tool.inputSchema`.
+ */
+declare const fromEffectSchema: <S extends Schema.Codec<any, any, never, any>>(schema: S) => S & ToolInputSchema<S["Type"]>;
+interface Tool<Name extends string, Input, Output, R = never> {
+  readonly name: Name;
+  readonly description: string;
+  readonly inputSchema: ToolInputSchema<Input>;
+  readonly run: (input: Input) => Effect.Effect<Output, unknown, R>;
+  /**
+   * Whether the provider should render this tool with its strict-mode
+   * flag (OpenAI's `strict: true`, etc). Default: true. The framework
+   * never rewrites the schema; if the rendered JSON Schema isn't
+   * compatible, the provider returns an error.
+   */
+  readonly strict?: boolean;
+}
+/**
+ * Provider-agnostic tool descriptor. Each provider maps `inputSchema`
+ * to its own wire field (OpenAI → `parameters`, Anthropic →
+ * `input_schema`). Built from a `Tool` by `Toolkit.toDescriptors`.
+ */
+interface ToolDescriptor {
+  readonly name: string;
+  readonly description: string;
+  readonly inputSchema: Record<string, unknown>;
+  readonly strict?: boolean;
+}
+declare const make: <Name extends string, Input, Output, R = never>(spec: Tool<Name, Input, Output, R>) => Tool<Name, Input, Output, R>;
+interface StreamingTool<Name extends string, Input, Event, Output, R = never> {
+  readonly _kind: "streaming";
+  readonly name: Name;
+  readonly description: string;
+  readonly inputSchema: ToolInputSchema<Input>;
+  readonly run: (input: Input) => Stream.Stream<Event, unknown, R>;
+  readonly finalize: (events: ReadonlyArray<Event>) => Output;
+  readonly strict?: boolean;
+}
+declare const streaming: <Name extends string, Input, Event, Output, R = never>(spec: Omit<StreamingTool<Name, Input, Event, Output, R>, "_kind">) => StreamingTool<Name, Input, Event, Output, R>;
+type AnyStreamingTool = StreamingTool<string, any, any, any, never>;
+type AnyPlainTool = Tool<string, any, any, never>;
+type AnyKindTool = AnyStreamingTool | AnyPlainTool;
+declare const isStreamingTool: (t: AnyKindTool) => t is AnyStreamingTool;
+/**
+ * Render any-kind tools (mixed plain and streaming) to provider-agnostic
+ * descriptors. Mirrors `Toolkit.toDescriptors` but accepts the union type
+ * so a single list can carry both kinds.
+ */
+declare const toDescriptors: (tools: ReadonlyArray<AnyKindTool>) => ReadonlyArray<ToolDescriptor>;
+/**
+ * Decode and validate the JSON arguments of a function_call against the
+ * tool's input schema, run the tool, and serialize the output into a
+ * function_call_output item.
+ */
+declare const execute: <Name extends string, Input, Output, R>(tool: Tool<Name, Input, Output, R>, call: FunctionCall) => Effect.Effect<FunctionCallOutput, ToolError, R>;
+//#endregion
+export { Tool as a, ToolInputSchema as c, fromEffectSchema as d, isStreamingTool as f, toDescriptors as h, StreamingTool as i, Tool_d_exports as l, streaming as m, AnyPlainTool as n, ToolDescriptor as o, make as p, AnyStreamingTool as r, ToolError as s, AnyKindTool as t, execute as u };
+//# sourceMappingURL=Tool-5wxOCuOh.d.mts.map

package/dist/Tool-5wxOCuOh.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Tool-5wxOCuOh.d.mts","names":[],"sources":["../src/tool/Tool.ts"],"mappings":";;;;;;;;;cAE0E,cAAA;;;;;;cAG7D,SAAA,SAAkB,cAAA;;;;;;;;;;KAmBnB,eAAA,oBAAmC,gBAAA,UAA0B,KAAA,IACvE,oBAAA,UAA8B,KAAA;;;AAvB0C;;;cA8B7D,gBAAA,aAA8B,MAAA,CAAO,KAAA,wBAChD,MAAA,EAAQ,CAAA,KACP,CAAA,GAAI,eAAA,CAAgB,CAAA;AAAA,UAIN,IAAA;EAAA,SACN,IAAA,EAAM,IAAA;EAAA,SACN,WAAA;EAAA,SACA,WAAA,EAAa,eAAA,CAAgB,KAAA;EAAA,SAC7B,GAAA,GAAM,KAAA,EAAO,KAAA,KAAU,MAAA,CAAO,MAAA,CAAO,MAAA,WAAiB,CAAA;;;;;;;WAOtD,MAAA;AAAA;;;;;;UAQM,cAAA;EAAA,SACN,IAAA;EAAA,SACA,WAAA;EAAA,SACA,WAAA,EAAa,MAAA;EAAA,SACb,MAAA;AAAA;AAAA,cAGE,IAAA,kDACX,IAAA,EAAM,IAAA,CAAK,IAAA,EAAM,KAAA,EAAO,MAAA,EAAQ,CAAA,MAC/B,IAAA,CAAK,IAAA,EAAM,KAAA,EAAO,MAAA,EAAQ,CAAA;AAAA,UAWZ,aAAA;EAAA,SACN,KAAA;EAAA,SACA,IAAA,EAAM,IAAA;EAAA,SACN,WAAA;EAAA,SACA,WAAA,EAAa,eAAA,CAAgB,KAAA;EAAA,SAC7B,GAAA,GAAM,KAAA,EAAO,KAAA,KAAU,MAAA,CAAO,MAAA,CAAO,KAAA,WAAgB,CAAA;EAAA,SACrD,QAAA,GAAW,MAAA,EAAQ,aAAA,CAAc,KAAA,MAAW,MAAA;EAAA,SAC5C,MAAA;AAAA;AAAA,cAGE,SAAA,yDACX,IAAA,EAAM,IAAA,CAAK,aAAA,CAAc,IAAA,EAAM,KAAA,EAAO,KAAA,EAAO,MAAA,EAAQ,CAAA,gBACpD,aAAA,CAAc,IAAA,EAAM,KAAA,EAAO,KAAA,EAAO,MAAA,EAAQ,CAAA;AAAA,KAEjC,gBAAA,GAAmB,aAAA;AAAA,KACnB,YAAA,GAAe,IAAA;AAAA,KACf,WAAA,GAAc,gBAAA,GAAmB,YAAA;AAAA,cAEhC,eAAA,GAAmB,CAAA,EAAG,WAAA,KAAc,CAAA,IAAK,gBAAA;;;;;;cAQzC,aAAA,GACX,KAAA,EAAO,aAAA,CAAc,WAAA,MACpB,aAAA,CAAc,cAAA;;;;;;cAkBJ,OAAA,0CACX,IAAA,EAAM,IAAA,CAAK,IAAA,EAAM,KAAA,EAAO,MAAA,EAAQ,CAAA,GAChC,IAAA,EAAM,YAAA,KACL,MAAA,CAAO,MAAA,CAAO,kBAAA,EAAoB,SAAA,EAAW,CAAA"}

package/dist/ToolEvent-B2N10hr3.d.mts

@@ -0,0 +1,29 @@
+import { n as ToolResult } from "./Outcome-C2JYknCu.mjs";
+
+//#region src/tool/ToolEvent.d.ts
+type ToolEvent = {
+  readonly _tag: "ApprovalRequested";
+  readonly call_id: string;
+  readonly tool: string;
+  readonly arguments: string;
+} | {
+  readonly _tag: "Intermediate";
+  readonly call_id: string;
+  readonly tool: string;
+  readonly data: unknown;
+} | {
+  readonly _tag: "Output";
+  readonly result: ToolResult;
+};
+declare const isApprovalRequested: (e: ToolEvent) => e is Extract<ToolEvent, {
+  _tag: "ApprovalRequested";
+}>;
+declare const isIntermediate: (e: ToolEvent) => e is Extract<ToolEvent, {
+  _tag: "Intermediate";
+}>;
+declare const isOutput: (e: ToolEvent) => e is Extract<ToolEvent, {
+  _tag: "Output";
+}>;
+//#endregion
+export { isOutput as i, isApprovalRequested as n, isIntermediate as r, ToolEvent as t };
+//# sourceMappingURL=ToolEvent-B2N10hr3.d.mts.map

package/dist/ToolEvent-B2N10hr3.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ToolEvent-B2N10hr3.d.mts","names":[],"sources":["../src/tool/ToolEvent.ts"],"mappings":";;;KAYY,SAAA;EAAA,SAEG,IAAA;EAAA,SACA,OAAA;EAAA,SACA,IAAA;EAAA,SACA,SAAA;AAAA;EAAA,SAGA,IAAA;EAAA,SACA,OAAA;EAAA,SACA,IAAA;EAAA,SACA,IAAA;AAAA;EAAA,SAEA,IAAA;EAAA,SAAyB,MAAA,EAAQ,UAAA;AAAA;AAAA,cAEnC,mBAAA,GACX,CAAA,EAAG,SAAA,KACF,CAAA,IAAK,OAAA,CAAQ,SAAA;EAAa,IAAA;AAAA;AAAA,cAEhB,cAAA,GACX,CAAA,EAAG,SAAA,KACF,CAAA,IAAK,OAAA,CAAQ,SAAA;EAAa,IAAA;AAAA;AAAA,cAEhB,QAAA,GAAY,CAAA,EAAG,SAAA,KAAY,CAAA,IAAK,OAAA,CAAQ,SAAA;EAAa,IAAA;AAAA"}

package/dist/Turn-rlTfuHaQ.d.mts

@@ -0,0 +1,211 @@
+import { g as Message, m as Item, o as FunctionCall, s as FunctionCallOutput, w as Usage, y as Reasoning } from "./Items-D1C2686t.mjs";
+import { i as StructuredFormat, n as JsonParseError, r as StructuredDecodeError } from "./StructuredFormat-B5ueioNr.mjs";
+import { Effect, Schema, Stream } from "effect";
+import * as _$effect_Types0 from "effect/Types";
+import * as _$effect_Cause0 from "effect/Cause";
+
+//#region src/domain/Turn.d.ts
+declare namespace Turn_d_exports {
+  export { Cursor, InteractionEvent, RefusalRejected, Turn, TurnEvent, assistantMessages, cursor, functionCalls, isTurnComplete, reasonings, textDeltas, 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.
+ */
+declare const Turn: Schema.Struct<{
+  readonly items: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"message">;
+    readonly role: Schema.Literals<readonly ["user", "assistant", "system"]>;
+    readonly content: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+      readonly type: Schema.Literal<"input_text">;
+      readonly text: Schema.String;
+    }>, Schema.Struct<{
+      readonly type: Schema.Literal<"input_image">;
+      readonly source: Schema.Union<readonly [Schema.Struct<{
+        readonly _tag: Schema.Literal<"url">;
+        readonly url: Schema.String;
+      }>, Schema.Struct<{
+        readonly _tag: Schema.Literal<"base64">;
+        readonly media_type: Schema.String;
+        readonly data: Schema.String;
+      }>]>;
+    }>, Schema.Struct<{
+      readonly type: Schema.Literal<"output_text">;
+      readonly text: Schema.String;
+      readonly annotations: Schema.optional<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"url_citation">;
+        readonly url: Schema.String;
+        readonly start_index: Schema.Number;
+        readonly end_index: Schema.Number;
+        readonly title: Schema.String;
+      }>, Schema.Struct<{
+        readonly type: Schema.Literal<"file_citation">;
+        readonly file_id: Schema.String;
+        readonly index: Schema.Number;
+      }>, Schema.Struct<{
+        readonly type: Schema.Literal<"container_file_citation">;
+        readonly container_id: Schema.String;
+        readonly file_id: Schema.String;
+        readonly start_index: Schema.Number;
+        readonly end_index: Schema.Number;
+      }>, Schema.Struct<{
+        readonly type: Schema.Literal<"file_path">;
+        readonly file_id: Schema.String;
+        readonly index: Schema.Number;
+      }>]>>>;
+    }>, Schema.Struct<{
+      readonly type: Schema.Literal<"refusal">;
+      readonly text: Schema.String;
+    }>]>>;
+    readonly providerData: Schema.optional<Schema.Unknown>;
+  }>, Schema.Struct<{
+    readonly type: Schema.Literal<"function_call">;
+    readonly call_id: Schema.String;
+    readonly name: Schema.String;
+    readonly arguments: Schema.String;
+    readonly providerData: Schema.optional<Schema.Unknown>;
+  }>, Schema.Struct<{
+    readonly type: Schema.Literal<"function_call_output">;
+    readonly call_id: Schema.String;
+    readonly output: Schema.String;
+    readonly providerData: Schema.optional<Schema.Unknown>;
+  }>, Schema.Struct<{
+    readonly type: Schema.Literal<"reasoning">;
+    readonly id: Schema.optional<Schema.String>;
+    readonly summary: Schema.optional<Schema.String>;
+    readonly signature: Schema.optional<Schema.String>;
+    readonly providerData: Schema.optional<Schema.Unknown>;
+  }>]>>;
+  readonly usage: Schema.Struct<{
+    readonly input_tokens: Schema.optional<Schema.Number>;
+    readonly output_tokens: Schema.optional<Schema.Number>;
+    readonly total_tokens: Schema.optional<Schema.Number>;
+    readonly input_tokens_details: Schema.optional<Schema.Struct<{
+      readonly cached_tokens: Schema.optional<Schema.Number>;
+    }>>;
+    readonly output_tokens_details: Schema.optional<Schema.Struct<{
+      readonly reasoning_tokens: Schema.optional<Schema.Number>;
+    }>>;
+  }>;
+  readonly stop_reason: Schema.Literals<readonly ["stop", "tool_calls", "max_tokens", "refusal", "content_filter", "max_tool_calls"]>;
+}>;
+type Turn = typeof Turn.Type;
+/**
+ * Canonical events emitted while a single turn is being generated. Most
+ * variants are streaming deltas (text, reasoning, tool-call args); the
+ * terminal `turn_complete` carries the assembled `Turn`. Lifecycle members
+ * aren't deltas, hence the union name.
+ */
+type TurnEvent = {
+  readonly type: "text_delta";
+  readonly text: string;
+} | {
+  readonly type: "reasoning_delta";
+  readonly text: string;
+  /**
+   * `trace` is the model's raw chain-of-thought; `summary` is a
+   * model-written summary intended for display. OpenAI Responses emits
+   * both as separate wire events; Anthropic and Gemini only emit
+   * `trace`. Consumers who just want any reasoning text match once;
+   * those who want only summaries filter `kind === "summary"`.
+   */
+  readonly kind: "trace" | "summary";
+}
+/**
+ * The model declined to answer. `text` is the (streamed) explanation.
+ * Distinct from the failure channel: a refusal is normal model output and
+ * the stream still completes with `turn_complete`. OpenAI Responses emits
+ * this; Anthropic surfaces refusals via `stop_reason`, and Gemini collapses
+ * them into `finishReason: SAFETY` - both go without a `refusal_delta`.
+ */
+| {
+  readonly type: "refusal_delta";
+  readonly text: string;
+} | {
+  readonly type: "tool_call_start";
+  readonly call_id: string;
+  readonly name: string;
+} | {
+  readonly type: "tool_call_args_delta";
+  readonly call_id: string;
+  readonly delta: string;
+}
+/**
+ * Mid-stream cumulative usage. Carries the full `Usage` (including cache
+ * token fields when the provider surfaces them) so consumers can drive
+ * live budget / cost tracking without waiting for `turn_complete`.
+ * Anthropic emits this on `message_start` and `message_delta`; other
+ * providers may not emit any `usage_update` and only deliver usage via
+ * `turn_complete.turn.usage`.
+ */
+| {
+  readonly type: "usage_update";
+  readonly usage: Usage;
+} | {
+  readonly type: "turn_complete";
+  readonly turn: Turn;
+};
+/**
+ * What flows out of an agent loop body to its consumer per turn: every
+ * `TurnEvent` the provider emits (including the terminal `turn_complete`
+ * carrying the assembled `Turn`), plus the output of any tool the loop ran.
+ * Both variants carry a `type` discriminator.
+ */
+type InteractionEvent = TurnEvent | FunctionCallOutput;
+declare const isTurnComplete: (d: TurnEvent) => d is Extract<TurnEvent, {
+  type: "turn_complete";
+}>;
+declare const functionCalls: (turn: Turn) => ReadonlyArray<FunctionCall>;
+declare const reasonings: (turn: Turn) => ReadonlyArray<Reasoning>;
+declare const assistantMessages: (turn: Turn) => ReadonlyArray<Message>;
+/**
+ * State stamped with the just-completed `Turn`. Recipes use this as the
+ * intermediate value between "turn lands" and "compute next state": extend
+ * `state.history` with the turn's items, and keep the assembled turn
+ * around for stop-reason / usage / function-call inspection.
+ *
+ * Generic over the recipe's state shape - any record carrying a
+ * `history: ReadonlyArray<Item>` field works.
+ */
+type Cursor<S> = S & {
+  readonly turn: Turn;
+};
+/**
+ * Build a `Cursor<S>` from a state record and the just-completed turn.
+ * Extends `state.history` with `turn.items` and stamps the turn.
+ */
+declare const cursor: <S extends {
+  readonly history: ReadonlyArray<Item>;
+}>(state: S, turn: Turn) => Cursor<S>;
+/**
+ * Project a `TurnEvent` stream onto its `text_delta` payloads. Other
+ * variants are dropped. Composes with `Lines.lines` +
+ * `decodeJsonLines` for prompted-JSONL streaming.
+ */
+declare const textDeltas: <E, R>(self: Stream.Stream<TurnEvent, E, R>) => Stream.Stream<string, E, R>;
+declare const RefusalRejected_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
+  readonly _tag: "RefusalRejected";
+} & Readonly<A>;
+/**
+ * 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.
+ */
+declare class RefusalRejected extends RefusalRejected_base<{
+  readonly turn: Turn;
+}> {}
+/**
+ * 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.
+ */
+declare const toStructured: <A>(turn: Turn, format: StructuredFormat<A>) => Effect.Effect<A, RefusalRejected | JsonParseError | StructuredDecodeError>;
+//#endregion
+export { TurnEvent as a, cursor as c, reasonings as d, textDeltas as f, Turn as i, functionCalls as l, InteractionEvent as n, Turn_d_exports as o, toStructured as p, RefusalRejected as r, assistantMessages as s, Cursor as t, isTurnComplete as u };
+//# sourceMappingURL=Turn-rlTfuHaQ.d.mts.map

package/dist/Turn-rlTfuHaQ.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Turn-rlTfuHaQ.d.mts","names":[],"sources":["../src/domain/Turn.ts"],"mappings":";;;;;;;;;;;;;;;cAmBa,IAAA,EAAI,MAAA,CAAA,MAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAKL,IAAA,UAAc,IAAA,CAAK,IAAA;;;;;;;KAQnB,SAAA;EAAA,SACG,IAAA;EAAA,SAA6B,IAAA;AAAA;EAAA,SAE7B,IAAA;EAAA,SACA,IAAA;;;;;;;;WAQA,IAAA;AAAA;;;;;;;;;WASA,IAAA;EAAA,SAAgC,IAAA;AAAA;EAAA,SAChC,IAAA;EAAA,SAAkC,OAAA;EAAA,SAA0B,IAAA;AAAA;EAAA,SAC5D,IAAA;EAAA,SAAuC,OAAA;EAAA,SAA0B,KAAA;AAAA;;;;;;;;;;WASjE,IAAA;EAAA,SAA+B,KAAA,EAAO,KAAA;AAAA;EAAA,SACtC,IAAA;EAAA,SAAgC,IAAA,EAAM,IAAA;AAAA;;;;;;;KAQzC,gBAAA,GAAmB,SAAA,GAAY,kBAAA;AAAA,cAE9B,cAAA,GAAkB,CAAA,EAAG,SAAA,KAAY,CAAA,IAAK,OAAA,CAAQ,SAAA;EAAa,IAAA;AAAA;AAAA,cAG3D,aAAA,GAAiB,IAAA,EAAM,IAAA,KAAO,aAAA,CAAc,YAAA;AAAA,cAG5C,UAAA,GAAc,IAAA,EAAM,IAAA,KAAO,aAAA,CAAc,SAAA;AAAA,cAGzC,iBAAA,GAAqB,IAAA,EAAM,IAAA,KAAO,aAAA,CAAc,OAAA;;;;;;;;;;KAYjD,MAAA,MAAY,CAAA;EAAA,SAAe,IAAA,EAAM,IAAA;AAAA;;;;;cAMhC,MAAA;EAAA,SAA+B,OAAA,EAAS,aAAA,CAAc,IAAA;AAAA,GACjE,KAAA,EAAO,CAAA,EACP,IAAA,EAAM,IAAA,KACL,MAAA,CAAO,CAAA;;;;;;cAeG,UAAA,SACX,IAAA,EAAM,MAAA,CAAO,MAAA,CAAO,SAAA,EAAW,CAAA,EAAG,CAAA,MACjC,MAAA,CAAO,MAAA,SAAe,CAAA,EAAG,CAAA;AAAA,cAKzB,oBAAA;;;;;;;;cAWU,eAAA,SAAwB,oBAAA;EAAA,SAC1B,IAAA,EAAM,IAAA;AAAA;;;;;;;;;;;cAyBJ,YAAA,MACX,IAAA,EAAM,IAAA,EACN,MAAA,EAAQ,gBAAA,CAAkC,CAAA,MACzC,MAAA,CAAO,MAAA,CACR,CAAA,EACA,eAAA,GAAkB,cAAA,GAAkC,qBAAA"}

package/dist/chunk-CfYAbeIz.mjs

@@ -0,0 +1,13 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+export { __exportAll as t };

package/dist/domain/AiError.d.mts

@@ -0,0 +1,2 @@
+import { a as Cancelled, c as GenerationFailed, d as RateLimited, f as Scope, i as AuthSubtype, l as IncompleteTurn, m as Unavailable, o as ContentFiltered, p as Timeout, r as AuthFailed, s as ContextLengthExceeded, t as AiError, u as InvalidRequest } from "../AiError-CqmYjXyx.mjs";
+export { AiError, AuthFailed, AuthSubtype, Cancelled, ContentFiltered, ContextLengthExceeded, GenerationFailed, IncompleteTurn, InvalidRequest, RateLimited, Scope, Timeout, Unavailable };

package/dist/domain/AiError.mjs

@@ -0,0 +1,40 @@
+import { t as __exportAll } from "../chunk-CfYAbeIz.mjs";
+import { Data } from "effect";
+//#region src/domain/AiError.ts
+var AiError_exports = /* @__PURE__ */ __exportAll({
+	AuthFailed: () => AuthFailed,
+	Cancelled: () => Cancelled,
+	ContentFiltered: () => ContentFiltered,
+	ContextLengthExceeded: () => ContextLengthExceeded,
+	GenerationFailed: () => GenerationFailed,
+	IncompleteTurn: () => IncompleteTurn,
+	InvalidRequest: () => InvalidRequest,
+	RateLimited: () => RateLimited,
+	Timeout: () => Timeout,
+	Unavailable: () => Unavailable
+});
+var RateLimited = class extends Data.TaggedError("RateLimited") {};
+var Unavailable = class extends Data.TaggedError("Unavailable") {};
+var Timeout = class extends Data.TaggedError("Timeout") {};
+var ContentFiltered = class extends Data.TaggedError("ContentFiltered") {};
+var ContextLengthExceeded = class extends Data.TaggedError("ContextLengthExceeded") {};
+var InvalidRequest = class extends Data.TaggedError("InvalidRequest") {};
+var AuthFailed = class extends Data.TaggedError("AuthFailed") {};
+var Cancelled = class extends Data.TaggedError("Cancelled") {};
+/**
+* The model errored mid-generation. Distinct from `Unavailable` (transport
+* problem before generation started) and from `IncompleteTurn` (provider
+* stream ended without a terminal event). The provider's own error message,
+* if any, is on `message`.
+*/
+var GenerationFailed = class extends Data.TaggedError("GenerationFailed") {};
+/**
+* The provider's delta stream ended without a terminal `turn_complete`.
+* Indicates a misbehaving provider or a connection that dropped mid-flight.
+* Non-terminal deltas seen so far have already been emitted downstream.
+*/
+var IncompleteTurn = class extends Data.TaggedError("IncompleteTurn") {};
+//#endregion
+export { AuthFailed, Cancelled, ContentFiltered, ContextLengthExceeded, GenerationFailed, IncompleteTurn, InvalidRequest, RateLimited, Timeout, Unavailable, AiError_exports as t };
+
+//# sourceMappingURL=AiError.mjs.map

package/dist/domain/AiError.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"AiError.mjs","names":[],"sources":["../../src/domain/AiError.ts"],"sourcesContent":["import { Data, Duration } from \"effect\"\n\nexport type Scope = \"rpm\" | \"tpm\" | \"rpd\" | \"tpd\"\n\nexport class RateLimited extends Data.TaggedError(\"RateLimited\")<{\n  provider: string\n  retryAfter?: Duration.Duration\n  scope?: Scope\n  requestId?: string\n  raw: unknown\n}> {}\n\nexport class Unavailable extends Data.TaggedError(\"Unavailable\")<{\n  provider: string\n  retryAfter?: Duration.Duration\n  status?: number\n  requestId?: string\n  raw: unknown\n}> {}\n\nexport class Timeout extends Data.TaggedError(\"Timeout\")<{\n  provider: string\n  requestId?: string\n  raw: unknown\n}> {}\n\nexport class ContentFiltered extends Data.TaggedError(\"ContentFiltered\")<{\n  provider: string\n  reason?: string\n  requestId?: string\n  raw: unknown\n}> {}\n\nexport class ContextLengthExceeded extends Data.TaggedError(\"ContextLengthExceeded\")<{\n  provider: string\n  modelLimit?: number\n  requested?: number\n  raw: unknown\n}> {}\n\nexport class InvalidRequest extends Data.TaggedError(\"InvalidRequest\")<{\n  provider: string\n  param?: string\n  requestId?: string\n  raw: unknown\n}> {}\n\nexport type AuthSubtype = \"auth\" | \"permission\" | \"billing\" | \"quota\"\n\nexport class AuthFailed extends Data.TaggedError(\"AuthFailed\")<{\n  provider: string\n  subtype: AuthSubtype\n  raw: unknown\n}> {}\n\nexport class Cancelled extends Data.TaggedError(\"Cancelled\")<{\n  provider: string\n}> {}\n\n/**\n * The model errored mid-generation. Distinct from `Unavailable` (transport\n * problem before generation started) and from `IncompleteTurn` (provider\n * stream ended without a terminal event). The provider's own error message,\n * if any, is on `message`.\n */\nexport class GenerationFailed extends Data.TaggedError(\"GenerationFailed\")<{\n  provider: string\n  code?: string\n  message?: string\n  requestId?: string\n  raw: unknown\n}> {}\n\n/**\n * The provider's delta stream ended without a terminal `turn_complete`.\n * Indicates a misbehaving provider or a connection that dropped mid-flight.\n * Non-terminal deltas seen so far have already been emitted downstream.\n */\nexport class IncompleteTurn extends Data.TaggedError(\"IncompleteTurn\")<{\n  raw?: unknown\n}> {}\n\nexport type AiError =\n  | RateLimited\n  | Unavailable\n  | Timeout\n  | ContentFiltered\n  | ContextLengthExceeded\n  | InvalidRequest\n  | AuthFailed\n  | Cancelled\n  | IncompleteTurn\n  | GenerationFailed\n"],"mappings":";;;;;;;;;;;;;;;AAIA,IAAa,cAAb,cAAiC,KAAK,YAAY,cAAc,CAM7D;AAEH,IAAa,cAAb,cAAiC,KAAK,YAAY,cAAc,CAM7D;AAEH,IAAa,UAAb,cAA6B,KAAK,YAAY,UAAU,CAIrD;AAEH,IAAa,kBAAb,cAAqC,KAAK,YAAY,kBAAkB,CAKrE;AAEH,IAAa,wBAAb,cAA2C,KAAK,YAAY,wBAAwB,CAKjF;AAEH,IAAa,iBAAb,cAAoC,KAAK,YAAY,iBAAiB,CAKnE;AAIH,IAAa,aAAb,cAAgC,KAAK,YAAY,aAAa,CAI3D;AAEH,IAAa,YAAb,cAA+B,KAAK,YAAY,YAAY,CAEzD;;;;;;;AAQH,IAAa,mBAAb,cAAsC,KAAK,YAAY,mBAAmB,CAMvE;;;;;;AAOH,IAAa,iBAAb,cAAoC,KAAK,YAAY,iBAAiB,CAEnE"}

package/dist/domain/Items.d.mts

@@ -0,0 +1,2 @@
+import { A as isFunctionCall, B as isUrlCitation, C as UrlCitation, D as isContainerFileCitation, E as functionCallOutput, F as isInputText, H as userText, I as isMessage, L as isOutputText, M as isImageBase64Source, N as isImageUrlSource, O as isFileCitation, P as isInputImage, R as isReasoning, S as StopReason, T as assistantText, V as systemText, _ as OutputText, a as FilePath, b as Refusal, c as ImageBase64Source, d as InputImage, f as InputText, g as Message, i as FileCitation, j as isFunctionCallOutput, k as isFilePath, l as ImageSource, m as Item, n as ContainerFileCitation, o as FunctionCall, p as InputTokensDetails, r as ContentBlock, s as FunctionCallOutput, t as Annotation, u as ImageUrlSource, v as OutputTokensDetails, w as Usage, x as Role, y as Reasoning, z as isRefusal } from "../Items-D1C2686t.mjs";
+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, userText };