agi 0.4.0 → 0.5.1

package/dist/index.js

@@ -1,1742 +0,0 @@
-'use strict';
-
-var eventsourceParser = require('eventsource-parser');
-var child_process = require('child_process');
-var events = require('events');
-var readline = require('readline');
-var fs = require('fs');
-var path = require('path');
-var url = require('url');
-var os = require('os');
-var module$1 = require('module');
-
-var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
-// src/http.ts
-
-// src/errors.ts
-var AGIError = class _AGIError extends Error {
-  constructor(message, statusCode, response) {
-    super(message);
-    this.statusCode = statusCode;
-    this.response = response;
-    this.name = "AGIError";
-    Object.setPrototypeOf(this, _AGIError.prototype);
-  }
-};
-var AuthenticationError = class _AuthenticationError extends AGIError {
-  constructor(message, response) {
-    super(message, 401, response);
-    this.name = "AuthenticationError";
-    Object.setPrototypeOf(this, _AuthenticationError.prototype);
-  }
-};
-var NotFoundError = class _NotFoundError extends AGIError {
-  constructor(message, response) {
-    super(message, 404, response);
-    this.name = "NotFoundError";
-    Object.setPrototypeOf(this, _NotFoundError.prototype);
-  }
-};
-var RateLimitError = class _RateLimitError extends AGIError {
-  constructor(message, response) {
-    super(message, 429, response);
-    this.name = "RateLimitError";
-    Object.setPrototypeOf(this, _RateLimitError.prototype);
-  }
-};
-var AgentExecutionError = class _AgentExecutionError extends AGIError {
-  constructor(message, response) {
-    super(message, void 0, response);
-    this.name = "AgentExecutionError";
-    Object.setPrototypeOf(this, _AgentExecutionError.prototype);
-  }
-};
-var ValidationError = class _ValidationError extends AGIError {
-  constructor(message, response) {
-    super(message, 422, response);
-    this.name = "ValidationError";
-    Object.setPrototypeOf(this, _ValidationError.prototype);
-  }
-};
-var PermissionError = class _PermissionError extends AGIError {
-  constructor(message, response) {
-    super(message, 403, response);
-    this.name = "PermissionError";
-    Object.setPrototypeOf(this, _PermissionError.prototype);
-  }
-};
-var APIError = class _APIError extends AGIError {
-  constructor(message, statusCode, response) {
-    super(message, statusCode, response);
-    this.name = "APIError";
-    Object.setPrototypeOf(this, _APIError.prototype);
-  }
-};
-
-// src/http.ts
-var HTTPClient = class {
-  apiKey;
-  baseUrl;
-  timeout;
-  maxRetries;
-  constructor(options) {
-    this.apiKey = options.apiKey;
-    this.baseUrl = options.baseUrl ?? "https://api.agi.tech";
-    this.timeout = options.timeout ?? 6e4;
-    this.maxRetries = options.maxRetries ?? 3;
-  }
-  /**
-   * Make an HTTP request with retries and error handling
-   */
-  async request(method, path, options) {
-    const url = this.buildUrl(path, options?.query);
-    const headers = this.buildHeaders(options?.headers);
-    let lastError;
-    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
-      try {
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
-        const response = await fetch(url, {
-          method,
-          headers,
-          body: options?.json ? JSON.stringify(options.json) : void 0,
-          signal: controller.signal
-        });
-        clearTimeout(timeoutId);
-        if (!response.ok) {
-          await this.handleErrorResponse(response);
-        }
-        const data = await response.json();
-        return data;
-      } catch (error) {
-        lastError = error;
-        if (error instanceof AGIError && error.statusCode && error.statusCode < 500) {
-          if (error.statusCode !== 429) {
-            throw error;
-          }
-        }
-        if (attempt === this.maxRetries) {
-          break;
-        }
-        await this.sleep(Math.pow(2, attempt) * 1e3);
-      }
-    }
-    throw lastError || new AGIError("Request failed after retries");
-  }
-  /**
-   * Make an HTTP request to an absolute URL with retries and error handling
-   */
-  async requestUrl(method, url, options) {
-    const headers = this.buildHeaders(options?.headers);
-    let lastError;
-    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
-      try {
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
-        const response = await fetch(url, {
-          method,
-          headers,
-          body: options?.json ? JSON.stringify(options.json) : void 0,
-          signal: controller.signal
-        });
-        clearTimeout(timeoutId);
-        if (!response.ok) {
-          await this.handleErrorResponse(response);
-        }
-        const data = await response.json();
-        return data;
-      } catch (error) {
-        lastError = error;
-        if (error instanceof AGIError && error.statusCode && error.statusCode < 500) {
-          if (error.statusCode !== 429) {
-            throw error;
-          }
-        }
-        if (attempt === this.maxRetries) {
-          break;
-        }
-        await this.sleep(Math.pow(2, attempt) * 1e3);
-      }
-    }
-    throw lastError || new AGIError("Request failed after retries");
-  }
-  /**
-   * Stream Server-Sent Events from an endpoint
-   */
-  async *streamEvents(path, query) {
-    const url = this.buildUrl(path, query);
-    const headers = this.buildHeaders();
-    const controller = new AbortController();
-    const response = await fetch(url, {
-      method: "GET",
-      headers: {
-        ...headers,
-        Accept: "text/event-stream"
-      },
-      signal: controller.signal
-    });
-    if (!response.ok) {
-      await this.handleErrorResponse(response);
-    }
-    if (!response.body) {
-      throw new AGIError("Response body is null");
-    }
-    const reader = response.body.getReader();
-    const decoder = new TextDecoder();
-    let buffer = "";
-    const parser = eventsourceParser.createParser((event) => {
-      if (event.type === "event") {
-        try {
-          const data = JSON.parse(event.data);
-          this.pendingEvents.push({
-            id: event.id,
-            event: event.event,
-            data
-          });
-        } catch {
-        }
-      }
-    });
-    const pendingEvents = [];
-    this.pendingEvents = pendingEvents;
-    try {
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done) {
-          break;
-        }
-        buffer += decoder.decode(value, { stream: true });
-        parser.feed(buffer);
-        buffer = "";
-        while (pendingEvents.length > 0) {
-          const event = pendingEvents.shift();
-          if (event) {
-            yield event;
-          }
-        }
-      }
-    } finally {
-      controller.abort();
-      reader.releaseLock();
-    }
-  }
-  pendingEvents = [];
-  buildUrl(path, query) {
-    const url = new URL(path, this.baseUrl);
-    if (query) {
-      Object.entries(query).forEach(([key, value]) => {
-        url.searchParams.append(key, value);
-      });
-    }
-    return url.toString();
-  }
-  buildHeaders(additional) {
-    return {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${this.apiKey}`,
-      "User-Agent": "agi-sdk-node/1.0.0",
-      ...additional
-    };
-  }
-  async handleErrorResponse(response) {
-    let errorData;
-    const text = await response.text();
-    try {
-      errorData = JSON.parse(text);
-    } catch {
-      errorData = text;
-    }
-    const errorMessage = typeof errorData === "object" && errorData.message ? errorData.message : typeof errorData === "string" ? errorData : `HTTP ${response.status}: ${response.statusText}`;
-    switch (response.status) {
-      case 401:
-        throw new AuthenticationError(`Authentication failed: ${errorMessage}`, errorData);
-      case 403:
-        throw new PermissionError(`Permission denied: ${errorMessage}`, errorData);
-      case 404:
-        throw new NotFoundError(`Resource not found: ${errorMessage}`, errorData);
-      case 422:
-        throw new ValidationError(`Validation error: ${errorMessage}`, errorData);
-      case 429:
-        throw new RateLimitError(`Rate limit exceeded: ${errorMessage}`, errorData);
-      default:
-        if (response.status >= 500) {
-          throw new APIError(
-            `Server error (${response.status}): ${errorMessage}`,
-            response.status,
-            errorData
-          );
-        }
-        throw new AGIError(
-          `API error (${response.status}): ${errorMessage}`,
-          response.status,
-          errorData
-        );
-    }
-  }
-  sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-  }
-};
-
-// src/types/screenshot.ts
-var Screenshot = class _Screenshot {
-  constructor(data, format, timestamp, width, height, url, title) {
-    this.data = data;
-    this.format = format;
-    this.timestamp = timestamp;
-    this.width = width;
-    this.height = height;
-    this.url = url;
-    this.title = title;
-  }
-  /**
-   * Save screenshot to file
-   *
-   * @param path - File path to save to (e.g., "screenshot.png")
-   *
-   * @example
-   * ```typescript
-   * const screenshot = await session.screenshot();
-   * await screenshot.save("amazon.png");
-   * ```
-   */
-  async save(path) {
-    const fs = await import('fs/promises');
-    await fs.writeFile(path, this.data);
-  }
-  /**
-   * Create Screenshot from base64 data URL
-   *
-   * @param base64Data - Base64-encoded data URL (e.g., "data:image/jpeg;base64,...")
-   * @param url - Current page URL
-   * @param title - Current page title
-   * @param timestamp - Screenshot timestamp (defaults to now)
-   * @returns Screenshot instance with decoded image data
-   */
-  static fromBase64(base64Data, url, title, timestamp) {
-    let header;
-    let encoded;
-    if (base64Data.includes(",")) {
-      [header, encoded] = base64Data.split(",", 2);
-    } else {
-      encoded = base64Data;
-      header = "data:image/png;base64";
-    }
-    const imageData = Buffer.from(encoded, "base64");
-    const format = header.toLowerCase().includes("jpeg") || header.toLowerCase().includes("jpg") ? "jpg" : "png";
-    const { width, height } = _Screenshot.getImageDimensions(imageData, format);
-    return new _Screenshot(imageData, format, timestamp || /* @__PURE__ */ new Date(), width, height, url, title);
-  }
-  /**
-   * Extract width and height from image data
-   *
-   * @param data - Raw image bytes
-   * @param format - Image format (png, jpg)
-   * @returns Tuple of (width, height)
-   */
-  static getImageDimensions(data, format) {
-    try {
-      if (format === "png" && data.length >= 24) {
-        const width = data.readUInt32BE(16);
-        const height = data.readUInt32BE(20);
-        return { width, height };
-      } else if (format === "jpg") {
-        for (let i = 0; i < data.length - 9; i++) {
-          if (data[i] === 255 && data[i + 1] === 192) {
-            const height = data.readUInt16BE(i + 5);
-            const width = data.readUInt16BE(i + 7);
-            return { width, height };
-          }
-        }
-      }
-    } catch (error) {
-    }
-    return { width: 0, height: 0 };
-  }
-};
-
-// src/context/session-context.ts
-var SessionContext = class {
-  constructor(client, agentName = "agi-0", createOptions) {
-    this.client = client;
-    this.agentName = agentName;
-    this.createOptions = createOptions;
-  }
-  sessionId;
-  vncUrl;
-  agentUrl;
-  /**
-   * Automatic cleanup via explicit resource management
-   */
-  async [Symbol.asyncDispose]() {
-    if (this.sessionId) {
-      try {
-        await this.client.sessions.delete(this.sessionId);
-      } catch (error) {
-      }
-    }
-  }
-  /**
-   * Ensure session is created
-   */
-  async ensureSession() {
-    if (this.sessionId) return;
-    const response = await this.client.sessions.create(this.agentName, this.createOptions);
-    this.sessionId = response.sessionId;
-    this.vncUrl = response.vncUrl;
-    this.agentUrl = response.agentUrl;
-  }
-  /**
-   * Run a task and wait for completion using HTTP polling
-   *
-   * This method uses HTTP polling instead of SSE streaming for better reliability
-   * with long-running tasks and network instability.
-   *
-   * @param task - Natural language task description
-   * @param options - Task execution options
-   * @returns TaskResult with data and execution metadata
-   *
-   * @example
-   * ```typescript
-   * const result = await session.runTask(
-   *   'Find cheapest iPhone 15 Pro',
-   *   { timeout: 300000, pollInterval: 2000 } // 5 min timeout, 2s polling
-   * );
-   * console.log(result.data);
-   * console.log(`Took ${result.metadata.duration}s, ${result.metadata.steps} steps`);
-   * ```
-   */
-  async runTask(task, options) {
-    await this.ensureSession();
-    if (!this.sessionId) throw new Error("Session not created");
-    const timeout = options?.timeout ?? 6e5;
-    const pollInterval = options?.pollInterval ?? 3e3;
-    await this.client.sessions.sendMessage(this.sessionId, task, {
-      startUrl: options?.startUrl
-    });
-    const startTime = Date.now();
-    while (true) {
-      const elapsed = Date.now() - startTime;
-      if (elapsed > timeout) {
-        throw new AgentExecutionError(
-          `Task exceeded timeout of ${timeout}ms (elapsed: ${elapsed}ms)`
-        );
-      }
-      const statusResponse = await this.client.sessions.getStatus(this.sessionId);
-      if (statusResponse.status === "finished" || statusResponse.status === "waiting_for_input") {
-        const messagesResponse = await this.client.sessions.getMessages(this.sessionId);
-        const messages = messagesResponse.messages;
-        const doneMsg = messages.find((msg) => msg.type === "DONE" || msg.type === "QUESTION");
-        if (!doneMsg) {
-          throw new AgentExecutionError(
-            `Task status '${statusResponse.status}' but no DONE/QUESTION message found`
-          );
-        }
-        const content = doneMsg.content;
-        const data = typeof content === "object" && content !== null ? content : { content: content ?? {} };
-        const duration = (Date.now() - startTime) / 1e3;
-        const steps = messages.filter(
-          (msg) => ["THOUGHT", "QUESTION", "DONE"].includes(msg.type)
-        ).length;
-        const metadata = {
-          taskId: doneMsg.id,
-          sessionId: this.sessionId,
-          duration,
-          cost: 0,
-          timestamp: /* @__PURE__ */ new Date(),
-          steps,
-          success: true
-        };
-        return { data, metadata };
-      }
-      if (statusResponse.status === "error") {
-        const messagesResponse = await this.client.sessions.getMessages(this.sessionId);
-        const errorMsg = messagesResponse.messages.find((msg) => msg.type === "ERROR");
-        const errorDetails = errorMsg ? typeof errorMsg.content === "string" ? errorMsg.content : JSON.stringify(errorMsg.content) : "Unknown error";
-        throw new AgentExecutionError(`Task failed: ${errorDetails}`);
-      }
-      await new Promise((resolve) => setTimeout(resolve, pollInterval));
-    }
-  }
-  /**
-   * Send a message to the agent
-   *
-   * @param message - Message content
-   * @param options - Message options
-   * @returns SuccessResponse confirming message was sent
-   *
-   * @example
-   * ```typescript
-   * await session.sendMessage('Find flights from SFO to JFK under $450');
-   * ```
-   */
-  async sendMessage(message, options) {
-    await this.ensureSession();
-    if (!this.sessionId) throw new Error("Session not created");
-    return this.client.sessions.sendMessage(this.sessionId, message, options);
-  }
-  /**
-   * Get current execution status
-   *
-   * @returns ExecuteStatusResponse with status
-   *
-   * @example
-   * ```typescript
-   * const status = await session.getStatus();
-   * console.log(status.status);
-   * ```
-   */
-  async getStatus() {
-    await this.ensureSession();
-    if (!this.sessionId) throw new Error("Session not created");
-    return this.client.sessions.getStatus(this.sessionId);
-  }
-  /**
-   * Get messages from the session
-   *
-   * @param afterId - Return messages with ID > afterId (for polling)
-   * @param sanitize - Filter out system messages, prompts, and images
-   * @returns MessagesResponse with messages list and status
-   *
-   * @example
-   * ```typescript
-   * const messages = await session.getMessages(0);
-   * for (const msg of messages.messages) {
-   *   console.log(`[${msg.type}] ${msg.content}`);
-   * }
-   * ```
-   */
-  async getMessages(afterId, sanitize = true) {
-    await this.ensureSession();
-    if (!this.sessionId) throw new Error("Session not created");
-    return this.client.sessions.getMessages(this.sessionId, afterId, sanitize);
-  }
-  /**
-   * Stream real-time events from the session via Server-Sent Events
-   *
-   * @param options - Stream options
-   * @yields SSEEvent objects
-   *
-   * @example
-   * ```typescript
-   * for await (const event of session.streamEvents()) {
-   *   if (event.event === 'thought') {
-   *     console.log('Agent:', event.data);
-   *   }
-   *   if (event.event === 'done') {
-   *     console.log('Result:', event.data);
-   *     break;
-   *   }
-   * }
-   * ```
-   */
-  async *streamEvents(options) {
-    await this.ensureSession();
-    if (!this.sessionId) throw new Error("Session not created");
-    yield* this.client.sessions.streamEvents(this.sessionId, options);
-  }
-  /**
-   * Pause task execution
-   *
-   * @returns SuccessResponse confirming pause
-   *
-   * @example
-   * ```typescript
-   * await session.pause();
-   * ```
-   */
-  async pause() {
-    await this.ensureSession();
-    if (!this.sessionId) throw new Error("Session not created");
-    return this.client.sessions.pause(this.sessionId);
-  }
-  /**
-   * Resume paused task
-   *
-   * @returns SuccessResponse confirming resume
-   *
-   * @example
-   * ```typescript
-   * await session.resume();
-   * ```
-   */
-  async resume() {
-    await this.ensureSession();
-    if (!this.sessionId) throw new Error("Session not created");
-    return this.client.sessions.resume(this.sessionId);
-  }
-  /**
-   * Cancel task execution
-   *
-   * @returns SuccessResponse confirming cancellation
-   *
-   * @example
-   * ```typescript
-   * await session.cancel();
-   * ```
-   */
-  async cancel() {
-    await this.ensureSession();
-    if (!this.sessionId) throw new Error("Session not created");
-    return this.client.sessions.cancel(this.sessionId);
-  }
-  /**
-   * Navigate browser to URL
-   *
-   * @param url - URL to navigate to
-   * @returns NavigateResponse with current URL
-   *
-   * @example
-   * ```typescript
-   * await session.navigate('https://amazon.com');
-   * ```
-   */
-  async navigate(url) {
-    await this.ensureSession();
-    if (!this.sessionId) throw new Error("Session not created");
-    return this.client.sessions.navigate(this.sessionId, url);
-  }
-  /**
-   * Get browser screenshot
-   *
-   * @returns Screenshot with decoded image data and save() method
-   *
-   * @example
-   * ```typescript
-   * const screenshot = await session.screenshot();
-   * await screenshot.save('page.png');
-   * console.log(`Size: ${screenshot.width}x${screenshot.height}`);
-   * ```
-   */
-  async screenshot() {
-    await this.ensureSession();
-    if (!this.sessionId) throw new Error("Session not created");
-    const response = await this.client.sessions.screenshot(this.sessionId);
-    return Screenshot.fromBase64(response.screenshot, response.url, response.title);
-  }
-};
-
-// src/utils.ts
-function normalizeSessionResponse(data) {
-  return {
-    sessionId: data.session_id ?? data.sessionId,
-    vncUrl: data.vnc_url ?? data.vncUrl,
-    agentUrl: data.agent_url ?? data.agentUrl,
-    agentName: data.agent_name ?? data.agentName,
-    status: data.status,
-    createdAt: data.created_at ?? data.createdAt,
-    environmentId: data.environment_id ?? data.environmentId,
-    goal: data.goal,
-    agentSessionType: data.agent_session_type ?? data.agentSessionType
-  };
-}
-
-// src/resources/sessions.ts
-var SessionsResource = class {
-  constructor(http) {
-    this.http = http;
-  }
-  // ===== SESSION MANAGEMENT =====
-  /**
-   * Create a new agent session
-   *
-   * @param agentName - Agent model to use (e.g., "agi-0", "agi-2-claude")
-   * @param options - Session creation options
-   * @returns SessionResponse with sessionId, vncUrl, agentUrl, status, etc.
-   *
-   * @example
-   * ```typescript
-   * // Standard browser session
-   * const session = await client.sessions.create('agi-0', {
-   *   webhookUrl: 'https://yourapp.com/webhook',
-   *   maxSteps: 200
-   * });
-   *
-   * // Desktop session (client-managed)
-   * const session = await client.sessions.create('agi-2-claude', {
-   *   agentSessionType: 'desktop',
-   *   goal: 'Open calculator and compute 2+2'
-   * });
-   * console.log(session.agentUrl); // Use with client.desktop.step()
-   * ```
-   */
-  async create(agentName = "agi-0", options) {
-    const payload = {
-      agent_name: agentName,
-      max_steps: options?.maxSteps ?? 100
-    };
-    if (options?.webhookUrl) payload.webhook_url = options.webhookUrl;
-    if (options?.goal) payload.goal = options.goal;
-    if (options?.restoreFromEnvironmentId) {
-      payload.restore_from_environment_id = options.restoreFromEnvironmentId;
-    }
-    if (options?.agentSessionType) {
-      payload.agent_session_type = options.agentSessionType;
-    }
-    if (options?.cdpUrl) payload.cdp_url = options.cdpUrl;
-    const response = await this.http.request("POST", "/v1/sessions", {
-      json: payload
-    });
-    return normalizeSessionResponse(response);
-  }
-  /**
-   * List all sessions for the authenticated user
-   *
-   * @returns Array of SessionResponse objects
-   *
-   * @example
-   * ```typescript
-   * const sessions = await client.sessions.list();
-   * for (const session of sessions) {
-   *   console.log(`${session.sessionId}: ${session.status}`);
-   * }
-   * ```
-   */
-  async list() {
-    const responses = await this.http.request(
-      "GET",
-      "/v1/sessions"
-    );
-    return responses.map(normalizeSessionResponse);
-  }
-  /**
-   * Get details for a specific session
-   *
-   * @param sessionId - Session UUID
-   * @returns SessionResponse with session details
-   *
-   * @example
-   * ```typescript
-   * const session = await client.sessions.get('session-uuid');
-   * console.log(session.status);
-   * ```
-   */
-  async get(sessionId) {
-    const response = await this.http.request(
-      "GET",
-      `/v1/sessions/${sessionId}`
-    );
-    return normalizeSessionResponse(response);
-  }
-  /**
-   * Delete a session and cleanup its resources
-   *
-   * @param sessionId - Session UUID
-   * @param saveSnapshotMode - Snapshot mode: "none", "memory", or "filesystem"
-   * @returns DeleteResponse confirming deletion
-   *
-   * @example
-   * ```typescript
-   * await client.sessions.delete('session-uuid', 'filesystem');
-   * ```
-   */
-  async delete(sessionId, saveSnapshotMode = "none") {
-    return this.http.request("DELETE", `/v1/sessions/${sessionId}`, {
-      query: { save_snapshot_mode: saveSnapshotMode }
-    });
-  }
-  /**
-   * Delete all sessions for the authenticated user
-   *
-   * @returns DeleteResponse with count of deleted sessions
-   *
-   * @example
-   * ```typescript
-   * const result = await client.sessions.deleteAll();
-   * console.log(result.message);
-   * ```
-   */
-  async deleteAll() {
-    return this.http.request("DELETE", "/v1/sessions");
-  }
-  // ===== AGENT INTERACTION =====
-  /**
-   * Send a message to the agent to start a task or respond to questions
-   *
-   * @param sessionId - Session UUID
-   * @param message - Message content (task instruction or response)
-   * @param options - Message options
-   * @returns SuccessResponse confirming message was sent
-   *
-   * @example
-   * ```typescript
-   * await client.sessions.sendMessage(
-   *   'session-uuid',
-   *   'Find flights from SFO to JFK under $450'
-   * );
-   * ```
-   */
-  async sendMessage(sessionId, message, options) {
-    return this.http.request("POST", `/v1/sessions/${sessionId}/message`, {
-      json: {
-        message,
-        start_url: options?.startUrl,
-        config_updates: options?.configUpdates
-      }
-    });
-  }
-  /**
-   * Get the current execution status of a session
-   *
-   * @param sessionId - Session UUID
-   * @returns ExecuteStatusResponse with status
-   *
-   * @example
-   * ```typescript
-   * const status = await client.sessions.getStatus('session-uuid');
-   * if (status.status === 'finished') {
-   *   console.log('Task completed!');
-   * }
-   * ```
-   */
-  async getStatus(sessionId) {
-    return this.http.request("GET", `/v1/sessions/${sessionId}/status`);
-  }
-  /**
-   * Poll for messages and updates from the agent
-   *
-   * @param sessionId - Session UUID
-   * @param afterId - Return messages with ID > afterId (for polling)
-   * @param sanitize - Filter out system messages, prompts, and images
-   * @returns MessagesResponse with messages list and status
-   *
-   * @example
-   * ```typescript
-   * const messages = await client.sessions.getMessages('session-uuid', 0);
-   * for (const msg of messages.messages) {
-   *   console.log(`[${msg.type}] ${msg.content}`);
-   * }
-   * ```
-   */
-  async getMessages(sessionId, afterId = 0, sanitize = true) {
-    const response = await this.http.request(
-      "GET",
-      `/v1/sessions/${sessionId}/messages`,
-      {
-        query: {
-          after_id: String(afterId),
-          sanitize: String(sanitize)
-        }
-      }
-    );
-    return {
-      messages: response.messages || [],
-      status: response.status,
-      hasAgent: response.has_agent ?? response.hasAgent ?? false
-    };
-  }
-  /**
-   * Stream real-time events from the session via Server-Sent Events
-   *
-   * @param sessionId - Session UUID
-   * @param options - Stream options
-   * @yields SSEEvent objects
-   *
-   * @example
-   * ```typescript
-   * for await (const event of client.sessions.streamEvents('session-uuid')) {
-   *   if (event.event === 'thought') {
-   *     console.log('Agent:', event.data);
-   *   }
-   *   if (event.event === 'done') {
-   *     console.log('Result:', event.data);
-   *     break;
-   *   }
-   * }
-   * ```
-   */
-  async *streamEvents(sessionId, options) {
-    const query = {
-      sanitize: String(options?.sanitize ?? true),
-      include_history: String(options?.includeHistory ?? true)
-    };
-    if (options?.eventTypes) {
-      query.event_types = options.eventTypes.join(",");
-    }
-    yield* this.http.streamEvents(`/v1/sessions/${sessionId}/events`, query);
-  }
-  // ===== SESSION CONTROL =====
-  /**
-   * Temporarily pause task execution
-   *
-   * @param sessionId - Session UUID
-   * @returns SuccessResponse confirming pause
-   *
-   * @example
-   * ```typescript
-   * await client.sessions.pause('session-uuid');
-   * ```
-   */
-  async pause(sessionId) {
-    return this.http.request("POST", `/v1/sessions/${sessionId}/pause`);
-  }
-  /**
-   * Resume a paused task
-   *
-   * @param sessionId - Session UUID
-   * @returns SuccessResponse confirming resume
-   *
-   * @example
-   * ```typescript
-   * await client.sessions.resume('session-uuid');
-   * ```
-   */
-  async resume(sessionId) {
-    return this.http.request("POST", `/v1/sessions/${sessionId}/resume`);
-  }
-  /**
-   * Cancel task execution
-   *
-   * @param sessionId - Session UUID
-   * @returns SuccessResponse confirming cancellation
-   *
-   * @example
-   * ```typescript
-   * await client.sessions.cancel('session-uuid');
-   * ```
-   */
-  async cancel(sessionId) {
-    return this.http.request("POST", `/v1/sessions/${sessionId}/cancel`);
-  }
-  // ===== BROWSER CONTROL =====
-  /**
-   * Navigate the browser to a specific URL
-   *
-   * @param sessionId - Session UUID
-   * @param url - URL to navigate to
-   * @returns NavigateResponse with current URL
-   *
-   * @example
-   * ```typescript
-   * await client.sessions.navigate('session-uuid', 'https://amazon.com');
-   * ```
-   */
-  async navigate(sessionId, url) {
-    const response = await this.http.request(
-      "POST",
-      `/v1/sessions/${sessionId}/navigate`,
-      {
-        json: { url }
-      }
-    );
-    return {
-      currentUrl: response.current_url ?? response.currentUrl
-    };
-  }
-  /**
-   * Get a screenshot of the browser
-   *
-   * @param sessionId - Session UUID
-   * @returns ScreenshotResponse with base64-encoded image, URL, and title
-   *
-   * @example
-   * ```typescript
-   * const screenshot = await client.sessions.screenshot('session-uuid');
-   * console.log(screenshot.url);
-   * ```
-   */
-  async screenshot(sessionId) {
-    return this.http.request("GET", `/v1/sessions/${sessionId}/screenshot`);
-  }
-  // ===== CLIENT-DRIVEN SESSION CONTROL =====
-  /**
-   * Execute a single step for client-driven sessions (desktop mode).
-   *
-   * In desktop mode (agentSessionType="desktop"), the client manages the
-   * execution loop. This method sends a screenshot to the agent and receives
-   * actions to execute locally.
-   *
-   * @param agentUrl - Agent service URL from session.agentUrl
-   * @param sessionId - Session ID (required for routing in shared sandbox)
-   * @param screenshot - Base64-encoded screenshot (full resolution, JPEG or PNG)
-   * @param message - Optional user message (goal on first call, or follow-up instruction)
-   * @returns StepDesktopResponse with actions, thinking, finished, askUser, and step
-   *
-   * @example
-   * ```typescript
-   * // Create a desktop session
-   * const session = await client.sessions.create('agi-2-claude', {
-   *   agentSessionType: 'desktop',
-   *   goal: 'Open calculator and compute 2+2'
-   * });
-   *
-   * // Client-managed loop
-   * let finished = false;
-   * while (!finished) {
-   *   const screenshot = captureScreenshot(); // Client captures
-   *   const result = await client.sessions.step(
-   *     session.agentUrl!,
-   *     session.sessionId,
-   *     screenshot
-   *   );
-   *   executeActions(result.actions); // Client executes
-   *   finished = result.finished;
-   *   if (result.askUser) {
-   *     const answer = await promptUser(result.askUser);
-   *     // Send answer in next step
-   *   }
-   * }
-   * ```
-   */
-  async step(agentUrl, sessionId, screenshot, message) {
-    const url = `${agentUrl.replace(/\/$/, "")}/step_desktop`;
-    const payload = { screenshot, session_id: sessionId };
-    if (message !== void 0) {
-      payload.message = message;
-    }
-    const response = await this.http.requestUrl("POST", url, {
-      json: payload
-    });
-    return {
-      actions: response.actions || [],
-      thinking: response.thinking,
-      finished: response.finished ?? false,
-      askUser: response.ask_user ?? response.askUser,
-      step: response.step ?? 0
-    };
-  }
-  // ===== MODELS =====
-  /**
-   * List available agent models.
-   *
-   * @param filter - Optional filter: "cdp" for browser agents, "desktop" for
-   *                 desktop agents
-   * @returns ModelsResponse with list of available model names
-   *
-   * @example
-   * ```typescript
-   * // List all models
-   * const models = await client.sessions.listModels();
-   * console.log(models.models);
-   *
-   * // List only desktop-compatible models
-   * const desktopModels = await client.sessions.listModels('desktop');
-   * console.log(desktopModels.models);
-   * // ['agi-2-claude', 'agi-2-qwen']
-   * ```
-   */
-  async listModels(filter) {
-    const query = {};
-    if (filter) {
-      query.filter = filter;
-    }
-    return this.http.request("GET", "/v1/models", { query });
-  }
-};
-
-// src/client.ts
-var AGIClient = class {
-  http;
-  /** Sessions resource for low-level API access */
-  sessions;
-  /**
-   * Create a new AGI client
-   *
-   * @param options - Client configuration options
-   *
-   * @example
-   * ```typescript
-   * // With explicit API key
-   * const client = new AGIClient({ apiKey: 'your_api_key' });
-   *
-   * // With custom base URL
-   * const client = new AGIClient({
-   *   apiKey: 'your_api_key',
-   *   baseUrl: 'https://custom-api.example.com',
-   *   timeout: 120000,
-   * });
-   * ```
-   */
-  constructor(options) {
-    if (!options.apiKey) {
-      throw new Error(
-        "api_key is required. Either pass it as a parameter or set the AGI_API_KEY environment variable."
-      );
-    }
-    this.http = new HTTPClient(options);
-    this.sessions = new SessionsResource(this.http);
-  }
-  /**
-   * Create a session context manager for easy session lifecycle management (recommended)
-   *
-   * This is the recommended way to use the SDK. The context manager automatically
-   * creates and deletes the session using `await using` syntax.
-   *
-   * @param agentName - Agent model to use (e.g., "agi-0", "agi-0-fast", "agi-1")
-   * @param options - Session creation options
-   * @returns SessionContext manager
-   *
-   * @example
-   * ```typescript
-   * // Simple usage
-   * await using session = client.session('agi-0');
-   * const result = await session.runTask('Find flights SFO→JFK under $450');
-   * console.log(result.data);
-   * // Session automatically deleted
-   *
-   * // With options
-   * await using session = client.session('agi-0', {
-   *   webhookUrl: 'https://yourapp.com/webhook',
-   *   maxSteps: 200
-   * });
-   * const result = await session.runTask('Research company XYZ');
-   * ```
-   */
-  session(agentName = "agi-0", options) {
-    return new SessionContext(this, agentName, options);
-  }
-};
-
-// src/loop.ts
-var AgentLoop = class {
-  client;
-  agentUrl;
-  sessionId;
-  captureScreenshot;
-  executeActions;
-  onThinking;
-  onAskUser;
-  onStep;
-  stepDelay;
-  _state = "idle";
-  _lastResult = null;
-  _currentStep = 0;
-  // Pause control using Promise-based approach
-  pauseResolve = null;
-  pausePromise = null;
-  constructor(options) {
-    this.client = options.client;
-    this.agentUrl = options.agentUrl;
-    this.sessionId = options.sessionId;
-    this.captureScreenshot = options.captureScreenshot;
-    this.executeActions = options.executeActions;
-    this.onThinking = options.onThinking;
-    this.onAskUser = options.onAskUser;
-    this.onStep = options.onStep;
-    this.stepDelay = options.stepDelay ?? 0;
-  }
-  /** Current state of the loop. */
-  get state() {
-    return this._state;
-  }
-  /** Current step number. */
-  get currentStep() {
-    return this._currentStep;
-  }
-  /** Last step result, if any. */
-  get lastResult() {
-    return this._lastResult;
-  }
-  /**
-   * Start the execution loop.
-   *
-   * Runs the loop until the task is finished, stopped, or an unhandled
-   * ask_user question is encountered.
-   *
-   * @param message - Optional initial message (goal or instruction).
-   *   Usually not needed if goal was set during session creation.
-   * @returns The final StepDesktopResponse
-   * @throws Error if loop is already running
-   */
-  async start(message) {
-    if (this._state === "running") {
-      throw new Error("Loop is already running");
-    }
-    this._state = "running";
-    let currentMessage = message;
-    let result = null;
-    try {
-      while (true) {
-        if (this.pausePromise) {
-          await this.pausePromise;
-        }
-        const currentState = this._state;
-        if (currentState === "paused") {
-          continue;
-        }
-        if (currentState !== "running") {
-          break;
-        }
-        const screenshot = await this.captureScreenshot();
-        result = await this.client.sessions.step(
-          this.agentUrl,
-          this.sessionId,
-          screenshot,
-          currentMessage
-        );
-        currentMessage = void 0;
-        this._lastResult = result;
-        this._currentStep = result.step;
-        if (result.thinking && this.onThinking) {
-          this.onThinking(result.thinking);
-        }
-        if (this.onStep) {
-          this.onStep(result.step, result);
-        }
-        if (result.askUser) {
-          if (this.onAskUser) {
-            const answer = await this.onAskUser(result.askUser);
-            currentMessage = answer;
-          } else {
-            this._state = "stopped";
-            return result;
-          }
-        }
-        if (result.actions.length > 0) {
-          await this.executeActions(result.actions);
-        }
-        if (result.finished) {
-          this._state = "finished";
-          return result;
-        }
-        if (this.stepDelay > 0) {
-          await new Promise((resolve) => setTimeout(resolve, this.stepDelay));
-        }
-      }
-    } catch (error) {
-      this._state = "stopped";
-      throw error;
-    }
-    if (result === null) {
-      result = {
-        actions: [],
-        thinking: void 0,
-        finished: true,
-        askUser: void 0,
-        step: this._currentStep
-      };
-    }
-    return result;
-  }
-  /**
-   * Pause the execution loop.
-   *
-   * The loop will complete the current step before pausing.
-   * Call resume() to continue.
-   */
-  pause() {
-    if (this._state !== "running") {
-      return;
-    }
-    this._state = "paused";
-    this.pausePromise = new Promise((resolve) => {
-      this.pauseResolve = resolve;
-    });
-  }
-  /**
-   * Resume a paused loop.
-   */
-  resume() {
-    if (this._state !== "paused") {
-      return;
-    }
-    this._state = "running";
-    if (this.pauseResolve) {
-      this.pauseResolve();
-      this.pauseResolve = null;
-      this.pausePromise = null;
-    }
-  }
-  /**
-   * Stop the execution loop.
-   *
-   * The loop will complete the current step before stopping.
-   */
-  stop() {
-    this._state = "stopped";
-    if (this.pauseResolve) {
-      this.pauseResolve();
-      this.pauseResolve = null;
-      this.pausePromise = null;
-    }
-  }
-  /** Check if the loop is currently running. */
-  isRunning() {
-    return this._state === "running";
-  }
-  /** Check if the loop is currently paused. */
-  isPaused() {
-    return this._state === "paused";
-  }
-  /** Check if the loop has finished successfully. */
-  isFinished() {
-    return this._state === "finished";
-  }
-};
-var __filename$1 = url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.js', document.baseURI).href)));
-var __dirname$1 = path.dirname(__filename$1);
-var require2 = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.js', document.baseURI).href)));
-function getPlatformId() {
-  const os$1 = os.platform();
-  const cpu = os.arch();
-  if (os$1 === "darwin") {
-    return cpu === "arm64" ? "darwin-arm64" : "darwin-x64";
-  } else if (os$1 === "linux") {
-    return "linux-x64";
-  } else if (os$1 === "win32") {
-    return "win32-x64";
-  }
-  throw new Error(`Unsupported platform: ${os$1}-${cpu}`);
-}
-function getBinaryFilename(platformId) {
-  const id = platformId ?? getPlatformId();
-  if (id === "win32-x64") {
-    return "agi-driver.exe";
-  }
-  return "agi-driver";
-}
-function getSearchPaths(platformId) {
-  const filename = getBinaryFilename(platformId);
-  const paths = [];
-  const packageName = `@agi/agi-${platformId}`;
-  try {
-    const packagePath = require2.resolve(`${packageName}/package.json`);
-    const packageDir = path.dirname(packagePath);
-    paths.push(path.join(packageDir, filename));
-  } catch {
-  }
-  paths.push(path.join(__dirname$1, "..", "..", "bin", filename));
-  paths.push(path.join(__dirname$1, "..", "..", "..", "bin", filename));
-  const envPath = process.env.PATH || "";
-  for (const dir of envPath.split(path.delimiter)) {
-    if (dir) {
-      paths.push(path.join(dir, filename));
-    }
-  }
-  return paths;
-}
-function getPythonFallback() {
-  const driverPath = process.env.AGI_DRIVER_PATH;
-  if (driverPath && fs.existsSync(path.join(driverPath, "__main__.py"))) {
-    return {
-      command: process.env.PYTHON_PATH || "python",
-      args: ["-m", "agi_driver"]
-    };
-  }
-  return null;
-}
-function findBinaryPath() {
-  const platformId = getPlatformId();
-  const searchPaths = getSearchPaths(platformId);
-  for (const path of searchPaths) {
-    if (fs.existsSync(path)) {
-      return path;
-    }
-  }
-  throw new Error(
-    `Could not find agi-driver binary for ${platformId}. Searched: ${searchPaths.join(", ")}. Install the optional dependency @agi/agi-${platformId} or ensure agi-driver is in PATH.`
-  );
-}
-function isBinaryAvailable() {
-  try {
-    findBinaryPath();
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-// src/driver/protocol.ts
-function parseEvent(line) {
-  const data = JSON.parse(line);
-  return data;
-}
-function serializeCommand(command) {
-  return JSON.stringify(command);
-}
-
-// src/driver/driver.ts
-var AgentDriver = class extends events.EventEmitter {
-  binaryPath;
-  pythonFallback;
-  model;
-  platform;
-  mode;
-  env;
-  process = null;
-  readline = null;
-  state = "idle";
-  step = 0;
-  sessionId = "";
-  screenWidth = 0;
-  screenHeight = 0;
-  resolveStart = null;
-  rejectStart = null;
-  // Pending callbacks for user interaction
-  pendingConfirm = null;
-  pendingAnswer = null;
-  constructor(options = {}) {
-    super();
-    let binaryPath = null;
-    try {
-      binaryPath = options.binaryPath ?? findBinaryPath();
-    } catch {
-    }
-    this.binaryPath = binaryPath;
-    this.pythonFallback = binaryPath ? null : getPythonFallback();
-    if (!this.binaryPath && !this.pythonFallback) {
-      throw new Error(
-        "Could not find agi-driver binary and Python fallback is not available. Set AGI_DRIVER_PATH to the agi_driver source directory for development."
-      );
-    }
-    this.model = options.model ?? "claude-sonnet";
-    this.platform = options.platform ?? "desktop";
-    this.mode = options.mode ?? "";
-    this.env = options.env ?? {};
-  }
-  /**
-   * Get the current state of the driver.
-   */
-  get currentState() {
-    return this.state;
-  }
-  /**
-   * Get the current step number.
-   */
-  get currentStep() {
-    return this.step;
-  }
-  /**
-   * Check if the driver is running.
-   */
-  get isRunning() {
-    return this.state === "running";
-  }
-  /**
-   * Check if the driver is waiting for user input.
-   */
-  get isWaiting() {
-    return this.state === "waiting_confirmation" || this.state === "waiting_answer";
-  }
-  /**
-   * Start the agent with a goal.
-   *
-   * @param goal - The task for the agent to accomplish
-   * @param screenshot - Initial screenshot (base64-encoded). Not needed in local mode.
-   * @param screenWidth - Screen width in pixels. Not needed in local mode.
-   * @param screenHeight - Screen height in pixels. Not needed in local mode.
-   * @param mode - Override the mode set in DriverOptions.
-   * @returns Promise that resolves when the agent finishes
-   */
-  async start(goal, screenshot = "", screenWidth = 0, screenHeight = 0, mode) {
-    if (this.process) {
-      throw new Error("Driver is already running");
-    }
-    this.sessionId = `session_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
-    this.screenWidth = screenWidth;
-    this.screenHeight = screenHeight;
-    return new Promise((resolve, reject) => {
-      this.resolveStart = resolve;
-      this.rejectStart = reject;
-      if (this.binaryPath) {
-        this.process = child_process.spawn(this.binaryPath, [], {
-          stdio: ["pipe", "pipe", "pipe"],
-          env: {
-            ...process.env,
-            ...this.env
-          }
-        });
-      } else if (this.pythonFallback) {
-        this.process = child_process.spawn(this.pythonFallback.command, this.pythonFallback.args, {
-          stdio: ["pipe", "pipe", "pipe"],
-          env: {
-            ...process.env,
-            ...this.env,
-            PYTHONPATH: process.env.AGI_DRIVER_PATH ? `${process.env.AGI_DRIVER_PATH}/..` : ""
-          },
-          cwd: process.env.AGI_DRIVER_PATH ? `${process.env.AGI_DRIVER_PATH}/..` : void 0
-        });
-      } else {
-        reject(new Error("No binary or Python fallback available"));
-        return;
-      }
-      this.process.on("error", (err) => {
-        this.cleanup();
-        if (this.rejectStart) {
-          this.rejectStart(err);
-          this.rejectStart = null;
-          this.resolveStart = null;
-        }
-      });
-      this.process.on("exit", (code) => {
-        this.cleanup();
-        if (this.rejectStart) {
-          this.rejectStart(new Error(`Driver exited with code ${code}`));
-          this.rejectStart = null;
-          this.resolveStart = null;
-        }
-      });
-      this.readline = readline.createInterface({
-        input: this.process.stdout,
-        crlfDelay: Infinity
-      });
-      this.readline.on("line", (line) => {
-        this.handleLine(line).catch((err) => {
-          this.emit("error", {
-            event: "error",
-            message: `Error handling line: ${err.message}`,
-            code: "parse_error",
-            recoverable: false,
-            step: this.step
-          });
-        });
-      });
-      this.process.stderr?.on("data", (data) => {
-        this.emit("stderr", data.toString());
-      });
-      this.once("ready", () => {
-        const startCmd = {
-          command: "start",
-          session_id: this.sessionId,
-          goal,
-          screenshot,
-          screen_width: screenWidth,
-          screen_height: screenHeight,
-          platform: this.platform,
-          model: this.model,
-          mode: mode ?? this.mode
-        };
-        this.sendCommand(startCmd);
-      });
-    });
-  }
-  /**
-   * Send a new screenshot to the driver.
-   *
-   * @param screenshot - Base64-encoded screenshot
-   * @param screenWidth - Screen width in pixels
-   * @param screenHeight - Screen height in pixels
-   */
-  sendScreenshot(screenshot, screenWidth, screenHeight) {
-    if (!this.process) {
-      throw new Error("Driver is not running");
-    }
-    const cmd = {
-      command: "screenshot",
-      data: screenshot,
-      screen_width: screenWidth ?? this.screenWidth,
-      screen_height: screenHeight ?? this.screenHeight
-    };
-    this.sendCommand(cmd);
-  }
-  /**
-   * Pause the driver.
-   */
-  pause() {
-    if (!this.process) return;
-    this.sendCommand({ command: "pause" });
-  }
-  /**
-   * Resume the driver.
-   */
-  resume() {
-    if (!this.process) return;
-    this.sendCommand({ command: "resume" });
-  }
-  /**
-   * Stop the driver.
-   *
-   * @param reason - Reason for stopping
-   */
-  async stop(reason) {
-    if (!this.process) return;
-    const cmd = {
-      command: "stop",
-      reason
-    };
-    this.sendCommand(cmd);
-    await new Promise((resolve) => {
-      if (!this.process) {
-        resolve();
-        return;
-      }
-      this.process.once("exit", () => resolve());
-      setTimeout(() => {
-        if (this.process) {
-          this.process.kill();
-        }
-        resolve();
-      }, 1e3);
-    });
-    this.cleanup();
-  }
-  /**
-   * Respond to a confirmation request.
-   *
-   * @param approved - Whether the action is approved
-   * @param message - Optional message to send with the response
-   */
-  respondConfirm(approved, message) {
-    if (!this.process || this.state !== "waiting_confirmation") {
-      throw new Error("Not waiting for confirmation");
-    }
-    const cmd = {
-      command: "confirm",
-      approved,
-      message
-    };
-    this.sendCommand(cmd);
-    if (this.pendingConfirm) {
-      this.pendingConfirm(approved, message);
-      this.pendingConfirm = null;
-    }
-  }
-  /**
-   * Respond to a question.
-   *
-   * @param text - The answer text
-   * @param questionId - Optional question ID
-   */
-  respondAnswer(text, questionId) {
-    if (!this.process || this.state !== "waiting_answer") {
-      throw new Error("Not waiting for answer");
-    }
-    const cmd = {
-      command: "answer",
-      text,
-      question_id: questionId
-    };
-    this.sendCommand(cmd);
-    if (this.pendingAnswer) {
-      this.pendingAnswer(text);
-      this.pendingAnswer = null;
-    }
-  }
-  sendCommand(cmd) {
-    if (!this.process?.stdin) return;
-    const line = serializeCommand(cmd) + "\n";
-    this.process.stdin.write(line);
-  }
-  async handleLine(line) {
-    if (!line.trim()) return;
-    let event;
-    try {
-      event = parseEvent(line);
-    } catch (e) {
-      console.error("Failed to parse event:", line);
-      return;
-    }
-    this.step = event.step;
-    this.emit("event", event);
-    switch (event.event) {
-      case "ready":
-        this.emit("ready", event);
-        break;
-      case "state_change":
-        this.state = event.state;
-        this.emit("state_change", event.state, event);
-        break;
-      case "thinking":
-        this.emit("thinking", event.text, event);
-        break;
-      case "action":
-        this.emit("action", event.action, event);
-        break;
-      case "confirm": {
-        this.state = "waiting_confirmation";
-        const confirmListeners = this.rawListeners("confirm");
-        let confirmHandled = false;
-        for (const listener of confirmListeners) {
-          try {
-            const approved = await listener(event.reason, event);
-            if (typeof approved === "boolean" && !confirmHandled) {
-              this.respondConfirm(approved);
-              confirmHandled = true;
-            }
-          } catch {
-          }
-        }
-        break;
-      }
-      case "ask_question": {
-        this.state = "waiting_answer";
-        const questionListeners = this.rawListeners("ask_question");
-        let questionHandled = false;
-        for (const listener of questionListeners) {
-          try {
-            const answer = await listener(event.question, event);
-            if (typeof answer === "string" && !questionHandled) {
-              this.respondAnswer(answer, event.question_id);
-              questionHandled = true;
-            }
-          } catch {
-          }
-        }
-        break;
-      }
-      case "screenshot_captured":
-        this.emit("screenshot_captured", event);
-        break;
-      case "finished":
-        this.handleFinished(event);
-        break;
-      case "error":
-        this.handleError(event);
-        break;
-    }
-  }
-  handleFinished(event) {
-    this.state = "finished";
-    this.emit("finished", event);
-    if (this.resolveStart) {
-      this.resolveStart({
-        success: event.success,
-        reason: event.reason,
-        summary: event.summary,
-        step: event.step
-      });
-      this.resolveStart = null;
-      this.rejectStart = null;
-    }
-    this.cleanup();
-  }
-  handleError(event) {
-    this.emit("error", event);
-    if (!event.recoverable) {
-      this.state = "error";
-      if (this.rejectStart) {
-        this.rejectStart(new Error(`${event.code}: ${event.message}`));
-        this.rejectStart = null;
-        this.resolveStart = null;
-      }
-      this.cleanup();
-    }
-  }
-  cleanup() {
-    if (this.readline) {
-      this.readline.close();
-      this.readline = null;
-    }
-    if (this.rejectStart) {
-      this.rejectStart(new Error("Driver stopped"));
-      this.rejectStart = null;
-      this.resolveStart = null;
-    }
-    if (this.process) {
-      this.process.kill();
-      this.process = null;
-    }
-    this.pendingConfirm = null;
-    this.pendingAnswer = null;
-  }
-};
-
-exports.AGIClient = AGIClient;
-exports.AGIError = AGIError;
-exports.APIError = APIError;
-exports.AgentDriver = AgentDriver;
-exports.AgentExecutionError = AgentExecutionError;
-exports.AgentLoop = AgentLoop;
-exports.AuthenticationError = AuthenticationError;
-exports.NotFoundError = NotFoundError;
-exports.PermissionError = PermissionError;
-exports.RateLimitError = RateLimitError;
-exports.Screenshot = Screenshot;
-exports.SessionContext = SessionContext;
-exports.SessionsResource = SessionsResource;
-exports.ValidationError = ValidationError;
-exports.findBinaryPath = findBinaryPath;
-exports.getPlatformId = getPlatformId;
-exports.isBinaryAvailable = isBinaryAvailable;
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map