@effect-uai/core 0.8.0 → 0.10.0

package/dist/Tool-2lC_XMth.d.mts

@@ -0,0 +1,284 @@
+import { v as ToolCall, y as ToolCallOutput } from "./Items-BnIduEV2.mjs";
+import { Effect, Schema } from "effect";
+import * as _$effect_Cause0 from "effect/Cause";
+import { StandardJSONSchemaV1, StandardSchemaV1 } from "@standard-schema/spec";
+
+//#region src/tool/Tool.d.ts
+declare namespace Tool_d_exports {
+  export { AnyLocalTool, AnyTool, DecodableTool, DecodeResult, Emit, InteractionTool, ProviderTool, SignalTool, Tool, ToolDescriptor, ToolE, ToolError, ToolFailed, ToolInputSchema, ToolR, ToolValidationError, decodeArgs, decodeCallInput, descriptorsOf, execute, fail, fromEffectSchema, fromStandardSchema, interaction, make, noInput, provider, 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>;
+}>, _$effect_Cause0.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>>;
+  }>>;
+}>, _$effect_Cause0.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>;
+}>, _$effect_Cause0.YieldableError>;
+/**
+ * The deliberate "speak to the model" failure sentinel. A tool's `run` that
+ * fails with a `ToolFailed` (or a bare `string`, its sugar) is absorbed by
+ * `Toolkit.run` into a `ToolResult.Failure` the model reads and adapts to,
+ * instead of ending the run. Every other error type propagates typed on the
+ * executor's stream. `kind` overrides the synthesized `Failure.kind`
+ * (default `"tool_failed"`) so a tool can hand the model a distinguishable
+ * category (`"not_found"`, `"rate_limited"`) without a new result variant.
+ */
+declare class ToolFailed extends ToolFailed_base {}
+/**
+ * Fail a tool's `run` with a model-visible message (optionally a `kind`).
+ * `yield* Tool.fail("page not found", { kind: "not_found" })` inside a
+ * `run`'s `Effect.gen`; the executor absorbs it as `ToolResult.Failure`.
+ */
+declare const fail: (message: string, options?: {
+  readonly kind?: string;
+}) => Effect.Effect<never, ToolFailed>;
+/**
+ * Schemas accepted on `Tool.inputSchema`. Must implement both Standard
+ * Schema validation and JSON Schema conversion (for rendering tool
+ * 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, Input, Event, Output, E = never, R = never>(spec: Omit<Tool<Name, Input, Event, Output, E, R>, "_tag">) => Tool<Name, Input, Event, Output, E, R>;
+/**
+ * A provider-hosted tool (native web search, code execution, RAG grounding).
+ * No local executor — `provider`/`config` drive the provider adapter's
+ * rendering. The model sees it; `Toolkit.run` reports it as `non_local_tool`.
+ */
+declare const provider: <Name extends string, Input, Provider extends string, Config>(spec: Omit<ProviderTool<Name, Input, Provider, Config>, "_tag">) => ProviderTool<Name, Input, Provider, Config>;
+/**
+ * A typed control-flow signal to the agent loop (escalate, pause, schedule,
+ * hand off). Decode-only: the loop interprets the call rather than executing a
+ * handler, so there is no `run`.
+ */
+declare const signal: <Name extends string, Input>(spec: Omit<SignalTool<Name, Input>, "_tag">) => SignalTool<Name, Input>;
+/**
+ * A typed request for an external actor to respond before the loop resumes
+ * (frontend, Telegram, CLI prompt). Decode-only; the loop stops/pauses and
+ * resumes by appending the actor's `function_call_output`.
+ */
+declare const interaction: <Name extends string, Input>(spec: Omit<InteractionTool<Name, Input>, "_tag">) => InteractionTool<Name, Input>;
+/**
+ * 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>;
+/** Render tools to provider-agnostic descriptors. Every kind is model-visible. */
+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 { toDescriptors as A, fromEffectSchema as C, noInput as D, make as E, withRun as M, provider as O, 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, withName as j, signal 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-2lC_XMth.d.mts.map

package/dist/Tool-2lC_XMth.d.mts.map

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

package/dist/ToolEvent-cWZ2BnbS.d.mts

@@ -0,0 +1,151 @@
+import { t as ToolResult } from "./ToolResult-CL4hK_9z.mjs";
+import { Data } from "effect";
+import * as _$effect_Unify0 from "effect/Unify";
+
+//#region src/tool/ToolEvent.d.ts
+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 ApprovalRequested: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "ApprovalRequested";
+    readonly call_id: string;
+    readonly tool: string;
+    readonly arguments: string;
+  }, "_tag">;
+  readonly Progress: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Progress";
+    readonly call_id: string;
+    readonly tool: string;
+    readonly data: unknown;
+  }, "_tag">;
+  readonly Output: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Output";
+    readonly result: ToolResult;
+  }, "_tag">;
+  readonly $is: <Tag extends "ApprovalRequested" | "Progress" | "Output">(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: "Progress";
+    readonly call_id: string;
+    readonly tool: string;
+    readonly data: unknown;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Output";
+    readonly result: ToolResult;
+  }, {
+    readonly _tag: Tag;
+  }>;
+  readonly $match: {
+    <Cases extends {
+      readonly ApprovalRequested: (args: {
+        readonly _tag: "ApprovalRequested";
+        readonly call_id: string;
+        readonly tool: string;
+        readonly arguments: string;
+      }) => any;
+      readonly Progress: (args: {
+        readonly _tag: "Progress";
+        readonly call_id: string;
+        readonly tool: string;
+        readonly data: unknown;
+      }) => any;
+      readonly Output: (args: {
+        readonly _tag: "Output";
+        readonly result: ToolResult;
+      }) => any;
+    }>(cases: Cases): (value: {
+      readonly _tag: "ApprovalRequested";
+      readonly call_id: string;
+      readonly tool: string;
+      readonly arguments: string;
+    } | {
+      readonly _tag: "Progress";
+      readonly call_id: string;
+      readonly tool: string;
+      readonly data: unknown;
+    } | {
+      readonly _tag: "Output";
+      readonly result: ToolResult;
+    }) => _$effect_Unify0.Unify<ReturnType<Cases["ApprovalRequested" | "Progress" | "Output"]>>;
+    <Cases extends {
+      readonly ApprovalRequested: (args: {
+        readonly _tag: "ApprovalRequested";
+        readonly call_id: string;
+        readonly tool: string;
+        readonly arguments: string;
+      }) => any;
+      readonly Progress: (args: {
+        readonly _tag: "Progress";
+        readonly call_id: string;
+        readonly tool: string;
+        readonly data: unknown;
+      }) => any;
+      readonly Output: (args: {
+        readonly _tag: "Output";
+        readonly result: ToolResult;
+      }) => any;
+    }>(value: {
+      readonly _tag: "ApprovalRequested";
+      readonly call_id: string;
+      readonly tool: string;
+      readonly arguments: string;
+    } | {
+      readonly _tag: "Progress";
+      readonly call_id: string;
+      readonly tool: string;
+      readonly data: unknown;
+    } | {
+      readonly _tag: "Output";
+      readonly result: ToolResult;
+    }, cases: Cases): _$effect_Unify0.Unify<ReturnType<Cases["ApprovalRequested" | "Progress" | "Output"]>>;
+  };
+};
+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-cWZ2BnbS.d.mts.map

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

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

