@morphllm/morphsdk 0.2.83 → 0.2.85

package/dist/client.d.ts

@@ -5,11 +5,12 @@ import './tools/browser/core.js';
 import './tools/warp_grep/client.js';
 import './git/client.js';
 import './modelrouter/core.js';
-export { M as MorphClient, a as MorphClientConfig } from './client-CsO9LifG.js';
+export { M as MorphClient, a as MorphClientConfig } from './client-Drz3OGq-.js';
 import './tools/fastapply/types.js';
 import './tools/codebase_search/types.js';
 import './tools/browser/types.js';
-import './types-Cv4LpqVl.js';
+import './tools/warp_grep/agent/types.js';
+import './types-BMowL9iZ.js';
 import './tools/warp_grep/providers/types.js';
 import './git/types.js';
 import 'isomorphic-git';

package/dist/client.js

@@ -1,14 +1,14 @@
 import {
   MorphClient
-} from "./chunk-HPR6BJA7.js";
-import "./chunk-RL4JBZ3T.js";
-import "./chunk-LXG37353.js";
-import "./chunk-S27A4NQM.js";
+} from "./chunk-SQF3OG24.js";
+import "./chunk-AJEE5RRB.js";
+import "./chunk-IXNX4HMC.js";
+import "./chunk-5X7IJXKA.js";
 import "./chunk-KW7OEGZK.js";
-import "./chunk-HRK53IKL.js";
-import "./chunk-QOYI77CN.js";
+import "./chunk-37SJ3IOY.js";
+import "./chunk-HJOMBO2A.js";
 import "./chunk-PUGSTXLO.js";
-import "./chunk-P2O5JKE5.js";
+import "./chunk-KRDIR7GG.js";
 import "./chunk-APP75CBN.js";
 import "./chunk-5QRN3JNB.js";
 import "./chunk-FMLHRJDF.js";

package/dist/index.cjs

