@effect-uai/core 0.1.0

package/dist/streaming/SSE.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"SSE.mjs","names":[],"sources":["../../src/streaming/SSE.ts"],"sourcesContent":["import { Stream } from \"effect\"\n\n/**\n * One Server-Sent Event. Fields per the WHATWG spec:\n * - `event`: optional event name (default \"message\" on the wire)\n * - `data`: payload, with multiple `data:` lines joined by `\\n`\n * - `id`: optional last-event id\n */\nexport interface Event {\n  readonly event?: string\n  readonly data: string\n  readonly id?: string\n}\n\n// ---------------------------------------------------------------------------\n// Generic stream helpers (kept module-local for now; promote to a shared\n// Stream module once a third caller appears).\n// ---------------------------------------------------------------------------\n\n/** Decode `Uint8Array` chunks as UTF-8, handling multi-byte boundaries. */\nconst decodeText = <E, R>(self: Stream.Stream<Uint8Array, E, R>): Stream.Stream<string, E, R> =>\n  self.pipe(\n    Stream.mapAccum(\n      (): TextDecoder => new TextDecoder(\"utf-8\"),\n      (decoder, chunk: Uint8Array) => [decoder, [decoder.decode(chunk, { stream: true })]] as const,\n      {\n        onHalt: (decoder: TextDecoder) => {\n          const tail = decoder.decode()\n          return tail.length > 0 ? [tail] : []\n        },\n      },\n    ),\n  )\n\n/** Split a text stream on a separator, buffering across chunk boundaries. */\nconst splitOn =\n  (separator: string) =>\n  <E, R>(self: Stream.Stream<string, E, R>): Stream.Stream<string, E, R> =>\n    self.pipe(\n      Stream.mapAccum(\n        (): string => \"\",\n        (buffer, chunk: string) => {\n          const parts = (buffer + chunk).split(separator)\n          const tail = parts[parts.length - 1] ?? \"\"\n          return [tail, parts.slice(0, -1)] as const\n        },\n        { onHalt: (tail: string) => (tail.length > 0 ? [tail] : []) },\n      ),\n    )\n\n// ---------------------------------------------------------------------------\n// Parser\n// ---------------------------------------------------------------------------\n\nconst parseField = (line: string): readonly [string, string] => {\n  const colon = line.indexOf(\":\")\n  if (colon < 0) return [line, \"\"]\n  const value = line.slice(colon + 1)\n  return [line.slice(0, colon), value.startsWith(\" \") ? value.slice(1) : value]\n}\n\nconst parseBlock = (block: string): Event | null => {\n  const lines = block.split(\"\\n\").filter((l) => l.length > 0 && !l.startsWith(\":\"))\n  if (lines.length === 0) return null\n\n  const fields = lines.map(parseField)\n  const dataLines = fields.filter(([f]) => f === \"data\").map(([, v]) => v)\n  const event = fields.find(([f]) => f === \"event\")?.[1]\n  const id = fields.find(([f]) => f === \"id\")?.[1]\n\n  const out: { event?: string; data: string; id?: string } = {\n    data: dataLines.join(\"\\n\"),\n  }\n  if (event !== undefined) out.event = event\n  if (id !== undefined) out.id = id\n  return out as Event\n}\n\n// ---------------------------------------------------------------------------\n// Public API\n// ---------------------------------------------------------------------------\n\n/**\n * Decode a `Stream<Uint8Array>` (e.g. an HTTP response body) into a\n * `Stream<SSE.Event>`. Handles partial UTF-8 sequences, CRLF/LF line\n * endings, and events split across chunk boundaries.\n */\nexport const fromBytes = <E, R>(\n  self: Stream.Stream<Uint8Array, E, R>,\n): Stream.Stream<Event, E, R> =>\n  self.pipe(\n    decodeText,\n    Stream.map((s) => s.replace(/\\r/g, \"\")), // SSE allows CRLF; normalize to LF\n    splitOn(\"\\n\\n\"),\n    Stream.map(parseBlock),\n    Stream.filter((ev): ev is Event => ev !== null),\n  )\n\nconst eventToString = (ev: Event): string => {\n  const parts: string[] = []\n  if (ev.event !== undefined) parts.push(`event: ${ev.event}`)\n  if (ev.id !== undefined) parts.push(`id: ${ev.id}`)\n  for (const line of ev.data.split(\"\\n\")) parts.push(`data: ${line}`)\n  return parts.join(\"\\n\") + \"\\n\\n\"\n}\n\nconst encoder = new TextEncoder()\n\n/**\n * Encode a `Stream<Event>` as `Stream<Uint8Array>` ready to send on an\n * HTTP response with `Content-Type: text/event-stream`.\n */\nexport const toBytes = <E, R>(self: Stream.Stream<Event, E, R>): Stream.Stream<Uint8Array, E, R> =>\n  Stream.map(self, (ev) => encoder.encode(eventToString(ev)))\n"],"mappings":";;;;;;;;AAoBA,MAAM,cAAoB,SACxB,KAAK,KACH,OAAO,eACc,IAAI,YAAY,QAAQ,GAC1C,SAAS,UAAsB,CAAC,SAAS,CAAC,QAAQ,OAAO,OAAO,EAAE,QAAQ,MAAM,CAAC,CAAC,CAAC,EACpF,EACE,SAAS,YAAyB;CAChC,MAAM,OAAO,QAAQ,QAAQ;AAC7B,QAAO,KAAK,SAAS,IAAI,CAAC,KAAK,GAAG,EAAE;GAEvC,CACF,CACF;;AAGH,MAAM,WACH,eACM,SACL,KAAK,KACH,OAAO,eACS,KACb,QAAQ,UAAkB;CACzB,MAAM,SAAS,SAAS,OAAO,MAAM,UAAU;AAE/C,QAAO,CADM,MAAM,MAAM,SAAS,MAAM,IAC1B,MAAM,MAAM,GAAG,GAAG,CAAC;GAEnC,EAAE,SAAS,SAAkB,KAAK,SAAS,IAAI,CAAC,KAAK,GAAG,EAAE,EAAG,CAC9D,CACF;AAML,MAAM,cAAc,SAA4C;CAC9D,MAAM,QAAQ,KAAK,QAAQ,IAAI;AAC/B,KAAI,QAAQ,EAAG,QAAO,CAAC,MAAM,GAAG;CAChC,MAAM,QAAQ,KAAK,MAAM,QAAQ,EAAE;AACnC,QAAO,CAAC,KAAK,MAAM,GAAG,MAAM,EAAE,MAAM,WAAW,IAAI,GAAG,MAAM,MAAM,EAAE,GAAG,MAAM;;AAG/E,MAAM,cAAc,UAAgC;CAClD,MAAM,QAAQ,MAAM,MAAM,KAAK,CAAC,QAAQ,MAAM,EAAE,SAAS,KAAK,CAAC,EAAE,WAAW,IAAI,CAAC;AACjF,KAAI,MAAM,WAAW,EAAG,QAAO;CAE/B,MAAM,SAAS,MAAM,IAAI,WAAW;CACpC,MAAM,YAAY,OAAO,QAAQ,CAAC,OAAO,MAAM,OAAO,CAAC,KAAK,GAAG,OAAO,EAAE;CACxE,MAAM,QAAQ,OAAO,MAAM,CAAC,OAAO,MAAM,QAAQ,GAAG;CACpD,MAAM,KAAK,OAAO,MAAM,CAAC,OAAO,MAAM,KAAK,GAAG;CAE9C,MAAM,MAAqD,EACzD,MAAM,UAAU,KAAK,KAAK,EAC3B;AACD,KAAI,UAAU,KAAA,EAAW,KAAI,QAAQ;AACrC,KAAI,OAAO,KAAA,EAAW,KAAI,KAAK;AAC/B,QAAO;;;;;;;AAYT,MAAa,aACX,SAEA,KAAK,KACH,YACA,OAAO,KAAK,MAAM,EAAE,QAAQ,OAAO,GAAG,CAAC,EACvC,QAAQ,OAAO,EACf,OAAO,IAAI,WAAW,EACtB,OAAO,QAAQ,OAAoB,OAAO,KAAK,CAChD;AAEH,MAAM,iBAAiB,OAAsB;CAC3C,MAAM,QAAkB,EAAE;AAC1B,KAAI,GAAG,UAAU,KAAA,EAAW,OAAM,KAAK,UAAU,GAAG,QAAQ;AAC5D,KAAI,GAAG,OAAO,KAAA,EAAW,OAAM,KAAK,OAAO,GAAG,KAAK;AACnD,MAAK,MAAM,QAAQ,GAAG,KAAK,MAAM,KAAK,CAAE,OAAM,KAAK,SAAS,OAAO;AACnE,QAAO,MAAM,KAAK,KAAK,GAAG;;AAG5B,MAAM,UAAU,IAAI,aAAa;;;;;AAMjC,MAAa,WAAiB,SAC5B,OAAO,IAAI,OAAO,OAAO,QAAQ,OAAO,cAAc,GAAG,CAAC,CAAC"}

package/dist/structured-format/StructuredFormat.d.mts

@@ -0,0 +1,2 @@
+import { c as decodeJsonLines, i as StructuredFormat, l as fromEffectSchema, n as JsonParseError, o as StructuredSchema, r as StructuredDecodeError, s as decode, t as DecodeIssue, u as parseJson } from "../StructuredFormat-B5ueioNr.mjs";
+export { DecodeIssue, JsonParseError, StructuredDecodeError, StructuredFormat, StructuredSchema, decode, decodeJsonLines, fromEffectSchema, parseJson };

package/dist/structured-format/StructuredFormat.mjs

