@morphllm/morphsdk 0.2.93 → 0.2.95

package/dist/tools/browser/core.cjs

@@ -120,7 +120,8 @@ function buildLiveUrl(debugUrl, options = {}) {
       "debugUrl is required. Ensure your backend returns debugUrl in the task response. Contact support@morphllm.com if you need help."
     );
   }
-  const url = new URL(debugUrl);
+  const normalized = normalizeLiveUrl(debugUrl);
+  const url = new URL(normalized);
   if (options.interactive !== void 0) {
     url.searchParams.set("interactive", String(options.interactive));
   }
@@ -138,6 +139,29 @@ function buildLiveUrl(debugUrl, options = {}) {
   }
   return url.toString();
 }
+function normalizeLiveUrl(debugUrl) {
+  const trimmed = debugUrl.trim();
+  if (!trimmed) {
+    return trimmed;
+  }
+  if (trimmed.startsWith("wss://") || trimmed.startsWith("ws://")) {
+    return `https://live.browser-use.com?wss=${encodeURIComponent(trimmed)}`;
+  }
+  let url;
+  try {
+    url = new URL(trimmed);
+  } catch {
+    return trimmed;
+  }
+  if (url.protocol === "wss:" || url.protocol === "ws:") {
+    return `https://live.browser-use.com?wss=${encodeURIComponent(trimmed)}`;
+  }
+  const wssParam = url.searchParams.get("wss");
+  if (wssParam && (wssParam.startsWith("wss://") || wssParam.startsWith("ws://"))) {
+    url.searchParams.set("wss", wssParam);
+  }
+  return url.toString();
+}
 function buildLiveIframe(debugUrl, options = {}) {
   const {
     width = "100%",
@@ -181,6 +205,570 @@ function resolvePreset(optionsOrPreset) {
   return optionsOrPreset;
 }
 
+// tools/browser/errors.ts
+var MorphError = class extends Error {
+  /** Error code for programmatic handling */
+  code;
+  /** Original cause of the error, if any */
+  cause;
+  constructor(message, code, cause) {
+    super(message);
+    this.name = "MorphError";
+    this.code = code;
+    this.cause = cause;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+  /**
+   * Returns a JSON representation of the error for logging.
+   */
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      code: this.code,
+      cause: this.cause?.message
+    };
+  }
+};
+var MorphValidationError = class extends MorphError {
+  /** The field that failed validation */
+  field;
+  constructor(message, field) {
+    super(message, "validation_error");
+    this.name = "MorphValidationError";
+    this.field = field;
+  }
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      field: this.field
+    };
+  }
+};
+var MorphAPIError = class extends MorphError {
+  /** HTTP status code */
+  statusCode;
+  /** Request ID for debugging (if available) */
+  requestId;
+  /** Raw response body */
+  rawResponse;
+  constructor(message, code, statusCode, options) {
+    super(message, code, options?.cause);
+    this.name = "MorphAPIError";
+    this.statusCode = statusCode;
+    this.requestId = options?.requestId;
+    this.rawResponse = options?.rawResponse;
+  }
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      statusCode: this.statusCode,
+      requestId: this.requestId
+    };
+  }
+};
+var MorphAuthenticationError = class extends MorphAPIError {
+  constructor(message = "Authentication required. Please provide a valid API key.") {
+    super(message, "authentication_required", 401);
+    this.name = "MorphAuthenticationError";
+  }
+};
+var MorphRateLimitError = class extends MorphAPIError {
+  /** When the rate limit resets (Unix timestamp) */
+  resetAt;
+  /** Number of seconds until reset */
+  retryAfter;
+  constructor(message = "Rate limit exceeded. Please retry later.", options) {
+    super(message, "rate_limit_exceeded", 429, { requestId: options?.requestId });
+    this.name = "MorphRateLimitError";
+    this.resetAt = options?.resetAt;
+    this.retryAfter = options?.retryAfter;
+  }
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      resetAt: this.resetAt,
+      retryAfter: this.retryAfter
+    };
+  }
+};
+var MorphNotFoundError = class extends MorphAPIError {
+  /** The type of resource that was not found */
+  resourceType;
+  /** The ID of the resource that was not found */
+  resourceId;
+  constructor(resourceType, resourceId) {
+    const message = resourceId ? `${resourceType} '${resourceId}' not found` : `${resourceType} not found`;
+    super(message, "resource_not_found", 404);
+    this.name = "MorphNotFoundError";
+    this.resourceType = resourceType;
+    this.resourceId = resourceId;
+  }
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      resourceType: this.resourceType,
+      resourceId: this.resourceId
+    };
+  }
+};
+var MorphProfileLimitError = class extends MorphAPIError {
+  /** Current number of profiles */
+  currentCount;
+  /** Maximum allowed profiles for the plan */
+  maxAllowed;
+  constructor(message = "Profile limit exceeded for your plan.", options) {
+    super(message, "profile_limit_exceeded", 403, { requestId: options?.requestId });
+    this.name = "MorphProfileLimitError";
+    this.currentCount = options?.currentCount;
+    this.maxAllowed = options?.maxAllowed;
+  }
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      currentCount: this.currentCount,
+      maxAllowed: this.maxAllowed
+    };
+  }
+};
+function parseAPIError(statusCode, responseText, requestId) {
+  let errorData = {};
+  try {
+    errorData = JSON.parse(responseText);
+  } catch {
+  }
+  const message = errorData.detail || errorData.message || responseText || "Unknown error";
+  const code = errorData.code;
+  switch (statusCode) {
+    case 401:
+      return new MorphAuthenticationError(message);
+    case 403:
+      if (code === "profile_limit_exceeded" || message.toLowerCase().includes("limit")) {
+        return new MorphProfileLimitError(message, { requestId });
+      }
+      return new MorphAPIError(message, "insufficient_permissions", statusCode, { requestId, rawResponse: responseText });
+    case 404:
+      if (message.toLowerCase().includes("profile")) {
+        return new MorphNotFoundError("Profile", void 0);
+      }
+      if (message.toLowerCase().includes("session")) {
+        return new MorphNotFoundError("Session", void 0);
+      }
+      return new MorphAPIError(message, "resource_not_found", statusCode, { requestId, rawResponse: responseText });
+    case 429:
+      return new MorphRateLimitError(message, { requestId });
+    case 422:
+      return new MorphAPIError(message, "validation_error", statusCode, { requestId, rawResponse: responseText });
+    case 500:
+    case 502:
+    case 503:
+    case 504:
+      return new MorphAPIError(message, "service_unavailable", statusCode, { requestId, rawResponse: responseText });
+    default:
+      return new MorphAPIError(message, "network_error", statusCode, { requestId, rawResponse: responseText });
+  }
+}
+
+// tools/browser/profiles/types.ts
+function transformProfile(api) {
+  return {
+    id: api.id,
+    name: api.name,
+    repoId: api.repo_id,
+    cookieDomains: api.cookie_domains,
+    lastUsedAt: api.last_used_at,
+    createdAt: api.created_at,
+    updatedAt: api.updated_at
+  };
+}
+function transformCreateInput(input) {
+  return {
+    name: input.name,
+    repo_id: input.repoId
+  };
+}
+function transformSession(api) {
+  return {
+    sessionId: api.session_id,
+    debugUrl: api.debug_url || ""
+  };
+}
+function transformSaveInput(input) {
+  return {
+    session_id: input.sessionId,
+    profile_id: input.profileId
+  };
+}
+function transformStateResponse(api) {
+  return {
+    profileId: api.profile_id,
+    stateUrl: api.state_url,
+    expiresIn: api.expires_in
+  };
+}
+
+// tools/browser/profiles/core.ts
+var DEFAULT_API_URL = process.env.MORPH_ENVIRONMENT === "DEV" ? "http://localhost:8000" : "https://browser.morphllm.com";
+var ProfilesClient = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+    * Create a new browser profile and immediately start a live session.
+    *
+    * @param input - Profile creation parameters
+    * @returns Profile setup handle with live URL + save()
+    * @throws {MorphValidationError} If input validation fails
+    * @throws {MorphProfileLimitError} If profile limit is exceeded
+    * @throws {MorphAuthenticationError} If API key is missing or invalid
+    *
+    * @example
+    * ```typescript
+  * const setup = await morph.browser.profiles.createProfile({
+  *   name: 'LinkedIn Production',
+  *   repoId: 'owner/repo'
+  * });
+  * console.log(setup.session.debugUrl);
+  * await setup.save();
+    * ```
+    */
+  async createProfile(input) {
+    return createProfile(input, this.config);
+  }
+  /**
+   * List all profiles for the authenticated user.
+   *
+   * @param repoId - Optional repository ID to filter by
+   * @returns Array of profiles
+   *
+   * @example
+   * ```typescript
+   * // List all profiles
+   * const allProfiles = await morph.browser.profiles.listProfiles();
+   *
+   * // List profiles for a specific repo
+   * const repoProfiles = await morph.browser.profiles.listProfiles('owner/repo');
+   * ```
+   */
+  async listProfiles(repoId) {
+    return listProfiles(this.config, repoId);
+  }
+  /**
+   * Get a profile by ID with convenience methods.
+   *
+   * @param id - Profile ID
+   * @returns Profile with attached methods
+   * @throws {MorphNotFoundError} If profile is not found
+   *
+   * @example
+   * ```typescript
+   * const profile = await morph.browser.profiles.getProfile('profile-id');
+   * const state = await profile.getState();
+   * await profile.delete();
+   * ```
+   */
+  async getProfile(id) {
+    return getProfile(id, this.config);
+  }
+  /**
+   * Update a profile by opening a live session (no rename).
+   *
+   * @param id - Profile ID
+   * @returns Profile setup handle with live URL + save()
+   */
+  async updateProfile(id) {
+    return updateProfile(id, this.config);
+  }
+  /**
+   * Delete a profile.
+   *
+   * @param id - Profile ID
+   * @throws {MorphNotFoundError} If profile is not found
+   */
+  async deleteProfile(id) {
+    return deleteProfile(id, this.config);
+  }
+  /**
+   * Start a browser session for profile setup.
+   *
+   * Returns a live URL where the user can sign into accounts.
+   * After signing in, call `saveSession` to persist the state.
+   *
+   * @param input - Optional session parameters
+   * @returns Session with debug URL
+   *
+   * @example
+   * ```typescript
+   * const session = await morph.browser.profiles.startSession();
+   * console.log('Sign in at:', session.debugUrl);
+   * // Open debugUrl in browser, user signs in...
+   * await morph.browser.profiles.saveSession(session.sessionId, profile.id);
+   * ```
+   */
+  async startSession(input) {
+    return startProfileSession(this.config, input);
+  }
+  /**
+   * Save browser state from a session to a profile.
+   *
+   * Call this after the user is done signing into accounts.
+   * Extracts cookies, localStorage, and sessionStorage.
+   *
+   * @param sessionId - Browser session ID from startSession
+   * @param profileId - Profile ID to save state to
+   * @returns Updated profile with cookie domains
+   */
+  async saveSession(sessionId, profileId) {
+    return saveProfileSession({ sessionId, profileId }, this.config);
+  }
+  /**
+   * List available repo IDs (discovery).
+   *
+   * @returns Repo summaries with profile counts
+   */
+  async listRepos() {
+    return listRepos(this.config);
+  }
+  /**
+   * Get the presigned URL for a profile's state.
+   *
+   * Use this to download the raw state JSON for debugging
+   * or to restore state manually.
+   *
+   * @param profileId - Profile ID
+   * @returns State URL with expiry information
+   */
+  async getProfileState(profileId) {
+    return getProfileState(profileId, this.config);
+  }
+};
+function validateCreateInput(input) {
+  if (!input.name || typeof input.name !== "string") {
+    throw new MorphValidationError("name is required", "name");
+  }
+  const trimmedName = input.name.trim();
+  if (trimmedName.length === 0) {
+    throw new MorphValidationError("name cannot be empty", "name");
+  }
+  if (trimmedName.length > 100) {
+    throw new MorphValidationError("name must be 100 characters or less", "name");
+  }
+  if (!input.repoId || typeof input.repoId !== "string") {
+    throw new MorphValidationError("repoId is required", "repoId");
+  }
+  if (input.repoId.trim().length === 0) {
+    throw new MorphValidationError("repoId cannot be empty", "repoId");
+  }
+}
+function validateId(id, fieldName) {
+  if (!id || typeof id !== "string") {
+    throw new MorphValidationError(`${fieldName} is required`, fieldName);
+  }
+  if (id.trim().length === 0) {
+    throw new MorphValidationError(`${fieldName} cannot be empty`, fieldName);
+  }
+}
+async function createProfile(input, config = {}) {
+  validateCreateInput(input);
+  const apiUrl = config.apiUrl || DEFAULT_API_URL;
+  const headers = buildHeaders(config);
+  const response = await fetchWithRetry(
+    `${apiUrl}/profiles`,
+    {
+      method: "POST",
+      headers,
+      body: JSON.stringify(transformCreateInput(input))
+    },
+    config.retryConfig
+  );
+  if (!response.ok) {
+    const errorText = await response.text().catch(() => response.statusText);
+    const requestId = response.headers.get("x-request-id") || void 0;
+    throw parseAPIError(response.status, errorText, requestId);
+  }
+  const apiProfile = await response.json();
+  const profile = transformProfile(apiProfile);
+  const session = await startProfileSession(config, { profileId: profile.id });
+  return buildProfileSetup(profile, session, config);
+}
+async function listProfiles(config = {}, repoId) {
+  const apiUrl = config.apiUrl || DEFAULT_API_URL;
+  const headers = buildHeaders(config);
+  const url = repoId ? `${apiUrl}/profiles?repo_id=${encodeURIComponent(repoId)}` : `${apiUrl}/profiles`;
+  const response = await fetchWithRetry(
+    url,
+    { method: "GET", headers },
+    config.retryConfig
+  );
+  if (!response.ok) {
+    const errorText = await response.text().catch(() => response.statusText);
+    const requestId = response.headers.get("x-request-id") || void 0;
+    throw parseAPIError(response.status, errorText, requestId);
+  }
+  const data = await response.json();
+  return data.profiles.map(transformProfile);
+}
+async function getProfile(id, config = {}) {
+  validateId(id, "id");
+  const apiUrl = config.apiUrl || DEFAULT_API_URL;
+  const headers = buildHeaders(config);
+  const response = await fetchWithRetry(
+    `${apiUrl}/profiles/${encodeURIComponent(id)}`,
+    { method: "GET", headers },
+    config.retryConfig
+  );
+  if (!response.ok) {
+    const errorText = await response.text().catch(() => response.statusText);
+    const requestId = response.headers.get("x-request-id") || void 0;
+    throw parseAPIError(response.status, errorText, requestId);
+  }
+  const apiProfile = await response.json();
+  const profile = transformProfile(apiProfile);
+  return {
+    ...profile,
+    getState: () => getProfileState(id, config),
+    delete: () => deleteProfile(id, config)
+  };
+}
+async function updateProfile(id, config = {}) {
+  validateId(id, "id");
+  const profile = await fetchProfile(id, config);
+  const session = await startProfileSession(config, { profileId: profile.id });
+  return buildProfileSetup(profile, session, config);
+}
+async function deleteProfile(id, config = {}) {
+  validateId(id, "id");
+  const apiUrl = config.apiUrl || DEFAULT_API_URL;
+  const headers = buildHeaders(config);
+  const response = await fetchWithRetry(
+    `${apiUrl}/profiles/${encodeURIComponent(id)}`,
+    { method: "DELETE", headers },
+    config.retryConfig
+  );
+  if (!response.ok) {
+    const errorText = await response.text().catch(() => response.statusText);
+    const requestId = response.headers.get("x-request-id") || void 0;
+    throw parseAPIError(response.status, errorText, requestId);
+  }
+}
+async function startProfileSession(config = {}, input) {
+  if (!config.apiKey) {
+    throw new MorphAuthenticationError();
+  }
+  const apiUrl = config.apiUrl || DEFAULT_API_URL;
+  const headers = buildHeaders(config);
+  const body = input?.profileId ? { profile_id: input.profileId } : {};
+  const response = await fetchWithRetry(
+    `${apiUrl}/profiles/session/start`,
+    {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body)
+    },
+    config.retryConfig
+  );
+  if (!response.ok) {
+    const errorText = await response.text().catch(() => response.statusText);
+    const requestId = response.headers.get("x-request-id") || void 0;
+    throw parseAPIError(response.status, errorText, requestId);
+  }
+  const apiSession = await response.json();
+  return transformSession(apiSession);
+}
+async function saveProfileSession(input, config = {}) {
+  validateId(input.sessionId, "sessionId");
+  validateId(input.profileId, "profileId");
+  const apiUrl = config.apiUrl || DEFAULT_API_URL;
+  const headers = buildHeaders(config);
+  const response = await fetchWithRetry(
+    `${apiUrl}/profiles/session/save`,
+    {
+      method: "POST",
+      headers,
+      body: JSON.stringify(transformSaveInput(input))
+    },
+    config.retryConfig
+  );
+  if (!response.ok) {
+    const errorText = await response.text().catch(() => response.statusText);
+    const requestId = response.headers.get("x-request-id") || void 0;
+    throw parseAPIError(response.status, errorText, requestId);
+  }
+  const apiProfile = await response.json();
+  return transformProfile(apiProfile);
+}
+async function listRepos(config = {}) {
+  const apiUrl = config.apiUrl || DEFAULT_API_URL;
+  const headers = buildHeaders(config);
+  const response = await fetchWithRetry(
+    `${apiUrl}/repos`,
+    { method: "GET", headers },
+    config.retryConfig
+  );
+  if (!response.ok) {
+    const errorText = await response.text().catch(() => response.statusText);
+    const requestId = response.headers.get("x-request-id") || void 0;
+    throw parseAPIError(response.status, errorText, requestId);
+  }
+  const data = await response.json();
+  const repos = Array.isArray(data?.repos) ? data.repos : [];
+  return repos.map((repo) => ({
+    repoId: repo.repo_id,
+    repoFullName: repo.repo_full_name,
+    profileCount: repo.profile_count ?? 0
+  }));
+}
+async function getProfileState(profileId, config = {}) {
+  validateId(profileId, "profileId");
+  const apiUrl = config.apiUrl || DEFAULT_API_URL;
+  const headers = buildHeaders(config);
+  const response = await fetchWithRetry(
+    `${apiUrl}/profiles/${encodeURIComponent(profileId)}/state`,
+    { method: "GET", headers },
+    config.retryConfig
+  );
+  if (!response.ok) {
+    const errorText = await response.text().catch(() => response.statusText);
+    const requestId = response.headers.get("x-request-id") || void 0;
+    throw parseAPIError(response.status, errorText, requestId);
+  }
+  const apiState = await response.json();
+  return transformStateResponse(apiState);
+}
+function buildHeaders(config) {
+  const headers = { "Content-Type": "application/json" };
+  if (config.apiKey) {
+    headers["Authorization"] = `Bearer ${config.apiKey}`;
+  }
+  return headers;
+}
+async function fetchProfile(id, config) {
+  const apiUrl = config.apiUrl || DEFAULT_API_URL;
+  const headers = buildHeaders(config);
+  const response = await fetchWithRetry(
+    `${apiUrl}/profiles/${encodeURIComponent(id)}`,
+    { method: "GET", headers },
+    config.retryConfig
+  );
+  if (!response.ok) {
+    const errorText = await response.text().catch(() => response.statusText);
+    const requestId = response.headers.get("x-request-id") || void 0;
+    throw parseAPIError(response.status, errorText, requestId);
+  }
+  const apiProfile = await response.json();
+  return transformProfile(apiProfile);
+}
+function buildProfileSetup(profile, session, config) {
+  return {
+    profile,
+    session,
+    save: () => saveProfileSession({ sessionId: session.sessionId, profileId: profile.id }, config)
+  };
+}
+
 // tools/browser/core.ts
 var DEFAULT_CONFIG = {
   apiUrl: process.env.MORPH_ENVIRONMENT === "DEV" ? "http://localhost:8000" : "https://browser.morphllm.com",
@@ -190,11 +778,16 @@ var DEFAULT_CONFIG = {
 };
 var BrowserClient = class {
   config;
+  /**
+   * Profile management - create and manage browser profiles for storing login state.
+   */
+  profiles;
   constructor(config = {}) {
     this.config = {
       ...DEFAULT_CONFIG,
       ...config
     };
+    this.profiles = new ProfilesClient(this.config);
   }
   /**
    * Execute a browser automation task
@@ -217,19 +810,21 @@ var BrowserClient = class {
       body: JSON.stringify({
         task: input.task,
         url: input.url,
-        max_steps: input.max_steps ?? 10,
+        max_steps: input.maxSteps ?? 10,
         model: input.model ?? "morph-computer-use-v0",
-        viewport_width: input.viewport_width ?? 1280,
-        viewport_height: input.viewport_height ?? 720,
-        external_id: input.external_id,
-        repo_id: input.repo_id,
-        commit_id: input.commit_id,
-        record_video: input.record_video ?? false,
-        video_width: input.video_width ?? input.viewport_width ?? 1280,
-        video_height: input.video_height ?? input.viewport_height ?? 720,
-        allow_resizing: input.allow_resizing ?? false,
+        viewport_width: input.viewportWidth ?? 1280,
+        viewport_height: input.viewportHeight ?? 720,
+        external_id: input.externalId,
+        repo_id: input.repoId,
+        repo_full_name: input.repoFullName,
+        commit_id: input.commitId,
+        record_video: input.recordVideo ?? false,
+        video_width: input.videoWidth ?? input.viewportWidth ?? 1280,
+        video_height: input.videoHeight ?? input.viewportHeight ?? 720,
+        allow_resizing: input.allowResizing ?? false,
         structured_output: "schema" in input ? stringifyStructuredOutput(input.schema) : void 0,
-        auth: input.auth
+        auth: input.auth,
+        profile_id: input.profileId
       })
     });
     if (!response.ok) {
@@ -237,9 +832,10 @@ var BrowserClient = class {
       if (debug) console.error(`[Browser] Error: ${response.status} - ${errorText}`);
       throw new Error(`HTTP ${response.status}: ${errorText}`);
     }
-    const result = await response.json();
+    const result = mapTaskResult(await response.json());
     if (debug) {
-      console.log(`[Browser] \u2705 Task created: recording_id=${result.recording_id ?? "none"} debug_url=${result.debugUrl ? "available" : "none"}`);
+      const debugUrl = result.debugUrl;
+      console.log(`[Browser] \u2705 Task created: recordingId=${result.recordingId ?? "none"} debugUrl=${debugUrl ? "available" : "none"}`);
     }
     if ("schema" in input) {
       return wrapTaskResponseWithSchema(result, this.config, input.schema);
@@ -294,15 +890,15 @@ async function executeBrowserTask(input, config = {}) {
       error: 'Task description is required. Example: "Go to example.com and click the login button"'
     };
   }
-  if (input.max_steps !== void 0 && (input.max_steps < 1 || input.max_steps > 50)) {
+  if (input.maxSteps !== void 0 && (input.maxSteps < 1 || input.maxSteps > 50)) {
     return {
       success: false,
-      error: "max_steps must be between 1 and 50. Use more steps for complex multi-page flows."
+      error: "maxSteps must be between 1 and 50. Use more steps for complex multi-page flows."
     };
   }
   if (debug) {
-    console.log(`[Browser] Task: "${input.task.slice(0, 60)}..." url=${input.url || "none"} maxSteps=${input.max_steps ?? 10}`);
-    console.log(`[Browser] Recording: ${input.record_video ? "yes" : "no"} | Calling ${apiUrl}/browser-task`);
+    console.log(`[Browser] Task: "${input.task.slice(0, 60)}..." url=${input.url || "none"} maxSteps=${input.maxSteps ?? 10}`);
+    console.log(`[Browser] Recording: ${input.recordVideo ? "yes" : "no"} | Calling ${apiUrl}/browser-task`);
   }
   const startTime = Date.now();
   try {
@@ -316,19 +912,20 @@ async function executeBrowserTask(input, config = {}) {
         body: JSON.stringify({
           task: input.task,
           url: input.url,
-          max_steps: input.max_steps ?? 10,
+          max_steps: input.maxSteps ?? 10,
           model: input.model ?? "morph-computer-use-v0",
-          viewport_width: input.viewport_width ?? 1280,
-          viewport_height: input.viewport_height ?? 720,
-          external_id: input.external_id,
-          repo_id: input.repo_id,
-          commit_id: input.commit_id,
-          record_video: input.record_video ?? false,
-          video_width: input.video_width ?? input.viewport_width ?? 1280,
-          video_height: input.video_height ?? input.viewport_height ?? 720,
-          allow_resizing: input.allow_resizing ?? false,
-          structured_output: input.structured_output,
-          auth: input.auth
+          viewport_width: input.viewportWidth ?? 1280,
+          viewport_height: input.viewportHeight ?? 720,
+          external_id: input.externalId,
+          repo_id: input.repoId,
+          commit_id: input.commitId,
+          record_video: input.recordVideo ?? false,
+          video_width: input.videoWidth ?? input.viewportWidth ?? 1280,
+          video_height: input.videoHeight ?? input.viewportHeight ?? 720,
+          allow_resizing: input.allowResizing ?? false,
+          structured_output: input.structuredOutput,
+          auth: input.auth,
+          profile_id: input.profileId
         })
       },
       config.retryConfig
@@ -336,17 +933,17 @@ async function executeBrowserTask(input, config = {}) {
     const response = await withTimeout(
       fetchPromise,
       timeout,
-      `Browser task timed out after ${timeout}ms. Consider increasing timeout or reducing max_steps.`
+      `Browser task timed out after ${timeout}ms. Consider increasing timeout or reducing maxSteps.`
     );
     if (!response.ok) {
       const errorText = await response.text().catch(() => response.statusText);
       if (debug) console.error(`[Browser] Error: ${response.status} - ${errorText}`);
       throw new Error(`HTTP ${response.status}: ${errorText}`);
     }
-    const result = await response.json();
+    const result = mapTaskResult(await response.json());
     const elapsed = Date.now() - startTime;
     if (debug) {
-      console.log(`[Browser] \u2705 ${result.success ? "Success" : "Failed"} in ${elapsed}ms | steps=${result.steps_taken ?? 0} recordingId=${result.recording_id ?? "none"}`);
+      console.log(`[Browser] \u2705 ${result.success ? "Success" : "Failed"} in ${elapsed}ms | steps=${result.stepsTaken ?? 0} recordingId=${result.recordingId ?? "none"}`);
     }
     return result;
   } catch (error) {
@@ -384,7 +981,7 @@ async function getRecording(recordingId, config = {}) {
     if (debug) console.error(`[Browser] getRecording error: ${response.status} - ${errorText}`);
     throw new Error(`HTTP ${response.status}: ${errorText}`);
   }
-  const data = await response.json();
+  const data = mapRecordingStatus(await response.json());
   if (debug) console.log(`[Browser] Recording status: ${data.status}`);
   return {
     ...data,
@@ -407,10 +1004,10 @@ async function waitForRecording(recordingId, config = {}, options = {}) {
 }
 async function executeWithRecording(input, config = {}) {
   const taskResult = await executeBrowserTask(input, config);
-  if (taskResult.recording_id) {
+  if (taskResult.recordingId) {
     try {
       const recording = await waitForRecording(
-        taskResult.recording_id,
+        taskResult.recordingId,
         config,
         { timeout: 6e4, pollInterval: 2e3 }
       );
@@ -420,12 +1017,12 @@ async function executeWithRecording(input, config = {}) {
       };
     } catch (error) {
       const errorRecording = {
-        id: taskResult.recording_id,
+        id: taskResult.recordingId,
         status: "ERROR",
         error: error instanceof Error ? error.message : String(error),
-        created_at: (/* @__PURE__ */ new Date()).toISOString(),
-        getWebp: (options) => getWebp(taskResult.recording_id, config, options),
-        getErrors: () => getErrors(taskResult.recording_id, config)
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        getWebp: (options) => getWebp(taskResult.recordingId, config, options),
+        getErrors: () => getErrors(taskResult.recordingId, config)
       };
       return {
         ...taskResult,
@@ -451,8 +1048,8 @@ async function getErrors(recordingId, config = {}) {
     if (debug) console.error(`[Browser] getErrors error: ${response.status} - ${errorText}`);
     throw new Error(`HTTP ${response.status}: ${errorText}`);
   }
-  const errors = await response.json();
-  if (debug) console.log(`[Browser] Found ${errors.total_errors} errors`);
+  const errors = mapErrorsResponse(await response.json());
+  if (debug) console.log(`[Browser] Found ${errors.totalErrors} errors`);
   return errors;
 }
 function stringifyStructuredOutput(schema) {
@@ -485,6 +1082,84 @@ function parseStructuredTaskOutput(result, schema) {
     throw error;
   }
 }
