@warlock.js/core 4.7.0 → 4.8.1

package/esm/ai/src/vcr/vcr.mjs

@@ -1,248 +0,0 @@
-import { redact } from "../security/redact.mjs";
-import { emptyCassette, loadCassette, saveCassette } from "./cassette-io.mjs";
-import { VcrCassetteMissError } from "./errors.mjs";
-import { DEFAULT_HASH_OPTIONS, hashRequest } from "./hash-request.mjs";
-
-//#region ../@warlock.js/ai/src/vcr/vcr.ts
-/**
-* Internal decorator that wraps an inner `ModelContract`, intercepting only
-* `complete()`/`stream()` and delegating every identity getter to the inner
-* model. Drives the record/replay state machine over a single in-memory
-* {@link Cassette}.
-*
-* **Why a class.** It holds mutable per-instance state (the loaded cassette,
-* the dirty flag, the load promise) behind a stable `ModelContract` surface;
-* the public API is the `vcr()` factory, never `new`.
-*/
-var Vcr = class {
-	constructor(inner, options) {
-		this.inner = inner;
-		this.dirty = false;
-		this.warnedVerbatim = false;
-		this.path = options.path;
-		this.mode = options.mode ?? "auto";
-		this.hashOptions = options.hashOptions ?? DEFAULT_HASH_OPTIONS;
-		this.recordRequest = options.recordRequest ?? "verbatim";
-		this.redactRequestHook = options.redactRequest;
-		this.redactResponseHook = options.redactResponse;
-		this.redactErrorHook = options.redactError;
-		this.loadedCassette = emptyCassette(inner.name, inner.provider);
-	}
-	/** Inner model identifier — delegated verbatim. */
-	get name() {
-		return this.inner.name;
-	}
-	/** Inner provider — delegated verbatim. */
-	get provider() {
-		return this.inner.provider;
-	}
-	/** Inner capability flags — delegated verbatim. */
-	get capabilities() {
-		return this.inner.capabilities;
-	}
-	/** Inner pricing — delegated verbatim so cost accounting is unchanged. */
-	get pricing() {
-		return this.inner.pricing;
-	}
-	/** Loaded/recorded cassette, exposed for assertions. */
-	get cassette() {
-		return this.loadedCassette;
-	}
-	/**
-	* Load the on-disk cassette exactly once. Pure `record` mode skips the
-	* read — it always writes fresh — but the in-memory cassette still starts
-	* empty so a record run never accidentally replays a stale entry.
-	*/
-	async ensureLoaded() {
-		if (this.loadPromise) return this.loadPromise;
-		this.loadPromise = this.mode === "record" ? Promise.resolve() : (async () => {
-			this.loadedCassette = await loadCassette(this.path, this.inner.name, this.inner.provider);
-		})();
-		return this.loadPromise;
-	}
-	/** Find a recorded entry whose hash matches the current request. */
-	findEntry(hash) {
-		return this.loadedCassette.entries.find((entry) => entry.requestHash === hash);
-	}
-	/** Re-throw a recorded error by reconstructing a plain `Error`. */
-	throwRecordedError(entry) {
-		const error = new Error(entry.error?.message ?? "Recorded error");
-		error.name = entry.error?.name ?? "Error";
-		throw error;
-	}
-	/**
-	* Non-streaming call. In `replay` a miss throws; in `auto`/`record` a miss
-	* calls the inner model and records the outcome (response or error).
-	*/
-	async complete(messages, options) {
-		await this.ensureLoaded();
-		const hash = hashRequest(messages, options, this.hashOptions);
-		if (this.mode !== "record") {
-			const entry = this.findEntry(hash);
-			if (entry) {
-				if (entry.error) this.throwRecordedError(entry);
-				if (entry.response) return entry.response;
-			}
-			if (this.mode === "replay") throw new VcrCassetteMissError(`No cassette entry for this request (model "${this.inner.name}", hash ${hash}).`, {
-				requestHash: hash,
-				path: this.path
-			});
-		}
-		try {
-			const response = await this.inner.complete(messages, options);
-			this.record({
-				requestHash: hash,
-				request: {
-					messages,
-					options
-				},
-				response
-			});
-			return response;
-		} catch (error) {
-			this.record({
-				requestHash: hash,
-				request: {
-					messages,
-					options
-				},
-				error: {
-					name: error.name,
-					message: error.message
-				}
-			});
-			throw error;
-		}
-	}
-	/**
-	* Streaming call. On replay the stored `chunks` are re-yielded in order
-	* (reproducing the `delta`/`tool-call`/`done` sequence) or the stored
-	* error is re-thrown. On record the inner stream is buffered into
-	* `chunks[]` while being re-emitted, then recorded once exhausted.
-	*/
-	async *stream(messages, options) {
-		await this.ensureLoaded();
-		const hash = hashRequest(messages, options, this.hashOptions);
-		if (this.mode !== "record") {
-			const entry = this.findEntry(hash);
-			if (entry) {
-				if (entry.error) this.throwRecordedError(entry);
-				if (entry.chunks) {
-					for (const chunk of entry.chunks) yield chunk;
-					return;
-				}
-			}
-			if (this.mode === "replay") throw new VcrCassetteMissError(`No cassette entry for this request (model "${this.inner.name}", hash ${hash}).`, {
-				requestHash: hash,
-				path: this.path
-			});
-		}
-		const chunks = [];
-		try {
-			for await (const chunk of this.inner.stream(messages, options)) {
-				chunks.push(chunk);
-				yield chunk;
-			}
-		} catch (error) {
-			this.record({
-				requestHash: hash,
-				request: {
-					messages,
-					options
-				},
-				error: {
-					name: error.name,
-					message: error.message
-				}
-			});
-			throw error;
-		}
-		this.record({
-			requestHash: hash,
-			request: {
-				messages,
-				options
-			},
-			chunks
-		});
-	}
-	/**
-	* Append an entry to the in-memory cassette and mark it dirty, applying
-	* the configured request/response/error redaction first (S2). Pure
-	* `replay` never reaches this path, so no replay run is ever dirtied.
-	*/
-	record(entry) {
-		this.loadedCassette.entries.push(this.applyRedaction(entry));
-		this.dirty = true;
-		this.maybeWarnVerbatim();
-	}
-	/**
-	* Apply the persisted-body privacy controls to an entry before it is
-	* stored. The request body follows `recordRequest`; response/error
-	* redactors are applied only when supplied. Replay matching is by the
-	* recomputed hash (kept verbatim), so none of this affects replay.
-	*/
-	applyRedaction(entry) {
-		const out = {
-			requestHash: entry.requestHash,
-			request: entry.request
-		};
-		if (this.recordRequest === "hash-only") out.request = { messages: [] };
-		else if (this.recordRequest === "redacted") out.request = this.redactRequestHook ? this.redactRequestHook(entry.request) : redact(entry.request);
-		if (entry.response) out.response = this.redactResponseHook ? this.redactResponseHook(entry.response) : entry.response;
-		if (entry.chunks) out.chunks = entry.chunks;
-		if (entry.error) out.error = this.redactErrorHook ? this.redactErrorHook(entry.error) : entry.error;
-		return out;
-	}
-	/**
-	* Warn once (outside tests) when the cassette is recording verbatim
-	* request bodies — they may carry prompts, tool args, and PII, so the
-	* file is not safe to commit until sanitized.
-	*/
-	maybeWarnVerbatim() {
-		if (this.warnedVerbatim || this.recordRequest !== "verbatim") return;
-		if (process.env.VITEST || process.env.NODE_ENV === "test") return;
-		this.warnedVerbatim = true;
-		console.warn(`[warlock-ai] VCR is recording verbatim request bodies to "${this.path}" — prompts, tool args, and any PII are stored unredacted. Sanitize before committing, or set recordRequest: "redacted" | "hash-only".`);
-	}
-	/**
-	* Flush newly recorded entries to `path`. No-op when nothing was recorded
-	* (pure replay, or a record/auto run that only ever hit cached entries).
-	*/
-	async save() {
-		if (!this.dirty) return;
-		await saveCassette(this.path, this.loadedCassette);
-		this.dirty = false;
-	}
-};
-/**
-* Wrap any `ModelContract` in a record/replay decorator backed by a JSON
-* cassette on disk.
-*
-* **What it does.** Intercepts only `complete()`/`stream()` — the single
-* seam every agent trip funnels through — and delegates `name`, `provider`,
-* `capabilities`, and `pricing` to the inner model untouched. On a call it
-* computes a stable hash over `{ messages, picked options }` and, depending
-* on `mode`:
-*
-* - **`record`** — always calls the inner model and appends a cassette entry.
-* - **`replay`** — returns the matching entry (or re-yields its chunks /
-*   re-throws its error); a miss throws `VcrCassetteMissError`, never a live
-*   call.
-* - **`auto`** (default) — replays a hit, records a miss.
-*
-* Composes *below* `fallbackModel` and works with any adapter because it
-* depends only on `ModelContract`. Call `save()` to flush new entries.
-*
-* @example
-* const model = vcr(liveModel, { path: "./cassettes/support.json" });
-* const response = await model.complete(messages);
-* await model.save(); // first run records; later runs replay deterministically.
-*/
-function vcr(model, options) {
-	return new Vcr(model, options);
-}
-
-//#endregion
-export { vcr };
-//# sourceMappingURL=vcr.mjs.map