@@ -0,0 +1,68 @@
+import { t as __exportAll } from "../chunk-CfYAbeIz.mjs";
+import { Data, Effect, Match, Schema, Stream, pipe } from "effect";
+//#region src/structured-format/StructuredFormat.ts
+var StructuredFormat_exports = /* @__PURE__ */ __exportAll({
+	JsonParseError: () => JsonParseError,
+	StructuredDecodeError: () => StructuredDecodeError,
+	decode: () => decode,
+	decodeJsonLines: () => decodeJsonLines,
+	fromEffectSchema: () => fromEffectSchema,
+	parseJson: () => parseJson
+});
+/**
+* Schema validation failed. `raw` is the original text (or stringified
+* value) that failed; `issues` is a flat list of per-field problems.
+*/
+var StructuredDecodeError = class extends Data.TaggedError("StructuredDecodeError") {};
+/**
+* `JSON.parse` threw on a string that was supposed to be JSON. Distinct
+* from `StructuredDecodeError`: the bytes weren't even JSON.
+*/
+var JsonParseError = class extends Data.TaggedError("StructuredJsonParseError") {};
+/**
+* Wrap an Effect `Schema` as a `StructuredFormat`. Effect Schema doesn't
+* natively implement Standard Schema; this helper installs the
+* `~standard` and JSON Schema interfaces.
+*/
+const fromEffectSchema = (schema, options) => ({
+	name: options?.name ?? "output",
+	schema: Schema.toStandardJSONSchemaV1(Schema.toStandardSchemaV1(schema)),
+	...options?.description !== void 0 && { description: options.description },
+	...options?.strict !== void 0 && { strict: options.strict }
+});
+const propertyKeyToScalar = Match.type().pipe(Match.when(Match.string, (s) => s), Match.when(Match.number, (n) => n), Match.when(Match.symbol, (s) => s.toString()), Match.exhaustive);
+const segmentToKey = Match.type().pipe(Match.when(Match.string, (s) => s), Match.when(Match.number, (n) => n), Match.when(Match.symbol, (s) => s.toString()), Match.orElse((segment) => propertyKeyToScalar(segment.key)));
+const issueToDecode = (issue) => ({
+	path: (issue.path ?? []).map(segmentToKey),
+	message: issue.message
+});
+/**
+* Validate an `unknown` against the format's schema. Returns the typed
+* value or a `StructuredDecodeError`. Standard Schema's `validate` may
+* be async; this function handles both sync and async results.
+*/
+const decode = (format) => (raw) => pipe(Effect.promise(async () => format.schema["~standard"].validate(raw)), Effect.flatMap((result) => result.issues === void 0 ? Effect.succeed(result.value) : Effect.fail(new StructuredDecodeError({
+	raw: typeof raw === "string" ? raw : JSON.stringify(raw),
+	issues: result.issues.map(issueToDecode)
+}))));
+/**
+* Parse a JSON string then validate against the format's schema. Two
+* failure modes: `JsonParseError` (bytes weren't JSON) and
+* `StructuredDecodeError` (JSON didn't match the schema).
+*/
+const parseJson = (format) => (raw) => pipe(Effect.try({
+	try: () => JSON.parse(raw),
+	catch: (cause) => new JsonParseError({
+		raw,
+		cause
+	})
+}), Effect.flatMap(decode(format)));
+/**
+* Stream operator: each input string is JSON-parsed and validated.
+* Failures surface in the stream's failure channel, distinguished by tag.
+*/
+const decodeJsonLines = (format) => (self) => self.pipe(Stream.mapEffect(parseJson(format)));
+//#endregion
+export { JsonParseError, StructuredDecodeError, decode, decodeJsonLines, fromEffectSchema, parseJson, StructuredFormat_exports as t };
+
+//# sourceMappingURL=StructuredFormat.mjs.map

package/dist/structured-format/StructuredFormat.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"StructuredFormat.mjs","names":[],"sources":["../../src/structured-format/StructuredFormat.ts"],"sourcesContent":["import type { StandardJSONSchemaV1, StandardSchemaV1 } from \"@standard-schema/spec\"\nimport { Data, Effect, Match, Schema, Stream, pipe } from \"effect\"\n\n// ---------------------------------------------------------------------------\n// Types\n// ---------------------------------------------------------------------------\n\n/**\n * Cross-validator schema constraint for structured outputs. Any schema\n * implementing both Standard Schema (runtime validation) and Standard\n * JSON Schema (wire encoding) works directly: Zod 4+, Valibot, ArkType,\n * and Effect Schema after `fromEffectSchema`.\n */\nexport type StructuredSchema<Output = unknown> = StandardSchemaV1<unknown, Output> &\n  StandardJSONSchemaV1<unknown, Output>\n\n/**\n * A schema-bound output the user wants the model to produce. Pairs the\n * cross-validator schema with metadata providers need (name, description,\n * strict-mode flag).\n */\nexport interface StructuredFormat<A> {\n  readonly name: string\n  readonly description?: string\n  readonly schema: StructuredSchema<A>\n  /**\n   * Provider strict-mode flag. OpenAI, Anthropic, and Mistral honour it\n   * (constrained decoding); other providers ignore.\n   */\n  readonly strict?: boolean\n}\n\n/** A single path-scoped validation problem. Library-agnostic shape. */\nexport interface DecodeIssue {\n  readonly path: ReadonlyArray<string | number>\n  readonly message: string\n}\n\n// ---------------------------------------------------------------------------\n// Errors\n// ---------------------------------------------------------------------------\n\n/**\n * Schema validation failed. `raw` is the original text (or stringified\n * value) that failed; `issues` is a flat list of per-field problems.\n */\nexport class StructuredDecodeError extends Data.TaggedError(\"StructuredDecodeError\")<{\n  readonly raw: string\n  readonly issues: ReadonlyArray<DecodeIssue>\n}> {}\n\n/**\n * `JSON.parse` threw on a string that was supposed to be JSON. Distinct\n * from `StructuredDecodeError`: the bytes weren't even JSON.\n */\nexport class JsonParseError extends Data.TaggedError(\"StructuredJsonParseError\")<{\n  readonly raw: string\n  readonly cause: unknown\n}> {}\n\n// ---------------------------------------------------------------------------\n// Constructors\n// ---------------------------------------------------------------------------\n\n/**\n * Wrap an Effect `Schema` as a `StructuredFormat`. Effect Schema doesn't\n * natively implement Standard Schema; this helper installs the\n * `~standard` and JSON Schema interfaces.\n */\nexport const fromEffectSchema = <S extends Schema.Codec<any, any, never, any>>(\n  schema: S,\n  options?: {\n    readonly name?: string\n    readonly description?: string\n    readonly strict?: boolean\n  },\n): StructuredFormat<S[\"Type\"]> => ({\n  name: options?.name ?? \"output\",\n  schema: Schema.toStandardJSONSchemaV1(Schema.toStandardSchemaV1(schema)),\n  ...(options?.description !== undefined && {\n    description: options.description,\n  }),\n  ...(options?.strict !== undefined && { strict: options.strict }),\n})\n\n// ---------------------------------------------------------------------------\n// Standard Schema → DecodeIssue\n// ---------------------------------------------------------------------------\n\nconst propertyKeyToScalar = Match.type<PropertyKey>().pipe(\n  Match.when(Match.string, (s) => s),\n  Match.when(Match.number, (n) => n),\n  Match.when(Match.symbol, (s) => s.toString()),\n  Match.exhaustive,\n)\n\nconst segmentToKey = Match.type<PropertyKey | StandardSchemaV1.PathSegment>().pipe(\n  Match.when(Match.string, (s) => s),\n  Match.when(Match.number, (n) => n),\n  Match.when(Match.symbol, (s) => s.toString()),\n  Match.orElse((segment) => propertyKeyToScalar(segment.key)),\n)\n\nconst issueToDecode = (issue: StandardSchemaV1.Issue): DecodeIssue => ({\n  path: (issue.path ?? []).map(segmentToKey),\n  message: issue.message,\n})\n\n// ---------------------------------------------------------------------------\n// Decoding\n// ---------------------------------------------------------------------------\n\n/**\n * Validate an `unknown` against the format's schema. Returns the typed\n * value or a `StructuredDecodeError`. Standard Schema's `validate` may\n * be async; this function handles both sync and async results.\n */\nexport const decode =\n  <A>(format: StructuredFormat<A>) =>\n  (raw: unknown): Effect.Effect<A, StructuredDecodeError> =>\n    pipe(\n      Effect.promise(async () => format.schema[\"~standard\"].validate(raw)),\n      Effect.flatMap((result) =>\n        result.issues === undefined\n          ? Effect.succeed(result.value)\n          : Effect.fail(\n              new StructuredDecodeError({\n                raw: typeof raw === \"string\" ? raw : JSON.stringify(raw),\n                issues: result.issues.map(issueToDecode),\n              }),\n            ),\n      ),\n    )\n\n/**\n * Parse a JSON string then validate against the format's schema. Two\n * failure modes: `JsonParseError` (bytes weren't JSON) and\n * `StructuredDecodeError` (JSON didn't match the schema).\n */\nexport const parseJson =\n  <A>(format: StructuredFormat<A>) =>\n  (raw: string): Effect.Effect<A, JsonParseError | StructuredDecodeError> =>\n    pipe(\n      Effect.try({\n        try: () => JSON.parse(raw),\n        catch: (cause) => new JsonParseError({ raw, cause }),\n      }),\n      Effect.flatMap(decode(format)),\n    )\n\n/**\n * Stream operator: each input string is JSON-parsed and validated.\n * Failures surface in the stream's failure channel, distinguished by tag.\n */\nexport const decodeJsonLines =\n  <A>(format: StructuredFormat<A>) =>\n  <E, R>(\n    self: Stream.Stream<string, E, R>,\n  ): Stream.Stream<A, E | JsonParseError | StructuredDecodeError, R> =>\n    self.pipe(Stream.mapEffect(parseJson(format)))\n"],"mappings":";;;;;;;;;;;;;;;AA8CA,IAAa,wBAAb,cAA2C,KAAK,YAAY,wBAAwB,CAGjF;;;;;AAMH,IAAa,iBAAb,cAAoC,KAAK,YAAY,2BAA2B,CAG7E;;;;;;AAWH,MAAa,oBACX,QACA,aAKiC;CACjC,MAAM,SAAS,QAAQ;CACvB,QAAQ,OAAO,uBAAuB,OAAO,mBAAmB,OAAO,CAAC;CACxE,GAAI,SAAS,gBAAgB,KAAA,KAAa,EACxC,aAAa,QAAQ,aACtB;CACD,GAAI,SAAS,WAAW,KAAA,KAAa,EAAE,QAAQ,QAAQ,QAAQ;CAChE;AAMD,MAAM,sBAAsB,MAAM,MAAmB,CAAC,KACpD,MAAM,KAAK,MAAM,SAAS,MAAM,EAAE,EAClC,MAAM,KAAK,MAAM,SAAS,MAAM,EAAE,EAClC,MAAM,KAAK,MAAM,SAAS,MAAM,EAAE,UAAU,CAAC,EAC7C,MAAM,WACP;AAED,MAAM,eAAe,MAAM,MAAkD,CAAC,KAC5E,MAAM,KAAK,MAAM,SAAS,MAAM,EAAE,EAClC,MAAM,KAAK,MAAM,SAAS,MAAM,EAAE,EAClC,MAAM,KAAK,MAAM,SAAS,MAAM,EAAE,UAAU,CAAC,EAC7C,MAAM,QAAQ,YAAY,oBAAoB,QAAQ,IAAI,CAAC,CAC5D;AAED,MAAM,iBAAiB,WAAgD;CACrE,OAAO,MAAM,QAAQ,EAAE,EAAE,IAAI,aAAa;CAC1C,SAAS,MAAM;CAChB;;;;;;AAWD,MAAa,UACP,YACH,QACC,KACE,OAAO,QAAQ,YAAY,OAAO,OAAO,aAAa,SAAS,IAAI,CAAC,EACpE,OAAO,SAAS,WACd,OAAO,WAAW,KAAA,IACd,OAAO,QAAQ,OAAO,MAAM,GAC5B,OAAO,KACL,IAAI,sBAAsB;CACxB,KAAK,OAAO,QAAQ,WAAW,MAAM,KAAK,UAAU,IAAI;CACxD,QAAQ,OAAO,OAAO,IAAI,cAAc;CACzC,CAAC,CACH,CACN,CACF;;;;;;AAOL,MAAa,aACP,YACH,QACC,KACE,OAAO,IAAI;CACT,WAAW,KAAK,MAAM,IAAI;CAC1B,QAAQ,UAAU,IAAI,eAAe;EAAE;EAAK;EAAO,CAAC;CACrD,CAAC,EACF,OAAO,QAAQ,OAAO,OAAO,CAAC,CAC/B;;;;;AAML,MAAa,mBACP,YAEF,SAEA,KAAK,KAAK,OAAO,UAAU,UAAU,OAAO,CAAC,CAAC"}

