@morphllm/morphsdk 0.2.28 → 0.2.38

package/dist/git/types.d.ts

@@ -0,0 +1,102 @@
+import { RetryConfig } from '../tools/utils/resilience.js';
+
+/**
+ * Types for Morph Git SDK
+ */
+
+interface MorphGitConfig {
+    apiKey?: string;
+    proxyUrl?: string;
+    /** Retry configuration for API calls */
+    retryConfig?: RetryConfig;
+}
+interface CloneOptions {
+    repoId: string;
+    dir: string;
+    branch?: string;
+    depth?: number;
+    singleBranch?: boolean;
+}
+interface PushOptions {
+    dir: string;
+    remote?: string;
+    branch: string;
+}
+interface PullOptions {
+    dir: string;
+    remote?: string;
+    branch: string;
+}
+interface AddOptions {
+    dir: string;
+    filepath: string;
+}
+interface ChatMessage {
+    role: string;
+    content: string;
+    [key: string]: any;
+}
+interface CommitMetadata {
+    chatHistory?: ChatMessage[];
+    recordingId?: string;
+}
+interface CommitOptions {
+    dir: string;
+    message: string;
+    author?: {
+        name: string | "Morph AI Agent";
+        email: string | "ai@morphllm.com";
+    };
+    chatHistory?: ChatMessage[];
+    recordingId?: string;
+}
+interface StatusOptions {
+    dir: string;
+    filepath?: string;
+}
+interface LogOptions {
+    dir: string;
+    depth?: number;
+    ref?: string;
+}
+interface CheckoutOptions {
+    dir: string;
+    ref: string;
+}
+interface BranchOptions {
+    dir: string;
+    name: string;
+    checkout?: boolean;
+}
+interface DiffOptions {
+    dir: string;
+    ref1?: string;
+    ref2?: string;
+    filepath?: string;
+}
+interface GitUser {
+    name: string;
+    email: string;
+}
+interface CommitObject {
+    oid: string;
+    commit: {
+        message: string;
+        author: {
+            name: string | "Morph AI Agent";
+            email: string | "ai@morphllm.com";
+            timestamp: number;
+        };
+        committer: {
+            name: string | "Morph AI Agent";
+            email: string | "ai@morphllm.com";
+            timestamp: number;
+        };
+    };
+}
+interface StatusResult {
+    filepath: string;
+    status: 'unmodified' | 'modified' | '*modified' | 'added' | '*added' | 'deleted' | '*deleted' | 'absent';
+}
+
+export type { AddOptions, BranchOptions, ChatMessage, CheckoutOptions, CloneOptions, CommitMetadata, CommitObject, CommitOptions, DiffOptions, GitUser, LogOptions, MorphGitConfig, PullOptions, PushOptions, StatusOptions, StatusResult };

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+export { MorphClient, MorphClientConfig } from './client.js';
+export { FastApplyClient } from './tools/fastapply/core.js';
+export { CodebaseSearchClient } from './tools/codebase_search/core.js';
+export { BrowserClient } from './tools/browser/core.js';
+export { MorphGit } from './git/client.js';
+export { MorphGitConfig } from './git/types.js';
+export { AnthropicRouter, GeminiRouter, OpenAIRouter } from './modelrouter/core.js';
+export { EditFileConfig, EditFileInput, EditFileResult } from './tools/fastapply/types.js';
+export { CodebaseSearchConfig, CodebaseSearchInput, CodebaseSearchResult } from './tools/codebase_search/types.js';
+export { BrowserConfig, BrowserError, BrowserTaskInput, BrowserTaskInputWithSchema, BrowserTaskResult, BrowserTaskWithPromise, BrowserTaskWithPromiseAndSchema, ErrorsResponse, RecordingStatus } from './tools/browser/types.js';
+export { ComplexityLevel, Provider, RouterConfig, RouterInput, RouterMode, RouterResult } from './modelrouter/types.js';
+export { RetryConfig } from './tools/utils/resilience.js';
+import 'isomorphic-git';
+import 'isomorphic-git/http/node';

package/dist/index.js

