@oagi/oagi 0.1.4 → 0.2.0

package/dist/cli.cjs

@@ -46,6 +46,7 @@ var ActionTypeSchema = z.enum([
   "type",
   "scroll",
   "finish",
+  "fail",
   "wait",
   "call_user"
 ]);
@@ -478,7 +479,21 @@ var exportToHtml = (events, filePath) => {
   ensureDir(outputDir);
   const moduleUrl = import_meta?.url ? import_meta.url : (0, import_node_url.pathToFileURL)(__filename).href;
   const moduleDir = import_node_path.default.dirname((0, import_node_url.fileURLToPath)(moduleUrl));
-  const templatePath = import_node_path.default.join(moduleDir, "report_template.html");
+  const primaryTemplate = import_node_path.default.join(moduleDir, "report_template.html");
+  const fallbackTemplate = import_node_path.default.resolve(
+    moduleDir,
+    "..",
+    "src",
+    "agent",
+    "observer",
+    "report_template.html"
+  );
+  const templatePath = import_node_fs.default.existsSync(primaryTemplate) ? primaryTemplate : fallbackTemplate;
+  if (!import_node_fs.default.existsSync(templatePath)) {
+    throw new Error(
+      `Report template not found at ${primaryTemplate} or ${fallbackTemplate}`
+    );
+  }
   const template = import_node_fs.default.readFileSync(templatePath, "utf-8");
   const eventsData = convertEventsForHtml(events);
   const eventsJson = JSON.stringify(eventsData);
@@ -571,9 +586,12 @@ var MODEL_THINKER = "lux-thinker-1";
 var MODE_ACTOR = "actor";
 var DEFAULT_MAX_STEPS = 20;
 var DEFAULT_MAX_STEPS_THINKER = 100;
-var MAX_STEPS_ACTOR = 30;
-var MAX_STEPS_THINKER = 120;
-var DEFAULT_STEP_DELAY = 0.3;
+var DEFAULT_MAX_STEPS_TASKER = 60;
+var MAX_STEPS_ACTOR = 100;
+var MAX_STEPS_THINKER = 300;
+var DEFAULT_REFLECTION_INTERVAL = 4;
+var DEFAULT_REFLECTION_INTERVAL_TASKER = 20;
+var DEFAULT_STEP_DELAY = 1;
 var DEFAULT_TEMPERATURE = 0.5;
 var DEFAULT_TEMPERATURE_LOW = 0.1;
 var HTTP_CLIENT_TIMEOUT = 60;
@@ -659,6 +677,39 @@ var logTraceOnFailure = (_, __, descriptor) => {
   return descriptor;
 };
 
+// src/platform-info.ts
+var import_module = require("module");
+var import_meta2 = {};
+var SDK_NAME = "oagi-typescript";
+function getSdkVersion() {
+  try {
+    const require2 = (0, import_module.createRequire)(import_meta2.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/utils/output-parser.ts
 var splitActions = (actionBlock) => {
   const actions = [];
@@ -725,7 +776,9 @@ var parseRawOutput = (rawOutput) => {
   return {
     reason,
     actions,
-    stop: actions.some((action2) => action2.type === "finish")
+    stop: actions.some(
+      (action2) => action2.type === "finish" || action2.type === "fail"
+    )
   };
 };
 
@@ -776,10 +829,12 @@ var _Client = class _Client {
         `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 import_openai.default({
       baseURL: new URL("./v1", baseURL).href,
       apiKey,
-      maxRetries
+      maxRetries,
+      defaultHeaders: sdkHeaders
     });
     logger2.info(`Client initialized with base_url: ${baseURL}`);
   }
@@ -795,7 +850,7 @@ var _Client = class _Client {
     return fetch(input, init);
   }
   buildHeaders(apiVersion) {
-    const headers = {};
+    const headers = getSdkHeaders();
     if (apiVersion) {
       headers["x-api-version"] = apiVersion;
     }
@@ -1242,6 +1297,783 @@ var DefaultAgent = class {
   }
 };
 
+// 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
+    };
+    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}`);
+      }
+    }
+    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 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
+    };
+  }
+};
+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}`);
+  }
+};
+
 // src/agent/registry.ts
 var agentRegistry = {};
 var asyncAgentRegister = (mode) => {
@@ -1319,11 +2151,119 @@ asyncAgentRegister("thinker")((options = {}) => {
     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
 var import_robotjs = __toESM(require("robotjs"), 1);
 var import_sharp = __toESM(require("sharp"), 1);
-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":
@@ -1484,7 +2424,7 @@ var DefaultActionHandler = class {
         import_robotjs.default.moveMouse(p1.x, p1.y);
         import_robotjs.default.mouseToggle("down", "left");
         import_robotjs.default.dragMouse(p2.x, p2.y);
-        await sleep2(this.#cfg.dragDurationMs);
+        await sleep3(this.#cfg.dragDurationMs);
         import_robotjs.default.mouseToggle("up", "left");
         return;
       }
@@ -1504,7 +2444,7 @@ var DefaultActionHandler = class {
         if (!last) return;
         const modifiers = keys.slice(0, -1);
         import_robotjs.default.keyTap(last, modifiers.length ? modifiers : []);
-        await sleep2(this.#cfg.hotkeyDelayMs);
+        await sleep3(this.#cfg.hotkeyDelayMs);
         return;
       }
       case "type": {
@@ -1524,10 +2464,11 @@ var DefaultActionHandler = class {
         return;
       }
       case "wait": {
-        await sleep2(this.#cfg.waitDurationMs);
+        await sleep3(this.#cfg.waitDurationMs);
         return;
       }
-      case "finish": {
+      case "finish":
+      case "fail": {
         this.reset();
         return;
       }
@@ -1614,7 +2555,7 @@ var StepTracker = class extends StepObserver {
 
 // src/cli/agent.ts
 var import_node_mac_permissions = __toESM(require("@hurdlegroup/node-mac-permissions"), 1);
-var logger5 = logger_default("cli.agent");
+var logger6 = logger_default("cli.agent");
 var checkPermissions = async () => {
   if (process.platform !== "darwin") {
     process.stdout.write(
@@ -1728,7 +2669,7 @@ If you're using pnpm and robotjs is installed, you may need to run: pnpm approve
     if (interrupted) {
       process.exitCode = 130;
     } else {
-      logger5.error(`Error during agent execution: ${String(err)}`);
+      logger6.error(`Error during agent execution: ${String(err)}`);
       process.exitCode = 1;
     }
   } finally {
@@ -1866,11 +2807,11 @@ var addConfigCommand = (program) => {
 };
 
 // src/cli/version.ts
-var import_module = require("module");
-var import_meta2 = {};
-var getSdkVersion = () => {
+var import_module2 = require("module");
+var import_meta3 = {};
+var getSdkVersion2 = () => {
   try {
-    const require2 = (0, import_module.createRequire)(import_meta2.url);
+    const require2 = (0, import_module2.createRequire)(import_meta3.url);
     for (const p of ["../package.json", "../../package.json"]) {
       try {
         const pkg = require2(p);
@@ -1883,7 +2824,7 @@ var getSdkVersion = () => {
   return "unknown";
 };
 var displayVersion = () => {
-  const sdkVersion = getSdkVersion();
+  const sdkVersion = getSdkVersion2();
   process.stdout.write(`OAGI SDK version: ${sdkVersion}
 `);
   process.stdout.write(`Node version: ${process.version}