@warlock.js/ai 4.4.0 → 4.5.0

package/esm/middleware/utils/extract-user-text.d.mts

@@ -16,12 +16,19 @@ import { Message } from "../../contracts/conversation-message.type.mjs";
  *   wins (correct when the agent has history + a fresh prompt).
  * - Returns a plain string directly when `content` is a string.
  * - Joins `text` parts with `"\n"` when `content` is a multipart
- *   `ContentPart[]`. Non-text parts (images, audio) are skipped —
+ *   `ContentPart[]`. Non-text parts (images, audio, pdf) are skipped —
  *   callers concerned with multimodal content inspect `request`
  *   / attachments separately.
  * - Returns `""` when there is no user message at all (e.g. a trip
  *   composed entirely of tool results).
  *
+ * **Coverage limit (D3).** Because only `text` parts are extracted, any
+ * guardrail / PII detector built on this helper inspects **text only** —
+ * image / PDF / audio attachment content is NOT scanned. A guardrail is
+ * therefore not a multimodal safety control: for non-text inputs add an
+ * attachment-level policy (e.g. an OCR / moderation pass before the call)
+ * rather than relying on input detectors.
+ *
  * @example
  * const prompt = extractUserText(context.messages);
  * if (!prompt) return;

package/esm/middleware/utils/extract-user-text.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"extract-user-text.d.mts","names":[],"sources":["../../../../../../../../@warlock.js/ai/src/middleware/utils/extract-user-text.ts"],"mappings":";;;;;AA4BA;;;;;;;;AAAgE;;;;;;;;;;;;;;;;iBAAhD,eAAA,CAAgB,QAAA,EAAU,aAAa,CAAC,OAAA"}
+{"version":3,"file":"extract-user-text.d.mts","names":[],"sources":["../../../../../../../../@warlock.js/ai/src/middleware/utils/extract-user-text.ts"],"mappings":";;;;;AAmCA;;;;;;;;AAAgE;;;;;;;;;;;;;;;;;;;;;;;iBAAhD,eAAA,CAAgB,QAAA,EAAU,aAAa,CAAC,OAAA"}

package/esm/middleware/utils/extract-user-text.mjs

@@ -14,12 +14,19 @@
 *   wins (correct when the agent has history + a fresh prompt).
 * - Returns a plain string directly when `content` is a string.
 * - Joins `text` parts with `"\n"` when `content` is a multipart
-*   `ContentPart[]`. Non-text parts (images, audio) are skipped —
+*   `ContentPart[]`. Non-text parts (images, audio, pdf) are skipped —
 *   callers concerned with multimodal content inspect `request`
 *   / attachments separately.
 * - Returns `""` when there is no user message at all (e.g. a trip
 *   composed entirely of tool results).
 *
+* **Coverage limit (D3).** Because only `text` parts are extracted, any
+* guardrail / PII detector built on this helper inspects **text only** —
+* image / PDF / audio attachment content is NOT scanned. A guardrail is
+* therefore not a multimodal safety control: for non-text inputs add an
+* attachment-level policy (e.g. an OCR / moderation pass before the call)
+* rather than relying on input detectors.
+*
 * @example
 * const prompt = extractUserText(context.messages);
 * if (!prompt) return;

