@morphllm/morphsdk 0.2.21 → 0.2.23

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 };

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

@@ -1,69 +0,0 @@
-import { ChatCompletionTool } from 'openai/resources/chat/completions.mjs';
-import { BrowserTaskInput, BrowserConfig, BrowserTaskResult } from './types.js';
-import '../utils/resilience.js';
-
-/**
- * OpenAI SDK adapter for browser automation tool
- */
-
-/**
- * OpenAI tool definition for browser automation
- */
-declare const browserTool: ChatCompletionTool;
-/**
- * Execute a browser task (for use in tool call handling)
- *
- * @param input - Tool input parameters (may be JSON string)
- * @param config - Optional browser worker configuration
- * @returns Task execution result
- */
-declare function execute(input: BrowserTaskInput | string, config?: BrowserConfig): Promise<BrowserTaskResult>;
-/**
- * Format browser task result for OpenAI tool result
- *
- * @param result - Browser task result
- * @returns Formatted string for tool result
- */
-declare function formatResult(result: BrowserTaskResult): string;
-/**
- * Get system prompt for browser automation
- */
-declare function getSystemPrompt(): string;
-/**
- * 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 OpenAI from 'openai';
- * import { createBrowserTool } from 'morphsdk/tools/browser/openai';
- *
- * const tool = createBrowserTool({
- *   apiUrl: 'https://browser-worker.example.com'
- * });
- *
- * 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: 'Test the checkout at https://3000-abc.e2b.dev'
- *   }]
- * });
- *
- * // Execute and format
- * const result = await tool.execute(toolCallArgs);
- * const formatted = tool.formatResult(result);
- * ```
- */
-declare function createBrowserTool(config?: BrowserConfig): ChatCompletionTool & {
-    execute: (input: BrowserTaskInput | string) => Promise<BrowserTaskResult>;
-    formatResult: (result: BrowserTaskResult) => string;
-    getSystemPrompt: () => string;
-};
-
-export { browserTool, createBrowserTool, execute, formatResult, getSystemPrompt };

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

@@ -1,7 +0,0 @@
-/**
- * Tool descriptions and prompts for AI models
- */
-declare const BROWSER_TOOL_DESCRIPTION = "Execute natural language browser automation tasks using an AI-powered agent. The agent can navigate websites, interact with elements, fill forms, click buttons, and verify functionality.\n\nUse this tool to:\n- Test web applications end-to-end\n- Verify UI functionality\n- Automate user workflows\n- Extract information from web pages\n\nThe agent uses GPT-4o-mini to interpret your task and execute the necessary browser actions. It runs in a remote browser via Browserless.io, so it can access any publicly accessible URL.\n\nImportant:\n- Provide clear, specific task descriptions\n- Include the starting URL if navigating to a specific page\n- Use remote URLs (e.g., https://3000-xyz.e2b.dev) not localhost\n- Complex tasks may require more max_steps";
-declare const BROWSER_SYSTEM_PROMPT = "You have access to browser automation capabilities. When testing or interacting with web applications:\n\n1. Be specific about what you're testing or verifying\n2. Break complex tasks into clear steps\n3. Always provide the full URL including protocol (https://)\n4. For localhost apps, use the remote tunnel URL (e.g., e2b.dev URLs)\n5. Specify the number of steps needed - simple tasks use 5-10, complex flows use 15-30\n\nExample good tasks:\n- \"Go to https://3000-abc.e2b.dev and verify the landing page loads with a hero section\"\n- \"Test guest checkout: add a pineapple to cart, proceed to checkout, fill shipping info, and verify order summary\"\n- \"Navigate to the dashboard and click on the settings tab, then verify the API keys section is visible\"\n\nExample bad tasks:\n- \"test the app\" (too vague)\n- \"go to localhost:3000\" (use remote URL instead)\n- \"do everything\" (not specific enough)";
-
-export { BROWSER_SYSTEM_PROMPT, BROWSER_TOOL_DESCRIPTION };

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