package/esm/ai/src/vcr/vcr.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"vcr.mjs","names":[],"sources":["../../../../../../../../../@warlock.js/ai/src/vcr/vcr.ts"],"sourcesContent":["import type { Message } from \"../contracts/conversation-message.type\";\nimport type {\n  ModelCallOptions,\n  ModelCapabilities,\n  ModelContract,\n  ModelResponse,\n  ModelStreamChunk,\n} from \"../contracts/model.contract\";\nimport type { ModelPricing } from \"../contracts/result/model-pricing.type\";\nimport { redact } from \"../security/redact\";\nimport { emptyCassette, loadCassette, saveCassette } from \"./cassette-io\";\nimport { VcrCassetteMissError } from \"./errors\";\nimport { DEFAULT_HASH_OPTIONS, hashRequest } from \"./hash-request\";\nimport type { Cassette, CassetteEntry, VcrMode, VcrModel, VcrOptions } from \"./vcr.type\";\n\n/**\n * Internal decorator that wraps an inner `ModelContract`, intercepting only\n * `complete()`/`stream()` and delegating every identity getter to the inner\n * model. Drives the record/replay state machine over a single in-memory\n * {@link Cassette}.\n *\n * **Why a class.** It holds mutable per-instance state (the loaded cassette,\n * the dirty flag, the load promise) behind a stable `ModelContract` surface;\n * the public API is the `vcr()` factory, never `new`.\n */\nclass Vcr implements VcrModel {\n  private readonly mode: VcrMode;\n  private readonly path: string;\n  private readonly hashOptions: readonly string[];\n\n  /** Loaded + newly recorded entries. Mutated in place as we record. */\n  private loadedCassette: Cassette;\n\n  /** Set when an entry is recorded so `save()` knows there's work to flush. */\n  private dirty = false;\n\n  /** One-shot lazy load of the on-disk cassette, shared across calls. */\n  private loadPromise: Promise<void> | undefined;\n\n  /** Persisted-body privacy controls (S2). */\n  private readonly recordRequest: NonNullable<VcrOptions[\"recordRequest\"]>;\n  private readonly redactRequestHook: VcrOptions[\"redactRequest\"];\n  private readonly redactResponseHook: VcrOptions[\"redactResponse\"];\n  private readonly redactErrorHook: VcrOptions[\"redactError\"];\n\n  /** Verbatim-recording warning fires at most once per instance. */\n  private warnedVerbatim = false;\n\n  public constructor(\n    private readonly inner: ModelContract,\n    options: VcrOptions,\n  ) {\n    this.path = options.path;\n    this.mode = options.mode ?? \"auto\";\n    this.hashOptions = options.hashOptions ?? DEFAULT_HASH_OPTIONS;\n    this.recordRequest = options.recordRequest ?? \"verbatim\";\n    this.redactRequestHook = options.redactRequest;\n    this.redactResponseHook = options.redactResponse;\n    this.redactErrorHook = options.redactError;\n    this.loadedCassette = emptyCassette(inner.name, inner.provider);\n  }\n\n  /** Inner model identifier — delegated verbatim. */\n  public get name(): string {\n    return this.inner.name;\n  }\n\n  /** Inner provider — delegated verbatim. */\n  public get provider(): string {\n    return this.inner.provider;\n  }\n\n  /** Inner capability flags — delegated verbatim. */\n  public get capabilities(): ModelCapabilities | undefined {\n    return this.inner.capabilities;\n  }\n\n  /** Inner pricing — delegated verbatim so cost accounting is unchanged. */\n  public get pricing(): ModelPricing | undefined {\n    return this.inner.pricing;\n  }\n\n  /** Loaded/recorded cassette, exposed for assertions. */\n  public get cassette(): Cassette {\n    return this.loadedCassette;\n  }\n\n  /**\n   * Load the on-disk cassette exactly once. Pure `record` mode skips the\n   * read — it always writes fresh — but the in-memory cassette still starts\n   * empty so a record run never accidentally replays a stale entry.\n   */\n  private async ensureLoaded(): Promise<void> {\n    if (this.loadPromise) {\n      return this.loadPromise;\n    }\n\n    this.loadPromise =\n      this.mode === \"record\"\n        ? Promise.resolve()\n        : (async () => {\n            this.loadedCassette = await loadCassette(\n              this.path,\n              this.inner.name,\n              this.inner.provider,\n            );\n          })();\n\n    return this.loadPromise;\n  }\n\n  /** Find a recorded entry whose hash matches the current request. */\n  private findEntry(hash: string): CassetteEntry | undefined {\n    return this.loadedCassette.entries.find((entry) => entry.requestHash === hash);\n  }\n\n  /** Re-throw a recorded error by reconstructing a plain `Error`. */\n  private throwRecordedError(entry: CassetteEntry): never {\n    const error = new Error(entry.error?.message ?? \"Recorded error\");\n\n    error.name = entry.error?.name ?? \"Error\";\n\n    throw error;\n  }\n\n  /**\n   * Non-streaming call. In `replay` a miss throws; in `auto`/`record` a miss\n   * calls the inner model and records the outcome (response or error).\n   */\n  public async complete(messages: Message[], options?: ModelCallOptions): Promise<ModelResponse> {\n    await this.ensureLoaded();\n\n    const hash = hashRequest(messages, options, this.hashOptions);\n\n    if (this.mode !== \"record\") {\n      const entry = this.findEntry(hash);\n\n      if (entry) {\n        if (entry.error) {\n          this.throwRecordedError(entry);\n        }\n\n        if (entry.response) {\n          return entry.response;\n        }\n      }\n\n      if (this.mode === \"replay\") {\n        throw new VcrCassetteMissError(\n          `No cassette entry for this request (model \"${this.inner.name}\", hash ${hash}).`,\n          { requestHash: hash, path: this.path },\n        );\n      }\n    }\n\n    try {\n      const response = await this.inner.complete(messages, options);\n\n      this.record({ requestHash: hash, request: { messages, options }, response });\n\n      return response;\n    } catch (error) {\n      this.record({\n        requestHash: hash,\n        request: { messages, options },\n        error: { name: (error as Error).name, message: (error as Error).message },\n      });\n\n      throw error;\n    }\n  }\n\n  /**\n   * Streaming call. On replay the stored `chunks` are re-yielded in order\n   * (reproducing the `delta`/`tool-call`/`done` sequence) or the stored\n   * error is re-thrown. On record the inner stream is buffered into\n   * `chunks[]` while being re-emitted, then recorded once exhausted.\n   */\n  public async *stream(\n    messages: Message[],\n    options?: ModelCallOptions,\n  ): AsyncIterable<ModelStreamChunk> {\n    await this.ensureLoaded();\n\n    const hash = hashRequest(messages, options, this.hashOptions);\n\n    if (this.mode !== \"record\") {\n      const entry = this.findEntry(hash);\n\n      if (entry) {\n        if (entry.error) {\n          this.throwRecordedError(entry);\n        }\n\n        if (entry.chunks) {\n          for (const chunk of entry.chunks) {\n            yield chunk;\n          }\n\n          return;\n        }\n      }\n\n      if (this.mode === \"replay\") {\n        throw new VcrCassetteMissError(\n          `No cassette entry for this request (model \"${this.inner.name}\", hash ${hash}).`,\n          { requestHash: hash, path: this.path },\n        );\n      }\n    }\n\n    const chunks: ModelStreamChunk[] = [];\n\n    try {\n      for await (const chunk of this.inner.stream(messages, options)) {\n        chunks.push(chunk);\n\n        yield chunk;\n      }\n    } catch (error) {\n      this.record({\n        requestHash: hash,\n        request: { messages, options },\n        error: { name: (error as Error).name, message: (error as Error).message },\n      });\n\n      throw error;\n    }\n\n    this.record({ requestHash: hash, request: { messages, options }, chunks });\n  }\n\n  /**\n   * Append an entry to the in-memory cassette and mark it dirty, applying\n   * the configured request/response/error redaction first (S2). Pure\n   * `replay` never reaches this path, so no replay run is ever dirtied.\n   */\n  private record(entry: CassetteEntry): void {\n    this.loadedCassette.entries.push(this.applyRedaction(entry));\n    this.dirty = true;\n    this.maybeWarnVerbatim();\n  }\n\n  /**\n   * Apply the persisted-body privacy controls to an entry before it is\n   * stored. The request body follows `recordRequest`; response/error\n   * redactors are applied only when supplied. Replay matching is by the\n   * recomputed hash (kept verbatim), so none of this affects replay.\n   */\n  private applyRedaction(entry: CassetteEntry): CassetteEntry {\n    const out: CassetteEntry = {\n      requestHash: entry.requestHash,\n      request: entry.request,\n    };\n\n    if (this.recordRequest === \"hash-only\") {\n      out.request = { messages: [] };\n    } else if (this.recordRequest === \"redacted\") {\n      out.request = this.redactRequestHook\n        ? this.redactRequestHook(entry.request)\n        : redact(entry.request);\n    }\n\n    if (entry.response) {\n      out.response = this.redactResponseHook\n        ? this.redactResponseHook(entry.response)\n        : entry.response;\n    }\n    if (entry.chunks) {\n      out.chunks = entry.chunks;\n    }\n    if (entry.error) {\n      out.error = this.redactErrorHook\n        ? this.redactErrorHook(entry.error)\n        : entry.error;\n    }\n\n    return out;\n  }\n\n  /**\n   * Warn once (outside tests) when the cassette is recording verbatim\n   * request bodies — they may carry prompts, tool args, and PII, so the\n   * file is not safe to commit until sanitized.\n   */\n  private maybeWarnVerbatim(): void {\n    if (this.warnedVerbatim || this.recordRequest !== \"verbatim\") return;\n    if (process.env.VITEST || process.env.NODE_ENV === \"test\") return;\n\n    this.warnedVerbatim = true;\n    console.warn(\n      `[warlock-ai] VCR is recording verbatim request bodies to \"${this.path}\" — prompts, tool args, and any PII are stored unredacted. ` +\n        'Sanitize before committing, or set recordRequest: \"redacted\" | \"hash-only\".',\n    );\n  }\n\n  /**\n   * Flush newly recorded entries to `path`. No-op when nothing was recorded\n   * (pure replay, or a record/auto run that only ever hit cached entries).\n   */\n  public async save(): Promise<void> {\n    if (!this.dirty) {\n      return;\n    }\n\n    await saveCassette(this.path, this.loadedCassette);\n    this.dirty = false;\n  }\n}\n\n/**\n * Wrap any `ModelContract` in a record/replay decorator backed by a JSON\n * cassette on disk.\n *\n * **What it does.** Intercepts only `complete()`/`stream()` — the single\n * seam every agent trip funnels through — and delegates `name`, `provider`,\n * `capabilities`, and `pricing` to the inner model untouched. On a call it\n * computes a stable hash over `{ messages, picked options }` and, depending\n * on `mode`:\n *\n * - **`record`** — always calls the inner model and appends a cassette entry.\n * - **`replay`** — returns the matching entry (or re-yields its chunks /\n *   re-throws its error); a miss throws `VcrCassetteMissError`, never a live\n *   call.\n * - **`auto`** (default) — replays a hit, records a miss.\n *\n * Composes *below* `fallbackModel` and works with any adapter because it\n * depends only on `ModelContract`. Call `save()` to flush new entries.\n *\n * @example\n * const model = vcr(liveModel, { path: \"./cassettes/support.json\" });\n * const response = await model.complete(messages);\n * await model.save(); // first run records; later runs replay deterministically.\n */\nexport function vcr(model: ModelContract, options: VcrOptions): VcrModel {\n  return new Vcr(model, options);\n}\n"],"mappings":"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"}

