@warlock.js/ai 4.4.0 → 4.6.0

package/esm/contracts/speech-model.contract.d.mts

@@ -0,0 +1,97 @@
+import { Usage } from "./result/usage.type.mjs";
+
+//#region ../@warlock.js/ai/src/contracts/speech-model.contract.d.ts
+/**
+ * USD pricing for a text-to-speech model. TTS providers meter one of
+ * two ways, and this single shape covers both so the cost folds into
+ * the same `Usage.cost` rollup the text + image paths use:
+ *
+ * - **Per-character** (OpenAI `tts-1` / `tts-1-hd`): billed per input
+ *   character. Set `perMillionCharacters` (USD per 1,000,000 chars).
+ * - **Token-metered** (OpenAI `gpt-4o-mini-tts`): billed per input/output
+ *   token like a chat model. Set `input` / `output` (USD per 1M tokens).
+ *
+ * Per-character wins when both are set. Nothing set → `Usage.cost`
+ * stays `undefined` (honest "cost unknown", not a false zero).
+ *
+ * @example
+ * const pricing: SpeechModelPricing = { perMillionCharacters: 15 }; // tts-1
+ */
+type SpeechModelPricing = {
+  /** USD per 1M input characters — per-character-metered TTS. */perMillionCharacters?: number; /** USD per 1M input tokens — token-metered TTS. */
+  input?: number; /** USD per 1M output (audio) tokens — token-metered TTS. */
+  output?: number;
+};
+/**
+ * Generated audio, normalized to a discriminated shape (mirrors
+ * {@link GeneratedImage}). TTS providers return raw audio bytes, so the
+ * `base64` variant is the only one today; the union leaves room for a
+ * future hosted-`url` variant without a breaking change.
+ */
+type GeneratedAudio = {
+  type: "base64"; /** Base64-encoded audio bytes. */
+  base64: string; /** IANA media type (e.g. `"audio/mpeg"`, `"audio/wav"`). */
+  mediaType: string;
+};
+/**
+ * Options for a single {@link SpeechModelContract.generate} request.
+ * Provider-neutral; each adapter maps the ones its API supports.
+ */
+type SpeechOptions = {
+  /** Voice id/name (e.g. OpenAI `"alloy"`, `"verse"`). Defaults per model config. */voice?: string; /** Output container (`"mp3"` / `"opus"` / `"aac"` / `"flac"` / `"wav"` / `"pcm"`). */
+  format?: string; /** Playback speed multiplier (provider range, e.g. OpenAI `0.25`–`4.0`). */
+  speed?: number; /** Extra steering of tone/delivery (OpenAI `gpt-4o-mini-tts` `instructions`). */
+  instructions?: string; /** Cancellation handle wired into the provider request where supported. */
+  signal?: AbortSignal; /** Provider-specific escape hatch — forwarded verbatim. */
+  [key: string]: unknown;
+};
+/**
+ * Raw result of a {@link SpeechModelContract.generate} call — low-level
+ * (like `EmbedderContract.embed`): returns the audio + usage and THROWS
+ * a typed `AIError` on failure. The never-throws `{ data, error, usage,
+ * report }` envelope is added by the `ai.speech()` facade verb.
+ */
+type SpeechGenerationResponse = {
+  audio: GeneratedAudio;
+  /**
+   * Token usage when the provider meters per token (gpt-4o-mini-tts);
+   * `{ input: 0, output: 0, total: 0 }` for per-character-metered models,
+   * whose spend is priced from {@link characters}.
+   */
+  usage: Usage; /** Number of input characters synthesized — drives per-character cost. */
+  characters: number;
+};
+/**
+ * Provider-neutral contract for a text-to-speech model — the audio
+ * sibling of {@link ImageModelContract}. Produced by an adapter's
+ * optional `speech?(config)` factory and consumed by `ai.speech()`.
+ *
+ * @example
+ * const tts = openai.speech({ name: "tts-1", voice: "alloy" });
+ * const { audio } = await tts.generate("Welcome aboard.");
+ */
+interface SpeechModelContract {
+  /** Model identifier (e.g. `"tts-1"`, `"gpt-4o-mini-tts"`). */
+  readonly name: string;
+  /** Provider this model belongs to (e.g. `"openai"`). */
+  readonly provider: string;
+  /** Per-character or per-token USD pricing; folded into `Usage.cost` by `ai.speech()`. */
+  readonly pricing?: SpeechModelPricing;
+  /** Synthesize speech from text. Throws a typed `AIError` on failure. */
+  generate(text: string, options?: SpeechOptions): Promise<SpeechGenerationResponse>;
+}
+/**
+ * Configuration passed to an adapter's `speech()` factory. Mirrors
+ * {@link ImageModelConfig}: `name` + an optional per-model `pricing`
+ * override + a default `voice`, with provider-specific keys on the
+ * index signature.
+ */
+type SpeechModelConfig = {
+  name: string; /** Per-model USD pricing override; wins over the SDK-level registry. */
+  pricing?: SpeechModelPricing; /** Default voice when a call omits `options.voice`. */
+  voice?: string;
+  [key: string]: unknown;
+};
+//#endregion
+export { GeneratedAudio, SpeechGenerationResponse, SpeechModelConfig, SpeechModelContract, SpeechModelPricing, SpeechOptions };
+//# sourceMappingURL=speech-model.contract.d.mts.map

package/esm/contracts/speech-model.contract.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"speech-model.contract.d.mts","names":[],"sources":["../../../../../../../@warlock.js/ai/src/contracts/speech-model.contract.ts"],"mappings":";;;;;AAkBA;;;;;;;;AAMQ;AASR;;;;;KAfY,kBAAA;EAoBV,+DAlBA,oBAAA,WAkBS;EAhBT,KAAA,WAuBuB;EArBvB,MAAA;AAAA;;;;;;;KASU,cAAA;EACV,IAAA,YAuBY;EArBZ,MAAA,UA8BkC;EA5BlC,SAAA;AAAA;;;;;KAOU,aAAA;EA8BA,mFA5BV,KAAA,WAwCe;EAtCf,MAAA;EAEA,KAAA,WA6CiC;EA3CjC,YAAA,WA2CiD;EAzCjD,MAAA,GAAS,WAAW,EAyCoC;EAAA,CAvCvD,GAAA;AAAA;;;;;;;KASS,wBAAA;EACV,KAAA,EAAO,cAAA;EA6B0E;AAAA;AASnF;;;EAhCE,KAAA,EAAO,KAAK,EAiCZ;EA/BA,UAAA;AAAA;;;;AAoCY;;;;;;UAxBG,mBAAA;;WAEN,IAAA;;WAEA,QAAA;;WAEA,OAAA,GAAU,kBAAA;;EAGnB,QAAA,CAAS,IAAA,UAAc,OAAA,GAAU,aAAA,GAAgB,OAAA,CAAQ,wBAAA;AAAA;;;;;;;KAS/C,iBAAA;EACV,IAAA;EAEA,OAAA,GAAU,kBAAkB;EAE5B,KAAA;EAAA,CACC,GAAA;AAAA"}

package/esm/contracts/supervisor/supervisor-config.type.d.mts

@@ -1,5 +1,6 @@
 import { Message } from "../conversation-message.type.mjs";
 import { AgentContract } from "../agent/agent.contract.mjs";
