@upstash/workflow 0.2.4 → 0.2.5-agents

package/svelte.js

@@ -1632,6 +1632,216 @@ var WorkflowApi = class extends BaseWorkflowApi {
   }
 };
 
+// src/agents/adapters.ts
+var import_openai2 = require("@ai-sdk/openai");
+var import_ai = require("ai");
+var AGENT_NAME_HEADER = "upstash-agent-name";
+var createWorkflowOpenAI = (context) => {
+  return (0, import_openai2.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 (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)
+  });
+};
+
+// src/agents/agent.ts
+var import_zod = require("zod");
+var import_ai2 = require("ai");
+var Agent = class {
+  name;
+  tools;
+  maxSteps;
+  background;
+  model;
+  constructor({ tools, maxSteps, background, name, model }) {
+    this.name = name;
+    this.tools = tools ?? {};
+    this.maxSteps = maxSteps;
+    this.background = background;
+    this.model = model;
+  }
+  async call({ prompt }) {
+    try {
+      return await (0, import_ai2.generateText)({
+        model: this.model,
+        tools: this.tools,
+        maxSteps: this.maxSteps,
+        system: this.background,
+        prompt,
+        headers: {
+          [AGENT_NAME_HEADER]: this.name
+        }
+      });
+    } catch (error) {
+      if (error instanceof import_ai2.ToolExecutionError) {
+        if (error.cause instanceof Error && error.cause.name === "WorkflowAbort") {
+          throw error.cause;
+        } else if (error.cause instanceof import_ai2.ToolExecutionError && error.cause.cause instanceof Error && error.cause.cause.name === "WorkflowAbort") {
+          throw error.cause.cause;
+        } else {
+          throw error;
+        }
+      } else {
+        throw error;
+      }
+    }
+  }
+  asTool() {
+    const toolDescriptions = Object.values(this.tools).map((tool3) => tool3.description).join("\n");
+    return (0, import_ai2.tool)({
+      parameters: import_zod.z.object({ prompt: import_zod.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 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;
+  constructor({
+    maxSteps,
+    background = MANAGER_AGENT_PROMPT,
+    agents,
+    model,
+    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;
+  }
+  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;
+  }
+  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 });
+  }
+  openai(...params) {
+    const openai2 = createWorkflowOpenAI(this.context);
+    return openai2(...params);
+  }
+};
+
 // src/context/context.ts
 var WorkflowContext = class {
   executor;
@@ -2017,6 +2227,11 @@ var WorkflowContext = class {
       context: this
     });
   }
+  get agents() {
+    return new WorkflowAgents({
+      context: this
+    });
+  }
 };
 
 // src/logger.ts
@@ -2221,6 +2436,7 @@ 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/svelte.mjs