package/esm/ai/src/workflow/as-tool.mjs

@@ -1,49 +0,0 @@
-import { WorkflowError } from "../errors/workflow-error.mjs";
-import "../errors/index.mjs";
-import { compositeAsTool } from "../tool/tool.mjs";
-
-//#region ../@warlock.js/ai/src/workflow/as-tool.ts
-/**
-* Wrap a `WorkflowInstance` as a `ToolContract` so an agent can invoke
-* it inside its tool-call loop. Closes the agent-calls-workflow
-* composition gap.
-*
-* Behavior:
-* - Tool `name` mirrors `workflow.name` — workflows without a name throw
-*   `WorkflowError` at wrap time (the agent surface needs a stable id).
-* - Tool `input` is the supplied `inputSchema`; the validated value is
-*   forwarded straight to `workflow.execute(input)`.
-* - On `result.error`, the workflow error is wrapped in
-*   `ToolExecutionError` with `cause` set to the original
-*   `WorkflowError` subclass — the agent's tool-call loop sees a
-*   uniform error class regardless of which primitive failed.
-*
-* @example
-* const wf = workflow({ name: "triage", steps: [...] });
-* const triageTool = asTool(wf, {
-*   description: "Run the support-ticket triage flow",
-*   inputSchema: ticketSchema,
-* });
-* const a = ai.agent({ model, tools: [triageTool] });
-*/
-function asTool(workflowInstance, options) {
-	if (!workflowInstance.name || typeof workflowInstance.name !== "string") throw new WorkflowError("workflow.asTool(): workflow must have a `name` to be wrapped as a tool");
-	return compositeAsTool({
-		name: workflowInstance.name,
-		description: options.description ?? `Invoke workflow "${workflowInstance.name}" as a tool.`,
-		input: options.inputSchema,
-		execute: async (input, ctx) => {
-			const result = await workflowInstance.execute(input, ctx?.signal ? { signal: ctx.signal } : void 0);
-			if (result.error) throw result.error;
-			return {
-				data: result.data,
-				usage: result.usage,
-				report: result.report
-			};
-		}
-	});
-}
-
-//#endregion
-export { asTool };
-//# sourceMappingURL=as-tool.mjs.map

