@morphllm/morphsdk 0.2.113 → 0.2.115

package/dist/client.cjs

@@ -30,86 +30,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// tools/utils/resilience.ts
-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));
-}
-var DEFAULT_RETRY_CONFIG;
-var init_resilience = __esm({
-  "tools/utils/resilience.ts"() {
-    "use strict";
-    DEFAULT_RETRY_CONFIG = {
-      maxRetries: 3,
-      initialDelay: 1e3,
-      maxDelay: 3e4,
-      backoffMultiplier: 2,
-      retryableErrors: ["ECONNREFUSED", "ETIMEDOUT", "ENOTFOUND"]
-    };
-  }
-});
-
 // tools/fastapply/apply.ts
 var apply_exports = {};
 __export(apply_exports, {
@@ -166,37 +86,25 @@ async function callMorphAPI(originalCode, codeEdit, instructions, filepath, conf
     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,
+  const client = new import_openai.default({
+    apiKey,
+    baseURL: `${apiUrl}/v1`,
     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}`);
+    maxRetries: config.retryConfig?.maxRetries ?? 3
+  });
+  const completion = await client.chat.completions.create({
+    model: "morph-v3-fast",
+    messages: [{ role: "user", content: message }]
+  });
+  const content = completion.choices[0]?.message?.content;
+  if (!content) {
+    throw new Error("Morph API returned empty response");
   }
-  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`);
+    console.log(`[FastApply] Success in ${elapsed}ms, merged: ${content.length} chars`);
   }
-  return { content: data.choices[0].message.content, completionId: data.id };
+  return { content, completionId: completion.id };
 }
 async function applyEdit(input, config = {}) {
   const debug = config.debug || false;
@@ -231,12 +139,12 @@ async function applyEdit(input, config = {}) {
     };
   }
 }