@@ -1,227 +0,0 @@
-import { RetryConfig } from '../utils/resilience.js';
-
-/**
- * Type definitions for browser automation tool
- */
-
-/**
- * Available browser automation models
- */
-type BrowserModel = 'gemini-flash-latest' | 'morph-computer-use-v0';
-/**
- * Configuration for the browser worker service
- */
-interface BrowserConfig {
-    /** Browser worker API URL (default: https://browser.morphllm.com) */
-    apiUrl?: string;
-    /** Morph API key for authentication (required in production) */
-    apiKey?: string;
-    /** Request timeout in milliseconds (default: 120000) */
-    timeout?: number;
-    /** Retry configuration for API calls */
-    retryConfig?: RetryConfig;
-    /** Enable debug logging (default: false) */
-    debug?: boolean;
-}
-/**
- * Input parameters for browser automation task
- */
-interface BrowserTaskInput {
-    /** Natural language description of what to do */
-    task: string;
-    /** 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;
-    /** Model to use for task execution (default: morph-computer-use-v0) */
-    model?: BrowserModel;
-    /** Browserless region: 'sfo' (US West) or 'lon' (Europe) */
-    region?: 'sfo' | 'lon';
-    /** Enable stealth mode to avoid bot detection (default: true) */
-    stealth?: boolean;
-    /** Browser viewport width (default: 1280) */
-    viewport_width?: number;
-    /** Browser viewport height (default: 720) */
-    viewport_height?: 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;
-    /** Optional commit UUID to associate with this session */
-    commit_id?: string;
-    /** Record session video to S3 (default: false) */
-    record_video?: boolean;
-    /** Video width (default: 1280) */
-    video_width?: number;
-    /** Video height (default: 720) */
-    video_height?: number;
-    /** Serialized structured output schema (internal use) */
-    structured_output?: string;
-}
-/**
- * Input with Zod schema for structured output
- */
-interface BrowserTaskInputWithSchema<T> extends Omit<BrowserTaskInput, 'structured_output'> {
-    /** Zod schema for structured output */
-    schema: any;
-}
-/**
- * Result from executing a browser task
- */
-interface BrowserTaskResult {
-    /** Whether the task completed successfully */
-    success: boolean;
-    /** Task result or findings */
-    result?: string;
-    /** Error message if task failed */
-    error?: string;
-    /** Number of browser actions taken */
-    steps_taken?: number;
-    /** Total execution time in milliseconds */
-    execution_time_ms?: number;
-    /** UUID of saved replay record (if session replay enabled) */
-    replay_id?: string;
-    /** Browserless replay URL (if session replay enabled) */
-    replay_url?: string;
-    /** Recording ID (if record_video=true) */
-    recording_id?: string;
-    /** Recording status: PENDING, PROCESSING, COMPLETED, ERROR */
-    recording_status?: string;
-    /** Task ID for async task tracking */
-    task_id?: string;
-    /** Task status: pending, running, completed, failed */
-    status?: string;
-    /** Structured output (JSON string) */
-    output?: string;
-    /** Live session debug URL for real-time viewing (WebRTC streaming) */
-    debugUrl?: string;
-}
-/**
- * Configuration for live session viewing
- */
-interface LiveSessionOptions {
-    /** Enable or disable remote control (default: true for headful, varies for headless) */
-    interactive?: boolean;
-    /** UI theme: 'dark' or 'light' (headless only, default: 'dark') */
-    theme?: 'dark' | 'light';
-    /** Show or hide navigation controls (headless only, default: true) */
-    showControls?: boolean;
-    /** Focus view on specific page/tab ID (headless only) */
-    pageId?: string;
-    /** Display specific tab by index (headless only) */
-    pageIndex?: string;
-}
-/**
- * Configuration for iframe generation
- */
-interface IframeOptions extends LiveSessionOptions {
-    /** Iframe width (default: '100%') */
-    width?: string | number;
-    /** Iframe height (default: '600px') */
-    height?: string | number;
-    /** Additional inline styles */
-    style?: string;
-    /** CSS class name */
-    className?: string;
-}
-/**
- * Task result with convenience methods for async execution
- */
-interface BrowserTaskWithPromise extends BrowserTaskResult {
-    task_id: string;
-    /** Live URL to watch task execution in real-time */
-    liveUrl: string;
-    /** Wait for task completion */
-    complete: (pollConfig?: {
-        interval?: number;
-        timeout?: number;
-    }) => Promise<BrowserTaskResult>;
-    /** Get live session URL with optional parameters (Steel.dev) - throws if debugUrl not available */
-    getLiveUrl: (options?: LiveSessionOptions) => string;
-    /** Get iframe HTML for embedding live session - throws if debugUrl not available */
-    getLiveIframe: (optionsOrPreset?: string | IframeOptions) => string;
-    /** Get complete embed code snippet - throws if debugUrl not available */
-    getEmbedCode: () => string;
-}
-/**
- * Task result with schema validation
- */
-interface BrowserTaskWithPromiseAndSchema<T> extends BrowserTaskResult {
-    task_id: string;
-    /** Live URL to watch task execution in real-time */
-    liveUrl: string;
-    /** Parsed and validated output */
-    parsed: T | null;
-    /** Wait for task completion with schema validation */
-    complete: (pollConfig?: {
-        interval?: number;
-        timeout?: number;
-    }) => Promise<BrowserTaskResult & {
-        parsed: T | null;
-    }>;
-    /** Get live session URL with optional parameters - throws if debugUrl not available */
-    getLiveUrl: (options?: LiveSessionOptions) => string;
-    /** Get iframe HTML for embedding live session - throws if debugUrl not available */
-    getLiveIframe: (optionsOrPreset?: string | IframeOptions) => string;
-    /** Get complete embed code snippet - throws if debugUrl not available */
-    getEmbedCode: () => string;
-}
-/**
- * Recording status and metadata
- */
-interface RecordingStatus {
-    /** Recording ID */
-    id: string;
-    /** Current status */
-    status: 'PENDING' | 'PROCESSING' | 'COMPLETED' | 'ERROR';
-    /** Presigned S3 URL for rrweb replay JSON (interactive DOM replay) */
-    replay_url?: string;
-    /** Presigned S3 URL for network logs (NDJSON format) */
-    network_url?: string;
-    /** Presigned S3 URL for console logs (NDJSON format) */
-    console_url?: string;
-    /** Presigned S3 URL for native browser video (WebM or MP4 format, real-time recording) */
-    video_url?: string;
-    /** Total rrweb events captured */
-    total_events?: number;
-    /** Total bytes of all files */
-    file_size?: number;
-    /** Duration in milliseconds */
-    duration?: number;
-    /** Error message if status=ERROR */
-    error?: string;
-    /** When recording was created */
-    created_at: string;
-}
-/**
- * Browser error with screenshot captured at error time
- */
-interface BrowserError {
-    /** Error type: console error or network error */
-    type: 'console' | 'network';
-    /** Error message */
-    message: string;
-    /** URL where error occurred */
-    url?: string;
-    /** CDP timestamp in seconds since browser start */
-    timestamp: number;
-    /** Presigned S3 URL to screenshot JPEG (captured 500ms after error) */
-    screenshot_url?: string;
-    /** When screenshot was captured (Unix timestamp) */
-    captured_at?: number;
-    /** HTTP status code (for network errors) */
-    status?: number;
-}
-/**
- * Response from getErrors()
- */
-interface ErrorsResponse {
-    /** Recording ID */
-    recording_id: string;
-    /** Total number of errors */
-    total_errors: number;
-    /** Errors with real-time screenshots */
-    errors: BrowserError[];
-}
-
-export type { BrowserConfig, BrowserError, BrowserModel, BrowserTaskInput, BrowserTaskInputWithSchema, BrowserTaskResult, BrowserTaskWithPromise, BrowserTaskWithPromiseAndSchema, ErrorsResponse, IframeOptions, LiveSessionOptions, RecordingStatus };

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