@@ -1611,14 +1611,23 @@ async function toolRead(provider, args) {
 
 // tools/warp_grep/agent/tools/list_directory.ts
 async function toolListDirectory(provider, args) {
-  const list = await provider.listDirectory({
-    path: args.path,
-    pattern: args.pattern ?? null,
-    maxResults: args.maxResults ?? AGENT_CONFIG.MAX_OUTPUT_LINES,
-    maxDepth: args.maxDepth ?? AGENT_CONFIG.MAX_LIST_DEPTH
-  });
+  const maxResults = args.maxResults ?? AGENT_CONFIG.MAX_OUTPUT_LINES;
+  const initialDepth = args.maxDepth ?? AGENT_CONFIG.MAX_LIST_DEPTH;
+  async function getListRecursive(currentDepth) {
+    const entries = await provider.listDirectory({
+      path: args.path,
+      pattern: args.pattern ?? null,
+      maxResults,
+      maxDepth: currentDepth
+    });
+    if (entries.length >= maxResults && currentDepth > 0) {
+      return getListRecursive(currentDepth - 1);
+    }
+    return { entries };
+  }
+  const { entries: list } = await getListRecursive(initialDepth);
   if (!list.length) return "empty";
-  if (list.length >= AGENT_CONFIG.MAX_OUTPUT_LINES) {
+  if (list.length >= maxResults) {
     return "query not specific enough, tool called tried to return too much context and failed";
   }
   return list.map((e) => {
@@ -2038,6 +2047,156 @@ async function runWarpGrep(config) {
     timings
   };
 }
+async function* runWarpGrepStreaming(config) {
+  const totalStart = Date.now();
+  const timeoutMs = config.timeout ?? AGENT_CONFIG.TIMEOUT_MS;
+  const timings = { turns: [], timeout_ms: timeoutMs };
+  const repoRoot = import_path3.default.resolve(config.repoRoot || process.cwd());
+  const messages = [];
+  messages.push({ role: "system", content: getSystemPrompt() });
+  const initialStateStart = Date.now();
+  const initialState = await buildInitialState(repoRoot, config.query, config.provider);
+  timings.initial_state_ms = Date.now() - initialStateStart;
+  messages.push({ role: "user", content: initialState });
+  const maxTurns = AGENT_CONFIG.MAX_TURNS;
+  const model = config.model || DEFAULT_MODEL;
+  const provider = config.provider;
+  const errors = [];
+  let finishMeta;
+  let terminationReason = "terminated";
+  for (let turn = 1; turn <= maxTurns; turn += 1) {
+    const turnMetrics = { turn, morph_api_ms: 0, local_tools_ms: 0 };
+    enforceContextLimit(messages);
+    const modelCallStart = Date.now();
+    const assistantContent = await callModel(messages, model, {
+      morphApiKey: config.morphApiKey,
+      morphApiUrl: config.morphApiUrl,
+      retryConfig: config.retryConfig,
+      timeout: timeoutMs
+    }).catch((e) => {
+      errors.push({ message: e instanceof Error ? e.message : String(e) });
+      return "";
+    });
+    turnMetrics.morph_api_ms = Date.now() - modelCallStart;
+    if (!assistantContent) {
+      timings.turns.push(turnMetrics);
+      break;
+    }
+    messages.push({ role: "assistant", content: assistantContent });
+    const toolCalls = parser.parse(assistantContent);
+    if (toolCalls.length === 0) {
+      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);
+      break;
+    }
+    yield {
+      turn,
+      toolCalls: toolCalls.map((c) => ({
+        name: c.name,
+        arguments: c.arguments ?? {}
+      }))
+    };
+    const finishCalls = toolCalls.filter((c) => c.name === "finish");
+    const grepCalls = toolCalls.filter((c) => c.name === "grep");
+    const listDirCalls = toolCalls.filter((c) => c.name === "list_directory");
+    const readCalls = toolCalls.filter((c) => c.name === "read");
+    const skipCalls = toolCalls.filter((c) => c.name === "_skip");
+    const formatted = [];
+    for (const c of skipCalls) {
+      const msg = c.arguments?.message || "Command skipped due to parsing error";
+      formatted.push(msg);
+    }
+    const allPromises = [];
+    for (const c of grepCalls) {
+      const args = c.arguments ?? {};
+      allPromises.push(
+        toolGrep(provider, args).then(
+          ({ output }) => formatAgentToolOutput("grep", args, output, { isError: false }),
+          (err) => formatAgentToolOutput("grep", args, String(err), { isError: true })
+        )
+      );
+    }
+    for (const c of listDirCalls) {
+      const args = c.arguments ?? {};
+      allPromises.push(
+        toolListDirectory(provider, args).then(
+          (p) => formatAgentToolOutput("list_directory", args, p, { isError: false }),
+          (err) => formatAgentToolOutput("list_directory", args, String(err), { isError: true })
+        )
+      );
+    }
+    for (const c of readCalls) {
+      const args = c.arguments ?? {};
+      allPromises.push(
+        toolRead(provider, args).then(
+          (p) => formatAgentToolOutput("read", args, p, { isError: false }),
+          (err) => formatAgentToolOutput("read", args, String(err), { isError: true })
+        )
+      );
+    }
+    const toolExecStart = Date.now();
+    const allResults = await Promise.all(allPromises);
+    turnMetrics.local_tools_ms = Date.now() - toolExecStart;
+    for (const result of allResults) {
+      formatted.push(result);
+    }
+    if (formatted.length > 0) {
+      const turnMessage = formatTurnMessage(turn, maxTurns);
+      const contextBudget = calculateContextBudget(messages);
+      messages.push({ role: "user", content: formatted.join("\n") + turnMessage + "\n" + contextBudget });
+    }
+    timings.turns.push(turnMetrics);
+    if (finishCalls.length) {
+      const fc = finishCalls[0];
+      const files = fc.arguments?.files ?? [];
+      finishMeta = { files };
+      terminationReason = "completed";
+      break;
+    }
+  }
+  if (terminationReason !== "completed" || !finishMeta) {
+    timings.total_ms = Date.now() - totalStart;
+    return { terminationReason, messages, errors, timings };
+  }
+  const parts = ["Relevant context found:"];
+  for (const f of finishMeta.files) {
+    const ranges = f.lines === "*" ? "*" : Array.isArray(f.lines) ? f.lines.map(([s, e]) => `${s}-${e}`).join(", ") : "*";
+    parts.push(`- ${f.path}: ${ranges}`);
+  }
+  const payload = parts.join("\n");
+  const finishResolutionStart = Date.now();
+  const fileReadErrors = [];
+  const resolved = await readFinishFiles(
+    repoRoot,
+    finishMeta.files,
+    async (p, s, e) => {
+      try {
+        const rr = await provider.read({ path: p, start: s, end: e });
+        return rr.lines.map((l) => {
+          const idx = l.indexOf("|");
+          return idx >= 0 ? l.slice(idx + 1) : l;
+        });
+      } catch (err) {
+        const errorMsg = err instanceof Error ? err.message : String(err);
+        fileReadErrors.push({ path: p, error: errorMsg });
+        console.error(`[warp_grep] Failed to read file: ${p} - ${errorMsg}`);
+        return [`[couldn't find: ${p}]`];
+      }
+    }
+  );
+  timings.finish_resolution_ms = Date.now() - finishResolutionStart;
+  if (fileReadErrors.length > 0) {
+    errors.push(...fileReadErrors.map((e) => ({ message: `File read error: ${e.path} - ${e.error}` })));
+  }
+  timings.total_ms = Date.now() - totalStart;
+  return {
+    terminationReason: "completed",
+    messages,
+    finish: { payload, metadata: finishMeta, resolved },
+    timings
+  };
+}
 
 // tools/warp_grep/providers/local.ts
 var import_promises3 = __toESM(require("fs/promises"), 1);
@@ -2631,43 +2790,23 @@ var WarpGrepClient = class {
       retryConfig: config.retryConfig
     };
   }
-  /**
-   * Execute a code search query
-   * 
-   * @param input - Search parameters including query, repoRoot, and optional provider
-   * @returns Search results with relevant code contexts
-   * 
-   * @example
-   * ```typescript
-   * const result = await client.execute({
-   *   query: 'Find authentication middleware',
-   *   repoRoot: '.'
-   * });
-   * 
-   * if (result.success) {
-   *   for (const ctx of result.contexts) {
-   *     console.log(`File: ${ctx.file}`);
-   *     console.log(ctx.content);
-   *   }
-   * }
-   * ```
-   */
-  async execute(input) {
-    return executeToolCall(
-      { query: input.query },
-      {
-        repoRoot: input.repoRoot,
-        remoteCommands: input.remoteCommands,
-        provider: input.provider,
-        excludes: input.excludes,
-        includes: input.includes,
-        debug: input.debug ?? this.config.debug,
-        morphApiKey: this.config.morphApiKey,
-        morphApiUrl: this.config.morphApiUrl,
-        retryConfig: this.config.retryConfig,
-        timeout: this.config.timeout
-      }
-    );
+  execute(input) {
+    const toolConfig = {
+      repoRoot: input.repoRoot,
+      remoteCommands: input.remoteCommands,
+      provider: input.provider,
+      excludes: input.excludes,
+      includes: input.includes,
+      debug: input.debug ?? this.config.debug,
+      morphApiKey: this.config.morphApiKey,
+      morphApiUrl: this.config.morphApiUrl,
+      retryConfig: this.config.retryConfig,
+      timeout: this.config.timeout
+    };
+    if (input.streamSteps) {
+      return executeToolCallStreaming({ query: input.query }, toolConfig);
+    }
+    return executeToolCall({ query: input.query }, toolConfig);
   }
 };
 async function executeToolCall(input, config) {
@@ -2695,6 +2834,43 @@ async function executeToolCall(input, config) {
   }));
   return { success: true, contexts, summary: finish.payload };
 }
