@morphllm/morphsdk 0.2.40 → 0.2.41

package/dist/modelrouter/core.d.ts

@@ -0,0 +1,69 @@
+import { RouterConfig, Provider, RouterInput, RouterResult, RawRouterResult } from './types.js';
+
+/**
+ * Core implementation for intelligent model routing
+ */
+
+declare abstract class BaseRouter {
+    protected config: Required<Omit<RouterConfig, 'apiKey' | 'retryConfig'>> & Pick<RouterConfig, 'apiKey' | 'retryConfig'>;
+    protected provider: Provider;
+    constructor(provider: Provider, config?: RouterConfig);
+    /**
+     * Select the optimal model for a given input and mode
+     */
+    selectModel(input: RouterInput): Promise<RouterResult>;
+}
+/**
+ * OpenAI model router for GPT-5 series
+ */
+declare class OpenAIRouter extends BaseRouter {
+    constructor(config?: RouterConfig);
+    /**
+     * Select optimal GPT-5 model
+     *
+     * @param input - User input and mode
+     * @returns Selected model name (gpt-5-mini | gpt-5-low | gpt-5-medium | gpt-5-high)
+     */
+    selectModel(input: RouterInput): Promise<RouterResult>;
+}
+/**
+ * Anthropic model router for Claude 4.5 series
+ */
+declare class AnthropicRouter extends BaseRouter {
+    constructor(config?: RouterConfig);
+    /**
+     * Select optimal Claude model
+     *
+     * @param input - User input and mode
+     * @returns Selected model name (claude-4.5-haiku | claude-4.5-sonnet)
+     */
+    selectModel(input: RouterInput): Promise<RouterResult>;
+}
+/**
+ * Google Gemini model router
+ */
+declare class GeminiRouter extends BaseRouter {
+    constructor(config?: RouterConfig);
+    /**
+     * Select optimal Gemini model
+     *
+     * @param input - User input and mode
+     * @returns Selected model name (gemini-2.5-flash | gemini-2.5-pro)
+     */
+    selectModel(input: RouterInput): Promise<RouterResult>;
+}
+/**
+ * Raw difficulty classification router (no provider-specific mapping)
+ */
+declare class RawRouter extends BaseRouter {
+    constructor(config?: RouterConfig);
+    /**
+     * Get raw difficulty classification
+     *
+     * @param input - User input and mode
+     * @returns Raw difficulty (easy | medium | hard | needs-info)
+     */
+    classify(input: RouterInput): Promise<RawRouterResult>;
+}
+
+export { AnthropicRouter, GeminiRouter, OpenAIRouter, RawRouter };

package/dist/modelrouter/index.d.ts

@@ -0,0 +1,2 @@
+export { AnthropicRouter, GeminiRouter, OpenAIRouter, RawRouter } from './core.js';
+export { ComplexityLevel, Provider, RawRouterResult, RouterConfig, RouterInput, RouterMode, RouterResult } from './types.js';

package/dist/modelrouter/types.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Model router types for intelligent model selection
+ */
+type ComplexityLevel = 'easy' | 'medium' | 'hard' | 'needs-info';
+type RouterMode = 'balanced' | 'aggressive';
+type Provider = 'openai' | 'anthropic' | 'gemini';
+interface RouterConfig {
+    /** Morph API key (defaults to MORPH_API_KEY env var) */
+    apiKey?: string;
+    /** Router API URL (defaults to https://api.morphllm.com) */
+    apiUrl?: string;
+    /** Request timeout in milliseconds (default: 10000) */
+    timeout?: number;
+    /** Enable debug logging */
+    debug?: boolean;
+    /** Retry configuration */
+    retryConfig?: {
+        maxRetries?: number;
+        initialDelay?: number;
+        maxDelay?: number;
+        backoffMultiplier?: number;
+    };
+}
+interface RouterInput {
+    /** User input or task description */
+    input: string;
+    /** Routing mode: balanced (cheaper models) or aggressive (more capable models) */
+    mode?: RouterMode;
+}
+interface RouterResult {
+    /** Selected model name */
+    model: string;
+}
+interface RawRouterResult {
+    /** Raw difficulty classification */
+    difficulty: ComplexityLevel;
+}
+
+export type { ComplexityLevel, Provider, RawRouterResult, RouterConfig, RouterInput, RouterMode, RouterResult };

package/dist/openai-BkKsS30n.d.ts