package/esm/middleware/utils/extract-user-text.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"extract-user-text.mjs","names":[],"sources":["../../../../../../../../@warlock.js/ai/src/middleware/utils/extract-user-text.ts"],"sourcesContent":["import type { Message } from \"../../contracts/conversation-message.type\";\n\n/**\n * Pull the text a content-inspection middleware should care about\n * from the outbound message list.\n *\n * **Role.** Built-ins that inspect \"what the user just said\" — the\n * guardrail on `trip.before`, the semantic cache on `trip.before`,\n * future consumers like PII redactors — all need the same string:\n * the most recent `user`-role message's text content. This helper\n * is the single authority on how that string is resolved.\n *\n * **Behavior.**\n * - Walks `messages` from the end backwards so the LAST user turn\n *   wins (correct when the agent has history + a fresh prompt).\n * - Returns a plain string directly when `content` is a string.\n * - Joins `text` parts with `\"\\n\"` when `content` is a multipart\n *   `ContentPart[]`. Non-text parts (images, audio) are skipped —\n *   callers concerned with multimodal content inspect `request`\n *   / attachments separately.\n * - Returns `\"\"` when there is no user message at all (e.g. a trip\n *   composed entirely of tool results).\n *\n * @example\n * const prompt = extractUserText(context.messages);\n * if (!prompt) return;\n * const verdict = await inputCheck(prompt);\n */\nexport function extractUserText(messages: ReadonlyArray<Message>): string {\n  for (let index = messages.length - 1; index >= 0; index--) {\n    const message = messages[index];\n\n    if (message.role !== \"user\") {\n      continue;\n    }\n\n    if (typeof message.content === \"string\") {\n      return message.content;\n    }\n\n    if (Array.isArray(message.content)) {\n      return message.content\n        .filter((part) => part.type === \"text\")\n        .map((part) => (part as { text: string }).text)\n        .join(\"\\n\");\n    }\n  }\n\n  return \"\";\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BA,SAAgB,gBAAgB,UAA0C;CACxE,KAAK,IAAI,QAAQ,SAAS,SAAS,GAAG,SAAS,GAAG,SAAS;EACzD,MAAM,UAAU,SAAS;EAEzB,IAAI,QAAQ,SAAS,QACnB;EAGF,IAAI,OAAO,QAAQ,YAAY,UAC7B,OAAO,QAAQ;EAGjB,IAAI,MAAM,QAAQ,QAAQ,OAAO,GAC/B,OAAO,QAAQ,QACZ,QAAQ,SAAS,KAAK,SAAS,MAAM,CAAC,CACtC,KAAK,SAAU,KAA0B,IAAI,CAAC,CAC9C,KAAK,IAAI;CAEhB;CAEA,OAAO;AACT"}
+{"version":3,"file":"extract-user-text.mjs","names":[],"sources":["../../../../../../../../@warlock.js/ai/src/middleware/utils/extract-user-text.ts"],"sourcesContent":["import type { Message } from \"../../contracts/conversation-message.type\";\n\n/**\n * Pull the text a content-inspection middleware should care about\n * from the outbound message list.\n *\n * **Role.** Built-ins that inspect \"what the user just said\" — the\n * guardrail on `trip.before`, the semantic cache on `trip.before`,\n * future consumers like PII redactors — all need the same string:\n * the most recent `user`-role message's text content. This helper\n * is the single authority on how that string is resolved.\n *\n * **Behavior.**\n * - Walks `messages` from the end backwards so the LAST user turn\n *   wins (correct when the agent has history + a fresh prompt).\n * - Returns a plain string directly when `content` is a string.\n * - Joins `text` parts with `\"\\n\"` when `content` is a multipart\n *   `ContentPart[]`. Non-text parts (images, audio, pdf) are skipped —\n *   callers concerned with multimodal content inspect `request`\n *   / attachments separately.\n * - Returns `\"\"` when there is no user message at all (e.g. a trip\n *   composed entirely of tool results).\n *\n * **Coverage limit (D3).** Because only `text` parts are extracted, any\n * guardrail / PII detector built on this helper inspects **text only** —\n * image / PDF / audio attachment content is NOT scanned. A guardrail is\n * therefore not a multimodal safety control: for non-text inputs add an\n * attachment-level policy (e.g. an OCR / moderation pass before the call)\n * rather than relying on input detectors.\n *\n * @example\n * const prompt = extractUserText(context.messages);\n * if (!prompt) return;\n * const verdict = await inputCheck(prompt);\n */\nexport function extractUserText(messages: ReadonlyArray<Message>): string {\n  for (let index = messages.length - 1; index >= 0; index--) {\n    const message = messages[index];\n\n    if (message.role !== \"user\") {\n      continue;\n    }\n\n    if (typeof message.content === \"string\") {\n      return message.content;\n    }\n\n    if (Array.isArray(message.content)) {\n      return message.content\n        .filter((part) => part.type === \"text\")\n        .map((part) => (part as { text: string }).text)\n        .join(\"\\n\");\n    }\n  }\n\n  return \"\";\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCA,SAAgB,gBAAgB,UAA0C;CACxE,KAAK,IAAI,QAAQ,SAAS,SAAS,GAAG,SAAS,GAAG,SAAS;EACzD,MAAM,UAAU,SAAS;EAEzB,IAAI,QAAQ,SAAS,QACnB;EAGF,IAAI,OAAO,QAAQ,YAAY,UAC7B,OAAO,QAAQ;EAGjB,IAAI,MAAM,QAAQ,QAAQ,OAAO,GAC/B,OAAO,QAAQ,QACZ,QAAQ,SAAS,KAAK,SAAS,MAAM,CAAC,CACtC,KAAK,SAAU,KAA0B,IAAI,CAAC,CAC9C,KAAK,IAAI;CAEhB;CAEA,OAAO;AACT"}

package/esm/object-stream/index.d.mts

@@ -0,0 +1,2 @@
+import { ObjectStreamEvent, StreamObjectParams, collectStreamObject, streamObject } from "./stream-object.mjs";
+import { parsePartialJson } from "./parse-partial-json.mjs";

package/esm/object-stream/index.mjs

@@ -0,0 +1,4 @@
+import { parsePartialJson } from "./parse-partial-json.mjs";
+import { collectStreamObject, streamObject } from "./stream-object.mjs";
+
+export {  };

package/esm/object-stream/parse-partial-json.d.mts

@@ -0,0 +1,22 @@
+//#region ../@warlock.js/ai/src/object-stream/parse-partial-json.d.ts
+/**
+ * Best-effort parse of a possibly-truncated JSON string into the value it
+ * is "on its way to" becoming. Used by {@link streamObject} to emit a
+ * partial object snapshot from each streamed delta before the full reply
+ * has arrived.
+ *
+ * Returns `undefined` when the prefix can't yet be coerced into a value
+ * (so the caller simply waits for more text). The FINAL parse in
+ * `streamObject` is always strict `JSON.parse` — this tolerant parser only
+ * powers the in-flight snapshots, so a too-clever completion never affects
+ * the authoritative result.
+ *
+ * @example
+ * parsePartialJson('{"name":"Al');      // → { name: "Al" }
+ * parsePartialJson('{"items":[1,2,');   // → { items: [1, 2] }
+ * parsePartialJson('{"a":1,"b"');       // → { a: 1 } (drops the dangling key)
+ */
+declare function parsePartialJson(text: string): unknown | undefined;
+//#endregion
+export { parsePartialJson };
+//# sourceMappingURL=parse-partial-json.d.mts.map

package/esm/object-stream/parse-partial-json.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-partial-json.d.mts","names":[],"sources":["../../../../../../../@warlock.js/ai/src/object-stream/parse-partial-json.ts"],"mappings":";;AAiBA;;;;AAA6C;;;;;;;;;;;;iBAA7B,gBAAA,CAAiB,IAAY"}

package/esm/object-stream/parse-partial-json.mjs

@@ -0,0 +1,78 @@
+//#region ../@warlock.js/ai/src/object-stream/parse-partial-json.ts
+/**
+* Best-effort parse of a possibly-truncated JSON string into the value it
+* is "on its way to" becoming. Used by {@link streamObject} to emit a
+* partial object snapshot from each streamed delta before the full reply
+* has arrived.
+*
+* Returns `undefined` when the prefix can't yet be coerced into a value
+* (so the caller simply waits for more text). The FINAL parse in
+* `streamObject` is always strict `JSON.parse` — this tolerant parser only
+* powers the in-flight snapshots, so a too-clever completion never affects
+* the authoritative result.
+*
+* @example
+* parsePartialJson('{"name":"Al');      // → { name: "Al" }
+* parsePartialJson('{"items":[1,2,');   // → { items: [1, 2] }
+* parsePartialJson('{"a":1,"b"');       // → { a: 1 } (drops the dangling key)
+*/
+function parsePartialJson(text) {
+	const trimmed = text.trim();
+	if (!trimmed) return void 0;
+	const direct = tryParse(trimmed);
+	if (direct.ok) return direct.value;
+	const completed = completePartialJson(trimmed);
+	if (completed === void 0) return void 0;
+	const parsed = tryParse(completed);
+	return parsed.ok ? parsed.value : void 0;
+}
+function tryParse(text) {
+	try {
+		return {
+			ok: true,
+			value: JSON.parse(text)
+		};
+	} catch {
+		return { ok: false };
+	}
+}
+/**
+* Reconstruct a parseable JSON string from a truncated prefix by closing
+* open strings/containers and trimming dangling separators, keys, and
+* partial literals. Tries the most faithful completion first, then falls
+* back to dropping the unfinished tail.
+*/
+function completePartialJson(text) {
+	const stack = [];
+	let inString = false;
+	let escaped = false;
+	for (const ch of text) {
+		if (inString) {
+			if (escaped) escaped = false;
+			else if (ch === "\\") escaped = true;
+			else if (ch === "\"") inString = false;
+			continue;
+		}
+		if (ch === "\"") inString = true;
+		else if (ch === "{" || ch === "[") stack.push(ch);
+		else if (ch === "}" || ch === "]") stack.pop();
+	}
+	const closers = () => stack.map((c) => c === "{" ? "}" : "]").reverse().join("");
+	let core = text;
+	if (inString) core += "\"";
+	core = core.replace(/\s+$/, "");
+	if (core.endsWith(",")) core = core.slice(0, -1);
+	if (core.endsWith(":")) core += "null";
+	const attempts = [core + closers()];
+	if (stack[stack.length - 1] === "{") {
+		const droppedKey = core.replace(/,?\s*"(?:[^"\\]|\\.)*"\s*$/, "");
+		attempts.push(droppedKey.replace(/,\s*$/, "") + closers());
+	}
+	const droppedLiteral = core.replace(/[:,]?\s*[A-Za-z0-9.+\-eE]+$/, (match) => match.trimStart().startsWith(":") ? ":null" : "");
+	attempts.push(droppedLiteral.replace(/,\s*$/, "") + closers());
+	for (const candidate of attempts) if (tryParse(candidate).ok) return candidate;
+}
+
+//#endregion
+export { parsePartialJson };
+//# sourceMappingURL=parse-partial-json.mjs.map