package/esm/ai/src/workflow/as-tool.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"as-tool.mjs","names":[],"sources":["../../../../../../../../../@warlock.js/ai/src/workflow/as-tool.ts"],"sourcesContent":["import type { StandardSchemaV1 } from \"@standard-schema/spec\";\nimport type { WorkflowInstance } from \"../contracts/workflow/workflow.contract\";\nimport { WorkflowError } from \"../errors\";\nimport { compositeAsTool, type ToolContract } from \"../tool/tool\";\n\n/**\n * Wrap a `WorkflowInstance` as a `ToolContract` so an agent can invoke\n * it inside its tool-call loop. Closes the agent-calls-workflow\n * composition gap.\n *\n * Behavior:\n * - Tool `name` mirrors `workflow.name` — workflows without a name throw\n *   `WorkflowError` at wrap time (the agent surface needs a stable id).\n * - Tool `input` is the supplied `inputSchema`; the validated value is\n *   forwarded straight to `workflow.execute(input)`.\n * - On `result.error`, the workflow error is wrapped in\n *   `ToolExecutionError` with `cause` set to the original\n *   `WorkflowError` subclass — the agent's tool-call loop sees a\n *   uniform error class regardless of which primitive failed.\n *\n * @example\n * const wf = workflow({ name: \"triage\", steps: [...] });\n * const triageTool = asTool(wf, {\n *   description: \"Run the support-ticket triage flow\",\n *   inputSchema: ticketSchema,\n * });\n * const a = ai.agent({ model, tools: [triageTool] });\n */\nexport function asTool<TInput, TOutput, TToolInput = TInput>(\n  workflowInstance: WorkflowInstance<TInput, TOutput>,\n  options: {\n    description?: string;\n    inputSchema: StandardSchemaV1<TToolInput>;\n  },\n): ToolContract<TToolInput, TOutput> {\n  if (!workflowInstance.name || typeof workflowInstance.name !== \"string\") {\n    throw new WorkflowError(\n      \"workflow.asTool(): workflow must have a `name` to be wrapped as a tool\",\n    );\n  }\n\n  return compositeAsTool<TToolInput, TOutput>({\n    name: workflowInstance.name,\n    description: options.description ?? `Invoke workflow \"${workflowInstance.name}\" as a tool.`,\n    input: options.inputSchema,\n    execute: async (input, ctx) => {\n      // Relay the outer agent's cancellation signal so cancelling the\n      // parent aborts this nested workflow run (C2).\n      const result = await workflowInstance.execute(\n        input as unknown as TInput,\n        ctx?.signal ? { signal: ctx.signal } : undefined,\n      );\n\n      if (result.error) {\n        // Throw the workflow error so the surrounding wrapper catches\n        // it and produces a `ToolExecutionError` with `cause` pointing\n        // back at the original `WorkflowError` subclass — keeps the\n        // agent's tool-call loop seeing one uniform error class\n        // regardless of which primitive failed.\n        throw result.error;\n      }\n\n      return {\n        data: result.data as TOutput,\n        usage: result.usage,\n        report: result.report,\n      };\n    },\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BA,SAAgB,OACd,kBACA,SAImC;CACnC,IAAI,CAAC,iBAAiB,QAAQ,OAAO,iBAAiB,SAAS,UAC7D,MAAM,IAAI,cACR,wEACF;CAGF,OAAO,gBAAqC;EAC1C,MAAM,iBAAiB;EACvB,aAAa,QAAQ,eAAe,oBAAoB,iBAAiB,KAAK;EAC9E,OAAO,QAAQ;EACf,SAAS,OAAO,OAAO,QAAQ;GAG7B,MAAM,SAAS,MAAM,iBAAiB,QACpC,OACA,KAAK,SAAS,EAAE,QAAQ,IAAI,OAAO,IAAI,MACzC;GAEA,IAAI,OAAO,OAMT,MAAM,OAAO;GAGf,OAAO;IACL,MAAM,OAAO;IACb,OAAO,OAAO;IACd,QAAQ,OAAO;GACjB;EACF;CACF,CAAC;AACH"}