@@ -0,0 +1,111 @@
+import { ChatCompletionTool } from 'openai/resources/chat/completions';
+import { EditFileInput, EditFileConfig, EditFileResult } from './tools/fastapply/types.js';
+
+/**
+ * OpenAI SDK adapter for edit_file tool
+ */
+
+/**
+ * OpenAI-native tool definition for edit_file
+ *
+ * @example
+ * ```ts
+ * import OpenAI from 'openai';
+ * import { editFileTool } from 'morphsdk/tools/openai';
+ *
+ * const client = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
+ *
+ * const response = await client.chat.completions.create({
+ *   model: "gpt-4o",
+ *   tools: [editFileTool],
+ *   messages: [{ role: "user", content: "Fix the bug in app.ts" }]
+ * });
+ * ```
+ */
+declare const editFileTool: ChatCompletionTool;
+/**
+ * Execute an edit_file tool call
+ *
+ * @param input - The tool input from GPT (parsed from tool_calls)
+ * @param config - Optional configuration
+ * @returns The result of the edit operation
+ *
+ * @example
+ * ```ts
+ * const args = JSON.parse(toolCall.function.arguments);
+ * const result = await execute(args);
+ * console.log('Changes applied:', result.udiff);
+ * ```
+ */
+declare function execute(input: EditFileInput, config?: EditFileConfig): Promise<EditFileResult>;
+/**
+ * Get the system prompt for edit_file usage
+ *
+ * Add this to your system message to guide GPT on using edit_file properly.
+ *
+ * @example
+ * ```ts
+ * const response = await client.chat.completions.create({
+ *   model: "gpt-4o",
+ *   messages: [
+ *     { role: "system", content: getSystemPrompt() },
+ *     { role: "user", content: "Fix bugs" }
+ *   ],
+ *   tools: [editFileTool]
+ * });
+ * ```
+ */
+declare function getSystemPrompt(): string;
+/**
+ * Format the result for passing back to GPT
+ *
+ * @param result - The edit result
+ * @returns Formatted string for tool message
+ */
+declare function formatResult(result: EditFileResult): string;
+/**
+ * Create a custom edit_file tool with configuration and methods
+ *
+ * @param config - Configuration options
+ * @returns Tool definition with execute and formatResult methods
+ *
+ * @example
+ * ```ts
+ * import OpenAI from 'openai';
+ * import { createEditFileTool } from 'morphsdk/tools/fastapply/openai';
+ *
+ * const tool = createEditFileTool({
+ *   baseDir: './src',
+ *   generateUdiff: true,
+ *   description: 'Custom tool description for your use case'
+ * });
+ *
+ * const client = new OpenAI();
+ *
+ * const response = await client.chat.completions.create({
+ *   model: 'gpt-4o',
+ *   tools: [tool], // tool itself is the ChatCompletionTool
+ *   messages: [{ role: 'user', content: 'Fix bug in app.ts' }]
+ * });
+ *
+ * // Execute and format
+ * const result = await tool.execute(toolCallArgs);
+ * const formatted = tool.formatResult(result);
+ * ```
+ */
+declare function createEditFileTool(config?: EditFileConfig): ChatCompletionTool & {
+    execute: (input: EditFileInput | string) => Promise<EditFileResult>;
+    formatResult: (result: EditFileResult) => string;
+    getSystemPrompt: () => string;
+};
+
+declare const openai_createEditFileTool: typeof createEditFileTool;
+declare const openai_editFileTool: typeof editFileTool;
+declare const openai_execute: typeof execute;
+declare const openai_formatResult: typeof formatResult;
+declare const openai_getSystemPrompt: typeof getSystemPrompt;
+declare namespace openai {
+  export { openai_createEditFileTool as createEditFileTool, editFileTool as default, openai_editFileTool as editFileTool, openai_execute as execute, openai_formatResult as formatResult, openai_getSystemPrompt as getSystemPrompt };
+}
+
+export { execute as a, createEditFileTool as c, editFileTool as e, formatResult as f, getSystemPrompt as g, openai as o };

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

