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

package/dist/Tool-Bkryw6-h.d.mts

@@ -0,0 +1,206 @@
+import { x as ToolCall } from "./Items-Bvx8s9QH.mjs";
+import { Effect, Schema, Stream } from "effect";
+import { StandardJSONSchemaV1, StandardSchemaV1 } from "@standard-schema/spec";
+declare namespace Tool_d_exports {
+  export { AnyDeclared, AnyDescribed, AnyLocalTool, AnyTool, Declared, DecodableTool, DecodeResult, InputSchema, ProviderTool, Run, Tool, ToolDescriptor, ToolE, ToolError, ToolFailed, ToolFailure, ToolInputSchema, ToolOutput, ToolR, ToolUnhandled, ToolValidationError, WithFailures, declare, decodeArgs, decodeCallInput, descriptorsOf, fail, fromEffectSchema, fromStandardSchema, isProviderTool, isStreamed, make, noInput, provider, providerToolsOf, toDescriptors, toStream, withFailures, 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>;
+/** A call's `arguments` failed the tool's `inputSchema` (from `decodeArgs`). */
+declare class ToolValidationError extends ToolValidationError_base {}
+declare const ToolFailed_base: Schema.Class<ToolFailed, Schema.TaggedStruct<"ToolFailed", {
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * A ready-made model-visible error for one-off messages. It reaches the model
+ * only when listed in the tool's `failureSchema` (or via `Toolkit.describeFailures`).
+ */
+declare class ToolFailed extends ToolFailed_base {}
+/** `yield* Tool.fail("page not found")` inside a `run`. */
+declare const fail: (message: string) => Effect.Effect<never, ToolFailed>;
+/**
+ * Standard Schema with JSON Schema conversion (Zod 4+, Valibot, ArkType, or an
+ * Effect Schema via `fromEffectSchema`). Validates the model's arguments and
+ * renders the provider descriptor.
+ */
+type ToolInputSchema<Input = unknown> = StandardSchemaV1<unknown, Input> & StandardJSONSchemaV1<unknown, Input>;
+/** What `inputSchema` accepts: an Effect Schema directly, or a `ToolInputSchema`. */
+type InputSchema<Input> = Schema.Codec<Input, any, never, any> | ToolInputSchema<Input>;
+/** Adds the Standard Schema and Standard JSON Schema interfaces to an Effect Schema. */
+declare const fromEffectSchema: <S extends Schema.Codec<any, any, never, any>>(schema: S) => S & ToolInputSchema<S["Type"]>;
+/**
+ * Types a schema that implements both Standard Schema and Standard JSON Schema
+ * (Zod 4.2+, Valibot 1.2+, ArkType 2.1.28+). A schema missing either half is a
+ * compile error here rather than a runtime surprise.
+ */
+declare const fromStandardSchema: <S extends StandardSchemaV1 & StandardJSONSchemaV1>(schema: S) => S & ToolInputSchema<StandardSchemaV1.InferOutput<S>>;
+/**
+ * Input for a tool without arguments: renders `{ type: "object", properties: {} }`
+ * (an empty `Schema.Struct` renders an `anyOf` that strict providers reject).
+ */
+declare const noInput: ToolInputSchema<Record<string, never>>;
+/** One result (`Effect`) or partial results whose last element is the result (`Stream`). */
+type Run<Input, Output, E, R> = (input: Input) => Effect.Effect<Output, E, R> | Stream.Stream<Output, E, R>;
+/** Whether `run` returned a `Stream` (values as partials) rather than an `Effect` (one value). */
+declare const isStreamed: <A, E, R>(out: Effect.Effect<A, E, R> | Stream.Stream<A, E, R>) => out is Stream.Stream<A, E, R>;
+/** An `Effect` is a one-element stream. */
+declare const toStream: <A, E, R>(out: Effect.Effect<A, E, R> | Stream.Stream<A, E, R>) => Stream.Stream<A, E, R>;
+type Described<Name extends string, Input, Output, Failure> = {
+  readonly name: Name;
+  readonly description: string;
+  readonly inputSchema: ToolInputSchema<Input>;
+  /** Checks every value and encodes it for history and the UI. A rejected value is `OutputInvalid`. */
+  readonly outputSchema?: Schema.Codec<Output, any>;
+  /**
+   * Every error a call may end with that the model sees: errors `run` raises and
+   * errors the app closes calls with (`ToolDecision.Denied`, see `Toolkit.close`).
+   */
+  readonly failureSchema?: Schema.Codec<Failure, any>;
+  /** Render with the provider's strict-mode flag. Default: true. */
+  readonly strict?: boolean;
+};
+/**
+ * A model-visible tool that `Toolkit.run` executes: errors matching
+ * `failureSchema` reach the model, any other error fails the stream.
+ */
+type Tool<Name extends string, Input, Output, Failure = never, E = never, R = never> = Described<Name, Input, Output, Failure> & {
+  readonly _tag: "LocalTool";
+  readonly run: Run<Input, Output, E, R>;
+};
+/**
+ * A model-visible tool without `run`: the app handles its calls. A signal to
+ * the loop (`escalate`), or a call answered elsewhere (`ask_user`, typed by
+ * `outputSchema`). `Tool.withRun` turns it into a `Tool`.
+ */
+type Declared<Name extends string, Input, Output = never, Failure = never> = Described<Name, Input, Output, Failure> & {
+  readonly _tag: "DeclaredTool";
+};
+/**
+ * A provider-hosted tool (native web search, code execution, grounding), executed
+ * by the provider. `provider` / `config` drive the adapter's rendering.
+ */
+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;
+};
+type AnyLocalTool<E = any, R = any> = Tool<string, any, any, any, E, R>;
+type AnyDeclared = Declared<string, any, any, any>;
+/** A tool with schemas the app sees: `Tool` or `Declared`. */
+type AnyDescribed = AnyLocalTool | AnyDeclared;
+type AnyTool<E = any, R = any> = AnyLocalTool<E, R> | AnyDeclared | ProviderTool<string, any, string, any>;
+/** Any tool kind with a decodable input schema. */
+type DecodableTool<Input> = {
+  readonly name: string;
+  readonly inputSchema: ToolInputSchema<Input>;
+};
+type DescribedTag = {
+  readonly _tag: "LocalTool" | "DeclaredTool";
+};
+type ToolOutput<T> = T extends DescribedTag & Described<string, any, infer O, any> ? O : never;
+type ToolFailure<T> = T extends DescribedTag & Described<string, any, any, infer F> ? F : never;
+type ToolE<T> = T extends Tool<string, any, any, any, infer E, any> ? E : never;
+type ToolR<T> = T extends Tool<string, any, any, any, any, infer R> ? R : never;
+/** The errors a tool did not declare: these fail `Toolkit.run`'s stream. */
+type ToolUnhandled<T> = T extends Tool<string, any, any, infer F, infer E, any> ? Exclude<E, F> : never;
+type Spec<Name extends string, Input, Failure, FailureEncoded> = {
+  readonly name: Name;
+  readonly description: string;
+  readonly inputSchema: InputSchema<Input>;
+  readonly failureSchema?: Schema.Codec<Failure, FailureEncoded>;
+  readonly strict?: boolean;
+};
+/**
+ * A tool `Toolkit.run` executes. `outputSchema` says what `run` returns and its
+ * encoded side must be JSON. `Content.Value` is the explicit "anything": text,
+ * JSON or media.
+ */
+declare const make: <const Name extends string, Input, Output, Encoded extends Schema.Json, Failure = never, FailureEncoded extends Schema.Json = never, E = never, R = never>(spec: Spec<Name, Input, Failure, FailureEncoded> & {
+  readonly outputSchema: Schema.Codec<Output, Encoded>;
+  readonly run: Run<Input, Output, E, R>;
+}) => Tool<Name, Input, Output, Failure, E, R>;
+/**
+ * A tool without `run`: the app handles its calls. A signal to the loop (no
+ * `outputSchema`), or a call answered elsewhere (typed by `outputSchema`).
+ */
+declare const declare: <const Name extends string, Input, Output = never, Encoded extends Schema.Json = never, Failure = never, FailureEncoded extends Schema.Json = never>(spec: Spec<Name, Input, Failure, FailureEncoded> & {
+  readonly outputSchema?: Schema.Codec<Output, Encoded>;
+}) => Declared<Name, Input, Output, Failure>;
+/** A provider-hosted tool. */
+declare const provider: <const Name extends string, Input, Provider extends string, Config>(spec: Omit<ProviderTool<Name, Input, Provider, Config>, "_tag" | "inputSchema"> & {
+  readonly inputSchema: InputSchema<Input>;
+}) => ProviderTool<Name, Input, Provider, Config>;
+/** A copy of a tool under a new `name`, e.g. to resolve a clash before `Toolkit.compose`. */
+declare const withName: <N extends string, T extends AnyTool>(tool: T, name: N) => Omit<T, "name"> & {
+  readonly name: N;
+};
+/**
+ * Give a tool a `run`, keeping everything else (name, description, schemas):
+ * implement a declared tool (a spec shared with the browser), or mock a tool.
+ * The new `run` returns the same output type.
+ */
+declare const withRun: <Name extends string, Input, Output, Failure, E2 = never, R2 = never>(tool: Tool<Name, Input, Output, Failure, any, any> | Declared<Name, Input, Output, Failure>, run: Run<Input, Output, E2, R2>) => Tool<Name, Input, Output, Failure, E2, R2>;
+/** The same kind of tool, with more failures. */
+type WithFailures<T, F2> = T extends Tool<infer N, infer I, infer O, infer F, infer E, infer R> ? Tool<N, I, O, F | F2, E, R> : T extends Declared<infer N, infer I, infer O, infer F> ? Declared<N, I, O, F | F2> : never;
+/**
+ * Add errors a call of this tool may end with, e.g. the app's `ToolDecision.Denied`
+ * for a tool that needs approval. Its `run` need not raise them; the app closes
+ * calls with them (`Toolkit.close`).
+ */
+declare const withFailures: {
+  <F2, F2Encoded extends Schema.Json>(failures: Schema.Codec<F2, F2Encoded>): <T extends AnyDescribed>(tool: T) => WithFailures<T, F2>;
+  <T extends AnyDescribed, F2, F2Encoded extends Schema.Json>(tool: T, failures: Schema.Codec<F2, F2Encoded>): WithFailures<T, F2>;
+};
+/** Provider-agnostic descriptor; each provider maps `inputSchema` to its own field. */
+type ToolDescriptor = {
+  readonly name: string;
+  readonly description: string;
+  readonly inputSchema: Record<string, unknown>;
+  readonly strict?: boolean;
+};
+declare const isProviderTool: (tool: AnyTool) => tool is ProviderTool<string, any, string, any>;
+/** The provider-hosted tools in a toolkit, for an adapter to render natively. */
+declare const providerToolsOf: (toolkit?: Readonly<Record<string, AnyTool>>) => ReadonlyArray<ProviderTool<string, any, string, any>>;
+/** Function descriptors for every tool except provider-hosted ones. */
+declare const toDescriptors: (tools: ReadonlyArray<AnyTool>) => ReadonlyArray<ToolDescriptor>;
+/** `toDescriptors` over a toolkit record; an absent toolkit has none. */
+declare const descriptorsOf: (toolkit?: Readonly<Record<string, AnyTool>>) => ReadonlyArray<ToolDescriptor>;
+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`, as data. Empty arguments read as `{}`
+ * (some models send `""` for tools without arguments). Never fails.
+ */
+declare const decodeCallInput: <Input>(tool: DecodableTool<Input>, call: ToolCall) => Effect.Effect<DecodeResult<Input>>;
+/**
+ * A call's typed input, e.g. for a tool without `run` the loop handles itself.
+ * Bad JSON fails with `ToolError`, a schema violation with `ToolValidationError`.
+ */
+declare const decodeArgs: <Input>(tool: DecodableTool<Input>, call: ToolCall) => Effect.Effect<Input, ToolError | ToolValidationError>;
+//#endregion
+export { fromStandardSchema as A, withName as B, WithFailures as C, descriptorsOf as D, decodeCallInput as E, provider as F, providerToolsOf as I, toDescriptors as L, isStreamed as M, make as N, fail as O, noInput as P, toStream as R, Tool_d_exports as S, decodeArgs as T, withRun as V, ToolInputSchema as _, Declared as a, ToolUnhandled as b, InputSchema as c, Tool as d, ToolDescriptor as f, ToolFailure as g, ToolFailed as h, AnyTool as i, isProviderTool as j, fromEffectSchema as k, ProviderTool as l, ToolError as m, AnyDescribed as n, DecodableTool as o, ToolE as p, AnyLocalTool as r, DecodeResult as s, AnyDeclared as t, Run as u, ToolOutput as v, declare as w, ToolValidationError as x, ToolR as y, withFailures as z };
+//# sourceMappingURL=Tool-Bkryw6-h.d.mts.map

package/dist/Tool-Bkryw6-h.d.mts.map

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

package/dist/ToolEvent-9inLx5cI.d.mts

@@ -0,0 +1,22 @@
+import { Result } from "effect";
+declare namespace ToolEvent_d_exports {
+  export { Output, Partial, ToolEvent };
+}
+/** An intermediate value of a `Stream` tool. */
+type Partial<Name extends string = string, Output = unknown> = {
+  readonly _tag: "Partial";
+  readonly call_id: string;
+  readonly tool: Name;
+  readonly value: Output;
+};
+/** The call ended: `Success` with its value, or `Failure` with a declared or core error. */
+type Output<Name extends string = string, Out = unknown, E = unknown> = {
+  readonly _tag: "Output";
+  readonly call_id: string;
+  readonly tool: Name;
+  readonly result: Result.Result<Out, E>;
+};
+type ToolEvent<Name extends string = string, Out = unknown, E = unknown> = Partial<Name, Out> | Output<Name, Out, E>;
+//#endregion
+export { ToolEvent_d_exports as i, Partial as n, ToolEvent as r, Output as t };
+//# sourceMappingURL=ToolEvent-9inLx5cI.d.mts.map

package/dist/ToolEvent-9inLx5cI.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ToolEvent-9inLx5cI.d.mts","names":[],"sources":["../src/tool/ToolEvent.ts"],"mappings":";;;;;KAQY,QAAQ,8BAA8B;WACvC;WACA;WACA,MAAM;WACN,OAAO;;;KAIN,OAAO,8BAA8B,eAAe;WACrD;WACA;WACA,MAAM;WACN,QAAQ,OAAO,OAAO,KAAK;;KAG1B,UAAU,8BAA8B,eAAe,eAC/D,QAAQ,MAAM,OACd,OAAO,MAAM,KAAK"}

package/dist/ToolOutput-BNTIQgGB.d.mts

@@ -0,0 +1,151 @@
+import { i as FileSource, r as FileMimeType } from "./File-B923KvZ9.mjs";
+import { i as ImageMimeType, o as ImageSource } from "./Image-Bzc1H_UK.mjs";
+import { C as ToolOutputContent, S as ToolCallOutput, l as InputJson, u as InputText, x as ToolCall } from "./Items-Bvx8s9QH.mjs";
+import { a as Value, n as File, r as Image } from "./Content-D_Qfn8Ja.mjs";
+import { Effect, Option, Schema } from "effect";
+declare namespace ToolOutput_d_exports {
+  export { Cancelled, CoreError, InputInvalid, OutputInvalid, PartJson, RunError, UnknownTool, ValueParts, encoded, failure, isTextual, make, partText, parts, single, success, text, value, valueParts };
+}
+type CallId = Pick<ToolCall, "call_id">;
+/** `decoded` decides the shape and supplies media; `encoded` supplies the JSON. */
+declare const parts: (decoded: unknown, encoded: Schema.Json) => ReadonlyArray<ToolOutputContent>;
+/** A value, encoded by `schema`, as the call's output. */
+declare const success: <A>(call: CallId, schema: Schema.Codec<A, Schema.Json>, value: A) => Effect.Effect<ToolCallOutput, Schema.SchemaError>;
+/** An error, encoded by `schema`, as the call's output, flagged `isError`. */
+declare const failure: <E>(call: CallId, schema: Schema.Codec<E, Schema.Json>, error: E) => Effect.Effect<ToolCallOutput, Schema.SchemaError>;
+/** Any `Content.Value` as the call's output, for calls the app closes itself. */
+declare const make: (call: CallId, value: Value) => Effect.Effect<{
+  readonly type: "function_call_output";
+  readonly call_id: string;
+  readonly output: readonly ({
+    readonly type: "input_text";
+    readonly text: string;
+  } | {
+    readonly type: "input_json";
+    readonly value: Schema.Json;
+  } | {
+    readonly type: "input_image";
+    readonly source: ImageSource;
+  } | {
+    readonly type: "input_file";
+    readonly source: FileSource;
+    readonly filename?: string;
+  })[];
+  readonly isError?: boolean;
+  readonly providerData?: unknown;
+}, Schema.SchemaError, never>;
+/** One value as itself, several (or none) as the array: how parts read back as a value. */
+declare const single: <A>(values: ReadonlyArray<A>) => A | ReadonlyArray<A>;
+/** A text or JSON part. */
+declare const isTextual: (p: ToolOutputContent) => p is InputText | InputJson;
+/** A text part verbatim, a JSON part serialized. */
+declare const partText: (p: InputText | InputJson) => string;
+/**
+ * The parts as one string joined by newlines, for wires (or wire paths) whose
+ * tool outputs carry text only. `None` when a part is media.
+ */
+declare const text: (output: ReadonlyArray<ToolOutputContent>) => Option.Option<string>;
+/** Parts back to a `Content.Value`, read from the parts' own types. */
+declare const value: (output: ReadonlyArray<ToolOutputContent>) => Value;
+/** Parts back to the encoded form an `outputSchema` decodes (media re-encoded). */
+declare const encoded: (output: ReadonlyArray<ToolOutputContent>) => Effect.Effect<unknown, Schema.SchemaError>;
+/** A `Content.Value` as history parts, by the same rule as `parts` (its JSON is itself). */
+declare const valueParts: (v: Value) => ReadonlyArray<ToolOutputContent>;
+/** A history part with JSON sources (bytes as base64), as it travels to a UI. */
+declare const PartJson: Schema.Union<readonly [Schema.Struct<{
+  readonly type: Schema.Literal<"input_text">;
+  readonly text: Schema.String;
+}>, Schema.Struct<{
+  readonly type: Schema.Literal<"input_json">;
+  readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>, Schema.Struct<{
+  readonly type: Schema.Literal<"input_image">;
+  readonly source: Schema.Union<readonly [Schema.TaggedStruct<"url", {
+    readonly url: Schema.String;
+    readonly mimeType: Schema.optionalKey<Schema.Codec<ImageMimeType, ImageMimeType, never, never>>;
+  }>, Schema.TaggedStruct<"base64", {
+    readonly base64: Schema.String;
+    readonly mimeType: Schema.Codec<ImageMimeType, ImageMimeType, never, never>;
+  }>, Schema.TaggedStruct<"bytes", {
+    readonly bytes: Schema.Uint8ArrayFromBase64;
+    readonly mimeType: Schema.Codec<ImageMimeType, ImageMimeType, never, never>;
+  }>]>;
+}>, Schema.Struct<{
+  readonly type: Schema.Literal<"input_file">;
+  readonly source: Schema.Union<readonly [Schema.TaggedStruct<"url", {
+    readonly url: Schema.String;
+    readonly mimeType: Schema.optionalKey<Schema.Codec<FileMimeType, FileMimeType, never, never>>;
+  }>, Schema.TaggedStruct<"base64", {
+    readonly base64: Schema.String;
+    readonly mimeType: Schema.Codec<FileMimeType, FileMimeType, never, never>;
+  }>, Schema.TaggedStruct<"bytes", {
+    readonly bytes: Schema.Uint8ArrayFromBase64;
+    readonly mimeType: Schema.Codec<FileMimeType, FileMimeType, never, never>;
+  }>]>;
+  readonly filename: Schema.optionalKey<Schema.String>;
+}>]>;
+/**
+ * A `Content.Value` on the wire to a UI: typed parts instead of its plain JSON,
+ * so JSON shaped like `{ _tag: "Image", source }` can't come back as an image.
+ */
+declare const ValueParts: Schema.decodeTo<Schema.toType<Schema.Union<readonly [Schema.String, Schema.Union<readonly [typeof Image, typeof File]>, Schema.$Array<Schema.Union<readonly [Schema.Union<readonly [typeof Image, typeof File]>, Schema.Codec<Schema.Json, Schema.Json, never, never>]>>, Schema.Codec<Schema.Json, Schema.Json, never, never>]>>, Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+  readonly type: Schema.Literal<"input_text">;
+  readonly text: Schema.String;
+}>, Schema.Struct<{
+  readonly type: Schema.Literal<"input_json">;
+  readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>, Schema.Struct<{
+  readonly type: Schema.Literal<"input_image">;
+  readonly source: Schema.Union<readonly [Schema.TaggedStruct<"url", {
+    readonly url: Schema.String;
+    readonly mimeType: Schema.optionalKey<Schema.Codec<ImageMimeType, ImageMimeType, never, never>>;
+  }>, Schema.TaggedStruct<"base64", {
+    readonly base64: Schema.String;
+    readonly mimeType: Schema.Codec<ImageMimeType, ImageMimeType, never, never>;
+  }>, Schema.TaggedStruct<"bytes", {
+    readonly bytes: Schema.Uint8ArrayFromBase64;
+    readonly mimeType: Schema.Codec<ImageMimeType, ImageMimeType, never, never>;
+  }>]>;
+}>, Schema.Struct<{
+  readonly type: Schema.Literal<"input_file">;
+  readonly source: Schema.Union<readonly [Schema.TaggedStruct<"url", {
+    readonly url: Schema.String;
+    readonly mimeType: Schema.optionalKey<Schema.Codec<FileMimeType, FileMimeType, never, never>>;
+  }>, Schema.TaggedStruct<"base64", {
+    readonly base64: Schema.String;
+    readonly mimeType: Schema.Codec<FileMimeType, FileMimeType, never, never>;
+  }>, Schema.TaggedStruct<"bytes", {
+    readonly bytes: Schema.Uint8ArrayFromBase64;
+    readonly mimeType: Schema.Codec<FileMimeType, FileMimeType, never, never>;
+  }>]>;
+  readonly filename: Schema.optionalKey<Schema.String>;
+}>]>>, never, never>;
+declare const InputInvalid_base: Schema.Class<InputInvalid, Schema.TaggedStruct<"InputInvalid", {
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** The model's arguments are not JSON or fail `inputSchema`. */
+declare class InputInvalid extends InputInvalid_base {}
+declare const OutputInvalid_base: Schema.Class<OutputInvalid, Schema.TaggedStruct<"OutputInvalid", {
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** `run` returned a value its `outputSchema` rejects: a bug in the tool. */
+declare class OutputInvalid extends OutputInvalid_base {}
+declare const UnknownTool_base: Schema.Class<UnknownTool, Schema.TaggedStruct<"UnknownTool", {
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** No local tool by that name (hallucinated, removed, or a declared or provider tool). */
+declare class UnknownTool extends UnknownTool_base {}
+declare const Cancelled_base: Schema.Class<Cancelled, Schema.TaggedStruct<"Cancelled", {
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** The call was left unanswered and closed before the next model call. */
+declare class Cancelled extends Cancelled_base {}
+/** What `Toolkit.run` produces itself. */
+type RunError = InputInvalid | OutputInvalid | UnknownTool;
+declare const RunError: Schema.Union<readonly [typeof InputInvalid, typeof OutputInvalid, typeof UnknownTool]>;
+/** Every error core writes into history; what history and the UI always decode. */
+type CoreError = RunError | Cancelled;
+declare const CoreError: Schema.Union<readonly [typeof InputInvalid, typeof OutputInvalid, typeof UnknownTool, typeof Cancelled]>;
+//#endregion
+export { success as _, PartJson as a, valueParts as b, UnknownTool as c, failure as d, isTextual as f, single as g, parts as h, OutputInvalid as i, ValueParts as l, partText as m, CoreError as n, RunError as o, make as p, InputInvalid as r, ToolOutput_d_exports as s, Cancelled as t, encoded as u, text as v, value as y };
+//# sourceMappingURL=ToolOutput-BNTIQgGB.d.mts.map

package/dist/ToolOutput-BNTIQgGB.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ToolOutput-BNTIQgGB.d.mts","names":[],"sources":["../src/tool/ToolOutput.ts"],"mappings":";;;;;;;;KAsBK,SAAS,KAAK;;cAmCN,QAAK,kBAAoB,SAAW,OAAO,SAAO,cAAc;;cAShE,UAAW,GAAC,MACjB,QAAM,QACJ,OAAO,MAAM,GAAG,OAAO,OAAK,OAC7B,MACN,OAAO,OAAO,gBAAgB,OAAO;;cAQ3B,UAAW,GAAC,MACjB,QAAM,QACJ,OAAO,MAAM,GAAG,OAAO,OAAK,OAC7B,MACN,OAAO,OAAO,gBAAgB,OAAO;;cAS3B,OAAI,MAAU,QAAM,OAAS,UAAa,OAAA;;;;;;;;;;;;;;;;;;;GAAwC,OAAA;;cAGlF,SAAU,GAAC,QAAU,cAAc,OAAK,IAAI,cAAc;;cAI1D,YAAS,GAAO,sBAAoB,KAAK,YAAkB;;cAI3D,WAAQ,GAAO,YAAkB;;;;;cAOjC,OAAI,QAAY,cAAc,uBAAqB,OAAO;;cAI1D,QAAK,QAAY,cAAc,uBAAqB;;cAIpD,UAAO,QACV,cAAc,uBACrB,OAAO,gBAAgB,OAAO;;cAgBpB,aAAU,GAAO,UAAgB,cAAc;;cAW/C,UAAQ,OAAA,gBAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAeR,YAAU,OAAA,SAAA,OAAA,OAAA,OAAA,gBAAA,OAAA,QAAA,OAAA,uBAAA,cAAA,QAAA,OAAA,OAAA,OAAA,gBAAA,OAAA,uBAAA,cAAA,QAAA,OAAA,MAAA,OAAA,MAAA,OAAA,wBAAA,OAAA,MAAA,OAAA,MAAA,OAAA,wBAAA,OAAA,OAAA,OAAA,gBAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAUV,qBAAqB;;;;;cAKrB,sBAAsB;;;;;cAKtB,oBAAoB;;;;;cAKpB,kBAAkB;;KAMnB,WAAW,eAAe,gBAAgB;cACzC,UAAQ,OAAA,uBAAA,qBAAA,sBAAA;;KAGT,YAAY,WAAW;cACtB,WAAS,OAAA,uBAAA,qBAAA,sBAAA,oBAAA"}

package/dist/Toolkit-D2VGeD5R.d.mts

@@ -0,0 +1,212 @@
+import { S as ToolCallOutput, o as HistoryItem, x as ToolCall } from "./Items-Bvx8s9QH.mjs";
+import { b as ToolUnhandled, d as Tool, f as ToolDescriptor, g as ToolFailure, h as ToolFailed, i as AnyTool, l as ProviderTool, v as ToolOutput, y as ToolR } from "./Tool-Bkryw6-h.mjs";
+import { Turn } from "./domain/Turn.mjs";
+import { r as Step } from "./Loop-CeA0AelN.mjs";
+import { r as ToolEvent, t as Output } from "./ToolEvent-9inLx5cI.mjs";
+import { i as OutputInvalid, n as CoreError, o as RunError, r as InputInvalid } from "./ToolOutput-BNTIQgGB.mjs";
+import { Cause, Effect, Result, Schema, Stream } from "effect";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+declare namespace Toolkit_d_exports {
+  export { DeclaredCall, DuplicateToolName, Event, ExecuteOptions, Handler, Middleware, NoDuplicateNames, Outcome, Split, ToolMap, Toolkit, ToolkitE, ToolkitFailure, ToolkitR, UndeclaredFailure, UniqueTools, appendResults, close, complete, compose, continueWith, decode, describeFailures, descriptors, fromArray, isOutcome, make, makeNamespaced, namespace, next, output, run, split, withFailures, wrap };
+}
+type ToolMap = Record<string, AnyTool>;
+type Toolkit<Tools extends ToolMap = ToolMap> = Tools;
+type Indexed<Tools extends ReadonlyArray<AnyTool>> = { [T in Tools[number] as T["name"]]: T; };
+/** Index tools by `name`. A repeated literal name is a compile error. */
+declare const make: <const Tools extends ReadonlyArray<AnyTool>>(...tools: UniqueTools<Tools>) => Toolkit<Indexed<Tools>>;
+/** A toolkit from a dynamic source (MCP server, plugin). Same-named tools: last wins. */
+declare const fromArray: (tools: ReadonlyArray<AnyTool>) => Toolkit;
+declare const descriptors: (toolkit: Toolkit) => ReadonlyArray<ToolDescriptor>;
+type Locals<T extends Toolkit> = Extract<T[keyof T], {
+  readonly _tag: "LocalTool";
+}>;
+/** Every tool's requirements. */
+type ToolkitR<T extends Toolkit> = ToolMap extends T ? never : ToolR<T[keyof T]>;
+/** Every error a tool did not declare in `failureSchema`: these fail `run`'s stream. */
+type ToolkitE<T extends Toolkit> = ToolMap extends T ? never : ToolUnhandled<T[keyof T]>;
+/** What `run` emits: one member per local tool, plus calls it could not run at all. */
+type Event<T extends Toolkit> = (Locals<T> extends (infer X) ? X extends Tool<infer N, any, infer O, infer F, any, any> ? ToolEvent<N, O, F | RunError> : never : never) | Output<string, never, RunError>;
+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}`;
+};
+type NoDuplicateNames<Tools extends ReadonlyArray<AnyTool>> = [DuplicateName<Tools>] extends [never] ? unknown : DuplicateNameError<DuplicateName<Tools>>;
+type UniqueTools<Tools extends ReadonlyArray<AnyTool>> = Tools & NoDuplicateNames<Tools>;
+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;
+declare const DuplicateToolName_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => Cause.YieldableError & {
+  readonly _tag: "DuplicateToolName";
+} & Readonly<A>;
+/** Two composed toolkits share a final name; `sources` are their positions. */
+declare class DuplicateToolName extends DuplicateToolName_base<{
+  readonly name: string;
+  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 O, infer F, infer E, infer R> ? Tool<PrefixName<Prefix, N>, I, O, F, E, R> : T extends ProviderTool<infer N, infer I, infer P, infer C> ? ProviderTool<PrefixName<Prefix, N>, I, P, C> : 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>__`, e.g. to keep two `search` tools apart. */
+declare const namespace: <const Prefix extends string, const T extends ToolMap>(prefix: Prefix, toolkit: Toolkit<T>) => Toolkit<Namespaced<Prefix, T>>;
+/** `namespace(prefix, make(...tools))` in one step. */
+declare const makeNamespaced: <const Prefix extends string, const Tools extends ReadonlyArray<AnyTool>>(prefix: Prefix, ...tools: UniqueTools<Tools>) => Toolkit<Namespaced<Prefix, Indexed<Tools>>>;
+/**
+ * Join independently built toolkits. A duplicate final name fails with
+ * `DuplicateToolName`; statically known duplicates are a compile error too.
+ */
+declare const compose: <const Kits extends ReadonlyArray<Toolkit>>(...toolkits: Kits & NoDuplicateComposedKeys<Kits>) => Effect.Effect<Toolkit<Composed<Kits>>, DuplicateToolName>;
+type Handler<Input, Output, E, R> = (input: Input) => Stream.Stream<Output, E, R>;
+type Middleware<R2 = never, E2 = never> = <Input, Output, E, R>(run: Handler<Input, Output, E, R>, name: string) => Handler<Input, Output, E | E2, R | R2>;
+type WrapTool<T extends AnyTool, R2, E2> = T extends Tool<infer N, infer I, infer O, infer F, infer E, infer R> ? Tool<N, I, O, F, 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`. Stacks with `pipe`, inner first: the last
+ * `wrap` runs first. The middleware sees a stream; an `Effect` tool stays one,
+ * with the stream's last value.
+ *
+ *   const observed = pipe(toolkit, Toolkit.wrap(logging), Toolkit.wrap(authz))
+ */
+declare const wrap: {
+  <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 AddFailures<T extends AnyTool, F2> = T extends Tool<infer N, infer I, infer O, infer F, infer E, infer R> ? Tool<N, I, O, F | F2, E, R> : T;
+type AddFailuresToolkit<T extends ToolMap, F2> = { readonly [K in keyof T]: T[K] extends AnyTool ? AddFailures<T[K], F2> : T[K]; };
+/**
+ * `Tool.withFailures` for every local tool, e.g. a whole MCP toolkit that needs
+ * approval. Prefer it per tool when only some tools are gated.
+ */
+declare const withFailures: {
+  <F2, F2Encoded extends Schema.Json>(failures: Schema.Codec<F2, F2Encoded>): <T extends Toolkit>(toolkit: T) => AddFailuresToolkit<T, F2>;
+  <T extends Toolkit, F2, F2Encoded extends Schema.Json>(toolkit: T, failures: Schema.Codec<F2, F2Encoded>): AddFailuresToolkit<T, F2>;
+};
+type DescribeTool<T extends AnyTool, D> = T extends Tool<infer N, infer I, infer O, infer F, infer E, infer R> ? Tool<N, I, O, F | ToolFailed, F | ToolFailed | (undefined extends D ? E : never), R> : T;
+type DescribeToolkit<T extends ToolMap, D> = { readonly [K in keyof T]: T[K] extends AnyTool ? DescribeTool<T[K], D> : T[K]; };
+/**
+ * Undeclared errors become a `ToolFailed` the model reads, e.g. with
+ * `AiError.describe`. Declared failures pass through unchanged. Return
+ * `undefined` for an error that should still fail the run (a dead session).
+ */
+declare const describeFailures: {
+  <E, D extends string | undefined>(describe: (e: E) => D): <T extends Toolkit>(toolkit: T) => DescribeToolkit<T, D>;
+  <T extends Toolkit, D extends string | undefined>(toolkit: T, describe: (e: ToolkitE<T>) => D): DescribeToolkit<T, D>;
+};
+type ExecuteOptions = {
+  readonly concurrency?: number | "unbounded";
+};
+/**
+ * Run the calls, emitting each one's partials and its `Output`, typed per tool
+ * and decoded. An error matching the tool's `failureSchema` becomes a `Failure`;
+ * any other error fails the stream (siblings of a failed batch may then stay
+ * unanswered: see `HistoryCheck.cancelAllPending`). Which calls run is the caller's call.
+ */
+declare const run: <T extends Toolkit>(toolkit: T, calls: ReadonlyArray<ToolCall>, options?: ExecuteOptions) => Stream.Stream<Event<T>, ToolkitE<T>, ToolkitR<T>>;
+/** Any call's outcome, as `run` emits it. */
+type Outcome = Output<string, unknown, unknown>;
+/** Every error the toolkit's tools declare (core's errors are always possible too). */
+type ToolkitFailure<T extends Toolkit> = ToolMap extends T ? unknown : ToolFailure<T[keyof T]>;
+declare const UndeclaredFailure_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => Cause.YieldableError & {
+  readonly _tag: "UndeclaredFailure";
+} & Readonly<A>;
+/** `Toolkit.close` got an error the call's tool doesn't declare: a bug in the app. */
+declare class UndeclaredFailure extends UndeclaredFailure_base<{
+  readonly tool: string;
+  readonly message: string;
+}> {}
+/**
+ * A call the app closes itself (denied, superseded), as the outcome `run`
+ * would emit. `error` must be core's or declared by the call's tool
+ * (`failureSchema`, `Tool.withFailures`), else this fails with `UndeclaredFailure`.
+ * Pass the tool's name to check `error` against that tool at compile time:
+ *
+ *   Toolkit.close(toolkit, "issue_refund", call, new Escalated({ team: "finance" }))
+ */
+declare function close<T extends Toolkit, N extends keyof T & string>(toolkit: T, name: N, call: ToolCall, error: ToolFailure<T[N]> | CoreError): Effect.Effect<Output<N, never, ToolFailure<T[N]> | CoreError>, UndeclaredFailure>;
+declare function close<T extends Toolkit>(toolkit: T, call: ToolCall, error: ToolkitFailure<T> | CoreError): Effect.Effect<Output<string, never, ToolkitFailure<T> | CoreError>, UndeclaredFailure>;
+/**
+ * A call the app answers itself (`ask_user`, a signal's acknowledgement), as
+ * the outcome `run` would emit: `close`'s success side. `value` is typed by the
+ * tool's `outputSchema`; a value it rejects ends the call with `OutputInvalid`,
+ * as from `run`. Fails with `UndeclaredFailure` if `call` is for another tool.
+ */
+declare const complete: <T extends Toolkit, N extends keyof T & string>(toolkit: T, name: N, call: ToolCall, value: ToolOutput<T[N]>) => Effect.Effect<Output<N, ToolOutput<T[N]>, OutputInvalid>, UndeclaredFailure>;
+type InputOf<T> = T extends {
+  readonly inputSchema: StandardSchemaV1<any, infer I>;
+} ? I : never;
+type DeclaredCallOf<K extends string, X> = X extends {
+  readonly _tag: "DeclaredTool";
+} ? {
+  readonly tool: K;
+  readonly call: ToolCall;
+  readonly input: InputOf<X>;
+} : never;
+/** A call to one of the toolkit's declared tools, its input decoded. `tool` is the discriminant. */
+type DeclaredCall<T extends Toolkit> = { [K in keyof T & string]: DeclaredCallOf<K, T[K]>; }[keyof T & string];
+/** A turn's calls, sorted for the loop. */
+type Split<T extends Toolkit> = {
+  /** For `Toolkit.run`: calls to tools with `run`, and to unknown names (closed there). */
+  readonly run: ReadonlyArray<ToolCall>;
+  /** Calls to declared tools, decoded: handle them with `Match.discriminatorsExhaustive("tool")`. */
+  readonly declared: ReadonlyArray<DeclaredCall<T>>;
+  /** Calls to declared tools with bad arguments, closed with `InputInvalid` for the model. */
+  readonly invalid: ReadonlyArray<Output<string, never, InputInvalid>>;
+};
+/**
+ * The turn's tool calls, sorted: `run` for `Toolkit.run`, and the calls to
+ * declared tools decoded and typed per tool. Handling `declared` with
+ * `Match.discriminatorsExhaustive("tool")` makes a new declared tool a compile
+ * error until the loop handles it:
+ *
+ *   const { run, declared, invalid } = yield* Toolkit.split(toolkit, turn)
+ *   declared.map(Match.discriminatorsExhaustive("tool")({ ask_user: ..., escalate: ... }))
+ */
+declare const split: <T extends Toolkit>(toolkit: T, turn: Turn) => Effect.Effect<Split<T>>;
+/** Narrows to the `Output` members (also in a loop's mixed stream), keeping the per-tool types. */
+declare const isOutcome: <A extends {
+  readonly _tag: string;
+}>(e: A) => e is Extract<A, {
+  readonly _tag: "Output";
+}>;
+/**
+ * An outcome as history, encoded with the tool's schemas (never stringified:
+ * that is the provider codec's job). `output(toolkit)` is the pipeable form.
+ */
+declare function output(toolkit: Toolkit): (event: Outcome) => Effect.Effect<ToolCallOutput, Schema.SchemaError>;
+declare function output(toolkit: Toolkit, event: Outcome): Effect.Effect<ToolCallOutput, Schema.SchemaError>;
+/** History back to a typed `Result` for tool `name`, decoded with its schemas. */
+declare function decode<T extends Toolkit, N extends keyof T & string>(toolkit: T, name: N, item: ToolCallOutput): Effect.Effect<Result.Result<ToolOutput<T[N]>, ToolFailure<T[N]> | CoreError>, Schema.SchemaError>;
+type Tagged = {
+  readonly _tag: string;
+};
+/**
+ * Forward every event as a `Loop.value`, then continue the loop with
+ * `build(outcomes)`. `build` is an Effect, so it can encode. The stream may
+ * carry the app's own tagged events too (any tag but `Output`).
+ */
+declare const continueWith: {
+  <S, E2, R2>(build: (outcomes: ReadonlyArray<Outcome>) => Effect.Effect<S, E2, R2>): <A extends Tagged, E, R>(stream: Stream.Stream<A, E, R>) => Stream.Stream<Step<A, S>, E | E2, R | R2>;
+  <A extends Tagged, E, R, S, E2, R2>(stream: Stream.Stream<A, E, R>, build: (outcomes: ReadonlyArray<Outcome>) => Effect.Effect<S, E2, R2>): Stream.Stream<Step<A, S>, E | E2, R | R2>;
+};
+/** Encode each outcome with `output` and append the turn plus the outputs to history. */
+declare const appendResults: <S extends {
+  readonly history: ReadonlyArray<HistoryItem>;
+}>(toolkit: Toolkit, state: S, turn: Turn) => (outcomes: ReadonlyArray<Outcome>) => Effect.Effect<S, Schema.SchemaError>;
+/** `continueWith(appendResults(toolkit, state, turn))`. */
+declare const next: <S extends {
+  readonly history: ReadonlyArray<HistoryItem>;
+}>(toolkit: Toolkit, state: S, turn: Turn) => <A extends Tagged, E, R>(stream: Stream.Stream<A, E, R>) => Stream.Stream<{
+  readonly _tag: "Next";
+  readonly state: S;
+} | {
+  readonly _tag: "Stop";
+} | {
+  readonly _tag: "StopWith";
+  readonly state: S;
+} | {
+  readonly _tag: "Value";
+  readonly value: A;
+}, E | Schema.SchemaError, R>;
+//#endregion
+export { namespace as A, decode as C, isOutcome as D, fromArray as E, withFailures as F, wrap as I, output as M, run as N, make as O, split as P, continueWith as S, descriptors as T, UniqueTools as _, Handler as a, complete as b, Outcome as c, Toolkit as d, ToolkitE as f, UndeclaredFailure as g, Toolkit_d_exports as h, ExecuteOptions as i, next as j, makeNamespaced as k, Split as l, ToolkitR as m, DuplicateToolName as n, Middleware as o, ToolkitFailure as p, Event as r, NoDuplicateNames as s, DeclaredCall as t, ToolMap as u, appendResults as v, describeFailures as w, compose as x, close as y };
+//# sourceMappingURL=Toolkit-D2VGeD5R.d.mts.map

package/dist/Toolkit-D2VGeD5R.d.mts.map

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