@morphllm/morphsdk 0.2.93 → 0.2.95

package/dist/tools/warp_grep/openai.js

@@ -3,25 +3,24 @@ import {
   execute,
   openai_default,
   warpGrepTool
-} from "../../chunk-LMUZ3NGC.js";
+} from "../../chunk-73RV6EXR.js";
 import "../../chunk-KW7OEGZK.js";
 import {
   formatResult
-} from "../../chunk-PUGIOVSP.js";
-import "../../chunk-VHOWYK66.js";
+} from "../../chunk-QAT5UVPX.js";
+import "../../chunk-43LQLGP6.js";
 import "../../chunk-PUGSTXLO.js";
 import "../../chunk-KRDIR7GG.js";
-import "../../chunk-APP75CBN.js";
-import "../../chunk-SNGGSPYJ.js";
-import {
-  getSystemPrompt
-} from "../../chunk-FMLHRJDF.js";
 import "../../chunk-4KMBU6T3.js";
 import "../../chunk-G2RSY56Q.js";
 import "../../chunk-YPKNMYD4.js";
 import "../../chunk-TPP2UGQP.js";
 import "../../chunk-5PNMAWLC.js";
-import "../../chunk-4VWJFZVS.js";
+import "../../chunk-APP75CBN.js";
+import "../../chunk-SNGGSPYJ.js";
+import {
+  getSystemPrompt
+} from "../../chunk-FMLHRJDF.js";
 import "../../chunk-PZ5AY32C.js";
 export {
   createWarpGrepTool,

package/dist/tools/warp_grep/vercel.cjs

@@ -732,80 +732,6 @@ function mergeRanges(ranges) {
   return merged;
 }
 
-// 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((resolve) => setTimeout(resolve, ms));
-}
-
 // tools/warp_grep/agent/formatter.ts
 var ToolOutputFormatter = class {
   format(toolName, args, output, options = {}) {
@@ -980,42 +906,36 @@ function enforceContextLimit(messages, maxChars = AGENT_CONFIG.MAX_CONTEXT_CHARS
 }
 
 // tools/warp_grep/agent/runner.ts
+var import_openai = __toESM(require("openai"), 1);
 var import_path2 = __toESM(require("path"), 1);
 var parser = new LLMResponseParser();
 var DEFAULT_API_URL = "https://api.morphllm.com";
 async function callModel(messages, model, options = {}) {
   const baseUrl = options.morphApiUrl || DEFAULT_API_URL;
   const apiKey = options.morphApiKey || process.env.MORPH_API_KEY || "";
-  const fetchPromise = fetchWithRetry(
-    `${baseUrl}/v1/chat/completions`,
-    {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${apiKey}`
-      },
-      body: JSON.stringify({
-        model,
-        temperature: 0,
-        max_tokens: 1024,
-        repetition_penalty: 1.05,
-        messages
-      })
-    },
-    options.retryConfig
-  );
   const timeoutMs = options.timeout ?? AGENT_CONFIG.TIMEOUT_MS;
-  const resp = await withTimeout(fetchPromise, timeoutMs, "morph-warp-grep request timed out");
-  if (!resp.ok) {
-    if (resp.status === 404) {
+  const client = new import_openai.default({
+    apiKey,
+    baseURL: baseUrl,
+    maxRetries: options.retryConfig?.maxRetries,
+    timeout: timeoutMs
+  });
+  let data;
+  try {
+    data = await client.chat.completions.create({
+      model,
+      temperature: 0,
+      max_tokens: 1024,
+      messages
+    });
+  } catch (error) {
+    if (error instanceof import_openai.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"
       );
     }
-    const t = await resp.text();
-    throw new Error(`morph-warp-grep error ${resp.status}: ${t}`);
+    throw error;
   }
-  const data = await resp.json();
   const content = data?.choices?.[0]?.message?.content;
   if (!content || typeof content !== "string") {
     throw new Error("Invalid response from model");