@@ -1,69 +0,0 @@
-import * as ai from 'ai';
-import { BrowserConfig } from './types.js';
-import '../utils/resilience.js';
-
-/**
- * Create Vercel AI SDK tool for browser automation
- *
- * @param config - Optional browser worker configuration
- * @returns Vercel AI SDK tool
- *
- * @example
- * ```typescript
- * import { generateText } from 'ai';
- * import { anthropic } from '@ai-sdk/anthropic';
- * import { createBrowserTool } from 'morphsdk/tools/browser/vercel';
- *
- * const browserTool = createBrowserTool({
- *   apiUrl: 'https://browser-worker.example.com'
- * });
- *
- * const result = await generateText({
- *   model: anthropic('claude-sonnet-4-5-20250929'),
- *   tools: { browserTask: browserTool },
- *   prompt: 'Test the checkout flow at https://3000-abc.e2b.dev',
- *   maxSteps: 5
- * });
- * ```
- */
-declare function createBrowserTool(config?: BrowserConfig): ai.Tool<{
-    task: string;
-    max_steps: number;
-    region: "sfo" | "lon";
-    url?: string | undefined;
-}, {
-    success: boolean;
-    result: string | undefined;
-    steps_taken: number | undefined;
-    execution_time_ms: number | undefined;
-    error?: undefined;
-} | {
-    success: boolean;
-    error: string | undefined;
-    result?: undefined;
-    steps_taken?: undefined;
-    execution_time_ms?: undefined;
-}>;
-/**
- * Default browser tool for Vercel AI SDK
- */
-declare const browserTool: ai.Tool<{
-    task: string;
-    max_steps: number;
-    region: "sfo" | "lon";
-    url?: string | undefined;
-}, {
-    success: boolean;
-    result: string | undefined;
-    steps_taken: number | undefined;
-    execution_time_ms: number | undefined;
-    error?: undefined;
-} | {
-    success: boolean;
-    error: string | undefined;
-    result?: undefined;
-    steps_taken?: undefined;
-    execution_time_ms?: undefined;
-}>;
-
-export { browserTool, createBrowserTool };

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