package/dist/testing/MockProvider.d.mts

@@ -0,0 +1,48 @@
+import { m as Item } from "../Items-D1C2686t.mjs";
+import { i as Turn } from "../Turn-rlTfuHaQ.mjs";
+import { LanguageModel, LanguageModelService } from "../language-model/LanguageModel.mjs";
+import { Duration, Effect, Layer } from "effect";
+
+//#region src/testing/MockProvider.d.ts
+interface MockOptions {
+  /**
+   * If set, deltas of each scripted turn are spaced by this duration via
+   * `Schedule.spaced`. Combine with `TestClock.adjust` for deterministic
+   * timing in tests.
+   */
+  readonly deltaInterval?: Duration.Input;
+}
+/**
+ * A scripted mock provider. Pre-canned `Turn` outputs are returned in order,
+ * one per call to `streamTurn`. Each scripted turn is split into synthetic
+ * deltas (text → tool_call_start → tool_call_args_delta → ... → turn_complete)
+ * so streaming consumers can see realistic delta shapes.
+ */
+interface MockRecorder {
+  readonly calls: ReadonlyArray<{
+    readonly history: ReadonlyArray<Item>;
+    readonly turn: Turn;
+  }>;
+}
+declare const layer: (scriptedTurns: ReadonlyArray<Turn>, options?: MockOptions) => Layer.Layer<LanguageModel>;
+/**
+ * Synchronous constructor that returns the `LanguageModelService` value
+ * directly, plus a recorder. Use this when you want to swap models
+ * mid-stream via `Effect.provideService` instead of providing one model
+ * for the whole program via `Layer`.
+ */
+declare const make: (scriptedTurns: ReadonlyArray<Turn>, options?: MockOptions) => {
+  readonly service: LanguageModelService;
+  readonly recorder: Effect.Effect<MockRecorder>;
+};
+/**
+ * Same as `layer`, but also exposes a recorder that captures every call
+ * (history + returned turn).
+ */
+declare const layerWithRecorder: (scriptedTurns: ReadonlyArray<Turn>, options?: MockOptions) => {
+  readonly layer: Layer.Layer<LanguageModel>;
+  readonly recorder: Effect.Effect<MockRecorder>;
+};
+//#endregion
+export { MockOptions, MockRecorder, layer, layerWithRecorder, make };
+//# sourceMappingURL=MockProvider.d.mts.map

package/dist/testing/MockProvider.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MockProvider.d.mts","names":[],"sources":["../../src/testing/MockProvider.ts"],"mappings":";;;;;;UAMiB,WAAA;;AAAjB;;;;WAMW,aAAA,GAAgB,QAAA,CAAS,KAAA;AAAA;;;;AASpC;;;UAAiB,YAAA;EAAA,SACN,KAAA,EAAO,aAAA;IAAA,SACL,OAAA,EAAS,aAAA,CAAc,IAAA;IAAA,SACvB,IAAA,EAAM,IAAA;EAAA;AAAA;AAAA,cAqEN,KAAA,GACX,aAAA,EAAe,aAAA,CAAc,IAAA,GAC7B,OAAA,GAAU,WAAA,KACT,KAAA,CAAM,KAAA,CAAM,aAAA;;;;;;;cAQF,IAAA,GACX,aAAA,EAAe,aAAA,CAAc,IAAA,GAC7B,OAAA,GAAU,WAAA;EAAA,SAED,OAAA,EAAS,oBAAA;EAAA,SACT,QAAA,EAAU,MAAA,CAAO,MAAA,CAAO,YAAA;AAAA;;;;;cAiCtB,iBAAA,GACX,aAAA,EAAe,aAAA,CAAc,IAAA,GAC7B,OAAA,GAAU,WAAA;EAAA,SAED,KAAA,EAAO,KAAA,CAAM,KAAA,CAAM,aAAA;EAAA,SACnB,QAAA,EAAU,MAAA,CAAO,MAAA,CAAO,YAAA;AAAA"}

package/dist/testing/MockProvider.mjs

@@ -0,0 +1,95 @@
+import { InvalidRequest } from "../domain/AiError.mjs";
+import { LanguageModel } from "../language-model/LanguageModel.mjs";
+import { Effect, Layer, Ref, Schedule, Stream } from "effect";
+//#region src/testing/MockProvider.ts
+const turnToDeltas = (turn) => {
+	const deltas = [];
+	for (const item of turn.items) if (item.type === "message" && item.role === "assistant") {
+		for (const block of item.content) if (block.type === "output_text") deltas.push({
+			type: "text_delta",
+			text: block.text
+		});
+	} else if (item.type === "function_call") {
+		deltas.push({
+			type: "tool_call_start",
+			call_id: item.call_id,
+			name: item.name
+		});
+		deltas.push({
+			type: "tool_call_args_delta",
+			call_id: item.call_id,
+			delta: item.arguments
+		});
+	} else if (item.type === "reasoning" && item.summary !== void 0) deltas.push({
+		type: "reasoning_delta",
+		text: item.summary,
+		kind: "summary"
+	});
+	deltas.push({
+		type: "turn_complete",
+		turn
+	});
+	return deltas;
+};
+const pacedDeltas = (turn, options) => {
+	const base = Stream.fromIterable(turnToDeltas(turn));
+	return options?.deltaInterval === void 0 ? base : base.pipe(Stream.schedule(Schedule.spaced(options.deltaInterval)));
+};
+const makeService = (scriptedTurns, options, recordCall) => Effect.gen(function* () {
+	const cursor = yield* Ref.make(0);
+	return LanguageModel.of({ streamTurn: (request) => Stream.unwrap(Effect.gen(function* () {
+		const i = yield* Ref.getAndUpdate(cursor, (n) => n + 1);
+		if (i >= scriptedTurns.length) return Stream.fail(new InvalidRequest({
+			provider: "mock",
+			raw: `MockProvider exhausted: ${scriptedTurns.length} turns scripted, but call ${i + 1} was made`
+		}));
+		const turn = scriptedTurns[i];
+		if (recordCall !== void 0) yield* recordCall(request.history, turn);
+		return pacedDeltas(turn, options);
+	})) });
+});
+const layer = (scriptedTurns, options) => Layer.effect(LanguageModel, makeService(scriptedTurns, options));
+/**
+* Synchronous constructor that returns the `LanguageModelService` value
+* directly, plus a recorder. Use this when you want to swap models
+* mid-stream via `Effect.provideService` instead of providing one model
+* for the whole program via `Layer`.
+*/
+const make = (scriptedTurns, options) => {
+	const cursor = Ref.makeUnsafe(0);
+	const callsRef = Ref.makeUnsafe([]);
+	return {
+		service: { streamTurn: (request) => Stream.unwrap(Effect.gen(function* () {
+			const i = yield* Ref.getAndUpdate(cursor, (n) => n + 1);
+			if (i >= scriptedTurns.length) return Stream.fail(new InvalidRequest({
+				provider: "mock",
+				raw: `MockProvider exhausted: ${scriptedTurns.length} turns scripted, but call ${i + 1} was made`
+			}));
+			const turn = scriptedTurns[i];
+			yield* Ref.update(callsRef, (xs) => [...xs, {
+				history: request.history,
+				turn
+			}]);
+			return pacedDeltas(turn, options);
+		})) },
+		recorder: Ref.get(callsRef).pipe(Effect.map((calls) => ({ calls })))
+	};
+};
+/**
+* Same as `layer`, but also exposes a recorder that captures every call
+* (history + returned turn).
+*/
+const layerWithRecorder = (scriptedTurns, options) => {
+	const callsRef = Ref.makeUnsafe([]);
+	return {
+		layer: Layer.effect(LanguageModel, makeService(scriptedTurns, options, (history, turn) => Ref.update(callsRef, (xs) => [...xs, {
+			history,
+			turn
+		}]))),
+		recorder: Ref.get(callsRef).pipe(Effect.map((calls) => ({ calls })))
+	};
+};
+//#endregion
+export { layer, layerWithRecorder, make };
+
+//# sourceMappingURL=MockProvider.mjs.map

