@arcgis/ai-components 5.2.0-next.3 → 5.2.0-next.30

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

@@ -9,7 +9,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
@@ -61,5 +61,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

@@ -2,6 +2,7 @@
 import "@arcgis/core/identity/IdentityManager.js";
 import "@arcgis/core/portal/Portal.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";
@@ -16,10 +17,10 @@ import { convertToLangChainMiddlewares as l } from "./middlewares/middleware.js"
 import { c as y } from "../chunks/graph.js";
 import { c as T } from "../chunks/state.js";
 import { c as d, h as M, g as x } from "../chunks/utils.js";
-var P = Object.defineProperty, b = Object.getOwnPropertyDescriptor, n = (t, s, r, e) => {
-  for (var o = e > 1 ? void 0 : e ? b(s, r) : s, p = t.length - 1, i; p >= 0; p--)
-    (i = t[p]) && (o = (e ? i(s, r, o) : i(o)) || o);
-  return e && o && P(s, r, o), o;
+var P = Object.defineProperty, b = Object.getOwnPropertyDescriptor, n = (t, r, s, e) => {
+  for (var o = e > 1 ? void 0 : e ? b(r, s) : r, p = t.length - 1, i; p >= 0; p--)
+    (i = t[p]) && (o = (e ? i(r, s, o) : i(o)) || o);
+  return e && o && P(r, s, o), o;
 };
 let a = class extends v {
   //#region Lifecycle
@@ -53,52 +54,52 @@ let a = class extends v {
   generate() {
     const t = T(this.getSchemas());
     this._set("workspace", t);
-    const s = this.id, r = { [s]: this._invoke.bind(this) }, e = [{ from: s, decide: () => {
+    const r = this.id, s = { [r]: this._invoke.bind(this) }, e = [{ from: r, decide: () => {
     } }];
     this._set(
       "createGraph",
-      () => y(r, e, t, {
+      () => y(s, e, t, {
         agent: this,
-        entryNode: s,
+        entryNode: r,
         middlewares: this.middlewares
       })
     );
   }
   //#endregion
   //#region Private Methods
-  async _invoke(t, s) {
+  async _invoke(t, r) {
     try {
-      return this.outputSchema ? await this._invokeStructured(t, s) : await this._invokeUnstructured(t, s);
-    } catch (r) {
-      if (f(r))
-        throw r;
-      const e = r instanceof Error ? r.message : String(r);
+      return this.outputSchema ? await this._invokeStructured(t, r) : await this._invokeUnstructured(t, r);
+    } catch (s) {
+      if (f(s))
+        throw s;
+      const e = s instanceof Error ? s.message : String(s);
       return d({ outputMessage: e }, "failed", e);
     }
   }
-  async _invokeStructured(t, s) {
+  async _invokeStructured(t, r) {
     if (!this.outputSchema)
       throw new Error("Output schema is required for structured invocation.");
     const e = await h({
-      model: await u(this.modelTier),
+      model: await u({ modelTier: this.modelTier }),
       systemPrompt: await this._getPromptWithInputVariables(t),
       tools: this._getTools(),
       checkpointer: !0,
       middleware: l(this.middlewares),
       responseFormat: this.outputSchema
-    }).invoke({ messages: t.agentExecutionContext.messages }, s);
+    }).invoke({ messages: t.agentExecutionContext.messages }, r);
     if (!("structuredResponse" in e) || e.structuredResponse === void 0)
       throw new Error("LLMAgent did not receive structured output from createAgent.");
     return M(e.structuredResponse, this.outputSchema, e.messages);
   }
-  async _invokeUnstructured(t, s) {
+  async _invokeUnstructured(t, r) {
     const o = (await h({
-      model: await u(this.modelTier),
+      model: await u({ modelTier: this.modelTier }),
       systemPrompt: await this._getPromptWithInputVariables(t),
       tools: this._getTools(),
       checkpointer: !0,
       middleware: l(this.middlewares)
-    }).invoke({ messages: t.agentExecutionContext.messages }, s)).messages, i = o.at(-1)?.content ?? "", c = typeof i == "string" ? i : JSON.stringify(i), g = c.trim() || "LLMAgent completed.";
+    }).invoke({ messages: t.agentExecutionContext.messages }, r)).messages, i = o.at(-1)?.content ?? "", c = typeof i == "string" ? i : JSON.stringify(i), g = c.trim() || "LLMAgent completed.";
     return d(
       { agentExecutionContext: { ...t.agentExecutionContext, messages: o }, outputMessage: c },
       "success",
@@ -106,10 +107,10 @@ let a = class extends v {
     );
   }
   async _getPromptWithInputVariables(t) {
-    const s = x(t, this.inputSchema);
+    const r = x(t, this.inputSchema);
     for (const { outputKey: e } of this.middlewares)
-      e && (s[String(e)] = t[e]);
-    return await S.fromTemplate(this.prompt).format(s);
+      e && (r[String(e)] = t[e]);
+    return await S.fromTemplate(this.prompt).format(r);
   }
   _getTools() {
     return this.tools?.map((t) => t.getTool()) ?? [];

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/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">;