@@ -0,0 +1,51 @@
+import { Tool } from '@anthropic-ai/sdk/resources/messages.mjs';
+import { BrowserConfig, BrowserTaskInput, BrowserTaskResult } from './types.js';
+import '../utils/resilience.js';
+
+/**
+ * Anthropic SDK adapter for browser automation tool
+ */
+
+/**
+ * Anthropic tool definition for browser automation
+ */
+declare const browserTool: Tool;
+/**
+ * Create a configured browser tool with execute and formatResult methods
+ *
+ * @param config - Browser worker configuration
+ * @returns Tool definition with execute and formatResult methods
+ *
+ * @example
+ * ```typescript
+ * import Anthropic from '@anthropic-ai/sdk';
+ * import { createBrowserTool } from 'morphsdk/tools/browser/anthropic';
+ *
+ * const tool = createBrowserTool({
+ *   apiKey: process.env.MORPH_API_KEY,
+ *   timeout: 180000
+ * });
+ *
+ * const client = new Anthropic();
+ *
+ * const response = await client.messages.create({
+ *   model: 'claude-sonnet-4-5-20250929',
+ *   tools: [tool], // tool itself is the Tool definition
+ *   messages: [{
+ *     role: 'user',
+ *     content: 'Test the checkout flow at https://3000-abc.e2b.dev'
+ *   }]
+ * });
+ *
+ * // Execute and format
+ * const result = await tool.execute(toolUseBlock.input);
+ * const formatted = tool.formatResult(result);
+ * ```
+ */
+declare function createBrowserTool(config?: BrowserConfig): Tool & {
+    execute: (input: BrowserTaskInput) => Promise<BrowserTaskResult>;
+    formatResult: (result: BrowserTaskResult) => string;
+    getSystemPrompt: () => string;
+};
+
+export { browserTool, createBrowserTool };

package/dist/tools/browser/anthropic.js

@@ -4,7 +4,8 @@ import {
 } from "../../chunk-EI4UKP24.js";
 import {
   executeBrowserTask
-} from "../../chunk-NCVWIW7L.js";
+} from "../../chunk-EYHXBQQX.js";
+import "../../chunk-SQN4DUQS.js";
 import "../../chunk-4VWJFZVS.js";
 import "../../chunk-PZ5AY32C.js";
 

