@langchain/langgraph 1.2.8 → 1.3.0

package/dist/stream/transformers/types.d.cts

@@ -0,0 +1,89 @@
+import { ChatModelStreamHandle, Namespace } from "../types.cjs";
+import { StreamChannel } from "../stream-channel.cjs";
+import { AgentStatus, LifecycleData } from "@langchain/protocol";
+
+//#region src/stream/transformers/types.d.ts
+/**
+ * The projection shape merged into a run stream by the messages transformer.
+ * Exposes a `messages` async iterable that yields one message stream handle
+ * per AI message lifecycle observed during the run.
+ */
+interface MessagesTransformerProjection {
+  messages: AsyncIterable<ChatModelStreamHandle>;
+}
+/**
+ * The projection shape merged into a run stream by the values transformer.
+ * Exposes the underlying local {@link StreamChannel} so that `StreamMux` can
+ * resolve the final output value on close.
+ */
+interface ValuesTransformerProjection {
+  _valuesLog: StreamChannel<Record<string, unknown>>;
+}
+/**
+ * Single lifecycle entry surfaced by the in-process
+ * `GraphRunStream.lifecycle` projection. Combines the CDDL
+ * {@link LifecycleData} payload with the namespace it applies to so
+ * consumers can filter or correlate without dipping into raw
+ * `ProtocolEvent`s.
+ */
+interface LifecycleEntry extends LifecycleData {
+  /** Namespace the lifecycle event applies to. */
+  readonly namespace: Namespace;
+  /** Wall-clock timestamp (milliseconds) of the emission. */
+  readonly timestamp: number;
+}
+/**
+ * Configuration knobs for {@link createLifecycleTransformer}.
+ */
+interface LifecycleTransformerOptions {
+  /**
+   * Human-readable name for the root graph. Used as `graph_name` for
+   * the root lifecycle event.
+   *
+   * @defaultValue `"root"`
+   */
+  rootGraphName?: string;
+  /**
+   * Lifecycle status emitted for the root namespace when
+   * {@link LifecycleTransformerOptions.emitRootOnRegister} is `true`.
+   *
+   * @defaultValue `"running"`
+   */
+  initialStatus?: AgentStatus;
+  /**
+   * When `true`, the transformer emits the root `lifecycle.started` (or
+   * `.running`) event synchronously from `onRegister` and emits the
+   * terminal root event from `finalize`/`fail`. Set to `false` when an
+   * outer authority (e.g. `RunProtocolSession`) is responsible for
+   * root lifecycle emission; in that case the transformer still tracks
+   * root status internally for cascade purposes but does not write to
+   * the wire.
+   *
+   * @defaultValue `true`
+   */
+  emitRootOnRegister?: boolean;
+  /**
+   * Resolves a human-readable graph name for a non-root namespace.
+   * The default uses the last segment of the namespace, stripping any
+   * `:suffix` (e.g. `["tools:abc"]` -> `"tools"`).
+   */
+  getGraphName?: (ns: Namespace) => string;
+  /**
+   * Optional async hook consulted by `finalize()` to override the
+   * computed terminal status. Returning a status here wins over the
+   * pending-interrupt heuristic. Useful for carriers (like the API
+   * session) that have authoritative knowledge of thread state.
+   */
+  getTerminalStatusOverride?: () => Promise<AgentStatus | undefined>;
+  /**
+   * Converts an unknown failure value to a string for the
+   * `lifecycle.failed` `error` field.
+   *
+   * @defaultValue a default implementation that handles `Error` and
+   *   primitives.
+   */
+  serializeError?: (err: unknown) => string;
+}
+//#endregion
+export { LifecycleEntry, LifecycleTransformerOptions, MessagesTransformerProjection, ValuesTransformerProjection };
+//# sourceMappingURL=types.d.cts.map

package/dist/stream/transformers/types.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.cts","names":[],"sources":["../../../src/stream/transformers/types.ts"],"mappings":";;;;;;;AAUA;;;UAAiB,6BAAA;EACf,QAAA,EAAU,aAAA,CAAc,qBAAA;AAAA;;;;AAQ1B;;UAAiB,2BAAA;EACf,UAAA,EAAY,aAAA,CAAc,MAAA;AAAA;;;;;AAU5B;;;UAAiB,cAAA,SAAuB,aAAA;EAAA;EAAA,SAE7B,SAAA,EAAW,SAAA;EAAA;EAAA,SAEX,SAAA;AAAA;;AAMX;;UAAiB,2BAAA;EAeC;;;;;;EARhB,aAAA;EAQA;;;;;;EAAA,aAAA,GAAgB,WAAA;EA4BkB;;;;;;;;;;;EAflC,kBAAA;;;;;;EAOA,YAAA,IAAgB,EAAA,EAAI,SAAA;;;;;;;EAQpB,yBAAA,SAAkC,OAAA,CAAQ,WAAA;;;;;;;;EAS1C,cAAA,IAAkB,GAAA;AAAA"}

package/dist/stream/transformers/types.d.ts