package/esm/ai/src/workflow/cancellation.mjs

@@ -1,44 +0,0 @@
-import { WorkflowCancelledError } from "../errors/workflow-cancelled-error.mjs";
-import "../errors/index.mjs";
-
-//#region ../@warlock.js/ai/src/workflow/cancellation.ts
-/**
-* Build a `WorkflowCancelledError` from an `AbortSignal`, extracting
-* a human-readable reason from `signal.reason` (string | Error | any).
-* Used both at between-step boundaries and inside the retry backoff
-* sleep.
-*/
-function createCancelledError(signal) {
-	const reason = signal?.reason;
-	const reasonText = typeof reason === "string" ? reason : reason instanceof Error ? reason.message : reason === void 0 ? "" : String(reason);
-	return new WorkflowCancelledError(`workflow cancelled${reasonText ? `: ${reasonText}` : ""}`, {
-		cancelledAt: (/* @__PURE__ */ new Date()).toISOString(),
-		reason: reasonText
-	});
-}
-/**
-* Promise-based sleep that resolves after `ms` milliseconds, or
-* rejects with `WorkflowCancelledError` if the signal fires. The
-* timer is cleared on abort so we never leak a pending setTimeout.
-*/
-function sleep(ms, signal) {
-	return new Promise((resolve, reject) => {
-		if (signal?.aborted) {
-			reject(createCancelledError(signal));
-			return;
-		}
-		const timer = setTimeout(() => {
-			signal?.removeEventListener("abort", onAbort);
-			resolve();
-		}, ms);
-		const onAbort = () => {
-			clearTimeout(timer);
-			reject(createCancelledError(signal));
-		};
-		signal?.addEventListener("abort", onAbort, { once: true });
-	});
-}
-
-//#endregion
-export { createCancelledError, sleep };
-//# sourceMappingURL=cancellation.mjs.map

