@effect-uai/core 0.5.2 → 0.6.0

package/dist/domain/Turn.d.mts

@@ -1,2 +1,388 @@
-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 };
+import { i as ImageSource } from "../Image-HNmMpMTh.mjs";
+import { d as Message, m as Reasoning, o as HistoryItem, v as ToolCall, x as Usage, y as ToolCallOutput } from "../Items-pXR5BAgW.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, appendToHistory, assistantMessages, assistantText, assistantTexts, decodeStructured, getToolCalls, isTurnComplete, reasonings, textDeltas };
+}
+/**
+ * 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 | ToolCallOutput;
+declare const isTurnComplete: (u: unknown) => u is {
+  readonly _tag: "TurnComplete";
+  readonly turn: Turn;
+};
+declare const getToolCalls: (turn: Turn) => ReadonlyArray<ToolCall>;
+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 `ToolCallOutput`s.
+ */
+declare const appendToHistory: <S extends {
+  readonly history: ReadonlyArray<HistoryItem>;
+}>(state: S, turn: Turn, items?: ReadonlyArray<HistoryItem>) => 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 `decodeStructured` 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 decodeStructured: <A>(turn: Turn, format: StructuredFormat<A>) => Effect.Effect<A, RefusalRejected | JsonParseError | StructuredDecodeError>;
+//#endregion
+export { InteractionEvent, RefusalRejected, Turn, TurnEvent, appendToHistory, assistantMessages, assistantText, assistantTexts, decodeStructured, getToolCalls, isTurnComplete, reasonings, Turn_d_exports as t, textDeltas };
+//# sourceMappingURL=Turn.d.mts.map

package/dist/domain/Turn.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Turn.d.mts","names":[],"sources":["../../src/domain/Turn.ts"],"mappings":";;;;;;;;;;;;;;;;;cAqBa,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,cAAA;AAAA,cAE9B,cAAA,GAAc,CAAA,cAAA,CAAA;EAAA;iBAbM,IAAA;AAAA;AAAA,cAepB,YAAA,GAAgB,IAAA,EAAM,IAAA,KAAO,aAAA,CAAc,QAAA;AAAA,cAE3C,UAAA,GAAc,IAAA,EAAM,IAAA,KAAO,aAAA,CAAc,SAAA;AAAA,cAEzC,iBAAA,GAAqB,IAAA,EAAM,IAAA,KAAO,aAAA,CAAc,OAAA;;;;;;;;cAUhD,cAAA,GAAkB,IAAA,EAAM,IAAA,KAAO,aAAA;;;;;;cAW/B,aAAA,GAAiB,IAAA,EAAM,IAAA;;;;;AA/CpC;cAsDa,eAAA;EAAA,SAAwC,OAAA,EAAS,aAAA,CAAc,WAAA;AAAA,GAC1E,KAAA,EAAO,CAAA,EACP,IAAA,EAAM,IAAA,EACN,KAAA,GAAO,aAAA,CAAc,WAAA,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;;;;;;;;;;AA/EjB;cAwGa,gBAAA,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/Turn.mjs

@@ -1,5 +1,5 @@
 import { n as __exportAll } from "../chunk-uyGKjUfl.mjs";
-import { Item, StopReason, Usage, isOutputText, isRefusal } from "./Items.mjs";
+import { HistoryItem, StopReason, Usage, isOutputText, isReasoning, isRefusal, isToolCall } from "./Items.mjs";
 import { parseJson } from "../structured-format/StructuredFormat.mjs";
 import { Data, Effect, Result, Schema, Stream, pipe } from "effect";
 //#region src/domain/Turn.ts
