@effect-uai/core 0.17.0 → 0.19.0-dev-20261109183959

package/src/web-read/WebReadTool.ts

@@ -65,7 +65,7 @@ export type WebReadToolOptions = {
  */
 export const webReadTool = (
   options?: WebReadToolOptions,
-): Tool.Tool<string, WebReadToolArgs, never, string, AiError.AiError, WebRead> => {
+): Tool.Tool<string, WebReadToolArgs, string, never, AiError.AiError, WebRead> => {
   const name = options?.name ?? "web_read"
   const format = options?.format ?? "markdown"
   const maxChars = options?.maxChars ?? 20_000
@@ -75,6 +75,7 @@ export const webReadTool = (
     description:
       "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).",
     inputSchema: Tool.fromEffectSchema(WebReadToolArgs),
+    outputSchema: Schema.String,
     // The call is wrapped in a tracing span so agent traces show the tool
     // invocation (url, format, content length) nested under the model turn.
     // `withSpan` is a no-op until a Tracer is installed, so this is free by

package/src/web-search/WebSearchTool.ts

@@ -72,7 +72,7 @@ export type WebSearchToolOptions = {
  */
 export const webSearchTool = (
   options?: WebSearchToolOptions,
-): Tool.Tool<string, WebSearchToolArgs, never, string, AiError.AiError, WebSearch> => {
+): Tool.Tool<string, WebSearchToolArgs, string, never, AiError.AiError, WebSearch> => {
   const name = options?.name ?? "web_search"
   const render = options?.render ?? defaultRender
   const maxResults = options?.maxResults ?? 5
@@ -83,6 +83,7 @@ export const webSearchTool = (
     description:
       "Search the web for current information. Returns ranked results with titles, URLs, and snippets.",
     inputSchema: Tool.fromEffectSchema(WebSearchToolArgs),
+    outputSchema: Schema.String,
     // The call is wrapped in a tracing span so agent traces show the tool
     // invocation (query, filters, result count) nested under the model turn.
     // `withSpan` is a no-op until a Tracer is installed, so this is free by

package/dist/Image-Cv6iBLTy.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Image-Cv6iBLTy.d.mts","names":[],"sources":["../src/domain/Image.ts"],"mappings":";;;;;;;;;;;;;KAoBY;KAYA,iBAAiB,SAAS;KAC1B,oBAAoB,YAAY;KAChC,mBAAmB,WAAW;;;;;;;;KAS9B,cAAc,YAAY;cAEzB,gBAAc,OAAA;;;;cAKd,mBAAiB,OAAA;;;;cAKjB,kBAAgB,OAAA;;;;cAKhB,aAAa,OAAO,OAAO;cAM3B,WAAQ,aAAe,WAAa,kBAAgB;cAGpD,cAAW,gBAAkB,UAAY,kBAAgB;cAMzD,aAAU,OAAW,YAAU,UAAY,kBAAgB;;;;;;;KAe5D;;;;;;;;;;cAaC,WAAQ;WACV,cAAc;WACd,aAAa;MACpB,OAAO,OAAO;;;;;;;;;;;;KAqBN;;KAGA;WACD,OAAO;;WAEP,YAAY;;WAEZ,eAAe;;cAGb,aAAU,GAAA,OAAA,MAAA,SAAA;;;;;cACV,gBAAa,GAAA,OAAA,MAAA,SAAA;;;;;cACb,eAAY,GAAA,OAAA,MAAA,SAAA"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"Items-C7MyrYPX.d.mts","names":[],"sources":["../src/domain/Items.ts"],"mappings":";;;;;cAOa,WAAS,OAAA;;;;KAIV,mBAAmB,UAAU;;;;;;;;;cAU5B,YAAU,OAAA;;;;KAIX,oBAAoB,WAAW;;;;;;;;;cAgB9B,aAAW,OAAA;;;;;;;;;KASZ,qBAAqB,YAAY;cAEhC,cAAY,OAAA;;;;;KAKb,sBAAsB,aAAa;cAElC,uBAAqB,OAAA;;;;;;;KAOtB,+BAA+B,sBAAsB;cAEpD,UAAQ,OAAA;;;;;KAKT,kBAAkB,SAAS;cAE1B,YAAU,OAAA,gBAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;KACX,oBAAoB,WAAW;cAE9B,gBAAa,GAAA,OAAA,MAAA,SAAA;;;;;;;;;cACb,iBAAc,GAAA,OAAA,MAAA,SAAA;;;;;cACd,0BAAuB,GAAA,OAAA,MAAA,SAAA;;;;;;;cACvB,aAAU,GAAA,OAAA,MAAA,SAAA;;;;;cAEV,YAAU,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;KAKX,oBAAoB,WAAW;;;;;;;;;;;cAY9B,aAAW,OAAA;;;;KAIZ,qBAAqB,YAAY;;;;;;;cAQhC,SAAO,OAAA;;;;KAIR,iBAAiB,QAAQ;cAExB,cAAY,OAAA,gBAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KACb,sBAAsB,aAAa;cAElC,MAAI,OAAA;KACL,cAAc,KAAK;cAqBlB,SAAO,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAMR,iBAAiB,QAAQ;cAExB,UAAQ,OAAA;;;;;;;KAQT,kBAAkB,SAAS;cAE1B,gBAAc,OAAA;;;;;;KAMf,wBAAwB,eAAe;;;;;;;cAQtC,WAAS,OAAA;;;;;;;KAOV,mBAAmB,UAAU;cAE5B,aAAW,OAAA,gBAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KACZ,qBAAqB,YAAY;cAMhC,cAAW,GAAA,OAAA,MAAA,SAAA;;;;cACX,eAAY,GAAA,OAAA,MAAA,SAAA;;;;cACZ,eAAY,GAAA,OAAA,MAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;cACZ,gBAAa,GAAA,OAAA,MAAA,SAAA;;;;cACb,YAAS,GAAA,OAAA,MAAA,SAAA;;;;cAET,YAAS,GAAA,OAAA,MAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cACT,aAAU,GAAA,OAAA,MAAA,SAAA;;;;;;;cACV,mBAAgB,GAAA,OAAA,MAAA,SAAA;;;;;;cAChB,cAAW,GAAA,OAAA,MAAA,SAAA;;;;;;;;;;;;;;;;;;cAiBX,oBAAkB,OAAA;;;;KAInB,4BAA4B,mBAAmB;cAE9C,qBAAmB,OAAA;;;KAGpB,6BAA6B,oBAAoB;cAEhD,OAAK,OAAA;;;;;;;;;;;;KAON,eAAe,MAAM;cAEpB,YAAU,OAAA;KAUX,oBAAoB,WAAW;cAM9B,WAAQ,iBAAmB;cAM3B,aAAU,iBAAmB;cAM7B,gBAAa,iBAAmB;cAMhC,iBAAc,iBAAmB,mBAAmB"}

package/dist/Loop-ChpaO-ya.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Loop-ChpaO-ya.d.mts","names":[],"sources":["../src/loop/Loop.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;KAwDY,KAAK,GAAG,KAAK,KAAK;EAC5B;aAAkB,OAAO;;EACzB;aAAiB,OAAO;;EACxB;EACA;aAAqB,OAAO;;;;;;;;;;;cAiBf,QAAK,GAAA,GAAA;;;;;GAAE,OAAI,GAAA,GAAA;;;;;GAAE,OAAI,GAAA,GAAA;;GAAE,WAAQ,GAAA,GAAA;;;;;;;cAG7B,QAAS,GAAC,GAAK,MAAI,KAAK;;;;;;cAOxB,OAAQ,GAAC,OAAS,MAAI,OAAO,OAAO,YAAY;;;;;;;;cAUhD,OAAQ,WAAS,QAAU,MAAI,OAAO,OAAO,YAAY;;;;;;;;;;;;;;;;;;;;;;;;KA8BjE,iBAAiB,GAAG,GAAG,IAAI,MAC5B,OAAO,OAAO,KAAK,GAAG,IAAI,IAAI,MAC9B,OAAO,OAAO,OAAO,OAAO,KAAK,GAAG,IAAI,IAAI,KAAK,IAAI;cAE5C;GACV,GAAG,GAAG,YAAY,YACjB,OAAO,MAAM,SAAS,iBAAiB,GAAG,GAAG,IAAI,OAC/C,GAAG,GACL,QAAQ,OAAO,OAAO,WAAW,GAAG,OACjC,OAAO,OAAO,KAAK,YAAY,GAAG,IAAI,IAAI,KAAK,gBAAgB,IAAI;GACvE,GAAG,GAAG,GAAG,GAAG,YAAY,YACvB,QAAQ,OAAO,OAAO,WAAW,GAAG,IACpC,OAAO,MAAM,SAAS,iBAAiB,GAAG,GAAG,IAAI,MAChD,OAAO,OAAO,KAAK,YAAY,GAAG,IAAI,IAAI,KAAK,gBAAgB,IAAI;;KA2EnE,SAAS,GAAG,GAAG,GAAG,MACrB,OAAO,MACJ,OAAO,OAAO,KAAK,GAAG,IAAI,GAAG,KAAK,OAAO,OAAO,OAAO,OAAO,KAAK,GAAG,IAAI,GAAG,IAAI,GAAG;;;;;;;;;;cAW5E;GACV,GAAG,GAAG,GAAG,GAAG,MAAM,SAAS,GAAG,GAAG,GAAG,MAAM,SAAS,MAAM,OAAO,OAAO,GAAG,GAAG;GAC7E,GAAG,GAAG,GAAG,GAAG,SAAS,GAAG,MAAM,SAAS,GAAG,GAAG,GAAG,KAAK,OAAO,OAAO,GAAG,GAAG;;KA2FvE,aAAa,GAAG,GAAG,GAAG,GAAG,MAC5B,OAAO,GACP,OAAO,MACJ,OAAO,OAAO,KAAK,GAAG,IAAI,GAAG,KAAK,OAAO,OAAO,OAAO,OAAO,KAAK,GAAG,IAAI,GAAG,IAAI,GAAG;;;;;;;;;;;;;;;;;;;;;;;;cAyB5E;GACV,GAAG,GAAG,GAAG,GAAG,GACX,SAAS,GACT,MAAM,aAAa,GAAG,GAAG,GAAG,GAAG,MAC7B,IAAI,IAAI,OAAO,OAAO,OAAO,GAAG,IAAI,QAAQ,OAAO,OAAO,GAAG,IAAI,IAAI,IAAI;GAC5E,GAAG,GAAG,GAAG,GAAG,GAAG,IAAI,IAClB,OAAO,OAAO,OAAO,GAAG,IAAI,KAC5B,SAAS,GACT,MAAM,aAAa,GAAG,GAAG,GAAG,GAAG,KAC9B,OAAO,OAAO,GAAG,IAAI,IAAI,IAAI;;;;;;;;;;;;;;;;;;;;;;cAmErB,gBAAiB,GAAG,GAAG,GAAG,GAAC,SAC7B,GAAC,MACJ,SAAS,GAAG,GAAG,GAAG,OACvB,OAAO;WACC,QAAQ,OAAO,OAAO,GAAG,GAAG;WAC5B,OAAO,gBAAgB,gBAAgB"}

package/dist/Tool-BF78QWtn.d.mts

@@ -1,314 +0,0 @@
-import { b as ToolCallOutput, y as ToolCall } from "./Items-C7MyrYPX.mjs";
-import { Effect, Schema } from "effect";
-import { StandardJSONSchemaV1, StandardSchemaV1 } from "@standard-schema/spec";
-declare namespace Tool_d_exports {
-  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;
-  readonly tool: Schema.String;
-  readonly message: Schema.String;
-  readonly cause: Schema.optional<Schema.Unknown>;
-}>, import("effect/Cause").YieldableError>;
-declare class ToolError extends ToolError_base {}
-declare const ToolValidationError_base: Schema.Class<ToolValidationError, Schema.TaggedStruct<"ToolValidationError", {
-  readonly call_id: Schema.String;
-  readonly tool: Schema.String;
-  readonly issues: Schema.$Array<Schema.Struct<{
-    readonly message: Schema.String;
-    readonly path: Schema.optional<Schema.$Array<Schema.Unknown>>;
-  }>>;
-}>, import("effect/Cause").YieldableError>;
-/**
- * The model's `arguments` for a call failed the tool's `inputSchema`. Distinct
- * from `ToolError` (malformed JSON, runtime crash) so callers can tell a
- * contract violation apart from a parse or execution failure, and so the
- * 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>;
-}>, import("effect/Cause").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
- * descriptors to provider request bodies).
- *
- * Any Standard-Schema-compliant library that exposes both interfaces
- * works directly: Zod 4+, Valibot, ArkType, Effect Schema (after
- * `fromEffectSchema`), etc.
- */
-type ToolInputSchema<Input = unknown> = StandardSchemaV1<unknown, Input> & StandardJSONSchemaV1<unknown, Input>;
-/**
- * Convenience wrapper for Effect Schema users - adds both the
- * `validate` and `jsonSchema` extensions to a plain Effect Schema so it
- * can be used as a `Tool.inputSchema`.
- */
-declare const fromEffectSchema: <S extends Schema.Codec<any, any, never, any>>(schema: S) => S & ToolInputSchema<S["Type"]>;
-/**
- * Use any schema library that implements both Standard Schema (validation)
- * and Standard JSON Schema (JSON Schema generation) as a `Tool.inputSchema`.
- * Covers Zod 4.2+, Valibot 1.2+, and ArkType 2.1.28+ in one helper.
- *
- * Effect Schema doesn't implement Standard JSON Schema natively — use
- * `fromEffectSchema` for those.
- *
- * The intersection constraint catches missing interfaces at compile time:
- * a Zod v3 schema (no Standard JSON Schema) produces a precise type error
- * pointing at the missing interface rather than a runtime surprise. The
- * helper itself is a thin type-narrowing identity — schemas that satisfy
- * both standards already structurally satisfy `ToolInputSchema`; the
- * 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
- * composes with `Stream.runForEach(emit)`.
- */
-type Emit<Event> = (event: Event) => Effect.Effect<void>;
-/**
- * A model-visible tool with a local `Effect` executor. `run` computes the
- * model-facing `Output`; emitting progress is a side channel via `emit`. A
- * plain tool never calls `emit` (its `Event` is irrelevant); a streaming tool
- * emits intermediate `Event`s that flow to the consumer as
- * `ToolEvent.Progress` in real time.
- *
- * This is one of four tool *kinds*, discriminated by `_tag`. The other three
- * (`ProviderTool`, `SignalTool`, `InteractionTool`) are model-visible but have
- * 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, 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, 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`
-   * (cross-tool, on `Toolkit.run`'s options).
-   */
-  readonly emitBufferSize?: number;
-  /**
-   * Whether the provider should render this tool with its strict-mode
-   * flag (OpenAI's `strict: true`, etc). Default: true. The framework
-   * never rewrites the schema; if the rendered JSON Schema isn't
-   * compatible, the provider returns an error.
-   */
-  readonly strict?: boolean;
-};
-/**
- * A provider-hosted tool: visible to the model and executed by the *provider*
- * (native web search, code execution, RAG grounding), never by this process.
- * It has no local `run`; `provider`/`config` tell the provider adapter how to
- * render it. Passing it to `Toolkit.run` yields a `non_local_tool` result.
- */
-type ProviderTool<Name extends string, Input, Provider extends string, Config> = {
-  readonly _tag: "ProviderTool";
-  readonly name: Name;
-  readonly description: string;
-  readonly inputSchema: ToolInputSchema<Input>;
-  readonly provider: Provider;
-  readonly config: Config;
-  readonly strict?: boolean;
-};
-/**
- * A typed request for the agent loop to change control flow (escalate, pause,
- * schedule, hand off). Model-visible and decodable (`decodeArgs`) but never
- * locally executed — the loop intercepts the call in `onTurnComplete` and acts
- * on it, so there is no fake `run`. `Toolkit.run` reports it as `non_local_tool`.
- */
-type SignalTool<Name extends string, Input> = {
-  readonly _tag: "SignalTool";
-  readonly name: Name;
-  readonly description: string;
-  readonly inputSchema: ToolInputSchema<Input>;
-};
-/**
- * A typed request for an external actor (user, channel, frontend) to respond
- * before the loop resumes. Like `SignalTool` it is decode-only, but its
- * lifecycle differs: the loop usually stops/pauses and resumes later by
- * appending a `function_call_output` once the actor replies.
- */
-type InteractionTool<Name extends string, Input> = {
-  readonly _tag: "InteractionTool";
-  readonly name: Name;
-  readonly description: string;
-  readonly inputSchema: ToolInputSchema<Input>;
-};
-/** A local (executable) tool of any shape. Readability alias. */
-type AnyLocalTool<E = any, R = any> = Tool<string, any, any, any, E, R>;
-/** Any of the four model-visible tool kinds. */
-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, 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 →
- * `input_schema`). Built from a `Tool` by `Tool.toDescriptors`.
- */
-type ToolDescriptor = {
-  readonly name: string;
-  readonly description: string;
-  readonly inputSchema: Record<string, unknown>;
-  readonly strict?: boolean;
-};
-/** A model-visible tool with a local `Effect` executor. */
-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, 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, 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, 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
- * renamed tool keys the toolkit record under the new name statically.
- */
-declare const withName: <N extends string, T extends AnyTool>(tool: T, name: N) => Omit<T, "name"> & {
-  readonly name: N;
-};
-/**
- * Replace a local tool's `run`, keeping its model-facing definition (name,
- * description, schema, `_tag`) identical. The new `run`'s `input` is typed from
- * the original tool, so override/mock need no annotation:
- *
- *   const safe = { ...toolkit, send_email: Tool.withRun(toolkit.send_email,
- *     ({ to }) => Effect.succeed({ status: "dry-run", to })) }
- *
- * 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, 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
- * an absent toolkit as no tools. The normalization point the `LanguageModel`
- * boundary uses so a request can carry the toolkit itself instead of a
- * pre-rendered descriptor array. Lives here (not on `Toolkit`) to keep providers
- * 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
- * `execute` - reach for it when you intercept a call to translate it into a
- * control-flow decision rather than running the tool's `run`.
- *
- * Malformed JSON fails with `ToolError`; a parsed body that violates
- * `inputSchema` fails with `ToolValidationError` carrying the issues.
- */
-declare const decodeArgs: <Input>(tool: DecodableTool<Input>, call: ToolCall) => Effect.Effect<Input, ToolError | ToolValidationError>;
-/**
- * Decode and validate the JSON arguments of a function_call against the
- * tool's input schema, run the tool, and serialize the output into a
- * function_call_output item. Single-shot: intermediate events emitted by
- * `run` are discarded (use `Toolkit.run` to stream them).
- */
-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 { 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-BF78QWtn.d.mts.map

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

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

package/dist/ToolEvent-Di4a723B.d.mts

@@ -1,144 +0,0 @@
-import { t as ToolResult } from "./ToolResult-BsYQRjmW.mjs";
-import { Data } from "effect";
-declare namespace ToolEvent_d_exports {
-  export { ToolEvent, isApprovalRequested, isOutput, isProgress };
-}
-type ToolEvent = Data.TaggedEnum<{
-  ApprovalRequested: {
-    readonly call_id: string;
-    readonly tool: string;
-    readonly arguments: string;
-  };
-  Progress: {
-    readonly call_id: string;
-    readonly tool: string;
-    readonly data: unknown;
-  };
-  Output: {
-    readonly result: ToolResult;
-  };
-}>;
-/**
- * Namespace of constructors, type guards, and matchers for `ToolEvent`,
- * provided by `Data.taggedEnum`. Use `ToolEvent.Output({ result })` to build
- * an event, `ToolEvent.$is("Output")` for type narrowing,
- * `ToolEvent.$match({ ApprovalRequested, Progress, Output })` for
- * exhaustive pattern matching.
- */
-declare const ToolEvent: {
-  readonly $is: <Tag extends "ApprovalRequested" | "Output" | "Progress">(tag: Tag) => (u: unknown) => u is Extract<{
-    readonly _tag: "ApprovalRequested";
-    readonly call_id: string;
-    readonly tool: string;
-    readonly arguments: string;
-  }, {
-    readonly _tag: Tag;
-  }> | Extract<{
-    readonly _tag: "Output";
-    readonly result: ToolResult;
-  }, {
-    readonly _tag: Tag;
-  }> | Extract<{
-    readonly _tag: "Progress";
-    readonly call_id: string;
-    readonly tool: string;
-    readonly data: unknown;
-  }, {
-    readonly _tag: Tag;
-  }>;
-  readonly $match: {
-    <Cases extends { readonly [Tag in "ApprovalRequested" | "Output" | "Progress"]: (args: Extract<{
-      readonly _tag: "ApprovalRequested";
-      readonly call_id: string;
-      readonly tool: string;
-      readonly arguments: string;
-    } | {
-      readonly _tag: "Output";
-      readonly result: ToolResult;
-    } | {
-      readonly _tag: "Progress";
-      readonly call_id: string;
-      readonly tool: string;
-      readonly data: unknown;
-    }, {
-      readonly _tag: Tag;
-    }>) => any; }>(cases: Cases): (value: {
-      readonly _tag: "ApprovalRequested";
-      readonly call_id: string;
-      readonly tool: string;
-      readonly arguments: string;
-    } | {
-      readonly _tag: "Output";
-      readonly result: ToolResult;
-    } | {
-      readonly _tag: "Progress";
-      readonly call_id: string;
-      readonly tool: string;
-      readonly data: unknown;
-    }) => import("effect/Unify").Unify<ReturnType<Cases["ApprovalRequested" | "Output" | "Progress"]>>;
-    <Cases extends { readonly [Tag in "ApprovalRequested" | "Output" | "Progress"]: (args: Extract<{
-      readonly _tag: "ApprovalRequested";
-      readonly call_id: string;
-      readonly tool: string;
-      readonly arguments: string;
-    } | {
-      readonly _tag: "Output";
-      readonly result: ToolResult;
-    } | {
-      readonly _tag: "Progress";
-      readonly call_id: string;
-      readonly tool: string;
-      readonly data: unknown;
-    }, {
-      readonly _tag: Tag;
-    }>) => any; }>(value: {
-      readonly _tag: "ApprovalRequested";
-      readonly call_id: string;
-      readonly tool: string;
-      readonly arguments: string;
-    } | {
-      readonly _tag: "Output";
-      readonly result: ToolResult;
-    } | {
-      readonly _tag: "Progress";
-      readonly call_id: string;
-      readonly tool: string;
-      readonly data: unknown;
-    }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["ApprovalRequested" | "Output" | "Progress"]>>;
-  };
-  readonly ApprovalRequested: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "ApprovalRequested";
-    readonly call_id: string;
-    readonly tool: string;
-    readonly arguments: string;
-  }, "_tag">;
-  readonly Output: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "Output";
-    readonly result: ToolResult;
-  }, "_tag">;
-  readonly Progress: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "Progress";
-    readonly call_id: string;
-    readonly tool: string;
-    readonly data: unknown;
-  }, "_tag">;
-};
-declare const isApprovalRequested: (u: unknown) => u is {
-  readonly _tag: "ApprovalRequested";
-  readonly call_id: string;
-  readonly tool: string;
-  readonly arguments: string;
-};
-declare const isProgress: (u: unknown) => u is {
-  readonly _tag: "Progress";
-  readonly call_id: string;
-  readonly tool: string;
-  readonly data: unknown;
-};
-declare const isOutput: (u: unknown) => u is {
-  readonly _tag: "Output";
-  readonly result: ToolResult;
-};
-//#endregion
-export { isProgress as a, isOutput as i, ToolEvent_d_exports as n, isApprovalRequested as r, ToolEvent as t };
-//# sourceMappingURL=ToolEvent-Di4a723B.d.mts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"ToolEvent-Di4a723B.d.mts","names":[],"sources":["../src/tool/ToolEvent.ts"],"mappings":";;;;;KAkBY,YAAY,KAAK;EAC3B;aACW;aACA;aACA;;EAEX;aACW;aACA;aACA;;EAEX;aACW,QAAQ;;;;;;;;;;cAWR;;;aArBS;aACH;aACK;;;;;aAQH,QAAA;;;;;aALC;aACH;aACA;;;;;;;eAPG;eACH;eACK;;;eAQH,QAAA;;;eALC;eACH;eACA;;;;;;;;;;;;;;;;;;;eAPG;eACH;eACK;;;eAQH,QAAA;;;eALC;eACH;eACA;;;;;;;;;;;;;;;;;;;;aAPG;aACH;aACK;;;;aAQH,QAAA;;;;aALC;aACH;aACA;;;cAgBN,sBAAmB,eAAA;;WAvBV;WACH;WACK;;cAsBX,aAAU,eAAA;;WAnBD;WACH;WACA;;cAkBN,WAAQ,eAAA;;WAfA,QAAA"}