@voltagent/core 1.1.33 → 1.1.35

package/dist/index.d.mts

@@ -3514,6 +3514,14 @@ declare class AgentTraceContext {
         cachedTokens?: number;
         reasoningTokens?: number;
     }): void;
+    /**
+     * Set finish reason on the root span
+     */
+    setFinishReason(finishReason: string | null | undefined): void;
+    /**
+     * Set stop condition metadata when maxSteps is reached
+     */
+    setStopConditionMet(stepCount: number, maxSteps: number): void;
     /**
      * End the root span with a status
      */
@@ -4590,6 +4598,48 @@ declare class Agent {
      * Get Memory instance if available
      */
     getMemory(): Memory | false | undefined;
+    /**
+     * Convert this agent into a tool that can be used by other agents.
+     * This enables supervisor/coordinator patterns where one agent can delegate
+     * work to other specialized agents.
+     *
+     * @param options - Optional configuration for the tool
+     * @param options.name - Custom name for the tool (defaults to `${agent.id}_tool`)
+     * @param options.description - Custom description (defaults to agent's purpose or auto-generated)
+     * @param options.parametersSchema - Custom input schema (defaults to { prompt: string })
+     *
+     * @returns A Tool instance that executes this agent
+     *
+     * @example
+     * ```typescript
+     * const writerAgent = new Agent({
+     *   id: "writer",
+     *   purpose: "Writes blog posts",
+     *   // ... other config
+     * });
+     *
+     * const editorAgent = new Agent({
+     *   id: "editor",
+     *   purpose: "Edits content",
+     *   // ... other config
+     * });
+     *
+     * // Supervisor agent that uses both as tools
+     * const supervisorAgent = new Agent({
+     *   id: "supervisor",
+     *   instructions: "First call writer, then editor",
+     *   tools: [
+     *     writerAgent.toTool(),
+     *     editorAgent.toTool()
+     *   ]
+     * });
+     * ```
+     */
+    toTool(options?: {
+        name?: string;
+        description?: string;
+        parametersSchema?: z.ZodObject<any>;
+    }): Tool<any, any>;
     /**
      * Check if working memory is supported
      */

package/dist/index.d.ts

@@ -3514,6 +3514,14 @@ declare class AgentTraceContext {
         cachedTokens?: number;
         reasoningTokens?: number;
     }): void;
+    /**
+     * Set finish reason on the root span
+     */
+    setFinishReason(finishReason: string | null | undefined): void;
+    /**
+     * Set stop condition metadata when maxSteps is reached
+     */
+    setStopConditionMet(stepCount: number, maxSteps: number): void;
     /**
      * End the root span with a status
      */
@@ -4590,6 +4598,48 @@ declare class Agent {
      * Get Memory instance if available
      */
     getMemory(): Memory | false | undefined;
+    /**
+     * Convert this agent into a tool that can be used by other agents.
+     * This enables supervisor/coordinator patterns where one agent can delegate
+     * work to other specialized agents.
+     *
+     * @param options - Optional configuration for the tool
+     * @param options.name - Custom name for the tool (defaults to `${agent.id}_tool`)
+     * @param options.description - Custom description (defaults to agent's purpose or auto-generated)
+     * @param options.parametersSchema - Custom input schema (defaults to { prompt: string })
+     *
+     * @returns A Tool instance that executes this agent
+     *
+     * @example
+     * ```typescript
+     * const writerAgent = new Agent({
+     *   id: "writer",
+     *   purpose: "Writes blog posts",
+     *   // ... other config
+     * });
+     *
+     * const editorAgent = new Agent({
+     *   id: "editor",
+     *   purpose: "Edits content",
+     *   // ... other config
+     * });
+     *
+     * // Supervisor agent that uses both as tools
+     * const supervisorAgent = new Agent({
+     *   id: "supervisor",
+     *   instructions: "First call writer, then editor",
+     *   tools: [
+     *     writerAgent.toTool(),
+     *     editorAgent.toTool()
+     *   ]
+     * });
+     * ```
+     */
+    toTool(options?: {
+        name?: string;
+        description?: string;
+        parametersSchema?: z.ZodObject<any>;
+    }): Tool<any, any>;
     /**
      * Check if working memory is supported
      */

package/dist/index.js

@@ -11251,6 +11251,24 @@ var AgentTraceContext = class {
       this.rootSpan.setAttribute("usage.reasoning_tokens", usage.reasoningTokens);
     }
   }
