@warlock.js/ai 4.1.1

package/esm/contracts/content-part.type.d.mts

@@ -0,0 +1,55 @@
+//#region ../../@warlock.js/ai/src/contracts/content-part.type.d.ts
+/**
+ * A single resolved piece of message content.
+ *
+ * `ContentPart` is the **resolved** form of attachable content — by the
+ * time a part reaches a model adapter, every input variant
+ * (path, URL, StorageFile, raw base64) has already been collapsed to a
+ * provider-ready shape. Adapters never read files or fetch URLs; they
+ * map parts directly into their wire format.
+ *
+ * Multipart content is opt-in: `Message.content` accepts a
+ * plain `string` (the common case) or `ContentPart[]` when attachments
+ * are present.
+ *
+ * @example
+ * const userMessage: Message = {
+ *   role: "user",
+ *   content: [
+ *     { type: "text", text: "What's in this picture?" },
+ *     { type: "image", source: { url: "https://example.com/cat.jpg" } },
+ *   ],
+ * };
+ *
+ * @example
+ * // Local file → base64-encoded by the agent before reaching the adapter
+ * const part: ContentPart = {
+ *   type: "image",
+ *   source: { base64: "iVBORw0KGgo...", mediaType: "image/png" },
+ * };
+ */
+type ContentPart = {
+  type: "text";
+  text: string;
+} | {
+  type: "image";
+  source: ImageSource;
+};
+/**
+ * Where an image's bytes live in a resolved `ContentPart`.
+ *
+ * - `{ url }` — remote URL the provider can fetch directly. Used for
+ *   public URLs and StorageFile entries that already expose a URL.
+ * - `{ base64, mediaType }` — inlined base64 bytes with an explicit
+ *   IANA media type (e.g. `"image/png"`). Used for local file paths
+ *   and StorageFile entries with only an absolute path.
+ */
+type ImageSource = {
+  url: string;
+} | {
+  base64: string;
+  mediaType: string;
+};
+//#endregion
+export { ContentPart, ImageSource };
+//# sourceMappingURL=content-part.type.d.mts.map

package/esm/contracts/content-part.type.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"content-part.type.d.mts","names":[],"sources":["../../../../../../@warlock.js/ai/src/contracts/content-part.type.ts"],"mappings":";;AA6BA;;;;;;;;;;AAA+F;AAW/F;;;;;;;;AAAuE;;;;;;;;;KAX3D,WAAA;EAAgB,IAAA;EAAc,IAAA;AAAA;EAAmB,IAAA;EAAe,MAAA,EAAQ,WAAW;AAAA;;;;;;;;;;KAWnF,WAAA;EAAgB,GAAA;AAAA;EAAkB,MAAA;EAAgB,SAAA;AAAA"}

package/esm/contracts/conversation-message.type.d.mts

@@ -0,0 +1,51 @@
+import { ContentPart } from "./content-part.type.mjs";
+import { ModelToolCallRequest } from "./model-tool-call-request.type.mjs";
+
+//#region ../../@warlock.js/ai/src/contracts/conversation-message.type.d.ts
+/**
+ * A single message in a conversation history.
+ *
+ * The `tool` role is used to return a tool's output to the model on the next trip.
+ * When the role is `assistant` and the model requested tool calls, `toolCalls`
+ * is populated so providers can reconstruct the original tool_calls message.
+ *
+ * `content` is `string` for plain text (the common case) or `ContentPart[]`
+ * when the message carries attachments (vision input, files, etc.). Adapters
+ * are expected to handle both shapes.
+ *
+ * @example
+ * const messages: Message[] = [
+ *   { role: "user", content: "What's the weather in Cairo?" },
+ *   { role: "assistant", content: "", toolCalls: [{ id: "call_1", name: "getWeather", input: { city: "Cairo" } }] },
+ *   { role: "tool", toolCallId: "call_1", content: '{"temp":82}' },
+ *   { role: "assistant", content: "It's 82°F in Cairo." },
+ * ];
+ *
+ * @example
+ * // Multipart user message with an image
+ * const visionMessage: Message = {
+ *   role: "user",
+ *   content: [
+ *     { type: "text", text: "Describe this picture" },
+ *     { type: "image", source: { url: "https://example.com/cat.jpg" } },
+ *   ],
+ * };
+ */
+type Message<User = Record<string, unknown>> = {
+  /** Message id */id?: string; /** Who sent this message */
+  role: "user" | "assistant" | "system" | "tool";
+  /**
+   * Message content. A plain string for text-only messages, or a
+   * `ContentPart[]` when the message includes attachments. Tool-result
+   * messages always use the string form (stringified JSON).
+   */
+  content: string | ContentPart[]; /** Provider-generated id — required when role is "tool", links to the assistant's tool_calls */
+  toolCallId?: string; /** Tool calls requested by the assistant — present when role is "assistant" and the LLM triggered tools */
+  toolCalls?: ModelToolCallRequest[]; /** When this message was created */
+  timestamp?: Date; /** Arbitrary metadata for application-level use */
+  metadata?: Record<string, unknown>; /** User info */
+  user?: User;
+};
+//#endregion
+export { Message };
+//# sourceMappingURL=conversation-message.type.d.mts.map