+function mapTaskResult(api) {
+  if (!api || typeof api !== "object") {
+    return api;
+  }
+  return {
+    success: api.success,
+    result: api.result,
+    error: api.error,
+    stepsTaken: api.steps_taken,
+    executionTimeMs: api.execution_time_ms,
+    urls: api.urls,
+    actionNames: api.action_names,
+    errors: api.errors,
+    modelActions: api.model_actions,
+    isDone: api.is_done,
+    actionHistory: api.action_history,
+    actionResults: api.action_results,
+    hasErrors: api.has_errors,
+    numberOfSteps: api.number_of_steps,
+    judgement: api.judgement,
+    isValidated: api.is_validated,
+    replayId: api.replay_id,
+    replayUrl: api.replay_url,
+    recordingId: api.recording_id,
+    recordingStatus: api.recording_status,
+    taskId: api.task_id,
+    status: api.status,
+    output: api.output,
+    debugUrl: api.debug_url
+  };
+}
+function mapRecordingStatus(api) {
+  return {
+    id: api.id,
+    status: api.status,
+    replayUrl: api.replay_url,
+    networkUrl: api.network_url,
+    consoleUrl: api.console_url,
+    videoUrl: api.video_url,
+    totalEvents: api.total_events,
+    fileSize: api.file_size,
+    duration: api.duration,
+    error: api.error,
+    createdAt: api.created_at
+  };
+}
+function mapBrowserError(api) {
+  return {
+    type: api.type,
+    message: api.message,
+    url: api.url,
+    timestamp: api.timestamp,
+    screenshotUrl: api.screenshot_url,
+    capturedAt: api.captured_at,
+    status: api.status
+  };
+}
+function mapErrorsResponse(api) {
+  return {
+    recordingId: api.recording_id,
+    totalErrors: api.total_errors,
+    errors: Array.isArray(api.errors) ? api.errors.map(mapBrowserError) : []
+  };
+}
+function mapWebpResponse(api) {
+  return {
+    webpUrl: api.webp_url,
+    cached: api.cached,
+    width: api.width,
+    fps: api.fps,
+    maxDuration: api.max_duration,
+    fileSize: api.file_size,
+    maxSizeMb: api.max_size_mb,
+    budgetMet: api.budget_met,
+    qualityUsed: api.quality_used,
+    attempts: api.attempts
+  };
+}
 async function getTaskStatus(taskId, config) {
   const apiUrl = config.apiUrl || DEFAULT_CONFIG.apiUrl;
   const debug = config.debug || false;
@@ -500,7 +1175,7 @@ async function getTaskStatus(taskId, config) {
     if (debug) console.error(`[Browser] getTaskStatus error: ${response.status} - ${errorText}`);
     throw new Error(`HTTP ${response.status}: ${errorText}`);
   }
-  const result = await response.json();
+  const result = mapTaskResult(await response.json());
   if (debug) console.log(`[Browser] Task status: ${result.status}`);
   return result;
 }