package/esm/object-stream/parse-partial-json.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-partial-json.mjs","names":[],"sources":["../../../../../../../@warlock.js/ai/src/object-stream/parse-partial-json.ts"],"sourcesContent":["/**\n * Best-effort parse of a possibly-truncated JSON string into the value it\n * is \"on its way to\" becoming. Used by {@link streamObject} to emit a\n * partial object snapshot from each streamed delta before the full reply\n * has arrived.\n *\n * Returns `undefined` when the prefix can't yet be coerced into a value\n * (so the caller simply waits for more text). The FINAL parse in\n * `streamObject` is always strict `JSON.parse` — this tolerant parser only\n * powers the in-flight snapshots, so a too-clever completion never affects\n * the authoritative result.\n *\n * @example\n * parsePartialJson('{\"name\":\"Al');      // → { name: \"Al\" }\n * parsePartialJson('{\"items\":[1,2,');   // → { items: [1, 2] }\n * parsePartialJson('{\"a\":1,\"b\"');       // → { a: 1 } (drops the dangling key)\n */\nexport function parsePartialJson(text: string): unknown | undefined {\n  const trimmed = text.trim();\n  if (!trimmed) return undefined;\n\n  // Fast path: already-valid JSON.\n  const direct = tryParse(trimmed);\n  if (direct.ok) return direct.value;\n\n  const completed = completePartialJson(trimmed);\n  if (completed === undefined) return undefined;\n\n  const parsed = tryParse(completed);\n  return parsed.ok ? parsed.value : undefined;\n}\n\nfunction tryParse(text: string): { ok: true; value: unknown } | { ok: false } {\n  try {\n    return { ok: true, value: JSON.parse(text) };\n  } catch {\n    return { ok: false };\n  }\n}\n\n/**\n * Reconstruct a parseable JSON string from a truncated prefix by closing\n * open strings/containers and trimming dangling separators, keys, and\n * partial literals. Tries the most faithful completion first, then falls\n * back to dropping the unfinished tail.\n */\nfunction completePartialJson(text: string): string | undefined {\n  const stack: Array<\"{\" | \"[\"> = [];\n  let inString = false;\n  let escaped = false;\n\n  for (const ch of text) {\n    if (inString) {\n      if (escaped) escaped = false;\n      else if (ch === \"\\\\\") escaped = true;\n      else if (ch === '\"') inString = false;\n      continue;\n    }\n    if (ch === '\"') inString = true;\n    else if (ch === \"{\" || ch === \"[\") stack.push(ch);\n    else if (ch === \"}\" || ch === \"]\") stack.pop();\n  }\n\n  const closers = () =>\n    stack\n      .map(c => (c === \"{\" ? \"}\" : \"]\"))\n      .reverse()\n      .join(\"\");\n\n  // Faithful completion: close an open string, drop a trailing comma,\n  // fill a dangling `key:` with null, then close containers.\n  let core = text;\n  if (inString) core += '\"';\n  core = core.replace(/\\s+$/, \"\");\n  if (core.endsWith(\",\")) core = core.slice(0, -1);\n  if (core.endsWith(\":\")) core += \"null\";\n\n  const attempts: string[] = [core + closers()];\n\n  // Fallback 1: drop a dangling object key (a `\"...\"` with no value yet).\n  if (stack[stack.length - 1] === \"{\") {\n    const droppedKey = core.replace(/,?\\s*\"(?:[^\"\\\\]|\\\\.)*\"\\s*$/, \"\");\n    attempts.push(droppedKey.replace(/,\\s*$/, \"\") + closers());\n  }\n\n  // Fallback 2: drop a partial trailing literal / number (e.g. `tr`, `12.`).\n  const droppedLiteral = core.replace(/[:,]?\\s*[A-Za-z0-9.+\\-eE]+$/, match =>\n    match.trimStart().startsWith(\":\") ? \":null\" : \"\",\n  );\n  attempts.push(droppedLiteral.replace(/,\\s*$/, \"\") + closers());\n\n  for (const candidate of attempts) {\n    if (tryParse(candidate).ok) return candidate;\n  }\n\n  return undefined;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAiBA,SAAgB,iBAAiB,MAAmC;CAClE,MAAM,UAAU,KAAK,KAAK;CAC1B,IAAI,CAAC,SAAS,OAAO;CAGrB,MAAM,SAAS,SAAS,OAAO;CAC/B,IAAI,OAAO,IAAI,OAAO,OAAO;CAE7B,MAAM,YAAY,oBAAoB,OAAO;CAC7C,IAAI,cAAc,QAAW,OAAO;CAEpC,MAAM,SAAS,SAAS,SAAS;CACjC,OAAO,OAAO,KAAK,OAAO,QAAQ;AACpC;AAEA,SAAS,SAAS,MAA4D;CAC5E,IAAI;EACF,OAAO;GAAE,IAAI;GAAM,OAAO,KAAK,MAAM,IAAI;EAAE;CAC7C,QAAQ;EACN,OAAO,EAAE,IAAI,MAAM;CACrB;AACF;;;;;;;AAQA,SAAS,oBAAoB,MAAkC;CAC7D,MAAM,QAA0B,CAAC;CACjC,IAAI,WAAW;CACf,IAAI,UAAU;CAEd,KAAK,MAAM,MAAM,MAAM;EACrB,IAAI,UAAU;GACZ,IAAI,SAAS,UAAU;QAClB,IAAI,OAAO,MAAM,UAAU;QAC3B,IAAI,OAAO,MAAK,WAAW;GAChC;EACF;EACA,IAAI,OAAO,MAAK,WAAW;OACtB,IAAI,OAAO,OAAO,OAAO,KAAK,MAAM,KAAK,EAAE;OAC3C,IAAI,OAAO,OAAO,OAAO,KAAK,MAAM,IAAI;CAC/C;CAEA,MAAM,gBACJ,MACG,KAAI,MAAM,MAAM,MAAM,MAAM,GAAI,CAAC,CACjC,QAAQ,CAAC,CACT,KAAK,EAAE;CAIZ,IAAI,OAAO;CACX,IAAI,UAAU,QAAQ;CACtB,OAAO,KAAK,QAAQ,QAAQ,EAAE;CAC9B,IAAI,KAAK,SAAS,GAAG,GAAG,OAAO,KAAK,MAAM,GAAG,EAAE;CAC/C,IAAI,KAAK,SAAS,GAAG,GAAG,QAAQ;CAEhC,MAAM,WAAqB,CAAC,OAAO,QAAQ,CAAC;CAG5C,IAAI,MAAM,MAAM,SAAS,OAAO,KAAK;EACnC,MAAM,aAAa,KAAK,QAAQ,8BAA8B,EAAE;EAChE,SAAS,KAAK,WAAW,QAAQ,SAAS,EAAE,IAAI,QAAQ,CAAC;CAC3D;CAGA,MAAM,iBAAiB,KAAK,QAAQ,gCAA+B,UACjE,MAAM,UAAU,CAAC,CAAC,WAAW,GAAG,IAAI,UAAU,EAChD;CACA,SAAS,KAAK,eAAe,QAAQ,SAAS,EAAE,IAAI,QAAQ,CAAC;CAE7D,KAAK,MAAM,aAAa,UACtB,IAAI,SAAS,SAAS,CAAC,CAAC,IAAI,OAAO;AAIvC"}

package/esm/object-stream/stream-object.d.mts

@@ -0,0 +1,68 @@
+import { Message } from "../contracts/conversation-message.type.mjs";
+import { AIError } from "../errors/ai-error.mjs";
+import { Usage } from "../contracts/result/usage.type.mjs";
+import { ModelCallOptions, ModelContract } from "../contracts/model.contract.mjs";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+
+//#region ../@warlock.js/ai/src/object-stream/stream-object.d.ts
+/**
+ * One event in a {@link streamObject} run.
+ *
+ * - `text-delta` — the raw token text as it streams (for a "typing" view).
+ * - `partial` — a best-effort snapshot of the object so far, re-parsed
+ *   from the accumulated text on each delta (only emitted when it changed).
+ * - `done` — terminal: the final text is strictly parsed and validated
+ *   against the schema. `valid` + `value` on success; `valid: false` +
+ *   `error` when the output wasn't valid JSON or failed the schema.
+ */
+type ObjectStreamEvent<T> = {
+  type: "text-delta";
+  delta: string;
+} | {
+  type: "partial";
+  value: unknown;
+} | {
+  type: "done";
+  valid: true;
+  value: T;
+  usage: Usage;
+} | {
+  type: "done";
+  valid: false;
+  error: AIError;
+  usage: Usage;
+};
+/** Parameters for {@link streamObject}. */
+type StreamObjectParams<T> = {
+  /** The model to stream from (e.g. `sdk.model({ name })`). */model: ModelContract; /** The prompt messages. */
+  messages: Message[]; /** Standard Schema the final object is validated against. */
+  schema: StandardSchemaV1<T>; /** Extra model call options (e.g. `responseSchema`, `temperature`). */
+  options?: ModelCallOptions;
+};
+/**
+ * Stream a structured object: emit raw token deltas, progressively-parsed
+ * partial-object snapshots, and a final strictly-validated object — the
+ * first-class structured-output streaming primitive (A1). Reuses the
+ * model's existing `stream()` seam; the partial snapshots come from a
+ * tolerant {@link parsePartialJson}, while the terminal `done` event is a
+ * strict `JSON.parse` + schema validation, so an over-eager partial parse
+ * never affects the authoritative result.
+ *
+ * Pair it with a `structuredOutput`-capable model and a `responseSchema`
+ * (via `options`) for the cleanest JSON; otherwise prompt the model to
+ * reply with JSON only.
+ *
+ * @example
+ * for await (const event of streamObject({ model, messages, schema })) {
+ *   if (event.type === "partial") render(event.value);          // live UI
+ *   if (event.type === "done" && event.valid) save(event.value); // final
+ * }
+ */
+declare function streamObject<T>(params: StreamObjectParams<T>): AsyncIterable<ObjectStreamEvent<T>>;
+/** Collect a {@link streamObject} run down to just its terminal event. */
+declare function collectStreamObject<T>(stream: AsyncIterable<ObjectStreamEvent<T>>): Promise<Extract<ObjectStreamEvent<T>, {
+  type: "done";
+}>>;
+//#endregion
+export { ObjectStreamEvent, StreamObjectParams, collectStreamObject, streamObject };
+//# sourceMappingURL=stream-object.d.mts.map

package/esm/object-stream/stream-object.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream-object.d.mts","names":[],"sources":["../../../../../../../@warlock.js/ai/src/object-stream/stream-object.ts"],"mappings":";;;;;;;;;;AAiBA;;;;;;;KAAY,iBAAA;EACN,IAAA;EAAoB,KAAA;AAAA;EACpB,IAAA;EAAiB,KAAA;AAAA;EACjB,IAAA;EAAc,KAAA;EAAa,KAAA,EAAO,CAAA;EAAG,KAAA,EAAO,KAAA;AAAA;EAC5C,IAAA;EAAc,KAAA;EAAc,KAAA,EAAO,OAAA;EAAS,KAAA,EAAO,KAAA;AAAA;;KAG7C,kBAAA;EAHkD,6DAK5D,KAAA,EAAO,aAAA,EAFG;EAIV,QAAA,EAAU,OAAA,IAJkB;EAM5B,MAAA,EAAQ,gBAAA,CAAiB,CAAA,GAFf;EAIV,OAAA,GAAU,gBAAA;AAAA;;;;;;;;;;;;;;;AAAgB;AAsB5B;;;;iBAAuB,YAAA,IACrB,MAAA,EAAQ,kBAAA,CAAmB,CAAA,IAC1B,aAAA,CAAc,iBAAA,CAAkB,CAAA;;iBAoEb,mBAAA,IACpB,MAAA,EAAQ,aAAA,CAAc,iBAAA,CAAkB,CAAA,KACvC,OAAA,CAAQ,OAAA,CAAQ,iBAAA,CAAkB,CAAA;EAAM,IAAA;AAAA"}

package/esm/object-stream/stream-object.mjs

@@ -0,0 +1,104 @@
+import { SchemaValidationError } from "../errors/schema-validation-error.mjs";
+import "../errors/index.mjs";
+import { parsePartialJson } from "./parse-partial-json.mjs";
+
+//#region ../@warlock.js/ai/src/object-stream/stream-object.ts
+/**
+* Stream a structured object: emit raw token deltas, progressively-parsed
+* partial-object snapshots, and a final strictly-validated object — the
+* first-class structured-output streaming primitive (A1). Reuses the
+* model's existing `stream()` seam; the partial snapshots come from a
+* tolerant {@link parsePartialJson}, while the terminal `done` event is a
+* strict `JSON.parse` + schema validation, so an over-eager partial parse
+* never affects the authoritative result.
+*
+* Pair it with a `structuredOutput`-capable model and a `responseSchema`
+* (via `options`) for the cleanest JSON; otherwise prompt the model to
+* reply with JSON only.
+*
+* @example
+* for await (const event of streamObject({ model, messages, schema })) {
+*   if (event.type === "partial") render(event.value);          // live UI
+*   if (event.type === "done" && event.valid) save(event.value); // final
+* }
+*/
+async function* streamObject(params) {
+	const { model, messages, schema, options } = params;
+	let accumulated = "";
+	let lastPartialKey;
+	let usage = {
+		input: 0,
+		output: 0,
+		total: 0
+	};
+	for await (const chunk of model.stream(messages, options)) if (chunk.type === "delta") {
+		accumulated += chunk.content;
+		yield {
+			type: "text-delta",
+			delta: chunk.content
+		};
+		const partial = parsePartialJson(accumulated);
+		if (partial !== void 0) {
+			const key = safeStringify(partial);
+			if (key !== lastPartialKey) {
+				lastPartialKey = key;
+				yield {
+					type: "partial",
+					value: partial
+				};
+			}
+		}
+	} else if (chunk.type === "done") usage = chunk.usage;
+	yield await finalize(accumulated, schema, usage);
+}
+/** Strict parse + schema validation of the complete streamed text. */
+async function finalize(text, schema, usage) {
+	const cleaned = stripJsonFences(text).trim();
+	let parsed;
+	try {
+		parsed = JSON.parse(cleaned);
+	} catch (cause) {
+		return {
+			type: "done",
+			valid: false,
+			error: new SchemaValidationError("streamObject: the final streamed output was not valid JSON", { cause }),
+			usage
+		};
+	}
+	const result = await schema["~standard"].validate(parsed);
+	if ("issues" in result && result.issues) return {
+		type: "done",
+		valid: false,
+		error: new SchemaValidationError("streamObject: the streamed object failed schema validation", { issues: result.issues }),
+		usage
+	};
+	return {
+		type: "done",
+		valid: true,
+		value: result.value,
+		usage
+	};
+}
+/** Collect a {@link streamObject} run down to just its terminal event. */
+async function collectStreamObject(stream) {
+	let done;
+	for await (const event of stream) if (event.type === "done") done = event;
+	if (!done) throw new SchemaValidationError("streamObject: stream ended without a terminal event");
+	return done;
+}
+/** Strip a leading/trailing ```json fence the model may wrap output in. */
+function stripJsonFences(text) {
+	const fenced = text.match(/```(?:json)?\s*([\s\S]*?)\s*```/i);
+	return fenced ? fenced[1] : text;
+}
+function safeStringify(value) {
+	try {
+		return JSON.stringify(value);
+	} catch {
+		return String(value);
+	}
+}
+
+//#endregion
+export { collectStreamObject, streamObject };
+//# sourceMappingURL=stream-object.mjs.map

package/esm/object-stream/stream-object.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream-object.mjs","names":[],"sources":["../../../../../../../@warlock.js/ai/src/object-stream/stream-object.ts"],"sourcesContent":["import type { StandardSchemaV1 } from \"@standard-schema/spec\";\nimport type { Message } from \"../contracts/conversation-message.type\";\nimport type { ModelCallOptions, ModelContract } from \"../contracts/model.contract\";\nimport type { Usage } from \"../contracts/result/usage.type\";\nimport { AIError, SchemaValidationError } from \"../errors\";\nimport { parsePartialJson } from \"./parse-partial-json\";\n\n/**\n * One event in a {@link streamObject} run.\n *\n * - `text-delta` — the raw token text as it streams (for a \"typing\" view).\n * - `partial` — a best-effort snapshot of the object so far, re-parsed\n *   from the accumulated text on each delta (only emitted when it changed).\n * - `done` — terminal: the final text is strictly parsed and validated\n *   against the schema. `valid` + `value` on success; `valid: false` +\n *   `error` when the output wasn't valid JSON or failed the schema.\n */\nexport type ObjectStreamEvent<T> =\n  | { type: \"text-delta\"; delta: string }\n  | { type: \"partial\"; value: unknown }\n  | { type: \"done\"; valid: true; value: T; usage: Usage }\n  | { type: \"done\"; valid: false; error: AIError; usage: Usage };\n\n/** Parameters for {@link streamObject}. */\nexport type StreamObjectParams<T> = {\n  /** The model to stream from (e.g. `sdk.model({ name })`). */\n  model: ModelContract;\n  /** The prompt messages. */\n  messages: Message[];\n  /** Standard Schema the final object is validated against. */\n  schema: StandardSchemaV1<T>;\n  /** Extra model call options (e.g. `responseSchema`, `temperature`). */\n  options?: ModelCallOptions;\n};\n\n/**\n * Stream a structured object: emit raw token deltas, progressively-parsed\n * partial-object snapshots, and a final strictly-validated object — the\n * first-class structured-output streaming primitive (A1). Reuses the\n * model's existing `stream()` seam; the partial snapshots come from a\n * tolerant {@link parsePartialJson}, while the terminal `done` event is a\n * strict `JSON.parse` + schema validation, so an over-eager partial parse\n * never affects the authoritative result.\n *\n * Pair it with a `structuredOutput`-capable model and a `responseSchema`\n * (via `options`) for the cleanest JSON; otherwise prompt the model to\n * reply with JSON only.\n *\n * @example\n * for await (const event of streamObject({ model, messages, schema })) {\n *   if (event.type === \"partial\") render(event.value);          // live UI\n *   if (event.type === \"done\" && event.valid) save(event.value); // final\n * }\n */\nexport async function* streamObject<T>(\n  params: StreamObjectParams<T>,\n): AsyncIterable<ObjectStreamEvent<T>> {\n  const { model, messages, schema, options } = params;\n\n  let accumulated = \"\";\n  let lastPartialKey: string | undefined;\n  let usage: Usage = { input: 0, output: 0, total: 0 };\n\n  for await (const chunk of model.stream(messages, options)) {\n    if (chunk.type === \"delta\") {\n      accumulated += chunk.content;\n      yield { type: \"text-delta\", delta: chunk.content };\n\n      const partial = parsePartialJson(accumulated);\n      if (partial !== undefined) {\n        const key = safeStringify(partial);\n        if (key !== lastPartialKey) {\n          lastPartialKey = key;\n          yield { type: \"partial\", value: partial };\n        }\n      }\n    } else if (chunk.type === \"done\") {\n      usage = chunk.usage;\n    }\n  }\n\n  yield await finalize(accumulated, schema, usage);\n}\n\n/** Strict parse + schema validation of the complete streamed text. */\nasync function finalize<T>(\n  text: string,\n  schema: StandardSchemaV1<T>,\n  usage: Usage,\n): Promise<ObjectStreamEvent<T>> {\n  const cleaned = stripJsonFences(text).trim();\n\n  let parsed: unknown;\n  try {\n    parsed = JSON.parse(cleaned);\n  } catch (cause) {\n    return {\n      type: \"done\",\n      valid: false,\n      error: new SchemaValidationError(\n        \"streamObject: the final streamed output was not valid JSON\",\n        { cause },\n      ),\n      usage,\n    };\n  }\n\n  const result = await schema[\"~standard\"].validate(parsed);\n  if (\"issues\" in result && result.issues) {\n    return {\n      type: \"done\",\n      valid: false,\n      error: new SchemaValidationError(\n        \"streamObject: the streamed object failed schema validation\",\n        { issues: result.issues },\n      ),\n      usage,\n    };\n  }\n\n  return { type: \"done\", valid: true, value: (result as { value: T }).value, usage };\n}\n\n/** Collect a {@link streamObject} run down to just its terminal event. */\nexport async function collectStreamObject<T>(\n  stream: AsyncIterable<ObjectStreamEvent<T>>,\n): Promise<Extract<ObjectStreamEvent<T>, { type: \"done\" }>> {\n  let done: Extract<ObjectStreamEvent<T>, { type: \"done\" }> | undefined;\n  for await (const event of stream) {\n    if (event.type === \"done\") done = event;\n  }\n  if (!done) {\n    throw new SchemaValidationError(\"streamObject: stream ended without a terminal event\");\n  }\n  return done;\n}\n\n/** Strip a leading/trailing ```json fence the model may wrap output in. */\nfunction stripJsonFences(text: string): string {\n  const fenced = text.match(/```(?:json)?\\s*([\\s\\S]*?)\\s*```/i);\n  return fenced ? fenced[1] : text;\n}\n\nfunction safeStringify(value: unknown): string {\n  try {\n    return JSON.stringify(value);\n  } catch {\n    return String(value);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAsDA,gBAAuB,aACrB,QACqC;CACrC,MAAM,EAAE,OAAO,UAAU,QAAQ,YAAY;CAE7C,IAAI,cAAc;CAClB,IAAI;CACJ,IAAI,QAAe;EAAE,OAAO;EAAG,QAAQ;EAAG,OAAO;CAAE;CAEnD,WAAW,MAAM,SAAS,MAAM,OAAO,UAAU,OAAO,GACtD,IAAI,MAAM,SAAS,SAAS;EAC1B,eAAe,MAAM;EACrB,MAAM;GAAE,MAAM;GAAc,OAAO,MAAM;EAAQ;EAEjD,MAAM,UAAU,iBAAiB,WAAW;EAC5C,IAAI,YAAY,QAAW;GACzB,MAAM,MAAM,cAAc,OAAO;GACjC,IAAI,QAAQ,gBAAgB;IAC1B,iBAAiB;IACjB,MAAM;KAAE,MAAM;KAAW,OAAO;IAAQ;GAC1C;EACF;CACF,OAAO,IAAI,MAAM,SAAS,QACxB,QAAQ,MAAM;CAIlB,MAAM,MAAM,SAAS,aAAa,QAAQ,KAAK;AACjD;;AAGA,eAAe,SACb,MACA,QACA,OAC+B;CAC/B,MAAM,UAAU,gBAAgB,IAAI,CAAC,CAAC,KAAK;CAE3C,IAAI;CACJ,IAAI;EACF,SAAS,KAAK,MAAM,OAAO;CAC7B,SAAS,OAAO;EACd,OAAO;GACL,MAAM;GACN,OAAO;GACP,OAAO,IAAI,sBACT,8DACA,EAAE,MAAM,CACV;GACA;EACF;CACF;CAEA,MAAM,SAAS,MAAM,OAAO,YAAY,CAAC,SAAS,MAAM;CACxD,IAAI,YAAY,UAAU,OAAO,QAC/B,OAAO;EACL,MAAM;EACN,OAAO;EACP,OAAO,IAAI,sBACT,8DACA,EAAE,QAAQ,OAAO,OAAO,CAC1B;EACA;CACF;CAGF,OAAO;EAAE,MAAM;EAAQ,OAAO;EAAM,OAAQ,OAAwB;EAAO;CAAM;AACnF;;AAGA,eAAsB,oBACpB,QAC0D;CAC1D,IAAI;CACJ,WAAW,MAAM,SAAS,QACxB,IAAI,MAAM,SAAS,QAAQ,OAAO;CAEpC,IAAI,CAAC,MACH,MAAM,IAAI,sBAAsB,qDAAqD;CAEvF,OAAO;AACT;;AAGA,SAAS,gBAAgB,MAAsB;CAC7C,MAAM,SAAS,KAAK,MAAM,kCAAkC;CAC5D,OAAO,SAAS,OAAO,KAAK;AAC9B;AAEA,SAAS,cAAc,OAAwB;CAC7C,IAAI;EACF,OAAO,KAAK,UAAU,KAAK;CAC7B,QAAQ;EACN,OAAO,OAAO,KAAK;CACrB;AACF"}