@@ -1,15 +1,15 @@
 import {
   MorphClient
-} from "./chunk-CMKITT6X.js";
-import {
-  BrowserClient
-} from "./chunk-NCVWIW7L.js";
+} from "./chunk-DJSQUQGY.js";
 import {
   CodebaseSearchClient
 } from "./chunk-AG3ICTC5.js";
 import {
   FastApplyClient
 } from "./chunk-Q7USYY6R.js";
+import {
+  BrowserClient
+} from "./chunk-NCVWIW7L.js";
 import "./chunk-Q7PDN7TS.js";
 import {
   MorphGit

package/dist/modelrouter/core.d.ts

@@ -0,0 +1,56 @@
+import { RouterConfig, Provider, RouterInput, RouterResult } 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>;
+}
+
+export { AnthropicRouter, GeminiRouter, OpenAIRouter };

package/dist/modelrouter/index.d.ts

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

package/dist/modelrouter/types.d.ts

@@ -0,0 +1,35 @@
+/**
+ * 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;
+}
+
+export type { ComplexityLevel, Provider, 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/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/index.d.ts

@@ -0,0 +1,72 @@
+export { BrowserClient, checkHealth, executeBrowserTask, executeWithRecording, getErrors, getRecording, waitForRecording } from './core.js';
+import { LiveSessionOptions, IframeOptions } from './types.js';
+export { BrowserConfig, BrowserError, BrowserModel, BrowserTaskInput, BrowserTaskInputWithSchema, BrowserTaskResult, BrowserTaskWithPromise, BrowserTaskWithPromiseAndSchema, ErrorsResponse, RecordingStatus } from './types.js';
+export { BROWSER_SYSTEM_PROMPT, BROWSER_TOOL_DESCRIPTION } from './prompts.js';
+import '../utils/resilience.js';
+
+/**
+ * Live session utilities for Morph browser sessions
+ *
+ * Provides helpers for embedding and sharing live browser sessions with WebRTC streaming.
+ */
+
+/**
+ * Preset configurations for common use cases
+ */
+declare const LIVE_PRESETS: {
+    /** Read-only monitoring (no interaction) */
+    readonly readonly: LiveSessionOptions;
+    /** Interactive control (human-in-the-loop) */
+    readonly interactive: LiveSessionOptions;
+    /** Watch-only without controls */
+    readonly monitoring: LiveSessionOptions;
+};
+/**
+ * Build a live session URL with query parameters
+ *
+ * @param debugUrl - Live session debug URL (e.g., from task.debugUrl)
+ * @param options - Live session configuration options
+ * @returns URL with query parameters for iframe embedding
+ *
+ * @example
+ * ```typescript
+ * const url = buildLiveUrl(task.debugUrl, { interactive: true });
+ * // Returns: https://example.com/sessions/abc?interactive=true
+ * ```
+ */
+declare function buildLiveUrl(debugUrl: string, options?: LiveSessionOptions): string;
+/**
+ * Build iframe HTML for embedding a live session
+ *
+ * @param debugUrl - Live session debug URL
+ * @param options - Iframe configuration including dimensions and session options
+ * @returns HTML iframe element as string
+ *
+ * @example
+ * ```typescript
+ * const iframe = buildLiveIframe(task.debugUrl, {
+ *   interactive: true,
+ *   width: '100%',
+ *   height: '600px'
+ * });
+ * ```
+ */
+declare function buildLiveIframe(debugUrl: string, options?: IframeOptions): string;
+/**
+ * Build complete embed code with HTML snippet
+ *
+ * @param debugUrl - Live session debug URL
+ * @param options - Iframe configuration
+ * @returns Multi-line HTML snippet ready to copy-paste
+ *
+ * @example
+ * ```typescript
+ * const code = buildEmbedCode(task.debugUrl, { interactive: false });
+ * console.log(code);
+ * // <!-- Embed Morph Live Session -->
+ * // <iframe src="..." style="..."></iframe>
+ * ```
+ */
+declare function buildEmbedCode(debugUrl: string, options?: IframeOptions): string;
+
+export { IframeOptions, LIVE_PRESETS, LiveSessionOptions, buildEmbedCode, buildLiveIframe, buildLiveUrl };