@@ -0,0 +1,89 @@
+import { ChatModelStreamHandle, Namespace } from "../types.js";
+import { StreamChannel } from "../stream-channel.js";
+import { AgentStatus, LifecycleData } from "@langchain/protocol";
+
+//#region src/stream/transformers/types.d.ts
+/**
+ * The projection shape merged into a run stream by the messages transformer.
+ * Exposes a `messages` async iterable that yields one message stream handle
+ * per AI message lifecycle observed during the run.
+ */
+interface MessagesTransformerProjection {
+  messages: AsyncIterable<ChatModelStreamHandle>;
+}
+/**
+ * The projection shape merged into a run stream by the values transformer.
+ * Exposes the underlying local {@link StreamChannel} so that `StreamMux` can
+ * resolve the final output value on close.
+ */
+interface ValuesTransformerProjection {
+  _valuesLog: StreamChannel<Record<string, unknown>>;
+}
+/**
+ * Single lifecycle entry surfaced by the in-process
+ * `GraphRunStream.lifecycle` projection. Combines the CDDL
+ * {@link LifecycleData} payload with the namespace it applies to so
+ * consumers can filter or correlate without dipping into raw
+ * `ProtocolEvent`s.
+ */
+interface LifecycleEntry extends LifecycleData {
+  /** Namespace the lifecycle event applies to. */
+  readonly namespace: Namespace;
+  /** Wall-clock timestamp (milliseconds) of the emission. */
+  readonly timestamp: number;
+}
+/**
+ * Configuration knobs for {@link createLifecycleTransformer}.
+ */
+interface LifecycleTransformerOptions {
+  /**
+   * Human-readable name for the root graph. Used as `graph_name` for
+   * the root lifecycle event.
+   *
+   * @defaultValue `"root"`
+   */
+  rootGraphName?: string;
+  /**
+   * Lifecycle status emitted for the root namespace when
+   * {@link LifecycleTransformerOptions.emitRootOnRegister} is `true`.
+   *
+   * @defaultValue `"running"`
+   */
+  initialStatus?: AgentStatus;
+  /**
+   * When `true`, the transformer emits the root `lifecycle.started` (or
+   * `.running`) event synchronously from `onRegister` and emits the
+   * terminal root event from `finalize`/`fail`. Set to `false` when an
+   * outer authority (e.g. `RunProtocolSession`) is responsible for
+   * root lifecycle emission; in that case the transformer still tracks
+   * root status internally for cascade purposes but does not write to
+   * the wire.
+   *
+   * @defaultValue `true`
+   */
+  emitRootOnRegister?: boolean;
+  /**
+   * Resolves a human-readable graph name for a non-root namespace.
+   * The default uses the last segment of the namespace, stripping any
+   * `:suffix` (e.g. `["tools:abc"]` -> `"tools"`).
+   */
+  getGraphName?: (ns: Namespace) => string;
+  /**
+   * Optional async hook consulted by `finalize()` to override the
+   * computed terminal status. Returning a status here wins over the
+   * pending-interrupt heuristic. Useful for carriers (like the API
+   * session) that have authoritative knowledge of thread state.
+   */
+  getTerminalStatusOverride?: () => Promise<AgentStatus | undefined>;
+  /**
+   * Converts an unknown failure value to a string for the
+   * `lifecycle.failed` `error` field.
+   *
+   * @defaultValue a default implementation that handles `Error` and
+   *   primitives.
+   */
+  serializeError?: (err: unknown) => string;
+}
+//#endregion
+export { LifecycleEntry, LifecycleTransformerOptions, MessagesTransformerProjection, ValuesTransformerProjection };
+//# sourceMappingURL=types.d.ts.map

package/dist/stream/transformers/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../../src/stream/transformers/types.ts"],"mappings":";;;;;;;AAUA;;;UAAiB,6BAAA;EACf,QAAA,EAAU,aAAA,CAAc,qBAAA;AAAA;;;;AAQ1B;;UAAiB,2BAAA;EACf,UAAA,EAAY,aAAA,CAAc,MAAA;AAAA;;;;;AAU5B;;;UAAiB,cAAA,SAAuB,aAAA;EAAA;EAAA,SAE7B,SAAA,EAAW,SAAA;EAAA;EAAA,SAEX,SAAA;AAAA;;AAMX;;UAAiB,2BAAA;EAeC;;;;;;EARhB,aAAA;EAQA;;;;;;EAAA,aAAA,GAAgB,WAAA;EA4BkB;;;;;;;;;;;EAflC,kBAAA;;;;;;EAOA,YAAA,IAAgB,EAAA,EAAI,SAAA;;;;;;;EAQpB,yBAAA,SAAkC,OAAA,CAAQ,WAAA;;;;;;;;EAS1C,cAAA,IAAkB,GAAA;AAAA"}

package/dist/stream/transformers/values.cjs

@@ -0,0 +1,39 @@
+const require_stream_channel = require("../stream-channel.cjs");
+const require_mux = require("../mux.cjs");
+//#region src/stream/transformers/values.ts
+/**
+* Creates a {@link StreamTransformer} that captures `values` channel events
+* into a local {@link StreamChannel}. Only events whose namespace exactly
+* matches {@link path} are recorded; events from child or sibling namespaces
+* are ignored.
+*
+* The final snapshot is resolved by {@link StreamMux.close} directly;
+* this transformer only accumulates intermediate values.
+*
+* @param path - Namespace prefix to match against incoming events.
+* @returns A `StreamTransformer` whose projection contains the internal
+*   `_valuesLog` local channel.
+*/
+function createValuesTransformer(path) {
+	const valuesLog = require_stream_channel.StreamChannel.local();
+	return {
+		init: () => ({ _valuesLog: valuesLog }),
+		process(event) {
+			if (event.method !== "values") return true;
+			if (event.params.namespace.length !== path.length) return true;
+			if (!require_mux.hasPrefix(event.params.namespace, path)) return true;
+			valuesLog.push(event.params.data);
+			return true;
+		},
+		finalize() {
+			valuesLog.close();
+		},
+		fail(err) {
+			valuesLog.fail(err);
+		}
+	};
+}
+//#endregion
+exports.createValuesTransformer = createValuesTransformer;
+
+//# sourceMappingURL=values.cjs.map

package/dist/stream/transformers/values.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"values.cjs","names":["StreamChannel","hasPrefix"],"sources":["../../../src/stream/transformers/values.ts"],"sourcesContent":["import { hasPrefix } from \"../mux.js\";\nimport { StreamChannel } from \"../stream-channel.js\";\nimport type { Namespace, ProtocolEvent, StreamTransformer } from \"../types.js\";\nimport type { ValuesTransformerProjection } from \"./types.js\";\n\n/**\n * Creates a {@link StreamTransformer} that captures `values` channel events\n * into a local {@link StreamChannel}. Only events whose namespace exactly\n * matches {@link path} are recorded; events from child or sibling namespaces\n * are ignored.\n *\n * The final snapshot is resolved by {@link StreamMux.close} directly;\n * this transformer only accumulates intermediate values.\n *\n * @param path - Namespace prefix to match against incoming events.\n * @returns A `StreamTransformer` whose projection contains the internal\n *   `_valuesLog` local channel.\n */\nexport function createValuesTransformer(\n  path: Namespace\n): StreamTransformer<ValuesTransformerProjection> {\n  const valuesLog = StreamChannel.local<Record<string, unknown>>();\n\n  return {\n    init: () => ({ _valuesLog: valuesLog }),\n\n    process(event: ProtocolEvent): boolean {\n      if (event.method !== \"values\") return true;\n      if (event.params.namespace.length !== path.length) return true;\n      if (!hasPrefix(event.params.namespace, path)) return true;\n      valuesLog.push(event.params.data as Record<string, unknown>);\n      return true;\n    },\n\n    finalize(): void {\n      valuesLog.close();\n    },\n\n    fail(err: unknown): void {\n      valuesLog.fail(err);\n    },\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAkBA,SAAgB,wBACd,MACgD;CAChD,MAAM,YAAYA,uBAAAA,cAAc,OAAgC;AAEhE,QAAO;EACL,aAAa,EAAE,YAAY,WAAW;EAEtC,QAAQ,OAA+B;AACrC,OAAI,MAAM,WAAW,SAAU,QAAO;AACtC,OAAI,MAAM,OAAO,UAAU,WAAW,KAAK,OAAQ,QAAO;AAC1D,OAAI,CAACC,YAAAA,UAAU,MAAM,OAAO,WAAW,KAAK,CAAE,QAAO;AACrD,aAAU,KAAK,MAAM,OAAO,KAAgC;AAC5D,UAAO;;EAGT,WAAiB;AACf,aAAU,OAAO;;EAGnB,KAAK,KAAoB;AACvB,aAAU,KAAK,IAAI;;EAEtB"}