+import { FlowObserveOption } from "../../observe/resolve-observers.mjs";
 import { SupervisorInput } from "./supervisor-input.type.mjs";
 import { SnapshotStore } from "../orchestrator/snapshot-store.contract.mjs";
 import { AgentMiddleware } from "../middleware/middleware.contract.mjs";
@@ -70,6 +71,15 @@ type SupervisorConfig<TOutput = unknown, TState = TOutput, TIntents extends Reco
    * independent.
    */
   version?: string;
+  /**
+   * INTERNAL — the report-type discriminator stamped on this run's root
+   * report + result envelope. Defaults to `"supervisor"`. `ai.team` sets
+   * `"team"` so its runs are distinguishable on the wire (group/filter as
+   * their own type) while reusing the supervisor engine wholesale. Not
+   * part of the public supervisor surface — plain `ai.supervisor` callers
+   * leave it unset.
+   */
+  reportType?: "supervisor" | "team";
   /**
    * Opt-in Standard Schema describing this supervisor's input. Purely
    * additive — when set, the supervisor can be dropped straight into an
@@ -392,6 +402,25 @@ type SupervisorConfig<TOutput = unknown, TState = TOutput, TIntents extends Reco
    * }),
    */
   finalizeArtifacts?: (state: TState, artifacts: TArtifacts) => TState;
+  /**
+   * Observability for this supervisor. Additive and gated — when
+   * omitted, the supervisor follows the global observe-all flag (off
+   * unless an observability tool turned it on), so behavior is unchanged
+   * by default.
+   *
+   * - `true` → route this run's completed report to the globally
+   *   registered observers, even when observe-all is off.
+   * - `false` → opt this supervisor out entirely, even when observe-all is on.
+   * - an `Observer` object → a flow-local collector receiving only this
+   *   supervisor's report. Typed as the structural `Observer` so core
+   *   stays panoptic-agnostic; a panoptic flow-local collector can be
+   *   passed directly. Observer errors are swallowed — they never break
+   *   the run.
+   *
+   * `ai.team(...)` forwards its `observe` here verbatim so a team
+   * inherits supervisor observability with no extra wiring.
+   */
+  observe?: FlowObserveOption;
 };
 //#endregion
 export { SupervisorConfig, SupervisorEventHandler, SupervisorEventHandlers };