+  /**
+   * Set finish reason on the root span
+   */
+  setFinishReason(finishReason) {
+    if (finishReason !== null && finishReason !== void 0) {
+      this.rootSpan.setAttribute("ai.response.finish_reason", finishReason);
+    }
+  }
+  /**
+   * Set stop condition metadata when maxSteps is reached
+   */
+  setStopConditionMet(stepCount, maxSteps) {
+    this.rootSpan.setAttributes({
+      "voltagent.stopped_by_max_steps": true,
+      "voltagent.step_count": stepCount,
+      "voltagent.max_steps": maxSteps
+    });
+  }
   /**
    * End the root span with a status
    */
@@ -14553,6 +14571,10 @@ var Agent = class {
         );
         this.setTraceContextUsage(oc.traceContext, result.usage);
         oc.traceContext.setOutput(finalText);
+        oc.traceContext.setFinishReason(result.finishReason);
+        if (result.steps && result.steps.length >= maxSteps) {
+          oc.traceContext.setStopConditionMet(result.steps.length, maxSteps);
+        }
         oc.output = finalText;
         this.enqueueEvalScoring({
           oc,
@@ -14713,6 +14735,11 @@ var Agent = class {
             }
             const guardrailedResult = guardrailSet.output.length > 0 ? { ...finalResult, text: finalText } : finalResult;
             oc.traceContext.setOutput(finalText);
+            oc.traceContext.setFinishReason(finalResult.finishReason);
+            const steps = finalResult.steps;
+            if (steps && steps.length >= maxSteps) {
+              oc.traceContext.setStopConditionMet(steps.length, maxSteps);
+            }
             oc.output = finalText;
             await this.getMergedHooks(options).onEnd?.({
               conversationId: oc.conversationId || "",
@@ -16615,6 +16642,68 @@ ${toolkit.instructions}`;
     }
     return this.memory ?? this.memoryManager.getMemory();
   }
+  /**
+   * Convert this agent into a tool that can be used by other agents.
+   * This enables supervisor/coordinator patterns where one agent can delegate
+   * work to other specialized agents.
+   *
+   * @param options - Optional configuration for the tool
+   * @param options.name - Custom name for the tool (defaults to `${agent.id}_tool`)
+   * @param options.description - Custom description (defaults to agent's purpose or auto-generated)
+   * @param options.parametersSchema - Custom input schema (defaults to { prompt: string })
+   *
+   * @returns A Tool instance that executes this agent
+   *
+   * @example
+   * ```typescript
+   * const writerAgent = new Agent({
+   *   id: "writer",
+   *   purpose: "Writes blog posts",
+   *   // ... other config
+   * });
+   *
+   * const editorAgent = new Agent({
+   *   id: "editor",
+   *   purpose: "Edits content",
+   *   // ... other config
+   * });
+   *
+   * // Supervisor agent that uses both as tools
+   * const supervisorAgent = new Agent({
+   *   id: "supervisor",
+   *   instructions: "First call writer, then editor",
+   *   tools: [
+   *     writerAgent.toTool(),
+   *     editorAgent.toTool()
+   *   ]
+   * });
+   * ```
+   */
+  toTool(options) {
+    const toolName = options?.name || `${this.id}_tool`;
+    const toolDescription = options?.description || this.purpose || `Executes the ${this.name} agent to complete a task`;
+    const parametersSchema = options?.parametersSchema || import_zod3.z.object({
+      prompt: import_zod3.z.string().describe("The prompt or task to send to the agent")
+    });
+    return createTool({
+      name: toolName,
+      description: toolDescription,
+      parameters: parametersSchema,
+      execute: /* @__PURE__ */ __name(async (args, context8) => {
+        const prompt = args.prompt || args;
+        const result = await this.generateText(prompt, {
+          // Pass through the operation context if available
+          parentOperationContext: context8,
+          conversationId: context8?.conversationId,
+          userId: context8?.userId
+        });
+        return {
+          text: result.text,
+          usage: result.usage
+        };
+      }, "execute")
+    });
+  }
   /**
    * Check if working memory is supported
    */