@effect-uai/core 0.9.0 → 0.11.0

package/dist/{Tool-0XUIT2A2.d.mts → Tool-CXFHCQrT.d.mts}

@@ -1,11 +1,11 @@
-import { v as ToolCall, y as ToolCallOutput } from "./Items-CgKD6Npw.mjs";
+import { v as ToolCall, y as ToolCallOutput } from "./Items-BWNu6VGp.mjs";
 import { Effect, Schema } from "effect";
 import * as _$effect_Cause0 from "effect/Cause";
 import { StandardJSONSchemaV1, StandardSchemaV1 } from "@standard-schema/spec";
 
 //#region src/tool/Tool.d.ts
 declare namespace Tool_d_exports {
-  export { AnyLocalTool, AnyTool, DecodableTool, Emit, InteractionTool, ProviderTool, SignalTool, Tool, ToolDescriptor, ToolError, ToolInputSchema, ToolR, ToolValidationError, decodeArgs, descriptorsOf, execute, fromEffectSchema, fromStandardSchema, interaction, make, provider, signal, toDescriptors, withName, withRun };
+  export { AnyLocalTool, AnyTool, DecodableTool, DecodeResult, Emit, InteractionTool, ProviderTool, SignalTool, Tool, ToolDescriptor, ToolE, ToolError, ToolFailed, ToolInputSchema, ToolR, ToolValidationError, decodeArgs, decodeCallInput, descriptorsOf, execute, fail, fromEffectSchema, fromStandardSchema, interaction, isProviderTool, make, noInput, provider, providerToolsOf, signal, toDescriptors, withName, withRun };
 }
 declare const ToolError_base: Schema.Class<ToolError, Schema.TaggedStruct<"ToolError", {
   readonly call_id: Schema.String;
@@ -29,6 +29,28 @@ declare const ToolValidationError_base: Schema.Class<ToolValidationError, Schema
  * structured `issues` survive instead of being flattened into a message string.
  */
 declare class ToolValidationError extends ToolValidationError_base {}
+declare const ToolFailed_base: Schema.Class<ToolFailed, Schema.TaggedStruct<"ToolFailed", {
+  readonly message: Schema.String;
+  readonly kind: Schema.optional<Schema.String>;
+}>, _$effect_Cause0.YieldableError>;
+/**
+ * The deliberate "speak to the model" failure sentinel. A tool's `run` that
+ * fails with a `ToolFailed` (or a bare `string`, its sugar) is absorbed by
+ * `Toolkit.run` into a `ToolResult.Failure` the model reads and adapts to,
+ * instead of ending the run. Every other error type propagates typed on the
+ * executor's stream. `kind` overrides the synthesized `Failure.kind`
+ * (default `"tool_failed"`) so a tool can hand the model a distinguishable
+ * category (`"not_found"`, `"rate_limited"`) without a new result variant.
+ */
+declare class ToolFailed extends ToolFailed_base {}
+/**
+ * Fail a tool's `run` with a model-visible message (optionally a `kind`).
+ * `yield* Tool.fail("page not found", { kind: "not_found" })` inside a
+ * `run`'s `Effect.gen`; the executor absorbs it as `ToolResult.Failure`.
+ */
+declare const fail: (message: string, options?: {
+  readonly kind?: string;
+}) => Effect.Effect<never, ToolFailed>;
 /**
  * Schemas accepted on `Tool.inputSchema`. Must implement both Standard
  * Schema validation and JSON Schema conversion (for rendering tool
@@ -61,6 +83,14 @@ declare const fromEffectSchema: <S extends Schema.Codec<any, any, never, any>>(s
  * helper makes the input type inference explicit at the call site.
  */
 declare const fromStandardSchema: <S extends StandardSchemaV1 & StandardJSONSchemaV1>(schema: S) => S & ToolInputSchema<StandardSchemaV1.InferOutput<S>>;
+/**
+ * Input schema for a tool that takes no arguments. Renders a clean
+ * `{ type: "object", properties: {} }`; validation accepts anything and
+ * yields `{}`. Use it instead of `fromEffectSchema(Schema.Struct({}))`,
+ * which renders a degenerate `anyOf` (object-or-array) that strict
+ * providers like Gemini reject.
+ */
+declare const noInput: ToolInputSchema<Record<string, never>>;
 /**
  * Emit one intermediate `Event` from inside a tool's `run`. Backed by the
  * executor's per-call queue, so it returns an `Effect` (backpressure) and
@@ -79,12 +109,12 @@ type Emit<Event> = (event: Event) => Effect.Effect<void>;
  * no local executor — see their constructors below. `Tool` keeps its name (and
  * the `Tool.make` constructor) because the local kind is by far the common one.
  */
-type Tool<Name extends string, Input, Event, Output, R = never> = {
+type Tool<Name extends string, Input, Event, Output, E = unknown, R = never> = {
   readonly _tag: "LocalTool";
   readonly name: Name;
   readonly description: string;
   readonly inputSchema: ToolInputSchema<Input>;
-  readonly run: (input: Input, emit: Emit<Event>) => Effect.Effect<Output, unknown, R>;
+  readonly run: (input: Input, emit: Emit<Event>) => Effect.Effect<Output, E, R>;
   /**
    * Bound on this tool's emit queue. Unbounded when omitted. Per-tool because
    * backpressure depends on how a given tool emits, unlike `concurrency`
@@ -139,16 +169,18 @@ type InteractionTool<Name extends string, Input> = {
   readonly inputSchema: ToolInputSchema<Input>;
 };
 /** A local (executable) tool of any shape. Readability alias. */
-type AnyLocalTool<R = any> = Tool<string, any, any, any, R>;
+type AnyLocalTool<E = any, R = any> = Tool<string, any, any, any, E, R>;
 /** Any of the four model-visible tool kinds. */
-type AnyTool<R = any> = Tool<string, any, any, any, R> | ProviderTool<string, any, string, any> | SignalTool<string, any> | InteractionTool<string, any>;
+type AnyTool<E = any, R = any> = Tool<string, any, any, any, E, R> | ProviderTool<string, any, string, any> | SignalTool<string, any> | InteractionTool<string, any>;
 /** A model-visible tool that carries a decodable input schema (every kind). */
 type DecodableTool<Input> = {
   readonly name: string;
   readonly inputSchema: ToolInputSchema<Input>;
 };
 /** Extract the `R` of a local tool; non-local kinds contribute `never`. */
-type ToolR<T> = T extends Tool<string, any, any, any, infer R> ? R : never;
+type ToolR<T> = T extends Tool<string, any, any, any, any, infer R> ? R : never;
+/** Extract the `E` of a local tool; non-local kinds contribute `never`. */
+type ToolE<T> = T extends Tool<string, any, any, any, infer E, any> ? E : never;
 /**
  * Provider-agnostic tool descriptor. Each provider maps `inputSchema`
  * to its own wire field (OpenAI → `parameters`, Anthropic →
@@ -161,25 +193,45 @@ type ToolDescriptor = {
   readonly strict?: boolean;
 };
 /** A model-visible tool with a local `Effect` executor. */
-declare const make: <Name extends string, Input, Event, Output, R = never>(spec: Omit<Tool<Name, Input, Event, Output, R>, "_tag">) => Tool<Name, Input, Event, Output, R>;
+declare const make: {
+  <Name extends string, S extends Schema.Codec<any, any, never, any>, Event, Output, E = never, R = never>(spec: Omit<Tool<Name, S["Type"], Event, Output, E, R>, "_tag" | "inputSchema"> & {
+    readonly inputSchema: S;
+  }): Tool<Name, S["Type"], Event, Output, E, R>;
+  <Name extends string, Input, Event, Output, E = never, R = never>(spec: Omit<Tool<Name, Input, Event, Output, E, R>, "_tag">): Tool<Name, Input, Event, Output, E, R>;
+};
 /**
  * A provider-hosted tool (native web search, code execution, RAG grounding).
  * No local executor — `provider`/`config` drive the provider adapter's
  * rendering. The model sees it; `Toolkit.run` reports it as `non_local_tool`.
  */
-declare const provider: <Name extends string, Input, Provider extends string, Config>(spec: Omit<ProviderTool<Name, Input, Provider, Config>, "_tag">) => ProviderTool<Name, Input, Provider, Config>;
+declare const provider: {
+  <Name extends string, S extends Schema.Codec<any, any, never, any>, Provider extends string, Config>(spec: Omit<ProviderTool<Name, S["Type"], Provider, Config>, "_tag" | "inputSchema"> & {
+    readonly inputSchema: S;
+  }): ProviderTool<Name, S["Type"], Provider, Config>;
+  <Name extends string, Input, Provider extends string, Config>(spec: Omit<ProviderTool<Name, Input, Provider, Config>, "_tag">): ProviderTool<Name, Input, Provider, Config>;
+};
 /**
  * A typed control-flow signal to the agent loop (escalate, pause, schedule,
  * hand off). Decode-only: the loop interprets the call rather than executing a
  * handler, so there is no `run`.
  */
-declare const signal: <Name extends string, Input>(spec: Omit<SignalTool<Name, Input>, "_tag">) => SignalTool<Name, Input>;
+declare const signal: {
+  <Name extends string, S extends Schema.Codec<any, any, never, any>>(spec: Omit<SignalTool<Name, S["Type"]>, "_tag" | "inputSchema"> & {
+    readonly inputSchema: S;
+  }): SignalTool<Name, S["Type"]>;
+  <Name extends string, Input>(spec: Omit<SignalTool<Name, Input>, "_tag">): SignalTool<Name, Input>;
+};
 /**
  * A typed request for an external actor to respond before the loop resumes
  * (frontend, Telegram, CLI prompt). Decode-only; the loop stops/pauses and
  * resumes by appending the actor's `function_call_output`.
  */
-declare const interaction: <Name extends string, Input>(spec: Omit<InteractionTool<Name, Input>, "_tag">) => InteractionTool<Name, Input>;
+declare const interaction: {
+  <Name extends string, S extends Schema.Codec<any, any, never, any>>(spec: Omit<InteractionTool<Name, S["Type"]>, "_tag" | "inputSchema"> & {
+    readonly inputSchema: S;
+  }): InteractionTool<Name, S["Type"]>;
+  <Name extends string, Input>(spec: Omit<InteractionTool<Name, Input>, "_tag">): InteractionTool<Name, Input>;
+};
 /**
  * Return a copy of a tool under a new `name`. Useful for resolving a name
  * clash before combining tools into one `Toolkit`. Literal-preserving, so the
@@ -199,8 +251,21 @@ declare const withName: <N extends string, T extends AnyTool>(tool: T, name: N)
  * Descriptors stay identical to production, so a mocked toolkit can't drift
  * from the contract the model sees.
  */
-declare const withRun: <Name extends string, Input, Event, Output, R, Output2, R2 = never>(tool: Tool<Name, Input, Event, Output, R>, run: (input: Input, emit: Emit<Event>) => Effect.Effect<Output2, unknown, R2>) => Tool<Name, Input, Event, Output2, R2>;
-/** Render tools to provider-agnostic descriptors. Every kind is model-visible. */
+declare const withRun: <Name extends string, Input, Event, Output, E, R, Output2, E2 = never, R2 = never>(tool: Tool<Name, Input, Event, Output, E, R>, run: (input: Input, emit: Emit<Event>) => Effect.Effect<Output2, E2, R2>) => Tool<Name, Input, Event, Output2, E2, R2>;
+/** True for provider-hosted tools — the kind a provider renders natively. */
+declare const isProviderTool: (tool: AnyTool) => tool is ProviderTool<string, any, string, any>;
+/**
+ * The `ProviderTool`s in a toolkit, for a provider adapter to render as its
+ * native hosted-tool entries (web search, code execution, grounding). The other
+ * kinds render as function declarations via `descriptorsOf`.
+ */
+declare const providerToolsOf: (toolkit?: Readonly<Record<string, AnyTool>>) => ReadonlyArray<ProviderTool<string, any, string, any>>;
+/**
+ * Render tools to provider-agnostic descriptors. `ProviderTool`s are excluded:
+ * they are provider-hosted and must never leak into the function-declaration
+ * list — each adapter renders them natively via `providerToolsOf`. Every other
+ * kind is model-visible as a declaration.
+ */
 declare const toDescriptors: (tools: ReadonlyArray<AnyTool>) => ReadonlyArray<ToolDescriptor>;
 /**
  * Render a `Toolkit` (a name-indexed record of tools) to descriptors, treating
@@ -210,6 +275,26 @@ declare const toDescriptors: (tools: ReadonlyArray<AnyTool>) => ReadonlyArray<To
  * free of a dependency on the toolkit module — it only needs the tool values.
  */
 declare const descriptorsOf: (toolkit?: Readonly<Record<string, AnyTool>>) => ReadonlyArray<ToolDescriptor>;
+/**
+ * Outcome of decoding a call's `arguments` against a tool's `inputSchema`,
+ * as data so both the typed (`decodeArgs`) and result-synthesizing
+ * (`Toolkit.run`) callers can translate it their own way.
+ */
+type DecodeResult<Input> = {
+  readonly _tag: "ok";
+  readonly input: Input;
+} | {
+  readonly _tag: "parseError";
+} | {
+  readonly _tag: "invalid";
+  readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
+};
+/**
+ * Parse and validate a call's `arguments`. Empty arguments normalize to
+ * `{}` (some models emit `""` for zero-arg tools); a throwing validator is
+ * captured, not propagated. Never fails.
+ */
+declare const decodeCallInput: <Input>(tool: DecodableTool<Input>, call: ToolCall) => Effect.Effect<DecodeResult<Input>>;
 /**
  * Decode and validate a function_call's JSON `arguments` against the tool's
  * own `inputSchema`, yielding the typed input. The decode-only half of
@@ -226,7 +311,7 @@ declare const decodeArgs: <Input>(tool: DecodableTool<Input>, call: ToolCall) =>
  * function_call_output item. Single-shot: intermediate events emitted by
  * `run` are discarded (use `Toolkit.run` to stream them).
  */
-declare const execute: <Name extends string, Input, Event, Output, R>(tool: Tool<Name, Input, Event, Output, R>, call: ToolCall) => Effect.Effect<ToolCallOutput, ToolError | ToolValidationError, R>;
+declare const execute: <Name extends string, Input, Event, Output, E, R>(tool: Tool<Name, Input, Event, Output, E, R>, call: ToolCall) => Effect.Effect<ToolCallOutput, E | ToolError | ToolValidationError, R>;
 //#endregion
-export { signal as C, withRun as E, provider as S, withName as T, execute as _, InteractionTool as a, interaction as b, Tool as c, ToolInputSchema as d, ToolR as f, descriptorsOf as g, decodeArgs as h, Emit as i, ToolDescriptor as l, Tool_d_exports as m, AnyTool as n, ProviderTool as o, ToolValidationError as p, DecodableTool as r, SignalTool as s, AnyLocalTool as t, ToolError as u, fromEffectSchema as v, toDescriptors as w, make as x, fromStandardSchema as y };
-//# sourceMappingURL=Tool-0XUIT2A2.d.mts.map
+export { providerToolsOf as A, fromEffectSchema as C, make as D, isProviderTool as E, toDescriptors as M, withName as N, noInput as O, withRun as P, fail as S, interaction as T, Tool_d_exports as _, Emit as a, descriptorsOf as b, SignalTool as c, ToolE as d, ToolError as f, ToolValidationError as g, ToolR as h, DecodeResult as i, signal as j, provider as k, Tool as l, ToolInputSchema as m, AnyTool as n, InteractionTool as o, ToolFailed as p, DecodableTool as r, ProviderTool as s, AnyLocalTool as t, ToolDescriptor as u, decodeArgs as v, fromStandardSchema as w, execute as x, decodeCallInput as y };
+//# sourceMappingURL=Tool-CXFHCQrT.d.mts.map

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

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

package/dist/{ToolEvent-DYrAUJGs.d.mts → ToolEvent-nVijCrvm.d.mts}

@@ -1,4 +1,4 @@
-import { t as ToolResult } from "./ToolResult-BZd-cEWW.mjs";
+import { t as ToolResult } from "./ToolResult-CQqKkcDa.mjs";
 import { Data } from "effect";
 import * as _$effect_Unify0 from "effect/Unify";
 
@@ -148,4 +148,4 @@ declare const isOutput: (u: unknown) => u is {
 };
 //#endregion
 export { isProgress as a, isOutput as i, ToolEvent_d_exports as n, isApprovalRequested as r, ToolEvent as t };
-//# sourceMappingURL=ToolEvent-DYrAUJGs.d.mts.map
+//# sourceMappingURL=ToolEvent-nVijCrvm.d.mts.map

package/dist/ToolEvent-nVijCrvm.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ToolEvent-nVijCrvm.d.mts","names":[],"sources":["../src/tool/ToolEvent.ts"],"mappings":";;;;;;;;KAkBY,SAAA,GAAY,IAAA,CAAK,UAAA;EAC3B,iBAAA;IAAA,SACW,OAAA;IAAA,SACA,IAAA;IAAA,SACA,SAAA;EAAA;EAEX,QAAA;IAAA,SACW,OAAA;IAAA,SACA,IAAA;IAAA,SACA,IAAA;EAAA;EAEX,MAAA;IAAA,SACW,MAAA,EAAQ,UAAA;EAAA;AAAA;;;;;;;;cAWR,SAAA;EAAA;;;;;;;;;;;;;;qBAXQ,UAAA;EAAA;EAAA;;;;;;;;;;;;;;;;qBAAA,UAAA;EAAA;IAAA;;;;;;;;;;;;;;;;;;yBAAA,UAAA;MAAA;IAAA;;;;;;;;;;;;uBAAA,UAAA;IAAA;;;;;;;;;;;;;;;;yBAAA,UAAA;MAAA;IAAA;;;;;;;;;;;;uBAAA,UAAA;IAAA;;;cAaR,mBAAA,GAAmB,CAAA,cAAA,CAAA;EAAA;;;;;cACnB,UAAA,GAAU,CAAA,cAAA,CAAA;EAAA;;;;;cACV,QAAA,GAAQ,CAAA,cAAA,CAAA;EAAA;mBAfA,UAAA;AAAA"}

package/dist/{ToolResult-BZd-cEWW.d.mts → ToolResult-CQqKkcDa.d.mts}

@@ -1,10 +1,10 @@
-import { v as ToolCall, y as ToolCallOutput } from "./Items-CgKD6Npw.mjs";
+import { v as ToolCall, y as ToolCallOutput } from "./Items-BWNu6VGp.mjs";
 import { Data } from "effect";
 import * as _$effect_Unify0 from "effect/Unify";
 
 //#region src/tool/ToolResult.d.ts
 declare namespace ToolResult_d_exports {
-  export { ToolResult, cancelled, denied, executionError, failed, isFailure, isOk, nonLocalTool, toToolCallOutput, validationError };
+  export { ToolResult, cancelled, denied, executionError, failed, isFailure, isOk, nonLocalTool, serializeValue, toToolCallOutput, validationError };
 }
 type ToolResult = Data.TaggedEnum<{
   Ok: {
@@ -145,7 +145,13 @@ declare const nonLocalTool: (call: ToolCall, reason?: string) => ToolResult;
  * runtime crash.
  */
 declare const validationError: (call: ToolCall, reason?: string) => ToolResult;
+/**
+ * Serialize a success value for the wire. A `string` passes through raw
+ * (models read plain text best; JSON.stringify would quote and escape it);
+ * `undefined` becomes `"null"`; anything else is JSON.
+ */
+declare const serializeValue: (value: unknown) => string;
 declare const toToolCallOutput: (r: ToolResult) => ToolCallOutput;
 //#endregion
-export { executionError as a, isOk as c, validationError as d, denied as i, nonLocalTool as l, ToolResult_d_exports as n, failed as o, cancelled as r, isFailure as s, ToolResult as t, toToolCallOutput as u };
-//# sourceMappingURL=ToolResult-BZd-cEWW.d.mts.map
+export { executionError as a, isOk as c, toToolCallOutput as d, validationError as f, denied as i, nonLocalTool as l, ToolResult_d_exports as n, failed as o, cancelled as r, isFailure as s, ToolResult as t, serializeValue as u };
+//# sourceMappingURL=ToolResult-CQqKkcDa.d.mts.map

package/dist/ToolResult-CQqKkcDa.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ToolResult-CQqKkcDa.d.mts","names":[],"sources":["../src/tool/ToolResult.ts"],"mappings":";;;;;;;;KAqBY,UAAA,GAAa,IAAA,CAAK,UAAA;EAC5B,EAAA;IAAA,SACW,OAAA;IAAA,SACA,IAAA;IAAA,SACA,KAAA;EAAA;EAEX,OAAA;IAAA,SACW,OAAA;IAAA,SACA,IAAA;IAAA,SACA,IAAA;IAAA,SACA,MAAA;EAAA;AAAA;;;;;;;;;cAYA,UAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAEA,IAAA,GAAI,CAAA,cAAA,CAAA;EAAA;;;;;cACJ,SAAA,GAAS,CAAA,cAAA,CAAA;EAAA;;;;;;cAMT,MAAA,GAAU,IAAA,EAAM,QAAA,EAAU,IAAA,UAAc,MAAA,cAAkB,UAAA;;cAS1D,MAAA,GAAU,IAAA,EAAM,QAAA,EAAU,MAAA,cAAkB,UAAA;;cAI5C,SAAA,GAAa,IAAA,EAAM,QAAA,EAAU,MAAA,cAAkB,UAAA;;cAI/C,cAAA,GAAkB,IAAA,EAAM,QAAA,EAAU,MAAA,aAAiB,UAAA;;;;;;;cASnD,YAAA,GAAgB,IAAA,EAAM,QAAA,EAAU,MAAA,cAAkB,UAAA;;;;;;cAYlD,eAAA,GAAmB,IAAA,EAAM,QAAA,EAAU,MAAA,cAAkB,UAAA;;AA7ClE;;;;cAyDa,cAAA,GAAkB,KAAA;AAAA,cAOlB,gBAAA,GAAoB,CAAA,EAAG,UAAA,KAAa,cAAA"}

package/dist/{Toolkit-BKC8b8Xo.d.mts → Toolkit-BYPwwu-j.d.mts}

@@ -1,15 +1,15 @@
-import { o as HistoryItem, v as ToolCall } from "./Items-CgKD6Npw.mjs";
+import { o as HistoryItem, v as ToolCall } from "./Items-BWNu6VGp.mjs";
+import { a as Emit, c as SignalTool, d as ToolE, h as ToolR, l as Tool, n as AnyTool, o as InteractionTool, p as ToolFailed, s as ProviderTool, u as ToolDescriptor } from "./Tool-CXFHCQrT.mjs";
 import { Turn } from "./domain/Turn.mjs";
-import { r as Step } from "./Loop-B5_cqumi.mjs";
-import { a as InteractionTool, c as Tool, f as ToolR, i as Emit, l as ToolDescriptor, n as AnyTool, o as ProviderTool, s as SignalTool } from "./Tool-0XUIT2A2.mjs";
-import { t as ToolResult } from "./ToolResult-BZd-cEWW.mjs";
-import { t as ToolEvent } from "./ToolEvent-DYrAUJGs.mjs";
+import { r as Step } from "./Loop-D8nWpowc.mjs";
+import { t as ToolResult } from "./ToolResult-CQqKkcDa.mjs";
+import { t as ToolEvent } from "./ToolEvent-nVijCrvm.mjs";
 import { Cause, Effect, Stream } from "effect";
 import * as _$effect_Types0 from "effect/Types";
 
 //#region src/tool/Toolkit.d.ts
 declare namespace Toolkit_d_exports {
-  export { DuplicateToolName, ExecuteOptions, Middleware, NoDuplicateNames, ToolMap, Toolkit, ToolkitR, UniqueTools, appendToolResults, collectResults, compose, continueWithResults, descriptors, fromArray, make, makeNamespaced, namespace, run, wrap };
+  export { DuplicateToolName, ExecuteOptions, Middleware, NoDuplicateNames, ToolMap, Toolkit, ToolkitE, ToolkitR, UniqueTools, appendToolResults, collectResults, compose, continueWithResults, describeFailures, descriptors, fromArray, make, makeNamespaced, namespace, run, wrap };
 }
 type ToolMap = Record<string, AnyTool>;
 type Toolkit<Tools extends ToolMap = ToolMap> = Tools;
@@ -33,6 +33,14 @@ declare const descriptors: (toolkit: Toolkit) => ReadonlyArray<ToolDescriptor>;
  * resulting stream's `R`. Concrete toolkits from `make` keep their precise R.
  */
 type ToolkitR<T extends Toolkit> = ToolMap extends T ? never : ToolR<T[keyof T]>;
+/**
+ * Union of every tool's `E` error type in a toolkit. `Toolkit.run` reports
+ * `Exclude<ToolkitE<T>, string | ToolFailed>` on its stream: the sentinel
+ * failures are absorbed into results, everything else propagates typed. The
+ * same `ToolMap extends T` guard as `ToolkitR` keeps a wide toolkit at
+ * `never` rather than `any`.
+ */
+type ToolkitE<T extends Toolkit> = ToolMap extends T ? never : ToolE<T[keyof T]>;
 type DuplicateName<Tools extends ReadonlyArray<AnyTool>, Seen extends string = never> = Tools extends readonly [infer Head extends AnyTool, ...infer Tail extends ReadonlyArray<AnyTool>] ? Head["name"] extends Seen ? Head["name"] : DuplicateName<Tail, Seen | Head["name"]> : never;
 type DuplicateNameError<Name extends string> = {
   readonly __error: `Duplicate tool name: ${Name}`;
@@ -58,7 +66,7 @@ declare class DuplicateToolName extends DuplicateToolName_base<{
   readonly sources: ReadonlyArray<string>;
 }> {}
 type PrefixName<Prefix extends string, Name extends string> = `${Prefix}__${Name}`;
-type PrefixTool<Prefix extends string, T extends AnyTool> = T extends Tool<infer N, infer I, infer Ev, infer O, infer R> ? Tool<PrefixName<Prefix, N>, I, Ev, O, R> : T extends ProviderTool<infer N, infer I, infer P, infer C> ? ProviderTool<PrefixName<Prefix, N>, I, P, C> : T extends SignalTool<infer N, infer I> ? SignalTool<PrefixName<Prefix, N>, I> : T extends InteractionTool<infer N, infer I> ? InteractionTool<PrefixName<Prefix, N>, I> : T;
+type PrefixTool<Prefix extends string, T extends AnyTool> = T extends Tool<infer N, infer I, infer Ev, infer O, infer E, infer R> ? Tool<PrefixName<Prefix, N>, I, Ev, O, E, R> : T extends ProviderTool<infer N, infer I, infer P, infer C> ? ProviderTool<PrefixName<Prefix, N>, I, P, C> : T extends SignalTool<infer N, infer I> ? SignalTool<PrefixName<Prefix, N>, I> : T extends InteractionTool<infer N, infer I> ? InteractionTool<PrefixName<Prefix, N>, I> : T;
 type Namespaced<Prefix extends string, T extends ToolMap> = { readonly [K in keyof T & string as PrefixName<Prefix, K>]: T[K] extends AnyTool ? PrefixTool<Prefix, T[K]> : never };
 /**
  * Prefix every tool name with `<namespace>__`, returning a new toolkit. Use it
@@ -77,32 +85,65 @@ declare const makeNamespaced: <const Prefix extends string, const Tools extends
  * provider. Statically-known collisions are additionally a compile error.
  */
 declare const compose: <const Kits extends ReadonlyArray<Toolkit>>(...toolkits: Kits & NoDuplicateComposedKeys<Kits>) => Effect.Effect<Toolkit<Composed<Kits>>, DuplicateToolName>;
-type Handler<Input, Event, Output, R> = (input: Input, emit: Emit<Event>) => Effect.Effect<Output, unknown, R>;
-type Middleware<R2 = never> = <Input, Event, Output, R>(run: Handler<Input, Event, Output, R>, name: string) => Handler<Input, Event, Output, R | R2>;
-type WrapTool<T extends AnyTool, R2> = T extends Tool<infer N, infer I, infer Ev, infer O, infer R> ? Tool<N, I, Ev, O, R | R2> : T;
-type WrapToolkit<T extends ToolMap, R2> = { readonly [K in keyof T]: T[K] extends AnyTool ? WrapTool<T[K], R2> : T[K] };
+type Handler<Input, Event, Output, E, R> = (input: Input, emit: Emit<Event>) => Effect.Effect<Output, E, R>;
+/**
+ * A `run` transform, tracking an added requirement `R2` and optional added
+ * error `E2`. The tool's own `E` is preserved; `describeFailures` is the
+ * combinator that *replaces* it (mapping every error to `string`).
+ */
+type Middleware<R2 = never, E2 = never> = <Input, Event, Output, E, R>(run: Handler<Input, Event, Output, E, R>, name: string) => Handler<Input, Event, Output, E | E2, R | R2>;
+type WrapTool<T extends AnyTool, R2, E2> = T extends Tool<infer N, infer I, infer Ev, infer O, infer E, infer R> ? Tool<N, I, Ev, O, E | E2, R | R2> : T;
+type WrapToolkit<T extends ToolMap, R2, E2> = { readonly [K in keyof T]: T[K] extends AnyTool ? WrapTool<T[K], R2, E2> : T[K] };
 /**
  * Wrap every local tool's `run` with a middleware, preserving each tool's
  * `Input`/`Output` and unioning the middleware's requirement `R2` into the
  * toolkit's `ToolkitR`. Non-local kinds pass through unchanged. Stack with
- * `pipe`:
+ * `pipe` - inner-first, so the last `wrap` applied is the outermost and runs
+ * first:
  *
  *   const observed = pipe(toolkit, Toolkit.wrap(logging), Toolkit.wrap(authz))
- *   Toolkit.run(observed, calls) // R = ToolkitR<typeof toolkit> | <authz R>
+ *   Toolkit.run(observed, calls) // authz runs, then logging, then the tool
  *
- * A middleware that `Effect.fail`s surfaces as a `ToolResult.Failure` from the
- * executor like any run failure; use the `Approval` flow for a distinct
- * "denied" verdict.
+ * A middleware that fails with `string` / `ToolFailed` is absorbed by the
+ * executor into a `ToolResult.Failure`; any other error propagates typed. Use
+ * `describeFailures` for the total "everything to the model" case, or the
+ * `Approval` flow for a distinct "denied" verdict.
  */
 declare const wrap: {
-  <R2>(middleware: Middleware<R2>): <T extends Toolkit>(toolkit: T) => WrapToolkit<T, R2>;
-  <T extends Toolkit, R2>(toolkit: T, middleware: Middleware<R2>): WrapToolkit<T, R2>;
+  <R2, E2>(middleware: Middleware<R2, E2>): <T extends Toolkit>(toolkit: T) => WrapToolkit<T, R2, E2>;
+  <T extends Toolkit, R2, E2>(toolkit: T, middleware: Middleware<R2, E2>): WrapToolkit<T, R2, E2>;
+};
+type DescribeTool<T extends AnyTool> = T extends Tool<infer N, infer I, infer Ev, infer O, any, infer R> ? Tool<N, I, Ev, O, string, R> : T;
+type DescribeToolkit<T extends ToolMap> = { readonly [K in keyof T]: T[K] extends AnyTool ? DescribeTool<T[K]> : T[K] };
+/**
+ * Map every local tool's error to a `string`, so `Toolkit.run` absorbs those
+ * failures into `ToolResult.Failure` the model reads and adapts to. Pairs
+ * with the domain `describe` helpers (`AiError.describe`,
+ * `BrowserError.describe`). Non-local kinds pass through.
+ *
+ *   const kit = yield* Toolkit.compose(
+ *     Toolkit.describeFailures(searchKit, AiError.describe),
+ *     browserToolkit(session), // failures stay typed
+ *   )
+ */
+declare const describeFailures: {
+  <E>(describe: (e: E) => string): <T extends Toolkit>(toolkit: T) => DescribeToolkit<T>;
+  <T extends Toolkit>(toolkit: T, describe: (e: ToolkitE<T>) => string): DescribeToolkit<T>;
 };
 type ExecuteOptions = {
   readonly concurrency?: number | "unbounded";
 };
-/** Execute every provided call. Approval/rejection policy belongs upstream. */
-declare const run: <T extends Toolkit>(toolkit: T, calls: ReadonlyArray<ToolCall>, options?: ExecuteOptions) => Stream.Stream<ToolEvent, never, ToolkitR<T>>;
+/**
+ * Execute every provided call. Approval/rejection policy belongs upstream.
+ *
+ * String and `ToolFailed` failures are absorbed into `ToolResult.Failure`
+ * (the model reads and adapts to them); every other tool error propagates
+ * typed on the stream, so `Exclude<ToolkitE<T>, string | ToolFailed>` is
+ * what a caller catches or lets end the run. If one call in a concurrent
+ * batch fails the stream, siblings may go unanswered: a loop that catches
+ * and continues must reconcile history first (`HistoryCheck.cancelAllPending`).
+ */
+declare const run: <T extends Toolkit>(toolkit: T, calls: ReadonlyArray<ToolCall>, options?: ExecuteOptions) => Stream.Stream<ToolEvent, Exclude<ToolkitE<T>, string | ToolFailed>, ToolkitR<T>>;
 /**
  * Append a completed turn plus tool results to a state's history, converting
  * the results to wire-format `ToolCallOutput`s. Curried so it slots directly
@@ -147,9 +188,9 @@ declare const collectResults: <E, R>(stream: Stream.Stream<ToolEvent, E, R>) =>
  * `stream.pipe(continueWithResults(build))` both work.
  */
 declare const continueWithResults: {
-  <S>(build: (results: ReadonlyArray<ToolResult>) => S): <R>(stream: Stream.Stream<ToolEvent, never, R>) => Stream.Stream<Step<ToolEvent, S>, never, R>;
-  <S, R>(stream: Stream.Stream<ToolEvent, never, R>, build: (results: ReadonlyArray<ToolResult>) => S): Stream.Stream<Step<ToolEvent, S>, never, R>;
+  <S>(build: (results: ReadonlyArray<ToolResult>) => S): <E, R>(stream: Stream.Stream<ToolEvent, E, R>) => Stream.Stream<Step<ToolEvent, S>, E, R>;
+  <S, E, R>(stream: Stream.Stream<ToolEvent, E, R>, build: (results: ReadonlyArray<ToolResult>) => S): Stream.Stream<Step<ToolEvent, S>, E, R>;
 };
 //#endregion
-export { makeNamespaced as _, ToolMap as a, wrap as b, Toolkit_d_exports as c, collectResults as d, compose as f, make as g, fromArray as h, NoDuplicateNames as i, UniqueTools as l, descriptors as m, ExecuteOptions as n, Toolkit as o, continueWithResults as p, Middleware as r, ToolkitR as s, DuplicateToolName as t, appendToolResults as u, namespace as v, run as y };
-//# sourceMappingURL=Toolkit-BKC8b8Xo.d.mts.map
+export { wrap as S, fromArray as _, ToolMap as a, namespace as b, ToolkitR as c, appendToolResults as d, collectResults as f, descriptors as g, describeFailures as h, NoDuplicateNames as i, Toolkit_d_exports as l, continueWithResults as m, ExecuteOptions as n, Toolkit as o, compose as p, Middleware as r, ToolkitE as s, DuplicateToolName as t, UniqueTools as u, make as v, run as x, makeNamespaced as y };
+//# sourceMappingURL=Toolkit-BYPwwu-j.d.mts.map

package/dist/Toolkit-BYPwwu-j.d.mts.map

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

package/dist/browser/Browser.d.mts

@@ -0,0 +1,190 @@
+import { BrowserError } from "./BrowserError.mjs";
+import { Brand, Context, Duration, Effect, Scope } from "effect";
+
+//#region src/browser/Browser.d.ts
+declare namespace Browser_d_exports {
+  export { AxNode, BoundingBox, Browser, BrowserService, BrowserSession, BrowserSessionId, BrowserSessionRef, CommonSessionRequest, Cookie, CookieApi, ElementInfo, PageFormat, ScreenshotOptions, ScrollDirection, ScrollOptions, attach, create, destroy, list };
+}
+/**
+ * Session identifier. Branded `string` so providers don't accidentally
+ * accept a raw user-supplied id, and so a session id can't be passed where
+ * another service's id is expected. Each provider mints these per its own
+ * scheme; core code treats them opaquely. Mint via `BrowserSessionId(...)`.
+ */
+type BrowserSessionId = Brand.Branded<string, "BrowserSessionId">;
+declare const BrowserSessionId: Brand.Constructor<BrowserSessionId>;
+/** Reference returned by `list`; enough to `attach`. */
+type BrowserSessionRef = {
+  readonly id: BrowserSessionId; /** Current top-level URL, when the provider reports it. */
+  readonly url?: string;
+};
+/**
+ * Output representation for {@link BrowserSession.content}. `markdown` is
+ * the default.
+ */
+type PageFormat = "markdown" | "html";
+/**
+ * Cross-provider session-create request. Provider-specific knobs (proxy,
+ * stealth, persistent profile, ...) live on each provider's narrowed
+ * request type which extends this.
+ */
+type CommonSessionRequest = {
+  /**
+   * Hard max lifetime of the session. Enforced locally (the handle is
+   * disposed and further calls fail with `BrowserSessionExpired`) and,
+   * where the provider supports it, passed through as a server-side cap so
+   * a crashed client still gets the session reclaimed. The provider cap
+   * must be >= the local reaper. Accepts millis, a string like
+   * `"5 minutes"`, or a `Duration`.
+   */
+  readonly timeout?: Duration.Input;
+  /**
+   * Idle teardown: dispose the session after this much inactivity, the
+   * timer resetting on each operation. Opt-in; omit for no idle limit.
+   */
+  readonly idleTimeout?: Duration.Input; /** Initial viewport size. Providers default differently. */
+  readonly viewport?: {
+    readonly width: number;
+    readonly height: number;
+  };
+};
+type BoundingBox = {
+  readonly x: number;
+  readonly y: number;
+  readonly width: number;
+  readonly height: number;
+};
+/**
+ * One element returned by {@link BrowserSession.query}. Serializable data,
+ * not a live handle (handles go stale across navigation and do not cross a
+ * provider boundary cleanly).
+ */
+type ElementInfo = {
+  /**
+   * Reference usable as a selector for a follow-up action. Valid until the
+   * next navigation; do not cache across `goto` or a page-changing click.
+   */
+  readonly ref: string;
+  readonly tag: string;
+  readonly text?: string;
+  readonly attributes: Readonly<Record<string, string>>;
+  readonly box?: BoundingBox;
+};
+/** Accessibility-tree node returned by {@link BrowserSession.snapshot}. */
+type AxNode = {
+  readonly role: string;
+  readonly name?: string;
+  readonly value?: string;
+  /**
+   * Reference usable as a selector for a follow-up action. Valid until the
+   * next navigation; do not cache across `goto` or a page-changing click.
+   */
+  readonly ref?: string;
+  readonly children: ReadonlyArray<AxNode>;
+};
+type ScrollDirection = "up" | "down" | "left" | "right";
+type ScrollOptions = {
+  readonly direction: ScrollDirection; /** Distance in CSS pixels. Provider default applies when omitted. */
+  readonly pixels?: number;
+};
+type ScreenshotOptions = {
+  /** Clip to the first element matching this selector. */readonly selector?: string; /** Capture the full scrollable page rather than the viewport. */
+  readonly fullPage?: boolean;
+};
+type Cookie = {
+  readonly name: string;
+  readonly value: string;
+  readonly domain?: string;
+  readonly path?: string;
+  readonly expires?: number;
+  readonly httpOnly?: boolean;
+  readonly secure?: boolean;
+  readonly sameSite?: "Strict" | "Lax" | "None";
+};
+/** Read / write the session's cookie jar. Needed for authenticated flows. */
+type CookieApi = {
+  readonly get: Effect.Effect<ReadonlyArray<Cookie>, BrowserError>;
+  readonly set: (cookies: ReadonlyArray<Cookie>) => Effect.Effect<void, BrowserError>;
+};
+/**
+ * Live session handle. Actions take a CSS selector string (so `#id` is
+ * just `#id`). Methods are plain `Effect` values; disposal is the scope
+ * finalizer, not a method here (see {@link BrowserService}). Anything not
+ * covered by a verb is reachable via `evaluate`. Per-operation time budgets
+ * are the provider's default; wrap any call in `Effect.timeout` for a
+ * tighter bound.
+ */
+type BrowserSession = {
+  readonly id: BrowserSessionId;
+  readonly goto: (url: string) => Effect.Effect<void, BrowserError>;
+  readonly waitFor: (selector: string) => Effect.Effect<void, BrowserError>;
+  readonly click: (selector: string) => Effect.Effect<void, BrowserError>;
+  readonly dblclick: (selector: string) => Effect.Effect<void, BrowserError>;
+  readonly fill: (selector: string, text: string) => Effect.Effect<void, BrowserError>;
+  readonly type: (selector: string, text: string) => Effect.Effect<void, BrowserError>;
+  readonly press: (key: string) => Effect.Effect<void, BrowserError>;
+  readonly hover: (selector: string) => Effect.Effect<void, BrowserError>;
+  readonly focus: (selector: string) => Effect.Effect<void, BrowserError>;
+  readonly select: (selector: string, value: string) => Effect.Effect<void, BrowserError>;
+  readonly check: (selector: string) => Effect.Effect<void, BrowserError>;
+  readonly uncheck: (selector: string) => Effect.Effect<void, BrowserError>;
+  readonly scroll: (options: ScrollOptions) => Effect.Effect<void, BrowserError>;
+  readonly scrollIntoView: (selector: string) => Effect.Effect<void, BrowserError>;
+  readonly content: (format?: PageFormat) => Effect.Effect<string, BrowserError>;
+  readonly screenshot: (options?: ScreenshotOptions) => Effect.Effect<Uint8Array, BrowserError>;
+  readonly snapshot: Effect.Effect<AxNode, BrowserError>;
+  readonly query: (selector: string) => Effect.Effect<ReadonlyArray<ElementInfo>, BrowserError>;
+  readonly cookies: CookieApi;
+  readonly evaluate: (script: string) => Effect.Effect<unknown, BrowserError>;
+};
+/**
+ * Cross-provider browser service.
+ *
+ * Lifetime: `create` and `attach` return a handle in `Scope.Scope`. The
+ * scope finalizer disposes the session (close the transport, destroy or
+ * detach the remote session, kill the local engine). Bind with
+ * `Effect.scoped` for a single call, or hold a wider scope to keep a
+ * session warm across many calls. This is why there is no `dispose()` on
+ * {@link BrowserSession}; the scope is the lifecycle handle.
+ */
+type BrowserService = {
+  /**
+   * Provision a new session, bound to the caller's scope. Disposed on
+   * scope close.
+   */
+  readonly create: (request: CommonSessionRequest) => Effect.Effect<BrowserSession, BrowserError, Scope.Scope>;
+  /**
+   * Re-acquire an existing session by id. Scope-bound, but the finalizer
+   * detaches rather than destroying, for sessions kept warm beyond a
+   * single run.
+   */
+  readonly attach: (id: BrowserSessionId) => Effect.Effect<BrowserSession, BrowserError, Scope.Scope>; /** Enumerate sessions visible to the configured account / project. */
+  readonly list: Effect.Effect<ReadonlyArray<BrowserSessionRef>, BrowserError>;
+  /**
+   * Destroy a session from outside its owning scope. Most callers should
+   * let the scope finalizer handle this.
+   */
+  readonly destroy: (id: BrowserSessionId) => Effect.Effect<void, BrowserError>;
+};
+declare const Browser_base: Context.ServiceClass<Browser, "@betalyra/effect-uai/Browser", BrowserService>;
+declare class Browser extends Browser_base {}
+/**
+ * Provision a session bound to the caller's scope. Drop the `Scope.Scope`
+ * requirement with `Effect.scoped`.
+ */
+declare const create: (request: CommonSessionRequest) => Effect.Effect<BrowserSession, BrowserError, Browser | Scope.Scope>;
+/**
+ * Re-acquire an existing session by id. Same scope semantics as `create`,
+ * but the finalizer detaches rather than destroying.
+ */
+declare const attach: (id: BrowserSessionId) => Effect.Effect<BrowserSession, BrowserError, Browser | Scope.Scope>;
+/** Enumerate sessions for the configured account / project. */
+declare const list: Effect.Effect<ReadonlyArray<BrowserSessionRef>, BrowserError, Browser>;
+/**
+ * Destroy a session from outside its owning scope. Most callers should let
+ * the scope finalizer handle this automatically.
+ */
+declare const destroy: (id: BrowserSessionId) => Effect.Effect<void, BrowserError, Browser>;
+//#endregion
+export { AxNode, BoundingBox, Browser, BrowserService, BrowserSession, BrowserSessionId, BrowserSessionRef, CommonSessionRequest, Cookie, CookieApi, ElementInfo, PageFormat, ScreenshotOptions, ScrollDirection, ScrollOptions, attach, create, destroy, list, Browser_d_exports as t };
+//# sourceMappingURL=Browser.d.mts.map

package/dist/browser/Browser.d.mts.map

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