@arcgis/ai-components 6.0.0-next.0 → 6.0.0-next.2

package/dist/agent-utils/BaseAgent.js

@@ -1,4 +1,4 @@
-/* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
+/* COPYRIGHT Esri - https://js.arcgis.com/6.0/LICENSE.txt */
 import { a } from "../chunks/state.js";
 const t = () => {
   throw new Error("createGraph method not implemented.");

package/dist/agent-utils/FunctionAgent.js

@@ -1,4 +1,4 @@
-/* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
+/* COPYRIGHT Esri - https://js.arcgis.com/6.0/LICENSE.txt */
 import { isGraphInterrupt as o } from "@langchain/langgraph/web";
 import { BaseAgent as c } from "./BaseAgent.js";
 import { c as u } from "../chunks/graph.js";

package/dist/agent-utils/LLMAgent.d.ts

@@ -2,10 +2,11 @@ import type { StructuredToolInterface } from "@langchain/core/tools";
 import type { BaseAgent } from "./BaseAgent.js";
 import type { AgentMiddleware } from "./middlewares/types.js";
 import type { FunctionToolLike } from "./tools/FunctionTool.js";
+import type { ToolProvider } from "./tools/ToolProvider.js";
 import type { AgentCustomState, AgentData, ZodObjectSchema } from "./types.js";
 import type { ChatModelTier } from "../orchestrator/models/chatModel.js";
 
-export type LLMAgentTool = FunctionToolLike | StructuredToolInterface;
+export type LLMAgentTool = FunctionToolLike | StructuredToolInterface | ToolProvider;
 
 /**
  * LLMAgent uses a language model to generate its output based on a provided prompt template and optional tools.
@@ -45,8 +46,14 @@ export class LLMAgent<TInput extends AgentData = AgentData, TOutput extends Agen
    * @required
    */
   prompt: string;
-  /** The tools property is an optional array of tools that the agent can use during execution. */
+  /**
+   * The tools property is an optional array of tools and tool providers that the agent can use during execution.
+   * Passing a provider transfers ownership to this agent. Providers must not be shared between agents.
+   * Providers are destroyed when this agent is destroyed. Ordinary tools remain caller-owned.
+   * Keep tools fixed for the agent's lifetime. To replace them, destroy this agent and create a new one.
+   */
   tools?: LLMAgentTool[];
+  destroy(): void;
   /**
    * Rebuilds internal workspace and createGraph wiring. Concrete agent constructors call this after assigning their
    * configuration. Call it manually after changing graph-defining properties.

package/dist/agent-utils/LLMAgent.js

@@ -1,70 +1,77 @@
-/* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
+/* COPYRIGHT Esri - https://js.arcgis.com/6.0/LICENSE.txt */
 import { ChatPromptTemplate as c } from "@langchain/core/prompts";
 import { ToolMessage as l } from "@langchain/core/messages";
 import { isGraphInterrupt as g } from "@langchain/langgraph/web";
-import { createAgent as m, providerStrategy as f } from "langchain";
+import { createAgent as d, providerStrategy as f } from "langchain";
 import { BaseAgent as w } from "./BaseAgent.js";
-import { convertToLangChainMiddlewares as d } from "./middlewares/middleware.js";
-import { c as T } from "../chunks/graph.js";
-import { c as A } from "../chunks/state.js";
-import { c as u, h as y } from "../chunks/utils.js";
+import { convertToLangChainMiddlewares as m } from "./middlewares/middleware.js";
+import { c as y } from "../chunks/graph.js";
+import { c as T } from "../chunks/state.js";
+import { c as u, h as A } from "../chunks/utils.js";
 class L extends w {
   //#region Lifecycle
   constructor(t) {
-    super(), this.middlewares = [], this.modelTier = "default", Object.assign(this, t), this.generate();
+    super(), this.middlewares = [], this.modelTier = "default", this._destroyed = !1, Object.assign(this, t), this.generate();
+  }
+  destroy() {
+    if (!this._destroyed) {
+      this._destroyed = !0;
+      for (const t of new Set(this.tools))
+        "getTools" in t && t.destroy();
+    }
   }
   //#endregion
   //#region Public Methods
   generate() {
-    const t = this.prompt ? c.fromTemplate(this.prompt).inputVariables : [], s = A(
+    const t = this.prompt ? c.fromTemplate(this.prompt).inputVariables : [], e = T(
       [this.inputSchema, this.outputSchema].filter(Boolean),
       t
-    ), e = this.id, o = { [e]: this._invoke.bind(this) }, r = [{ from: e, decide: () => {
+    ), s = this.id, o = { [s]: this._invoke.bind(this) }, r = [{ from: s, decide: () => {
     } }];
-    this.workspace = s, this.createGraph = () => T(o, r, s, {
+    this.workspace = e, this.createGraph = () => y(o, r, e, {
       agent: this,
-      entryNode: e,
+      entryNode: s,
       middlewares: this.middlewares
     });
   }
   //#endregion
   //#region Private Methods
-  async _invoke(t, s) {
+  async _invoke(t, e) {
     try {
-      return this.outputSchema ? await this._invokeStructured(t, s) : await this._invokeUnstructured(t, s);
-    } catch (e) {
-      if (g(e) || s?.signal?.aborted || e instanceof Error && e.name === "AbortError")
-        throw e;
-      const o = e instanceof Error ? e.message : String(e);
+      return this.outputSchema ? await this._invokeStructured(t, e) : await this._invokeUnstructured(t, e);
+    } catch (s) {
+      if (g(s) || e?.signal?.aborted || s instanceof Error && s.name === "AbortError")
+        throw s;
+      const o = s instanceof Error ? s.message : String(s);
       return u({ outputMessage: o }, "failed", o);
     }
   }
-  async _invokeStructured(t, s) {
+  async _invokeStructured(t, e) {
     if (!this.outputSchema)
       throw new Error("Output schema is required for structured invocation.");
-    const { createChatModel: e } = await import("../orchestrator/models/chatModel.js"), r = await m({
-      model: await e({ modelTier: this.modelTier }),
+    const { createChatModel: s } = await import("../orchestrator/models/chatModel.js"), r = await d({
+      model: await s({ modelTier: this.modelTier }),
       systemPrompt: await this._getPromptWithInputVariables(t),
-      tools: this._getTools(),
+      tools: await this._getTools(),
       checkpointer: !0,
-      middleware: d(this.middlewares),
+      middleware: m(this.middlewares),
       responseFormat: f(this.outputSchema)
-    }).invoke({ messages: t.agentExecutionContext.messages }, s);
+    }).invoke({ messages: t.agentExecutionContext.messages }, e);
     if (!("structuredResponse" in r) || r.structuredResponse === void 0)
       throw new Error("LLMAgent did not receive structured output from createAgent.");
     return {
-      ...y(r.structuredResponse, this.outputSchema, r.messages),
+      ...A(r.structuredResponse, this.outputSchema, r.messages),
       sharedResourceAdditions: p(r.messages)
     };
   }
-  async _invokeUnstructured(t, s) {
-    const { createChatModel: e } = await import("../orchestrator/models/chatModel.js"), a = (await m({
-      model: await e({ modelTier: this.modelTier }),
+  async _invokeUnstructured(t, e) {
+    const { createChatModel: s } = await import("../orchestrator/models/chatModel.js"), a = (await d({
+      model: await s({ modelTier: this.modelTier }),
       systemPrompt: await this._getPromptWithInputVariables(t),
-      tools: this._getTools(),
+      tools: await this._getTools(),
       checkpointer: !0,
-      middleware: d(this.middlewares)
-    }).invoke({ messages: t.agentExecutionContext.messages }, s)).messages, n = a.at(-1)?.text ?? "", h = n.trim() || "LLMAgent completed.";
+      middleware: m(this.middlewares)
+    }).invoke({ messages: t.agentExecutionContext.messages }, e)).messages, n = a.at(-1)?.text ?? "", h = n.trim() || "LLMAgent completed.";
     return u(
       {
         agentExecutionContext: { ...t.agentExecutionContext, messages: a },
@@ -78,18 +85,20 @@ class L extends w {
   async _getPromptWithInputVariables(t) {
     return await c.fromTemplate(this.prompt).format(t);
   }
-  _getTools() {
-    return this.tools?.map((t) => "getTool" in t ? t.getTool() : t) ?? [];
+  async _getTools() {
+    return (await Promise.all(
+      (this.tools ?? []).map(async (e) => "getTools" in e ? await e.getTools() : ["getTool" in e ? e.getTool() : e])
+    )).flat();
   }
   //#endregion
 }
 function p(i) {
   const t = [];
-  for (const s of i)
-    if (l.isInstance(s) && s.status !== "error") {
-      const e = s.artifact;
-      if (typeof e == "object" && e !== null && "sharedResourceAdditions" in e) {
-        const o = e.sharedResourceAdditions;
+  for (const e of i)
+    if (l.isInstance(e) && e.status !== "error") {
+      const s = e.artifact;
+      if (typeof s == "object" && s !== null && "sharedResourceAdditions" in s) {
+        const o = s.sharedResourceAdditions;
         if (Array.isArray(o))
           for (const r of o)
             t.push({

package/dist/agent-utils/SkillAgent.js

@@ -1,4 +1,4 @@
-/* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
+/* COPYRIGHT Esri - https://js.arcgis.com/6.0/LICENSE.txt */
 import { BaseAgent as r } from "./BaseAgent.js";
 import { c as a } from "../chunks/createSkillAgent.js";
 class d extends r {

package/dist/agent-utils/WorkflowAgent.js

@@ -1,4 +1,4 @@
-/* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
+/* COPYRIGHT Esri - https://js.arcgis.com/6.0/LICENSE.txt */
 import { BaseAgent as h } from "./BaseAgent.js";
 import { c as n } from "../chunks/graph.js";
 class l extends h {

package/dist/agent-utils/createSchema.js

@@ -1,4 +1,4 @@
-/* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
+/* COPYRIGHT Esri - https://js.arcgis.com/6.0/LICENSE.txt */
 async function c(e) {
   const { createZodObjectSchema: t } = await import("../chunks/schema.js");
   return t(e);

package/dist/agent-utils/middlewares/humanInTheLoop.js

@@ -1,4 +1,4 @@
-/* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
+/* COPYRIGHT Esri - https://js.arcgis.com/6.0/LICENSE.txt */
 import { NodeInterrupt as s } from "@langchain/langgraph/web";
 import { createAgentMiddleware as f, createToolMiddleware as I } from "./middleware.js";
 const m = "human-in-the-loop", w = "Agent execution requires approval", p = "Agent execution rejected by the user.", h = "human-in-the-loop-tool", y = "Tool execution requires approval";

package/dist/agent-utils/middlewares/middleware.js

@@ -1,4 +1,4 @@
-/* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
+/* COPYRIGHT Esri - https://js.arcgis.com/6.0/LICENSE.txt */
 import { createMiddleware as p } from "langchain";
 function g(e, t, r) {
   return {

package/dist/agent-utils/middlewares/trace.js

@@ -1,4 +1,4 @@
-/* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
+/* COPYRIGHT Esri - https://js.arcgis.com/6.0/LICENSE.txt */
 import { sendTraceMessage as n } from "../../orchestrator/signals.js";
 import { AIMessage as i, ToolMessage as c } from "@langchain/core/messages";
 import { createAgentMiddleware as s, createToolMiddleware as d } from "./middleware.js";

package/dist/agent-utils/middlewares/types.js

@@ -1,2 +1,2 @@
-/* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
+/* COPYRIGHT Esri - https://js.arcgis.com/6.0/LICENSE.txt */
 

package/dist/agent-utils/tools/FunctionTool.d.ts

@@ -100,8 +100,19 @@ export class FunctionTool<TInput extends AgentData, TOutput = unknown> {
    * The output schema defines the expected structure of the result returned by the tool.
    * This should be a Zod schema object.
    * The agent will validate the output against this schema after execution.
+   * With `content-and-artifact`, the schema validates the entire tuple, including the artifact.
    */
   outputSchema?: z.ZodType<TOutput>;
+  /**
+   * The format of the tool's response. With `content`, the result is interpreted as message content.
+   * With `content-and-artifact`, execute must return a two-item tuple containing message content
+   * and an artifact. Only the content is sent to the model; the artifact is available to the application.
+   * String results from middleware are treated as content with no artifact.
+   *
+   * @default "content"
+   * @since 5.2
+   */
+  responseFormat: "content-and-artifact" | "content";
   /**
    * The result mode determines how the agent should treat the output of this tool.
    * If set to `terminal`, the agent will
@@ -122,5 +133,5 @@ export interface FunctionToolMiddlewareTool {
   resultMode: ToolResultMode;
 }
 
-export type FunctionToolConstructProperties<TInput extends AgentData, TOutput> = Partial<Pick<FunctionTool<TInput, TOutput>, "inputSchema" | "middlewares" | "outputSchema" | "resultMode">>
+export type FunctionToolConstructProperties<TInput extends AgentData, TOutput> = Partial<Pick<FunctionTool<TInput, TOutput>, "inputSchema" | "middlewares" | "outputSchema" | "responseFormat" | "resultMode">>
   & Pick<FunctionTool<TInput, TOutput>, "description" | "execute" | "name">;

package/dist/agent-utils/tools/FunctionTool.js

@@ -1,9 +1,9 @@
-/* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
-import { tool as n } from "@langchain/core/tools";
-class d {
+/* COPYRIGHT Esri - https://js.arcgis.com/6.0/LICENSE.txt */
+import { tool as c } from "@langchain/core/tools";
+class h {
   //#region Lifecycle
   constructor(t) {
-    this.resultMode = "continue", this.middlewares = [], Object.assign(this, t);
+    this.resultMode = "continue", this.responseFormat = "content", this.middlewares = [], Object.assign(this, t);
   }
   //#endregion
   //#region Public Methods
@@ -11,24 +11,25 @@ class d {
    * Builds the LangChain tool adapter used by LLM agents.
    */
   getTool() {
-    return n(this._executeWithMiddlewares.bind(this), {
+    return c(this._executeWithMiddlewares.bind(this), {
       name: this.name,
       description: this.description,
       returnDirect: this.resultMode === "terminal",
-      schema: this.inputSchema
+      schema: this.inputSchema,
+      responseFormat: this.responseFormat === "content-and-artifact" ? "content_and_artifact" : "content"
     });
   }
   //#endregion
   //#region Private Methods
   async _executeWithMiddlewares(t, e) {
-    const a = async (i) => {
-      const s = await this.execute(i.input, i.config);
-      return this._validateOutput(s);
-    };
-    return await this.middlewares.reduceRight(
-      (i, s) => async (r) => await s.handler(r, i),
+    const a = async (o) => {
+      const i = await this.execute(o.input, o.config);
+      return this._validateOutput(i);
+    }, s = await this.middlewares.reduceRight(
+      (o, i) => async (r) => await i.handler(r, o),
       a
     )({ config: e, input: t, tool: this, toolCallId: l(e) });
+    return this.responseFormat === "content-and-artifact" && typeof s == "string" ? [s, void 0] : s;
   }
   _validateOutput(t) {
     if (!this.outputSchema)
@@ -40,10 +41,10 @@ class d {
   }
   //#endregion
 }
-function l(o) {
-  const t = o?.toolCall;
+function l(n) {
+  const t = n?.toolCall;
   return typeof t?.id == "string" ? t.id : void 0;
 }
 export {
-  d as FunctionTool
+  h as FunctionTool
 };

package/dist/agent-utils/tools/MCPToolProvider.d.ts

@@ -0,0 +1,54 @@
+import type { StructuredToolInterface } from "@langchain/core/tools";
+import type { ToolResultMode } from "./FunctionTool.js";
+
+/** @internal */
+export type MCPToolProviderConstructProperties = Partial<Pick<MCPToolProvider, "allowedTools" | "headers" | "resultModes">>
+  & Pick<MCPToolProvider, "serverUrl">;
+
+/**
+ * Discovers tools hosted by a remote Streamable HTTP MCP server and adapts them for use by LLM agents.
+ *
+ * @internal
+ */
+export class MCPToolProvider {
+  constructor(properties?: MCPToolProviderConstructProperties);
+  /**
+   * Names of the advertised tools to expose. All advertised tools are exposed when this property is undefined.
+   *
+   * @internal
+   */
+  allowedTools?: string[];
+  /**
+   * Request headers sent to the MCP server, for example an authorization header.
+   *
+   * @internal
+   */
+  headers?: Record<string, string>;
+  /**
+   * Result modes keyed by tool name. Tools without an entry default to "continue".
+   * "continue" lets the agent process the result; "terminal" ends the run with the tool result.
+   *
+   * @internal
+   */
+  resultModes?: Partial<Record<string, ToolResultMode>>;
+  /**
+   * Streamable HTTP endpoint for the MCP server.
+   *
+   * @required
+   * @internal
+   */
+  serverUrl: string;
+  /**
+   * Closes the MCP connection when the provider is no longer needed.
+   *
+   * @internal
+   */
+  close(): Promise<void>;
+  destroy(): void;
+  /**
+   * Discovers the tools advertised by the MCP server and builds their LangChain adapters.
+   *
+   * @internal
+   */
+  getTools(): Promise<StructuredToolInterface[]>;
+}

package/dist/agent-utils/tools/MCPToolProvider.js

@@ -0,0 +1,120 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/6.0/LICENSE.txt */
+import { DynamicStructuredTool as a } from "@langchain/core/tools";
+import { Client as c, StreamableHTTPClientTransport as l } from "@modelcontextprotocol/client";
+class u {
+  //#region Lifecycle
+  constructor(t) {
+    Object.assign(this, t);
+  }
+  destroy() {
+    this.close();
+  }
+  //#endregion
+  //#region Public Methods
+  /**
+   * Discovers the tools advertised by the MCP server and builds their LangChain adapters.
+   *
+   * @internal
+   */
+  async getTools() {
+    const t = await this._getClient();
+    try {
+      const e = await this._getToolDefinitions(t), o = this.allowedTools;
+      if (o) {
+        const n = new Set(e.map(({ name: i }) => i)), r = o.filter((i) => !n.has(i));
+        if (r.length > 0)
+          throw new Error(`MCP server did not advertise the following allowed tools: ${r.join(", ")}`);
+      }
+      const s = o ? new Set(o) : void 0;
+      return e.filter(({ name: n }) => !s || s.has(n)).map((n) => this._createTool(n));
+    } finally {
+      await this._closeConnection();
+    }
+  }
+  /**
+   * Closes the MCP connection when the provider is no longer needed.
+   *
+   * @internal
+   */
+  async close() {
+    this._toolDefinitions = void 0, await this._closeConnection();
+  }
+  //#endregion
+  //#region Private Methods
+  _createTool(t) {
+    return new a({
+      description: t.description ?? t.title ?? t.name,
+      func: async (e, o, s) => await this._invoke(t.name, e, s),
+      name: t.name,
+      returnDirect: this.resultModes?.[t.name] === "terminal",
+      schema: t.inputSchema
+    });
+  }
+  async _invoke(t, e, o) {
+    const s = await this._getClient();
+    try {
+      const n = await s.callTool(
+        { arguments: e, name: t },
+        o?.signal ? { requestSignal: o.signal } : void 0
+      );
+      if ("toolResult" in n)
+        return JSON.stringify(n.toolResult);
+      const r = n.content.map((i) => i.type === "text" ? i.text : JSON.stringify(i)).join(`
+`);
+      if (n.isError)
+        throw new Error(r);
+      return r;
+    } finally {
+      await this._closeConnection();
+    }
+  }
+  async _listTools(t) {
+    const e = [];
+    let o;
+    do {
+      const s = await t.listTools(o ? { cursor: o } : void 0);
+      e.push(...s.tools), o = s.nextCursor;
+    } while (o);
+    return e;
+  }
+  async _getToolDefinitions(t) {
+    return this._toolDefinitions ??= this._listTools(t).catch((e) => {
+      throw this._toolDefinitions = void 0, e;
+    }), await this._toolDefinitions;
+  }
+  async _getClient() {
+    if (this._client)
+      return this._client;
+    this._connection ??= this._connect();
+    try {
+      return await this._connection;
+    } catch (t) {
+      throw this._connection = void 0, t;
+    }
+  }
+  async _closeConnection() {
+    const t = this._transport;
+    this._client = void 0, this._connection = void 0, this._transport = void 0, t && await t.close();
+  }
+  async _connect() {
+    const t = new c(
+      { name: "@arcgis/ai-components", version: "5.2" },
+      { versionNegotiation: { mode: "auto" } }
+    ), e = new l(new URL(this.serverUrl), {
+      requestInit: { headers: this.headers }
+    });
+    this._transport = e;
+    try {
+      return await t.connect(e), this._client = t, t;
+    } catch (o) {
+      throw this._transport = void 0, await e.close(), o instanceof TypeError ? new Error(
+        "Could not connect to the MCP server. Check the URL, network connection, and server's CORS settings. See the browser console for details.",
+        { cause: o }
+      ) : o;
+    }
+  }
+  //#endregion
+}
+export {
+  u as MCPToolProvider
+};

package/dist/agent-utils/tools/ToolProvider.d.ts

@@ -0,0 +1,13 @@
+import type { StructuredToolInterface } from "@langchain/core/tools";
+
+/**
+ * Supplies tools owned by an LLM agent. Provider instances must not be shared between agents.
+ *
+ * @since 5.2
+ */
+export interface ToolProvider {
+  /** Resolves the tools available for an agent invocation. */
+  getTools: () => Promise<StructuredToolInterface[]>;
+  /** Releases provider resources when the owning agent is destroyed. */
+  destroy: () => void;
+}

package/dist/agent-utils/tools/WebMCPToolProvider.d.ts

@@ -0,0 +1,37 @@
+import type { StructuredToolInterface } from "@langchain/core/tools";
+import type { ToolResultMode } from "./FunctionTool.js";
+
+/** @internal */
+export type WebMCPToolProviderConstructProperties = Partial<Pick<WebMCPToolProvider, "allowedTools" | "resultModes">>;
+
+/**
+ * Adapts tools exposed to the current document by the experimental WebMCP API for use by LLM agents.
+ * Requires the draft document.modelContext.getTools() and executeTool() APIs in a secure context.
+ * Discovery uses the browser's default same-origin scope; page-owned registrations are never removed.
+ *
+ * @see https://webmachinelearning.github.io/webmcp/#model-context-container
+ * @internal
+ */
+export class WebMCPToolProvider {
+  constructor(properties?: WebMCPToolProviderConstructProperties);
+  /**
+   * Names of tools to expose. All discovered tools are exposed when undefined.
+   *
+   * @internal
+   */
+  allowedTools?: string[];
+  /**
+   * Result modes keyed by tool name. Tools without an entry default to "continue".
+   * "continue" lets the agent process the result; "terminal" ends the run with the tool result.
+   *
+   * @internal
+   */
+  resultModes?: Partial<Record<string, ToolResultMode>>;
+  destroy(): void;
+  /**
+   * Discovers currently available WebMCP tools and builds their LangChain adapters.
+   *
+   * @internal
+   */
+  getTools(): Promise<StructuredToolInterface[]>;
+}

package/dist/agent-utils/tools/WebMCPToolProvider.js

@@ -0,0 +1,71 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/6.0/LICENSE.txt */
+import { DynamicStructuredTool as c } from "@langchain/core/tools";
+function u(n) {
+  return n instanceof Error && /^Failed to parse (?:input|arguments)/u.test(n.message);
+}
+class p {
+  //#region Lifecycle
+  constructor(e) {
+    this._abortController = new AbortController(), Object.assign(this, e);
+  }
+  destroy() {
+    this._abortController.abort();
+  }
+  //#endregion
+  //#region Public Methods
+  /**
+   * Discovers currently available WebMCP tools and builds their LangChain adapters.
+   *
+   * @internal
+   */
+  async getTools() {
+    const e = this._abortController.signal;
+    e.throwIfAborted();
+    const t = typeof document > "u" ? void 0 : document.modelContext;
+    if (typeof t?.getTools != "function" || typeof t.executeTool != "function")
+      throw new Error("WebMCP tools are unavailable because WebMCP is unsupported or disabled on this page.");
+    const s = await t.getTools();
+    if (e.throwIfAborted(), this.allowedTools) {
+      const o = new Set(s.map(({ name: a }) => a)), r = this.allowedTools.filter((a) => !o.has(a));
+      if (r.length > 0)
+        throw new Error(`WebMCP did not expose the following allowed tools: ${r.join(", ")}`);
+    }
+    const l = this.allowedTools ? new Set(this.allowedTools) : void 0;
+    return s.filter(({ name: o }) => !l || l.has(o)).map((o) => this._createTool(o, t));
+  }
+  //#endregion
+  //#region Private Methods
+  _createTool(e, t) {
+    return new c({
+      name: e.name,
+      description: e.description,
+      func: async (s, l, i) => {
+        const o = i?.signal ? AbortSignal.any([this._abortController.signal, i.signal]) : this._abortController.signal;
+        o.throwIfAborted();
+        let r;
+        try {
+          r = await t.executeTool(e, JSON.stringify(s), { signal: o });
+        } catch (a) {
+          if (!u(a) || !s || typeof s != "object")
+            throw a;
+          r = await t.executeTool(e, s, { signal: o });
+        }
+        return typeof r == "string" ? r : JSON.stringify(r) ?? String(r);
+      },
+      returnDirect: this.resultModes?.[e.name] === "terminal",
+      schema: this._parseInputSchema(e)
+    });
+  }
+  _parseInputSchema(e) {
+    if (!e.inputSchema)
+      return { properties: {}, type: "object" };
+    let t = e.inputSchema;
+    if (typeof t == "string" && (t = JSON.parse(t)), typeof t != "object" || t === null || Array.isArray(t))
+      throw new TypeError(`WebMCP tool "${e.name}" has an invalid input schema.`);
+    return t;
+  }
+  //#endregion
+}
+export {
+  p as WebMCPToolProvider
+};

package/dist/agent-utils/workflows/ConditionalWorkflow.js

@@ -1,4 +1,4 @@
-/* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
+/* COPYRIGHT Esri - https://js.arcgis.com/6.0/LICENSE.txt */
 import { B as l, g as r } from "../../chunks/BaseWorkflow.js";
 class g extends l {
   //#region Lifecycle

package/dist/agent-utils/workflows/LoopWorkflow.js

@@ -1,4 +1,4 @@
-/* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
+/* COPYRIGHT Esri - https://js.arcgis.com/6.0/LICENSE.txt */
 import { c as d } from "../../chunks/graph.js";
 import { B as l } from "../../chunks/BaseWorkflow.js";
 class m extends l {

package/dist/agent-utils/workflows/ParallelWorkflow.js

@@ -1,4 +1,4 @@
-/* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
+/* COPYRIGHT Esri - https://js.arcgis.com/6.0/LICENSE.txt */
 import { c as M } from "../../chunks/graph.js";
 import { a as R } from "../../chunks/state.js";
 import { B as k, c as P, g as m, a as F } from "../../chunks/BaseWorkflow.js";

package/dist/agent-utils/workflows/RouterWorkflow.js

@@ -1,4 +1,4 @@
-/* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
+/* COPYRIGHT Esri - https://js.arcgis.com/6.0/LICENSE.txt */
 import { B as u, g as n } from "../../chunks/BaseWorkflow.js";
 class g extends u {
   //#region Lifecycle

package/dist/agent-utils/workflows/SequentialWorkflow.js

@@ -1,4 +1,4 @@
-/* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
+/* COPYRIGHT Esri - https://js.arcgis.com/6.0/LICENSE.txt */
 import { B as u, g as s, a as l } from "../../chunks/BaseWorkflow.js";
 class m extends u {
   //#region Lifecycle