@effect-uai/core 0.12.0 → 0.12.1

package/dist/web-read/WebRead.d.mts

@@ -1,7 +1,5 @@
-import { t as AiError } from "../AiError-Bf1pq4BB.mjs";
+import { t as AiError } from "../AiError-eLV9t1lU.mjs";
 import { Context, Duration, Effect } from "effect";
-
-//#region src/web-read/WebRead.d.ts
 declare namespace WebRead_d_exports {
   export { CommonReadRequest, ReadFormat, ReadResponse, WebRead, WebReadService, read };
 }
@@ -12,16 +10,24 @@ type ReadFormat = "markdown" | "html";
  * knobs live on the provider-typed request.
  */
 type CommonReadRequest = {
-  /** The page to read. */readonly url: string; /** Output representation. Defaults to `markdown`. See {@link ReadFormat}. */
-  readonly format?: ReadFormat; /** Upper bound on time spent fetching the page. */
+  /** The page to read. */
+  readonly url: string;
+  /** Output representation. Defaults to `markdown`. See {@link ReadFormat}. */
+  readonly format?: ReadFormat;
+  /** Upper bound on time spent fetching the page. */
   readonly timeout?: Duration.Duration;
 };
 /** One normalized read result. */
 type ReadResponse = {
-  /** The URL that was read. */readonly url: string; /** Extracted content in the requested {@link ReadFormat}. */
-  readonly content: string; /** Page title, when reported. */
-  readonly title?: string; /** Links discovered on the page, when returned. */
-  readonly links?: ReadonlyArray<string>; /** The provider-native response. */
+  /** The URL that was read. */
+  readonly url: string;
+  /** Extracted content in the requested {@link ReadFormat}. */
+  readonly content: string;
+  /** Page title, when reported. */
+  readonly title?: string;
+  /** Links discovered on the page, when returned. */
+  readonly links?: ReadonlyArray<string>;
+  /** The provider-native response. */
   readonly raw: unknown;
 };
 /**

package/dist/web-read/WebRead.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"WebRead.d.mts","names":[],"sources":["../../src/web-read/WebRead.ts"],"mappings":";;;;;;;;KAQY,UAAA;;;;;KAUA,iBAAA;mCAED,GAAA;WAEA,MAAA,GAAS,UAAA,EAdR;EAAA,SAgBD,OAAA,GAAU,QAAA,CAAS,QAAA;AAAA;;KAQlB,YAAA;EAdA,sCAgBD,GAAA;WAEA,OAAA,UAhBA;EAAA,SAkBA,KAAA,WAhBS;EAAA,SAkBT,KAAA,GAAQ,aAAA,UAhBE;EAAA,SAkBV,GAAA;AAAA;;AAVX;;;KAqBY,cAAA;EAAA,SACD,IAAA,GAAO,OAAA,EAAS,iBAAA,KAAsB,MAAA,CAAO,MAAA,CAAO,YAAA,EAAc,OAAA;AAAA;AAAA,cAC5E,YAAA;;;;;cAMY,OAAA,SAAgB,YAAA;;cAKhB,IAAA,GACX,OAAA,EAAS,iBAAA,KACR,MAAA,CAAO,MAAA,CAAO,YAAA,EAAc,OAAA,EAAiB,OAAA"}
+{"version":3,"file":"WebRead.d.mts","names":[],"sources":["../../src/web-read/WebRead.ts"],"mappings":";;;;;;KAQY;;;;;KAUA;;WAED;;WAEA,SAAS;;WAET,UAAU,SAAS;;;KAQlB;;WAED;;WAEA;;WAEA;;WAEA,QAAQ;;WAER;;;;;;KAWC;WACD,OAAO,SAAS,sBAAsB,OAAO,OAAO,cAAc;;;;;;;cAOhE,gBAAgB;;cAKhB,OAAI,SACN,sBACR,OAAO,OAAO,cAAc,SAAiB"}

package/dist/web-read/WebRead.mjs

@@ -1,4 +1,4 @@
-import { n as __exportAll } from "../chunk-uyGKjUfl.mjs";
+import { n as __exportAll } from "../rolldown-runtime-EAsCxrDo.mjs";
 import { Context, Effect } from "effect";
 //#region src/web-read/WebRead.ts
 var WebRead_exports = /* @__PURE__ */ __exportAll({

package/dist/web-read/WebRead.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"WebRead.mjs","names":[],"sources":["../../src/web-read/WebRead.ts"],"sourcesContent":["import { Context, type Duration, Effect } from \"effect\"\nimport type * as AiError from \"../domain/AiError.js\"\n\n// ---------------------------------------------------------------------------\n// Format\n// ---------------------------------------------------------------------------\n\n/** Representation to return for a page. `markdown` is the default. */\nexport type ReadFormat = \"markdown\" | \"html\"\n\n// ---------------------------------------------------------------------------\n// Request\n// ---------------------------------------------------------------------------\n\n/**\n * Cross-provider read request: one URL in, clean content out. Provider-specific\n * knobs live on the provider-typed request.\n */\nexport type CommonReadRequest = {\n  /** The page to read. */\n  readonly url: string\n  /** Output representation. Defaults to `markdown`. See {@link ReadFormat}. */\n  readonly format?: ReadFormat\n  /** Upper bound on time spent fetching the page. */\n  readonly timeout?: Duration.Duration\n}\n\n// ---------------------------------------------------------------------------\n// Response\n// ---------------------------------------------------------------------------\n\n/** One normalized read result. */\nexport type ReadResponse = {\n  /** The URL that was read. */\n  readonly url: string\n  /** Extracted content in the requested {@link ReadFormat}. */\n  readonly content: string\n  /** Page title, when reported. */\n  readonly title?: string\n  /** Links discovered on the page, when returned. */\n  readonly links?: ReadonlyArray<string>\n  /** The provider-native response. */\n  readonly raw: unknown\n}\n\n// ---------------------------------------------------------------------------\n// Service + helper\n// ---------------------------------------------------------------------------\n\n/**\n * The portable read surface: one operation, `read`. Every implementor can\n * answer, so this capability needs no marker tags.\n */\nexport type WebReadService = {\n  readonly read: (request: CommonReadRequest) => Effect.Effect<ReadResponse, AiError.AiError>\n}\n\n/**\n * Generic read service tag. Yield this for provider-portable code; yield a\n * provider tag for provider-specific knobs. A provider `layer` registers both.\n */\nexport class WebRead extends Context.Service<WebRead, WebReadService>()(\n  \"@betalyra/effect-uai/WebRead\",\n) {}\n\n/** Read one URL against whichever provider Layer is in scope. */\nexport const read = (\n  request: CommonReadRequest,\n): Effect.Effect<ReadResponse, AiError.AiError, WebRead> =>\n  Effect.flatMap(WebRead, (s) => s.read(request))\n"],"mappings":";;;;;;;;;;;AA6DA,IAAa,UAAb,cAA6B,QAAQ,SAAkC,CACrE,+BACD,CAAC;;AAGF,MAAa,QACX,YAEA,OAAO,QAAQ,UAAU,MAAM,EAAE,KAAK,QAAQ,CAAC"}
+{"version":3,"file":"WebRead.mjs","names":[],"sources":["../../src/web-read/WebRead.ts"],"sourcesContent":["import { Context, type Duration, Effect } from \"effect\"\nimport type * as AiError from \"../domain/AiError.js\"\n\n// ---------------------------------------------------------------------------\n// Format\n// ---------------------------------------------------------------------------\n\n/** Representation to return for a page. `markdown` is the default. */\nexport type ReadFormat = \"markdown\" | \"html\"\n\n// ---------------------------------------------------------------------------\n// Request\n// ---------------------------------------------------------------------------\n\n/**\n * Cross-provider read request: one URL in, clean content out. Provider-specific\n * knobs live on the provider-typed request.\n */\nexport type CommonReadRequest = {\n  /** The page to read. */\n  readonly url: string\n  /** Output representation. Defaults to `markdown`. See {@link ReadFormat}. */\n  readonly format?: ReadFormat\n  /** Upper bound on time spent fetching the page. */\n  readonly timeout?: Duration.Duration\n}\n\n// ---------------------------------------------------------------------------\n// Response\n// ---------------------------------------------------------------------------\n\n/** One normalized read result. */\nexport type ReadResponse = {\n  /** The URL that was read. */\n  readonly url: string\n  /** Extracted content in the requested {@link ReadFormat}. */\n  readonly content: string\n  /** Page title, when reported. */\n  readonly title?: string\n  /** Links discovered on the page, when returned. */\n  readonly links?: ReadonlyArray<string>\n  /** The provider-native response. */\n  readonly raw: unknown\n}\n\n// ---------------------------------------------------------------------------\n// Service + helper\n// ---------------------------------------------------------------------------\n\n/**\n * The portable read surface: one operation, `read`. Every implementor can\n * answer, so this capability needs no marker tags.\n */\nexport type WebReadService = {\n  readonly read: (request: CommonReadRequest) => Effect.Effect<ReadResponse, AiError.AiError>\n}\n\n/**\n * Generic read service tag. Yield this for provider-portable code; yield a\n * provider tag for provider-specific knobs. A provider `layer` registers both.\n */\nexport class WebRead extends Context.Service<WebRead, WebReadService>()(\n  \"@betalyra/effect-uai/WebRead\",\n) {}\n\n/** Read one URL against whichever provider Layer is in scope. */\nexport const read = (\n  request: CommonReadRequest,\n): Effect.Effect<ReadResponse, AiError.AiError, WebRead> =>\n  Effect.flatMap(WebRead, (s) => s.read(request))\n"],"mappings":";;;;;;;;;;;AA6DA,IAAa,UAAb,cAA6B,QAAQ,QAAiC,CAAC,CACrE,8BACF,CAAC,CAAC,CAAC;;AAGH,MAAa,QACX,YAEA,OAAO,QAAQ,UAAU,MAAM,EAAE,KAAK,OAAO,CAAC"}

package/dist/web-read/WebReadTool.d.mts

@@ -1,9 +1,7 @@
-import { l as Tool } from "../Tool-u5bag8SO.mjs";
-import { t as AiError } from "../AiError-Bf1pq4BB.mjs";
+import { l as Tool } from "../Tool-DE-rnvkw.mjs";
+import { t as AiError } from "../AiError-eLV9t1lU.mjs";
 import { ReadFormat, ReadResponse, WebRead } from "./WebRead.mjs";
 import { Schema } from "effect";
-
-//#region src/web-read/WebReadTool.d.ts
 declare namespace WebReadTool_d_exports {
   export { WebReadToolArgs, WebReadToolOptions, webReadTool };
 }
@@ -18,7 +16,8 @@ declare const WebReadToolArgs: Schema.Struct<{
 }>;
 type WebReadToolArgs = typeof WebReadToolArgs.Type;
 type WebReadToolOptions = {
-  /** Tool name the model sees. Default `"web_read"`. */readonly name?: string;
+  /** Tool name the model sees. Default `"web_read"`. */
+  readonly name?: string;
   /**
    * App-fixed representation for every read - a policy choice, not a model
    * knob. Default `"markdown"` (what models read best).

package/dist/web-read/WebReadTool.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"WebReadTool.d.mts","names":[],"sources":["../../src/web-read/WebReadTool.ts"],"mappings":";;;;;;;;;;;;;;;cAWM,eAAA,EAAe,MAAA,CAAA,MAAA;EAAA,cAInB,MAAA,CAAA,MAAA;AAAA;AAAA,KAEU,eAAA,UAAyB,eAAA,CAAgB,IAAA;AAAA,KAYzC,kBAAA;EAlBS,+DAoBV,IAAA;EApBU;;;;EAAA,SAyBV,MAAA,GAAS,UAAA;;AAnBpB;;;WAwBW,QAAA;EAxB8C;AAYzD;;;EAZyD,SA6B9C,MAAA,IAAU,QAAA,EAAU,YAAA;AAAA;;;;;;;;;AAmB/B;;;;;;;;cAAa,WAAA,GACX,OAAA,GAAU,kBAAA,KACT,IAAA,SAAkB,eAAA,iBAAgC,OAAA,EAAiB,OAAA"}
+{"version":3,"file":"WebReadTool.d.mts","names":[],"sources":["../../src/web-read/WebReadTool.ts"],"mappings":";;;;;;;;;;;;;cAWM,iBAAe,OAAA;gBAAf,OAAA;;KAMM,yBAAyB,gBAAgB;KAYzC;;WAED;;;;;WAKA,SAAS;;;;;WAKT;;;;;WAKA,UAAU,UAAU;;;;;;;;;;;;;;;;;;cAmBlB,cAAW,UACZ,uBACT,aAAkB,gCAAgC,SAAiB"}

package/dist/web-read/WebReadTool.mjs

@@ -1,4 +1,4 @@
-import { n as __exportAll } from "../chunk-uyGKjUfl.mjs";
+import { n as __exportAll } from "../rolldown-runtime-EAsCxrDo.mjs";
 import { fromEffectSchema, make } from "../tool/Tool.mjs";
 import { read } from "./WebRead.mjs";
 import { Effect, Schema } from "effect";

package/dist/web-read/WebReadTool.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"WebReadTool.mjs","names":["Tool.make","Tool.fromEffectSchema"],"sources":["../../src/web-read/WebReadTool.ts"],"sourcesContent":["import { Effect, Schema } from \"effect\"\nimport type * as AiError from \"../domain/AiError.js\"\nimport * as Tool from \"../tool/Tool.js\"\nimport { read, type ReadFormat, type ReadResponse, WebRead } from \"./WebRead.js\"\n\n/**\n * Model-facing argument schema. Deliberately narrow: the URL is the only\n * thing that is genuinely the model's call. Output format and the content\n * cost ceiling are app policy, pinned on the constructor instead, so they\n * are guaranteed rather than left to the model to remember each call.\n */\nconst WebReadToolArgs = Schema.Struct({\n  url: Schema.String.annotate({\n    description: \"Absolute URL of the page to read.\",\n  }),\n})\n\nexport type WebReadToolArgs = typeof WebReadToolArgs.Type\n\n/** `title / url` header plus the extracted content - what a model reads best. */\nconst defaultRender = (response: ReadResponse, maxChars: number): string => {\n  const header = response.title === undefined ? response.url : `${response.title}\\n${response.url}`\n  const body =\n    response.content.length > maxChars\n      ? `${response.content.slice(0, maxChars)}\\n[content truncated at ${maxChars} characters]`\n      : response.content\n  return `${header}\\n\\n${body}`\n}\n\nexport type WebReadToolOptions = {\n  /** Tool name the model sees. Default `\"web_read\"`. */\n  readonly name?: string\n  /**\n   * App-fixed representation for every read - a policy choice, not a model\n   * knob. Default `\"markdown\"` (what models read best).\n   */\n  readonly format?: ReadFormat\n  /**\n   * App-fixed ceiling on rendered content characters per call - a context\n   * cost guard, not exposed to the model. Default `20000`.\n   */\n  readonly maxChars?: number\n  /**\n   * Override how a read response is rendered into the model-facing string.\n   * Default: `title / url` header plus the content, truncated at `maxChars`.\n   */\n  readonly render?: (response: ReadResponse) => string\n}\n\n/**\n * The canonical web-read tool. Its `R` is just `WebRead`, so providing any\n * read-provider Layer satisfies it and the model-facing contract (name,\n * description, schema) is identical no matter which backend answers - swap\n * `FirecrawlRead.layer` for `JinaRead.layer` and the tool the model sees\n * does not change. Drops straight into a `Toolkit` next to `webSearchTool`\n * (search finds the URLs, read fetches the ones worth reading in full).\n *\n * `Output` is the rendered page; failures stay typed on the `AiError`\n * channel. To let the model recover from a failed read, wrap the toolkit in\n * `Toolkit.describeFailures(AiError.describe)`.\n *\n * This is a simple default implementation for quick use. For more elaborate\n * cases (a different output contract, more model-facing knobs), build your\n * own tool with `Tool.make` over the same `read` helper.\n */\nexport const webReadTool = (\n  options?: WebReadToolOptions,\n): Tool.Tool<string, WebReadToolArgs, never, string, AiError.AiError, WebRead> => {\n  const name = options?.name ?? \"web_read\"\n  const format = options?.format ?? \"markdown\"\n  const maxChars = options?.maxChars ?? 20_000\n  const render = options?.render ?? ((response: ReadResponse) => defaultRender(response, maxChars))\n  return Tool.make({\n    name,\n    description:\n      \"Read a web page and return its content as clean text. Use it to read a promising URL in full (e.g. one found via search).\",\n    inputSchema: Tool.fromEffectSchema(WebReadToolArgs),\n    // The call is wrapped in a tracing span so agent traces show the tool\n    // invocation (url, format, content length) nested under the model turn.\n    // `withSpan` is a no-op until a Tracer is installed, so this is free by\n    // default and adds nothing to the requirements.\n    run: (args) =>\n      read({ url: args.url, format }).pipe(\n        Effect.tap((r) => Effect.annotateCurrentSpan(\"web_read.content_chars\", r.content.length)),\n        Effect.map(render),\n        Effect.withSpan(name, {\n          kind: \"client\",\n          attributes: {\n            \"web_read.url\": args.url,\n            \"web_read.format\": format,\n            \"web_read.max_chars\": maxChars,\n          },\n        }),\n      ),\n  })\n}\n"],"mappings":";;;;;;;;;;;;AAWA,MAAM,kBAAkB,OAAO,OAAO,EACpC,KAAK,OAAO,OAAO,SAAS,EAC1B,aAAa,qCACd,CAAC,EACH,CAAC;;AAKF,MAAM,iBAAiB,UAAwB,aAA6B;AAM1E,QAAO,GALQ,SAAS,UAAU,KAAA,IAAY,SAAS,MAAM,GAAG,SAAS,MAAM,IAAI,SAAS,MAK3E,MAHf,SAAS,QAAQ,SAAS,WACtB,GAAG,SAAS,QAAQ,MAAM,GAAG,SAAS,CAAC,0BAA0B,SAAS,gBAC1E,SAAS;;;;;;;;;;;;;;;;;;AAwCjB,MAAa,eACX,YACgF;CAChF,MAAM,OAAO,SAAS,QAAQ;CAC9B,MAAM,SAAS,SAAS,UAAU;CAClC,MAAM,WAAW,SAAS,YAAY;CACtC,MAAM,SAAS,SAAS,YAAY,aAA2B,cAAc,UAAU,SAAS;AAChG,QAAOA,KAAU;EACf;EACA,aACE;EACF,aAAaC,iBAAsB,gBAAgB;EAKnD,MAAM,SACJ,KAAK;GAAE,KAAK,KAAK;GAAK;GAAQ,CAAC,CAAC,KAC9B,OAAO,KAAK,MAAM,OAAO,oBAAoB,0BAA0B,EAAE,QAAQ,OAAO,CAAC,EACzF,OAAO,IAAI,OAAO,EAClB,OAAO,SAAS,MAAM;GACpB,MAAM;GACN,YAAY;IACV,gBAAgB,KAAK;IACrB,mBAAmB;IACnB,sBAAsB;IACvB;GACF,CAAC,CACH;EACJ,CAAC"}
+{"version":3,"file":"WebReadTool.mjs","names":["Tool.make","Tool.fromEffectSchema"],"sources":["../../src/web-read/WebReadTool.ts"],"sourcesContent":["import { Effect, Schema } from \"effect\"\nimport type * as AiError from \"../domain/AiError.js\"\nimport * as Tool from \"../tool/Tool.js\"\nimport { read, type ReadFormat, type ReadResponse, WebRead } from \"./WebRead.js\"\n\n/**\n * Model-facing argument schema. Deliberately narrow: the URL is the only\n * thing that is genuinely the model's call. Output format and the content\n * cost ceiling are app policy, pinned on the constructor instead, so they\n * are guaranteed rather than left to the model to remember each call.\n */\nconst WebReadToolArgs = Schema.Struct({\n  url: Schema.String.annotate({\n    description: \"Absolute URL of the page to read.\",\n  }),\n})\n\nexport type WebReadToolArgs = typeof WebReadToolArgs.Type\n\n/** `title / url` header plus the extracted content - what a model reads best. */\nconst defaultRender = (response: ReadResponse, maxChars: number): string => {\n  const header = response.title === undefined ? response.url : `${response.title}\\n${response.url}`\n  const body =\n    response.content.length > maxChars\n      ? `${response.content.slice(0, maxChars)}\\n[content truncated at ${maxChars} characters]`\n      : response.content\n  return `${header}\\n\\n${body}`\n}\n\nexport type WebReadToolOptions = {\n  /** Tool name the model sees. Default `\"web_read\"`. */\n  readonly name?: string\n  /**\n   * App-fixed representation for every read - a policy choice, not a model\n   * knob. Default `\"markdown\"` (what models read best).\n   */\n  readonly format?: ReadFormat\n  /**\n   * App-fixed ceiling on rendered content characters per call - a context\n   * cost guard, not exposed to the model. Default `20000`.\n   */\n  readonly maxChars?: number\n  /**\n   * Override how a read response is rendered into the model-facing string.\n   * Default: `title / url` header plus the content, truncated at `maxChars`.\n   */\n  readonly render?: (response: ReadResponse) => string\n}\n\n/**\n * The canonical web-read tool. Its `R` is just `WebRead`, so providing any\n * read-provider Layer satisfies it and the model-facing contract (name,\n * description, schema) is identical no matter which backend answers - swap\n * `FirecrawlRead.layer` for `JinaRead.layer` and the tool the model sees\n * does not change. Drops straight into a `Toolkit` next to `webSearchTool`\n * (search finds the URLs, read fetches the ones worth reading in full).\n *\n * `Output` is the rendered page; failures stay typed on the `AiError`\n * channel. To let the model recover from a failed read, wrap the toolkit in\n * `Toolkit.describeFailures(AiError.describe)`.\n *\n * This is a simple default implementation for quick use. For more elaborate\n * cases (a different output contract, more model-facing knobs), build your\n * own tool with `Tool.make` over the same `read` helper.\n */\nexport const webReadTool = (\n  options?: WebReadToolOptions,\n): Tool.Tool<string, WebReadToolArgs, never, string, AiError.AiError, WebRead> => {\n  const name = options?.name ?? \"web_read\"\n  const format = options?.format ?? \"markdown\"\n  const maxChars = options?.maxChars ?? 20_000\n  const render = options?.render ?? ((response: ReadResponse) => defaultRender(response, maxChars))\n  return Tool.make({\n    name,\n    description:\n      \"Read a web page and return its content as clean text. Use it to read a promising URL in full (e.g. one found via search).\",\n    inputSchema: Tool.fromEffectSchema(WebReadToolArgs),\n    // The call is wrapped in a tracing span so agent traces show the tool\n    // invocation (url, format, content length) nested under the model turn.\n    // `withSpan` is a no-op until a Tracer is installed, so this is free by\n    // default and adds nothing to the requirements.\n    run: (args) =>\n      read({ url: args.url, format }).pipe(\n        Effect.tap((r) => Effect.annotateCurrentSpan(\"web_read.content_chars\", r.content.length)),\n        Effect.map(render),\n        Effect.withSpan(name, {\n          kind: \"client\",\n          attributes: {\n            \"web_read.url\": args.url,\n            \"web_read.format\": format,\n            \"web_read.max_chars\": maxChars,\n          },\n        }),\n      ),\n  })\n}\n"],"mappings":";;;;;;;;;;;;AAWA,MAAM,kBAAkB,OAAO,OAAO,EACpC,KAAK,OAAO,OAAO,SAAS,EAC1B,aAAa,oCACf,CAAC,EACH,CAAC;;AAKD,MAAM,iBAAiB,UAAwB,aAA6B;CAM1E,OAAO,GALQ,SAAS,UAAU,KAAA,IAAY,SAAS,MAAM,GAAG,SAAS,MAAM,IAAI,SAAS,MAK3E,MAHf,SAAS,QAAQ,SAAS,WACtB,GAAG,SAAS,QAAQ,MAAM,GAAG,QAAQ,EAAE,0BAA0B,SAAS,gBAC1E,SAAS;AAEjB;;;;;;;;;;;;;;;;;AAsCA,MAAa,eACX,YACgF;CAChF,MAAM,OAAO,SAAS,QAAQ;CAC9B,MAAM,SAAS,SAAS,UAAU;CAClC,MAAM,WAAW,SAAS,YAAY;CACtC,MAAM,SAAS,SAAS,YAAY,aAA2B,cAAc,UAAU,QAAQ;CAC/F,OAAOA,KAAU;EACf;EACA,aACE;EACF,aAAaC,iBAAsB,eAAe;EAKlD,MAAM,SACJ,KAAK;GAAE,KAAK,KAAK;GAAK;EAAO,CAAC,CAAC,CAAC,KAC9B,OAAO,KAAK,MAAM,OAAO,oBAAoB,0BAA0B,EAAE,QAAQ,MAAM,CAAC,GACxF,OAAO,IAAI,MAAM,GACjB,OAAO,SAAS,MAAM;GACpB,MAAM;GACN,YAAY;IACV,gBAAgB,KAAK;IACrB,mBAAmB;IACnB,sBAAsB;GACxB;EACF,CAAC,CACH;CACJ,CAAC;AACH"}

package/dist/web-search/WebSearch.d.mts

@@ -1,7 +1,5 @@
-import { t as AiError } from "../AiError-Bf1pq4BB.mjs";
+import { t as AiError } from "../AiError-eLV9t1lU.mjs";
 import { Context, DateTime, Effect, Schema } from "effect";
-
-//#region src/web-search/WebSearch.d.ts
 declare namespace WebSearch_d_exports {
   export { CommonSearchRequest, SearchRecency, SearchResponse, SearchResult, WebSearch, WebSearchService, search };
 }
@@ -35,7 +33,8 @@ type SearchRecency = typeof SearchRecency.Type;
  * `searchDepth`) is a mode knob, so it stays on the provider-typed request.
  */
 type CommonSearchRequest = {
-  /** The search query. The one field every provider requires. */readonly query: string;
+  /** The search query. The one field every provider requires. */
+  readonly query: string;
   /**
    * Upper bound on the number of results to return in this one call.
    * Providers cap differently (Perplexity / Tavily / Brave at ~20, Exa /
@@ -43,18 +42,24 @@ type CommonSearchRequest = {
    * provider. There is no common pagination - only two providers paginate
    * and only shallowly, so `offset` is provider-typed.
    */
-  readonly maxResults?: number; /** Restrict results to these domains (e.g. `["docs.foo.com"]`). */
-  readonly includeDomains?: ReadonlyArray<string>; /** Drop results from these domains. */
+  readonly maxResults?: number;
+  /** Restrict results to these domains (e.g. `["docs.foo.com"]`). */
+  readonly includeDomains?: ReadonlyArray<string>;
+  /** Drop results from these domains. */
   readonly excludeDomains?: ReadonlyArray<string>;
   /**
    * Coarse freshness filter - see {@link SearchRecency}. Sugar over an
    * explicit `startDate`; ignored where {@link startDate} is also set and
    * the provider takes only one.
    */
-  readonly recency?: SearchRecency; /** Published-after bound. The precise alternative to {@link recency}. */
-  readonly startDate?: DateTime.DateTime; /** Published-before bound. */
-  readonly endDate?: DateTime.DateTime; /** ISO 3166-1 alpha-2 country code to localize results (e.g. `"us"`). */
-  readonly country?: string; /** ISO 639-1 language code to bias results toward (e.g. `"en"`). */
+  readonly recency?: SearchRecency;
+  /** Published-after bound. The precise alternative to {@link recency}. */
+  readonly startDate?: DateTime.DateTime;
+  /** Published-before bound. */
+  readonly endDate?: DateTime.DateTime;
+  /** ISO 3166-1 alpha-2 country code to localize results (e.g. `"us"`). */
+  readonly country?: string;
+  /** ISO 639-1 language code to bias results toward (e.g. `"en"`). */
   readonly language?: string;
 };
 /**
@@ -65,7 +70,9 @@ type CommonSearchRequest = {
  * here (`author`, `favicon`, multi-chunk `snippets[]`, …).
  */
 type SearchResult = {
-  /** Canonical result URL. Always present. */readonly url: string; /** Result title / headline, when the provider returns one. */
+  /** Canonical result URL. Always present. */
+  readonly url: string;
+  /** Result title / headline, when the provider returns one. */
   readonly title?: string;
   /**
    * Primary short excerpt - the one text field all providers return (under
@@ -73,7 +80,8 @@ type SearchResult = {
    * extract fields (`text`, `highlights`, `summary`) belong to the
    * out-of-scope extract feature and stay on the provider-typed result.
    */
-  readonly snippet?: string; /** Publication date, when the provider reports one. */
+  readonly snippet?: string;
+  /** Publication date, when the provider reports one. */
   readonly publishedDate?: DateTime.DateTime;
   /**
    * Relevance score, only from providers that rank (Exa, Tavily);
@@ -81,7 +89,8 @@ type SearchResult = {
    * being non-universal because ranking is core to what a "search result"
    * means - and `undefined` cleanly says "this backend doesn't score."
    */
-  readonly score?: number; /** The provider-native result object, never lossy. */
+  readonly score?: number;
+  /** The provider-native result object, never lossy. */
   readonly raw: unknown;
 };
 type SearchResponse = {

package/dist/web-search/WebSearch.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"WebSearch.d.mts","names":[],"sources":["../../src/web-search/WebSearch.ts"],"mappings":";;;;;;;;;;;;;;;;;;;AAsBA;;;cAAa,aAAA,EAAa,MAAA,CAAA,QAAA;AAAA,KAEd,aAAA,UAAuB,aAAA,CAAc,IAAA;AAAjD;;;;;AAkBA;;;;;;;AAlBA,KAkBY,mBAAA;EAwB0B,wEAtB3B,KAAA;EAAA;;;;;;;EAAA,SAQA,UAAA,WAYA;EAAA,SAVA,cAAA,GAAiB,aAAA,UAUI;EAAA,SARrB,cAAA,GAAiB,aAAA;EAUP;;;;;EAAA,SAJV,OAAA,GAAU,aAAA,EAsBT;EAAA,SApBD,SAAA,GAAY,QAAA,CAAS,QAAA;WAErB,OAAA,GAAU,QAAA,CAAS,QAAA,EAoBnB;EAAA,SAlBA,OAAA,WA2BA;EAAA,SAzBA,QAAA;AAAA;;;;;;AAuCX;;KAzBY,YAAA;EA0BqB,qDAxBtB,GAAA,UAwBS;EAAA,SAtBT,KAAA;EA+BA;;;AAaX;;;EAbW,SAxBA,OAAA,WAsCwD;EAAA,SApCxD,aAAA,GAAgB,QAAA,CAAS,QAAA;EAoCiB;;;;;;EAAA,SA7B1C,KAAA,WA6BiD;EAAA,SA3BjD,GAAA;AAAA;AAAA,KAGC,cAAA;EAAA,SACD,OAAA,EAAS,aAAA,CAAc,YAAA;EAuBgE;AACjG;;;;;;;EADiG,SAdvF,GAAA;AAAA;;;;;;AAsBX;KATY,gBAAA;EAAA,SACD,MAAA,GAAS,OAAA,EAAS,mBAAA,KAAwB,MAAA,CAAO,MAAA,CAAO,cAAA,EAAgB,OAAA;AAAA;AAAA,cAClF,cAAA;AAYD;;;;;AAAA,cALa,SAAA,SAAkB,cAAA;;cAKlB,MAAA,GACX,OAAA,EAAS,mBAAA,KACR,MAAA,CAAO,MAAA,CAAO,cAAA,EAAgB,OAAA,EAAiB,SAAA"}
+{"version":3,"file":"WebSearch.d.mts","names":[],"sources":["../../src/web-search/WebSearch.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;cAsBa,eAAa,OAAA;KAEd,uBAAuB,cAAc;;;;;;;;;;;;;KAkBrC;;WAED;;;;;;;;WAQA;;WAEA,iBAAiB;;WAEjB,iBAAiB;;;;;;WAMjB,UAAU;;WAEV,YAAY,SAAS;;WAErB,UAAU,SAAS;;WAEnB;;WAEA;;;;;;;;;KAcC;;WAED;;WAEA;;;;;;;WAOA;;WAEA,gBAAgB,SAAS;;;;;;;WAOzB;;WAEA;;KAGC;WACD,SAAS,cAAc;;;;;;;;;WASvB;;;;;;;;KAaC;WACD,SAAS,SAAS,wBAAwB,OAAO,OAAO,gBAAgB;;;;;;;;cAQtE,kBAAkB;;cAKlB,SAAM,SACR,wBACR,OAAO,OAAO,gBAAgB,SAAiB"}

package/dist/web-search/WebSearch.mjs

@@ -1,4 +1,4 @@
-import { n as __exportAll } from "../chunk-uyGKjUfl.mjs";
+import { n as __exportAll } from "../rolldown-runtime-EAsCxrDo.mjs";
 import { Context, Effect, Schema } from "effect";
 //#region src/web-search/WebSearch.ts
 var WebSearch_exports = /* @__PURE__ */ __exportAll({

package/dist/web-search/WebSearch.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"WebSearch.mjs","names":[],"sources":["../../src/web-search/WebSearch.ts"],"sourcesContent":["import { Context, type DateTime, Effect, Schema } from \"effect\"\nimport type * as AiError from \"../domain/AiError.js\"\n\n// ---------------------------------------------------------------------------\n// Recency\n// ---------------------------------------------------------------------------\n\n/**\n * Convenience freshness enum shared by every provider. A coarse \"published\n * within the last …\" filter that maps onto each provider's native recency\n * knob (Perplexity `search_recency_filter`, Brave `freshness`, Tavily\n * `time_range`, You.com `freshness`), or onto a computed published-date\n * range where a provider has no enum (Exa).\n *\n * For a precise window use {@link CommonSearchRequest.startDate} /\n * {@link CommonSearchRequest.endDate} instead; `recency` is the sugar for\n * the common \"past week / past month\" case.\n *\n * Exposed as a `Schema` so {@link \"../web-search/WebSearchTool\".webSearchTool}\n * can hand it straight to a model as a tool parameter; the\n * {@link SearchRecency} type is derived from it.\n */\nexport const SearchRecency = Schema.Literals([\"hour\", \"day\", \"week\", \"month\", \"year\"])\n\nexport type SearchRecency = typeof SearchRecency.Type\n\n// ---------------------------------------------------------------------------\n// Request\n// ---------------------------------------------------------------------------\n\n/**\n * Cross-provider web-search request. A field earns a place here only if\n * most of the supported providers honor it and a developer would expect it\n * from a generic search interface; everything provider-specific (Exa\n * `type`, Tavily `searchDepth`, Brave `goggles`, pagination `offset`,\n * `safeSearch`, `topic`, …) lives on that provider's typed request.\n *\n * Note the one structural difference from `EmbeddingModel` /\n * `Transcriber`: there is no `model`. None of the pure-`/search` endpoints\n * take one - what looks model-shaped on a provider (Exa `type`, Tavily\n * `searchDepth`) is a mode knob, so it stays on the provider-typed request.\n */\nexport type CommonSearchRequest = {\n  /** The search query. The one field every provider requires. */\n  readonly query: string\n  /**\n   * Upper bound on the number of results to return in this one call.\n   * Providers cap differently (Perplexity / Tavily / Brave at ~20, Exa /\n   * You.com at ~100); a value above a provider's cap is clamped by that\n   * provider. There is no common pagination - only two providers paginate\n   * and only shallowly, so `offset` is provider-typed.\n   */\n  readonly maxResults?: number\n  /** Restrict results to these domains (e.g. `[\"docs.foo.com\"]`). */\n  readonly includeDomains?: ReadonlyArray<string>\n  /** Drop results from these domains. */\n  readonly excludeDomains?: ReadonlyArray<string>\n  /**\n   * Coarse freshness filter - see {@link SearchRecency}. Sugar over an\n   * explicit `startDate`; ignored where {@link startDate} is also set and\n   * the provider takes only one.\n   */\n  readonly recency?: SearchRecency\n  /** Published-after bound. The precise alternative to {@link recency}. */\n  readonly startDate?: DateTime.DateTime\n  /** Published-before bound. */\n  readonly endDate?: DateTime.DateTime\n  /** ISO 3166-1 alpha-2 country code to localize results (e.g. `\"us\"`). */\n  readonly country?: string\n  /** ISO 639-1 language code to bias results toward (e.g. `\"en\"`). */\n  readonly language?: string\n}\n\n// ---------------------------------------------------------------------------\n// Response\n// ---------------------------------------------------------------------------\n\n/**\n * One normalized web-search hit. A flat record with optionals rather than a\n * tagged union: the providers differ by *which fields are present*, not by\n * *kind*. The provider's untouched result object is always on `raw`, so a\n * caller holding a typed provider tag can recover anything not promoted\n * here (`author`, `favicon`, multi-chunk `snippets[]`, …).\n */\nexport type SearchResult = {\n  /** Canonical result URL. Always present. */\n  readonly url: string\n  /** Result title / headline, when the provider returns one. */\n  readonly title?: string\n  /**\n   * Primary short excerpt - the one text field all providers return (under\n   * various wire names: `snippet`, `content`, `description`). The richer\n   * extract fields (`text`, `highlights`, `summary`) belong to the\n   * out-of-scope extract feature and stay on the provider-typed result.\n   */\n  readonly snippet?: string\n  /** Publication date, when the provider reports one. */\n  readonly publishedDate?: DateTime.DateTime\n  /**\n   * Relevance score, only from providers that rank (Exa, Tavily);\n   * `undefined` for providers that return an unscored list. Kept despite\n   * being non-universal because ranking is core to what a \"search result\"\n   * means - and `undefined` cleanly says \"this backend doesn't score.\"\n   */\n  readonly score?: number\n  /** The provider-native result object, never lossy. */\n  readonly raw: unknown\n}\n\nexport type SearchResponse = {\n  readonly results: ReadonlyArray<SearchResult>\n  /**\n   * The provider-native top-level response object. Cost / usage reporting\n   * is deliberately not modeled on this surface yet: providers disagree on\n   * both what (Exa returns USD, Tavily credits, Brave nothing in-body) and\n   * where (Brave reports cost in response headers), so it is deferred to the\n   * unified usage design (see plans/usage-tracking.md). Anything a provider\n   * reports survives here on `raw`.\n   */\n  readonly raw: unknown\n}\n\n// ---------------------------------------------------------------------------\n// Service + helper\n// ---------------------------------------------------------------------------\n\n/**\n * The portable web-search surface: one operation, `search`. Pure search is\n * the one thing every provider does, so - unlike `SpeechSynthesizer` /\n * `Transcriber` - this capability needs no marker tags; every provider\n * Layer can answer.\n */\nexport type WebSearchService = {\n  readonly search: (request: CommonSearchRequest) => Effect.Effect<SearchResponse, AiError.AiError>\n}\n\n/**\n * Generic web-search service tag. Yield this for provider-portable code;\n * yield a provider tag (`PerplexitySearch`, `ExaSearch`, …) when you need\n * that provider's own knobs. A provider's `layer` registers both.\n */\nexport class WebSearch extends Context.Service<WebSearch, WebSearchService>()(\n  \"@betalyra/effect-uai/WebSearch\",\n) {}\n\n/** Run one web search against whichever provider Layer is in scope. */\nexport const search = (\n  request: CommonSearchRequest,\n): Effect.Effect<SearchResponse, AiError.AiError, WebSearch> =>\n  Effect.flatMap(WebSearch, (s) => s.search(request))\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAsBA,MAAa,gBAAgB,OAAO,SAAS;CAAC;CAAQ;CAAO;CAAQ;CAAS;CAAO,CAAC;;;;;;AAuHtF,IAAa,YAAb,cAA+B,QAAQ,SAAsC,CAC3E,iCACD,CAAC;;AAGF,MAAa,UACX,YAEA,OAAO,QAAQ,YAAY,MAAM,EAAE,OAAO,QAAQ,CAAC"}
+{"version":3,"file":"WebSearch.mjs","names":[],"sources":["../../src/web-search/WebSearch.ts"],"sourcesContent":["import { Context, type DateTime, Effect, Schema } from \"effect\"\nimport type * as AiError from \"../domain/AiError.js\"\n\n// ---------------------------------------------------------------------------\n// Recency\n// ---------------------------------------------------------------------------\n\n/**\n * Convenience freshness enum shared by every provider. A coarse \"published\n * within the last …\" filter that maps onto each provider's native recency\n * knob (Perplexity `search_recency_filter`, Brave `freshness`, Tavily\n * `time_range`, You.com `freshness`), or onto a computed published-date\n * range where a provider has no enum (Exa).\n *\n * For a precise window use {@link CommonSearchRequest.startDate} /\n * {@link CommonSearchRequest.endDate} instead; `recency` is the sugar for\n * the common \"past week / past month\" case.\n *\n * Exposed as a `Schema` so {@link \"../web-search/WebSearchTool\".webSearchTool}\n * can hand it straight to a model as a tool parameter; the\n * {@link SearchRecency} type is derived from it.\n */\nexport const SearchRecency = Schema.Literals([\"hour\", \"day\", \"week\", \"month\", \"year\"])\n\nexport type SearchRecency = typeof SearchRecency.Type\n\n// ---------------------------------------------------------------------------\n// Request\n// ---------------------------------------------------------------------------\n\n/**\n * Cross-provider web-search request. A field earns a place here only if\n * most of the supported providers honor it and a developer would expect it\n * from a generic search interface; everything provider-specific (Exa\n * `type`, Tavily `searchDepth`, Brave `goggles`, pagination `offset`,\n * `safeSearch`, `topic`, …) lives on that provider's typed request.\n *\n * Note the one structural difference from `EmbeddingModel` /\n * `Transcriber`: there is no `model`. None of the pure-`/search` endpoints\n * take one - what looks model-shaped on a provider (Exa `type`, Tavily\n * `searchDepth`) is a mode knob, so it stays on the provider-typed request.\n */\nexport type CommonSearchRequest = {\n  /** The search query. The one field every provider requires. */\n  readonly query: string\n  /**\n   * Upper bound on the number of results to return in this one call.\n   * Providers cap differently (Perplexity / Tavily / Brave at ~20, Exa /\n   * You.com at ~100); a value above a provider's cap is clamped by that\n   * provider. There is no common pagination - only two providers paginate\n   * and only shallowly, so `offset` is provider-typed.\n   */\n  readonly maxResults?: number\n  /** Restrict results to these domains (e.g. `[\"docs.foo.com\"]`). */\n  readonly includeDomains?: ReadonlyArray<string>\n  /** Drop results from these domains. */\n  readonly excludeDomains?: ReadonlyArray<string>\n  /**\n   * Coarse freshness filter - see {@link SearchRecency}. Sugar over an\n   * explicit `startDate`; ignored where {@link startDate} is also set and\n   * the provider takes only one.\n   */\n  readonly recency?: SearchRecency\n  /** Published-after bound. The precise alternative to {@link recency}. */\n  readonly startDate?: DateTime.DateTime\n  /** Published-before bound. */\n  readonly endDate?: DateTime.DateTime\n  /** ISO 3166-1 alpha-2 country code to localize results (e.g. `\"us\"`). */\n  readonly country?: string\n  /** ISO 639-1 language code to bias results toward (e.g. `\"en\"`). */\n  readonly language?: string\n}\n\n// ---------------------------------------------------------------------------\n// Response\n// ---------------------------------------------------------------------------\n\n/**\n * One normalized web-search hit. A flat record with optionals rather than a\n * tagged union: the providers differ by *which fields are present*, not by\n * *kind*. The provider's untouched result object is always on `raw`, so a\n * caller holding a typed provider tag can recover anything not promoted\n * here (`author`, `favicon`, multi-chunk `snippets[]`, …).\n */\nexport type SearchResult = {\n  /** Canonical result URL. Always present. */\n  readonly url: string\n  /** Result title / headline, when the provider returns one. */\n  readonly title?: string\n  /**\n   * Primary short excerpt - the one text field all providers return (under\n   * various wire names: `snippet`, `content`, `description`). The richer\n   * extract fields (`text`, `highlights`, `summary`) belong to the\n   * out-of-scope extract feature and stay on the provider-typed result.\n   */\n  readonly snippet?: string\n  /** Publication date, when the provider reports one. */\n  readonly publishedDate?: DateTime.DateTime\n  /**\n   * Relevance score, only from providers that rank (Exa, Tavily);\n   * `undefined` for providers that return an unscored list. Kept despite\n   * being non-universal because ranking is core to what a \"search result\"\n   * means - and `undefined` cleanly says \"this backend doesn't score.\"\n   */\n  readonly score?: number\n  /** The provider-native result object, never lossy. */\n  readonly raw: unknown\n}\n\nexport type SearchResponse = {\n  readonly results: ReadonlyArray<SearchResult>\n  /**\n   * The provider-native top-level response object. Cost / usage reporting\n   * is deliberately not modeled on this surface yet: providers disagree on\n   * both what (Exa returns USD, Tavily credits, Brave nothing in-body) and\n   * where (Brave reports cost in response headers), so it is deferred to the\n   * unified usage design (see plans/usage-tracking.md). Anything a provider\n   * reports survives here on `raw`.\n   */\n  readonly raw: unknown\n}\n\n// ---------------------------------------------------------------------------\n// Service + helper\n// ---------------------------------------------------------------------------\n\n/**\n * The portable web-search surface: one operation, `search`. Pure search is\n * the one thing every provider does, so - unlike `SpeechSynthesizer` /\n * `Transcriber` - this capability needs no marker tags; every provider\n * Layer can answer.\n */\nexport type WebSearchService = {\n  readonly search: (request: CommonSearchRequest) => Effect.Effect<SearchResponse, AiError.AiError>\n}\n\n/**\n * Generic web-search service tag. Yield this for provider-portable code;\n * yield a provider tag (`PerplexitySearch`, `ExaSearch`, …) when you need\n * that provider's own knobs. A provider's `layer` registers both.\n */\nexport class WebSearch extends Context.Service<WebSearch, WebSearchService>()(\n  \"@betalyra/effect-uai/WebSearch\",\n) {}\n\n/** Run one web search against whichever provider Layer is in scope. */\nexport const search = (\n  request: CommonSearchRequest,\n): Effect.Effect<SearchResponse, AiError.AiError, WebSearch> =>\n  Effect.flatMap(WebSearch, (s) => s.search(request))\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAsBA,MAAa,gBAAgB,OAAO,SAAS;CAAC;CAAQ;CAAO;CAAQ;CAAS;AAAM,CAAC;;;;;;AAuHrF,IAAa,YAAb,cAA+B,QAAQ,QAAqC,CAAC,CAC3E,gCACF,CAAC,CAAC,CAAC;;AAGH,MAAa,UACX,YAEA,OAAO,QAAQ,YAAY,MAAM,EAAE,OAAO,OAAO,CAAC"}

package/dist/web-search/WebSearchTool.d.mts

@@ -1,9 +1,7 @@
-import { l as Tool } from "../Tool-u5bag8SO.mjs";
-import { t as AiError } from "../AiError-Bf1pq4BB.mjs";
+import { l as Tool } from "../Tool-DE-rnvkw.mjs";
+import { t as AiError } from "../AiError-eLV9t1lU.mjs";
 import { SearchResult, WebSearch } from "./WebSearch.mjs";
 import { Schema } from "effect";
-
-//#region src/web-search/WebSearchTool.d.ts
 declare namespace WebSearchTool_d_exports {
   export { WebSearchToolArgs, WebSearchToolOptions, webSearchTool };
 }
@@ -21,7 +19,8 @@ declare const WebSearchToolArgs: Schema.Struct<{
 }>;
 type WebSearchToolArgs = typeof WebSearchToolArgs.Type;
 type WebSearchToolOptions = {
-  /** Tool name the model sees. Default `"web_search"`. */readonly name?: string;
+  /** Tool name the model sees. Default `"web_search"`. */
+  readonly name?: string;
   /**
    * App-fixed ceiling on results per call - a cost guard, not exposed to
    * the model. Default `5`.
@@ -31,7 +30,8 @@ type WebSearchToolOptions = {
    * App-fixed allowlist applied to every search. A policy scope ("only
    * search our docs"), not a model knob - so it is enforced, not requested.
    */
-  readonly includeDomains?: ReadonlyArray<string>; /** App-fixed denylist applied to every search ("never return X"). */
+  readonly includeDomains?: ReadonlyArray<string>;
+  /** App-fixed denylist applied to every search ("never return X"). */
   readonly excludeDomains?: ReadonlyArray<string>;
   /**
    * Override how results are rendered into the model-facing string.

package/dist/web-search/WebSearchTool.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"WebSearchTool.d.mts","names":[],"sources":["../../src/web-search/WebSearchTool.ts"],"mappings":";;;;;;;;;;;;;;;;;cAaM,iBAAA,EAAiB,MAAA,CAAA,MAAA;EAAA;;;KAKX,iBAAA,UAA2B,iBAAA,CAAkB,IAAA;AAAA,KAa7C,oBAAA;EAlBW,iEAoBZ,IAAA;EApBY;;;;EAAA,SAyBZ,UAAA;;;;;WAKA,cAAA,GAAiB,aAAA;WAEjB,cAAA,GAAiB,aAAA;;AA3B5B;;;WAgCW,MAAA,IAAU,OAAA,EAAS,aAAA,CAAc,YAAA;AAAA;AAnB5C;;;;;;;;;;;;;;;;;;;AAAA,cAyCa,aAAA,GACX,OAAA,GAAU,oBAAA,KACT,IAAA,SAAkB,iBAAA,iBAAkC,OAAA,EAAiB,SAAA"}
+{"version":3,"file":"WebSearchTool.d.mts","names":[],"sources":["../../src/web-search/WebSearchTool.ts"],"mappings":";;;;;;;;;;;;;;;cAaM,mBAAiB,OAAA;;;;KAKX,2BAA2B,kBAAkB;KAa7C;;WAED;;;;;WAKA;;;;;WAKA,iBAAiB;;WAEjB,iBAAiB;;;;;WAKjB,UAAU,SAAS,cAAc;;;;;;;;;;;;;;;;;;;;;cAsB/B,gBAAa,UACd,yBACT,aAAkB,kCAAkC,SAAiB"}

package/dist/web-search/WebSearchTool.mjs

@@ -1,4 +1,4 @@
-import { n as __exportAll } from "../chunk-uyGKjUfl.mjs";
+import { n as __exportAll } from "../rolldown-runtime-EAsCxrDo.mjs";
 import { fromEffectSchema, make } from "../tool/Tool.mjs";
 import { SearchRecency, search } from "./WebSearch.mjs";
 import { Effect, Schema } from "effect";

package/dist/web-search/WebSearchTool.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"WebSearchTool.mjs","names":["Tool.make","Tool.fromEffectSchema"],"sources":["../../src/web-search/WebSearchTool.ts"],"sourcesContent":["import { Effect, Schema } from \"effect\"\nimport type * as AiError from \"../domain/AiError.js\"\nimport * as Tool from \"../tool/Tool.js\"\nimport { search, SearchRecency, type SearchResult, WebSearch } from \"./WebSearch.js\"\n\n/**\n * Model-facing argument schema. Deliberately narrow: `query` plus the one\n * filter that is genuinely the model's call - `recency` (it knows whether a\n * question is about current events or evergreen). App-policy scoping\n * (`includeDomains` / `excludeDomains`) and the `maxResults` cost ceiling\n * are pinned on the constructor instead, so they are guaranteed rather than\n * left to the model to remember each call.\n */\nconst WebSearchToolArgs = Schema.Struct({\n  query: Schema.String,\n  recency: Schema.optional(SearchRecency),\n})\n\nexport type WebSearchToolArgs = typeof WebSearchToolArgs.Type\n\n/** Numbered `title / url / snippet` list - what a model reads best. */\nconst defaultRender = (results: ReadonlyArray<SearchResult>): string =>\n  results.length === 0\n    ? \"No results found.\"\n    : results\n        .map((r, i) => {\n          const head = `${i + 1}. ${r.title ?? r.url}\\n   ${r.url}`\n          return r.snippet === undefined ? head : `${head}\\n   ${r.snippet}`\n        })\n        .join(\"\\n\\n\")\n\nexport type WebSearchToolOptions = {\n  /** Tool name the model sees. Default `\"web_search\"`. */\n  readonly name?: string\n  /**\n   * App-fixed ceiling on results per call - a cost guard, not exposed to\n   * the model. Default `5`.\n   */\n  readonly maxResults?: number\n  /**\n   * App-fixed allowlist applied to every search. A policy scope (\"only\n   * search our docs\"), not a model knob - so it is enforced, not requested.\n   */\n  readonly includeDomains?: ReadonlyArray<string>\n  /** App-fixed denylist applied to every search (\"never return X\"). */\n  readonly excludeDomains?: ReadonlyArray<string>\n  /**\n   * Override how results are rendered into the model-facing string.\n   * Default: a numbered `title / url / snippet` list.\n   */\n  readonly render?: (results: ReadonlyArray<SearchResult>) => string\n}\n\n/**\n * The canonical web-search tool. Its `R` is just `WebSearch`, so providing\n * any search-provider Layer satisfies it and the model-facing contract\n * (name, description, schema) is identical no matter which backend answers\n * - swap `PerplexitySearch.layer` for `ExaSearch.layer` and the tool the\n * model sees does not change. Drops straight into a `Toolkit` and the\n * `LanguageModel` tool-calling loop.\n *\n * The model controls only `query` and `recency`; domain scoping and the\n * result cap are app policy, fixed here on the constructor. `Output` is the\n * rendered text (the model reads a numbered list better than raw\n * `SearchResult[]`; pass `render` to change the format); failures stay typed\n * on the `AiError` channel. To let the model recover from a failed search,\n * wrap the toolkit in `Toolkit.describeFailures(AiError.describe)`.\n *\n * This is a simple default implementation for quick use. For more elaborate\n * cases (a different output contract, more model-facing knobs), build your\n * own tool with `Tool.make` over the same `search` helper.\n */\nexport const webSearchTool = (\n  options?: WebSearchToolOptions,\n): Tool.Tool<string, WebSearchToolArgs, never, string, AiError.AiError, WebSearch> => {\n  const name = options?.name ?? \"web_search\"\n  const render = options?.render ?? defaultRender\n  const maxResults = options?.maxResults ?? 5\n  const includeDomains = options?.includeDomains\n  const excludeDomains = options?.excludeDomains\n  return Tool.make({\n    name,\n    description:\n      \"Search the web for current information. Returns ranked results with titles, URLs, and snippets.\",\n    inputSchema: Tool.fromEffectSchema(WebSearchToolArgs),\n    // The call is wrapped in a tracing span so agent traces show the tool\n    // invocation (query, filters, result count) nested under the model turn.\n    // `withSpan` is a no-op until a Tracer is installed, so this is free by\n    // default and adds nothing to the requirements.\n    run: (args) =>\n      search({\n        query: args.query,\n        maxResults,\n        ...(args.recency !== undefined && { recency: args.recency }),\n        ...(includeDomains !== undefined && { includeDomains }),\n        ...(excludeDomains !== undefined && { excludeDomains }),\n      }).pipe(\n        Effect.tap((r) => Effect.annotateCurrentSpan(\"web_search.result_count\", r.results.length)),\n        Effect.map((r) => render(r.results)),\n        Effect.withSpan(name, {\n          kind: \"client\",\n          attributes: {\n            \"web_search.query\": args.query,\n            \"web_search.max_results\": maxResults,\n            ...(args.recency !== undefined && { \"web_search.recency\": args.recency }),\n            ...(includeDomains !== undefined && { \"web_search.include_domains\": includeDomains }),\n            ...(excludeDomains !== undefined && { \"web_search.exclude_domains\": excludeDomains }),\n          },\n        }),\n      ),\n  })\n}\n"],"mappings":";;;;;;;;;;;;;;AAaA,MAAM,oBAAoB,OAAO,OAAO;CACtC,OAAO,OAAO;CACd,SAAS,OAAO,SAAS,cAAc;CACxC,CAAC;;AAKF,MAAM,iBAAiB,YACrB,QAAQ,WAAW,IACf,sBACA,QACG,KAAK,GAAG,MAAM;CACb,MAAM,OAAO,GAAG,IAAI,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,OAAO,EAAE;AACpD,QAAO,EAAE,YAAY,KAAA,IAAY,OAAO,GAAG,KAAK,OAAO,EAAE;EACzD,CACD,KAAK,OAAO;;;;;;;;;;;;;;;;;;;;AA2CrB,MAAa,iBACX,YACoF;CACpF,MAAM,OAAO,SAAS,QAAQ;CAC9B,MAAM,SAAS,SAAS,UAAU;CAClC,MAAM,aAAa,SAAS,cAAc;CAC1C,MAAM,iBAAiB,SAAS;CAChC,MAAM,iBAAiB,SAAS;AAChC,QAAOA,KAAU;EACf;EACA,aACE;EACF,aAAaC,iBAAsB,kBAAkB;EAKrD,MAAM,SACJ,OAAO;GACL,OAAO,KAAK;GACZ;GACA,GAAI,KAAK,YAAY,KAAA,KAAa,EAAE,SAAS,KAAK,SAAS;GAC3D,GAAI,mBAAmB,KAAA,KAAa,EAAE,gBAAgB;GACtD,GAAI,mBAAmB,KAAA,KAAa,EAAE,gBAAgB;GACvD,CAAC,CAAC,KACD,OAAO,KAAK,MAAM,OAAO,oBAAoB,2BAA2B,EAAE,QAAQ,OAAO,CAAC,EAC1F,OAAO,KAAK,MAAM,OAAO,EAAE,QAAQ,CAAC,EACpC,OAAO,SAAS,MAAM;GACpB,MAAM;GACN,YAAY;IACV,oBAAoB,KAAK;IACzB,0BAA0B;IAC1B,GAAI,KAAK,YAAY,KAAA,KAAa,EAAE,sBAAsB,KAAK,SAAS;IACxE,GAAI,mBAAmB,KAAA,KAAa,EAAE,8BAA8B,gBAAgB;IACpF,GAAI,mBAAmB,KAAA,KAAa,EAAE,8BAA8B,gBAAgB;IACrF;GACF,CAAC,CACH;EACJ,CAAC"}
+{"version":3,"file":"WebSearchTool.mjs","names":["Tool.make","Tool.fromEffectSchema"],"sources":["../../src/web-search/WebSearchTool.ts"],"sourcesContent":["import { Effect, Schema } from \"effect\"\nimport type * as AiError from \"../domain/AiError.js\"\nimport * as Tool from \"../tool/Tool.js\"\nimport { search, SearchRecency, type SearchResult, WebSearch } from \"./WebSearch.js\"\n\n/**\n * Model-facing argument schema. Deliberately narrow: `query` plus the one\n * filter that is genuinely the model's call - `recency` (it knows whether a\n * question is about current events or evergreen). App-policy scoping\n * (`includeDomains` / `excludeDomains`) and the `maxResults` cost ceiling\n * are pinned on the constructor instead, so they are guaranteed rather than\n * left to the model to remember each call.\n */\nconst WebSearchToolArgs = Schema.Struct({\n  query: Schema.String,\n  recency: Schema.optional(SearchRecency),\n})\n\nexport type WebSearchToolArgs = typeof WebSearchToolArgs.Type\n\n/** Numbered `title / url / snippet` list - what a model reads best. */\nconst defaultRender = (results: ReadonlyArray<SearchResult>): string =>\n  results.length === 0\n    ? \"No results found.\"\n    : results\n        .map((r, i) => {\n          const head = `${i + 1}. ${r.title ?? r.url}\\n   ${r.url}`\n          return r.snippet === undefined ? head : `${head}\\n   ${r.snippet}`\n        })\n        .join(\"\\n\\n\")\n\nexport type WebSearchToolOptions = {\n  /** Tool name the model sees. Default `\"web_search\"`. */\n  readonly name?: string\n  /**\n   * App-fixed ceiling on results per call - a cost guard, not exposed to\n   * the model. Default `5`.\n   */\n  readonly maxResults?: number\n  /**\n   * App-fixed allowlist applied to every search. A policy scope (\"only\n   * search our docs\"), not a model knob - so it is enforced, not requested.\n   */\n  readonly includeDomains?: ReadonlyArray<string>\n  /** App-fixed denylist applied to every search (\"never return X\"). */\n  readonly excludeDomains?: ReadonlyArray<string>\n  /**\n   * Override how results are rendered into the model-facing string.\n   * Default: a numbered `title / url / snippet` list.\n   */\n  readonly render?: (results: ReadonlyArray<SearchResult>) => string\n}\n\n/**\n * The canonical web-search tool. Its `R` is just `WebSearch`, so providing\n * any search-provider Layer satisfies it and the model-facing contract\n * (name, description, schema) is identical no matter which backend answers\n * - swap `PerplexitySearch.layer` for `ExaSearch.layer` and the tool the\n * model sees does not change. Drops straight into a `Toolkit` and the\n * `LanguageModel` tool-calling loop.\n *\n * The model controls only `query` and `recency`; domain scoping and the\n * result cap are app policy, fixed here on the constructor. `Output` is the\n * rendered text (the model reads a numbered list better than raw\n * `SearchResult[]`; pass `render` to change the format); failures stay typed\n * on the `AiError` channel. To let the model recover from a failed search,\n * wrap the toolkit in `Toolkit.describeFailures(AiError.describe)`.\n *\n * This is a simple default implementation for quick use. For more elaborate\n * cases (a different output contract, more model-facing knobs), build your\n * own tool with `Tool.make` over the same `search` helper.\n */\nexport const webSearchTool = (\n  options?: WebSearchToolOptions,\n): Tool.Tool<string, WebSearchToolArgs, never, string, AiError.AiError, WebSearch> => {\n  const name = options?.name ?? \"web_search\"\n  const render = options?.render ?? defaultRender\n  const maxResults = options?.maxResults ?? 5\n  const includeDomains = options?.includeDomains\n  const excludeDomains = options?.excludeDomains\n  return Tool.make({\n    name,\n    description:\n      \"Search the web for current information. Returns ranked results with titles, URLs, and snippets.\",\n    inputSchema: Tool.fromEffectSchema(WebSearchToolArgs),\n    // The call is wrapped in a tracing span so agent traces show the tool\n    // invocation (query, filters, result count) nested under the model turn.\n    // `withSpan` is a no-op until a Tracer is installed, so this is free by\n    // default and adds nothing to the requirements.\n    run: (args) =>\n      search({\n        query: args.query,\n        maxResults,\n        ...(args.recency !== undefined && { recency: args.recency }),\n        ...(includeDomains !== undefined && { includeDomains }),\n        ...(excludeDomains !== undefined && { excludeDomains }),\n      }).pipe(\n        Effect.tap((r) => Effect.annotateCurrentSpan(\"web_search.result_count\", r.results.length)),\n        Effect.map((r) => render(r.results)),\n        Effect.withSpan(name, {\n          kind: \"client\",\n          attributes: {\n            \"web_search.query\": args.query,\n            \"web_search.max_results\": maxResults,\n            ...(args.recency !== undefined && { \"web_search.recency\": args.recency }),\n            ...(includeDomains !== undefined && { \"web_search.include_domains\": includeDomains }),\n            ...(excludeDomains !== undefined && { \"web_search.exclude_domains\": excludeDomains }),\n          },\n        }),\n      ),\n  })\n}\n"],"mappings":";;;;;;;;;;;;;;AAaA,MAAM,oBAAoB,OAAO,OAAO;CACtC,OAAO,OAAO;CACd,SAAS,OAAO,SAAS,aAAa;AACxC,CAAC;;AAKD,MAAM,iBAAiB,YACrB,QAAQ,WAAW,IACf,sBACA,QACG,KAAK,GAAG,MAAM;CACb,MAAM,OAAO,GAAG,IAAI,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,OAAO,EAAE;CACpD,OAAO,EAAE,YAAY,KAAA,IAAY,OAAO,GAAG,KAAK,OAAO,EAAE;AAC3D,CAAC,CAAC,CACD,KAAK,MAAM;;;;;;;;;;;;;;;;;;;;AA2CpB,MAAa,iBACX,YACoF;CACpF,MAAM,OAAO,SAAS,QAAQ;CAC9B,MAAM,SAAS,SAAS,UAAU;CAClC,MAAM,aAAa,SAAS,cAAc;CAC1C,MAAM,iBAAiB,SAAS;CAChC,MAAM,iBAAiB,SAAS;CAChC,OAAOA,KAAU;EACf;EACA,aACE;EACF,aAAaC,iBAAsB,iBAAiB;EAKpD,MAAM,SACJ,OAAO;GACL,OAAO,KAAK;GACZ;GACA,GAAI,KAAK,YAAY,KAAA,KAAa,EAAE,SAAS,KAAK,QAAQ;GAC1D,GAAI,mBAAmB,KAAA,KAAa,EAAE,eAAe;GACrD,GAAI,mBAAmB,KAAA,KAAa,EAAE,eAAe;EACvD,CAAC,CAAC,CAAC,KACD,OAAO,KAAK,MAAM,OAAO,oBAAoB,2BAA2B,EAAE,QAAQ,MAAM,CAAC,GACzF,OAAO,KAAK,MAAM,OAAO,EAAE,OAAO,CAAC,GACnC,OAAO,SAAS,MAAM;GACpB,MAAM;GACN,YAAY;IACV,oBAAoB,KAAK;IACzB,0BAA0B;IAC1B,GAAI,KAAK,YAAY,KAAA,KAAa,EAAE,sBAAsB,KAAK,QAAQ;IACvE,GAAI,mBAAmB,KAAA,KAAa,EAAE,8BAA8B,eAAe;IACnF,GAAI,mBAAmB,KAAA,KAAa,EAAE,8BAA8B,eAAe;GACrF;EACF,CAAC,CACH;CACJ,CAAC;AACH"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect-uai/core",
-  "version": "0.12.0",
+  "version": "0.12.1",
   "description": "Low-level primitives (loop, conversation, items, tools, streaming codecs) for building AI agents with Effect.",
   "keywords": [
     "agents",
@@ -242,11 +242,11 @@
     "@standard-schema/spec": "^1.1.0"
   },
   "devDependencies": {
-    "effect": "4.0.0-beta.94",
-    "typescript": "^6.0.3"
+    "effect": "4.0.0-rc.111",
+    "typescript": "^7.0.2"
   },
   "peerDependencies": {
-    "effect": ">=4.0.0-beta.94 <5.0.0"
+    "effect": ">=4.0.0-rc.111 <5.0.0"
   },
   "scripts": {
     "build": "tsdown",

package/src/loop/Loop.test.ts

@@ -68,10 +68,8 @@ describe("Loop.loop", () => {
 
   it("propagates errors from the body's stream", async () => {
     const boom = new Error("boom")
-    const stream = loop(
-      0,
-      (n: number): Stream.Stream<Step<number, number>, Error> =>
-        n === 2 ? Stream.fail(boom) : Stream.succeed(value(n)).pipe(Stream.concat(next(n + 1))),
+    const stream = loop(0, (n: number): Stream.Stream<Step<number, number>, Error> =>
+      n === 2 ? Stream.fail(boom) : Stream.succeed(value(n)).pipe(Stream.concat(next(n + 1))),
     )
 
     const result = await Effect.runPromiseExit(Stream.runCollect(stream))
@@ -293,13 +291,12 @@ const conversationLoop = (initial: State, runTool: ToolRunner) =>
                 ? Ref.update(textsRef, (t) => [...t, d.text])
                 : Ref.update(toolCallsRef, (t) => [...t, { id: d.id, name: d.name }]),
             ),
-            Stream.flatMap(
-              (d): Stream.Stream<Step<UiEvent, State>> =>
-                d.type === "text"
-                  ? Stream.fromIterable([value<UiEvent>({ type: "text", text: d.text })])
-                  : Stream.fromIterable([
-                      value<UiEvent>({ type: "tool_started", id: d.id, name: d.name }),
-                    ]),
+            Stream.flatMap((d): Stream.Stream<Step<UiEvent, State>> =>
+              d.type === "text"
+                ? Stream.fromIterable([value<UiEvent>({ type: "text", text: d.text })])
+                : Stream.fromIterable([
+                    value<UiEvent>({ type: "tool_started", id: d.id, name: d.name }),
+                  ]),
             ),
           )
 
@@ -314,9 +311,11 @@ const conversationLoop = (initial: State, runTool: ToolRunner) =>
 
             const turnItems: ReadonlyArray<HistoryItem> = [
               ...(texts.length > 0 ? [{ type: "assistant" as const, text: texts.join("") }] : []),
-              ...toolCalls.map(
-                (tc): HistoryItem => ({ type: "tool_call", id: tc.id, name: tc.name }),
-              ),
+              ...toolCalls.map((tc): HistoryItem => ({
+                type: "tool_call",
+                id: tc.id,
+                name: tc.name,
+              })),
             ]
 
             const outcomes = toolCalls.map((call) => ({ call, outcome: runTool(call) }))

package/src/loop/Loop.ts

@@ -229,91 +229,89 @@ type LoopBody<S, A, E, R> = (
 export const loop: {
   <S, A, E, R>(body: LoopBody<S, A, E, R>): (initial: S) => Stream.Stream<A, E, R>
   <S, A, E, R>(initial: S, body: LoopBody<S, A, E, R>): Stream.Stream<A, E, R>
-} = Function.dual(
-  2,
-  <S, A, E, R>(initial: S, body: LoopBody<S, A, E, R>): Stream.Stream<A, E, R> =>
-    Stream.scoped(
-      Stream.fromPull(
-        Effect.gen(function* () {
-          const outerScope = yield* Effect.scope
-          let state = initial
-          let current: CurrentBody<S, A, E, R> | undefined
-          let done = false
-
-          const closeActive = (
-            active: CurrentBody<S, A, E, R>,
-            exit: Exit.Exit<unknown, unknown>,
-          ) => {
-            const isActive = current === active
-            if (isActive) current = undefined
-            // Scope.close is idempotent. Multiple paths can race to close the
-            // active body during cancellation/failure, so closing twice is safe.
-            return closeBody(active, exit)
-          }
+} = Function.dual(2, <S, A, E, R>(initial: S, body: LoopBody<S, A, E, R>): Stream.Stream<A, E, R> =>
+  Stream.scoped(
+    Stream.fromPull(
+      Effect.gen(function* () {
+        const outerScope = yield* Effect.scope
+        let state = initial
+        let current: CurrentBody<S, A, E, R> | undefined
+        let done = false
+
+        const closeActive = (
+          active: CurrentBody<S, A, E, R>,
+          exit: Exit.Exit<unknown, unknown>,
+        ) => {
+          const isActive = current === active
+          if (isActive) current = undefined
+          // Scope.close is idempotent. Multiple paths can race to close the
+          // active body during cancellation/failure, so closing twice is safe.
+          return closeBody(active, exit)
+        }
+
+        yield* Scope.addFinalizerExit(outerScope, (exit) =>
+          current === undefined ? Effect.void : closeActive(current, exit),
+        )
 
-          yield* Scope.addFinalizerExit(outerScope, (exit) =>
-            current === undefined ? Effect.void : closeActive(current, exit),
-          )
-
-          const pull = Effect.gen(function* () {
-            while (true) {
-              if (done) return yield* Cause.done()
-
-              if (current === undefined) {
-                const result = body(state)
-                const stream = Effect.isEffect(result) ? Stream.unwrap(result) : result
-                const bodyScope = yield* Scope.fork(outerScope)
-                const bodyPull = yield* Channel.toPullScoped(
-                  Stream.toChannel(stream),
-                  bodyScope,
-                ).pipe(Effect.onError((cause) => Scope.close(bodyScope, Exit.failCause(cause))))
-                current = { scope: bodyScope, pull: bodyPull }
-              }
+        const pull = Effect.gen(function* () {
+          while (true) {
+            if (done) return yield* Cause.done()
+
+            if (current === undefined) {
+              const result = body(state)
+              const stream = Effect.isEffect(result) ? Stream.unwrap(result) : result
+              const bodyScope = yield* Scope.fork(outerScope)
+              const bodyPull = yield* Channel.toPullScoped(
+                Stream.toChannel(stream),
+                bodyScope,
+              ).pipe(Effect.onError((cause) => Scope.close(bodyScope, Exit.failCause(cause))))
+              current = { scope: bodyScope, pull: bodyPull }
+            }
 
-              const active = current
-              const chunk = yield* active.pull.pipe(
-                Effect.catchIf(Cause.isDone, () =>
-                  closeActive(active, Exit.void).pipe(
-                    Effect.as(undefined as ReadonlyArray<Step<A, S>> | undefined),
-                  ),
+            const active = current
+            const chunk = yield* active.pull.pipe(
+              Effect.catchIf(Cause.isDone, () =>
+                closeActive(active, Exit.void).pipe(
+                  Effect.as(undefined as ReadonlyArray<Step<A, S>> | undefined),
                 ),
-                Effect.onError((cause) => closeActive(active, Exit.failCause(cause))),
-              )
+              ),
+              Effect.onError((cause) => closeActive(active, Exit.failCause(cause))),
+            )
+
+            if (chunk === undefined) {
+              done = true
+              return yield* Cause.done()
+            }
+
+            const { values, decision } = partitionChunk(chunk)
 
-              if (chunk === undefined) {
+            if (Option.isSome(decision)) {
+              yield* closeActive(active, Exit.void)
+              if (decision.value._tag === "Stop" || decision.value._tag === "StopWith") {
+                // `loop` has no next iteration to apply StopWith's state to;
+                // the state lands in `loopOver`'s outer ref or
+                // `loopWithState`'s SubscriptionRef via their taps.
                 done = true
-                return yield* Cause.done()
+              } else if (decision.value._tag === "Next") {
+                state = decision.value.state
               }
+            }
 
-              const { values, decision } = partitionChunk(chunk)
-
-              if (Option.isSome(decision)) {
-                yield* closeActive(active, Exit.void)
-                if (decision.value._tag === "Stop" || decision.value._tag === "StopWith") {
-                  // `loop` has no next iteration to apply StopWith's state to;
-                  // the state lands in `loopOver`'s outer ref or
-                  // `loopWithState`'s SubscriptionRef via their taps.
-                  done = true
-                } else if (decision.value._tag === "Next") {
-                  state = decision.value.state
-                }
-              }
+            // Emit the values seen so far if any. Chunks from a Stream pull
+            // are non-empty, so when `decision` is `None` every step was
+            // a `Value` and `values` is non-empty here. With a decision and
+            // no preceding values, fall through to the next iteration.
+            if (isNonEmpty(values)) return values
+          }
+        })
 
-              // Emit the values seen so far if any. Chunks from a Stream pull
-              // are non-empty, so when `decision` is `None` every step was
-              // a `Value` and `values` is non-empty here. With a decision and
-              // no preceding values, fall through to the next iteration.
-              if (isNonEmpty(values)) return values
-            }
-          })
-
-          // `Stream.fromPull` expects the generator to RETURN the pull effect,
-          // not run it; `return yield* pull` would execute a pull and break it.
-          // @effect-diagnostics-next-line effect/returnEffectInGen:off
-          return pull
-        }),
-      ),
+        // `Stream.fromPull` expects the generator to RETURN the pull effect,
+        // not run it; `return yield* pull` would execute a pull and break it.
+        // @effect-diagnostics-next-line effect/returnEffectInGen:off
+        return pull
+      }),
     ),
+  ),
 )
 
 // ---------------------------------------------------------------------------