@arcgis/ai-components 5.2.0-next.99 → 6.0.0-next.0

package/dist/chunks/orchestrator.js

@@ -1,778 +0,0 @@
-/* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
-import M from "@arcgis/core/identity/IdentityManager.js";
-import _ from "@arcgis/core/portal/Portal.js";
-import { j as $, k as b, D, n as F, o as L, W } from "./generateLayerDescriptions.js";
-import { isGraphInterrupt as q, StateGraph as T, START as j, END as H, MemorySaver as P } from "@langchain/langgraph/web";
-import { generateGuid as A } from "@arcgis/toolkit/string";
-import { HumanMessage as U, AIMessage as O } from "@langchain/core/messages";
-import { s as p } from "./index.js";
-import { BaseCallbackHandler as G } from "@langchain/core/callbacks/base";
-import * as N from "@arcgis/core/core/reactiveUtils.js";
-import V from "@arcgis/core/layers/FeatureLayer.js";
-import z from "@arcgis/core/request.js";
-const B = async (n) => {
-  const e = await Q(), r = await $("default"), s = _.getDefault(), a = (await M.getCredential(`${s.url}/sharing`)).token, i = {
-    type: "generateEmbeddings",
-    webmapEmbeddings: n,
-    auth: { apiUrl: r, token: a }
-  };
-  return e.postMessage(i), await new Promise((o, d) => {
-    const c = (g) => {
-      g.data === "completed" && (e.removeEventListener("message", c), o());
-    }, u = (g) => {
-      e.removeEventListener("message", c), d(g instanceof Error ? g : new Error("Embeddings worker error"));
-    };
-    e.addEventListener("message", c), e.addEventListener("error", u, { once: !0 });
-  }), e;
-}, Q = async () => {
-  {
-    const n = (await import("./embeddings.worker.js")).default;
-    return new n();
-  }
-}, K = (n) => {
-  n.currentIntent = "none";
-}, J = async (n, e) => {
-  const r = b(e);
-  if (n.agentExecutionContext.userRequest) {
-    const t = new U(n.agentExecutionContext.userRequest.trim());
-    n.agentExecutionContext.messages = [...n.agentExecutionContext.messages, t], K(n);
-  }
-  const s = r?.services.agentRegistry.list().map((t) => t.agent.id) ?? [];
-  return await p({ text: `Available agents: ${[...s].join(", ")}` }, e), await p({ text: "Analyzing user input" }, e), n;
-}, X = async (n, e) => (await p({ text: "Exiting..." }, e), n), E = (n) => typeof n == "object" && n !== null && !Array.isArray(n), Y = (n, e) => {
-  if (!E(n)) {
-    n !== void 0 && console.warn(`Agent "${e}" returned invalid sharedStatePatch. Ignoring it.`);
-    return;
-  }
-  const r = {};
-  for (const [s, t] of Object.entries(n)) {
-    if (!E(t) || !("value" in t)) {
-      console.warn(
-        `Agent "${e}" returned invalid sharedStatePatch entry for key "${s}". Ignoring that entry.`
-      );
-      continue;
-    }
-    r[s] = { value: t.value };
-  }
-  return r;
-}, Z = (n) => {
-  const { previousSharedState: e, patch: r, agentId: s } = n;
-  if (!r)
-    return e;
-  const t = Date.now(), a = {
-    ...e
-  };
-  for (const [i, o] of Object.entries(r))
-    o?.value !== void 0 && (a[i] = {
-      value: o.value,
-      meta: {
-        updatedByAgentId: s,
-        updatedAt: t
-      }
-    });
-  return a;
-}, ee = 256, te = /* @__PURE__ */ new Set(["point", "polyline", "polygon", "extent", "custom"]), ne = (n) => typeof n == "object" && n !== null && !Array.isArray(n), re = (n, e) => {
-  if (n === void 0)
-    return;
-  if (!Array.isArray(n)) {
-    console.warn(`Agent "${e}" returned invalid sharedResourceAdditions. Ignoring it.`);
-    return;
-  }
-  const r = [];
-  for (const [s, t] of n.entries()) {
-    if (!ne(t) || typeof t.kind != "string" || !te.has(t.kind) || typeof t.description != "string" || !t.description.trim() || !("payload" in t) || t.payload === void 0) {
-      console.warn(
-        `Agent "${e}" returned invalid sharedResourceAdditions entry at index ${s}. Ignoring that entry.`
-      );
-      continue;
-    }
-    let a;
-    try {
-      a = structuredClone(t.payload);
-    } catch {
-      console.warn(
-        `Agent "${e}" returned invalid sharedResourceAdditions entry at index ${s}. Ignoring that entry.`
-      );
-      continue;
-    }
-    r.push({
-      kind: t.kind,
-      description: t.description.trim().slice(0, ee),
-      payload: a
-    });
-  }
-  return r.length ? r : void 0;
-}, se = (n) => {
-  const { previousSharedResources: e, additions: r, agentId: s } = n;
-  if (!r?.length)
-    return e;
-  const t = Date.now(), a = r.map((i) => ({
-    ...i,
-    id: A(),
-    meta: {
-      createdByAgentId: s,
-      createdAt: t
-    }
-  }));
-  return [...e, ...a].slice(-50);
-}, R = (n) => {
-  if (typeof n != "string")
-    return;
-  const e = n.trim();
-  return e || void 0;
-}, ae = (n) => {
-  switch (n) {
-    case "failed":
-      return "Agent failed without a summary.";
-    case "unknown":
-      return "Agent returned with unknown status.";
-    case "success":
-      return "Agent completed without a summary.";
-    default:
-      return "Agent completed without a summary.";
-  }
-}, ie = (n, e) => {
-  const r = R(e?.outputMessage), s = R(e?.summary), t = e?.status, a = t === "success" || t === "failed" ? t : "unknown";
-  a === "unknown" && console.warn(`Agent "${n}" returned missing/invalid status. Defaulting to "unknown".`);
-  const i = Y(e?.sharedStatePatch, n), o = re(e?.sharedResourceAdditions, n);
-  return {
-    outputMessage: r,
-    summary: s ?? r ?? ae(a),
-    status: a,
-    sharedStatePatch: i,
-    sharedResourceAdditions: o
-  };
-}, x = 4e3, oe = async (n, e) => {
-  const r = b(e);
-  if (e?.signal?.aborted)
-    return await p({ text: "Run cancelled; skipping agent execution" }, e), {
-      ...n,
-      currentIntent: "none",
-      requiresFollowUp: !1
-    };
-  const { agentRegistry: s } = r?.services ?? {}, t = s?.get(n.currentIntent);
-  if (!t)
-    return console.warn(`No agent found for intent: ${n.currentIntent}`), n;
-  await p({ text: `Executing registered agent: ${t.agent.name}` }, e);
-  const a = {
-    ...e ?? {},
-    metadata: {
-      ...e?.metadata,
-      agentId: t.agent.id
-    },
-    configurable: {
-      ...r ?? {},
-      agentId: t.agent.id,
-      context: t.getContext ? await t.getContext() : void 0
-    }
-  };
-  let i;
-  try {
-    const c = await t.agent.createGraph().compile().invoke(
-      {
-        agentExecutionContext: {
-          ...n.agentExecutionContext,
-          // deep clone on messages did not work in agents, so its a shallow clone here.
-          messages: [...n.agentExecutionContext.messages],
-          // deep clone to prevent accidental mutations by agents
-          priorSteps: structuredClone(n.agentExecutionContext.priorSteps ?? []),
-          sharedState: structuredClone(n.agentExecutionContext.sharedState ?? {}),
-          sharedResources: structuredClone(n.agentExecutionContext.sharedResources ?? [])
-        }
-      },
-      a
-    );
-    i = ie(t.agent.name, c), await p({ text: `Finished executing registered agent: ${t.agent.name}` }, e);
-  } catch (c) {
-    if (q(c) || e?.signal?.aborted || c instanceof Error && c.name === "AbortError")
-      throw c;
-    const u = c instanceof Error ? c.message : String(c);
-    console.error(`Agent "${t.agent.name}" failed:`, c), await p({ text: `Registered agent failed: ${t.agent.name}. ${u}` }, e), i = {
-      status: "failed",
-      outputMessage: `Agent execution failed: ${u}`,
-      summary: `Agent execution failed: ${u}`
-    };
-  }
-  const o = i.outputMessage, d = [...n.agentExecutionContext.messages];
-  if (o) {
-    const c = o.length > x ? `${o.slice(0, x - 14)}
-[truncated]` : o;
-    d.push(new O(c));
-  }
-  return {
-    ...n,
-    stepCount: n.stepCount + 1,
-    lastExecutedAgent: t.agent.id,
-    requiresFollowUp: i.status === "failed" ? !0 : n.requiresFollowUp,
-    finalOutputMessage: o ?? "",
-    agentExecutionContext: {
-      ...n.agentExecutionContext,
-      messages: d,
-      priorSteps: [
-        ...n.agentExecutionContext.priorSteps ?? [],
-        {
-          agentId: t.agent.id,
-          assignedTask: n.agentExecutionContext.assignedTask,
-          summary: i?.summary || "No summary provided.",
-          status: i?.status || "unknown"
-        }
-      ],
-      sharedState: Z({
-        previousSharedState: n.agentExecutionContext.sharedState,
-        patch: i.sharedStatePatch,
-        agentId: t.agent.id
-      }),
-      sharedResources: se({
-        previousSharedResources: n.agentExecutionContext.sharedResources,
-        additions: i.sharedResourceAdditions,
-        agentId: t.agent.id
-      })
-    }
-  };
-}, ce = async (n, e) => {
-  if (n.routing.mode !== "direct")
-    throw new Error("Direct agent assignment requires direct routing.");
-  return await p({ text: `Doing a direct route to agent: ${n.routing.agentId}` }, e), {
-    ...n,
-    currentIntent: n.routing.agentId,
-    requiresFollowUp: !1,
-    agentExecutionContext: {
-      ...n.agentExecutionContext,
-      assignedTask: n.agentExecutionContext.userRequest
-    }
-  };
-}, de = 3, ue = (n) => n.routing.mode === "direct" ? "assignDirectAgent" : "intentLLM", ge = (n) => n.routing.mode === "direct" || n.stepCount >= de || !n.requiresFollowUp ? "exit" : "intentLLM", le = () => new T(D).addNode("ingestInput", J).addNode("assignDirectAgent", ce).addNode("intentLLM", F).addNode("executeRegisteredAgent", oe).addNode("exit", X).addEdge(j, "ingestInput").addConditionalEdges("ingestInput", ue).addEdge("assignDirectAgent", "executeRegisteredAgent").addConditionalEdges("intentLLM", (e) => e.currentIntent === "none" || e.currentIntent === e.lastExecutedAgent ? "exit" : "executeRegisteredAgent").addConditionalEdges("executeRegisteredAgent", ge).addEdge("exit", H), he = (n, e) => {
-  const r = n.output?.usage_metadata ?? e.usage_metadata, s = n.output?.llmOutput?.tokenUsage, t = r?.input_tokens ?? s?.promptTokens, a = r?.output_tokens ?? s?.completionTokens, i = r?.total_tokens ?? s?.totalTokens;
-  if (t === void 0 || a === void 0 || i === void 0)
-    return;
-  const o = r?.input_token_details?.cache_read, d = r?.output_token_details?.reasoning;
-  return {
-    input: t,
-    output: a,
-    total: i,
-    ...o !== void 0 && { cacheRead: o },
-    ...d !== void 0 && { reasoning: d }
-  };
-}, pe = (n, e, r, s) => {
-  switch (n) {
-    case "chat_model":
-    case "llm":
-      return "model";
-    case "tool":
-    case "retriever":
-      return n;
-    case "chain":
-      return !s || e === "LangGraph" ? "workflow" : r === e ? "node" : "chain";
-    default:
-      return;
-  }
-}, me = (n) => {
-  if (n instanceof Error)
-    return { message: n.message, name: n.name };
-  const e = n, r = typeof e?.message == "string" ? e.message : String(n ?? "Unknown runtime error"), s = typeof e?.name == "string" ? e.name : void 0;
-  return { message: r, ...s && { name: s } };
-}, ye = ({
-  event: n,
-  runId: e,
-  parentSpanId: r,
-  timestamp: s
-}) => {
-  const t = /^on_(.+)_(start|end|error)$/u.exec(n.event);
-  if (!t)
-    return;
-  const [, a, i] = t, o = n.metadata ?? {}, d = o.langgraph_node, c = pe(a, n.name, d, r);
-  if (!c)
-    return;
-  const u = o.agentId, g = o.model ?? o.ls_model_name, l = n.data, f = i === "end" && c === "model" ? he(l, o) : void 0, h = n.tags?.includes("langsmith:hidden") || d === "__start__", v = {
-    ...g && { model: g },
-    ...f && { tokenUsage: f },
-    ...h && { internal: !0 }
-  }, w = {
-    id: n.run_id,
-    ...r && { parentId: r },
-    label: n.name,
-    type: c,
-    ...Object.keys(v).length && { metadata: v }
-  }, m = { runId: e, timestamp: s, type: "runtime", ...u && { agentId: u } };
-  switch (i) {
-    case "start":
-      return {
-        ...m,
-        phase: "started",
-        span: {
-          ...w,
-          ...l?.input !== void 0 && { input: l.input }
-        }
-      };
-    case "end":
-      return {
-        ...m,
-        phase: "completed",
-        span: {
-          ...w,
-          ...l?.output !== void 0 && { output: l.output }
-        }
-      };
-    case "error":
-      return { ...m, phase: "failed", span: { ...w, error: me(l?.error) } };
-    default:
-      return;
-  }
-};
-class S {
-  constructor() {
-    this.agentRegistry = /* @__PURE__ */ new Map();
-  }
-  register(e) {
-    const { agent: r } = e;
-    if (this.agentRegistry.has(r.id))
-      throw new Error(`Duplicate agent id: ${r.id}`);
-    this.agentRegistry.set(r.id, e);
-  }
-  get(e) {
-    return this.agentRegistry.get(e);
-  }
-  list() {
-    return [...this.agentRegistry.values()];
-  }
-}
-class fe {
-  /**
-   * Create a new InterruptHandler tied to a specific compiled graph and config.
-   */
-  constructor(e, r) {
-    this.graph = e, this.config = { ...r };
-  }
-  /**
-   * Returns a promise that resolves when the user provides a HITL response.
-   */
-  async waitForUser() {
-    return await new Promise((e, r) => {
-      this.resolveWait = e, this.rejectWait = r;
-    });
-  }
-  /**
-   * Resume graph execution after the UI responds to an interrupt.
-   */
-  handle(e, r) {
-    try {
-      const s = {
-        agentId: e.agentId,
-        id: e.id,
-        payload: r
-      }, t = this.graph.streamEvents(null, {
-        ...this.config,
-        configurable: {
-          ...this.config.configurable,
-          hitlResponse: s
-        },
-        subgraphs: !0,
-        version: "v2"
-      });
-      this.resolveWait?.(t);
-    } catch (s) {
-      this.rejectWait?.(s);
-    } finally {
-      this.resolveWait = void 0, this.rejectWait = void 0;
-    }
-  }
-  /**
-   * Abort the HITL wait and reject any pending continuation.
-   */
-  cancel() {
-    this.rejectWait && (this.rejectWait(new Error("Request cancelled by user.")), this.resolveWait = void 0, this.rejectWait = void 0);
-  }
-}
-const we = async (n) => {
-  try {
-    return await (await L()).embedDocuments(n);
-  } catch (e) {
-    throw console.error("Failed to generate embeddings:", e), e;
-  }
-}, C = async (n, e) => {
-  const r = e.get(n);
-  if (r)
-    return r;
-  const s = await we([n]);
-  return e.set(n, s[0]), s[0];
-};
-async function ve(n, e, r, s) {
-  const t = `req-${Date.now()}`, i = {
-    type: "layerSearch",
-    precomputedEmbedding: s ? await C(n, s) : void 0,
-    requestId: t,
-    minScore: r
-  };
-  return await new Promise((o) => {
-    const d = (c) => {
-      c.data.requestId === t && o(c.data.results);
-    };
-    e.addEventListener("message", d, { once: !0 }), e.postMessage(i);
-  });
-}
-function Ee(n) {
-  const { worker: e } = n;
-  return {
-    async searchLayers({
-      text: r,
-      minScore: s,
-      embeddingCache: t
-    }) {
-      return await ve(r, e, s, t);
-    }
-  };
-}
-const Re = async ({
-  combinedQuery: n,
-  layerIds: e,
-  embeddingsWorker: r,
-  minScore: s,
-  topResults: t,
-  embeddingCache: a
-}) => {
-  const i = `req-${Date.now()}`, o = a ? await C(n, a) : void 0, d = {
-    type: "fieldSearch",
-    layerIdForFieldsSearch: e,
-    precomputedEmbedding: o,
-    requestId: i,
-    minScore: s,
-    topResults: t
-  };
-  return await new Promise((c) => {
-    const u = (g) => {
-      if (g.data.requestId !== i)
-        return;
-      const l = g.data.results.map(({ layerId: f, results: h }) => ({
-        layerId: f,
-        results: h
-      }));
-      c(l);
-    };
-    r.addEventListener("message", u, { once: !0 }), r.postMessage(d);
-  });
-};
-function xe(n) {
-  const { worker: e } = n;
-  return {
-    async searchFields({ text: r, layerIds: s, minScore: t, topResults: a, embeddingCache: i }) {
-      return await Re({
-        combinedQuery: r,
-        layerIds: s,
-        embeddingsWorker: e,
-        minScore: t,
-        topResults: a,
-        embeddingCache: i
-      });
-    }
-  };
-}
-const Se = (n) => {
-  const e = W.safeParse(n);
-  if (!e.success)
-    throw new Error("Embeddings response validation failed. Regenerate embeddings.");
-  return e.data;
-}, be = (n, e) => {
-  const r = /* @__PURE__ */ new Map(), s = /* @__PURE__ */ new Map();
-  if (e.allLayers.forEach((t) => {
-    t instanceof V && s.set(t.id, t);
-  }), n.length !== s.size)
-    throw new Error("Layer count mismatch during registry restoration. Regenerate embeddings.");
-  for (const t of n) {
-    const a = s.get(t.id);
-    if (!a)
-      throw new Error(
-        `Layer with ID ${t.id} not found in the original map during registry restoration. Regenerate embeddings.`
-      );
-    if (t.fields.length !== a.fields.length)
-      throw new Error(
-        `Field count mismatch for layer ID ${t.id} during registry restoration. Regenerate embeddings.`
-      );
-    const i = {
-      name: t.name,
-      title: t.title,
-      description: t.description
-    }, o = /* @__PURE__ */ new Map();
-    for (const d of t.fields) {
-      const c = a.fieldsIndex.get(d.name);
-      if (!c)
-        throw new Error(
-          `Field with name ${d.name} not found in the original layer ${t.id} during registry restoration. Regenerate embeddings.`
-        );
-      o.set(d.name, {
-        name: d.name,
-        alias: a.getFieldAlias(d.name) ?? d.alias,
-        description: d.description,
-        type: c.type || "unknown",
-        valueType: c.valueType || "unknown",
-        domain: a.getFieldDomain(d.name) ?? void 0
-      });
-    }
-    r.set(t.id, {
-      layerItem: i,
-      fieldRegistry: o
-    });
-  }
-  return r;
-}, Ae = async (n) => {
-  try {
-    return (await z(n, {
-      responseType: "json"
-    })).data;
-  } catch (e) {
-    throw new Error(`Failed to fetch data from ${n}: ${String(e)}`);
-  }
-}, Ce = async (n) => {
-  const e = n.map;
-  if (!e?.portalItem)
-    throw new Error("WebMap portal item is missing.");
-  const { resources: r } = await e.portalItem.fetchResources(), s = r.find((i) => i.resource.path === "embeddings-v01.json");
-  if (!s?.resource.url)
-    throw new Error("Embeddings resource 'embeddings-v01.json' not found in the webmap portal item.");
-  const t = await Ae(s.resource.url);
-  return Se(t);
-};
-class k {
-  constructor() {
-    this.orchestratorReady = !1, this.chatHistory = [], this.priorSteps = [], this.sharedState = {}, this.sharedResources = [], this.agentRegistry = new S(), this.activeRunId = "", this.cancelledRunIds = /* @__PURE__ */ new Set(), this.parentRunIds = /* @__PURE__ */ new Map(), this.activeRuntimeSpans = /* @__PURE__ */ new Map(), this.runtimeEventsEnabled = !1, this.streamEpoch = 0;
-  }
-  /**
-   * Creates and returns an AI-ready Orchestrator instance.
-   * @param deps Core dependencies (layer/field registry plus optional map views).
-   * @returns Ready Orchestrator.
-   */
-  static async init(e) {
-    const r = new k();
-    r.runtimeEventsEnabled = e.runtimeEventsEnabled ?? !1;
-    try {
-      if (e.view?.map) {
-        await N.whenOnce(() => e.view.ready);
-        const s = await Ce(e.view), t = be(
-          s.layers,
-          e.view.map
-        );
-        r.layersAndFieldsRegistry = t, r.embeddingsWorker = await B(s);
-      }
-      return e.agents?.forEach((s) => {
-        r.agentRegistry.register(s);
-      }), r.orchestratorReady = !0, r;
-    } catch (s) {
-      throw console.error("Orchestrator initialization failed:", s), s;
-    }
-  }
-  /**
-   * Run a new chat turn through the graph.
-   * Yields structured events for the UI to consume:
-   *  - `trace`: intermediate model output
-   *  - `interrupt`: HITL required, wait for `resumeInterrupt()`
-   *  - `completed`: final result with chat history + layer styling
-   *  - `cancelled`: user aborted the run
-   * @param userInput User request to process.
-   * @param options Agent selection and routing behavior for this run.
-   */
-  async *ask(e, r = {}) {
-    if (!this.orchestratorReady)
-      throw new Error("Orchestrator is not ready yet.");
-    if (!this.agentRegistry.list().length)
-      throw new Error("Orchestrator has no registered agents.");
-    const s = this.createRequestAgentRegistry(r);
-    if (!s.list().length)
-      throw new Error("Orchestrator has no agents selected for this request.");
-    if (++this.streamEpoch, !e.trim())
-      return;
-    const t = A();
-    this.parentRunIds.clear(), this.activeRuntimeSpans.clear(), this.activeRunId = t, this.activeAbortController = new AbortController(), this.graph || (this.graph = le().compile({ checkpointer: new P() }));
-    const a = this.embeddingsWorker ? Ee({ worker: this.embeddingsWorker }) : void 0, i = this.embeddingsWorker ? xe({ worker: this.embeddingsWorker }) : void 0, o = /* @__PURE__ */ new Map(), d = r.routing === "direct" ? { mode: "direct", agentId: r.agentId } : { mode: "auto" }, c = {
-      // eslint-disable-next-line @typescript-eslint/naming-convention
-      thread_id: t,
-      hitlResponse: null,
-      services: {
-        layerSearch: a,
-        fieldSearch: i,
-        layersAndFieldsRegistry: this.layersAndFieldsRegistry,
-        agentRegistry: s,
-        embeddingCache: o
-      }
-    }, u = {
-      version: "v2",
-      streamMode: "custom",
-      signal: this.activeAbortController.signal,
-      ...this.runtimeEventsEnabled && { callbacks: [this.createHierarchyCallback()] },
-      configurable: c,
-      subgraphs: !0
-    }, g = this.graph?.streamEvents(
-      {
-        routing: d,
-        agentExecutionContext: {
-          userRequest: e,
-          messages: this.chatHistory,
-          priorSteps: this.priorSteps,
-          sharedState: this.sharedState,
-          sharedResources: this.sharedResources
-        }
-      },
-      u
-    ), l = ++this.streamEpoch;
-    if (yield* this.pipeStream(g, l, t), this.isRunCancelled(t)) {
-      yield* this.createCancellationEvents(t);
-      return;
-    }
-    for (; ; ) {
-      if (this.isRunCancelled(t)) {
-        yield* this.createCancellationEvents(t);
-        return;
-      }
-      const m = (await this.graph.getState(u, { subgraphs: !0 })).tasks.find((y) => y.interrupts.length > 0)?.interrupts[0]?.value;
-      if (!m)
-        break;
-      this.currentInterrupt = m, this.interruptHandler = new fe(this.graph, u), yield* this.closeActiveRuntimeSpans(t, "interrupted"), yield { runId: t, timestamp: Date.now(), type: "interrupt", interrupt: m };
-      try {
-        const y = await this.interruptHandler.waitForUser(), I = ++this.streamEpoch;
-        yield* this.pipeStream(y, I, t);
-      } catch (y) {
-        if (this.isRunCancelled(t)) {
-          yield* this.createCancellationEvents(t);
-          return;
-        }
-        if (y) {
-          yield {
-            runId: t,
-            timestamp: Date.now(),
-            type: "error",
-            error: { message: y?.message }
-          };
-          return;
-        }
-      }
-    }
-    if (this.isRunCancelled(t)) {
-      yield* this.createCancellationEvents(t);
-      return;
-    }
-    const h = (await this.graph.getState(u, { subgraphs: !0 })).values;
-    if (this.isRunCancelled(t)) {
-      yield* this.createCancellationEvents(t);
-      return;
-    }
-    this.chatHistory = h.agentExecutionContext.messages.length ? h.agentExecutionContext.messages : this.chatHistory, this.priorSteps = h.agentExecutionContext.priorSteps?.slice(-5) ?? [], this.sharedState = h.agentExecutionContext.sharedState ?? {}, this.sharedResources = h.agentExecutionContext.sharedResources ?? [], yield {
-      runId: t,
-      timestamp: Date.now(),
-      type: "completed",
-      result: { content: h.finalOutputMessage }
-    };
-  }
-  /**
-   * Start a new conversation by clearing chat history, prior steps, and shared state.
-   */
-  newConversation() {
-    this.chatHistory = [], this.priorSteps = [], this.sharedState = {}, this.sharedResources = [];
-  }
-  /**
-   * Generic resume for any HITL interrupt.
-   * The payload is whatever the UI collected (e.g. "yes", "no", layerId, etc).
-   */
-  resumeInterrupt(e) {
-    if (!this.currentInterrupt || !this.interruptHandler)
-      throw new Error("No pending interrupt to resume.");
-    this.interruptHandler.handle(this.currentInterrupt, e);
-  }
-  /**
-   * Optional: allow UI to cancel the current HITL.
-   */
-  cancelInterrupt() {
-    this.interruptHandler && this.interruptHandler.cancel();
-  }
-  /**
-   * Cancels the active run.
-   *
-   * - Aborts in-flight work for consumers that honor AbortSignal.
-   * - Invalidates active stream iterators via epoch bump.
-   * - Unblocks any pending HITL wait.
-   */
-  cancel() {
-    this.activeRunId && (this.cancelledRunIds.add(this.activeRunId), this.activeAbortController?.abort(), ++this.streamEpoch, this.interruptHandler?.cancel());
-  }
-  async *pipeStream(e, r, s) {
-    try {
-      for await (const t of e) {
-        if (this.isRunCancelled(s) || r !== this.streamEpoch)
-          break;
-        if (this.runtimeEventsEnabled) {
-          const a = ye({
-            event: t,
-            runId: s,
-            parentSpanId: this.parentRunIds.get(t.run_id),
-            timestamp: Date.now()
-          });
-          a && (a.phase === "started" ? this.activeRuntimeSpans.set(a.span.id, a) : this.activeRuntimeSpans.delete(a.span.id), yield a);
-        }
-        t.event === "on_custom_event" && t.name === "trace_message" ? yield { runId: s, timestamp: Date.now(), type: "trace", data: t.data } : t.name === "graph_ux_suggestion" && (yield {
-          runId: s,
-          timestamp: Date.now(),
-          type: "ux-suggestion",
-          suggestion: t.data
-        });
-      }
-    } catch (t) {
-      if (!this.isRunCancelled(s))
-        throw t;
-    }
-  }
-  *createCancellationEvents(e) {
-    yield* this.closeActiveRuntimeSpans(e, "cancelled"), yield { runId: e, timestamp: Date.now(), type: "cancelled", reason: "user" };
-  }
-  *closeActiveRuntimeSpans(e, r) {
-    const s = Date.now(), t = [...this.activeRuntimeSpans.values()].reverse();
-    this.activeRuntimeSpans.clear();
-    for (const a of t) {
-      const { input: i, ...o } = a.span;
-      yield {
-        type: "runtime",
-        phase: r,
-        runId: e,
-        timestamp: s,
-        ...a.agentId && { agentId: a.agentId },
-        span: o
-      };
-    }
-  }
-  // v2 stream events omit parent run IDs, so capture them through callbacks to preserve the normalized span hierarchy.
-  createHierarchyCallback() {
-    const e = (r, s) => {
-      s && this.parentRunIds.set(r, s);
-    };
-    return G.fromMethods({
-      handleLLMStart: (r, s, t, a) => e(t, a),
-      handleChatModelStart: (r, s, t, a) => e(t, a),
-      handleChainStart: (r, s, t, a) => e(t, a),
-      handleToolStart: (r, s, t, a) => e(t, a),
-      handleRetrieverStart: (r, s, t, a) => e(t, a)
-    });
-  }
-  isRunCancelled(e) {
-    return this.cancelledRunIds.has(e);
-  }
-  /**
-   * Creates a request-scoped registry containing all agents by default,
-   * or only the explicitly selected agents when filtering is requested.
-   */
-  createRequestAgentRegistry(e) {
-    const r = e.routing === "direct" ? [e.agentId] : e.agentIds, s = r ? r.map((a) => {
-      const i = this.agentRegistry.get(a);
-      if (!i)
-        throw new Error(`Agent is not registered: ${a}`);
-      return i;
-    }) : this.agentRegistry.list(), t = new S();
-    return s.forEach((a) => t.register(a)), t;
-  }
-  /**
-   * Disposes this instance by terminating the embeddings worker
-   * and cleaning up all related resources.
-   */
-  dispose() {
-    this.sharedResources = [], this.embeddingsWorker && (this.embeddingsWorker.terminate(), this.embeddingsWorker = void 0), this.orchestratorReady = !1;
-  }
-}
-export {
-  k as O,
-  we as g
-};