package/dist/ToolResult-CL4hK_9z.d.mts

@@ -0,0 +1,157 @@
+import { v as ToolCall, y as ToolCallOutput } from "./Items-BnIduEV2.mjs";
+import { Data } from "effect";
+import * as _$effect_Unify0 from "effect/Unify";
+
+//#region src/tool/ToolResult.d.ts
+declare namespace ToolResult_d_exports {
+  export { ToolResult, cancelled, denied, executionError, failed, isFailure, isOk, nonLocalTool, serializeValue, toToolCallOutput, validationError };
+}
+type ToolResult = Data.TaggedEnum<{
+  Ok: {
+    readonly call_id: string;
+    readonly tool: string;
+    readonly value: unknown;
+  };
+  Failure: {
+    readonly call_id: string;
+    readonly tool: string;
+    readonly kind: string;
+    readonly reason?: string;
+  };
+}>;
+/**
+ * Namespace of constructors, type guards, and matchers for `ToolResult`,
+ * provided by `Data.taggedEnum`. Use `ToolResult.$is("Ok")` for type
+ * narrowing and `ToolResult.$match({ Ok, Failure })` for exhaustive
+ * pattern matching. Synthetic-result helpers (`denied`, `cancelled`,
+ * `executionError`, `failed`) below are kinder constructors than the
+ * raw `ToolResult.Failure(...)`.
+ */
+declare const ToolResult: {
+  readonly Ok: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Ok";
+    readonly call_id: string;
+    readonly tool: string;
+    readonly value: unknown;
+  }, "_tag">;
+  readonly Failure: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Failure";
+    readonly call_id: string;
+    readonly tool: string;
+    readonly kind: string;
+    readonly reason?: string;
+  }, "_tag">;
+  readonly $is: <Tag extends "Ok" | "Failure">(tag: Tag) => (u: unknown) => u is Extract<{
+    readonly _tag: "Ok";
+    readonly call_id: string;
+    readonly tool: string;
+    readonly value: unknown;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Failure";
+    readonly call_id: string;
+    readonly tool: string;
+    readonly kind: string;
+    readonly reason?: string;
+  }, {
+    readonly _tag: Tag;
+  }>;
+  readonly $match: {
+    <Cases extends {
+      readonly Ok: (args: {
+        readonly _tag: "Ok";
+        readonly call_id: string;
+        readonly tool: string;
+        readonly value: unknown;
+      }) => any;
+      readonly Failure: (args: {
+        readonly _tag: "Failure";
+        readonly call_id: string;
+        readonly tool: string;
+        readonly kind: string;
+        readonly reason?: string;
+      }) => any;
+    }>(cases: Cases): (value: {
+      readonly _tag: "Ok";
+      readonly call_id: string;
+      readonly tool: string;
+      readonly value: unknown;
+    } | {
+      readonly _tag: "Failure";
+      readonly call_id: string;
+      readonly tool: string;
+      readonly kind: string;
+      readonly reason?: string;
+    }) => _$effect_Unify0.Unify<ReturnType<Cases["Ok" | "Failure"]>>;
+    <Cases extends {
+      readonly Ok: (args: {
+        readonly _tag: "Ok";
+        readonly call_id: string;
+        readonly tool: string;
+        readonly value: unknown;
+      }) => any;
+      readonly Failure: (args: {
+        readonly _tag: "Failure";
+        readonly call_id: string;
+        readonly tool: string;
+        readonly kind: string;
+        readonly reason?: string;
+      }) => any;
+    }>(value: {
+      readonly _tag: "Ok";
+      readonly call_id: string;
+      readonly tool: string;
+      readonly value: unknown;
+    } | {
+      readonly _tag: "Failure";
+      readonly call_id: string;
+      readonly tool: string;
+      readonly kind: string;
+      readonly reason?: string;
+    }, cases: Cases): _$effect_Unify0.Unify<ReturnType<Cases["Ok" | "Failure"]>>;
+  };
+};
+declare const isOk: (u: unknown) => u is {
+  readonly _tag: "Ok";
+  readonly call_id: string;
+  readonly tool: string;
+  readonly value: unknown;
+};
+declare const isFailure: (u: unknown) => u is {
+  readonly _tag: "Failure";
+  readonly call_id: string;
+  readonly tool: string;
+  readonly kind: string;
+  readonly reason?: string;
+};
+declare const failed: (call: ToolCall, kind: string, reason?: string) => ToolResult;
+/** Explicit user/policy rejection. */
+declare const denied: (call: ToolCall, reason?: string) => ToolResult;
+/** Implicit non-answer (follow-up, inactivity, abort). */
+declare const cancelled: (call: ToolCall, reason?: string) => ToolResult;
+/** Tool's own execution failed (JSON parse error, runtime crash). */
+declare const executionError: (call: ToolCall, reason: string) => ToolResult;
+/**
+ * The model called a tool that is visible to it but has no local executor — a
+ * provider-hosted, signal, or interaction tool routed through `Toolkit.run`.
+ * Distinct from `unknown_tool` (no such tool at all): the loop is expected to
+ * intercept these kinds before execution, so this kind flags a missing handler.
+ */
+declare const nonLocalTool: (call: ToolCall, reason?: string) => ToolResult;
+/**
+ * The model's `arguments` failed the tool's input schema. Distinct kind from
+ * `execution_error` so recipes can tell a contract violation apart from a
+ * runtime crash.
+ */
+declare const validationError: (call: ToolCall, reason?: string) => ToolResult;
+/**
+ * Serialize a success value for the wire. A `string` passes through raw
+ * (models read plain text best; JSON.stringify would quote and escape it);
+ * `undefined` becomes `"null"`; anything else is JSON.
+ */
+declare const serializeValue: (value: unknown) => string;
+declare const toToolCallOutput: (r: ToolResult) => ToolCallOutput;
+//#endregion
+export { executionError as a, isOk as c, toToolCallOutput as d, validationError as f, denied as i, nonLocalTool as l, ToolResult_d_exports as n, failed as o, cancelled as r, isFailure as s, ToolResult as t, serializeValue as u };
+//# sourceMappingURL=ToolResult-CL4hK_9z.d.mts.map

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

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