@morphllm/morphsdk 0.2.20 → 0.2.22

package/dist/git/index.d.ts

@@ -1,5 +0,0 @@
-export { MorphGit } from './client.js';
-export { AddOptions, BranchOptions, CheckoutOptions, CloneOptions, CommitObject, CommitOptions, DiffOptions, LogOptions, MorphGitConfig, PullOptions, PushOptions, StatusOptions, StatusResult } from './types.js';
-export { default as git } from 'isomorphic-git';
-export { default as http } from 'isomorphic-git/http/node';
-import '../tools/utils/resilience.js';

package/dist/git/types.d.ts

@@ -1,91 +0,0 @@
-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 CommitOptions {
-    dir: string;
-    message: string;
-    author?: {
-        name: string | "Morph AI Agent";
-        email: string | "ai@morphllm.com";
-    };
-}
-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, CheckoutOptions, CloneOptions, CommitObject, CommitOptions, DiffOptions, GitUser, LogOptions, MorphGitConfig, PullOptions, PushOptions, StatusOptions, StatusResult };

package/dist/index.d.ts

@@ -1,14 +0,0 @@
-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/modelrouter/core.d.ts

@@ -1,56 +0,0 @@
-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

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

package/dist/modelrouter/types.d.ts

@@ -1,35 +0,0 @@
-/**
- * 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

@@ -1,111 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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

@@ -1,196 +0,0 @@
-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
- *
- * @param input - Task parameters
- * @param config - Optional configuration (apiKey, apiUrl to override default)
- * @returns Task result with success status and findings
- *
- * @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('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

@@ -1,72 +0,0 @@
-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 };