package/dist/stream/transformers/values.d.cts

@@ -0,0 +1,21 @@
+import { Namespace, StreamTransformer } from "../types.cjs";
+import { ValuesTransformerProjection } from "./types.cjs";
+
+//#region src/stream/transformers/values.d.ts
+/**
+ * Creates a {@link StreamTransformer} that captures `values` channel events
+ * into a local {@link StreamChannel}. Only events whose namespace exactly
+ * matches {@link path} are recorded; events from child or sibling namespaces
+ * are ignored.
+ *
+ * The final snapshot is resolved by {@link StreamMux.close} directly;
+ * this transformer only accumulates intermediate values.
+ *
+ * @param path - Namespace prefix to match against incoming events.
+ * @returns A `StreamTransformer` whose projection contains the internal
+ *   `_valuesLog` local channel.
+ */
+declare function createValuesTransformer(path: Namespace): StreamTransformer<ValuesTransformerProjection>;
+//#endregion
+export { createValuesTransformer };
+//# sourceMappingURL=values.d.cts.map

package/dist/stream/transformers/values.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"values.d.cts","names":[],"sources":["../../../src/stream/transformers/values.ts"],"mappings":";;;;;;AAkBA;;;;;;;;;;;iBAAgB,uBAAA,CACd,IAAA,EAAM,SAAA,GACL,iBAAA,CAAkB,2BAAA"}

package/dist/stream/transformers/values.d.ts

@@ -0,0 +1,21 @@
+import { Namespace, StreamTransformer } from "../types.js";
+import { ValuesTransformerProjection } from "./types.js";
+
+//#region src/stream/transformers/values.d.ts
+/**
+ * Creates a {@link StreamTransformer} that captures `values` channel events
+ * into a local {@link StreamChannel}. Only events whose namespace exactly
+ * matches {@link path} are recorded; events from child or sibling namespaces
+ * are ignored.
+ *
+ * The final snapshot is resolved by {@link StreamMux.close} directly;
+ * this transformer only accumulates intermediate values.
+ *
+ * @param path - Namespace prefix to match against incoming events.
+ * @returns A `StreamTransformer` whose projection contains the internal
+ *   `_valuesLog` local channel.
+ */
+declare function createValuesTransformer(path: Namespace): StreamTransformer<ValuesTransformerProjection>;
+//#endregion
+export { createValuesTransformer };
+//# sourceMappingURL=values.d.ts.map

package/dist/stream/transformers/values.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"values.d.ts","names":[],"sources":["../../../src/stream/transformers/values.ts"],"mappings":";;;;;;AAkBA;;;;;;;;;;;iBAAgB,uBAAA,CACd,IAAA,EAAM,SAAA,GACL,iBAAA,CAAkB,2BAAA"}

package/dist/stream/transformers/values.js

@@ -0,0 +1,39 @@
+import { StreamChannel } from "../stream-channel.js";
+import { hasPrefix } from "../mux.js";
+//#region src/stream/transformers/values.ts
+/**
+* Creates a {@link StreamTransformer} that captures `values` channel events
+* into a local {@link StreamChannel}. Only events whose namespace exactly
+* matches {@link path} are recorded; events from child or sibling namespaces
+* are ignored.
+*
+* The final snapshot is resolved by {@link StreamMux.close} directly;
+* this transformer only accumulates intermediate values.
+*
+* @param path - Namespace prefix to match against incoming events.
+* @returns A `StreamTransformer` whose projection contains the internal
+*   `_valuesLog` local channel.
+*/
+function createValuesTransformer(path) {
+	const valuesLog = StreamChannel.local();
+	return {
+		init: () => ({ _valuesLog: valuesLog }),
+		process(event) {
+			if (event.method !== "values") return true;
+			if (event.params.namespace.length !== path.length) return true;
+			if (!hasPrefix(event.params.namespace, path)) return true;
+			valuesLog.push(event.params.data);
+			return true;
+		},
+		finalize() {
+			valuesLog.close();
+		},
+		fail(err) {
+			valuesLog.fail(err);
+		}
+	};
+}
+//#endregion
+export { createValuesTransformer };
+
+//# sourceMappingURL=values.js.map