package/esm/contracts/conversation-message.type.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conversation-message.type.d.mts","names":[],"sources":["../../../../../../@warlock.js/ai/src/contracts/conversation-message.type.ts"],"mappings":";;;;;;AAgCA;;;;;;;;;;;;;;;;;;;;;;;;;;;KAAY,OAAA,QAAe,MAAA;mBAEzB,EAAA;EAEA,IAAA;;;;;;EAMA,OAAA,WAAkB,WAAA;EAElB,UAAA;EAEA,SAAA,GAAY,oBAAA;EAEZ,SAAA,GAAY,IAAA;EAEZ,QAAA,GAAW,MAAA;EAEX,IAAA,GAAO,IAAA;AAAA"}

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

@@ -0,0 +1,69 @@
+//#region ../../@warlock.js/ai/src/contracts/embedder.contract.d.ts
+/** Token usage returned from an embedding request. */
+type EmbeddingUsage = {
+  promptTokens: number;
+  totalTokens: number;
+};
+/** Result of embedding a single string input. */
+type EmbeddingResult = {
+  vector: number[];
+  dimensions: number;
+  usage: EmbeddingUsage;
+};
+/** Result of embedding a batch of string inputs. */
+type EmbeddingBatchResult = {
+  vectors: number[][];
+  dimensions: number;
+  usage: EmbeddingUsage;
+};
+/**
+ * Configuration passed to `SDKAdapterContract.embedder()`.
+ *
+ * `dimensions` is an optional override supported by models like
+ * `text-embedding-3-*` that allow output truncation. When omitted,
+ * the adapter resolves `dimensions` lazily from the first response.
+ */
+type EmbedderConfig = {
+  name: string;
+  dimensions?: number;
+  [key: string]: unknown;
+};
+/**
+ * Provider-neutral contract for an embedding model.
+ *
+ * Single-input and batch are split into separate methods (`embed` vs
+ * `embedMany`) rather than one overloaded call — they have different
+ * cost profiles, different per-request limits, and different failure
+ * modes. Splitting keeps each method's JSDoc narrow and avoids the
+ * overload-narrowing trap when callers hold a `string | string[]`.
+ *
+ * @example
+ * const embedder = openai.embedder({ name: "text-embedding-3-small" });
+ * const { vector, dimensions } = await embedder.embed("Hello world");
+ * const { vectors } = await embedder.embedMany(["doc 1", "doc 2"]);
+ */
+interface EmbedderContract {
+  readonly name: string;
+  readonly provider: string;
+  /**
+   * Resolved output dimension count. Starts at `0` when no config
+   * override is given, then is set to the response's vector length on
+   * the first successful `embed()` / `embedMany()` call and cached.
+   *
+   * Not declared `readonly` because implementations populate it
+   * lazily. Treat the value as a post-first-call snapshot.
+   */
+  dimensions: number;
+  /** Embed a single string into a vector. */
+  embed(input: string): Promise<EmbeddingResult>;
+  /**
+   * Embed a batch of strings in a single provider call. The whole
+   * batch is one request, so total input tokens must fit under the
+   * provider's per-request cap. Result `vectors` are returned in the
+   * same order as `inputs`.
+   */
+  embedMany(inputs: string[]): Promise<EmbeddingBatchResult>;
+}
+//#endregion
+export { EmbedderConfig, EmbedderContract, EmbeddingBatchResult, EmbeddingResult, EmbeddingUsage };
+//# sourceMappingURL=embedder.contract.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"embedder.contract.d.mts","names":[],"sources":["../../../../../../@warlock.js/ai/src/contracts/embedder.contract.ts"],"mappings":";;KACY,cAAA;EACV,YAAA;EACA,WAAW;AAAA;AAAA;AAAA,KAID,eAAA;EACV,MAAA;EACA,UAAA;EACA,KAAA,EAAO,cAAc;AAAA;;KAIX,oBAAA;EACV,OAAA;EACA,UAAA;EACA,KAAA,EAAO,cAAc;AAAA;;;;;;;;KAUX,cAAA;EACV,IAAA;EACA,UAAA;EAAA,CACC,GAAA;AAAA;;;;;;AAAW;AAiBd;;;;;;;;UAAiB,gBAAA;EAAA,SACN,IAAA;EAAA,SACA,QAAA;EAST;;;;;;;;EAAA,UAAA;EAWyD;EARzD,KAAA,CAAM,KAAA,WAAgB,OAAA,CAAQ,eAAA;;;;;;;EAQ9B,SAAA,CAAU,MAAA,aAAmB,OAAA,CAAQ,oBAAA;AAAA"}