@@ -7,15 +7,15 @@ var Turn_exports = /* @__PURE__ */ __exportAll({
 	RefusalRejected: () => RefusalRejected,
 	Turn: () => Turn,
 	TurnEvent: () => TurnEvent,
-	appendTurn: () => appendTurn,
+	appendToHistory: () => appendToHistory,
 	assistantMessages: () => assistantMessages,
 	assistantText: () => assistantText,
 	assistantTexts: () => assistantTexts,
-	functionCalls: () => functionCalls,
+	decodeStructured: () => decodeStructured,
+	getToolCalls: () => getToolCalls,
 	isTurnComplete: () => isTurnComplete,
 	reasonings: () => reasonings,
-	textDeltas: () => textDeltas,
-	toStructured: () => toStructured
+	textDeltas: () => textDeltas
 });
 /**
 * The result of a single LLM generation. A turn produces zero or more items
@@ -23,14 +23,14 @@ var Turn_exports = /* @__PURE__ */ __exportAll({
 * and reports usage + a stop reason.
 */
 const Turn = Schema.Struct({
-	items: Schema.Array(Item),
+	items: Schema.Array(HistoryItem),
 	usage: Usage,
 	stop_reason: StopReason
 });
 const TurnEvent = Data.taggedEnum();
 const isTurnComplete = TurnEvent.$is("TurnComplete");
-const functionCalls = (turn) => turn.items.filter((i) => i.type === "function_call");
-const reasonings = (turn) => turn.items.filter((i) => i.type === "reasoning");
+const getToolCalls = (turn) => turn.items.filter(isToolCall);
+const reasonings = (turn) => turn.items.filter(isReasoning);
 const assistantMessages = (turn) => turn.items.filter((i) => i.type === "message" && i.role === "assistant");
 /**
 * Every `output_text` payload across every assistant message in the turn,
@@ -49,9 +49,9 @@ const assistantText = (turn) => assistantTexts(turn).join("");
 /**
 * 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.
+* converted to model-facing `ToolCallOutput`s.
 */
-const appendTurn = (state, turn, items = []) => ({
+const appendToHistory = (state, turn, items = []) => ({
 	...state,
 	history: [
 		...state.history,
@@ -67,7 +67,7 @@ const appendTurn = (state, turn, items = []) => ({
 const textDeltas = (self) => self.pipe(Stream.filterMap((ev) => ev._tag === "TextDelta" ? Result.succeed(ev.text) : Result.failVoid));
 /**
 * The assistant message on the just-completed turn was a refusal block,
-* not an `output_text` payload. Returned by `toStructured` to short-circuit
+* not an `output_text` payload. Returned by `decodeStructured` to short-circuit
 * decoding before `JSON.parse` / schema validation runs.
 */
 var RefusalRejected = class extends Data.TaggedError("RefusalRejected") {};
@@ -97,8 +97,8 @@ const lastAssistantContent = (turn) => {
 * - `JsonParseError` — the assembled text wasn't valid JSON.
 * - `StructuredDecodeError` — the JSON didn't match the schema.
 */
-const toStructured = (turn, format) => pipe(lastAssistantContent(turn), ({ text, refused }) => refused ? Effect.fail(new RefusalRejected({ turn })) : parseJson(format)(text));
+const decodeStructured = (turn, format) => pipe(lastAssistantContent(turn), ({ text, refused }) => refused ? Effect.fail(new RefusalRejected({ turn })) : parseJson(format)(text));
 //#endregion
-export { RefusalRejected, Turn, TurnEvent, appendTurn, assistantMessages, assistantText, assistantTexts, functionCalls, isTurnComplete, reasonings, Turn_exports as t, textDeltas, toStructured };
+export { RefusalRejected, Turn, TurnEvent, appendToHistory, assistantMessages, assistantText, assistantTexts, decodeStructured, getToolCalls, isTurnComplete, reasonings, Turn_exports as t, textDeltas };
 
 //# sourceMappingURL=Turn.mjs.map

package/dist/domain/Turn.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"Turn.mjs","names":["StructuredFormat.parseJson"],"sources":["../../src/domain/Turn.ts"],"sourcesContent":["import { Data, Effect, Result, Schema, Stream, pipe } from \"effect\"\nimport * as StructuredFormat from \"../structured-format/StructuredFormat.js\"\nimport {\n  FunctionCall,\n  FunctionCallOutput,\n  Item,\n  isOutputText,\n  isRefusal,\n  Message,\n  Reasoning,\n  StopReason,\n  Usage,\n} from \"./Items.js\"\n\n/**\n * The result of a single LLM generation. A turn produces zero or more items\n * (typically one assistant message and zero or more function_call items)\n * and reports usage + a stop reason.\n */\nexport const Turn = Schema.Struct({\n  items: Schema.Array(Item),\n  usage: Usage,\n  stop_reason: StopReason,\n})\nexport type Turn = typeof Turn.Type\n\n/**\n * Canonical events emitted while a single turn is being generated. Most\n * variants are streaming deltas (text, reasoning, tool-call args); the\n * terminal `TurnComplete` carries the assembled `Turn`. Lifecycle members\n * aren't deltas, hence the union name.\n *\n * `ReasoningDelta.kind`: `trace` is the model's raw chain-of-thought;\n * `summary` is a model-written summary intended for display. OpenAI\n * Responses emits both; Anthropic and Gemini only emit `trace`.\n *\n * `RefusalDelta`: the model declined to answer. OpenAI Responses emits\n * this as its own event; Anthropic surfaces refusals via `stop_reason`\n * and Gemini collapses them into `finishReason: SAFETY` — both go\n * without a `RefusalDelta`.\n *\n * `UsageUpdate`: mid-stream cumulative usage. Anthropic emits this on\n * `message_start` and `message_delta`; other providers may only deliver\n * usage via `TurnComplete.turn.usage`.\n */\nexport type TurnEvent = Data.TaggedEnum<{\n  TextDelta: { readonly text: string }\n  ReasoningDelta: { readonly text: string; readonly kind: \"trace\" | \"summary\" }\n  RefusalDelta: { readonly text: string }\n  ToolCallStart: { readonly call_id: string; readonly name: string }\n  ToolCallArgsDelta: { readonly call_id: string; readonly delta: string }\n  UsageUpdate: { readonly usage: Usage }\n  TurnComplete: { readonly turn: Turn }\n}>\n\nexport const TurnEvent = Data.taggedEnum<TurnEvent>()\n\n/**\n * What flows out of an agent loop body to its consumer per turn: every\n * `TurnEvent` the provider emits (including the terminal `TurnComplete`\n * carrying the assembled `Turn`), plus the output of any tool the loop ran.\n * Both variants carry a `_tag` discriminator.\n */\nexport type InteractionEvent = TurnEvent | FunctionCallOutput\n\nexport const isTurnComplete = TurnEvent.$is(\"TurnComplete\")\n\nexport const functionCalls = (turn: Turn): ReadonlyArray<FunctionCall> =>\n  turn.items.filter((i): i is FunctionCall => i.type === \"function_call\")\n\nexport const reasonings = (turn: Turn): ReadonlyArray<Reasoning> =>\n  turn.items.filter((i): i is Reasoning => i.type === \"reasoning\")\n\nexport const assistantMessages = (turn: Turn): ReadonlyArray<Message> =>\n  turn.items.filter((i): i is Message => i.type === \"message\" && i.role === \"assistant\")\n\n/**\n * Every `output_text` payload across every assistant message in the turn,\n * preserving order. Refusals and other content blocks are dropped — use\n * `assistantMessages` if you need to inspect them. The primitive for\n * \"give me the assistant's text\"; callers decide how to combine\n * (typically `.join(\"\")` for prose or `.join(\" \")` for log strings).\n */\nexport const assistantTexts = (turn: Turn): ReadonlyArray<string> =>\n  assistantMessages(turn)\n    .flatMap((m) => m.content)\n    .filter(isOutputText)\n    .map((b) => b.text)\n\n/**\n * Sugar over `assistantTexts(turn).join(\"\")` — the common case for\n * summarizers, classifiers, judge calls, and structured-output backstops\n * that want one concatenated string.\n */\nexport const assistantText = (turn: Turn): string => assistantTexts(turn).join(\"\")\n\n/**\n * Append a completed turn and optional follow-up items to a state record's\n * history. Recipes use this at the point where structured tool results are\n * converted to model-facing `FunctionCallOutput`s.\n */\nexport const appendTurn = <S extends { readonly history: ReadonlyArray<Item> }>(\n  state: S,\n  turn: Turn,\n  items: ReadonlyArray<Item> = [],\n): S => ({\n  ...state,\n  history: [...state.history, ...turn.items, ...items],\n})\n\n// ---------------------------------------------------------------------------\n// Stream operators\n// ---------------------------------------------------------------------------\n\n/**\n * Project a `TurnEvent` stream onto its `TextDelta` payloads. Other\n * variants are dropped. Composes with `Lines.lines` +\n * `decodeJsonLines` for prompted-JSONL streaming.\n */\nexport const textDeltas = <E, R>(\n  self: Stream.Stream<TurnEvent, E, R>,\n): Stream.Stream<string, E, R> =>\n  self.pipe(\n    Stream.filterMap((ev) => (ev._tag === \"TextDelta\" ? Result.succeed(ev.text) : Result.failVoid)),\n  )\n\n// ---------------------------------------------------------------------------\n// Structured-output integration\n// ---------------------------------------------------------------------------\n\n/**\n * The assistant message on the just-completed turn was a refusal block,\n * not an `output_text` payload. Returned by `toStructured` to short-circuit\n * decoding before `JSON.parse` / schema validation runs.\n */\nexport class RefusalRejected extends Data.TaggedError(\"RefusalRejected\")<{\n  readonly turn: Turn\n}> {}\n\nconst lastAssistantContent = (turn: Turn): { readonly text: string; readonly refused: boolean } => {\n  const assistants = assistantMessages(turn)\n  const last = assistants[assistants.length - 1]\n  if (last === undefined) return { text: \"\", refused: false }\n  if (last.content.some(isRefusal)) return { text: \"\", refused: true }\n  const text = last.content\n    .filter(isOutputText)\n    .map((b) => b.text)\n    .join(\"\")\n  return { text, refused: false }\n}\n\n/**\n * Validate a completed `Turn` against a `StructuredFormat`. Concatenates\n * `output_text` blocks on the last assistant message, then runs\n * `JSON.parse` + the format's schema validation.\n *\n * Three failure modes:\n * - `RefusalRejected` — the assistant emitted a refusal block.\n * - `JsonParseError` — the assembled text wasn't valid JSON.\n * - `StructuredDecodeError` — the JSON didn't match the schema.\n */\nexport const toStructured = <A>(\n  turn: Turn,\n  format: StructuredFormat.StructuredFormat<A>,\n): Effect.Effect<\n  A,\n  RefusalRejected | StructuredFormat.JsonParseError | StructuredFormat.StructuredDecodeError\n> =>\n  pipe(lastAssistantContent(turn), ({ text, refused }) =>\n    refused ? Effect.fail(new RefusalRejected({ turn })) : StructuredFormat.parseJson(format)(text),\n  )\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAmBA,MAAa,OAAO,OAAO,OAAO;CAChC,OAAO,OAAO,MAAM,KAAK;CACzB,OAAO;CACP,aAAa;CACd,CAAC;AAgCF,MAAa,YAAY,KAAK,YAAuB;AAUrD,MAAa,iBAAiB,UAAU,IAAI,eAAe;AAE3D,MAAa,iBAAiB,SAC5B,KAAK,MAAM,QAAQ,MAAyB,EAAE,SAAS,gBAAgB;AAEzE,MAAa,cAAc,SACzB,KAAK,MAAM,QAAQ,MAAsB,EAAE,SAAS,YAAY;AAElE,MAAa,qBAAqB,SAChC,KAAK,MAAM,QAAQ,MAAoB,EAAE,SAAS,aAAa,EAAE,SAAS,YAAY;;;;;;;;AASxF,MAAa,kBAAkB,SAC7B,kBAAkB,KAAK,CACpB,SAAS,MAAM,EAAE,QAAQ,CACzB,OAAO,aAAa,CACpB,KAAK,MAAM,EAAE,KAAK;;;;;;AAOvB,MAAa,iBAAiB,SAAuB,eAAe,KAAK,CAAC,KAAK,GAAG;;;;;;AAOlF,MAAa,cACX,OACA,MACA,QAA6B,EAAE,MACxB;CACP,GAAG;CACH,SAAS;EAAC,GAAG,MAAM;EAAS,GAAG,KAAK;EAAO,GAAG;EAAM;CACrD;;;;;;AAWD,MAAa,cACX,SAEA,KAAK,KACH,OAAO,WAAW,OAAQ,GAAG,SAAS,cAAc,OAAO,QAAQ,GAAG,KAAK,GAAG,OAAO,SAAU,CAChG;;;;;;AAWH,IAAa,kBAAb,cAAqC,KAAK,YAAY,kBAAkB,CAErE;AAEH,MAAM,wBAAwB,SAAqE;CACjG,MAAM,aAAa,kBAAkB,KAAK;CAC1C,MAAM,OAAO,WAAW,WAAW,SAAS;AAC5C,KAAI,SAAS,KAAA,EAAW,QAAO;EAAE,MAAM;EAAI,SAAS;EAAO;AAC3D,KAAI,KAAK,QAAQ,KAAK,UAAU,CAAE,QAAO;EAAE,MAAM;EAAI,SAAS;EAAM;AAKpE,QAAO;EAAE,MAJI,KAAK,QACf,OAAO,aAAa,CACpB,KAAK,MAAM,EAAE,KAAK,CAClB,KAAK,GACK;EAAE,SAAS;EAAO;;;;;;;;;;;;AAajC,MAAa,gBACX,MACA,WAKA,KAAK,qBAAqB,KAAK,GAAG,EAAE,MAAM,cACxC,UAAU,OAAO,KAAK,IAAI,gBAAgB,EAAE,MAAM,CAAC,CAAC,GAAGA,UAA2B,OAAO,CAAC,KAAK,CAChG"}
+{"version":3,"file":"Turn.mjs","names":["StructuredFormat.parseJson"],"sources":["../../src/domain/Turn.ts"],"sourcesContent":["import { Data, Effect, Result, Schema, Stream, pipe } from \"effect\"\nimport * as StructuredFormat from \"../structured-format/StructuredFormat.js\"\nimport {\n  HistoryItem,\n  Message,\n  Reasoning,\n  StopReason,\n  ToolCall,\n  ToolCallOutput,\n  Usage,\n  isOutputText,\n  isReasoning,\n  isRefusal,\n  isToolCall,\n} from \"./Items.js\"\n\n/**\n * The result of a single LLM generation. A turn produces zero or more items\n * (typically one assistant message and zero or more function_call items)\n * and reports usage + a stop reason.\n */\nexport const Turn = Schema.Struct({\n  items: Schema.Array(HistoryItem),\n  usage: Usage,\n  stop_reason: StopReason,\n})\nexport type Turn = typeof Turn.Type\n\n/**\n * Canonical events emitted while a single turn is being generated. Most\n * variants are streaming deltas (text, reasoning, tool-call args); the\n * terminal `TurnComplete` carries the assembled `Turn`. Lifecycle members\n * aren't deltas, hence the union name.\n *\n * `ReasoningDelta.kind`: `trace` is the model's raw chain-of-thought;\n * `summary` is a model-written summary intended for display. OpenAI\n * Responses emits both; Anthropic and Gemini only emit `trace`.\n *\n * `RefusalDelta`: the model declined to answer. OpenAI Responses emits\n * this as its own event; Anthropic surfaces refusals via `stop_reason`\n * and Gemini collapses them into `finishReason: SAFETY` — both go\n * without a `RefusalDelta`.\n *\n * `UsageUpdate`: mid-stream cumulative usage. Anthropic emits this on\n * `message_start` and `message_delta`; other providers may only deliver\n * usage via `TurnComplete.turn.usage`.\n */\nexport type TurnEvent = Data.TaggedEnum<{\n  TextDelta: { readonly text: string }\n  ReasoningDelta: { readonly text: string; readonly kind: \"trace\" | \"summary\" }\n  RefusalDelta: { readonly text: string }\n  ToolCallStart: { readonly call_id: string; readonly name: string }\n  ToolCallArgsDelta: { readonly call_id: string; readonly delta: string }\n  UsageUpdate: { readonly usage: Usage }\n  TurnComplete: { readonly turn: Turn }\n}>\n\nexport const TurnEvent = Data.taggedEnum<TurnEvent>()\n\n/**\n * What flows out of an agent loop body to its consumer per turn: every\n * `TurnEvent` the provider emits (including the terminal `TurnComplete`\n * carrying the assembled `Turn`), plus the output of any tool the loop ran.\n * Both variants carry a `_tag` discriminator.\n */\nexport type InteractionEvent = TurnEvent | ToolCallOutput\n\nexport const isTurnComplete = TurnEvent.$is(\"TurnComplete\")\n\nexport const getToolCalls = (turn: Turn): ReadonlyArray<ToolCall> => turn.items.filter(isToolCall)\n\nexport const reasonings = (turn: Turn): ReadonlyArray<Reasoning> => turn.items.filter(isReasoning)\n\nexport const assistantMessages = (turn: Turn): ReadonlyArray<Message> =>\n  turn.items.filter((i): i is Message => i.type === \"message\" && i.role === \"assistant\")\n\n/**\n * Every `output_text` payload across every assistant message in the turn,\n * preserving order. Refusals and other content blocks are dropped — use\n * `assistantMessages` if you need to inspect them. The primitive for\n * \"give me the assistant's text\"; callers decide how to combine\n * (typically `.join(\"\")` for prose or `.join(\" \")` for log strings).\n */\nexport const assistantTexts = (turn: Turn): ReadonlyArray<string> =>\n  assistantMessages(turn)\n    .flatMap((m) => m.content)\n    .filter(isOutputText)\n    .map((b) => b.text)\n\n/**\n * Sugar over `assistantTexts(turn).join(\"\")` — the common case for\n * summarizers, classifiers, judge calls, and structured-output backstops\n * that want one concatenated string.\n */\nexport const assistantText = (turn: Turn): string => assistantTexts(turn).join(\"\")\n\n/**\n * Append a completed turn and optional follow-up items to a state record's\n * history. Recipes use this at the point where structured tool results are\n * converted to model-facing `ToolCallOutput`s.\n */\nexport const appendToHistory = <S extends { readonly history: ReadonlyArray<HistoryItem> }>(\n  state: S,\n  turn: Turn,\n  items: ReadonlyArray<HistoryItem> = [],\n): S => ({\n  ...state,\n  history: [...state.history, ...turn.items, ...items],\n})\n\n// ---------------------------------------------------------------------------\n// Stream operators\n// ---------------------------------------------------------------------------\n\n/**\n * Project a `TurnEvent` stream onto its `TextDelta` payloads. Other\n * variants are dropped. Composes with `Lines.lines` +\n * `decodeJsonLines` for prompted-JSONL streaming.\n */\nexport const textDeltas = <E, R>(\n  self: Stream.Stream<TurnEvent, E, R>,\n): Stream.Stream<string, E, R> =>\n  self.pipe(\n    Stream.filterMap((ev) => (ev._tag === \"TextDelta\" ? Result.succeed(ev.text) : Result.failVoid)),\n  )\n\n// ---------------------------------------------------------------------------\n// Structured-output integration\n// ---------------------------------------------------------------------------\n\n/**\n * The assistant message on the just-completed turn was a refusal block,\n * not an `output_text` payload. Returned by `decodeStructured` to short-circuit\n * decoding before `JSON.parse` / schema validation runs.\n */\nexport class RefusalRejected extends Data.TaggedError(\"RefusalRejected\")<{\n  readonly turn: Turn\n}> {}\n\nconst lastAssistantContent = (turn: Turn): { readonly text: string; readonly refused: boolean } => {\n  const assistants = assistantMessages(turn)\n  const last = assistants[assistants.length - 1]\n  if (last === undefined) return { text: \"\", refused: false }\n  if (last.content.some(isRefusal)) return { text: \"\", refused: true }\n  const text = last.content\n    .filter(isOutputText)\n    .map((b) => b.text)\n    .join(\"\")\n  return { text, refused: false }\n}\n\n/**\n * Validate a completed `Turn` against a `StructuredFormat`. Concatenates\n * `output_text` blocks on the last assistant message, then runs\n * `JSON.parse` + the format's schema validation.\n *\n * Three failure modes:\n * - `RefusalRejected` — the assistant emitted a refusal block.\n * - `JsonParseError` — the assembled text wasn't valid JSON.\n * - `StructuredDecodeError` — the JSON didn't match the schema.\n */\nexport const decodeStructured = <A>(\n  turn: Turn,\n  format: StructuredFormat.StructuredFormat<A>,\n): Effect.Effect<\n  A,\n  RefusalRejected | StructuredFormat.JsonParseError | StructuredFormat.StructuredDecodeError\n> =>\n  pipe(lastAssistantContent(turn), ({ text, refused }) =>\n    refused ? Effect.fail(new RefusalRejected({ turn })) : StructuredFormat.parseJson(format)(text),\n  )\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAqBA,MAAa,OAAO,OAAO,OAAO;CAChC,OAAO,OAAO,MAAM,YAAY;CAChC,OAAO;CACP,aAAa;CACd,CAAC;AAgCF,MAAa,YAAY,KAAK,YAAuB;AAUrD,MAAa,iBAAiB,UAAU,IAAI,eAAe;AAE3D,MAAa,gBAAgB,SAAwC,KAAK,MAAM,OAAO,WAAW;AAElG,MAAa,cAAc,SAAyC,KAAK,MAAM,OAAO,YAAY;AAElG,MAAa,qBAAqB,SAChC,KAAK,MAAM,QAAQ,MAAoB,EAAE,SAAS,aAAa,EAAE,SAAS,YAAY;;;;;;;;AASxF,MAAa,kBAAkB,SAC7B,kBAAkB,KAAK,CACpB,SAAS,MAAM,EAAE,QAAQ,CACzB,OAAO,aAAa,CACpB,KAAK,MAAM,EAAE,KAAK;;;;;;AAOvB,MAAa,iBAAiB,SAAuB,eAAe,KAAK,CAAC,KAAK,GAAG;;;;;;AAOlF,MAAa,mBACX,OACA,MACA,QAAoC,EAAE,MAC/B;CACP,GAAG;CACH,SAAS;EAAC,GAAG,MAAM;EAAS,GAAG,KAAK;EAAO,GAAG;EAAM;CACrD;;;;;;AAWD,MAAa,cACX,SAEA,KAAK,KACH,OAAO,WAAW,OAAQ,GAAG,SAAS,cAAc,OAAO,QAAQ,GAAG,KAAK,GAAG,OAAO,SAAU,CAChG;;;;;;AAWH,IAAa,kBAAb,cAAqC,KAAK,YAAY,kBAAkB,CAErE;AAEH,MAAM,wBAAwB,SAAqE;CACjG,MAAM,aAAa,kBAAkB,KAAK;CAC1C,MAAM,OAAO,WAAW,WAAW,SAAS;AAC5C,KAAI,SAAS,KAAA,EAAW,QAAO;EAAE,MAAM;EAAI,SAAS;EAAO;AAC3D,KAAI,KAAK,QAAQ,KAAK,UAAU,CAAE,QAAO;EAAE,MAAM;EAAI,SAAS;EAAM;AAKpE,QAAO;EAAE,MAJI,KAAK,QACf,OAAO,aAAa,CACpB,KAAK,MAAM,EAAE,KAAK,CAClB,KAAK,GACK;EAAE,SAAS;EAAO;;;;;;;;;;;;AAajC,MAAa,oBACX,MACA,WAKA,KAAK,qBAAqB,KAAK,GAAG,EAAE,MAAM,cACxC,UAAU,OAAO,KAAK,IAAI,gBAAgB,EAAE,MAAM,CAAC,CAAC,GAAGA,UAA2B,OAAO,CAAC,KAAK,CAChG"}

package/dist/index.d.mts

@@ -2,28 +2,33 @@ 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-BH8xUkoR.mjs";
+import { u as Items_d_exports } from "./Items-pXR5BAgW.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-0CwCAyVe.mjs";
+import { t as Turn_d_exports } from "./domain/Turn.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-87ViKCCO.mjs";
+import { l as Tool_d_exports } from "./Tool-DP-AwKOf.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 Memory_d_exports } from "./sandbox/Memory.mjs";
+import { o as SandboxError_d_exports } from "./SandboxError-BvKypkJm.mjs";
+import { t as Sandbox_d_exports } from "./sandbox/Sandbox.mjs";
+import { t as SandboxImage_d_exports } from "./sandbox/SandboxImage.mjs";
+import { t as SandboxNetwork_d_exports } from "./sandbox/SandboxNetwork.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 ToolResult_d_exports } from "./tool/ToolResult.mjs";
 import { t as ToolEvent_d_exports } from "./tool/ToolEvent.mjs";
 import { t as Toolkit_d_exports } from "./tool/Toolkit.mjs";
-import { t as Resolvers_d_exports } from "./tool/Resolvers.mjs";
+import { t as Approval_d_exports } from "./tool/Approval.mjs";
 import { t as HistoryCheck_d_exports } from "./tool/HistoryCheck.mjs";
 import { t as JSONL_d_exports } from "./streaming/JSONL.mjs";
 import { t as Lines_d_exports } from "./streaming/Lines.mjs";
 import { t as SSE_d_exports } from "./streaming/SSE.mjs";
 import { t as Metrics_d_exports } from "./observability/Metrics.mjs";
-export { AiError_d_exports as AiError, 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 };
+export { AiError_d_exports as AiError, Approval_d_exports as Approval, 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, Memory_d_exports as Memory, Metrics_d_exports as Metrics, Music_d_exports as Music, MusicGenerator_d_exports as MusicGenerator, Retry_d_exports as Retry, SSE_d_exports as SSE, Sandbox_d_exports as Sandbox, SandboxError_d_exports as SandboxError, SandboxImage_d_exports as SandboxImage, SandboxNetwork_d_exports as SandboxNetwork, SpeechSynthesizer_d_exports as SpeechSynthesizer, StructuredFormat_d_exports as StructuredFormat, Tool_d_exports as Tool, ToolEvent_d_exports as ToolEvent, ToolResult_d_exports as ToolResult, 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

@@ -11,19 +11,24 @@ import { t as Embedding_exports } from "./embedding-model/Embedding.mjs";
 import { t as EmbeddingModel_exports } from "./embedding-model/EmbeddingModel.mjs";
 import { t as LanguageModel_exports } from "./language-model/LanguageModel.mjs";
 import { t as MusicGenerator_exports } from "./music-generator/MusicGenerator.mjs";
+import { t as Memory_exports } from "./sandbox/Memory.mjs";
+import { t as Sandbox_exports } from "./sandbox/Sandbox.mjs";
+import { t as SandboxError_exports } from "./sandbox/SandboxError.mjs";
+import { t as SandboxImage_exports } from "./sandbox/SandboxImage.mjs";
+import { t as SandboxNetwork_exports } from "./sandbox/SandboxNetwork.mjs";
 import { t as SpeechSynthesizer_exports } from "./speech-synthesizer/SpeechSynthesizer.mjs";
 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 ToolResult_exports } from "./tool/ToolResult.mjs";
 import { t as ToolEvent_exports } from "./tool/ToolEvent.mjs";
 import { t as Toolkit_exports } from "./tool/Toolkit.mjs";
-import { t as Resolvers_exports } from "./tool/Resolvers.mjs";
+import { t as Approval_exports } from "./tool/Approval.mjs";
 import { t as HistoryCheck_exports } from "./tool/HistoryCheck.mjs";
 import { t as JSONL_exports } from "./streaming/JSONL.mjs";
 import { t as Lines_exports } from "./streaming/Lines.mjs";
 import { t as SSE_exports } from "./streaming/SSE.mjs";
 import { t as Metrics_exports } from "./observability/Metrics.mjs";
-export { AiError_exports as AiError, 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 };
+export { AiError_exports as AiError, Approval_exports as Approval, 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, Memory_exports as Memory, Metrics_exports as Metrics, Music_exports as Music, MusicGenerator_exports as MusicGenerator, Retry_exports as Retry, SSE_exports as SSE, Sandbox_exports as Sandbox, SandboxError_exports as SandboxError, SandboxImage_exports as SandboxImage, SandboxNetwork_exports as SandboxNetwork, SpeechSynthesizer_exports as SpeechSynthesizer, StructuredFormat_exports as StructuredFormat, Tool_exports as Tool, ToolEvent_exports as ToolEvent, ToolResult_exports as ToolResult, 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,8 +1,8 @@
 import { t as AiError } from "../AiError-CAX_48RU.mjs";
-import { d as Item } from "../Items-BH8xUkoR.mjs";
+import { o as HistoryItem } from "../Items-pXR5BAgW.mjs";
 import { i as StructuredFormat } from "../StructuredFormat-BbN4dosH.mjs";
-import { i as TurnEvent, r as Turn } from "../Turn-0CwCAyVe.mjs";
-import { o as ToolDescriptor } from "../Tool-87ViKCCO.mjs";
+import { Turn, TurnEvent } from "../domain/Turn.mjs";
+import { o as ToolDescriptor } from "../Tool-DP-AwKOf.mjs";
 import { Context, Effect, Stream } from "effect";
 
 //#region src/language-model/LanguageModel.d.ts
@@ -16,7 +16,7 @@ declare namespace LanguageModel_d_exports {
  * ...) lives in that provider's own request interface, which extends this.
  */
 type CommonRequest = {
-  readonly history: ReadonlyArray<Item>;
+  readonly history: ReadonlyArray<HistoryItem>;
   /**
    * Model identifier. Each provider narrows this to its typed literal union,
    * so code that yields a typed provider tag gets autocompletion.
@@ -32,7 +32,7 @@ type CommonRequest = {
   readonly maxOutputTokens?: number;
   /**
    * Schema-bound JSON output. The provider constrains the wire to match the
-   * schema; pair with `Turn.toStructured` for runtime validation. Supported
+   * schema; pair with `Turn.decodeStructured` for runtime validation. Supported
    * across all current providers (OpenAI Responses json_schema, Anthropic
    * `output_config`, Gemini `responseJsonSchema`).
    */

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;;;;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"}
+{"version":3,"file":"LanguageModel.d.mts","names":[],"sources":["../../src/language-model/LanguageModel.ts"],"mappings":";;;;;;;;;;;;;;;;;KAaY,aAAA;EAAA,SACD,OAAA,EAAS,aAAA,CAAc,WAAA;;;;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"}