@effect-uai/core 0.5.0 → 0.5.2

package/dist/{Items-DqbaJoz7.d.mts → Items-BH8xUkoR.d.mts}

@@ -74,8 +74,8 @@ declare const Annotation: Schema.Union<readonly [Schema.Struct<{
 }>]>;
 type Annotation = typeof Annotation.Type;
 declare const isUrlCitation: <I>(input: I) => input is I & {
-  readonly type: "url_citation";
   readonly url: string;
+  readonly type: "url_citation";
   readonly start_index: number;
   readonly end_index: number;
   readonly title: string;
@@ -309,8 +309,8 @@ declare const isOutputText: <I>(input: I) => input is I & {
   readonly type: "output_text";
   readonly text: string;
   readonly annotations?: readonly ({
-    readonly type: "url_citation";
     readonly url: string;
+    readonly type: "url_citation";
     readonly start_index: number;
     readonly end_index: number;
     readonly title: string;
@@ -346,8 +346,8 @@ declare const isMessage: <I>(input: I) => input is I & {
     readonly type: "output_text";
     readonly text: string;
     readonly annotations?: readonly ({
-      readonly type: "url_citation";
       readonly url: string;
+      readonly type: "url_citation";
       readonly start_index: number;
       readonly end_index: number;
       readonly title: string;
@@ -374,15 +374,15 @@ declare const isMessage: <I>(input: I) => input is I & {
   readonly providerData?: unknown;
 };
 declare const isFunctionCall: <I>(input: I) => input is I & {
-  readonly call_id: string;
   readonly type: "function_call";
+  readonly call_id: string;
   readonly name: string;
   readonly arguments: string;
   readonly providerData?: unknown;
 };
 declare const isFunctionCallOutput: <I>(input: I) => input is I & {
-  readonly call_id: string;
   readonly type: "function_call_output";
+  readonly call_id: string;
   readonly output: string;
   readonly providerData?: unknown;
 };
@@ -421,4 +421,4 @@ declare const assistantText: (text: string) => Message;
 declare const functionCallOutput: (call_id: string, output: string) => FunctionCallOutput;
 //#endregion
 export { isInputText as A, functionCallOutput as C, isFunctionCall as D, isFilePath as E, isUrlCitation as F, systemText as I, userText as L, isOutputText as M, isReasoning as N, isFunctionCallOutput as O, isRefusal as P, assistantText as S, isFileCitation as T, Refusal as _, FilePath as a, UrlCitation as b, InputImage as c, Item as d, Items_d_exports as f, Reasoning as g, OutputTokensDetails as h, FileCitation as i, isMessage as j, isInputImage as k, InputText as l, OutputText as m, ContainerFileCitation as n, FunctionCall as o, Message as p, ContentBlock as r, FunctionCallOutput as s, Annotation as t, InputTokensDetails as u, Role as v, isContainerFileCitation as w, Usage as x, StopReason as y };
-//# sourceMappingURL=Items-DqbaJoz7.d.mts.map
+//# sourceMappingURL=Items-BH8xUkoR.d.mts.map

package/dist/{Items-DqbaJoz7.d.mts.map → Items-BH8xUkoR.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"Items-DqbaJoz7.d.mts","names":[],"sources":["../src/domain/Items.ts"],"mappings":";;;;;;;cAOa,SAAA,EAAS,MAAA,CAAA,MAAA;EAAA;;;KAIV,SAAA,UAAmB,SAAA,CAAU,IAAA;;;;;;;;;cAU5B,UAAA,EAAU,MAAA,CAAA,MAAA;EAAA;;;KAIX,UAAA,UAAoB,UAAA,CAAW,IAAA;AAAA,cAQ9B,WAAA,EAAW,MAAA,CAAA,MAAA;EAAA;;;;;;KAOZ,WAAA,UAAqB,WAAA,CAAY,IAAA;AAAA,cAEhC,YAAA,EAAY,MAAA,CAAA,MAAA;EAAA;;;;KAKb,YAAA,UAAsB,YAAA,CAAa,IAAA;AAAA,cAElC,qBAAA,EAAqB,MAAA,CAAA,MAAA;EAAA;;;;;;KAOtB,qBAAA,UAA+B,qBAAA,CAAsB,IAAA;AAAA,cAEpD,QAAA,EAAQ,MAAA,CAAA,MAAA;EAAA;;;;KAKT,QAAA,UAAkB,QAAA,CAAS,IAAA;AAAA,cAE1B,UAAA,EAAU,MAAA,CAAA,KAAA,WAAA,MAAA,CAAA,MAAA;EAAA;;;;;;;;;;;;;;;;;;;;KACX,UAAA,UAAoB,UAAA,CAAW,IAAA;AAAA,cAE9B,aAAA,MAAa,KAAA,EAAA,CAAA,KAAA,KAAA,IAAA,CAAA;EAAA;;;;;;cACb,cAAA,MAAc,KAAA,EAAA,CAAA,KAAA,KAAA,IAAA,CAAA;EAAA;;;;cACd,uBAAA,MAAuB,KAAA,EAAA,CAAA,KAAA,KAAA,IAAA,CAAA;EAAA;;;;;;cACvB,UAAA,MAAU,KAAA,EAAA,CAAA,KAAA,KAAA,IAAA,CAAA;EAAA;;;;cAEV,UAAA,EAAU,MAAA,CAAA,MAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;KAKX,UAAA,UAAoB,UAAA,CAAW,IAAA;;AAtC3C;;;;;cA8Ca,OAAA,EAAO,MAAA,CAAA,MAAA;EAAA;;;KAIR,OAAA,UAAiB,OAAA,CAAQ,IAAA;AAAA,cAExB,YAAA,EAAY,MAAA,CAAA,KAAA,WAAA,MAAA,CAAA,MAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KACb,YAAA,UAAsB,YAAA,CAAa,IAAA;AAAA,cAElC,IAAA,EAAI,MAAA,CAAA,QAAA;AAAA,KACL,IAAA,UAAc,IAAA,CAAK,IAAA;AAAA,cAelB,OAAA,EAAO,MAAA,CAAA,MAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAMR,OAAA,UAAiB,OAAA,CAAQ,IAAA;AAAA,cAExB,YAAA,EAAY,MAAA,CAAA,MAAA;EAAA;;;;;;KAQb,YAAA,UAAsB,YAAA,CAAa,IAAA;AAAA,cAElC,kBAAA,EAAkB,MAAA,CAAA,MAAA;EAAA;;;;;KAMnB,kBAAA,UAA4B,kBAAA,CAAmB,IAAA;;;;;;;cAQ9C,SAAA,EAAS,MAAA,CAAA,MAAA;EAAA;;;;;;KAOV,SAAA,UAAmB,SAAA,CAAU,IAAA;AAAA,cAE5B,IAAA,EAAI,MAAA,CAAA,KAAA,WAAA,MAAA,CAAA,MAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KACL,IAAA,UAAc,IAAA,CAAK,IAAA;AAAA,cAMlB,WAAA,MAAW,KAAA,EAAA,CAAA,KAAA,KAAA,IAAA,CAAA;EAAA;;;cACX,YAAA,MAAY,KAAA,EAAA,CAAA,KAAA,KAAA,IAAA,CAAA;EAAA;;;cACZ,YAAA,MAAY,KAAA,EAAA,CAAA,KAAA,KAAA,IAAA,CAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;cACZ,SAAA,MAAS,KAAA,EAAA,CAAA,KAAA,KAAA,IAAA,CAAA;EAAA;;;cAET,SAAA,MAAS,KAAA,EAAA,CAAA,KAAA,KAAA,IAAA,CAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cACT,cAAA,MAAc,KAAA,EAAA,CAAA,KAAA,KAAA,IAAA,CAAA;EAAA;;;;;;cACd,oBAAA,MAAoB,KAAA,EAAA,CAAA,KAAA,KAAA,IAAA,CAAA;EAAA;;;;;cACpB,WAAA,MAAW,KAAA,EAAA,CAAA,KAAA,KAAA,IAAA,CAAA;EAAA;;;;;;cAMX,kBAAA,EAAkB,MAAA,CAAA,MAAA;EAAA;;KAGnB,kBAAA,UAA4B,kBAAA,CAAmB,IAAA;AAAA,cAE9C,mBAAA,EAAmB,MAAA,CAAA,MAAA;EAAA;;KAGpB,mBAAA,UAA6B,mBAAA,CAAoB,IAAA;AAAA,cAEhD,KAAA,EAAK,MAAA,CAAA,MAAA;EAAA;;;;;;;;;;KAON,KAAA,UAAe,KAAA,CAAM,IAAA;AAAA,cAEpB,UAAA,EAAU,MAAA,CAAA,QAAA;AAAA,KAUX,UAAA,UAAoB,UAAA,CAAW,IAAA;AAAA,cAM9B,QAAA,GAAY,IAAA,aAAe,OAAA;AAAA,cAM3B,UAAA,GAAc,IAAA,aAAe,OAAA;AAAA,cAM7B,aAAA,GAAiB,IAAA,aAAe,OAAA;AAAA,cAMhC,kBAAA,GAAsB,OAAA,UAAiB,MAAA,aAAiB,kBAAA"}
+{"version":3,"file":"Items-BH8xUkoR.d.mts","names":[],"sources":["../src/domain/Items.ts"],"mappings":"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"}

package/dist/{Tool-Y0__Py1H.d.mts → Tool-87ViKCCO.d.mts}

@@ -1,4 +1,4 @@
-import { o as FunctionCall, s as FunctionCallOutput } from "./Items-DqbaJoz7.mjs";
+import { o as FunctionCall, s as FunctionCallOutput } from "./Items-BH8xUkoR.mjs";
 import { Effect, Schema, Stream } from "effect";
 import * as _$effect_Cause0 from "effect/Cause";
 import { StandardJSONSchemaV1, StandardSchemaV1 } from "@standard-schema/spec";
@@ -99,4 +99,4 @@ declare const toDescriptors: <R>(tools: ReadonlyArray<AnyKindTool<R>>) => Readon
 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, fromStandardSchema as f, toDescriptors as g, streaming as h, StreamingTool as i, Tool_d_exports as l, make as m, AnyPlainTool as n, ToolDescriptor as o, isStreamingTool as p, AnyStreamingTool as r, ToolError as s, AnyKindTool as t, execute as u };
-//# sourceMappingURL=Tool-Y0__Py1H.d.mts.map
+//# sourceMappingURL=Tool-87ViKCCO.d.mts.map

package/dist/{Tool-Y0__Py1H.d.mts.map → Tool-87ViKCCO.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"Tool-Y0__Py1H.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;;;;;;;;;;;;;;;;cAmBV,kBAAA,aAAgC,gBAAA,GAAmB,oBAAA,EAC9D,MAAA,EAAQ,CAAA,KACP,CAAA,GAAI,eAAA,CAAgB,gBAAA,CAAiB,WAAA,CAAY,CAAA;AAAA,KAGxC,IAAA;EAAA,SACD,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;;;;;AAhEX;KAwEY,cAAA;EAAA,SACD,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,KAWjB,aAAA;EAAA,SACD,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,YAA4B,aAAA,wBAAqC,CAAA;AAAA,KACjE,YAAA,YAAwB,IAAA,mBAAuB,CAAA;AAAA,KAC/C,WAAA,YAAuB,gBAAA,CAAiB,CAAA,IAAK,YAAA,CAAa,CAAA;AAAA,cAEzD,eAAA,MAAsB,CAAA,EAAG,WAAA,CAAY,CAAA,MAAK,CAAA,IAAK,gBAAA,CAAiB,CAAA;;;;;;cAQhE,aAAA,MACX,KAAA,EAAO,aAAA,CAAc,WAAA,CAAY,CAAA,OAChC,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"}
+{"version":3,"file":"Tool-87ViKCCO.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;;;;;;;;;;;;;;;;cAmBV,kBAAA,aAAgC,gBAAA,GAAmB,oBAAA,EAC9D,MAAA,EAAQ,CAAA,KACP,CAAA,GAAI,eAAA,CAAgB,gBAAA,CAAiB,WAAA,CAAY,CAAA;AAAA,KAGxC,IAAA;EAAA,SACD,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;;;;;AAhEX;KAwEY,cAAA;EAAA,SACD,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,KAWjB,aAAA;EAAA,SACD,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,YAA4B,aAAA,wBAAqC,CAAA;AAAA,KACjE,YAAA,YAAwB,IAAA,mBAAuB,CAAA;AAAA,KAC/C,WAAA,YAAuB,gBAAA,CAAiB,CAAA,IAAK,YAAA,CAAa,CAAA;AAAA,cAEzD,eAAA,MAAsB,CAAA,EAAG,WAAA,CAAY,CAAA,MAAK,CAAA,IAAK,gBAAA,CAAiB,CAAA;;;;;;cAQhE,aAAA,MACX,KAAA,EAAO,aAAA,CAAc,WAAA,CAAY,CAAA,OAChC,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/{Turn-ChbL2foc.d.mts → Turn-0CwCAyVe.d.mts}

@@ -1,5 +1,5 @@
 import { i as ImageSource } from "./Image-HNmMpMTh.mjs";
-import { d as Item, g as Reasoning, o as FunctionCall, p as Message, s as FunctionCallOutput, x as Usage } from "./Items-DqbaJoz7.mjs";
+import { d as Item, g as Reasoning, o as FunctionCall, p as Message, s as FunctionCallOutput, x as Usage } from "./Items-BH8xUkoR.mjs";
 import { i as StructuredFormat, n as JsonParseError, r as StructuredDecodeError } from "./StructuredFormat-BbN4dosH.mjs";
 import { Data, Effect, Schema, Stream } from "effect";
 import * as _$effect_Types0 from "effect/Types";
@@ -385,4 +385,4 @@ declare class RefusalRejected extends RefusalRejected_base<{
 declare const toStructured: <A>(turn: Turn, format: StructuredFormat<A>) => Effect.Effect<A, RefusalRejected | JsonParseError | StructuredDecodeError>;
 //#endregion
 export { Turn_d_exports as a, assistantText as c, isTurnComplete as d, reasonings as f, TurnEvent as i, assistantTexts as l, toStructured as m, RefusalRejected as n, appendTurn as o, textDeltas as p, Turn as r, assistantMessages as s, InteractionEvent as t, functionCalls as u };
-//# sourceMappingURL=Turn-ChbL2foc.d.mts.map
+//# sourceMappingURL=Turn-0CwCAyVe.d.mts.map

package/dist/{Turn-ChbL2foc.d.mts.map → Turn-0CwCAyVe.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"Turn-ChbL2foc.d.mts","names":[],"sources":["../src/domain/Turn.ts"],"mappings":";;;;;;;;;;;;;;;;;cAmBa,IAAA,EAAI,MAAA,CAAA,MAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAKL,IAAA,UAAc,IAAA,CAAK,IAAA;;;;;;;;;;;;;;;;;;;;KAqBnB,SAAA,GAAY,IAAA,CAAK,UAAA;EAC3B,SAAA;IAAA,SAAsB,IAAA;EAAA;EACtB,cAAA;IAAA,SAA2B,IAAA;IAAA,SAAuB,IAAA;EAAA;EAClD,YAAA;IAAA,SAAyB,IAAA;EAAA;EACzB,aAAA;IAAA,SAA0B,OAAA;IAAA,SAA0B,IAAA;EAAA;EACpD,iBAAA;IAAA,SAA8B,OAAA;IAAA,SAA0B,KAAA;EAAA;EACxD,WAAA;IAAA,SAAwB,KAAA,EAAO,KAAA;EAAA;EAC/B,YAAA;IAAA,SAAyB,IAAA,EAAM,IAAA;EAAA;AAAA;AAAA,cAGpB,SAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;oBAJoB,KAAA;EAAA;EAAA;;mBACA,IAAA;EAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBADA,KAAA;EAAA;IAAA;;;mBACA,IAAA;EAAA;IAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBADA,KAAA;MAAA;MAAA;;uBACA,IAAA;MAAA;IAAA;;;;;;;;;;;;;;;;;;;;sBADA,KAAA;IAAA;MAAA;qBACA,IAAA;IAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;wBADA,KAAA;MAAA;MAAA;;uBACA,IAAA;MAAA;IAAA;;;;;;;;;;;;;;;;;;;;sBADA,KAAA;IAAA;MAAA;qBACA,IAAA;IAAA;;;;;;;;;KAWrB,gBAAA,GAAmB,SAAA,GAAY,kBAAA;AAAA,cAE9B,cAAA,GAAc,CAAA,cAAA,CAAA;EAAA;iBAbM,IAAA;AAAA;AAAA,cAepB,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;;;;;;;;cAUhD,cAAA,GAAkB,IAAA,EAAM,IAAA,KAAO,aAAA;;;;;;cAW/B,aAAA,GAAiB,IAAA,EAAM,IAAA;;;;;AAjDpC;cAwDa,UAAA;EAAA,SAAmC,OAAA,EAAS,aAAA,CAAc,IAAA;AAAA,GACrE,KAAA,EAAO,CAAA,EACP,IAAA,EAAM,IAAA,EACN,KAAA,GAAO,aAAA,CAAc,IAAA,MACpB,CAAA;;;;;;cAcU,UAAA,SACX,IAAA,EAAM,MAAA,CAAO,MAAA,CAAO,SAAA,EAAW,CAAA,EAAG,CAAA,MACjC,MAAA,CAAO,MAAA,SAAe,CAAA,EAAG,CAAA;AAAA,cAGzB,oBAAA;;;;;;;;cAWU,eAAA,SAAwB,oBAAA;EAAA,SAC1B,IAAA,EAAM,IAAA;AAAA;;;;;;;;;;AAjFjB;cA0Ga,YAAA,MACX,IAAA,EAAM,IAAA,EACN,MAAA,EAAQ,gBAAA,CAAkC,CAAA,MACzC,MAAA,CAAO,MAAA,CACR,CAAA,EACA,eAAA,GAAkB,cAAA,GAAkC,qBAAA"}
+{"version":3,"file":"Turn-0CwCAyVe.d.mts","names":[],"sources":["../src/domain/Turn.ts"],"mappings":";;;;;;;;;;;;;;;;;cAmBa,IAAA,EAAI,MAAA,CAAA,MAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAKL,IAAA,UAAc,IAAA,CAAK,IAAA;;;;;;;;;;;;;;;;;;;;KAqBnB,SAAA,GAAY,IAAA,CAAK,UAAA;EAC3B,SAAA;IAAA,SAAsB,IAAA;EAAA;EACtB,cAAA;IAAA,SAA2B,IAAA;IAAA,SAAuB,IAAA;EAAA;EAClD,YAAA;IAAA,SAAyB,IAAA;EAAA;EACzB,aAAA;IAAA,SAA0B,OAAA;IAAA,SAA0B,IAAA;EAAA;EACpD,iBAAA;IAAA,SAA8B,OAAA;IAAA,SAA0B,KAAA;EAAA;EACxD,WAAA;IAAA,SAAwB,KAAA,EAAO,KAAA;EAAA;EAC/B,YAAA;IAAA,SAAyB,IAAA,EAAM,IAAA;EAAA;AAAA;AAAA,cAGpB,SAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;oBAJoB,KAAA;EAAA;EAAA;;mBACA,IAAA;EAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBADA,KAAA;EAAA;IAAA;;;mBACA,IAAA;EAAA;IAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBADA,KAAA;MAAA;MAAA;;uBACA,IAAA;MAAA;IAAA;;;;;;;;;;;;;;;;;;;;sBADA,KAAA;IAAA;MAAA;qBACA,IAAA;IAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;wBADA,KAAA;MAAA;MAAA;;uBACA,IAAA;MAAA;IAAA;;;;;;;;;;;;;;;;;;;;sBADA,KAAA;IAAA;MAAA;qBACA,IAAA;IAAA;;;;;;;;;KAWrB,gBAAA,GAAmB,SAAA,GAAY,kBAAA;AAAA,cAE9B,cAAA,GAAc,CAAA,cAAA,CAAA;EAAA;iBAbM,IAAA;AAAA;AAAA,cAepB,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;;;;;;;;cAUhD,cAAA,GAAkB,IAAA,EAAM,IAAA,KAAO,aAAA;;;;;;cAW/B,aAAA,GAAiB,IAAA,EAAM,IAAA;;;;;AAjDpC;cAwDa,UAAA;EAAA,SAAmC,OAAA,EAAS,aAAA,CAAc,IAAA;AAAA,GACrE,KAAA,EAAO,CAAA,EACP,IAAA,EAAM,IAAA,EACN,KAAA,GAAO,aAAA,CAAc,IAAA,MACpB,CAAA;;;;;;cAcU,UAAA,SACX,IAAA,EAAM,MAAA,CAAO,MAAA,CAAO,SAAA,EAAW,CAAA,EAAG,CAAA,MACjC,MAAA,CAAO,MAAA,SAAe,CAAA,EAAG,CAAA;AAAA,cAGzB,oBAAA;;;;;;;;cAWU,eAAA,SAAwB,oBAAA;EAAA,SAC1B,IAAA,EAAM,IAAA;AAAA;;;;;;;;;;AAjFjB;cA0Ga,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/domain/Items.d.mts

@@ -1,2 +1,2 @@
-import { A as isInputText, C as functionCallOutput, D as isFunctionCall, E as isFilePath, F as isUrlCitation, I as systemText, L as userText, M as isOutputText, N as isReasoning, O as isFunctionCallOutput, P as isRefusal, S as assistantText, T as isFileCitation, _ as Refusal, a as FilePath, b as UrlCitation, c as InputImage, d as Item, g as Reasoning, h as OutputTokensDetails, i as FileCitation, j as isMessage, k as isInputImage, l as InputText, m as OutputText, n as ContainerFileCitation, o as FunctionCall, p as Message, r as ContentBlock, s as FunctionCallOutput, t as Annotation, u as InputTokensDetails, v as Role, w as isContainerFileCitation, x as Usage, y as StopReason } from "../Items-DqbaJoz7.mjs";
+import { A as isInputText, C as functionCallOutput, D as isFunctionCall, E as isFilePath, F as isUrlCitation, I as systemText, L as userText, M as isOutputText, N as isReasoning, O as isFunctionCallOutput, P as isRefusal, S as assistantText, T as isFileCitation, _ as Refusal, a as FilePath, b as UrlCitation, c as InputImage, d as Item, g as Reasoning, h as OutputTokensDetails, i as FileCitation, j as isMessage, k as isInputImage, l as InputText, m as OutputText, n as ContainerFileCitation, o as FunctionCall, p as Message, r as ContentBlock, s as FunctionCallOutput, t as Annotation, u as InputTokensDetails, v as Role, w as isContainerFileCitation, x as Usage, y as StopReason } from "../Items-BH8xUkoR.mjs";
 export { Annotation, ContainerFileCitation, ContentBlock, FileCitation, FilePath, FunctionCall, FunctionCallOutput, InputImage, InputText, InputTokensDetails, Item, Message, OutputText, OutputTokensDetails, Reasoning, Refusal, Role, StopReason, UrlCitation, Usage, assistantText, functionCallOutput, isContainerFileCitation, isFileCitation, isFilePath, isFunctionCall, isFunctionCallOutput, isInputImage, isInputText, isMessage, isOutputText, isReasoning, isRefusal, isUrlCitation, systemText, userText };

package/dist/domain/Turn.d.mts

@@ -1,2 +1,2 @@
-import { c as assistantText, d as isTurnComplete, f as reasonings, i as TurnEvent, l as assistantTexts, m as toStructured, n as RefusalRejected, o as appendTurn, p as textDeltas, r as Turn, s as assistantMessages, t as InteractionEvent, u as functionCalls } from "../Turn-ChbL2foc.mjs";
+import { c as assistantText, d as isTurnComplete, f as reasonings, i as TurnEvent, l as assistantTexts, m as toStructured, n as RefusalRejected, o as appendTurn, p as textDeltas, r as Turn, s as assistantMessages, t as InteractionEvent, u as functionCalls } from "../Turn-0CwCAyVe.mjs";
 export { InteractionEvent, RefusalRejected, Turn, TurnEvent, appendTurn, assistantMessages, assistantText, assistantTexts, functionCalls, isTurnComplete, reasonings, textDeltas, toStructured };

package/dist/index.d.mts

@@ -2,20 +2,21 @@ import { n as AiError_d_exports } from "./AiError-CAX_48RU.mjs";
 import { a as Media_d_exports } from "./Media-D_CpcM1Z.mjs";
 import { o as Audio_d_exports } from "./Audio-BfCTGnH3.mjs";
 import { o as Image_d_exports } from "./Image-HNmMpMTh.mjs";
-import { f as Items_d_exports } from "./Items-DqbaJoz7.mjs";
+import { f as Items_d_exports } from "./Items-BH8xUkoR.mjs";
 import { t as Music_d_exports } from "./domain/Music.mjs";
 import { t as Transcript_d_exports } from "./domain/Transcript.mjs";
 import { a as StructuredFormat_d_exports } from "./StructuredFormat-BbN4dosH.mjs";
-import { a as Turn_d_exports } from "./Turn-ChbL2foc.mjs";
+import { a as Turn_d_exports } from "./Turn-0CwCAyVe.mjs";
 import { t as Embedding_d_exports } from "./embedding-model/Embedding.mjs";
 import { t as EmbeddingModel_d_exports } from "./embedding-model/EmbeddingModel.mjs";
-import { l as Tool_d_exports } from "./Tool-Y0__Py1H.mjs";
+import { l as Tool_d_exports } from "./Tool-87ViKCCO.mjs";
 import { t as LanguageModel_d_exports } from "./language-model/LanguageModel.mjs";
 import { t as MusicGenerator_d_exports } from "./music-generator/MusicGenerator.mjs";
 import { t as SpeechSynthesizer_d_exports } from "./speech-synthesizer/SpeechSynthesizer.mjs";
 import { t as Transcriber_d_exports } from "./transcriber/Transcriber.mjs";
 import { t as Vector_d_exports } from "./math/Vector.mjs";
 import { t as Loop_d_exports } from "./loop/Loop.mjs";
+import { t as Retry_d_exports } from "./retry/Retry.mjs";
 import { t as Outcome_d_exports } from "./tool/Outcome.mjs";
 import { t as ToolEvent_d_exports } from "./tool/ToolEvent.mjs";
 import { t as Toolkit_d_exports } from "./tool/Toolkit.mjs";
@@ -25,4 +26,4 @@ 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, Audio_d_exports as Audio, Embedding_d_exports as Embedding, EmbeddingModel_d_exports as EmbeddingModel, HistoryCheck_d_exports as HistoryCheck, Image_d_exports as Image, 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, Media_d_exports as Media, Metrics_d_exports as Metrics, Music_d_exports as Music, MusicGenerator_d_exports as MusicGenerator, Outcome_d_exports as Outcome, Resolvers_d_exports as Resolvers, SSE_d_exports as SSE, SpeechSynthesizer_d_exports as SpeechSynthesizer, StructuredFormat_d_exports as StructuredFormat, Tool_d_exports as Tool, ToolEvent_d_exports as ToolEvent, Toolkit_d_exports as Toolkit, Transcriber_d_exports as Transcriber, Transcript_d_exports as Transcript, Turn_d_exports as Turn, Vector_d_exports as Vector };
+export { AiError_d_exports as AiError, Audio_d_exports as Audio, Embedding_d_exports as Embedding, EmbeddingModel_d_exports as EmbeddingModel, HistoryCheck_d_exports as HistoryCheck, Image_d_exports as Image, 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, Media_d_exports as Media, Metrics_d_exports as Metrics, Music_d_exports as Music, MusicGenerator_d_exports as MusicGenerator, Outcome_d_exports as Outcome, Resolvers_d_exports as Resolvers, Retry_d_exports as Retry, SSE_d_exports as SSE, SpeechSynthesizer_d_exports as SpeechSynthesizer, StructuredFormat_d_exports as StructuredFormat, Tool_d_exports as Tool, ToolEvent_d_exports as ToolEvent, Toolkit_d_exports as Toolkit, Transcriber_d_exports as Transcriber, Transcript_d_exports as Transcript, Turn_d_exports as Turn, Vector_d_exports as Vector };

package/dist/index.mjs

@@ -15,6 +15,7 @@ import { t as SpeechSynthesizer_exports } from "./speech-synthesizer/SpeechSynth
 import { t as Transcriber_exports } from "./transcriber/Transcriber.mjs";
 import { t as Vector_exports } from "./math/Vector.mjs";
 import { t as Loop_exports } from "./loop/Loop.mjs";
+import { t as Retry_exports } from "./retry/Retry.mjs";
 import { t as Tool_exports } from "./tool/Tool.mjs";
 import { t as Outcome_exports } from "./tool/Outcome.mjs";
 import { t as ToolEvent_exports } from "./tool/ToolEvent.mjs";
@@ -25,4 +26,4 @@ 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, Audio_exports as Audio, Embedding_exports as Embedding, EmbeddingModel_exports as EmbeddingModel, HistoryCheck_exports as HistoryCheck, Image_exports as Image, Items_exports as Items, JSONL_exports as JSONL, LanguageModel_exports as LanguageModel, Lines_exports as Lines, Loop_exports as Loop, Media_exports as Media, Metrics_exports as Metrics, Music_exports as Music, MusicGenerator_exports as MusicGenerator, Outcome_exports as Outcome, Resolvers_exports as Resolvers, SSE_exports as SSE, SpeechSynthesizer_exports as SpeechSynthesizer, StructuredFormat_exports as StructuredFormat, Tool_exports as Tool, ToolEvent_exports as ToolEvent, Toolkit_exports as Toolkit, Transcriber_exports as Transcriber, Transcript_exports as Transcript, Turn_exports as Turn, Vector_exports as Vector };
+export { AiError_exports as AiError, Audio_exports as Audio, Embedding_exports as Embedding, EmbeddingModel_exports as EmbeddingModel, HistoryCheck_exports as HistoryCheck, Image_exports as Image, Items_exports as Items, JSONL_exports as JSONL, LanguageModel_exports as LanguageModel, Lines_exports as Lines, Loop_exports as Loop, Media_exports as Media, Metrics_exports as Metrics, Music_exports as Music, MusicGenerator_exports as MusicGenerator, Outcome_exports as Outcome, Resolvers_exports as Resolvers, Retry_exports as Retry, SSE_exports as SSE, SpeechSynthesizer_exports as SpeechSynthesizer, StructuredFormat_exports as StructuredFormat, Tool_exports as Tool, ToolEvent_exports as ToolEvent, Toolkit_exports as Toolkit, Transcriber_exports as Transcriber, Transcript_exports as Transcript, Turn_exports as Turn, Vector_exports as Vector };

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

@@ -1,15 +1,13 @@
-import { d as RateLimited, l as IncompleteTurn, m as Unavailable, p as Timeout, t as AiError } from "../AiError-CAX_48RU.mjs";
-import { d as Item } from "../Items-DqbaJoz7.mjs";
+import { t as AiError } from "../AiError-CAX_48RU.mjs";
+import { d as Item } from "../Items-BH8xUkoR.mjs";
 import { i as StructuredFormat } from "../StructuredFormat-BbN4dosH.mjs";
-import { i as TurnEvent, r as Turn } from "../Turn-ChbL2foc.mjs";
-import { o as ToolDescriptor } from "../Tool-Y0__Py1H.mjs";
-import { Context, Effect, Schedule, Stream } from "effect";
-import * as _$effect_Types0 from "effect/Types";
-import * as _$effect_Cause0 from "effect/Cause";
+import { i as TurnEvent, r as Turn } from "../Turn-0CwCAyVe.mjs";
+import { o as ToolDescriptor } from "../Tool-87ViKCCO.mjs";
+import { Context, Effect, Stream } from "effect";
 
 //#region src/language-model/LanguageModel.d.ts
 declare namespace LanguageModel_d_exports {
-  export { CommonRequest, LanguageModel, LanguageModelService, Retryable, retry, streamTurn, turn };
+  export { CommonRequest, LanguageModel, LanguageModelService, streamTurn, turn, turnFromStream };
 }
 /**
  * Cross-provider request shape. Every call carries its own `history` and
@@ -42,6 +40,16 @@ type CommonRequest = {
 };
 type LanguageModelService = {
   readonly streamTurn: (request: CommonRequest) => Stream.Stream<TurnEvent, AiError>;
+  /**
+   * Drain a single turn and return the assembled `Turn` from the
+   * terminal `TurnComplete` event. Fails with `IncompleteTurn` if the
+   * stream ends without one.
+   *
+   * Most providers derive this from `streamTurn` via
+   * {@link turnFromStream}; providers with a native non-streaming
+   * endpoint may override with a cheaper direct call.
+   */
+  readonly turn: (request: CommonRequest) => Effect.Effect<Turn, AiError>;
 };
 declare const LanguageModel_base: Context.ServiceClass<LanguageModel, "@betalyra/effect-uai/LanguageModel", LanguageModelService>;
 declare class LanguageModel extends LanguageModel_base {}
@@ -50,25 +58,19 @@ declare class LanguageModel extends LanguageModel_base {}
  */
 declare const streamTurn: (request: CommonRequest) => Stream.Stream<TurnEvent, AiError, LanguageModel>;
 /**
- * Drain `streamTurn` and return the assembled `Turn` from the terminal
- * `TurnComplete` event. Fails with `IncompleteTurn` if the stream ends
- * without one. Derived from `streamTurn`; providers get it for free.
+ * Drain a single turn and return the assembled `Turn`. Delegates to the
+ * service's `turn` method — providers with a native complete endpoint
+ * can override; the rest get the default streamTurn-drain via
+ * {@link turnFromStream}.
  */
-declare const turn: (request: CommonRequest) => Effect.Effect<Turn, AiError | IncompleteTurn, LanguageModel>;
-declare const Retryable_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: "RetryableAi";
-} & Readonly<A>;
-/** Internal wrapper around the retryable subset of `AiError`. */
-declare class Retryable extends Retryable_base<{
-  readonly cause: RateLimited | Unavailable | Timeout;
-}> {}
+declare const turn: (request: CommonRequest) => Effect.Effect<Turn, AiError, LanguageModel>;
 /**
- * Retry a stream of `AiError` on the retryable subset
- * (`RateLimited | Unavailable | Timeout`). Other failures bypass the
- * schedule and propagate unchanged. Like all `Stream.retry`, the entire
- * stream re-runs — deltas before the failure replay on the next attempt.
+ * Build a `turn` implementation from a `streamTurn` implementation.
+ * Providers without a native non-streaming endpoint use this to
+ * populate the service's `turn` field. Generic over the request type so
+ * provider-typed services (with their narrowed request) can reuse it.
  */
-declare const retry: <Out>(schedule: Schedule.Schedule<Out, Retryable>) => <A, R>(stream: Stream.Stream<A, AiError, R>) => Stream.Stream<A, AiError, R>;
+declare const turnFromStream: <Req>(streamTurn: (request: Req) => Stream.Stream<TurnEvent, AiError>) => (request: Req) => Effect.Effect<Turn, AiError>;
 //#endregion
-export { CommonRequest, LanguageModel, LanguageModelService, Retryable, retry, streamTurn, LanguageModel_d_exports as t, turn };
+export { CommonRequest, LanguageModel, LanguageModelService, streamTurn, LanguageModel_d_exports as t, turn, turnFromStream };
 //# sourceMappingURL=LanguageModel.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"LanguageModel.d.mts","names":[],"sources":["../../src/language-model/LanguageModel.ts"],"mappings":";;;;;;;;;;;;;;;;;;;KAaY,aAAA;EAAA,SACD,OAAA,EAAS,aAAA,CAAc,IAAA;;;;;WAKvB,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;EAOa;;;;;;EAAA,SAAb,UAAA,GAAa,gBAAA;AAAA;AAAA,KAGZ,oBAAA;EAAA,SACD,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;;;;AAb7C;;cAqBa,IAAA,GACX,OAAA,EAAS,aAAA,KACR,MAAA,CAAO,MAAA,CAAO,IAAA,EAAM,OAAA,GAAkB,cAAA,EAAwB,aAAA;AAAA,cAW9D,cAAA;;;;cAOU,SAAA,SAAkB,cAAA;EAAA,SACpB,KAAA,EAAO,WAAA,GAAsB,WAAA,GAAsB,OAAA;AAAA;;;;;;;cAoBjD,KAAA,QACL,QAAA,EAAU,QAAA,CAAS,QAAA,CAAS,GAAA,EAAK,SAAA,aAChC,MAAA,EAAQ,MAAA,CAAO,MAAA,CAAO,CAAA,EAAG,OAAA,EAAiB,CAAA,MAAK,MAAA,CAAO,MAAA,CAAO,CAAA,EAAG,OAAA,EAAiB,CAAA"}
+{"version":3,"file":"LanguageModel.d.mts","names":[],"sources":["../../src/language-model/LanguageModel.ts"],"mappings":";;;;;;;;;;;;;;;;;KAaY,aAAA;EAAA,SACD,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;EAdA;;;;;;EAAA,SAqBA,UAAA,GAAa,gBAAA;AAAA;AAAA,KAGZ,oBAAA;EAAA,SACD,UAAA,GAAa,OAAA,EAAS,aAAA,KAAkB,MAAA,CAAO,MAAA,CAAO,SAAA,EAAW,OAAA;EAbjE;;;;;;;;AAYX;EAZW,SAuBA,IAAA,GAAO,OAAA,EAAS,aAAA,KAAkB,MAAA,CAAO,MAAA,CAAO,IAAA,EAAM,OAAA;AAAA;AAAA,cAChE,kBAAA;cAEY,aAAA,SAAsB,kBAAA;;;;cAOtB,UAAA,GACX,OAAA,EAAS,aAAA,KACR,MAAA,CAAO,MAAA,CAAO,SAAA,EAAW,OAAA,EAAiB,aAAA;;;;;;;cAShC,IAAA,GAAQ,OAAA,EAAS,aAAA,KAAgB,MAAA,CAAO,MAAA,CAAO,IAAA,EAAM,OAAA,EAAiB,aAAA;;;;;;;cAStE,cAAA,QACL,UAAA,GAAa,OAAA,EAAS,GAAA,KAAQ,MAAA,CAAO,MAAA,CAAO,SAAA,EAAW,OAAA,OAC5D,OAAA,EAAS,GAAA,KAAM,MAAA,CAAO,MAAA,CAAO,IAAA,EAAM,OAAA"}

package/dist/language-model/LanguageModel.mjs

@@ -1,14 +1,13 @@
 import { n as __exportAll } from "../chunk-uyGKjUfl.mjs";
 import { IncompleteTurn } from "../domain/AiError.mjs";
 import { isTurnComplete } from "../domain/Turn.mjs";
-import { Array, Context, Data, Effect, Option, Stream } from "effect";
+import { Array, Context, Effect, Option, Stream } from "effect";
 //#region src/language-model/LanguageModel.ts
 var LanguageModel_exports = /* @__PURE__ */ __exportAll({
 	LanguageModel: () => LanguageModel,
-	Retryable: () => Retryable,
-	retry: () => retry,
 	streamTurn: () => streamTurn,
-	turn: () => turn
+	turn: () => turn,
+	turnFromStream: () => turnFromStream
 });
 var LanguageModel = class extends Context.Service()("@betalyra/effect-uai/LanguageModel") {};
 /**
@@ -16,31 +15,23 @@ var LanguageModel = class extends Context.Service()("@betalyra/effect-uai/Langua
 */
 const streamTurn = (request) => Stream.unwrap(Effect.map(LanguageModel.asEffect(), (m) => m.streamTurn(request)));
 /**
-* Drain `streamTurn` and return the assembled `Turn` from the terminal
-* `TurnComplete` event. Fails with `IncompleteTurn` if the stream ends
-* without one. Derived from `streamTurn`; providers get it for free.
+* Drain a single turn and return the assembled `Turn`. Delegates to the
+* service's `turn` method — providers with a native complete endpoint
+* can override; the rest get the default streamTurn-drain via
+* {@link turnFromStream}.
 */
-const turn = (request) => streamTurn(request).pipe(Stream.runCollect, Effect.flatMap((events) => Array.findLast(events, isTurnComplete).pipe(Option.match({
+const turn = (request) => Effect.flatMap(LanguageModel.asEffect(), (m) => m.turn(request));
+/**
+* Build a `turn` implementation from a `streamTurn` implementation.
+* Providers without a native non-streaming endpoint use this to
+* populate the service's `turn` field. Generic over the request type so
+* provider-typed services (with their narrowed request) can reuse it.
+*/
+const turnFromStream = (streamTurn) => (request) => streamTurn(request).pipe(Stream.runCollect, Effect.flatMap((events) => Array.findLast(events, isTurnComplete).pipe(Option.match({
 	onNone: () => Effect.fail(new IncompleteTurn({})),
 	onSome: (e) => Effect.succeed(e.turn)
 }))));
-/** Internal wrapper around the retryable subset of `AiError`. */
-var Retryable = class extends Data.TaggedError("RetryableAi") {};
-const isRetryable = (e) => e._tag === "RateLimited" || e._tag === "Unavailable" || e._tag === "Timeout";
-/**
-* Retry a stream of `AiError` on the retryable subset
-* (`RateLimited | Unavailable | Timeout`). Other failures bypass the
-* schedule and propagate unchanged. Like all `Stream.retry`, the entire
-* stream re-runs — deltas before the failure replay on the next attempt.
-*/
-const retry = (schedule) => (stream) => stream.pipe(Stream.map((value) => ({
-	_tag: "Item",
-	value
-})), Stream.catchIf(isRetryable, (cause) => Stream.fail(new Retryable({ cause })), (cause) => Stream.succeed({
-	_tag: "Terminal",
-	cause
-})), Stream.retry(schedule), Stream.catchTag("RetryableAi", (e) => Stream.fail(e.cause)), Stream.flatMap((item) => item._tag === "Item" ? Stream.succeed(item.value) : Stream.fail(item.cause)));
 //#endregion
-export { LanguageModel, Retryable, retry, streamTurn, LanguageModel_exports as t, turn };
+export { LanguageModel, streamTurn, LanguageModel_exports as t, turn, turnFromStream };
 
 //# sourceMappingURL=LanguageModel.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"LanguageModel.mjs","names":["Arr","AiError.IncompleteTurn"],"sources":["../../src/language-model/LanguageModel.ts"],"sourcesContent":["import { Array as Arr, Context, Data, Effect, Option, type Schedule, 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 type 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 type 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 * Drain `streamTurn` and return the assembled `Turn` from the terminal\n * `TurnComplete` event. Fails with `IncompleteTurn` if the stream ends\n * without one. Derived from `streamTurn`; providers get it for free.\n */\nexport const turn = (\n  request: CommonRequest,\n): Effect.Effect<Turn, AiError.AiError | AiError.IncompleteTurn, LanguageModel> =>\n  streamTurn(request).pipe(\n    Stream.runCollect,\n    Effect.flatMap((events) =>\n      Arr.findLast(events, isTurnComplete).pipe(\n        Option.match({\n          onNone: () => Effect.fail(new AiError.IncompleteTurn({})),\n          onSome: (e) => Effect.succeed(e.turn),\n        }),\n      ),\n    ),\n  )\n\n// ---------------------------------------------------------------------------\n// retry — retry the retryable subset of AiError, let other failures escape\n// ---------------------------------------------------------------------------\n\n/** Internal wrapper around the retryable subset of `AiError`. */\nexport class Retryable extends Data.TaggedError(\"RetryableAi\")<{\n  readonly cause: AiError.RateLimited | AiError.Unavailable | AiError.Timeout\n}> {}\n\nconst isRetryable = (\n  e: AiError.AiError,\n): e is AiError.RateLimited | AiError.Unavailable | AiError.Timeout =>\n  e._tag === \"RateLimited\" || e._tag === \"Unavailable\" || e._tag === \"Timeout\"\n\n// Lift events to Items, non-retryable failures to Terminal values (escape\n// retry), retryable failures to wrapped errors (only thing retry sees).\ntype Lifted<A> =\n  | { readonly _tag: \"Item\"; readonly value: A }\n  | { readonly _tag: \"Terminal\"; readonly cause: AiError.AiError }\n\n/**\n * Retry a stream of `AiError` on the retryable subset\n * (`RateLimited | Unavailable | Timeout`). Other failures bypass the\n * schedule and propagate unchanged. Like all `Stream.retry`, the entire\n * stream re-runs — deltas before the failure replay on the next attempt.\n */\nexport const retry =\n  <Out>(schedule: Schedule.Schedule<Out, Retryable>) =>\n  <A, R>(stream: Stream.Stream<A, AiError.AiError, R>): Stream.Stream<A, AiError.AiError, R> =>\n    stream.pipe(\n      Stream.map((value): Lifted<A> => ({ _tag: \"Item\", value })),\n      Stream.catchIf(\n        isRetryable,\n        (cause) => Stream.fail(new Retryable({ cause })),\n        (cause) => Stream.succeed<Lifted<A>>({ _tag: \"Terminal\", cause }),\n      ),\n      Stream.retry(schedule),\n      Stream.catchTag(\"RetryableAi\", (e) => Stream.fail<AiError.AiError>(e.cause)),\n      Stream.flatMap((item) =>\n        item._tag === \"Item\" ? Stream.succeed(item.value) : Stream.fail(item.cause),\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;;;;;;AAOnF,MAAa,QACX,YAEA,WAAW,QAAQ,CAAC,KAClB,OAAO,YACP,OAAO,SAAS,WACdA,MAAI,SAAS,QAAQ,eAAe,CAAC,KACnC,OAAO,MAAM;CACX,cAAc,OAAO,KAAK,IAAIC,eAAuB,EAAE,CAAC,CAAC;CACzD,SAAS,MAAM,OAAO,QAAQ,EAAE,KAAK;CACtC,CAAC,CACH,CACF,CACF;;AAOH,IAAa,YAAb,cAA+B,KAAK,YAAY,cAAc,CAE3D;AAEH,MAAM,eACJ,MAEA,EAAE,SAAS,iBAAiB,EAAE,SAAS,iBAAiB,EAAE,SAAS;;;;;;;AAcrE,MAAa,SACL,cACC,WACL,OAAO,KACL,OAAO,KAAK,WAAsB;CAAE,MAAM;CAAQ;CAAO,EAAE,EAC3D,OAAO,QACL,cACC,UAAU,OAAO,KAAK,IAAI,UAAU,EAAE,OAAO,CAAC,CAAC,GAC/C,UAAU,OAAO,QAAmB;CAAE,MAAM;CAAY;CAAO,CAAC,CAClE,EACD,OAAO,MAAM,SAAS,EACtB,OAAO,SAAS,gBAAgB,MAAM,OAAO,KAAsB,EAAE,MAAM,CAAC,EAC5E,OAAO,SAAS,SACd,KAAK,SAAS,SAAS,OAAO,QAAQ,KAAK,MAAM,GAAG,OAAO,KAAK,KAAK,MAAM,CAC5E,CACF"}
+{"version":3,"file":"LanguageModel.mjs","names":["Arr","AiError.IncompleteTurn"],"sources":["../../src/language-model/LanguageModel.ts"],"sourcesContent":["import { Array as Arr, Context, Effect, Option, 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 type 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 type LanguageModelService = {\n  readonly streamTurn: (request: CommonRequest) => Stream.Stream<TurnEvent, AiError.AiError>\n  /**\n   * Drain a single turn and return the assembled `Turn` from the\n   * terminal `TurnComplete` event. Fails with `IncompleteTurn` if the\n   * stream ends without one.\n   *\n   * Most providers derive this from `streamTurn` via\n   * {@link turnFromStream}; providers with a native non-streaming\n   * endpoint may override with a cheaper direct call.\n   */\n  readonly turn: (request: CommonRequest) => Effect.Effect<Turn, 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 * Drain a single turn and return the assembled `Turn`. Delegates to the\n * service's `turn` method — providers with a native complete endpoint\n * can override; the rest get the default streamTurn-drain via\n * {@link turnFromStream}.\n */\nexport const turn = (request: CommonRequest): Effect.Effect<Turn, AiError.AiError, LanguageModel> =>\n  Effect.flatMap(LanguageModel.asEffect(), (m) => m.turn(request))\n\n/**\n * Build a `turn` implementation from a `streamTurn` implementation.\n * Providers without a native non-streaming endpoint use this to\n * populate the service's `turn` field. Generic over the request type so\n * provider-typed services (with their narrowed request) can reuse it.\n */\nexport const turnFromStream =\n  <Req>(streamTurn: (request: Req) => Stream.Stream<TurnEvent, AiError.AiError>) =>\n  (request: Req): Effect.Effect<Turn, AiError.AiError> =>\n    streamTurn(request).pipe(\n      Stream.runCollect,\n      Effect.flatMap((events) =>\n        Arr.findLast(events, isTurnComplete).pipe(\n          Option.match({\n            onNone: () => Effect.fail(new AiError.IncompleteTurn({})),\n            onSome: (e) => Effect.succeed(e.turn),\n          }),\n        ),\n      ),\n    )\n"],"mappings":";;;;;;;;;;;AAoDA,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;;;;;;;AAQnF,MAAa,QAAQ,YACnB,OAAO,QAAQ,cAAc,UAAU,GAAG,MAAM,EAAE,KAAK,QAAQ,CAAC;;;;;;;AAQlE,MAAa,kBACL,gBACL,YACC,WAAW,QAAQ,CAAC,KAClB,OAAO,YACP,OAAO,SAAS,WACdA,MAAI,SAAS,QAAQ,eAAe,CAAC,KACnC,OAAO,MAAM;CACX,cAAc,OAAO,KAAK,IAAIC,eAAuB,EAAE,CAAC,CAAC;CACzD,SAAS,MAAM,OAAO,QAAQ,EAAE,KAAK;CACtC,CAAC,CACH,CACF,CACF"}

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

@@ -1,11 +1,15 @@
-import { ContentFiltered, IncompleteTurn, RateLimited, Timeout, Unavailable } from "../domain/AiError.mjs";
+import { IncompleteTurn, RateLimited } from "../domain/AiError.mjs";
 import { assistantText, userText } from "../domain/Items.mjs";
 import { TurnEvent } from "../domain/Turn.mjs";
-import { LanguageModel, retry, turn } from "./LanguageModel.mjs";
+import { LanguageModel, turn, turnFromStream } from "./LanguageModel.mjs";
 import { i as it, n as globalExpect, r as describe } from "../dist-DV5ISja1.mjs";
 import { layer } from "../testing/MockProvider.mjs";
-import { Cause, Effect, Exit, Layer, Option, Ref, Schedule, Stream } from "effect";
+import { Cause, Effect, Exit, Layer, Option, Stream } from "effect";
 //#region src/language-model/LanguageModel.test.ts
+const serviceFromStream = (streamTurn) => ({
+	streamTurn,
+	turn: turnFromStream(streamTurn)
+});
 const oneTextTurn = (text) => ({
 	items: [assistantText(text)],
 	usage: {
@@ -24,7 +28,7 @@ describe("LanguageModel.turn", () => {
 		globalExpect(await Effect.runPromise(program.pipe(Effect.provide(layer([expected]))))).toEqual(expected);
 	});
 	it("fails with IncompleteTurn when the stream ends without TurnComplete", async () => {
-		const broken = Layer.succeed(LanguageModel, { streamTurn: () => Stream.fromIterable([TurnEvent.TextDelta({ text: "partial" })]) });
+		const broken = Layer.succeed(LanguageModel, serviceFromStream(() => Stream.fromIterable([TurnEvent.TextDelta({ text: "partial" })])));
 		const program = turn({
 			history: [userText("hi")],
 			model: "mock"
@@ -42,7 +46,7 @@ describe("LanguageModel.turn", () => {
 			provider: "mock",
 			raw: null
 		});
-		const failing = Layer.succeed(LanguageModel, { streamTurn: () => Stream.fail(rateLimited) });
+		const failing = Layer.succeed(LanguageModel, serviceFromStream(() => Stream.fail(rateLimited)));
 		const program = turn({
 			history: [],
 			model: "mock"
@@ -54,7 +58,7 @@ describe("LanguageModel.turn", () => {
 	it("returns the LAST TurnComplete when the stream contains multiple (defensive)", async () => {
 		const first = oneTextTurn("first");
 		const second = oneTextTurn("second");
-		const weird = Layer.succeed(LanguageModel, { streamTurn: () => Stream.fromIterable([TurnEvent.TurnComplete({ turn: first }), TurnEvent.TurnComplete({ turn: second })]) });
+		const weird = Layer.succeed(LanguageModel, serviceFromStream(() => Stream.fromIterable([TurnEvent.TurnComplete({ turn: first }), TurnEvent.TurnComplete({ turn: second })])));
 		const program = turn({
 			history: [],
 			model: "mock"
@@ -62,81 +66,6 @@ describe("LanguageModel.turn", () => {
 		globalExpect(await Effect.runPromise(program.pipe(Effect.provide(weird)))).toEqual(second);
 	});
 });
-describe("LanguageModel.retry", () => {
-	const textDelta = (text) => TurnEvent.TextDelta({ text });
-	const textTurn = (text) => ({
-		items: [assistantText(text)],
-		usage: {
-			input_tokens: 0,
-			output_tokens: 0
-		},
-		stop_reason: "stop"
-	});
-	const completeEvent = (text) => TurnEvent.TurnComplete({ turn: textTurn(text) });
-	const attemptStream = (attempts, plan) => Stream.unwrap(Ref.getAndUpdate(attempts, (n) => n + 1).pipe(Effect.map((n) => plan[Math.min(n, plan.length - 1)])));
-	it("retries on RateLimited and yields the success on the next attempt", async () => {
-		const program = Effect.gen(function* () {
-			const attempts = yield* Ref.make(0);
-			const stream = attemptStream(attempts, [Stream.fail(new RateLimited({
-				provider: "mock",
-				raw: null
-			})), Stream.fromIterable([textDelta("ok"), completeEvent("ok")])]).pipe(retry(Schedule.recurs(3)));
-			const events = yield* Stream.runCollect(stream);
-			const count = yield* Ref.get(attempts);
-			return {
-				events: Array.from(events),
-				count
-			};
-		});
-		const { events, count } = await Effect.runPromise(program);
-		globalExpect(count).toBe(2);
-		globalExpect(events.map((e) => e._tag)).toEqual(["TextDelta", "TurnComplete"]);
-	});
-	it("surfaces the underlying retryable failure when retries are exhausted", async () => {
-		const cause = new Unavailable({
-			provider: "mock",
-			raw: null
-		});
-		const stream = Stream.fail(cause).pipe(retry(Schedule.recurs(2)));
-		const exit = await Effect.runPromise(Effect.exit(Stream.runCollect(stream)));
-		globalExpect(Exit.isFailure(exit)).toBe(true);
-		if (Exit.isFailure(exit)) globalExpect(Cause.findErrorOption(exit.cause)).toEqual(Option.some(cause));
-	});
-	it("bypasses retry for non-retryable AiError (ContentFiltered)", async () => {
-		const program = Effect.gen(function* () {
-			const attempts = yield* Ref.make(0);
-			const cause = new ContentFiltered({
-				provider: "mock",
-				raw: null
-			});
-			const stream = attemptStream(attempts, [Stream.fail(cause)]).pipe(retry(Schedule.recurs(5)));
-			return {
-				exit: yield* Effect.exit(Stream.runCollect(stream)),
-				count: yield* Ref.get(attempts),
-				cause
-			};
-		});
-		const { exit, count, cause } = await Effect.runPromise(program);
-		globalExpect(count).toBe(1);
-		globalExpect(Exit.isFailure(exit)).toBe(true);
-		if (Exit.isFailure(exit)) globalExpect(Cause.findErrorOption(exit.cause)).toEqual(Option.some(cause));
-	});
-	it("preserves deltas emitted before a retryable failure (and replays on retry)", async () => {
-		const program = Effect.gen(function* () {
-			const stream = attemptStream(yield* Ref.make(0), [Stream.concat(Stream.succeed(textDelta("partial")), Stream.fail(new Timeout({
-				provider: "mock",
-				raw: null
-			}))), Stream.fromIterable([textDelta("partial"), completeEvent("done")])]).pipe(retry(Schedule.recurs(1)));
-			const events = yield* Stream.runCollect(stream);
-			return Array.from(events);
-		});
-		globalExpect((await Effect.runPromise(program)).map((e) => e._tag)).toEqual([
-			"TextDelta",
-			"TextDelta",
-			"TurnComplete"
-		]);
-	});
-});
 //#endregion
 export {};
 

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

@@ -1 +1 @@
-{"version":3,"file":"LanguageModel.test.mjs","names":["Items.assistantText","Items.userText","MockProvider.layer","AiError.IncompleteTurn","AiError.RateLimited","AiError.Unavailable","AiError.ContentFiltered","AiError.Timeout"],"sources":["../../src/language-model/LanguageModel.test.ts"],"sourcesContent":["import { Cause, Effect, Exit, Layer, Option, Ref, Schedule, Stream } from \"effect\"\nimport { describe, expect, it } from \"vitest\"\nimport * as AiError from \"../domain/AiError.js\"\nimport * as Items from \"../domain/Items.js\"\nimport { type Turn, TurnEvent } from \"../domain/Turn.js\"\nimport { LanguageModel, retry, turn } from \"./LanguageModel.js\"\nimport * as MockProvider from \"../testing/MockProvider.js\"\n\nconst oneTextTurn = (text: string): Turn => ({\n  items: [Items.assistantText(text)],\n  usage: { input_tokens: 1, output_tokens: 1 },\n  stop_reason: \"stop\",\n})\n\ndescribe(\"LanguageModel.turn\", () => {\n  it(\"returns the assembled Turn from the terminal TurnComplete event\", async () => {\n    const expected = oneTextTurn(\"hello world\")\n    const program = turn({ history: [Items.userText(\"hi\")], model: \"mock\" })\n\n    const result = await Effect.runPromise(\n      program.pipe(Effect.provide(MockProvider.layer([expected]))),\n    )\n\n    expect(result).toEqual(expected)\n  })\n\n  it(\"fails with IncompleteTurn when the stream ends without TurnComplete\", async () => {\n    // Custom service whose stream emits a single TextDelta and then ends.\n    const broken = Layer.succeed(LanguageModel, {\n      streamTurn: () => Stream.fromIterable<TurnEvent>([TurnEvent.TextDelta({ text: \"partial\" })]),\n    })\n\n    const program = turn({ history: [Items.userText(\"hi\")], model: \"mock\" })\n    const exit = await Effect.runPromise(Effect.exit(program.pipe(Effect.provide(broken))))\n\n    expect(Exit.isFailure(exit)).toBe(true)\n    if (Exit.isFailure(exit)) {\n      const failure = Cause.findErrorOption(exit.cause)\n      expect(Option.isSome(failure)).toBe(true)\n      if (Option.isSome(failure)) {\n        expect(failure.value).toBeInstanceOf(AiError.IncompleteTurn)\n      }\n    }\n  })\n\n  it(\"propagates an AiError raised by streamTurn\", async () => {\n    const rateLimited = new AiError.RateLimited({ provider: \"mock\", raw: null })\n    const failing = Layer.succeed(LanguageModel, {\n      streamTurn: () => Stream.fail<AiError.AiError>(rateLimited),\n    })\n\n    const program = turn({ history: [], model: \"mock\" })\n    const exit = await Effect.runPromise(Effect.exit(program.pipe(Effect.provide(failing))))\n\n    expect(Exit.isFailure(exit)).toBe(true)\n    if (Exit.isFailure(exit)) {\n      expect(Cause.findErrorOption(exit.cause)).toEqual(Option.some(rateLimited))\n    }\n  })\n\n  it(\"returns the LAST TurnComplete when the stream contains multiple (defensive)\", async () => {\n    // A misbehaving provider might emit two TurnComplete events; turn\n    // should pick the last one (the most recent assembled Turn).\n    const first = oneTextTurn(\"first\")\n    const second = oneTextTurn(\"second\")\n    const weird = Layer.succeed(LanguageModel, {\n      streamTurn: () =>\n        Stream.fromIterable<TurnEvent>([\n          TurnEvent.TurnComplete({ turn: first }),\n          TurnEvent.TurnComplete({ turn: second }),\n        ]),\n    })\n\n    const program = turn({ history: [], model: \"mock\" })\n    const result = await Effect.runPromise(program.pipe(Effect.provide(weird)))\n\n    expect(result).toEqual(second)\n  })\n})\n\ndescribe(\"LanguageModel.retry\", () => {\n  const textDelta = (text: string): TurnEvent => TurnEvent.TextDelta({ text })\n  const textTurn = (text: string): Turn => ({\n    items: [Items.assistantText(text)],\n    usage: { input_tokens: 0, output_tokens: 0 },\n    stop_reason: \"stop\",\n  })\n  const completeEvent = (text: string): TurnEvent =>\n    TurnEvent.TurnComplete({ turn: textTurn(text) })\n\n  // Builds a stream that emits a failure or success based on attempt counter.\n  // Each call to the returned Effect produces a fresh attempt stream.\n  const attemptStream = (\n    attempts: Ref.Ref<number>,\n    plan: ReadonlyArray<Stream.Stream<TurnEvent, AiError.AiError>>,\n  ): Stream.Stream<TurnEvent, AiError.AiError> =>\n    Stream.unwrap(\n      Ref.getAndUpdate(attempts, (n) => n + 1).pipe(\n        Effect.map((n) => plan[Math.min(n, plan.length - 1)]!),\n      ),\n    )\n\n  it(\"retries on RateLimited and yields the success on the next attempt\", async () => {\n    const program = Effect.gen(function* () {\n      const attempts = yield* Ref.make(0)\n      const stream = attemptStream(attempts, [\n        Stream.fail(new AiError.RateLimited({ provider: \"mock\", raw: null })),\n        Stream.fromIterable([textDelta(\"ok\"), completeEvent(\"ok\")]),\n      ]).pipe(retry(Schedule.recurs(3)))\n      const events = yield* Stream.runCollect(stream)\n      const count = yield* Ref.get(attempts)\n      return { events: Array.from(events), count }\n    })\n\n    const { events, count } = await Effect.runPromise(program)\n    expect(count).toBe(2)\n    expect(events.map((e) => e._tag)).toEqual([\"TextDelta\", \"TurnComplete\"])\n  })\n\n  it(\"surfaces the underlying retryable failure when retries are exhausted\", async () => {\n    const cause = new AiError.Unavailable({ provider: \"mock\", raw: null })\n    const stream = Stream.fail<AiError.AiError>(cause).pipe(retry(Schedule.recurs(2)))\n\n    const exit = await Effect.runPromise(Effect.exit(Stream.runCollect(stream)))\n    expect(Exit.isFailure(exit)).toBe(true)\n    if (Exit.isFailure(exit)) {\n      expect(Cause.findErrorOption(exit.cause)).toEqual(Option.some(cause))\n    }\n  })\n\n  it(\"bypasses retry for non-retryable AiError (ContentFiltered)\", async () => {\n    const program = Effect.gen(function* () {\n      const attempts = yield* Ref.make(0)\n      const cause = new AiError.ContentFiltered({ provider: \"mock\", raw: null })\n      const stream = attemptStream(attempts, [Stream.fail(cause)]).pipe(retry(Schedule.recurs(5)))\n      const exit = yield* Effect.exit(Stream.runCollect(stream))\n      const count = yield* Ref.get(attempts)\n      return { exit, count, cause }\n    })\n\n    const { exit, count, cause } = await Effect.runPromise(program)\n    expect(count).toBe(1) // no retry happened\n    expect(Exit.isFailure(exit)).toBe(true)\n    if (Exit.isFailure(exit)) {\n      expect(Cause.findErrorOption(exit.cause)).toEqual(Option.some(cause))\n    }\n  })\n\n  it(\"preserves deltas emitted before a retryable failure (and replays on retry)\", async () => {\n    // Documents the 'replays on retry' caveat in the JSDoc — first attempt\n    // emits a delta then fails; second attempt is a clean success. Consumer\n    // sees the first delta twice (once from the failed attempt, once from\n    // the replay).\n    const program = Effect.gen(function* () {\n      const attempts = yield* Ref.make(0)\n      const stream = attemptStream(attempts, [\n        Stream.concat(\n          Stream.succeed<TurnEvent>(textDelta(\"partial\")),\n          Stream.fail(new AiError.Timeout({ provider: \"mock\", raw: null })),\n        ),\n        Stream.fromIterable([textDelta(\"partial\"), completeEvent(\"done\")]),\n      ]).pipe(retry(Schedule.recurs(1)))\n      const events = yield* Stream.runCollect(stream)\n      return Array.from(events)\n    })\n\n    const events = await Effect.runPromise(program)\n    expect(events.map((e) => e._tag)).toEqual([\"TextDelta\", \"TextDelta\", \"TurnComplete\"])\n  })\n})\n"],"mappings":"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"}
+{"version":3,"file":"LanguageModel.test.mjs","names":["Items.assistantText","Items.userText","MockProvider.layer","AiError.IncompleteTurn","AiError.RateLimited"],"sources":["../../src/language-model/LanguageModel.test.ts"],"sourcesContent":["import { Cause, Effect, Exit, Layer, Option, Stream } from \"effect\"\nimport { describe, expect, it } from \"vitest\"\nimport * as AiError from \"../domain/AiError.js\"\nimport * as Items from \"../domain/Items.js\"\nimport { type Turn, TurnEvent } from \"../domain/Turn.js\"\nimport { LanguageModel, type LanguageModelService, turn, turnFromStream } from \"./LanguageModel.js\"\n\nconst serviceFromStream = (\n  streamTurn: LanguageModelService[\"streamTurn\"],\n): LanguageModelService => ({ streamTurn, turn: turnFromStream(streamTurn) })\nimport * as MockProvider from \"../testing/MockProvider.js\"\n\nconst oneTextTurn = (text: string): Turn => ({\n  items: [Items.assistantText(text)],\n  usage: { input_tokens: 1, output_tokens: 1 },\n  stop_reason: \"stop\",\n})\n\ndescribe(\"LanguageModel.turn\", () => {\n  it(\"returns the assembled Turn from the terminal TurnComplete event\", async () => {\n    const expected = oneTextTurn(\"hello world\")\n    const program = turn({ history: [Items.userText(\"hi\")], model: \"mock\" })\n\n    const result = await Effect.runPromise(\n      program.pipe(Effect.provide(MockProvider.layer([expected]))),\n    )\n\n    expect(result).toEqual(expected)\n  })\n\n  it(\"fails with IncompleteTurn when the stream ends without TurnComplete\", async () => {\n    // Custom service whose stream emits a single TextDelta and then ends.\n    const broken = Layer.succeed(\n      LanguageModel,\n      serviceFromStream(() =>\n        Stream.fromIterable<TurnEvent>([TurnEvent.TextDelta({ text: \"partial\" })]),\n      ),\n    )\n\n    const program = turn({ history: [Items.userText(\"hi\")], model: \"mock\" })\n    const exit = await Effect.runPromise(Effect.exit(program.pipe(Effect.provide(broken))))\n\n    expect(Exit.isFailure(exit)).toBe(true)\n    if (Exit.isFailure(exit)) {\n      const failure = Cause.findErrorOption(exit.cause)\n      expect(Option.isSome(failure)).toBe(true)\n      if (Option.isSome(failure)) {\n        expect(failure.value).toBeInstanceOf(AiError.IncompleteTurn)\n      }\n    }\n  })\n\n  it(\"propagates an AiError raised by streamTurn\", async () => {\n    const rateLimited = new AiError.RateLimited({ provider: \"mock\", raw: null })\n    const failing = Layer.succeed(\n      LanguageModel,\n      serviceFromStream(() => Stream.fail<AiError.AiError>(rateLimited)),\n    )\n\n    const program = turn({ history: [], model: \"mock\" })\n    const exit = await Effect.runPromise(Effect.exit(program.pipe(Effect.provide(failing))))\n\n    expect(Exit.isFailure(exit)).toBe(true)\n    if (Exit.isFailure(exit)) {\n      expect(Cause.findErrorOption(exit.cause)).toEqual(Option.some(rateLimited))\n    }\n  })\n\n  it(\"returns the LAST TurnComplete when the stream contains multiple (defensive)\", async () => {\n    // A misbehaving provider might emit two TurnComplete events; turn\n    // should pick the last one (the most recent assembled Turn).\n    const first = oneTextTurn(\"first\")\n    const second = oneTextTurn(\"second\")\n    const weird = Layer.succeed(\n      LanguageModel,\n      serviceFromStream(() =>\n        Stream.fromIterable<TurnEvent>([\n          TurnEvent.TurnComplete({ turn: first }),\n          TurnEvent.TurnComplete({ turn: second }),\n        ]),\n      ),\n    )\n\n    const program = turn({ history: [], model: \"mock\" })\n    const result = await Effect.runPromise(program.pipe(Effect.provide(weird)))\n\n    expect(result).toEqual(second)\n  })\n})\n"],"mappings":";;;;;;;;AAOA,MAAM,qBACJ,gBAC0B;CAAE;CAAY,MAAM,eAAe,WAAW;CAAE;AAG5E,MAAM,eAAe,UAAwB;CAC3C,OAAO,CAACA,cAAoB,KAAK,CAAC;CAClC,OAAO;EAAE,cAAc;EAAG,eAAe;EAAG;CAC5C,aAAa;CACd;AAED,SAAS,4BAA4B;AACnC,IAAG,mEAAmE,YAAY;EAChF,MAAM,WAAW,YAAY,cAAc;EAC3C,MAAM,UAAU,KAAK;GAAE,SAAS,CAACC,SAAe,KAAK,CAAC;GAAE,OAAO;GAAQ,CAAC;AAMxE,eAAO,MAJc,OAAO,WAC1B,QAAQ,KAAK,OAAO,QAAQC,MAAmB,CAAC,SAAS,CAAC,CAAC,CAAC,CAC7D,CAEa,CAAC,QAAQ,SAAS;GAChC;AAEF,IAAG,uEAAuE,YAAY;EAEpF,MAAM,SAAS,MAAM,QACnB,eACA,wBACE,OAAO,aAAwB,CAAC,UAAU,UAAU,EAAE,MAAM,WAAW,CAAC,CAAC,CAAC,CAC3E,CACF;EAED,MAAM,UAAU,KAAK;GAAE,SAAS,CAACD,SAAe,KAAK,CAAC;GAAE,OAAO;GAAQ,CAAC;EACxE,MAAM,OAAO,MAAM,OAAO,WAAW,OAAO,KAAK,QAAQ,KAAK,OAAO,QAAQ,OAAO,CAAC,CAAC,CAAC;AAEvF,eAAO,KAAK,UAAU,KAAK,CAAC,CAAC,KAAK,KAAK;AACvC,MAAI,KAAK,UAAU,KAAK,EAAE;GACxB,MAAM,UAAU,MAAM,gBAAgB,KAAK,MAAM;AACjD,gBAAO,OAAO,OAAO,QAAQ,CAAC,CAAC,KAAK,KAAK;AACzC,OAAI,OAAO,OAAO,QAAQ,CACxB,cAAO,QAAQ,MAAM,CAAC,eAAeE,eAAuB;;GAGhE;AAEF,IAAG,8CAA8C,YAAY;EAC3D,MAAM,cAAc,IAAIC,YAAoB;GAAE,UAAU;GAAQ,KAAK;GAAM,CAAC;EAC5E,MAAM,UAAU,MAAM,QACpB,eACA,wBAAwB,OAAO,KAAsB,YAAY,CAAC,CACnE;EAED,MAAM,UAAU,KAAK;GAAE,SAAS,EAAE;GAAE,OAAO;GAAQ,CAAC;EACpD,MAAM,OAAO,MAAM,OAAO,WAAW,OAAO,KAAK,QAAQ,KAAK,OAAO,QAAQ,QAAQ,CAAC,CAAC,CAAC;AAExF,eAAO,KAAK,UAAU,KAAK,CAAC,CAAC,KAAK,KAAK;AACvC,MAAI,KAAK,UAAU,KAAK,CACtB,cAAO,MAAM,gBAAgB,KAAK,MAAM,CAAC,CAAC,QAAQ,OAAO,KAAK,YAAY,CAAC;GAE7E;AAEF,IAAG,+EAA+E,YAAY;EAG5F,MAAM,QAAQ,YAAY,QAAQ;EAClC,MAAM,SAAS,YAAY,SAAS;EACpC,MAAM,QAAQ,MAAM,QAClB,eACA,wBACE,OAAO,aAAwB,CAC7B,UAAU,aAAa,EAAE,MAAM,OAAO,CAAC,EACvC,UAAU,aAAa,EAAE,MAAM,QAAQ,CAAC,CACzC,CAAC,CACH,CACF;EAED,MAAM,UAAU,KAAK;GAAE,SAAS,EAAE;GAAE,OAAO;GAAQ,CAAC;AAGpD,eAAO,MAFc,OAAO,WAAW,QAAQ,KAAK,OAAO,QAAQ,MAAM,CAAC,CAAC,CAE7D,CAAC,QAAQ,OAAO;GAC9B;EACF"}

package/dist/loop/Loop.d.mts

@@ -1,5 +1,5 @@
 import { l as IncompleteTurn } from "../AiError-CAX_48RU.mjs";
-import { i as TurnEvent, r as Turn } from "../Turn-ChbL2foc.mjs";
+import { i as TurnEvent, r as Turn } from "../Turn-0CwCAyVe.mjs";
 import { Data, Effect, Stream, SubscriptionRef } from "effect";
 
 //#region src/loop/Loop.d.ts

package/dist/retry/Retry.d.mts

@@ -0,0 +1,64 @@
+import { d as RateLimited, m as Unavailable, p as Timeout, t as AiError } from "../AiError-CAX_48RU.mjs";
+import { Effect, Schedule, Stream } from "effect";
+import * as _$effect_Types0 from "effect/Types";
+import * as _$effect_Cause0 from "effect/Cause";
+
+//#region src/retry/Retry.d.ts
+declare namespace Retry_d_exports {
+  export { Retryable, effect, isRetryable, stream };
+}
+declare const Retryable_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: "RetryableAi";
+} & Readonly<A>;
+/**
+ * Subset-aware retry helpers for `AiError`.
+ *
+ * Effect's own `Effect.retry` / `Stream.retry` apply the schedule to
+ * every failure. For AI calls that's the wrong policy — replaying a
+ * `ContentFiltered` or `InvalidRequest` won't change the outcome and
+ * just wastes quota. These helpers gate the schedule on the
+ * {@link Retryable} subset (rate limits, transport hiccups, timeouts);
+ * everything else propagates unchanged.
+ *
+ * Two carriers:
+ * - {@link stream} — for `Stream<A, AiError, R>` (e.g. `streamTurn`,
+ *   `streamSynthesis`, `streamTranscriptionFrom`). Caveat: the entire
+ *   stream re-runs on retry, so deltas before the failure replay on
+ *   the next attempt.
+ * - {@link effect} — for `Effect<A, AiError, R>` (e.g. `turn`, `embed`,
+ *   `embedMany`, `synthesize`, `transcribe`). At-most-once.
+ *
+ * Composes with `Stream.retry` / `Effect.retry` directly (no naming
+ * collision since these live under the `Retry` namespace).
+ */
+/**
+ * Wrapper around the retryable subset of `AiError`. Internal to the
+ * lift/retry/unlift dance — exported so callers can build their own
+ * variants if needed (e.g. a custom schedule that observes `cause`).
+ */
+declare class Retryable extends Retryable_base<{
+  readonly cause: RateLimited | Unavailable | Timeout;
+}> {}
+/** Type-narrowing predicate for the retryable subset. */
+declare const isRetryable: (e: AiError) => e is RateLimited | Unavailable | Timeout;
+/**
+ * Retry a `Stream<A, AiError, R>` on the retryable subset. Other
+ * failures bypass the schedule and propagate unchanged. The whole
+ * stream replays on each attempt — deltas emitted before the failure
+ * are re-emitted on the next try.
+ */
+declare const stream: <Out>(schedule: Schedule.Schedule<Out, Retryable>) => <A, R>(s: Stream.Stream<A, AiError, R>) => Stream.Stream<A, AiError, R>;
+/**
+ * Retry an `Effect<A, AiError, R>` on the retryable subset. Other
+ * failures bypass the schedule and propagate unchanged. At-most-once
+ * — the underlying call only re-runs if the previous attempt failed
+ * with a retryable tag.
+ *
+ * Skips the lift/unlift dance the Stream variant needs: `Effect.retry`
+ * exposes a `while:` predicate so the error channel stays a plain
+ * `AiError` throughout.
+ */
+declare const effect: <Out>(schedule: Schedule.Schedule<Out, AiError>) => <A, R>(eff: Effect.Effect<A, AiError, R>) => Effect.Effect<A, AiError, R>;
+//#endregion
+export { Retryable, effect, isRetryable, stream, Retry_d_exports as t };
+//# sourceMappingURL=Retry.d.mts.map