package/esm/contracts/end.type.d.mts

@@ -0,0 +1,53 @@
+//#region ../../@warlock.js/ai/src/contracts/end.type.d.ts
+/**
+ * Framework-global termination sentinel. Emitted by any primitive
+ * whose control flow is routed through JSON-serializable strings —
+ * supervisor (router agent's `next`, deterministic `route` callback),
+ * future planner (plan steps), future orchestrator (session
+ * directive), any future primitive that needs to say "stop" across a
+ * wire that can't carry `null`.
+ *
+ * **Why one shared literal.** Consumers learn one word. Cross-
+ * primitive pipes — a planner feeding a supervisor, a supervisor
+ * nested as a tool inside an orchestrator — can pass the sentinel
+ * through without translation.
+ *
+ * **Why this specific string.** Brand-prefixed (`__warlock:`) so it
+ * can't collide with a realistic user-chosen intent / step / route
+ * key (`"end"`, `"done"`, `"stop"` are all valid user keys).
+ * Underscore-surrounded so it stands out in logs and snapshots.
+ * JSON-safe so a router agent emits it verbatim.
+ *
+ * **Not used by every primitive.** Workflow's `nextStep` returns
+ * `null` to end — a callback-level mechanism that predates this
+ * sentinel. Workflows keep `null`; the sentinel is for primitives
+ * whose "end" must survive a JSON boundary.
+ *
+ * @example
+ * import { END } from "@warlock.js/ai";
+ *
+ * // Supervisor route callback
+ * ai.supervisor({
+ *   intents: { writer, critic },
+ *   route: (ctx) => (ctx.iteration >= 5 ? END : "writer"),
+ * });
+ *
+ * // Router agent output schema
+ * const router = ai.agent({
+ *   model,
+ *   output: z.object({
+ *     next: z.union([z.string(), z.array(z.string()), z.literal(END)]),
+ *   }),
+ * });
+ */
+declare const END: "__warlock:end__";
+/**
+ * Value type of `END`. Exposed so consumers building Zod / Standard
+ * Schema output schemas can write `z.literal(END)` without
+ * hard-coding the string, and so generic helpers that accept "the
+ * end sentinel" can type-narrow correctly.
+ */
+type EndSentinel = typeof END;
+//#endregion
+export { END, EndSentinel };
+//# sourceMappingURL=end.type.d.mts.map

package/esm/contracts/end.type.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"end.type.d.mts","names":[],"sources":["../../../../../../@warlock.js/ai/src/contracts/end.type.ts"],"mappings":";;AAyCA;;;;AAA6C;AAQ7C;;;;AAAoC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cARvB,GAAA;;;;;;;KAQD,WAAA,UAAqB,GAAG"}

package/esm/contracts/end.type.mjs

@@ -0,0 +1,47 @@
+//#region ../../@warlock.js/ai/src/contracts/end.type.ts
+/**
+* Framework-global termination sentinel. Emitted by any primitive
+* whose control flow is routed through JSON-serializable strings —
+* supervisor (router agent's `next`, deterministic `route` callback),
+* future planner (plan steps), future orchestrator (session
+* directive), any future primitive that needs to say "stop" across a
+* wire that can't carry `null`.
+*
+* **Why one shared literal.** Consumers learn one word. Cross-
+* primitive pipes — a planner feeding a supervisor, a supervisor
+* nested as a tool inside an orchestrator — can pass the sentinel
+* through without translation.
+*
+* **Why this specific string.** Brand-prefixed (`__warlock:`) so it
+* can't collide with a realistic user-chosen intent / step / route
+* key (`"end"`, `"done"`, `"stop"` are all valid user keys).
+* Underscore-surrounded so it stands out in logs and snapshots.
+* JSON-safe so a router agent emits it verbatim.
+*
+* **Not used by every primitive.** Workflow's `nextStep` returns
+* `null` to end — a callback-level mechanism that predates this
+* sentinel. Workflows keep `null`; the sentinel is for primitives
+* whose "end" must survive a JSON boundary.
+*
+* @example
+* import { END } from "@warlock.js/ai";
+*
+* // Supervisor route callback
+* ai.supervisor({
+*   intents: { writer, critic },
+*   route: (ctx) => (ctx.iteration >= 5 ? END : "writer"),
+* });
+*
+* // Router agent output schema
+* const router = ai.agent({
+*   model,
+*   output: z.object({
+*     next: z.union([z.string(), z.array(z.string()), z.literal(END)]),
+*   }),
+* });
+*/
+const END = "__warlock:end__";
+
+//#endregion
+export { END };
+//# sourceMappingURL=end.type.mjs.map

