@arcgis/ai-components 5.2.0-next.9 → 5.2.0-next.91

package/LICENSE.md

@@ -1,12 +1,14 @@
 # Licensing
 
-COPYRIGHT © Esri
+COPYRIGHT Esri
 
 All rights reserved under the copyright laws of the United States and applicable international laws, treaties, and conventions.
 
-This material is licensed for use under the [Esri Master License Agreement (MLA)](https://www.esri.com/content/dam/esrisites/en-us/media/legal/ma-full/ma-full.pdf), and is bound by the terms of that agreement.
+This material is licensed for use under the Esri Master License Agreement (MLA), and is bound by the terms of that agreement.
 You may redistribute and use this code without modification, provided you adhere to the terms of the MLA and include this copyright notice.
 
+See use restrictions at https://www.esri.com/content/dam/esrisites/en-us/media/legal/ma-full/ma-full.pdf.
+
 For additional information, contact:
 Environmental Systems Research Institute, Inc.
 Attn: Contracts and Legal Services Department

package/README.md

@@ -6,5 +6,5 @@ The ArcGIS Maps SDK for JavaScript provides a suite of ready-to-use UI component
 
 ## License
 
-This package is licensed under the terms described in the `LICENSE.md` file, located in the root of the package, and at https://js.arcgis.com/5.1/LICENSE.txt.
-For third party notices, see https://js.arcgis.com/5.1/third-party-notices.txt.
+This package is licensed under the terms described in the `LICENSE.md` file, located in the root of the package, and at https://js.arcgis.com/5.2/LICENSE.txt.
+For third party notices, see https://js.arcgis.com/5.2/third-party-notices.txt.

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

@@ -18,7 +18,7 @@ export type FunctionAgentExecute<TInput extends AgentData, TOutput extends Agent
  * @since 5.1
  */
 export class FunctionAgent<TInput extends AgentData = AgentData, TOutput extends AgentData = AgentData> extends BaseAgent<AgentCustomState<TInput, TOutput>> {
-  constructor(properties?: ConstructProperties<TInput, TOutput>);
+  constructor(properties?: FunctionAgentConstructProperties<TInput, TOutput>);
   /**
    * The execute function contains the core logic of the FunctionAgent.
    * It receives the current agent state and an optional execution configuration,
@@ -60,5 +60,5 @@ export class FunctionAgent<TInput extends AgentData = AgentData, TOutput extends
   initialize(): void;
 }
 
-export type ConstructProperties<TInput extends AgentData, TOutput extends AgentData> = Partial<Pick<FunctionAgent<TInput, TOutput>, "description" | "inputSchema" | "middlewares" | "outputSchema">>
+export type FunctionAgentConstructProperties<TInput extends AgentData, TOutput extends AgentData> = Partial<Pick<FunctionAgent<TInput, TOutput>, "description" | "inputSchema" | "middlewares" | "outputSchema">>
   & Pick<FunctionAgent<TInput, TOutput>, "execute" | "name">;

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

@@ -1,7 +1,10 @@
+import type { StructuredToolInterface } from "@langchain/core/tools";
 import type { BaseAgent } from "./BaseAgent.js";
 import type { FunctionToolLike } from "./tools/FunctionTool.js";
 import type { AgentCustomState, AgentData, ZodObjectSchema } from "./types.js";
 
+export type LLMAgentTool = FunctionToolLike | StructuredToolInterface;
+
 /**
  * LLMAgent uses a language model to generate its output based on a provided prompt template and optional tools.
  * It supports structured input and output through Zod schemas, allowing for validation and type safety. The agent's logic is defined by the prompt and the tools it has access to, making it a flexible option for a wide range of use cases.
@@ -9,7 +12,7 @@ import type { AgentCustomState, AgentData, ZodObjectSchema } from "./types.js";
  * @since 5.1
  */
 export class LLMAgent<TInput extends AgentData = AgentData, TOutput extends AgentData = AgentData> extends BaseAgent<AgentCustomState<TInput, TOutput>> {
-  constructor(properties?: ConstructProperties<TInput, TOutput>);
+  constructor(properties?: LLMAgentConstructProperties<TInput, TOutput>);
   /**
    * The inputSchema property is an optional Zod schema describing the expected structured input for the agent.
    * This can be used for validation of the input state before execution and also to extract variables from the input
@@ -39,8 +42,8 @@ export class LLMAgent<TInput extends AgentData = AgentData, TOutput extends Agen
    * @required
    */
   accessor prompt: string;
-  /** The tools property is an optional array of FunctionTools that the agent can use during execution. */
-  accessor tools: FunctionToolLike[] | undefined;
+  /** The tools property is an optional array of tools that the agent can use during execution. */
+  accessor tools: LLMAgentTool[] | undefined;
   /**
    * Rebuilds internal workspace and createGraph wiring. This is automatically called during initialization and whenever
    * the name or description properties change, but can also be called manually if needed to refresh the agent's graph definition.
@@ -61,5 +64,5 @@ export class LLMAgent<TInput extends AgentData = AgentData, TOutput extends Agen
   initialize(): void;
 }
 
-export type ConstructProperties<TInput extends AgentData, TOutput extends AgentData> = Partial<Pick<LLMAgent<TInput, TOutput>, "description" | "inputSchema" | "middlewares" | "modelTier" | "outputSchema" | "tools">>
+export type LLMAgentConstructProperties<TInput extends AgentData, TOutput extends AgentData> = Partial<Pick<LLMAgent<TInput, TOutput>, "description" | "inputSchema" | "middlewares" | "modelTier" | "outputSchema" | "tools">>
   & Pick<LLMAgent<TInput, TOutput>, "name" | "prompt">;

package/dist/agent-utils/LLMAgent.js

@@ -1,13 +1,15 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
 import "@arcgis/core/identity/IdentityManager.js";
 import "@arcgis/core/portal/Portal.js";
+import "@arcgis/core/request.js";
 import { isGraphInterrupt as f } from "@langchain/langgraph/web";
+import "@arcgis/toolkit/string";
 import { c as u } from "../chunks/generateLayerDescriptions.js";
 import "@langchain/core/messages";
 import "@langchain/core/callbacks/dispatch/web";
+import "@langchain/core/callbacks/base";
 import { watch as w } from "@arcgis/core/core/reactiveUtils.js";
 import "@arcgis/core/layers/FeatureLayer.js";
-import "@arcgis/core/request.js";
 import { ChatPromptTemplate as S } from "@langchain/core/prompts";
 import { property as m, subclass as _ } from "@arcgis/core/core/accessorSupport/decorators.js";
 import { createAgent as h } from "langchain";
@@ -112,7 +114,7 @@ let a = class extends v {
     return await S.fromTemplate(this.prompt).format(r);
   }
   _getTools() {
-    return this.tools?.map((t) => t.getTool()) ?? [];
+    return this.tools?.map((t) => "getTool" in t ? t.getTool() : t) ?? [];
   }
   //#endregion
 };

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

@@ -9,7 +9,7 @@ import type { AgentData, ZodObjectSchema } from "./types.js";
  * @since 5.1
  */
 export class WorkflowAgent<TState extends AgentData = AgentData> extends BaseAgent<TState> {
-  constructor(properties: ConstructProperties<TState>);
+  constructor(properties: WorkflowAgentConstructProperties<TState>);
   /** Optional structured input schema for the workflow wrapper. */
   accessor inputSchema: ZodObjectSchema<object> | undefined;
   /** Optional structured output schema for the workflow wrapper. */
@@ -40,5 +40,5 @@ export class WorkflowAgent<TState extends AgentData = AgentData> extends BaseAge
   initialize(): void;
 }
 
-export type ConstructProperties<TState extends AgentData = AgentData> = Partial<Pick<WorkflowAgent<TState>, "description" | "inputSchema" | "middlewares" | "outputSchema">>
+export type WorkflowAgentConstructProperties<TState extends AgentData = AgentData> = Partial<Pick<WorkflowAgent<TState>, "description" | "inputSchema" | "middlewares" | "outputSchema">>
   & Pick<WorkflowAgent<TState>, "name" | "workflow">;

package/dist/agent-utils/WorkflowAgent.js

@@ -3,13 +3,12 @@ import { property as h, subclass as c } from "@arcgis/core/core/accessorSupport/
 import { watch as l } from "@arcgis/core/core/reactiveUtils.js";
 import { BaseAgent as m } from "./BaseAgent.js";
 import { c as u } from "../chunks/graph.js";
-import "../chunks/BaseWorkflow.js";
-var f = Object.defineProperty, w = Object.getOwnPropertyDescriptor, n = (e, r, s, o) => {
-  for (var t = o > 1 ? void 0 : o ? w(r, s) : r, i = e.length - 1, a; i >= 0; i--)
-    (a = e[i]) && (t = (o ? a(r, s, t) : a(t)) || t);
+var f = Object.defineProperty, w = Object.getOwnPropertyDescriptor, p = (e, r, s, o) => {
+  for (var t = o > 1 ? void 0 : o ? w(r, s) : r, a = e.length - 1, i; a >= 0; a--)
+    (i = e[a]) && (t = (o ? i(r, s, t) : i(t)) || t);
   return o && t && f(r, s, t), t;
 };
-let p = class extends m {
+let n = class extends m {
   //#region Lifecycle
   constructor(e) {
     super(e);
@@ -38,7 +37,7 @@ let p = class extends m {
       this._set("createGraph", r);
     else {
       const s = this.id, o = {
-        [s]: async (i, a) => await r().compile().invoke(i, a)
+        [s]: async (a, i) => await r().compile().invoke(a, i)
       }, t = [{ from: s, decide: () => {
       } }];
       this._set(
@@ -53,18 +52,18 @@ let p = class extends m {
   }
   //#endregion
 };
-n([
+p([
   h()
-], p.prototype, "workflow", 2);
-n([
+], n.prototype, "workflow", 2);
+p([
   h()
-], p.prototype, "inputSchema", 2);
-n([
+], n.prototype, "inputSchema", 2);
+p([
   h()
-], p.prototype, "outputSchema", 2);
-p = n([
+], n.prototype, "outputSchema", 2);
+n = p([
   c("WorkflowAgent")
-], p);
+], n);
 export {
-  p as WorkflowAgent
+  n as WorkflowAgent
 };

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

@@ -0,0 +1,177 @@
+import type { FunctionAgent, FunctionAgentConstructProperties } from "./FunctionAgent.js";
+import type { LLMAgent, LLMAgentConstructProperties } from "./LLMAgent.js";
+import type { WorkflowAgent, WorkflowAgentConstructProperties } from "./WorkflowAgent.js";
+import type { AgentData, SchemaDefinition, SchemaDefinitionData, ZodObjectSchema } from "./types.js";
+import type { FunctionTool, FunctionToolConstructProperties } from "./tools/FunctionTool.js";
+import type { ConditionalWorkflow, ConditionalWorkflowConstructProperties } from "./workflows/ConditionalWorkflow.js";
+import type { LoopWorkflow, LoopWorkflowConstructProperties } from "./workflows/LoopWorkflow.js";
+import type { ParallelWorkflow, ParallelWorkflowConstructProperties } from "./workflows/ParallelWorkflow.js";
+import type { RouterWorkflow, RouterWorkflowConstructProperties } from "./workflows/RouterWorkflow.js";
+import type { SequentialWorkflow, SequentialWorkflowConstructProperties } from "./workflows/SequentialWorkflow.js";
+import type { SwitchWorkflow, SwitchWorkflowConstructProperties } from "./workflows/SwitchWorkflow.js";
+import type { RunnableConfig } from "@langchain/core/runnables";
+
+/**
+ * Creates a Zod schema from a plain object schema definition.
+ *
+ * Supports all schema field variants:
+ * - `string` (with optional `enum`)
+ * - `number`
+ * - `boolean`
+ * - `array` with primitive or nested item definitions
+ * - `object` with nested `fields`
+ *
+ * @param definition
+ * @example
+ * ```ts
+ * const primitiveSchema = await createSchema({
+ *   name: { type: "string", description: "Search location name", required: true },
+ *   radius: { type: "number", description: "Search radius in miles" },
+ *   active: { type: "boolean", description: "Whether the search is enabled" },
+ * });
+ * ```
+ * @example
+ * ```ts
+ * const nestedObjectSchema = await createSchema({
+ *   query: { type: "string", description: "User search text", required: true },
+ *   options: {
+ *     type: "object",
+ *     description: "Search options",
+ *     required: true,
+ *     fields: {
+ *       center: {
+ *         type: "object",
+ *         description: "Map center point",
+ *         fields: {
+ *           latitude: { type: "number", description: "Center latitude", required: true },
+ *           longitude: { type: "number", description: "Center longitude", required: true },
+ *         },
+ *       },
+ *       categories: { type: "array", description: "Selected categories", itemType: "string" },
+ *     },
+ *   },
+ * });
+ * ```
+ * @example
+ * ```ts
+ * const arrayOfObjectsSchema = await createSchema({
+ *   constraints: {
+ *     type: "array",
+ *     description: "Constraint rules",
+ *     itemType: {
+ *       type: "object",
+ *       description: "Single constraint rule",
+ *       fields: {
+ *         key: { type: "string", description: "Constraint key", required: true },
+ *         enabled: { type: "boolean", description: "Whether this rule is active" },
+ *         values: { type: "array", description: "Rule values", itemType: "string" },
+ *       },
+ *     },
+ *   },
+ * });
+ * ```
+ * @since 5.1
+ */
+export function createSchema<const TDefinition extends SchemaDefinition>(definition: TDefinition): Promise<ZodObjectSchema<SchemaDefinitionData<TDefinition>>>;
+
+/**
+ * The suggestions emitted by the agent to the user interface.
+ *
+ * @since 5.1
+ */
+export type UXSuggestion = {
+  /** The type of suggestion being made. */
+  type: string;
+  /** Optional additional data associated with the suggestion. */
+  data?: Record<string, unknown>;
+};
+
+/**
+ * Sends an optional UX suggestion from an agent run to the host application.
+ * Use this for non-blocking hints (for example, recommended next actions or UI prompts) that the app may choose to display.
+ *
+ * @param suggestion
+ * @param config
+ * @since 5.1
+ */
+export function sendUXSuggestion(suggestion: UXSuggestion, config?: RunnableConfig): Promise<void>;
+
+/**
+ * Creates a FunctionAgent instance from the existing agent implementation.
+ *
+ * @param properties
+ * @since 5.1
+ */
+export function createFunctionAgent<TInput extends AgentData = AgentData, TOutput extends AgentData = AgentData>(properties: FunctionAgentConstructProperties<TInput, TOutput>): Promise<FunctionAgent<TInput, TOutput>>;
+
+/**
+ * Creates a FunctionTool instance from the existing tool implementation.
+ *
+ * @param properties
+ * @since 5.1
+ */
+export function createFunctionTool<TInput extends AgentData, TOutput = unknown>(properties: FunctionToolConstructProperties<TInput, TOutput>): Promise<FunctionTool<TInput, TOutput>>;
+
+/**
+ * Creates an LLMAgent instance from the existing agent implementation.
+ *
+ * @param properties
+ * @since 5.1
+ */
+export function createLLMAgent<TInput extends AgentData = AgentData, TOutput extends AgentData = AgentData>(properties: LLMAgentConstructProperties<TInput, TOutput>): Promise<LLMAgent<TInput, TOutput>>;
+
+/**
+ * Creates a WorkflowAgent instance from the existing workflow agent implementation.
+ *
+ * @param properties
+ * @since 5.1
+ */
+export function createWorkflowAgent<TState extends AgentData = AgentData>(properties: WorkflowAgentConstructProperties<TState>): Promise<WorkflowAgent<TState>>;
+
+/**
+ * Creates a ConditionalWorkflow instance from the existing workflow implementation.
+ *
+ * @param properties
+ * @since 5.1
+ */
+export function createConditionalWorkflow<TState extends AgentData = AgentData>(properties: ConditionalWorkflowConstructProperties<TState>): Promise<ConditionalWorkflow<TState>>;
+
+/**
+ * Creates a LoopWorkflow instance from the existing workflow implementation.
+ *
+ * @param properties
+ * @since 5.1
+ */
+export function createLoopWorkflow<TState extends AgentData = AgentData>(properties: LoopWorkflowConstructProperties<TState>): Promise<LoopWorkflow<TState>>;
+
+/**
+ * Creates a ParallelWorkflow instance from the existing workflow implementation.
+ *
+ * @param properties
+ * @since 5.1
+ */
+export function createParallelWorkflow<TState extends AgentData = AgentData>(properties: ParallelWorkflowConstructProperties<TState>): Promise<ParallelWorkflow<TState>>;
+
+/**
+ * Creates a RouterWorkflow instance from the existing workflow implementation.
+ *
+ * @param properties
+ * @since 5.1
+ */
+export function createRouterWorkflow<TState extends AgentData = AgentData>(properties: RouterWorkflowConstructProperties<TState>): Promise<RouterWorkflow<TState>>;
+
+/**
+ * Creates a SequentialWorkflow instance from the existing workflow implementation.
+ *
+ * @param properties
+ * @since 5.1
+ */
+export function createSequentialWorkflow<TState extends AgentData = AgentData>(properties: SequentialWorkflowConstructProperties<TState>): Promise<SequentialWorkflow<TState>>;
+
+/**
+ * Creates a SwitchWorkflow instance from the existing workflow implementation.
+ *
+ * @param properties
+ * @since 5.1
+ */
+export function createSwitchWorkflow<TState extends AgentData = AgentData>(properties: SwitchWorkflowConstructProperties<TState>): Promise<SwitchWorkflow<TState>>;

package/dist/agent-utils/index.js

@@ -0,0 +1,167 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
+let i, a, c, u, l, s, w, m, f, p, d, g;
+async function n(e, t) {
+  if (t in e)
+    return e[t];
+  if ("default" in e) {
+    const o = await e.default;
+    return typeof o == "object" && o !== null && t in o ? o[t] : o;
+  }
+  throw new Error(`Unable to resolve ${String(t)} from module.`);
+}
+function y(e, t) {
+  const o = {};
+  for (const [r, k] of Object.entries(t))
+    o[r] = S(e, k);
+  return o;
+}
+function W(e, t) {
+  return e.object(y(e, t));
+}
+function S(e, t) {
+  const o = h(e, t);
+  return t.required === !0 ? o : o.optional();
+}
+function h(e, t) {
+  let o = P(e, t);
+  return t.description !== void 0 && (o = o.describe(t.description)), o;
+}
+function b(e, t) {
+  switch (t) {
+    case "string":
+      return e.string();
+    case "number":
+      return e.number();
+    case "boolean":
+      return e.boolean();
+  }
+}
+function M(e) {
+  return e === "string" || e === "number" || e === "boolean";
+}
+function P(e, t) {
+  switch (t.type) {
+    case "string": {
+      if (t.enum != null) {
+        if (t.enum.length === 0)
+          throw new Error("String schema field enum must include at least one value.");
+        return e.enum(t.enum);
+      }
+      return e.string();
+    }
+    case "number":
+      return e.number();
+    case "boolean":
+      return e.boolean();
+    case "array": {
+      if (t.itemType == null)
+        throw new Error("Array schema field requires an itemType definition.");
+      return e.array(
+        M(t.itemType) ? b(e, t.itemType) : h(e, t.itemType)
+      );
+    }
+    case "object": {
+      if (t.fields == null)
+        throw new Error("Object schema field requires a fields definition.");
+      return W(e, t.fields);
+    }
+  }
+}
+async function A(e) {
+  d ??= import("zod");
+  const t = await d;
+  return W(t.z, e);
+}
+async function T(e, t) {
+  g ??= import("../utils/index.js");
+  const o = await g;
+  return await (await n(
+    o,
+    "sendUXSuggestion"
+  ))(e, t);
+}
+async function L(e) {
+  i ??= import("./FunctionAgent.js");
+  const t = await i, o = await n(
+    t,
+    "FunctionAgent"
+  );
+  return new o(e);
+}
+async function q(e) {
+  a ??= import("./tools/FunctionTool.js");
+  const t = await a, o = await n(
+    t,
+    "FunctionTool"
+  );
+  return new o(e);
+}
+async function F(e) {
+  c ??= import("./LLMAgent.js");
+  const t = await c, o = await n(t, "LLMAgent");
+  return new o(e);
+}
+async function j(e) {
+  u ??= import("./WorkflowAgent.js");
+  const t = await u, o = await n(
+    t,
+    "WorkflowAgent"
+  );
+  return new o(e);
+}
+async function E(e) {
+  l ??= import("./workflows/ConditionalWorkflow.js");
+  const t = await l, o = await n(t, "ConditionalWorkflow");
+  return new o(e);
+}
+async function v(e) {
+  s ??= import("./workflows/LoopWorkflow.js");
+  const t = await s, o = await n(
+    t,
+    "LoopWorkflow"
+  );
+  return new o(e);
+}
+async function U(e) {
+  w ??= import("./workflows/ParallelWorkflow.js");
+  const t = await w, o = await n(
+    t,
+    "ParallelWorkflow"
+  );
+  return new o(e);
+}
+async function R(e) {
+  m ??= import("./workflows/RouterWorkflow.js");
+  const t = await m, o = await n(
+    t,
+    "RouterWorkflow"
+  );
+  return new o(e);
+}
+async function X(e) {
+  f ??= import("./workflows/SequentialWorkflow.js");
+  const t = await f, o = await n(t, "SequentialWorkflow");
+  return new o(e);
+}
+async function x(e) {
+  p ??= import("./workflows/SwitchWorkflow.js");
+  const t = await p, o = await n(
+    t,
+    "SwitchWorkflow"
+  );
+  return new o(e);
+}
+export {
+  E as createConditionalWorkflow,
+  L as createFunctionAgent,
+  q as createFunctionTool,
+  F as createLLMAgent,
+  v as createLoopWorkflow,
+  U as createParallelWorkflow,
+  R as createRouterWorkflow,
+  A as createSchema,
+  X as createSequentialWorkflow,
+  x as createSwitchWorkflow,
+  j as createWorkflowAgent,
+  T as sendUXSuggestion
+};

package/dist/agent-utils/middlewares/trace.d.ts

@@ -10,6 +10,7 @@ import type { AgentData } from "../types.js";
  * executions, which can be useful for debugging and monitoring the agent's behavior.
  *
  * @returns An agent middleware that wraps model calls and sends trace messages.
+ * @internal
  * @since 5.1
  */
 export function createAgentTraceMiddleware(): AgentMiddleware;
@@ -20,6 +21,7 @@ export function createAgentTraceMiddleware(): AgentMiddleware;
  * debugging and monitoring the behavior of tools within the agent's execution.
  *
  * @returns A function tool middleware that wraps tool calls and sends trace messages.
+ * @internal
  * @since 5.1
  */
 export function createToolTraceMiddleware<TInput extends AgentData = AgentData, TOutput = unknown>(): FunctionToolMiddleware<TInput, TOutput>;

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

@@ -1,50 +1,42 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
-import "@arcgis/core/identity/IdentityManager.js";
-import "@arcgis/core/portal/Portal.js";
-import "@langchain/langgraph/web";
-import { s as n } from "../../chunks/generateLayerDescriptions.js";
-import { AIMessage as l, ToolMessage as s } from "@langchain/core/messages";
-import "@langchain/openai";
-import "@arcgis/core/core/reactiveUtils.js";
-import "@arcgis/core/layers/FeatureLayer.js";
-import "@arcgis/core/request.js";
-import "@langchain/core/prompts";
-import { createAgentMiddleware as c, createToolMiddleware as m } from "./middleware.js";
-const d = "agent-trace", g = "tool-trace";
-function $() {
-  return c(d, {
-    wrapModelCall: async (t, o) => {
-      const e = await o(t), a = t.runtime, i = p(e);
+import { s as r } from "../../chunks/index.js";
+import { AIMessage as i, ToolMessage as s } from "@langchain/core/messages";
+import { createAgentMiddleware as c, createToolMiddleware as d } from "./middleware.js";
+const g = "agent-trace", f = "tool-trace";
+function p() {
+  return c(g, {
+    wrapModelCall: async (e, a) => {
+      const t = await a(e), o = e.runtime, l = m(t);
       return await Promise.all(
-        i.map(
-          async (r) => await n(
+        l.map(
+          async (n) => await r(
             {
-              text: `LLM requested tool call "${r.name}" with arguments: ${JSON.stringify(r.args, null, 2)}`
+              text: `LLM requested tool call "${n.name}" with arguments: ${JSON.stringify(n.args, null, 2)}`
             },
-            a
+            o
           )
         )
-      ), e;
+      ), t;
     }
   });
 }
-function h() {
-  return m(g, {
-    wrapToolCall: async (t, o) => {
-      const e = await o(t), a = t.config;
-      return await n(
+function T() {
+  return d(f, {
+    wrapToolCall: async (e, a) => {
+      const t = await a(e), o = e.config;
+      return await r(
         {
-          text: `Finished executing tool: ${s.isInstance(e) ? e.content.toString() : typeof e == "string" ? e : t.tool.name}`
+          text: `Finished executing tool: ${s.isInstance(t) ? t.content.toString() : typeof t == "string" ? t : e.tool.name}`
         },
-        a
-      ), e;
+        o
+      ), t;
     }
   });
 }
-function p(t) {
-  return !l.isInstance(t) || !Array.isArray(t.tool_calls) ? [] : t.tool_calls.filter((o) => typeof o?.name == "string");
+function m(e) {
+  return !i.isInstance(e) || !Array.isArray(e.tool_calls) ? [] : e.tool_calls.filter((a) => typeof a?.name == "string");
 }
 export {
-  $ as createAgentTraceMiddleware,
-  h as createToolTraceMiddleware
+  p as createAgentTraceMiddleware,
+  T as createToolTraceMiddleware
 };

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

@@ -59,7 +59,7 @@ export interface FunctionToolLike {
  * @since 5.1
  */
 export class FunctionTool<TInput extends AgentData, TOutput = unknown> extends Accessor {
-  constructor(properties?: ConstructProperties<TInput, TOutput>);
+  constructor(properties?: FunctionToolConstructProperties<TInput, TOutput>);
   /**
    * A concise, but clear description of the tool's functionality.
    * This should provide enough information for the agent to understand when and why to use the tool.
@@ -123,5 +123,5 @@ export interface FunctionToolMiddlewareTool {
   resultMode: ToolResultMode;
 }
 
-export type ConstructProperties<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" | "resultMode">>
   & Pick<FunctionTool<TInput, TOutput>, "description" | "execute" | "name">;