@effect-uai/core 0.5.2 → 0.7.0

package/README.md

@@ -10,7 +10,7 @@ This package exposes:
 
 - **Domain types** - `Items`, `Turn`, `AiError`
 - **Provider contract** - `LanguageModel`
-- **Loop primitive** - `Loop` (`loop`, `loopWithState`, `value`, `next`, `stop`, `nextAfter`, `nextAfterFold`, `onTurnComplete`)
+- **Loop primitive** - `Loop` (`loop`, `loopWithState`, `value`, `next`, `stop`, `nextAfter`, `onTurnComplete`)
 - **Tools** - `Tool`, `Toolkit`, `Outcome`, `ToolEvent`, `Resolvers`, `HistoryCheck`
 - **Streaming codecs** - `SSE`, `JSONL`, `Lines`
 - **Structured output** - `StructuredFormat`

package/dist/{Audio-BfCTGnH3.d.mts → Audio-DPlTsNdz.d.mts}

@@ -1,4 +1,5 @@
 import { i as MediaUrl, n as MediaBytes, t as MediaBase64 } from "./Media-D_CpcM1Z.mjs";
+import { Duration } from "effect";
 
 //#region src/domain/Audio.d.ts
 declare namespace Audio_d_exports {
@@ -54,8 +55,8 @@ type AudioChunk = {
 type AudioBlob = {
   readonly format: AudioFormat;
   readonly bytes: Uint8Array;
-  readonly durationSeconds?: number;
+  readonly duration?: Duration.Duration;
 };
 //#endregion
 export { AudioSource as a, isAudioBytes as c, AudioMimeType as i, isAudioUrl as l, AudioChunk as n, Audio_d_exports as o, AudioFormat as r, isAudioBase64 as s, AudioBlob as t };
-//# sourceMappingURL=Audio-BfCTGnH3.d.mts.map
+//# sourceMappingURL=Audio-DPlTsNdz.d.mts.map

package/dist/Audio-DPlTsNdz.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Audio-DPlTsNdz.d.mts","names":[],"sources":["../src/domain/Audio.ts"],"mappings":";;;;;;;;;;;;;;;KAWY,aAAA;;;;;AAAZ;;;;;KA0BY,WAAA,GACR,QAAA,CAAS,aAAA,IACT,WAAA,CAAY,aAAA,IACZ,UAAA,CAAW,aAAA;AAAA,cAEF,UAAA,GAAc,CAAA,EAAG,WAAA,KAAc,CAAA,IAAK,QAAA,CAAS,aAAA;AAAA,cAC7C,aAAA,GAAiB,CAAA,EAAG,WAAA,KAAc,CAAA,IAAK,WAAA,CAAY,aAAA;AAAA,cAEnD,YAAA,GAAgB,CAAA,EAAG,WAAA,KAAc,CAAA,IAAK,UAAA,CAAW,aAAA;;;;;;;KAQlD,WAAA;EAAA,SACD,SAAA;EAAA,SACA,QAAA;EAAA,SAUA,UAAA,wDA1BK;EAAA,SA4BL,OAAA;EAAA,SACA,QAAA;AAAA;;AA1BX;;;;KAkCY,UAAA;EAAA,SACD,KAAA,EAAO,UAAA;AAAA;;;;;KAON,SAAA;EAAA,SACD,MAAA,EAAQ,WAAA;EAAA,SACR,KAAA,EAAO,UAAA;EAAA,SACP,QAAA,GAAW,QAAA,CAAS,QAAA;AAAA"}

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

@@ -3,7 +3,7 @@ import { Schema } from "effect";
 
 //#region src/domain/Items.d.ts
 declare namespace Items_d_exports {
-  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 };
+  export { Annotation, ContainerFileCitation, ContentBlock, FileCitation, FilePath, HistoryItem, InputImage, InputText, InputTokensDetails, Message, OutputText, OutputTokensDetails, Reasoning, Refusal, Role, StopReason, ToolCall, ToolCallOutput, UrlCitation, Usage, assistantText, isContainerFileCitation, isFileCitation, isFilePath, isInputImage, isInputText, isMessage, isOutputText, isReasoning, isRefusal, isToolCall, isToolCallOutput, isUrlCitation, systemText, toolCallOutput, userText };
 }
 declare const InputText: Schema.Struct<{
   readonly type: Schema.Literal<"input_text">;
@@ -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;
@@ -211,21 +211,21 @@ declare const Message: Schema.Struct<{
   readonly providerData: Schema.optional<Schema.Unknown>;
 }>;
 type Message = typeof Message.Type;
-declare const FunctionCall: Schema.Struct<{
+declare const ToolCall: 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>;
 }>;
-type FunctionCall = typeof FunctionCall.Type;
-declare const FunctionCallOutput: Schema.Struct<{
+type ToolCall = typeof ToolCall.Type;
+declare const ToolCallOutput: Schema.Struct<{
   readonly type: Schema.Literal<"function_call_output">;
   readonly call_id: Schema.String;
   readonly output: Schema.String;
   readonly providerData: Schema.optional<Schema.Unknown>;
 }>;
-type FunctionCallOutput = typeof FunctionCallOutput.Type;
+type ToolCallOutput = typeof ToolCallOutput.Type;
 /**
  * Reasoning item - top-level, mirrors OpenAI Responses API. Common shape
  * across providers covers `summary` (human-readable text) and `signature`
@@ -240,7 +240,7 @@ declare const Reasoning: Schema.Struct<{
   readonly providerData: Schema.optional<Schema.Unknown>;
 }>;
 type Reasoning = typeof Reasoning.Type;
-declare const Item: Schema.Union<readonly [Schema.Struct<{
+declare const HistoryItem: 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<{
@@ -296,7 +296,7 @@ declare const Item: Schema.Union<readonly [Schema.Struct<{
   readonly signature: Schema.optional<Schema.String>;
   readonly providerData: Schema.optional<Schema.Unknown>;
 }>]>;
-type Item = typeof Item.Type;
+type HistoryItem = typeof HistoryItem.Type;
 declare const isInputText: <I>(input: I) => input is I & {
   readonly type: "input_text";
   readonly text: 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 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;
@@ -373,14 +373,14 @@ declare const isMessage: <I>(input: I) => input is I & {
   readonly role: "user" | "assistant" | "system";
   readonly providerData?: unknown;
 };
-declare const isFunctionCall: <I>(input: I) => input is I & {
+declare const isToolCall: <I>(input: I) => input is I & {
   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 & {
+declare const isToolCallOutput: <I>(input: I) => input is I & {
   readonly type: "function_call_output";
   readonly call_id: string;
   readonly output: string;
@@ -418,7 +418,7 @@ type StopReason = typeof StopReason.Type;
 declare const userText: (text: string) => Message;
 declare const systemText: (text: string) => Message;
 declare const assistantText: (text: string) => Message;
-declare const functionCallOutput: (call_id: string, output: string) => FunctionCallOutput;
+declare const toolCallOutput: (call_id: string, output: string) => ToolCallOutput;
 //#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-BH8xUkoR.d.mts.map
+export { isReasoning as A, isContainerFileCitation as C, isInputText as D, isInputImage as E, systemText as F, toolCallOutput as I, userText as L, isToolCall as M, isToolCallOutput as N, isMessage as O, isUrlCitation as P, assistantText as S, isFilePath as T, StopReason as _, FilePath as a, UrlCitation as b, InputText as c, Message as d, OutputText as f, Role as g, Refusal as h, FileCitation as i, isRefusal as j, isOutputText as k, InputTokensDetails as l, Reasoning as m, ContainerFileCitation as n, HistoryItem as o, OutputTokensDetails as p, ContentBlock as r, InputImage as s, Annotation as t, Items_d_exports as u, ToolCall as v, isFileCitation as w, Usage as x, ToolCallOutput as y };
+//# sourceMappingURL=Items-D8UaXQx_.d.mts.map

package/dist/Items-D8UaXQx_.d.mts.map

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

package/dist/SandboxError-BvKypkJm.d.mts

@@ -0,0 +1,158 @@
+import { Duration } from "effect";
+import * as _$effect_Types0 from "effect/Types";
+import * as _$effect_Cause0 from "effect/Cause";
+
+//#region src/sandbox/SandboxError.d.ts
+declare namespace SandboxError_d_exports {
+  export { SandboxAlreadyExists, SandboxAuthFailed, SandboxAuthSubtype, SandboxCreateFailed, SandboxError, SandboxExecFailed, SandboxInvalidRequest, SandboxNetworkPolicyDenied, SandboxNotFound, SandboxQuotaExceeded, SandboxTimeout, SandboxUnsupported };
+}
+declare const SandboxCreateFailed_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: "SandboxCreateFailed";
+} & Readonly<A>;
+/**
+ * Failed to provision a sandbox. Covers image pull failures, region
+ * unavailability, the provider being unreachable, etc. The provider's
+ * structured reason (if any) is on `reason`; the raw error from the
+ * underlying SDK is on `raw`.
+ */
+declare class SandboxCreateFailed extends SandboxCreateFailed_base<{
+  provider: string;
+  reason?: string;
+  raw: unknown;
+}> {}
+declare const SandboxNotFound_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: "SandboxNotFound";
+} & Readonly<A>;
+/**
+ * The requested sandbox id does not exist (or was already destroyed).
+ * Distinct from `SandboxCreateFailed` — this is for `attach` / `destroy` /
+ * `get`-style lookups against a stale id.
+ */
+declare class SandboxNotFound extends SandboxNotFound_base<{
+  provider: string;
+  id: string;
+}> {}
+declare const SandboxAlreadyExists_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: "SandboxAlreadyExists";
+} & Readonly<A>;
+/**
+ * Caller tried to create a sandbox whose id is already taken. Providers
+ * that keyed by name (Microsandbox, Modal) surface this when a previous
+ * sandbox with the same name is still alive. Distinct from
+ * `SandboxCreateFailed` so callers can retry with `replace` semantics.
+ */
+declare class SandboxAlreadyExists extends SandboxAlreadyExists_base<{
+  provider: string;
+  id: string;
+}> {}
+declare const SandboxExecFailed_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: "SandboxExecFailed";
+} & Readonly<A>;
+/**
+ * A shell exec inside the sandbox failed at the transport / SDK layer —
+ * i.e. the SDK couldn't deliver the command to the guest, or the guest
+ * agent itself errored. A non-zero exit code from the guest's command
+ * is NOT an error; it's an `ExecResult` with `exitCode !== 0`.
+ */
+declare class SandboxExecFailed extends SandboxExecFailed_base<{
+  provider: string;
+  reason?: string;
+  raw: unknown;
+}> {}
+declare const SandboxTimeout_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: "SandboxTimeout";
+} & Readonly<A>;
+/**
+ * A sandbox operation (create, exec, file op) exceeded its time budget.
+ * Carries the budget that was breached for observability.
+ */
+declare class SandboxTimeout extends SandboxTimeout_base<{
+  provider: string;
+  operation: "create" | "exec" | "filesystem" | "attach";
+  budget?: Duration.Duration;
+  raw?: unknown;
+}> {}
+declare const SandboxNetworkPolicyDenied_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: "SandboxNetworkPolicyDenied";
+} & Readonly<A>;
+/**
+ * Outbound network request from inside the sandbox was blocked by the
+ * configured egress policy (host not on allowlist, CIDR mismatch, etc.).
+ * Surfaced when the provider's SDK reports the denial back to the host
+ * — many providers simply let the request fail inside the guest and
+ * never report this to the host, in which case this error is never
+ * raised by the adapter.
+ */
+declare class SandboxNetworkPolicyDenied extends SandboxNetworkPolicyDenied_base<{
+  provider: string;
+  host?: string;
+  reason?: string;
+  raw: unknown;
+}> {}
+declare const SandboxQuotaExceeded_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: "SandboxQuotaExceeded";
+} & Readonly<A>;
+/**
+ * Provider rejected the create / exec because account / org / project
+ * quota or concurrency limit was exceeded. Surfaced separately from
+ * `SandboxCreateFailed` so callers can back off and retry intelligently.
+ */
+declare class SandboxQuotaExceeded extends SandboxQuotaExceeded_base<{
+  provider: string;
+  reason?: string;
+  raw: unknown;
+}> {}
+declare const SandboxInvalidRequest_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: "SandboxInvalidRequest";
+} & Readonly<A>;
+/**
+ * Caller's request shape is malformed for the wired provider — e.g. a
+ * Dockerfile passed to a provider that only accepts registry refs, a
+ * hostname allowlist passed to a CIDR-only provider, etc. Adapters
+ * should also reject these at the request-schema layer where possible;
+ * this is the runtime fallback.
+ */
+declare class SandboxInvalidRequest extends SandboxInvalidRequest_base<{
+  provider: string;
+  param?: string;
+  reason?: string;
+  raw?: unknown;
+}> {}
+/**
+ * Sandbox SDK could not authenticate against the provider. Subtype
+ * mirrors the model-side `AiError.AuthFailed` shape for consistency.
+ */
+type SandboxAuthSubtype = "auth" | "permission" | "billing" | "quota";
+declare const SandboxAuthFailed_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: "SandboxAuthFailed";
+} & Readonly<A>;
+declare class SandboxAuthFailed extends SandboxAuthFailed_base<{
+  provider: string;
+  subtype: SandboxAuthSubtype;
+  raw: unknown;
+}> {}
+declare const SandboxUnsupported_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: "SandboxUnsupported";
+} & Readonly<A>;
+/**
+ * The wired provider does not implement the requested capability for
+ * this specific request. Distinct from `SandboxInvalidRequest` (the
+ * request shape is malformed) and from compile-time capability
+ * markers (`SandboxSnapshots`, `SandboxSecretInjection`, …) which gate
+ * blanket provider-level gaps.
+ *
+ * Reserved for request-data-dependent gaps where the provider supports
+ * the method in general but not for these inputs — e.g. passing
+ * `hosts: [...]` to a CIDR-only allowlist provider, or passing
+ * `dockerfile: ...` to a provider whose `SandboxCustomImage` marker
+ * was provided but which only accepts a flat Dockerfile string.
+ */
+declare class SandboxUnsupported extends SandboxUnsupported_base<{
+  provider: string;
+  capability: string;
+  reason?: string;
+}> {}
+type SandboxError = SandboxCreateFailed | SandboxNotFound | SandboxAlreadyExists | SandboxExecFailed | SandboxTimeout | SandboxNetworkPolicyDenied | SandboxQuotaExceeded | SandboxInvalidRequest | SandboxAuthFailed | SandboxUnsupported;
+//#endregion
+export { SandboxError as a, SandboxInvalidRequest as c, SandboxQuotaExceeded as d, SandboxTimeout as f, SandboxCreateFailed as i, SandboxNetworkPolicyDenied as l, SandboxAuthFailed as n, SandboxError_d_exports as o, SandboxUnsupported as p, SandboxAuthSubtype as r, SandboxExecFailed as s, SandboxAlreadyExists as t, SandboxNotFound as u };
+//# sourceMappingURL=SandboxError-BvKypkJm.d.mts.map