@@ -1,7 +1,8 @@
 import {
   SDK_TELEMETRY,
   serveBase
-} from "./chunk-ETDFMXER.mjs";
+} from "./chunk-RFX5YRRT.mjs";
+import "./chunk-PU5J4TNC.mjs";
 
 // platforms/svelte.ts
 var serve = (routeFunction, options) => {

package/{types-Bt4-paRy.d.mts → types-BEyIoCRe.d.mts}

@@ -1,4 +1,8 @@
 import { PublishRequest, Client, Receiver, HTTPMethods as HTTPMethods$1 } from '@upstash/qstash';
+import * as ai from 'ai';
+import { CoreTool, generateText } from 'ai';
+import * as _ai_sdk_openai from '@ai-sdk/openai';
+import { Tool } from 'langchain/tools';
 
 /**
  * Base class outlining steps. Basically, each step kind (run/sleep/sleepUntil)
@@ -387,6 +391,76 @@ declare class WorkflowApi extends BaseWorkflowApi {
     get anthropic(): AnthropicAPI;
 }
 
+declare class Agent {
+    readonly name: AgentParameters["name"];
+    readonly tools: AgentParameters["tools"];
+    readonly maxSteps: AgentParameters["maxSteps"];
+    readonly background: AgentParameters["background"];
+    readonly model: AgentParameters["model"];
+    constructor({ tools, maxSteps, background, name, model }: AgentParameters);
+    call({ prompt }: {
+        prompt: string;
+    }): Promise<ai.GenerateTextResult<Record<string, AISDKTool>, never>>;
+    asTool(): AISDKTool;
+}
+type ManagerAgentParameters = {
+    agents: Agent[];
+    model: Model;
+} & Pick<Partial<AgentParameters>, "name" | "background"> & Pick<AgentParameters, "maxSteps">;
+declare class ManagerAgent extends Agent {
+    agents: ManagerAgentParameters["agents"];
+    constructor({ maxSteps, background, agents, model, name, }: ManagerAgentParameters);
+}
+
+type AISDKTool = CoreTool;
+type LangchainTool = Tool;
+type GenerateTextParams = Parameters<typeof generateText>[0];
+type Model = GenerateTextParams["model"];
+type AgentParameters<TTool extends AISDKTool | LangchainTool = AISDKTool> = {
+    maxSteps: number;
+    background: string;
+    tools: Record<string, TTool>;
+    name: string;
+    model: Model;
+};
+type TaskParams = {
+    prompt: string;
+};
+type SingleAgentTaskParams = TaskParams & {
+    agent: Agent;
+};
+type MultiAgentTaskParams = TaskParams & {
+    agents: Agent[];
+    maxSteps: number;
+    model: Model;
+    background?: string;
+};
+
+declare const createWorkflowOpenAI: (context: WorkflowContext) => _ai_sdk_openai.OpenAIProvider;
+
+declare class Task {
+    private readonly context;
+    private readonly taskParameters;
+    constructor({ context, taskParameters, }: {
+        context: WorkflowContext;
+        taskParameters: SingleAgentTaskParams | MultiAgentTaskParams;
+    });
+    run(): Promise<{
+        text: string;
+    }>;
+}
+
+declare class WorkflowAgents {
+    private context;
+    constructor({ context }: {
+        context: WorkflowContext;
+    });
+    agent(params: AgentParameters<AISDKTool | LangchainTool>): Agent;
+    task(taskParameters: SingleAgentTaskParams): Task;
+    task(taskParameters: MultiAgentTaskParams): Task;
+    openai(...params: Parameters<ReturnType<typeof createWorkflowOpenAI>>): ai.LanguageModelV1;
+}
+
 /**
  * Upstash Workflow context
  *
@@ -682,6 +756,7 @@ declare class WorkflowContext<TInitialPayload = unknown> {
      */
     protected addStep<TResult = unknown>(step: BaseLazyStep<TResult>): Promise<TResult>;
     get api(): WorkflowApi;
+    get agents(): WorkflowAgents;
 }
 
 /**
@@ -1057,4 +1132,4 @@ type HeaderParams = {
     callTimeout?: never;
 });
 
-export { type AsyncStepFunction as A, type CallResponse as C, type Duration as D, type FinishCondition as F, type HeaderParams as H, type LogLevel as L, type NotifyResponse as N, type ParallelCallState as P, type RouteFunction as R, type Step as S, type Telemetry as T, type WorkflowServeOptions as W, type Waiter as a, WorkflowContext as b, type WorkflowClient as c, type WorkflowReceiver as d, StepTypes as e, type StepType as f, type RawStep as g, type SyncStepFunction as h, type StepFunction as i, type PublicServeOptions as j, type FailureFunctionPayload as k, type RequiredExceptFields as l, type WaitRequest as m, type WaitStepResponse as n, type NotifyStepResponse as o, type WaitEventOptions as p, type CallSettings as q, type WorkflowLoggerOptions as r, WorkflowLogger as s };
+export { type AsyncStepFunction as A, type CallResponse as C, type Duration as D, type FinishCondition as F, type HeaderParams as H, type LogLevel as L, ManagerAgent as M, type NotifyResponse as N, type ParallelCallState as P, type RouteFunction as R, type Step as S, type Telemetry as T, type WorkflowServeOptions as W, type Waiter as a, WorkflowContext as b, type WorkflowClient as c, type WorkflowReceiver as d, StepTypes as e, type StepType as f, type RawStep as g, type SyncStepFunction as h, type StepFunction as i, type PublicServeOptions as j, type FailureFunctionPayload as k, type RequiredExceptFields as l, type WaitRequest as m, type WaitStepResponse as n, type NotifyStepResponse as o, type WaitEventOptions as p, type CallSettings as q, type WorkflowLoggerOptions as r, WorkflowLogger as s, WorkflowAgents as t, createWorkflowOpenAI as u, Agent as v };

package/{types-Bt4-paRy.d.ts → types-BEyIoCRe.d.ts}

@@ -1,4 +1,8 @@
 import { PublishRequest, Client, Receiver, HTTPMethods as HTTPMethods$1 } from '@upstash/qstash';
+import * as ai from 'ai';
+import { CoreTool, generateText } from 'ai';
+import * as _ai_sdk_openai from '@ai-sdk/openai';
+import { Tool } from 'langchain/tools';
 
 /**
  * Base class outlining steps. Basically, each step kind (run/sleep/sleepUntil)
@@ -387,6 +391,76 @@ declare class WorkflowApi extends BaseWorkflowApi {
     get anthropic(): AnthropicAPI;
 }
 
+declare class Agent {
+    readonly name: AgentParameters["name"];
+    readonly tools: AgentParameters["tools"];
+    readonly maxSteps: AgentParameters["maxSteps"];
+    readonly background: AgentParameters["background"];
+    readonly model: AgentParameters["model"];
+    constructor({ tools, maxSteps, background, name, model }: AgentParameters);
+    call({ prompt }: {
+        prompt: string;
+    }): Promise<ai.GenerateTextResult<Record<string, AISDKTool>, never>>;
+    asTool(): AISDKTool;
+}
+type ManagerAgentParameters = {
+    agents: Agent[];
+    model: Model;
+} & Pick<Partial<AgentParameters>, "name" | "background"> & Pick<AgentParameters, "maxSteps">;
+declare class ManagerAgent extends Agent {
+    agents: ManagerAgentParameters["agents"];
+    constructor({ maxSteps, background, agents, model, name, }: ManagerAgentParameters);
+}
+
+type AISDKTool = CoreTool;
+type LangchainTool = Tool;
+type GenerateTextParams = Parameters<typeof generateText>[0];
+type Model = GenerateTextParams["model"];
+type AgentParameters<TTool extends AISDKTool | LangchainTool = AISDKTool> = {
+    maxSteps: number;
+    background: string;
+    tools: Record<string, TTool>;
+    name: string;
+    model: Model;
+};
+type TaskParams = {
+    prompt: string;
+};
+type SingleAgentTaskParams = TaskParams & {
+    agent: Agent;
+};
+type MultiAgentTaskParams = TaskParams & {
+    agents: Agent[];
+    maxSteps: number;
+    model: Model;
+    background?: string;
+};
+
+declare const createWorkflowOpenAI: (context: WorkflowContext) => _ai_sdk_openai.OpenAIProvider;
+
+declare class Task {
+    private readonly context;
+    private readonly taskParameters;
+    constructor({ context, taskParameters, }: {
+        context: WorkflowContext;
+        taskParameters: SingleAgentTaskParams | MultiAgentTaskParams;
+    });
+    run(): Promise<{
+        text: string;
+    }>;
+}
+
+declare class WorkflowAgents {
+    private context;
+    constructor({ context }: {
+        context: WorkflowContext;
+    });
+    agent(params: AgentParameters<AISDKTool | LangchainTool>): Agent;
+    task(taskParameters: SingleAgentTaskParams): Task;
+    task(taskParameters: MultiAgentTaskParams): Task;
+    openai(...params: Parameters<ReturnType<typeof createWorkflowOpenAI>>): ai.LanguageModelV1;
+}
+
 /**
  * Upstash Workflow context
  *
@@ -682,6 +756,7 @@ declare class WorkflowContext<TInitialPayload = unknown> {
      */
     protected addStep<TResult = unknown>(step: BaseLazyStep<TResult>): Promise<TResult>;
     get api(): WorkflowApi;