package/dist/testing/MockProvider.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"MockProvider.mjs","names":["AiError.InvalidRequest"],"sources":["../../src/testing/MockProvider.ts"],"sourcesContent":["import { Duration, Effect, Layer, Ref, Schedule, Stream } from \"effect\"\nimport * as AiError from \"../domain/AiError.js\"\nimport type { Item } from \"../domain/Items.js\"\nimport { LanguageModel, type LanguageModelService } from \"../language-model/LanguageModel.js\"\nimport type { Turn, TurnEvent } from \"../domain/Turn.js\"\n\nexport interface MockOptions {\n  /**\n   * If set, deltas of each scripted turn are spaced by this duration via\n   * `Schedule.spaced`. Combine with `TestClock.adjust` for deterministic\n   * timing in tests.\n   */\n  readonly deltaInterval?: Duration.Input\n}\n\n/**\n * A scripted mock provider. Pre-canned `Turn` outputs are returned in order,\n * one per call to `streamTurn`. Each scripted turn is split into synthetic\n * deltas (text → tool_call_start → tool_call_args_delta → ... → turn_complete)\n * so streaming consumers can see realistic delta shapes.\n */\nexport interface MockRecorder {\n  readonly calls: ReadonlyArray<{\n    readonly history: ReadonlyArray<Item>\n    readonly turn: Turn\n  }>\n}\n\nconst turnToDeltas = (turn: Turn): ReadonlyArray<TurnEvent> => {\n  const deltas: TurnEvent[] = []\n  for (const item of turn.items) {\n    if (item.type === \"message\" && item.role === \"assistant\") {\n      for (const block of item.content) {\n        if (block.type === \"output_text\") {\n          deltas.push({ type: \"text_delta\", text: block.text })\n        }\n      }\n    } else if (item.type === \"function_call\") {\n      deltas.push({\n        type: \"tool_call_start\",\n        call_id: item.call_id,\n        name: item.name,\n      })\n      deltas.push({\n        type: \"tool_call_args_delta\",\n        call_id: item.call_id,\n        delta: item.arguments,\n      })\n    } else if (item.type === \"reasoning\" && item.summary !== undefined) {\n      deltas.push({ type: \"reasoning_delta\", text: item.summary, kind: \"summary\" })\n    }\n  }\n  deltas.push({ type: \"turn_complete\", turn })\n  return deltas\n}\n\nconst pacedDeltas = (turn: Turn, options?: MockOptions): Stream.Stream<TurnEvent> => {\n  const base = Stream.fromIterable(turnToDeltas(turn))\n  return options?.deltaInterval === undefined\n    ? base\n    : base.pipe(Stream.schedule(Schedule.spaced(options.deltaInterval)))\n}\n\nconst makeService = (\n  scriptedTurns: ReadonlyArray<Turn>,\n  options?: MockOptions,\n  recordCall?: (history: ReadonlyArray<Item>, turn: Turn) => Effect.Effect<void>,\n) =>\n  Effect.gen(function* () {\n    const cursor = yield* Ref.make(0)\n    return LanguageModel.of({\n      streamTurn: (request) =>\n        Stream.unwrap(\n          Effect.gen(function* () {\n            const i = yield* Ref.getAndUpdate(cursor, (n) => n + 1)\n            if (i >= scriptedTurns.length) {\n              return Stream.fail(\n                new AiError.InvalidRequest({\n                  provider: \"mock\",\n                  raw: `MockProvider exhausted: ${scriptedTurns.length} turns scripted, but call ${i + 1} was made`,\n                }),\n              )\n            }\n            const turn = scriptedTurns[i]!\n            if (recordCall !== undefined) {\n              yield* recordCall(request.history, turn)\n            }\n            return pacedDeltas(turn, options)\n          }),\n        ),\n    })\n  })\n\nexport const layer = (\n  scriptedTurns: ReadonlyArray<Turn>,\n  options?: MockOptions,\n): Layer.Layer<LanguageModel> => Layer.effect(LanguageModel, makeService(scriptedTurns, options))\n\n/**\n * Synchronous constructor that returns the `LanguageModelService` value\n * directly, plus a recorder. Use this when you want to swap models\n * mid-stream via `Effect.provideService` instead of providing one model\n * for the whole program via `Layer`.\n */\nexport const make = (\n  scriptedTurns: ReadonlyArray<Turn>,\n  options?: MockOptions,\n): {\n  readonly service: LanguageModelService\n  readonly recorder: Effect.Effect<MockRecorder>\n} => {\n  const cursor = Ref.makeUnsafe(0)\n  const callsRef = Ref.makeUnsafe<ReadonlyArray<{ history: ReadonlyArray<Item>; turn: Turn }>>([])\n  const service: LanguageModelService = {\n    streamTurn: (request) =>\n      Stream.unwrap(\n        Effect.gen(function* () {\n          const i = yield* Ref.getAndUpdate(cursor, (n) => n + 1)\n          if (i >= scriptedTurns.length) {\n            return Stream.fail(\n              new AiError.InvalidRequest({\n                provider: \"mock\",\n                raw: `MockProvider exhausted: ${scriptedTurns.length} turns scripted, but call ${i + 1} was made`,\n              }),\n            )\n          }\n          const turn = scriptedTurns[i]!\n          yield* Ref.update(callsRef, (xs) => [...xs, { history: request.history, turn }])\n          return pacedDeltas(turn, options)\n        }),\n      ),\n  }\n  return {\n    service,\n    recorder: Ref.get(callsRef).pipe(Effect.map((calls) => ({ calls }))),\n  }\n}\n\n/**\n * Same as `layer`, but also exposes a recorder that captures every call\n * (history + returned turn).\n */\nexport const layerWithRecorder = (\n  scriptedTurns: ReadonlyArray<Turn>,\n  options?: MockOptions,\n): {\n  readonly layer: Layer.Layer<LanguageModel>\n  readonly recorder: Effect.Effect<MockRecorder>\n} => {\n  const callsRef = Ref.makeUnsafe<ReadonlyArray<{ history: ReadonlyArray<Item>; turn: Turn }>>([])\n  const live = Layer.effect(\n    LanguageModel,\n    makeService(scriptedTurns, options, (history, turn) =>\n      Ref.update(callsRef, (xs) => [...xs, { history, turn }]),\n    ),\n  )\n  return {\n    layer: live,\n    recorder: Ref.get(callsRef).pipe(Effect.map((calls) => ({ calls }))),\n  }\n}\n"],"mappings":";;;;AA4BA,MAAM,gBAAgB,SAAyC;CAC7D,MAAM,SAAsB,EAAE;AAC9B,MAAK,MAAM,QAAQ,KAAK,MACtB,KAAI,KAAK,SAAS,aAAa,KAAK,SAAS;OACtC,MAAM,SAAS,KAAK,QACvB,KAAI,MAAM,SAAS,cACjB,QAAO,KAAK;GAAE,MAAM;GAAc,MAAM,MAAM;GAAM,CAAC;YAGhD,KAAK,SAAS,iBAAiB;AACxC,SAAO,KAAK;GACV,MAAM;GACN,SAAS,KAAK;GACd,MAAM,KAAK;GACZ,CAAC;AACF,SAAO,KAAK;GACV,MAAM;GACN,SAAS,KAAK;GACd,OAAO,KAAK;GACb,CAAC;YACO,KAAK,SAAS,eAAe,KAAK,YAAY,KAAA,EACvD,QAAO,KAAK;EAAE,MAAM;EAAmB,MAAM,KAAK;EAAS,MAAM;EAAW,CAAC;AAGjF,QAAO,KAAK;EAAE,MAAM;EAAiB;EAAM,CAAC;AAC5C,QAAO;;AAGT,MAAM,eAAe,MAAY,YAAoD;CACnF,MAAM,OAAO,OAAO,aAAa,aAAa,KAAK,CAAC;AACpD,QAAO,SAAS,kBAAkB,KAAA,IAC9B,OACA,KAAK,KAAK,OAAO,SAAS,SAAS,OAAO,QAAQ,cAAc,CAAC,CAAC;;AAGxE,MAAM,eACJ,eACA,SACA,eAEA,OAAO,IAAI,aAAa;CACtB,MAAM,SAAS,OAAO,IAAI,KAAK,EAAE;AACjC,QAAO,cAAc,GAAG,EACtB,aAAa,YACX,OAAO,OACL,OAAO,IAAI,aAAa;EACtB,MAAM,IAAI,OAAO,IAAI,aAAa,SAAS,MAAM,IAAI,EAAE;AACvD,MAAI,KAAK,cAAc,OACrB,QAAO,OAAO,KACZ,IAAIA,eAAuB;GACzB,UAAU;GACV,KAAK,2BAA2B,cAAc,OAAO,4BAA4B,IAAI,EAAE;GACxF,CAAC,CACH;EAEH,MAAM,OAAO,cAAc;AAC3B,MAAI,eAAe,KAAA,EACjB,QAAO,WAAW,QAAQ,SAAS,KAAK;AAE1C,SAAO,YAAY,MAAM,QAAQ;GACjC,CACH,EACJ,CAAC;EACF;AAEJ,MAAa,SACX,eACA,YAC+B,MAAM,OAAO,eAAe,YAAY,eAAe,QAAQ,CAAC;;;;;;;AAQjG,MAAa,QACX,eACA,YAIG;CACH,MAAM,SAAS,IAAI,WAAW,EAAE;CAChC,MAAM,WAAW,IAAI,WAAwE,EAAE,CAAC;AAoBhG,QAAO;EACL,SAAA,EAnBA,aAAa,YACX,OAAO,OACL,OAAO,IAAI,aAAa;GACtB,MAAM,IAAI,OAAO,IAAI,aAAa,SAAS,MAAM,IAAI,EAAE;AACvD,OAAI,KAAK,cAAc,OACrB,QAAO,OAAO,KACZ,IAAIA,eAAuB;IACzB,UAAU;IACV,KAAK,2BAA2B,cAAc,OAAO,4BAA4B,IAAI,EAAE;IACxF,CAAC,CACH;GAEH,MAAM,OAAO,cAAc;AAC3B,UAAO,IAAI,OAAO,WAAW,OAAO,CAAC,GAAG,IAAI;IAAE,SAAS,QAAQ;IAAS;IAAM,CAAC,CAAC;AAChF,UAAO,YAAY,MAAM,QAAQ;IACjC,CACH,EAGI;EACP,UAAU,IAAI,IAAI,SAAS,CAAC,KAAK,OAAO,KAAK,WAAW,EAAE,OAAO,EAAE,CAAC;EACrE;;;;;;AAOH,MAAa,qBACX,eACA,YAIG;CACH,MAAM,WAAW,IAAI,WAAwE,EAAE,CAAC;AAOhG,QAAO;EACL,OAPW,MAAM,OACjB,eACA,YAAY,eAAe,UAAU,SAAS,SAC5C,IAAI,OAAO,WAAW,OAAO,CAAC,GAAG,IAAI;GAAE;GAAS;GAAM,CAAC,CAAC,CACzD,CAGU;EACX,UAAU,IAAI,IAAI,SAAS,CAAC,KAAK,OAAO,KAAK,WAAW,EAAE,OAAO,EAAE,CAAC;EACrE"}

