@upstash/workflow 0.2.5-agents → 0.2.5-agents-2

package/astro.d.mts

@@ -1,9 +1,8 @@
 import { APIContext, APIRoute } from 'astro';
-import { b as WorkflowContext, j as PublicServeOptions } from './types-BEyIoCRe.mjs';
+import { b as WorkflowContext, j as PublicServeOptions } from './types-D9gwTj2n.mjs';
 import '@upstash/qstash';
 import 'ai';
 import '@ai-sdk/openai';
-import 'langchain/tools';
 
 declare function serve<TInitialPayload = unknown>(routeFunction: (workflowContext: WorkflowContext<TInitialPayload>, apiContext: APIContext) => Promise<void>, options?: PublicServeOptions<TInitialPayload>): {
     POST: APIRoute;

package/astro.d.ts

@@ -1,9 +1,8 @@
 import { APIContext, APIRoute } from 'astro';
-import { b as WorkflowContext, j as PublicServeOptions } from './types-BEyIoCRe.js';
+import { b as WorkflowContext, j as PublicServeOptions } from './types-D9gwTj2n.js';
 import '@upstash/qstash';
 import 'ai';
 import '@ai-sdk/openai';
-import 'langchain/tools';
 
 declare function serve<TInitialPayload = unknown>(routeFunction: (workflowContext: WorkflowContext<TInitialPayload>, apiContext: APIContext) => Promise<void>, options?: PublicServeOptions<TInitialPayload>): {
     POST: APIRoute;

package/astro.js

@@ -826,29 +826,16 @@ var triggerWorkflowDelete = async (workflowContext, debug, cancel = false) => {
   await debug?.log("SUBMIT", "SUBMIT_CLEANUP", {
     deletedWorkflowRunId: workflowContext.workflowRunId
   });
-  try {
-    await workflowContext.qstashClient.http.request({
-      path: ["v2", "workflows", "runs", `${workflowContext.workflowRunId}?cancel=${cancel}`],
-      method: "DELETE",
-      parseResponseAsJson: false
-    });
-    await debug?.log(
-      "SUBMIT",
-      "SUBMIT_CLEANUP",
-      `workflow run ${workflowContext.workflowRunId} deleted.`
-    );
-    return { deleted: true };
-  } catch (error) {
-    if (error instanceof import_qstash3.QstashError && error.status === 404) {
-      await debug?.log("WARN", "SUBMIT_CLEANUP", {
-        message: `Failed to remove workflow run ${workflowContext.workflowRunId} as it doesn't exist.`,
-        name: error.name,
-        errorMessage: error.message
-      });
-      return { deleted: false };
-    }
-    throw error;
-  }
+  await workflowContext.qstashClient.http.request({
+    path: ["v2", "workflows", "runs", `${workflowContext.workflowRunId}?cancel=${cancel}`],
+    method: "DELETE",
+    parseResponseAsJson: false
+  });
+  await debug?.log(
+    "SUBMIT",
+    "SUBMIT_CLEANUP",
+    `workflow run ${workflowContext.workflowRunId} deleted.`
+  );
 };
 var recreateUserHeaders = (headers) => {
   const filteredHeaders = new Headers();
@@ -1635,7 +1622,22 @@ var WorkflowApi = class extends BaseWorkflowApi {
 // src/agents/adapters.ts
 var import_openai2 = require("@ai-sdk/openai");
 var import_ai = require("ai");
+
+// src/agents/constants.ts
 var AGENT_NAME_HEADER = "upstash-agent-name";
+var MANAGER_AGENT_PROMPT = `You are an agent orchestrating other AI Agents.
+
+These other agents have tools available to them.
+
+Given a prompt, utilize these agents to address requests.
+
+Don't always call all the agents provided to you at the same time. You can call one and use it's response to call another.
+
+Avoid calling the same agent twice in one turn. Instead, prefer to call it once but provide everything
+you need from that agent.
+`;
+
+// src/agents/adapters.ts
 var createWorkflowOpenAI = (context) => {
   return (0, import_openai2.createOpenAI)({
     compatibility: "strict",
@@ -1702,8 +1704,7 @@ var convertLangchainTool = (langchainTool) => {
   return (0, import_ai.tool)({
     description: langchainTool.description,
     parameters: langchainTool.schema,
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    execute: async (param) => langchainTool.invoke(param)
+    execute: async (...param) => langchainTool.invoke(...param)
   });
 };
 
@@ -1716,16 +1717,24 @@ var Agent = class {
   maxSteps;
   background;
   model;
-  constructor({ tools, maxSteps, background, name, model }) {
+  temparature;
+  constructor({ tools, maxSteps, background, name, model, temparature = 0.1 }) {
     this.name = name;
     this.tools = tools ?? {};
     this.maxSteps = maxSteps;
     this.background = background;
     this.model = model;
+    this.temparature = temparature;
   }
+  /**
+   * Trigger the agent by passing a prompt
+   *
+   * @param prompt task to assign to the agent
+   * @returns Response as `{ text: string }`
+   */
   async call({ prompt }) {
     try {
-      return await (0, import_ai2.generateText)({
+      const result = await (0, import_ai2.generateText)({
         model: this.model,
         tools: this.tools,
         maxSteps: this.maxSteps,
@@ -1733,8 +1742,10 @@ var Agent = class {
         prompt,
         headers: {
           [AGENT_NAME_HEADER]: this.name
-        }
+        },
+        temperature: this.temparature
       });
+      return { text: result.text };
     } catch (error) {
       if (error instanceof import_ai2.ToolExecutionError) {
         if (error.cause instanceof Error && error.cause.name === "WorkflowAbort") {
@@ -1749,6 +1760,11 @@ var Agent = class {
       }
     }
   }
+  /**
+   * Convert the agent to a tool which can be used by other agents.
+   *
+   * @returns the agent as a tool
+   */
   asTool() {
     const toolDescriptions = Object.values(this.tools).map((tool3) => tool3.description).join("\n");
     return (0, import_ai2.tool)({
@@ -1760,18 +1776,25 @@ var Agent = class {
     });
   }
 };
-var MANAGER_AGENT_PROMPT = `You are an AI agent who orchestrates other AI Agents.
-These other agents have tools available to them.
-Given a prompt, utilize these agents to address requests.
-Don't always call all the agents provided to you at the same time. You can call one and use it's response to call another. 
-`;
 var ManagerAgent = class extends Agent {
   agents;
+  /**
+   * A manager agent which coordinates agents available to it to achieve a
+   * given task
+   *
+   * @param name Name of the agent
+   * @param background Background of the agent. If not passed, default will be used.
+   * @param model LLM model to use
+   * @param agents: List of agents available to the agent
+   * @param maxSteps number of times the manager agent can call the LLM at most.
+   *   If the agent abruptly stops execution after calling other agents, you may
+   *   need to increase maxSteps
+   */
   constructor({
-    maxSteps,
-    background = MANAGER_AGENT_PROMPT,
     agents,
+    background = MANAGER_AGENT_PROMPT,
     model,
+    maxSteps,
     name = "manager llm"
   }) {
     super({
@@ -1796,6 +1819,11 @@ var Task = class {
     this.context = context;
     this.taskParameters = taskParameters;
   }
+  /**
+   * Run the agents to complete the task
+   *
+   * @returns Result of the task as { text: string }
+   */
   async run() {
     const { prompt, ...otherParams } = this.taskParameters;
     const safePrompt = await this.context.run("Get Prompt", () => prompt);
@@ -1826,6 +1854,29 @@ var WorkflowAgents = class {
   constructor({ context }) {
     this.context = context;
   }
+  /**
+   * Defines an agent
+   *
+   * ```ts
+   * const researcherAgent = context.agents.agent({
+   *   model,
+   *   name: 'academic',
+   *   maxSteps: 2,
+   *   tools: {
+   *     wikiTool: new WikipediaQueryRun({
+   *       topKResults: 1,
+   *       maxDocContentLength: 500,
+   *     })
+   *   },
+   *   background:
+   *     'You are researcher agent with access to Wikipedia. ' +
+   *     'Utilize Wikipedia as much as possible for correct information',
+   * });
+   * ```
+   *
+   * @param params agent parameters
+   * @returns
+   */
   agent(params) {
     const wrappedTools = wrapTools({ context: this.context, tools: params.tools });
     return new Agent({
@@ -1836,6 +1887,9 @@ var WorkflowAgents = class {
   task(taskParameters) {
     return new Task({ context: this.context, taskParameters });
   }
+  /**
+   * creates an openai model for agents
+   */
   openai(...params) {
     const openai2 = createWorkflowOpenAI(this.context);
     return openai2(...params);
@@ -2436,7 +2490,6 @@ var checkIfLastOneIsDuplicate = async (steps, debug) => {
     if (step.stepId === lastStepId && step.targetStep === lastTargetStepId) {
       const message = `Upstash Workflow: The step '${step.stepName}' with id '${step.stepId}'  has run twice during workflow execution. Rest of the workflow will continue running as usual.`;
       await debug?.log("WARN", "RESPONSE_DEFAULT", message);
-      console.log(steps);
       console.warn(message);
       return true;
     }

package/astro.mjs

@@ -1,8 +1,7 @@
 import {
   SDK_TELEMETRY,
   serveBase
-} from "./chunk-RFX5YRRT.mjs";
-import "./chunk-PU5J4TNC.mjs";
+} from "./chunk-VOM3CFYZ.mjs";
 
 // platforms/astro.ts
 function serve(routeFunction, options) {

package/{chunk-RFX5YRRT.mjs → chunk-VOM3CFYZ.mjs}

@@ -1,6 +1,34 @@
-import {
-  WorkflowAgents
-} from "./chunk-PU5J4TNC.mjs";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 
 // src/constants.ts
 var WORKFLOW_ID_HEADER = "Upstash-Workflow-RunId";
@@ -811,29 +839,16 @@ var triggerWorkflowDelete = async (workflowContext, debug, cancel = false) => {
   await debug?.log("SUBMIT", "SUBMIT_CLEANUP", {
     deletedWorkflowRunId: workflowContext.workflowRunId
   });
-  try {
-    await workflowContext.qstashClient.http.request({
-      path: ["v2", "workflows", "runs", `${workflowContext.workflowRunId}?cancel=${cancel}`],
-      method: "DELETE",
-      parseResponseAsJson: false
-    });
-    await debug?.log(
-      "SUBMIT",
-      "SUBMIT_CLEANUP",
-      `workflow run ${workflowContext.workflowRunId} deleted.`
-    );
-    return { deleted: true };
-  } catch (error) {
-    if (error instanceof QstashError3 && error.status === 404) {
-      await debug?.log("WARN", "SUBMIT_CLEANUP", {
-        message: `Failed to remove workflow run ${workflowContext.workflowRunId} as it doesn't exist.`,
-        name: error.name,
-        errorMessage: error.message
-      });
-      return { deleted: false };
-    }
-    throw error;
-  }
+  await workflowContext.qstashClient.http.request({
+    path: ["v2", "workflows", "runs", `${workflowContext.workflowRunId}?cancel=${cancel}`],
+    method: "DELETE",
+    parseResponseAsJson: false
+  });
+  await debug?.log(
+    "SUBMIT",
+    "SUBMIT_CLEANUP",
+    `workflow run ${workflowContext.workflowRunId} deleted.`
+  );
 };
 var recreateUserHeaders = (headers) => {
   const filteredHeaders = new Headers();
@@ -1617,6 +1632,283 @@ var WorkflowApi = class extends BaseWorkflowApi {
   }
 };
 
+// src/agents/adapters.ts
+import { createOpenAI } from "@ai-sdk/openai";
+import { tool } from "ai";
+
+// src/agents/constants.ts
+var AGENT_NAME_HEADER = "upstash-agent-name";
+var MANAGER_AGENT_PROMPT = `You are an agent orchestrating other AI Agents.
+
+These other agents have tools available to them.
+
+Given a prompt, utilize these agents to address requests.
+
+Don't always call all the agents provided to you at the same time. You can call one and use it's response to call another.
+
+Avoid calling the same agent twice in one turn. Instead, prefer to call it once but provide everything
+you need from that agent.
+`;
+
+// src/agents/adapters.ts
+var createWorkflowOpenAI = (context) => {
+  return createOpenAI({
+    compatibility: "strict",
+    fetch: async (input, init) => {
+      try {
+        const headers = init?.headers ? Object.fromEntries(new Headers(init.headers).entries()) : {};
+        const body = init?.body ? JSON.parse(init.body) : void 0;
+        const agentName = headers[AGENT_NAME_HEADER];
+        const stepName = agentName ? `Call Agent ${agentName}` : "Call Agent";
+        const responseInfo = await context.call(stepName, {
+          url: input.toString(),
+          method: init?.method,
+          headers,
+          body
+        });
+        const responseHeaders = new Headers(
+          Object.entries(responseInfo.header).reduce(
+            (acc, [key, values]) => {
+              acc[key] = values.join(", ");
+              return acc;
+            },
+            {}
+          )
+        );
+        return new Response(JSON.stringify(responseInfo.body), {
+          status: responseInfo.status,
+          headers: responseHeaders
+        });
+      } catch (error) {
+        if (error instanceof Error && error.name === "WorkflowAbort") {
+          throw error;
+        } else {
+          console.error("Error in fetch implementation:", error);
+          throw error;
+        }
+      }
+    }
+  });
+};
+var wrapTools = ({
+  context,
+  tools
+}) => {
+  return Object.fromEntries(
+    Object.entries(tools).map((toolInfo) => {
+      const [toolName, tool3] = toolInfo;
+      const aiSDKTool = convertToAISDKTool(tool3);
+      const execute = aiSDKTool.execute;
+      if (execute) {
+        const wrappedExecute = (...params) => {
+          return context.run(`Run tool ${toolName}`, () => execute(...params));
+        };
+        aiSDKTool.execute = wrappedExecute;
+      }
+      return [toolName, aiSDKTool];
+    })
+  );
+};
+var convertToAISDKTool = (tool3) => {
+  const isLangchainTool = "invoke" in tool3;
+  return isLangchainTool ? convertLangchainTool(tool3) : tool3;
+};
+var convertLangchainTool = (langchainTool) => {
+  return tool({
+    description: langchainTool.description,
+    parameters: langchainTool.schema,
+    execute: async (...param) => langchainTool.invoke(...param)
+  });
+};
+
+// src/agents/agent.ts
+import { z } from "zod";
+import { generateText, tool as tool2, ToolExecutionError } from "ai";
+var Agent = class {
+  name;
+  tools;
+  maxSteps;
+  background;
+  model;
+  temparature;
+  constructor({ tools, maxSteps, background, name, model, temparature = 0.1 }) {
+    this.name = name;
+    this.tools = tools ?? {};
+    this.maxSteps = maxSteps;
+    this.background = background;
+    this.model = model;
+    this.temparature = temparature;
+  }
+  /**
+   * Trigger the agent by passing a prompt
+   *
+   * @param prompt task to assign to the agent
+   * @returns Response as `{ text: string }`
+   */
+  async call({ prompt }) {
+    try {
+      const result = await generateText({
+        model: this.model,
+        tools: this.tools,
+        maxSteps: this.maxSteps,
+        system: this.background,
+        prompt,
+        headers: {
+          [AGENT_NAME_HEADER]: this.name
+        },
+        temperature: this.temparature
+      });
+      return { text: result.text };
+    } catch (error) {
+      if (error instanceof ToolExecutionError) {
+        if (error.cause instanceof Error && error.cause.name === "WorkflowAbort") {
+          throw error.cause;
+        } else if (error.cause instanceof ToolExecutionError && error.cause.cause instanceof Error && error.cause.cause.name === "WorkflowAbort") {
+          throw error.cause.cause;
+        } else {
+          throw error;
+        }
+      } else {
+        throw error;
+      }
+    }
+  }
+  /**
+   * Convert the agent to a tool which can be used by other agents.
+   *
+   * @returns the agent as a tool
+   */
+  asTool() {
+    const toolDescriptions = Object.values(this.tools).map((tool3) => tool3.description).join("\n");
+    return tool2({
+      parameters: z.object({ prompt: z.string() }),
+      execute: async ({ prompt }) => {
+        return await this.call({ prompt });
+      },
+      description: `An AI Agent with the following background: ${this.background}Has access to the following tools: ${toolDescriptions}`
+    });
+  }
+};
+var ManagerAgent = class extends Agent {
+  agents;
+  /**
+   * A manager agent which coordinates agents available to it to achieve a
+   * given task
+   *
+   * @param name Name of the agent
+   * @param background Background of the agent. If not passed, default will be used.
+   * @param model LLM model to use
+   * @param agents: List of agents available to the agent
+   * @param maxSteps number of times the manager agent can call the LLM at most.
+   *   If the agent abruptly stops execution after calling other agents, you may
+   *   need to increase maxSteps
+   */
+  constructor({
+    agents,
+    background = MANAGER_AGENT_PROMPT,
+    model,
+    maxSteps,
+    name = "manager llm"
+  }) {
+    super({
+      background,
+      maxSteps,
+      tools: Object.fromEntries(agents.map((agent) => [agent.name, agent.asTool()])),
+      name,
+      model
+    });
+    this.agents = agents;
+  }
+};
+
+// src/agents/task.ts
+var Task = class {
+  context;
+  taskParameters;
+  constructor({
+    context,
+    taskParameters
+  }) {
+    this.context = context;
+    this.taskParameters = taskParameters;
+  }
+  /**
+   * Run the agents to complete the task
+   *
+   * @returns Result of the task as { text: string }
+   */
+  async run() {
+    const { prompt, ...otherParams } = this.taskParameters;
+    const safePrompt = await this.context.run("Get Prompt", () => prompt);
+    if ("agent" in otherParams) {
+      const agent = otherParams.agent;
+      const result = await agent.call({
+        prompt: safePrompt
+      });
+      return { text: result.text };
+    } else {
+      const { agents, maxSteps, model, background } = otherParams;
+      const managerAgent = new ManagerAgent({
+        model,
+        maxSteps,
+        agents,
+        name: "Manager LLM",
+        background
+      });
+      const result = await managerAgent.call({ prompt: safePrompt });
+      return { text: result.text };
+    }
+  }
+};
+
+// src/agents/index.ts
+var WorkflowAgents = class {
+  context;
+  constructor({ context }) {
+    this.context = context;
+  }
+  /**
+   * Defines an agent
+   *
+   * ```ts
+   * const researcherAgent = context.agents.agent({
+   *   model,
+   *   name: 'academic',
+   *   maxSteps: 2,
+   *   tools: {
+   *     wikiTool: new WikipediaQueryRun({
+   *       topKResults: 1,
+   *       maxDocContentLength: 500,
+   *     })
+   *   },
+   *   background:
+   *     'You are researcher agent with access to Wikipedia. ' +
+   *     'Utilize Wikipedia as much as possible for correct information',
+   * });
+   * ```
+   *
+   * @param params agent parameters
+   * @returns
+   */
+  agent(params) {
+    const wrappedTools = wrapTools({ context: this.context, tools: params.tools });
+    return new Agent({
+      ...params,
+      tools: wrappedTools
+    });
+  }
+  task(taskParameters) {
+    return new Task({ context: this.context, taskParameters });
+  }
+  /**
+   * creates an openai model for agents
+   */
+  openai(...params) {
+    const openai2 = createWorkflowOpenAI(this.context);
+    return openai2(...params);
+  }
+};
+
 // src/context/context.ts
 var WorkflowContext = class {
   executor;
@@ -2211,7 +2503,6 @@ var checkIfLastOneIsDuplicate = async (steps, debug) => {
     if (step.stepId === lastStepId && step.targetStep === lastTargetStepId) {
       const message = `Upstash Workflow: The step '${step.stepName}' with id '${step.stepId}'  has run twice during workflow execution. Rest of the workflow will continue running as usual.`;
       await debug?.log("WARN", "RESPONSE_DEFAULT", message);
-      console.log(steps);
       console.warn(message);
       return true;
     }
@@ -2571,6 +2862,9 @@ var serve = (routeFunction, options) => {
 };
 
 export {
+  __require,
+  __commonJS,
+  __toESM,
   makeNotifyRequest,
   makeGetWaitersRequest,
   SDK_TELEMETRY,

package/cloudflare.d.mts

@@ -1,8 +1,7 @@
-import { R as RouteFunction, j as PublicServeOptions } from './types-BEyIoCRe.mjs';
+import { R as RouteFunction, j as PublicServeOptions } from './types-D9gwTj2n.mjs';
 import '@upstash/qstash';
 import 'ai';
 import '@ai-sdk/openai';
-import 'langchain/tools';
 
 type WorkflowBindings = {
     QSTASH_TOKEN: string;

package/cloudflare.d.ts

@@ -1,8 +1,7 @@
-import { R as RouteFunction, j as PublicServeOptions } from './types-BEyIoCRe.js';
+import { R as RouteFunction, j as PublicServeOptions } from './types-D9gwTj2n.js';
 import '@upstash/qstash';
 import 'ai';
 import '@ai-sdk/openai';
-import 'langchain/tools';
 
 type WorkflowBindings = {
     QSTASH_TOKEN: string;