package/esm/observe/index.mjs

@@ -0,0 +1,4 @@
+import { getObservers, isObserveAll, registerObserver, setObserveAll } from "./observer-registry.mjs";
+import { notifyObservers, resolveObservers } from "./resolve-observers.mjs";
+
+export {  };

package/esm/observe/observer-registry.d.mts

@@ -0,0 +1,30 @@
+import { Observer } from "./observer.contract.mjs";
+
+//#region ../@warlock.js/ai/src/observe/observer-registry.d.ts
+/**
+ * Register a global {@link Observer}. Every flow that resolves to
+ * "observed" (via `observeAll` or `observe: true`) routes its completed
+ * report to it. An observability tool registers its collector here once,
+ * when its config is applied.
+ */
+declare function registerObserver(observer: Observer): void;
+/**
+ * The currently registered global observers. Returned as a read-only
+ * snapshot reference — callers must not mutate it; use
+ * {@link registerObserver} to add and {@link clearObservers} (test-only)
+ * to reset.
+ */
+declare function getObservers(): readonly Observer[];
+/**
+ * Set the global "observe every flow by default" flag. An observability
+ * tool flips this on when configured with its own observe-all option.
+ */
+declare function setObserveAll(value: boolean): void;
+/**
+ * Read the global "observe every flow by default" flag. Consulted by the
+ * observe-resolution helper when a flow left `observe` undefined.
+ */
+declare function isObserveAll(): boolean;
+//#endregion
+export { getObservers, isObserveAll, registerObserver, setObserveAll };
+//# sourceMappingURL=observer-registry.d.mts.map