package/esm/contracts/supervisor/supervisor-config.type.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"supervisor-config.type.d.mts","names":[],"sources":["../../../../../../../../@warlock.js/ai/src/contracts/supervisor/supervisor-config.type.ts"],"mappings":";;;;;;;;;;;;;;;;;;;AAoBA;;KAAY,sBAAA,iBAAuC,kBAAA,KACjD,OAAA,EAAS,kBAAA,CAAmB,CAAA;AAAA,KAGlB,uBAAA,GAA0B,OAAA,eACxB,kBAAA,GAAqB,sBAAA,CAAuB,CAAA;;;;;;;;;AAJ1B;AAGhC;;;;;;;;;;;;;;;AAC2D;AAyC3D;;;;;;;;;;;;;KAAY,gBAAA,6BAED,OAAA,mBACQ,MAAA,SAAe,qBAAA,IAAyB,MAAA,SAAe,qBAAA,gBAC3D,MAAA;EAuGJ,sEApGT,IAAA;EAoGkC;;;;;;;;EA1FlC,OAAA;EAuH6C;;;;;;;;;;;EA1G7C,WAAA,GAAc,gBAAA,CAAiB,eAAA;EAoRI;;;;;EA7QnC,YAAA,GAAe,oBAAA;EAiUqD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA1RpE,IAAA,YAAgB,oBAAA;EA4DiB;;;;;;;;;;;;;;;;;;;EAvCjC,OAAA,GAAU,OAAA;EA+JG;;;;;;;;EArJb,MAAA,GAAS,aAAA,YAAyB,WAAA,CAAY,MAAA;EAmO9C;;;;EA7NA,KAAA,IAAS,GAAA,EAAK,YAAA,CAAa,MAAA,MAAY,IAAA,GAAO,OAAA,CAAQ,IAAA;EAqPP;;;;AAAqB;;;;;;EAzOpE,OAAA,EAAS,QAAA;;;;;;;;;;EAWT,QAAA,IAAY,GAAA,EAAK,eAAA,CAAgB,MAAA,MAAY,cAAA,GAAiB,OAAA,CAAQ,cAAA;;;;;;;;;;;;;;;;EAiBtE,KAAA,GAAQ,MAAA;;;;;EAMR,aAAA;;;;;EAMA,YAAA;;;;;;;;;;;EAYA,MAAA,GAAS,gBAAA,CAAiB,OAAA;;;;;;;;;;;;;EAc1B,aAAA,GAAgB,aAAA;;;;;;EAOhB,EAAA,GAAK,uBAAA;;;;;;;;;;;;;;;;;EAkBL,GAAA,GAAM,SAAA,CAAU,MAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwChB,UAAA,GAAa,gBAAA,CAAiB,MAAA;;;;;;;;;;;;;;;;;;;;;;EAsB9B,aAAA;IACE,MAAA;IACA,MAAA;IACA,GAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;EAyBF,eAAA,GAAkB,gBAAA,CAAiB,UAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4BnC,UAAA,GAAa,eAAA;;;;;;;;;;;;;;;;;;;;;;;EAwBb,iBAAA,IAAqB,KAAA,EAAO,MAAA,EAAQ,SAAA,EAAW,UAAA,KAAe,MAAA;AAAA"}
+{"version":3,"file":"supervisor-config.type.d.mts","names":[],"sources":["../../../../../../../../@warlock.js/ai/src/contracts/supervisor/supervisor-config.type.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;AAqBA;;KAAY,sBAAA,iBAAuC,kBAAA,KACjD,OAAA,EAAS,kBAAA,CAAmB,CAAA;AAAA,KAGlB,uBAAA,GAA0B,OAAA,eACxB,kBAAA,GAAqB,sBAAA,CAAuB,CAAA;;;;;;;;;AAJ1B;AAGhC;;;;;;;;;;;;;;;AAC2D;AAyC3D;;;;;;;;;;;;;KAAY,gBAAA,6BAED,OAAA,mBACQ,MAAA,SAAe,qBAAA,IAAyB,MAAA,SAAe,qBAAA,gBAC3D,MAAA;EAiHJ,sEA9GT,IAAA;EA8GkC;;;;;;;;EApGlC,OAAA;EAiI6C;;;;;;;;EAvH7C,UAAA;EAuMM;;;;;;;;;;;EA1LN,WAAA,GAAc,gBAAA,CAAiB,eAAA;EAvC/B;;;;;EA8CA,YAAA,GAAe,oBAAA;EA5C0C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmFzD,IAAA,YAAgB,oBAAA;EAmFhB;;;;;;;;;;;;;;;;;;;EA9DA,OAAA,GAAU,OAAA;EAiNQ;;;;;;;;EAvMlB,MAAA,GAAS,aAAA,YAAyB,WAAA,CAAY,MAAA;EA2PgB;;;;EArP9D,KAAA,IAAS,GAAA,EAAK,YAAA,CAAa,MAAA,MAAY,IAAA,GAAO,OAAA,CAAQ,IAAA;;;;;;;;;;;EAYtD,OAAA,EAAS,QAAA;;;;;;;;;;EAWT,QAAA,IAAY,GAAA,EAAK,eAAA,CAAgB,MAAA,MAAY,cAAA,GAAiB,OAAA,CAAQ,cAAA;;;;;;;;;;;;;;;;EAiBtE,KAAA,GAAQ,MAAA;;;;;EAMR,aAAA;;;;;EAMA,YAAA;;;;;;;;;;;EAYA,MAAA,GAAS,gBAAA,CAAiB,OAAA;;;;;;;;;;;;;EAc1B,aAAA,GAAgB,aAAA;;;;;;EAOhB,EAAA,GAAK,uBAAA;;;;;;;;;;;;;;;;;EAkBL,GAAA,GAAM,SAAA,CAAU,MAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwChB,UAAA,GAAa,gBAAA,CAAiB,MAAA;;;;;;;;;;;;;;;;;;;;;;EAsB9B,aAAA;IACE,MAAA;IACA,MAAA;IACA,GAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;EAyBF,eAAA,GAAkB,gBAAA,CAAiB,UAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4BnC,UAAA,GAAa,eAAA;;;;;;;;;;;;;;;;;;;;;;;EAwBb,iBAAA,IAAqB,KAAA,EAAO,MAAA,EAAQ,SAAA,EAAW,UAAA,KAAe,MAAA;;;;;;;;;;;;;;;;;;;EAoB9D,OAAA,GAAU,iBAAA;AAAA"}

package/esm/contracts/system-prompt.contract.d.mts

@@ -1,4 +1,5 @@
 import { Placeholders } from "./placeholders.type.mjs";
+import { PromptValidationResult, PromptsValidateOptions } from "../prompts/prompts-manager.type.mjs";
 
 //#region ../@warlock.js/ai/src/contracts/system-prompt.contract.d.ts
 /**
@@ -53,6 +54,53 @@ interface PersonaContract extends SystemPromptBlockContract {
 interface InstructionContract extends SystemPromptBlockContract {
   readonly type: "instruction";
 }
+/**
+ * Identity + provenance metadata attached to a `SystemPromptContract`.
+ *
+ * A prompt that carries a `name` becomes addressable in the `ai.prompts`
+ * registry (keyed by `name@version`); anonymous prompts (no `name`) are never
+ * registered and exist only for inline composition / display.
+ *
+ * `composedFrom` records the deterministic source labels a prompt was merged
+ * from (e.g. `["base@2", "global-instructions@1"]`) — provenance with no
+ * random suffixes, so the same merge always yields the same labels.
+ *
+ * @example
+ * const base = ai.systemPrompt("You are support.", {
+ *   name: "support",
+ *   version: "1",
+ *   description: "Tier-1 support persona.",
+ * });
+ */
+interface SystemPromptMeta {
+  /** Registry name. When present the prompt auto-registers in `ai.prompts`. */
+  readonly name?: string;
+  /** Registry version label. Defaults to the next integer when omitted. */
+  readonly version?: string;
+  /** Human-readable description of the prompt's purpose. */
+  readonly description?: string;
+  /** Deterministic source labels this prompt was composed from (e.g. `["base@2"]`). */
+  readonly composedFrom?: readonly string[];
+  /** Placeholder keys callers must supply when resolving this prompt. */
+  readonly required?: readonly string[];
+}
+/**
+ * Options for the registry-aware overload of {@link SystemPromptContract.merge}
+ * that folds in a named prompt resolved from `ai.prompts`.
+ */
+interface SystemPromptMergeOptions {
+  /**
+   * Which registered version to fold in when merging by name. Defaults to the
+   * latest registered version. Ignored when merging a contract instance.
+   */
+  readonly fromVersion?: string;
+}
+/**
+ * A source that {@link SystemPromptContract.merge} can fold in: a pre-built
+ * block, another prompt contract (its blocks are folded — persona replaces,
+ * instructions append), or a registered prompt name resolved from `ai.prompts`.
+ */
+type SystemPromptMergeSource = SystemPromptBlockContract | SystemPromptContract | string;
 /**
  * Immutable builder for composing a layered system prompt out of persona and
  * instruction blocks. Every mutating method returns a fresh builder — the
@@ -92,6 +140,29 @@ interface InstructionContract extends SystemPromptBlockContract {
 interface SystemPromptContract {
   /** All blocks in render order. Read-only snapshot — use `persona()` / `instruction()` to derive a new builder. */
   readonly blocks: readonly SystemPromptBlockContract[];
+  /**
+   * Identity + provenance metadata. Read it via the no-argument
+   * {@link SystemPromptContract.meta} accessor (`prompt.meta()`); it is
+   * present when the prompt was given a name (via `systemPrompt(input, meta)`
+   * or `.meta({ name })`) or acquired `composedFrom` provenance through a
+   * `merge`, and `undefined` for a bare anonymous prompt.
+   *
+   * Exposed as a method (not a bare field) because the same `meta` identifier
+   * also serves as the immutable updater — see the call signatures below.
+   */
+  /**
+   * No-argument form: read the current metadata snapshot (or `undefined` when
+   * the prompt is anonymous and carries no provenance).
+   */
+  meta(): SystemPromptMeta | undefined;
+  /**
+   * Updater form: return a new builder with `meta` merged onto the current
+   * metadata (shallow). Immutable — the original is untouched. Giving the
+   * result a `name` registers it in `ai.prompts` under `name@version`
+   * (version defaults to the next integer); renaming a forked prompt creates
+   * a new registry key while the original entry stays put.
+   */
+  meta(meta: SystemPromptMeta): SystemPromptContract;
   /**
    * Set (or replace) the persona block. Returns a new builder. If a persona
    * already exists it's replaced in place (preserving its position);
@@ -103,6 +174,30 @@ interface SystemPromptContract {
    * accumulate — instructions render in the order they were added.
    */
   instruction(instruction: InstructionContract | string): SystemPromptContract;
+  /**
+   * Merge N predefined blocks into the prompt in one call. Each block is
+   * folded in order through the same per-type rules as `persona()` /
+   * `instruction()`: a `persona` block sets/replaces the single, leading
+   * persona; every other block is appended in order. Accepts pre-built
+   * `ai.persona()` / `ai.instruction()` blocks (or any `SystemPromptBlockContract`)
+   * for reuse across prompts. Returns a new builder; the original is untouched.
+   */
+  merge(...blocks: readonly SystemPromptBlockContract[]): SystemPromptContract;
+  /**
+   * Fold in another prompt's blocks. A persona block replaces this prompt's
+   * persona; instruction (and any other) blocks append in order. The result's
+   * `meta.composedFrom` records the deterministic source labels of both this
+   * prompt and the folded one (e.g. `["base@2", "global-instructions@1"]`).
+   * Returns a new builder; the original is untouched.
+   */
+  merge(source: SystemPromptContract): SystemPromptContract;
+  /**
+   * Fold in a prompt resolved from the `ai.prompts` registry by name. Uses the
+   * latest registered version unless `options.fromVersion` selects another.
+   * Throws `InvalidRequestError` when the name (or requested version) is not
+   * registered. Provenance is recorded in `meta.composedFrom`.
+   */
+  merge(name: string, options?: SystemPromptMergeOptions): SystemPromptContract;
   /**
    * Resolve all placeholders across every block, producing the final system
    * prompt string. Blocks render in insertion order, separated by a blank line.
@@ -112,7 +207,14 @@ interface SystemPromptContract {
    * @param placeholders - Values to inject into `{{mustache}}` slots.
    */
   resolve(placeholders?: Placeholders): string;
+  /**
+   * Sugar over `ai.prompts.validate(this, options)`. Runs the deterministic
+   * placeholder check (missing required `{{keys}}`) and, when `options.judge`
+   * is a model, the Nova-safe LLM-as-judge quality pass. The result's `ok`
+   * reflects the deterministic verdict alone; a flaky judge never flips it.
+   */
+  validate(options?: PromptsValidateOptions): Promise<PromptValidationResult>;
 }
 //#endregion
