agi 0.2.2 → 0.3.0

package/dist/index.js

@@ -0,0 +1,959 @@
+'use strict';
+
+var eventsourceParser = require('eventsource-parser');
+
+// 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");
+  }
+  /**
+   * 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;
+    try {
+      errorData = await response.json();
+    } catch {
+      errorData = await response.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
+  };
+}
+
+// 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-0-fast", "agi-1")
+   * @param options - Session creation options
+   * @returns SessionResponse with session_id, vnc_url, status, etc.
+   *
+   * @example
+   * ```typescript
+   * const session = await client.sessions.create('agi-0', {
+   *   webhookUrl: 'https://yourapp.com/webhook',
+   *   maxSteps: 200
+   * });
+   * ```
+   */
+  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;
+    }
+    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`);
+  }
+};
+
+// 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);
+  }
+};
+
+exports.AGIClient = AGIClient;
+exports.AGIError = AGIError;
+exports.APIError = APIError;
+exports.AgentExecutionError = AgentExecutionError;
+exports.AuthenticationError = AuthenticationError;
+exports.NotFoundError = NotFoundError;
+exports.PermissionError = PermissionError;
+exports.RateLimitError = RateLimitError;
+exports.Screenshot = Screenshot;
+exports.SessionContext = SessionContext;
+exports.SessionsResource = SessionsResource;
+exports.ValidationError = ValidationError;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map