package/dist/tool/HistoryCheck.d.mts

@@ -0,0 +1,24 @@
+import { m as Item, o as FunctionCall } from "../Items-D1C2686t.mjs";
+import { n as ToolResult } from "../Outcome-C2JYknCu.mjs";
+
+//#region src/tool/HistoryCheck.d.ts
+/**
+ * Return every `function_call` in `history` that does not have a matching
+ * `function_call_output` later in `history` (correlated by `call_id`).
+ * Empty result = history is provider-submittable from this invariant.
+ */
+declare const findUnansweredCalls: (history: ReadonlyArray<Item>) => ReadonlyArray<FunctionCall>;
+/** Cheap predicate: is this history submittable to a provider? */
+declare const isReconciled: (history: ReadonlyArray<Item>) => boolean;
+/**
+ * Synthesize cancellation results for every unanswered call. Caller maps
+ * via `toFunctionCallOutput` and appends to history before submitting.
+ *
+ * Use when: a new user message arrives mid-approval; an approval timer
+ * fires; a persisted checkpoint contains orphans (crash recovery); a
+ * stateless HTTP server reconstructed history from a stale checkpoint.
+ */
+declare const cancelAllPending: (history: ReadonlyArray<Item>, reason?: string) => ReadonlyArray<ToolResult>;
+//#endregion
+export { cancelAllPending, findUnansweredCalls, isReconciled };
+//# sourceMappingURL=HistoryCheck.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"HistoryCheck.d.mts","names":[],"sources":["../../src/tool/HistoryCheck.ts"],"mappings":";;;;;;;;;cAyBa,mBAAA,GACX,OAAA,EAAS,aAAA,CAAc,IAAA,MACtB,aAAA,CAAc,YAAA;AAMjB;AAAA,cAAa,YAAA,GAAgB,OAAA,EAAS,aAAA,CAAc,IAAA;;;;;;;;AAWpD;cAAa,gBAAA,GACX,OAAA,EAAS,aAAA,CAAc,IAAA,GACvB,MAAA,cACC,aAAA,CAAc,UAAA"}

package/dist/tool/HistoryCheck.mjs

@@ -0,0 +1,39 @@
+import { isFunctionCall, isFunctionCallOutput } from "../domain/Items.mjs";
+import { cancelled } from "./Outcome.mjs";
+//#region src/tool/HistoryCheck.ts
+/**
+* History-consistency primitives. Useful even WITHOUT HITL.
+*
+* Every provider rejects a new request if any prior `function_call` lacks
+* a matching `function_call_output`. Multi-turn flows that can be
+* interrupted, restarted, or branched (HITL, mid-stream abort, persisted
+* checkpoints, stateless HTTP servers) need to detect orphans and
+* synthesize closing outputs before submitting.
+*
+* Recipe author calls these at known transition points (right before the
+* next provider request). Not invoked from inside the loop.
+*/
+/**
+* Return every `function_call` in `history` that does not have a matching
+* `function_call_output` later in `history` (correlated by `call_id`).
+* Empty result = history is provider-submittable from this invariant.
+*/
+const findUnansweredCalls = (history) => {
+	const answered = new Set(history.filter(isFunctionCallOutput).map((o) => o.call_id));
+	return history.filter(isFunctionCall).filter((c) => !answered.has(c.call_id));
+};
+/** Cheap predicate: is this history submittable to a provider? */
+const isReconciled = (history) => findUnansweredCalls(history).length === 0;
+/**
+* Synthesize cancellation results for every unanswered call. Caller maps
+* via `toFunctionCallOutput` and appends to history before submitting.
+*
+* Use when: a new user message arrives mid-approval; an approval timer
+* fires; a persisted checkpoint contains orphans (crash recovery); a
+* stateless HTTP server reconstructed history from a stale checkpoint.
+*/
+const cancelAllPending = (history, reason) => findUnansweredCalls(history).map((call) => cancelled(call, reason));
+//#endregion
+export { cancelAllPending, findUnansweredCalls, isReconciled };
+
+//# sourceMappingURL=HistoryCheck.mjs.map

package/dist/tool/HistoryCheck.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"HistoryCheck.mjs","names":[],"sources":["../../src/tool/HistoryCheck.ts"],"sourcesContent":["/**\n * History-consistency primitives. Useful even WITHOUT HITL.\n *\n * Every provider rejects a new request if any prior `function_call` lacks\n * a matching `function_call_output`. Multi-turn flows that can be\n * interrupted, restarted, or branched (HITL, mid-stream abort, persisted\n * checkpoints, stateless HTTP servers) need to detect orphans and\n * synthesize closing outputs before submitting.\n *\n * Recipe author calls these at known transition points (right before the\n * next provider request). Not invoked from inside the loop.\n */\nimport {\n  type FunctionCall,\n  type Item,\n  isFunctionCall,\n  isFunctionCallOutput,\n} from \"../domain/Items.js\"\nimport { type ToolResult, cancelled } from \"./Outcome.js\"\n\n/**\n * Return every `function_call` in `history` that does not have a matching\n * `function_call_output` later in `history` (correlated by `call_id`).\n * Empty result = history is provider-submittable from this invariant.\n */\nexport const findUnansweredCalls = (\n  history: ReadonlyArray<Item>,\n): ReadonlyArray<FunctionCall> => {\n  const answered = new Set(history.filter(isFunctionCallOutput).map((o) => o.call_id))\n  return history.filter(isFunctionCall).filter((c) => !answered.has(c.call_id))\n}\n\n/** Cheap predicate: is this history submittable to a provider? */\nexport const isReconciled = (history: ReadonlyArray<Item>): boolean =>\n  findUnansweredCalls(history).length === 0\n\n/**\n * Synthesize cancellation results for every unanswered call. Caller maps\n * via `toFunctionCallOutput` and appends to history before submitting.\n *\n * Use when: a new user message arrives mid-approval; an approval timer\n * fires; a persisted checkpoint contains orphans (crash recovery); a\n * stateless HTTP server reconstructed history from a stale checkpoint.\n */\nexport const cancelAllPending = (\n  history: ReadonlyArray<Item>,\n  reason?: string,\n): ReadonlyArray<ToolResult> =>\n  findUnansweredCalls(history).map((call) => cancelled(call, reason))\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAyBA,MAAa,uBACX,YACgC;CAChC,MAAM,WAAW,IAAI,IAAI,QAAQ,OAAO,qBAAqB,CAAC,KAAK,MAAM,EAAE,QAAQ,CAAC;AACpF,QAAO,QAAQ,OAAO,eAAe,CAAC,QAAQ,MAAM,CAAC,SAAS,IAAI,EAAE,QAAQ,CAAC;;;AAI/E,MAAa,gBAAgB,YAC3B,oBAAoB,QAAQ,CAAC,WAAW;;;;;;;;;AAU1C,MAAa,oBACX,SACA,WAEA,oBAAoB,QAAQ,CAAC,KAAK,SAAS,UAAU,MAAM,OAAO,CAAC"}

package/dist/tool/Outcome.d.mts

@@ -0,0 +1,2 @@
+import { a as execute, c as isValue, d as toFunctionCallOutput, i as denied, l as reject, n as ToolResult, o as executionError, r as cancelled, s as isFailure, t as ToolDecision, u as rejected } from "../Outcome-C2JYknCu.mjs";
+export { ToolDecision, ToolResult, cancelled, denied, execute, executionError, isFailure, isValue, reject, rejected, toFunctionCallOutput };