-export { InstructionContract, PersonaContract, SystemPromptBlockContract, SystemPromptContract };
+export { InstructionContract, PersonaContract, SystemPromptBlockContract, SystemPromptContract, SystemPromptMergeOptions, SystemPromptMergeSource, SystemPromptMeta };
 //# sourceMappingURL=system-prompt.contract.d.mts.map

package/esm/contracts/system-prompt.contract.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"system-prompt.contract.d.mts","names":[],"sources":["../../../../../../../@warlock.js/ai/src/contracts/system-prompt.contract.ts"],"mappings":";;;;;AAiBA;;;;;;;;;;AAQqC;AAarC;;UArBiB,yBAAA;EAqBwB;EAAA,SAnB9B,IAAA;EAoCM;EAAA,SAjCN,IAAA;;EAGT,OAAA,CAAQ,YAAA,GAAe,YAAY;AAAA;AAsErC;;;;;;;;;;AAAA,UAzDiB,eAAA,SAAwB,yBAAyB;EAAA,SACvD,IAAI;AAAA;;;;;;;;;;;;;AAiFsB;UAjEpB,mBAAA,SAA4B,yBAAyB;EAAA,SAC3D,IAAI;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAuCE,oBAAA;;WAEN,MAAA,WAAiB,yBAAA;;;;;;EAO1B,OAAA,CAAQ,OAAA,EAAS,eAAA,YAA2B,oBAAA;;;;;EAM5C,WAAA,CAAY,WAAA,EAAa,mBAAA,YAA+B,oBAAA;;;;;;;;;EAUxD,OAAA,CAAQ,YAAA,GAAe,YAAA;AAAA"}
+{"version":3,"file":"system-prompt.contract.d.mts","names":[],"sources":["../../../../../../../@warlock.js/ai/src/contracts/system-prompt.contract.ts"],"mappings":";;;;;;AAqBA;;;;;;;;;;AAQqC;AAarC;;UArBiB,yBAAA;EAqBwB;EAAA,SAnB9B,IAAA;EAoCM;EAAA,SAjCN,IAAA;;EAGT,OAAA,CAAQ,YAAA,GAAe,YAAY;AAAA;AAoDrC;;;;;;;;;;AAAA,UAvCiB,eAAA,SAAwB,yBAAyB;EAAA,SACvD,IAAI;AAAA;;;AAgEO;AAQtB;;;;AAEwB;AAuCxB;;;;;UAjGiB,mBAAA,SAA4B,yBAAyB;EAAA,SAC3D,IAAI;AAAA;;;;;;;;;;;;;;;;;;;UAqBE,gBAAA;EAuGf;EAAA,SArGS,IAAA;EAqGJ;EAAA,SAlGI,OAAA;EAyGT;EAAA,SAtGS,WAAA;EAsGD;EAAA,SAnGC,YAAA;EAyGT;EAAA,SAtGS,QAAA;AAAA;;;;;UAOM,wBAAA;EAkHf;;;;EAAA,SA7GS,WAAW;AAAA;;;;;;KAQV,uBAAA,GACR,yBAAA,GACA,oBAAoB;;;;;;;AAgIoD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAzF3D,oBAAA;;WAEN,MAAA,WAAiB,yBAAA;;;;;;;;;;;;;;;EAiB1B,IAAA,IAAQ,gBAAA;;;;;;;;EASR,IAAA,CAAK,IAAA,EAAM,gBAAA,GAAmB,oBAAA;;;;;;EAO9B,OAAA,CAAQ,OAAA,EAAS,eAAA,YAA2B,oBAAA;;;;;EAM5C,WAAA,CAAY,WAAA,EAAa,mBAAA,YAA+B,oBAAA;;;;;;;;;EAUxD,KAAA,IAAS,MAAA,WAAiB,yBAAA,KAA8B,oBAAA;;;;;;;;EASxD,KAAA,CAAM,MAAA,EAAQ,oBAAA,GAAuB,oBAAA;;;;;;;EAQrC,KAAA,CACE,IAAA,UACA,OAAA,GAAU,wBAAA,GACT,oBAAA;;;;;;;;;EAUH,OAAA,CAAQ,YAAA,GAAe,YAAA;;;;;;;EAQvB,QAAA,CAAS,OAAA,GAAU,sBAAA,GAAyB,OAAA,CAAQ,sBAAA;AAAA"}

package/esm/contracts/team/index.d.mts

@@ -0,0 +1 @@
+import { TeamConfig, TeamGate, TeamGateFn, TeamMemberValue } from "./team-config.type.mjs";

package/esm/contracts/team/team-config.type.d.mts

