@arcgis/ai-components 5.1.0-next.98 → 5.1.0

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.1/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/humanInTheLoop.d.ts

@@ -0,0 +1,152 @@
+import type { FunctionToolMiddleware, FunctionToolMiddlewareRequest } from "../tools/FunctionTool.js";
+import type { AgentData, AgentExecutionConfig, AgentGraphState } from "../types.js";
+import type { AgentMiddleware, AgentRunRequest } from "./types.js";
+import type { UiInterrupt } from "../../utils/index.js";
+
+/** @since 5.1 */
+export interface HumanInTheLoopInterruptRequest<TCustomState extends AgentData = AgentData> extends AgentRunRequest<TCustomState> {
+  /**
+   * The ID of the agent requesting human intervention. This can be used to correlate the
+   * interrupt with a specific agent, especially in cases where
+   * multiple agents may be running concurrently and using the same middleware.
+   *
+   * @since 5.1
+   */
+  agentId: string;
+}
+
+/** @since 5.1 */
+export type HumanInTheLoopInterrupt = Partial<UiInterrupt>;
+
+/**
+ * Options for configuring the HumanInTheLoopMiddleware.
+ *
+ * @since 5.1
+ */
+export interface HumanInTheLoopMiddlewareOptions<TCustomState extends AgentData = AgentData> {
+  /**
+   * An optional function that generates a custom interrupt object based on the agent run request. This allows for dynamic messages and
+   * metadata to be included in the interrupt, providing context to the user when prompting for input or approval.
+   *
+   * If not provided, a default interrupt with a generic approval message will be used.
+   *
+   * @param request - The agent run request that triggered the interrupt, containing details about the agent, node, and execution context.
+   * @returns An object containing the interrupt details, which will be thrown as a NodeInterrupt to pause the agent's execution.
+   * @since 5.1
+   */
+  interrupt?(request: HumanInTheLoopInterruptRequest<TCustomState>): HumanInTheLoopInterrupt | Promise<HumanInTheLoopInterrupt>;
+  /**
+   * An optional key in the agent state where the human response should be stored.
+   *
+   * @since 5.1
+   */
+  outputKey?: keyof AgentGraphState<TCustomState>;
+}
+
+/** @since 5.1 */
+export interface HumanInTheLoopToolMessageRequest<TInput extends AgentData = AgentData> extends FunctionToolMiddlewareRequest<TInput> {
+  /**
+   * The arguments passed to the tool that is requesting human intervention.
+   *
+   * @since 5.1
+   */
+  args: object;
+  /**
+   * The id of the tool call that is requesting human intervention.
+   *
+   * @since 5.1
+   */
+  toolCallId?: string;
+  /**
+   * The name of the tool that is requesting human intervention.
+   *
+   * @since 5.1
+   */
+  toolName: string;
+}
+
+/**
+ * This middleware is designed to allow for human intervention during agent execution by throwing an interrupt that can be handled by the orchestrator to pause the agent and
+ * prompt the user for input or approval.
+ *
+ * @since 5.1
+ */
+export interface HumanInTheLoopToolMiddlewareOptions<TInput extends AgentData = AgentData> {
+  /**
+   * An optional function that generates a custom interrupt object based on the tool middleware request. This allows for dynamic messages and
+   * metadata to be included in the interrupt, providing context to the user when prompting for input or approval at the tool execution level.
+   *
+   * @param request - The tool middleware request that triggered the interrupt, containing details about the tool, input arguments, and execution context.
+   * @since 5.1
+   * @return An object containing the interrupt details, which will be thrown as a NodeInterrupt to pause the tool's execution.
+   */
+  interrupt?(request: HumanInTheLoopToolMessageRequest<TInput>): HumanInTheLoopInterrupt | Promise<HumanInTheLoopInterrupt>;
+  /**
+   * An optional key in the tool input where the human response should be stored.
+   *
+   * @since 5.1
+   */
+  outputKey?: keyof TInput;
+}
+
+/**
+ * This middleware allows for human intervention during agent execution by throwing an interrupt
+ * to pause the agent and prompt the user for input or approval prior to proceeding. It can be used
+ * to implement a human-in-the-loop workflow, where certain decisions or actions require human approval before proceeding.
+ *
+ * The interrupt includes customizable messages and metadata to provide context to the user.
+ *
+ * @param options - Configuration options for the middleware, including the interrupt handler and optional output key for storing the human response in
+ * the agent state.
+ * @returns An agent middleware that can be added to an agent's middleware stack.
+ * @since 5.1
+ * @example
+ * ```ts
+ * const agent = new WorkflowAgent({
+ *   workflow: myWorkflow,
+ *   middlewares: [
+ *     createHumanInTheLoopMiddleware({
+ *       interrupt: async ({ agentId }) => ({
+ *         message: `Agent ${agentId} is requesting approval to continue. Do you approve?`,
+ *       }),
+ *     }),
+ *   ],
+ * });
+ * ```
+ */
+export function createHumanInTheLoopMiddleware<TCustomState extends AgentData = AgentData>(options?: HumanInTheLoopMiddlewareOptions<TCustomState>): AgentMiddleware<TCustomState>;
+
+/**
+ * This middleware is designed to wrap tool calls within an agent, allowing for human intervention at the tool execution level. When a tool wrapped with this middleware is invoked,
+ * it will throw an interrupt similar to the agent-level middleware, prompting the user for input or approval before the tool executes.
+ *
+ * @param options - Configuration options for the middleware, including the interrupt handler and optional output key for storing the human response in the tool input.
+ * @returns A function tool middleware that can be added to a tool's middleware stack.
+ * @since 5.1
+ * @example
+ * ```ts
+ * const myTool = new FunctionTool({
+ *   name: "sensitiveOperation",
+ *   execute: async (input) => {
+ *     // perform sensitive operation
+ *   },
+ *   middlewares: [
+ *     createHumanInTheLoopToolMiddleware({
+ *       interrupt: async ({ toolName, args }) => ({
+ *         message: `Tool ${toolName} is requesting approval to execute with arguments: ${JSON.stringify(args)}. Do you approve?`,
+ *       }),
+ *     }),
+ *   ],
+ * });
+ * ```
+ */
+export function createHumanInTheLoopToolMiddleware<TInput extends AgentData = AgentData, TOutput = unknown>(options?: HumanInTheLoopToolMiddlewareOptions<TInput>): FunctionToolMiddleware<TInput, TOutput>;
+
+/**
+ * This function retrieves the human-in-the-loop (HITL) response payload from the agent execution configuration.
+ *
+ * @param config - The agent execution configuration that may contain a HITL response.
+ * @returns The payload from the HITL response if available; otherwise, undefined.
+ * @since 5.1
+ */
+export function getHumanInTheLoopPayload<TPayload = unknown>(config: AgentExecutionConfig | undefined): TPayload | undefined;

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

