@effect-uai/core 0.8.0 → 0.9.0

package/dist/Tool-0XUIT2A2.d.mts

@@ -0,0 +1,232 @@
+import { v as ToolCall, y as ToolCallOutput } from "./Items-CgKD6Npw.mjs";
+import { Effect, Schema } from "effect";
+import * as _$effect_Cause0 from "effect/Cause";
+import { StandardJSONSchemaV1, StandardSchemaV1 } from "@standard-schema/spec";
+
+//#region src/tool/Tool.d.ts
+declare namespace Tool_d_exports {
+  export { AnyLocalTool, AnyTool, DecodableTool, Emit, InteractionTool, ProviderTool, SignalTool, Tool, ToolDescriptor, ToolError, ToolInputSchema, ToolR, ToolValidationError, decodeArgs, descriptorsOf, execute, fromEffectSchema, fromStandardSchema, interaction, make, provider, signal, toDescriptors, withName, withRun };
+}
+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 {}
+/**
+ * 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>>;
+/**
+ * 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, R = never> = {
+  readonly _tag: "LocalTool";
+  readonly name: Name;
+  readonly description: string;
+  readonly inputSchema: ToolInputSchema<Input>;
+  readonly run: (input: Input, emit: Emit<Event>) => Effect.Effect<Output, unknown, R>;
+  /**
+   * 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<R = any> = Tool<string, any, any, any, R>;
+/** Any of the four model-visible tool kinds. */
+type AnyTool<R = any> = Tool<string, any, any, any, R> | ProviderTool<string, any, string, any> | SignalTool<string, any> | InteractionTool<string, any>;
+/** A model-visible tool that carries a decodable input schema (every kind). */
+type DecodableTool<Input> = {
+  readonly name: string;
+  readonly inputSchema: ToolInputSchema<Input>;
+};
+/** Extract the `R` of a local tool; non-local kinds contribute `never`. */
+type ToolR<T> = T extends Tool<string, any, any, any, infer R> ? R : never;
+/**
+ * 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, R = never>(spec: Omit<Tool<Name, Input, Event, Output, R>, "_tag">) => Tool<Name, Input, Event, Output, 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, R, Output2, R2 = never>(tool: Tool<Name, Input, Event, Output, R>, run: (input: Input, emit: Emit<Event>) => Effect.Effect<Output2, unknown, R2>) => Tool<Name, Input, Event, Output2, R2>;
+/** Render tools to provider-agnostic descriptors. Every kind is model-visible. */
+declare const 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>;
+/**
+ * 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, R>(tool: Tool<Name, Input, Event, Output, R>, call: ToolCall) => Effect.Effect<ToolCallOutput, ToolError | ToolValidationError, R>;
+//#endregion
+export { signal as C, withRun as E, provider as S, withName as T, execute as _, InteractionTool as a, interaction as b, Tool as c, ToolInputSchema as d, ToolR as f, descriptorsOf as g, decodeArgs as h, Emit as i, ToolDescriptor as l, Tool_d_exports as m, AnyTool as n, ProviderTool as o, ToolValidationError as p, DecodableTool as r, SignalTool as s, AnyLocalTool as t, ToolError as u, fromEffectSchema as v, toDescriptors as w, make as x, fromStandardSchema as y };
+//# sourceMappingURL=Tool-0XUIT2A2.d.mts.map

package/dist/Tool-0XUIT2A2.d.mts.map

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

package/dist/ToolEvent-DYrAUJGs.d.mts

@@ -0,0 +1,151 @@
+import { t as ToolResult } from "./ToolResult-BZd-cEWW.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-DYrAUJGs.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ToolEvent-DYrAUJGs.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/ToolResult-BZd-cEWW.d.mts

@@ -0,0 +1,151 @@
+import { v as ToolCall, y as ToolCallOutput } from "./Items-CgKD6Npw.mjs";
+import { Data } from "effect";
+import * as _$effect_Unify0 from "effect/Unify";
+
+//#region src/tool/ToolResult.d.ts
+declare namespace ToolResult_d_exports {
+  export { ToolResult, cancelled, denied, executionError, failed, isFailure, isOk, nonLocalTool, toToolCallOutput, validationError };
+}
+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;
+declare const toToolCallOutput: (r: ToolResult) => ToolCallOutput;
+//#endregion
+export { executionError as a, isOk as c, validationError as d, denied as i, nonLocalTool as l, ToolResult_d_exports as n, failed as o, cancelled as r, isFailure as s, ToolResult as t, toToolCallOutput as u };
+//# sourceMappingURL=ToolResult-BZd-cEWW.d.mts.map

package/dist/ToolResult-BZd-cEWW.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ToolResult-BZd-cEWW.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;;;;;;;cASnD,YAAA,GAAgB,IAAA,EAAM,QAAA,EAAU,MAAA,cAAkB,UAAA;;;;;;cAYlD,eAAA,GAAmB,IAAA,EAAM,QAAA,EAAU,MAAA,cAAkB,UAAA;AAAA,cAOrD,gBAAA,GAAoB,CAAA,EAAG,UAAA,KAAa,cAAA"}