package/esm/ai/src/workflow/cancellation.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"cancellation.mjs","names":[],"sources":["../../../../../../../../../@warlock.js/ai/src/workflow/cancellation.ts"],"sourcesContent":["import { WorkflowCancelledError } from \"../errors\";\n\n/**\n * Build a `WorkflowCancelledError` from an `AbortSignal`, extracting\n * a human-readable reason from `signal.reason` (string | Error | any).\n * Used both at between-step boundaries and inside the retry backoff\n * sleep.\n */\nexport function createCancelledError(\n  signal: AbortSignal | undefined,\n): WorkflowCancelledError {\n  const reason = signal?.reason;\n  const reasonText =\n    typeof reason === \"string\"\n      ? reason\n      : reason instanceof Error\n        ? reason.message\n        : reason === undefined\n          ? \"\"\n          : String(reason);\n\n  return new WorkflowCancelledError(\n    `workflow cancelled${reasonText ? `: ${reasonText}` : \"\"}`,\n    { cancelledAt: new Date().toISOString(), reason: reasonText },\n  );\n}\n\n/**\n * Promise-based sleep that resolves after `ms` milliseconds, or\n * rejects with `WorkflowCancelledError` if the signal fires. The\n * timer is cleared on abort so we never leak a pending setTimeout.\n */\nexport function sleep(ms: number, signal?: AbortSignal): Promise<void> {\n  return new Promise((resolve, reject) => {\n    if (signal?.aborted) {\n      reject(createCancelledError(signal));\n      return;\n    }\n\n    const timer = setTimeout(() => {\n      signal?.removeEventListener(\"abort\", onAbort);\n      resolve();\n    }, ms);\n\n    const onAbort = () => {\n      clearTimeout(timer);\n      reject(createCancelledError(signal));\n    };\n\n    signal?.addEventListener(\"abort\", onAbort, { once: true });\n  });\n}\n"],"mappings":";;;;;;;;;;AAQA,SAAgB,qBACd,QACwB;CACxB,MAAM,SAAS,QAAQ;CACvB,MAAM,aACJ,OAAO,WAAW,WACd,SACA,kBAAkB,QAChB,OAAO,UACP,WAAW,SACT,KACA,OAAO,MAAM;CAEvB,OAAO,IAAI,uBACT,qBAAqB,aAAa,KAAK,eAAe,MACtD;EAAE,8BAAa,IAAI,KAAK,EAAC,CAAC,YAAY;EAAG,QAAQ;CAAW,CAC9D;AACF;;;;;;AAOA,SAAgB,MAAM,IAAY,QAAqC;CACrE,OAAO,IAAI,SAAS,SAAS,WAAW;EACtC,IAAI,QAAQ,SAAS;GACnB,OAAO,qBAAqB,MAAM,CAAC;GACnC;EACF;EAEA,MAAM,QAAQ,iBAAiB;GAC7B,QAAQ,oBAAoB,SAAS,OAAO;GAC5C,QAAQ;EACV,GAAG,EAAE;EAEL,MAAM,gBAAgB;GACpB,aAAa,KAAK;GAClB,OAAO,qBAAqB,MAAM,CAAC;EACrC;EAEA,QAAQ,iBAAiB,SAAS,SAAS,EAAE,MAAM,KAAK,CAAC;CAC3D,CAAC;AACH"}