package/esm/contracts/end.type.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"end.type.mjs","names":[],"sources":["../../../../../../@warlock.js/ai/src/contracts/end.type.ts"],"sourcesContent":["/**\n * Framework-global termination sentinel. Emitted by any primitive\n * whose control flow is routed through JSON-serializable strings —\n * supervisor (router agent's `next`, deterministic `route` callback),\n * future planner (plan steps), future orchestrator (session\n * directive), any future primitive that needs to say \"stop\" across a\n * wire that can't carry `null`.\n *\n * **Why one shared literal.** Consumers learn one word. Cross-\n * primitive pipes — a planner feeding a supervisor, a supervisor\n * nested as a tool inside an orchestrator — can pass the sentinel\n * through without translation.\n *\n * **Why this specific string.** Brand-prefixed (`__warlock:`) so it\n * can't collide with a realistic user-chosen intent / step / route\n * key (`\"end\"`, `\"done\"`, `\"stop\"` are all valid user keys).\n * Underscore-surrounded so it stands out in logs and snapshots.\n * JSON-safe so a router agent emits it verbatim.\n *\n * **Not used by every primitive.** Workflow's `nextStep` returns\n * `null` to end — a callback-level mechanism that predates this\n * sentinel. Workflows keep `null`; the sentinel is for primitives\n * whose \"end\" must survive a JSON boundary.\n *\n * @example\n * import { END } from \"@warlock.js/ai\";\n *\n * // Supervisor route callback\n * ai.supervisor({\n *   intents: { writer, critic },\n *   route: (ctx) => (ctx.iteration >= 5 ? END : \"writer\"),\n * });\n *\n * // Router agent output schema\n * const router = ai.agent({\n *   model,\n *   output: z.object({\n *     next: z.union([z.string(), z.array(z.string()), z.literal(END)]),\n *   }),\n * });\n */\nexport const END = \"__warlock:end__\" as const;\n\n/**\n * Value type of `END`. Exposed so consumers building Zod / Standard\n * Schema output schemas can write `z.literal(END)` without\n * hard-coding the string, and so generic helpers that accept \"the\n * end sentinel\" can type-narrow correctly.\n */\nexport type EndSentinel = typeof END;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyCA,MAAa,MAAM"}

package/esm/contracts/events/agent-events.type.d.mts

