@arcgis/ai-components 5.2.0-next.99 → 6.0.0-next.1

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

@@ -1,16 +1,9 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
-import c from "@arcgis/core/core/Accessor.js";
-import { property as a, subclass as p } from "@arcgis/core/core/accessorSupport/decorators.js";
-import { tool as d } from "@langchain/core/tools";
-var h = Object.defineProperty, m = Object.getOwnPropertyDescriptor, s = (o, t, n, u) => {
-  for (var e = u > 1 ? void 0 : u ? m(t, n) : t, i = o.length - 1, l; i >= 0; i--)
-    (l = o[i]) && (e = (u ? l(t, n, e) : l(e)) || e);
-  return u && e && h(t, n, e), e;
-};
-let r = class extends c {
+import { tool as c } from "@langchain/core/tools";
+class h {
   //#region Lifecycle
-  constructor(o) {
-    super(o), this.resultMode = "continue", this.middlewares = [];
+  constructor(t) {
+    this.resultMode = "continue", this.responseFormat = "content", this.middlewares = [], Object.assign(this, t);
   }
   //#endregion
   //#region Public Methods
@@ -18,63 +11,40 @@ let r = class extends c {
    * Builds the LangChain tool adapter used by LLM agents.
    */
   getTool() {
-    return d(this._executeWithMiddlewares.bind(this), {
+    return c(this._executeWithMiddlewares.bind(this), {
       name: this.name,
       description: this.description,
       returnDirect: this.resultMode === "terminal",
-      schema: this.inputSchema
+      schema: this.inputSchema,
+      responseFormat: this.responseFormat === "content-and-artifact" ? "content_and_artifact" : "content"
     });
   }
   //#endregion
   //#region Private Methods
-  async _executeWithMiddlewares(o, t) {
-    const n = async (e) => {
-      const i = await this.execute(e.input, e.config);
+  async _executeWithMiddlewares(t, e) {
+    const a = async (o) => {
+      const i = await this.execute(o.input, o.config);
       return this._validateOutput(i);
-    };
-    return await this.middlewares.reduceRight(
-      (e, i) => async (l) => await i.handler(l, e),
-      n
-    )({ config: t, input: o, tool: this, toolCallId: f(t) });
+    }, s = await this.middlewares.reduceRight(
+      (o, i) => async (r) => await i.handler(r, o),
+      a
+    )({ config: e, input: t, tool: this, toolCallId: l(e) });
+    return this.responseFormat === "content-and-artifact" && typeof s == "string" ? [s, void 0] : s;
   }
-  _validateOutput(o) {
+  _validateOutput(t) {
     if (!this.outputSchema)
-      return o;
-    const t = this.outputSchema.safeParse(o);
-    if (!t.success)
-      throw new Error(`FunctionTool output schema validation failed: ${t.error.message}`);
-    return t.data;
+      return t;
+    const e = this.outputSchema.safeParse(t);
+    if (!e.success)
+      throw new Error(`FunctionTool output schema validation failed: ${e.error.message}`);
+    return e.data;
   }
   //#endregion
-};
-s([
-  a()
-], r.prototype, "name", 2);
-s([
-  a()
-], r.prototype, "description", 2);
-s([
-  a()
-], r.prototype, "resultMode", 2);
-s([
-  a()
-], r.prototype, "inputSchema", 2);
-s([
-  a()
-], r.prototype, "outputSchema", 2);
-s([
-  a()
-], r.prototype, "middlewares", 2);
-s([
-  a()
-], r.prototype, "execute", 2);
-r = s([
-  p("FunctionTool")
-], r);
-function f(o) {
-  const t = o?.toolCall;
+}
+function l(n) {
+  const t = n?.toolCall;
   return typeof t?.id == "string" ? t.id : void 0;
 }
 export {
-  r as FunctionTool
+  h as FunctionTool
 };

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

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

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

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

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

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

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

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

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

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

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

@@ -1,42 +1,26 @@
 import type z from "zod";
 import type { BaseChannel, BinaryOperatorAggregate } from "@langchain/langgraph/channels";
 import type { AnnotationRoot, StateDefinitionInit, StateGraph } from "@langchain/langgraph/web";
-import type { AgentExecutionContext, AgentRegistration, AgentStatus } from "../utils/index.js";
+import type { AgentExecutionContext, AgentRegistration, AgentStatus, AssistantInputPart } from "../orchestrator/types.js";
+import type { SharedResourceInput } from "../orchestrator/state/types.js";
 
 export type AgentData = Record<string, unknown>;
 
 export type EmptyAgentData = Record<never, never>;
 
-/** @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[];
-}) & {
+export type SchemaFieldDefinition = {
   description?: string;
-  required?: boolean;
+  enum?: readonly string[];
+  items?: SchemaFieldDefinition;
+  properties?: Readonly<Record<string, SchemaFieldDefinition>>;
+  required?: readonly string[];
+  type: "array" | "boolean" | "number" | "object" | "string";
 };
 
-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]>;
+export type SchemaDefinition = {
+  properties: Readonly<Record<string, SchemaFieldDefinition>>;
+  required?: readonly string[];
+  type: "object";
 };
 
 /** @privateRemark All agents are orchestrator-driven, so these channels exist for every agent graph. */
@@ -48,14 +32,15 @@ export type AgentRuntimeState = {
   summary: string;
   /** The status field represents the current status of the agent execution, which can be used to indicate success, failure, or other relevant states. */
   status?: AgentStatus;
+  sharedResourceAdditions?: readonly SharedResourceInput[];
 };
 
-export type AgentGraphState<TState extends AgentData = EmptyAgentData> = AgentRuntimeState
+export type AgentGraphState<TState extends AgentData = EmptyAgentData> = InternalAgentRuntimeState
   & Omit<TState, keyof AgentRuntimeState>;
 
 export interface BaseAgentLike<TCustomState extends AgentData = EmptyAgentData> {
   /**
-   * Stable ID derived from the agent name and used for graph node and registration identity.
+   * Stable ID provided by the user or derived from the agent name, used for graph node and registration identity.
    *
    * @since 5.1
    */
@@ -84,10 +69,12 @@ export interface BaseAgentLike<TCustomState extends AgentData = EmptyAgentData>
    * @since 5.1
    */
   registration: AgentRegistration;
-  /** Regenerates workspace and graph wiring for this agent. */
+  /**
+   * Regenerates workspace and graph wiring for this agent.
+   *
+   * @since 5.2
+   */
   generate: () => void;
-  /** Returns all schemas the agent contributes to state/input/output validation. */
-  getSchemas: () => ZodObjectSchema<object>[];
   /**
    * Executes the compiled graph for this agent.
    *
@@ -140,6 +127,7 @@ export type AgentStateAnnotation<TState extends AgentData> = AnnotationRoot<{
     outputMessage: BaseChannel<string, unknown, unknown>;
     summary: BaseChannel<string, unknown, unknown>;
     status: BaseChannel<AgentStatus | undefined, unknown, unknown>;
+    sharedResourceAdditions: BaseChannel<readonly SharedResourceInput[] | undefined, unknown, unknown>;
 }>;
 
 /**
@@ -178,4 +166,12 @@ export type GraphEdge<S extends AgentData> = {
     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;
+export type InternalAgentRuntimeState = Omit<AgentRuntimeState, "agentExecutionContext">
+  & {
+  agentExecutionContext: InternalAgentExecutionContext;
+};
+
+export type InternalAgentExecutionContext = AgentExecutionContext
+  & {
+  inputParts?: readonly AssistantInputPart[];
+};

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

@@ -1,5 +1,4 @@
-import type Accessor from "@arcgis/core/core/Accessor.js";
-import type { AgentCreateGraph, AgentData, AgentGraphState, AgentStateAnnotation, BaseAgentLike, GraphEdge, GraphNodes } from "../types.js";
+import type { AgentCreateGraph, AgentData, AgentGraphState, AgentStateAnnotation, BaseAgentLike, GraphEdge, GraphNodes, ZodObjectSchema } from "../types.js";
 
 /**
  * Return payload from `BaseWorkflow.generate()`.
@@ -41,7 +40,7 @@ export type WorkflowGenerateResult<TState extends AgentData = AgentData> = {
  *
  * @since 5.1
  */
-export abstract class BaseWorkflow<TState extends AgentData = AgentData> extends Accessor {
+export abstract class BaseWorkflow<TState extends AgentData = AgentData> {
   /**
    * Builds the workflow-specific edges.
    *
@@ -58,11 +57,11 @@ export abstract class BaseWorkflow<TState extends AgentData = AgentData> extends
    */
   protected buildNodes(agents: BaseAgentLike<TState>[]): GraphNodes<AgentGraphState<TState>>;
   /**
-   * Generates the workflow's graph and shared workspace based on the defined agents and their schemas. This method is
-   * called by the WorkflowAgent when it generates its graph, and it orchestrates the creation of the workflow's structure,
-   * including validating the agents, deriving shared state from their schemas, and building the nodes and edges of the graph.
+   * Generates the workflow's graph and shared workspace based on its agents and optional boundary schemas.
+   *
+   * @param parameter0
    */
-  generate(): WorkflowGenerateResult<TState>;
+  generate(parameter0?: { additionalSchemas?: readonly (ZodObjectSchema<object> | undefined)[]; }): WorkflowGenerateResult<TState>;
   /** A list of agents that are part of this workflow. */
   abstract getAgents(): BaseAgentLike<TState>[];
   /**

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

@@ -33,13 +33,13 @@ export class ConditionalWorkflow<TState extends AgentData = AgentData> extends B
    *
    * @required
    */
-  accessor agents: BaseAgentLike<TState>[];
+  agents: BaseAgentLike<TState>[];
   /**
    * Predicate that chooses the next branch.
    *
    * @required
    */
-  accessor condition: ConditionDecider<TState>;
+  condition: ConditionDecider<TState>;
   /**
    * Builds the workflow-specific edges.
    *

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

@@ -1,15 +1,9 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
-import { property as u, subclass as f } from "@arcgis/core/core/accessorSupport/decorators.js";
-import { B as p, g as c } from "../../chunks/BaseWorkflow.js";
-var g = Object.defineProperty, w = Object.getOwnPropertyDescriptor, a = (e, r, n, t) => {
-  for (var o = t > 1 ? void 0 : t ? w(r, n) : r, i = e.length - 1, s; i >= 0; i--)
-    (s = e[i]) && (o = (t ? s(r, n, o) : s(o)) || o);
-  return t && o && g(r, n, o), o;
-};
-let l = class extends p {
+import { B as l, g as r } from "../../chunks/BaseWorkflow.js";
+class g extends l {
   //#region Lifecycle
   constructor(e) {
-    super(e);
+    super(), Object.assign(this, e);
   }
   //#endregion
   //#region Public Methods
@@ -19,23 +13,23 @@ let l = class extends p {
   //#endregion
   //#region Protected Methods
   buildNodes(e) {
-    const r = super.buildNodes(e);
-    return r[d] = () => ({}), r;
+    const t = super.buildNodes(e);
+    return t[o] = () => ({}), t;
   }
   buildEdges(e) {
-    const r = this.condition;
-    if (!r)
+    const t = this.condition;
+    if (!t)
       throw new Error("ConditionalWorkflow requires a condition.");
-    const n = c(e[0], 0), t = c(e[1], 1);
+    const n = r(e[0], 0), i = r(e[1], 1);
     return [
       {
-        from: d,
-        decide: async (o, i) => await Promise.resolve(r(o, i)) ? n : t
+        from: o,
+        decide: async (s, d) => await Promise.resolve(t(s, d)) ? n : i
       }
     ];
   }
   getEntryNode() {
-    return d;
+    return o;
   }
   isTerminalAgent() {
     return !0;
@@ -45,17 +39,8 @@ let l = class extends p {
       throw new Error(`ConditionalWorkflow requires exactly 2 agents; received ${e.length}.`);
   }
   //#endregion
-};
-a([
-  u()
-], l.prototype, "condition", 2);
-a([
-  u()
-], l.prototype, "agents", 2);
-l = a([
-  f("ConditionalWorkflow")
-], l);
-const d = "__conditional_decide";
+}
+const o = "__conditional_decide";
 export {
-  l as ConditionalWorkflow
+  g as ConditionalWorkflow
 };

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

@@ -32,20 +32,16 @@ export class LoopWorkflow<TState extends AgentData = AgentData> extends BaseWork
    *
    * @required
    */
-  accessor decideContinue: LoopDecider<TState>;
+  decideContinue: LoopDecider<TState>;
   /**
    * Inner workflow to execute on each loop iteration.
    *
    * @required
    */
-  accessor workflow: BaseWorkflow<TState>;
+  workflow: BaseWorkflow<TState>;
   /** Builds the workflow-specific edges. */
   protected buildEdges(): GraphEdge<AgentGraphState<TState>>[];
-  /**
-   * Generates the workflow's graph and shared workspace based on the defined agents and their schemas. This method is
-   * called by the WorkflowAgent when it generates its graph, and it orchestrates the creation of the workflow's structure,
-   * including validating the agents, deriving shared state from their schemas, and building the nodes and edges of the graph.
-   */
+  /** Generates the workflow's graph and shared workspace based on its agents and optional boundary schemas. */
   generate(): WorkflowGenerateResult<TState>;
   /** A list of agents that are part of this workflow. */
   getAgents(): BaseAgentLike<TState>[];