package/esm/observe/observer-registry.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"observer-registry.d.mts","names":[],"sources":["../../../../../../../@warlock.js/ai/src/observe/observer-registry.ts"],"mappings":";;;;;AAwBA;;;;iBAAgB,gBAAA,CAAiB,QAAkB,EAAR,QAAQ;AAUnD;;;;AAAiD;AAQjD;AARA,iBAAgB,YAAA,aAAyB,QAAQ;;;AAQL;AAQ5C;iBARgB,aAAA,CAAc,KAAc;;;AAQhB;;iBAAZ,YAAA"}

package/esm/observe/observer-registry.mjs

@@ -0,0 +1,51 @@
+//#region ../@warlock.js/ai/src/observe/observer-registry.ts
+/**
+* Module-level list of globally registered {@link Observer}s. A flow
+* that resolves to "observed" hands its finished report to every entry
+* here. An observability tool (panoptic, …) registers exactly one
+* collector when its config is applied.
+*/
+const observers = [];
+/**
+* Global "observe every flow by default" flag. When `true`, a flow that
+* did not set its own `observe` option is observed (routed to the
+* globally registered observers). Individual flows opt out with
+* `observe: false`. Default `false` — opt-in observability.
+*/
+let observeAll = false;
+/**
+* Register a global {@link Observer}. Every flow that resolves to
+* "observed" (via `observeAll` or `observe: true`) routes its completed
+* report to it. An observability tool registers its collector here once,
+* when its config is applied.
+*/
+function registerObserver(observer) {
+	observers.push(observer);
+}
+/**
+* The currently registered global observers. Returned as a read-only
+* snapshot reference — callers must not mutate it; use
+* {@link registerObserver} to add and {@link clearObservers} (test-only)
+* to reset.
+*/
+function getObservers() {
+	return observers;
+}
+/**
+* Set the global "observe every flow by default" flag. An observability
+* tool flips this on when configured with its own observe-all option.
+*/
+function setObserveAll(value) {
+	observeAll = value;
+}
+/**
+* Read the global "observe every flow by default" flag. Consulted by the
+* observe-resolution helper when a flow left `observe` undefined.
+*/
+function isObserveAll() {
+	return observeAll;
+}
+
+//#endregion
+export { getObservers, isObserveAll, registerObserver, setObserveAll };
+//# sourceMappingURL=observer-registry.mjs.map