package/dist/tools/browser/anthropic.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../tools/browser/anthropic.ts"],"sourcesContent":["/**\n * Anthropic SDK adapter for browser automation tool\n */\n\nimport type { Tool } from '@anthropic-ai/sdk/resources/messages.mjs';\nimport { executeBrowserTask } from './core.js';\nimport type {\n  BrowserConfig,\n  BrowserTaskInput,\n  BrowserTaskResult,\n} from './types.js';\nimport { BROWSER_TOOL_DESCRIPTION, BROWSER_SYSTEM_PROMPT } from './prompts.js';\n\n/**\n * Anthropic tool definition for browser automation\n */\nexport const browserTool: Tool = {\n  name: 'browser_task',\n  description: BROWSER_TOOL_DESCRIPTION,\n  input_schema: {\n    type: 'object',\n    properties: {\n      task: {\n        type: 'string',\n        description: 'Natural language description of what to do (e.g., \"Test checkout flow for buying a pineapple\")',\n      },\n      url: {\n        type: 'string',\n        description: 'Starting URL (e.g., https://3000-xyz.e2b.dev). Required if navigating to a specific page.',\n      },\n      max_steps: {\n        type: 'number',\n        description: 'Maximum number of browser actions to take (1-50). Default: 10. Use 15-30 for complex flows.',\n        default: 10,\n      },\n      region: {\n        type: 'string',\n        enum: ['sfo', 'lon'],\n        description: 'Browserless region: sfo (US West Coast) or lon (Europe). Default: sfo.',\n        default: 'sfo',\n      },\n    },\n    required: ['task'],\n  },\n};\n\n/**\n * Format browser task result for Anthropic tool result\n * \n * Returns a concise summary suitable for agent context. The full result object\n * (with urls, errors, action_history, judgement, etc.) is available when calling\n * execute() directly, but this formatted string omits those details to save tokens.\n * \n * @param result - Browser task result with full history data\n * @returns Formatted string summary for tool result\n */\nfunction formatResult(result: BrowserTaskResult): string {\n  if (result.success) {\n    const parts = [\n      '✅ Browser task completed successfully',\n      `Steps taken: ${result.steps_taken ?? 0}`,\n      result.execution_time_ms ? `Execution time: ${result.execution_time_ms}ms` : null,\n      '',\n      'Result:',\n      result.result || 'Task completed',\n    ];\n    return parts.filter(Boolean).join('\\n');\n  }\n\n  return `❌ Browser task failed: ${result.error || 'Unknown error'}`;\n}\n\n/**\n * Create a configured browser tool with execute and formatResult methods\n * \n * @param config - Browser worker configuration\n * @returns Tool definition with execute and formatResult methods\n * \n * @example\n * ```typescript\n * import Anthropic from '@anthropic-ai/sdk';\n * import { createBrowserTool } from 'morphsdk/tools/browser/anthropic';\n * \n * const tool = createBrowserTool({\n *   apiKey: process.env.MORPH_API_KEY,\n *   timeout: 180000\n * });\n * \n * const client = new Anthropic();\n * \n * const response = await client.messages.create({\n *   model: 'claude-sonnet-4-5-20250929',\n *   tools: [tool], // tool itself is the Tool definition\n *   messages: [{\n *     role: 'user',\n *     content: 'Test the checkout flow at https://3000-abc.e2b.dev'\n *   }]\n * });\n * \n * // Execute and format\n * const result = await tool.execute(toolUseBlock.input);\n * const formatted = tool.formatResult(result);\n * ```\n */\nexport function createBrowserTool(config?: BrowserConfig) {\n  return Object.assign({}, browserTool, {\n    execute: async (input: BrowserTaskInput): Promise<BrowserTaskResult> => {\n      return executeBrowserTask(input, config);\n    },\n    formatResult: (result: BrowserTaskResult): string => {\n      return formatResult(result);\n    },\n    getSystemPrompt: (): string => {\n      return BROWSER_SYSTEM_PROMPT;\n    },\n  });\n}\n\n"],"mappings":";;;;;;;;;;;AAgBO,IAAM,cAAoB;AAAA,EAC/B,MAAM;AAAA,EACN,aAAa;AAAA,EACb,cAAc;AAAA,IACZ,MAAM;AAAA,IACN,YAAY;AAAA,MACV,MAAM;AAAA,QACJ,MAAM;AAAA,QACN,aAAa;AAAA,MACf;AAAA,MACA,KAAK;AAAA,QACH,MAAM;AAAA,QACN,aAAa;AAAA,MACf;AAAA,MACA,WAAW;AAAA,QACT,MAAM;AAAA,QACN,aAAa;AAAA,QACb,SAAS;AAAA,MACX;AAAA,MACA,QAAQ;AAAA,QACN,MAAM;AAAA,QACN,MAAM,CAAC,OAAO,KAAK;AAAA,QACnB,aAAa;AAAA,QACb,SAAS;AAAA,MACX;AAAA,IACF;AAAA,IACA,UAAU,CAAC,MAAM;AAAA,EACnB;AACF;AAYA,SAAS,aAAa,QAAmC;AACvD,MAAI,OAAO,SAAS;AAClB,UAAM,QAAQ;AAAA,MACZ;AAAA,MACA,gBAAgB,OAAO,eAAe,CAAC;AAAA,MACvC,OAAO,oBAAoB,mBAAmB,OAAO,iBAAiB,OAAO;AAAA,MAC7E;AAAA,MACA;AAAA,MACA,OAAO,UAAU;AAAA,IACnB;AACA,WAAO,MAAM,OAAO,OAAO,EAAE,KAAK,IAAI;AAAA,EACxC;AAEA,SAAO,+BAA0B,OAAO,SAAS,eAAe;AAClE;AAkCO,SAAS,kBAAkB,QAAwB;AACxD,SAAO,OAAO,OAAO,CAAC,GAAG,aAAa;AAAA,IACpC,SAAS,OAAO,UAAwD;AACtE,aAAO,mBAAmB,OAAO,MAAM;AAAA,IACzC;AAAA,IACA,cAAc,CAAC,WAAsC;AACnD,aAAO,aAAa,MAAM;AAAA,IAC5B;AAAA,IACA,iBAAiB,MAAc;AAC7B,aAAO;AAAA,IACT;AAAA,EACF,CAAC;AACH;","names":[]}
+{"version":3,"sources":["../../../tools/browser/anthropic.ts"],"sourcesContent":["/**\n * Anthropic SDK adapter for browser automation tool\n */\n\nimport type { Tool } from '@anthropic-ai/sdk/resources/messages.mjs';\nimport { executeBrowserTask } from './core.js';\nimport type {\n  BrowserConfig,\n  BrowserTaskInput,\n  BrowserTaskResult,\n} from './types.js';\nimport { BROWSER_TOOL_DESCRIPTION, BROWSER_SYSTEM_PROMPT } from './prompts.js';\n\n/**\n * Anthropic tool definition for browser automation\n */\nexport const browserTool: Tool = {\n  name: 'browser_task',\n  description: BROWSER_TOOL_DESCRIPTION,\n  input_schema: {\n    type: 'object',\n    properties: {\n      task: {\n        type: 'string',\n        description: 'Natural language description of what to do (e.g., \"Test checkout flow for buying a pineapple\")',\n      },\n      url: {\n        type: 'string',\n        description: 'Starting URL (e.g., https://3000-xyz.e2b.dev). Required if navigating to a specific page.',\n      },\n      max_steps: {\n        type: 'number',\n        description: 'Maximum number of browser actions to take (1-50). Default: 10. Use 15-30 for complex flows.',\n        default: 10,\n      },\n      region: {\n        type: 'string',\n        enum: ['sfo', 'lon'],\n        description: 'Browserless region: sfo (US West Coast) or lon (Europe). Default: sfo.',\n        default: 'sfo',\n      },\n    },\n    required: ['task'],\n  },\n};\n\n/**\n * Format browser task result for Anthropic tool result\n * \n * Returns a concise summary suitable for agent context. The full result object\n * (with urls, errors, action_history, judgement, etc.) is available when calling\n * execute() directly, but this formatted string omits those details to save tokens.\n * \n * @param result - Browser task result with full history data\n * @returns Formatted string summary for tool result\n */\nfunction formatResult(result: BrowserTaskResult): string {\n  if (result.success) {\n    const parts = [\n      '✅ Browser task completed successfully',\n      `Steps taken: ${result.steps_taken ?? 0}`,\n      result.execution_time_ms ? `Execution time: ${result.execution_time_ms}ms` : null,\n      '',\n      'Result:',\n      result.result || 'Task completed',\n    ];\n    return parts.filter(Boolean).join('\\n');\n  }\n\n  return `❌ Browser task failed: ${result.error || 'Unknown error'}`;\n}\n\n/**\n * Create a configured browser tool with execute and formatResult methods\n * \n * @param config - Browser worker configuration\n * @returns Tool definition with execute and formatResult methods\n * \n * @example\n * ```typescript\n * import Anthropic from '@anthropic-ai/sdk';\n * import { createBrowserTool } from 'morphsdk/tools/browser/anthropic';\n * \n * const tool = createBrowserTool({\n *   apiKey: process.env.MORPH_API_KEY,\n *   timeout: 180000\n * });\n * \n * const client = new Anthropic();\n * \n * const response = await client.messages.create({\n *   model: 'claude-sonnet-4-5-20250929',\n *   tools: [tool], // tool itself is the Tool definition\n *   messages: [{\n *     role: 'user',\n *     content: 'Test the checkout flow at https://3000-abc.e2b.dev'\n *   }]\n * });\n * \n * // Execute and format\n * const result = await tool.execute(toolUseBlock.input);\n * const formatted = tool.formatResult(result);\n * ```\n */\nexport function createBrowserTool(config?: BrowserConfig) {\n  return Object.assign({}, browserTool, {\n    execute: async (input: BrowserTaskInput): Promise<BrowserTaskResult> => {\n      return executeBrowserTask(input, config);\n    },\n    formatResult: (result: BrowserTaskResult): string => {\n      return formatResult(result);\n    },\n    getSystemPrompt: (): string => {\n      return BROWSER_SYSTEM_PROMPT;\n    },\n  });\n}\n\n"],"mappings":";;;;;;;;;;;;AAgBO,IAAM,cAAoB;AAAA,EAC/B,MAAM;AAAA,EACN,aAAa;AAAA,EACb,cAAc;AAAA,IACZ,MAAM;AAAA,IACN,YAAY;AAAA,MACV,MAAM;AAAA,QACJ,MAAM;AAAA,QACN,aAAa;AAAA,MACf;AAAA,MACA,KAAK;AAAA,QACH,MAAM;AAAA,QACN,aAAa;AAAA,MACf;AAAA,MACA,WAAW;AAAA,QACT,MAAM;AAAA,QACN,aAAa;AAAA,QACb,SAAS;AAAA,MACX;AAAA,MACA,QAAQ;AAAA,QACN,MAAM;AAAA,QACN,MAAM,CAAC,OAAO,KAAK;AAAA,QACnB,aAAa;AAAA,QACb,SAAS;AAAA,MACX;AAAA,IACF;AAAA,IACA,UAAU,CAAC,MAAM;AAAA,EACnB;AACF;AAYA,SAAS,aAAa,QAAmC;AACvD,MAAI,OAAO,SAAS;AAClB,UAAM,QAAQ;AAAA,MACZ;AAAA,MACA,gBAAgB,OAAO,eAAe,CAAC;AAAA,MACvC,OAAO,oBAAoB,mBAAmB,OAAO,iBAAiB,OAAO;AAAA,MAC7E;AAAA,MACA;AAAA,MACA,OAAO,UAAU;AAAA,IACnB;AACA,WAAO,MAAM,OAAO,OAAO,EAAE,KAAK,IAAI;AAAA,EACxC;AAEA,SAAO,+BAA0B,OAAO,SAAS,eAAe;AAClE;AAkCO,SAAS,kBAAkB,QAAwB;AACxD,SAAO,OAAO,OAAO,CAAC,GAAG,aAAa;AAAA,IACpC,SAAS,OAAO,UAAwD;AACtE,aAAO,mBAAmB,OAAO,MAAM;AAAA,IACzC;AAAA,IACA,cAAc,CAAC,WAAsC;AACnD,aAAO,aAAa,MAAM;AAAA,IAC5B;AAAA,IACA,iBAAiB,MAAc;AAC7B,aAAO;AAAA,IACT;AAAA,EACF,CAAC;AACH;","names":[]}

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

