@effect-uai/core 0.10.0 → 0.11.0

package/dist/index.d.mts

@@ -1,23 +1,27 @@
 import { t as BrowserError_d_exports } from "./browser/BrowserError.mjs";
 import { t as Browser_d_exports } from "./browser/Browser.mjs";
 import { a as Media_d_exports } from "./Media-D_CpcM1Z.mjs";
-import { o as Image_d_exports } from "./Image-BZmKfIdq.mjs";
-import { u as Items_d_exports } from "./Items-BnIduEV2.mjs";
-import { _ as Tool_d_exports } from "./Tool-2lC_XMth.mjs";
+import { o as Image_d_exports } from "./Image-C4vuBmu0.mjs";
+import { u as Items_d_exports } from "./Items-BWNu6VGp.mjs";
+import { _ as Tool_d_exports } from "./Tool-CXFHCQrT.mjs";
 import { t as BrowserTool_d_exports } from "./browser/BrowserTool.mjs";
 import { t as Capabilities_d_exports } from "./capabilities/Capabilities.mjs";
 import { n as AiError_d_exports } from "./AiError-Bf1pq4BB.mjs";
 import { o as Audio_d_exports } from "./Audio-CR7CSljJ.mjs";
+import { t as Citation_d_exports } from "./domain/Citation.mjs";
 import { t as Music_d_exports } from "./domain/Music.mjs";
-import { t as Transcript_d_exports } from "./domain/Transcript.mjs";
+import { t as Job_d_exports } from "./job/Job.mjs";
 import { a as StructuredFormat_d_exports } from "./StructuredFormat-DHaUJBdd.mjs";
 import { t as Turn_d_exports } from "./domain/Turn.mjs";
+import { t as Research_d_exports } from "./domain/Research.mjs";
+import { t as Transcript_d_exports } from "./domain/Transcript.mjs";
 import { t as Embedding_d_exports } from "./embedding-model/Embedding.mjs";
 import { t as EmbeddingModel_d_exports } from "./embedding-model/EmbeddingModel.mjs";
+import { t as DeepResearch_d_exports } from "./research/DeepResearch.mjs";
 import { t as Loop_d_exports } from "./Loop-D8nWpowc.mjs";
-import { n as ToolResult_d_exports } from "./ToolResult-CL4hK_9z.mjs";
-import { n as ToolEvent_d_exports } from "./ToolEvent-cWZ2BnbS.mjs";
-import { l as Toolkit_d_exports } from "./Toolkit-Dr9l_hNy.mjs";
+import { n as ToolResult_d_exports } from "./ToolResult-CQqKkcDa.mjs";
+import { n as ToolEvent_d_exports } from "./ToolEvent-nVijCrvm.mjs";
+import { l as Toolkit_d_exports } from "./Toolkit-BYPwwu-j.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";
@@ -40,4 +44,4 @@ 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";
 import { t as Telemetry_d_exports } from "./observability/Telemetry.mjs";
-export { AiError_d_exports as AiError, Approval_d_exports as Approval, Audio_d_exports as Audio, Browser_d_exports as Browser, BrowserError_d_exports as BrowserError, BrowserTool_d_exports as BrowserTool, Capabilities_d_exports as Capabilities, 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, Telemetry_d_exports as Telemetry, 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, WebRead_d_exports as WebRead, WebReadTool_d_exports as WebReadTool, WebSearch_d_exports as WebSearch, WebSearchTool_d_exports as WebSearchTool };
+export { AiError_d_exports as AiError, Approval_d_exports as Approval, Audio_d_exports as Audio, Browser_d_exports as Browser, BrowserError_d_exports as BrowserError, BrowserTool_d_exports as BrowserTool, Capabilities_d_exports as Capabilities, Citation_d_exports as Citation, DeepResearch_d_exports as DeepResearch, 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, Job_d_exports as Job, 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, Research_d_exports as Research, 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, Telemetry_d_exports as Telemetry, 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, WebRead_d_exports as WebRead, WebReadTool_d_exports as WebReadTool, WebSearch_d_exports as WebSearch, WebSearchTool_d_exports as WebSearchTool };

package/dist/index.mjs

@@ -13,8 +13,12 @@ import { t as ToolEvent_exports } from "./tool/ToolEvent.mjs";
 import { t as Toolkit_exports } from "./tool/Toolkit.mjs";
 import { t as BrowserTool_exports } from "./browser/BrowserTool.mjs";
 import { t as Capabilities_exports } from "./capabilities/Capabilities.mjs";
+import { t as Citation_exports } from "./domain/Citation.mjs";
+import { t as Job_exports } from "./job/Job.mjs";
+import { t as DeepResearch_exports } from "./research/DeepResearch.mjs";
 import { t as Media_exports } from "./domain/Media.mjs";
 import { t as Music_exports } from "./domain/Music.mjs";
+import { t as Research_exports } from "./domain/Research.mjs";
 import { t as Transcript_exports } from "./domain/Transcript.mjs";
 import { t as Embedding_exports } from "./embedding-model/Embedding.mjs";
 import { t as EmbeddingModel_exports } from "./embedding-model/EmbeddingModel.mjs";
@@ -40,4 +44,4 @@ 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";
 import { t as Telemetry_exports } from "./observability/Telemetry.mjs";
-export { AiError_exports as AiError, Approval_exports as Approval, Audio_exports as Audio, Browser_exports as Browser, BrowserError_exports as BrowserError, BrowserTool_exports as BrowserTool, Capabilities_exports as Capabilities, 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, Telemetry_exports as Telemetry, 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, WebRead_exports as WebRead, WebReadTool_exports as WebReadTool, WebSearch_exports as WebSearch, WebSearchTool_exports as WebSearchTool };
+export { AiError_exports as AiError, Approval_exports as Approval, Audio_exports as Audio, Browser_exports as Browser, BrowserError_exports as BrowserError, BrowserTool_exports as BrowserTool, Capabilities_exports as Capabilities, Citation_exports as Citation, DeepResearch_exports as DeepResearch, Embedding_exports as Embedding, EmbeddingModel_exports as EmbeddingModel, HistoryCheck_exports as HistoryCheck, Image_exports as Image, Items_exports as Items, JSONL_exports as JSONL, Job_exports as Job, 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, Research_exports as Research, 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, Telemetry_exports as Telemetry, 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, WebRead_exports as WebRead, WebReadTool_exports as WebReadTool, WebSearch_exports as WebSearch, WebSearchTool_exports as WebSearchTool };

package/dist/job/Job.d.mts

@@ -0,0 +1,80 @@
+import { t as AiError } from "../AiError-Bf1pq4BB.mjs";
+import { Duration, Effect } from "effect";
+
+//#region src/job/Job.d.ts
+declare namespace Job_d_exports {
+  export { JobConfig, JobOps, JobRef, JobState, collect, isSettled, jobRef, run };
+}
+/**
+ * Normalized state of a provider-hosted background job. Implementors map their
+ * provider's status vocabulary onto these four states. The terminal states
+ * carry their payload: `Succeeded` the collected result, `Failed` an optional
+ * reason and the raw provider error. This mirrors the wire, where a single
+ * poll response returns both status and (when done) the result.
+ */
+type JobState<A> = {
+  readonly _tag: "Pending";
+} | {
+  readonly _tag: "Running";
+} | {
+  readonly _tag: "Succeeded";
+  readonly result: A;
+} | {
+  readonly _tag: "Failed";
+  readonly reason?: string;
+  readonly raw?: unknown;
+};
+/** The two states that end a poll loop. */
+declare const isSettled: <A>(state: JobState<A>) => state is Extract<JobState<A>, {
+  _tag: "Succeeded" | "Failed";
+}>;
+declare const ResultType: unique symbol;
+/**
+ * Opaque, provider-tagged handle to a running background job. Jobs can run for
+ * minutes and outlive a single process, so the handle is detachable: submit
+ * now, collect later. `provider` tags who owns `id`.
+ *
+ * Parameterized by the result type `A` it collects to, so a ref cannot be
+ * crossed between capabilities (a `JobRef<Turn>` is not a `JobRef<VideoResult>`).
+ * The brand is phantom: the runtime value is just `{ _tag, provider, id }`, so
+ * a ref stays plain serializable data for persistence across restarts.
+ */
+type JobRef<A = unknown> = {
+  readonly _tag: "JobRef";
+  readonly provider: string;
+  readonly id: string;
+  readonly [ResultType]?: A;
+};
+declare const jobRef: <A = unknown>(provider: string, id: string) => JobRef<A>;
+/**
+ * The three wire operations a poll-based async job supplies. `run` / `collect`
+ * drive the submit -> poll -> settle cadence around them, so an implementor
+ * states only its provider calls, not the loop. `poll` returns the current
+ * `JobState`, carrying the result in `Succeeded`. Generic over the collected
+ * `Result`.
+ */
+type JobOps<Result> = {
+  readonly submit: Effect.Effect<JobRef<Result>, AiError>;
+  readonly poll: (ref: JobRef<Result>) => Effect.Effect<JobState<Result>, AiError>;
+  readonly cancel: (ref: JobRef<Result>) => Effect.Effect<void, AiError>;
+};
+type JobConfig = {
+  /** Cadence between status fetches. Default 10 seconds, jittered. */readonly pollInterval?: Duration.Input; /** Overall wait cap; exceeding it fails `Timeout`. Default 45 minutes. */
+  readonly timeout?: Duration.Input;
+};
+/**
+ * Poll `poll(ref)` on a jittered fixed cadence until the job settles, then
+ * return the result or fail `GenerationFailed`. Bounded by `timeout`, which
+ * fails `Timeout` if the job never settles. Takes the poll op alone (not the
+ * full `JobOps`) so a detached `collect(ref)` needs no submit-bound request.
+ */
+declare const collect: <Result>(poll: (ref: JobRef<Result>) => Effect.Effect<JobState<Result>, AiError>, ref: JobRef<Result>, config?: JobConfig) => Effect.Effect<Result, AiError>;
+/**
+ * Submit, then poll to completion. Best-effort cancels the server job if the
+ * caller interrupts (where the provider supports it). The one-call path; use
+ * `ops.submit` + `collect` directly for the detached case.
+ */
+declare const run: <Result>(ops: JobOps<Result>, config?: JobConfig) => Effect.Effect<Result, AiError>;
+//#endregion
+export { JobConfig, JobOps, JobRef, JobState, collect, isSettled, jobRef, run, Job_d_exports as t };
+//# sourceMappingURL=Job.d.mts.map