@@ -0,0 +1,127 @@
+import { AgentContract } from "../agent/agent.contract.mjs";
+import { FlowObserveOption } from "../../observe/resolve-observers.mjs";
+import { SnapshotStore } from "../orchestrator/snapshot-store.contract.mjs";
+import { WorkflowInstance } from "../workflow/workflow.contract.mjs";
+import { SystemPromptContract } from "../system-prompt.contract.mjs";
+import { RouterEntry } from "../supervisor/router-entry.type.mjs";
+import { SupervisorConfig, SupervisorEventHandlers } from "../supervisor/supervisor-config.type.mjs";
+import { EvaluateContext, EvaluateResult } from "../supervisor/evaluate-context.type.mjs";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+
+//#region ../@warlock.js/ai/src/contracts/team/team-config.type.d.ts
+/**
+ * A role member — an agent or a workflow. The same shorthand the
+ * supervisor accepts on each `intents` value, narrowed to the two
+ * dispatchable unit shapes `team()` forwards verbatim. (Callback /
+ * full-entry intent shapes still work when forwarded — this alias is
+ * the documented, autocomplete-friendly subset for the common case.)
+ */
+type TeamMemberValue = AgentContract<unknown> | WorkflowInstance<unknown, unknown>;
+/**
+ * The built-in quality-gate strategies. Each desugars to a concrete
+ * {@link SupervisorConfig.evaluate} callback — no new loop or
+ * termination code; both lean entirely on the already-shipped
+ * {@link EvaluateResult} semantics (`satisfied` terminates,
+ * `reassignTo` re-dispatches the fixer, `feedback` threads forward).
+ *
+ * - `"quality"` — review-then-fix loop. After members settle, read the
+ *   reviewer's verdict slice (`state.approved` by default); if not
+ *   approved, `reassignTo` the fixer with the reviewer feedback
+ *   (`state.notes`) threaded forward. Terminates on approval.
+ * - `"verify"` — test-then-fix loop. Same shape but keyed on the
+ *   tester's pass/fail slice (`state.passed` by default) instead of a
+ *   subjective reviewer score.
+ */
+type TeamGate = "quality" | "verify";
+/**
+ * Fully-custom gate — an escape hatch identical to
+ * {@link SupervisorConfig.evaluate}. Supplying a function instead of a
+ * {@link TeamGate} string opts out of the sugar entirely while keeping
+ * the rest of `team()`'s wiring. Forwarded straight through as
+ * `evaluate` with zero wrapping.
+ */
+type TeamGateFn<TState> = (ctx: EvaluateContext<TState>) => EvaluateResult | Promise<EvaluateResult>;
+/**
+ * Config for `ai.team(config)` — thin, transparent sugar over
+ * {@link SupervisorConfig}. `team()` builds a `SupervisorConfig` from
+ * these fields and calls `supervisor(...)`, returning the **unchanged**
+ * `SupervisorContract<TOutput>`. It owns no loop: the manager becomes
+ * `route`/`router`, the members become `intents`, and the gate becomes
+ * `evaluate`. Everything else passes through 1:1.
+ *
+ * @example
+ * const codeTeam = ai.team({
+ *   name: "code-team",
+ *   goal: "Ship a tested module that passes review.",
+ *   manager: techLeadRouter,
+ *   members: { builder, reviewer, fixer },
+ *   gate: "quality",
+ *   output: v.object({ code: v.string() }),
+ *   maxIterations: 6,
+ * });
+ */
+type TeamConfig<TOutput = unknown, TState = TOutput, TMembers extends Record<string, TeamMemberValue> = Record<string, TeamMemberValue>> = {
+  /** Stable identifier — forwarded verbatim to `SupervisorConfig.name`. */name: string; /** Optional dev-curated version string — forwarded to `SupervisorConfig.version`. */
+  version?: string;
+  /**
+   * The manager. Drives dispatch each iteration. Two forms:
+   * - an `AgentContract` / `RouterEntry` → becomes `SupervisorConfig.router`
+   *   (LLM-driven manager).
+   * - `{ route }` → becomes `SupervisorConfig.route` (deterministic manager).
+   * Exactly one is forwarded; mutually exclusive (mirrors the
+   * supervisor's own `router` XOR `route` rule).
+   */
+  manager: AgentContract<unknown> | RouterEntry<TState> | {
+    route: NonNullable<SupervisorConfig<TOutput, TState>["route"]>;
+  };
+  /**
+   * Role members keyed by role name (e.g. `builder`, `reviewer`,
+   * `tester`, `fixer`). Forwarded verbatim as `SupervisorConfig.intents`.
+   * The keys are the role names the manager routes to AND the keys
+   * `ctx.intents.<role>` exposes (escape hatch preserved).
+   */
+  members: TMembers;
+  /**
+   * The quality gate. A {@link TeamGate} string selects a pre-built
+   * `evaluate` strategy; a function is forwarded straight to
+   * `SupervisorConfig.evaluate` (full escape hatch). Required — a team
+   * without a gate is just a supervisor.
+   */
+  gate: TeamGate | TeamGateFn<TState>;
+  /**
+   * Role-name mapping for the built-in string gates. Only consulted
+   * when `gate` is a {@link TeamGate} string. Defaults:
+   * `{ reviewer: "reviewer", fixer: "fixer", tester: "tester" }`.
+   * Override when your `members` keys differ from the canonical role
+   * names.
+   */
+  roles?: {
+    reviewer?: keyof TMembers & string;
+    fixer?: keyof TMembers & string;
+    tester?: keyof TMembers & string;
+  };
+  /**
+   * State key the gate reads to decide satisfaction. Defaults to
+   * `"approved"` for `gate: "quality"` and `"passed"` for
+   * `gate: "verify"`. The named member's `output` schema must write a
+   * boolean into this key.
+   */
+  gateKey?: string; /** Natural-language objective — forwarded verbatim to `SupervisorConfig.goal`. */
+  goal?: string | SystemPromptContract; /** Final-state schema — forwarded verbatim to `SupervisorConfig.output`. */
+  output?: StandardSchemaV1<TOutput>; /** Initial state seed — forwarded verbatim to `SupervisorConfig.state`. */
+  state?: TState; /** Hard iteration cap — forwarded verbatim; defaults to the supervisor's `10`. */
+  maxIterations?: number; /** Durable snapshot store — forwarded verbatim to `SupervisorConfig.snapshotStore`. */
+  snapshotStore?: SnapshotStore; /** Definition-level event handlers — forwarded verbatim to `SupervisorConfig.on`. */
+  on?: SupervisorEventHandlers;
+  /**
+   * Observability for this team — forwarded verbatim to
+   * `SupervisorConfig.observe`, so the underlying supervisor routes its
+   * completed report through the same generic `Observer` seam every
+   * other flow uses. Additive and gated; see `SupervisorConfig.observe`
+   * for the value semantics (`true` / `false` / a flow-local `Observer`).
+   */
+  observe?: FlowObserveOption;
+};
+//#endregion
+export { TeamConfig, TeamGate, TeamGateFn, TeamMemberValue };
+//# sourceMappingURL=team-config.type.d.mts.map

package/esm/contracts/team/team-config.type.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"team-config.type.d.mts","names":[],"sources":["../../../../../../../../@warlock.js/ai/src/contracts/team/team-config.type.ts"],"mappings":";;;;;;;;;;;;;AAiBA;;;;AAEoB;KAFR,eAAA,GACR,aAAA,YACA,gBAAgB;;;;AAiBA;AASpB;;;;;;;;;;;KATY,QAAA;;;;;;;AAWgC;KAFhC,UAAA,YACV,GAAA,EAAK,eAAA,CAAgB,MAAA,MAClB,cAAA,GAAiB,OAAA,CAAQ,cAAA;;;;;;;;;;;;;;;;;;;;KAqBlB,UAAA,6BAED,OAAA,mBACQ,MAAA,SAAe,eAAA,IAAmB,MAAA,SAAe,eAAA;EA+CjD,yEA5CjB,IAAA,UA6D0B;EA1D1B,OAAA;EA6DQ;;;;;;;;EAnDR,OAAA,EACI,aAAA,YACA,WAAA,CAAY,MAAA;IACV,KAAA,EAAO,WAAA,CAAY,gBAAA,CAAiB,OAAA,EAAS,MAAA;EAAA;EAnBnB;;;;;;EA2BhC,OAAA,EAAS,QAAA;EATL;;;;;;EAiBJ,IAAA,EAAM,QAAA,GAAW,UAAA,CAAW,MAAA;EAR5B;;;;;;;EAiBA,KAAA;IACE,QAAA,SAAiB,QAAA;IACjB,KAAA,SAAc,QAAA;IACd,MAAA,SAAe,QAAA;EAAA;EAAA;;;;;;EASjB,OAAA,WAWA;EANA,IAAA,YAAgB,oBAAA,EAShB;EANA,MAAA,GAAS,gBAAA,CAAiB,OAAA,GASV;EANhB,KAAA,GAAQ,MAAA,EASH;EANL,aAAA,WAeU;EAZV,aAAA,GAAgB,aAAA,EAYW;EAT3B,EAAA,GAAK,uBAAA;;;;;;;;EASL,OAAA,GAAU,iBAAA;AAAA"}

