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

package/dist/agent-utils/LLMAgent.js

@@ -1,141 +1,115 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
-import "@arcgis/core/identity/IdentityManager.js";
-import "@arcgis/core/portal/Portal.js";
-import "@arcgis/core/request.js";
-import { isGraphInterrupt as f } from "@langchain/langgraph/web";
-import "@arcgis/toolkit/string";
-import { c as u } from "../chunks/generateLayerDescriptions.js";
-import "@langchain/core/messages";
-import "@langchain/core/callbacks/dispatch/web";
-import "@langchain/core/callbacks/base";
-import { watch as w } from "@arcgis/core/core/reactiveUtils.js";
-import "@arcgis/core/layers/FeatureLayer.js";
-import { ChatPromptTemplate as S } from "@langchain/core/prompts";
-import { property as m, subclass as _ } from "@arcgis/core/core/accessorSupport/decorators.js";
-import { createAgent as h } from "langchain";
-import { BaseAgent as v } from "./BaseAgent.js";
-import { convertToLangChainMiddlewares as l } from "./middlewares/middleware.js";
+import { ChatPromptTemplate as c } from "@langchain/core/prompts";
+import { ToolMessage as l } from "@langchain/core/messages";
+import { isGraphInterrupt as g } from "@langchain/langgraph/web";
+import { createAgent as d, providerStrategy as f } from "langchain";
+import { BaseAgent as w } from "./BaseAgent.js";
+import { convertToLangChainMiddlewares as m } 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, 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 {
+import { c as u, h as A } from "../chunks/utils.js";
+class L extends w {
   //#region Lifecycle
   constructor(t) {
-    super(t), this.modelTier = "default";
+    super(), this.middlewares = [], this.modelTier = "default", this._destroyed = !1, Object.assign(this, t), this.generate();
   }
-  initialize() {
-    this.addHandles(
-      w(
-        () => [
-          this.description,
-          this.inputSchema,
-          this.modelTier,
-          this.name,
-          this.outputSchema,
-          this.prompt,
-          this.tools
-        ],
-        () => {
-          this.generate();
-        },
-        { initial: !0, sync: !0 }
-      )
-    );
+  destroy() {
+    if (!this._destroyed) {
+      this._destroyed = !0;
+      for (const t of new Set(this.tools))
+        "getTools" in t && t.destroy();
+    }
   }
   //#endregion
   //#region Public Methods
-  getSchemas() {
-    return [this.inputSchema, this.outputSchema].filter(Boolean);
-  }
   generate() {
-    const t = T(this.getSchemas());
-    this._set("workspace", t);
-    const r = this.id, s = { [r]: this._invoke.bind(this) }, e = [{ from: r, decide: () => {
+    const t = this.prompt ? c.fromTemplate(this.prompt).inputVariables : [], e = T(
+      [this.inputSchema, this.outputSchema].filter(Boolean),
+      t
+    ), s = this.id, o = { [s]: this._invoke.bind(this) }, r = [{ from: s, decide: () => {
     } }];
-    this._set(
-      "createGraph",
-      () => y(s, e, t, {
-        agent: this,
-        entryNode: r,
-        middlewares: this.middlewares
-      })
-    );
+    this.workspace = e, this.createGraph = () => y(o, r, e, {
+      agent: this,
+      entryNode: s,
+      middlewares: this.middlewares
+    });
   }
   //#endregion
   //#region Private Methods
-  async _invoke(t, r) {
+  async _invoke(t, e) {
     try {
-      return this.outputSchema ? await this._invokeStructured(t, r) : await this._invokeUnstructured(t, r);
+      return this.outputSchema ? await this._invokeStructured(t, e) : await this._invokeUnstructured(t, e);
     } catch (s) {
-      if (f(s))
+      if (g(s) || e?.signal?.aborted || s instanceof Error && s.name === "AbortError")
         throw s;
-      const e = s instanceof Error ? s.message : String(s);
-      return d({ outputMessage: e }, "failed", e);
+      const o = s instanceof Error ? s.message : String(s);
+      return u({ outputMessage: o }, "failed", o);
     }
   }
-  async _invokeStructured(t, r) {
+  async _invokeStructured(t, e) {
     if (!this.outputSchema)
       throw new Error("Output schema is required for structured invocation.");
-    const e = await h({
-      model: await u({ modelTier: this.modelTier }),
+    const { createChatModel: s } = await import("../orchestrator/models/chatModel.js"), r = await d({
+      model: await s({ modelTier: this.modelTier }),
       systemPrompt: await this._getPromptWithInputVariables(t),
-      tools: this._getTools(),
+      tools: await this._getTools(),
       checkpointer: !0,
-      middleware: l(this.middlewares),
-      responseFormat: this.outputSchema
-    }).invoke({ messages: t.agentExecutionContext.messages }, r);
-    if (!("structuredResponse" in e) || e.structuredResponse === void 0)
+      middleware: m(this.middlewares),
+      responseFormat: f(this.outputSchema)
+    }).invoke({ messages: t.agentExecutionContext.messages }, e);
+    if (!("structuredResponse" in r) || r.structuredResponse === void 0)
       throw new Error("LLMAgent did not receive structured output from createAgent.");
-    return M(e.structuredResponse, this.outputSchema, e.messages);
+    return {
+      ...A(r.structuredResponse, this.outputSchema, r.messages),
+      sharedResourceAdditions: p(r.messages)
+    };
   }
-  async _invokeUnstructured(t, r) {
-    const o = (await h({
-      model: await u({ modelTier: this.modelTier }),
+  async _invokeUnstructured(t, e) {
+    const { createChatModel: s } = await import("../orchestrator/models/chatModel.js"), a = (await d({
+      model: await s({ modelTier: this.modelTier }),
       systemPrompt: await this._getPromptWithInputVariables(t),
-      tools: this._getTools(),
+      tools: await this._getTools(),
       checkpointer: !0,
-      middleware: l(this.middlewares)
-    }).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 },
+      middleware: m(this.middlewares)
+    }).invoke({ messages: t.agentExecutionContext.messages }, e)).messages, n = a.at(-1)?.text ?? "", h = n.trim() || "LLMAgent completed.";
+    return u(
+      {
+        agentExecutionContext: { ...t.agentExecutionContext, messages: a },
+        outputMessage: n,
+        sharedResourceAdditions: p(a)
+      },
       "success",
-      g
+      h
     );
   }
   async _getPromptWithInputVariables(t) {
-    const r = x(t, this.inputSchema);
-    for (const { outputKey: e } of this.middlewares)
-      e && (r[String(e)] = t[e]);
-    return await S.fromTemplate(this.prompt).format(r);
+    return await c.fromTemplate(this.prompt).format(t);
   }
-  _getTools() {
-    return this.tools?.map((t) => "getTool" in t ? t.getTool() : t) ?? [];
+  async _getTools() {
+    return (await Promise.all(
+      (this.tools ?? []).map(async (e) => "getTools" in e ? await e.getTools() : ["getTool" in e ? e.getTool() : e])
+    )).flat();
   }
   //#endregion
-};
-n([
-  m()
-], a.prototype, "prompt", 2);
-n([
-  m()
-], a.prototype, "tools", 2);
-n([
-  m()
-], a.prototype, "inputSchema", 2);
-n([
-  m()
-], a.prototype, "outputSchema", 2);
-n([
-  m()
-], a.prototype, "modelTier", 2);
-a = n([
-  _("LLMAgent")
-], a);
+}
+function p(i) {
+  const t = [];
+  for (const e of i)
+    if (l.isInstance(e) && e.status !== "error") {
+      const s = e.artifact;
+      if (typeof s == "object" && s !== null && "sharedResourceAdditions" in s) {
+        const o = s.sharedResourceAdditions;
+        if (Array.isArray(o))
+          for (const r of o)
+            t.push({
+              kind: r.kind,
+              description: r.description,
+              payload: r.payload
+            });
+      }
+    }
+  return t;
+}
 export {
-  a as LLMAgent
+  L as LLMAgent
 };

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

@@ -0,0 +1,66 @@
+import type { StructuredToolInterface } from "@langchain/core/tools";
+import type { BaseAgent } from "./BaseAgent.js";
+import type { AgentData, AgentExecutionConfig } from "./types.js";
+import type { FunctionToolLike } from "./tools/FunctionTool.js";
+import type { ChatModelTier } from "../orchestrator/models/chatModel.js";
+
+/** Function tool or structured tool accepted by the skill runtime. */
+export type SkillAgentTool = FunctionToolLike | StructuredToolInterface;
+
+/** Custom tool loaders available to skills by tool name. */
+export type SkillAgentToolLoaders = Readonly<Record<string, () => Promise<SkillAgentTool>>>;
+
+/** Options passed to the runtime context loader for each skill-agent run. */
+export type SkillAgentRuntimeContextLoaderOptions = {
+  config?: AgentExecutionConfig;
+};
+
+/**
+ * Loads runtime context for a skill-agent run.
+ *
+ * @param options
+ */
+export type SkillAgentRuntimeContextLoader = (options: SkillAgentRuntimeContextLoaderOptions) => Promise<string> | string;
+
+/** Properties used to construct a skill-backed agent. */
+export type SkillAgentConstructProperties = {
+  id: string;
+  name: string;
+  description: string;
+  systemPrompt: string;
+  skillLoaders: readonly [() => Promise<string>, ...(() => Promise<string>)[]];
+  toolLoaders?: SkillAgentToolLoaders;
+  modelTier?: ChatModelTier;
+  runtimeContextLoader?: SkillAgentRuntimeContextLoader;
+  instructions?: string;
+};
+
+/** SkillAgent runs bundled skills through the assistant's skill runtime. */
+export class SkillAgent extends BaseAgent<AgentData> {
+  constructor(properties: SkillAgentConstructProperties);
+  /** Additional instructions appended to the system prompt. */
+  instructions?: string;
+  /**
+   * Model tier used by the agent.
+   *
+   * @default "default"
+   */
+  modelTier: ChatModelTier;
+  /** Loads runtime context for each agent execution. */
+  runtimeContextLoader?: SkillAgentRuntimeContextLoader;
+  /** Markdown loaders for the skills available to this agent. */
+  skillLoaders: SkillAgentConstructProperties["skillLoaders"];
+  /** The system prompt used to guide this skill-backed agent. */
+  systemPrompt: string;
+  /** Optional lazy tool loaders keyed by skill tool name. */
+  toolLoaders?: SkillAgentToolLoaders;
+  /**
+   * Rebuilds internal workspace and createGraph wiring. Concrete agent constructors call this after assigning their
+   * configuration. Call it manually after changing graph-defining properties.
+   *
+   * The agent implementation is responsible for defining the createGraph function and workspace structure in this method, which are then used during execution.
+   *
+   * @since 5.2
+   */
+  generate(): void;
+}

package/dist/agent-utils/SkillAgent.js

@@ -0,0 +1,37 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
+import { BaseAgent as r } from "./BaseAgent.js";
+import { c as a } from "../chunks/createSkillAgent.js";
+class d extends r {
+  //#region Lifecycle
+  constructor(t) {
+    super(), this.modelTier = "default", Object.assign(this, t), this.generate();
+  }
+  //#endregion
+  //#region Public Methods
+  generate() {
+    const t = this.toolLoaders ? Object.fromEntries(
+      Object.entries(this.toolLoaders).map(([o, i]) => [
+        o,
+        async () => {
+          const e = await i();
+          return "getTool" in e ? e.getTool() : e;
+        }
+      ])
+    ) : void 0, s = a({
+      id: this.id,
+      name: this.name,
+      description: this.description,
+      systemPrompt: this.systemPrompt,
+      skillLoaders: this.skillLoaders,
+      toolLoaders: t,
+      modelTier: this.modelTier,
+      runtimeContextLoader: this.runtimeContextLoader,
+      instructions: this.instructions
+    });
+    this.createGraph = s.createGraph, this.workspace = s.workspace;
+  }
+  //#endregion
+}
+export {
+  d as SkillAgent
+};

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

@@ -1,4 +1,5 @@
 import type { BaseAgent } from "./BaseAgent.js";
+import type { AgentMiddleware } from "./middlewares/types.js";
 import type { BaseWorkflow } from "./workflows/BaseWorkflow.js";
 import type { AgentData, ZodObjectSchema } from "./types.js";
 
@@ -11,34 +12,27 @@ import type { AgentData, ZodObjectSchema } from "./types.js";
 export class WorkflowAgent<TState extends AgentData = AgentData> extends BaseAgent<TState> {
   constructor(properties: WorkflowAgentConstructProperties<TState>);
   /** Optional structured input schema for the workflow wrapper. */
-  accessor inputSchema: ZodObjectSchema<object> | undefined;
+  inputSchema?: ZodObjectSchema<object>;
+  /** Middleware functions that wrap execution of the generated workflow graph. */
+  middlewares: AgentMiddleware<TState>[];
   /** Optional structured output schema for the workflow wrapper. */
-  accessor outputSchema: ZodObjectSchema<object> | undefined;
+  outputSchema?: ZodObjectSchema<object>;
   /**
    * The workflow to execute when generating and running this agent's graph.
    *
    * @required
    */
-  accessor workflow: BaseWorkflow<TState>;
+  workflow: BaseWorkflow<TState>;
   /**
-   * Rebuilds internal workspace and createGraph wiring. This is automatically called during initialization and whenever
-   * the name or description properties change, but can also be called manually if needed to refresh the agent's graph definition.
+   * Rebuilds internal workspace and createGraph wiring. Concrete agent constructors call this after assigning their
+   * configuration. Call it manually after changing graph-defining properties.
    *
    * The agent implementation is responsible for defining the createGraph function and workspace structure in this method, which are then used during execution.
    *
-   * @internal
+   * @since 5.2
    */
   generate(): void;
-  /**
-   * Returns all schemas required by this agent implementation.
-   *
-   * @returns An array of Zod object schemas that define the structure of the agent's expected input and output data.
-   * These schemas are used for validation and type inference during graph execution.
-   * @internal
-   */
-  getSchemas(): ZodObjectSchema<object>[];
-  initialize(): void;
 }
 
-export type WorkflowAgentConstructProperties<TState extends AgentData = AgentData> = Partial<Pick<WorkflowAgent<TState>, "description" | "inputSchema" | "middlewares" | "outputSchema">>
+export type WorkflowAgentConstructProperties<TState extends AgentData = AgentData> = Partial<Pick<WorkflowAgent<TState>, "description" | "id" | "inputSchema" | "middlewares" | "outputSchema">>
   & Pick<WorkflowAgent<TState>, "name" | "workflow">;

package/dist/agent-utils/WorkflowAgent.js

@@ -1,69 +1,33 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
-import { property as h, subclass as c } from "@arcgis/core/core/accessorSupport/decorators.js";
-import { watch as l } from "@arcgis/core/core/reactiveUtils.js";
-import { BaseAgent as m } from "./BaseAgent.js";
-import { c as u } from "../chunks/graph.js";
-var f = Object.defineProperty, w = Object.getOwnPropertyDescriptor, p = (e, r, s, o) => {
-  for (var t = o > 1 ? void 0 : o ? w(r, s) : r, a = e.length - 1, i; a >= 0; a--)
-    (i = e[a]) && (t = (o ? i(r, s, t) : i(t)) || t);
-  return o && t && f(r, s, t), t;
-};
-let n = class extends m {
+import { BaseAgent as h } from "./BaseAgent.js";
+import { c as n } from "../chunks/graph.js";
+class l extends h {
   //#region Lifecycle
   constructor(e) {
-    super(e);
-  }
-  initialize() {
-    this.addHandles(
-      l(
-        () => [this.name, this.description, this.inputSchema, this.outputSchema, this.workflow],
-        () => this.generate(),
-        { initial: !0, sync: !0 }
-      )
-    );
+    super(), this.middlewares = [], Object.assign(this, e), this.generate();
   }
   //#endregion
   //#region Public Methods
-  getSchemas() {
-    return [
-      this.inputSchema,
-      ...this.workflow.getAgents().flatMap((e) => e.getSchemas()),
-      this.outputSchema
-    ].filter(Boolean);
-  }
   generate() {
-    const { workspace: e, createGraph: r } = this.workflow.generate();
-    if (this._set("workspace", e), !this.middlewares?.length)
-      this._set("createGraph", r);
+    const { workspace: e, createGraph: s } = this.workflow.generate({
+      additionalSchemas: [this.inputSchema, this.outputSchema]
+    });
+    if (this.workspace = e, !this.middlewares.length)
+      this.createGraph = s;
     else {
-      const s = this.id, o = {
-        [s]: async (a, i) => await r().compile().invoke(a, i)
-      }, t = [{ from: s, decide: () => {
+      const t = this.id, a = s().compile(), r = {
+        [t]: async (o, c) => await a.invoke(o, c)
+      }, i = [{ from: t, decide: () => {
       } }];
-      this._set(
-        "createGraph",
-        () => u(o, t, e, {
-          agent: this,
-          entryNode: s,
-          middlewares: this.middlewares
-        })
-      );
+      this.createGraph = () => n(r, i, e, {
+        agent: this,
+        entryNode: t,
+        middlewares: this.middlewares
+      });
     }
   }
   //#endregion
-};
-p([
-  h()
-], n.prototype, "workflow", 2);
-p([
-  h()
-], n.prototype, "inputSchema", 2);
-p([
-  h()
-], n.prototype, "outputSchema", 2);
-n = p([
-  c("WorkflowAgent")
-], n);
+}
 export {
-  n as WorkflowAgent
+  l as WorkflowAgent
 };

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

@@ -0,0 +1,12 @@
+import type z from "zod";
+import type { SchemaDefinition } from "./types.js";
+
+/**
+ * Creates a Zod schema from a JSON Schema-style object definition.
+ *
+ * Supports string, number, boolean, array, and nested object fields.
+ *
+ * @param definition
+ * @since 5.2
+ */
+export function createSchema(definition: SchemaDefinition): Promise<z.ZodObject>;

package/dist/agent-utils/createSchema.js

@@ -0,0 +1,8 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
+async function c(e) {
+  const { createZodObjectSchema: t } = await import("../chunks/schema.js");
+  return t(e);
+}
+export {
+  c as createSchema
+};

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

@@ -1,7 +1,7 @@
 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";
+import type { UiInterrupt } from "../../orchestrator/types.js";
 
 /** @since 5.1 */
 export interface HumanInTheLoopInterruptRequest<TCustomState extends AgentData = AgentData> extends AgentRunRequest<TCustomState> {

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

@@ -1,17 +1,17 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
-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";
+import { sendTraceMessage as n } from "../../orchestrator/signals.js";
+import { AIMessage as i, ToolMessage as c } from "@langchain/core/messages";
+import { createAgentMiddleware as s, createToolMiddleware as d } from "./middleware.js";
 const g = "agent-trace", f = "tool-trace";
 function p() {
-  return c(g, {
+  return s(g, {
     wrapModelCall: async (e, a) => {
       const t = await a(e), o = e.runtime, l = m(t);
       return await Promise.all(
         l.map(
-          async (n) => await r(
+          async (r) => await n(
             {
-              text: `LLM requested tool call "${n.name}" with arguments: ${JSON.stringify(n.args, null, 2)}`
+              text: `LLM requested tool call "${r.name}" with arguments: ${JSON.stringify(r.args, null, 2)}`
             },
             o
           )
@@ -24,9 +24,9 @@ function T() {
   return d(f, {
     wrapToolCall: async (e, a) => {
       const t = await a(e), o = e.config;
-      return await r(
+      return await n(
         {
-          text: `Finished executing tool: ${s.isInstance(t) ? t.content.toString() : typeof t == "string" ? t : e.tool.name}`
+          text: `Finished executing tool: ${c.isInstance(t) ? t.text : typeof t == "string" ? t : e.tool.name}`
         },
         o
       ), t;

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

@@ -1,4 +1,3 @@
-import type Accessor from "@arcgis/core/core/Accessor.js";
 import type z from "zod";
 import type { StructuredToolInterface } from "@langchain/core/tools";
 import type { Middleware } from "../middlewares/types.js";
@@ -58,7 +57,7 @@ export interface FunctionToolLike {
  *
  * @since 5.1
  */
-export class FunctionTool<TInput extends AgentData, TOutput = unknown> extends Accessor {
+export class FunctionTool<TInput extends AgentData, TOutput = unknown> {
   constructor(properties?: FunctionToolConstructProperties<TInput, TOutput>);
   /**
    * A concise, but clear description of the tool's functionality.
@@ -68,7 +67,7 @@ export class FunctionTool<TInput extends AgentData, TOutput = unknown> extends A
    *
    * @required
    */
-  accessor description: string;
+  description: string;
   /**
    * The execute function contains the custom logic that will be executed when the tool is invoked
    * by an agent. It receives
@@ -80,15 +79,15 @@ export class FunctionTool<TInput extends AgentData, TOutput = unknown> extends A
    * @required
    * @since 5.1
    */
-  accessor execute: FunctionToolExecute<TInput, TOutput>;
+  execute: FunctionToolExecute<TInput, TOutput>;
   /**
    * The input schema defines the expected structure of the input object when invoking the tool.
    * This should be a Zod schema object.
    * The agent will validate the input against this schema before execution.
    */
-  accessor inputSchema: z.ZodType<TInput> | undefined;
+  inputSchema?: z.ZodType<TInput>;
   /** Middleware that can wrap this tool's execution. */
-  accessor middlewares: FunctionToolMiddleware<TInput, TOutput>[];
+  middlewares: FunctionToolMiddleware<TInput, TOutput>[];
   /**
    * The name of the tool, which will be used to invoke it. This should be unique among the tools
    * available to an agent. It should also be descriptive of the tool's functionality to make it
@@ -96,13 +95,24 @@ export class FunctionTool<TInput extends AgentData, TOutput = unknown> extends A
    *
    * @required
    */
-  accessor name: string;
+  name: string;
   /**
    * The output schema defines the expected structure of the result returned by the tool.
    * This should be a Zod schema object.
    * The agent will validate the output against this schema after execution.
+   * With `content-and-artifact`, the schema validates the entire tuple, including the artifact.
+   */
+  outputSchema?: z.ZodType<TOutput>;
+  /**
+   * The format of the tool's response. With `content`, the result is interpreted as message content.
+   * With `content-and-artifact`, execute must return a two-item tuple containing message content
+   * and an artifact. Only the content is sent to the model; the artifact is available to the application.
+   * String results from middleware are treated as content with no artifact.
+   *
+   * @default "content"
+   * @since 5.2
    */
-  accessor outputSchema: z.ZodType<TOutput> | undefined;
+  responseFormat: "content-and-artifact" | "content";
   /**
    * The result mode determines how the agent should treat the output of this tool.
    * If set to `terminal`, the agent will
@@ -112,7 +122,7 @@ export class FunctionTool<TInput extends AgentData, TOutput = unknown> extends A
    *
    * @default "continue"
    */
-  accessor resultMode: ToolResultMode;
+  resultMode: ToolResultMode;
   /** Builds the LangChain tool adapter used by LLM agents. */
   getTool(): StructuredToolInterface;
 }
@@ -123,5 +133,5 @@ export interface FunctionToolMiddlewareTool {
   resultMode: ToolResultMode;
 }
 
-export type FunctionToolConstructProperties<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" | "responseFormat" | "resultMode">>
   & Pick<FunctionTool<TInput, TOutput>, "description" | "execute" | "name">;