package/esm/observe/observer-registry.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"observer-registry.mjs","names":[],"sources":["../../../../../../../@warlock.js/ai/src/observe/observer-registry.ts"],"sourcesContent":["import type { Observer } from \"./observer.contract\";\n\n/**\n * Module-level list of globally registered {@link Observer}s. A flow\n * that resolves to \"observed\" hands its finished report to every entry\n * here. An observability tool (panoptic, …) registers exactly one\n * collector when its config is applied.\n */\nconst observers: Observer[] = [];\n\n/**\n * Global \"observe every flow by default\" flag. When `true`, a flow that\n * did not set its own `observe` option is observed (routed to the\n * globally registered observers). Individual flows opt out with\n * `observe: false`. Default `false` — opt-in observability.\n */\nlet observeAll = false;\n\n/**\n * Register a global {@link Observer}. Every flow that resolves to\n * \"observed\" (via `observeAll` or `observe: true`) routes its completed\n * report to it. An observability tool registers its collector here once,\n * when its config is applied.\n */\nexport function registerObserver(observer: Observer): void {\n  observers.push(observer);\n}\n\n/**\n * The currently registered global observers. Returned as a read-only\n * snapshot reference — callers must not mutate it; use\n * {@link registerObserver} to add and {@link clearObservers} (test-only)\n * to reset.\n */\nexport function getObservers(): readonly Observer[] {\n  return observers;\n}\n\n/**\n * Set the global \"observe every flow by default\" flag. An observability\n * tool flips this on when configured with its own observe-all option.\n */\nexport function setObserveAll(value: boolean): void {\n  observeAll = value;\n}\n\n/**\n * Read the global \"observe every flow by default\" flag. Consulted by the\n * observe-resolution helper when a flow left `observe` undefined.\n */\nexport function isObserveAll(): boolean {\n  return observeAll;\n}\n\n/**\n * Reset the registry to its initial empty state — clears all registered\n * observers and turns off the observe-all flag. Internal: intended for\n * test isolation so one spec's registrations don't leak into the next.\n * Not part of the public surface.\n */\nexport function clearObservers(): void {\n  observers.length = 0;\n  observeAll = false;\n}\n"],"mappings":";;;;;;;AAQA,MAAM,YAAwB,CAAC;;;;;;;AAQ/B,IAAI,aAAa;;;;;;;AAQjB,SAAgB,iBAAiB,UAA0B;CACzD,UAAU,KAAK,QAAQ;AACzB;;;;;;;AAQA,SAAgB,eAAoC;CAClD,OAAO;AACT;;;;;AAMA,SAAgB,cAAc,OAAsB;CAClD,aAAa;AACf;;;;;AAMA,SAAgB,eAAwB;CACtC,OAAO;AACT"}