package/esm/contracts/tool.contract.d.mts

@@ -121,8 +121,10 @@ interface ToolConfig<TInput = unknown, TOutput = unknown> {
    *
    * Two forms:
    * - **string** — static, used as-is.
-   * - **function** — receives the validated input and returns a
-   *   string, so callers can include input data
+   * - **function** — receives the model's **raw, pre-validation**
+   *   input (resolved at the dispatch boundary, before `execute`'s
+   *   schema validation runs) and returns a string, so callers can
+   *   include input data
    *   (`(input) => \`Searching for "${input.query}"\``).
    *
    * Resolved at the framework boundary; consumers receive a

package/esm/contracts/tool.contract.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"tool.contract.d.mts","names":[],"sources":["../../../../../../../@warlock.js/ai/src/contracts/tool.contract.ts"],"mappings":";;;;;AAQA;;;;KAAY,QAAA,GAAW,MAAM;AAoC7B;;;;AAAoB;AAmCpB;;;;;;;;;;;;;;;AASsB;AAiBtB;;;;;;;;;;;;;AA7DA,KAAY,QAAA;;;;;;;;;;;;;;;;;;;;;;;;AAmHgD;;;;;;;;;;KAhFhD,WAAA,cAAyB,MAAA;;;;;;;EAOnC,SAAA,EAAW,UAAA;EAEX,MAAA,GAAS,WAAA;AAAA;;;;;;;;;;;;;;;UAiBM,UAAA;;EAEf,IAAA;;EAEA,WAAA;;;;;;;;EAQA,OAAA;;;;;;;;;;;;;;;;EAgBA,MAAA,cAAoB,KAAA,EAAO,MAAA;;EAE3B,IAAA,GAAO,QAAA;;;;;;;EAOP,IAAA,GAAO,QAAA;;;;;;EAMP,KAAA,GAAQ,gBAAA,CAAiB,MAAA;;;;;;;;;;;EAWzB,OAAA,CAAQ,KAAA,EAAO,MAAA,EAAQ,GAAA,GAAM,WAAA,GAAc,OAAA,CAAQ,OAAA;AAAA"}
+{"version":3,"file":"tool.contract.d.mts","names":[],"sources":["../../../../../../../@warlock.js/ai/src/contracts/tool.contract.ts"],"mappings":";;;;;AAQA;;;;KAAY,QAAA,GAAW,MAAM;AAoC7B;;;;AAAoB;AAmCpB;;;;;;;;;;;;;;;AASsB;AAiBtB;;;;;;;;;;;;;AA7DA,KAAY,QAAA;;;;;;;;;;;;;;;;;;;;;;;;AAqHgD;;;;;;;;;;KAlFhD,WAAA,cAAyB,MAAA;;;;;;;EAOnC,SAAA,EAAW,UAAA;EAEX,MAAA,GAAS,WAAA;AAAA;;;;;;;;;;;;;;;UAiBM,UAAA;;EAEf,IAAA;;EAEA,WAAA;;;;;;;;EAQA,OAAA;;;;;;;;;;;;;;;;;;EAkBA,MAAA,cAAoB,KAAA,EAAO,MAAA;;EAE3B,IAAA,GAAO,QAAA;;;;;;;EAOP,IAAA,GAAO,QAAA;;;;;;EAMP,KAAA,GAAQ,gBAAA,CAAiB,MAAA;;;;;;;;;;;EAWzB,OAAA,CAAQ,KAAA,EAAO,MAAA,EAAQ,GAAA,GAAM,WAAA,GAAc,OAAA,CAAQ,OAAA;AAAA"}

package/esm/contracts/transcription-model.contract.d.mts

@@ -0,0 +1,101 @@
+import { Usage } from "./result/usage.type.mjs";
+
+//#region ../@warlock.js/ai/src/contracts/transcription-model.contract.d.ts
+/**
+ * USD pricing for a speech-to-text (transcription) model. STT providers
+ * meter one of two ways; this single shape covers both so the cost
+ * folds into the same `Usage.cost` rollup as text / image / speech:
+ *
+ * - **Per-minute** (OpenAI `whisper-1`): billed per minute of input
+ *   audio. Set `perMinute` (USD per audio-minute).
+ * - **Token-metered** (OpenAI `gpt-4o-transcribe`): billed per
+ *   input/output token. Set `input` / `output` (USD per 1M tokens).
+ *
+ * Per-minute wins when both are set. Nothing set → `Usage.cost` stays
+ * `undefined`.
+ *
+ * @example
+ * const pricing: TranscriptionModelPricing = { perMinute: 0.006 }; // whisper-1
+ */
+type TranscriptionModelPricing = {
+  /** USD per minute of input audio — per-minute-metered STT. */perMinute?: number; /** USD per 1M input (audio) tokens — token-metered STT. */
+  input?: number; /** USD per 1M output (text) tokens — token-metered STT. */
+  output?: number;
+};
+/** One timestamped segment of a transcription (when the provider returns segments). */
+type TranscriptionSegment = {
+  text: string; /** Segment start time in seconds. */
+  start?: number; /** Segment end time in seconds. */
+  end?: number;
+};
+/**
+ * The audio to transcribe — inlined base64 bytes with an explicit IANA
+ * media type, plus an optional filename (some providers infer the codec
+ * from the extension). Read a file to base64 before calling, or pass
+ * in-memory bytes; this keeps the verb provider-neutral and
+ * serializable (no `fs` coupling in core).
+ *
+ * @example
+ * const audio: AudioInput = { base64: buf.toString("base64"), mediaType: "audio/mpeg", filename: "note.mp3" };
+ */
+type AudioInput = {
+  base64: string;
+  mediaType: string;
+  filename?: string;
+};
+/** Options for a single {@link TranscriptionModelContract.transcribe} request. */
+type TranscribeOptions = {
+  /** BCP-47 language hint (e.g. `"en"`) — improves accuracy + latency. */language?: string; /** Optional priming prompt (spelling/style hints). */
+  prompt?: string; /** Provider response format override (e.g. `"verbose_json"` for segments + duration). */
+  format?: string; /** Cancellation handle wired into the provider request where supported. */
+  signal?: AbortSignal; /** Provider-specific escape hatch — forwarded verbatim. */
+  [key: string]: unknown;
+};
+/**
+ * Raw result of a {@link TranscriptionModelContract.transcribe} call —
+ * low-level (throws a typed `AIError` on failure). The never-throws
+ * envelope is added by the `ai.transcribe()` facade verb.
+ */
+type TranscriptionResponse = {
+  /** The full transcript text. */text: string; /** Timestamped segments when the provider returns them (verbose mode). */
+  segments?: TranscriptionSegment[]; /** Input audio duration in seconds — drives per-minute cost when present. */
+  durationSeconds?: number;
+  /**
+   * Token usage when the provider meters per token (gpt-4o-transcribe);
+   * `{ input: 0, output: 0, total: 0 }` for per-minute-metered models,
+   * whose spend is priced from {@link durationSeconds}.
+   */
+  usage: Usage;
+};
+/**
+ * Provider-neutral contract for a speech-to-text model — the inverse of
+ * {@link SpeechModelContract}. Produced by an adapter's optional
+ * `transcribe?(config)` factory and consumed by `ai.transcribe()`.
+ *
+ * @example
+ * const stt = openai.transcribe({ name: "whisper-1" });
+ * const { text } = await stt.transcribe({ base64, mediaType: "audio/mpeg" });
+ */
+interface TranscriptionModelContract {
+  /** Model identifier (e.g. `"whisper-1"`, `"gpt-4o-transcribe"`). */
+  readonly name: string;
+  /** Provider this model belongs to (e.g. `"openai"`). */
+  readonly provider: string;
+  /** Per-minute or per-token USD pricing; folded into `Usage.cost` by `ai.transcribe()`. */
+  readonly pricing?: TranscriptionModelPricing;
+  /** Transcribe audio to text. Throws a typed `AIError` on failure. */
+  transcribe(audio: AudioInput, options?: TranscribeOptions): Promise<TranscriptionResponse>;
+}
+/**
+ * Configuration passed to an adapter's `transcribe()` factory. Mirrors
+ * {@link SpeechModelConfig}: `name` + an optional per-model `pricing`
+ * override, with provider-specific keys on the index signature.
+ */
+type TranscriptionModelConfig = {
+  name: string; /** Per-model USD pricing override; wins over the SDK-level registry. */
+  pricing?: TranscriptionModelPricing;
+  [key: string]: unknown;
+};
+//#endregion
+export { AudioInput, TranscribeOptions, TranscriptionModelConfig, TranscriptionModelContract, TranscriptionModelPricing, TranscriptionResponse, TranscriptionSegment };
+//# sourceMappingURL=transcription-model.contract.d.mts.map

