@providerprotocol/agents 0.0.1 → 0.0.3

package/dist/execution/index.js

@@ -0,0 +1,679 @@
+export { loop } from '../chunk-4ESYN66B.js';
+import { generateUUID } from '../chunk-EKRXMSDX.js';
+import { UserMessage } from '@providerprotocol/ai';
+
+var DEFAULT_REACT_OPTIONS = {
+  maxSteps: Infinity,
+  reasoningPrompt: "Think step by step about what you need to do next. Consider the current state, what tools are available, and what action would be most helpful."
+};
+function react(options = {}) {
+  const opts = { ...DEFAULT_REACT_OPTIONS, ...options };
+  return {
+    name: "react",
+    async execute(context) {
+      const { llm, input, state, strategy, signal } = context;
+      let currentState = state.withMessage(input).withMetadata("agentId", context.agent.id);
+      let step = 0;
+      let finalTurn;
+      const messages = [...currentState.messages];
+      while (true) {
+        step++;
+        currentState = currentState.withStep(step);
+        if (signal?.aborted) {
+          throw new Error("Execution aborted");
+        }
+        strategy.onStepStart?.(step, currentState);
+        const reasoningMessages = [
+          ...messages,
+          new UserMessage(opts.reasoningPrompt)
+        ];
+        const reasoningTurn = await llm.generate(reasoningMessages);
+        const reasoning = reasoningTurn.response.text;
+        currentState = currentState.withReasoning(reasoning);
+        strategy.onReason?.(step, reasoning);
+        messages.push(...reasoningTurn.messages);
+        const actionPrompt = new UserMessage(
+          "Based on your reasoning, take the appropriate action. Use tools if needed, or provide a final answer."
+        );
+        messages.push(actionPrompt);
+        const actionTurn = await llm.generate(messages);
+        finalTurn = actionTurn;
+        messages.push(...actionTurn.messages);
+        currentState = currentState.withMessages(actionTurn.messages);
+        if (actionTurn.response.hasToolCalls) {
+          strategy.onAct?.(step, actionTurn.response.toolCalls ?? []);
+        }
+        if (actionTurn.toolExecutions && actionTurn.toolExecutions.length > 0) {
+          strategy.onObserve?.(step, actionTurn.toolExecutions);
+        }
+        strategy.onStepEnd?.(step, { turn: actionTurn, state: currentState });
+        const shouldStop = await strategy.stopCondition?.(currentState);
+        if (shouldStop) {
+          break;
+        }
+        if (!actionTurn.response.hasToolCalls) {
+          break;
+        }
+        if (opts.maxSteps !== Infinity && step >= opts.maxSteps) {
+          break;
+        }
+      }
+      if (!finalTurn) {
+        throw new Error("No turn generated");
+      }
+      let finalState = currentState;
+      if (context.sessionId) {
+        finalState = currentState.withMetadata("sessionId", context.sessionId);
+      }
+      const result = {
+        turn: finalTurn,
+        state: finalState
+      };
+      strategy.onComplete?.(result);
+      return result;
+    },
+    stream(context) {
+      const { llm, input, state, strategy, signal } = context;
+      const agentId = context.agent.id;
+      let aborted = false;
+      const abortController = new AbortController();
+      if (signal) {
+        signal.addEventListener("abort", () => abortController.abort());
+      }
+      let resolveResult;
+      let rejectResult;
+      const resultPromise = new Promise((resolve, reject) => {
+        resolveResult = resolve;
+        rejectResult = reject;
+      });
+      async function* generateEvents() {
+        let currentState = state.withMessage(input).withMetadata("agentId", context.agent.id);
+        let step = 0;
+        let finalTurn;
+        const messages = [...currentState.messages];
+        try {
+          while (!aborted) {
+            step++;
+            currentState = currentState.withStep(step);
+            if (abortController.signal.aborted) {
+              throw new Error("Execution aborted");
+            }
+            strategy.onStepStart?.(step, currentState);
+            yield {
+              source: "uap",
+              uap: {
+                type: "step_start",
+                step,
+                agentId,
+                data: { phase: "reasoning" }
+              }
+            };
+            const reasoningMessages = [
+              ...messages,
+              new UserMessage(opts.reasoningPrompt)
+            ];
+            const reasoningStream = llm.stream(reasoningMessages);
+            let reasoningText = "";
+            for await (const event of reasoningStream) {
+              if (abortController.signal.aborted) {
+                throw new Error("Execution aborted");
+              }
+              yield { source: "upp", upp: event };
+              if (event.type === "text_delta" && event.delta.text) {
+                reasoningText += event.delta.text;
+              }
+            }
+            const reasoningTurn = await reasoningStream.turn;
+            currentState = currentState.withReasoning(reasoningText || reasoningTurn.response.text);
+            strategy.onReason?.(step, reasoningText || reasoningTurn.response.text);
+            yield {
+              source: "uap",
+              uap: {
+                type: "reasoning",
+                step,
+                agentId,
+                data: { reasoning: reasoningText || reasoningTurn.response.text }
+              }
+            };
+            messages.push(...reasoningTurn.messages);
+            const actionPrompt = new UserMessage(
+              "Based on your reasoning, take the appropriate action. Use tools if needed, or provide a final answer."
+            );
+            messages.push(actionPrompt);
+            const actionStream = llm.stream(messages);
+            for await (const event of actionStream) {
+              if (abortController.signal.aborted) {
+                throw new Error("Execution aborted");
+              }
+              yield { source: "upp", upp: event };
+            }
+            const actionTurn = await actionStream.turn;
+            finalTurn = actionTurn;
+            messages.push(...actionTurn.messages);
+            currentState = currentState.withMessages(actionTurn.messages);
+            if (actionTurn.response.hasToolCalls) {
+              strategy.onAct?.(step, actionTurn.response.toolCalls ?? []);
+              yield {
+                source: "uap",
+                uap: {
+                  type: "action",
+                  step,
+                  agentId,
+                  data: { toolCalls: actionTurn.response.toolCalls }
+                }
+              };
+            }
+            if (actionTurn.toolExecutions && actionTurn.toolExecutions.length > 0) {
+              strategy.onObserve?.(step, actionTurn.toolExecutions);
+              yield {
+                source: "uap",
+                uap: {
+                  type: "observation",
+                  step,
+                  agentId,
+                  data: { observations: actionTurn.toolExecutions }
+                }
+              };
+            }
+            strategy.onStepEnd?.(step, { turn: actionTurn, state: currentState });
+            yield {
+              source: "uap",
+              uap: {
+                type: "step_end",
+                step,
+                agentId,
+                data: { phase: "complete" }
+              }
+            };
+            const shouldStop = await strategy.stopCondition?.(currentState);
+            if (shouldStop) {
+              break;
+            }
+            if (!actionTurn.response.hasToolCalls) {
+              break;
+            }
+            if (opts.maxSteps !== Infinity && step >= opts.maxSteps) {
+              break;
+            }
+          }
+          if (!finalTurn) {
+            throw new Error("No turn generated");
+          }
+          let finalState = currentState;
+          if (context.sessionId) {
+            finalState = currentState.withMetadata("sessionId", context.sessionId);
+          }
+          const result = {
+            turn: finalTurn,
+            state: finalState
+          };
+          strategy.onComplete?.(result);
+          resolveResult(result);
+        } catch (error) {
+          const err = error instanceof Error ? error : new Error(String(error));
+          strategy.onError?.(err, currentState);
+          rejectResult(err);
+          throw err;
+        }
+      }
+      const iterator = generateEvents();
+      return {
+        [Symbol.asyncIterator]() {
+          return iterator;
+        },
+        result: resultPromise,
+        abort() {
+          aborted = true;
+          abortController.abort();
+        }
+      };
+    }
+  };
+}
+var DEFAULT_PLAN_OPTIONS = {
+  maxPlanSteps: Infinity,
+  allowReplan: true,
+  planSchema: {
+    type: "object",
+    properties: {
+      steps: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            id: { type: "string", description: "Unique step identifier" },
+            description: { type: "string", description: "What this step does" },
+            tool: { type: "string", description: "Tool to use (if applicable)" },
+            dependsOn: {
+              type: "array",
+              items: { type: "string" },
+              description: "IDs of steps this depends on"
+            }
+          },
+          required: ["id", "description", "dependsOn"]
+        }
+      }
+    },
+    required: ["steps"]
+  }
+};
+var PLAN_PROMPT = `Create a detailed execution plan to accomplish the task.
+Break it down into clear steps, specifying which tool to use for each step if applicable.
+Include dependencies between steps (which steps must complete before others can start).
+Return your plan as a JSON object with a "steps" array.`;
+function plan(options = {}) {
+  const opts = { ...DEFAULT_PLAN_OPTIONS, ...options };
+  return {
+    name: "plan",
+    async execute(context) {
+      const { llm, input, state, strategy, signal } = context;
+      let currentState = state.withMessage(input).withMetadata("agentId", context.agent.id);
+      let step = 0;
+      let finalTurn;
+      const messages = [...currentState.messages];
+      step++;
+      currentState = currentState.withStep(step);
+      if (signal?.aborted) {
+        throw new Error("Execution aborted");
+      }
+      strategy.onStepStart?.(step, currentState);
+      const planMessages = [
+        ...messages,
+        new UserMessage(PLAN_PROMPT)
+      ];
+      const planTurn = await llm.generate(planMessages);
+      let planData;
+      try {
+        if (planTurn.data) {
+          planData = planTurn.data;
+        } else {
+          const jsonMatch = planTurn.response.text.match(/\{[\s\S]*\}/);
+          if (jsonMatch) {
+            planData = JSON.parse(jsonMatch[0]);
+          } else {
+            throw new Error("Could not parse plan from response");
+          }
+        }
+      } catch (err) {
+        throw new Error(`Failed to parse execution plan: ${err instanceof Error ? err.message : String(err)}`);
+      }
+      let planSteps = planData.steps.map((s) => ({
+        id: s.id || generateUUID(),
+        description: s.description,
+        tool: s.tool,
+        dependsOn: s.dependsOn || [],
+        status: "pending"
+      }));
+      if (opts.maxPlanSteps !== Infinity && planSteps.length > opts.maxPlanSteps) {
+        planSteps = planSteps.slice(0, opts.maxPlanSteps);
+      }
+      currentState = currentState.withPlan(planSteps);
+      messages.push(...planTurn.messages);
+      strategy.onStepEnd?.(step, { turn: planTurn, state: currentState });
+      const completedSteps = /* @__PURE__ */ new Set();
+      while (planSteps.some((s) => s.status === "pending")) {
+        const nextStep = planSteps.find(
+          (s) => s.status === "pending" && s.dependsOn.every((depId) => completedSteps.has(depId))
+        );
+        if (!nextStep) {
+          break;
+        }
+        step++;
+        currentState = currentState.withStep(step);
+        if (signal?.aborted) {
+          throw new Error("Execution aborted");
+        }
+        strategy.onStepStart?.(step, currentState);
+        nextStep.status = "in_progress";
+        currentState = currentState.withPlan([...planSteps]);
+        const stepPrompt = new UserMessage(
+          `Execute step "${nextStep.id}": ${nextStep.description}${nextStep.tool ? ` using the ${nextStep.tool} tool` : ""}`
+        );
+        messages.push(stepPrompt);
+        try {
+          const stepTurn = await llm.generate(messages);
+          finalTurn = stepTurn;
+          messages.push(...stepTurn.messages);
+          currentState = currentState.withMessages(stepTurn.messages);
+          if (stepTurn.response.hasToolCalls) {
+            strategy.onAct?.(step, stepTurn.response.toolCalls ?? []);
+          }
+          if (stepTurn.toolExecutions && stepTurn.toolExecutions.length > 0) {
+            strategy.onObserve?.(step, stepTurn.toolExecutions);
+          }
+          nextStep.status = "completed";
+          completedSteps.add(nextStep.id);
+          currentState = currentState.withPlan([...planSteps]);
+          strategy.onStepEnd?.(step, { turn: stepTurn, state: currentState });
+        } catch (err) {
+          nextStep.status = "failed";
+          currentState = currentState.withPlan([...planSteps]);
+          throw err;
+        }
+        const shouldStop = await strategy.stopCondition?.(currentState);
+        if (shouldStop) {
+          break;
+        }
+      }
+      if (!finalTurn) {
+        finalTurn = planTurn;
+      }
+      let finalState = currentState;
+      if (context.sessionId) {
+        finalState = currentState.withMetadata("sessionId", context.sessionId);
+      }
+      const result = {
+        turn: finalTurn,
+        state: finalState
+      };
+      strategy.onComplete?.(result);
+      return result;
+    },
+    stream(context) {
+      const { llm, input, state, strategy, signal } = context;
+      const agentId = context.agent.id;
+      let aborted = false;
+      const abortController = new AbortController();
+      if (signal) {
+        signal.addEventListener("abort", () => abortController.abort());
+      }
+      let resolveResult;
+      let rejectResult;
+      const resultPromise = new Promise((resolve, reject) => {
+        resolveResult = resolve;
+        rejectResult = reject;
+      });
+      async function* generateEvents() {
+        let currentState = state.withMessage(input).withMetadata("agentId", context.agent.id);
+        let step = 0;
+        let finalTurn;
+        const messages = [...currentState.messages];
+        try {
+          step++;
+          currentState = currentState.withStep(step);
+          if (abortController.signal.aborted) {
+            throw new Error("Execution aborted");
+          }
+          strategy.onStepStart?.(step, currentState);
+          yield {
+            source: "uap",
+            uap: {
+              type: "step_start",
+              step,
+              agentId,
+              data: { phase: "planning" }
+            }
+          };
+          const planMessages = [
+            ...messages,
+            new UserMessage(PLAN_PROMPT)
+          ];
+          const planStream = llm.stream(planMessages);
+          for await (const event of planStream) {
+            if (abortController.signal.aborted) {
+              throw new Error("Execution aborted");
+            }
+            yield { source: "upp", upp: event };
+          }
+          const planTurn = await planStream.turn;
+          let planData;
+          try {
+            if (planTurn.data) {
+              planData = planTurn.data;
+            } else {
+              const jsonMatch = planTurn.response.text.match(/\{[\s\S]*\}/);
+              if (jsonMatch) {
+                planData = JSON.parse(jsonMatch[0]);
+              } else {
+                throw new Error("Could not parse plan from response");
+              }
+            }
+          } catch (err) {
+            throw new Error(`Failed to parse execution plan: ${err instanceof Error ? err.message : String(err)}`);
+          }
+          let planSteps = planData.steps.map((s) => ({
+            id: s.id || generateUUID(),
+            description: s.description,
+            tool: s.tool,
+            dependsOn: s.dependsOn || [],
+            status: "pending"
+          }));
+          if (opts.maxPlanSteps !== Infinity && planSteps.length > opts.maxPlanSteps) {
+            planSteps = planSteps.slice(0, opts.maxPlanSteps);
+          }
+          currentState = currentState.withPlan(planSteps);
+          messages.push(...planTurn.messages);
+          yield {
+            source: "uap",
+            uap: {
+              type: "plan_created",
+              step,
+              agentId,
+              data: { plan: planSteps }
+            }
+          };
+          strategy.onStepEnd?.(step, { turn: planTurn, state: currentState });
+          yield {
+            source: "uap",
+            uap: {
+              type: "step_end",
+              step,
+              agentId,
+              data: { phase: "planning" }
+            }
+          };
+          const completedSteps = /* @__PURE__ */ new Set();
+          while (planSteps.some((s) => s.status === "pending") && !aborted) {
+            const nextStep = planSteps.find(
+              (s) => s.status === "pending" && s.dependsOn.every((depId) => completedSteps.has(depId))
+            );
+            if (!nextStep) {
+              break;
+            }
+            step++;
+            currentState = currentState.withStep(step);
+            if (abortController.signal.aborted) {
+              throw new Error("Execution aborted");
+            }
+            strategy.onStepStart?.(step, currentState);
+            yield {
+              source: "uap",
+              uap: {
+                type: "plan_step_start",
+                step,
+                agentId,
+                data: { planStep: nextStep }
+              }
+            };
+            nextStep.status = "in_progress";
+            currentState = currentState.withPlan([...planSteps]);
+            const stepPrompt = new UserMessage(
+              `Execute step "${nextStep.id}": ${nextStep.description}${nextStep.tool ? ` using the ${nextStep.tool} tool` : ""}`
+            );
+            messages.push(stepPrompt);
+            const stepStream = llm.stream(messages);
+            for await (const event of stepStream) {
+              if (abortController.signal.aborted) {
+                throw new Error("Execution aborted");
+              }
+              yield { source: "upp", upp: event };
+            }
+            const stepTurn = await stepStream.turn;
+            finalTurn = stepTurn;
+            messages.push(...stepTurn.messages);
+            currentState = currentState.withMessages(stepTurn.messages);
+            if (stepTurn.response.hasToolCalls) {
+              strategy.onAct?.(step, stepTurn.response.toolCalls ?? []);
+              yield {
+                source: "uap",
+                uap: {
+                  type: "action",
+                  step,
+                  agentId,
+                  data: { toolCalls: stepTurn.response.toolCalls }
+                }
+              };
+            }
+            if (stepTurn.toolExecutions && stepTurn.toolExecutions.length > 0) {
+              strategy.onObserve?.(step, stepTurn.toolExecutions);
+              yield {
+                source: "uap",
+                uap: {
+                  type: "observation",
+                  step,
+                  agentId,
+                  data: { observations: stepTurn.toolExecutions }
+                }
+              };
+            }
+            nextStep.status = "completed";
+            completedSteps.add(nextStep.id);
+            currentState = currentState.withPlan([...planSteps]);
+            strategy.onStepEnd?.(step, { turn: stepTurn, state: currentState });
+            yield {
+              source: "uap",
+              uap: {
+                type: "plan_step_end",
+                step,
+                agentId,
+                data: { planStep: nextStep }
+              }
+            };
+            const shouldStop = await strategy.stopCondition?.(currentState);
+            if (shouldStop) {
+              break;
+            }
+          }
+          if (!finalTurn) {
+            finalTurn = planTurn;
+          }
+          let finalState = currentState;
+          if (context.sessionId) {
+            finalState = currentState.withMetadata("sessionId", context.sessionId);
+          }
+          const result = {
+            turn: finalTurn,
+            state: finalState
+          };
+          strategy.onComplete?.(result);
+          resolveResult(result);
+        } catch (error) {
+          const err = error instanceof Error ? error : new Error(String(error));
+          strategy.onError?.(err, currentState);
+          rejectResult(err);
+          throw err;
+        }
+      }
+      const iterator = generateEvents();
+      return {
+        [Symbol.asyncIterator]() {
+          return iterator;
+        },
+        result: resultPromise,
+        abort() {
+          aborted = true;
+          abortController.abort();
+        }
+      };
+    }
+  };
+}
+
+// src/execution/tool-ordering.ts
+function buildToolMap(tools) {
+  const map = /* @__PURE__ */ new Map();
+  for (const tool of tools) {
+    map.set(tool.name, tool);
+  }
+  return map;
+}
+function getModelDependencies(call) {
+  const orderedCall = call;
+  return orderedCall.after ?? [];
+}
+function orderToolCalls(toolCalls, tools) {
+  if (toolCalls.length === 0) {
+    return [];
+  }
+  const toolMap = buildToolMap(tools);
+  const groups = [];
+  const completedCallIds = /* @__PURE__ */ new Set();
+  const completedToolNames = /* @__PURE__ */ new Set();
+  const pending = [...toolCalls];
+  while (pending.length > 0) {
+    const readyForExecution = [];
+    let hasSequential = false;
+    const stillPending = [];
+    for (const call of pending) {
+      const tool = toolMap.get(call.toolName);
+      const toolDependsOn = tool?.dependsOn ?? [];
+      const modelDependsOn = getModelDependencies(call);
+      const toolDepsOk = toolDependsOn.every(
+        (depName) => completedToolNames.has(depName)
+      );
+      const modelDepsOk = modelDependsOn.every(
+        (depId) => completedCallIds.has(depId)
+      );
+      if (toolDepsOk && modelDepsOk) {
+        readyForExecution.push(call);
+        if (tool?.sequential) {
+          hasSequential = true;
+        }
+      } else {
+        stillPending.push(call);
+      }
+    }
+    if (readyForExecution.length === 0 && stillPending.length > 0) {
+      groups.push({
+        calls: stillPending,
+        isBarrier: false
+      });
+      break;
+    }
+    if (hasSequential) {
+      for (const call of readyForExecution) {
+        const tool = toolMap.get(call.toolName);
+        groups.push({
+          calls: [call],
+          isBarrier: tool?.sequential ?? false
+        });
+        completedCallIds.add(call.toolCallId);
+        completedToolNames.add(call.toolName);
+      }
+    } else {
+      groups.push({
+        calls: readyForExecution,
+        isBarrier: false
+      });
+      for (const call of readyForExecution) {
+        completedCallIds.add(call.toolCallId);
+        completedToolNames.add(call.toolName);
+      }
+    }
+    pending.length = 0;
+    pending.push(...stillPending);
+  }
+  return groups;
+}
+function hasToolDependencies(tools) {
+  for (const tool of tools) {
+    const t = tool;
+    if (t.sequential || t.dependsOn && t.dependsOn.length > 0) {
+      return true;
+    }
+  }
+  return false;
+}
+function hasCallDependencies(toolCalls) {
+  for (const call of toolCalls) {
+    const ordered = call;
+    if (ordered.after && ordered.after.length > 0) {
+      return true;
+    }
+  }
+  return false;
+}
+
+export { hasCallDependencies, hasToolDependencies, orderToolCalls, plan, react };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map