package/esm/observe/observer.contract.d.mts

@@ -0,0 +1,40 @@
+import { ExecutionReport } from "../contracts/result/execution-report.type.mjs";
+
+//#region ../@warlock.js/ai/src/observe/observer.contract.d.ts
+/**
+ * Generic, panoptic-agnostic observability seam. A flow that resolves
+ * to "observed" hands its completed {@link ExecutionReport} to every
+ * registered `Observer`. Core depends only on this structural shape and
+ * `ExecutionReport` — it never imports any observability package
+ * (panoptic, OTel, Langfuse, …). An observability tool implements
+ * `Observer` and registers itself via {@link registerObserver}, so
+ * `observe: true` / `observeAll` route reports without coupling core to
+ * the tool. This is the dependency inversion that keeps the two sides
+ * decoupled.
+ *
+ * The object form of a flow's `observe` option is typed as this same
+ * structural `Observer` (NOT a panoptic-specific options type), so a
+ * panoptic flow-local collector — which implements `Observer` — can be
+ * passed directly.
+ *
+ * @example
+ * const collector: Observer = {
+ *   collect(report) {
+ *     // forward the finished report to a store / exporter
+ *   },
+ * };
+ * registerObserver(collector);
+ */
+interface Observer {
+  /**
+   * Receive a completed flow's report. May be sync or async — the flow
+   * awaits it. A throw is **isolated** (never breaks the run) but no
+   * longer **silent**: it is surfaced via `notifyObservers`' `onError`
+   * hook, or warned once per observer, so a broken exporter can't vanish
+   * from production with no signal (C5).
+   */
+  collect(report: ExecutionReport): void | Promise<void>;
+}
+//#endregion
+export { Observer };
+//# sourceMappingURL=observer.contract.d.mts.map