@@ -0,0 +1,203 @@
+import { BrowserConfig, BrowserTaskInput, BrowserTaskResult, BrowserTaskWithPromise, BrowserTaskInputWithSchema, BrowserTaskWithPromiseAndSchema, RecordingStatus, ErrorsResponse } from './types.js';
+import '../utils/resilience.js';
+
+/**
+ * Core implementation for browser automation tasks
+ */
+
+/**
+ * BrowserClient class for easier usage with instance configuration
+ */
+declare class BrowserClient {
+    private config;
+    constructor(config?: BrowserConfig);
+    /**
+     * Execute a browser automation task
+     */
+    execute(input: BrowserTaskInput): Promise<BrowserTaskResult>;
+    createTask(input: BrowserTaskInput): Promise<BrowserTaskWithPromise>;
+    createTask<T>(input: BrowserTaskInputWithSchema<T>): Promise<BrowserTaskWithPromiseAndSchema<T>>;
+    /**
+     * Execute task with recording and wait for video to be ready
+     */
+    executeWithRecording(input: BrowserTaskInput & {
+        record_video: true;
+    }): Promise<BrowserTaskResult & {
+        recording?: RecordingStatus;
+    }>;
+    /**
+     * Get recording status and URLs
+     */
+    getRecording(recordingId: string): Promise<RecordingStatus>;
+    /**
+     * Wait for recording to complete with automatic polling
+     */
+    waitForRecording(recordingId: string, options?: {
+        timeout?: number;
+        pollInterval?: number;
+    }): Promise<RecordingStatus>;
+    /**
+     * Get errors from recording with screenshots
+     */
+    getErrors(recordingId: string): Promise<ErrorsResponse>;
+    /**
+     * Check if browser worker service is healthy
+     */
+    checkHealth(): Promise<{
+        ok: boolean;
+        google_configured: boolean;
+        database_configured: boolean;
+        s3_configured: boolean;
+        error?: string;
+    }>;
+}
+/**
+ * Execute a natural language browser automation task
+ *
+ * Returns the full task result including rich agent history data (urls, errors,
+ * action_history, judgement, etc.). When using this as an agent tool, use the
+ * formatResult() functions from the SDK adapters to return a concise summary.
+ *
+ * @param input - Task parameters
+ * @param config - Optional configuration (apiKey, apiUrl to override default)
+ * @returns Task result with success status, findings, and comprehensive execution history
+ *
+ * @example
+ * ```typescript
+ * const result = await executeBrowserTask(
+ *   {
+ *     task: "Test checkout flow for buying a pineapple",
+ *     url: "https://3000-abc.e2b.dev",
+ *     max_steps: 20,
+ *     repo_id: "my-project",
+ *     commit_id: "uuid-here"
+ *   },
+ *   {
+ *     apiKey: process.env.MORPH_API_KEY,
+ *     // apiUrl: 'http://localhost:8001' // Override for local testing
+ *   }
+ * );
+ *
+ * if (result.success) {
+ *   console.log('Task completed:', result.result);
+ *   console.log('URLs visited:', result.urls);
+ *   console.log('Actions taken:', result.action_names);
+ *   console.log('Has errors:', result.has_errors);
+ *   console.log('Replay:', result.replay_url);
+ * }
+ * ```
+ */
+declare function executeBrowserTask(input: BrowserTaskInput, config?: BrowserConfig): Promise<BrowserTaskResult>;
+/**
+ * Get recording status and video URL
+ *
+ * @param recordingId - Recording UUID from BrowserTaskResult
+ * @param config - Configuration with apiKey
+ * @returns Recording status with video URL when ready
+ *
+ * @example
+ * ```typescript
+ * const status = await getRecording('uuid-here', { apiKey: 'key' });
+ * if (status.status === 'COMPLETED' && status.video_url) {
+ *   console.log('Video ready:', status.video_url);
+ * }
+ * ```
+ */
+declare function getRecording(recordingId: string, config?: BrowserConfig): Promise<RecordingStatus>;
+/**
+ * Wait for recording to complete with automatic polling
+ *
+ * @param recordingId - Recording UUID
+ * @param config - Configuration with apiKey
+ * @param options - Polling options
+ * @returns Recording status when completed or errored
+ *
+ * @example
+ * ```typescript
+ * const result = await executeBrowserTask({ task: '...', record_video: true }, config);
+ * if (result.recording_id) {
+ *   const recording = await waitForRecording(result.recording_id, config, {
+ *     timeout: 60000,  // 1 minute
+ *     pollInterval: 2000  // Check every 2 seconds
+ *   });
+ *   console.log('Video URL:', recording.video_url);
+ * }
+ * ```
+ */
+declare function waitForRecording(recordingId: string, config?: BrowserConfig, options?: {
+    timeout?: number;
+    pollInterval?: number;
+}): Promise<RecordingStatus>;
+/**
+ * Execute task with recording and wait for video to be ready
+ *
+ * @param input - Task parameters with record_video=true
+ * @param config - Configuration with apiKey
+ * @returns Task result with ready video URL
+ *
+ * @example
+ * ```typescript
+ * const result = await executeWithRecording(
+ *   {
+ *     task: "Test checkout flow",
+ *     url: "https://example.com",
+ *     record_video: true,
+ *     repo_id: "my-project"
+ *   },
+ *   { apiKey: process.env.MORPH_API_KEY }
+ * );
+ *
+ * console.log('Task result:', result.result);
+ * console.log('Video URL:', result.recording?.video_url);
+ * ```
+ */
+declare function executeWithRecording(input: BrowserTaskInput & {
+    record_video: true;
+}, config?: BrowserConfig): Promise<BrowserTaskResult & {
+    recording?: RecordingStatus;
+}>;
+/**
+ * Get errors from recording with screenshots
+ *
+ * Screenshots are captured in real-time (500ms after error occurs) during the browser session.
+ *
+ * @param recordingId - Recording UUID from BrowserTaskResult
+ * @param config - Configuration with apiKey
+ * @returns Errors with real-time screenshots
+ *
+ * @example
+ * ```typescript
+ * const { errors, total_errors } = await getErrors('uuid-here', { apiKey: 'key' });
+ *
+ * console.log(`Found ${total_errors} errors`);
+ *
+ * errors.forEach(err => {
+ *   console.log(`[${err.type}] ${err.message}`);
+ *   if (err.url) console.log(`  URL: ${err.url}`);
+ *   if (err.screenshot_url) console.log(`  Screenshot: ${err.screenshot_url}`);
+ *
+ *   // Download screenshot
+ *   if (err.screenshot_url) {
+ *     const response = await fetch(err.screenshot_url);
+ *     const screenshot = await response.arrayBuffer();
+ *     // Save or process screenshot
+ *   }
+ * });
+ * ```
+ */
+declare function getErrors(recordingId: string, config?: BrowserConfig): Promise<ErrorsResponse>;
+/**
+ * Check if browser worker service is healthy
+ *
+ * @param config - Optional configuration
+ * @returns Health status
+ */
+declare function checkHealth(config?: BrowserConfig): Promise<{
+    ok: boolean;
+    google_configured: boolean;
+    database_configured: boolean;
+    s3_configured: boolean;
+    error?: string;
+}>;
+
+export { BrowserClient, checkHealth, executeBrowserTask, executeWithRecording, getErrors, getRecording, waitForRecording };