package/dist/stream/transformers/values.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"values.js","names":[],"sources":["../../../src/stream/transformers/values.ts"],"sourcesContent":["import { hasPrefix } from \"../mux.js\";\nimport { StreamChannel } from \"../stream-channel.js\";\nimport type { Namespace, ProtocolEvent, StreamTransformer } from \"../types.js\";\nimport type { ValuesTransformerProjection } from \"./types.js\";\n\n/**\n * Creates a {@link StreamTransformer} that captures `values` channel events\n * into a local {@link StreamChannel}. Only events whose namespace exactly\n * matches {@link path} are recorded; events from child or sibling namespaces\n * are ignored.\n *\n * The final snapshot is resolved by {@link StreamMux.close} directly;\n * this transformer only accumulates intermediate values.\n *\n * @param path - Namespace prefix to match against incoming events.\n * @returns A `StreamTransformer` whose projection contains the internal\n *   `_valuesLog` local channel.\n */\nexport function createValuesTransformer(\n  path: Namespace\n): StreamTransformer<ValuesTransformerProjection> {\n  const valuesLog = StreamChannel.local<Record<string, unknown>>();\n\n  return {\n    init: () => ({ _valuesLog: valuesLog }),\n\n    process(event: ProtocolEvent): boolean {\n      if (event.method !== \"values\") return true;\n      if (event.params.namespace.length !== path.length) return true;\n      if (!hasPrefix(event.params.namespace, path)) return true;\n      valuesLog.push(event.params.data as Record<string, unknown>);\n      return true;\n    },\n\n    finalize(): void {\n      valuesLog.close();\n    },\n\n    fail(err: unknown): void {\n      valuesLog.fail(err);\n    },\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAkBA,SAAgB,wBACd,MACgD;CAChD,MAAM,YAAY,cAAc,OAAgC;AAEhE,QAAO;EACL,aAAa,EAAE,YAAY,WAAW;EAEtC,QAAQ,OAA+B;AACrC,OAAI,MAAM,WAAW,SAAU,QAAO;AACtC,OAAI,MAAM,OAAO,UAAU,WAAW,KAAK,OAAQ,QAAO;AAC1D,OAAI,CAAC,UAAU,MAAM,OAAO,WAAW,KAAK,CAAE,QAAO;AACrD,aAAU,KAAK,MAAM,OAAO,KAAgC;AAC5D,UAAO;;EAGT,WAAiB;AACf,aAAU,OAAO;;EAGnB,KAAK,KAAoB;AACvB,aAAU,KAAK,IAAI;;EAEtB"}

package/dist/stream/types.cjs

@@ -0,0 +1,11 @@
+//#region src/stream/types.ts
+/**
+* Type guard that tests whether a transformer is a {@link NativeStreamTransformer}.
+*/
+function isNativeTransformer(t) {
+	return "__native" in t && t.__native === true;
+}
+//#endregion
+exports.isNativeTransformer = isNativeTransformer;
+
+//# sourceMappingURL=types.cjs.map