package/esm/observe/observer.contract.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"observer.contract.d.mts","names":[],"sources":["../../../../../../../@warlock.js/ai/src/observe/observer.contract.ts"],"mappings":";;;;;AA0BA;;;;;;;;;AAQkD;;;;;;;;;;;;;UARjC,QAAA;;;;;;;;EAQf,OAAA,CAAQ,MAAA,EAAQ,eAAA,UAAyB,OAAO;AAAA"}

package/esm/observe/resolve-observers.d.mts

@@ -0,0 +1,40 @@
+import { Observer } from "./observer.contract.mjs";
+
+//#region ../@warlock.js/ai/src/observe/resolve-observers.d.ts
+/**
+ * The value a flow's `observe` config option may take. Additive and
+ * gated — when `undefined` (the default), behavior follows the global
+ * observe-all flag, so a flow that never sets `observe` behaves exactly
+ * as before unless an observability tool turned observe-all on.
+ *
+ * - `true`  → route this flow to the globally registered observers,
+ *   even when observe-all is off.
+ * - `false` → opt this flow out entirely, even when observe-all is on.
+ * - an {@link Observer} object → a flow-local collector; only this flow's
+ *   report is routed, and only to it (the global observers are skipped).
+ *   A panoptic flow-local collector implements `Observer`, so it can be
+ *   passed here directly — core stays panoptic-agnostic.
+ * - `undefined` → follow the global observe-all flag.
+ */
+type FlowObserveOption = boolean | Observer;
+/**
+ * Resolve a flow's `observe` option into the concrete list of
+ * {@link Observer}s to notify with that flow's completed report:
+ *
+ * - `false` → `[]` (opted out).
+ * - `true` → the globally registered observers.
+ * - an `Observer` object → just that one (flow-local).
+ * - `undefined` → the globally registered observers when observe-all is
+ *   on AND this is a ROOT run, otherwise `[]`.
+ *
+ * Reads the ambient {@link currentRunFrame} for the observe-all path:
+ * flows call it at completion, so a present frame means the run is nested
+ * inside an orchestration callback and is already attached to its parent's
+ * report tree — self-routing it again would double-count it as a separate
+ * top-level trace (and double its tokens/cost in the aggregate). Explicit
+ * `observe: true` / an `Observer` still route regardless of nesting.
+ */
+declare function resolveObservers(observe: FlowObserveOption | undefined): readonly Observer[];
+//#endregion
+export { FlowObserveOption, resolveObservers };
+//# sourceMappingURL=resolve-observers.d.mts.map

package/esm/observe/resolve-observers.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-observers.d.mts","names":[],"sources":["../../../../../../../@warlock.js/ai/src/observe/resolve-observers.ts"],"mappings":";;;;;AAmBA;;;;AAAkD;AAmBlD;;;;;;;;KAnBY,iBAAA,aAA8B,QAAQ;;;;;;;;;;;;;;;;;;iBAmBlC,gBAAA,CAAiB,OAAA,EAAS,iBAAA,wBAAyC,QAAQ"}