@@ -0,0 +1,71 @@
+import { AIError } from "../../errors/ai-error.mjs";
+import { ToolCall } from "../result/tool-call.type.mjs";
+import { LLMTrip } from "../result/llm-trip.type.mjs";
+import { AgentResult } from "../result/agent-result.type.mjs";
+
+//#region ../../@warlock.js/ai/src/contracts/events/agent-events.type.d.ts
+/**
+ * Lightweight tool metadata surfaced on tool-lifecycle events. A
+ * deliberately thin slice of `ToolConfig` — name and description
+ * for identity, plus the resolved present-progressive `action`
+ * string for streaming UX. Wrapped tools may carry heavy state
+ * (validated schemas, captured closures, large `meta` blocks); we
+ * keep events serializable and cheap by omitting all of that.
+ */
+type ToolEventMeta = {
+  /** Tool name as exposed to the LLM. */name: string; /** Tool description (the same string the LLM sees). */
+  description: string;
+  /**
+   * Resolved status string for UI display. The framework resolves
+   * `ToolConfig.action` (string or `(input) => string`) into a
+   * plain string at emit time so consumers don't have to.
+   * `undefined` when the tool didn't declare an `action`.
+   */
+  action?: string;
+};
+/** Agent is about to begin execution */
+type AgentStartingPayload = {
+  input: string;
+};
+/** A new LLM trip is beginning */
+type AgentTripStartedPayload = {
+  tripIndex: number;
+  input: string;
+};
+/** Token delta received during streaming */
+type AgentStreamingPayload = {
+  delta: string;
+  tripIndex: number;
+};
+/** LLM has requested a tool call */
+type AgentToolCallingPayload = {
+  tool: ToolEventMeta;
+  input: unknown;
+  tripIndex: number;
+};
+/** Tool call completed successfully */
+type AgentToolCalledPayload = ToolCall & {
+  tool: ToolEventMeta;
+};
+/** Tool call failed with an error */
+type AgentToolCallingFailedPayload = {
+  tool: ToolEventMeta;
+  input: unknown;
+  error: AIError;
+  tripIndex: number;
+};
+/** An LLM trip completed */
+type AgentTripCompletedPayload = {
+  trip: LLMTrip;
+};
+/** Agent execution completed successfully */
+type AgentCompletedPayload<TOutput = unknown> = {
+  result: AgentResult<TOutput>;
+};
+/** Agent execution failed */
+type AgentErrorPayload = {
+  error: AIError;
+};
+//#endregion
+export { AgentCompletedPayload, AgentErrorPayload, AgentStartingPayload, AgentStreamingPayload, AgentToolCalledPayload, AgentToolCallingFailedPayload, AgentToolCallingPayload, AgentTripCompletedPayload, AgentTripStartedPayload, ToolEventMeta };
+//# sourceMappingURL=agent-events.type.d.mts.map

package/esm/contracts/events/agent-events.type.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-events.type.d.mts","names":[],"sources":["../../../../../../../@warlock.js/ai/src/contracts/events/agent-events.type.ts"],"mappings":";;;;;;;;AAaA;;;;;;KAAY,aAAA;EAWJ,uCATN,IAAA,UAaU;EAXV,WAAA;;;AAWwC;AAG1C;;;EAPE,MAAA;AAAA;AAUF;AAAA,KANY,oBAAA;EAAyB,KAAK;AAAA;AAMoB;AAAA,KAHlD,uBAAA;EAA4B,SAAA;EAAmB,KAAK;AAAA;;KAGpD,qBAAA;EAA0B,KAAA;EAAe,SAAS;AAAA;AAMnD;AAAA,KAHC,uBAAA;EACV,IAAA,EAAM,aAAa;EACnB,KAAA;EACA,SAAA;AAAA;;KAIU,sBAAA,GAAyB,QAAA;EAAa,IAAA,EAAM,aAAa;AAAA;AAGrE;AAAA,KAAY,6BAAA;EACV,IAAA,EAAM,aAAA;EACN,KAAA;EACA,KAAA,EAAO,OAAO;EACd,SAAA;AAAA;;KAIU,yBAAA;EAA8B,IAAA,EAAM,OAAO;AAAA;AAJ5C;AAAA,KAOC,qBAAA;EACV,MAAA,EAAQ,WAAW,CAAC,OAAA;AAAA;;KAIV,iBAAA;EAAsB,KAAA,EAAO,OAAO;AAAA"}

package/esm/contracts/events/complete-event.type.d.mts

@@ -0,0 +1,33 @@
+import { AgentResult } from "../result/agent-result.type.mjs";
+
+//#region ../../@warlock.js/ai/src/contracts/events/complete-event.type.d.ts
+/**
+ * Execution-completion payload for the `onComplete` agent hook (T1
+ * of the 2026-05-08 ai-usage/runs/state/cart plan).
+ *
+ * Fired once at the end of every `agent.execute()` / `agent.stream()`
+ * call — regardless of outcome. Audit-log code subscribes here to
+ * write one `ai_runs` row per execution with the full report.
+ *
+ * Distinct from the existing `agent.completed` event: this hook
+ * receives a flat payload with the `runId` pre-extracted and the
+ * end-to-end duration pre-computed, matching the shape the cost-ledger
+ * / audit-log infrastructure consumes. Existing `agent.completed`
+ * subscribers are unaffected — both fire.
+ *
+ * Hook handlers may be sync or async. Errors thrown inside the hook
+ * are swallowed so consumer bugs cannot crash the agent loop or
+ * interfere with the result returned to the caller.
+ *
+ * `result.error` is non-null when the run failed — consumers should
+ * check it to differentiate completed-vs-failed-vs-cancelled runs
+ * (the `result.report.status` field carries the enum).
+ */
+type CompleteEvent<TOutput = unknown> = {
+  /** Final result. May carry `error` for failed/cancelled runs. */result: AgentResult<TOutput>; /** Run-scoped identifier (matches `result.report.runId`). */
+  runId: string; /** End-to-end wall-clock duration in milliseconds. */
+  durationMs: number;
+};
+//#endregion
+export { CompleteEvent };
+//# sourceMappingURL=complete-event.type.d.mts.map