package/dist/tool/Outcome.mjs

@@ -0,0 +1,45 @@
+import { functionCallOutput } from "../domain/Items.mjs";
+import { Match } from "effect";
+//#region src/tool/Outcome.ts
+/**
+* Pre-execution decision (`ToolDecision`) and post-execution result
+* (`ToolResult`) for the resolver-based executor.
+*
+*   - Resolver returns ToolDecision (Execute | Reject(result)) per call.
+*   - Executor emits ToolResult (Value | Failure) per call.
+*
+* Wire conversion stays at the recipe boundary via `toFunctionCallOutput`
+* so recipes can inspect, redact, or audit values before serialization.
+*
+* `output` and `reason` are `string`, not `unknown`: the wire wants strings,
+* and `unknown` would invite non-serializable values (Date, Map, BigInt,
+* fn). Recipes that want structured detail JSON.stringify themselves.
+*/
+const isValue = (r) => r._tag === "Value";
+const isFailure = (r) => r._tag === "Failure";
+const execute = { _tag: "Execute" };
+const reject = (result) => ({
+	_tag: "Reject",
+	result
+});
+const rejected = (call, kind, reason) => ({
+	_tag: "Failure",
+	call_id: call.call_id,
+	tool: call.name,
+	kind,
+	...reason !== void 0 ? { reason } : {}
+});
+/** Explicit user/policy rejection. */
+const denied = (call, reason) => rejected(call, "denied", reason);
+/** Implicit non-answer (follow-up, inactivity, abort). */
+const cancelled = (call, reason) => rejected(call, "cancelled", reason);
+/** Tool's own execution failed (parse error, schema, runtime crash). */
+const executionError = (call, reason) => rejected(call, "execution_error", reason);
+const toFunctionCallOutput = (r) => Match.value(r).pipe(Match.tag("Value", (v) => functionCallOutput(v.call_id, JSON.stringify(v.value))), Match.tag("Failure", (f) => functionCallOutput(f.call_id, JSON.stringify(f.reason !== void 0 ? {
+	kind: f.kind,
+	reason: f.reason
+} : { kind: f.kind }))), Match.exhaustive);
+//#endregion
+export { cancelled, denied, execute, executionError, isFailure, isValue, reject, rejected, toFunctionCallOutput };
+
+//# sourceMappingURL=Outcome.mjs.map

package/dist/tool/Outcome.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Outcome.mjs","names":[],"sources":["../../src/tool/Outcome.ts"],"sourcesContent":["/**\n * Pre-execution decision (`ToolDecision`) and post-execution result\n * (`ToolResult`) for the resolver-based executor.\n *\n *   - Resolver returns ToolDecision (Execute | Reject(result)) per call.\n *   - Executor emits ToolResult (Value | Failure) per call.\n *\n * Wire conversion stays at the recipe boundary via `toFunctionCallOutput`\n * so recipes can inspect, redact, or audit values before serialization.\n *\n * `output` and `reason` are `string`, not `unknown`: the wire wants strings,\n * and `unknown` would invite non-serializable values (Date, Map, BigInt,\n * fn). Recipes that want structured detail JSON.stringify themselves.\n */\nimport { Match } from \"effect\"\nimport type { FunctionCall, FunctionCallOutput } from \"../domain/Items.js\"\nimport { functionCallOutput } from \"../domain/Items.js\"\n\n// ---------------------------------------------------------------------------\n// ToolResult\n// ---------------------------------------------------------------------------\n\nexport type ToolResult =\n  | {\n      readonly _tag: \"Value\"\n      readonly call_id: string\n      readonly tool: string\n      readonly value: unknown\n    }\n  | {\n      readonly _tag: \"Failure\"\n      readonly call_id: string\n      readonly tool: string\n      readonly kind: string\n      readonly reason?: string\n    }\n\nexport const isValue = (r: ToolResult): r is Extract<ToolResult, { _tag: \"Value\" }> =>\n  r._tag === \"Value\"\n\nexport const isFailure = (r: ToolResult): r is Extract<ToolResult, { _tag: \"Failure\" }> =>\n  r._tag === \"Failure\"\n\n// ---------------------------------------------------------------------------\n// ToolDecision\n// ---------------------------------------------------------------------------\n\nexport type ToolDecision =\n  | { readonly _tag: \"Execute\" }\n  | { readonly _tag: \"Reject\"; readonly result: ToolResult }\n\nexport const execute: ToolDecision = { _tag: \"Execute\" }\n\nexport const reject = (result: ToolResult): ToolDecision => ({ _tag: \"Reject\", result })\n\n// ---------------------------------------------------------------------------\n// Synthesizers. `denied` and `cancelled` are operationally distinct;\n// anything else is just a recipe-chosen `kind` via `rejected`.\n// ---------------------------------------------------------------------------\n\nexport const rejected = (\n  call: FunctionCall,\n  kind: string,\n  reason?: string,\n): ToolResult => ({\n  _tag: \"Failure\",\n  call_id: call.call_id,\n  tool: call.name,\n  kind,\n  ...(reason !== undefined ? { reason } : {}),\n})\n\n/** Explicit user/policy rejection. */\nexport const denied = (call: FunctionCall, reason?: string): ToolResult =>\n  rejected(call, \"denied\", reason)\n\n/** Implicit non-answer (follow-up, inactivity, abort). */\nexport const cancelled = (call: FunctionCall, reason?: string): ToolResult =>\n  rejected(call, \"cancelled\", reason)\n\n/** Tool's own execution failed (parse error, schema, runtime crash). */\nexport const executionError = (call: FunctionCall, reason: string): ToolResult =>\n  rejected(call, \"execution_error\", reason)\n\n// ---------------------------------------------------------------------------\n// Wire conversion - the one place structured → string happens.\n// ---------------------------------------------------------------------------\n\nexport const toFunctionCallOutput = (r: ToolResult): FunctionCallOutput =>\n  Match.value(r).pipe(\n    Match.tag(\"Value\", (v) => functionCallOutput(v.call_id, JSON.stringify(v.value))),\n    Match.tag(\"Failure\", (f) =>\n      functionCallOutput(\n        f.call_id,\n        JSON.stringify(\n          f.reason !== undefined ? { kind: f.kind, reason: f.reason } : { kind: f.kind },\n        ),\n      ),\n    ),\n    Match.exhaustive,\n  )\n"],"mappings":";;;;;;;;;;;;;;;;;AAqCA,MAAa,WAAW,MACtB,EAAE,SAAS;AAEb,MAAa,aAAa,MACxB,EAAE,SAAS;AAUb,MAAa,UAAwB,EAAE,MAAM,WAAW;AAExD,MAAa,UAAU,YAAsC;CAAE,MAAM;CAAU;CAAQ;AAOvF,MAAa,YACX,MACA,MACA,YACgB;CAChB,MAAM;CACN,SAAS,KAAK;CACd,MAAM,KAAK;CACX;CACA,GAAI,WAAW,KAAA,IAAY,EAAE,QAAQ,GAAG,EAAE;CAC3C;;AAGD,MAAa,UAAU,MAAoB,WACzC,SAAS,MAAM,UAAU,OAAO;;AAGlC,MAAa,aAAa,MAAoB,WAC5C,SAAS,MAAM,aAAa,OAAO;;AAGrC,MAAa,kBAAkB,MAAoB,WACjD,SAAS,MAAM,mBAAmB,OAAO;AAM3C,MAAa,wBAAwB,MACnC,MAAM,MAAM,EAAE,CAAC,KACb,MAAM,IAAI,UAAU,MAAM,mBAAmB,EAAE,SAAS,KAAK,UAAU,EAAE,MAAM,CAAC,CAAC,EACjF,MAAM,IAAI,YAAY,MACpB,mBACE,EAAE,SACF,KAAK,UACH,EAAE,WAAW,KAAA,IAAY;CAAE,MAAM,EAAE;CAAM,QAAQ,EAAE;CAAQ,GAAG,EAAE,MAAM,EAAE,MAAM,CAC/E,CACF,CACF,EACD,MAAM,WACP"}

package/dist/tool/Resolvers.d.mts

