@polka-codes/core 0.9.39 → 0.9.41

package/dist/index.js

@@ -29,16 +29,18 @@ var toolInfo = {
       {
         description: "Single clarifying question (no options)",
         input: {
-          questions: { prompt: "What is the target deployment environment?" }
+          questions: [{ prompt: "What is the target deployment environment?" }]
         }
       },
       {
         description: "Single question with multiple-choice options",
         input: {
-          questions: {
-            prompt: "Which frontend framework are you using?",
-            options: ["React", "Angular", "Vue", "Svelte"]
-          }
+          questions: [
+            {
+              prompt: "Which frontend framework are you using?",
+              options: ["React", "Angular", "Vue", "Svelte"]
+            }
+          ]
         }
       },
       {
@@ -56,10 +58,12 @@ var toolInfo = {
       {
         description: "Binary (yes/no) confirmation",
         input: {
-          questions: {
-            prompt: "Is it acceptable to refactor existing tests to improve performance?",
-            options: ["Yes", "No"]
-          }
+          questions: [
+            {
+              prompt: "Is it acceptable to refactor existing tests to improve performance?",
+              options: ["Yes", "No"]
+            }
+          ]
         }
       }
     ]
@@ -87,9 +91,9 @@ var handler = async (provider, args) => {
   }
   const answers = [];
   for (const question of questions) {
-    const { prompt: prompt3, options } = question;
-    const answer = await provider.askFollowupQuestion(prompt3, options);
-    answers.push(`<ask_followup_question_answer question="${prompt3}">
+    const { prompt: prompt2, options } = question;
+    const answer = await provider.askFollowupQuestion(prompt2, options);
+    answers.push(`<ask_followup_question_answer question="${prompt2}">
 ${answer}
 </ask_followup_question_answer>`);
   }
@@ -262,11 +266,11 @@ var handler4 = async (provider, args) => {
       }
     };
   }
-  const { command: command2, requiresApproval } = toolInfo4.parameters.parse(args);
+  const { command, requiresApproval } = toolInfo4.parameters.parse(args);
   try {
-    console.log("Executing command:", command2, "Requires approval:", requiresApproval);
-    const result = await provider.executeCommand(command2, requiresApproval);
-    let message = `<command>${command2}</command>
+    console.log("Executing command:", command, "Requires approval:", requiresApproval);
+    const result = await provider.executeCommand(command, requiresApproval);
+    let message = `<command>${command}</command>
 <command_exit_code>${result.exitCode}</command_exit_code>
 `;
     if (result.summary) {
@@ -1778,14 +1782,14 @@ The following additional instructions are provided by the user, and should be fo
 ${joined}`;
 };
 var customScripts = (commands) => {
-  const joined = Object.entries(commands).map(([name, command2]) => {
-    if (typeof command2 === "string") {
+  const joined = Object.entries(commands).map(([name, command]) => {
+    if (typeof command === "string") {
       return `- ${name}
-  - Command: \`${command2}\``;
+  - Command: \`${command}\``;
     }
     return `- ${name}
-  - Command: \`${command2.command}\`
-  - Description: ${command2.description}`;
+  - Command: \`${command.command}\`
+  - Description: ${command.description}`;
   }).join("\n");
   if (joined.trim() === "") {
     return "";
@@ -1870,7 +1874,7 @@ Avoid unnecessary escape characters or special characters.
         ];
     }
   },
-  commandResult: (command2, exitCode, stdout, stderr) => `<command>${command2}</command>
+  commandResult: (command, exitCode, stdout, stderr) => `<command>${command}</command>
 <command_exit_code>${exitCode}</command_exit_code>
 <command_stdout>
 ${stdout}
