@morphllm/morphsdk 0.2.93 → 0.2.95

package/dist/tools/browser/types.d.ts

@@ -7,7 +7,7 @@ import { RetryConfig } from '../utils/resilience.js';
 /**
  * Available browser automation models
  */
-type BrowserModel = 'gemini-3-flash-preview' | 'morph-computer-use-v0';
+type BrowserModel = 'gemini-3-flash-preview' | 'morph-computer-use-v0' | 'morph-computer-use-v1';
 /**
  * Configuration for the browser worker service
  */
@@ -43,7 +43,7 @@ interface BrowserTaskInput {
     /** Starting URL (e.g., https://3000-xyz.e2b.dev) */
     url?: string;
     /** Maximum number of browser actions to take (1-50, default: 10) */
-    max_steps?: number;
+    maxSteps?: number;
     /** Model to use for task execution (default: morph-computer-use-v0) */
     model?: BrowserModel;
     /** Browserless region: 'sfo' (US West) or 'lon' (Europe) */
@@ -51,32 +51,36 @@ interface BrowserTaskInput {
     /** Enable stealth mode to avoid bot detection (default: true) */
     stealth?: boolean;
     /** Browser viewport width (default: 1280) */
-    viewport_width?: number;
+    viewportWidth?: number;
     /** Browser viewport height (default: 720) */
-    viewport_height?: number;
+    viewportHeight?: number;
     /** User-defined reference/tracking ID (e.g., "PR-1234", "jira-PROJ-567") */
-    external_id?: string;
-    /** Optional repository ID to associate with this session */
-    repo_id?: string;
+    externalId?: string;
+    /** Optional repository database ID (UUID) to associate with this session - for internal use */
+    repoId?: string;
+    /** Optional repository full name (e.g., "owner/repo") - for external SDK users */
+    repoFullName?: string;
     /** Optional commit UUID to associate with this session */
-    commit_id?: string;
+    commitId?: string;
     /** Record session video to S3 (default: false) */
-    record_video?: boolean;
+    recordVideo?: boolean;
     /** Video width (default: 1280) */
-    video_width?: number;
+    videoWidth?: number;
     /** Video height (default: 720) */
-    video_height?: number;
+    videoHeight?: number;
     /** Enable window resizing for responsive/mobile testing. Disables stealth mode. (default: false) */
-    allow_resizing?: boolean;
+    allowResizing?: boolean;
     /** Serialized structured output schema (internal use) */
-    structured_output?: string;
+    structuredOutput?: string;
     /** Site authentication - global credentials or per-domain dict (follows browser-use pattern) */
     auth?: AuthCredentials | Record<string, AuthCredentials>;
+    /** Profile ID - restore cookies/localStorage from a saved browser profile */
+    profileId?: string;
 }
 /**
  * Input with Zod schema for structured output
  */
-interface BrowserTaskInputWithSchema<T> extends Omit<BrowserTaskInput, 'structured_output'> {
+interface BrowserTaskInputWithSchema<T> extends Omit<BrowserTaskInput, 'structuredOutput'> {
     /** Zod schema for structured output */
     schema: any;
 }
@@ -91,27 +95,27 @@ interface BrowserTaskResult {
     /** Error message if task failed */
     error?: string;
     /** Number of browser actions taken */
-    steps_taken?: number;
+    stepsTaken?: number;
     /** Total execution time in milliseconds */
-    execution_time_ms?: number;
+    executionTimeMs?: number;
     /** All URLs visited during execution */
     urls?: (string | null)[];
     /** Names of all actions executed */
-    action_names?: string[];
+    actionNames?: string[];
     /** Per-step errors (null for steps without errors) */
     errors?: (string | null)[];
     /** All model actions with parameters */
-    model_actions?: any[];
+    modelActions?: any[];
     /** Whether agent marked task as done */
-    is_done?: boolean;
+    isDone?: boolean;
     /** Truncated action history with essential fields */
-    action_history?: any[][];
+    actionHistory?: any[][];
     /** All action results */
-    action_results?: any[];
+    actionResults?: any[];
     /** Whether any errors occurred */
-    has_errors?: boolean;
+    hasErrors?: boolean;
     /** Total number of steps executed */
-    number_of_steps?: number;
+    numberOfSteps?: number;
     /** Judge validation result if available */
     judgement?: {
         reasoning?: string;
@@ -121,17 +125,17 @@ interface BrowserTaskResult {
         reached_captcha?: boolean;
     };
     /** Whether judge validated the execution */
-    is_validated?: boolean;
+    isValidated?: boolean;
     /** UUID of saved replay record (if session replay enabled) */
-    replay_id?: string;
+    replayId?: string;
     /** Browserless replay URL (if session replay enabled) */
-    replay_url?: string;
-    /** Recording ID (if record_video=true) */
-    recording_id?: string;
+    replayUrl?: string;
+    /** Recording ID (if recordVideo=true) */
+    recordingId?: string;
     /** Recording status: PENDING, PROCESSING, COMPLETED, ERROR */
-    recording_status?: string;
+    recordingStatus?: string;
     /** Task ID for async task tracking */
-    task_id?: string;
+    taskId?: string;
     /** Task status: pending, running, completed, failed */
     status?: string;
     /** Structured output (JSON string) */
@@ -171,7 +175,7 @@ interface IframeOptions extends LiveSessionOptions {
  * Task result with convenience methods for async execution
  */
 interface BrowserTaskWithPromise extends BrowserTaskResult {
-    task_id: string;
+    taskId: string;
     /** Live URL to watch task execution in real-time */
     liveUrl: string;
     /** Wait for task completion */
@@ -190,7 +194,7 @@ interface BrowserTaskWithPromise extends BrowserTaskResult {
  * Task result with schema validation
  */
 interface BrowserTaskWithPromiseAndSchema<T> extends BrowserTaskResult {
-    task_id: string;
+    taskId: string;
     /** Live URL to watch task execution in real-time */
     liveUrl: string;
     /** Parsed and validated output */
@@ -218,23 +222,23 @@ interface RecordingStatus {
     /** Current status */
     status: 'PENDING' | 'PROCESSING' | 'COMPLETED' | 'ERROR';
     /** Presigned S3 URL for rrweb replay JSON (interactive DOM replay) */
-    replay_url?: string;
+    replayUrl?: string;
     /** Presigned S3 URL for network logs (NDJSON format) */
-    network_url?: string;
+    networkUrl?: string;
     /** Presigned S3 URL for console logs (NDJSON format) */
-    console_url?: string;
+    consoleUrl?: string;
     /** Presigned S3 URL for native browser video (WebM or MP4 format, real-time recording) */
-    video_url?: string;
+    videoUrl?: string;
     /** Total rrweb events captured */
-    total_events?: number;
+    totalEvents?: number;
     /** Total bytes of all files */
-    file_size?: number;
+    fileSize?: number;
     /** Duration in milliseconds */
     duration?: number;
     /** Error message if status=ERROR */
     error?: string;
     /** When recording was created */
-    created_at: string;
+    createdAt: string;
 }
 /**
  * Browser error with screenshot captured at error time
@@ -249,9 +253,9 @@ interface BrowserError {
     /** CDP timestamp in seconds since browser start */
     timestamp: number;
     /** Presigned S3 URL to screenshot JPEG (captured 500ms after error) */
-    screenshot_url?: string;
+    screenshotUrl?: string;
     /** When screenshot was captured (Unix timestamp) */
-    captured_at?: number;
+    capturedAt?: number;
     /** HTTP status code (for network errors) */
     status?: number;
 }
@@ -260,9 +264,9 @@ interface BrowserError {
  */
 interface ErrorsResponse {
     /** Recording ID */
-    recording_id: string;
+    recordingId: string;
     /** Total number of errors */
-    total_errors: number;
+    totalErrors: number;
     /** Errors with real-time screenshots */
     errors: BrowserError[];
 }
@@ -271,7 +275,7 @@ interface ErrorsResponse {
  */
 interface WebpOptions {
     /** Maximum duration in seconds (1-120, default: 60) */
-    max_duration?: number;
+    maxDuration?: number;
     /** Frame rate (5-30, default: 15) */
     fps?: number;
     /** Output width in pixels (320-1920, default: 780) */
@@ -281,14 +285,14 @@ interface WebpOptions {
     /** Enable auto-zoom that follows click/input actions (default: false) */
     autoZoom?: boolean;
     /** Maximum file size in MB (0.5-50). Uses iterative reduction to guarantee budget. */
-    max_size_mb?: number;
+    maxSizeMb?: number;
 }
 /**
  * Response from getWebp()
  */
 interface WebpResponse {
     /** Presigned S3 URL for the WebP file */
-    webp_url: string;
+    webpUrl: string;
     /** Whether the WebP was served from cache */
     cached: boolean;
     /** Width of the WebP (may differ from requested if budget-constrained) */
@@ -296,15 +300,15 @@ interface WebpResponse {
     /** Frame rate of the WebP (may differ from requested if budget-constrained) */
     fps: number;
     /** Max duration used (may differ from requested if budget-constrained) */
-    max_duration: number;
+    maxDuration: number;
     /** File size in bytes */
-    file_size?: number;
+    fileSize?: number;
     /** Max size budget in MB (if specified) */
-    max_size_mb?: number;
+    maxSizeMb?: number;
     /** Whether the file fits within the budget */
-    budget_met?: boolean;
+    budgetMet?: boolean;
     /** Quality setting used (may differ from requested if budget-constrained) */
-    quality_used?: number;
+    qualityUsed?: number;
     /** Number of encoding attempts needed to meet budget */
     attempts?: number;
 }

package/dist/tools/browser/vercel.cjs

@@ -101,6 +101,9 @@ function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
+// tools/browser/profiles/core.ts
+var DEFAULT_API_URL = process.env.MORPH_ENVIRONMENT === "DEV" ? "http://localhost:8000" : "https://browser.morphllm.com";
+
 // tools/browser/core.ts
 var DEFAULT_CONFIG = {
   apiUrl: process.env.MORPH_ENVIRONMENT === "DEV" ? "http://localhost:8000" : "https://browser.morphllm.com",
@@ -118,15 +121,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 {
@@ -140,19 +143,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
@@ -160,17 +164,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) {
@@ -192,6 +196,37 @@ async function executeBrowserTask(input, config = {}) {
     };
   }
 }
+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
+  };
+}
 
 // tools/browser/prompts.ts
 var BROWSER_TOOL_DESCRIPTION = `Test and verify your implemented code in a live browser. This tool executes natural language test instructions and returns a video recording plus detailed logs to help you debug issues.
@@ -229,31 +264,31 @@ Include verification steps:
 ## Requirements
 - **URL**: Must be publicly accessible (use tunnels like ngrok, Cloudflare, or deploy to staging)
 - **Timing**: Use this after implementation, not during coding
-- **Complexity**: Set max_steps higher (20-30) for multi-step user workflows`;
+- **Complexity**: Set maxSteps higher (20-30) for multi-step user workflows`;
 
 // tools/browser/vercel.ts
 function createBrowserTool(config) {
   const schema = import_zod.z.object({
     task: import_zod.z.string().describe('Natural language description of what to do (e.g., "Test checkout flow for buying a pineapple")'),
     url: import_zod.z.string().optional().describe("Starting URL (e.g., https://3000-xyz.e2b.dev)"),
-    max_steps: import_zod.z.number().min(1).max(50).default(10).describe("Maximum number of browser actions to take"),
+    maxSteps: import_zod.z.number().min(1).max(50).default(10).describe("Maximum number of browser actions to take"),
     region: import_zod.z.enum(["sfo", "lon"]).default("sfo").describe("Browserless region: sfo (US West) or lon (Europe)")
   });
   return (0, import_ai.tool)({
     description: BROWSER_TOOL_DESCRIPTION,
     inputSchema: schema,
     execute: async (params) => {
-      const { task, url, max_steps, region } = params;
+      const { task, url, maxSteps, region } = params;
       const result = await executeBrowserTask(
-        { task, url, max_steps, region },
+        { task, url, maxSteps, region },
         config
       );
       if (result.success) {
         return {
           success: true,
           result: result.result,
-          steps_taken: result.steps_taken,
-          execution_time_ms: result.execution_time_ms
+          stepsTaken: result.stepsTaken,
+          executionTimeMs: result.executionTimeMs
         };
       }
       return {