+function processAgentResult(result) {
+  const finish = result.finish;
+  if (result.terminationReason !== "completed" || !finish?.metadata) {
+    return { success: false, error: "Search did not complete" };
+  }
+  const contexts = (finish.resolved ?? []).map((r) => ({
+    file: r.path,
+    content: r.content
+  }));
+  return { success: true, contexts, summary: finish.payload };
+}
+async function* executeToolCallStreaming(input, config) {
+  const parsed = typeof input === "string" ? JSON.parse(input) : input;
+  const provider = config.remoteCommands ? new RemoteCommandsProvider(config.repoRoot, config.remoteCommands) : config.provider ?? new LocalRipgrepProvider(config.repoRoot, config.excludes);
+  const generator = runWarpGrepStreaming({
+    query: parsed.query,
+    repoRoot: config.repoRoot,
+    provider,
+    excludes: config.excludes,
+    includes: config.includes,
+    debug: config.debug ?? false,
+    morphApiKey: config.morphApiKey,
+    morphApiUrl: config.morphApiUrl,
+    retryConfig: config.retryConfig,
+    timeout: config.timeout
+  });
+  let agentResult;
+  for (; ; ) {
+    const { value, done } = await generator.next();
+    if (done) {
+      agentResult = value;
+      break;
+    }
+    yield value;
+  }
+  return processAgentResult(agentResult);
+}
 function formatResult(result) {
   if (!result.success) {
     return `Search failed: ${result.error}`;