@deepagents/agent 0.1.0

package/dist/index.js

@@ -0,0 +1,916 @@
+// packages/agent/src/lib/agent.ts
+import {
+  Output as Output2,
+  dynamicTool,
+  generateText as generateText2,
+  jsonSchema,
+  stepCountIs as stepCountIs2,
+  tool
+} from "ai";
+import chalk2 from "chalk";
+import { snakecase } from "stringcase";
+import z from "zod";
+
+// packages/agent/src/lib/prompts.ts
+import dedent from "dedent";
+var RECOMMENDED_PROMPT_PREFIX = [
+  `# System context`,
+  `You are part of a multi-agent system called the DeepAgents SDK, designed to make agent coordination and execution easy.`,
+  `Agents uses two primary abstraction: **Agents** and **Handoffs**.`,
+  `An agent encompasses instructions and tools and can hand off a conversation to another agent when appropriate.`,
+  `Handoffs are achieved by calling a handoff function, generally named \`transfer_to_<agent_name>\`.`,
+  `Transfers between agents are handled seamlessly in the background; do not mention or draw attention to these transfers in your conversation with the user.`
+  // 'Do not pass context between agents. the agents already have the complete context without agent to agent communication.',
+  // From 4.1 beast mode
+  // `Please keep going until the user’s query is completely resolved, before ending your turn and yielding back to the user.`,
+  // `Your thinking should be thorough and so it's fine if it's very long. However, avoid unnecessary repetition and verbosity. You should be concise, but thorough.`,
+  // `You MUST iterate and keep going until the problem is solved.`,
+  // `You have everything you need to resolve this problem. I want you to fully solve this autonomously before coming back to me.`,
+  // `Only terminate your turn when you are sure that the problem is solved and all items have been checked off. Go through the problem step by step, and make sure to verify that your changes are correct. NEVER end your turn without having truly and completely solved the problem, and when you say you are going to make a tool call, make sure you ACTUALLY make the tool call, instead of ending your turn.`,
+  // `Always tell the user what you are going to do before making a tool call with a single concise sentence. This will help them understand what you are doing and why.`,
+  // `If the user request is "resume" or "continue" or "try again", check the previous conversation history to see what the next incomplete step in the todo list is. Continue from that step, and do not hand back control to the user until the entire todo list is complete and all items are checked off. Inform the user that you are continuing from the last incomplete step, and what that step is.`,
+  // `Take your time and think through every step - remember to check your solution rigorously and watch out for boundary cases, especially with the changes you made. Use the sequential thinking tool if available. Your solution must be perfect. If not, continue working on it. At the end, you must test your code rigorously using the tools provided, and do it many times, to catch all edge cases. If it is not robust, iterate more and make it perfect. Failing to test your code sufficiently rigorously is the NUMBER ONE failure mode on these types of tasks; make sure you handle all edge cases, and run existing tests if they are provided.`,
+  // `You MUST plan extensively before each function call, and reflect extensively on the outcomes of the previous function calls. DO NOT do this entire process by making function calls only, as this can impair your ability to solve the problem and think insightfully.`,
+  // `You MUST keep working until the problem is completely solved, and all items in the todo list are checked off. Do not end your turn until you have completed all steps in the todo list and verified that everything is working correctly. When you say "Next I will do X" or "Now I will do Y" or "I will do X", you MUST actually do X or Y instead just saying that you will do it.`,
+  // `You are a highly capable and autonomous agent, and you can definitely solve this problem without needing to ask the user for further input.`,
+].join("\n");
+var SUPERVISOR_PROMPT_PREFIX = dedent`
+# System Context
+You are part of a multi-agent system called the DeepAgents SDK, designed to facilitate agent coordination and execution.
+
+- The primary agent, known as the "Supervisor Agent," coordinates communication between specialized agents. The Supervisor Agent does not perform specialized tasks but acts as the central point for communication.
+- Specialized agents must transfer control back to the Supervisor Agent upon completing their tasks.
+
+**Core Directives:**
+- Begin with a concise checklist (3-7 bullets) of what you will do for each user query; items should be conceptual, not implementation-level.
+- Continue working until the user's query is completely resolved; only then yield control back to the user.
+- Your thinking must be thorough and step-by-step. Aim for completeness and rigor while avoiding unnecessary repetition and verbosity.
+- You must iterate and keep working until the problem is fully solved. You have all the requirements and information needed; solve the problem autonomously without user intervention.
+- Do not terminate your turn unless you are certain all issues are resolved and the entire todo list is complete and verified.
+- When making tool calls, explicitly state, in a single concise sentence, the purpose and minimal inputs for the action before executing it.
+- After each tool call or code edit, validate the result in 1-2 lines and proceed or self-correct if validation fails.
+- For requests such as "resume", "continue", or "try again":
+    - Check previous conversation history to determine the next incomplete todo step, continue from there, and do not return control until all items are complete.
+    - Inform the user you are resuming from the last incomplete step, and specify what that step is.
+- Take your time and rigorously check your solution, especially edge and boundary cases. Use sequential thinking tools when available. Your solution must be robust and perfect; continue iterating and retesting as needed.
+- Always test your code using all available tools and provided tests, with repetition as necessary to catch edge cases.
+- Plan extensively before each function/tool call and reflect thoroughly on previous actions before proceeding. Do not proceed solely by chaining function calls—use stepwise planning and reflection.
+- Explicitly complete every todo list item and confirm all steps are working before ending your turn. Always follow through on stated actions.
+- You are a highly capable, autonomous agent, and should not require additional user input to fully solve the task.
+`;
+
+// packages/agent/src/lib/stream_utils.ts
+import {
+  generateId
+} from "ai";
+import { flow } from "lodash-es";
+import { createWriteStream } from "node:fs";
+import { createInterface } from "node:readline/promises";
+import { Readable } from "node:stream";
+import { isPromise } from "node:util/types";
+
+// packages/agent/src/lib/visualize.ts
+import { titlecase } from "stringcase";
+function visualizeMermaid(root, options = {}) {
+  const { direction = "LR", showTools = true } = options;
+  const nodes = [];
+  const edges = [];
+  const seen = /* @__PURE__ */ new Set();
+  const nameToId = /* @__PURE__ */ new Map();
+  const sanitizeId = (name) => name.toLowerCase().replace(/[^a-z0-9]+/gi, "_").replace(/^_+|_+$/g, "");
+  const ensureNode = (agent2) => {
+    const name = agent2.handoff.name;
+    if (!nameToId.has(name)) {
+      const base = sanitizeId(name) || "agent";
+      let id = base;
+      let i = 1;
+      while (nodes.some((n) => n.id === id)) id = `${base}_${i++}`;
+      nameToId.set(name, id);
+      nodes.push({
+        id,
+        name,
+        tools: Object.keys(agent2.handoff.tools ?? {})
+      });
+    }
+    return nameToId.get(name);
+  };
+  const stack = [root];
+  while (stack.length) {
+    const current = stack.pop();
+    const currentName = current.handoff.name;
+    if (seen.has(currentName)) continue;
+    seen.add(currentName);
+    const fromId = ensureNode(current);
+    for (const child of current.toHandoffs()) {
+      const toId = ensureNode(child);
+      const label = Object.keys(child.handoffTool)[0].replace(
+        /transfer_to_/g,
+        ""
+      );
+      edges.push({ from: fromId, to: toId, label });
+      stack.push(child);
+    }
+  }
+  const lines = [];
+  lines.push(`flowchart ${direction}`);
+  for (const n of nodes) {
+    const name = titlecase(n.name.replace(/_agent/g, "").replace(/_/g, " "));
+    const toolLine = showTools && n.tools.length ? `<br/>tools: ${n.tools.map((it) => it.replace(/transfer_to_/g, "")).join(", ")}` : "";
+    lines.push(`${n.id}["${escapeLabel(`Agent: ${name}${toolLine}`)}"]`);
+  }
+  for (const e of edges) {
+    lines.push(`${e.from} -- ${escapeLabel(e.label)} --> ${e.to}`);
+  }
+  return lines.join("\n");
+}
+function escapeLabel(s) {
+  return s.replace(/"/g, '\\"');
+}
+function visualizeSemantic(root) {
+  const lines = [];
+  const seen = /* @__PURE__ */ new Set();
+  const stack = [root];
+  while (stack.length) {
+    const current = stack.pop();
+    const currentName = current.handoff.name;
+    if (seen.has(currentName)) continue;
+    seen.add(currentName);
+    const from = current.handoff.name;
+    const transfers = current.toHandoffs().map((h) => h.handoff.name);
+    const uniqueTransfers = Array.from(new Set(transfers));
+    const rhs = uniqueTransfers.length ? uniqueTransfers.join(", ") : "none";
+    lines.push(`${from} transfers to: ${rhs}`);
+    for (const child of current.toHandoffs()) stack.push(child);
+  }
+  return lines.join("\n");
+}
+function visualizeRichSemantic(root) {
+  const stack = [root];
+  const seen = /* @__PURE__ */ new Set();
+  const edgeSet = /* @__PURE__ */ new Set();
+  const edges = [];
+  while (stack.length) {
+    const current = stack.pop();
+    const from = current.handoff.name;
+    if (!seen.has(from)) {
+      seen.add(from);
+      for (const child of current.toHandoffs()) {
+        const to = child.handoff.name;
+        const key = `${from}->${to}`;
+        if (!edgeSet.has(key)) {
+          edgeSet.add(key);
+          edges.push({ from, to });
+        }
+        stack.push(child);
+      }
+    }
+  }
+  if (edges.length === 0) return `${root.handoff.name} \u2500\u2500\u25B6 none`;
+  return edges.map(({ from, to }) => `${from} \u2500\u2500\u25B6 ${to}`).join("\n");
+}
+
+// packages/agent/src/lib/stream_utils.ts
+async function streamWrite(response) {
+  response.consumeStream();
+  const writeStream = createWriteStream("blog_writer_output.md");
+  Readable.fromWeb(response.textStream).pipe(writeStream);
+  console.log(await response.totalUsage);
+}
+function printChunk(chunk, options) {
+  const {
+    reasoning: includeReasoning,
+    wrapInTags,
+    text: includeText
+  } = options;
+  if (includeReasoning) {
+    if (chunk.type === "reasoning-start") {
+      process.stdout.write(`
+${wrapInTags ? "<reasoning>" : ""}
+`);
+    }
+    if (chunk.type === "reasoning-delta") {
+      process.stdout.write(chunk.delta);
+    }
+    if (chunk.type === "reasoning-end") {
+      process.stdout.write(`
+${wrapInTags ? "</reasoning>" : ""}
+`);
+    }
+  }
+  if (includeText) {
+    if (chunk.type === "text-start") {
+      process.stdout.write(`
+${wrapInTags ? "<text>" : ""}
+`);
+    }
+    if (chunk.type === "text-delta") {
+      process.stdout.write(chunk.delta);
+    }
+    if (chunk.type === "text-end") {
+      process.stdout.write(`
+${wrapInTags ? "</text>" : ""}
+`);
+    }
+  }
+}
+var printer = {
+  readableStream: async (stream2, options) => {
+    const includeReasoning = options?.reasoning ?? true;
+    const wrapInTags = options?.wrapInTags ?? true;
+    const includeText = options?.text ?? true;
+    for await (const chunk of stream2) {
+      printChunk(chunk, {
+        reasoning: includeReasoning,
+        wrapInTags,
+        text: includeText
+      });
+    }
+  },
+  stdout: async (response, options) => {
+    const includeReasoning = options?.reasoning ?? true;
+    const includeText = options?.text ?? true;
+    const wrapInTags = options?.wrapInTags ?? true;
+    for await (const chunk of response.toUIMessageStream()) {
+      printChunk(chunk, {
+        reasoning: includeReasoning,
+        text: includeText,
+        wrapInTags
+      });
+    }
+    console.log(await response.totalUsage);
+  },
+  mermaid: flow(visualizeMermaid, console.log),
+  semantic: flow(visualizeSemantic, console.log),
+  richSemantic: flow(visualizeRichSemantic, console.log)
+};
+function messageToUiMessage(message) {
+  return {
+    id: generateId(),
+    role: "user",
+    parts: [
+      {
+        type: "text",
+        text: message
+      }
+    ]
+  };
+}
+var user = messageToUiMessage;
+async function input(defaultValue) {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  const answer = await rl.question(
+    `Please enter your input${defaultValue ? ` (default: ${defaultValue})` : ""}: `
+  );
+  rl.close();
+  return answer || defaultValue || "";
+}
+async function confirm(message, defaultValue = true) {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  const defaultText = defaultValue ? "Y/n" : "y/N";
+  while (true) {
+    const answer = await rl.question(`${message} (${defaultText}): `);
+    const normalized = answer.toLowerCase().trim();
+    if (normalized === "") {
+      rl.close();
+      return defaultValue;
+    }
+    if (normalized === "y" || normalized === "yes") {
+      rl.close();
+      return true;
+    } else if (normalized === "n" || normalized === "no") {
+      rl.close();
+      return false;
+    } else {
+      console.log(
+        "Please answer with y/yes or n/no (or press Enter for default)"
+      );
+    }
+  }
+}
+async function last(iterable, position = -1) {
+  const arr = await Array.fromAsync(iterable);
+  return arr.at(position);
+}
+async function finished(iterable) {
+  await Array.fromAsync(iterable);
+}
+function toOutput(result) {
+  return isPromise(result) ? result.then((res) => res.experimental_output) : last(result.experimental_partialOutputStream);
+}
+function toState(options) {
+  return options.experimental_context;
+}
+
+// packages/agent/src/lib/swarm.ts
+import { groq } from "@ai-sdk/groq";
+import {
+  NoSuchToolError,
+  Output,
+  convertToModelMessages,
+  createUIMessageStream,
+  generateId as generateId2,
+  generateText,
+  smoothStream,
+  stepCountIs,
+  streamText,
+  wrapLanguageModel
+} from "ai";
+import chalk from "chalk";
+import dedent2 from "dedent";
+import { zodToJsonSchema } from "zod-to-json-schema";
+function run(agent2, messages, contextVariables, config) {
+  return generateText({
+    abortSignal: config?.abortSignal,
+    providerOptions: config?.providerOptions,
+    model: agent2.model,
+    system: agent2.instructions(contextVariables),
+    messages: convertToModelMessages(
+      Array.isArray(messages) ? messages : [user(messages)]
+    ),
+    temperature: agent2.temperature,
+    stopWhen: stepCountIs(25),
+    tools: agent2.toToolset(),
+    activeTools: agent2.toolsNames,
+    experimental_context: contextVariables,
+    toolChoice: agent2.toolChoice,
+    experimental_output: agent2.output ? Output.object({ schema: agent2.output }) : void 0,
+    // onStepFinish: (step) => tagAgents(step, agent.handoff.name),
+    onStepFinish: (step) => {
+      const toolCall = step.toolCalls.at(-1);
+      if (toolCall) {
+        console.log(
+          `Debug: ${chalk.yellow("ToolCalled")}: ${toolCall.toolName}(${JSON.stringify(toolCall.input)})`
+        );
+      }
+    },
+    prepareStep: prepareStep(agent2, agent2.model, contextVariables)
+    // onFinish: (result) => {
+    //   (contextVariables as any).content = result.content;
+    // },
+  });
+}
+function execute(agent2, messages, contextVariables, config) {
+  return streamText({
+    abortSignal: config?.abortSignal,
+    providerOptions: config?.providerOptions,
+    model: agent2.model,
+    system: agent2.instructions(contextVariables),
+    messages: convertToModelMessages(
+      Array.isArray(messages) ? messages : [user(messages)]
+    ),
+    temperature: agent2.temperature,
+    stopWhen: stepCountIs(25),
+    experimental_transform: smoothStream(),
+    tools: agent2.toToolset(),
+    activeTools: agent2.toolsNames,
+    experimental_context: contextVariables,
+    toolChoice: agent2.toolChoice,
+    experimental_repairToolCall: async ({
+      toolCall,
+      tools,
+      inputSchema,
+      error
+    }) => {
+      if (NoSuchToolError.isInstance(error)) {
+        return null;
+      }
+      const tool2 = tools[toolCall.toolName];
+      const { experimental_output } = await generateText({
+        model: groq("openai/gpt-oss-20b"),
+        experimental_output: Output.object({ schema: tool2.inputSchema }),
+        prompt: [
+          `The model tried to call the tool "${toolCall.toolName}" with the following inputs:`,
+          JSON.stringify(toolCall.input),
+          `The tool accepts the following schema:`,
+          JSON.stringify(inputSchema(toolCall)),
+          "Please fix the inputs."
+        ].join("\n")
+      });
+      return { ...toolCall, input: JSON.stringify(experimental_output) };
+    },
+    onError: (error) => {
+      console.error(
+        chalk.red(`Error during agent (${agent2.internalName}) execution: `),
+        error instanceof Error ? error.message : error
+      );
+      console.dir(error, { depth: null });
+    },
+    experimental_output: agent2.output ? Output.object({ schema: agent2.output }) : void 0,
+    // onStepFinish: (step) => tagAgents(step, agent.handoff.name),
+    onStepFinish: (step) => {
+      const toolCall = step.toolCalls.at(-1);
+      if (toolCall) {
+        console.log(
+          `Debug: ${chalk.yellow("ToolCalled")}: ${toolCall.toolName}(${JSON.stringify(toolCall.input)})`
+        );
+      }
+    },
+    prepareStep: prepareStep(agent2, agent2.model, contextVariables)
+    // onFinish: (result) => {
+    //   (contextVariables as any).content = result.content;
+    // },
+  });
+}
+var stream = execute;
+var generate = run;
+var prepareStep = (agent2, model, contextVariables) => {
+  return async ({ steps, messages }) => {
+    const step = steps.at(-1);
+    const agentName = contextVariables.currentActiveAgent;
+    if (!step) {
+      return await prepareAgent(model, agent2, messages, contextVariables);
+    }
+    if (!agentName) {
+      return await prepareAgent(model, agent2, messages, contextVariables);
+    }
+    const nextAgent = findAgent(agent2, agentName);
+    if (!nextAgent) {
+      console.error(`Debug: ${chalk.red("NotFound")}: Agent ${agentName}`);
+      console.dir(
+        {
+          steps: steps.map(({ request, response, ...etc }) => etc),
+          messages
+        },
+        { depth: null }
+      );
+      return void 0;
+    }
+    return await prepareAgent(model, nextAgent, messages, contextVariables);
+  };
+};
+function swarm(agent2, messages, contextVariables, abortSignal) {
+  const originalMessages = Array.isArray(messages) ? messages : [messageToUiMessage(messages)];
+  return createUIMessageStream({
+    originalMessages,
+    generateId: generateId2,
+    async execute({ writer }) {
+      const stream2 = execute(agent2, originalMessages, contextVariables, {
+        abortSignal
+      });
+      const parts = [];
+      writer.merge(
+        stream2.toUIMessageStream({
+          sendFinish: false,
+          sendStart: true,
+          onFinish: (event) => {
+            parts.push(...event.responseMessage.parts);
+          }
+        })
+      );
+      await stream2.consumeStream({ onError: console.error });
+      await last(stream2.fullStream);
+      if (!agent2.prepareEnd) return;
+      while (true) {
+        const state = contextVariables;
+        if (state.currentActiveAgent === void 0) {
+          console.warn(
+            `swarm: active agent was never set, so no prepareEnd call will be made`
+          );
+          return;
+        }
+        if (state.currentActiveAgent === agent2.internalName) {
+          console.warn(
+            `swarm: active agent is the root agent, so no prepareEnd call will be made`
+          );
+          return;
+        }
+        const responseMessage = { id: "", parts, role: "assistant" };
+        const stream3 = agent2.prepareEnd({
+          responseMessage,
+          messages: [...originalMessages, responseMessage],
+          contextVariables,
+          abortSignal
+        });
+        if (!stream3) break;
+        writer.merge(
+          stream3.toUIMessageStream({
+            sendFinish: false,
+            sendStart: false,
+            onFinish: (event) => {
+              parts.push(...event.responseMessage.parts);
+            }
+          })
+        );
+        await stream3.consumeStream({ onError: console.error });
+        await last(stream3.fullStream);
+      }
+      writer.write({ type: "finish" });
+    }
+  });
+}
+async function prepareAgent(defaultModel, agent2, messages, contextVariables) {
+  agent2.debug();
+  await agent2.prepareHandoff?.(messages);
+  let stepModel = agent2.model ?? defaultModel;
+  if (agent2.output) {
+    const json_schema = zodToJsonSchema(agent2.output, {
+      $refStrategy: "root"
+    });
+    stepModel = wrapLanguageModel({
+      model: stepModel,
+      middleware: {
+        transformParams: async ({ params }) => ({
+          ...params,
+          response_format: {
+            type: "json_schema",
+            json_schema,
+            name: `${agent2.handoff.name}_output`
+          }
+        })
+      }
+    });
+  }
+  return {
+    system: agent2.instructions(contextVariables),
+    activeTools: agent2.toolsNames,
+    model: stepModel,
+    messages,
+    // messages: removeTransferCalls(messages),
+    toolChoice: agent2.toolChoice
+  };
+}
+function findAgent(agent2, agentName) {
+  return [...agent2.toHandoffs(), agent2].find(
+    (it) => it.handoff.name === agentName
+  );
+}
+
+// packages/agent/src/lib/agent.ts
+function agent(config) {
+  return new Agent(config);
+}
+var Agent = class _Agent {
+  model;
+  toolChoice;
+  parent;
+  handoffs;
+  prepareHandoff;
+  prepareEnd;
+  internalName;
+  handoff;
+  handoffToolName;
+  handoffTool;
+  output;
+  temperature;
+  constructor(config) {
+    this.model = config.model;
+    this.toolChoice = config.toolChoice || "auto";
+    this.handoffs = config.handoffs ?? [];
+    this.prepareHandoff = config.prepareHandoff;
+    this.prepareEnd = config.prepareEnd;
+    this.output = config.output;
+    this.temperature = config.temperature;
+    this.internalName = snakecase(config.name);
+    this.handoff = {
+      name: this.internalName,
+      instructions: config.prompt,
+      tools: config.tools ?? {},
+      handoffDescription: config.handoffDescription
+    };
+    this.handoffToolName = `transfer_to_${this.internalName}`;
+    this.handoffTool = {
+      [this.handoffToolName]: dynamicTool({
+        description: [
+          `An input/parameter/argument less tool to transfer control to the ${this.internalName} agent.`,
+          // `Handoff to the ${this.internalName} agent to handle the request`,
+          // `Do not include any parameters/inputs. The agent have access to all the context it needs.`,
+          config.handoffDescription
+        ].filter(Boolean).join(" "),
+        inputSchema: jsonSchema({
+          type: "object",
+          properties: {},
+          additionalProperties: true
+        }),
+        execute: async (_, options) => {
+          const state = toState(options);
+          state.currentActiveAgent = this.internalName;
+          return `Transfer successful to ${this.internalName}.`;
+        }
+      })
+    };
+  }
+  get transfer_tools() {
+    return Object.fromEntries(
+      this.toHandoffs().flatMap((it) => Object.entries(it.handoffTool))
+    );
+  }
+  get toolsNames() {
+    return [
+      // Note: do not add the handoff tool itself otherwise it'd create a agent recursion/loop
+      ...Object.keys(this.transfer_tools),
+      ...Object.keys(this.handoff.tools)
+    ];
+  }
+  #prepareInstructions(contextVariables) {
+    return [
+      typeof this.handoff.instructions === "function" ? this.handoff.instructions(contextVariables) : Array.isArray(this.handoff.instructions) ? this.handoff.instructions.join("\n") : this.handoff.instructions,
+      "",
+      ""
+    ].join("\n");
+  }
+  instructions(contextVariables) {
+    const text = this.#prepareInstructions(contextVariables);
+    const handoffsData = this.toHandoffs();
+    if (handoffsData.length === 0) {
+      return text.replace("<specialized_agents_placeholder>", " ");
+    }
+    const handoffs = [
+      "## Specialized Agents",
+      "| Agent Name | Agent Description |",
+      "| --- | --- |",
+      ...handoffsData.map(
+        (hf) => `| ${hf.handoff.name} | ${hf.handoff.handoffDescription || "No description available"} |`
+      ),
+      "",
+      ""
+    ].join("\n");
+    return text.replace("<specialized_agents_placeholder>", handoffs);
+  }
+  toHandoffs() {
+    const hfs = [];
+    for (const it of this.handoffs ?? []) {
+      const hf = typeof it === "function" ? it() : it;
+      hf.parent = this;
+      hfs.push(hf);
+    }
+    return hfs;
+  }
+  asTool(props) {
+    return tool({
+      description: props?.toolDescription || this.handoff.handoffDescription,
+      inputSchema: z.object({
+        input: z.string()
+      }),
+      execute: async ({ input: input2 }, options) => {
+        try {
+          const result = await generateText2({
+            model: this.model,
+            system: this.#prepareInstructions(),
+            prompt: input2,
+            temperature: 0,
+            tools: this.handoff.tools,
+            abortSignal: options.abortSignal,
+            stopWhen: stepCountIs2(25),
+            experimental_context: options.experimental_context,
+            experimental_output: this.output ? Output2.object({ schema: this.output }) : void 0,
+            onStepFinish: (step) => {
+              const toolCall = step.toolCalls.at(-1);
+              if (toolCall) {
+                console.log(
+                  `Debug: ${chalk2.yellow("ToolCalled")}: ${toolCall.toolName}(${JSON.stringify(toolCall.input)})`
+                );
+              }
+            },
+            prepareStep: prepareStep(
+              this,
+              this.model,
+              options.experimental_context
+            )
+          });
+          if (props?.outputExtractor) {
+            return await props.outputExtractor(result);
+          }
+          return result.steps.map((it) => it.toolResults).flat();
+        } catch (error) {
+          console.error(error);
+          return `Error: ${JSON.stringify(error)}`;
+        }
+      }
+    });
+  }
+  toTool(props) {
+    return { [this.handoffToolName]: this.asTool(props) };
+  }
+  debug(prefix = "") {
+    console.log(
+      `Debug: ${chalk2.bgMagenta("Agent")}: ${chalk2.bold(this.handoff.name)}`
+    );
+    const transferTools = this.toolsNames.filter((toolName) => toolName.startsWith("transfer_to")).map((toolName) => toolName.replace("transfer_to_", ""));
+    const agentTools = this.toolsNames.filter(
+      (toolName) => !toolName.startsWith("transfer_to")
+    );
+    console.log(
+      `Debug: ${chalk2.blue("TransferTools")}: ${transferTools.length ? transferTools : "None"}`
+    );
+    console.log(
+      `Debug: ${chalk2.blue("Agent Tools")}: ${agentTools.length ? agentTools : "None"}`
+    );
+  }
+  toToolset(options) {
+    const tools = flattenTools(
+      this,
+      (node) => node.toHandoffs(),
+      (node) => node.handoff.tools
+    );
+    return {
+      ...Object.fromEntries(tools.flatMap((it) => Object.entries(it))),
+      ...options?.includeTransferTool !== false ? this.transfer_tools : {},
+      ...options?.includeHandoffs !== false ? this.handoffTool : {}
+    };
+  }
+  clone(agent2) {
+    return new _Agent({
+      prepareHandoff: (messages) => {
+        this.prepareHandoff?.(messages);
+      },
+      model: agent2?.model ?? this.model,
+      toolChoice: agent2?.toolChoice ?? this.toolChoice,
+      prompt: agent2?.prompt ?? this.handoff.instructions,
+      tools: agent2?.tools ?? this.handoff.tools,
+      name: agent2?.name ?? this.handoff.name,
+      handoffDescription: agent2?.handoffDescription ?? this.handoff.handoffDescription,
+      handoffs: [...this.handoffs],
+      output: agent2?.output ?? this.output
+    });
+  }
+};
+function flattenTools(root, getChildren, extract) {
+  const stack = [root];
+  const visited = /* @__PURE__ */ new Set();
+  const result = [];
+  while (stack.length) {
+    const node = stack.pop();
+    if (visited.has(node)) continue;
+    visited.add(node);
+    result.push(extract(node));
+    stack.push(...getChildren(node));
+  }
+  return result;
+}
+function instructions({ purpose, routine }) {
+  const lines = [
+    "# Agent Context",
+    ...Array.isArray(purpose) ? purpose : [purpose],
+    "",
+    "",
+    "<specialized_agents_placeholder>"
+  ];
+  if (routine.length) {
+    lines.push(
+      `Use the following routine to fulfill the task.`,
+      `# Routine`,
+      ...routine.map((it, i) => `${i + 1}. ${it}`)
+    );
+  }
+  return lines.join("\n");
+}
+instructions.swarm = ({ purpose, routine }) => {
+  const lines = [
+    RECOMMENDED_PROMPT_PREFIX,
+    "",
+    "",
+    "# Agent Context",
+    ...Array.isArray(purpose) ? purpose : [purpose],
+    "",
+    "",
+    "<specialized_agents_placeholder>"
+  ];
+  if (routine.length) {
+    lines.push(
+      `Use the following routine to fulfill the task.`,
+      `# Routine`,
+      ...routine.map((it, i) => `${i + 1}. ${it}`)
+    );
+  }
+  return lines.join("\n");
+};
+instructions.supervisor = ({
+  purpose,
+  routine
+}) => {
+  const lines = [
+    SUPERVISOR_PROMPT_PREFIX,
+    "",
+    "",
+    "# Agent Context",
+    ...Array.isArray(purpose) ? purpose : [purpose],
+    "",
+    "",
+    "<specialized_agents_placeholder>"
+  ];
+  if (routine.length) {
+    lines.push(
+      `Use the following routine to fulfill the task.`,
+      `# Routine`,
+      ...routine.filter(Boolean).map((it, i) => `${i + 1}. ${it}`)
+    );
+  }
+  return lines.join("\n");
+};
+instructions.supervisor_subagent = ({
+  purpose,
+  routine
+}) => {
+  const lines = [
+    SUPERVISOR_PROMPT_PREFIX,
+    "",
+    "",
+    "# Agent Context",
+    ...Array.isArray(purpose) ? purpose : [purpose],
+    ""
+  ];
+  if (routine.length) {
+    lines.push(
+      `Use the following routine to fulfill the task. Execute ALL steps immediately.`,
+      `# Routine`,
+      ...routine.map((it, i) => `${i + 1}. ${it}`),
+      `${routine.length + 1}. transfer_to_supervisor_agent`
+      // `1. IMMEDIATELY START: ${routine[0]}`,
+      // ...routine.slice(1).map((it, i) => `${i + 2}. ${it}`),
+      // `${routine.length + 1}. STOP HERE - Do not do any other agent's work`,
+      // `${routine.length + 2}. MANDATORY: You MUST call transfer_to_supervisor_agent function RIGHT NOW to return control`,
+      // `${routine.length + 3}. DO NOT END YOUR RESPONSE WITHOUT CALLING THE TRANSFER FUNCTION`,
+    );
+  } else {
+    lines.push(
+      "CRITICAL: end the generation by calling transfer_to_supervisor_agent tool"
+    );
+  }
+  return lines.join("\n");
+};
+function isTransferToolResult(call) {
+  if (!call) {
+    return false;
+  }
+  if (typeof call !== "object") {
+    return false;
+  }
+  if (!("output" in call)) {
+    return false;
+  }
+  const lastActiveAgent = call.output.lastActiveAgent;
+  if (!lastActiveAgent) {
+    return false;
+  }
+  return true;
+}
+function lastTransferResult(messages) {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const message = messages[i];
+    for (let i2 = message.parts.length - 1; i2 >= 0; i2--) {
+      const part = message.parts[i2];
+      if (part.type === "dynamic-tool" && part.toolName.startsWith("transfer_to_") && part.state === "output-available" && isTransferToolResult(part)) {
+        return part.output;
+      }
+    }
+  }
+  return void 0;
+}
+
+// packages/agent/src/lib/models.ts
+import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
+import { embedMany } from "ai";
+var lmstudio = createOpenAICompatible({
+  name: "lmstudio",
+  baseURL: "http://127.0.0.1:1234/v1",
+  supportsStructuredOutputs: true,
+  includeUsage: true
+});
+var glm = createOpenAICompatible({
+  name: "z.ai",
+  baseURL: "https://api.z.ai/api/paas/v4/",
+  apiKey: process.env.ZAI_API_KEY
+});
+async function embed(documents) {
+  const dimensions = 1024;
+  const { embeddings } = await embedMany({
+    model: lmstudio.textEmbeddingModel("text-embedding-qwen3-embedding-0.6b"),
+    values: documents,
+    providerOptions: { lmstudio: { dimensions } }
+  });
+  return { embeddings, dimensions };
+}
+export {
+  Agent,
+  agent,
+  confirm,
+  embed,
+  execute,
+  finished,
+  generate,
+  glm,
+  input,
+  instructions,
+  isTransferToolResult,
+  last,
+  lastTransferResult,
+  lmstudio,
+  messageToUiMessage,
+  prepareAgent,
+  prepareStep,
+  printer,
+  run,
+  stream,
+  streamWrite,
+  swarm,
+  toOutput,
+  toState,
+  user
+};
+//# sourceMappingURL=index.js.map