@oagi/oagi 0.1.3

package/dist/cli.cjs

@@ -0,0 +1,1927 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+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/cli/main.ts
+var import_commander = require("commander");
+
+// src/types/models/action.ts
+var z = __toESM(require("zod"), 1);
+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
+var z2 = __toESM(require("zod"), 1);
+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
+var z3 = __toESM(require("zod"), 1);
+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
+var z4 = __toESM(require("zod"), 1);
+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/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_meta = {};
+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_meta?.url ? import_meta.url : (0, import_node_url.pathToFileURL)(__filename).href;
+  const moduleDir = import_node_path.default.dirname((0, import_node_url.fileURLToPath)(moduleUrl));
+  const templatePath = import_node_path.default.join(moduleDir, "report_template.html");
+  const 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 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/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/actor.ts
+var import_crypto = require("crypto");
+
+// src/client.ts
+var import_openai = __toESM(require("openai"), 1);
+
+// 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/logger.ts
+var import_pino = __toESM(require("pino"), 1);
+var levelEnv = process.env.OAGI_LOG?.toLowerCase() ?? "info";
+var allowedLevels = ["debug", "info", "warn", "error", "fatal"];
+var logger = (0, import_pino.default)({
+  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/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 import_openai.default({
+      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
+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 = (0, import_crypto.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 = (0, import_crypto.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/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 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 } = import_robotjs.default.getScreenSize();
+    const screenshot = import_robotjs.default.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 = (0, import_sharp.default)(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 } = import_robotjs.default.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]);
+        import_robotjs.default.moveMouse(p.x, p.y);
+        import_robotjs.default.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]);
+        import_robotjs.default.moveMouse(p.x, p.y);
+        import_robotjs.default.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]);
+        import_robotjs.default.moveMouse(p.x, p.y);
+        import_robotjs.default.mouseClick("left", true);
+        import_robotjs.default.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]);
+        import_robotjs.default.moveMouse(p.x, p.y);
+        import_robotjs.default.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]);
+        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);
+        import_robotjs.default.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") {
+            import_robotjs.default.keyTap("capslock");
+          } else {
+            this.#sessionCapsEnabled = !this.#sessionCapsEnabled;
+          }
+          return;
+        }
+        const last = keys.at(-1);
+        if (!last) return;
+        const modifiers = keys.slice(0, -1);
+        import_robotjs.default.keyTap(last, modifiers.length ? modifiers : []);
+        await sleep2(this.#cfg.hotkeyDelayMs);
+        return;
+      }
+      case "type": {
+        const raw = arg.replace(/^['"]/, "").replace(/['"]$/, "");
+        const text = applySessionCaps(raw, this.#sessionCapsEnabled);
+        import_robotjs.default.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];
+        import_robotjs.default.moveMouse(p.x, p.y);
+        const amount = direction === "up" ? this.#cfg.scrollAmount : -this.#cfg.scrollAmount;
+        import_robotjs.default.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)}`);
+      }
+    }
+  }
+};
+
+// src/cli/display.ts
+var import_cli_table3 = __toESM(require("cli-table3"), 1);
+var displayStepTable = (steps, success, durationSeconds) => {
+  const table = new import_cli_table3.default({
+    head: ["Step", "Reasoning", "Actions", "Status"],
+    colWidths: [6, 60, 40, 10],
+    wordWrap: true
+  });
+  for (const step of steps) {
+    const reason = step.reasoning ?? "N/A";
+    const actionsDisplay = [];
+    for (const action of step.actions.slice(0, 3)) {
+      const arg = action.argument ? String(action.argument).slice(0, 20) : "";
+      const countStr = action.count && action.count > 1 ? ` x${action.count}` : "";
+      actionsDisplay.push(`${action.type}(${arg})${countStr}`);
+    }
+    let actionsStr = actionsDisplay.join(", ");
+    if (step.actions.length > 3) {
+      actionsStr += ` (+${step.actions.length - 3} more)`;
+    }
+    const statusDisplay = step.status === "completed" ? "ok" : step.status;
+    table.push([String(step.step_num), reason, actionsStr, statusDisplay]);
+  }
+  process.stdout.write(String(table) + "\n");
+  const statusText = success ? "Success" : "Failed/Interrupted";
+  process.stdout.write(
+    `
+Total Steps: ${steps.length} | Status: ${statusText}
+`
+  );
+  if (typeof durationSeconds === "number") {
+    process.stdout.write(`Duration: ${durationSeconds.toFixed(2)}s
+`);
+  }
+};
+
+// src/cli/tracking.ts
+var StepTracker = class extends StepObserver {
+  /** Tracks agent step execution by implementing AsyncObserver protocol. */
+  steps = [];
+  async onEvent(event) {
+    switch (event.type) {
+      case "step": {
+        const e = event;
+        this.steps.push({
+          step_num: e.step_num,
+          timestamp: e.timestamp,
+          reasoning: e.step.reason ?? null,
+          actions: e.step.actions,
+          action_count: e.step.actions.length,
+          status: "running"
+        });
+        return;
+      }
+      case "action": {
+        const e = event;
+        for (const step of this.steps) {
+          if (step.step_num === e.step_num) {
+            step.status = e.error ? "error" : "completed";
+            break;
+          }
+        }
+        return;
+      }
+      default:
+        return;
+    }
+  }
+};
+
+// src/cli/agent.ts
+var import_node_mac_permissions = __toESM(require("@hurdlegroup/node-mac-permissions"), 1);
+var logger5 = logger_default("cli.agent");
+var checkPermissions = async () => {
+  if (process.platform !== "darwin") {
+    process.stdout.write(
+      "Warning: Permission check is only applicable on macOS.\n"
+    );
+    process.stdout.write(
+      "On other platforms, no special permissions are required.\n"
+    );
+    return;
+  }
+  const screenPermission = import_node_mac_permissions.default.getAuthStatus("screen");
+  const accessibilityPermission = import_node_mac_permissions.default.getAuthStatus("accessibility");
+  console.log("Checking permissions...");
+  console.log(`  ${screenPermission ? "[OK]" : "[MISSING]"} Screen Recording`);
+  console.log(
+    `  ${accessibilityPermission ? "[OK]" : "[MISSING]"} Accessibility`
+  );
+  if (!screenPermission) {
+    import_node_mac_permissions.default.askForScreenCaptureAccess(true);
+  }
+  if (!accessibilityPermission) {
+    import_node_mac_permissions.default.askForAccessibilityAccess();
+  }
+  if (screenPermission && accessibilityPermission) {
+    console.log("All permissions granted. You can run the agent.");
+  } else {
+    console.log("After granting, run this command again to continue.");
+    console.log(
+      "Note: You may need to restart your terminal after granting permissions."
+    );
+    process.exitCode = 1;
+    return;
+  }
+};
+var runAgent = async (instruction, opts) => {
+  const apiKey = opts.oagiApiKey ?? process.env.OAGI_API_KEY;
+  if (!apiKey) {
+    process.stderr.write(
+      `Error: OAGI API key not provided.
+Set OAGI_API_KEY environment variable or use --oagi-api-key flag.
+Get your API key at ${API_KEY_HELP_URL}
+`
+    );
+    process.exitCode = 1;
+    return;
+  }
+  const baseUrl = opts.oagiBaseUrl ?? process.env.OAGI_BASE_URL ?? DEFAULT_BASE_URL;
+  const mode = opts.mode ?? MODE_ACTOR;
+  const stepDelay = opts.stepDelay ?? DEFAULT_STEP_DELAY;
+  const exportFormat = opts.export;
+  const exportFile = opts.exportFile;
+  const stepTracker = new StepTracker();
+  const agentObserver = exportFormat ? new AsyncAgentObserver() : null;
+  const createOpts = {
+    apiKey,
+    baseUrl,
+    stepObserver: stepTracker.chain(agentObserver),
+    stepDelay
+  };
+  if (opts.model) {
+    createOpts.model = opts.model;
+    if (opts.model === MODEL_THINKER && !opts.maxSteps) {
+      createOpts.maxSteps = DEFAULT_MAX_STEPS_THINKER;
+    }
+  }
+  if (typeof opts.maxSteps === "number") {
+    createOpts.maxSteps = opts.maxSteps;
+  }
+  if (typeof opts.temperature === "number") {
+    createOpts.temperature = opts.temperature;
+  }
+  const agent = createAgent(mode, createOpts);
+  let actionHandler;
+  let imageProvider;
+  try {
+    actionHandler = new DefaultActionHandler();
+    imageProvider = new ScreenshotMaker();
+  } catch (e) {
+    process.stderr.write(
+      `Error: desktop automation dependencies failed to load: ${String(e)}
+If you're using pnpm and robotjs is installed, you may need to run: pnpm approve-builds
+`
+    );
+    process.exitCode = 1;
+    return;
+  }
+  if (instruction) {
+    process.stdout.write(`Starting agent with instruction: ${instruction}
+`);
+  } else {
+    process.stdout.write(
+      `Starting agent with mode: ${mode} (using pre-configured instruction)
+`
+    );
+  }
+  process.stdout.write(`Mode: ${mode}
+`);
+  process.stdout.write("-".repeat(60) + "\n");
+  const start = Date.now();
+  let success = false;
+  let interrupted = false;
+  const onSigint = () => {
+    interrupted = true;
+    process.stdout.write("\nAgent execution interrupted by user (Ctrl+C)\n");
+  };
+  process.once("SIGINT", onSigint);
+  try {
+    if (interrupted) throw new Error("Interrupted");
+    success = await agent.execute(instruction, actionHandler, imageProvider);
+  } catch (err) {
+    if (interrupted) {
+      process.exitCode = 130;
+    } else {
+      logger5.error(`Error during agent execution: ${String(err)}`);
+      process.exitCode = 1;
+    }
+  } finally {
+    process.off("SIGINT", onSigint);
+    const durationSeconds = (Date.now() - start) / 1e3;
+    if (stepTracker.steps.length) {
+      process.stdout.write("\n" + "=".repeat(60) + "\n");
+      displayStepTable(stepTracker.steps, success, durationSeconds);
+    } else {
+      process.stdout.write("\nNo steps were executed.\n");
+    }
+    if (exportFormat && agentObserver) {
+      const extMap = {
+        markdown: "md",
+        html: "html",
+        json: "json"
+      };
+      const outputPath = exportFile ?? `execution_report.${extMap[exportFormat]}`;
+      try {
+        agentObserver.export(exportFormat, outputPath);
+        process.stdout.write(
+          `
+Execution history exported to: ${outputPath}
+`
+        );
+      } catch (e) {
+        process.stderr.write(
+          `
+Error exporting execution history: ${String(e)}
+`
+        );
+      }
+    }
+    if (interrupted) {
+      process.exitCode = 130;
+    } else if (!success && !process.exitCode) {
+      process.exitCode = 1;
+    }
+  }
+};
+var addAgentCommand = (program) => {
+  const agent = program.command("agent").description("Agent execution commands");
+  agent.command("run").description("Run an agent with the given instruction").argument("[instruction]", "Task instruction for the agent to execute").option("--model <model>", "Model to use (default: determined by mode)").option(
+    "--max-steps <number>",
+    "Maximum number of steps (default: determined by mode)",
+    (v) => Number(v)
+  ).option(
+    "--temperature <number>",
+    "Sampling temperature (default: determined by mode)",
+    (v) => Number(v)
+  ).option(
+    "--mode <mode>",
+    `Agent mode to use (default: ${MODE_ACTOR})`,
+    MODE_ACTOR
+  ).option(
+    "--oagi-api-key <key>",
+    "OAGI API key (default: OAGI_API_KEY env var)"
+  ).option(
+    "--oagi-base-url <url>",
+    `OAGI base URL (default: ${DEFAULT_BASE_URL}, or OAGI_BASE_URL env var)`
+  ).option(
+    "--export <format>",
+    "Export execution history to file (markdown, html, or json)"
+  ).option(
+    "--export-file <path>",
+    "Output file path for export (default: execution_report.[md|html|json])"
+  ).option(
+    "--step-delay <number>",
+    `Delay in seconds after each step before next screenshot (default: ${DEFAULT_STEP_DELAY})`,
+    (v) => Number(v)
+  ).action(async (instruction, options) => {
+    await runAgent(instruction ?? "", {
+      model: options.model,
+      maxSteps: options.maxSteps,
+      temperature: options.temperature,
+      mode: options.mode,
+      oagiApiKey: options.oagiApiKey,
+      oagiBaseUrl: options.oagiBaseUrl,
+      export: options.export,
+      exportFile: options.exportFile,
+      stepDelay: options.stepDelay
+    });
+  });
+  agent.command("modes").description("List available agent modes").action(() => {
+    const modes = listAgentModes();
+    process.stdout.write("Available agent modes:\n");
+    for (const m of modes) process.stdout.write(`  - ${m}
+`);
+  });
+  agent.command("permission").description(
+    "Check macOS permissions for screen recording and accessibility"
+  ).action(async () => {
+    await checkPermissions();
+  });
+};
+
+// src/cli/utils.ts
+var setupLogging = (verbose) => {
+  if (verbose) {
+    process.env.OAGI_LOG = "debug";
+  }
+};
+var maskApiKey = (value) => {
+  if (!value) return "";
+  return value.length > 8 ? `${value.slice(0, 8)}...` : "***";
+};
+
+// src/cli/config.ts
+var displayConfig = () => {
+  const configVars = {
+    OAGI_API_KEY: process.env.OAGI_API_KEY ?? "",
+    OAGI_BASE_URL: process.env.OAGI_BASE_URL ?? DEFAULT_BASE_URL,
+    OAGI_DEFAULT_MODEL: process.env.OAGI_DEFAULT_MODEL ?? MODEL_ACTOR,
+    OAGI_LOG: process.env.OAGI_LOG ?? "info",
+    OAGI_MAX_STEPS: process.env.OAGI_MAX_STEPS ?? "30"
+  };
+  process.stdout.write("Current Configuration:\n");
+  process.stdout.write("-".repeat(50) + "\n");
+  for (const [key, value] of Object.entries(configVars)) {
+    if (key === "OAGI_API_KEY" && value) {
+      process.stdout.write(`${key}: ${maskApiKey(value)}
+`);
+    } else {
+      const displayValue = value ? value : "(not set)";
+      process.stdout.write(`${key}: ${displayValue}
+`);
+    }
+  }
+};
+var addConfigCommand = (program) => {
+  const config = program.command("config").description("Configuration management");
+  config.command("show").description("Display current configuration").action(() => {
+    displayConfig();
+  });
+};
+
+// src/cli/version.ts
+var import_module = require("module");
+var import_meta2 = {};
+var getSdkVersion = () => {
+  try {
+    const require2 = (0, import_module.createRequire)(import_meta2.url);
+    for (const p of ["../package.json", "../../package.json"]) {
+      try {
+        const pkg = require2(p);
+        if (pkg.version && pkg.version !== "0.0.0") return pkg.version;
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return "unknown";
+};
+var displayVersion = () => {
+  const sdkVersion = getSdkVersion();
+  process.stdout.write(`OAGI SDK version: ${sdkVersion}
+`);
+  process.stdout.write(`Node version: ${process.version}
+`);
+  process.stdout.write(`Platform: ${process.platform}
+`);
+};
+var addVersionCommand = (program) => {
+  program.command("version").description("Show SDK version and environment info").action(() => {
+    displayVersion();
+  });
+};
+
+// src/cli/main.ts
+var createProgram = () => {
+  const program = new import_commander.Command();
+  program.name("oagi").description("OAGI SDK Command Line Interface").option("-v, --verbose", "Enable verbose (debug) logging");
+  addAgentCommand(program);
+  addVersionCommand(program);
+  addConfigCommand(program);
+  return program;
+};
+var main = async (argv = process.argv) => {
+  const program = createProgram();
+  try {
+    program.hook("preAction", (thisCommand) => {
+      const opts = thisCommand.opts();
+      setupLogging(Boolean(opts?.verbose));
+    });
+    await program.parseAsync(argv);
+  } catch (err) {
+    if (err instanceof Error && err.name === "CommanderError") {
+      process.exitCode = 1;
+      return;
+    }
+    if (err instanceof Error && err.message === "Interrupted") {
+      process.exitCode = 130;
+      return;
+    }
+    process.stderr.write(`Unexpected error: ${String(err)}
+`);
+    process.exitCode = 1;
+  }
+};
+
+// src/cli.ts
+main().catch((err) => {
+  process.stderr.write(`Unexpected error: ${String(err)}
+`);
+  process.exitCode = 1;
+});
+//# sourceMappingURL=cli.cjs.map