package/dist/stream/types.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.cjs","names":[],"sources":["../../src/stream/types.ts"],"sourcesContent":["/**\n * Core type definitions for the v2 streaming interface.\n *\n * Channel event data types (`MessagesEventData`, `ToolsEventData`,\n * `UpdatesEventData`, `UsageInfo`, `Checkpoint`, `CheckpointSource`) are\n * re-exported from `@langchain/protocol` — the generated TypeScript\n * bindings for the canonical CDDL schema.  Stream-specific types\n * (`StreamTransformer`, `ChatModelStream`, `ToolCallStream`,\n * `InterruptPayload`) are defined here.\n */\n\nimport type { ChatModelStream as CoreChatModelStream } from \"@langchain/core/language_models/stream\";\nimport type { ChatModelStreamEvent as CoreChatModelStreamEvent } from \"@langchain/core/language_models/event\";\nimport type { StreamMode } from \"../pregel/types.js\";\n\n/**\n * Re-exports from `@langchain/protocol`.\n *\n * These are the canonical wire-format types generated from `protocol.cddl`.\n * They are re-exported with local aliases so that consumers of this module\n * do not need a direct dependency on `@langchain/protocol`.\n */\nexport type {\n  MessagesData as MessagesEventData,\n  ToolsData as ToolsEventData,\n  UpdatesData as UpdatesEventData,\n  UsageInfo,\n  MessageStartData,\n  ContentBlockStartData,\n  ContentBlockDeltaData,\n  ContentBlockFinishData,\n  MessageFinishData,\n  MessageErrorData,\n  ToolStartedData,\n  ToolOutputDeltaData,\n  ToolFinishedData,\n  ToolErrorData,\n  Checkpoint,\n  CheckpointSource,\n  AgentStatus,\n  LifecycleData,\n  LifecycleCause,\n} from \"@langchain/protocol\";\n\n/**\n * Hierarchical path identifying a position in the agent tree.\n *\n * Each element is one segment; longer arrays mean deeper nesting (e.g.\n * subgraph or multi-agent scopes).\n */\nexport type Namespace = string[];\n\n/**\n * Channels that can appear on a protocol event.  Beyond the raw\n * {@link StreamMode} channels emitted by the Pregel stream, the v2\n * protocol layer synthesizes additional channels (e.g. `lifecycle`,\n * `input`) via built-in {@link StreamTransformer}s and exposes\n * user-defined channels created with {@link StreamChannel}.\n */\nexport type ProtocolMethod = StreamMode | \"lifecycle\" | \"input\" | (string & {});\n\n/**\n * Single envelope for a streaming protocol emission: sequence, channel\n * (`method`), and payload (`params`).\n */\nexport interface ProtocolEvent {\n  /** Discriminator; always `\"event\"` for this shape. */\n  readonly type: \"event\";\n\n  /** Monotonic sequence number for ordering and deduplication within a run. */\n  readonly seq: number;\n\n  /**\n   * Logical stream channel.  Built-in channels match {@link StreamMode}\n   * (e.g. `messages`, `updates`); transformer-synthesized channels\n   * include `lifecycle` and `input`; user-defined channels carry their\n   * {@link StreamChannel.channelName}.\n   */\n  readonly method: ProtocolMethod;\n\n  /** Channel-specific payload and routing metadata. */\n  readonly params: {\n    /** Namespace of the node or scope that emitted this event. */\n    readonly namespace: Namespace;\n\n    /** Wall-clock or logical timestamp for the emission (milliseconds). */\n    readonly timestamp: number;\n\n    /**\n     * Graph node id when the engine can attribute the event to a single node;\n     * omitted for run-level or ambiguous emissions.\n     */\n    readonly node?: string;\n\n    /** Opaque channel payload; shape depends on `method`. */\n    readonly data: unknown;\n  };\n}\n\n/**\n * Infers the merged extensions type from a tuple of transformer factory functions.\n *\n * Given `[() => StreamTransformer<{ a: number }>, () => StreamTransformer<{ b: string }>]`,\n * produces `{ a: number } & { b: string }`.\n */\nexport type InferExtensions<\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  T extends ReadonlyArray<() => StreamTransformer<any>>,\n> = T extends readonly []\n  ? Record<string, never>\n  : T extends readonly [\n        () => StreamTransformer<infer P>,\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        ...infer Rest extends ReadonlyArray<() => StreamTransformer<any>>,\n      ]\n    ? P & InferExtensions<Rest>\n    : Record<string, unknown>;\n\n/**\n * Observes {@link ProtocolEvent}s during a graph run and builds typed derived\n * projections (secondary event logs, promises, etc.).\n *\n * Data is surfaced to consumers through **projections** returned from\n * `init()`.  Projections are merged into `GraphRunStream.extensions` for\n * in-process consumers.  Use {@link StreamChannel.local} for local streaming\n * values, {@link StreamChannel.remote} for values that should also be visible\n * to remote clients, or `Promise<T>` for final values.\n *\n * To make projection data available to **remote** clients (SDK consumers\n * over WebSocket / SSE), create a named channel with\n * `StreamChannel.remote(name)`.  The {@link StreamMux} detects named\n * `StreamChannel` instances in the `init()` return and auto-forwards every\n * `push()` as a {@link ProtocolEvent} on the channel's named method.  Remote\n * clients subscribe via `session.subscribe(\"custom:<name>\")`.\n *\n * `finalize` and `fail` are optional.  When a transformer uses\n * `StreamChannel`, the mux auto-closes/fails the channels on run\n * completion — no manual lifecycle management needed.  Implement\n * `finalize`/`fail` only for non-channel teardown (e.g. resolving a\n * `Promise`).\n *\n * @typeParam TProjection - Shape returned by {@link init}, merged into\n *   `GraphRunStream.extensions`.\n */\nexport interface StreamTransformer<TProjection = unknown> {\n  /**\n   * Called once before the run starts.\n   *\n   * @returns Initial projection merged into `GraphRunStream.extensions`.\n   *   Any named {@link StreamChannel} instances in the return value are\n   *   automatically wired to the protocol event stream by the mux. Unnamed\n   *   channels stay in-process-only.\n   */\n  init(): TProjection;\n\n  /**\n   * Optional hook invoked by {@link StreamMux.addTransformer} immediately\n   * after the transformer is attached to the mux. Receives a limited\n   * handle that exposes only {@link StreamEmitter.push} — enough for\n   * the transformer to emit synthesized {@link ProtocolEvent}s on any\n   * namespace it chooses (e.g. a deepagents `SubagentTransformer`\n   * fabricating `lifecycle`/`messages`/`values` events under a\n   * `[\"tools:<tool_call_id>\"]` namespace when a `task` tool starts).\n   *\n   * Transformers that do not synthesize events can omit this hook.\n   *\n   * The {@link StreamEmitter} handle is only safe to call *from within*\n   * {@link StreamTransformer.process}. Emitting from an unrelated async\n   * context (e.g. after `process` has returned, from a `setTimeout`,\n   * etc.) races with the mux's close/fail cycle and may land events in\n   * an already-closed log.\n   */\n  onRegister?(emitter: StreamEmitter): void;\n\n  /**\n   * Called for each {@link ProtocolEvent} before it is appended to the main log.\n   *\n   * @param event - Next protocol envelope for this run.\n   * @returns `false` to drop the original event from the main log (use\n   *   sparingly; prefer keeping events visible and adding derived data\n   *   alongside).\n   */\n  process(event: ProtocolEvent): boolean;\n\n  /**\n   * Called once when the underlying Pregel run completes without throwing.\n   * Optional — only needed for non-channel teardown (e.g. resolving promises).\n   *\n   * May return a `PromiseLike<void>` to defer the main event log close\n   * until the async work (e.g. emitting terminal lifecycle events) has\n   * completed.  The mux awaits all returned promises before closing its\n   * event log.\n   */\n  finalize?(): void | PromiseLike<void>;\n\n  /**\n   * Called once when the run fails; `err` is the rejection or error value.\n   * Optional — only needed for non-channel teardown (e.g. rejecting promises).\n   *\n   * @param err - Failure reason from the engine or user code.\n   */\n  fail?(err: unknown): void;\n}\n\n/**\n * Narrow capability handle passed to\n * {@link StreamTransformer.onRegister}. Exposes only the minimal mux\n * surface required for synthetic event emission — intentionally does\n * not expose close/fail/register/etc. to keep the transformer contract\n * small and tamper-resistant.\n */\nexport interface StreamEmitter {\n  /**\n   * Injects a new {@link ProtocolEvent} into the mux pipeline. The\n   * event is routed through every registered transformer (including\n   * the emitting transformer — implementers must guard against\n   * re-entrant self-processing) and, if not suppressed, appended to\n   * the main event log.\n   *\n   * @param ns - Target namespace for the synthetic event.\n   * @param event - The event envelope to inject. ``event.seq`` is\n   *   overwritten by the mux; callers can pass any placeholder.\n   */\n  push(ns: Namespace, event: ProtocolEvent): void;\n}\n\nexport type ChatModelStream = Omit<\n  CoreChatModelStream,\n  typeof Symbol.asyncIterator\n> & {\n  /** Namespace of the graph node that produced this stream. */\n  readonly namespace: Namespace;\n\n  /** Graph node id for this stream, if the runtime attributed it. */\n  readonly node: string | undefined;\n\n  /**\n   * Low-level async iteration over message lifecycle events.\n   *\n   * @returns Iterator yielding Core-compatible chat model stream events.\n   */\n  [Symbol.asyncIterator](): AsyncIterator<CoreChatModelStreamEvent>;\n};\n\n/**\n * Public view yielded by `run.messages`.\n *\n * `ChatModelStream` is PromiseLike to mirror Core, but TypeScript applies\n * `Awaited<T>` to values produced by `for await`. Exposing a non-thenable view\n * keeps loop variables typed as the streaming handle instead of `AIMessage`.\n */\nexport type ChatModelStreamHandle = Omit<ChatModelStream, \"then\">;\n\n/**\n * High-level outcome of a single tool call for UI or aggregators.\n */\nexport type ToolCallStatus =\n  /** Invocation in flight or output still streaming. */\n  | \"running\"\n  /** Completed without error. */\n  | \"finished\"\n  /** Failed or aborted; see {@link ToolCallStream.error}. */\n  | \"error\";\n\n/**\n * Stable handle for one tool call: name, arguments, and async results.\n *\n * Emitted when `content-block-finish` delivers a finalized `tool_call` block.\n *\n * @typeParam TName - Registered tool name.\n * @typeParam TInput - Parsed or raw input type for the call.\n * @typeParam TOutput - Successful result type after the tool returns.\n */\nexport interface ToolCallStream<\n  TName extends string = string,\n  TInput = unknown,\n  TOutput = unknown,\n> {\n  /** Tool identifier as registered on the graph or model schema. */\n  readonly name: TName;\n\n  /** Correlates with protocol `toolCallId` when the runtime provides one. */\n  readonly callId: string;\n\n  /** Arguments passed to the tool (finalized when the call is observable). */\n  readonly input: TInput;\n\n  /**\n   * Resolves to the tool return value on success.\n   *\n   * @remarks\n   * Rejection or hang semantics depend on the runner; pairing with\n   * {@link ToolCallStream.status} and {@link ToolCallStream.error} is recommended.\n   */\n  readonly output: Promise<TOutput>;\n\n  /**\n   * Resolves to {@link ToolCallStatus} when the call leaves the running state.\n   */\n  readonly status: Promise<ToolCallStatus>;\n\n  /**\n   * Resolves to an error message string if {@link ToolCallStream.status} is\n   * `\"error\"`, otherwise `undefined`.\n   */\n  readonly error: Promise<string | undefined>;\n}\n\n/**\n * Marker interface for transformers provided by internal LangChain products\n * (e.g. ReactAgent's ToolCallTransformer, DeepAgent's SubagentTransformer).\n *\n * Native transformers differ from user-defined extension transformers in\n * where their projection lands on the run stream:\n *\n *   - **Native** — projections become direct getters on a\n *     `GraphRunStream` subclass (e.g. `run.toolCalls`, `run.subagents`).\n *     They emit events on protocol-defined channels (`tools`, `lifecycle`,\n *     `tasks`, etc.).\n *\n *   - **Extension** (user-defined) — projections are merged into\n *     `run.extensions`.  Events emitted via `emit()` use an\n *     application-chosen method name (e.g. `emit(\"a2a\", data)`) and are\n *     accessible to remote clients via `session.subscribe(\"custom:<name>\")`.\n *\n * The `__native` brand is used by downstream stream factory functions\n * to distinguish native transformers from extension transformers at\n * registration time.  See `docs/native-stream-transformers.md` for the\n * full pattern.\n */\nexport interface NativeStreamTransformer<\n  TProjection = unknown,\n> extends StreamTransformer<TProjection> {\n  readonly __native: true;\n}\n\n/**\n * Type guard that tests whether a transformer is a {@link NativeStreamTransformer}.\n */\nexport function isNativeTransformer(\n  t: StreamTransformer<unknown>\n): t is NativeStreamTransformer {\n  return \"__native\" in t && (t as NativeStreamTransformer).__native === true;\n}\n\n/**\n * Human-in-the-loop interrupt: stable id plus opaque payload for resume UIs.\n */\nexport interface InterruptPayload<TPayload = unknown> {\n  /** Idempotent key for this interrupt instance within the run. */\n  interruptId: string;\n\n  /** Arbitrary data supplied by the graph (e.g. questions, draft state). */\n  payload: TPayload;\n}\n"],"mappings":";;;;AAmVA,SAAgB,oBACd,GAC8B;AAC9B,QAAO,cAAc,KAAM,EAA8B,aAAa"}