package/esm/contracts/events/complete-event.type.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"complete-event.type.d.mts","names":[],"sources":["../../../../../../../@warlock.js/ai/src/contracts/events/complete-event.type.ts"],"mappings":";;;;;AAwBA;;;;;;;;;;;AAMY;;;;;;;;;KANA,aAAA;mEAEV,MAAA,EAAQ,WAAW,CAAC,OAAA;EAEpB,KAAA;EAEA,UAAA;AAAA"}

package/esm/contracts/events/event-identity.type.d.mts

@@ -0,0 +1,30 @@
+//#region ../../@warlock.js/ai/src/contracts/events/event-identity.type.d.ts
+/**
+ * Run-scoped identity stamped onto every lifecycle event payload
+ * (agent, workflow, supervisor) and every stream event.
+ *
+ * Every emitted event carries this so consumers correlating events to
+ * a run — cost ledgers, trip archives, trace UIs — never need to
+ * smuggle the id through an out-of-band closure.
+ *
+ * - `runId` — id of the run that emitted this event.
+ * - `rootRunId` — id of the outermost run this one belongs to. Equal
+ *   to `runId` for a standalone run; for a run nested under a
+ *   composite (`asTool`) it points at the top-level run so a flat
+ *   query can reconstruct the whole tree. (Nested propagation lands
+ *   in a follow-up; until then `rootRunId === runId` always.)
+ */
+type EventIdentity = {
+  runId: string;
+  rootRunId: string;
+};
+/**
+ * The payload shape an emitter call site supplies — everything the
+ * event carries EXCEPT the run identity, which the central `emit`
+ * chokepoint injects. Keeps call sites from hand-threading `runId`
+ * on every emission.
+ */
+type WithoutIdentity<T> = Omit<T, keyof EventIdentity>;
+//#endregion
+export { EventIdentity, WithoutIdentity };
+//# sourceMappingURL=event-identity.type.d.mts.map

package/esm/contracts/events/event-identity.type.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-identity.type.d.mts","names":[],"sources":["../../../../../../../@warlock.js/ai/src/contracts/events/event-identity.type.ts"],"mappings":";;AAeA;;;;AAAsD;AAQtD;;;;;;;;;KARY,aAAA;EAAkB,KAAA;EAAe,SAAS;AAAA;AAQM;;;;;;AAAA,KAAhD,eAAA,MAAqB,IAAA,CAAK,CAAA,QAAS,aAAA"}

package/esm/contracts/events/event-map.type.d.mts

