@morphllm/morphsdk 0.2.6

package/dist/client.cjs

@@ -0,0 +1,1358 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// client.ts
+var client_exports = {};
+__export(client_exports, {
+  MorphClient: () => MorphClient
+});
+module.exports = __toCommonJS(client_exports);
+
+// tools/fastapply/core.ts
+var import_promises = require("fs/promises");
+var import_path = require("path");
+var import_diff = require("diff");
+
+// tools/utils/resilience.ts
+var DEFAULT_RETRY_CONFIG = {
+  maxRetries: 3,
+  initialDelay: 1e3,
+  maxDelay: 3e4,
+  backoffMultiplier: 2,
+  retryableErrors: ["ECONNREFUSED", "ETIMEDOUT", "ENOTFOUND"]
+};
+async function fetchWithRetry(url, options, retryConfig = {}) {
+  const {
+    maxRetries = DEFAULT_RETRY_CONFIG.maxRetries,
+    initialDelay = DEFAULT_RETRY_CONFIG.initialDelay,
+    maxDelay = DEFAULT_RETRY_CONFIG.maxDelay,
+    backoffMultiplier = DEFAULT_RETRY_CONFIG.backoffMultiplier,
+    retryableErrors = DEFAULT_RETRY_CONFIG.retryableErrors,
+    onRetry
+  } = retryConfig;
+  let lastError = null;
+  let delay = initialDelay;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      const response = await fetch(url, options);
+      if (response.status === 429 || response.status === 503) {
+        if (attempt < maxRetries) {
+          const retryAfter = response.headers.get("Retry-After");
+          const waitTime = retryAfter ? parseInt(retryAfter) * 1e3 : Math.min(delay, maxDelay);
+          const error = new Error(`HTTP ${response.status}: Retrying after ${waitTime}ms`);
+          if (onRetry) {
+            onRetry(attempt + 1, error);
+          }
+          await sleep(waitTime);
+          delay *= backoffMultiplier;
+          continue;
+        }
+      }
+      return response;
+    } catch (error) {
+      lastError = error;
+      const isRetryable = retryableErrors.some(
+        (errType) => lastError?.message?.includes(errType)
+      );
+      if (!isRetryable || attempt === maxRetries) {
+        throw lastError;
+      }
+      const waitTime = Math.min(delay, maxDelay);
+      if (onRetry) {
+        onRetry(attempt + 1, lastError);
+      }
+      await sleep(waitTime);
+      delay *= backoffMultiplier;
+    }
+  }
+  throw lastError || new Error("Max retries exceeded");
+}
+async function withTimeout(promise, timeoutMs, errorMessage) {
+  let timeoutId;
+  const timeoutPromise = new Promise((_, reject) => {
+    timeoutId = setTimeout(() => {
+      reject(new Error(errorMessage || `Operation timed out after ${timeoutMs}ms`));
+    }, timeoutMs);
+  });
+  try {
+    const result = await Promise.race([promise, timeoutPromise]);
+    clearTimeout(timeoutId);
+    return result;
+  } catch (error) {
+    clearTimeout(timeoutId);
+    throw error;
+  }
+}
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+
+// tools/fastapply/core.ts
+var DEFAULT_CONFIG = {
+  morphApiUrl: "https://api.morphllm.com",
+  baseDir: process.cwd(),
+  generateUdiff: true,
+  autoWrite: true,
+  timeout: 3e4,
+  debug: false
+};
+var FastApplyClient = class {
+  config;
+  constructor(config = {}) {
+    this.config = {
+      morphApiKey: config.apiKey,
+      morphApiUrl: DEFAULT_CONFIG.morphApiUrl,
+      debug: config.debug,
+      timeout: config.timeout || DEFAULT_CONFIG.timeout,
+      retryConfig: config.retryConfig,
+      generateUdiff: DEFAULT_CONFIG.generateUdiff,
+      autoWrite: DEFAULT_CONFIG.autoWrite
+    };
+  }
+  /**
+   * Execute a file edit operation
+   * 
+   * @param input - Edit parameters including filepath, instructions, and code_edit
+   * @param overrides - Optional config overrides for this operation
+   * @returns Edit result with success status and changes
+   */
+  async execute(input, overrides) {
+    return executeEditFile(input, { ...this.config, ...overrides });
+  }
+};
+function generateUdiff(original, modified, filepath) {
+  return (0, import_diff.createTwoFilesPatch)(
+    filepath,
+    filepath,
+    original,
+    modified,
+    "Original",
+    "Modified"
+  );
+}
+function countChanges(original, modified) {
+  const diff = generateUdiff(original, modified, "file");
+  const lines = diff.split("\n");
+  let linesAdded = 0;
+  let linesRemoved = 0;
+  for (const line of lines) {
+    if (line.startsWith("+") && !line.startsWith("+++")) {
+      linesAdded++;
+    } else if (line.startsWith("-") && !line.startsWith("---")) {
+      linesRemoved++;
+    }
+  }
+  const linesModified = Math.min(linesAdded, linesRemoved);
+  return {
+    linesAdded: linesAdded - linesModified,
+    linesRemoved: linesRemoved - linesModified,
+    linesModified
+  };
+}
+async function callMorphAPI(originalCode, codeEdit, instructions, filepath, config) {
+  const apiKey = config.morphApiKey || process.env.MORPH_API_KEY;
+  const apiUrl = config.morphApiUrl || DEFAULT_CONFIG.morphApiUrl;
+  const timeout = config.timeout || DEFAULT_CONFIG.timeout;
+  const debug = config.debug || false;
+  if (!apiKey) {
+    throw new Error(
+      "Morph API key not found. Set MORPH_API_KEY environment variable or pass morphApiKey in config."
+    );
+  }
+  const message = `<instruction>${instructions}</instruction>
+<code>${originalCode}</code>
+<update>${codeEdit}</update>`;
+  if (debug) {
+    console.log(`[FastApply] Calling ${apiUrl}/v1/chat/completions`);
+    console.log(`[FastApply] File: ${filepath}, Instructions: ${instructions.slice(0, 60)}...`);
+    console.log(`[FastApply] Original: ${originalCode.length} chars, Edit: ${codeEdit.length} chars`);
+  }
+  const startTime = Date.now();
+  const fetchPromise = fetchWithRetry(
+    `${apiUrl}/v1/chat/completions`,
+    {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${apiKey}`
+      },
+      body: JSON.stringify({
+        model: "morph-v3-fast",
+        messages: [{ role: "user", content: message }]
+      })
+    },
+    config.retryConfig
+  );
+  const response = await withTimeout(
+    fetchPromise,
+    timeout,
+    `Morph API request timed out after ${timeout}ms`
+  );
+  if (!response.ok) {
+    const error = await response.text();
+    if (debug) console.error(`[FastApply] API error: ${response.status} - ${error}`);
+    throw new Error(`Morph API error (${response.status}): ${error}`);
+  }
+  const data = await response.json();
+  const elapsed = Date.now() - startTime;
+  if (debug) {
+    console.log(`[FastApply] \u2705 Success in ${elapsed}ms, merged: ${data.choices[0].message.content.length} chars`);
+  }
+  return data.choices[0].message.content;
+}
+async function executeEditFile(input, config = {}) {
+  const baseDir = config.baseDir || DEFAULT_CONFIG.baseDir;
+  const fullPath = (0, import_path.resolve)((0, import_path.join)(baseDir, input.target_filepath));
+  const debug = config.debug || false;
+  const relativePath = (0, import_path.relative)(baseDir, fullPath);
+  if (relativePath.startsWith("..") || fullPath === baseDir) {
+    return {
+      success: false,
+      filepath: input.target_filepath,
+      changes: { linesAdded: 0, linesRemoved: 0, linesModified: 0 },
+      error: `Invalid filepath: '${input.target_filepath}' is outside baseDir`
+    };
+  }
+  try {
+    if (debug) console.log(`[FastApply] Reading file: ${input.target_filepath}`);
+    const originalCode = await (0, import_promises.readFile)(fullPath, "utf-8");
+    const mergedCode = await callMorphAPI(originalCode, input.code_edit, input.instructions, input.target_filepath, config);
+    const udiff = config.generateUdiff !== false ? generateUdiff(originalCode, mergedCode, input.target_filepath) : void 0;
+    if (config.autoWrite !== false) {
+      await (0, import_promises.writeFile)(fullPath, mergedCode, "utf-8");
+      if (debug) console.log(`[FastApply] Wrote ${mergedCode.length} chars to ${input.target_filepath}`);
+    }
+    const changes = countChanges(originalCode, mergedCode);
+    return {
+      success: true,
+      filepath: input.target_filepath,
+      udiff,
+      changes
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+    if (debug) console.error(`[FastApply] Error: ${errorMessage}`);
+    return {
+      success: false,
+      filepath: input.target_filepath,
+      changes: { linesAdded: 0, linesRemoved: 0, linesModified: 0 },
+      error: errorMessage
+    };
+  }
+}
+
+// tools/codebase_search/core.ts
+var CodebaseSearchClient = class {
+  config;
+  constructor(config = {}) {
+    this.config = {
+      apiKey: config.apiKey,
+      searchUrl: process.env.MORPH_SEARCH_URL || "http://embedrerank.morphllm.com:8081",
+      debug: config.debug,
+      timeout: config.timeout || 3e4,
+      retryConfig: config.retryConfig
+    };
+  }
+  /**
+   * Execute a semantic code search
+   * 
+   * @param input - Search parameters including query, repoId, and target directories
+   * @param overrides - Optional config overrides for this operation
+   * @returns Search results with ranked code matches
+   */
+  async search(input, overrides) {
+    return executeCodebaseSearch(
+      {
+        query: input.query,
+        target_directories: input.target_directories,
+        explanation: input.explanation,
+        limit: input.limit
+      },
+      { ...this.config, repoId: input.repoId, ...overrides }
+    );
+  }
+};
+async function executeCodebaseSearch(input, config) {
+  const apiKey = config.apiKey || process.env.MORPH_API_KEY;
+  if (!apiKey) {
+    throw new Error("MORPH_API_KEY not found. Set environment variable or pass in config");
+  }
+  const searchUrl = config.searchUrl || process.env.MORPH_SEARCH_URL || "http://embedrerank.morphllm.com:8081";
+  const timeout = config.timeout || 3e4;
+  const debug = config.debug || false;
+  if (debug) {
+    console.log(`[CodebaseSearch] Query: "${input.query.slice(0, 60)}..." repo=${config.repoId}`);
+    console.log(`[CodebaseSearch] URL: ${searchUrl}/v1/codebase_search`);
+  }
+  const startTime = Date.now();
+  try {
+    const fetchPromise = fetchWithRetry(
+      `${searchUrl}/v1/codebase_search`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Bearer ${apiKey}`
+        },
+        body: JSON.stringify({
+          query: input.query,
+          repoId: config.repoId,
+          targetDirectories: input.target_directories || [],
+          limit: input.limit || 10,
+          candidateLimit: 50
+        })
+      },
+      config.retryConfig
+    );
+    const response = await withTimeout(fetchPromise, timeout, `Codebase search timed out after ${timeout}ms`);
+    if (!response.ok) {
+      const errorText = await response.text();
+      if (debug) console.error(`[CodebaseSearch] Error: ${response.status} - ${errorText}`);
+      return {
+        success: false,
+        results: [],
+        stats: { totalResults: 0, candidatesRetrieved: 0, searchTimeMs: 0 },
+        error: `Search failed (${response.status}): ${errorText}`
+      };
+    }
+    const data = await response.json();
+    const elapsed = Date.now() - startTime;
+    if (debug) {
+      console.log(`[CodebaseSearch] \u2705 ${data.results?.length || 0} results in ${elapsed}ms`);
+    }
+    return {
+      success: true,
+      results: data.results || [],
+      stats: data.stats || { totalResults: 0, candidatesRetrieved: 0, searchTimeMs: elapsed }
+    };
+  } catch (error) {
+    if (debug) console.error(`[CodebaseSearch] Exception: ${error instanceof Error ? error.message : error}`);
+    return {
+      success: false,
+      results: [],
+      stats: { totalResults: 0, candidatesRetrieved: 0, searchTimeMs: 0 },
+      error: error instanceof Error ? error.message : "Unknown error"
+    };
+  }
+}
+
+// tools/browser/core.ts
+var DEFAULT_CONFIG2 = {
+  apiUrl: process.env.MORPH_ENVIRONMENT === "DEV" ? "http://localhost:8000" : "https://browser.morphllm.com",
+  timeout: 12e4,
+  // 2 minutes for complex tasks
+  debug: false
+};
+var BrowserClient = class {
+  config;
+  constructor(config = {}) {
+    this.config = {
+      ...DEFAULT_CONFIG2,
+      ...config
+    };
+  }
+  /**
+   * Execute a browser automation task
+   */
+  async execute(input) {
+    return executeBrowserTask(input, this.config);
+  }
+  async createTask(input) {
+    if ("schema" in input) {
+      const taskInput = {
+        ...input,
+        structured_output: stringifyStructuredOutput(input.schema)
+      };
+      const result = await executeBrowserTask(taskInput, this.config);
+      return wrapTaskResponseWithSchema(result, this.config, input.schema);
+    } else {
+      const result = await executeBrowserTask(input, this.config);
+      return wrapTaskResponse(result, this.config);
+    }
+  }
+  /**
+   * Execute task with recording and wait for video to be ready
+   */
+  async executeWithRecording(input) {
+    return executeWithRecording(input, this.config);
+  }
+  /**
+   * Get recording status and URLs
+   */
+  async getRecording(recordingId) {
+    return getRecording(recordingId, this.config);
+  }
+  /**
+   * Wait for recording to complete with automatic polling
+   */
+  async waitForRecording(recordingId, options) {
+    return waitForRecording(recordingId, this.config, options);
+  }
+  /**
+   * Get errors from recording with screenshots
+   */
+  async getErrors(recordingId) {
+    return getErrors(recordingId, this.config);
+  }
+  /**
+   * Check if browser worker service is healthy
+   */
+  async checkHealth() {
+    return checkHealth(this.config);
+  }
+};
+async function executeBrowserTask(input, config = {}) {
+  const apiUrl = config.apiUrl || DEFAULT_CONFIG2.apiUrl;
+  const timeout = config.timeout || DEFAULT_CONFIG2.timeout;
+  const debug = config.debug || false;
+  if (!input.task || input.task.trim().length === 0) {
+    return { success: false, error: "Task description is required" };
+  }
+  if (input.max_steps !== void 0 && (input.max_steps < 1 || input.max_steps > 50)) {
+    return { success: false, error: "max_steps must be between 1 and 50" };
+  }
+  if (debug) {
+    console.log(`[Browser] Task: "${input.task.slice(0, 60)}..." url=${input.url || "none"} maxSteps=${input.max_steps ?? 10}`);
+    console.log(`[Browser] Recording: ${input.record_video ? "yes" : "no"} | Calling ${apiUrl}/browser-task`);
+  }
+  const startTime = Date.now();
+  try {
+    const headers = { "Content-Type": "application/json" };
+    if (config.apiKey) headers["Authorization"] = `Bearer ${config.apiKey}`;
+    const fetchPromise = fetchWithRetry(
+      `${apiUrl}/browser-task`,
+      {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          task: input.task,
+          url: input.url,
+          max_steps: input.max_steps ?? 10,
+          model: input.model ?? "morph-computer-use-v0",
+          viewport_width: input.viewport_width ?? 1280,
+          viewport_height: input.viewport_height ?? 720,
+          repo_id: input.repo_id,
+          commit_id: input.commit_id,
+          record_video: input.record_video ?? false,
+          video_width: input.video_width ?? input.viewport_width ?? 1280,
+          video_height: input.video_height ?? input.viewport_height ?? 720,
+          structured_output: input.structured_output
+        })
+      },
+      config.retryConfig
+    );
+    const response = await withTimeout(
+      fetchPromise,
+      timeout,
+      `Browser task timed out after ${timeout}ms. Consider increasing timeout or reducing max_steps.`
+    );
+    if (!response.ok) {
+      const errorText = await response.text().catch(() => response.statusText);
+      if (debug) console.error(`[Browser] Error: ${response.status} - ${errorText}`);
+      throw new Error(`HTTP ${response.status}: ${errorText}`);
+    }
+    const result = await response.json();
+    const elapsed = Date.now() - startTime;
+    if (debug) {
+      console.log(`[Browser] \u2705 ${result.success ? "Success" : "Failed"} in ${elapsed}ms | steps=${result.steps_taken ?? 0} recordingId=${result.recording_id ?? "none"}`);
+    }
+    return result;
+  } catch (error) {
+    if (error instanceof Error) {
+      if (error.message.includes("ECONNREFUSED") || error.message.includes("fetch failed")) {
+        return {
+          success: false,
+          error: `Cannot connect to browser worker at ${apiUrl}. Ensure the service is running.`
+        };
+      }
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+    return {
+      success: false,
+      error: String(error)
+    };
+  }
+}
+async function getRecording(recordingId, config = {}) {
+  const apiUrl = config.apiUrl || DEFAULT_CONFIG2.apiUrl;
+  const debug = config.debug || false;
+  if (!config.apiKey) {
+    throw new Error("API key required for getRecording");
+  }
+  if (debug) console.log(`[Browser] getRecording: ${recordingId}`);
+  const response = await fetch(`${apiUrl}/recordings/${recordingId}`, {
+    method: "GET",
+    headers: { "Authorization": `Bearer ${config.apiKey}` }
+  });
+  if (!response.ok) {
+    const errorText = await response.text().catch(() => response.statusText);
+    if (debug) console.error(`[Browser] getRecording error: ${response.status} - ${errorText}`);
+    throw new Error(`HTTP ${response.status}: ${errorText}`);
+  }
+  const recording = await response.json();
+  if (debug) console.log(`[Browser] Recording status: ${recording.status}`);
+  return recording;
+}
+async function waitForRecording(recordingId, config = {}, options = {}) {
+  const timeout = options.timeout ?? 6e4;
+  const pollInterval = options.pollInterval ?? 2e3;
+  const startTime = Date.now();
+  while (Date.now() - startTime < timeout) {
+    const status = await getRecording(recordingId, config);
+    if (status.status === "COMPLETED" || status.status === "ERROR") {
+      return status;
+    }
+    await new Promise((resolve2) => setTimeout(resolve2, pollInterval));
+  }
+  throw new Error(`Recording timeout after ${timeout}ms - status still pending`);
+}
+async function executeWithRecording(input, config = {}) {
+  const taskResult = await executeBrowserTask(input, config);
+  if (taskResult.recording_id) {
+    try {
+      const recording = await waitForRecording(
+        taskResult.recording_id,
+        config,
+        { timeout: 6e4, pollInterval: 2e3 }
+      );
+      return {
+        ...taskResult,
+        recording
+      };
+    } catch (error) {
+      return {
+        ...taskResult,
+        recording: {
+          id: taskResult.recording_id,
+          status: "ERROR",
+          error: error instanceof Error ? error.message : String(error),
+          created_at: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      };
+    }
+  }
+  return taskResult;
+}
+async function getErrors(recordingId, config = {}) {
+  const apiUrl = config.apiUrl || DEFAULT_CONFIG2.apiUrl;
+  const debug = config.debug || false;
+  if (!config.apiKey) {
+    throw new Error("API key required for getErrors");
+  }
+  if (debug) console.log(`[Browser] getErrors: ${recordingId}`);
+  const response = await fetch(`${apiUrl}/recordings/${recordingId}/errors`, {
+    method: "GET",
+    headers: { "Authorization": `Bearer ${config.apiKey}` }
+  });
+  if (!response.ok) {
+    const errorText = await response.text().catch(() => response.statusText);
+    if (debug) console.error(`[Browser] getErrors error: ${response.status} - ${errorText}`);
+    throw new Error(`HTTP ${response.status}: ${errorText}`);
+  }
+  const errors = await response.json();
+  if (debug) console.log(`[Browser] Found ${errors.total_errors} errors`);
+  return errors;
+}
+function stringifyStructuredOutput(schema) {
+  try {
+    return JSON.stringify({
+      type: "object",
+      description: "Zod schema definition (Zod v3)",
+      zodDef: schema._def
+    });
+  } catch (error) {
+    console.warn("[Browser] Failed to serialize Zod schema:", error);
+    return JSON.stringify({
+      type: "object",
+      description: "Schema serialization failed"
+    });
+  }
+}
+function parseStructuredTaskOutput(result, schema) {
+  if (!result.output) {
+    return { ...result, parsed: null };
+  }
+  try {
+    const parsed = JSON.parse(result.output);
+    const validated = schema.parse(parsed);
+    return { ...result, parsed: validated };
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      return { ...result, parsed: null };
+    }
+    throw error;
+  }
+}
+async function getTaskStatus(taskId, config) {
+  const apiUrl = config.apiUrl || DEFAULT_CONFIG2.apiUrl;
+  const debug = config.debug || false;
+  if (debug) console.log(`[Browser] getTaskStatus: ${taskId}`);
+  const headers = {};
+  if (config.apiKey) headers["Authorization"] = `Bearer ${config.apiKey}`;
+  const response = await fetch(`${apiUrl}/tasks/${taskId}`, {
+    method: "GET",
+    headers
+  });
+  if (!response.ok) {
+    const errorText = await response.text().catch(() => response.statusText);
+    if (debug) console.error(`[Browser] getTaskStatus error: ${response.status} - ${errorText}`);
+    throw new Error(`HTTP ${response.status}: ${errorText}`);
+  }
+  const result = await response.json();
+  if (debug) console.log(`[Browser] Task status: ${result.status}`);
+  return result;
+}
+function generateLiveUrl(taskId, config) {
+  const apiUrl = config.apiUrl || DEFAULT_CONFIG2.apiUrl;
+  const baseUrl = apiUrl.replace("/api", "");
+  return `${baseUrl}/tasks/${taskId}/live`;
+}
+async function pollTaskUntilComplete(taskId, config, pollConfig = {}) {
+  const interval = pollConfig.interval ?? 2e3;
+  const timeout = pollConfig.timeout ?? 3e5;
+  const startTime = Date.now();
+  while (Date.now() - startTime < timeout) {
+    const status = await getTaskStatus(taskId, config);
+    if (status.status === "completed" || status.status === "failed") {
+      return status;
+    }
+    await new Promise((resolve2) => setTimeout(resolve2, interval));
+  }
+  throw new Error(`Task polling timeout after ${timeout}ms`);
+}
+function wrapTaskResponse(result, config) {
+  if (!result.task_id) {
+    throw new Error("task_id is required to wrap response");
+  }
+  return {
+    ...result,
+    task_id: result.task_id,
+    liveUrl: generateLiveUrl(result.task_id, config),
+    complete: async (pollConfig) => {
+      return pollTaskUntilComplete(result.task_id, config, pollConfig);
+    }
+  };
+}
+function wrapTaskResponseWithSchema(result, config, schema) {
+  if (!result.task_id) {
+    throw new Error("task_id is required to wrap response");
+  }
+  const parsed = result.output ? parseStructuredTaskOutput(result, schema) : { ...result, parsed: null };
+  return {
+    ...parsed,
+    task_id: result.task_id,
+    liveUrl: generateLiveUrl(result.task_id, config),
+    complete: async (pollConfig) => {
+      const finalResult = await pollTaskUntilComplete(result.task_id, config, pollConfig);
+      return parseStructuredTaskOutput(finalResult, schema);
+    }
+  };
+}
+async function checkHealth(config = {}) {
+  const apiUrl = config.apiUrl || DEFAULT_CONFIG2.apiUrl;
+  try {
+    const response = await fetch(`${apiUrl}/health`, {
+      method: "GET",
+      headers: config.apiKey ? { "Authorization": `Bearer ${config.apiKey}` } : {}
+    });
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}`);
+    }
+    const data = await response.json();
+    return {
+      ok: true,
+      google_configured: data.google_configured ?? false,
+      database_configured: data.database_configured ?? false,
+      s3_configured: data.s3_configured ?? false
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      google_configured: false,
+      database_configured: false,
+      s3_configured: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+
+// git/client.ts
+var import_isomorphic_git = __toESM(require("isomorphic-git"), 1);
+var import_node = __toESM(require("isomorphic-git/http/node"), 1);
+var import_fs = __toESM(require("fs"), 1);
+var DEFAULT_PROXY_URL = "https://repos.morphllm.com";
+var MorphGit = class {
+  apiKey;
+  proxyUrl;
+  constructor(config) {
+    if (!config.apiKey) {
+      throw new Error("API key is required. Get one at https://morphllm.com/dashboard");
+    }
+    if (!config.apiKey.startsWith("sk-") && !config.apiKey.startsWith("morph-")) {
+      throw new Error("Invalid API key format. Expected: sk-... or morph-...");
+    }
+    this.apiKey = config.apiKey;
+    this.proxyUrl = config.proxyUrl || DEFAULT_PROXY_URL;
+  }
+  /**
+   * Get auth callback for isomorphic-git operations
+   * @private
+   */
+  getAuthCallback() {
+    return () => ({
+      username: "morph",
+      password: this.apiKey
+    });
+  }
+  /**
+   * Initialize a new repository
+   * Creates the repo in the database and in the git provider
+   * 
+   * @example
+   * ```ts
+   * await morphGit.init({
+   *   repoId: 'my-project',
+   *   dir: './my-project',
+   *   defaultBranch: 'main'
+   * });
+   * ```
+   */
+  async init(options) {
+    const { repoId, dir, defaultBranch = "main" } = options;
+    const response = await fetch(`${this.proxyUrl}/v1/repos`, {
+      method: "POST",
+      headers: {
+        "Authorization": `Bearer ${this.apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        repoId,
+        name: repoId,
+        defaultBranch
+      })
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Failed to create repository: ${error}`);
+    }
+    await import_isomorphic_git.default.init({
+      fs: import_fs.default,
+      dir,
+      defaultBranch
+    });
+    await import_isomorphic_git.default.addRemote({
+      fs: import_fs.default,
+      dir,
+      remote: "origin",
+      url: `${this.proxyUrl}/v1/repos/${repoId}`
+    });
+    console.log(`\u2713 Repository '${repoId}' initialized`);
+  }
+  /**
+   * Clone a repository from Morph repos
+   * 
+   * @example
+   * ```ts
+   * await morphGit.clone({
+   *   repoId: 'my-project',
+   *   dir: './my-project'
+   * });
+   * ```
+   */
+  async clone(options) {
+    const { repoId, dir, branch = "main", depth, singleBranch = true } = options;
+    await import_isomorphic_git.default.clone({
+      fs: import_fs.default,
+      http: import_node.default,
+      dir,
+      corsProxy: this.proxyUrl,
+      url: `${this.proxyUrl}/v1/repos/${repoId}`,
+      ref: branch,
+      singleBranch,
+      depth,
+      onAuth: this.getAuthCallback()
+    });
+  }
+  /**
+   * Push changes to remote repository
+   * 
+   * @example
+   * ```ts
+   * await morphGit.push({ dir: './my-project' });
+   * ```
+   */
+  async push(options) {
+    const { dir, remote = "origin", branch } = options;
+    await import_isomorphic_git.default.push({
+      fs: import_fs.default,
+      http: import_node.default,
+      dir,
+      remote,
+      ref: branch,
+      onAuth: this.getAuthCallback()
+    });
+  }
+  /**
+   * Pull changes from remote repository
+   * 
+   * @example
+   * ```ts
+   * await morphGit.pull({ dir: './my-project' });
+   * ```
+   */
+  async pull(options) {
+    const { dir, remote = "origin", branch } = options;
+    await import_isomorphic_git.default.pull({
+      fs: import_fs.default,
+      http: import_node.default,
+      dir,
+      remote,
+      ref: branch,
+      onAuth: this.getAuthCallback(),
+      author: {
+        name: "Morph Agent",
+        email: "agent@morph.com"
+      }
+    });
+  }
+  /**
+   * Stage a file for commit
+   * 
+   * @example
+   * ```ts
+   * await morphGit.add({
+   *   dir: './my-project',
+   *   filepath: 'src/app.ts'
+   * });
+   * ```
+   */
+  async add(options) {
+    const { dir, filepath } = options;
+    await import_isomorphic_git.default.add({
+      fs: import_fs.default,
+      dir,
+      filepath
+    });
+  }
+  /**
+   * Remove a file from staging
+   * 
+   * @example
+   * ```ts
+   * await morphGit.remove({
+   *   dir: './my-project',
+   *   filepath: 'src/old-file.ts'
+   * });
+   * ```
+   */
+  async remove(options) {
+    const { dir, filepath } = options;
+    await import_isomorphic_git.default.remove({
+      fs: import_fs.default,
+      dir,
+      filepath
+    });
+  }
+  /**
+   * Commit staged changes
+   * 
+   * @example
+   * ```ts
+   * await morphGit.commit({
+   *   dir: './my-project',
+   *   message: 'Add new feature',
+   *   author: {
+   *     name: 'AI Agent',
+   *     email: 'ai@example.com'
+   *   }
+   * });
+   * ```
+   */
+  async commit(options) {
+    const { dir, message, author } = options;
+    const commitAuthor = author || {
+      name: "Morph SDK",
+      email: "sdk@morphllm.com"
+    };
+    const sha = await import_isomorphic_git.default.commit({
+      fs: import_fs.default,
+      dir,
+      message,
+      author: commitAuthor
+    });
+    return sha;
+  }
+  /**
+   * Get status of a file
+   * 
+   * @example
+   * ```ts
+   * const status = await morphGit.status({
+   *   dir: './my-project',
+   *   filepath: 'src/app.ts'
+   * });
+   * console.log(status); // 'modified', '*added', etc.
+   * ```
+   */
+  async status(options) {
+    const { dir, filepath } = options;
+    if (!filepath) {
+      throw new Error("filepath is required for status check");
+    }
+    const status = await import_isomorphic_git.default.status({
+      fs: import_fs.default,
+      dir,
+      filepath
+    });
+    return status;
+  }
+  /**
+   * Get commit history
+   * 
+   * @example
+   * ```ts
+   * const commits = await morphGit.log({
+   *   dir: './my-project',
+   *   depth: 10
+   * });
+   * ```
+   */
+  async log(options) {
+    const { dir, depth, ref } = options;
+    const commits = await import_isomorphic_git.default.log({
+      fs: import_fs.default,
+      dir,
+      depth,
+      ref
+    });
+    return commits;
+  }
+  /**
+   * Checkout a branch or commit
+   * 
+   * @example
+   * ```ts
+   * await morphGit.checkout({
+   *   dir: './my-project',
+   *   ref: 'feature-branch'
+   * });
+   * ```
+   */
+  async checkout(options) {
+    const { dir, ref } = options;
+    await import_isomorphic_git.default.checkout({
+      fs: import_fs.default,
+      dir,
+      ref
+    });
+  }
+  /**
+   * Create a new branch
+   * 
+   * @example
+   * ```ts
+   * await morphGit.branch({
+   *   dir: './my-project',
+   *   name: 'feature-branch',
+   *   checkout: true
+   * });
+   * ```
+   */
+  async branch(options) {
+    const { dir, name, checkout = false } = options;
+    await import_isomorphic_git.default.branch({
+      fs: import_fs.default,
+      dir,
+      ref: name,
+      checkout
+    });
+  }
+  /**
+   * List all branches
+   * 
+   * @example
+   * ```ts
+   * const branches = await morphGit.listBranches({
+   *   dir: './my-project'
+   * });
+   * ```
+   */
+  async listBranches(options) {
+    const { dir } = options;
+    const branches = await import_isomorphic_git.default.listBranches({
+      fs: import_fs.default,
+      dir
+    });
+    return branches;
+  }
+  /**
+   * Get the current branch name
+   * 
+   * @example
+   * ```ts
+   * const branch = await morphGit.currentBranch({
+   *   dir: './my-project'
+   * });
+   * ```
+   */
+  async currentBranch(options) {
+    const { dir } = options;
+    const branch = await import_isomorphic_git.default.currentBranch({
+      fs: import_fs.default,
+      dir
+    });
+    return branch || void 0;
+  }
+  /**
+   * Get list of changed files (similar to git diff --name-only)
+   * 
+   * @example
+   * ```ts
+   * const changes = await morphGit.statusMatrix({
+   *   dir: './my-project'
+   * });
+   * ```
+   */
+  async statusMatrix(options) {
+    const { dir } = options;
+    const matrix = await import_isomorphic_git.default.statusMatrix({
+      fs: import_fs.default,
+      dir
+    });
+    return matrix.map(([filepath, HEADStatus, workdirStatus, stageStatus]) => {
+      let status = "unmodified";
+      if (HEADStatus === 1 && workdirStatus === 2 && stageStatus === 2) {
+        status = "modified";
+      } else if (HEADStatus === 1 && workdirStatus === 2 && stageStatus === 1) {
+        status = "*modified";
+      } else if (HEADStatus === 0 && workdirStatus === 2 && stageStatus === 2) {
+        status = "added";
+      } else if (HEADStatus === 0 && workdirStatus === 2 && stageStatus === 0) {
+        status = "*added";
+      } else if (HEADStatus === 1 && workdirStatus === 0 && stageStatus === 0) {
+        status = "deleted";
+      } else if (HEADStatus === 1 && workdirStatus === 0 && stageStatus === 1) {
+        status = "*deleted";
+      } else if (HEADStatus === 1 && workdirStatus === 1 && stageStatus === 1) {
+        status = "unmodified";
+      } else if (HEADStatus === 0 && workdirStatus === 0 && stageStatus === 0) {
+        status = "absent";
+      }
+      return {
+        filepath,
+        status
+      };
+    });
+  }
+  /**
+   * Get the current commit hash
+   * 
+   * @example
+   * ```ts
+   * const hash = await morphGit.resolveRef({
+   *   dir: './my-project',
+   *   ref: 'HEAD'
+   * });
+   * ```
+   */
+  async resolveRef(options) {
+    const { dir, ref } = options;
+    const oid = await import_isomorphic_git.default.resolveRef({
+      fs: import_fs.default,
+      dir,
+      ref
+    });
+    return oid;
+  }
+};
+
+// git/index.ts
+var import_isomorphic_git2 = __toESM(require("isomorphic-git"), 1);
+var import_node2 = __toESM(require("isomorphic-git/http/node"), 1);
+
+// tools/modelrouter/core.ts
+var DEFAULT_CONFIG3 = {
+  apiUrl: "https://api.morphllm.com",
+  timeout: 1e4,
+  // 10 seconds
+  debug: false
+};
+var MODEL_MAPPINGS = {
+  openai: {
+    balanced: {
+      easy: "gpt-5-mini",
+      medium: "gpt-5-low",
+      hard: "gpt-5-medium",
+      "needs-info": "gpt-5-mini"
+    },
+    aggressive: {
+      easy: "gpt-5-low",
+      medium: "gpt-5-medium",
+      hard: "gpt-5-high",
+      "needs-info": "gpt-5-mini"
+    }
+  },
+  anthropic: {
+    balanced: {
+      easy: "claude-4.5-haiku",
+      medium: "claude-4.5-haiku",
+      hard: "claude-4.5-sonnet",
+      "needs-info": "claude-4.5-haiku"
+    },
+    aggressive: {
+      easy: "claude-4.5-haiku",
+      medium: "claude-4.5-sonnet",
+      hard: "claude-4.5-sonnet",
+      "needs-info": "claude-4.5-haiku"
+    }
+  },
+  gemini: {
+    balanced: {
+      easy: "gemini-2.5-flash",
+      medium: "gemini-2.5-flash",
+      hard: "gemini-2.5-pro",
+      "needs-info": "gemini-2.5-flash"
+    },
+    aggressive: {
+      easy: "gemini-2.5-flash",
+      medium: "gemini-2.5-pro",
+      hard: "gemini-2.5-pro",
+      "needs-info": "gemini-2.5-flash"
+    }
+  }
+};
+var BaseRouter = class {
+  config;
+  provider;
+  constructor(provider, config = {}) {
+    this.provider = provider;
+    this.config = {
+      apiKey: config.apiKey,
+      apiUrl: config.apiUrl || DEFAULT_CONFIG3.apiUrl,
+      timeout: config.timeout || DEFAULT_CONFIG3.timeout,
+      debug: config.debug || DEFAULT_CONFIG3.debug,
+      retryConfig: config.retryConfig
+    };
+  }
+  /**
+   * Map backend complexity classification to actual model name
+   */
+  mapComplexityToModel(complexity, mode) {
+    const mapping = MODEL_MAPPINGS[this.provider][mode];
+    return mapping[complexity];
+  }
+  /**
+   * Select the optimal model for a given input and mode
+   */
+  async selectModel(input) {
+    const mode = input.mode || "balanced";
+    const apiKey = this.config.apiKey || process.env.MORPH_API_KEY;
+    if (!apiKey) {
+      throw new Error(
+        "Morph API key is required. Set MORPH_API_KEY environment variable or pass apiKey in config."
+      );
+    }
+    const url = `${this.config.apiUrl}/router/${this.provider}`;
+    const payload = {
+      input: input.input,
+      mode
+    };
+    if (this.config.debug) {
+      console.log(`[ModelRouter] Requesting ${this.provider} model selection:`, {
+        mode,
+        inputLength: input.input.length
+      });
+    }
+    try {
+      const fetchPromise = fetchWithRetry(
+        url,
+        {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${apiKey}`
+          },
+          body: JSON.stringify(payload)
+        },
+        this.config.retryConfig
+      );
+      const response = await withTimeout(
+        fetchPromise,
+        this.config.timeout,
+        `Router API request timed out after ${this.config.timeout}ms`
+      );
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(
+          `Router API error (${response.status}): ${errorText || response.statusText}`
+        );
+      }
+      const apiResult = await response.json();
+      const actualModel = this.mapComplexityToModel(apiResult.model, mode);
+      const result = {
+        model: actualModel,
+        reasoning: apiResult.reasoning
+      };
+      if (this.config.debug) {
+        console.log(`[ModelRouter] Complexity: ${apiResult.model}, Selected model: ${actualModel}`);
+      }
+      return result;
+    } catch (error) {
+      if (this.config.debug) {
+        console.error(`[ModelRouter] Error selecting model:`, error);
+      }
+      throw error;
+    }
+  }
+};
+var OpenAIRouter = class extends BaseRouter {
+  constructor(config = {}) {
+    super("openai", config);
+  }
+  /**
+   * 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)
+   */
+  async selectModel(input) {
+    return super.selectModel(input);
+  }
+};
+var AnthropicRouter = class extends BaseRouter {
+  constructor(config = {}) {
+    super("anthropic", config);
+  }
+  /**
+   * Select optimal Claude model
+   * 
+   * @param input - User input and mode
+   * @returns Selected model name (claude-4.5-haiku | claude-4.5-sonnet)
+   */
+  async selectModel(input) {
+    return super.selectModel(input);
+  }
+};
+var GeminiRouter = class extends BaseRouter {
+  constructor(config = {}) {
+    super("gemini", config);
+  }
+  /**
+   * Select optimal Gemini model
+   * 
+   * @param input - User input and mode
+   * @returns Selected model name (gemini-2.5-flash | gemini-2.5-pro)
+   */
+  async selectModel(input) {
+    return super.selectModel(input);
+  }
+};
+
+// client.ts
+var MorphClient = class {
+  /** Client configuration */
+  config;
+  /** FastApply tool for editing files with AI-powered merge */
+  fastApply;
+  /** CodebaseSearch tool for semantic code search */
+  codebaseSearch;
+  /** Browser tool for AI-powered browser automation */
+  browser;
+  /** Git tool for version control operations */
+  git;
+  /** Model routers for intelligent model selection */
+  routers;
+  /**
+   * Create a new Morph SDK client
+   * 
+   * @param config - Client configuration (apiKey, debug, timeout, retryConfig)
+   * 
+   * @example
+   * ```typescript
+   * const morph = new MorphClient({ 
+   *   apiKey: process.env.MORPH_API_KEY,
+   *   debug: true,
+   *   timeout: 60000
+   * });
+   * ```
+   */
+  constructor(config = {}) {
+    this.config = config;
+    this.fastApply = new FastApplyClient({
+      apiKey: config.apiKey,
+      debug: config.debug,
+      timeout: config.timeout,
+      retryConfig: config.retryConfig
+    });
+    this.codebaseSearch = new CodebaseSearchClient({
+      apiKey: config.apiKey,
+      debug: config.debug,
+      timeout: config.timeout,
+      retryConfig: config.retryConfig
+    });
+    this.browser = new BrowserClient({
+      apiKey: config.apiKey,
+      debug: config.debug,
+      timeout: config.timeout,
+      retryConfig: config.retryConfig
+    });
+    this.git = new MorphGit({
+      apiKey: config.apiKey,
+      retryConfig: config.retryConfig
+    });
+    this.routers = {
+      openai: new OpenAIRouter({
+        apiKey: config.apiKey,
+        debug: config.debug,
+        timeout: config.timeout,
+        retryConfig: config.retryConfig
+      }),
+      anthropic: new AnthropicRouter({
+        apiKey: config.apiKey,
+        debug: config.debug,
+        timeout: config.timeout,
+        retryConfig: config.retryConfig
+      }),
+      gemini: new GeminiRouter({
+        apiKey: config.apiKey,
+        debug: config.debug,
+        timeout: config.timeout,
+        retryConfig: config.retryConfig
+      })
+    };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MorphClient
+});
+//# sourceMappingURL=client.cjs.map