package/esm/contracts/transcription-model.contract.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transcription-model.contract.d.mts","names":[],"sources":["../../../../../../../@warlock.js/ai/src/contracts/transcription-model.contract.ts"],"mappings":";;;;;AAkBA;;;;;;;;AAMQ;AAIR;;;;;KAVY,yBAAA;EAeV,8DAbA,SAAA,WAaG;EAXH,KAAA,WAwBoB;EAtBpB,MAAA;AAAA;;KAIU,oBAAA;EACV,IAAA,UAoBQ;EAlBR,KAAA,WAsBU;EApBV,GAAA;AAAA;;;;;;;;;AA8BY;AAQd;KAzBY,UAAA;EACV,MAAA;EACA,SAAA;EACA,QAAA;AAAA;;KAIU,iBAAA;EA8BV,wEA5BA,QAAA,WA4BY;EA1BZ,MAAA,WAsCe;EApCf,MAAA;EAEA,MAAA,GAAS,WAAW,EA2CF;EAAA,CAzCjB,GAAA;AAAA;;;;;;KAQS,qBAAA;EA8BS,gCA5BnB,IAAA,UA+BkB;EA7BlB,QAAA,GAAW,oBAAA,IA6B6B;EA3BxC,eAAA;EA2B4D;;;AAA6B;AAQ3F;EA7BE,KAAA,EAAO,KAAK;AAAA;;;;;;;AAiCA;;;UArBG,0BAAA;;WAEN,IAAA;;WAEA,QAAA;;WAEA,OAAA,GAAU,yBAAA;;EAGnB,UAAA,CAAW,KAAA,EAAO,UAAA,EAAY,OAAA,GAAU,iBAAA,GAAoB,OAAA,CAAQ,qBAAA;AAAA;;;;;;KAQ1D,wBAAA;EACV,IAAA;EAEA,OAAA,GAAU,yBAAyB;EAAA,CAClC,GAAA;AAAA"}

package/esm/contracts/workflow/step.contract.d.mts

@@ -169,13 +169,38 @@ type StepDefinition<TInput = unknown, TState = Record<string, unknown>, TContext
    */
   retry?: RetryConfig | false;
   /**
-   * Parallel children — run concurrently, share `ctx.state`
-   * (last-write-wins). Mutually exclusive with `run` and `agent`.
-   * The parent's snapshot is atomic: written only after every child
-   * settles. Children are addressable at both `ctx.steps.<child>` and
-   * `ctx.steps.<parent>.steps.<child>`.
+   * Parallel children — run concurrently, each starting from a snapshot
+   * of the parent `ctx.state`. After every child settles, their
+   * resulting states are merged back into the parent in **declaration
+   * order** (the order children appear in this array), so a key written
+   * by more than one child deterministically resolves to the
+   * **last-declared** child's value — regardless of which child finished
+   * first. Supply {@link mergeState} to customize conflict resolution
+   * (e.g. sum counters, concat arrays). Mutually exclusive with `run`
+   * and `agent`. The parent's snapshot is atomic: written only after
+   * every child settles. Children are addressable at both
+   * `ctx.steps.<child>` and `ctx.steps.<parent>.steps.<child>`.
    */
   parallel?: StepDefinition<TInput, TState, TContext>[];
