@effect-uai/core 0.8.0 → 0.9.0

package/src/tool/Toolkit.ts

@@ -1,35 +1,306 @@
-import { Array as Arr, Effect, Function, Ref, Schema, Stream } from "effect"
+import {
+  Array as Arr,
+  Cause,
+  Data,
+  Effect,
+  Fiber,
+  Function,
+  Match,
+  Option,
+  Queue,
+  Record,
+  Ref,
+  Schema,
+  Stream,
+} from "effect"
 import * as Loop from "../loop/Loop.js"
-import type { ToolCall, HistoryItem } from "../domain/Items.js"
+import type { HistoryItem, ToolCall } from "../domain/Items.js"
 import { appendToHistory, type Turn } from "../domain/Turn.js"
 import {
+  type AnyLocalTool,
   type AnyTool,
-  type AnyPlainTool,
-  type AnyStreamingTool,
-  isStreamingTool,
-  type StreamingTool,
+  type Emit,
+  type InteractionTool,
+  type ProviderTool,
+  type SignalTool,
   type Tool,
+  type ToolDescriptor,
+  type ToolR,
+  toDescriptors,
 } from "./Tool.js"
-import { ToolResult, executionError, failed, toToolCallOutput } from "./ToolResult.js"
+import {
+  ToolResult,
+  executionError,
+  failed,
+  nonLocalTool,
+  toToolCallOutput,
+  validationError,
+} from "./ToolResult.js"
 import { ToolEvent } from "./ToolEvent.js"
 import { isOutput } from "./ToolEvent.js"
 
+// ---------------------------------------------------------------------------
+// Toolkit: a name-indexed record of tools — "what the model sees". The record
+// gives O(1) dispatch and within-toolkit name-uniqueness for free; descriptors
+// are derived, not stored. Build a static one with `make` (compile-time
+// duplicate-name check), a dynamic one with `fromArray` (trusted single source,
+// last-wins), and combine independent ones with `compose` (the application
+// boundary where cross-source names can clash).
+// ---------------------------------------------------------------------------
+
+export type ToolMap = Record<string, AnyTool>
+
+export type Toolkit<Tools extends ToolMap = ToolMap> = Tools
+
+const indexByName = (tools: ReadonlyArray<AnyTool>): ToolMap =>
+  Object.fromEntries(tools.map((tool) => [tool.name, tool]))
+
 /**
- * Union of every tool's `R` requirements in a mixed plain + streaming array.
- * Used by `run` to surface the services tools need at the recipe level, so
- * the loop's stream type carries them through to `Effect.provide`.
+ * Index literal tools by their `name`. Duplicate names are a compile error
+ * (`UniqueTools`). Names are not otherwise checked: a malformed name is a
+ * developer typo in a literal that the provider rejects clearly on first use,
+ * and there is no single cross-provider name rule to enforce here anyway.
  */
-export type ToolKindR<Tools extends ReadonlyArray<AnyTool<any>>> =
-  Tools[number] extends StreamingTool<any, any, any, any, infer R>
-    ? R
-    : Tools[number] extends Tool<any, any, any, infer R>
-      ? R
-      : never
+const buildStatic = <Tools extends ReadonlyArray<AnyTool>>(
+  tools: Tools,
+): Toolkit<{ [T in Tools[number] as T["name"]]: T }> =>
+  indexByName(tools) as Toolkit<{ [T in Tools[number] as T["name"]]: T }>
+
+export const make = <const Tools extends ReadonlyArray<AnyTool>>(
+  ...tools: UniqueTools<Tools>
+): Toolkit<{ [T in Tools[number] as T["name"]]: T }> => buildStatic(tools as unknown as Tools)
+
+/**
+ * Build a toolkit from a dynamically-sourced array (MCP server, plugin). Names
+ * are not validated (MCP legitimately uses dots / >64 chars — sanitize at the
+ * provider adapter); same-named tools resolve last-wins. Cross-source clashes
+ * are caught by `compose`.
+ */
+export const fromArray = (tools: ReadonlyArray<AnyTool>): Toolkit => indexByName(tools)
+
+/** Render the provider-facing descriptors for a toolkit on demand. */
+export const descriptors = (toolkit: Toolkit): ReadonlyArray<ToolDescriptor> =>
+  toDescriptors(Object.values(toolkit))
+
+/**
+ * Union of every tool's `R` requirements in a toolkit. Surfaced by `run` so the
+ * loop's stream type carries the services tools need through to `Effect.provide`.
+ *
+ * The `ToolMap extends T` guard yields `never` for the wide `Toolkit` type (a
+ * toolkit passed through an untyped boundary, where the requirements aren't
+ * statically known) instead of `any`, which would otherwise poison the
+ * resulting stream's `R`. Concrete toolkits from `make` keep their precise R.
+ */
+export type ToolkitR<T extends Toolkit> = ToolMap extends T ? never : ToolR<T[keyof T]>
 
 // ---------------------------------------------------------------------------