@@ -1976,9 +1980,9 @@ ${instance.prompt}`;
   async #callback(event) {
     await this.config.callback?.(event);
   }
-  async start(prompt3) {
+  async start(prompt2) {
     this.#callback({ kind: "StartTask" /* StartTask */, agent: this, systemPrompt: this.config.systemPrompt });
-    return await this.#processLoop(prompt3);
+    return await this.#processLoop(prompt2);
   }
   async step(message) {
     if (this.#messages.length === 0) {
@@ -3000,21 +3004,21 @@ var CoderAgent = class extends AgentBase {
       return;
     }
     const script = this.config.scripts?.[scriptName];
-    const command2 = typeof script === "string" ? script : script?.command;
-    if (command2) {
+    const command = typeof script === "string" ? script : script?.command;
+    if (command) {
       try {
-        const { exitCode, stdout, stderr } = await executeCommand(command2, false);
+        const { exitCode, stdout, stderr } = await executeCommand(command, false);
         if (exitCode !== 0 && shouldReplyWithError) {
           return {
             type: "Reply" /* Reply */,
             message: {
               type: "error-text",
-              value: responsePrompts.commandResult(command2, exitCode, stdout, stderr)
+              value: responsePrompts.commandResult(command, exitCode, stdout, stderr)
             }
           };
         }
       } catch (error) {
-        console.warn(`Failed to run ${scriptName} using command: ${command2}`, error);
+        console.warn(`Failed to run ${scriptName} using command: ${command}`, error);
       }
     }
   }
@@ -3055,24 +3059,24 @@ var MultiAgent = class {
     switch (exitReason.type) {
       case "HandOver" /* HandOver */: {
         this.#agents.pop();
-        const prompt3 = await this.#config.getPrompt?.(
+        const prompt2 = await this.#config.getPrompt?.(
           exitReason.agentName,
           exitReason.task,
           exitReason.context,
           exitReason.files,
           this.#originalTask
         ) ?? exitReason.task;
-        return await this.#startTask(exitReason.agentName, prompt3);
+        return await this.#startTask(exitReason.agentName, prompt2);
       }
       case "Delegate" /* Delegate */: {
-        const prompt3 = await this.#config.getPrompt?.(
+        const prompt2 = await this.#config.getPrompt?.(
           exitReason.agentName,
           exitReason.task,
           exitReason.context,
           exitReason.files,
           this.#originalTask
         ) ?? exitReason.task;
-        const delegateResult = await this.#startTask(exitReason.agentName, prompt3);
+        const delegateResult = await this.#startTask(exitReason.agentName, prompt2);
         switch (delegateResult.type) {
           case "HandOver" /* HandOver */:
           case "Delegate" /* Delegate */:
@@ -3488,64 +3492,6 @@ var createNewProject_default = {
   agent: "architect"
 };
 
-// src/AiTool/generateProjectConfig.ts
-var prompt2 = `
-Role: Analyzer agent
-Goal: Produce a valid polkacodes YAML configuration for the project.
-
-Workflow
-1. Scan project files with tool_read_file and identify:
-   - Package/build tool (npm, bun, pnpm, etc.)
-   - Test framework and patterns (snapshot tests, coverage, etc.)
-   - Formatter / linter and their rules
-   - Folder structure and naming conventions
-   - CI / development workflows
-
-2. Build a YAML config with three root keys:
-
-\`\`\`yaml
-scripts:          # derive from package.json and CI
-  format:        # code formatter
-    command: "<formatter cmd>"
-    description: "Format code"
-  check:         # linter / type checker
-    command: "<linter cmd>"
-    description: "Static checks"
-  test:          # test runner
-    command: "<test cmd>"
-    description: "Run tests"
-  # add any other meaningful project scripts
-
-rules:            # bullet list of key conventions/tools
-
-excludeFiles:     # only files likely to hold secrets
-  - ".env"
-  - ".env.*"
-  - ".npmrc"
-  # do NOT list build artifacts, lockfiles, or paths already in .gitignore
-\`\`\`
-
-3. Return the YAML exactly once, wrapped like:
-
-<tool_attempt_completion>
-<tool_parameter_result>
-# YAML (2-space indents, double-quoted commands)
-</tool_parameter_result>
-</tool_attempt_completion>
-`;
-var generateProjectConfig_default = {
-  name: "generateProjectConfig",
-  description: "Analyzes project files to generate polkacodes config sections",
-  prompt: prompt2,
-  formatInput: () => {
-    return "";
-  },
-  parseOutput: (output) => {
-    return output;
-  },
-  agent: "analyzer"
-};
-
 // src/AiTool/index.ts
 var executeTool = async (definition, ai, params, usageMeter) => {
   const resp = await generateText({
@@ -3598,706 +3544,7 @@ var makeAgentTool = (definition) => {
     return executeAgentTool(definition, options, params);
   };
 };
-var generateProjectConfig = makeMultiAgentTool(generateProjectConfig_default);
 var createNewProject = makeMultiAgentTool(createNewProject_default);
-
-// src/workflow/agent.ts
-import { toJSONSchema as toJSONSchema2 } from "zod/v4";
-
-// src/workflow/utils.ts
-import { template } from "lodash";
-var resolveTemplatedString = (templatedString, input) => {
-  if (typeof templatedString === "string") {
-    return templatedString;
-  }
-  if (templatedString.type === "function") {
-    return templatedString.fn(input);
-  }
-  return template(templatedString.template)(input);
-};
-
-// src/workflow/agent.ts
-var agentRegistry = {
-  analyzer: AnalyzerAgent,
-  architect: ArchitectAgent,
-  coder: CoderAgent,
-  codefixer: CodeFixerAgent
-};
-var WorkflowAgent = class extends AgentBase {
-  onBeforeInvokeTool(_name, _args) {
-    return Promise.resolve(void 0);
-  }
-};
-var makeAgentStepSpecHandler = (getModelFn) => ({
-  type: "agent",
-  handler(step2) {
-    return {
-      ...step2,
-      async run(input, context, resumedState) {
-        const logger = context.logger ?? console;
-        if (context.verbose && context.verbose >= 1) {
-          logger.log(`[agent-step] Running agent step '${step2.id}' with input:`, input);
-        }
-        try {
-          const model = await getModelFn(step2, context);
-          const parameters = context.parameters ?? {};
-          const usageMeter = parameters?.usageMeter ?? new UsageMeter();
-          const toolFormat = step2.toolFormat ?? parameters.toolFormat ?? "native";
-          const policies = parameters.policies ?? [];
-          const modelParameters = { ...parameters.modelParameters ?? {}, ...step2.modelParameters ?? {} };
-          if (resumedState?.usage) {
-            usageMeter.setUsage(resumedState.usage);
-          }
-          const getAgent = () => {
-            if (step2.agent) {
-              const agentName = step2.agent;
-              const AgentClass = agentRegistry[agentName];
-              if (!AgentClass) {
-                throw new Error(`Unknown agent: ${agentName}`);
-              }
-              if (context.verbose && context.verbose >= 1) {
-                logger.log(`[agent-step] Using agent: ${agentName}`);
-              }
-              return new AgentClass({
-                ai: model,
-                os: parameters.os ?? "linux",
-                provider: context.provider,
-                toolFormat,
-                additionalTools: step2.tools,
-                policies,
-                usageMeter,
-                parameters: modelParameters,
-                scripts: parameters.scripts,
-                callback: context.agentCallback,
-                requireToolUse: false,
-                retryCount: parameters.retryCount,
-                requestTimeoutSeconds: parameters.requestTimeoutSeconds
-              });
-            } else {
-              if (!step2.systemPrompt) {
-                throw new Error("No system prompt specified for the agent step.");
-              }
-              if (context.verbose && context.verbose >= 1) {
-                logger.log(`[agent-step] Using generic WorkflowAgent`);
-              }
-              const systemPrompt = resolveTemplatedString(step2.systemPrompt, input);
-              return new WorkflowAgent("agent", model, {
-                systemPrompt,
-                tools: step2.tools ?? [],
-                toolNamePrefix: toolFormat === "native" ? "" : "tool_",
-                provider: context.provider,
-                agents: [],
-                scripts: parameters.scripts,
-                callback: void 0,
-                policies,
-                toolFormat,
-                parameters: modelParameters,
-                usageMeter,
-                requireToolUse: false,
-                retryCount: parameters.retryCount,
-                requestTimeoutSeconds: parameters.requestTimeoutSeconds
-              });
-            }
-          };
-          const agent = getAgent();
-          if (resumedState?.messages) {
-            agent.setMessages(resumedState.messages);
-          }
-          const userContentArray = step2.messages.map((message) => {
-            if (typeof message === "string" || Array.isArray(message)) {
-              return message;
-            }
-            return resolveTemplatedString(message, input);
-          });
-          const combinedContentParts = [];
-          for (const content of userContentArray) {
-            if (typeof content === "string") {
-              combinedContentParts.push({ type: "text", text: content });
-            } else {
-              combinedContentParts.push(...content);
-            }
-          }
-          if (context.verbose && context.verbose >= 1) {
-            logger.log(`[agent-step] Starting agent with content:`, JSON.stringify(combinedContentParts, null, 2));
-          }
-          const exitReason = await agent.start(combinedContentParts);
-          if (context.verbose && context.verbose >= 1) {
-            logger.log(`[agent-step] Agent exited with reason:`, exitReason);
-          }
-          const handleExitReason = async (reason) => {
-            switch (reason.type) {
-              case "Pause":
-                return {
-                  type: "paused",
-                  state: {
-                    messages: agent.messages,
-                    usage: usageMeter.usage
-                  }
-                };
-              case "UsageExceeded":
-                return { type: "error", error: new Error("Usage limit exceeded") };
-              case "Exit" /* Exit */: {
-                const raw = reason.message;
-                if (step2.parseOutput) {
-                  const result = step2.parseOutput(raw);
-                  if (result.success) {
-                    if (step2.outputSchema) {
-                      const validationResult = step2.outputSchema.safeParse(result.data);
-                      if (validationResult.success) {
-                        return { type: "success", output: validationResult.data };
-                      }
-                      let errorMessage2 = `Output validation failed: ${validationResult.error.toString()}`;
-                      if (step2.outputSchema) {
-                        errorMessage2 += `
-
-Expected JSON schema:
-${JSON.stringify(toJSONSchema2(step2.outputSchema), null, 2)}`;
-                      }
-                      const newReason2 = await agent.continueTask(errorMessage2);
-                      return handleExitReason(newReason2);
-                    }
-                    return { type: "success", output: result.data };
-                  }
-                  let errorMessage = result.error ?? "Invalid format.";
-                  if (step2.outputSchema) {
-                    errorMessage += `
-
-Expected JSON schema:
-${JSON.stringify(toJSONSchema2(step2.outputSchema), null, 2)}`;
-                  }
-                  const newReason = await agent.continueTask(errorMessage);
-                  return handleExitReason(newReason);
-                } else if (step2.outputSchema) {
-                  try {
-                    const output = JSON.parse(raw);
-                    const validationResult = step2.outputSchema.safeParse(output);
-                    if (validationResult.success) {
-                      return { type: "success", output: validationResult.data };
-                    }
-                    let errorMessage = `Output validation failed: ${validationResult.error.toString()}`;
-                    errorMessage += `
-
-Expected JSON schema:
-${JSON.stringify(toJSONSchema2(step2.outputSchema), null, 2)}`;
-                    const newReason = await agent.continueTask(errorMessage);
-                    return handleExitReason(newReason);
-                  } catch (e) {
-                    const error = e instanceof Error ? e : new Error(String(e));
-                    let errorMessage = `Failed to parse agent output as JSON: ${error.message}`;
-                    errorMessage += `
-
-Expected JSON schema:
-${JSON.stringify(toJSONSchema2(step2.outputSchema), null, 2)}`;
-                    const newReason = await agent.continueTask(errorMessage);
-                    return handleExitReason(newReason);
-                  }
-                }
-                return { type: "success", output: reason };
-              }
-              case "HandOver" /* HandOver */:
-              case "Delegate" /* Delegate */:
-                return { type: "success", output: reason };
-              case "Aborted":
-              case "WaitForUserInput":
-                return { type: "error", error: new Error(`Agent exited for reason: ${reason.type}`) };
-              case "Interrupted" /* Interrupted */:
-                return { type: "error", error: new Error(JSON.stringify(reason.message)) };
-              default:
-                return {
-                  type: "error",
-                  error: new Error(`Agent exited for an unhandled reason: ${JSON.stringify(reason)}`)
-                };
-            }
-          };
-          return await handleExitReason(exitReason);
-        } catch (e) {
-          return { type: "error", error: e instanceof Error ? e : new Error(String(e)) };
-        }
-      }
-    };
-  }
-});
-
-// src/workflow/builder.ts
-var StepsBuilder = class {
-  #steps = [];
-  build() {
-    if (this.#steps.length === 0) {
-      throw new Error("A workflow must have at least one step.");
-    }
-    const rootStep = this.#steps.length > 1 ? {
-      id: "root",
-      type: "sequential",
-      steps: this.#steps
-    } : this.#steps[0];
-    return rootStep;
-  }
-  step(step2) {
-    this.#steps.push(step2);
-    return this;
-  }
-  parallel(id, step2) {
-    return this.step({
-      id,
-      type: "parallel",
-      step: step2
-    });
-  }
-  loop(id, config) {
-    return this.step({
-      ...config,
-      id,
-      type: "loop"
-    });
-  }
-  custom(idOrSpec, run2) {
-    if (typeof idOrSpec === "string") {
-      if (!run2) {
-        throw new Error('Custom step "run" function must be provided.');
-      }
-      return this.step({
-        id: idOrSpec,
-        type: "custom",
-        run: run2
-      });
-    }
-    return this.step(idOrSpec);
-  }
-  workflow(id, config) {
-    return this.step({
-      ...config,
-      id,
-      type: "workflow"
-    });
-  }
-  agent(id, spec) {
-    return this.step({
-      ...spec,
-      id,
-      type: "agent"
-    });
-  }
-  branch(id, config) {
-    return this.step({
-      ...config,
-      id,
-      type: "branch"
-    });
-  }
-};
-var builder = () => {
-  return new StepsBuilder();
-};
-
-// src/workflow/command.ts
-var commandStepSpecHandler = {
-  type: "command",
-  handler(step2) {
-    return {
-      ...step2,
-      async run(input, context) {
-        try {
-          if (!context.provider.executeCommand) {
-            throw new Error("executeCommand is not available in the provider");
-          }
-          const command2 = step2.command.map((arg) => resolveTemplatedString(arg, input));
-          const commandString = command2.map((arg) => {
-            if (/[^A-Za-z0-9_/:=-]/.test(arg)) {
-              return `"${arg.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
-            }
-            return arg;
-          }).join(" ");
-          const result = await context.provider.executeCommand(commandString, false);
-          const output = {};
-          if (step2.outputs?.includes("stdout")) {
-            output.stdout = result.stdout;
-          }
-          if (step2.outputs?.includes("stderr")) {
-            output.stderr = result.stderr;
-          }
-          if (step2.outputs?.includes("exitCode")) {
-            output.exitCode = result.exitCode;
-          }
-          return { type: "success", output };
-        } catch (e) {
-          return { type: "error", error: e instanceof Error ? e : new Error(String(e)) };
-        }
-      }
-    };
-  }
-};
-var command = (id, ...command2) => ({
-  id,
-  type: "command",
-  command: command2
-});
-
-// src/workflow/runStep.ts
-var runStep = async (step2, input, context, resumedState, allOutputs) => {
-  const logger = context.logger ?? console;
-  if (context.verbose && context.verbose >= 1) {
-    logger.log(`[workflow] running step: ${step2.id}`);
-    logger.log(`[workflow] input: ${JSON.stringify(input, null, 2)}`);
-  }
-  try {
-    const validatedInput = step2.inputSchema?.parse(input) ?? input;
-    const result = await step2.run({ ...validatedInput, $: allOutputs }, context, resumedState);
-    if (context.verbose && context.verbose >= 1) {
-      logger.log(`[workflow] step result: ${step2.id}`, JSON.stringify(result, null, 2));
-    }
-    if (result.type === "success") {
-      const validatedOutput = step2.outputSchema?.parse(result.output) ?? result.output;
-      return {
-        ...result,
-        output: validatedOutput
-      };
-    }
-    return result;
-  } catch (error) {
-    if (context.verbose && context.verbose >= 1) {
-      logger.error(`[workflow] step error: ${step2.id}`, error);
-    }
-    return { type: "error", error };
-  }
-};
-
-// src/workflow/workflow.ts
-var run = async (workflow, context, handler15, input) => {
-  const rootStep = handler15(workflow.step, handler15);
-  const result = await runStep(rootStep, input, context, void 0, {});
-  switch (result.type) {
-    case "paused":
-      return {
-        type: "paused",
-        state: result.state
-      };
-    case "error":
-      return {
-        type: "error",
-        error: result.error
-      };
-    case "success":
-      return {
-        type: "success",
-        output: result.output
-      };
-  }
-};
-var resume = async (workflow, context, handler15, state, input) => {
-  const rootStep = handler15(workflow.step, handler15);
-  const result = await runStep(rootStep, input, context, state, {});
-  switch (result.type) {
-    case "paused":
-      return {
-        type: "paused",
-        state: result.state
-      };
-    case "error":
-      return {
-        type: "error",
-        error: result.error
-      };
-    case "success":
-      return {
-        type: "success",
-        output: result.output
-      };
-  }
-};
-
-// src/workflow/steps.ts
-var combineHandlers = (...handlers) => {
-  const allHandlers = {};
-  for (const handler15 of handlers) {
-    if (allHandlers[handler15.type]) {
-      throw new Error(`Handler with type ${handler15.type} already exists`);
-    }
-    allHandlers[handler15.type] = handler15;
-  }
-  return (step2, rootHandler) => {
-    const handler15 = allHandlers[step2.type];
-    if (!handler15) {
-      throw new Error(`No handler found for step type: ${step2.type}`);
-    }
-    return handler15.handler(step2, rootHandler);
-  };
-};
-var sequentialStepSpecHandler = {
-  type: "sequential",
-  handler(step2, rootHandler) {
-    const steps = step2.steps.map((subStep) => rootHandler(subStep, rootHandler));
-    return {
-      ...step2,
-      async run(input, context, resumedState) {
-        let currentInput = input;
-        const allOutputs = resumedState ? resumedState.allOutputs : {};
-        const startStepIndex = resumedState ? resumedState.stepIndex : 0;
-        for (let i = startStepIndex; i < steps.length; i++) {
-          const subStep = steps[i];
-          const stateToPass = i === startStepIndex && resumedState ? resumedState.stepState : void 0;
-          const result = await runStep(subStep, currentInput, context, stateToPass, allOutputs);
-          switch (result.type) {
-            case "paused":
-              return {
-                type: "paused",
-                state: { stepIndex: i, stepState: result.state, allOutputs }
-              };
-            case "error":
-              return result;
-            // Propagate error
-            case "success":
-              if (subStep.id) {
-                allOutputs[subStep.id] = result.output;
-              }
-              currentInput = result.output;
-              break;
-          }
-        }
-        return { type: "success", output: currentInput };
-      }
-    };
-  }
-};
-var parallelStepSpecHandler = {
-  type: "parallel",
-  handler(step2, rootHandler) {
-    const innerStep = rootHandler(step2.step, rootHandler);
-    return {
-      ...step2,
-      async run(input, context, resumedState) {
-        const items = input.items ?? [];
-        const promises = items.map((innerInput, index) => {
-          const previousResult = resumedState?.[index];
-          if (previousResult) {
-            if (previousResult.type === "paused") {
-              return runStep(innerStep, innerInput, context, previousResult.state, input.$);
-            }
-            return previousResult;
-          }
-          return runStep(innerStep, innerInput, context, void 0, input.$);
-        });
-        const results = await Promise.all(promises);
-        const errors = results.filter((r) => r.type === "error");
-        if (errors.length > 0) {
-          return {
-            type: "error",
-            error: new Error(`Multiple errors: ${errors.map((e) => e.error).join(", ")}`)
-          };
-        }
-        const isPaused = results.some((r) => r.type === "paused");
-        if (isPaused) {
-          return { type: "paused", state: results };
-        }
-        const outputs = results.map((r) => r.output);
-        return { type: "success", output: { results: outputs } };
-      }
-    };
-  }
-};
-var loopStepSpecHandler = {
-  type: "loop",
-  handler(step2, rootHandler) {
-    const innerStep = rootHandler(step2.step, rootHandler);
-    return {
-      ...step2,
-      async run(input, context, resumedState) {
-        const allOutputs = input.$ ?? {};
-        const initialInput = { ...input };
-        delete initialInput.$;
-        const results = resumedState ? [...resumedState.results] : [];
-        let iteration = resumedState?.iteration ?? results.length;
-        let accumulator = resumedState?.accumulator;
-        if (step2.accumulator && accumulator === void 0) {
-          const initialAccumulator = step2.accumulator.initial;
-          accumulator = typeof initialAccumulator === "function" ? initialAccumulator() : initialAccumulator;
-        }
-        const hasPredicates = Boolean(step2.while || step2.until);
-        const effectiveMaxIterations = step2.maxIterations ?? (hasPredicates ? void 0 : 1);
-        const createState = () => ({
-          iteration,
-          input: initialInput,
-          results,
-          last: results[results.length - 1],
-          accumulator
-        });
-        const completeSuccess = () => {
-          const output = { results };
-          if (results.length > 0) {
-            output.last = results[results.length - 1];
-          }
-          if (accumulator !== void 0 && step2.accumulator) {
-            output.accumulator = accumulator;
-          }
-          return { type: "success", output };
-        };
-        const shouldContinue = async () => {
-          const state = createState();
-          if (step2.until) {
-            const shouldStop = await step2.until(state, context);
-            if (shouldStop) {
-              return false;
-            }
-          }
-          if (step2.while) {
-            return Boolean(await step2.while(state, context));
-          }
-          return true;
-        };
-        let pendingResumeState = resumedState;
-        while (true) {
-          if (!hasPredicates && effectiveMaxIterations !== void 0 && iteration >= effectiveMaxIterations) {
-            return completeSuccess();
-          }
-          if (hasPredicates) {
-            const canContinue = await shouldContinue();
-            if (!canContinue) {
-              return completeSuccess();
-            }
-            if (step2.maxIterations !== void 0 && iteration >= step2.maxIterations) {
-              return {
-                type: "error",
-                error: new Error(`Loop exceeded max iterations: ${step2.maxIterations}`)
-              };
-            }
-          }
-          const stateBeforeRun = createState();
-          const iterationInput = step2.mapInput ? await step2.mapInput(stateBeforeRun, context) : stateBeforeRun.last ?? initialInput;
-          const resumeStateForInner = pendingResumeState && pendingResumeState.iteration === iteration ? pendingResumeState.stepState : void 0;
-          const result = await runStep(innerStep, iterationInput, context, resumeStateForInner, allOutputs);
-          if (result.type === "paused") {
-            return {
-              type: "paused",
-              state: {
-                iteration,
-                stepState: result.state,
-                results,
-                accumulator
-              }
-            };
-          }
-          if (result.type === "error") {
-            return result;
-          }
-          results[iteration] = result.output;
-          if (step2.accumulator) {
-            const updated = await step2.accumulator.update(
-              {
-                ...stateBeforeRun,
-                results,
-                last: result.output,
-                accumulator,
-                result: result.output
-              },
-              context
-            );
-            accumulator = updated;
-          }
-          iteration += 1;
-          pendingResumeState = void 0;
-        }
-      }
-    };
-  }
-};
-var workflowStepSpecHandler = {
-  type: "workflow",
-  handler(step2, rootHandler) {
-    return {
-      ...step2,
-      async run(input, context, resumedState) {
-        const { $, ...rest } = input;
-        void $;
-        const defaultWorkflowInput = rest;
-        const workflowInput = step2.mapInput ? await step2.mapInput(input, context) : defaultWorkflowInput;
-        const workflowState = resumedState && "workflowState" in resumedState ? resumedState.workflowState : resumedState;
-        const result = workflowState ? await resume(step2.workflow, context, rootHandler, workflowState, workflowInput) : await run(step2.workflow, context, rootHandler, workflowInput);
-        if (result.type === "paused") {
-          return { type: "paused", state: { workflowState: result.state, workflowInput } };
-        }
-        if (result.type === "error") {
-          return { type: "error", error: result.error };
-        }
-        const finalOutput = step2.mapOutput ? await step2.mapOutput(
-          {
-            input,
-            workflowInput,
-            workflowOutput: result.output
-          },
-          context
-        ) : result.output;
-        return { type: "success", output: finalOutput };
-      }
-    };
-  }
-};
-var branchStepSpecHandler = {
-  type: "branch",
-  handler(step2, rootHandler) {
-    const branches = step2.branches.map((branch) => ({
-      ...branch,
-      step: rootHandler(branch.step, rootHandler)
-    }));
-    const otherwise = step2.otherwise ? rootHandler(step2.otherwise, rootHandler) : void 0;
-    return {
-      ...step2,
-      async run(input, context, resumedState) {
-        const allOutputs = input.$ ?? {};
-        let branchIndex = resumedState?.branchIndex;
-        let stepToRun;
-        if (branchIndex === void 0) {
-          for (let i = 0; i < branches.length; i++) {
-            const shouldRun = await branches[i].when(input, context);
-            if (shouldRun) {
-              branchIndex = i;
-              break;
-            }
-          }
-          if (branchIndex === void 0 && otherwise) {
-            branchIndex = branches.length;
-          }
-        }
-        if (branchIndex !== void 0) {
-          if (branchIndex < branches.length) {
-            stepToRun = branches[branchIndex].step;
-          } else if (branchIndex === branches.length && otherwise) {
-            stepToRun = otherwise;
-          }
-        }
-        if (!stepToRun) {
-          return {
-            type: "error",
-            error: new Error("No branch predicate matched and no otherwise branch provided")
-          };
-        }
-        const result = await runStep(
-          stepToRun,
-          input,
-          context,
-          branchIndex === resumedState?.branchIndex ? resumedState?.stepState : void 0,
-          allOutputs
-        );
-        if (result.type === "paused") {
-          return { type: "paused", state: { branchIndex, stepState: result.state } };
-        }
-        return result;
-      }
-    };
-  }
-};
-var customStepSpecHandler = {
-  type: "custom",
-  handler(step2) {
-    return {
-      ...step2,
-      async run(input, context, resumedState) {
-        return step2.run(input, context, resumedState);
-      }
-    };
-  }
-};
-function step(id, run2) {
-  return { id, type: "custom", run: run2 };
-}
 export {
   AgentBase,
   AnalyzerAgent,
@@ -4318,35 +3565,25 @@ export {
   architectAgentInfo,
   askFollowupQuestion_default as askFollowupQuestion,
   attemptCompletion_default as attemptCompletion,
-  branchStepSpecHandler,
-  builder,
   capabilities,
   codeFixerAgentInfo,
   coderAgentInfo,
-  combineHandlers,
-  command,
-  commandStepSpecHandler,
   configSchema,
   createNewProject,
   customInstructions,
   customScripts,
-  customStepSpecHandler,
   delegate_default as delegate,
   executeAgentTool,
   executeCommand_default as executeCommand,
   executeMultiAgentTool,
   executeTool,
   fetchUrl_default as fetchUrl,
-  generateProjectConfig,
   getAvailableTools,
   handOver_default as handOver,
   listFiles_default as listFiles,
-  loopStepSpecHandler,
-  makeAgentStepSpecHandler,
   makeAgentTool,
   makeMultiAgentTool,
   makeTool,
-  parallelStepSpecHandler,
   parseAssistantMessage,
   parseJsonFromMarkdown,
   readBinaryFile_default as readBinaryFile,
@@ -4356,13 +3593,8 @@ export {
   replaceInFile_default as replaceInFile,
   replaceInFile as replaceInFileHelper,
   responsePrompts,
-  resume,
-  run,
   searchFiles_default as searchFiles,
-  sequentialStepSpecHandler,
-  step,
   systemInformation,
   toolUsePrompt,
-  workflowStepSpecHandler,
   writeToFile_default as writeToFile
 };