@@ -523,42 +1198,44 @@ async function pollTaskUntilComplete(taskId, config, pollConfig = {}) {
   throw new Error(`Task polling timeout after ${timeout}ms`);
 }
 function wrapTaskResponse(result, config) {
+  const debugUrl = result.debugUrl ?? "";
   const wrapped = {
     ...result,
-    task_id: result.task_id || "",
-    liveUrl: result.task_id ? generateLiveUrl(result.task_id, config) : result.debugUrl || "",
+    debugUrl,
+    taskId: result.taskId || "",
+    liveUrl: result.taskId ? generateLiveUrl(result.taskId, config) : debugUrl,
     complete: async (pollConfig) => {
-      if (result.task_id) {
-        return pollTaskUntilComplete(result.task_id, config, pollConfig);
+      if (result.taskId) {
+        return pollTaskUntilComplete(result.taskId, config, pollConfig);
       }
-      if (result.recording_id) {
+      if (result.recordingId) {
         const recording = await waitForRecording(
-          result.recording_id,
+          result.recordingId,
           config,
           pollConfig
         );
         return {
           ...result,
-          recording_status: recording.status
+          recordingStatus: recording.status
         };
       }
-      throw new Error("Cannot poll completion: no task_id or recording_id available");
+      throw new Error("Cannot poll completion: no taskId or recordingId available");
     },
     // Add Steel live session helpers - either functional or error-throwing
-    getLiveUrl: result.debugUrl ? (options) => buildLiveUrl(result.debugUrl, options) : () => {
+    getLiveUrl: debugUrl ? (options) => buildLiveUrl(debugUrl, options) : () => {
       throw new Error(
         "Live sessions not available. Your backend must return a debugUrl in the response. Contact support@morphllm.com if you need help."
       );
     },
-    getLiveIframe: result.debugUrl ? (optionsOrPreset) => {
+    getLiveIframe: debugUrl ? (optionsOrPreset) => {
       const options = resolvePreset(optionsOrPreset);
-      return buildLiveIframe(result.debugUrl, options);
+      return buildLiveIframe(debugUrl, options);
     } : () => {
       throw new Error(
         "Live sessions not available. Your backend must return a debugUrl in the response. Contact support@morphllm.com if you need help."
       );
     },
-    getEmbedCode: result.debugUrl ? () => buildEmbedCode(result.debugUrl) : () => {
+    getEmbedCode: debugUrl ? () => buildEmbedCode(debugUrl) : () => {
       throw new Error(
         "Live sessions not available. Your backend must return a debugUrl in the response. Contact support@morphllm.com if you need help."
       );
@@ -567,44 +1244,46 @@ function wrapTaskResponse(result, config) {
   return wrapped;
 }
 function wrapTaskResponseWithSchema(result, config, schema) {
+  const debugUrl = result.debugUrl ?? "";
   const parsed = result.output ? parseStructuredTaskOutput(result, schema) : { ...result, parsed: null };
   const wrapped = {
     ...parsed,
-    task_id: result.task_id || "",
-    liveUrl: result.task_id ? generateLiveUrl(result.task_id, config) : result.debugUrl || "",
+    debugUrl,
+    taskId: result.taskId || "",
+    liveUrl: result.taskId ? generateLiveUrl(result.taskId, config) : debugUrl,
     complete: async (pollConfig) => {
-      if (result.task_id) {
-        const finalResult = await pollTaskUntilComplete(result.task_id, config, pollConfig);
+      if (result.taskId) {
+        const finalResult = await pollTaskUntilComplete(result.taskId, config, pollConfig);
         return parseStructuredTaskOutput(finalResult, schema);
       }
-      if (result.recording_id) {
+      if (result.recordingId) {
         const recording = await waitForRecording(
-          result.recording_id,
+          result.recordingId,
           config,
           pollConfig
         );
         return {
           ...parsed,
-          recording_status: recording.status
+          recordingStatus: recording.status
         };
       }
-      throw new Error("Cannot poll completion: no task_id or recording_id available");
+      throw new Error("Cannot poll completion: no taskId or recordingId available");
     },
     // Add Steel live session helpers - either functional or error-throwing
-    getLiveUrl: result.debugUrl ? (options) => buildLiveUrl(result.debugUrl, options) : () => {
+    getLiveUrl: debugUrl ? (options) => buildLiveUrl(debugUrl, options) : () => {
       throw new Error(
         "Live sessions not available. Your backend must return a debugUrl in the response. Contact support@morphllm.com if you need help enabling live sessions. "
       );
     },
-    getLiveIframe: result.debugUrl ? (optionsOrPreset) => {
+    getLiveIframe: debugUrl ? (optionsOrPreset) => {
       const options = resolvePreset(optionsOrPreset);
-      return buildLiveIframe(result.debugUrl, options);
+      return buildLiveIframe(debugUrl, options);
     } : () => {
       throw new Error(
         "Live sessions not available. Your backend must return a debugUrl in the response. Contact support@morphllm.com if you need help enabling live sessions."
       );
     },
-    getEmbedCode: result.debugUrl ? () => buildEmbedCode(result.debugUrl) : () => {
+    getEmbedCode: debugUrl ? () => buildEmbedCode(debugUrl) : () => {
       throw new Error(
         "Live sessions not available. Your backend must return a debugUrl in the response. Contact support@morphllm.com if you need help enabling live sessions."
       );
@@ -619,10 +1298,11 @@ async function getWebp(recordingId, config = {}, options = {}) {
     throw new Error("API key required for getWebp");
   }
   const params = new URLSearchParams();
-  if (options.max_duration !== void 0) params.set("max_duration", String(options.max_duration));
+  if (options.maxDuration !== void 0) params.set("max_duration", String(options.maxDuration));
   if (options.fps !== void 0) params.set("fps", String(options.fps));
   if (options.width !== void 0) params.set("width", String(options.width));
   if (options.quality !== void 0) params.set("quality", String(options.quality));
+  if (options.maxSizeMb !== void 0) params.set("max_size_mb", String(options.maxSizeMb));
   const url = `${apiUrl}/recordings/${recordingId}/webp${params.toString() ? "?" + params.toString() : ""}`;
   if (debug) console.log(`[Browser] getWebp: ${url}`);
   const response = await fetch(url, {
@@ -634,8 +1314,8 @@ async function getWebp(recordingId, config = {}, options = {}) {
     if (debug) console.error(`[Browser] getWebp error: ${response.status} - ${errorText}`);
     throw new Error(`HTTP ${response.status}: ${errorText}`);
   }
-  const result = await response.json();
-  if (debug) console.log(`[Browser] WebP ready: ${result.webp_url} (cached: ${result.cached})`);
+  const result = mapWebpResponse(await response.json());
+  if (debug) console.log(`[Browser] WebP ready: ${result.webpUrl} (cached: ${result.cached})`);
   return result;
 }
 async function checkHealth(config = {}) {