@@ -0,0 +1,44 @@
+import { o as FunctionCall } from "../Items-D1C2686t.mjs";
+import { n as ToolResult, t as ToolDecision } from "../Outcome-C2JYknCu.mjs";
+import { t as ToolEvent } from "../ToolEvent-B2N10hr3.mjs";
+import { Resolver } from "./Toolkit.mjs";
+import { Effect, Queue, Scope, Stream } from "effect";
+
+//#region src/tool/Resolvers.d.ts
+interface Verdict {
+  readonly call_id: string;
+  readonly decision: "approve" | "deny";
+  readonly reason?: string;
+}
+/**
+ * Queue-backed resolver. The router fiber drains verdicts and resolves
+ * pre-registered Deferreds keyed by `call_id`. Returns the resolver and
+ * a stream of `ApprovalRequested` events for the gated calls; the recipe
+ * merges the announce stream into its consumer view.
+ */
+declare const fromVerdictQueue: (predicate: (call: FunctionCall) => boolean, verdicts: Queue.Dequeue<Verdict>) => (calls: ReadonlyArray<FunctionCall>) => Effect.Effect<{
+  readonly resolve: Resolver;
+  readonly announce: Stream.Stream<ToolEvent>;
+}, never, Scope.Scope>;
+type ApprovalMapEntry = {
+  readonly decision: "approve";
+} | {
+  readonly decision: "deny";
+  readonly reason?: string;
+};
+declare const fromApprovalMap: (predicate: (call: FunctionCall) => boolean, approvals: ReadonlyMap<string, ApprovalMapEntry>) => Resolver;
+/**
+ * Authz gate. `canApprove` runs BEFORE the inner resolver; failures
+ * short-circuit to a `permission_denied` rejection. Override `onForbidden`
+ * if your audit format wants a different kind or reason.
+ */
+declare const withPermissions: (inner: Resolver, canApprove: (call: FunctionCall) => Effect.Effect<boolean>, onForbidden?: (call: FunctionCall) => ToolResult) => Resolver;
+/**
+ * Fallback gate. If `inner` returns a Reject whose result matches the
+ * `recoverable` predicate, run `fallback(call)` instead and use that
+ * decision. Otherwise pass the original Reject through.
+ */
+declare const withFallback: (inner: Resolver, recoverable: (result: ToolResult) => boolean, fallback: (call: FunctionCall) => Effect.Effect<ToolDecision>) => Resolver;
+//#endregion
+export { ApprovalMapEntry, Verdict, fromApprovalMap, fromVerdictQueue, withFallback, withPermissions };
+//# sourceMappingURL=Resolvers.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Resolvers.d.mts","names":[],"sources":["../../src/tool/Resolvers.ts"],"mappings":";;;;;;;UA8BiB,OAAA;EAAA,SACN,OAAA;EAAA,SACA,QAAA;EAAA,SACA,MAAA;AAAA;;;;;;;cASE,gBAAA,GAET,SAAA,GAAY,IAAA,EAAM,YAAA,cAClB,QAAA,EAAU,KAAA,CAAM,OAAA,CAAQ,OAAA,OAGxB,KAAA,EAAO,aAAA,CAAc,YAAA,MACpB,MAAA,CAAO,MAAA;EAAA,SAEG,OAAA,EAAS,QAAA;EAAA,SACT,QAAA,EAAU,MAAA,CAAO,MAAA,CAAO,SAAA;AAAA,UAGnC,KAAA,CAAM,KAAA;AAAA,KAkDE,gBAAA;EAAA,SACG,QAAA;AAAA;EAAA,SACA,QAAA;EAAA,SAA2B,MAAA;AAAA;AAAA,cAE7B,eAAA,GAET,SAAA,GAAY,IAAA,EAAM,YAAA,cAClB,SAAA,EAAW,WAAA,SAAoB,gBAAA,MAC9B,QAAA;;;;;;cAmBQ,eAAA,GAET,KAAA,EAAO,QAAA,EACP,UAAA,GAAa,IAAA,EAAM,YAAA,KAAiB,MAAA,CAAO,MAAA,WAC3C,WAAA,IAAc,IAAA,EAAM,YAAA,KAAiB,UAAA,KAEpC,QAAA;;;;;;cAaQ,YAAA,GAET,KAAA,EAAO,QAAA,EACP,WAAA,GAAc,MAAA,EAAQ,UAAA,cACtB,QAAA,GAAW,IAAA,EAAM,YAAA,KAAiB,MAAA,CAAO,MAAA,CAAO,YAAA,MAC/C,QAAA"}

package/dist/tool/Resolvers.mjs

@@ -0,0 +1,67 @@
+import { cancelled, denied, execute, reject, rejected } from "./Outcome.mjs";
+import { Deferred, Effect, Queue, Stream } from "effect";
+//#region src/tool/Resolvers.ts
+/**
+* Ready-made `Resolver`s for the two transport flavors plus combinators
+* for layering policy on top.
+*
+*   - `fromVerdictQueue` : long-lived channel (WebSocket / SSE).
+*   - `fromApprovalMap`  : request-shaped (HTTP chat).
+*   - `withPermissions`  : authz wrapper.
+*   - `withFallback`     : recovery wrapper.
+*
+* None of these know about the executor's stream shape; they just produce
+* `Effect<ToolDecision>`s a `Resolver` can return.
+*/
+/**
+* Queue-backed resolver. The router fiber drains verdicts and resolves
+* pre-registered Deferreds keyed by `call_id`. Returns the resolver and
+* a stream of `ApprovalRequested` events for the gated calls; the recipe
+* merges the announce stream into its consumer view.
+*/
+const fromVerdictQueue = (predicate, verdicts) => (calls) => Effect.gen(function* () {
+	const gated = calls.filter(predicate);
+	const entries = yield* Effect.forEach(gated, (call) => Deferred.make().pipe(Effect.map((d) => [call.call_id, d])));
+	const deferreds = new Map(entries);
+	yield* Effect.forkScoped(Effect.forever(Effect.gen(function* () {
+		const v = yield* Queue.take(verdicts);
+		const d = deferreds.get(v.call_id);
+		if (d !== void 0) yield* Deferred.succeed(d, v);
+	})));
+	const resolve = (call) => {
+		if (!predicate(call)) return Effect.succeed(execute);
+		const d = deferreds.get(call.call_id);
+		return Deferred.await(d).pipe(Effect.map((v) => v.decision === "approve" ? execute : reject(denied(call, v.reason))));
+	};
+	return {
+		resolve,
+		announce: Stream.fromIterable(gated.map((call) => ({
+			_tag: "ApprovalRequested",
+			call_id: call.call_id,
+			tool: call.name,
+			arguments: call.arguments
+		})))
+	};
+});
+const fromApprovalMap = (predicate, approvals) => (call) => {
+	if (!predicate(call)) return Effect.succeed(execute);
+	const v = approvals.get(call.call_id);
+	if (v === void 0) return Effect.succeed(reject(cancelled(call)));
+	return Effect.succeed(v.decision === "approve" ? execute : reject(denied(call, v.reason)));
+};
+/**
+* Authz gate. `canApprove` runs BEFORE the inner resolver; failures
+* short-circuit to a `permission_denied` rejection. Override `onForbidden`
+* if your audit format wants a different kind or reason.
+*/
+const withPermissions = (inner, canApprove, onForbidden = (call) => rejected(call, "permission_denied", "missing permissions")) => (call) => canApprove(call).pipe(Effect.flatMap((allowed) => allowed ? inner(call) : Effect.succeed(reject(onForbidden(call)))));
+/**
+* Fallback gate. If `inner` returns a Reject whose result matches the
+* `recoverable` predicate, run `fallback(call)` instead and use that
+* decision. Otherwise pass the original Reject through.
+*/
+const withFallback = (inner, recoverable, fallback) => (call) => inner(call).pipe(Effect.flatMap((decision) => decision._tag === "Reject" && recoverable(decision.result) ? fallback(call) : Effect.succeed(decision)));
+//#endregion
+export { fromApprovalMap, fromVerdictQueue, withFallback, withPermissions };
+
+//# sourceMappingURL=Resolvers.mjs.map