@@ -0,0 +1,80 @@
+import { AgentCompletedPayload, AgentErrorPayload, AgentStartingPayload, AgentStreamingPayload, AgentToolCalledPayload, AgentToolCallingFailedPayload, AgentToolCallingPayload, AgentTripCompletedPayload, AgentTripStartedPayload } from "./agent-events.type.mjs";
+import { EventIdentity } from "./event-identity.type.mjs";
+import { SupervisorAckCompletedPayload, SupervisorAckStreamingPayload, SupervisorAgentCompletedPayload, SupervisorAgentFailedPayload, SupervisorAgentStartingPayload, SupervisorAgentStreamingPayload, SupervisorCancelledPayload, SupervisorClassifierCompletedPayload, SupervisorClassifierFailedPayload, SupervisorClassifierStartingPayload, SupervisorClassifierStreamingPayload, SupervisorCompletedPayload, SupervisorErrorPayload, SupervisorEvaluateVerdictPayload, SupervisorIterationCompletedPayload, SupervisorIterationStartingPayload, SupervisorRouterDecidedPayload, SupervisorRouterDecidingPayload, SupervisorStartingPayload } from "./supervisor-events.type.mjs";
+import { WorkflowCancelledPayload, WorkflowCompletedPayload, WorkflowErrorPayload, WorkflowLoopWarningPayload, WorkflowStartingPayload, WorkflowStepCompletedPayload, WorkflowStepFailedPayload, WorkflowStepRetryingPayload, WorkflowStepSkippedPayload, WorkflowStepStartingPayload, WorkflowStepStreamingPayload } from "./workflow-events.type.mjs";
+
+//#region ../../@warlock.js/ai/src/contracts/events/event-map.type.d.ts
+/**
+ * Apply run identity to every value of an event map. The central
+ * `emit` chokepoint of each primitive injects `runId` / `rootRunId`,
+ * so subscribers always receive them while call sites stay
+ * identity-free (see `WithoutIdentity`).
+ */
+type WithIdentity<TMap> = { [K in keyof TMap]: TMap[K] & EventIdentity };
+/**
+ * Event map for agent execution. Keys use dot-notation so every event
+ * name is unambiguous across primitives (agent vs workflow vs supervisor)
+ * and so consumers can group or filter by prefix (`agent.*`, `agent.tool.*`).
+ *
+ * Every payload carries `EventIdentity` (`runId` / `rootRunId`),
+ * injected centrally by the agent's `emit` so consumers can correlate
+ * any event back to its run without an out-of-band closure.
+ */
+type AgentEventMap = WithIdentity<{
+  "agent.starting": AgentStartingPayload;
+  "agent.trip.started": AgentTripStartedPayload;
+  "agent.trip.streaming": AgentStreamingPayload;
+  "agent.trip.completed": AgentTripCompletedPayload;
+  "agent.tool.calling": AgentToolCallingPayload;
+  "agent.tool.called": AgentToolCalledPayload;
+  "agent.tool.failed": AgentToolCallingFailedPayload;
+  "agent.completed": AgentCompletedPayload;
+  "agent.error": AgentErrorPayload;
+}>;
+/** Event map for workflow execution. Every payload carries `EventIdentity`. */
+type WorkflowEventMap = WithIdentity<{
+  "workflow.starting": WorkflowStartingPayload;
+  "workflow.step.starting": WorkflowStepStartingPayload;
+  "workflow.step.streaming": WorkflowStepStreamingPayload;
+  "workflow.step.completed": WorkflowStepCompletedPayload;
+  "workflow.step.skipped": WorkflowStepSkippedPayload;
+  "workflow.step.retrying": WorkflowStepRetryingPayload;
+  "workflow.step.failed": WorkflowStepFailedPayload;
+  "workflow.loop.warning": WorkflowLoopWarningPayload;
+  "workflow.cancelled": WorkflowCancelledPayload;
+  "workflow.completed": WorkflowCompletedPayload;
+  "workflow.error": WorkflowErrorPayload;
+}>;
+/**
+ * Event map for supervisor execution. Three-tier subscription —
+ * definition, instance, per-call — fires in that order on every
+ * emission. Router-only events (`supervisor.router.*`) are skipped
+ * entirely in deterministic `route`-callback mode.
+ *
+ * Every payload carries `EventIdentity` (`runId` / `rootRunId`),
+ * injected centrally by `SupervisorExecution.emit`.
+ */
+type SupervisorEventMap = WithIdentity<{
+  "supervisor.starting": SupervisorStartingPayload;
+  "supervisor.iteration.starting": SupervisorIterationStartingPayload;
+  "supervisor.router.deciding": SupervisorRouterDecidingPayload;
+  "supervisor.router.decided": SupervisorRouterDecidedPayload;
+  "supervisor.agent.starting": SupervisorAgentStartingPayload;
+  "supervisor.agent.streaming": SupervisorAgentStreamingPayload;
+  "supervisor.agent.completed": SupervisorAgentCompletedPayload;
+  "supervisor.agent.failed": SupervisorAgentFailedPayload;
+  "supervisor.ack.streaming": SupervisorAckStreamingPayload;
+  "supervisor.ack.completed": SupervisorAckCompletedPayload;
+  "supervisor.classifier.starting": SupervisorClassifierStartingPayload;
+  "supervisor.classifier.streaming": SupervisorClassifierStreamingPayload;
+  "supervisor.classifier.completed": SupervisorClassifierCompletedPayload;
+  "supervisor.classifier.failed": SupervisorClassifierFailedPayload;
+  "supervisor.evaluate.verdict": SupervisorEvaluateVerdictPayload;
+  "supervisor.iteration.completed": SupervisorIterationCompletedPayload;
+  "supervisor.cancelled": SupervisorCancelledPayload;
+  "supervisor.completed": SupervisorCompletedPayload;
+  "supervisor.error": SupervisorErrorPayload;
+}>;
+//#endregion
+export { AgentEventMap, SupervisorEventMap, WorkflowEventMap };
+//# sourceMappingURL=event-map.type.d.mts.map

