@morphllm/morphsdk 0.2.92 → 0.2.94

package/dist/tools/browser/index.cjs

@@ -24,6 +24,14 @@ __export(browser_exports, {
   BROWSER_TOOL_DESCRIPTION: () => BROWSER_TOOL_DESCRIPTION,
   BrowserClient: () => BrowserClient,
   LIVE_PRESETS: () => LIVE_PRESETS,
+  MorphAPIError: () => MorphAPIError,
+  MorphAuthenticationError: () => MorphAuthenticationError,
+  MorphError: () => MorphError,
+  MorphNotFoundError: () => MorphNotFoundError,
+  MorphProfileLimitError: () => MorphProfileLimitError,
+  MorphRateLimitError: () => MorphRateLimitError,
+  MorphValidationError: () => MorphValidationError,
+  ProfilesClient: () => ProfilesClient,
   anthropic: () => anthropic_exports,
   buildEmbedCode: () => buildEmbedCode,
   buildLiveIframe: () => buildLiveIframe,
@@ -36,6 +44,7 @@ __export(browser_exports, {
   getRecording: () => getRecording,
   getWebp: () => getWebp,
   openai: () => openai_exports,
+  parseAPIError: () => parseAPIError,
   vercel: () => vercel_exports,
   waitForRecording: () => waitForRecording
 });
@@ -191,6 +200,541 @@ 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 || api.debugUrl || ""
+  };
+}
+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.
+   *
+   * @param input - Profile creation parameters
+   * @returns The created profile
+   * @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 profile = await morph.browser.profiles.createProfile({
+   *   name: 'LinkedIn Production',
+   *   repoId: 'repo-uuid-here'
+   * });
+   * ```
+   */
+  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('repo-uuid');
+   * ```
+   */
+  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's name.
+   *
+   * @param id - Profile ID
+   * @param input - Update parameters
+   * @returns Updated profile
+   */
+  async updateProfile(id, input) {
+    return updateProfile(id, input, 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);
+  }
+  /**
+   * 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();
+  return transformProfile(apiProfile);
+}
+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, input, config = {}) {
+  validateId(id, "id");
+  if (input.name !== void 0) {
+    if (typeof input.name !== "string") {
+      throw new MorphValidationError("name must be a string", "name");
+    }
+    if (input.name.trim().length === 0) {
+      throw new MorphValidationError("name cannot be empty", "name");
+    }
+    if (input.name.length > 100) {
+      throw new MorphValidationError("name must be 100 characters or less", "name");
+    }
+  }
+  const apiUrl = config.apiUrl || DEFAULT_API_URL;
+  const headers = buildHeaders(config);
+  const response = await fetchWithRetry(
+    `${apiUrl}/profiles/${encodeURIComponent(id)}`,
+    {
+      method: "PATCH",
+      headers,
+      body: JSON.stringify(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 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 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;
+}
+
 // tools/browser/core.ts
 var DEFAULT_CONFIG = {
   apiUrl: process.env.MORPH_ENVIRONMENT === "DEV" ? "http://localhost:8000" : "https://browser.morphllm.com",
@@ -200,11 +744,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
@@ -239,7 +788,8 @@ var BrowserClient = class {
         video_height: input.video_height ?? input.viewport_height ?? 720,
         allow_resizing: input.allow_resizing ?? false,
         structured_output: "schema" in input ? stringifyStructuredOutput(input.schema) : void 0,
-        auth: input.auth
+        auth: input.auth,
+        profile_id: input.profile_id
       })
     });
     if (!response.ok) {
@@ -338,7 +888,8 @@ async function executeBrowserTask(input, config = {}) {
           video_height: input.video_height ?? input.viewport_height ?? 720,
           allow_resizing: input.allow_resizing ?? false,
           structured_output: input.structured_output,
-          auth: input.auth
+          auth: input.auth,
+          profile_id: input.profile_id
         })
       },
       config.retryConfig
@@ -981,6 +1532,14 @@ var gemini_default = browserFunctionDeclaration;
   BROWSER_TOOL_DESCRIPTION,
   BrowserClient,
   LIVE_PRESETS,
+  MorphAPIError,
+  MorphAuthenticationError,
+  MorphError,
+  MorphNotFoundError,
+  MorphProfileLimitError,
+  MorphRateLimitError,
+  MorphValidationError,
+  ProfilesClient,
   anthropic,
   buildEmbedCode,
   buildLiveIframe,
@@ -993,6 +1552,7 @@ var gemini_default = browserFunctionDeclaration;
   getRecording,
   getWebp,
   openai,
+  parseAPIError,
   vercel,
   waitForRecording
 });