package/dist/job/Job.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Job.d.mts","names":[],"sources":["../../src/job/Job.ts"],"mappings":";;;;;;;;;;;;;;KAcY,QAAA;EAAA,SACG,IAAA;AAAA;EAAA,SACA,IAAA;AAAA;EAAA,SACA,IAAA;EAAA,SAA4B,MAAA,EAAQ,CAAA;AAAA;EAAA,SACpC,IAAA;EAAA,SAAyB,MAAA;EAAA,SAA0B,GAAA;AAAA;;cAGrD,SAAA,MACX,KAAA,EAAO,QAAA,CAAS,CAAA,MACf,KAAA,IAAS,OAAA,CAAQ,QAAA,CAAS,CAAA;EAAM,IAAA;AAAA;AAAA,cAGrB,UAAA;;;;;AALd;;;;;;KAiBY,MAAA;EAAA,SACD,IAAA;EAAA,SACA,QAAA;EAAA,SACA,EAAA;EAAA,UACC,UAAA,IAAc,CAAA;AAAA;AAAA,cAGb,MAAA,gBAAuB,QAAA,UAAkB,EAAA,aAAa,MAAA,CAAO,CAAA;;;;;;;;KAiB9D,MAAA;EAAA,SACD,MAAA,EAAQ,MAAA,CAAO,MAAA,CAAO,MAAA,CAAO,MAAA,GAAS,OAAA;EAAA,SACtC,IAAA,GAAO,GAAA,EAAK,MAAA,CAAO,MAAA,MAAY,MAAA,CAAO,MAAA,CAAO,QAAA,CAAS,MAAA,GAAS,OAAA;EAAA,SAC/D,MAAA,GAAS,GAAA,EAAK,MAAA,CAAO,MAAA,MAAY,MAAA,CAAO,MAAA,OAAa,OAAA;AAAA;AAAA,KAGpD,SAAA;EA9BA,6EAgCD,YAAA,GAAe,QAAA,CAAS,KAAA,EAhCjB;EAAA,SAkCP,OAAA,GAAU,QAAA,CAAS,KAAA;AAAA;;;;;;;cAYjB,OAAA,WACX,IAAA,GAAO,GAAA,EAAK,MAAA,CAAO,MAAA,MAAY,MAAA,CAAO,MAAA,CAAO,QAAA,CAAS,MAAA,GAAS,OAAA,GAC/D,GAAA,EAAK,MAAA,CAAO,MAAA,GACZ,MAAA,GAAS,SAAA,KACR,MAAA,CAAO,MAAA,CAAO,MAAA,EAAQ,OAAA;AA3CzB;;;;;AAAA,cAuEa,GAAA,WACX,GAAA,EAAK,MAAA,CAAO,MAAA,GACZ,MAAA,GAAS,SAAA,KACR,MAAA,CAAO,MAAA,CAAO,MAAA,EAAQ,OAAA"}

package/dist/job/Job.mjs

@@ -0,0 +1,49 @@
+import { n as __exportAll } from "../chunk-uyGKjUfl.mjs";
+import { GenerationFailed, Timeout } from "../domain/AiError.mjs";
+import { Effect, Schedule } from "effect";
+//#region src/job/Job.ts
+var Job_exports = /* @__PURE__ */ __exportAll({
+	collect: () => collect,
+	isSettled: () => isSettled,
+	jobRef: () => jobRef,
+	run: () => run
+});
+/** The two states that end a poll loop. */
+const isSettled = (state) => state._tag === "Succeeded" || state._tag === "Failed";
+const jobRef = (provider, id) => ({
+	_tag: "JobRef",
+	provider,
+	id
+});
+const DEFAULT_POLL_INTERVAL = "10 seconds";
+const DEFAULT_TIMEOUT = "45 minutes";
+/**
+* Poll `poll(ref)` on a jittered fixed cadence until the job settles, then
+* return the result or fail `GenerationFailed`. Bounded by `timeout`, which
+* fails `Timeout` if the job never settles. Takes the poll op alone (not the
+* full `JobOps`) so a detached `collect(ref)` needs no submit-bound request.
+*/
+const collect = (poll, ref, config) => poll(ref).pipe(Effect.repeat({
+	schedule: Schedule.jittered(Schedule.spaced(config?.pollInterval ?? DEFAULT_POLL_INTERVAL)),
+	until: isSettled
+}), Effect.flatMap((state) => state._tag === "Succeeded" ? Effect.succeed(state.result) : Effect.fail(new GenerationFailed({
+	provider: ref.provider,
+	message: state._tag === "Failed" ? state.reason ?? "job failed" : "job failed",
+	raw: state._tag === "Failed" ? state.raw ?? ref : ref
+}))), Effect.timeoutOrElse({
+	duration: config?.timeout ?? DEFAULT_TIMEOUT,
+	orElse: () => Effect.fail(new Timeout({
+		provider: ref.provider,
+		raw: ref
+	}))
+}));
+/**
+* Submit, then poll to completion. Best-effort cancels the server job if the
+* caller interrupts (where the provider supports it). The one-call path; use
+* `ops.submit` + `collect` directly for the detached case.
+*/
+const run = (ops, config) => ops.submit.pipe(Effect.flatMap((ref) => collect(ops.poll, ref, config).pipe(Effect.onInterrupt(() => Effect.ignore(ops.cancel(ref))))));
+//#endregion
+export { collect, isSettled, jobRef, run, Job_exports as t };
+
+//# sourceMappingURL=Job.mjs.map

package/dist/job/Job.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Job.mjs","names":["AiError.GenerationFailed","AiError.Timeout"],"sources":["../../src/job/Job.ts"],"sourcesContent":["import { Duration, Effect, Schedule } from \"effect\"\nimport * as AiError from \"../domain/AiError.js\"\n\n// ---------------------------------------------------------------------------\n// Status + handle\n// ---------------------------------------------------------------------------\n\n/**\n * Normalized state of a provider-hosted background job. Implementors map their\n * provider's status vocabulary onto these four states. The terminal states\n * carry their payload: `Succeeded` the collected result, `Failed` an optional\n * reason and the raw provider error. This mirrors the wire, where a single\n * poll response returns both status and (when done) the result.\n */\nexport type JobState<A> =\n  | { readonly _tag: \"Pending\" }\n  | { readonly _tag: \"Running\" }\n  | { readonly _tag: \"Succeeded\"; readonly result: A }\n  | { readonly _tag: \"Failed\"; readonly reason?: string; readonly raw?: unknown }\n\n/** The two states that end a poll loop. */\nexport const isSettled = <A>(\n  state: JobState<A>,\n): state is Extract<JobState<A>, { _tag: \"Succeeded\" | \"Failed\" }> =>\n  state._tag === \"Succeeded\" || state._tag === \"Failed\"\n\ndeclare const ResultType: unique symbol\n\n/**\n * Opaque, provider-tagged handle to a running background job. Jobs can run for\n * minutes and outlive a single process, so the handle is detachable: submit\n * now, collect later. `provider` tags who owns `id`.\n *\n * Parameterized by the result type `A` it collects to, so a ref cannot be\n * crossed between capabilities (a `JobRef<Turn>` is not a `JobRef<VideoResult>`).\n * The brand is phantom: the runtime value is just `{ _tag, provider, id }`, so\n * a ref stays plain serializable data for persistence across restarts.\n */\nexport type JobRef<A = unknown> = {\n  readonly _tag: \"JobRef\"\n  readonly provider: string\n  readonly id: string\n  readonly [ResultType]?: A\n}\n\nexport const jobRef = <A = unknown>(provider: string, id: string): JobRef<A> => ({\n  _tag: \"JobRef\",\n  provider,\n  id,\n})\n\n// ---------------------------------------------------------------------------\n// Poll driver\n// ---------------------------------------------------------------------------\n\n/**\n * The three wire operations a poll-based async job supplies. `run` / `collect`\n * drive the submit -> poll -> settle cadence around them, so an implementor\n * states only its provider calls, not the loop. `poll` returns the current\n * `JobState`, carrying the result in `Succeeded`. Generic over the collected\n * `Result`.\n */\nexport type JobOps<Result> = {\n  readonly submit: Effect.Effect<JobRef<Result>, AiError.AiError>\n  readonly poll: (ref: JobRef<Result>) => Effect.Effect<JobState<Result>, AiError.AiError>\n  readonly cancel: (ref: JobRef<Result>) => Effect.Effect<void, AiError.AiError>\n}\n\nexport type JobConfig = {\n  /** Cadence between status fetches. Default 10 seconds, jittered. */\n  readonly pollInterval?: Duration.Input\n  /** Overall wait cap; exceeding it fails `Timeout`. Default 45 minutes. */\n  readonly timeout?: Duration.Input\n}\n\nconst DEFAULT_POLL_INTERVAL: Duration.Input = \"10 seconds\"\nconst DEFAULT_TIMEOUT: Duration.Input = \"45 minutes\"\n\n/**\n * Poll `poll(ref)` on a jittered fixed cadence until the job settles, then\n * return the result or fail `GenerationFailed`. Bounded by `timeout`, which\n * fails `Timeout` if the job never settles. Takes the poll op alone (not the\n * full `JobOps`) so a detached `collect(ref)` needs no submit-bound request.\n */\nexport const collect = <Result>(\n  poll: (ref: JobRef<Result>) => Effect.Effect<JobState<Result>, AiError.AiError>,\n  ref: JobRef<Result>,\n  config?: JobConfig,\n): Effect.Effect<Result, AiError.AiError> =>\n  poll(ref).pipe(\n    Effect.repeat({\n      schedule: Schedule.jittered(Schedule.spaced(config?.pollInterval ?? DEFAULT_POLL_INTERVAL)),\n      until: isSettled,\n    }),\n    Effect.flatMap((state) =>\n      state._tag === \"Succeeded\"\n        ? Effect.succeed(state.result)\n        : Effect.fail(\n            new AiError.GenerationFailed({\n              provider: ref.provider,\n              message: state._tag === \"Failed\" ? (state.reason ?? \"job failed\") : \"job failed\",\n              raw: state._tag === \"Failed\" ? (state.raw ?? ref) : ref,\n            }),\n          ),\n    ),\n    Effect.timeoutOrElse({\n      duration: config?.timeout ?? DEFAULT_TIMEOUT,\n      orElse: () => Effect.fail(new AiError.Timeout({ provider: ref.provider, raw: ref })),\n    }),\n  )\n\n/**\n * Submit, then poll to completion. Best-effort cancels the server job if the\n * caller interrupts (where the provider supports it). The one-call path; use\n * `ops.submit` + `collect` directly for the detached case.\n */\nexport const run = <Result>(\n  ops: JobOps<Result>,\n  config?: JobConfig,\n): Effect.Effect<Result, AiError.AiError> =>\n  ops.submit.pipe(\n    Effect.flatMap((ref) =>\n      collect(ops.poll, ref, config).pipe(Effect.onInterrupt(() => Effect.ignore(ops.cancel(ref)))),\n    ),\n  )\n"],"mappings":";;;;;;;;;;;AAqBA,MAAa,aACX,UAEA,MAAM,SAAS,eAAe,MAAM,SAAS;AAqB/C,MAAa,UAAuB,UAAkB,QAA2B;CAC/E,MAAM;CACN;CACA;CACD;AA0BD,MAAM,wBAAwC;AAC9C,MAAM,kBAAkC;;;;;;;AAQxC,MAAa,WACX,MACA,KACA,WAEA,KAAK,IAAI,CAAC,KACR,OAAO,OAAO;CACZ,UAAU,SAAS,SAAS,SAAS,OAAO,QAAQ,gBAAgB,sBAAsB,CAAC;CAC3F,OAAO;CACR,CAAC,EACF,OAAO,SAAS,UACd,MAAM,SAAS,cACX,OAAO,QAAQ,MAAM,OAAO,GAC5B,OAAO,KACL,IAAIA,iBAAyB;CAC3B,UAAU,IAAI;CACd,SAAS,MAAM,SAAS,WAAY,MAAM,UAAU,eAAgB;CACpE,KAAK,MAAM,SAAS,WAAY,MAAM,OAAO,MAAO;CACrD,CAAC,CACH,CACN,EACD,OAAO,cAAc;CACnB,UAAU,QAAQ,WAAW;CAC7B,cAAc,OAAO,KAAK,IAAIC,QAAgB;EAAE,UAAU,IAAI;EAAU,KAAK;EAAK,CAAC,CAAC;CACrF,CAAC,CACH;;;;;;AAOH,MAAa,OACX,KACA,WAEA,IAAI,OAAO,KACT,OAAO,SAAS,QACd,QAAQ,IAAI,MAAM,KAAK,OAAO,CAAC,KAAK,OAAO,kBAAkB,OAAO,OAAO,IAAI,OAAO,IAAI,CAAC,CAAC,CAAC,CAC9F,CACF"}

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