package/esm/contracts/events/event-map.type.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-map.type.d.mts","names":[],"sources":["../../../../../../../@warlock.js/ai/src/contracts/events/event-map.type.ts"],"mappings":";;;;;;;;AA6CgC;;;;KAQ3B,YAAA,uBAAmC,IAAA,GAAO,IAAA,CAAK,CAAA,IAAK,aAAA;;;;;;;;;;KAW7C,aAAA,GAAgB,YAAA;EAC1B,gBAAA,EAAkB,oBAAA;EAClB,oBAAA,EAAsB,uBAAA;EACtB,sBAAA,EAAwB,qBAAA;EACxB,sBAAA,EAAwB,yBAAA;EACxB,oBAAA,EAAsB,uBAAA;EACtB,mBAAA,EAAqB,sBAAA;EACrB,mBAAA,EAAqB,6BAAA;EACrB,iBAAA,EAAmB,qBAAA;EACnB,aAAA,EAAe,iBAAA;AAAA;;KAIL,gBAAA,GAAmB,YAAA;EAC7B,mBAAA,EAAqB,uBAAA;EACrB,wBAAA,EAA0B,2BAAA;EAC1B,yBAAA,EAA2B,4BAAA;EAC3B,yBAAA,EAA2B,4BAAA;EAC3B,uBAAA,EAAyB,0BAAA;EACzB,wBAAA,EAA0B,2BAAA;EAC1B,sBAAA,EAAwB,yBAAA;EACxB,uBAAA,EAAyB,0BAAA;EACzB,oBAAA,EAAsB,wBAAA;EACtB,oBAAA,EAAsB,wBAAA;EACtB,gBAAA,EAAkB,oBAAA;AAAA;;;;;;;;;;KAYR,kBAAA,GAAqB,YAAA;EAC/B,qBAAA,EAAuB,yBAAA;EACvB,+BAAA,EAAiC,kCAAA;EACjC,4BAAA,EAA8B,+BAAA;EAC9B,2BAAA,EAA6B,8BAAA;EAC7B,2BAAA,EAA6B,8BAAA;EAC7B,4BAAA,EAA8B,+BAAA;EAC9B,4BAAA,EAA8B,+BAAA;EAC9B,yBAAA,EAA2B,4BAAA;EAC3B,0BAAA,EAA4B,6BAAA;EAC5B,0BAAA,EAA4B,6BAAA;EAC5B,gCAAA,EAAkC,mCAAA;EAClC,iCAAA,EAAmC,oCAAA;EACnC,iCAAA,EAAmC,oCAAA;EACnC,8BAAA,EAAgC,iCAAA;EAChC,6BAAA,EAA+B,gCAAA;EAC/B,gCAAA,EAAkC,mCAAA;EAClC,sBAAA,EAAwB,0BAAA;EACxB,sBAAA,EAAwB,0BAAA;EACxB,kBAAA,EAAoB,sBAAA;AAAA"}

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

@@ -0,0 +1,7 @@
+import { AgentCompletedPayload, AgentErrorPayload, AgentStartingPayload, AgentStreamingPayload, AgentToolCalledPayload, AgentToolCallingFailedPayload, AgentToolCallingPayload, AgentTripCompletedPayload, AgentTripStartedPayload, ToolEventMeta } from "./agent-events.type.mjs";
+import { EventIdentity, WithoutIdentity } from "./event-identity.type.mjs";
+import { SupervisorAgentCompletedPayload, SupervisorAgentFailedPayload, SupervisorAgentStartingPayload, SupervisorAgentStreamingPayload, SupervisorCancelledPayload, SupervisorCompletedPayload, SupervisorErrorPayload, SupervisorEvaluateVerdictPayload, SupervisorIterationCompletedPayload, SupervisorIterationStartingPayload, SupervisorRouterDecidedPayload, SupervisorRouterDecidingPayload, SupervisorStartingPayload } from "./supervisor-events.type.mjs";
+import { WorkflowCancelledPayload, WorkflowCompletedPayload, WorkflowErrorPayload, WorkflowLoopWarningPayload, WorkflowStartingPayload, WorkflowStepCompletedPayload, WorkflowStepFailedPayload, WorkflowStepRetryingPayload, WorkflowStepSkippedPayload, WorkflowStepStartingPayload, WorkflowStepStreamingPayload } from "./workflow-events.type.mjs";
+import { AgentEventMap, SupervisorEventMap, WorkflowEventMap } from "./event-map.type.mjs";
+import { CompleteEvent } from "./complete-event.type.mjs";
+import { UsageEvent } from "./usage-event.type.mjs";