package/dist/tool/Resolvers.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Resolvers.mjs","names":[],"sources":["../../src/tool/Resolvers.ts"],"sourcesContent":["/**\n * Ready-made `Resolver`s for the two transport flavors plus combinators\n * for layering policy on top.\n *\n *   - `fromVerdictQueue` : long-lived channel (WebSocket / SSE).\n *   - `fromApprovalMap`  : request-shaped (HTTP chat).\n *   - `withPermissions`  : authz wrapper.\n *   - `withFallback`     : recovery wrapper.\n *\n * None of these know about the executor's stream shape; they just produce\n * `Effect<ToolDecision>`s a `Resolver` can return.\n */\nimport { Deferred, Effect, Queue, Scope, Stream } from \"effect\"\nimport type { FunctionCall } from \"../domain/Items.js\"\nimport {\n  type ToolDecision,\n  type ToolResult,\n  cancelled,\n  denied,\n  execute,\n  reject,\n  rejected,\n} from \"./Outcome.js\"\nimport type { Resolver } from \"./Toolkit.js\"\nimport type { ToolEvent } from \"./ToolEvent.js\"\n\n// ---------------------------------------------------------------------------\n// Verdict queue (WebSocket-style transport).\n// ---------------------------------------------------------------------------\n\nexport interface Verdict {\n  readonly call_id: string\n  readonly decision: \"approve\" | \"deny\"\n  readonly reason?: string\n}\n\n/**\n * Queue-backed resolver. The router fiber drains verdicts and resolves\n * pre-registered Deferreds keyed by `call_id`. Returns the resolver and\n * a stream of `ApprovalRequested` events for the gated calls; the recipe\n * merges the announce stream into its consumer view.\n */\nexport const fromVerdictQueue =\n  (\n    predicate: (call: FunctionCall) => boolean,\n    verdicts: Queue.Dequeue<Verdict>,\n  ) =>\n  (\n    calls: ReadonlyArray<FunctionCall>,\n  ): Effect.Effect<\n    {\n      readonly resolve: Resolver\n      readonly announce: Stream.Stream<ToolEvent>\n    },\n    never,\n    Scope.Scope\n  > =>\n    Effect.gen(function* () {\n      const gated = calls.filter(predicate)\n\n      const entries = yield* Effect.forEach(gated, (call) =>\n        Deferred.make<Verdict>().pipe(Effect.map((d) => [call.call_id, d] as const)),\n      )\n      const deferreds: ReadonlyMap<string, Deferred.Deferred<Verdict>> = new Map(entries)\n\n      // Router is forked into the surrounding Scope so it lives as long\n      // as the consumer is pulling events. Recipes typically supply the\n      // scope by wrapping the events construction in `Stream.unwrap`.\n      yield* Effect.forkScoped(\n        Effect.forever(\n          Effect.gen(function* () {\n            const v = yield* Queue.take(verdicts)\n            const d = deferreds.get(v.call_id)\n            if (d !== undefined) yield* Deferred.succeed(d, v)\n          }),\n        ),\n      )\n\n      const resolve: Resolver = (call) => {\n        if (!predicate(call)) return Effect.succeed(execute)\n        const d = deferreds.get(call.call_id)!\n        return Deferred.await(d).pipe(\n          Effect.map((v) =>\n            v.decision === \"approve\" ? execute : reject(denied(call, v.reason)),\n          ),\n        )\n      }\n\n      const announce = Stream.fromIterable<ToolEvent>(\n        gated.map((call) => ({\n          _tag: \"ApprovalRequested\",\n          call_id: call.call_id,\n          tool: call.name,\n          arguments: call.arguments,\n        })),\n      )\n\n      return { resolve, announce }\n    })\n\n// ---------------------------------------------------------------------------\n// Approval map (HTTP-style transport). Verdicts arrive synchronously\n// bundled in the request payload. Missing entries → cancelled.\n// ---------------------------------------------------------------------------\n\nexport type ApprovalMapEntry =\n  | { readonly decision: \"approve\" }\n  | { readonly decision: \"deny\"; readonly reason?: string }\n\nexport const fromApprovalMap =\n  (\n    predicate: (call: FunctionCall) => boolean,\n    approvals: ReadonlyMap<string, ApprovalMapEntry>,\n  ): Resolver =>\n  (call) => {\n    if (!predicate(call)) return Effect.succeed(execute)\n    const v = approvals.get(call.call_id)\n    if (v === undefined) return Effect.succeed(reject(cancelled(call)))\n    return Effect.succeed(\n      v.decision === \"approve\" ? execute : reject(denied(call, v.reason)),\n    )\n  }\n\n// ---------------------------------------------------------------------------\n// Combinators - compose policy onto an inner resolver.\n// ---------------------------------------------------------------------------\n\n/**\n * Authz gate. `canApprove` runs BEFORE the inner resolver; failures\n * short-circuit to a `permission_denied` rejection. Override `onForbidden`\n * if your audit format wants a different kind or reason.\n */\nexport const withPermissions =\n  (\n    inner: Resolver,\n    canApprove: (call: FunctionCall) => Effect.Effect<boolean>,\n    onForbidden: (call: FunctionCall) => ToolResult = (call) =>\n      rejected(call, \"permission_denied\", \"missing permissions\"),\n  ): Resolver =>\n  (call) =>\n    canApprove(call).pipe(\n      Effect.flatMap((allowed) =>\n        allowed ? inner(call) : Effect.succeed(reject(onForbidden(call))),\n      ),\n    )\n\n/**\n * Fallback gate. If `inner` returns a Reject whose result matches the\n * `recoverable` predicate, run `fallback(call)` instead and use that\n * decision. Otherwise pass the original Reject through.\n */\nexport const withFallback =\n  (\n    inner: Resolver,\n    recoverable: (result: ToolResult) => boolean,\n    fallback: (call: FunctionCall) => Effect.Effect<ToolDecision>,\n  ): Resolver =>\n  (call) =>\n    inner(call).pipe(\n      Effect.flatMap((decision) =>\n        decision._tag === \"Reject\" && recoverable(decision.result)\n          ? fallback(call)\n          : Effect.succeed(decision),\n      ),\n    )\n\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AA0CA,MAAa,oBAET,WACA,cAGA,UASA,OAAO,IAAI,aAAa;CACtB,MAAM,QAAQ,MAAM,OAAO,UAAU;CAErC,MAAM,UAAU,OAAO,OAAO,QAAQ,QAAQ,SAC5C,SAAS,MAAe,CAAC,KAAK,OAAO,KAAK,MAAM,CAAC,KAAK,SAAS,EAAE,CAAU,CAAC,CAC7E;CACD,MAAM,YAA6D,IAAI,IAAI,QAAQ;AAKnF,QAAO,OAAO,WACZ,OAAO,QACL,OAAO,IAAI,aAAa;EACtB,MAAM,IAAI,OAAO,MAAM,KAAK,SAAS;EACrC,MAAM,IAAI,UAAU,IAAI,EAAE,QAAQ;AAClC,MAAI,MAAM,KAAA,EAAW,QAAO,SAAS,QAAQ,GAAG,EAAE;GAClD,CACH,CACF;CAED,MAAM,WAAqB,SAAS;AAClC,MAAI,CAAC,UAAU,KAAK,CAAE,QAAO,OAAO,QAAQ,QAAQ;EACpD,MAAM,IAAI,UAAU,IAAI,KAAK,QAAQ;AACrC,SAAO,SAAS,MAAM,EAAE,CAAC,KACvB,OAAO,KAAK,MACV,EAAE,aAAa,YAAY,UAAU,OAAO,OAAO,MAAM,EAAE,OAAO,CAAC,CACpE,CACF;;AAYH,QAAO;EAAE;EAAS,UATD,OAAO,aACtB,MAAM,KAAK,UAAU;GACnB,MAAM;GACN,SAAS,KAAK;GACd,MAAM,KAAK;GACX,WAAW,KAAK;GACjB,EAAE,CAGqB;EAAE;EAC5B;AAWN,MAAa,mBAET,WACA,eAED,SAAS;AACR,KAAI,CAAC,UAAU,KAAK,CAAE,QAAO,OAAO,QAAQ,QAAQ;CACpD,MAAM,IAAI,UAAU,IAAI,KAAK,QAAQ;AACrC,KAAI,MAAM,KAAA,EAAW,QAAO,OAAO,QAAQ,OAAO,UAAU,KAAK,CAAC,CAAC;AACnE,QAAO,OAAO,QACZ,EAAE,aAAa,YAAY,UAAU,OAAO,OAAO,MAAM,EAAE,OAAO,CAAC,CACpE;;;;;;;AAYL,MAAa,mBAET,OACA,YACA,eAAmD,SACjD,SAAS,MAAM,qBAAqB,sBAAsB,MAE7D,SACC,WAAW,KAAK,CAAC,KACf,OAAO,SAAS,YACd,UAAU,MAAM,KAAK,GAAG,OAAO,QAAQ,OAAO,YAAY,KAAK,CAAC,CAAC,CAClE,CACF;;;;;;AAOL,MAAa,gBAET,OACA,aACA,cAED,SACC,MAAM,KAAK,CAAC,KACV,OAAO,SAAS,aACd,SAAS,SAAS,YAAY,YAAY,SAAS,OAAO,GACtD,SAAS,KAAK,GACd,OAAO,QAAQ,SAAS,CAC7B,CACF"}

package/dist/tool/Tool.d.mts

@@ -0,0 +1,2 @@
+import { a as Tool, c as ToolInputSchema, d as fromEffectSchema, f as isStreamingTool, h as toDescriptors, i as StreamingTool, m as streaming, n as AnyPlainTool, o as ToolDescriptor, p as make, r as AnyStreamingTool, s as ToolError, t as AnyKindTool, u as execute } from "../Tool-5wxOCuOh.mjs";
+export { AnyKindTool, AnyPlainTool, AnyStreamingTool, StreamingTool, Tool, ToolDescriptor, ToolError, ToolInputSchema, execute, fromEffectSchema, isStreamingTool, make, streaming, toDescriptors };

package/dist/tool/Tool.mjs

@@ -0,0 +1,79 @@
+import { t as __exportAll } from "../chunk-CfYAbeIz.mjs";
+import { functionCallOutput } from "../domain/Items.mjs";
+import { Effect, Schema } from "effect";
+//#region src/tool/Tool.ts
+var Tool_exports = /* @__PURE__ */ __exportAll({
+	ToolError: () => ToolError,
+	execute: () => execute,
+	fromEffectSchema: () => fromEffectSchema,
+	isStreamingTool: () => isStreamingTool,
+	make: () => make,
+	streaming: () => streaming,
+	toDescriptors: () => toDescriptors
+});
+var ToolError = class extends Schema.TaggedErrorClass("@betalyra/effect-uai/ToolError")("ToolError", {
+	call_id: Schema.String,
+	tool: Schema.String,
+	message: Schema.String,
+	cause: Schema.optional(Schema.Unknown)
+}) {};
+/**
+* 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`.
+*/
+const fromEffectSchema = (schema) => Schema.toStandardJSONSchemaV1(Schema.toStandardSchemaV1(schema));
+const make = (spec) => spec;
+const streaming = (spec) => ({
+	_kind: "streaming",
+	...spec
+});
+const isStreamingTool = (t) => "_kind" in t && t._kind === "streaming";
+/**
+* Render any-kind tools (mixed plain and streaming) to provider-agnostic
+* descriptors. Mirrors `Toolkit.toDescriptors` but accepts the union type
+* so a single list can carry both kinds.
+*/
+const toDescriptors = (tools) => tools.map((tool) => {
+	const inputSchema = tool.inputSchema["~standard"].jsonSchema.input({ target: "draft-2020-12" });
+	return tool.strict !== void 0 ? {
+		name: tool.name,
+		description: tool.description,
+		inputSchema,
+		strict: tool.strict
+	} : {
+		name: tool.name,
+		description: tool.description,
+		inputSchema
+	};
+});
+const toToolError = (call, toolName, message) => (cause) => new ToolError({
+	call_id: call.call_id,
+	tool: toolName,
+	message,
+	cause
+});
+/**
+* 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.
+*/
+const execute = (tool, call) => Effect.gen(function* () {
+	const parsed = yield* Effect.try({
+		try: () => JSON.parse(call.arguments),
+		catch: toToolError(call, tool.name, "Failed to parse JSON arguments")
+	});
+	const result = yield* Effect.promise(() => Promise.resolve(tool.inputSchema["~standard"].validate(parsed)));
+	if (result.issues !== void 0) return yield* new ToolError({
+		call_id: call.call_id,
+		tool: tool.name,
+		message: "Tool input failed schema validation",
+		cause: result.issues
+	});
+	const output = yield* tool.run(result.value).pipe(Effect.mapError(toToolError(call, tool.name, "Tool execution failed")));
+	return functionCallOutput(call.call_id, JSON.stringify(output));
+});
+//#endregion
+export { ToolError, execute, fromEffectSchema, isStreamingTool, make, streaming, Tool_exports as t, toDescriptors };
+
+//# sourceMappingURL=Tool.mjs.map