@@ -1,8 +1,8 @@
-import { o as HistoryItem } from "../Items-BnIduEV2.mjs";
+import { o as HistoryItem } from "../Items-BWNu6VGp.mjs";
 import { t as AiError } from "../AiError-Bf1pq4BB.mjs";
 import { i as StructuredFormat } from "../StructuredFormat-DHaUJBdd.mjs";
 import { Turn, TurnEvent } from "../domain/Turn.mjs";
-import { o as Toolkit } from "../Toolkit-Dr9l_hNy.mjs";
+import { o as Toolkit } from "../Toolkit-BYPwwu-j.mjs";
 import { Context, Effect, Stream } from "effect";
 
 //#region src/language-model/LanguageModel.d.ts

package/dist/language-model/LanguageModel.mjs

@@ -13,14 +13,14 @@ var LanguageModel = class extends Context.Service()("@betalyra/effect-uai/Langua
 /**
 * Stream the deltas of a single turn.
 */
-const streamTurn = (request) => Stream.unwrap(Effect.map(LanguageModel.asEffect(), (m) => m.streamTurn(request)));
+const streamTurn = (request) => Stream.unwrap(Effect.map(LanguageModel, (m) => m.streamTurn(request)));
 /**
 * Drain a single turn and return the assembled `Turn`. Delegates to the
 * service's `turn` method — providers with a native complete endpoint
 * can override; the rest get the default streamTurn-drain via
 * {@link turnFromStream}.
 */
-const turn = (request) => Effect.flatMap(LanguageModel.asEffect(), (m) => m.turn(request));
+const turn = (request) => Effect.flatMap(LanguageModel, (m) => m.turn(request));
 /**
 * Build a `turn` implementation from a `streamTurn` implementation.
 * Providers without a native non-streaming endpoint use this to

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

@@ -1 +1 @@
-{"version":3,"file":"LanguageModel.mjs","names":["Arr","AiError.IncompleteTurn"],"sources":["../../src/language-model/LanguageModel.ts"],"sourcesContent":["import { Array as Arr, Context, Effect, Option, Stream } from \"effect\"\nimport * as AiError from \"../domain/AiError.js\"\nimport type { HistoryItem } from \"../domain/Items.js\"\nimport type * as StructuredFormat from \"../structured-format/StructuredFormat.js\"\nimport type { Toolkit } from \"../tool/Toolkit.js\"\nimport { isTurnComplete, type Turn, type TurnEvent } from \"../domain/Turn.js\"\n\n/**\n * Cross-provider request shape. Every call carries its own `history` and\n * `model` - models are not bound at layer construction. Anything specific\n * to a single provider (reasoning effort, prompt caching, store flags,\n * ...) lives in that provider's own request interface, which extends this.\n */\nexport type CommonRequest = {\n  readonly history: ReadonlyArray<HistoryItem>\n  /**\n   * Model identifier. Each provider narrows this to its typed literal union,\n   * so code that yields a typed provider tag gets autocompletion.\n   */\n  readonly model: string\n  /**\n   * The model-visible tools for this request, as a `Toolkit`. The provider\n   * renders it to wire descriptors (`Tool.descriptorsOf`); omit it for a turn\n   * with no tools.\n   */\n  readonly tools?: Toolkit\n  readonly toolChoice?:\n    | \"auto\"\n    | \"required\"\n    | \"none\"\n    | { readonly type: \"function\"; readonly name: string }\n  readonly temperature?: number\n  readonly topP?: number\n  readonly maxOutputTokens?: number\n  /**\n   * Schema-bound JSON output. The provider constrains the wire to match the\n   * schema; pair with `Turn.decodeStructured` for runtime validation. Supported\n   * across all current providers (OpenAI Responses json_schema, Anthropic\n   * `output_config`, Gemini `responseJsonSchema`).\n   */\n  readonly structured?: StructuredFormat.StructuredFormat<unknown>\n}\n\nexport type LanguageModelService = {\n  readonly streamTurn: (request: CommonRequest) => Stream.Stream<TurnEvent, AiError.AiError>\n  /**\n   * Drain a single turn and return the assembled `Turn` from the\n   * terminal `TurnComplete` event. Fails with `IncompleteTurn` if the\n   * stream ends without one.\n   *\n   * Most providers derive this from `streamTurn` via\n   * {@link turnFromStream}; providers with a native non-streaming\n   * endpoint may override with a cheaper direct call.\n   */\n  readonly turn: (request: CommonRequest) => Effect.Effect<Turn, AiError.AiError>\n}\n\nexport class LanguageModel extends Context.Service<LanguageModel, LanguageModelService>()(\n  \"@betalyra/effect-uai/LanguageModel\",\n) {}\n\n/**\n * Stream the deltas of a single turn.\n */\nexport const streamTurn = (\n  request: CommonRequest,\n): Stream.Stream<TurnEvent, AiError.AiError, LanguageModel> =>\n  Stream.unwrap(Effect.map(LanguageModel.asEffect(), (m) => m.streamTurn(request)))\n\n/**\n * Drain a single turn and return the assembled `Turn`. Delegates to the\n * service's `turn` method — providers with a native complete endpoint\n * can override; the rest get the default streamTurn-drain via\n * {@link turnFromStream}.\n */\nexport const turn = (request: CommonRequest): Effect.Effect<Turn, AiError.AiError, LanguageModel> =>\n  Effect.flatMap(LanguageModel.asEffect(), (m) => m.turn(request))\n\n/**\n * Build a `turn` implementation from a `streamTurn` implementation.\n * Providers without a native non-streaming endpoint use this to\n * populate the service's `turn` field. Generic over the request type so\n * provider-typed services (with their narrowed request) can reuse it.\n */\nexport const turnFromStream =\n  <Req>(streamTurn: (request: Req) => Stream.Stream<TurnEvent, AiError.AiError>) =>\n  (request: Req): Effect.Effect<Turn, AiError.AiError> =>\n    streamTurn(request).pipe(\n      Stream.runCollect,\n      Effect.flatMap((events) =>\n        Arr.findLast(events, isTurnComplete).pipe(\n          Option.match({\n            onNone: () => Effect.fail(new AiError.IncompleteTurn({})),\n            onSome: (e) => Effect.succeed(e.turn),\n          }),\n        ),\n      ),\n    )\n"],"mappings":";;;;;;;;;;;AAyDA,IAAa,gBAAb,cAAmC,QAAQ,SAA8C,CACvF,qCACD,CAAC;;;;AAKF,MAAa,cACX,YAEA,OAAO,OAAO,OAAO,IAAI,cAAc,UAAU,GAAG,MAAM,EAAE,WAAW,QAAQ,CAAC,CAAC;;;;;;;AAQnF,MAAa,QAAQ,YACnB,OAAO,QAAQ,cAAc,UAAU,GAAG,MAAM,EAAE,KAAK,QAAQ,CAAC;;;;;;;AAQlE,MAAa,kBACL,gBACL,YACC,WAAW,QAAQ,CAAC,KAClB,OAAO,YACP,OAAO,SAAS,WACdA,MAAI,SAAS,QAAQ,eAAe,CAAC,KACnC,OAAO,MAAM;CACX,cAAc,OAAO,KAAK,IAAIC,eAAuB,EAAE,CAAC,CAAC;CACzD,SAAS,MAAM,OAAO,QAAQ,EAAE,KAAK;CACtC,CAAC,CACH,CACF,CACF"}
+{"version":3,"file":"LanguageModel.mjs","names":["Arr","AiError.IncompleteTurn"],"sources":["../../src/language-model/LanguageModel.ts"],"sourcesContent":["import { Array as Arr, Context, Effect, Option, Stream } from \"effect\"\nimport * as AiError from \"../domain/AiError.js\"\nimport type { HistoryItem } from \"../domain/Items.js\"\nimport type * as StructuredFormat from \"../structured-format/StructuredFormat.js\"\nimport type { Toolkit } from \"../tool/Toolkit.js\"\nimport { isTurnComplete, type Turn, type TurnEvent } from \"../domain/Turn.js\"\n\n/**\n * Cross-provider request shape. Every call carries its own `history` and\n * `model` - models are not bound at layer construction. Anything specific\n * to a single provider (reasoning effort, prompt caching, store flags,\n * ...) lives in that provider's own request interface, which extends this.\n */\nexport type CommonRequest = {\n  readonly history: ReadonlyArray<HistoryItem>\n  /**\n   * Model identifier. Each provider narrows this to its typed literal union,\n   * so code that yields a typed provider tag gets autocompletion.\n   */\n  readonly model: string\n  /**\n   * The model-visible tools for this request, as a `Toolkit`. The provider\n   * renders it to wire descriptors (`Tool.descriptorsOf`); omit it for a turn\n   * with no tools.\n   */\n  readonly tools?: Toolkit\n  readonly toolChoice?:\n    | \"auto\"\n    | \"required\"\n    | \"none\"\n    | { readonly type: \"function\"; readonly name: string }\n  readonly temperature?: number\n  readonly topP?: number\n  readonly maxOutputTokens?: number\n  /**\n   * Schema-bound JSON output. The provider constrains the wire to match the\n   * schema; pair with `Turn.decodeStructured` for runtime validation. Supported\n   * across all current providers (OpenAI Responses json_schema, Anthropic\n   * `output_config`, Gemini `responseJsonSchema`).\n   */\n  readonly structured?: StructuredFormat.StructuredFormat<unknown>\n}\n\nexport type LanguageModelService = {\n  readonly streamTurn: (request: CommonRequest) => Stream.Stream<TurnEvent, AiError.AiError>\n  /**\n   * Drain a single turn and return the assembled `Turn` from the\n   * terminal `TurnComplete` event. Fails with `IncompleteTurn` if the\n   * stream ends without one.\n   *\n   * Most providers derive this from `streamTurn` via\n   * {@link turnFromStream}; providers with a native non-streaming\n   * endpoint may override with a cheaper direct call.\n   */\n  readonly turn: (request: CommonRequest) => Effect.Effect<Turn, AiError.AiError>\n}\n\nexport class LanguageModel extends Context.Service<LanguageModel, LanguageModelService>()(\n  \"@betalyra/effect-uai/LanguageModel\",\n) {}\n\n/**\n * Stream the deltas of a single turn.\n */\nexport const streamTurn = (\n  request: CommonRequest,\n): Stream.Stream<TurnEvent, AiError.AiError, LanguageModel> =>\n  Stream.unwrap(Effect.map(LanguageModel, (m) => m.streamTurn(request)))\n\n/**\n * Drain a single turn and return the assembled `Turn`. Delegates to the\n * service's `turn` method — providers with a native complete endpoint\n * can override; the rest get the default streamTurn-drain via\n * {@link turnFromStream}.\n */\nexport const turn = (request: CommonRequest): Effect.Effect<Turn, AiError.AiError, LanguageModel> =>\n  Effect.flatMap(LanguageModel, (m) => m.turn(request))\n\n/**\n * Build a `turn` implementation from a `streamTurn` implementation.\n * Providers without a native non-streaming endpoint use this to\n * populate the service's `turn` field. Generic over the request type so\n * provider-typed services (with their narrowed request) can reuse it.\n */\nexport const turnFromStream =\n  <Req>(streamTurn: (request: Req) => Stream.Stream<TurnEvent, AiError.AiError>) =>\n  (request: Req): Effect.Effect<Turn, AiError.AiError> =>\n    streamTurn(request).pipe(\n      Stream.runCollect,\n      Effect.flatMap((events) =>\n        Arr.findLast(events, isTurnComplete).pipe(\n          Option.match({\n            onNone: () => Effect.fail(new AiError.IncompleteTurn({})),\n            onSome: (e) => Effect.succeed(e.turn),\n          }),\n        ),\n      ),\n    )\n"],"mappings":";;;;;;;;;;;AAyDA,IAAa,gBAAb,cAAmC,QAAQ,SAA8C,CACvF,qCACD,CAAC;;;;AAKF,MAAa,cACX,YAEA,OAAO,OAAO,OAAO,IAAI,gBAAgB,MAAM,EAAE,WAAW,QAAQ,CAAC,CAAC;;;;;;;AAQxE,MAAa,QAAQ,YACnB,OAAO,QAAQ,gBAAgB,MAAM,EAAE,KAAK,QAAQ,CAAC;;;;;;;AAQvD,MAAa,kBACL,gBACL,YACC,WAAW,QAAQ,CAAC,KAClB,OAAO,YACP,OAAO,SAAS,WACdA,MAAI,SAAS,QAAQ,eAAe,CAAC,KACnC,OAAO,MAAM;CACX,cAAc,OAAO,KAAK,IAAIC,eAAuB,EAAE,CAAC,CAAC;CACzD,SAAS,MAAM,OAAO,QAAQ,EAAE,KAAK;CACtC,CAAC,CACH,CACF,CACF"}

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

