@arcgis/ai-components 5.2.0-next.5 → 5.2.0-next.51

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

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

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

@@ -3,13 +3,43 @@ import type { BaseChannel, BinaryOperatorAggregate } from "@langchain/langgraph/
 import type { AnnotationRoot, StateDefinitionInit, StateGraph } from "@langchain/langgraph/web";
 import type { AgentExecutionContext, AgentRegistration, AgentStatus } from "../utils/index.js";
 
-/** @internal */
 export type AgentData = Record<string, unknown>;
 
-/** @internal */
 export type EmptyAgentData = Record<never, never>;
 
-/** @privateRemark All ADK agents are orchestrator-driven, so these channels exist for every agent graph. */
+/** @internal */
+export type ZodModule = {
+  z: typeof z;
+};
+
+export type SchemaPrimitiveFieldType = "boolean" | "number" | "string";
+
+export type SchemaArrayItemDefinition = SchemaFieldDefinition | SchemaPrimitiveFieldType;
+
+export type SchemaFieldDefinition = ({
+    type: "array";
+    itemType: SchemaArrayItemDefinition;
+} | { type: "boolean" | "number"; } | {
+    type: "object";
+    fields: SchemaDefinition;
+} | {
+    type: "string";
+    enum?: readonly string[];
+}) & {
+  description?: string;
+  required?: boolean;
+};
+
+export type SchemaDefinition = Record<string, SchemaFieldDefinition>;
+
+export type SchemaDefinitionData<TDefinition extends SchemaDefinition> = {
+    [K in keyof TDefinition as TDefinition[K] extends { required: true; } ? K : never]: SchemaFieldData<TDefinition[K]>;
+} &
+  {
+    [K in keyof TDefinition as TDefinition[K] extends { required: true; } ? never : K]?: SchemaFieldData<TDefinition[K]>;
+};
+
+/** @privateRemark All agents are orchestrator-driven, so these channels exist for every agent graph. */
 export type AgentRuntimeState = {
   agentExecutionContext: AgentExecutionContext;
   /** The outputMessage is a string representing the output of an agent execution. */
@@ -101,7 +131,6 @@ export type AgentNodeUpdate<TInput extends AgentData, TOutput extends AgentData>
  * AgentStateAnnotation defines the shape of the agent state used in LangGraph nodes, including both the built-in runtime channels
  * and any custom fields defined by the agent.
  *
- * @internal
  * @since 5.1
  */
 export type AgentStateAnnotation<TState extends AgentData> = AnnotationRoot<{
@@ -123,7 +152,6 @@ export type RunnableUpdate<TState extends AgentData> = Partial<TState> extends o
 /**
  * Internal type representing the compiled graph used for agent execution.
  *
- * @internal
  * @since 5.1
  */
 export type TypedStateGraph<TState extends AgentData> = StateGraph<StateDefinitionInit, AgentGraphState<TState>, RunnableUpdate<AgentGraphState<TState>>, string>;
@@ -132,7 +160,6 @@ export type TypedStateGraph<TState extends AgentData> = StateGraph<StateDefiniti
  * The shape of the `createGraph` function used by agents to generate their internal graph representation.
  * This function is responsible for defining the nodes and edges of the graph, as well as any associated state and middleware.
  *
- * @internal
  * @since 5.1
  */
 export type AgentCreateGraph<TState extends AgentData> = () => TypedStateGraph<TState>;
@@ -149,4 +176,6 @@ export type GraphEdge<S extends AgentData> = {
 } | {
     from: string;
     to: string;
-};
+};
+
+export type SchemaFieldData<TField extends SchemaFieldDefinition> = TField extends { type: "string"; } ? TField["enum"] extends readonly (infer TValue extends string)[] ? TValue : string : TField extends { type: "array"; } ? (TField["itemType"] extends "string" ? string : TField["itemType"] extends "number" ? number : TField["itemType"] extends "boolean" ? boolean : TField["itemType"] extends SchemaFieldDefinition ? SchemaFieldData<TField["itemType"]> : never)[] : TField extends { type: "object"; } ? SchemaDefinitionData<TField["fields"]> : TField extends { type: "number"; } ? number : boolean;

package/dist/agent-utils/workflows/ConditionalWorkflow.d.ts

@@ -26,7 +26,7 @@ export type ConditionDecider<TState extends AgentData = AgentData> = (state: Age
  * @since 5.1
  */
 export class ConditionalWorkflow<TState extends AgentData = AgentData> extends BaseWorkflow<TState> {
-  constructor(properties: ConstructProperties<TState>);
+  constructor(properties: ConditionalWorkflowConstructProperties<TState>);
   /**
    * Must contain exactly two agents: `[trueAgent, falseAgent]`. The first agent is executed when
    * the condition is true, the second when the condition is false.
@@ -69,4 +69,4 @@ export class ConditionalWorkflow<TState extends AgentData = AgentData> extends B
   protected validateAgents(agents: BaseAgentLike<TState>[]): void;
 }
 
-export type ConstructProperties<TState extends AgentData> = Pick<ConditionalWorkflow<TState>, "agents" | "condition">;
+export type ConditionalWorkflowConstructProperties<TState extends AgentData> = Pick<ConditionalWorkflow<TState>, "agents" | "condition">;

package/dist/agent-utils/workflows/LoopWorkflow.d.ts

@@ -26,7 +26,7 @@ export type LoopDecider<TState extends AgentData = AgentData> = (state: AgentGra
  * @since 5.1
  */
 export class LoopWorkflow<TState extends AgentData = AgentData> extends BaseWorkflow<TState> {
-  constructor(properties: ConstructProperties<TState>);
+  constructor(properties: LoopWorkflowConstructProperties<TState>);
   /**
    * Function that decides whether the loop should continue.
    *
@@ -55,4 +55,4 @@ export class LoopWorkflow<TState extends AgentData = AgentData> extends BaseWork
   protected isTerminalAgent(): boolean;
 }
 
-export type ConstructProperties<TState extends AgentData> = Pick<LoopWorkflow<TState>, "decideContinue" | "workflow">;
+export type LoopWorkflowConstructProperties<TState extends AgentData> = Pick<LoopWorkflow<TState>, "decideContinue" | "workflow">;

package/dist/agent-utils/workflows/ParallelWorkflow.d.ts

@@ -20,7 +20,7 @@ import type { BaseWorkflow, WorkflowGenerateResult } from "./BaseWorkflow.js";
  * @since 5.1
  */
 export class ParallelWorkflow<TState extends AgentData = AgentData> extends BaseWorkflow<TState> {
-  constructor(properties: ConstructProperties<TState>);
+  constructor(properties: ParallelWorkflowConstructProperties<TState>);
   /**
    * Agents to run in parallel from the same input snapshot.
    *
@@ -65,4 +65,4 @@ export class ParallelWorkflow<TState extends AgentData = AgentData> extends Base
   protected isTerminalAgent(_agents: BaseAgentLike<TState>[], _index: number): boolean;
 }
 
-export type ConstructProperties<TState extends AgentData> = Pick<ParallelWorkflow<TState>, "agents">;
+export type ParallelWorkflowConstructProperties<TState extends AgentData> = Pick<ParallelWorkflow<TState>, "agents">;

package/dist/agent-utils/workflows/RouterWorkflow.d.ts

@@ -16,7 +16,7 @@ import type { BaseWorkflow } from "./BaseWorkflow.js";
  * @since 5.1
  */
 export class RouterWorkflow<TState extends AgentData = AgentData> extends BaseWorkflow<TState> {
-  constructor(properties: ConstructProperties<TState>);
+  constructor(properties: RouterWorkflowConstructProperties<TState>);
   /**
    * Mapping of route keys to destination agents.
    *
@@ -60,4 +60,4 @@ export class RouterWorkflow<TState extends AgentData = AgentData> extends BaseWo
   protected validateAgents(agents: BaseAgentLike<TState>[]): void;
 }
 
-export type ConstructProperties<TState extends AgentData> = Pick<RouterWorkflow<TState>, "agentsMap" | "routerAgent" | "routerOutputKey">;
+export type RouterWorkflowConstructProperties<TState extends AgentData> = Pick<RouterWorkflow<TState>, "agentsMap" | "routerAgent" | "routerOutputKey">;