@@ -1,40 +0,0 @@
-import { Tool } from '@anthropic-ai/sdk/resources/messages';
-import { CodebaseSearchConfig, CodebaseSearchInput, CodebaseSearchResult } from './types.js';
-import '../utils/resilience.js';
-
-/**
- * Anthropic SDK adapter for codebase_search tool
- */
-
-/**
- * Create Anthropic-native codebase_search tool with execute and formatResult methods
- *
- * @param config - Configuration with repoId
- * @returns Anthropic Tool definition with execute and formatResult methods
- *
- * @example
- * ```ts
- * import Anthropic from '@anthropic-ai/sdk';
- * import { createCodebaseSearchTool } from 'morphsdk/tools/anthropic';
- *
- * const client = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });
- * const tool = createCodebaseSearchTool({ repoId: 'my-project' });
- *
- * const response = await client.messages.create({
- *   model: "claude-sonnet-4-5-20250929",
- *   tools: [tool], // tool itself is the Tool definition
- *   messages: [{ role: "user", content: "Find authentication code" }]
- * });
- *
- * // Execute tool and format result
- * const result = await tool.execute(toolUseBlock.input);
- * const formatted = tool.formatResult(result);
- * ```
- */
-declare function createCodebaseSearchTool(config: CodebaseSearchConfig): Tool & {
-    execute: (input: CodebaseSearchInput) => Promise<CodebaseSearchResult>;
-    formatResult: (result: CodebaseSearchResult) => string;
-    getSystemPrompt: () => string;
-};
-
-export { createCodebaseSearchTool };