@@ -0,0 +1,94 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.1/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";
+function k(t = {}) {
+  const { outputKey: n } = t;
+  return f(
+    m,
+    {
+      wrapAgent: async (e, r) => {
+        const a = T(e), o = M(a, e), i = u(e.config?.configurable);
+        if (i?.agentId !== a)
+          throw new s(await g({ agentId: a, interruptId: o, options: t, request: e }));
+        if (i.id !== o) {
+          if (b(a, i.id))
+            return await r(e);
+          throw new s(await g({ agentId: a, interruptId: o, options: t, request: e }));
+        }
+        if (i.payload === !1)
+          return { outputMessage: p, status: "failed", summary: p };
+        const l = n ? { ...e.state, [n]: i.payload } : e.state, d = { ...e, state: l };
+        return await r(d);
+      }
+    },
+    { outputKey: n }
+  );
+}
+function v(t = {}) {
+  const { outputKey: n } = t;
+  return I(h, {
+    wrapToolCall: async (e, r) => {
+      const a = e.tool.name, o = A(e.config?.configurable), i = R(o, e.toolCallId ?? a), l = u(e.config?.configurable);
+      if (l?.agentId !== o || l.id !== i)
+        throw new s(await $({ agentId: o, interruptId: i, options: t, request: e }));
+      if (l.payload === !1)
+        return `Tool call "${a}" was rejected by the user.`;
+      const d = n ? { ...e.input, [n]: l.payload } : e.input, c = { ...e, input: d };
+      return await r(c);
+    }
+  });
+}
+async function g(t) {
+  const { agentId: n, interruptId: e, options: r, request: a } = t, o = await r.interrupt?.({ ...a, agentId: n });
+  return {
+    agentId: n,
+    id: e,
+    kind: o?.kind ?? "booleanChoice",
+    message: o?.message ?? w,
+    metadata: o?.metadata
+  };
+}
+function T(t) {
+  return typeof t.config?.configurable?.agentId == "string" ? t.config.configurable.agentId : t.agent.id;
+}
+function M(t, n) {
+  const e = n.config?.configurable?.thread_id, r = typeof e == "string" && e ? `${e}:` : "";
+  return `${t}:${r}${n.nodeName}`;
+}
+function b(t, n) {
+  return n.startsWith(`${t}:tool:`);
+}
+function A(t) {
+  return typeof t?.agentId == "string" ? t.agentId : "llm-agent";
+}
+function R(t, n) {
+  return `${t}:tool:${n}`;
+}
+async function $(t) {
+  const { agentId: n, interruptId: e, options: r, request: a } = t, { input: o, tool: i, toolCallId: l } = a, d = i.name, c = await r.interrupt?.({ ...a, args: o, toolName: d, toolCallId: l });
+  return {
+    agentId: n,
+    id: e,
+    kind: c?.kind ?? "booleanChoice",
+    message: c?.message ?? `${y}
+Tool: ${d}`,
+    metadata: c?.metadata ?? {
+      args: o,
+      toolCallId: l,
+      toolName: d
+    }
+  };
+}
+function H(t) {
+  return u(t?.configurable)?.payload;
+}
+function u(t) {
+  const n = t?.hitlResponse;
+  return n && typeof n == "object" && "id" in n && "agentId" in n ? n : null;
+}
+export {
+  k as createHumanInTheLoopMiddleware,
+  v as createHumanInTheLoopToolMiddleware,
+  H as getHumanInTheLoopPayload
+};

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