+  /**
+   * Conflict resolver for {@link parallel} children that write the same
+   * `ctx.state` keys. Called once per child, in **declaration order**,
+   * with the accumulator (the parent state being built up), that child's
+   * resolved state, and the child's name. Mutate `acc` in place.
+   *
+   * Omit it to keep the deterministic default (last-declared child wins
+   * per key — a plain `Object.assign` in declaration order). Supply it
+   * for advanced merges:
+   *
+   * ```ts
+   * mergeState: (acc, childState) => {
+   *   acc.total = (acc.total ?? 0) + (childState.total ?? 0); // sum
+   * }
+   * ```
+   *
+   * Only consulted for parallel steps; ignored otherwise.
+   */
+  mergeState?: (acc: TState, childState: TState, childName: string) => void;
   /**
    * Per-step event handlers — fires alongside the workflow-level
    * `workflow.step.*` events. Scope is step-local (no `workflow.`

package/esm/contracts/workflow/step.contract.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"step.contract.d.mts","names":[],"sources":["../../../../../../../../@warlock.js/ai/src/contracts/workflow/step.contract.ts"],"mappings":";;;;;;;;;;;;AAaA;;KAAY,eAAA;EAAe,yEAEzB,QAAA;IAAY,IAAA;EAAA,GAGV;EADF,QAAA;IACE,IAAA;IACA,OAAA;IACA,aAAA;IACA,SAAA;EAAA,GAGsC;EAAxC,MAAA;IAAU,IAAA;IAAc,KAAA;IAAgB,QAAA;EAAA,GAEY;EAApD,SAAA;IAAa,IAAA;IAAc,MAAA;IAAiB,QAAA;EAAA;AAAA;;;;;;KAQlC,cAAA,GAAiB,mBAAmB;EAqBvC,8DAnBP,MAAM;AAAA;;;;;;;;;;KAYI,cAAA,+CAGD,MAAA;EAGT,OAAA,GACE,GAAA,EAAK,eAAA,CAAgB,MAAA,EAAQ,MAAA,EAAQ,QAAA,MAClC,OAAA,GAAU,OAAA,CAAQ,OAAA;EACvB,MAAA,GAAS,gBAAA,CAAiB,OAAA;AAAA;;;;;;;;;;;AAAO;AAoBnC;;;;;;KAAY,cAAA,4BAED,MAAA;EAkBI;;;;;;EATb,IAAA;EAwB4B;;;;;;;EAf5B,IAAA,IAAQ,GAAA,EAAK,eAAA,CAAgB,MAAA,EAAQ,MAAA,EAAQ,QAAA,gBAAwB,OAAA;EAgCvD;;;;;;EAxBd,MAAA,IAAU,GAAA,EAAK,eAAA,CAAgB,MAAA,EAAQ,MAAA,EAAQ,QAAA,aAAqB,OAAA;EA+B3D;;;;;EAxBT,GAAA,IAAO,GAAA,EAAK,eAAA,CAAgB,MAAA,EAAQ,MAAA,EAAQ,QAAA;EA4CX;;;;;;;EAnCjC,KAAA,GAAQ,aAAA;EAoDuB;;;;;;EA5C/B,KAAA,IAAS,GAAA,EAAK,eAAA,CAAgB,MAAA,EAAQ,MAAA,EAAQ,QAAA,MAAc,cAAA,GAAiB,OAAA,CAAQ,cAAA;EAsDpD;;;;;EA/CjC,MAAA,GAAS,cAAA,UAAwB,MAAA,EAAQ,MAAA,EAAQ,QAAA;EAgEvB;;;;;;EAxD1B,KAAA,IAAS,GAAA,EAAK,eAAA,CAAgB,MAAA,EAAQ,MAAA,EAAQ,QAAA,aAAqB,OAAA;EAgE9D;;;;;;;;;;EApDL,QAAA,IAAY,GAAA,EAAK,eAAA,CAAgB,MAAA,EAAQ,MAAA,EAAQ,QAAA,MAAc,cAAA,GAAiB,OAAA,CAAQ,cAAA;EA3DnD;;;;;;;;;;;;;;EA2ErC,SAAA,IACE,GAAA,EAAK,eAAA,CAAgB,MAAA,EAAQ,MAAA,EAAQ,QAAA,GACrC,KAAA,EAAO,OAAA,KACJ,cAAA,GAAiB,OAAA,CAAQ,cAAA;EA/Dc;;;;;;EAuE5C,QAAA,IAAY,GAAA,EAAK,eAAA,CAAgB,MAAA,EAAQ,MAAA,EAAQ,QAAA,aAAqB,OAAA;EAtDhC;;;;;;EA8DtC,KAAA,GAAQ,WAAA;EAvDC;;;;;;;EAgET,QAAA,GAAW,cAAA,CAAe,MAAA,EAAQ,MAAA,EAAQ,QAAA;EAxDI;;;;;;EAgE9C,EAAA,GAAK,OAAA,eACS,eAAA,IAAmB,OAAA,EAAS,eAAA,CAAgB,CAAA;AAAA"}
+{"version":3,"file":"step.contract.d.mts","names":[],"sources":["../../../../../../../../@warlock.js/ai/src/contracts/workflow/step.contract.ts"],"mappings":";;;;;;;;;;;;AAaA;;KAAY,eAAA;EAAe,yEAEzB,QAAA;IAAY,IAAA;EAAA,GAGV;EADF,QAAA;IACE,IAAA;IACA,OAAA;IACA,aAAA;IACA,SAAA;EAAA,GAGsC;EAAxC,MAAA;IAAU,IAAA;IAAc,KAAA;IAAgB,QAAA;EAAA,GAEY;EAApD,SAAA;IAAa,IAAA;IAAc,MAAA;IAAiB,QAAA;EAAA;AAAA;;;;;;KAQlC,cAAA,GAAiB,mBAAmB;EAqBvC,8DAnBP,MAAM;AAAA;;;;;;;;;;KAYI,cAAA,+CAGD,MAAA;EAGT,OAAA,GACE,GAAA,EAAK,eAAA,CAAgB,MAAA,EAAQ,MAAA,EAAQ,QAAA,MAClC,OAAA,GAAU,OAAA,CAAQ,OAAA;EACvB,MAAA,GAAS,gBAAA,CAAiB,OAAA;AAAA;;;;;;;;;;;AAAO;AAoBnC;;;;;;KAAY,cAAA,4BAED,MAAA;EAkBI;;;;;;EATb,IAAA;EAwB4B;;;;;;;EAf5B,IAAA,IAAQ,GAAA,EAAK,eAAA,CAAgB,MAAA,EAAQ,MAAA,EAAQ,QAAA,gBAAwB,OAAA;EAgCvD;;;;;;EAxBd,MAAA,IAAU,GAAA,EAAK,eAAA,CAAgB,MAAA,EAAQ,MAAA,EAAQ,QAAA,aAAqB,OAAA;EA+B3D;;;;;EAxBT,GAAA,IAAO,GAAA,EAAK,eAAA,CAAgB,MAAA,EAAQ,MAAA,EAAQ,QAAA;EA4CX;;;;;;;EAnCjC,KAAA,GAAQ,aAAA;EAoDuB;;;;;;EA5C/B,KAAA,IAAS,GAAA,EAAK,eAAA,CAAgB,MAAA,EAAQ,MAAA,EAAQ,QAAA,MAAc,cAAA,GAAiB,OAAA,CAAQ,cAAA;EAsDpD;;;;;EA/CjC,MAAA,GAAS,cAAA,UAAwB,MAAA,EAAQ,MAAA,EAAQ,QAAA;EAsEvB;;;;;;EA9D1B,KAAA,IAAS,GAAA,EAAK,eAAA,CAAgB,MAAA,EAAQ,MAAA,EAAQ,QAAA,aAAqB,OAAA;EA2FzB;;;;;;;;;;EA/E1C,QAAA,IAAY,GAAA,EAAK,eAAA,CAAgB,MAAA,EAAQ,MAAA,EAAQ,QAAA,MAAc,cAAA,GAAiB,OAAA,CAAQ,cAAA;EA3D3E;;;;;;;;;;;;;;EA2Eb,SAAA,IACE,GAAA,EAAK,eAAA,CAAgB,MAAA,EAAQ,MAAA,EAAQ,QAAA,GACrC,KAAA,EAAO,OAAA,KACJ,cAAA,GAAiB,OAAA,CAAQ,cAAA;EA/DF;;;;;;EAuE5B,QAAA,IAAY,GAAA,EAAK,eAAA,CAAgB,MAAA,EAAQ,MAAA,EAAQ,QAAA,aAAqB,OAAA;EAtDxD;;;;;;EA8Dd,KAAA,GAAQ,WAAA;EA9D6E;;;;;;;;;;;;;EA6ErF,QAAA,GAAW,cAAA,CAAe,MAAA,EAAQ,MAAA,EAAQ,QAAA;EAlDzB;;;;;;;;;;;;;;;;;;EAsEjB,UAAA,IAAc,GAAA,EAAK,MAAA,EAAQ,UAAA,EAAY,MAAA,EAAQ,SAAA;EA3C/C;;;;;;EAmDA,EAAA,GAAK,OAAA,eACS,eAAA,IAAmB,OAAA,EAAS,eAAA,CAAgB,CAAA;AAAA"}