-// Tool executor. Streams `ToolEvent`s in real time and dispatches streaming
-// and plain tools uniformly. Policy stays outside this module: callers pass
-// only the calls they have already decided should run.
+// Uniqueness & composition. `make` rejects duplicate literal names at compile
+// time; `compose` rejects cross-source collisions — at compile time when the
+// names are statically known, and at runtime (`DuplicateToolName`) for dynamic
+// sources whose keys are only `string`. No silent last-wins overwrite, no late
+// provider 400.
+// ---------------------------------------------------------------------------
+
+// --- compile-time duplicate detection --------------------------------------
+
+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}`
+}
+
+export type NoDuplicateNames<Tools extends ReadonlyArray<AnyTool>> = [
+  DuplicateName<Tools>,
+] extends [never]
+  ? unknown
+  : DuplicateNameError<DuplicateName<Tools>>
+
+/** `Tools` constrained so a repeated literal name is a compile error in `make`. */
+export type UniqueTools<Tools extends ReadonlyArray<AnyTool>> = Tools & NoDuplicateNames<Tools>
+
+// Cross-toolkit literal-key collision, skipping wide (`string`-keyed, dynamic)
+// toolkits so the compile-time check never false-positives on `fromArray`.
+type ComposeDuplicateKey<
+  Kits extends ReadonlyArray<Toolkit>,
+  Seen extends string = never,
+> = Kits extends readonly [infer Head extends Toolkit, ...infer Tail extends ReadonlyArray<Toolkit>]
+  ? string extends keyof Head
+    ? ComposeDuplicateKey<Tail, Seen>
+    : Extract<keyof Head & string, Seen> extends never
+      ? ComposeDuplicateKey<Tail, Seen | (keyof Head & string)>
+      : Extract<keyof Head & string, Seen>
+  : never
+
+type NoDuplicateComposedKeys<Kits extends ReadonlyArray<Toolkit>> = [
+  ComposeDuplicateKey<Kits>,
+] extends [never]
+  ? unknown
+  : DuplicateNameError<ComposeDuplicateKey<Kits>>
+
+type UnionToIntersection<U> = (U extends unknown ? (x: U) => void : never) extends (
+  x: infer I,
+) => void
+  ? I
+  : never
+
+type Composed<Kits extends ReadonlyArray<Toolkit>> =
+  UnionToIntersection<Kits[number]> extends infer M ? (M extends ToolMap ? M : ToolMap) : ToolMap
+
+// --- uniqueness error ------------------------------------------------------
+
+/**
+ * Two composed toolkits resolved to the same final name. Carries the colliding
+ * `sources` (the positions of the clashing toolkits) so the error says *which*
+ * inputs collided. Raised at runtime by `compose` for dynamic sources; static
+ * collisions are caught earlier at compile time.
+ */
+export class DuplicateToolName extends Data.TaggedError("DuplicateToolName")<{
+  readonly name: string
+  readonly sources: ReadonlyArray<string>
+}> {}
+
+// --- namespacing -----------------------------------------------------------
+
+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 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
+ * to keep generic names (`search`) from two sources distinct before `compose`.
+ * If two namespaces collide at the `__` separator, the duplicate final name
+ * surfaces from `compose` as a `DuplicateToolName`.
+ */
+export const namespace = <const Prefix extends string, const T extends ToolMap>(
+  prefix: Prefix,
+  toolkit: Toolkit<T>,
+): Toolkit<Namespaced<Prefix, T>> => {
+  const renamed = Arr.map(Record.values(toolkit), (tool) => ({
+    ...tool,
+    name: `${prefix}__${tool.name}`,
+  }))
+  return indexByName(renamed) as Toolkit<Namespaced<Prefix, T>>
+}
+
+/** `namespace(prefix, make(...tools))` in one step, for static namespaced tools. */
+export const makeNamespaced = <
+  const Prefix extends string,
+  const Tools extends ReadonlyArray<AnyTool>,
+>(
+  prefix: Prefix,
+  ...tools: UniqueTools<Tools>
+): Toolkit<Namespaced<Prefix, { [T in Tools[number] as T["name"]]: T }>> =>
+  namespace(prefix, buildStatic(tools as unknown as Tools))
+
+// --- composition (the application boundary) --------------------------------
+
+/**
+ * Combine independently-built toolkits into one. This is where names from
+ * separate sources can collide, so it is the one effectful constructor: a
+ * duplicate final name fails with `DuplicateToolName` (naming the colliding
+ * input positions) instead of silently overwriting or 400-ing later at the
+ * provider. Statically-known collisions are additionally a compile error.
+ */
+export const compose = <const Kits extends ReadonlyArray<Toolkit>>(
+  ...toolkits: Kits & NoDuplicateComposedKeys<Kits>
+): Effect.Effect<Toolkit<Composed<Kits>>, DuplicateToolName> =>
+  Effect.gen(function* () {
+    const kits = toolkits as unknown as ReadonlyArray<Toolkit>
+    const labelled = Arr.flatMap(kits, (kit, i) =>
+      Arr.map(Record.keys(kit), (name) => ({ name, source: `toolkit-${i}` })),
+    )
+    const collision = Arr.findFirst(
+      Record.toEntries(Arr.groupBy(labelled, (entry) => entry.name)),
+      ([, group]) => group.length > 1,
+    )
+    if (Option.isSome(collision)) {
+      const [name, group] = collision.value
+      return yield* new DuplicateToolName({ name, sources: Arr.map(group, (e) => e.source) })
+    }
+    return Arr.reduce(kits, {} as ToolMap, (acc, kit) => ({ ...acc, ...kit })) as Toolkit<
+      Composed<Kits>
+    >
+  })
+
+// ---------------------------------------------------------------------------
+// Middleware: a `Toolkit -> Toolkit` transform applied up front, then the
+// wrapped toolkit is run. A middleware transforms one local tool's `run` given
+// its name (logging, retry, auth, metrics); `wrap` lifts it over the whole
+// toolkit, leaving provider/signal/interaction kinds untouched. The one reason
+// this is a combinator rather than native `Record.map`: it tracks the
+// middleware's added requirement `R2`, unioning it into `ToolkitR` instead of
+// widening every tool's type.
+// ---------------------------------------------------------------------------
+
+type Handler<Input, Event, Output, R> = (
+  input: Input,
+  emit: Emit<Event>,
+) => Effect.Effect<Output, unknown, R>
+
+export 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]
+}
+
+/**
+ * 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`:
+ *
+ *   const observed = pipe(toolkit, Toolkit.wrap(logging), Toolkit.wrap(authz))
+ *   Toolkit.run(observed, calls) // R = ToolkitR<typeof toolkit> | <authz R>
+ *
+ * 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.
+ */
+export 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>
+} = Function.dual(
+  2,
+  <T extends Toolkit, R2>(toolkit: T, middleware: Middleware<R2>): WrapToolkit<T, R2> =>
+    Record.map(toolkit, (tool) =>
+      tool._tag === "LocalTool" ? { ...tool, run: middleware(tool.run, tool.name) } : tool,
+    ) as WrapToolkit<T, R2>,
+)
+
+// ---------------------------------------------------------------------------
+// Tool executor. Streams `ToolEvent`s in real time. Policy stays outside this
+// module: callers pass only the calls they have already decided should run.
 // ---------------------------------------------------------------------------
 
 export type ExecuteOptions = {
@@ -37,69 +308,40 @@ export type ExecuteOptions = {
 }
 
 /** Execute every provided call. Approval/rejection policy belongs upstream. */
-export const run = <Tools extends ReadonlyArray<AnyTool<any>>>(
-  tools: Tools,
+export const run = <T extends Toolkit>(
+  toolkit: T,
   calls: ReadonlyArray<ToolCall>,
   options?: ExecuteOptions,
-): Stream.Stream<ToolEvent, never, ToolKindR<Tools>> =>
+): Stream.Stream<ToolEvent, never, ToolkitR<T>> =>
   Stream.fromIterable(calls).pipe(
-    Stream.flatMap((call) => runOne(tools, call), {
+    Stream.flatMap((call) => runOne(toolkit, call), {
       concurrency: options?.concurrency ?? "unbounded",
     }),
-  )
+  ) as Stream.Stream<ToolEvent, never, ToolkitR<T>>
 
 const okResult = (call: ToolCall, tool: string, value: unknown): ToolResult =>
-  ToolResult.Ok({
-    call_id: call.call_id,
-    tool,
-    value,
-  })
+  ToolResult.Ok({ call_id: call.call_id, tool, value })
 
-const runOne = <R>(
-  tools: ReadonlyArray<AnyTool<R>>,
-  call: ToolCall,
-): Stream.Stream<ToolEvent, never, R> => {
-  const tool = tools.find((t) => t.name === call.name)
-  if (tool === undefined) {
-    // Graceful: emit a synthetic Failure so OTHER calls in this turn
-    // still execute. LLMs hallucinate tool names; MCP tools come and go.
-    return Stream.succeed(
-      ToolEvent.Output({
-        result: failed(call, "unknown_tool", `No tool registered with name "${call.name}"`),
-      }),
-    )
-  }
-  if (isStreamingTool(tool)) return runStreaming(tool, call)
-  return runPlain(tool, call)
-}
+const outputEvent = (result: ToolResult): Stream.Stream<ToolEvent, never, any> =>
+  Stream.succeed(ToolEvent.Output({ result }))
 
-const parseJsonUnknown = Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Unknown))
-
-const runPlain = <R>(tool: AnyPlainTool<R>, call: ToolCall): Stream.Stream<ToolEvent, never, R> =>
-  Stream.fromEffect(
-    Effect.gen(function* () {
-      const parsed = yield* parseJsonUnknown(call.arguments).pipe(
-        Effect.mapError(() => "json_parse_error" as const),
-      )
-      const validated = yield* Effect.tryPromise({
-        try: () => Promise.resolve(tool.inputSchema["~standard"].validate(parsed)),
-        catch: () => "validation_threw" as const,
-      })
-      if (validated.issues !== undefined) {
-        return executionError(call, "Tool input failed schema validation")
-      }
-      const output = yield* tool.run(validated.value)
-      return okResult(call, tool.name, output)
-    }).pipe(
-      Effect.catchCause(() => Effect.succeed(executionError(call, "Tool execution failed"))),
-      Effect.map((result) => ToolEvent.Output({ result })),
+const runOne = (toolkit: ToolMap, call: ToolCall): Stream.Stream<ToolEvent, never, any> =>
+  Match.value(toolkit[call.name]).pipe(
+    // No such tool. Graceful: emit a synthetic Failure so OTHER calls in this
+    // turn still execute. LLMs hallucinate tool names; MCP tools come and go.
+    Match.when(Match.undefined, () =>
+      outputEvent(failed(call, "unknown_tool", `No tool registered with name "${call.name}"`)),
     ),
+    Match.tag("LocalTool", (local) => runTool(local, call)),
+    // Provider/signal/interaction tools are model-visible but not locally
+    // executable. The loop is expected to intercept these (decode + act) before
+    // execution; reaching here means it didn't, so report it rather than crash.
+    Match.orElse(() => outputEvent(nonLocalTool(call))),
   )
 
-const runStreaming = <R>(
-  tool: AnyStreamingTool<R>,
-  call: ToolCall,
-): Stream.Stream<ToolEvent, never, R> =>
+const parseJsonUnknown = Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Unknown))
+
+const runTool = (tool: AnyLocalTool, call: ToolCall): Stream.Stream<ToolEvent, never, any> =>
   Stream.unwrap(
     Effect.gen(function* () {
       const parsed = yield* parseJsonUnknown(call.arguments).pipe(
@@ -110,45 +352,40 @@ const runStreaming = <R>(
         catch: () => "validation_threw" as const,
       })
       if (validated.issues !== undefined) {
-        return Stream.succeed<ToolEvent>(
-          ToolEvent.Output({
-            result: executionError(call, "Tool input failed schema validation"),
-          }),
-        )
+        return Stream.succeed<ToolEvent>(ToolEvent.Output({ result: validationError(call) }))
       }
 
-      // Real-time: tap each event into a Ref as it flows; emit one
-      // Progress per event; then concat one synthetic Output element
-      // built from the accumulated Ref via `finalize`.
-      const ref = yield* Ref.make<Array<unknown>>([])
-      const progress = tool.run(validated.value).pipe(
-        Stream.tap((event) => Ref.update(ref, Arr.append(event))),
-        Stream.map((data) =>
-          ToolEvent.Progress({
-            call_id: call.call_id,
-            tool: tool.name,
-            data,
-          }),
-        ),
+      // Per-call queue: `emit` offers events as `run` produces them; the
+      // progress stream drains them in real time; `Queue.end` (in the
+      // `ensuring`) flushes pending events then signals a clean end, which
+      // `Stream.fromQueue` treats as completion. `Queue.shutdown` would clear
+      // queued items and interrupt pending takes — wrong for graceful teardown.
+      const queue = yield* Queue.make<unknown, Cause.Done>({ capacity: tool.emitBufferSize })
+      const emit = (event: unknown) => Effect.asVoid(Queue.offer(queue, event))
+      const fiber = yield* tool
+        .run(validated.value, emit)
+        .pipe(Effect.ensuring(Queue.end(queue)), Effect.forkScoped)
+
+      const progress = Stream.fromQueue(queue).pipe(
+        Stream.map((data) => ToolEvent.Progress({ call_id: call.call_id, tool: tool.name, data })),
       )
       const output = Stream.fromEffect(
-        Ref.get(ref).pipe(
-          Effect.map((events) =>
-            ToolEvent.Output({
-              result: okResult(call, tool.name, tool.finalize(events)),
-            }),
+        Fiber.join(fiber).pipe(
+          Effect.map((value) => ToolEvent.Output({ result: okResult(call, tool.name, value) })),
+          Effect.catchCause(() =>
+            Effect.succeed(
+              ToolEvent.Output({ result: executionError(call, "Tool execution failed") }),
+            ),
           ),
         ),
       )
       return progress.pipe(Stream.concat(output))
     }),
   ).pipe(
+    // Backstop for the input-parsing failures (`json_parse_error`,
+    // `validation_threw`) and any defect before the run fiber is forked.
     Stream.catchCause(() =>
-      Stream.succeed(
-        ToolEvent.Output({
-          result: executionError(call, "Tool execution failed"),
-        }),
-      ),
+      Stream.succeed(ToolEvent.Output({ result: executionError(call, "Tool execution failed") })),
     ),
   )
 
@@ -167,7 +404,7 @@ const runStreaming = <R>(
  * the results to wire-format `ToolCallOutput`s. Curried so it slots directly
  * into `continueWithResults`:
  *
- *   Toolkit.run(tools, calls).pipe(
+ *   Toolkit.run(toolkit, calls).pipe(
  *     Toolkit.continueWithResults(Toolkit.appendToolResults(state, turn)),
  *   )
  *

package/src/web-search/WebSearchTool.ts

@@ -66,7 +66,7 @@ export type WebSearchToolOptions = {
  */
 export const webSearchTool = (
   options?: WebSearchToolOptions,
-): Tool.Tool<string, WebSearchToolArgs, string, WebSearch> => {
+): Tool.Tool<string, WebSearchToolArgs, never, string, WebSearch> => {
   const name = options?.name ?? "web_search"
   const render = options?.render ?? defaultRender
   const maxResults = options?.maxResults ?? 5

package/dist/Tool-BKiieFXk.d.mts

@@ -1,102 +0,0 @@
-import { v as ToolCall, y as ToolCallOutput } from "./Items-7ljaVxH_.mjs";
-import { Effect, Schema, Stream } from "effect";
-import * as _$effect_Cause0 from "effect/Cause";
-import { StandardJSONSchemaV1, StandardSchemaV1 } from "@standard-schema/spec";
-
-//#region src/tool/Tool.d.ts
-declare namespace Tool_d_exports {
-  export { AnyPlainTool, AnyStreamingTool, AnyTool, StreamingTool, Tool, ToolDescriptor, ToolError, ToolInputSchema, execute, fromEffectSchema, fromStandardSchema, isStreamingTool, make, streaming, toDescriptors };
-}
-declare const ToolError_base: Schema.Class<ToolError, Schema.TaggedStruct<"ToolError", {
-  readonly call_id: Schema.String;
-  readonly tool: Schema.String;
-  readonly message: Schema.String;
-  readonly cause: Schema.optional<Schema.Unknown>;
-}>, _$effect_Cause0.YieldableError>;
-declare class ToolError extends ToolError_base {}
-/**
- * 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>>;
-type Tool<Name extends string, Input, Output, R = never> = {
-  readonly name: Name;
-  readonly description: string;
-  readonly inputSchema: ToolInputSchema<Input>;
-  readonly run: (input: Input) => Effect.Effect<Output, unknown, R>;
-  /**
-   * 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;
-};
-/**
- * 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;
-};
-declare const make: <Name extends string, Input, Output, R = never>(spec: Tool<Name, Input, Output, R>) => Tool<Name, Input, Output, R>;
-type StreamingTool<Name extends string, Input, Event, Output, R = never> = {
-  readonly _kind: "streaming";
-  readonly name: Name;
-  readonly description: string;
-  readonly inputSchema: ToolInputSchema<Input>;
-  readonly run: (input: Input) => Stream.Stream<Event, unknown, R>;
-  readonly finalize: (events: ReadonlyArray<Event>) => Output;
-  readonly strict?: boolean;
-};
-declare const streaming: <Name extends string, Input, Event, Output, R = never>(spec: Omit<StreamingTool<Name, Input, Event, Output, R>, "_kind">) => StreamingTool<Name, Input, Event, Output, R>;
-type AnyStreamingTool<R = any> = StreamingTool<string, any, any, any, R>;
-type AnyPlainTool<R = any> = Tool<string, any, any, R>;
-type AnyTool<R = any> = AnyStreamingTool<R> | AnyPlainTool<R>;
-declare const isStreamingTool: <R>(t: AnyTool<R>) => t is AnyStreamingTool<R>;
-/**
- * Render any-kind tools (mixed plain and streaming) to provider-agnostic
- * descriptors. Accepts the union type so a single list can carry both
- * plain and streaming tools.
- */
-declare const toDescriptors: <R>(tools: ReadonlyArray<AnyTool<R>>) => ReadonlyArray<ToolDescriptor>;
-/**
- * Decode and validate the JSON arguments of a function_call against the
- * tool's input schema, run the tool, and serialize the output into a
- * function_call_output item.
- */
-declare const execute: <Name extends string, Input, Output, R>(tool: Tool<Name, Input, Output, R>, call: ToolCall) => Effect.Effect<ToolCallOutput, ToolError, R>;
-//#endregion
-export { Tool as a, ToolInputSchema as c, fromEffectSchema as d, fromStandardSchema as f, toDescriptors as g, streaming as h, StreamingTool as i, Tool_d_exports as l, make as m, AnyStreamingTool as n, ToolDescriptor as o, isStreamingTool as p, AnyTool as r, ToolError as s, AnyPlainTool as t, execute as u };
-//# sourceMappingURL=Tool-BKiieFXk.d.mts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"Tool-BKiieFXk.d.mts","names":[],"sources":["../src/tool/Tool.ts"],"mappings":";;;;;;;;;cAEkE,cAAA;;;;;;cAGrD,SAAA,SAAkB,cAAA;;;;;;;;;;KAmBnB,eAAA,oBAAmC,gBAAA,UAA0B,KAAA,IACvE,oBAAA,UAA8B,KAAA;;;;AAvBkC;;cA8BrD,gBAAA,aAA8B,MAAA,CAAO,KAAA,wBAChD,MAAA,EAAQ,CAAA,KACP,CAAA,GAAI,eAAA,CAAgB,CAAA;;;;;;;;;;;;;;;;cAmBV,kBAAA,aAAgC,gBAAA,GAAmB,oBAAA,EAC9D,MAAA,EAAQ,CAAA,KACP,CAAA,GAAI,eAAA,CAAgB,gBAAA,CAAiB,WAAA,CAAY,CAAA;AAAA,KAGxC,IAAA;EAAA,SACD,IAAA,EAAM,IAAA;EAAA,SACN,WAAA;EAAA,SACA,WAAA,EAAa,eAAA,CAAgB,KAAA;EAAA,SAC7B,GAAA,GAAM,KAAA,EAAO,KAAA,KAAU,MAAA,CAAO,MAAA,CAAO,MAAA,WAAiB,CAAA;;;;;;;WAOtD,MAAA;AAAA;;;;;AAhEX;KAwEY,cAAA;EAAA,SACD,IAAA;EAAA,SACA,WAAA;EAAA,SACA,WAAA,EAAa,MAAA;EAAA,SACb,MAAA;AAAA;AAAA,cAGE,IAAA,kDACX,IAAA,EAAM,IAAA,CAAK,IAAA,EAAM,KAAA,EAAO,MAAA,EAAQ,CAAA,MAC/B,IAAA,CAAK,IAAA,EAAM,KAAA,EAAO,MAAA,EAAQ,CAAA;AAAA,KAWjB,aAAA;EAAA,SACD,KAAA;EAAA,SACA,IAAA,EAAM,IAAA;EAAA,SACN,WAAA;EAAA,SACA,WAAA,EAAa,eAAA,CAAgB,KAAA;EAAA,SAC7B,GAAA,GAAM,KAAA,EAAO,KAAA,KAAU,MAAA,CAAO,MAAA,CAAO,KAAA,WAAgB,CAAA;EAAA,SACrD,QAAA,GAAW,MAAA,EAAQ,aAAA,CAAc,KAAA,MAAW,MAAA;EAAA,SAC5C,MAAA;AAAA;AAAA,cAGE,SAAA,yDACX,IAAA,EAAM,IAAA,CAAK,aAAA,CAAc,IAAA,EAAM,KAAA,EAAO,KAAA,EAAO,MAAA,EAAQ,CAAA,gBACpD,aAAA,CAAc,IAAA,EAAM,KAAA,EAAO,KAAA,EAAO,MAAA,EAAQ,CAAA;AAAA,KAEjC,gBAAA,YAA4B,aAAA,wBAAqC,CAAA;AAAA,KACjE,YAAA,YAAwB,IAAA,mBAAuB,CAAA;AAAA,KAC/C,OAAA,YAAmB,gBAAA,CAAiB,CAAA,IAAK,YAAA,CAAa,CAAA;AAAA,cAErD,eAAA,MAAsB,CAAA,EAAG,OAAA,CAAQ,CAAA,MAAK,CAAA,IAAK,gBAAA,CAAiB,CAAA;;;;;;cAQ5D,aAAA,MAAoB,KAAA,EAAO,aAAA,CAAc,OAAA,CAAQ,CAAA,OAAM,aAAA,CAAc,cAAA;;;;;;cAkBrE,OAAA,0CACX,IAAA,EAAM,IAAA,CAAK,IAAA,EAAM,KAAA,EAAO,MAAA,EAAQ,CAAA,GAChC,IAAA,EAAM,QAAA,KACL,MAAA,CAAO,MAAA,CAAO,cAAA,EAAgB,SAAA,EAAW,CAAA"}

package/dist/loop/Loop.d.mts.map

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

package/dist/tool/ToolEvent.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ToolEvent.d.mts","names":[],"sources":["../../src/tool/ToolEvent.ts"],"mappings":";;;;;;;;KAaY,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;;;;;AAWrB;;;cAAa,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/tool/ToolResult.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ToolResult.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;;;;;;AAYb;;;cAAa,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;AAAA,cAOnD,gBAAA,GAAoB,CAAA,EAAG,UAAA,KAAa,cAAA"}

package/dist/tool/Toolkit.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Toolkit.d.mts","names":[],"sources":["../../src/tool/Toolkit.ts"],"mappings":";;;;;;;;;;;;;;;;;KAqBY,SAAA,eAAwB,aAAA,CAAc,OAAA,UAChD,KAAA,iBAAsB,aAAA,gCAClB,CAAA,GACA,KAAA,iBAAsB,IAAA,2BACpB,CAAA;AAAA,KASI,cAAA;EAAA,SACD,WAAA;AAAA;;cAIE,GAAA,iBAAqB,aAAA,CAAc,OAAA,QAC9C,KAAA,EAAO,KAAA,EACP,KAAA,EAAO,aAAA,CAAc,QAAA,GACrB,OAAA,GAAU,cAAA,KACT,MAAA,CAAO,MAAA,CAAO,SAAA,SAAkB,SAAA,CAAU,KAAA;AAtB7C;;;;;;;;;;;;AAAA,cA2Ja,iBAAA;EAAA,SACW,OAAA,EAAS,aAAA,CAAc,WAAA;AAAA,GAAgB,KAAA,EAAO,CAAA,EAAG,IAAA,EAAM,IAAA,MAC5E,OAAA,EAAS,aAAA,CAAc,UAAA,MAAc,CAAA;;;;;;;;;;AAhJxC;;cA8Ja,cAAA,SACX,MAAA,EAAQ,MAAA,CAAO,MAAA,CAAO,SAAA,EAAW,CAAA,EAAG,CAAA,MACnC,MAAA,CAAO,MAAA,CAAO,aAAA,CAAc,UAAA,GAAa,CAAA,EAAG,CAAA;;;AA3J/C;;;;;;;;;;;;;;cAkLa,mBAAA;EAAA,IAET,KAAA,GAAQ,OAAA,EAAS,aAAA,CAAc,UAAA,MAAgB,CAAA,OAE/C,MAAA,EAAQ,MAAA,CAAO,MAAA,CAAO,SAAA,SAAkB,CAAA,MACrC,MAAA,CAAO,MAAA,CAAO,IAAA,CAAU,SAAA,EAAW,CAAA,UAAW,CAAA;EAAA,OAEjD,MAAA,EAAQ,MAAA,CAAO,MAAA,CAAO,SAAA,SAAkB,CAAA,GACxC,KAAA,GAAQ,OAAA,EAAS,aAAA,CAAc,UAAA,MAAgB,CAAA,GAC9C,MAAA,CAAO,MAAA,CAAO,IAAA,CAAU,SAAA,EAAW,CAAA,UAAW,CAAA;AAAA"}