@oagi/oagi 0.1.4 → 0.1.5

package/dist/index.cjs

@@ -41,11 +41,13 @@ var src_exports = {};
 __export(src_exports, {
   APIError: () => APIError,
   Actor: () => Actor,
+  AsyncAgentObserver: () => AsyncAgentObserver,
   AuthenticationError: () => AuthenticationError,
   Client: () => Client,
   ConfigurationError: () => ConfigurationError,
   DefaultActionHandler: () => DefaultActionHandler,
   DefaultAgent: () => DefaultAgent,
+  ExportFormat: () => ExportFormat,
   NetworkError: () => NetworkError,
   NotFoundError: () => NotFoundError,
   OAGIError: () => OAGIError,
@@ -53,6 +55,7 @@ __export(src_exports, {
   RequestTimeoutError: () => RequestTimeoutError,
   ScreenshotMaker: () => ScreenshotMaker,
   ServerError: () => ServerError,
+  TaskerAgent: () => TaskerAgent,
   ValidationError: () => ValidationError
 });
 module.exports = __toCommonJS(src_exports);
@@ -72,8 +75,11 @@ var MODEL_ACTOR = "lux-actor-1";
 var MODEL_THINKER = "lux-thinker-1";
 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;
@@ -154,6 +160,39 @@ var logTraceOnFailure = (_, __, descriptor) => {
   return descriptor;
 };
 
+// src/platform-info.ts
+var import_module = require("module");
+var import_meta = {};
+var SDK_NAME = "oagi-typescript";
+function getSdkVersion() {
+  try {
+    const require2 = (0, import_module.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
 var z = __toESM(require("zod"), 1);
 var ActionTypeSchema = z.enum([
@@ -297,6 +336,24 @@ var PlanEventSchema = BaseEventSchema.extend({
   result: z4.string().optional(),
   request_id: z4.string().optional()
 });
+var StepObserver = class {
+  chain(observer) {
+    return new ChainedStepObserver([this, observer ?? null]);
+  }
+};
+var ChainedStepObserver = class extends StepObserver {
+  observers;
+  constructor(observers) {
+    super();
+    this.observers = observers;
+  }
+  async onEvent(event) {
+    return await this.observers.reduce(async (prev, observer) => {
+      await prev;
+      if (observer) await observer.onEvent(event);
+    }, Promise.resolve());
+  }
+};
 
 // src/utils/output-parser.ts
 var splitActions = (actionBlock) => {
@@ -415,10 +472,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}`);
   }
@@ -434,7 +493,7 @@ var _Client = class _Client {
     return fetch(input, init);
   }
   buildHeaders(apiVersion) {
-    const headers = {};
+    const headers = getSdkHeaders();
     if (apiVersion) {
       headers["x-api-version"] = apiVersion;
     }
@@ -881,6 +940,784 @@ 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,
+      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}`);
+      }
+    }
+    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) => {
@@ -936,16 +1773,504 @@ 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/agent/observer/exporters.ts
 var import_node_fs = __toESM(require("fs"), 1);
 var import_node_path = __toESM(require("path"), 1);
 var import_node_url = require("url");
+var import_meta2 = {};
+var ensureDir = (dirPath) => {
+  import_node_fs.default.mkdirSync(dirPath, { recursive: true });
+};
+var parseActionCoords = (action) => {
+  const arg = action.argument.replace(/^\(|\)$/g, "");
+  switch (action.type) {
+    case "click":
+    case "left_double":
+    case "left_triple":
+    case "right_single": {
+      const coords = parseCoords(arg);
+      if (coords) {
+        return { type: "click", x: coords[0], y: coords[1] };
+      }
+      return null;
+    }
+    case "drag": {
+      const coords = parseDragCoords(arg);
+      if (coords) {
+        return {
+          type: "drag",
+          x1: coords[0],
+          y1: coords[1],
+          x2: coords[2],
+          y2: coords[3]
+        };
+      }
+      return null;
+    }
+    case "scroll": {
+      const result = parseScroll(arg);
+      if (result) {
+        return {
+          type: "scroll",
+          x: result[0],
+          y: result[1],
+          direction: result[2]
+        };
+      }
+      return null;
+    }
+    default:
+      return null;
+  }
+};
+var exportToMarkdown = (events, filePath, imagesDir) => {
+  const outputDir = import_node_path.default.dirname(filePath);
+  ensureDir(outputDir);
+  if (imagesDir) {
+    ensureDir(imagesDir);
+  }
+  const lines = ["# Agent Execution Report\n"];
+  for (const event of events) {
+    const d = event.timestamp instanceof Date ? event.timestamp : new Date(event.timestamp);
+    const timestamp = d.toTimeString().slice(0, 8);
+    switch (event.type) {
+      case "step":
+        lines.push(`
+## Step ${event.step_num}
+`);
+        lines.push(`**Time:** ${timestamp}
+`);
+        if (event.task_id) {
+          lines.push(`**Task ID:** \`${event.task_id}\`
+`);
+        }
+        if (typeof event.image !== "string") {
+          if (imagesDir) {
+            const imageFilename = `step_${event.step_num}.png`;
+            const imagePath = import_node_path.default.join(imagesDir, imageFilename);
+            import_node_fs.default.writeFileSync(imagePath, Buffer.from(event.image));
+            const relPath = import_node_path.default.join(import_node_path.default.basename(imagesDir), imageFilename);
+            lines.push(`
+![Step ${event.step_num}](${relPath})
+`);
+          } else {
+            lines.push(
+              `
+*[Screenshot captured - ${event.image.byteLength} bytes]*
+`
+            );
+          }
+        } else {
+          lines.push(`
+**Screenshot URL:** ${event.image}
+`);
+        }
+        if (event.step.reason) {
+          lines.push(`
+**Reasoning:**
+> ${event.step.reason}
+`);
+        }
+        if (event.step.actions?.length) {
+          lines.push("\n**Planned Actions:**\n");
+          for (const action of event.step.actions) {
+            const countStr = action.count && action.count > 1 ? ` (x${action.count})` : "";
+            lines.push(`- \`${action.type}\`: ${action.argument}${countStr}
+`);
+          }
+        }
+        if (event.step.stop) {
+          lines.push("\n**Status:** Task Complete\n");
+        }
+        break;
+      case "action":
+        lines.push(`
+### Actions Executed (${timestamp})
+`);
+        if (event.error) {
+          lines.push(`
+**Error:** ${event.error}
+`);
+        } else {
+          lines.push("\n**Result:** Success\n");
+        }
+        break;
+      case "log":
+        lines.push(`
+> **Log (${timestamp}):** ${event.message}
+`);
+        break;
+      case "split":
+        if (event.label) {
+          lines.push(`
+---
+
+### ${event.label}
+`);
+        } else {
+          lines.push("\n---\n");
+        }
+        break;
+      case "image":
+        break;
+      case "plan": {
+        const phaseTitles = {
+          initial: "Initial Planning",
+          reflection: "Reflection",
+          summary: "Summary"
+        };
+        const phaseTitle = phaseTitles[event.phase] ?? event.phase;
+        lines.push(`
+### ${phaseTitle} (${timestamp})
+`);
+        if (event.request_id) {
+          lines.push(`**Request ID:** \`${event.request_id}\`
+`);
+        }
+        if (event.image) {
+          if (typeof event.image !== "string") {
+            if (imagesDir) {
+              const imageFilename = `plan_${event.phase}_${Date.now()}.png`;
+              const imagePath = import_node_path.default.join(imagesDir, imageFilename);
+              import_node_fs.default.writeFileSync(imagePath, Buffer.from(event.image));
+              const relPath = import_node_path.default.join(
+                import_node_path.default.basename(imagesDir),
+                imageFilename
+              );
+              lines.push(`
+![${phaseTitle}](${relPath})
+`);
+            } else {
+              lines.push(
+                `
+*[Screenshot captured - ${event.image.byteLength} bytes]*
+`
+              );
+            }
+          } else {
+            lines.push(`
+**Screenshot URL:** ${event.image}
+`);
+          }
+        }
+        if (event.reasoning) {
+          lines.push(`
+**Reasoning:**
+> ${event.reasoning}
+`);
+        }
+        if (event.result) {
+          lines.push(`
+**Result:** ${event.result}
+`);
+        }
+        break;
+      }
+    }
+  }
+  import_node_fs.default.writeFileSync(filePath, lines.join(""), "utf-8");
+};
+var convertEventsForHtml = (events) => {
+  const result = [];
+  for (const event of events) {
+    const d = event.timestamp instanceof Date ? event.timestamp : new Date(event.timestamp);
+    const timestamp = d.toTimeString().slice(0, 8);
+    switch (event.type) {
+      case "step": {
+        const action_coords = [];
+        const actions = [];
+        if (event.step.actions?.length) {
+          for (const action of event.step.actions) {
+            const coords = parseActionCoords(action);
+            if (coords) {
+              action_coords.push(coords);
+            }
+            actions.push({
+              type: action.type,
+              argument: action.argument,
+              count: action.count ?? 1
+            });
+          }
+        }
+        let image = null;
+        if (typeof event.image !== "string") {
+          image = Buffer.from(event.image).toString("base64");
+        } else {
+          image = event.image;
+        }
+        result.push({
+          event_type: "step",
+          timestamp,
+          step_num: event.step_num,
+          image,
+          action_coords,
+          reason: event.step.reason,
+          actions,
+          stop: event.step.stop,
+          task_id: event.task_id
+        });
+        break;
+      }
+      case "action":
+        result.push({
+          event_type: "action",
+          timestamp,
+          error: event.error ?? null
+        });
+        break;
+      case "log":
+        result.push({ event_type: "log", timestamp, message: event.message });
+        break;
+      case "split":
+        result.push({ event_type: "split", timestamp, label: event.label });
+        break;
+      case "image":
+        break;
+      case "plan": {
+        let image = null;
+        if (event.image) {
+          if (typeof event.image !== "string") {
+            image = Buffer.from(event.image).toString("base64");
+          } else {
+            image = event.image;
+          }
+        }
+        result.push({
+          event_type: "plan",
+          timestamp,
+          phase: event.phase,
+          image,
+          reasoning: event.reasoning,
+          result: event.result ?? null,
+          request_id: event.request_id ?? null
+        });
+        break;
+      }
+    }
+  }
+  return result;
+};
+var exportToHtml = (events, filePath) => {
+  const outputDir = import_node_path.default.dirname(filePath);
+  ensureDir(outputDir);
+  const moduleUrl = import_meta2?.url ? import_meta2.url : (0, import_node_url.pathToFileURL)(__filename).href;
+  const moduleDir = import_node_path.default.dirname((0, import_node_url.fileURLToPath)(moduleUrl));
+  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);
+  const htmlContent = template.replace("{EVENTS_DATA}", eventsJson);
+  import_node_fs.default.writeFileSync(filePath, htmlContent, "utf-8");
+};
+var exportToJson = (events, filePath) => {
+  const outputDir = import_node_path.default.dirname(filePath);
+  ensureDir(outputDir);
+  const jsonEvents = events.map((event) => {
+    const timestamp = event.timestamp instanceof Date ? event.timestamp.toISOString() : new Date(event.timestamp).toISOString();
+    if ("image" in event && event.image instanceof ArrayBuffer) {
+      return {
+        ...event,
+        timestamp,
+        image: Buffer.from(event.image).toString("base64"),
+        image_encoding: "base64"
+      };
+    }
+    return {
+      ...event,
+      timestamp
+    };
+  });
+  import_node_fs.default.writeFileSync(filePath, JSON.stringify(jsonEvents, null, 2), "utf-8");
+};
+
+// 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.
+   *
+   * This class implements the AsyncObserver protocol and provides
+   * functionality for recording events during agent execution and
+   * exporting them to Markdown or HTML formats.
+   */
+  events = [];
+  async onEvent(event) {
+    this.events.push(event);
+  }
+  addLog(message) {
+    const event = {
+      type: "log",
+      timestamp: /* @__PURE__ */ new Date(),
+      message
+    };
+    this.events.push(event);
+  }
+  addSplit(label = "") {
+    const event = {
+      type: "split",
+      timestamp: /* @__PURE__ */ new Date(),
+      label
+    };
+    this.events.push(event);
+  }
+  clear() {
+    this.events = [];
+  }
+  getEventsByStep(step_num) {
+    return this.events.filter(
+      (event) => event.step_num !== void 0 && event.step_num === step_num
+    );
+  }
+  export(format, path2, images_dir) {
+    const normalized = typeof format === "string" ? format.toLowerCase() : format;
+    switch (normalized) {
+      case "markdown" /* MARKDOWN */:
+        exportToMarkdown(this.events, path2, images_dir ?? void 0);
+        return;
+      case "html" /* HTML */:
+        exportToHtml(this.events, path2);
+        return;
+      case "json" /* JSON */:
+        exportToJson(this.events, path2);
+        return;
+      default:
+        throw new Error(`Unknown export format: ${String(format)}`);
+    }
+  }
+};
 
 // 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":
@@ -1106,7 +2431,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;
       }
@@ -1126,7 +2451,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": {
@@ -1146,7 +2471,7 @@ var DefaultActionHandler = class {
         return;
       }
       case "wait": {
-        await sleep2(this.#cfg.waitDurationMs);
+        await sleep3(this.#cfg.waitDurationMs);
         return;
       }
       case "finish": {
@@ -1167,11 +2492,13 @@ var DefaultActionHandler = class {
 0 && (module.exports = {
   APIError,
   Actor,
+  AsyncAgentObserver,
   AuthenticationError,
   Client,
   ConfigurationError,
   DefaultActionHandler,
   DefaultAgent,
+  ExportFormat,
   NetworkError,
   NotFoundError,
   OAGIError,
@@ -1179,6 +2506,7 @@ var DefaultActionHandler = class {
   RequestTimeoutError,
   ScreenshotMaker,
   ServerError,
+  TaskerAgent,
   ValidationError
 });
 //# sourceMappingURL=index.cjs.map