package/dist/tools/browser/core.js

@@ -6,7 +6,8 @@ import {
   getErrors,
   getRecording,
   waitForRecording
-} from "../../chunk-NCVWIW7L.js";
+} from "../../chunk-EYHXBQQX.js";
+import "../../chunk-SQN4DUQS.js";
 import "../../chunk-4VWJFZVS.js";
 import "../../chunk-PZ5AY32C.js";
 export {

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

@@ -0,0 +1,5 @@
+export { BrowserClient, checkHealth, executeBrowserTask, executeWithRecording, getErrors, getRecording, waitForRecording } from './core.js';
+export { BrowserConfig, BrowserError, BrowserModel, BrowserTaskInput, BrowserTaskInputWithSchema, BrowserTaskResult, BrowserTaskWithPromise, BrowserTaskWithPromiseAndSchema, ErrorsResponse, IframeOptions, LiveSessionOptions, RecordingStatus } from './types.js';
+export { BROWSER_SYSTEM_PROMPT, BROWSER_TOOL_DESCRIPTION } from './prompts.js';
+export { LIVE_PRESETS, buildEmbedCode, buildLiveIframe, buildLiveUrl } from './live.js';
+import '../utils/resilience.js';

package/dist/tools/browser/index.js

@@ -4,17 +4,19 @@ import {
 } from "../../chunk-EI4UKP24.js";
 import {
   BrowserClient,
-  LIVE_PRESETS,
-  buildEmbedCode,
-  buildLiveIframe,
-  buildLiveUrl,
   checkHealth,
   executeBrowserTask,
   executeWithRecording,
   getErrors,
   getRecording,
   waitForRecording
-} from "../../chunk-NCVWIW7L.js";
+} from "../../chunk-EYHXBQQX.js";
+import {
+  LIVE_PRESETS,
+  buildEmbedCode,
+  buildLiveIframe,
+  buildLiveUrl
+} from "../../chunk-SQN4DUQS.js";
 import "../../chunk-4VWJFZVS.js";
 import "../../chunk-PZ5AY32C.js";
 export {

package/dist/tools/browser/live.cjs

@@ -0,0 +1,112 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// tools/browser/live.ts
+var live_exports = {};
+__export(live_exports, {
+  LIVE_PRESETS: () => LIVE_PRESETS,
+  buildEmbedCode: () => buildEmbedCode,
+  buildLiveIframe: () => buildLiveIframe,
+  buildLiveUrl: () => buildLiveUrl,
+  resolvePreset: () => resolvePreset
+});
+module.exports = __toCommonJS(live_exports);
+var LIVE_PRESETS = {
+  /** Read-only monitoring (no interaction) */
+  readonly: { interactive: false },
+  /** Interactive control (human-in-the-loop) */
+  interactive: { interactive: true },
+  /** Watch-only without controls */
+  monitoring: { interactive: false, showControls: false }
+};
+function buildLiveUrl(debugUrl, options = {}) {
+  if (!debugUrl) {
+    throw new Error(
+      "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);
+  if (options.interactive !== void 0) {
+    url.searchParams.set("interactive", String(options.interactive));
+  }
+  if (options.theme) {
+    url.searchParams.set("theme", options.theme);
+  }
+  if (options.showControls !== void 0) {
+    url.searchParams.set("showControls", String(options.showControls));
+  }
+  if (options.pageId) {
+    url.searchParams.set("pageId", options.pageId);
+  }
+  if (options.pageIndex) {
+    url.searchParams.set("pageIndex", options.pageIndex);
+  }
+  return url.toString();
+}
+function buildLiveIframe(debugUrl, options = {}) {
+  const {
+    width = "100%",
+    height = "600px",
+    style = "",
+    className = "",
+    ...sessionOptions
+  } = options;
+  const src = buildLiveUrl(debugUrl, sessionOptions);
+  const widthStr = typeof width === "number" ? `${width}px` : width;
+  const heightStr = typeof height === "number" ? `${height}px` : height;
+  const baseStyle = `width: ${widthStr}; height: ${heightStr}; border: none;`;
+  const fullStyle = style ? `${baseStyle} ${style}` : baseStyle;
+  const attributes = [
+    `src="${src}"`,
+    `style="${fullStyle}"`
+  ];
+  if (className) {
+    attributes.push(`class="${className}"`);
+  }
+  return `<iframe ${attributes.join(" ")}></iframe>`;
+}
+function buildEmbedCode(debugUrl, options = {}) {
+  const iframe = buildLiveIframe(debugUrl, options);
+  return `<!-- Embed Morph Live Session -->
+${iframe}`;
+}
+function resolvePreset(optionsOrPreset) {
+  if (!optionsOrPreset) {
+    return {};
+  }
+  if (typeof optionsOrPreset === "string") {
+    const preset = LIVE_PRESETS[optionsOrPreset];
+    if (!preset) {
+      throw new Error(
+        `Unknown preset: ${optionsOrPreset}. Available presets: ${Object.keys(LIVE_PRESETS).join(", ")}`
+      );
+    }
+    return preset;
+  }
+  return optionsOrPreset;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LIVE_PRESETS,
+  buildEmbedCode,
+  buildLiveIframe,
+  buildLiveUrl,
+  resolvePreset
+});
+//# sourceMappingURL=live.cjs.map