@@ -0,0 +1,25 @@
+import type { FunctionToolMiddleware } from "../tools/FunctionTool.js";
+import type { AgentData, AgentGraphState, EmptyAgentData } from "../types.js";
+import type { AgentMiddleware, AgentMiddlewareHooks, ToolMiddlewareHooks } from "./types.js";
+
+/**
+ * Creates an agent middleware with the specified hooks and options.
+ *
+ * @param name - The name of the middleware.
+ * @param hooks - The hooks to be used in the middleware.
+ * @param options - Optional configuration for the middleware, such as the output key.
+ * @returns The created agent middleware.
+ * @since 5.1
+ */
+export function createAgentMiddleware<TCustomState extends AgentData = EmptyAgentData>(name: string, hooks: AgentMiddlewareHooks<TCustomState>, options?: { outputKey?: keyof AgentGraphState<TCustomState>; }): AgentMiddleware<TCustomState>;
+
+/**
+ * Creates a tool middleware with the specified hooks and options.
+ *
+ * @param name - The name of the middleware.
+ * @param hooks - The hooks to be used in the middleware.
+ * @param options - Optional configuration for the middleware, such as the output key.
+ * @returns The created function tool middleware.
+ * @since 5.1
+ */
+export function createToolMiddleware<TInput extends AgentData = AgentData, TOutput = unknown>(name: string, hooks: ToolMiddlewareHooks<TInput, TOutput>, options?: { outputKey?: string; }): FunctionToolMiddleware<TInput, TOutput>;

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

@@ -0,0 +1,44 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.1/LICENSE.txt */
+import { createMiddleware as p } from "langchain";
+function g(e, t, r) {
+  return {
+    name: e,
+    handler: async (a, n) => {
+      const c = async (l) => {
+        const d = await t.beforeAgent?.(l), u = d ? {
+          ...l,
+          state: {
+            ...l.state,
+            ...d
+          }
+        } : l, i = await n(u), w = await t.afterAgent?.({ ...u, result: i });
+        return w ? { ...i, ...w } : i;
+      };
+      return t.wrapAgent ? await t.wrapAgent(a, c) : await c(a);
+    },
+    hooks: t,
+    outputKey: r?.outputKey
+  };
+}
+function y(e, t, r) {
+  return { name: e, handler: async (a, n) => t.wrapToolCall ? await t.wrapToolCall(a, n) : await n(a), outputKey: r?.outputKey };
+}
+function C(e) {
+  return e.map((t) => f(t.name, t.hooks ?? {})).filter((t) => !!t);
+}
+function f(e, t) {
+  const { afterModel: r, beforeModel: o, wrapModelCall: a, wrapToolCall: n } = t;
+  if (!(!r && !o && !a && !n))
+    return p({
+      afterModel: r,
+      beforeModel: o,
+      name: e,
+      wrapModelCall: a,
+      wrapToolCall: n
+    });
+}
+export {
+  C as convertToLangChainMiddlewares,
+  g as createAgentMiddleware,
+  y as createToolMiddleware
+};

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

@@ -0,0 +1,27 @@
+import type { FunctionToolMiddleware } from "../tools/FunctionTool.js";
+import type { AgentMiddleware } from "./types.js";
+import type { AgentData } from "../types.js";
+
+/**
+ * This middleware is responsible for sending trace messages whenever the agent makes a call to the language model or executes a tool.
+ *
+ * It uses the `sendTraceMessage` function from the orchestrator to send messages that include
+ * details about the model calls and tool
+ * 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;
+
+/**
+ * This middleware is responsible for sending trace messages whenever a tool is executed by the agent. It wraps tool calls and uses the `sendTraceMessage`
+ * function from the orchestrator to send messages that include details about the tool execution, such as the tool name and its result. This can be useful for
+ * 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>;