package/esm/ai/src/workflow/emitter.mjs

@@ -1,40 +0,0 @@
-//#region ../@warlock.js/ai/src/workflow/emitter.ts
-/**
-* Three-tier workflow event emitter — factory (definition) → instance →
-* per-execution. All matching handlers fire, in layer order. Handler
-* errors are swallowed so listener bugs can never derail the workflow.
-*/
-var WorkflowEmitter = class {
-	constructor(factoryHandlers) {
-		this.instanceHandlers = /* @__PURE__ */ new Map();
-		this.factoryHandlers = factoryHandlers;
-	}
-	on(event, handler) {
-		let bucket = this.instanceHandlers.get(event);
-		if (!bucket) {
-			bucket = /* @__PURE__ */ new Set();
-			this.instanceHandlers.set(event, bucket);
-		}
-		bucket.add(handler);
-		return () => this.off(event, handler);
-	}
-	off(event, handler) {
-		this.instanceHandlers.get(event)?.delete(handler);
-	}
-	emit(event, payload, executionHandlers) {
-		invoke(this.factoryHandlers?.[event], payload);
-		const bucket = this.instanceHandlers.get(event);
-		if (bucket) for (const handler of bucket) invoke(handler, payload);
-		invoke(executionHandlers?.[event], payload);
-	}
-};
-function invoke(handler, payload) {
-	if (typeof handler !== "function") return;
-	try {
-		handler(payload);
-	} catch {}
-}
-
-//#endregion
-export { WorkflowEmitter };
-//# sourceMappingURL=emitter.mjs.map