package/dist/stream/types.d.cts

@@ -0,0 +1,255 @@
+import { StreamMode } from "../pregel/types.cjs";
+import { ChatModelStream } from "@langchain/core/language_models/stream";
+import { ChatModelStreamEvent } from "@langchain/core/language_models/event";
+import { AgentStatus as AgentStatus$1, Checkpoint, LifecycleCause, LifecycleData as LifecycleData$1, MessagesData as MessagesEventData, ToolsData as ToolsEventData, UpdatesData as UpdatesEventData, UsageInfo } from "@langchain/protocol";
+
+//#region src/stream/types.d.ts
+/**
+ * Hierarchical path identifying a position in the agent tree.
+ *
+ * Each element is one segment; longer arrays mean deeper nesting (e.g.
+ * subgraph or multi-agent scopes).
+ */
+type Namespace = string[];
+/**
+ * Channels that can appear on a protocol event.  Beyond the raw
+ * {@link StreamMode} channels emitted by the Pregel stream, the v2
+ * protocol layer synthesizes additional channels (e.g. `lifecycle`,
+ * `input`) via built-in {@link StreamTransformer}s and exposes
+ * user-defined channels created with {@link StreamChannel}.
+ */
+type ProtocolMethod = StreamMode | "lifecycle" | "input" | (string & {});
+/**
+ * Single envelope for a streaming protocol emission: sequence, channel
+ * (`method`), and payload (`params`).
+ */
+interface ProtocolEvent {
+  /** Discriminator; always `"event"` for this shape. */
+  readonly type: "event";
+  /** Monotonic sequence number for ordering and deduplication within a run. */
+  readonly seq: number;
+  /**
+   * Logical stream channel.  Built-in channels match {@link StreamMode}
+   * (e.g. `messages`, `updates`); transformer-synthesized channels
+   * include `lifecycle` and `input`; user-defined channels carry their
+   * {@link StreamChannel.channelName}.
+   */
+  readonly method: ProtocolMethod;
+  /** Channel-specific payload and routing metadata. */
+  readonly params: {
+    /** Namespace of the node or scope that emitted this event. */readonly namespace: Namespace; /** Wall-clock or logical timestamp for the emission (milliseconds). */
+    readonly timestamp: number;
+    /**
+     * Graph node id when the engine can attribute the event to a single node;
+     * omitted for run-level or ambiguous emissions.
+     */
+    readonly node?: string; /** Opaque channel payload; shape depends on `method`. */
+    readonly data: unknown;
+  };
+}
+/**
+ * Infers the merged extensions type from a tuple of transformer factory functions.
+ *
+ * Given `[() => StreamTransformer<{ a: number }>, () => StreamTransformer<{ b: string }>]`,
+ * produces `{ a: number } & { b: string }`.
+ */
+type InferExtensions<T extends ReadonlyArray<() => StreamTransformer<any>>> = T extends readonly [] ? Record<string, never> : T extends readonly [() => StreamTransformer<infer P>, ...infer Rest extends ReadonlyArray<() => StreamTransformer<any>>] ? P & InferExtensions<Rest> : Record<string, unknown>;
+/**
+ * Observes {@link ProtocolEvent}s during a graph run and builds typed derived
+ * projections (secondary event logs, promises, etc.).
+ *
+ * Data is surfaced to consumers through **projections** returned from
+ * `init()`.  Projections are merged into `GraphRunStream.extensions` for
+ * in-process consumers.  Use {@link StreamChannel.local} for local streaming
+ * values, {@link StreamChannel.remote} for values that should also be visible
+ * to remote clients, or `Promise<T>` for final values.
+ *
+ * To make projection data available to **remote** clients (SDK consumers
+ * over WebSocket / SSE), create a named channel with
+ * `StreamChannel.remote(name)`.  The {@link StreamMux} detects named
+ * `StreamChannel` instances in the `init()` return and auto-forwards every
+ * `push()` as a {@link ProtocolEvent} on the channel's named method.  Remote
+ * clients subscribe via `session.subscribe("custom:<name>")`.
+ *
+ * `finalize` and `fail` are optional.  When a transformer uses
+ * `StreamChannel`, the mux auto-closes/fails the channels on run
+ * completion — no manual lifecycle management needed.  Implement
+ * `finalize`/`fail` only for non-channel teardown (e.g. resolving a
+ * `Promise`).
+ *
+ * @typeParam TProjection - Shape returned by {@link init}, merged into
+ *   `GraphRunStream.extensions`.
+ */
+interface StreamTransformer<TProjection = unknown> {
+  /**
+   * Called once before the run starts.
+   *
+   * @returns Initial projection merged into `GraphRunStream.extensions`.
+   *   Any named {@link StreamChannel} instances in the return value are
+   *   automatically wired to the protocol event stream by the mux. Unnamed
+   *   channels stay in-process-only.
+   */
+  init(): TProjection;
+  /**
+   * Optional hook invoked by {@link StreamMux.addTransformer} immediately
+   * after the transformer is attached to the mux. Receives a limited
+   * handle that exposes only {@link StreamEmitter.push} — enough for
+   * the transformer to emit synthesized {@link ProtocolEvent}s on any
+   * namespace it chooses (e.g. a deepagents `SubagentTransformer`
+   * fabricating `lifecycle`/`messages`/`values` events under a
+   * `["tools:<tool_call_id>"]` namespace when a `task` tool starts).
+   *
+   * Transformers that do not synthesize events can omit this hook.
+   *
+   * The {@link StreamEmitter} handle is only safe to call *from within*
+   * {@link StreamTransformer.process}. Emitting from an unrelated async
+   * context (e.g. after `process` has returned, from a `setTimeout`,
+   * etc.) races with the mux's close/fail cycle and may land events in
+   * an already-closed log.
+   */
+  onRegister?(emitter: StreamEmitter): void;
+  /**
+   * Called for each {@link ProtocolEvent} before it is appended to the main log.
+   *
+   * @param event - Next protocol envelope for this run.
+   * @returns `false` to drop the original event from the main log (use
+   *   sparingly; prefer keeping events visible and adding derived data
+   *   alongside).
+   */
+  process(event: ProtocolEvent): boolean;
+  /**
+   * Called once when the underlying Pregel run completes without throwing.
+   * Optional — only needed for non-channel teardown (e.g. resolving promises).
+   *
+   * May return a `PromiseLike<void>` to defer the main event log close
+   * until the async work (e.g. emitting terminal lifecycle events) has
+   * completed.  The mux awaits all returned promises before closing its
+   * event log.
+   */
+  finalize?(): void | PromiseLike<void>;
+  /**
+   * Called once when the run fails; `err` is the rejection or error value.
+   * Optional — only needed for non-channel teardown (e.g. rejecting promises).
+   *
+   * @param err - Failure reason from the engine or user code.
+   */
+  fail?(err: unknown): void;
+}
+/**
+ * Narrow capability handle passed to
+ * {@link StreamTransformer.onRegister}. Exposes only the minimal mux
+ * surface required for synthetic event emission — intentionally does
+ * not expose close/fail/register/etc. to keep the transformer contract
+ * small and tamper-resistant.
+ */
+interface StreamEmitter {
+  /**
+   * Injects a new {@link ProtocolEvent} into the mux pipeline. The
+   * event is routed through every registered transformer (including
+   * the emitting transformer — implementers must guard against
+   * re-entrant self-processing) and, if not suppressed, appended to
+   * the main event log.
+   *
+   * @param ns - Target namespace for the synthetic event.
+   * @param event - The event envelope to inject. ``event.seq`` is
+   *   overwritten by the mux; callers can pass any placeholder.
+   */
+  push(ns: Namespace, event: ProtocolEvent): void;
+}
+type ChatModelStream$1 = Omit<ChatModelStream, typeof Symbol.asyncIterator> & {
+  /** Namespace of the graph node that produced this stream. */readonly namespace: Namespace; /** Graph node id for this stream, if the runtime attributed it. */
+  readonly node: string | undefined;
+  /**
+   * Low-level async iteration over message lifecycle events.
+   *
+   * @returns Iterator yielding Core-compatible chat model stream events.
+   */
+  [Symbol.asyncIterator](): AsyncIterator<ChatModelStreamEvent>;
+};
+/**
+ * Public view yielded by `run.messages`.
+ *
+ * `ChatModelStream` is PromiseLike to mirror Core, but TypeScript applies
+ * `Awaited<T>` to values produced by `for await`. Exposing a non-thenable view
+ * keeps loop variables typed as the streaming handle instead of `AIMessage`.
+ */
+type ChatModelStreamHandle = Omit<ChatModelStream$1, "then">;
+/**
+ * High-level outcome of a single tool call for UI or aggregators.
+ */
+type ToolCallStatus = /** Invocation in flight or output still streaming. */"running" /** Completed without error. */ | "finished" /** Failed or aborted; see {@link ToolCallStream.error}. */ | "error";
+/**
+ * Stable handle for one tool call: name, arguments, and async results.
+ *
+ * Emitted when `content-block-finish` delivers a finalized `tool_call` block.
+ *
+ * @typeParam TName - Registered tool name.
+ * @typeParam TInput - Parsed or raw input type for the call.
+ * @typeParam TOutput - Successful result type after the tool returns.
+ */
+interface ToolCallStream<TName extends string = string, TInput = unknown, TOutput = unknown> {
+  /** Tool identifier as registered on the graph or model schema. */
+  readonly name: TName;
+  /** Correlates with protocol `toolCallId` when the runtime provides one. */
+  readonly callId: string;
+  /** Arguments passed to the tool (finalized when the call is observable). */
+  readonly input: TInput;
+  /**
+   * Resolves to the tool return value on success.
+   *
+   * @remarks
+   * Rejection or hang semantics depend on the runner; pairing with
+   * {@link ToolCallStream.status} and {@link ToolCallStream.error} is recommended.
+   */
+  readonly output: Promise<TOutput>;
+  /**
+   * Resolves to {@link ToolCallStatus} when the call leaves the running state.
+   */
+  readonly status: Promise<ToolCallStatus>;
+  /**
+   * Resolves to an error message string if {@link ToolCallStream.status} is
+   * `"error"`, otherwise `undefined`.
+   */
+  readonly error: Promise<string | undefined>;
+}
+/**
+ * Marker interface for transformers provided by internal LangChain products
+ * (e.g. ReactAgent's ToolCallTransformer, DeepAgent's SubagentTransformer).
+ *
+ * Native transformers differ from user-defined extension transformers in
+ * where their projection lands on the run stream:
+ *
+ *   - **Native** — projections become direct getters on a
+ *     `GraphRunStream` subclass (e.g. `run.toolCalls`, `run.subagents`).
+ *     They emit events on protocol-defined channels (`tools`, `lifecycle`,
+ *     `tasks`, etc.).
+ *
+ *   - **Extension** (user-defined) — projections are merged into
+ *     `run.extensions`.  Events emitted via `emit()` use an
+ *     application-chosen method name (e.g. `emit("a2a", data)`) and are
+ *     accessible to remote clients via `session.subscribe("custom:<name>")`.
+ *
+ * The `__native` brand is used by downstream stream factory functions
+ * to distinguish native transformers from extension transformers at
+ * registration time.  See `docs/native-stream-transformers.md` for the
+ * full pattern.
+ */
+interface NativeStreamTransformer<TProjection = unknown> extends StreamTransformer<TProjection> {
+  readonly __native: true;
+}
+/**
+ * Type guard that tests whether a transformer is a {@link NativeStreamTransformer}.
+ */
+declare function isNativeTransformer(t: StreamTransformer<unknown>): t is NativeStreamTransformer;
+/**
+ * Human-in-the-loop interrupt: stable id plus opaque payload for resume UIs.
+ */
+interface InterruptPayload<TPayload = unknown> {
+  /** Idempotent key for this interrupt instance within the run. */
+  interruptId: string;
+  /** Arbitrary data supplied by the graph (e.g. questions, draft state). */
+  payload: TPayload;
+}
+//#endregion
+export { type AgentStatus$1 as AgentStatus, ChatModelStream$1 as ChatModelStream, ChatModelStreamHandle, type Checkpoint, InferExtensions, InterruptPayload, type LifecycleCause, type LifecycleData$1 as LifecycleData, type MessagesEventData, Namespace, NativeStreamTransformer, ProtocolEvent, StreamEmitter, StreamTransformer, ToolCallStatus, ToolCallStream, type ToolsEventData, type UpdatesEventData, type UsageInfo, isNativeTransformer };
+//# sourceMappingURL=types.d.cts.map