package/dist/SandboxError-BvKypkJm.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SandboxError-BvKypkJm.d.mts","names":[],"sources":["../src/sandbox/SandboxError.ts"],"mappings":";;;;;;;;cAAuC,wBAAA;;;;;;;;;cAQ1B,mBAAA,SAA4B,wBAAA;EACvC,QAAA;EACA,MAAA;EACA,GAAA;AAAA;AAAA,cACG,oBAAA;;;;AAZkC;;;;cAmB1B,eAAA,SAAwB,oBAAA;EACnC,QAAA;EACA,EAAA;AAAA;AAAA,cACG,yBAAA;;;;;;;;;cAQQ,oBAAA,SAA6B,yBAAA;EACxC,QAAA;EACA,EAAA;AAAA;AAAA,cACG,sBAAA;;;;;;;;AAzBL;cAiCa,iBAAA,SAA0B,sBAAA;EACrC,QAAA;EACA,MAAA;EACA,GAAA;AAAA;AAAA,cACG,mBAAA;;;AAjCA;;;;AAAA,cAuCQ,cAAA,SAAuB,mBAAA;EAClC,QAAA;EACA,SAAA;EACA,MAAA,GAAS,QAAA,CAAS,QAAA;EAClB,GAAA;AAAA;AAAA,cACG,+BAAA;;;;;;;;;;;cAUQ,0BAAA,SAAmC,+BAAA;EAC9C,QAAA;EACA,IAAA;EACA,MAAA;EACA,GAAA;AAAA;AAAA,cACG,yBAAA;;;;;;;;cAOQ,oBAAA,SAA6B,yBAAA;EACxC,QAAA;EACA,MAAA;EACA,GAAA;AAAA;AAAA,cACG,0BAAA;;;;;;;;;;cASQ,qBAAA,SAA8B,0BAAA;EACzC,QAAA;EACA,KAAA;EACA,MAAA;EACA,GAAA;AAAA;;;;;KAOU,kBAAA;AAAA,cAAgE,sBAAA;;;cAE/D,iBAAA,SAA0B,sBAAA;EACrC,QAAA;EACA,OAAA,EAAS,kBAAA;EACT,GAAA;AAAA;AAAA,cACG,uBAAA;;;;;;AA3EA;;;;;;;;;;cA0FQ,kBAAA,SAA2B,uBAAA;EACtC,QAAA;EACA,UAAA;EACA,MAAA;AAAA;AAAA,KAGU,YAAA,GACR,mBAAA,GACA,eAAA,GACA,oBAAA,GACA,iBAAA,GACA,cAAA,GACA,0BAAA,GACA,oBAAA,GACA,qBAAA,GACA,iBAAA,GACA,kBAAA"}

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

