@oagi/oagi 0.1.3

package/dist/chunk-SDBYP57G.js

@@ -0,0 +1,1536 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+
+// src/errors.ts
+var OAGIError = class extends Error {
+};
+var APIError = class extends OAGIError {
+  constructor(response, message) {
+    super(message ?? response.statusText);
+    this.response = response;
+  }
+  toString() {
+    return `API Error [${this.response.status}]: ${this.message}`;
+  }
+};
+var AuthenticationError = class extends APIError {
+};
+var RateLimitError = class extends APIError {
+};
+var ValidationError = class extends APIError {
+};
+var NotFoundError = class extends APIError {
+};
+var ServerError = class extends APIError {
+};
+var ConfigurationError = class extends OAGIError {
+};
+var NetworkError = class extends OAGIError {
+  constructor(message, originalError) {
+    super(message);
+    this.originalError = originalError;
+  }
+};
+var RequestTimeoutError = class extends NetworkError {
+};
+var ValueError = class extends OAGIError {
+};
+
+// src/client.ts
+import OpenAI from "openai";
+
+// src/consts.ts
+var DEFAULT_BASE_URL = "https://api.agiopen.org";
+var API_KEY_HELP_URL = "https://developer.agiopen.org/api-keys";
+var API_V1_FILE_UPLOAD_ENDPOINT = "/v1/file/upload";
+var API_V1_GENERATE_ENDPOINT = "/v1/generate";
+var MODEL_ACTOR = "lux-actor-1";
+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_TEMPERATURE = 0.5;
+var DEFAULT_TEMPERATURE_LOW = 0.1;
+var HTTP_CLIENT_TIMEOUT = 60;
+var DEFAULT_MAX_RETRIES = 2;
+
+// src/logger.ts
+import pino from "pino";
+var levelEnv = process.env.OAGI_LOG?.toLowerCase() ?? "info";
+var allowedLevels = ["debug", "info", "warn", "error", "fatal"];
+var logger = pino({
+  level: allowedLevels.includes(levelEnv) ? levelEnv : "info",
+  base: null,
+  timestamp: () => `,"time":"${(/* @__PURE__ */ new Date()).toISOString()}"`,
+  messageKey: "msg",
+  transport: {
+    target: "pino-pretty",
+    options: {
+      colorize: false,
+      translateTime: "SYS:yyyy-mm-dd HH:MM:ss",
+      messageFormat: "{msg}",
+      ignore: "pid,hostname"
+    }
+  }
+});
+var getLogger = (name) => logger.child({ name: `oagi.${name}` });
+var logger_default = getLogger;
+var logTraceOnFailure = (_, __, descriptor) => {
+  const original = descriptor.value;
+  descriptor.value = async function(...args) {
+    try {
+      return await original.apply(this, args);
+    } catch (err) {
+      if (err instanceof APIError) {
+        const requestId = err.response.headers.get("x-request-id") ?? "";
+        const traceId = err.response.headers.get("x-trace-id") ?? "";
+        logger.error(`Request Id: ${requestId}`);
+        logger.error(`Trace Id: ${traceId}`);
+      }
+      throw err;
+    }
+  };
+  return descriptor;
+};
+
+// src/types/models/action.ts
+import * as z from "zod";
+var ActionTypeSchema = z.enum([
+  "click",
+  "left_double",
+  "left_triple",
+  "right_single",
+  "drag",
+  "hotkey",
+  "type",
+  "scroll",
+  "finish",
+  "wait",
+  "call_user"
+]);
+var ActionSchema = z.object({
+  /**
+   * Type of action to perform
+   */
+  type: ActionTypeSchema,
+  /**
+   * Action argument in the specified format
+   */
+  argument: z.string(),
+  /**
+   * Number of times to repeat the action
+   */
+  count: z.int().default(1)
+});
+var parseCoords = (args) => {
+  const match = /(\d+),\s*(\d+)/.exec(args);
+  if (!match) {
+    return null;
+  }
+  return [Number(match[1]), Number(match[2])];
+};
+var parseDragCoords = (args) => {
+  const match = /(\d+),\s*(\d+),\s*(\d+),\s*(\d+)/.exec(args);
+  if (!match) {
+    return null;
+  }
+  return [
+    Number(match[1]),
+    Number(match[2]),
+    Number(match[3]),
+    Number(match[4])
+  ];
+};
+var parseScroll = (args) => {
+  const match = /(\d+),\s*(\d+),\s*(\w+)/.exec(args);
+  if (!match) {
+    return null;
+  }
+  return [Number(match[1]), Number(match[2]), match[3].toLowerCase()];
+};
+
+// src/types/models/client.ts
+import * as z2 from "zod";
+var UsageSchema = z2.object({
+  prompt_tokens: z2.int(),
+  completion_tokens: z2.int(),
+  total_tokens: z2.int()
+});
+var ErrorDetailSchema = z2.object({
+  code: z2.string(),
+  message: z2.string()
+});
+var ErrorResponseSchema = z2.object({
+  error: ErrorDetailSchema.nullish()
+});
+var UploadFileResponseSchema = z2.object({
+  url: z2.string(),
+  uuid: z2.string(),
+  expires_at: z2.int(),
+  file_expires_at: z2.int(),
+  download_url: z2.string()
+});
+var GenerateResponseSchema = z2.object({
+  response: z2.string(),
+  prompt_tokens: z2.int(),
+  completion_tokens: z2.int(),
+  /**
+   * @deprecated This field is deprecated
+   */
+  cost: z2.float64().nullish(),
+  request_id: z2.string().nullish()
+});
+
+// src/types/models/image-config.ts
+import * as z3 from "zod";
+var ImageConfigSchema = z3.object({
+  format: z3.enum(["PNG", "JPEG"]).default("JPEG"),
+  quality: z3.int().min(1).max(100).default(85),
+  width: z3.int().positive().nullish().default(1260),
+  height: z3.int().positive().nullish().default(700),
+  optimize: z3.boolean().default(false),
+  resample: z3.enum(["NEAREST", "BILINEAR", "BICUBIC", "LANCZOS"]).default("LANCZOS")
+}).transform((value) => {
+  if (value.format === "PNG") {
+    return { ...value, quality: 85 };
+  }
+  return value;
+});
+
+// src/types/step_observer.ts
+import * as z4 from "zod";
+var BaseEventSchema = z4.object({
+  timestamp: z4.date().default(() => /* @__PURE__ */ new Date())
+});
+var ImageEventSchema = BaseEventSchema.extend({
+  type: z4.literal("image"),
+  step_num: z4.number(),
+  image: z4.string()
+});
+var StepEventSchema = BaseEventSchema.extend({
+  type: z4.literal("step"),
+  step_num: z4.number(),
+  image: z4.custom(),
+  step: z4.custom(),
+  task_id: z4.string().optional()
+});
+var ActionEventSchema = BaseEventSchema.extend({
+  type: z4.literal("action"),
+  step_num: z4.number(),
+  actions: z4.array(z4.custom()),
+  error: z4.string().optional()
+});
+var LogEventSchema = BaseEventSchema.extend({
+  type: z4.literal("log"),
+  message: z4.string()
+});
+var SplitEventSchema = BaseEventSchema.extend({
+  type: z4.literal("split"),
+  label: z4.string().optional()
+});
+var PlanEventSchema = BaseEventSchema.extend({
+  type: z4.literal("plan"),
+  phase: z4.enum(["initial", "reflection", "summary"]),
+  image: z4.string().or(z4.custom()).optional(),
+  reasoning: z4.string(),
+  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) => {
+  const actions = [];
+  let currentAction = [];
+  let parenLevel = 0;
+  for (const char of actionBlock) {
+    currentAction.push(char);
+    switch (char) {
+      case "(":
+        parenLevel++;
+        break;
+      case ")":
+        parenLevel--;
+        break;
+      case "&":
+        if (parenLevel === 0) {
+          const action = currentAction.join("").trim();
+          action && actions.push(action);
+          currentAction = [];
+        }
+        break;
+    }
+  }
+  const lastAction = currentAction.join("").trim();
+  lastAction && actions.push(lastAction);
+  return actions;
+};
+var parseAction = (action) => {
+  const match = /(\w+)\((.*)\)/.exec(action);
+  if (!match) return null;
+  const { data: actionType, success } = ActionTypeSchema.safeParse(match[1]);
+  if (!success) return null;
+  let argument = match[2].trim();
+  const args = argument.split(",");
+  let count = 1;
+  switch (actionType) {
+    // hotkey(key, c) - press key c times
+    case "hotkey":
+      if (args.length >= 2 && args[1].trim()) {
+        argument = args[0].trim();
+        count = Number(args[1].trim());
+      }
+      break;
+    case "scroll":
+      if (args.length >= 4) {
+        const x = args[0].trim();
+        const y = args[1].trim();
+        const direction = args[2].trim();
+        argument = `${x},${y},${direction}`;
+        count = Number(args[3].trim());
+      }
+      break;
+    default:
+  }
+  if (!Number.isInteger(count) || count <= 0) {
+    count = 1;
+  }
+  return { type: actionType, argument, count };
+};
+var parseRawOutput = (rawOutput) => {
+  const reason = /<\|think_start\|>(.*?)<\|think_end\|>/s.exec(rawOutput)?.[1] ?? "";
+  const action = /<\|action_start\|>(.*?)<\|action_end\|>/s.exec(rawOutput)?.[1] ?? "";
+  const actions = splitActions(action).map(parseAction).filter((action2) => !!action2);
+  return {
+    reason,
+    actions,
+    stop: actions.some((action2) => action2.type === "finish")
+  };
+};
+
+// src/utils/prompt-builder.ts
+var buildPrompt = (taskDescription) => `You are a Desktop Agent completing computer use tasks from a user instruction.
+
+Every step, you will look at the screenshot and output the desired actions in a format as:
+
+<|think_start|> brief description of your intent and reasoning <|think_end|>
+<|action_start|> one of the allowed actions as below <|action_end|>
+
+In the action field, you have the following action formats:
+1. click(x, y) # left-click at the position (x, y), where x and y are integers normalized between 0 and 1000
+2. left_double(x, y) # left-double-click at the position (x, y), where x and y are integers normalized between 0 and 1000
+3. left_triple(x, y) # left-triple-click at the position (x, y), where x and y are integers normalized between 0 and 1000
+4. right_single(x, y) # right-click at the position (x, y), where x and y are integers normalized between 0 and 1000
+5. drag(x1, y1, x2, y2) # drag the mouse from (x1, y1) to (x2, y2) to select or move contents, where x1, y1, x2, y2 are integers normalized between 0 and 1000
+6. hotkey(key, c) # press the key for c times
+7. type(text) # type a text string on the keyboard
+8. scroll(x, y, direction, c) # scroll the mouse at position (x, y) in the direction of up or down for c times, where x and y are integers normalized between 0 and 1000
+9. wait() # wait for a while
+10. finish() # indicate the task is finished
+
+Directly output the text beginning with <|think_start|>, no additional text is needed for this scenario.
+
+The user instruction is:
+${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;
+    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}`
+      );
+    }
+    this.client = new OpenAI({
+      baseURL: new URL("./v1", baseUrl).href,
+      apiKey,
+      maxRetries
+    });
+    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);
+    } else {
+      input = new URL(input.url, this.baseUrl);
+    }
+    init ??= {};
+    const signal = AbortSignal.timeout(this.timeout * 1e3);
+    init.signal = init.signal ? AbortSignal.any([signal, init.signal]) : signal;
+    return fetch(input, init);
+  }
+  buildHeaders(apiVersion) {
+    const headers = {};
+    if (apiVersion) {
+      headers["x-api-version"] = apiVersion;
+    }
+    if (this.apiKey) {
+      headers["x-api-key"] = this.apiKey;
+    }
+    return headers;
+  }
+  async handleResponseError(response) {
+    const data = await response.json();
+    const cls = _Client.getErrorClass(response.status);
+    const err = new cls(response, data.error?.message);
+    logger2.error(err.toString());
+    throw err;
+  }
+  handleHttpErrors(err) {
+    if (err instanceof DOMException) {
+      if (err.name === "TimeoutError") {
+        const message = `Request timed out after ${this.timeout} seconds`;
+        logger2.error(message);
+        throw new RequestTimeoutError(message, err);
+      }
+    } else if (err instanceof TypeError) {
+      const message = `Network error: ${err}`;
+      logger2.error(message);
+      throw new NetworkError(message, err);
+    }
+    throw err;
+  }
+  static getErrorClass(statusCode) {
+    if (statusCode >= 500) return ServerError;
+    return {
+      401: AuthenticationError,
+      404: NotFoundError,
+      422: ValidationError,
+      429: RateLimitError
+    }[statusCode] ?? APIError;
+  }
+  /**
+   * Call OpenAI-compatible /v1/chat/completions endpoint.
+   *
+   * @param model Model to use for inference
+   * @param messages Full message history (OpenAI-compatible format)
+   * @param temperature Sampling temperature (0.0-2.0)
+   * @param taskId Optional task ID for multi-turn conversations
+   * @returns Tuple of (Step, raw_output, Usage)
+   *   - Step: Parsed actions and reasoning
+   *   - raw_output: Raw model output string (for message history)
+   *   - Usage: Token usage statistics (or None if not available)
+   */
+  async chatCompletions(model, messages, temperature, taskId) {
+    logger2.info(`Making async chat completion request with model: ${model}`);
+    const response = await this.client.chat.completions.create({
+      model,
+      messages,
+      temperature,
+      // @ts-expect-error extra body
+      task_id: taskId
+    });
+    const rawOutput = response.choices[0].message.content ?? "";
+    const step = parseRawOutput(rawOutput);
+    taskId = response.task_id;
+    const task = taskId ? `task_id: ${taskId}, ` : "";
+    const usage = response.usage ? `, tokens: ${response.usage.prompt_tokens}+${response.usage.completion_tokens}` : "";
+    logger2.info(
+      `Chat completion successful - ${task}actions: ${step.actions.length}, stop: ${step.stop}${usage}`
+    );
+    return [step, rawOutput, response.usage];
+  }
+  /**
+   * Call the /v1/file/upload endpoint to get a S3 presigned URL
+   *
+   * @param apiVersion API version header
+   * @returns {Promise<UploadFileResponse>} The response from /v1/file/upload with uuid and presigned S3 URL
+   */
+  async getS3PresignedUrl(apiVersion) {
+    logger2.debug(`Making async API request to ${API_V1_FILE_UPLOAD_ENDPOINT}`);
+    try {
+      const headers = this.buildHeaders(apiVersion);
+      const response = await this.fetch(API_V1_FILE_UPLOAD_ENDPOINT, {
+        headers
+      });
+      if (!response.ok) {
+        await this.handleResponseError(response);
+      }
+      try {
+        const uploadFileResponse = UploadFileResponseSchema.parse(
+          await response.json()
+        );
+        logger2.debug("Calling /v1/file/upload successful");
+        return uploadFileResponse;
+      } catch (err) {
+        logger2.error(`Invalid upload response: ${response.status}`);
+        throw new APIError(
+          response,
+          `Invalid presigned S3 URL response: ${err}`
+        );
+      }
+    } catch (err) {
+      this.handleHttpErrors(err);
+    }
+  }
+  /**
+   * Upload image bytes to S3 using presigned URL
+   *
+   * @param url S3 presigned URL
+   * @param content Image bytes to upload
+   * @throws {APIError} If upload fails
+   */
+  async uploadToS3(url, content) {
+    logger2.debug("Uploading image to S3");
+    let response = null;
+    try {
+      response = await this.fetch(url, {
+        body: content,
+        method: "PUT"
+      });
+      if (!response.ok) {
+        await this.handleResponseError(response);
+      }
+    } catch (err) {
+      logger2.error(`S3 upload failed ${err}`);
+      if (err instanceof APIError) {
+        throw err;
+      }
+      throw new APIError(
+        response ?? new Response(null, { status: 500 }),
+        `${err}`
+      );
+    }
+  }
+  /**
+   * Get S3 presigned URL and upload image (convenience method)
+   *
+   * @param screenshot Screenshot image bytes
+   * @param apiVersion API version header
+   * @returns {UploadFileResponse} The response from /v1/file/upload with uuid and presigned S3 URL
+   */
+  async putS3PresignedUrl(screenshot, apiVersion) {
+    const uploadFileResponse = await this.getS3PresignedUrl(apiVersion);
+    await this.uploadToS3(uploadFileResponse.url, screenshot);
+    return uploadFileResponse;
+  }
+  async callWorker({
+    workerId,
+    overallTodo,
+    taskDescription,
+    todos,
+    history = [],
+    currentTodoIndex,
+    taskExecutionSummary,
+    currentScreenshot,
+    currentSubtaskInstruction,
+    windowSteps,
+    windowScreenshots,
+    resultScreenshot,
+    priorNotes,
+    latestTodoSummary,
+    apiVersion
+  }) {
+    const validWorkers = ["oagi_first", "oagi_follow", "oagi_task_summary"];
+    if (!validWorkers.includes(workerId)) {
+      throw new ValueError(
+        `Invalid worker_id '${workerId}'. Must be one of: ${validWorkers}`
+      );
+    }
+    logger2.info(`Calling /v1/generate with worker_id: ${workerId}`);
+    const payload = {
+      external_worker_id: workerId,
+      overall_todo: overallTodo,
+      task_description: taskDescription,
+      todos,
+      history,
+      // Add optional memory fields
+      current_todo_index: currentTodoIndex,
+      task_execution_summary: taskExecutionSummary,
+      // Add optional screenshot/worker-specific fields
+      current_screenshot: currentScreenshot,
+      current_subtask_instruction: currentSubtaskInstruction,
+      window_steps: windowSteps,
+      window_screenshots: windowScreenshots,
+      result_screenshot: resultScreenshot,
+      prior_notes: priorNotes,
+      latest_todo_summary: latestTodoSummary
+    };
+    const headers = this.buildHeaders(apiVersion);
+    try {
+      const response = await this.fetch(API_V1_GENERATE_ENDPOINT, {
+        body: JSON.stringify(payload),
+        headers,
+        method: "POST"
+      });
+      if (!response.ok) {
+        await this.handleResponseError(response);
+      }
+      const result = GenerateResponseSchema.parse(await response.json());
+      result.request_id = response.headers.get("X-Request-ID");
+      logger2.info(
+        `Generate request successful - tokens: ${result.prompt_tokens}+${result.completion_tokens}, request_id: ${result.request_id}`
+      );
+      return result;
+    } catch (err) {
+      this.handleHttpErrors(err);
+    }
+  }
+};
+__decorateClass([
+  logTraceOnFailure
+], _Client.prototype, "callWorker", 1);
+var Client = _Client;
+
+// src/actor.ts
+import { randomUUID } from "crypto";
+var logger3 = logger_default("task");
+var Actor = class {
+  constructor(apiKey, baseUrl, model = MODEL_ACTOR, temperature) {
+    this.model = model;
+    this.temperature = temperature;
+    this.client = new Client(baseUrl, apiKey);
+  }
+  /**
+   * Client-side generated UUID
+   */
+  taskId = randomUUID();
+  taskDescription = null;
+  /**
+   * OpenAI-compatible message history
+   */
+  messageHistory = [];
+  maxSteps = DEFAULT_MAX_STEPS;
+  /**
+   * Current step counter
+   */
+  currentStep = 0;
+  client;
+  validateAndIncrementStep() {
+    if (!this.taskDescription) {
+      throw new ValueError(
+        "Task description must be set. Call initTask() first."
+      );
+    }
+    if (this.currentStep >= this.maxSteps) {
+      throw new ValueError(
+        `Max steps limit (${this.maxSteps}) reached. Call initTask() to start a new task.`
+      );
+    }
+    this.currentStep++;
+  }
+  /**
+   * Get screenshot URL, uploading to S3 if needed (async version).
+   * @param screenshot Screenshot as URL string, or raw bytes
+   * @returns Screenshot URL (either direct or from S3 upload)
+   */
+  async ensureScreenshotUrl(screenshot) {
+    if (typeof screenshot === "string") return screenshot;
+    const uploadResponse = await this.client.putS3PresignedUrl(screenshot);
+    return uploadResponse.download_url;
+  }
+  /**
+   * Add user message with screenshot to message history.
+   *
+   * @param screenshot URL of the screenshot
+   * @param prompt Optional prompt text (for first message only)
+   */
+  addUserMessageToHistory(screenshot, prompt) {
+    const content = [];
+    if (prompt) {
+      content.push({
+        type: "text",
+        text: prompt
+      });
+    }
+    content.push({
+      type: "image_url",
+      image_url: {
+        url: screenshot
+      }
+    });
+    this.messageHistory.push({ role: "user", content });
+  }
+  /**
+   * Build prompt for first message only.
+   */
+  buildStepPrompt() {
+    if (this.messageHistory.length === 0) {
+      return buildPrompt(this.taskDescription);
+    }
+  }
+  /**
+   * Initialize a new task with the given description.
+   *
+   * @param taskDescription Task description
+   * @param maxSteps Maximum number of steps allowed
+   */
+  initTask(taskDescription, maxSteps = DEFAULT_MAX_STEPS) {
+    this.taskId = randomUUID();
+    this.taskDescription = taskDescription;
+    this.messageHistory = [];
+    const limit = this.model == MODEL_THINKER ? MAX_STEPS_THINKER : MAX_STEPS_ACTOR;
+    if (maxSteps > limit) {
+      logger3.warn(
+        `max_steps (${maxSteps}) exceeds limit for model '${this.model}'. Capping to ${limit}.`
+      );
+      maxSteps = limit;
+    }
+    this.maxSteps = maxSteps;
+    this.currentStep = 0;
+    logger3.info(
+      `Task initialized: '${taskDescription}' (max_steps: ${maxSteps})`
+    );
+  }
+  /**
+   * Send screenshot to the server and get the next actions.
+   *
+   * @param screenshot Screenshot as URL string, or raw bytes
+   * @param instruction Optional additional instruction for this step (currently unused)
+   * @param temperature Sampling temperature for this step (overrides task default if provided)
+   */
+  async step(screenshot, _instruction, temperature) {
+    this.validateAndIncrementStep();
+    logger3.debug(`Executing step for task: '${this.taskDescription}'`);
+    try {
+      const screenshotUrl = await this.ensureScreenshotUrl(screenshot);
+      this.addUserMessageToHistory(screenshotUrl, this.buildStepPrompt());
+      const [step, rawOutput] = await this.client.chatCompletions(
+        this.model,
+        this.messageHistory,
+        temperature ?? this.temperature,
+        this.taskId
+      );
+      if (rawOutput) {
+        this.messageHistory.push({
+          role: "assistant",
+          content: [
+            {
+              type: "text",
+              text: rawOutput
+            }
+          ]
+        });
+      }
+      if (step.stop) {
+        logger3.info("Task completed.");
+      } else {
+        logger3.debug(`Step completed with${step.actions.length} actions`);
+      }
+      return step;
+    } catch (err) {
+      logger3.error(`Error during step execution: ${err}`);
+      throw err;
+    }
+  }
+};
+
+// src/agent/default.ts
+var logger4 = logger_default("agent.default");
+var resetHandler = (handler) => {
+  if (typeof handler.reset === "function") {
+    handler.reset();
+  }
+};
+var sleep = (seconds) => new Promise((resolve) => setTimeout(resolve, seconds * 1e3));
+var DefaultAgent = class {
+  /** Default asynchronous agent implementation using OAGI client. */
+  api_key;
+  base_url;
+  model;
+  max_steps;
+  temperature;
+  step_observer;
+  step_delay;
+  constructor(api_key, base_url, model = MODEL_ACTOR, max_steps = DEFAULT_MAX_STEPS, temperature = DEFAULT_TEMPERATURE, step_observer, step_delay = DEFAULT_STEP_DELAY) {
+    this.api_key = api_key;
+    this.base_url = base_url;
+    this.model = model;
+    this.max_steps = max_steps;
+    this.temperature = temperature;
+    this.step_observer = step_observer;
+    this.step_delay = step_delay;
+  }
+  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);
+    resetHandler(action_handler);
+    for (let i = 0; i < this.max_steps; i++) {
+      const step_num = i + 1;
+      logger4.debug(`Executing step ${step_num}/${this.max_steps}`);
+      const image = await image_provider.provide();
+      const step = await actor.step(image, void 0, this.temperature);
+      if (step.reason) {
+        logger4.info(`Step ${step_num}: ${step.reason}`);
+      }
+      if (this.step_observer) {
+        const event = {
+          type: "step",
+          timestamp: /* @__PURE__ */ new Date(),
+          step_num,
+          image,
+          step,
+          task_id: actor.taskId
+        };
+        await this.step_observer.onEvent(event);
+      }
+      if (step.actions?.length) {
+        logger4.info(`Actions (${step.actions.length}):`);
+        for (const action of step.actions) {
+          const count_suffix = action.count && action.count > 1 ? ` x${action.count}` : "";
+          logger4.info(`  [${action.type}] ${action.argument}${count_suffix}`);
+        }
+        let error = null;
+        try {
+          await action_handler.handle(step.actions);
+        } catch (e) {
+          error = String(e);
+          throw e;
+        } finally {
+          if (this.step_observer) {
+            const event = {
+              type: "action",
+              timestamp: /* @__PURE__ */ new Date(),
+              step_num,
+              actions: step.actions,
+              error: error ?? void 0
+            };
+            await this.step_observer.onEvent(event);
+          }
+        }
+      }
+      if (this.step_delay > 0) {
+        await sleep(this.step_delay);
+      }
+      if (step.stop) {
+        logger4.info(`Task completed successfully after ${step_num} steps`);
+        return true;
+      }
+    }
+    logger4.warn(
+      `Task reached max steps (${this.max_steps}) without completion`
+    );
+    return false;
+  }
+};
+
+// 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
+  );
+});
+
+// src/agent/observer/exporters.ts
+import fs from "fs";
+import path from "path";
+import { fileURLToPath, pathToFileURL } from "url";
+var ensureDir = (dirPath) => {
+  fs.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 = path.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 = path.join(imagesDir, imageFilename);
+            fs.writeFileSync(imagePath, Buffer.from(event.image));
+            const relPath = path.join(path.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 = path.join(imagesDir, imageFilename);
+              fs.writeFileSync(imagePath, Buffer.from(event.image));
+              const relPath = path.join(
+                path.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;
+      }
+    }
+  }
+  fs.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 = path.dirname(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 template = fs.readFileSync(templatePath, "utf-8");
+  const eventsData = convertEventsForHtml(events);
+  const eventsJson = JSON.stringify(eventsData);
+  const htmlContent = template.replace("{EVENTS_DATA}", eventsJson);
+  fs.writeFileSync(filePath, htmlContent, "utf-8");
+};
+var exportToJson = (events, filePath) => {
+  const outputDir = path.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
+    };
+  });
+  fs.writeFileSync(filePath, JSON.stringify(jsonEvents, null, 2), "utf-8");
+};
+
+// src/agent/observer/agent_observer.ts
+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
+import robot from "robotjs";
+import sharp from "sharp";
+var sleep2 = (ms) => new Promise((r) => setTimeout(r, ms));
+var toSharpKernel = (resample) => {
+  switch (resample) {
+    case "NEAREST":
+      return "nearest";
+    case "BICUBIC":
+      return "cubic";
+    case "BILINEAR":
+      return "mitchell";
+    case "LANCZOS":
+    default:
+      return "lanczos3";
+  }
+};
+var normalizeKey = (raw, opts) => {
+  const key = raw.trim().toLowerCase();
+  if (key === "caps_lock" || key === "caps") return "capslock";
+  if (key === "page_up" || key === "pageup") return "pageup";
+  if (key === "page_down" || key === "pagedown") return "pagedown";
+  if (key === "cmd") return "command";
+  if (opts.macosCtrlToCmd && process.platform === "darwin" && key === "ctrl") {
+    return "command";
+  }
+  if (key === "ctrl") return "control";
+  return key;
+};
+var parseHotkey = (arg, opts) => {
+  const s = arg.trim().replace(/^\(/, "").replace(/\)$/, "");
+  return s.split("+").map((k) => normalizeKey(k, opts)).filter(Boolean);
+};
+var stripOuterParens = (s) => s.trim().replace(/^\(/, "").replace(/\)$/, "");
+var applySessionCaps = (text, enabled) => {
+  if (!enabled) return text;
+  return text.split("").map((c) => /[a-z]/i.test(c) ? c.toUpperCase() : c).join("");
+};
+var defaultDesktopAutomationConfig = () => ({
+  dragDurationMs: 500,
+  scrollAmount: process.platform === "darwin" ? 2 : 100,
+  waitDurationMs: 1e3,
+  hotkeyDelayMs: 100,
+  macosCtrlToCmd: true,
+  capslockMode: "session"
+});
+var ScreenshotMaker = class _ScreenshotMaker {
+  #cfg;
+  constructor(cfg) {
+    const defaultConfig = ImageConfigSchema.parse({});
+    this.#cfg = { ...defaultConfig, ...cfg };
+  }
+  static toArrayBuffer(buffer) {
+    const arraybuffer = new ArrayBuffer(buffer.length);
+    const view = new Uint8Array(arraybuffer);
+    for (let i = 0; i < buffer.length; ++i) {
+      view[i] = buffer[i];
+    }
+    return arraybuffer;
+  }
+  async provide() {
+    const { width, height } = robot.getScreenSize();
+    const screenshot = robot.screen.capture(0, 0, width, height);
+    const channels = 3;
+    const data = new Uint8Array(
+      screenshot.width * screenshot.height * channels
+    );
+    for (let w = 0; w < screenshot.width; ++w) {
+      for (let h = 0; h < screenshot.height; ++h) {
+        let offset = (h * screenshot.width + w) * channels;
+        let offset2 = screenshot.byteWidth * h + w * screenshot.bytesPerPixel;
+        data[offset] = screenshot.image.readUInt8(offset2 + 2);
+        data[offset + 1] = screenshot.image.readUInt8(offset2 + 1);
+        data[offset + 2] = screenshot.image.readUInt8(offset2 + 0);
+      }
+    }
+    let p = sharp(Buffer.from(data), {
+      raw: {
+        width: screenshot.width,
+        height: screenshot.height,
+        channels
+      }
+    });
+    if (this.#cfg.width || this.#cfg.height) {
+      p = p.resize(this.#cfg.width ?? width, this.#cfg.height ?? height, {
+        fit: "fill",
+        kernel: toSharpKernel(this.#cfg.resample)
+      });
+    }
+    const encoded = this.#cfg.format === "PNG" ? await p.png({ compressionLevel: this.#cfg.optimize ? 9 : 6 }).toBuffer() : await p.jpeg({ quality: this.#cfg.quality }).toBuffer();
+    return _ScreenshotMaker.toArrayBuffer(encoded);
+  }
+};
+var DefaultActionHandler = class {
+  #cfg;
+  #sessionCapsEnabled = false;
+  constructor(cfg) {
+    this.#cfg = { ...defaultDesktopAutomationConfig(), ...cfg };
+  }
+  reset() {
+    this.#sessionCapsEnabled = false;
+  }
+  async handle(actions) {
+    for (const action of actions) {
+      const count = action.count ?? 1;
+      for (let i = 0; i < count; i++) {
+        await this.#handleOne(action);
+      }
+    }
+  }
+  #denormalize(x, y) {
+    const { width, height } = robot.getScreenSize();
+    let px = Math.floor(x * width / 1e3);
+    let py = Math.floor(y * height / 1e3);
+    if (px < 1) px = 1;
+    if (px > width - 1) px = width - 1;
+    if (py < 1) py = 1;
+    if (py > height - 1) py = height - 1;
+    return { x: px, y: py };
+  }
+  async #handleOne(action) {
+    const arg = stripOuterParens(action.argument);
+    switch (action.type) {
+      case "click": {
+        const coords = parseCoords(arg);
+        if (!coords) throw new Error(`Invalid coords: ${arg}`);
+        const p = this.#denormalize(coords[0], coords[1]);
+        robot.moveMouse(p.x, p.y);
+        robot.mouseClick("left", false);
+        return;
+      }
+      case "left_double": {
+        const coords = parseCoords(arg);
+        if (!coords) throw new Error(`Invalid coords: ${arg}`);
+        const p = this.#denormalize(coords[0], coords[1]);
+        robot.moveMouse(p.x, p.y);
+        robot.mouseClick("left", true);
+        return;
+      }
+      case "left_triple": {
+        const coords = parseCoords(arg);
+        if (!coords) throw new Error(`Invalid coords: ${arg}`);
+        const p = this.#denormalize(coords[0], coords[1]);
+        robot.moveMouse(p.x, p.y);
+        robot.mouseClick("left", true);
+        robot.mouseClick("left", false);
+        return;
+      }
+      case "right_single": {
+        const coords = parseCoords(arg);
+        if (!coords) throw new Error(`Invalid coords: ${arg}`);
+        const p = this.#denormalize(coords[0], coords[1]);
+        robot.moveMouse(p.x, p.y);
+        robot.mouseClick("right", false);
+        return;
+      }
+      case "drag": {
+        const coords = parseDragCoords(arg);
+        if (!coords) throw new Error(`Invalid drag coords: ${arg}`);
+        const p1 = this.#denormalize(coords[0], coords[1]);
+        const p2 = this.#denormalize(coords[2], coords[3]);
+        robot.moveMouse(p1.x, p1.y);
+        robot.mouseToggle("down", "left");
+        robot.dragMouse(p2.x, p2.y);
+        await sleep2(this.#cfg.dragDurationMs);
+        robot.mouseToggle("up", "left");
+        return;
+      }
+      case "hotkey": {
+        const keys = parseHotkey(arg, {
+          macosCtrlToCmd: this.#cfg.macosCtrlToCmd
+        });
+        if (keys.length === 1 && keys[0] === "capslock") {
+          if (this.#cfg.capslockMode === "system") {
+            robot.keyTap("capslock");
+          } else {
+            this.#sessionCapsEnabled = !this.#sessionCapsEnabled;
+          }
+          return;
+        }
+        const last = keys.at(-1);
+        if (!last) return;
+        const modifiers = keys.slice(0, -1);
+        robot.keyTap(last, modifiers.length ? modifiers : []);
+        await sleep2(this.#cfg.hotkeyDelayMs);
+        return;
+      }
+      case "type": {
+        const raw = arg.replace(/^['"]/, "").replace(/['"]$/, "");
+        const text = applySessionCaps(raw, this.#sessionCapsEnabled);
+        robot.typeString(text);
+        return;
+      }
+      case "scroll": {
+        const parsed = parseScroll(arg);
+        if (!parsed) throw new Error(`Invalid scroll: ${arg}`);
+        const p = this.#denormalize(parsed[0], parsed[1]);
+        const direction = parsed[2];
+        robot.moveMouse(p.x, p.y);
+        const amount = direction === "up" ? this.#cfg.scrollAmount : -this.#cfg.scrollAmount;
+        robot.scrollMouse(0, amount);
+        return;
+      }
+      case "wait": {
+        await sleep2(this.#cfg.waitDurationMs);
+        return;
+      }
+      case "finish": {
+        this.reset();
+        return;
+      }
+      case "call_user": {
+        return;
+      }
+      default: {
+        const exhaustive = action.type;
+        throw new Error(`Unknown action type: ${String(exhaustive)}`);
+      }
+    }
+  }
+};
+
+export {
+  DEFAULT_BASE_URL,
+  API_KEY_HELP_URL,
+  MODEL_ACTOR,
+  MODEL_THINKER,
+  MODE_ACTOR,
+  DEFAULT_MAX_STEPS_THINKER,
+  DEFAULT_STEP_DELAY,
+  OAGIError,
+  APIError,
+  AuthenticationError,
+  RateLimitError,
+  ValidationError,
+  NotFoundError,
+  ServerError,
+  ConfigurationError,
+  NetworkError,
+  RequestTimeoutError,
+  logger_default,
+  StepObserver,
+  Client,
+  Actor,
+  DefaultAgent,
+  listAgentModes,
+  createAgent,
+  AsyncAgentObserver,
+  ScreenshotMaker,
+  DefaultActionHandler
+};
+//# sourceMappingURL=chunk-SDBYP57G.js.map