package/dist/stream/types.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.cts","names":[],"sources":["../../src/stream/types.ts"],"mappings":";;;;;;;;;;;;KAkDY,SAAA;;;;;AAuDZ;;;KA9CY,cAAA,GAAiB,UAAA;;;;;UAMZ,aAAA;EAgDiC;EAAA,SA9CvC,IAAA;EAgDL;EAAA,SA7CK,GAAA;EA6CD;;;;;;EAAA,SArCC,MAAA,EAAQ,cAAA;EA8Bf;EAAA,SA3BO,MAAA;IA6BP,uEA3BS,SAAA,EAAW,SAAA,EA4Bc;IAAA,SAzBzB,SAAA;IA2BiB;;;;IAAA,SArBjB,IAAA,WAwBP;IAAA,SArBO,IAAA;EAAA;AAAA;;;;;;;KAUD,eAAA,WAEA,aAAA,OAAoB,iBAAA,UAC5B,CAAA,uBACA,MAAA,kBACA,CAAA,yBACU,iBAAA,iCAEgB,aAAA,OAAoB,iBAAA,UAE5C,CAAA,GAAI,eAAA,CAAgB,IAAA,IACpB,MAAA;;;;;;;;;;;;;;AA+FN;;;;;;;;;;;AAeA;;UAlFiB,iBAAA;EAmFf;;;;;;;;EA1EA,IAAA,IAAQ,WAAA;EA0ER;;;;;;;;;;;;;AAwBF;;;;EA/EE,UAAA,EAAY,OAAA,EAAS,aAAA;EAoFX;;;;;AAiBZ;;;EA3FE,OAAA,CAAQ,KAAA,EAAO,aAAA;EAuGC;;;;;;;;;EA5FhB,QAAA,YAAoB,WAAA;EAmFpB;;;;;;EA3EA,IAAA,EAAM,GAAA;AAAA;;;;;;;;UAUS,aAAA;EAuHA;;;;;;;;;;AASjB;EApHE,IAAA,CAAK,EAAA,EAAI,SAAA,EAAW,KAAA,EAAO,aAAA;AAAA;AAAA,KAGjB,iBAAA,GAAkB,IAAA,CAC5B,eAAA,SACO,MAAA,CAAO,aAAA;EAgHX,sEA7GM,SAAA,EAAW,SAAA,EA8GnB;EAAA,SA3GQ,IAAA;EA2GoB;;AAO/B;;;EAP+B,CApG5B,MAAA,CAAO,aAAP,KAAyB,aAAA,CAAc,oBAAA;AAAA;;;;;;;;KAU9B,qBAAA,GAAwB,IAAA,CAAK,iBAAA;;;;KAK7B,cAAA;;;;;;;;;;UAiBK,cAAA;;WAMN,IAAA,EAAM,KAAA;;WAGN,MAAA;;WAGA,KAAA,EAAO,MAAA;;;;;;;;WASP,MAAA,EAAQ,OAAA,CAAQ,OAAA;;;;WAKhB,MAAA,EAAQ,OAAA,CAAQ,cAAA;;;;;WAMhB,KAAA,EAAO,OAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;UAyBD,uBAAA,gCAEP,iBAAA,CAAkB,WAAA;EAAA,SACjB,QAAA;AAAA;;;;iBAMK,mBAAA,CACd,CAAA,EAAG,iBAAA,YACF,CAAA,IAAK,uBAAA;;;;UAOS,gBAAA;;EAEf,WAAA;;EAGA,OAAA,EAAS,QAAA;AAAA"}