Mikec/token limit mcp logs (#40515)

<img width="1017" height="207" alt="image" src="https://github.com/user-attachments/assets/6c0a3757-85ac-4724-a60d-947d03db76ba" />

https://www.youtube.com/watch?v=1hlDpwePKsg&lc=UgwkBqoiqbmQ6Dj6XSV4AaABAg

This user noted that there is a 25k token limit with Claude code and MCP calls and that its quite frustrating to work with the MCP logs tool currently because of this.

This PR seeks to rectify this by allowing the model to optionally specify a token limit which the code then attempts to estimate.

The model can still supply an optional line limit if it wants to, both limits will be applied and sliced to the nearest entry boundry.

Its currently set to 20k limit to allow for inaccuracies in token estimation.

As mentioned in the `tokens.ts` file I borrowed the estimation logic from this repo: https://github.com/johannschopplich/tokenx I decided not to take a dependency on it and instead just copy it in as its simple and self contained. I dont know what the policy is on this brining in of third party code, but its MIT licensed so I assume its okay?

I have tested this all by running it locally and it all works as expected.

GitOrigin-RevId: a54bab51381988127382be5257a068ff78c7dcfc

Author: mikecann

npm-packages/convex/src/cli/lib/mcp/tools/logs.ts

@@ -14,14 +14,23 @@ const inputSchema = z.object({
     .describe(
       "Optional cursor (in ms) to start reading from. Use 0 to read from the beginning.",
     ),
-  limit: z
+  entriesLimit: z
     .number()
     .int()
     .positive()
     .max(1000)
     .optional()
     .describe(
-      "Maximum number of log entries to return. If omitted, returns all available in this chunk.",
+      "Maximum number of log entries to return (from the end). If omitted, returns all available in this chunk.",
+    ),
+  tokensLimit: z
+    .number()
+    .int()
+    .positive()
+    .default(20000)
+    .optional()
+    .describe(
+      "Approximate maximum number of tokens to return (applied to the JSON payload). Defaults to 20000.",
     ),
 });
 
@@ -30,6 +39,10 @@ const outputSchema = z.object({
   newCursor: z.number(),
 });
 
+const logsResponseSchema = outputSchema;
+
+type LogEntry = z.infer<typeof logsResponseSchema>["entries"][number];
+
 const description = `
 Fetch a chunk of recent log entries from your Convex deployment.
 
@@ -63,25 +76,71 @@ export const LogsTool: ConvexTool<typeof inputSchema, typeof outputSchema> = {
     const response = await fetch(`/api/stream_function_logs?cursor=${cursor}`, {
       method: "GET",
     });
+
     if (!response.ok) {
       return await ctx.crash({
         exitCode: 1,
         errorType: "fatal",
         printedMessage: `HTTP error ${response.status}: ${await response.text()}`,
       });
     }
-    const { entries, newCursor } = (await response.json()) as {
-      entries: unknown[];
-      newCursor: number;
-    };
 
-    // Optionally limit the number of entries returned from the end.
-    const limitedEntries =
-      typeof args.limit === "number" && entries.length > args.limit
-        ? entries.slice(entries.length - args.limit)
-        : entries;
+    const { entries, newCursor } = await response
+      .json()
+      .then(logsResponseSchema.parse);
 
-    const parsed = outputSchema.parse({ entries: limitedEntries, newCursor });
-    return parsed;
+    return {
+      entries: limitLogs({
+        entries,
+        tokensLimit: args.tokensLimit ?? 20000,
+        entriesLimit: args.entriesLimit ?? entries.length,
+      }),
+      newCursor,
+    };
   },
 };
+
+export function limitLogs({
+  entries,
+  tokensLimit,
+  entriesLimit,
+}: {
+  entries: LogEntry[];
+  tokensLimit: number;
+  entriesLimit: number;
+}): LogEntry[] {
+  // 1) Apply entries limit first so we cut off neatly at entry boundaries (latest entries kept)
+  const limitedByEntries = entries.slice(entries.length - entriesLimit);
+
+  // 2) Apply token limit by iterating over log lines from newest to oldest and
+  //    only include lines while within token budget. We cut off at the nearest log line.
+  const limitedByTokens = limitEntriesByTokenBudget({
+    entries: limitedByEntries,
+    tokensLimit,
+  });
+
+  return limitedByTokens;
+}
+
+function limitEntriesByTokenBudget({
+  entries,
+  tokensLimit,
+}: {
+  entries: LogEntry[];
+  tokensLimit: number;
+}): LogEntry[] {
+  const result: LogEntry[] = [];
+  let tokens = 0;
+  for (const entry of entries) {
+    const entryString = JSON.stringify(entry);
+    const entryTokens = estimateTokenCount(entryString);
+    tokens += entryTokens;
+    if (tokens > tokensLimit) break;
+    result.push(entry);
+  }
+  return result;
+}
+
+function estimateTokenCount(entryString: string): number {
+  return entryString.length * 0.33;
+}