@@ -2,7 +2,7 @@ import { IncompleteTurn, RateLimited } from "../domain/AiError.mjs";
 import { assistantText, userText } from "../domain/Items.mjs";
 import { TurnEvent } from "../domain/Turn.mjs";
 import { LanguageModel, turn, turnFromStream } from "./LanguageModel.mjs";
-import { a as describe, n as globalExpect, o as it } from "../dist-B04dlFHg.mjs";
+import { c as it, n as globalExpect, o as describe } from "../dist-CcRV3-A5.mjs";
 import { layer } from "../testing/MockProvider.mjs";
 import { Cause, Effect, Exit, Layer, Option, Stream } from "effect";
 //#region src/language-model/LanguageModel.test.ts

package/dist/loop/Loop.test.mjs

@@ -1,7 +1,7 @@
 import { RateLimited } from "../domain/AiError.mjs";
 import { TurnEvent } from "../domain/Turn.mjs";
 import { loop, loopOver, loopWithState, next, onTurnComplete, stop, value } from "./Loop.mjs";
-import { a as describe, n as globalExpect, o as it, t as import_dist } from "../dist-B04dlFHg.mjs";
+import { c as it, n as globalExpect, o as describe, t as import_dist } from "../dist-CcRV3-A5.mjs";
 import { Deferred, Effect, Fiber, Latch, Ref, Stream, SubscriptionRef, pipe } from "effect";
 //#region src/loop/Loop.test.ts
 describe("Loop.loop", () => {

package/dist/music-generator/MusicGenerator.mjs

@@ -21,9 +21,9 @@ var MusicGenerator = class extends Context.Service()("@betalyra/effect-uai/Music
 */
 var MusicInteractiveSession = class extends Context.Service()("@betalyra/effect-uai/capability/MusicInteractiveSession") {};
 /** One-shot generation. Returns the full `GenerateResult`. */
-const generate = (request) => Effect.flatMap(MusicGenerator.asEffect(), (s) => s.generate(request));
+const generate = (request) => Effect.flatMap(MusicGenerator, (s) => s.generate(request));
 /** Prompt in, audio chunks out. */
-const streamGeneration = (request) => Stream.unwrap(Effect.map(MusicGenerator.asEffect(), (s) => s.streamGeneration(request)));
+const streamGeneration = (request) => Stream.unwrap(Effect.map(MusicGenerator, (s) => s.streamGeneration(request)));
 /**
 * Bidirectional generation. Dual-arity: pipeable (data-last) and
 * direct (data-first). Requires `MusicInteractiveSession` in R,
@@ -49,8 +49,8 @@ const streamGeneration = (request) => Stream.unwrap(Effect.map(MusicGenerator.as
 * ```
 */
 const streamGenerationFrom = Function.dual(2, (input, request) => Stream.unwrap(Effect.gen(function* () {
-	const s = yield* MusicGenerator.asEffect();
-	yield* MusicInteractiveSession.asEffect();
+	const s = yield* MusicGenerator;
+	yield* MusicInteractiveSession;
 	return s.streamGenerationFrom(input, request);
 })));
 //#endregion

package/dist/music-generator/MusicGenerator.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"MusicGenerator.mjs","names":[],"sources":["../../src/music-generator/MusicGenerator.ts"],"sourcesContent":["import { Context, Effect, Function, Stream } from \"effect\"\nimport * as AiError from \"../domain/AiError.js\"\nimport type {\n  CommonGenerateMusicRequest,\n  CommonStreamGenerateMusicRequest,\n  GenerateResult,\n  MusicSessionInput,\n  MusicStreamEvent,\n} from \"../domain/Music.js\"\nimport type { AudioChunk } from \"../domain/Audio.js\"\n\nexport type {\n  CommonGenerateMusicRequest,\n  CommonStreamGenerateMusicRequest,\n  GenerateResult,\n  MusicResult,\n  MusicSection,\n  MusicSessionControl,\n  MusicSessionInput,\n  MusicStreamEvent,\n  Watermark,\n  WeightedPrompt,\n} from \"../domain/Music.js\"\n\nexport type MusicGeneratorService = {\n  /**\n   * One-shot. Prompt in, full audio bytes out. Universally supported.\n   * Async/poll-based providers (Suno, Mureka) hide their poll loop\n   * inside the adapter, caller still sees a single `Effect`.\n   *\n   * Returns `GenerateResult` with `primary` plus a `variants` array.\n   * Suno and Mureka always return 2 tracks; every other provider\n   * returns 1 (and `primary === variants[0]`).\n   */\n  readonly generate: (\n    request: CommonGenerateMusicRequest,\n  ) => Effect.Effect<GenerateResult, AiError.AiError>\n  /**\n   * Prompt in, audio chunks streamed out. Providers without a native\n   * chunked-output endpoint (Lyria 3 sync, Mureka, MiniMax, Stable\n   * Audio) emulate this by calling `generate` and emitting a single\n   * `AudioChunk`, first-class, no `Unsupported`.\n   */\n  readonly streamGeneration: (\n    request: CommonStreamGenerateMusicRequest,\n  ) => Stream.Stream<AudioChunk, AiError.AiError>\n  /**\n   * Bidirectional session: a `Stream` of `MusicSessionInput` (prompts\n   * + playback control) flows in, a `Stream` of `MusicStreamEvent`\n   * flows out. The session WS / RPC is acquired on first pull and\n   * released when the output stream is finalized via `Stream.scoped`.\n   *\n   * Cross-provider callers send `prompts` (steer the active\n   * generation) and `control` (play / pause / stop / reset) — the two\n   * actions that converge across interactive-media protocols.\n   * Provider-specific model knobs (Lyria RealTime's density /\n   * brightness / mute-stems / BPM / scale, etc.) live on the\n   * provider-typed service (`LyriaRealtimeGenerator.streamGenerationFrom`),\n   * which extends this union with its own `config` variant.\n   *\n   * Output is `MusicStreamEvent`: `audio` chunks alongside in-band\n   * `warning` and `filteredPrompt` events the model emits server-side.\n   *\n   * Gated by the `MusicInteractiveSession` capability marker on the\n   * top-level helper. Providers without bidirectional support don't\n   * ship the marker, so calls fail at `Effect.provide` with a type\n   * error.\n   */\n  readonly streamGenerationFrom: <E, R>(\n    input: Stream.Stream<MusicSessionInput, E, R>,\n    request: CommonStreamGenerateMusicRequest,\n  ) => Stream.Stream<MusicStreamEvent, AiError.AiError | E, R>\n}\n\nexport class MusicGenerator extends Context.Service<MusicGenerator, MusicGeneratorService>()(\n  \"@betalyra/effect-uai/MusicGenerator\",\n) {}\n\n/**\n * Capability marker, provided by provider layers whose\n * `streamGenerationFrom` is wired up at the wire level. Currently only\n * Lyria RealTime (via the BidiGenerateMusic WebSocket) ships it.\n * Calling `streamGenerationFrom` while only a non-interactive Layer is\n * in scope fails at `Effect.provide` with a type error.\n *\n * Phantom: the value is `void`; providers register with\n * `Layer.succeed(MusicInteractiveSession, undefined)`.\n */\nexport class MusicInteractiveSession extends Context.Service<MusicInteractiveSession, void>()(\n  \"@betalyra/effect-uai/capability/MusicInteractiveSession\",\n) {}\n\n/** One-shot generation. Returns the full `GenerateResult`. */\nexport const generate = (\n  request: CommonGenerateMusicRequest,\n): Effect.Effect<GenerateResult, AiError.AiError, MusicGenerator> =>\n  Effect.flatMap(MusicGenerator.asEffect(), (s) => s.generate(request))\n\n/** Prompt in, audio chunks out. */\nexport const streamGeneration = (\n  request: CommonStreamGenerateMusicRequest,\n): Stream.Stream<AudioChunk, AiError.AiError, MusicGenerator> =>\n  Stream.unwrap(Effect.map(MusicGenerator.asEffect(), (s) => s.streamGeneration(request)))\n\n/**\n * Bidirectional generation. Dual-arity: pipeable (data-last) and\n * direct (data-first). Requires `MusicInteractiveSession` in R,\n * providers without bidirectional support are a type error at provide\n * time.\n *\n * On the cross-provider surface, `input` is `Stream<unknown>` and\n * output is `Stream<MusicStreamEvent>`. Use the provider-typed\n * service (`LyriaRealtimeGenerator`) when you want to construct\n * typed session messages.\n *\n * @example\n * ```ts\n * // Generic surface (opaque input):\n * const audio = inputs.pipe(\n *   MusicGenerator.streamGenerationFrom({ model: \"lyria-realtime-exp\", prompt: \"\" }),\n * )\n *\n * // Lyria-typed surface (full config knobs):\n * const audio = inputs.pipe(\n *   LyriaRealtimeGenerator.streamGenerationFrom({ model: \"lyria-realtime-exp\", prompt: \"\" }),\n * )\n * ```\n */\nexport const streamGenerationFrom: {\n  (\n    request: CommonStreamGenerateMusicRequest,\n  ): <E, R>(\n    input: Stream.Stream<MusicSessionInput, E, R>,\n  ) => Stream.Stream<\n    MusicStreamEvent,\n    AiError.AiError | E,\n    R | MusicGenerator | MusicInteractiveSession\n  >\n  <E, R>(\n    input: Stream.Stream<MusicSessionInput, E, R>,\n    request: CommonStreamGenerateMusicRequest,\n  ): Stream.Stream<\n    MusicStreamEvent,\n    AiError.AiError | E,\n    R | MusicGenerator | MusicInteractiveSession\n  >\n} = Function.dual(\n  2,\n  <E, R>(\n    input: Stream.Stream<MusicSessionInput, E, R>,\n    request: CommonStreamGenerateMusicRequest,\n  ): Stream.Stream<\n    MusicStreamEvent,\n    AiError.AiError | E,\n    R | MusicGenerator | MusicInteractiveSession\n  > =>\n    Stream.unwrap(\n      Effect.gen(function* () {\n        const s = yield* MusicGenerator.asEffect()\n        yield* MusicInteractiveSession.asEffect()\n        return s.streamGenerationFrom(input, request)\n      }),\n    ),\n)\n"],"mappings":";;;;;;;;;;AA0EA,IAAa,iBAAb,cAAoC,QAAQ,SAAgD,CAC1F,sCACD,CAAC;;;;;;;;;;;AAYF,IAAa,0BAAb,cAA6C,QAAQ,SAAwC,CAC3F,0DACD,CAAC;;AAGF,MAAa,YACX,YAEA,OAAO,QAAQ,eAAe,UAAU,GAAG,MAAM,EAAE,SAAS,QAAQ,CAAC;;AAGvE,MAAa,oBACX,YAEA,OAAO,OAAO,OAAO,IAAI,eAAe,UAAU,GAAG,MAAM,EAAE,iBAAiB,QAAQ,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;AA0B1F,MAAa,uBAkBT,SAAS,KACX,IAEE,OACA,YAMA,OAAO,OACL,OAAO,IAAI,aAAa;CACtB,MAAM,IAAI,OAAO,eAAe,UAAU;AAC1C,QAAO,wBAAwB,UAAU;AACzC,QAAO,EAAE,qBAAqB,OAAO,QAAQ;EAC7C,CACH,CACJ"}
+{"version":3,"file":"MusicGenerator.mjs","names":[],"sources":["../../src/music-generator/MusicGenerator.ts"],"sourcesContent":["import { Context, Effect, Function, Stream } from \"effect\"\nimport * as AiError from \"../domain/AiError.js\"\nimport type {\n  CommonGenerateMusicRequest,\n  CommonStreamGenerateMusicRequest,\n  GenerateResult,\n  MusicSessionInput,\n  MusicStreamEvent,\n} from \"../domain/Music.js\"\nimport type { AudioChunk } from \"../domain/Audio.js\"\n\nexport type {\n  CommonGenerateMusicRequest,\n  CommonStreamGenerateMusicRequest,\n  GenerateResult,\n  MusicResult,\n  MusicSection,\n  MusicSessionControl,\n  MusicSessionInput,\n  MusicStreamEvent,\n  Watermark,\n  WeightedPrompt,\n} from \"../domain/Music.js\"\n\nexport type MusicGeneratorService = {\n  /**\n   * One-shot. Prompt in, full audio bytes out. Universally supported.\n   * Async/poll-based providers (Suno, Mureka) hide their poll loop\n   * inside the adapter, caller still sees a single `Effect`.\n   *\n   * Returns `GenerateResult` with `primary` plus a `variants` array.\n   * Suno and Mureka always return 2 tracks; every other provider\n   * returns 1 (and `primary === variants[0]`).\n   */\n  readonly generate: (\n    request: CommonGenerateMusicRequest,\n  ) => Effect.Effect<GenerateResult, AiError.AiError>\n  /**\n   * Prompt in, audio chunks streamed out. Providers without a native\n   * chunked-output endpoint (Lyria 3 sync, Mureka, MiniMax, Stable\n   * Audio) emulate this by calling `generate` and emitting a single\n   * `AudioChunk`, first-class, no `Unsupported`.\n   */\n  readonly streamGeneration: (\n    request: CommonStreamGenerateMusicRequest,\n  ) => Stream.Stream<AudioChunk, AiError.AiError>\n  /**\n   * Bidirectional session: a `Stream` of `MusicSessionInput` (prompts\n   * + playback control) flows in, a `Stream` of `MusicStreamEvent`\n   * flows out. The session WS / RPC is acquired on first pull and\n   * released when the output stream is finalized via `Stream.scoped`.\n   *\n   * Cross-provider callers send `prompts` (steer the active\n   * generation) and `control` (play / pause / stop / reset) — the two\n   * actions that converge across interactive-media protocols.\n   * Provider-specific model knobs (Lyria RealTime's density /\n   * brightness / mute-stems / BPM / scale, etc.) live on the\n   * provider-typed service (`LyriaRealtimeGenerator.streamGenerationFrom`),\n   * which extends this union with its own `config` variant.\n   *\n   * Output is `MusicStreamEvent`: `audio` chunks alongside in-band\n   * `warning` and `filteredPrompt` events the model emits server-side.\n   *\n   * Gated by the `MusicInteractiveSession` capability marker on the\n   * top-level helper. Providers without bidirectional support don't\n   * ship the marker, so calls fail at `Effect.provide` with a type\n   * error.\n   */\n  readonly streamGenerationFrom: <E, R>(\n    input: Stream.Stream<MusicSessionInput, E, R>,\n    request: CommonStreamGenerateMusicRequest,\n  ) => Stream.Stream<MusicStreamEvent, AiError.AiError | E, R>\n}\n\nexport class MusicGenerator extends Context.Service<MusicGenerator, MusicGeneratorService>()(\n  \"@betalyra/effect-uai/MusicGenerator\",\n) {}\n\n/**\n * Capability marker, provided by provider layers whose\n * `streamGenerationFrom` is wired up at the wire level. Currently only\n * Lyria RealTime (via the BidiGenerateMusic WebSocket) ships it.\n * Calling `streamGenerationFrom` while only a non-interactive Layer is\n * in scope fails at `Effect.provide` with a type error.\n *\n * Phantom: the value is `void`; providers register with\n * `Layer.succeed(MusicInteractiveSession, undefined)`.\n */\nexport class MusicInteractiveSession extends Context.Service<MusicInteractiveSession, void>()(\n  \"@betalyra/effect-uai/capability/MusicInteractiveSession\",\n) {}\n\n/** One-shot generation. Returns the full `GenerateResult`. */\nexport const generate = (\n  request: CommonGenerateMusicRequest,\n): Effect.Effect<GenerateResult, AiError.AiError, MusicGenerator> =>\n  Effect.flatMap(MusicGenerator, (s) => s.generate(request))\n\n/** Prompt in, audio chunks out. */\nexport const streamGeneration = (\n  request: CommonStreamGenerateMusicRequest,\n): Stream.Stream<AudioChunk, AiError.AiError, MusicGenerator> =>\n  Stream.unwrap(Effect.map(MusicGenerator, (s) => s.streamGeneration(request)))\n\n/**\n * Bidirectional generation. Dual-arity: pipeable (data-last) and\n * direct (data-first). Requires `MusicInteractiveSession` in R,\n * providers without bidirectional support are a type error at provide\n * time.\n *\n * On the cross-provider surface, `input` is `Stream<unknown>` and\n * output is `Stream<MusicStreamEvent>`. Use the provider-typed\n * service (`LyriaRealtimeGenerator`) when you want to construct\n * typed session messages.\n *\n * @example\n * ```ts\n * // Generic surface (opaque input):\n * const audio = inputs.pipe(\n *   MusicGenerator.streamGenerationFrom({ model: \"lyria-realtime-exp\", prompt: \"\" }),\n * )\n *\n * // Lyria-typed surface (full config knobs):\n * const audio = inputs.pipe(\n *   LyriaRealtimeGenerator.streamGenerationFrom({ model: \"lyria-realtime-exp\", prompt: \"\" }),\n * )\n * ```\n */\nexport const streamGenerationFrom: {\n  (\n    request: CommonStreamGenerateMusicRequest,\n  ): <E, R>(\n    input: Stream.Stream<MusicSessionInput, E, R>,\n  ) => Stream.Stream<\n    MusicStreamEvent,\n    AiError.AiError | E,\n    R | MusicGenerator | MusicInteractiveSession\n  >\n  <E, R>(\n    input: Stream.Stream<MusicSessionInput, E, R>,\n    request: CommonStreamGenerateMusicRequest,\n  ): Stream.Stream<\n    MusicStreamEvent,\n    AiError.AiError | E,\n    R | MusicGenerator | MusicInteractiveSession\n  >\n} = Function.dual(\n  2,\n  <E, R>(\n    input: Stream.Stream<MusicSessionInput, E, R>,\n    request: CommonStreamGenerateMusicRequest,\n  ): Stream.Stream<\n    MusicStreamEvent,\n    AiError.AiError | E,\n    R | MusicGenerator | MusicInteractiveSession\n  > =>\n    Stream.unwrap(\n      Effect.gen(function* () {\n        const s = yield* MusicGenerator\n        yield* MusicInteractiveSession\n        return s.streamGenerationFrom(input, request)\n      }),\n    ),\n)\n"],"mappings":";;;;;;;;;;AA0EA,IAAa,iBAAb,cAAoC,QAAQ,SAAgD,CAC1F,sCACD,CAAC;;;;;;;;;;;AAYF,IAAa,0BAAb,cAA6C,QAAQ,SAAwC,CAC3F,0DACD,CAAC;;AAGF,MAAa,YACX,YAEA,OAAO,QAAQ,iBAAiB,MAAM,EAAE,SAAS,QAAQ,CAAC;;AAG5D,MAAa,oBACX,YAEA,OAAO,OAAO,OAAO,IAAI,iBAAiB,MAAM,EAAE,iBAAiB,QAAQ,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;AA0B/E,MAAa,uBAkBT,SAAS,KACX,IAEE,OACA,YAMA,OAAO,OACL,OAAO,IAAI,aAAa;CACtB,MAAM,IAAI,OAAO;AACjB,QAAO;AACP,QAAO,EAAE,qBAAqB,OAAO,QAAQ;EAC7C,CACH,CACJ"}

package/dist/music-generator/MusicGenerator.test.mjs

@@ -1,6 +1,6 @@
 import { audioEvent, controlInput, promptsInput, singleVariant } from "../domain/Music.mjs";
 import { generate, streamGeneration, streamGenerationFrom } from "./MusicGenerator.mjs";
-import { a as describe, n as globalExpect, o as it, t as import_dist } from "../dist-B04dlFHg.mjs";
+import { c as it, n as globalExpect, o as describe, t as import_dist } from "../dist-CcRV3-A5.mjs";
 import { layer, layerWithoutInteractive } from "../testing/MockMusicGenerator.mjs";
 import { Duration, Effect, Stream } from "effect";
 //#region src/music-generator/MusicGenerator.test.ts

package/dist/observability/Metrics.d.mts

@@ -1,4 +1,4 @@
-import { x as Usage } from "../Items-BnIduEV2.mjs";
+import { x as Usage } from "../Items-BWNu6VGp.mjs";
 import { TurnEvent } from "../domain/Turn.mjs";
 import { Duration, Effect, Option, Stream } from "effect";
 

package/dist/observability/Metrics.test.mjs

@@ -1,7 +1,7 @@
 import { TurnEvent } from "../domain/Turn.mjs";
 import { computeThroughputTick, isMetricEvent, makeEvent, metricEvents, throughput, timeToCompletion, timeToFirstToken, tokenTotals } from "./Metrics.mjs";
-import { a as describe, n as globalExpect } from "../dist-B04dlFHg.mjs";
-import { t as it } from "../dist-DWgRbDN3.mjs";
+import { n as globalExpect, o as describe } from "../dist-CcRV3-A5.mjs";
+import { t as it } from "../dist-C0m0QnUP.mjs";
 import { Array, Duration, Effect, Fiber, Option, Stream } from "effect";
 import * as TestClock from "effect/testing/TestClock";
 //#region src/observability/Metrics.test.ts

package/dist/observability/Telemetry.test.mjs

@@ -1,7 +1,7 @@
 import { makeEvent } from "./Metrics.mjs";
 import { layerOtlp, record } from "./Telemetry.mjs";
-import { a as describe, n as globalExpect } from "../dist-B04dlFHg.mjs";
-import { t as it } from "../dist-DWgRbDN3.mjs";
+import { n as globalExpect, o as describe } from "../dist-CcRV3-A5.mjs";
+import { t as it } from "../dist-C0m0QnUP.mjs";
 import { Array, Duration, Effect, Layer, Metric, Option, Ref, Stream } from "effect";
 import { HttpClient, HttpClientResponse } from "effect/unstable/http";
 //#region src/observability/Telemetry.test.ts

package/dist/research/DeepResearch.d.mts

@@ -0,0 +1,71 @@
+import { t as AiError } from "../AiError-Bf1pq4BB.mjs";
+import { JobConfig } from "../job/Job.mjs";
+import { Turn, TurnEvent } from "../domain/Turn.mjs";
+import { ResearchJobRef, ResearchRequest, ResearchState } from "../domain/Research.mjs";
+import { Context, Effect, Stream } from "effect";
+
+//#region src/research/DeepResearch.d.ts
+declare namespace DeepResearch_d_exports {
+  export { DeepResearch, DeepResearchService, DeepResearchServiceShape, ResearchJobOps, ResearchJobRef, ResearchRequest, ResearchState, cancel, collect, fromJob, research, researchStream, status, streamFrom, submit };
+}
+/**
+ * Deep research: submit a question, watch a long-running background job, collect
+ * one cited report. Every provider is modeled as a job (`submit` / `poll` /
+ * `cancel`), so the surface is uniform. The convenience derivations
+ * (`research` / `researchStream` / `collect` / `status`) are the same for every
+ * provider and are built once by {@link fromJob}, so an implementor states only
+ * its wire calls, never the poll loop.
+ *
+ * `research` is the blocking one-liner (submit then poll to the terminal `Turn`);
+ * `researchStream` forwards live progress as `TurnEvent`s, terminating in
+ * `TurnComplete` whose `turn` is the value `research` / `collect` return. The job
+ * ref is plain serializable data, so it can be persisted and collected from a
+ * later process where the provider's job is server-backed.
+ */
+type DeepResearchServiceShape<Req> = {
+  readonly submit: (request: Req) => Effect.Effect<ResearchJobRef, AiError>;
+  readonly status: (ref: ResearchJobRef) => Effect.Effect<ResearchState, AiError>;
+  readonly collect: (ref: ResearchJobRef) => Effect.Effect<Turn, AiError>;
+  readonly streamFrom: (ref: ResearchJobRef) => Stream.Stream<TurnEvent, AiError>;
+  readonly cancel: (ref: ResearchJobRef) => Effect.Effect<void, AiError>;
+  readonly research: (request: Req) => Effect.Effect<Turn, AiError>;
+  readonly researchStream: (request: Req) => Stream.Stream<TurnEvent, AiError>;
+};
+type DeepResearchService = DeepResearchServiceShape<ResearchRequest>;
+declare const DeepResearch_base: Context.ServiceClass<DeepResearch, "@betalyra/effect-uai/DeepResearch", DeepResearchService>;
+declare class DeepResearch extends DeepResearch_base {}
+/** The wire ops a provider supplies. `streamFrom` is optional: poll-only jobs
+ *  get a synthesized stream ({@link synthesizedStream}) in its place. */
+type ResearchJobOps<Req> = {
+  readonly submit: (request: Req) => Effect.Effect<ResearchJobRef, AiError>;
+  readonly poll: (ref: ResearchJobRef) => Effect.Effect<ResearchState, AiError>;
+  readonly cancel: (ref: ResearchJobRef) => Effect.Effect<void, AiError>;
+  readonly streamFrom?: (ref: ResearchJobRef) => Stream.Stream<TurnEvent, AiError>;
+};
+/**
+ * Assemble a {@link DeepResearchServiceShape} from the job ops. `research` is
+ * `submit` then poll-to-settle (best-effort cancel on interrupt, via
+ * {@link Job.run}); `collect` / `status` are the detached equivalents;
+ * `researchStream` submits then attaches. Generic over the request type so a
+ * provider-typed tag keeps its narrowed `submit`. `config` tunes the poll
+ * cadence and overall timeout of every derived poll loop (see
+ * {@link Job.JobConfig} for the defaults).
+ */
+declare const fromJob: <Req extends ResearchRequest>(ops: ResearchJobOps<Req>, config?: JobConfig) => DeepResearchServiceShape<Req>;
+/** Submit and poll to the terminal `Turn`. Cancels the job on interrupt. */
+declare const research: (request: ResearchRequest) => Effect.Effect<Turn, AiError, DeepResearch>;
+/** Submit and forward live progress, terminating in `TurnComplete`. */
+declare const researchStream: (request: ResearchRequest) => Stream.Stream<TurnEvent, AiError, DeepResearch>;
+/** Submit a detached job and return its ref. */
+declare const submit: (request: ResearchRequest) => Effect.Effect<ResearchJobRef, AiError, DeepResearch>;
+/** Current state of a job. */
+declare const status: (ref: ResearchJobRef) => Effect.Effect<ResearchState, AiError, DeepResearch>;
+/** Poll a detached job to completion. */
+declare const collect: (ref: ResearchJobRef) => Effect.Effect<Turn, AiError, DeepResearch>;
+/** Attach a live progress stream to a job (call again to re-attach). */
+declare const streamFrom: (ref: ResearchJobRef) => Stream.Stream<TurnEvent, AiError, DeepResearch>;
+/** Cancel a running job. */
+declare const cancel: (ref: ResearchJobRef) => Effect.Effect<void, AiError, DeepResearch>;
+//#endregion
+export { DeepResearch, DeepResearchService, DeepResearchServiceShape, ResearchJobOps, type ResearchJobRef, type ResearchRequest, type ResearchState, cancel, collect, fromJob, research, researchStream, status, streamFrom, submit, DeepResearch_d_exports as t };
+//# sourceMappingURL=DeepResearch.d.mts.map

package/dist/research/DeepResearch.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DeepResearch.d.mts","names":[],"sources":["../../src/research/DeepResearch.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;KAuBY,wBAAA;EAAA,SACD,MAAA,GAAS,OAAA,EAAS,GAAA,KAAQ,MAAA,CAAO,MAAA,CAAO,cAAA,EAAgB,OAAA;EAAA,SACxD,MAAA,GAAS,GAAA,EAAK,cAAA,KAAmB,MAAA,CAAO,MAAA,CAAO,aAAA,EAAe,OAAA;EAAA,SAC9D,OAAA,GAAU,GAAA,EAAK,cAAA,KAAmB,MAAA,CAAO,MAAA,CAAO,IAAA,EAAM,OAAA;EAAA,SACtD,UAAA,GAAa,GAAA,EAAK,cAAA,KAAmB,MAAA,CAAO,MAAA,CAAO,SAAA,EAAW,OAAA;EAAA,SAC9D,MAAA,GAAS,GAAA,EAAK,cAAA,KAAmB,MAAA,CAAO,MAAA,OAAa,OAAA;EAAA,SACrD,QAAA,GAAW,OAAA,EAAS,GAAA,KAAQ,MAAA,CAAO,MAAA,CAAO,IAAA,EAAM,OAAA;EAAA,SAChD,cAAA,GAAiB,OAAA,EAAS,GAAA,KAAQ,MAAA,CAAO,MAAA,CAAO,SAAA,EAAW,OAAA;AAAA;AAAA,KAG1D,mBAAA,GAAsB,wBAAA,CAAyB,eAAA;AAAA,cAAgB,iBAAA;cAE9D,YAAA,SAAqB,iBAAA;;;KAWtB,cAAA;EAAA,SACD,MAAA,GAAS,OAAA,EAAS,GAAA,KAAQ,MAAA,CAAO,MAAA,CAAO,cAAA,EAAgB,OAAA;EAAA,SACxD,IAAA,GAAO,GAAA,EAAK,cAAA,KAAmB,MAAA,CAAO,MAAA,CAAO,aAAA,EAAe,OAAA;EAAA,SAC5D,MAAA,GAAS,GAAA,EAAK,cAAA,KAAmB,MAAA,CAAO,MAAA,OAAa,OAAA;EAAA,SACrD,UAAA,IAAc,GAAA,EAAK,cAAA,KAAmB,MAAA,CAAO,MAAA,CAAO,SAAA,EAAW,OAAA;AAAA;;;;;;;;;;cA2B7D,OAAA,eAAuB,eAAA,EAClC,GAAA,EAAK,cAAA,CAAe,GAAA,GACpB,MAAA,GAAS,SAAA,KACR,wBAAA,CAAyB,GAAA;;cAqBf,QAAA,GACX,OAAA,EAAS,eAAA,KACR,MAAA,CAAO,MAAA,CAAO,IAAA,EAAM,OAAA,EAAiB,YAAA;;cAI3B,cAAA,GACX,OAAA,EAAS,eAAA,KACR,MAAA,CAAO,MAAA,CAAO,SAAA,EAAW,OAAA,EAAiB,YAAA;;cAIhC,MAAA,GACX,OAAA,EAAS,eAAA,KACR,MAAA,CAAO,MAAA,CAAO,cAAA,EAAgB,OAAA,EAAiB,YAAA;;cAIrC,MAAA,GACX,GAAA,EAAK,cAAA,KACJ,MAAA,CAAO,MAAA,CAAO,aAAA,EAAe,OAAA,EAAiB,YAAA;;cAIpC,OAAA,GAAW,GAAA,EAAK,cAAA,KAAiB,MAAA,CAAO,MAAA,CAAO,IAAA,EAAM,OAAA,EAAiB,YAAA;;cAItE,UAAA,GACX,GAAA,EAAK,cAAA,KACJ,MAAA,CAAO,MAAA,CAAO,SAAA,EAAW,OAAA,EAAiB,YAAA;;cAIhC,MAAA,GAAU,GAAA,EAAK,cAAA,KAAiB,MAAA,CAAO,MAAA,OAAa,OAAA,EAAiB,YAAA"}

package/dist/research/DeepResearch.mjs

@@ -0,0 +1,61 @@
+import { n as __exportAll } from "../chunk-uyGKjUfl.mjs";
+import { TurnEvent } from "../domain/Turn.mjs";
+import { collect as collect$1, run } from "../job/Job.mjs";
+import { Context, Effect, Stream } from "effect";
+//#region src/research/DeepResearch.ts
+var DeepResearch_exports = /* @__PURE__ */ __exportAll({
+	DeepResearch: () => DeepResearch,
+	cancel: () => cancel,
+	collect: () => collect,
+	fromJob: () => fromJob,
+	research: () => research,
+	researchStream: () => researchStream,
+	status: () => status,
+	streamFrom: () => streamFrom,
+	submit: () => submit
+});
+var DeepResearch = class extends Context.Service()("@betalyra/effect-uai/DeepResearch") {};
+const synthesizedStream = (ops, ref, config) => Stream.concat(Stream.make(TurnEvent.WebSearchCall({ status: "searching" })), Stream.map(Stream.fromEffect(collect$1(ops.poll, ref, config)), (turn) => TurnEvent.TurnComplete({ turn })));
+/**
+* Assemble a {@link DeepResearchServiceShape} from the job ops. `research` is
+* `submit` then poll-to-settle (best-effort cancel on interrupt, via
+* {@link Job.run}); `collect` / `status` are the detached equivalents;
+* `researchStream` submits then attaches. Generic over the request type so a
+* provider-typed tag keeps its narrowed `submit`. `config` tunes the poll
+* cadence and overall timeout of every derived poll loop (see
+* {@link Job.JobConfig} for the defaults).
+*/
+const fromJob = (ops, config) => {
+	const streamFrom = ops.streamFrom ?? ((ref) => synthesizedStream(ops, ref, config));
+	return {
+		submit: ops.submit,
+		status: ops.poll,
+		collect: (ref) => collect$1(ops.poll, ref, config),
+		cancel: ops.cancel,
+		streamFrom,
+		research: (request) => run({
+			submit: ops.submit(request),
+			poll: ops.poll,
+			cancel: ops.cancel
+		}, config),
+		researchStream: (request) => Stream.unwrap(Effect.map(ops.submit(request), streamFrom))
+	};
+};
+/** Submit and poll to the terminal `Turn`. Cancels the job on interrupt. */
+const research = (request) => Effect.flatMap(DeepResearch, (s) => s.research(request));
+/** Submit and forward live progress, terminating in `TurnComplete`. */
+const researchStream = (request) => Stream.unwrap(Effect.map(DeepResearch, (s) => s.researchStream(request)));
+/** Submit a detached job and return its ref. */
+const submit = (request) => Effect.flatMap(DeepResearch, (s) => s.submit(request));
+/** Current state of a job. */
+const status = (ref) => Effect.flatMap(DeepResearch, (s) => s.status(ref));
+/** Poll a detached job to completion. */
+const collect = (ref) => Effect.flatMap(DeepResearch, (s) => s.collect(ref));
+/** Attach a live progress stream to a job (call again to re-attach). */
+const streamFrom = (ref) => Stream.unwrap(Effect.map(DeepResearch, (s) => s.streamFrom(ref)));
+/** Cancel a running job. */
+const cancel = (ref) => Effect.flatMap(DeepResearch, (s) => s.cancel(ref));
+//#endregion
+export { DeepResearch, cancel, collect, fromJob, research, researchStream, status, streamFrom, submit, DeepResearch_exports as t };
+
+//# sourceMappingURL=DeepResearch.mjs.map

package/dist/research/DeepResearch.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"DeepResearch.mjs","names":["Job.collect","Job.run"],"sources":["../../src/research/DeepResearch.ts"],"sourcesContent":["import { Context, Effect, Stream } from \"effect\"\nimport * as AiError from \"../domain/AiError.js\"\nimport * as Job from \"../job/Job.js\"\nimport type { ResearchJobRef, ResearchRequest, ResearchState } from \"../domain/Research.js\"\nimport type { Turn } from \"../domain/Turn.js\"\nimport { TurnEvent } from \"../domain/Turn.js\"\n\nexport type { ResearchJobRef, ResearchRequest, ResearchState } from \"../domain/Research.js\"\n\n/**\n * Deep research: submit a question, watch a long-running background job, collect\n * one cited report. Every provider is modeled as a job (`submit` / `poll` /\n * `cancel`), so the surface is uniform. The convenience derivations\n * (`research` / `researchStream` / `collect` / `status`) are the same for every\n * provider and are built once by {@link fromJob}, so an implementor states only\n * its wire calls, never the poll loop.\n *\n * `research` is the blocking one-liner (submit then poll to the terminal `Turn`);\n * `researchStream` forwards live progress as `TurnEvent`s, terminating in\n * `TurnComplete` whose `turn` is the value `research` / `collect` return. The job\n * ref is plain serializable data, so it can be persisted and collected from a\n * later process where the provider's job is server-backed.\n */\nexport type DeepResearchServiceShape<Req> = {\n  readonly submit: (request: Req) => Effect.Effect<ResearchJobRef, AiError.AiError>\n  readonly status: (ref: ResearchJobRef) => Effect.Effect<ResearchState, AiError.AiError>\n  readonly collect: (ref: ResearchJobRef) => Effect.Effect<Turn, AiError.AiError>\n  readonly streamFrom: (ref: ResearchJobRef) => Stream.Stream<TurnEvent, AiError.AiError>\n  readonly cancel: (ref: ResearchJobRef) => Effect.Effect<void, AiError.AiError>\n  readonly research: (request: Req) => Effect.Effect<Turn, AiError.AiError>\n  readonly researchStream: (request: Req) => Stream.Stream<TurnEvent, AiError.AiError>\n}\n\nexport type DeepResearchService = DeepResearchServiceShape<ResearchRequest>\n\nexport class DeepResearch extends Context.Service<DeepResearch, DeepResearchService>()(\n  \"@betalyra/effect-uai/DeepResearch\",\n) {}\n\n// ---------------------------------------------------------------------------\n// fromJob: build the whole service from the three job ops (+ an optional real\n// live stream). The derivations are identical for every provider.\n// ---------------------------------------------------------------------------\n\n/** The wire ops a provider supplies. `streamFrom` is optional: poll-only jobs\n *  get a synthesized stream ({@link synthesizedStream}) in its place. */\nexport type ResearchJobOps<Req> = {\n  readonly submit: (request: Req) => Effect.Effect<ResearchJobRef, AiError.AiError>\n  readonly poll: (ref: ResearchJobRef) => Effect.Effect<ResearchState, AiError.AiError>\n  readonly cancel: (ref: ResearchJobRef) => Effect.Effect<void, AiError.AiError>\n  readonly streamFrom?: (ref: ResearchJobRef) => Stream.Stream<TurnEvent, AiError.AiError>\n}\n\n// A poll-only job has no event stream, so synthesize one: a leading \"searching\"\n// progress event, then the terminal `TurnComplete` off the poll loop. Honest\n// low-fidelity progress, not a fabricated per-search feed.\nconst synthesizedStream = <Req>(\n  ops: ResearchJobOps<Req>,\n  ref: ResearchJobRef,\n  config?: Job.JobConfig,\n): Stream.Stream<TurnEvent, AiError.AiError> =>\n  Stream.concat(\n    Stream.make(TurnEvent.WebSearchCall({ status: \"searching\" })),\n    Stream.map(Stream.fromEffect(Job.collect(ops.poll, ref, config)), (turn) =>\n      TurnEvent.TurnComplete({ turn }),\n    ),\n  )\n\n/**\n * Assemble a {@link DeepResearchServiceShape} from the job ops. `research` is\n * `submit` then poll-to-settle (best-effort cancel on interrupt, via\n * {@link Job.run}); `collect` / `status` are the detached equivalents;\n * `researchStream` submits then attaches. Generic over the request type so a\n * provider-typed tag keeps its narrowed `submit`. `config` tunes the poll\n * cadence and overall timeout of every derived poll loop (see\n * {@link Job.JobConfig} for the defaults).\n */\nexport const fromJob = <Req extends ResearchRequest>(\n  ops: ResearchJobOps<Req>,\n  config?: Job.JobConfig,\n): DeepResearchServiceShape<Req> => {\n  const streamFrom =\n    ops.streamFrom ?? ((ref: ResearchJobRef) => synthesizedStream(ops, ref, config))\n  return {\n    submit: ops.submit,\n    status: ops.poll,\n    collect: (ref) => Job.collect(ops.poll, ref, config),\n    cancel: ops.cancel,\n    streamFrom,\n    research: (request) =>\n      Job.run({ submit: ops.submit(request), poll: ops.poll, cancel: ops.cancel }, config),\n    researchStream: (request) => Stream.unwrap(Effect.map(ops.submit(request), streamFrom)),\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Top-level accessors over the generic tag. Portable code uses these; they\n// require only `DeepResearch` in `R`.\n// ---------------------------------------------------------------------------\n\n/** Submit and poll to the terminal `Turn`. Cancels the job on interrupt. */\nexport const research = (\n  request: ResearchRequest,\n): Effect.Effect<Turn, AiError.AiError, DeepResearch> =>\n  Effect.flatMap(DeepResearch, (s) => s.research(request))\n\n/** Submit and forward live progress, terminating in `TurnComplete`. */\nexport const researchStream = (\n  request: ResearchRequest,\n): Stream.Stream<TurnEvent, AiError.AiError, DeepResearch> =>\n  Stream.unwrap(Effect.map(DeepResearch, (s) => s.researchStream(request)))\n\n/** Submit a detached job and return its ref. */\nexport const submit = (\n  request: ResearchRequest,\n): Effect.Effect<ResearchJobRef, AiError.AiError, DeepResearch> =>\n  Effect.flatMap(DeepResearch, (s) => s.submit(request))\n\n/** Current state of a job. */\nexport const status = (\n  ref: ResearchJobRef,\n): Effect.Effect<ResearchState, AiError.AiError, DeepResearch> =>\n  Effect.flatMap(DeepResearch, (s) => s.status(ref))\n\n/** Poll a detached job to completion. */\nexport const collect = (ref: ResearchJobRef): Effect.Effect<Turn, AiError.AiError, DeepResearch> =>\n  Effect.flatMap(DeepResearch, (s) => s.collect(ref))\n\n/** Attach a live progress stream to a job (call again to re-attach). */\nexport const streamFrom = (\n  ref: ResearchJobRef,\n): Stream.Stream<TurnEvent, AiError.AiError, DeepResearch> =>\n  Stream.unwrap(Effect.map(DeepResearch, (s) => s.streamFrom(ref)))\n\n/** Cancel a running job. */\nexport const cancel = (ref: ResearchJobRef): Effect.Effect<void, AiError.AiError, DeepResearch> =>\n  Effect.flatMap(DeepResearch, (s) => s.cancel(ref))\n"],"mappings":";;;;;;;;;;;;;;;;AAmCA,IAAa,eAAb,cAAkC,QAAQ,SAA4C,CACpF,oCACD,CAAC;AAmBF,MAAM,qBACJ,KACA,KACA,WAEA,OAAO,OACL,OAAO,KAAK,UAAU,cAAc,EAAE,QAAQ,aAAa,CAAC,CAAC,EAC7D,OAAO,IAAI,OAAO,WAAWA,UAAY,IAAI,MAAM,KAAK,OAAO,CAAC,GAAG,SACjE,UAAU,aAAa,EAAE,MAAM,CAAC,CACjC,CACF;;;;;;;;;;AAWH,MAAa,WACX,KACA,WACkC;CAClC,MAAM,aACJ,IAAI,gBAAgB,QAAwB,kBAAkB,KAAK,KAAK,OAAO;AACjF,QAAO;EACL,QAAQ,IAAI;EACZ,QAAQ,IAAI;EACZ,UAAU,QAAQA,UAAY,IAAI,MAAM,KAAK,OAAO;EACpD,QAAQ,IAAI;EACZ;EACA,WAAW,YACTC,IAAQ;GAAE,QAAQ,IAAI,OAAO,QAAQ;GAAE,MAAM,IAAI;GAAM,QAAQ,IAAI;GAAQ,EAAE,OAAO;EACtF,iBAAiB,YAAY,OAAO,OAAO,OAAO,IAAI,IAAI,OAAO,QAAQ,EAAE,WAAW,CAAC;EACxF;;;AASH,MAAa,YACX,YAEA,OAAO,QAAQ,eAAe,MAAM,EAAE,SAAS,QAAQ,CAAC;;AAG1D,MAAa,kBACX,YAEA,OAAO,OAAO,OAAO,IAAI,eAAe,MAAM,EAAE,eAAe,QAAQ,CAAC,CAAC;;AAG3E,MAAa,UACX,YAEA,OAAO,QAAQ,eAAe,MAAM,EAAE,OAAO,QAAQ,CAAC;;AAGxD,MAAa,UACX,QAEA,OAAO,QAAQ,eAAe,MAAM,EAAE,OAAO,IAAI,CAAC;;AAGpD,MAAa,WAAW,QACtB,OAAO,QAAQ,eAAe,MAAM,EAAE,QAAQ,IAAI,CAAC;;AAGrD,MAAa,cACX,QAEA,OAAO,OAAO,OAAO,IAAI,eAAe,MAAM,EAAE,WAAW,IAAI,CAAC,CAAC;;AAGnE,MAAa,UAAU,QACrB,OAAO,QAAQ,eAAe,MAAM,EAAE,OAAO,IAAI,CAAC"}

package/dist/retry/Retry.test.mjs

@@ -1,6 +1,6 @@
 import { ContentFiltered, RateLimited, Timeout, Unavailable } from "../domain/AiError.mjs";
 import { effect, stream } from "./Retry.mjs";
-import { a as describe, n as globalExpect, o as it } from "../dist-B04dlFHg.mjs";
+import { c as it, n as globalExpect, o as describe } from "../dist-CcRV3-A5.mjs";
 import { Cause, Effect, Exit, Option, Ref, Schedule, Stream } from "effect";
 //#region src/retry/Retry.test.ts
 const planned = (attempts, plan) => Stream.unwrap(Ref.getAndUpdate(attempts, (n) => n + 1).pipe(Effect.map((n) => plan[Math.min(n, plan.length - 1)])));