package/esm/ai/src/workflow/emitter.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"emitter.mjs","names":[],"sources":["../../../../../../../../../@warlock.js/ai/src/workflow/emitter.ts"],"sourcesContent":["import type { WithoutIdentity } from \"../contracts/events/event-identity.type\";\nimport type { WorkflowEventMap } from \"../contracts/events/event-map.type\";\nimport type {\n  WorkflowEventHandler,\n  WorkflowEventHandlers,\n} from \"../contracts/workflow/workflow.contract\";\n\ntype AnyHandler = WorkflowEventHandler<keyof WorkflowEventMap>;\n\n/**\n * The emit surface the workflow engine and step-runner depend on.\n * They never construct run identity themselves — they hand a bare\n * payload to a sink that injects `runId` / `rootRunId` before\n * delegating to the real three-tier `WorkflowEmitter`.\n *\n * `WorkflowEmitter` is factory-scoped (shared across every\n * `execute()`), so it cannot own per-run identity. A per-run sink\n * (see `runScopedEmitter`) closes that gap without touching the ~15\n * `emit` call sites in `engine.ts` / `step-runner.ts`.\n */\nexport interface WorkflowEventSink {\n  emit<K extends keyof WorkflowEventMap>(\n    event: K,\n    payload: WithoutIdentity<WorkflowEventMap[K]>,\n    executionHandlers?: WorkflowEventHandlers,\n  ): void;\n}\n\n/**\n * Three-tier workflow event emitter — factory (definition) → instance →\n * per-execution. All matching handlers fire, in layer order. Handler\n * errors are swallowed so listener bugs can never derail the workflow.\n */\nexport class WorkflowEmitter {\n  private readonly factoryHandlers?: WorkflowEventHandlers;\n  private readonly instanceHandlers = new Map<\n    keyof WorkflowEventMap,\n    Set<AnyHandler>\n  >();\n\n  public constructor(factoryHandlers?: WorkflowEventHandlers) {\n    this.factoryHandlers = factoryHandlers;\n  }\n\n  public on<K extends keyof WorkflowEventMap>(\n    event: K,\n    handler: WorkflowEventHandler<K>,\n  ): () => void {\n    let bucket = this.instanceHandlers.get(event);\n    if (!bucket) {\n      bucket = new Set();\n      this.instanceHandlers.set(event, bucket);\n    }\n    bucket.add(handler as AnyHandler);\n    return () => this.off(event, handler);\n  }\n\n  public off<K extends keyof WorkflowEventMap>(\n    event: K,\n    handler: WorkflowEventHandler<K>,\n  ): void {\n    this.instanceHandlers.get(event)?.delete(handler as AnyHandler);\n  }\n\n  public emit<K extends keyof WorkflowEventMap>(\n    event: K,\n    payload: WorkflowEventMap[K],\n    executionHandlers?: WorkflowEventHandlers,\n  ): void {\n    // Layer 1 — factory\n    invoke(this.factoryHandlers?.[event], payload);\n\n    // Layer 2 — instance (set-based, possibly many handlers)\n    const bucket = this.instanceHandlers.get(event);\n    if (bucket) {\n      for (const handler of bucket) invoke(handler, payload);\n    }\n\n    // Layer 3 — per-execution\n    invoke(executionHandlers?.[event], payload);\n  }\n}\n\nfunction invoke<K extends keyof WorkflowEventMap>(\n  handler: ((payload: WorkflowEventMap[K]) => void) | undefined,\n  payload: WorkflowEventMap[K],\n): void {\n  if (typeof handler !== \"function\") return;\n  try {\n    handler(payload);\n  } catch {\n    // Swallow — listener bugs must not derail workflow execution.\n  }\n}\n"],"mappings":";;;;;;AAiCA,IAAa,kBAAb,MAA6B;CAO3B,AAAO,YAAY,iBAAyC;0CALxB,IAAI,IAGtC;EAGA,KAAK,kBAAkB;CACzB;CAEA,AAAO,GACL,OACA,SACY;EACZ,IAAI,SAAS,KAAK,iBAAiB,IAAI,KAAK;EAC5C,IAAI,CAAC,QAAQ;GACX,yBAAS,IAAI,IAAI;GACjB,KAAK,iBAAiB,IAAI,OAAO,MAAM;EACzC;EACA,OAAO,IAAI,OAAqB;EAChC,aAAa,KAAK,IAAI,OAAO,OAAO;CACtC;CAEA,AAAO,IACL,OACA,SACM;EACN,KAAK,iBAAiB,IAAI,KAAK,CAAC,EAAE,OAAO,OAAqB;CAChE;CAEA,AAAO,KACL,OACA,SACA,mBACM;EAEN,OAAO,KAAK,kBAAkB,QAAQ,OAAO;EAG7C,MAAM,SAAS,KAAK,iBAAiB,IAAI,KAAK;EAC9C,IAAI,QACF,KAAK,MAAM,WAAW,QAAQ,OAAO,SAAS,OAAO;EAIvD,OAAO,oBAAoB,QAAQ,OAAO;CAC5C;AACF;AAEA,SAAS,OACP,SACA,SACM;CACN,IAAI,OAAO,YAAY,YAAY;CACnC,IAAI;EACF,QAAQ,OAAO;CACjB,QAAQ,CAER;AACF"}