@effect-uai/core 0.4.0 → 0.5.0

package/dist/{AiError-csR8Bhxx.d.mts → AiError-CAX_48RU.d.mts}

@@ -97,7 +97,7 @@ declare const IncompleteTurn_base: new <A extends Record<string, any> = {}>(args
   readonly _tag: "IncompleteTurn";
 } & Readonly<A>;
 /**
- * The provider's delta stream ended without a terminal `turn_complete`.
+ * The provider's delta stream ended without a terminal `TurnComplete`.
  * Indicates a misbehaving provider or a connection that dropped mid-flight.
  * Non-terminal deltas seen so far have already been emitted downstream.
  */
@@ -129,4 +129,4 @@ declare class Unsupported extends Unsupported_base<{
 type AiError = RateLimited | Unavailable | Timeout | ContentFiltered | ContextLengthExceeded | InvalidRequest | AuthFailed | Cancelled | IncompleteTurn | GenerationFailed | Unsupported;
 //#endregion
 export { Cancelled as a, GenerationFailed as c, RateLimited as d, Scope$1 as f, Unsupported as h, AuthSubtype as i, IncompleteTurn as l, Unavailable as m, AiError_d_exports as n, ContentFiltered as o, Timeout as p, AuthFailed as r, ContextLengthExceeded as s, AiError as t, InvalidRequest as u };
-//# sourceMappingURL=AiError-csR8Bhxx.d.mts.map
+//# sourceMappingURL=AiError-CAX_48RU.d.mts.map

package/dist/{AiError-csR8Bhxx.d.mts.map → AiError-CAX_48RU.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"AiError-csR8Bhxx.d.mts","names":[],"sources":["../src/domain/AiError.ts"],"mappings":";;;;;;;;KAEY,OAAA;AAAA,cAAqC,gBAAA;;;cAEpC,WAAA,SAAoB,gBAAA;EAC/B,QAAA;EACA,UAAA,GAAa,QAAA,CAAS,QAAA;EACtB,KAAA,GAAQ,OAAA;EACR,SAAA;EACA,GAAA;AAAA;AAAA,cACG,gBAAA;;;cAEQ,WAAA,SAAoB,gBAAA;EAC/B,QAAA;EACA,UAAA,GAAa,QAAA,CAAS,QAAA;EACtB,MAAA;EACA,SAAA;EACA,GAAA;AAAA;AAAA,cACG,YAAA;;;cAEQ,OAAA,SAAgB,YAAA;EAC3B,QAAA;EACA,SAAA;EACA,GAAA;AAAA;AAAA,cACG,oBAAA;;;cAEQ,eAAA,SAAwB,oBAAA;EACnC,QAAA;EACA,MAAA;EACA,SAAA;EACA,GAAA;AAAA;AAAA,cACG,0BAAA;;;cAEQ,qBAAA,SAA8B,0BAAA;EACzC,QAAA;EACA,UAAA;EACA,SAAA;EACA,GAAA;AAAA;AAAA,cACG,mBAAA;;;cAEQ,cAAA,SAAuB,mBAAA;EAClC,QAAA;EACA,KAAA;EACA,SAAA;EACA,GAAA;AAAA;AAAA,KAGU,WAAA;AAAA,cAAyD,eAAA;;;cAExD,UAAA,SAAmB,eAAA;EAC9B,QAAA;EACA,OAAA,EAAS,WAAA;EACT,GAAA;AAAA;AAAA,cACG,cAAA;;;cAEQ,SAAA,SAAkB,cAAA;EAC7B,QAAA;AAAA;AAAA,cACG,qBAAA;;;;;;;;;cAQQ,gBAAA,SAAyB,qBAAA;EACpC,QAAA;EACA,IAAA;EACA,OAAA;EACA,SAAA;EACA,GAAA;AAAA;AAAA,cACG,mBAAA;;;;;;;;cAOQ,cAAA,SAAuB,mBAAA;EAClC,GAAA;AAAA;AAAA,cACG,gBAAA;;;;;;;;;;;;;AA9DA;;;;cA8EQ,WAAA,SAAoB,gBAAA;EAC/B,QAAA;EACA,UAAA;EACA,MAAA;AAAA;AAAA,KAGU,OAAA,GACR,WAAA,GACA,WAAA,GACA,OAAA,GACA,eAAA,GACA,qBAAA,GACA,cAAA,GACA,UAAA,GACA,SAAA,GACA,cAAA,GACA,gBAAA,GACA,WAAA"}
+{"version":3,"file":"AiError-CAX_48RU.d.mts","names":[],"sources":["../src/domain/AiError.ts"],"mappings":";;;;;;;;KAEY,OAAA;AAAA,cAAqC,gBAAA;;;cAEpC,WAAA,SAAoB,gBAAA;EAC/B,QAAA;EACA,UAAA,GAAa,QAAA,CAAS,QAAA;EACtB,KAAA,GAAQ,OAAA;EACR,SAAA;EACA,GAAA;AAAA;AAAA,cACG,gBAAA;;;cAEQ,WAAA,SAAoB,gBAAA;EAC/B,QAAA;EACA,UAAA,GAAa,QAAA,CAAS,QAAA;EACtB,MAAA;EACA,SAAA;EACA,GAAA;AAAA;AAAA,cACG,YAAA;;;cAEQ,OAAA,SAAgB,YAAA;EAC3B,QAAA;EACA,SAAA;EACA,GAAA;AAAA;AAAA,cACG,oBAAA;;;cAEQ,eAAA,SAAwB,oBAAA;EACnC,QAAA;EACA,MAAA;EACA,SAAA;EACA,GAAA;AAAA;AAAA,cACG,0BAAA;;;cAEQ,qBAAA,SAA8B,0BAAA;EACzC,QAAA;EACA,UAAA;EACA,SAAA;EACA,GAAA;AAAA;AAAA,cACG,mBAAA;;;cAEQ,cAAA,SAAuB,mBAAA;EAClC,QAAA;EACA,KAAA;EACA,SAAA;EACA,GAAA;AAAA;AAAA,KAGU,WAAA;AAAA,cAAyD,eAAA;;;cAExD,UAAA,SAAmB,eAAA;EAC9B,QAAA;EACA,OAAA,EAAS,WAAA;EACT,GAAA;AAAA;AAAA,cACG,cAAA;;;cAEQ,SAAA,SAAkB,cAAA;EAC7B,QAAA;AAAA;AAAA,cACG,qBAAA;;;;;;;;;cAQQ,gBAAA,SAAyB,qBAAA;EACpC,QAAA;EACA,IAAA;EACA,OAAA;EACA,SAAA;EACA,GAAA;AAAA;AAAA,cACG,mBAAA;;;;;;;;cAOQ,cAAA,SAAuB,mBAAA;EAClC,GAAA;AAAA;AAAA,cACG,gBAAA;;;;;;;;;;;;;AA9DA;;;;cA8EQ,WAAA,SAAoB,gBAAA;EAC/B,QAAA;EACA,UAAA;EACA,MAAA;AAAA;AAAA,KAGU,OAAA,GACR,WAAA,GACA,WAAA,GACA,OAAA,GACA,eAAA,GACA,qBAAA,GACA,cAAA,GACA,UAAA,GACA,SAAA,GACA,cAAA,GACA,gBAAA,GACA,WAAA"}

package/dist/{Image-DxyXqzAM.d.mts → Image-HNmMpMTh.d.mts}

@@ -42,20 +42,20 @@ declare const imageUrl: (url: string, mimeType?: ImageMimeType) => ImageUrlSourc
 declare const imageBase64: (base64: string, mimeType: ImageMimeType) => ImageBase64Source;
 declare const imageBytes: (bytes: Uint8Array, mimeType: ImageMimeType) => ImageBytesSource;
 declare const isImageUrl: <I>(input: I) => input is I & {
-  readonly url: string;
   readonly _tag: "url";
+  readonly url: string;
   readonly mimeType?: ImageMimeType | undefined;
 };
 declare const isImageBase64: <I>(input: I) => input is I & {
+  readonly _tag: "base64";
   readonly mimeType: ImageMimeType;
   readonly base64: string;
-  readonly _tag: "base64";
 };
 declare const isImageBytes: <I>(input: I) => input is I & {
+  readonly _tag: "bytes";
   readonly mimeType: ImageMimeType;
   readonly bytes: Uint8Array<ArrayBufferLike>;
-  readonly _tag: "bytes";
 };
 //#endregion
 export { ImageUrlSource as a, imageBytes as c, isImageBytes as d, isImageUrl as f, ImageSource as i, imageUrl as l, ImageBytesSource as n, Image_d_exports as o, ImageMimeType as r, imageBase64 as s, ImageBase64Source as t, isImageBase64 as u };
-//# sourceMappingURL=Image-DxyXqzAM.d.mts.map
+//# sourceMappingURL=Image-HNmMpMTh.d.mts.map

package/dist/{Image-DxyXqzAM.d.mts.map → Image-HNmMpMTh.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"Image-DxyXqzAM.d.mts","names":[],"sources":["../src/domain/Image.ts"],"mappings":";;;;;;;;;;;;;;;KAWY,aAAA;AAAA,KAYA,cAAA,GAAiB,QAAA,CAAS,aAAA;AAAA,KAC1B,iBAAA,GAAoB,WAAA,CAAY,aAAA;AAAA,KAChC,gBAAA,GAAmB,UAAA,CAAW,aAAA;;;;;AAd1C;;;KAuBY,WAAA,GAAc,WAAA,CAAY,aAAA;AAAA,cAEzB,cAAA,EAAc,MAAA,CAAA,YAAA;EAAA;;;cAKd,iBAAA,EAAiB,MAAA,CAAA,YAAA;EAAA;;;cAKjB,gBAAA,EAAgB,MAAA,CAAA,YAAA;EAAA;;;cAKhB,WAAA,EAAa,MAAA,CAAO,MAAA,CAAO,WAAA;AAAA,cAM3B,QAAA,GAAY,GAAA,UAAa,QAAA,GAAW,aAAA,KAAgB,cAAA;AAAA,cAGpD,WAAA,GAAe,MAAA,UAAgB,QAAA,EAAU,aAAA,KAAgB,iBAAA;AAAA,cAMzD,UAAA,GAAc,KAAA,EAAO,UAAA,EAAY,QAAA,EAAU,aAAA,KAAgB,gBAAA;AAAA,cAM3D,UAAA,MAAU,KAAA,EAAA,CAAA,KAAA,KAAA,IAAA,CAAA;EAAA;;;;cACV,aAAA,MAAa,KAAA,EAAA,CAAA,KAAA,KAAA,IAAA,CAAA;EAAA;;;;cACb,YAAA,MAAY,KAAA,EAAA,CAAA,KAAA,KAAA,IAAA,CAAA;EAAA"}
+{"version":3,"file":"Image-HNmMpMTh.d.mts","names":[],"sources":["../src/domain/Image.ts"],"mappings":";;;;;;;;;;;;;;;KAWY,aAAA;AAAA,KAYA,cAAA,GAAiB,QAAA,CAAS,aAAA;AAAA,KAC1B,iBAAA,GAAoB,WAAA,CAAY,aAAA;AAAA,KAChC,gBAAA,GAAmB,UAAA,CAAW,aAAA;;;;;AAd1C;;;KAuBY,WAAA,GAAc,WAAA,CAAY,aAAA;AAAA,cAEzB,cAAA,EAAc,MAAA,CAAA,YAAA;EAAA;;;cAKd,iBAAA,EAAiB,MAAA,CAAA,YAAA;EAAA;;;cAKjB,gBAAA,EAAgB,MAAA,CAAA,YAAA;EAAA;;;cAKhB,WAAA,EAAa,MAAA,CAAO,MAAA,CAAO,WAAA;AAAA,cAM3B,QAAA,GAAY,GAAA,UAAa,QAAA,GAAW,aAAA,KAAgB,cAAA;AAAA,cAGpD,WAAA,GAAe,MAAA,UAAgB,QAAA,EAAU,aAAA,KAAgB,iBAAA;AAAA,cAMzD,UAAA,GAAc,KAAA,EAAO,UAAA,EAAY,QAAA,EAAU,aAAA,KAAgB,gBAAA;AAAA,cAM3D,UAAA,MAAU,KAAA,EAAA,CAAA,KAAA,KAAA,IAAA,CAAA;EAAA;;;;cACV,aAAA,MAAa,KAAA,EAAA,CAAA,KAAA,KAAA,IAAA,CAAA;EAAA;;;;cACb,YAAA,MAAY,KAAA,EAAA,CAAA,KAAA,KAAA,IAAA,CAAA;EAAA"}

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

@@ -1,4 +1,4 @@
-import { i as ImageSource } from "./Image-DxyXqzAM.mjs";
+import { i as ImageSource } from "./Image-HNmMpMTh.mjs";
 import { Schema } from "effect";
 
 //#region src/domain/Items.d.ts
@@ -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 url: string;
   readonly type: "url_citation";
+  readonly url: string;
   readonly start_index: number;
   readonly end_index: number;
   readonly title: string;
@@ -127,7 +127,7 @@ type OutputText = typeof OutputText.Type;
  * Model-emitted refusal. Distinct from `output_text`: the model declined
  * to answer rather than producing normal output. Pair with
  * `stop_reason: "refusal"` on the surrounding `Turn`. Streamed via the
- * `refusal_delta` `TurnEvent`.
+ * `RefusalDelta` `TurnEvent`.
  */
 declare const Refusal: Schema.Struct<{
   readonly type: Schema.Literal<"refusal">;
@@ -309,8 +309,8 @@ declare const isOutputText: <I>(input: I) => input is I & {
   readonly type: "output_text";
   readonly text: string;
   readonly annotations?: readonly ({
-    readonly url: string;
     readonly type: "url_citation";
+    readonly url: string;
     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 url: string;
       readonly type: "url_citation";
+      readonly url: string;
       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 type: "function_call";
   readonly call_id: string;
+  readonly type: "function_call";
   readonly name: string;
   readonly arguments: string;
   readonly providerData?: unknown;
 };
 declare const isFunctionCallOutput: <I>(input: I) => input is I & {
-  readonly type: "function_call_output";
   readonly call_id: string;
+  readonly type: "function_call_output";
   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-Hg5AsYxl.d.mts.map
+//# sourceMappingURL=Items-DqbaJoz7.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"Items-Hg5AsYxl.d.mts","names":[],"sources":["../src/domain/Items.ts"],"mappings":"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"}
+{"version":3,"file":"Items-DqbaJoz7.d.mts","names":[],"sources":["../src/domain/Items.ts"],"mappings":"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"}

package/dist/{StructuredFormat-Cl41C56K.d.mts → StructuredFormat-BbN4dosH.d.mts}

@@ -1,11 +1,11 @@
-import { Effect, Schema, Stream } from "effect";
+import { Effect, Result, 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 };
+  export { DecodeIssue, JsonParseError, StructuredDecodeError, StructuredFormat, StructuredSchema, decode, decodeJsonLines, decodeJsonLinesRecoverable, fromEffectSchema, parseJson };
 }
 /**
  * Cross-validator schema constraint for structured outputs. Any schema
@@ -83,6 +83,13 @@ declare const parseJson: <A>(format: StructuredFormat<A>) => (raw: string) => Ef
  * 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>;
+/**
+ * Like {@link decodeJsonLines}, but each line yields a `Result` instead of
+ * failing the stream. Use when one bad line shouldn't abort the rest —
+ * log-and-continue, or partial-recovery with a corrective re-prompt.
+ * Upstream errors (the input stream's own `E`) still propagate normally.
+ */
+declare const decodeJsonLinesRecoverable: <A>(format: StructuredFormat<A>) => <E, R>(self: Stream.Stream<string, E, R>) => Stream.Stream<Result.Result<A, JsonParseError | StructuredDecodeError>, E, 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-Cl41C56K.d.mts.map
+export { StructuredFormat_d_exports as a, decodeJsonLines as c, parseJson as d, StructuredFormat as i, decodeJsonLinesRecoverable as l, JsonParseError as n, StructuredSchema as o, StructuredDecodeError as r, decode as s, DecodeIssue as t, fromEffectSchema as u };
+//# sourceMappingURL=StructuredFormat-BbN4dosH.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"StructuredFormat-BbN4dosH.d.mts","names":[],"sources":["../src/structured-format/StructuredFormat.ts"],"mappings":";;;;;;;;;;;;;;;KAaY,gBAAA,qBAAqC,gBAAA,UAA0B,MAAA,IACzE,oBAAA,UAA8B,MAAA;;;;;;KAOpB,gBAAA;EAAA,SACD,IAAA;EAAA,SACA,WAAA;EAAA,SACA,MAAA,EAAQ,gBAAA,CAAiB,CAAA;;AAXpC;;;WAgBW,MAAA;AAAA;;KAIC,WAAA;EAAA,SACD,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;;;;;;;cAMQ,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;;;;;;;cASrD,0BAAA,MACP,MAAA,EAAQ,gBAAA,CAAiB,CAAA,aAE3B,IAAA,EAAM,MAAA,CAAO,MAAA,SAAe,CAAA,EAAG,CAAA,MAC9B,MAAA,CAAO,MAAA,CAAO,MAAA,CAAO,MAAA,CAAO,CAAA,EAAG,cAAA,GAAiB,qBAAA,GAAwB,CAAA,EAAG,CAAA"}

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

@@ -1,11 +1,11 @@
-import { o as FunctionCall, s as FunctionCallOutput } from "./Items-Hg5AsYxl.mjs";
+import { o as FunctionCall, s as FunctionCallOutput } from "./Items-DqbaJoz7.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 };
+  export { AnyKindTool, AnyPlainTool, AnyStreamingTool, StreamingTool, Tool, ToolDescriptor, ToolError, ToolInputSchema, execute, fromEffectSchema, fromStandardSchema, isStreamingTool, make, streaming, toDescriptors };
 }
 declare const ToolError_base: Schema.Class<ToolError, Schema.TaggedStruct<"ToolError", {
   readonly call_id: Schema.String;
@@ -30,6 +30,22 @@ type ToolInputSchema<Input = unknown> = StandardSchemaV1<unknown, Input> & Stand
  * can be used as a `Tool.inputSchema`.
  */
 declare const fromEffectSchema: <S extends Schema.Codec<any, any, never, any>>(schema: S) => S & ToolInputSchema<S["Type"]>;
+/**
+ * Use any schema library that implements both Standard Schema (validation)
+ * and Standard JSON Schema (JSON Schema generation) as a `Tool.inputSchema`.
+ * Covers Zod 4.2+, Valibot 1.2+, and ArkType 2.1.28+ in one helper.
+ *
+ * Effect Schema doesn't implement Standard JSON Schema natively — use
+ * `fromEffectSchema` for those.
+ *
+ * The intersection constraint catches missing interfaces at compile time:
+ * a Zod v3 schema (no Standard JSON Schema) produces a precise type error
+ * pointing at the missing interface rather than a runtime surprise. The
+ * helper itself is a thin type-narrowing identity — schemas that satisfy
+ * both standards already structurally satisfy `ToolInputSchema`; the
+ * helper makes the input type inference explicit at the call site.
+ */
+declare const fromStandardSchema: <S extends StandardSchemaV1 & StandardJSONSchemaV1>(schema: S) => S & ToolInputSchema<StandardSchemaV1.InferOutput<S>>;
 type Tool<Name extends string, Input, Output, R = never> = {
   readonly name: Name;
   readonly description: string;
@@ -82,5 +98,5 @@ 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, 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-B8B5qVEy.d.mts.map
+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

package/dist/Tool-Y0__Py1H.d.mts.map

@@ -0,0 +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"}

package/dist/Turn-ChbL2foc.d.mts

@@ -0,0 +1,388 @@
+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 { 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";
+import * as _$effect_Cause0 from "effect/Cause";
+import * as _$effect_Unify0 from "effect/Unify";
+
+//#region src/domain/Turn.d.ts
+declare namespace Turn_d_exports {
+  export { InteractionEvent, RefusalRejected, Turn, TurnEvent, appendTurn, assistantMessages, assistantText, assistantTexts, 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.Schema<ImageSource>;
+    }>, 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 `TurnComplete` carries the assembled `Turn`. Lifecycle members
+ * aren't deltas, hence the union name.
+ *
+ * `ReasoningDelta.kind`: `trace` is the model's raw chain-of-thought;
+ * `summary` is a model-written summary intended for display. OpenAI
+ * Responses emits both; Anthropic and Gemini only emit `trace`.
+ *
+ * `RefusalDelta`: the model declined to answer. OpenAI Responses emits
+ * this as its own event; Anthropic surfaces refusals via `stop_reason`
+ * and Gemini collapses them into `finishReason: SAFETY` — both go
+ * without a `RefusalDelta`.
+ *
+ * `UsageUpdate`: mid-stream cumulative usage. Anthropic emits this on
+ * `message_start` and `message_delta`; other providers may only deliver
+ * usage via `TurnComplete.turn.usage`.
+ */
+type TurnEvent = Data.TaggedEnum<{
+  TextDelta: {
+    readonly text: string;
+  };
+  ReasoningDelta: {
+    readonly text: string;
+    readonly kind: "trace" | "summary";
+  };
+  RefusalDelta: {
+    readonly text: string;
+  };
+  ToolCallStart: {
+    readonly call_id: string;
+    readonly name: string;
+  };
+  ToolCallArgsDelta: {
+    readonly call_id: string;
+    readonly delta: string;
+  };
+  UsageUpdate: {
+    readonly usage: Usage;
+  };
+  TurnComplete: {
+    readonly turn: Turn;
+  };
+}>;
+declare const TurnEvent: {
+  readonly TextDelta: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "TextDelta";
+    readonly text: string;
+  }, "_tag">;
+  readonly ReasoningDelta: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "ReasoningDelta";
+    readonly text: string;
+    readonly kind: "trace" | "summary";
+  }, "_tag">;
+  readonly RefusalDelta: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "RefusalDelta";
+    readonly text: string;
+  }, "_tag">;
+  readonly ToolCallStart: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "ToolCallStart";
+    readonly call_id: string;
+    readonly name: string;
+  }, "_tag">;
+  readonly ToolCallArgsDelta: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "ToolCallArgsDelta";
+    readonly call_id: string;
+    readonly delta: string;
+  }, "_tag">;
+  readonly UsageUpdate: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "UsageUpdate";
+    readonly usage: Usage;
+  }, "_tag">;
+  readonly TurnComplete: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "TurnComplete";
+    readonly turn: Turn;
+  }, "_tag">;
+  readonly $is: <Tag extends "TextDelta" | "ReasoningDelta" | "RefusalDelta" | "ToolCallStart" | "ToolCallArgsDelta" | "UsageUpdate" | "TurnComplete">(tag: Tag) => (u: unknown) => u is Extract<{
+    readonly _tag: "TextDelta";
+    readonly text: string;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "ReasoningDelta";
+    readonly text: string;
+    readonly kind: "trace" | "summary";
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "RefusalDelta";
+    readonly text: string;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "ToolCallStart";
+    readonly call_id: string;
+    readonly name: string;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "ToolCallArgsDelta";
+    readonly call_id: string;
+    readonly delta: string;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "UsageUpdate";
+    readonly usage: Usage;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "TurnComplete";
+    readonly turn: Turn;
+  }, {
+    readonly _tag: Tag;
+  }>;
+  readonly $match: {
+    <Cases extends {
+      readonly TextDelta: (args: {
+        readonly _tag: "TextDelta";
+        readonly text: string;
+      }) => any;
+      readonly ReasoningDelta: (args: {
+        readonly _tag: "ReasoningDelta";
+        readonly text: string;
+        readonly kind: "trace" | "summary";
+      }) => any;
+      readonly RefusalDelta: (args: {
+        readonly _tag: "RefusalDelta";
+        readonly text: string;
+      }) => any;
+      readonly ToolCallStart: (args: {
+        readonly _tag: "ToolCallStart";
+        readonly call_id: string;
+        readonly name: string;
+      }) => any;
+      readonly ToolCallArgsDelta: (args: {
+        readonly _tag: "ToolCallArgsDelta";
+        readonly call_id: string;
+        readonly delta: string;
+      }) => any;
+      readonly UsageUpdate: (args: {
+        readonly _tag: "UsageUpdate";
+        readonly usage: Usage;
+      }) => any;
+      readonly TurnComplete: (args: {
+        readonly _tag: "TurnComplete";
+        readonly turn: Turn;
+      }) => any;
+    }>(cases: Cases): (value: {
+      readonly _tag: "TextDelta";
+      readonly text: string;
+    } | {
+      readonly _tag: "ReasoningDelta";
+      readonly text: string;
+      readonly kind: "trace" | "summary";
+    } | {
+      readonly _tag: "RefusalDelta";
+      readonly text: string;
+    } | {
+      readonly _tag: "ToolCallStart";
+      readonly call_id: string;
+      readonly name: string;
+    } | {
+      readonly _tag: "ToolCallArgsDelta";
+      readonly call_id: string;
+      readonly delta: string;
+    } | {
+      readonly _tag: "UsageUpdate";
+      readonly usage: Usage;
+    } | {
+      readonly _tag: "TurnComplete";
+      readonly turn: Turn;
+    }) => _$effect_Unify0.Unify<ReturnType<Cases["TextDelta" | "ReasoningDelta" | "RefusalDelta" | "ToolCallStart" | "ToolCallArgsDelta" | "UsageUpdate" | "TurnComplete"]>>;
+    <Cases extends {
+      readonly TextDelta: (args: {
+        readonly _tag: "TextDelta";
+        readonly text: string;
+      }) => any;
+      readonly ReasoningDelta: (args: {
+        readonly _tag: "ReasoningDelta";
+        readonly text: string;
+        readonly kind: "trace" | "summary";
+      }) => any;
+      readonly RefusalDelta: (args: {
+        readonly _tag: "RefusalDelta";
+        readonly text: string;
+      }) => any;
+      readonly ToolCallStart: (args: {
+        readonly _tag: "ToolCallStart";
+        readonly call_id: string;
+        readonly name: string;
+      }) => any;
+      readonly ToolCallArgsDelta: (args: {
+        readonly _tag: "ToolCallArgsDelta";
+        readonly call_id: string;
+        readonly delta: string;
+      }) => any;
+      readonly UsageUpdate: (args: {
+        readonly _tag: "UsageUpdate";
+        readonly usage: Usage;
+      }) => any;
+      readonly TurnComplete: (args: {
+        readonly _tag: "TurnComplete";
+        readonly turn: Turn;
+      }) => any;
+    }>(value: {
+      readonly _tag: "TextDelta";
+      readonly text: string;
+    } | {
+      readonly _tag: "ReasoningDelta";
+      readonly text: string;
+      readonly kind: "trace" | "summary";
+    } | {
+      readonly _tag: "RefusalDelta";
+      readonly text: string;
+    } | {
+      readonly _tag: "ToolCallStart";
+      readonly call_id: string;
+      readonly name: string;
+    } | {
+      readonly _tag: "ToolCallArgsDelta";
+      readonly call_id: string;
+      readonly delta: string;
+    } | {
+      readonly _tag: "UsageUpdate";
+      readonly usage: Usage;
+    } | {
+      readonly _tag: "TurnComplete";
+      readonly turn: Turn;
+    }, cases: Cases): _$effect_Unify0.Unify<ReturnType<Cases["TextDelta" | "ReasoningDelta" | "RefusalDelta" | "ToolCallStart" | "ToolCallArgsDelta" | "UsageUpdate" | "TurnComplete"]>>;
+  };
+};
+/**
+ * What flows out of an agent loop body to its consumer per turn: every
+ * `TurnEvent` the provider emits (including the terminal `TurnComplete`
+ * carrying the assembled `Turn`), plus the output of any tool the loop ran.
+ * Both variants carry a `_tag` discriminator.
+ */
+type InteractionEvent = TurnEvent | FunctionCallOutput;
+declare const isTurnComplete: (u: unknown) => u is {
+  readonly _tag: "TurnComplete";
+  readonly turn: Turn;
+};
+declare const functionCalls: (turn: Turn) => ReadonlyArray<FunctionCall>;
+declare const reasonings: (turn: Turn) => ReadonlyArray<Reasoning>;
+declare const assistantMessages: (turn: Turn) => ReadonlyArray<Message>;
+/**
+ * Every `output_text` payload across every assistant message in the turn,
+ * preserving order. Refusals and other content blocks are dropped — use
+ * `assistantMessages` if you need to inspect them. The primitive for
+ * "give me the assistant's text"; callers decide how to combine
+ * (typically `.join("")` for prose or `.join(" ")` for log strings).
+ */
+declare const assistantTexts: (turn: Turn) => ReadonlyArray<string>;
+/**
+ * Sugar over `assistantTexts(turn).join("")` — the common case for
+ * summarizers, classifiers, judge calls, and structured-output backstops
+ * that want one concatenated string.
+ */
+declare const assistantText: (turn: Turn) => string;
+/**
+ * Append a completed turn and optional follow-up items to a state record's
+ * history. Recipes use this at the point where structured tool results are
+ * converted to model-facing `FunctionCallOutput`s.
+ */
+declare const appendTurn: <S extends {
+  readonly history: ReadonlyArray<Item>;
+}>(state: S, turn: Turn, items?: ReadonlyArray<Item>) => S;
+/**
+ * Project a `TurnEvent` stream onto its `TextDelta` 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 { 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

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

@@ -0,0 +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"}

package/dist/domain/AiError.d.mts

@@ -1,2 +1,2 @@
-import { a as Cancelled, c as GenerationFailed, d as RateLimited, f as Scope, h as Unsupported, 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-csR8Bhxx.mjs";
+import { a as Cancelled, c as GenerationFailed, d as RateLimited, f as Scope, h as Unsupported, 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-CAX_48RU.mjs";
 export { AiError, AuthFailed, AuthSubtype, Cancelled, ContentFiltered, ContextLengthExceeded, GenerationFailed, IncompleteTurn, InvalidRequest, RateLimited, Scope, Timeout, Unavailable, Unsupported };

package/dist/domain/AiError.mjs

@@ -30,7 +30,7 @@ var Cancelled = class extends Data.TaggedError("Cancelled") {};
 */
 var GenerationFailed = class extends Data.TaggedError("GenerationFailed") {};
 /**
-* The provider's delta stream ended without a terminal `turn_complete`.
+* The provider's delta stream ended without a terminal `TurnComplete`.
 * Indicates a misbehaving provider or a connection that dropped mid-flight.
 * Non-terminal deltas seen so far have already been emitted downstream.
 */