-var import_diff, DEFAULT_API_URL, DEFAULT_TIMEOUT;
+var import_diff, import_openai, DEFAULT_API_URL, DEFAULT_TIMEOUT;
 var init_apply = __esm({
   "tools/fastapply/apply.ts"() {
     "use strict";
     import_diff = require("diff");
-    init_resilience();
+    import_openai = __toESM(require("openai"), 1);
     DEFAULT_API_URL = "https://api.morphllm.com";
     DEFAULT_TIMEOUT = 3e4;
   }
@@ -894,8 +802,81 @@ async function executeEditFile(input, config = {}) {
   }
 }
 
+// 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/codebase_search/core.ts
-init_resilience();
 var CodebaseSearchClient = class {
   config;
   constructor(config = {}) {
@@ -990,9 +971,6 @@ async function executeCodebaseSearch(input, config) {
   }
 }
 
-// tools/browser/core.ts
-init_resilience();
-
 // tools/browser/live.ts
 var LIVE_PRESETS = {
   /** Read-only monitoring (no interaction) */
@@ -1093,9 +1071,6 @@ function resolvePreset(optionsOrPreset) {
   return optionsOrPreset;
 }
 
-// tools/browser/profiles/core.ts
-init_resilience();
-
 // tools/browser/errors.ts
 var MorphError = class extends Error {
   /** Error code for programmatic handling */
@@ -3025,7 +3000,7 @@ function enforceContextLimit(messages, maxChars = AGENT_CONFIG.MAX_CONTEXT_CHARS
 }
 
 // tools/warp_grep/agent/runner.ts
-var import_openai = __toESM(require("openai"), 1);
+var import_openai2 = __toESM(require("openai"), 1);
 var import_path3 = __toESM(require("path"), 1);
 var parser = new LLMResponseParser();
 var DEFAULT_API_URL3 = "https://api.morphllm.com";
@@ -3033,7 +3008,7 @@ async function callModel(messages, model, options = {}) {
   const baseUrl = options.morphApiUrl || DEFAULT_API_URL3;
   const apiKey = options.morphApiKey || process.env.MORPH_API_KEY || "";
   const timeoutMs = options.timeout ?? AGENT_CONFIG.TIMEOUT_MS;
-  const client = new import_openai.default({
+  const client = new import_openai2.default({
     apiKey,
     baseURL: `${baseUrl}/v1`,
     maxRetries: options.retryConfig?.maxRetries,
@@ -3048,7 +3023,7 @@ async function callModel(messages, model, options = {}) {
       messages
     });
   } catch (error) {
-    if (error instanceof import_openai.default.APIError && error.status === 404) {
+    if (error instanceof import_openai2.default.APIError && error.status === 404) {
       throw new Error(
         "The endpoint you are trying to call is likely deprecated. Please update with: npm cache clean --force && npx -y @morphllm/morphmcp@latest or visit: https://morphllm.com/mcp"
       );
@@ -3088,17 +3063,21 @@ async function runWarpGrep(config) {
       retryConfig: config.retryConfig,
       timeout: timeoutMs
     }).catch((e) => {
-      errors.push({ message: e instanceof Error ? e.message : String(e) });
+      const errMsg = e instanceof Error ? e.message : String(e);
+      console.error(`[warp_grep] Morph API call failed on turn ${turn}:`, errMsg);
+      errors.push({ message: errMsg });
       return "";
     });
     turnMetrics.morph_api_ms = Date.now() - modelCallStart;
     if (!assistantContent) {
+      console.error(`[warp_grep] Empty response from Morph API on turn ${turn}. Errors so far:`, errors);
       timings.turns.push(turnMetrics);
       break;
     }
     messages.push({ role: "assistant", content: assistantContent });
     const toolCalls = parser.parse(assistantContent);
     if (toolCalls.length === 0) {
+      console.error(`[warp_grep] No tool calls parsed on turn ${turn}. Assistant content (first 500 chars):`, assistantContent.slice(0, 500));
       errors.push({ message: "No tool calls produced by the model. Your MCP is likely out of date! Update it by running: rm -rf ~/.npm/_npx && npm cache clean --force && npx -y @morphllm/morphmcp@latest" });
       terminationReason = "terminated";
       timings.turns.push(turnMetrics);
@@ -3231,17 +3210,21 @@ async function* runWarpGrepStreaming(config) {
       retryConfig: config.retryConfig,
       timeout: timeoutMs
     }).catch((e) => {
-      errors.push({ message: e instanceof Error ? e.message : String(e) });
+      const errMsg = e instanceof Error ? e.message : String(e);
+      console.error(`[warp_grep:stream] Morph API call failed on turn ${turn}:`, errMsg);
+      errors.push({ message: errMsg });
       return "";
     });
     turnMetrics.morph_api_ms = Date.now() - modelCallStart;
     if (!assistantContent) {
+      console.error(`[warp_grep:stream] Empty response from Morph API on turn ${turn}. Errors so far:`, errors);
       timings.turns.push(turnMetrics);
       break;
     }
     messages.push({ role: "assistant", content: assistantContent });
     const toolCalls = parser.parse(assistantContent);
     if (toolCalls.length === 0) {
+      console.error(`[warp_grep:stream] No tool calls parsed on turn ${turn}. Assistant content (first 500 chars):`, assistantContent.slice(0, 500));
       errors.push({ message: "No tool calls produced by the model. Your MCP is likely out of date! Update it by running: rm -rf ~/.npm/_npx && npm cache clean --force && npx -y @morphllm/morphmcp@latest" });
       terminationReason = "terminated";
       timings.turns.push(turnMetrics);
@@ -3588,7 +3571,9 @@ async function executeToolCall(input, config) {
   });
   const finish = result.finish;
   if (result.terminationReason !== "completed" || !finish?.metadata) {
-    return { success: false, error: "Search did not complete" };
+    const errorDetails = result.errors?.map((e) => e.message).join("; ") || "unknown reason";
+    console.error(`[warp_grep] executeToolCall failed. Reason: ${result.terminationReason}. Errors: ${errorDetails}. Turns: ${result.timings?.turns?.length ?? 0}`);
+    return { success: false, error: `Search did not complete: ${errorDetails}` };
   }
   const contexts = (finish.resolved ?? []).map((r) => ({
     file: r.path,
@@ -3600,7 +3585,9 @@ async function executeToolCall(input, config) {
 function processAgentResult(result) {
   const finish = result.finish;
   if (result.terminationReason !== "completed" || !finish?.metadata) {
-    return { success: false, error: "Search did not complete" };
+    const errorDetails = result.errors?.map((e) => e.message).join("; ") || "unknown reason";
+    console.error(`[warp_grep] processAgentResult failed. Reason: ${result.terminationReason}. Errors: ${errorDetails}. Turns: ${result.timings?.turns?.length ?? 0}`);
+    return { success: false, error: `Search did not complete: ${errorDetails}` };
   }
   const contexts = (finish.resolved ?? []).map((r) => ({
     file: r.path,
@@ -4555,7 +4542,6 @@ var import_isomorphic_git2 = __toESM(require("isomorphic-git"), 1);
 var import_node2 = __toESM(require("isomorphic-git/http/node"), 1);
 
 // modelrouter/core.ts
-init_resilience();
 var DEFAULT_CONFIG3 = {
   apiUrl: "https://api.morphllm.com",
   timeout: 5e3,
@@ -5234,14 +5220,26 @@ function createWarpGrepTool3(config) {
     description: config.description ?? WARP_GREP_DESCRIPTION,
     inputSchema: schema,
     execute: async (params) => {
-      const result = await executeToolCall(params, config);
+      const steps = [];
+      const generator = executeToolCallStreaming(params, config);
+      let result;
+      for (; ; ) {
+        const { value, done } = await generator.next();
+        if (done) {
+          result = value;
+          break;
+        }
+        steps.push(value);
+      }
       if (!result.success) {
         throw new Error(`Failed to search codebase: ${result.error}`);
       }
+      const allToolCalls = steps.flatMap((s) => s.toolCalls);
       return {
         success: true,
         contexts: result.contexts,
-        summary: result.summary
+        summary: result.summary,
+        progress: allToolCalls.length > 0 ? { turn: steps.length, toolCalls: allToolCalls } : void 0
       };
     }
   });