+    get agents(): WorkflowAgents;
 }
 
 /**
@@ -1057,4 +1132,4 @@ type HeaderParams = {
     callTimeout?: never;
 });
 
-export { type AsyncStepFunction as A, type CallResponse as C, type Duration as D, type FinishCondition as F, type HeaderParams as H, type LogLevel as L, type NotifyResponse as N, type ParallelCallState as P, type RouteFunction as R, type Step as S, type Telemetry as T, type WorkflowServeOptions as W, type Waiter as a, WorkflowContext as b, type WorkflowClient as c, type WorkflowReceiver as d, StepTypes as e, type StepType as f, type RawStep as g, type SyncStepFunction as h, type StepFunction as i, type PublicServeOptions as j, type FailureFunctionPayload as k, type RequiredExceptFields as l, type WaitRequest as m, type WaitStepResponse as n, type NotifyStepResponse as o, type WaitEventOptions as p, type CallSettings as q, type WorkflowLoggerOptions as r, WorkflowLogger as s };
+export { type AsyncStepFunction as A, type CallResponse as C, type Duration as D, type FinishCondition as F, type HeaderParams as H, type LogLevel as L, ManagerAgent as M, type NotifyResponse as N, type ParallelCallState as P, type RouteFunction as R, type Step as S, type Telemetry as T, type WorkflowServeOptions as W, type Waiter as a, WorkflowContext as b, type WorkflowClient as c, type WorkflowReceiver as d, StepTypes as e, type StepType as f, type RawStep as g, type SyncStepFunction as h, type StepFunction as i, type PublicServeOptions as j, type FailureFunctionPayload as k, type RequiredExceptFields as l, type WaitRequest as m, type WaitStepResponse as n, type NotifyStepResponse as o, type WaitEventOptions as p, type CallSettings as q, type WorkflowLoggerOptions as r, WorkflowLogger as s, WorkflowAgents as t, createWorkflowOpenAI as u, Agent as v };