@oagi/oagi 0.1.3 → 0.1.5

package/dist/{chunk-SDBYP57G.js → chunk-SRTB44IH.js}

@@ -58,8 +58,11 @@ var MODEL_THINKER = "lux-thinker-1";
 var MODE_ACTOR = "actor";
 var DEFAULT_MAX_STEPS = 20;
 var DEFAULT_MAX_STEPS_THINKER = 100;
+var DEFAULT_MAX_STEPS_TASKER = 60;
 var MAX_STEPS_ACTOR = 30;
 var MAX_STEPS_THINKER = 120;
+var DEFAULT_REFLECTION_INTERVAL = 4;
+var DEFAULT_REFLECTION_INTERVAL_TASKER = 20;
 var DEFAULT_STEP_DELAY = 0.3;
 var DEFAULT_TEMPERATURE = 0.5;
 var DEFAULT_TEMPERATURE_LOW = 0.1;
@@ -105,6 +108,38 @@ var logTraceOnFailure = (_, __, descriptor) => {
   return descriptor;
 };
 
+// src/platform-info.ts
+import { createRequire } from "module";
+var SDK_NAME = "oagi-typescript";
+function getSdkVersion() {
+  try {
+    const require2 = createRequire(import.meta.url);
+    for (const p of ["../package.json", "../../package.json"]) {
+      try {
+        const pkg = require2(p);
+        if (pkg.version && pkg.version !== "0.0.0") return pkg.version;
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return "unknown";
+}
+function getUserAgent() {
+  return `${SDK_NAME}/${getSdkVersion()} (node ${process.version}; ${process.platform}; ${process.arch})`;
+}
+function getSdkHeaders() {
+  return {
+    "User-Agent": getUserAgent(),
+    "x-sdk-name": SDK_NAME,
+    "x-sdk-version": getSdkVersion(),
+    "x-sdk-language": "typescript",
+    "x-sdk-language-version": process.version,
+    "x-sdk-os": process.platform,
+    "x-sdk-platform": process.arch
+  };
+}
+
 // src/types/models/action.ts
 import * as z from "zod";
 var ActionTypeSchema = z.enum([
@@ -366,28 +401,38 @@ ${taskDescription}
 // src/client.ts
 var logger2 = logger_default("client");
 var _Client = class _Client {
-  constructor(baseUrl = process.env.OAGI_BASE_URL ?? DEFAULT_BASE_URL, apiKey = process.env.OAGI_API_KEY ?? null, maxRetries = DEFAULT_MAX_RETRIES) {
-    this.baseUrl = baseUrl;
+  baseURL;
+  apiKey;
+  timeout = HTTP_CLIENT_TIMEOUT;
+  client;
+  constructor(baseURL, apiKey, maxRetries) {
+    if (typeof baseURL === "object") {
+      ({ baseURL, apiKey, maxRetries } = baseURL);
+    }
+    baseURL ??= process.env.OAGI_BASE_URL ?? DEFAULT_BASE_URL;
+    apiKey ??= process.env.OAGI_API_KEY;
+    maxRetries ??= DEFAULT_MAX_RETRIES;
+    this.baseURL = baseURL;
     this.apiKey = apiKey;
     if (!apiKey) {
       throw new ConfigurationError(
         `OAGI API key must be provided either as 'api_key' parameter or OAGI_API_KEY environment variable. Get your API key at ${API_KEY_HELP_URL}`
       );
     }
+    const sdkHeaders = getSdkHeaders();
     this.client = new OpenAI({
-      baseURL: new URL("./v1", baseUrl).href,
+      baseURL: new URL("./v1", baseURL).href,
       apiKey,
-      maxRetries
+      maxRetries,
+      defaultHeaders: sdkHeaders
     });
-    logger2.info(`Client initialized with base_url: ${baseUrl}`);
+    logger2.info(`Client initialized with base_url: ${baseURL}`);
   }
-  timeout = HTTP_CLIENT_TIMEOUT;
-  client;
   fetch(input, init) {
     if (typeof input === "string" || input instanceof URL) {
-      input = new URL(input, this.baseUrl);
+      input = new URL(input, this.baseURL);
     } else {
-      input = new URL(input.url, this.baseUrl);
+      input = new URL(input.url, this.baseURL);
     }
     init ??= {};
     const signal = AbortSignal.timeout(this.timeout * 1e3);
@@ -395,7 +440,7 @@ var _Client = class _Client {
     return fetch(input, init);
   }
   buildHeaders(apiVersion) {
-    const headers = {};
+    const headers = getSdkHeaders();
     if (apiVersion) {
       headers["x-api-version"] = apiVersion;
     }
@@ -456,7 +501,10 @@ var _Client = class _Client {
       task_id: taskId
     });
     const rawOutput = response.choices[0].message.content ?? "";
-    const step = parseRawOutput(rawOutput);
+    const step = {
+      ...parseRawOutput(rawOutput),
+      usage: response.usage
+    };
     taskId = response.task_id;
     const task = taskId ? `task_id: ${taskId}, ` : "";
     const usage = response.usage ? `, tokens: ${response.usage.prompt_tokens}+${response.usage.completion_tokens}` : "";
@@ -611,10 +659,10 @@ var Client = _Client;
 import { randomUUID } from "crypto";
 var logger3 = logger_default("task");
 var Actor = class {
-  constructor(apiKey, baseUrl, model = MODEL_ACTOR, temperature) {
+  constructor(apiKey, baseURL, model = MODEL_ACTOR, temperature) {
     this.model = model;
     this.temperature = temperature;
-    this.client = new Client(baseUrl, apiKey);
+    this.client = new Client(baseURL, apiKey);
   }
   /**
    * Client-side generated UUID
@@ -779,7 +827,7 @@ var DefaultAgent = class {
   async execute(instruction, action_handler, image_provider) {
     const actor = new Actor(this.api_key, this.base_url, this.model);
     logger4.info(`Starting async task execution: ${instruction}`);
-    await actor.initTask(instruction, this.max_steps);
+    actor.initTask(instruction, this.max_steps);
     resetHandler(action_handler);
     for (let i = 0; i < this.max_steps; i++) {
       const step_num = i + 1;
@@ -840,84 +888,784 @@ var DefaultAgent = class {
   }
 };
 
-// src/agent/registry.ts
-var agentRegistry = {};
-var asyncAgentRegister = (mode) => {
-  return (func) => {
-    if (mode in agentRegistry) {
-      throw new Error(
-        `Agent mode '${mode}' is already registered. Cannot register the same mode twice.`
+// src/agent/tasker.ts
+var logger5 = logger_default("agent.tasker");
+var resetHandler2 = (handler) => {
+  if (typeof handler.reset === "function") {
+    handler.reset();
+  }
+};
+var sleep2 = (seconds) => new Promise((resolve) => setTimeout(resolve, seconds * 1e3));
+var extractUuidFromUrl = (url) => {
+  const pattern = /\/([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})(?:\.[a-z]+)?(?:\?|$)/i;
+  const match = pattern.exec(url);
+  return match ? match[1] : null;
+};
+var PlannerMemory = class {
+  taskDescription = "";
+  todos = [];
+  history = [];
+  taskExecutionSummary = "";
+  todoExecutionSummaries = {};
+  setTask(taskDescription, todos) {
+    this.taskDescription = taskDescription;
+    this.todos = todos.map(
+      (todo) => typeof todo === "string" ? { description: todo, status: "pending" } : todo
+    );
+  }
+  getCurrentTodo() {
+    for (let i = 0; i < this.todos.length; i++) {
+      const todo = this.todos[i];
+      if (todo.status === "pending" || todo.status === "in_progress") {
+        return { todo, index: i };
+      }
+    }
+    return null;
+  }
+  updateTodo(index, status, summary) {
+    if (index < 0 || index >= this.todos.length) return;
+    this.todos[index].status = status;
+    if (summary) {
+      this.todoExecutionSummaries[index] = summary;
+    }
+  }
+  addHistory(todoIndex, actions, summary, completed = false) {
+    if (todoIndex < 0 || todoIndex >= this.todos.length) return;
+    this.history.push({
+      todo_index: todoIndex,
+      todo: this.todos[todoIndex].description,
+      actions,
+      summary,
+      completed
+    });
+  }
+  getContext() {
+    return {
+      task_description: this.taskDescription,
+      todos: this.todos.map((todo, index) => ({
+        index,
+        description: todo.description,
+        status: todo.status
+      })),
+      history: this.history.map((history) => ({
+        todo_index: history.todo_index,
+        todo: history.todo,
+        action_count: history.actions.length,
+        summary: history.summary,
+        completed: history.completed
+      })),
+      task_execution_summary: this.taskExecutionSummary,
+      todo_execution_summaries: this.todoExecutionSummaries
+    };
+  }
+  getTodoStatusSummary() {
+    const summary = {
+      pending: 0,
+      in_progress: 0,
+      completed: 0,
+      skipped: 0,
+      blocked: 0
+    };
+    for (const todo of this.todos) {
+      summary[todo.status] = (summary[todo.status] ?? 0) + 1;
+    }
+    return summary;
+  }
+  appendTodo(description) {
+    this.todos.push({ description, status: "pending" });
+  }
+};
+var Planner = class {
+  constructor(client, apiKey, baseUrl) {
+    this.apiKey = apiKey;
+    this.baseUrl = baseUrl;
+    this.client = client;
+  }
+  client;
+  ownsClient = false;
+  ensureClient() {
+    if (!this.client) {
+      this.client = new Client(this.baseUrl, this.apiKey);
+      this.ownsClient = true;
+    }
+    return this.client;
+  }
+  getClient() {
+    return this.ensureClient();
+  }
+  async close() {
+    if (!this.ownsClient || !this.client) return;
+    const closable = this.client;
+    if (typeof closable.close === "function") {
+      await closable.close();
+    }
+  }
+  extractMemoryData(memory, context, todoIndex) {
+    if (memory && todoIndex !== void 0) {
+      const taskDescription = memory.taskDescription;
+      const todos = memory.todos.map((todo, index) => ({
+        index,
+        description: todo.description,
+        status: todo.status,
+        execution_summary: memory.todoExecutionSummaries[index] ?? void 0
+      }));
+      const history = memory.history.map((history2) => ({
+        todo_index: history2.todo_index,
+        todo_description: history2.todo,
+        action_count: history2.actions.length,
+        summary: history2.summary ?? void 0,
+        completed: history2.completed
+      }));
+      const taskExecutionSummary = memory.taskExecutionSummary || void 0;
+      const overallTodo = memory.todos[todoIndex] ? memory.todos[todoIndex].description : "";
+      return {
+        taskDescription,
+        todos,
+        history,
+        taskExecutionSummary,
+        overallTodo
+      };
+    }
+    const rawTodos = context.todos;
+    const rawHistory = context.history;
+    return {
+      taskDescription: context.task_description ?? "",
+      todos: Array.isArray(rawTodos) ? rawTodos : [],
+      history: Array.isArray(rawHistory) ? rawHistory : [],
+      taskExecutionSummary: void 0,
+      overallTodo: context.current_todo ?? ""
+    };
+  }
+  extractJsonString(text) {
+    const start = text.indexOf("{");
+    const end = text.lastIndexOf("}") + 1;
+    if (start < 0 || end <= start) return "";
+    return text.slice(start, end);
+  }
+  parsePlannerOutput(response) {
+    try {
+      const jsonResponse = this.extractJsonString(response);
+      const data = JSON.parse(jsonResponse);
+      return {
+        instruction: data.subtask ?? data.instruction ?? "",
+        reasoning: data.reasoning ?? "",
+        subtodos: data.subtodos ?? []
+      };
+    } catch {
+      return {
+        instruction: "",
+        reasoning: "Failed to parse structured response",
+        subtodos: []
+      };
+    }
+  }
+  parseReflectionOutput(response) {
+    try {
+      const jsonResponse = this.extractJsonString(response);
+      const data = JSON.parse(jsonResponse);
+      const success = data.success === "yes";
+      const newSubtask = (data.subtask_instruction ?? "").trim();
+      const continueCurrent = !success && !newSubtask;
+      return {
+        continue_current: continueCurrent,
+        new_instruction: newSubtask || null,
+        reasoning: data.reflection ?? data.reasoning ?? "",
+        success_assessment: success
+      };
+    } catch {
+      return {
+        continue_current: true,
+        new_instruction: null,
+        reasoning: "Failed to parse reflection response, continuing current approach",
+        success_assessment: false
+      };
+    }
+  }
+  formatExecutionNotes(context) {
+    const history = context.history;
+    if (!history?.length) return "";
+    const parts = [];
+    for (const item of history) {
+      parts.push(
+        `Todo ${item.todo_index}: ${item.action_count} actions, completed: ${item.completed}`
       );
+      if (item.summary) {
+        parts.push(`Summary: ${item.summary}`);
+      }
     }
-    agentRegistry[mode] = func;
-    return func;
-  };
+    return parts.join("\n");
+  }
+  async ensureScreenshotUuid(screenshot) {
+    if (!screenshot) return { uuid: void 0, url: void 0 };
+    if (typeof screenshot === "string") {
+      const uuid = extractUuidFromUrl(screenshot);
+      return { uuid: uuid ?? void 0, url: screenshot };
+    }
+    const client = this.ensureClient();
+    const upload = await client.putS3PresignedUrl(screenshot);
+    return { uuid: upload.uuid, url: upload.download_url };
+  }
+  async initialPlan(todo, context, screenshot, memory, todoIndex) {
+    const client = this.ensureClient();
+    const { uuid } = await this.ensureScreenshotUuid(screenshot);
+    const { taskDescription, todos, history, taskExecutionSummary } = this.extractMemoryData(memory, context, todoIndex);
+    const response = await client.callWorker({
+      workerId: "oagi_first",
+      overallTodo: todo,
+      taskDescription,
+      todos,
+      history,
+      currentTodoIndex: todoIndex,
+      taskExecutionSummary,
+      currentScreenshot: uuid
+    });
+    return {
+      output: this.parsePlannerOutput(response.response),
+      requestId: response.request_id
+    };
+  }
+  async reflect(actions, context, screenshot, memory, todoIndex, currentInstruction, reflectionInterval = DEFAULT_REFLECTION_INTERVAL) {
+    const client = this.ensureClient();
+    const { uuid } = await this.ensureScreenshotUuid(screenshot);
+    const {
+      taskDescription,
+      todos,
+      history,
+      taskExecutionSummary,
+      overallTodo
+    } = this.extractMemoryData(memory, context, todoIndex);
+    const windowActions = actions.slice(-reflectionInterval);
+    const windowSteps = windowActions.map((action, index) => ({
+      step_number: index + 1,
+      action_type: action.action_type,
+      target: action.target ?? "",
+      reasoning: action.reasoning ?? ""
+    }));
+    const windowScreenshots = windowActions.map((action) => action.screenshot_uuid).filter(Boolean);
+    const priorNotes = this.formatExecutionNotes(context);
+    const response = await client.callWorker({
+      workerId: "oagi_follow",
+      overallTodo,
+      taskDescription,
+      todos,
+      history,
+      currentTodoIndex: todoIndex,
+      taskExecutionSummary,
+      currentSubtaskInstruction: currentInstruction ?? "",
+      windowSteps,
+      windowScreenshots,
+      resultScreenshot: uuid,
+      priorNotes
+    });
+    return {
+      output: this.parseReflectionOutput(response.response),
+      requestId: response.request_id
+    };
+  }
+  async summarize(_executionHistory, context, memory, todoIndex) {
+    const client = this.ensureClient();
+    const {
+      taskDescription,
+      todos,
+      history,
+      taskExecutionSummary,
+      overallTodo
+    } = this.extractMemoryData(memory, context, todoIndex);
+    const latestTodoSummary = memory && todoIndex !== void 0 ? memory.todoExecutionSummaries[todoIndex] : "";
+    const response = await client.callWorker({
+      workerId: "oagi_task_summary",
+      overallTodo,
+      taskDescription,
+      todos,
+      history,
+      currentTodoIndex: todoIndex,
+      taskExecutionSummary,
+      latestTodoSummary
+    });
+    try {
+      const parsed = JSON.parse(response.response);
+      return {
+        summary: parsed.task_summary ?? response.response,
+        requestId: response.request_id
+      };
+    } catch {
+      return { summary: response.response, requestId: response.request_id };
+    }
+  }
 };
-var getAgentFactory = (mode) => {
-  if (!(mode in agentRegistry)) {
-    const availableModes = Object.keys(agentRegistry);
-    throw new Error(
-      `Unknown agent mode: '${mode}'. Available modes: ${availableModes}`
+var TaskeeAgent = class {
+  apiKey;
+  baseUrl;
+  model;
+  maxSteps;
+  reflectionInterval;
+  temperature;
+  planner;
+  externalMemory;
+  todoIndex;
+  stepObserver;
+  stepDelay;
+  actor;
+  currentTodo = "";
+  currentInstruction = "";
+  actions = [];
+  totalActions = 0;
+  sinceReflection = 0;
+  success = false;
+  constructor(apiKey, baseUrl, model = MODEL_ACTOR, maxSteps = DEFAULT_MAX_STEPS, reflectionInterval = DEFAULT_REFLECTION_INTERVAL, temperature = DEFAULT_TEMPERATURE, planner, externalMemory, todoIndex, stepObserver, stepDelay = DEFAULT_STEP_DELAY) {
+    this.apiKey = apiKey;
+    this.baseUrl = baseUrl;
+    this.model = model;
+    this.maxSteps = maxSteps;
+    this.reflectionInterval = reflectionInterval;
+    this.temperature = temperature;
+    this.planner = planner ?? new Planner(void 0, apiKey, baseUrl);
+    this.externalMemory = externalMemory;
+    this.todoIndex = todoIndex;
+    this.stepObserver = stepObserver;
+    this.stepDelay = stepDelay;
+  }
+  async execute(instruction, actionHandler, imageProvider) {
+    resetHandler2(actionHandler);
+    this.currentTodo = instruction;
+    this.actions = [];
+    this.totalActions = 0;
+    this.sinceReflection = 0;
+    this.success = false;
+    try {
+      this.actor = new Actor(
+        this.apiKey,
+        this.baseUrl,
+        this.model,
+        this.temperature
+      );
+      await this.initialPlan(imageProvider);
+      this.actor.initTask(this.currentInstruction, this.maxSteps);
+      let remainingSteps = this.maxSteps;
+      while (remainingSteps > 0 && !this.success) {
+        const stepsTaken = await this.executeSubtask(
+          Math.min(this.maxSteps, remainingSteps),
+          actionHandler,
+          imageProvider
+        );
+        remainingSteps -= stepsTaken;
+        if (!this.success && remainingSteps > 0) {
+          const shouldContinue = await this.reflectAndDecide(imageProvider);
+          if (!shouldContinue) {
+            break;
+          }
+        }
+      }
+      await this.generateSummary();
+      return this.success;
+    } catch (err) {
+      logger5.error(`Error executing todo: ${err}`);
+      this.recordAction("error", null, String(err));
+      return false;
+    } finally {
+      this.actor = void 0;
+    }
+  }
+  getContext() {
+    return this.externalMemory ? this.externalMemory.getContext() : {};
+  }
+  recordAction(actionType, target, reasoning, result, screenshotUuid) {
+    this.actions.push({
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      action_type: actionType,
+      target,
+      reasoning,
+      result,
+      details: {},
+      screenshot_uuid: screenshotUuid ?? void 0
+    });
+  }
+  async initialPlan(imageProvider) {
+    logger5.info("Generating initial plan for todo");
+    const screenshot = await imageProvider.provide();
+    const context = this.getContext();
+    const { output, requestId } = await this.planner.initialPlan(
+      this.currentTodo,
+      context,
+      screenshot,
+      this.externalMemory,
+      this.todoIndex
     );
+    this.recordAction("plan", "initial", output.reasoning, output.instruction);
+    if (this.stepObserver) {
+      const event = {
+        type: "plan",
+        timestamp: /* @__PURE__ */ new Date(),
+        phase: "initial",
+        image: screenshot,
+        reasoning: output.reasoning,
+        result: output.instruction,
+        request_id: requestId ?? void 0
+      };
+      await this.stepObserver.onEvent(event);
+    }
+    this.currentInstruction = output.instruction;
+    logger5.info(`Initial instruction: ${this.currentInstruction}`);
+  }
+  async executeSubtask(maxSteps, actionHandler, imageProvider) {
+    logger5.info(`Executing subtask with max ${maxSteps} steps`);
+    let stepsTaken = 0;
+    const client = this.planner.getClient();
+    for (let stepNum = 0; stepNum < maxSteps; stepNum++) {
+      const screenshot = await imageProvider.provide();
+      let screenshotUuid;
+      let screenshotUrl;
+      try {
+        if (typeof screenshot === "string") {
+          screenshotUuid = extractUuidFromUrl(screenshot) ?? void 0;
+          screenshotUrl = screenshot;
+        } else {
+          const upload = await client.putS3PresignedUrl(screenshot);
+          screenshotUuid = upload.uuid;
+          screenshotUrl = upload.download_url;
+        }
+      } catch (err) {
+        logger5.error(`Error uploading screenshot: ${err}`);
+        this.recordAction("error", "screenshot_upload", String(err));
+        break;
+      }
+      let step;
+      try {
+        step = await this.actor.step(screenshotUrl ?? screenshot, void 0);
+      } catch (err) {
+        logger5.error(`Error getting step from OAGI: ${err}`);
+        this.recordAction(
+          "error",
+          "oagi_step",
+          String(err),
+          null,
+          screenshotUuid
+        );
+        break;
+      }
+      if (step.reason) {
+        logger5.info(`Step ${this.totalActions + 1}: ${step.reason}`);
+      }
+      if (this.stepObserver) {
+        const event = {
+          type: "step",
+          timestamp: /* @__PURE__ */ new Date(),
+          step_num: this.totalActions + 1,
+          image: screenshot,
+          step,
+          task_id: this.actor.taskId
+        };
+        await this.stepObserver.onEvent(event);
+      }
+      if (step.actions?.length) {
+        logger5.info(`Actions (${step.actions.length}):`);
+        for (const action of step.actions) {
+          const countSuffix = action.count && action.count > 1 ? ` x${action.count}` : "";
+          logger5.info(`  [${action.type}] ${action.argument}${countSuffix}`);
+        }
+        for (const action of step.actions) {
+          this.recordAction(
+            action.type,
+            action.argument,
+            step.reason ?? null,
+            null,
+            screenshotUuid
+          );
+        }
+        let error = null;
+        try {
+          await actionHandler.handle(step.actions);
+        } catch (err) {
+          error = String(err);
+          throw err;
+        } finally {
+          if (this.stepObserver) {
+            const event = {
+              type: "action",
+              timestamp: /* @__PURE__ */ new Date(),
+              step_num: this.totalActions + 1,
+              actions: step.actions,
+              error: error ?? void 0
+            };
+            await this.stepObserver.onEvent(event);
+          }
+        }
+        this.totalActions += step.actions.length;
+        this.sinceReflection += step.actions.length;
+      }
+      if (this.stepDelay > 0) {
+        await sleep2(this.stepDelay);
+      }
+      stepsTaken += 1;
+      if (step.stop) {
+        logger5.info("OAGI signaled task completion");
+        break;
+      }
+      if (this.sinceReflection >= this.reflectionInterval) {
+        logger5.info("Reflection interval reached");
+        break;
+      }
+    }
+    return stepsTaken;
+  }
+  async reflectAndDecide(imageProvider) {
+    logger5.info("Reflecting on progress");
+    const screenshot = await imageProvider.provide();
+    const context = this.getContext();
+    context.current_todo = this.currentTodo;
+    const recentActions = this.actions.slice(-this.sinceReflection);
+    const { output, requestId } = await this.planner.reflect(
+      recentActions,
+      context,
+      screenshot,
+      this.externalMemory,
+      this.todoIndex,
+      this.currentInstruction,
+      this.reflectionInterval
+    );
+    this.recordAction(
+      "reflect",
+      null,
+      output.reasoning,
+      output.continue_current ? "continue" : "pivot"
+    );
+    if (this.stepObserver) {
+      const decision = output.success_assessment ? "success" : output.continue_current ? "continue" : "pivot";
+      const event = {
+        type: "plan",
+        timestamp: /* @__PURE__ */ new Date(),
+        phase: "reflection",
+        image: screenshot,
+        reasoning: output.reasoning,
+        result: decision,
+        request_id: requestId ?? void 0
+      };
+      await this.stepObserver.onEvent(event);
+    }
+    if (output.success_assessment) {
+      this.success = true;
+      logger5.info("Reflection indicates task is successful");
+      return false;
+    }
+    this.sinceReflection = 0;
+    if (!output.continue_current && output.new_instruction) {
+      logger5.info(`Pivoting to new instruction: ${output.new_instruction}`);
+      this.currentInstruction = output.new_instruction;
+      await this.actor.initTask(this.currentInstruction, this.maxSteps);
+      return true;
+    }
+    return output.continue_current;
+  }
+  async generateSummary() {
+    logger5.info("Generating execution summary");
+    const context = this.getContext();
+    context.current_todo = this.currentTodo;
+    const { summary, requestId } = await this.planner.summarize(
+      this.actions,
+      context,
+      this.externalMemory,
+      this.todoIndex
+    );
+    this.recordAction("summary", null, summary);
+    if (this.stepObserver) {
+      const event = {
+        type: "plan",
+        timestamp: /* @__PURE__ */ new Date(),
+        phase: "summary",
+        image: void 0,
+        reasoning: summary,
+        result: void 0,
+        request_id: requestId ?? void 0
+      };
+      await this.stepObserver.onEvent(event);
+    }
+    logger5.info(`Execution summary: ${summary}`);
+  }
+  returnExecutionResults() {
+    let summary = "";
+    for (let i = this.actions.length - 1; i >= 0; i--) {
+      if (this.actions[i].action_type === "summary") {
+        summary = this.actions[i].reasoning ?? "";
+        break;
+      }
+    }
+    return {
+      success: this.success,
+      actions: this.actions,
+      summary,
+      total_steps: this.totalActions
+    };
   }
-  return agentRegistry[mode];
-};
-var listAgentModes = () => {
-  return Object.keys(agentRegistry);
 };
-var createAgent = (mode, options = {}) => {
-  const factory = getAgentFactory(mode);
-  const agent = factory(options);
-  if (!agent || typeof agent.execute !== "function") {
-    throw new TypeError(
-      `Factory for mode '${mode}' returned an object that doesn't implement Agent. Expected an object with an 'execute' method.`
+var TaskerAgent = class {
+  /** Hierarchical agent that manages multi-todo workflows. */
+  apiKey;
+  baseUrl;
+  model;
+  maxSteps;
+  temperature;
+  reflectionInterval;
+  planner;
+  stepObserver;
+  stepDelay;
+  memory = new PlannerMemory();
+  currentTaskeeAgent;
+  constructor(apiKey, baseUrl, model = MODEL_ACTOR, maxSteps = DEFAULT_MAX_STEPS_TASKER, temperature = DEFAULT_TEMPERATURE, reflectionInterval = DEFAULT_REFLECTION_INTERVAL, planner, stepObserver, stepDelay = DEFAULT_STEP_DELAY) {
+    this.apiKey = apiKey;
+    this.baseUrl = baseUrl;
+    this.model = model;
+    this.maxSteps = maxSteps;
+    this.temperature = temperature;
+    this.reflectionInterval = reflectionInterval;
+    this.planner = planner ?? new Planner(void 0, apiKey, baseUrl);
+    this.stepObserver = stepObserver;
+    this.stepDelay = stepDelay;
+  }
+  setTask(task, todos) {
+    this.memory.setTask(task, todos);
+    logger5.info(`Task set with ${todos.length} todos`);
+  }
+  set_task(task, todos) {
+    this.setTask(task, todos);
+  }
+  async execute(_instruction, actionHandler, imageProvider) {
+    resetHandler2(actionHandler);
+    let overallSuccess = true;
+    while (true) {
+      const todoInfo = this.prepare();
+      if (!todoInfo) {
+        logger5.info("No more todos to execute");
+        break;
+      }
+      const { todo, index } = todoInfo;
+      logger5.info(`Executing todo ${index}: ${todo.description}`);
+      if (this.stepObserver) {
+        const event = {
+          type: "split",
+          timestamp: /* @__PURE__ */ new Date(),
+          label: `Start of todo ${index + 1}: ${todo.description}`
+        };
+        await this.stepObserver.onEvent(event);
+      }
+      const success = await this.executeTodo(
+        index,
+        actionHandler,
+        imageProvider
+      );
+      if (this.stepObserver) {
+        const event = {
+          type: "split",
+          timestamp: /* @__PURE__ */ new Date(),
+          label: `End of todo ${index + 1}: ${todo.description}`
+        };
+        await this.stepObserver.onEvent(event);
+      }
+      if (!success) {
+        logger5.warn(`Todo ${index} failed`);
+        overallSuccess = false;
+        const currentStatus = this.memory.todos[index]?.status;
+        if (currentStatus === "in_progress") {
+          logger5.error("Todo failed with exception, stopping execution");
+          break;
+        }
+      }
+      this.updateTaskSummary();
+    }
+    const statusSummary = this.memory.getTodoStatusSummary();
+    logger5.info(
+      `Workflow complete. Status summary: ${JSON.stringify(statusSummary)}`
     );
+    return overallSuccess;
+  }
+  prepare() {
+    const current = this.memory.getCurrentTodo();
+    if (!current) return null;
+    this.currentTaskeeAgent = new TaskeeAgent(
+      this.apiKey,
+      this.baseUrl,
+      this.model,
+      this.maxSteps,
+      this.reflectionInterval,
+      this.temperature,
+      this.planner,
+      this.memory,
+      current.index,
+      this.stepObserver,
+      this.stepDelay
+    );
+    if (current.todo.status === "pending") {
+      this.memory.updateTodo(current.index, "in_progress");
+    }
+    logger5.info(`Prepared taskee agent for todo ${current.index}`);
+    return current;
+  }
+  async executeTodo(todoIndex, actionHandler, imageProvider) {
+    if (!this.currentTaskeeAgent || todoIndex < 0) {
+      logger5.error("No taskee agent prepared");
+      return false;
+    }
+    const todo = this.memory.todos[todoIndex];
+    try {
+      const success = await this.currentTaskeeAgent.execute(
+        todo.description,
+        actionHandler,
+        imageProvider
+      );
+      const results = this.currentTaskeeAgent.returnExecutionResults();
+      this.updateMemoryFromExecution(todoIndex, results, success);
+      return success;
+    } catch (err) {
+      logger5.error(`Error executing todo ${todoIndex}: ${err}`);
+      this.memory.updateTodo(
+        todoIndex,
+        "in_progress",
+        `Execution failed: ${String(err)}`
+      );
+      return false;
+    }
+  }
+  updateMemoryFromExecution(todoIndex, results, success) {
+    const status = success ? "completed" : "in_progress";
+    this.memory.updateTodo(todoIndex, status, results.summary);
+    this.memory.addHistory(
+      todoIndex,
+      results.actions,
+      results.summary,
+      success
+    );
+    if (success) {
+      const summaryLine = `- Completed todo ${todoIndex}: ${results.summary}`;
+      this.memory.taskExecutionSummary = this.memory.taskExecutionSummary ? `${this.memory.taskExecutionSummary}
+${summaryLine}` : summaryLine;
+    }
+    logger5.info(
+      `Updated memory for todo ${todoIndex}: status=${status}, actions=${results.actions.length}`
+    );
+  }
+  updateTaskSummary() {
+    const statusSummary = this.memory.getTodoStatusSummary();
+    const completed = statusSummary.completed ?? 0;
+    const total = this.memory.todos.length;
+    const summaryParts = [`Progress: ${completed}/${total} todos completed`];
+    const recentHistory = this.memory.history.slice(-3);
+    for (const history of recentHistory) {
+      if (history.completed && history.summary) {
+        summaryParts.push(
+          `- Todo ${history.todo_index}: ${history.summary.slice(0, 100)}`
+        );
+      }
+    }
+    this.memory.taskExecutionSummary = summaryParts.join("\n");
+  }
+  getMemory() {
+    return this.memory;
+  }
+  appendTodo(description) {
+    this.memory.appendTodo(description);
+    logger5.info(`Appended new todo: ${description}`);
   }
-  return agent;
 };
 
-// src/agent/factories.ts
-asyncAgentRegister("actor")((options = {}) => {
-  const {
-    apiKey,
-    baseUrl,
-    model = MODEL_ACTOR,
-    maxSteps = DEFAULT_MAX_STEPS,
-    temperature = DEFAULT_TEMPERATURE_LOW,
-    stepObserver,
-    stepDelay = DEFAULT_STEP_DELAY
-  } = options;
-  return new DefaultAgent(
-    apiKey,
-    baseUrl,
-    model,
-    maxSteps,
-    temperature,
-    stepObserver ?? void 0,
-    stepDelay
-  );
-});
-asyncAgentRegister("thinker")((options = {}) => {
-  const {
-    apiKey,
-    baseUrl,
-    model = MODEL_THINKER,
-    maxSteps = DEFAULT_MAX_STEPS_THINKER,
-    temperature = DEFAULT_TEMPERATURE_LOW,
-    stepObserver,
-    stepDelay = DEFAULT_STEP_DELAY
-  } = options;
-  return new DefaultAgent(
-    apiKey,
-    baseUrl,
-    model,
-    maxSteps,
-    temperature,
-    stepObserver ?? void 0,
-    stepDelay
-  );
-});
-
 // src/agent/observer/exporters.ts
 import fs from "fs";
 import path from "path";
@@ -1199,7 +1947,21 @@ var exportToHtml = (events, filePath) => {
   ensureDir(outputDir);
   const moduleUrl = import.meta?.url ? import.meta.url : pathToFileURL(__filename).href;
   const moduleDir = path.dirname(fileURLToPath(moduleUrl));
-  const templatePath = path.join(moduleDir, "report_template.html");
+  const primaryTemplate = path.join(moduleDir, "report_template.html");
+  const fallbackTemplate = path.resolve(
+    moduleDir,
+    "..",
+    "src",
+    "agent",
+    "observer",
+    "report_template.html"
+  );
+  const templatePath = fs.existsSync(primaryTemplate) ? primaryTemplate : fallbackTemplate;
+  if (!fs.existsSync(templatePath)) {
+    throw new Error(
+      `Report template not found at ${primaryTemplate} or ${fallbackTemplate}`
+    );
+  }
   const template = fs.readFileSync(templatePath, "utf-8");
   const eventsData = convertEventsForHtml(events);
   const eventsJson = JSON.stringify(eventsData);
@@ -1228,6 +1990,12 @@ var exportToJson = (events, filePath) => {
 };
 
 // src/agent/observer/agent_observer.ts
+var ExportFormat = /* @__PURE__ */ ((ExportFormat2) => {
+  ExportFormat2["MARKDOWN"] = "markdown";
+  ExportFormat2["HTML"] = "html";
+  ExportFormat2["JSON"] = "json";
+  return ExportFormat2;
+})(ExportFormat || {});
 var AsyncAgentObserver = class extends StepObserver {
   /**
    * Records agent execution events and exports to various formats.
@@ -1282,10 +2050,196 @@ var AsyncAgentObserver = class extends StepObserver {
   }
 };
 
+// src/agent/registry.ts
+var agentRegistry = {};
+var asyncAgentRegister = (mode) => {
+  return (func) => {
+    if (mode in agentRegistry) {
+      throw new Error(
+        `Agent mode '${mode}' is already registered. Cannot register the same mode twice.`
+      );
+    }
+    agentRegistry[mode] = func;
+    return func;
+  };
+};
+var getAgentFactory = (mode) => {
+  if (!(mode in agentRegistry)) {
+    const availableModes = Object.keys(agentRegistry);
+    throw new Error(
+      `Unknown agent mode: '${mode}'. Available modes: ${availableModes}`
+    );
+  }
+  return agentRegistry[mode];
+};
+var listAgentModes = () => {
+  return Object.keys(agentRegistry);
+};
+var createAgent = (mode, options = {}) => {
+  const factory = getAgentFactory(mode);
+  const agent = factory(options);
+  if (!agent || typeof agent.execute !== "function") {
+    throw new TypeError(
+      `Factory for mode '${mode}' returned an object that doesn't implement Agent. Expected an object with an 'execute' method.`
+    );
+  }
+  return agent;
+};
+
+// src/agent/factories.ts
+asyncAgentRegister("actor")((options = {}) => {
+  const {
+    apiKey,
+    baseURL,
+    model = MODEL_ACTOR,
+    maxSteps = DEFAULT_MAX_STEPS,
+    temperature = DEFAULT_TEMPERATURE_LOW,
+    stepObserver,
+    stepDelay = DEFAULT_STEP_DELAY
+  } = options;
+  return new DefaultAgent(
+    apiKey,
+    baseURL,
+    model,
+    maxSteps,
+    temperature,
+    stepObserver ?? void 0,
+    stepDelay
+  );
+});
+asyncAgentRegister("thinker")((options = {}) => {
+  const {
+    apiKey,
+    baseURL,
+    model = MODEL_THINKER,
+    maxSteps = DEFAULT_MAX_STEPS_THINKER,
+    temperature = DEFAULT_TEMPERATURE_LOW,
+    stepObserver,
+    stepDelay = DEFAULT_STEP_DELAY
+  } = options;
+  return new DefaultAgent(
+    apiKey,
+    baseURL,
+    model,
+    maxSteps,
+    temperature,
+    stepObserver ?? void 0,
+    stepDelay
+  );
+});
+asyncAgentRegister("tasker")((options = {}) => {
+  const {
+    apiKey,
+    baseURL,
+    model = MODEL_ACTOR,
+    maxSteps = DEFAULT_MAX_STEPS_TASKER,
+    temperature = DEFAULT_TEMPERATURE,
+    reflectionInterval = DEFAULT_REFLECTION_INTERVAL_TASKER,
+    stepObserver,
+    stepDelay = DEFAULT_STEP_DELAY
+  } = options;
+  return new TaskerAgent(
+    apiKey,
+    baseURL,
+    model,
+    maxSteps,
+    temperature,
+    reflectionInterval,
+    void 0,
+    stepObserver ?? void 0,
+    stepDelay
+  );
+});
+asyncAgentRegister("tasker:cvs_appointment")(
+  (options = {}) => {
+    const {
+      apiKey,
+      baseURL,
+      model = MODEL_ACTOR,
+      maxSteps = DEFAULT_MAX_STEPS_TASKER,
+      temperature = DEFAULT_TEMPERATURE,
+      reflectionInterval = DEFAULT_REFLECTION_INTERVAL_TASKER,
+      stepObserver,
+      stepDelay = DEFAULT_STEP_DELAY
+    } = options;
+    const tasker = new TaskerAgent(
+      apiKey,
+      baseURL,
+      model,
+      maxSteps,
+      temperature,
+      reflectionInterval,
+      void 0,
+      stepObserver ?? void 0,
+      stepDelay
+    );
+    const firstName = "First";
+    const lastName = "Last";
+    const email = "user@example.com";
+    const birthday = "01-01-1990";
+    const zipCode = "00000";
+    const [month, day, year] = birthday.split("-");
+    const instruction = `Schedule an appointment at CVS for ${firstName} ${lastName} with email ${email} and birthday ${birthday}`;
+    const todos = [
+      "Open a new tab, go to www.cvs.com, type 'flu shot' in the search bar and press enter, wait for the page to load, then click on the button of Schedule vaccinations on the top of the page",
+      `Enter the first name '${firstName}', last name '${lastName}', and email '${email}' in the form. Do not use any suggested autofills. Make sure the mobile phone number is empty.`,
+      "Slightly scroll down to see the date of birth, enter Month '" + month + "', Day '" + day + "', and Year '" + year + "' in the form",
+      "Click on 'Continue as guest' button, wait for the page to load with wait, click on 'Add vaccines' button, select 'Flu' and click on 'Add vaccines'",
+      "Click on 'next' to enter the page with recommendation vaccines, then click on 'next' again, until on the page of entering zip code, enter '" + zipCode + "', select the first option from the dropdown menu, and click on 'Search'"
+    ];
+    tasker.setTask(instruction, todos);
+    return tasker;
+  }
+);
+asyncAgentRegister("tasker:software_qa")(
+  (options = {}) => {
+    const {
+      apiKey,
+      baseURL,
+      model = MODEL_ACTOR,
+      maxSteps = DEFAULT_MAX_STEPS_TASKER,
+      temperature = DEFAULT_TEMPERATURE,
+      reflectionInterval = DEFAULT_REFLECTION_INTERVAL_TASKER,
+      stepObserver,
+      stepDelay = DEFAULT_STEP_DELAY
+    } = options;
+    const tasker = new TaskerAgent(
+      apiKey,
+      baseURL,
+      model,
+      maxSteps,
+      temperature,
+      reflectionInterval,
+      void 0,
+      stepObserver ?? void 0,
+      stepDelay
+    );
+    const instruction = "QA: click through every sidebar button in the Nuclear Player UI";
+    const todos = [
+      "Click on 'Dashboard' in the left sidebar",
+      "Click on 'Downloads' in the left sidebar",
+      "Click on 'Lyrics' in the left sidebar",
+      "Click on 'Plugins' in the left sidebar",
+      "Click on 'Search Results' in the left sidebar",
+      "Click on 'Settings' in the left sidebar",
+      "Click on 'Equalizer' in the left sidebar",
+      "Click on 'Visualizer' in the left sidebar",
+      "Click on 'Listening History' in the left sidebar",
+      "Click on 'Favorite Albums' in the left sidebar",
+      "Click on 'Favorite Tracks' in the left sidebar",
+      "Click on 'Favorite Artists' in the left sidebar",
+      "Click on 'Local Library' in the left sidebar",
+      "Click on 'Playlists' in the left sidebar"
+    ];
+    tasker.setTask(instruction, todos);
+    return tasker;
+  }
+);
+
 // src/handler.ts
 import robot from "robotjs";
 import sharp from "sharp";
-var sleep2 = (ms) => new Promise((r) => setTimeout(r, ms));
+var sleep3 = (ms) => new Promise((r) => setTimeout(r, ms));
 var toSharpKernel = (resample) => {
   switch (resample) {
     case "NEAREST":
@@ -1446,7 +2400,7 @@ var DefaultActionHandler = class {
         robot.moveMouse(p1.x, p1.y);
         robot.mouseToggle("down", "left");
         robot.dragMouse(p2.x, p2.y);
-        await sleep2(this.#cfg.dragDurationMs);
+        await sleep3(this.#cfg.dragDurationMs);
         robot.mouseToggle("up", "left");
         return;
       }
@@ -1466,7 +2420,7 @@ var DefaultActionHandler = class {
         if (!last) return;
         const modifiers = keys.slice(0, -1);
         robot.keyTap(last, modifiers.length ? modifiers : []);
-        await sleep2(this.#cfg.hotkeyDelayMs);
+        await sleep3(this.#cfg.hotkeyDelayMs);
         return;
       }
       case "type": {
@@ -1486,7 +2440,7 @@ var DefaultActionHandler = class {
         return;
       }
       case "wait": {
-        await sleep2(this.#cfg.waitDurationMs);
+        await sleep3(this.#cfg.waitDurationMs);
         return;
       }
       case "finish": {
@@ -1527,10 +2481,12 @@ export {
   Client,
   Actor,
   DefaultAgent,
+  TaskerAgent,
   listAgentModes,
   createAgent,
+  ExportFormat,
   AsyncAgentObserver,
   ScreenshotMaker,
   DefaultActionHandler
 };
-//# sourceMappingURL=chunk-SDBYP57G.js.map
+//# sourceMappingURL=chunk-SRTB44IH.js.map