@@ -1,11 +1,11 @@
-import { o as FunctionCall, s as FunctionCallOutput } from "./Items-BH8xUkoR.mjs";
+import { v as ToolCall, y as ToolCallOutput } from "./Items-D8UaXQx_.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, fromStandardSchema, isStreamingTool, make, streaming, toDescriptors };
+  export { AnyPlainTool, AnyStreamingTool, AnyTool, 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;
@@ -62,7 +62,7 @@ type Tool<Name extends string, Input, Output, R = never> = {
 /**
  * Provider-agnostic tool descriptor. Each provider maps `inputSchema`
  * to its own wire field (OpenAI → `parameters`, Anthropic →
- * `input_schema`). Built from a `Tool` by `Toolkit.toDescriptors`.
+ * `input_schema`). Built from a `Tool` by `Tool.toDescriptors`.
  */
 type ToolDescriptor = {
   readonly name: string;
@@ -83,20 +83,20 @@ type StreamingTool<Name extends string, Input, Event, Output, R = never> = {
 declare const streaming: <Name extends string, Input, Event, Output, R = never>(spec: Omit<StreamingTool<Name, Input, Event, Output, R>, "_kind">) => StreamingTool<Name, Input, Event, Output, R>;
 type AnyStreamingTool<R = any> = StreamingTool<string, any, any, any, R>;
 type AnyPlainTool<R = any> = Tool<string, any, any, R>;
-type AnyKindTool<R = any> = AnyStreamingTool<R> | AnyPlainTool<R>;
-declare const isStreamingTool: <R>(t: AnyKindTool<R>) => t is AnyStreamingTool<R>;
+type AnyTool<R = any> = AnyStreamingTool<R> | AnyPlainTool<R>;
+declare const isStreamingTool: <R>(t: AnyTool<R>) => t is AnyStreamingTool<R>;
 /**
  * Render any-kind tools (mixed plain and streaming) to provider-agnostic
- * descriptors. Mirrors `Toolkit.toDescriptors` but accepts the union type
- * so a single list can carry both kinds.
+ * descriptors. Accepts the union type so a single list can carry both
+ * plain and streaming tools.
  */
-declare const toDescriptors: <R>(tools: ReadonlyArray<AnyKindTool<R>>) => ReadonlyArray<ToolDescriptor>;
+declare const toDescriptors: <R>(tools: ReadonlyArray<AnyTool<R>>) => ReadonlyArray<ToolDescriptor>;
 /**
  * Decode and validate the JSON arguments of a function_call against the
  * tool's input schema, run the tool, and serialize the output into a
  * function_call_output item.
  */
-declare const execute: <Name extends string, Input, Output, R>(tool: Tool<Name, Input, Output, R>, call: FunctionCall) => Effect.Effect<FunctionCallOutput, ToolError, R>;
+declare const execute: <Name extends string, Input, Output, R>(tool: Tool<Name, Input, Output, R>, call: ToolCall) => Effect.Effect<ToolCallOutput, 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-87ViKCCO.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, AnyStreamingTool as n, ToolDescriptor as o, isStreamingTool as p, AnyTool as r, ToolError as s, AnyPlainTool as t, execute as u };
+//# sourceMappingURL=Tool-CiFXYjmR.d.mts.map

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

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"Tool-CiFXYjmR.d.mts","names":[],"sources":["../src/tool/Tool.ts"],"mappings":";;;;;;;;;cAEkE,cAAA;;;;;;cAGrD,SAAA,SAAkB,cAAA;;;;;;;;;;KAmBnB,eAAA,oBAAmC,gBAAA,UAA0B,KAAA,IACvE,oBAAA,UAA8B,KAAA;;;;AAvBkC;;cA8BrD,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,OAAA,YAAmB,gBAAA,CAAiB,CAAA,IAAK,YAAA,CAAa,CAAA;AAAA,cAErD,eAAA,MAAsB,CAAA,EAAG,OAAA,CAAQ,CAAA,MAAK,CAAA,IAAK,gBAAA,CAAiB,CAAA;;;;;;cAQ5D,aAAA,MAAoB,KAAA,EAAO,aAAA,CAAc,OAAA,CAAQ,CAAA,OAAM,aAAA,CAAc,cAAA;;;;;;cAkBrE,OAAA,0CACX,IAAA,EAAM,IAAA,CAAK,IAAA,EAAM,KAAA,EAAO,MAAA,EAAQ,CAAA,GAChC,IAAA,EAAM,QAAA,KACL,MAAA,CAAO,MAAA,CAAO,cAAA,EAAgB,SAAA,EAAW,CAAA"}

package/dist/capabilities/Capabilities.d.mts

@@ -0,0 +1,78 @@
+import { Effect } from "effect";
+
+//#region src/capabilities/Capabilities.d.ts
+declare namespace Capabilities_d_exports {
+  export { CapabilityWarning, warnDropped, warnDroppedWhen };
+}
+/**
+ * Structured event emitted when a provider adapter drops a Common
+ * request field because its wire API has no place to put it (bucket 2
+ * per the capabilities policy: the provider has no structured
+ * interpretation; the output is still valid, just less aligned with
+ * the caller's hint).
+ *
+ * Carried on `Effect.logWarning` today for visibility; may be
+ * promoted to a typed `AiError` variant in the future if callers need
+ * to react programmatically. The shape itself is stable.
+ *
+ * @category capabilities
+ */
+type CapabilityWarning = {
+  readonly _tag: "CapabilityWarning";
+  readonly provider: string; /** The capability name as it appears in docs (`"lyrics"`, `"bpm"`). */
+  readonly capability: string; /** The Common-request field name that was dropped. */
+  readonly field: string; /** The value the caller passed; included when useful for debugging. */
+  readonly value?: unknown; /** Human-readable explanation; should suggest a workaround. */
+  readonly reason: string;
+};
+/**
+ * Emit a structured `CapabilityWarning` via `Effect.logWarning`. Use
+ * when a provider adapter receives a Common-request field it has no
+ * structured wire field for, and would otherwise drop silently.
+ *
+ * Bucket-2 cases only (per the capabilities policy): the provider has
+ * no interpretation; the output is still valid, just less aligned
+ * with the caller's hint. For bucket-1 cases (structurally broken
+ * output if dropped, like wrong audio format), fail
+ * `AiError.Unsupported` instead.
+ *
+ * @example
+ * ```ts
+ * if (request.lyrics !== undefined) {
+ *   yield* warnDropped({
+ *     provider: "lyria",
+ *     capability: "lyrics",
+ *     field: "lyrics",
+ *     reason: "Lyria 3 sync has no `lyrics` wire field. Embed in your prompt instead.",
+ *   })
+ * }
+ * ```
+ */
+declare const warnDropped: (warning: Omit<CapabilityWarning, "_tag">) => Effect.Effect<void>;
+/**
+ * Shorthand for the most common shape: warn-and-drop when a specific
+ * field on the Common request is set. The field's value is included
+ * automatically.
+ *
+ * @example
+ * ```ts
+ * yield* Effect.all([
+ *   warnDroppedWhen(request.lyrics, {
+ *     provider: "lyria",
+ *     capability: "lyrics",
+ *     field: "lyrics",
+ *     reason: "Lyria 3 sync has no `lyrics` wire field. Embed in your prompt instead.",
+ *   }),
+ *   warnDroppedWhen(request.duration, {
+ *     provider: "lyria",
+ *     capability: "duration",
+ *     field: "duration",
+ *     reason: "Lyria 3 clip is fixed at 30 s.",
+ *   }),
+ * ], { discard: true })
+ * ```
+ */
+declare const warnDroppedWhen: <T>(value: T | undefined, warning: Omit<CapabilityWarning, "_tag" | "value">) => Effect.Effect<void>;
+//#endregion
+export { CapabilityWarning, Capabilities_d_exports as t, warnDropped, warnDroppedWhen };
+//# sourceMappingURL=Capabilities.d.mts.map

package/dist/capabilities/Capabilities.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Capabilities.d.mts","names":[],"sources":["../../src/capabilities/Capabilities.ts"],"mappings":";;;;;;;;;;;;;;AAeA;;;;;KAAY,iBAAA;EAAA,SACD,IAAA;EAAA,SACA,QAAA,UAMA;EAAA,SAJA,UAAA,UAMM;EAAA,SAJN,KAAA,UA8BE;EAAA,SA5BF,KAAA;WAEA,MAAA;AAAA;;;;;;;;;;;AAoDX;;;;;;;;;;;;;cA1Ba,WAAA,GAAe,OAAA,EAAS,IAAA,CAAK,iBAAA,cAA6B,MAAA,CAAO,MAAA;;;;;;;;;;;;;;;;;;;;;;;;cA0BjE,eAAA,MACX,KAAA,EAAO,CAAA,cACP,OAAA,EAAS,IAAA,CAAK,iBAAA,wBACb,MAAA,CAAO,MAAA"}

package/dist/capabilities/Capabilities.mjs

@@ -0,0 +1,65 @@
+import { n as __exportAll } from "../chunk-uyGKjUfl.mjs";
+import { Effect } from "effect";
+//#region src/capabilities/Capabilities.ts
+var Capabilities_exports = /* @__PURE__ */ __exportAll({
+	warnDropped: () => warnDropped,
+	warnDroppedWhen: () => warnDroppedWhen
+});
+/**
+* Emit a structured `CapabilityWarning` via `Effect.logWarning`. Use
+* when a provider adapter receives a Common-request field it has no
+* structured wire field for, and would otherwise drop silently.
+*
+* Bucket-2 cases only (per the capabilities policy): the provider has
+* no interpretation; the output is still valid, just less aligned
+* with the caller's hint. For bucket-1 cases (structurally broken
+* output if dropped, like wrong audio format), fail
+* `AiError.Unsupported` instead.
+*
+* @example
+* ```ts
+* if (request.lyrics !== undefined) {
+*   yield* warnDropped({
+*     provider: "lyria",
+*     capability: "lyrics",
+*     field: "lyrics",
+*     reason: "Lyria 3 sync has no `lyrics` wire field. Embed in your prompt instead.",
+*   })
+* }
+* ```
+*/
+const warnDropped = (warning) => Effect.logWarning("Capability dropped", {
+	...warning,
+	_tag: "CapabilityWarning"
+});
+/**
+* Shorthand for the most common shape: warn-and-drop when a specific
+* field on the Common request is set. The field's value is included
+* automatically.
+*
+* @example
+* ```ts
+* yield* Effect.all([
+*   warnDroppedWhen(request.lyrics, {
+*     provider: "lyria",
+*     capability: "lyrics",
+*     field: "lyrics",
+*     reason: "Lyria 3 sync has no `lyrics` wire field. Embed in your prompt instead.",
+*   }),
+*   warnDroppedWhen(request.duration, {
+*     provider: "lyria",
+*     capability: "duration",
+*     field: "duration",
+*     reason: "Lyria 3 clip is fixed at 30 s.",
+*   }),
+* ], { discard: true })
+* ```
+*/
+const warnDroppedWhen = (value, warning) => value === void 0 ? Effect.void : warnDropped({
+	...warning,
+	value
+});
+//#endregion
+export { Capabilities_exports as t, warnDropped, warnDroppedWhen };
+
+//# sourceMappingURL=Capabilities.mjs.map

package/dist/capabilities/Capabilities.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Capabilities.mjs","names":[],"sources":["../../src/capabilities/Capabilities.ts"],"sourcesContent":["import { Effect } from \"effect\"\n\n/**\n * Structured event emitted when a provider adapter drops a Common\n * request field because its wire API has no place to put it (bucket 2\n * per the capabilities policy: the provider has no structured\n * interpretation; the output is still valid, just less aligned with\n * the caller's hint).\n *\n * Carried on `Effect.logWarning` today for visibility; may be\n * promoted to a typed `AiError` variant in the future if callers need\n * to react programmatically. The shape itself is stable.\n *\n * @category capabilities\n */\nexport type CapabilityWarning = {\n  readonly _tag: \"CapabilityWarning\"\n  readonly provider: string\n  /** The capability name as it appears in docs (`\"lyrics\"`, `\"bpm\"`). */\n  readonly capability: string\n  /** The Common-request field name that was dropped. */\n  readonly field: string\n  /** The value the caller passed; included when useful for debugging. */\n  readonly value?: unknown\n  /** Human-readable explanation; should suggest a workaround. */\n  readonly reason: string\n}\n\n/**\n * Emit a structured `CapabilityWarning` via `Effect.logWarning`. Use\n * when a provider adapter receives a Common-request field it has no\n * structured wire field for, and would otherwise drop silently.\n *\n * Bucket-2 cases only (per the capabilities policy): the provider has\n * no interpretation; the output is still valid, just less aligned\n * with the caller's hint. For bucket-1 cases (structurally broken\n * output if dropped, like wrong audio format), fail\n * `AiError.Unsupported` instead.\n *\n * @example\n * ```ts\n * if (request.lyrics !== undefined) {\n *   yield* warnDropped({\n *     provider: \"lyria\",\n *     capability: \"lyrics\",\n *     field: \"lyrics\",\n *     reason: \"Lyria 3 sync has no `lyrics` wire field. Embed in your prompt instead.\",\n *   })\n * }\n * ```\n */\nexport const warnDropped = (warning: Omit<CapabilityWarning, \"_tag\">): Effect.Effect<void> =>\n  Effect.logWarning(\"Capability dropped\", { ...warning, _tag: \"CapabilityWarning\" })\n\n/**\n * Shorthand for the most common shape: warn-and-drop when a specific\n * field on the Common request is set. The field's value is included\n * automatically.\n *\n * @example\n * ```ts\n * yield* Effect.all([\n *   warnDroppedWhen(request.lyrics, {\n *     provider: \"lyria\",\n *     capability: \"lyrics\",\n *     field: \"lyrics\",\n *     reason: \"Lyria 3 sync has no `lyrics` wire field. Embed in your prompt instead.\",\n *   }),\n *   warnDroppedWhen(request.duration, {\n *     provider: \"lyria\",\n *     capability: \"duration\",\n *     field: \"duration\",\n *     reason: \"Lyria 3 clip is fixed at 30 s.\",\n *   }),\n * ], { discard: true })\n * ```\n */\nexport const warnDroppedWhen = <T>(\n  value: T | undefined,\n  warning: Omit<CapabilityWarning, \"_tag\" | \"value\">,\n): Effect.Effect<void> => (value === undefined ? Effect.void : warnDropped({ ...warning, value }))\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmDA,MAAa,eAAe,YAC1B,OAAO,WAAW,sBAAsB;CAAE,GAAG;CAAS,MAAM;CAAqB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;AAyBpF,MAAa,mBACX,OACA,YACyB,UAAU,KAAA,IAAY,OAAO,OAAO,YAAY;CAAE,GAAG;CAAS;CAAO,CAAC"}

package/dist/domain/Audio.d.mts

@@ -1,2 +1,2 @@
-import { a as AudioSource, c as isAudioBytes, i as AudioMimeType, l as isAudioUrl, n as AudioChunk, r as AudioFormat, s as isAudioBase64, t as AudioBlob } from "../Audio-BfCTGnH3.mjs";
+import { a as AudioSource, c as isAudioBytes, i as AudioMimeType, l as isAudioUrl, n as AudioChunk, r as AudioFormat, s as isAudioBase64, t as AudioBlob } from "../Audio-DPlTsNdz.mjs";
 export { AudioBlob, AudioChunk, AudioFormat, AudioMimeType, AudioSource, isAudioBase64, isAudioBytes, isAudioUrl };

package/dist/domain/Audio.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"Audio.mjs","names":[],"sources":["../../src/domain/Audio.ts"],"sourcesContent":["import type { MediaBase64, MediaBytes, MediaUrl } from \"./Media.js\"\n\n/**\n * MIME types we care about across STT input and TTS output. Container-\n * level only — sample rate / encoding flavours live on `AudioFormat`.\n *\n * Per-provider request types narrow this further. The `(string & {})`\n * tail keeps autocomplete on the literals while still accepting any\n * string, so unusual formats work without an SDK update.\n */\nexport type AudioMimeType =\n  | \"audio/mpeg\"\n  | \"audio/wav\"\n  | \"audio/x-wav\"\n  | \"audio/ogg\"\n  | \"audio/opus\"\n  | \"audio/flac\"\n  | \"audio/aac\"\n  | \"audio/mp4\"\n  | \"audio/webm\"\n  | \"audio/L16\"\n  | \"audio/pcm\"\n  | \"audio/mulaw\"\n  | \"audio/alaw\"\n  // eslint-disable-next-line @typescript-eslint/ban-types\n  | (string & {})\n\n/**\n * Audio at rest — instantiates `MediaSource` with the audio MIME union.\n * Used for sync STT input.\n *\n * URL variant is best-effort: some providers (OpenAI, Cartesia, Azure\n * short-audio) reject URL ingestion and the adapter must upload via the\n * `bytes` or `base64` variant instead. Adapter layers reject unsupported\n * shapes up front with `AiError.InvalidRequest`.\n */\nexport type AudioSource =\n  | MediaUrl<AudioMimeType>\n  | MediaBase64<AudioMimeType>\n  | MediaBytes<AudioMimeType>\n\nexport const isAudioUrl = (s: AudioSource): s is MediaUrl<AudioMimeType> => s._tag === \"url\"\nexport const isAudioBase64 = (s: AudioSource): s is MediaBase64<AudioMimeType> =>\n  s._tag === \"base64\"\nexport const isAudioBytes = (s: AudioSource): s is MediaBytes<AudioMimeType> => s._tag === \"bytes\"\n\n/**\n * Structural audio format. Used both as TTS output spec and as STT\n * streaming-input declaration. Providers that use compound slugs\n * (`mp3_44100_128`, `audio-16khz-128kbitrate-mono-mp3`,\n * `aura-2-thalia-en`) are encoded at the adapter layer.\n */\nexport type AudioFormat = {\n  readonly container: \"mp3\" | \"wav\" | \"ogg\" | \"opus\" | \"flac\" | \"aac\" | \"webm\" | \"raw\"\n  readonly encoding:\n    | \"pcm_s16le\"\n    | \"pcm_f32le\"\n    | \"pcm_mulaw\"\n    | \"pcm_alaw\"\n    | \"mp3\"\n    | \"opus\"\n    | \"vorbis\"\n    | \"flac\"\n    | \"aac\"\n  readonly sampleRate: 8000 | 16000 | 22050 | 24000 | 32000 | 44100 | 48000\n  /** mp3 / opus only. */\n  readonly bitRate?: number\n  readonly channels?: 1 | 2\n}\n\n/**\n * Streamed audio chunk. `bytes` carries the codec-encoded payload as\n * declared on the stream's `AudioFormat`. No per-chunk timestamp here —\n * providers that emit timing do so via `TranscriptEvent.words[]`.\n */\nexport type AudioChunk = {\n  readonly bytes: Uint8Array\n}\n\n/**\n * Full audio result for sync TTS. Format mirrors the request; provider\n * layers normalize.\n */\nexport type AudioBlob = {\n  readonly format: AudioFormat\n  readonly bytes: Uint8Array\n  readonly durationSeconds?: number\n}\n"],"mappings":";;;;;;;AAyCA,MAAa,cAAc,MAAiD,EAAE,SAAS;AACvF,MAAa,iBAAiB,MAC5B,EAAE,SAAS;AACb,MAAa,gBAAgB,MAAmD,EAAE,SAAS"}
+{"version":3,"file":"Audio.mjs","names":[],"sources":["../../src/domain/Audio.ts"],"sourcesContent":["import type { Duration } from \"effect\"\nimport type { MediaBase64, MediaBytes, MediaUrl } from \"./Media.js\"\n\n/**\n * MIME types we care about across STT input and TTS output. Container-\n * level only — sample rate / encoding flavours live on `AudioFormat`.\n *\n * Per-provider request types narrow this further. The `(string & {})`\n * tail keeps autocomplete on the literals while still accepting any\n * string, so unusual formats work without an SDK update.\n */\nexport type AudioMimeType =\n  | \"audio/mpeg\"\n  | \"audio/wav\"\n  | \"audio/x-wav\"\n  | \"audio/ogg\"\n  | \"audio/opus\"\n  | \"audio/flac\"\n  | \"audio/aac\"\n  | \"audio/mp4\"\n  | \"audio/webm\"\n  | \"audio/L16\"\n  | \"audio/pcm\"\n  | \"audio/mulaw\"\n  | \"audio/alaw\"\n  // eslint-disable-next-line @typescript-eslint/ban-types\n  | (string & {})\n\n/**\n * Audio at rest — instantiates `MediaSource` with the audio MIME union.\n * Used for sync STT input.\n *\n * URL variant is best-effort: some providers (OpenAI, Cartesia, Azure\n * short-audio) reject URL ingestion and the adapter must upload via the\n * `bytes` or `base64` variant instead. Adapter layers reject unsupported\n * shapes up front with `AiError.InvalidRequest`.\n */\nexport type AudioSource =\n  | MediaUrl<AudioMimeType>\n  | MediaBase64<AudioMimeType>\n  | MediaBytes<AudioMimeType>\n\nexport const isAudioUrl = (s: AudioSource): s is MediaUrl<AudioMimeType> => s._tag === \"url\"\nexport const isAudioBase64 = (s: AudioSource): s is MediaBase64<AudioMimeType> =>\n  s._tag === \"base64\"\nexport const isAudioBytes = (s: AudioSource): s is MediaBytes<AudioMimeType> => s._tag === \"bytes\"\n\n/**\n * Structural audio format. Used both as TTS output spec and as STT\n * streaming-input declaration. Providers that use compound slugs\n * (`mp3_44100_128`, `audio-16khz-128kbitrate-mono-mp3`,\n * `aura-2-thalia-en`) are encoded at the adapter layer.\n */\nexport type AudioFormat = {\n  readonly container: \"mp3\" | \"wav\" | \"ogg\" | \"opus\" | \"flac\" | \"aac\" | \"webm\" | \"raw\"\n  readonly encoding:\n    | \"pcm_s16le\"\n    | \"pcm_f32le\"\n    | \"pcm_mulaw\"\n    | \"pcm_alaw\"\n    | \"mp3\"\n    | \"opus\"\n    | \"vorbis\"\n    | \"flac\"\n    | \"aac\"\n  readonly sampleRate: 8000 | 16000 | 22050 | 24000 | 32000 | 44100 | 48000\n  /** mp3 / opus only. */\n  readonly bitRate?: number\n  readonly channels?: 1 | 2\n}\n\n/**\n * Streamed audio chunk. `bytes` carries the codec-encoded payload as\n * declared on the stream's `AudioFormat`. No per-chunk timestamp here —\n * providers that emit timing do so via `TranscriptEvent.words[]`.\n */\nexport type AudioChunk = {\n  readonly bytes: Uint8Array\n}\n\n/**\n * Full audio result for sync TTS. Format mirrors the request; provider\n * layers normalize.\n */\nexport type AudioBlob = {\n  readonly format: AudioFormat\n  readonly bytes: Uint8Array\n  readonly duration?: Duration.Duration\n}\n"],"mappings":";;;;;;;AA0CA,MAAa,cAAc,MAAiD,EAAE,SAAS;AACvF,MAAa,iBAAiB,MAC5B,EAAE,SAAS;AACb,MAAa,gBAAgB,MAAmD,EAAE,SAAS"}

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-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 };
+import { A as isReasoning, C as isContainerFileCitation, D as isInputText, E as isInputImage, F as systemText, I as toolCallOutput, L as userText, M as isToolCall, N as isToolCallOutput, O as isMessage, P as isUrlCitation, S as assistantText, T as isFilePath, _ as StopReason, a as FilePath, b as UrlCitation, c as InputText, d as Message, f as OutputText, g as Role, h as Refusal, i as FileCitation, j as isRefusal, k as isOutputText, l as InputTokensDetails, m as Reasoning, n as ContainerFileCitation, o as HistoryItem, p as OutputTokensDetails, r as ContentBlock, s as InputImage, t as Annotation, v as ToolCall, w as isFileCitation, x as Usage, y as ToolCallOutput } from "../Items-D8UaXQx_.mjs";
+export { Annotation, ContainerFileCitation, ContentBlock, FileCitation, FilePath, HistoryItem, InputImage, InputText, InputTokensDetails, Message, OutputText, OutputTokensDetails, Reasoning, Refusal, Role, StopReason, ToolCall, ToolCallOutput, UrlCitation, Usage, assistantText, isContainerFileCitation, isFileCitation, isFilePath, isInputImage, isInputText, isMessage, isOutputText, isReasoning, isRefusal, isToolCall, isToolCallOutput, isUrlCitation, systemText, toolCallOutput, userText };