crawlforge-mcp-server 5.10.0 → 6.1.0

package/src/cli/commands/login.js

@@ -0,0 +1,176 @@
+/**
+ * login command — browser handoff that stores an API key in ~/.crawlforge/config.json.
+ *
+ * The CLI mints PKCE parameters, prints an approval URL for the human, and polls
+ * the website until the signed-in user approves; the key is delivered once, over
+ * the poll, and never typed into a terminal. This command stores the credential
+ * ONLY — registering the MCP server with a client is `crawlforge init`.
+ */
+import { randomBytes, createHash } from 'node:crypto';
+import { hostname } from 'node:os';
+import { existsSync } from 'node:fs';
+import authManager from '../../core/authManager.js';
+import { resolveApiEndpoint } from '../../core/endpointGuard.js';
+
+const POLL_INTERVAL_MS = 3000;
+const MAX_BACKOFF_MS = 30000;
+const MAX_CONSECUTIVE_FAILURES = 10;
+
+export function generateLoginParams() {
+  const codeVerifier = randomBytes(32).toString('base64url');
+  return {
+    sessionId: randomBytes(16).toString('hex'),
+    codeVerifier,
+    codeChallenge: createHash('sha256').update(codeVerifier).digest('base64url'),
+  };
+}
+
+export function buildApprovalUrl(endpoint, params, name) {
+  return `${endpoint}/cli-auth?session_id=${params.sessionId}` +
+    `&code_challenge=${params.codeChallenge}&name=${encodeURIComponent(name)}`;
+}
+
+function loginError(code, message) {
+  const err = new Error(message);
+  err.code = code;
+  return err;
+}
+
+/**
+ * Poll the status endpoint until the key arrives. Resolves with the `complete`
+ * payload; rejects with an error whose `code` names why (CLI_AUTH_TIMEOUT,
+ * CLI_AUTH_VERIFIER_MISMATCH, CLI_AUTH_UNREACHABLE). `sleep` and `now` are
+ * injectable so tests neither wait nor hit the network.
+ */
+export async function pollStatus(fetchImpl, endpoint, params, {
+  intervalMs = POLL_INTERVAL_MS,
+  timeoutMs = 600000,
+  requestTimeoutMs = 30000,
+  sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+  now = Date.now,
+} = {}) {
+  const deadline = now() + timeoutMs;
+  let interval = intervalMs;
+  let failures = 0;
+  let lastFailure = '';
+
+  while (now() < deadline) {
+    let response;
+    try {
+      response = await fetchImpl(`${endpoint}/api/auth/cli/status`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ session_id: params.sessionId, code_verifier: params.codeVerifier }),
+        signal: AbortSignal.timeout(requestTimeoutMs),
+      });
+    } catch (err) {
+      response = null;
+      lastFailure = err.message;
+    }
+
+    if (response && response.status === 200) {
+      const body = await response.json();
+      if (body.status === 'complete') return body;
+      if (body.status === 'pending') {
+        failures = 0;
+      } else {
+        failures++;
+        lastFailure = `unexpected status "${body.status}"`;
+      }
+    } else if (response && response.status === 403) {
+      let code = 'CLI_AUTH_FORBIDDEN';
+      try { code = (await response.json()).error?.code || code; } catch { /* keep default */ }
+      throw loginError(code, code === 'CLI_AUTH_VERIFIER_MISMATCH'
+        ? 'The website rejected this session\'s verifier. Run crawlforge login again and open the new URL.'
+        : `The website refused the login session (${code}).`);
+    } else if (response && response.status === 429) {
+      interval = Math.min(interval * 2, MAX_BACKOFF_MS);
+    } else if (response) {
+      failures++;
+      lastFailure = `HTTP ${response.status}`;
+    } else {
+      failures++;
+    }
+
+    if (failures >= MAX_CONSECUTIVE_FAILURES) {
+      throw loginError('CLI_AUTH_UNREACHABLE',
+        `Gave up after ${failures} consecutive failed status checks (last: ${lastFailure}).`);
+    }
+    await sleep(interval);
+  }
+
+  throw loginError('CLI_AUTH_TIMEOUT',
+    `No approval within ${Math.round(timeoutMs / 1000)} seconds. Run crawlforge login again.`);
+}
+
+export function register(program) {
+  program
+    .command('login')
+    .description('Sign in through your browser and store an API key in ~/.crawlforge/config.json (does not touch client configs)')
+    .option('--name <name>', 'Name for the API key the approval creates', `CLI on ${hostname()}`)
+    // Not `--timeout`: the program-level `--timeout <ms>` parses argv first and
+    // would swallow the value, so a subcommand option of that name never gets one.
+    .option('--wait <seconds>', 'How long to wait for approval', '600')
+    .action(async (opts, cmd) => {
+      const json = cmd.parent.opts().json;
+      const out = (msg) => process.stderr.write(msg + '\n');
+      const fail = (code, message) => {
+        if (json) {
+          process.stdout.write(JSON.stringify({ status: 'error', code, message }) + '\n', () => process.exit(1));
+        } else {
+          out('Error: ' + message);
+          process.exit(1);
+        }
+      };
+      process.on('SIGINT', () => fail('CLI_AUTH_CANCELLED', 'Login cancelled.'));
+
+      // resolveApiEndpoint() returns the origin with a trailing slash; strip it
+      // so the approval URL and the status endpoint are not `host//path`.
+      const endpoint = resolveApiEndpoint(process.env.CRAWLFORGE_API_URL || 'https://www.crawlforge.dev').replace(/\/+$/, '');
+      const params = generateLoginParams();
+      const hadConfig = existsSync(authManager.configPath);
+
+      out('Open this URL in your browser and approve the key (session ' + params.sessionId.slice(0, 8) + '):');
+      out('');
+      out('  ' + buildApprovalUrl(endpoint, params, opts.name));
+      out('');
+      out('Waiting for approval… (Ctrl-C to cancel)');
+
+      let result;
+      try {
+        result = await pollStatus(fetch, endpoint, params, {
+          timeoutMs: parseInt(opts.wait, 10) * 1000,
+          requestTimeoutMs: parseInt(process.env.CRAWLFORGE_CLI_TIMEOUT || '30000', 10),
+        });
+      } catch (err) {
+        return fail(err.code || 'CLI_AUTH_FAILED', err.message);
+      }
+
+      const validation = await authManager.validateApiKey(result.api_key);
+      if (!validation.valid) {
+        return fail('CLI_AUTH_KEY_INVALID', 'The delivered API key failed validation: ' + validation.error);
+      }
+      await authManager.saveConfig(result.api_key, validation.userId, validation.email);
+
+      if (json) {
+        const line = JSON.stringify({
+          status: 'complete',
+          email: validation.email,
+          key_name: result.key_name,
+          config_path: authManager.configPath,
+          credits_remaining: validation.creditsRemaining,
+          plan: validation.planId,
+        });
+        process.stdout.write(line + '\n', () => process.exit(0));
+        return;
+      }
+
+      out('Signed in as ' + validation.email);
+      out('Credits remaining: ' + validation.creditsRemaining);
+      out('Plan: ' + validation.planId);
+      out('API key "' + result.key_name + '" saved to ' + authManager.configPath +
+        (hadConfig ? ' (replaced the previous config)' : ''));
+      out('Next: crawlforge init --client claude-code|claude-desktop|cursor registers the MCP server with a client (this command did not modify any client config).');
+      process.exit(0);
+    });
+}

package/src/cli/index.js

@@ -59,6 +59,7 @@ import { register as registerMonitor } from './commands/monitor.js';
 import { register as registerInstallSkills } from './commands/install-skills.js';
 import { register as registerUninstallSkills } from './commands/uninstall-skills.js';
 import { register as registerInit } from './commands/init.js';
+import { register as registerLogin } from './commands/login.js';
 
 // ─── MCP stdio server mode (backward compatibility) ──────────────────────────
 // Before v4.1.0 the `crawlforge` bin WAS the MCP server. v4.1.0 turned it into
@@ -138,6 +139,7 @@ registerMonitor(program);
 registerInstallSkills(program);
 registerUninstallSkills(program);
 registerInit(program);
+registerLogin(program);
 
 // `crawlforge mcp` / `crawlforge serve` — explicitly start the MCP server over
 // stdio. Extra args (e.g. --http) are read directly by server.js from argv.

package/src/core/ActionExecutor.js

@@ -166,7 +166,7 @@ const ActionChainSchema = z.object({
   continueOnError: z.boolean().default(false),
   timeout: z.number().min(1000).max(300000).default(30000),
   retryChain: z.number().min(0).max(3).default(0),
-  metadata: z.record(z.any()).default({})
+  metadata: z.record(z.any()).prefault({})
 });
 
 export class ActionExecutor extends EventEmitter {

package/src/core/AuthManager.js

@@ -241,9 +241,16 @@ class AuthManager {
   }
 
   /**
-   * Check if user has enough credits for a tool
+   * Check if user has enough credits for a tool.
+   *
+   * @param {number} estimatedCredits
+   * @param {object} [ctx] the SDK per-request context, so the low-credit
+   *   warning can ask as a multi-round-trip step (Phase 4.4).
+   * @returns {Promise<boolean|object>} `true`/`false` as before, or an
+   *   `input_required` result the caller must RETURN verbatim — `withAuth`
+   *   detects it, bills nothing and lets the SDK gather the answer.
    */
-  async checkCredits(estimatedCredits = 1) {
+  async checkCredits(estimatedCredits = 1, ctx) {
     // Creator mode has unlimited credits
     if (this.isCreatorMode()) {
       return true;
@@ -277,10 +284,16 @@ class AuthManager {
         this.lastCreditCheck = now;
         this.lastSuccessfulCreditCheck.set(this.config.userId, now);
 
-        // D1.4: If credits are close to running out, elicit confirmation instead of hard-failing
+        // D1.4: If credits are close to running out, elicit confirmation instead
+        // of hard-failing. Phase 4.4: the ask is a round trip now — `ask` hands
+        // an `input_required` result back to withAuth, which returns it unbilled
+        // and is re-entered here with the answer. A client that cannot be asked
+        // still proceeds, which is what the inline helper did.
         if (data.creditsRemaining < estimatedCredits) {
           if (this._elicitation) {
-            const proceed = await this._elicitation.confirm(
+            const gate = this._elicitation.confirm(
+              ctx,
+              'credits:low',
               `Low credits: ${data.creditsRemaining} remaining, this tool needs ~${estimatedCredits}. Proceed anyway?`,
               {
                 credits_remaining: data.creditsRemaining,
@@ -288,8 +301,8 @@ class AuthManager {
                 note: 'Top up at https://www.crawlforge.dev/dashboard',
               }
             );
-            if (!proceed) return false;
-            return true; // user confirmed — let tool attempt it
+            if (gate.status === 'ask') return gate.result;
+            return gate.status === 'proceed'; // confirmed (or unaskable) — let tool attempt it
           }
           return false; // no elicitation — standard hard-fail behavior
         }

package/src/core/ChangeTracker.js

@@ -37,7 +37,7 @@ const ChangeTrackingSchema = z.object({
       moderate: z.number().min(0).max(1).default(0.3),
       major: z.number().min(0).max(1).default(0.7)
     }).optional()
-  }).optional().default({})
+  }).optional().prefault({})
 });
 
 const ChangeComparisonSchema = z.object({

package/src/core/ElicitationHelper.js

@@ -1,13 +1,83 @@
 /**
  * ElicitationHelper — MCP Elicitation for CrawlForge
  *
- * Allows tools to request user confirmation or input mid-execution for
- * expensive or ambiguous operations. Falls back gracefully when the
- * MCP client does not support elicitation.
+ * Allows tools to request user confirmation before an expensive or ambiguous
+ * operation. Falls back gracefully when the MCP client cannot be asked.
  *
- * MCP Spec 2025-11-25: client/elicit request with requestedSchema
+ * Phase 4.4 moved confirmations from an inline server→client request to the
+ * 2026-07-28 MULTI-ROUND-TRIP form: `confirm()` no longer sends anything and no
+ * longer awaits. It returns a verdict, and when the user must be asked the
+ * verdict carries an `input_required` result for the tool to RETURN. The SDK
+ * then either hands it to a 2026-era client or, on a 2025-era connection, runs
+ * its own legacy shim (real `elicitation/create` + handler re-entry). One shape
+ * serves both eras, which is why nothing here branches on the protocol version
+ * any more — the previous era guard reported "unsupported" on 2026-07-28 and
+ * every prompt there was silently skipped.
+ *
+ * THE HANDLER IS RE-ENTERED. Everything a tool does above its gate runs a
+ * second time when the answer arrives, so a gate belongs above every fetch and
+ * every side effect. Billing is not a caller's problem: `withAuth` charges an
+ * `input_required` return zero and reports no usage, so a round trip and a
+ * declined confirmation are both free (G4).
+ *
+ * Two properties of the old helper are deliberately preserved:
+ *
+ *   - **Fail-open.** A client that never declared elicitation is not asked, and
+ *     the operation proceeds. This is not politeness — the SDK answers an
+ *     `input_required` return on such a connection with `isError: true`
+ *     ("did not declare the required capability"), so dropping the capability
+ *     gate would turn a nicety into a failed call. Verified against the SDK.
+ *   - **We ask at most once.** `inputResponses` is absent on a first entry and
+ *     present on a retry, so a retry whose answer did not survive the trip
+ *     (a dropped key, an answer of another kind) proceeds rather than asking
+ *     again until the shim's round limit fails the call.
+ *
+ * The one case that cannot be preserved: a client that DECLARES elicitation and
+ * then throws answering it now yields an `isError` result from the SDK where the
+ * old inline path proceeded. The failure happens inside the SDK after the
+ * handler has returned, so nothing here can intercept it. It costs nothing — the
+ * handler did no work, so `withAuth` bills zero.
+ *
+ * Which server instance we ask matters as much as what we ask. server.js
+ * constructs this against the top-level template McpServer, but neither HTTP
+ * leg serves from it — the 2025-era path connects a clone per session and the
+ * modern leg builds one per request, so the template is never `.connect()`ed
+ * and reports no client capabilities. The transport stamps the serving clone on
+ * the request context; this resolves it from there and falls back to the
+ * injected instance, which on stdio IS the connected one. On a 2026-era request
+ * there is no connected instance to read at all — capabilities arrive per
+ * request in the `_meta` envelope, which is why `ctx` is consulted first.
  */
 
+import { inputRequired, inputResponse, CLIENT_CAPABILITIES_META_KEY } from '@modelcontextprotocol/server';
+import { servingRequestId, servingServer } from '../server/requestContext.js';
+
+/** The one-boolean schema a confirmation asks with. */
+const CONFIRM_SCHEMA = {
+  type: 'object',
+  properties: {
+    confirmed: {
+      type: 'boolean',
+      title: 'Proceed?',
+      description: 'Confirm to proceed with the operation',
+    },
+  },
+  required: ['confirmed'],
+};
+
+/**
+ * Whether the client's declared capabilities cover FORM elicitation, by the
+ * SDK's own rule: `elicitation.form` counts, and so does a bare `elicitation`
+ * declaration naming neither mode (the pre-mode 2025 meaning). A client that
+ * declared only `elicitation.url` has not declared form support.
+ */
+function formElicitationDeclared(caps) {
+  const elicitation = caps?.elicitation;
+  if (!elicitation) return false;
+  if (elicitation.form !== undefined) return true;
+  return elicitation.url === undefined;
+}
+
 export class ElicitationHelper {
   /**
    * @param {object} options
@@ -20,69 +90,101 @@ export class ElicitationHelper {
   }
 
   /**
-   * Whether the connected MCP client supports elicitation.
-   * @returns {boolean}
+   * The McpServer this request is served from: the clone the transport stamped
+   * on the request context, else the constructor-injected instance (stdio, and
+   * any caller outside a request context).
+   * @private
+   */
+  get _server() {
+    return servingServer() ?? this._mcpServer;
+  }
+
+  /**
+   * The client's declared capabilities for the request in flight. A 2026-era
+   * request carries them per-request in the `_meta` envelope and has no
+   * connected server instance to read; a 2025-era one has them on the serving
+   * instance and no envelope.
+   * @private
    */
-  get supported() {
-    const server = this._mcpServer?.server;
-    // The MCP SDK exposes elicitation via Server.elicitInput(); it is only
-    // usable when the connected CLIENT advertised the `elicitation` capability.
-    if (typeof server?.elicitInput !== 'function') return false;
+  _clientCapabilities(ctx) {
+    const fromEnvelope = ctx?.mcpReq?.envelope?.[CLIENT_CAPABILITIES_META_KEY];
+    if (fromEnvelope) return fromEnvelope;
     try {
-      const caps = server.getClientCapabilities?.();
-      return !!caps?.elicitation;
+      return this._server?.server?.getClientCapabilities?.();
     } catch {
-      return false;
+      return undefined;
     }
   }
 
+  /**
+   * Whether asking will actually reach the user rather than fail the call.
+   * @param {object} [ctx] the SDK per-request context the handler received
+   * @returns {boolean}
+   */
+  supported(ctx) {
+    return formElicitationDeclared(this._clientCapabilities(ctx));
+  }
+
   /**
    * Ask for user confirmation before proceeding with an expensive operation.
-   * Returns true if confirmed (or if elicitation is unsupported — fail-open
-   * so tools continue working in non-elicitation clients).
+   * SYNCHRONOUS — it performs no I/O. Do not `await` it.
    *
-   * @param {string} message - Human-readable explanation of what requires confirmation
-   * @param {object} [details] - Additional context (projected cost, URL count, etc.)
-   * @returns {Promise<boolean>} - true = proceed, false = cancel
+   * @param {object|undefined} ctx - the SDK per-request context the handler received
+   * @param {string} key - stable identifier for this question, unique across tools
+   * @param {string} message - human-readable explanation of what requires confirmation
+   * @param {object} [details] - additional context (projected cost, URL count, etc.)
+   * @returns {{status:'proceed'}|{status:'cancelled'}|{status:'ask', result: object}}
+   *   `ask` carries an `input_required` result the caller must RETURN verbatim.
    */
-  async confirm(message, details = {}) {
-    if (!this.supported) {
-      this._logger.warn('Elicitation not supported by client — proceeding without confirmation', { message });
-      return true;
+  confirm(ctx, key, message, details = {}) {
+    const responses = ctx?.mcpReq?.inputResponses;
+    const answered = inputResponse(responses, key);
+
+    if (answered.kind === 'elicit') {
+      // Only an explicit accept + confirmed=true proceeds; decline/cancel = stop.
+      return answered.action === 'accept' && answered.content?.confirmed === true
+        ? { status: 'proceed' }
+        : { status: 'cancelled' };
     }
 
-    try {
-      const detailLines = Object.entries(details)
-        .map(([k, v]) => `  ${k}: ${v}`)
-        .join('\n');
-      const fullMessage = detailLines ? `${message}\n\n${detailLines}` : message;
-
-      const result = await this._mcpServer.server.elicitInput({
-        message: fullMessage,
-        requestedSchema: {
-          type: 'object',
-          properties: {
-            confirmed: {
-              type: 'boolean',
-              title: 'Proceed?',
-              description: 'Confirm to proceed with the operation',
-            },
-          },
-          required: ['confirmed'],
-        },
-      });
+    // A retry carries an `inputResponses` object even when this key's answer
+    // did not survive it. Asking again would burn the shim's rounds and end in
+    // a failed call, so one unanswered round trip proceeds instead.
+    if (responses !== undefined) {
+      this._logger.warn('Elicitation answer did not come back — proceeding without confirmation', { key });
+      return { status: 'proceed' };
+    }
 
-      // Only an explicit accept + confirmed=true proceeds; decline/cancel = stop.
-      return result?.action === 'accept' && result?.content?.confirmed === true;
-    } catch (err) {
-      this._logger.warn('Elicitation request failed — proceeding without confirmation', { error: err.message });
-      return true; // fail-open
+    if (!this.supported(ctx)) {
+      this._logger.warn('Elicitation not supported by client — proceeding without confirmation', { message });
+      return { status: 'proceed' };
     }
+
+    const detailLines = Object.entries(details)
+      .map(([k, v]) => `  ${k}: ${v}`)
+      .join('\n');
+    const fullMessage = detailLines ? `${message}\n\n${detailLines}` : message;
+
+    return {
+      status: 'ask',
+      result: inputRequired({
+        inputRequests: {
+          [key]: inputRequired.elicit({ message: fullMessage, requestedSchema: CONFIRM_SCHEMA }),
+        },
+      }),
+    };
   }
 
   /**
    * Ask the user to provide a string value (e.g. missing schema field).
    *
+   * Still the 2025-era inline form, and still reached by no tool — this is the
+   * repo's one caller-less elicitation path, left as-is under G6 (dead code is
+   * reported, not deleted). It therefore keeps the era guard that `confirm()`
+   * shed: an inline request throws on a 2026-era connection, so the default is
+   * returned there rather than the call being failed. Converting it to a round
+   * trip is speculative until something calls it.
+   *
    * @param {string} message
    * @param {object} [options]
    * @param {string} [options.fieldName]
@@ -91,29 +193,47 @@ export class ElicitationHelper {
    * @returns {Promise<string|null>} - The user-provided value or null if cancelled/unsupported
    */
   async requestString(message, { fieldName = 'value', fieldDescription = '', defaultValue } = {}) {
-    if (!this.supported) {
+    const server = this._server?.server;
+    const inlineUsable = typeof server?.request === 'function'
+      && !this._modernEra(server)
+      && formElicitationDeclared(this._clientCapabilities());
+
+    if (!inlineUsable) {
       this._logger.warn('Elicitation not supported — using default value', { fieldName, defaultValue });
       return defaultValue || null;
     }
 
     try {
-      const result = await this._mcpServer.server.elicitInput({
-        message,
-        requestedSchema: {
-          type: 'object',
-          properties: {
-            [fieldName]: {
-              type: 'string',
-              title: fieldName,
-              description: fieldDescription,
-              ...(defaultValue ? { default: defaultValue } : {}),
+      // relatedRequestId ties the prompt to the tools/call in flight. Without it
+      // the 2025-era HTTP transport puts the request on the standalone GET SSE
+      // stream and drops it outright when the client never opened one.
+      const relatedRequestId = servingRequestId();
+      const result = await server.request(
+        {
+          method: 'elicitation/create',
+          params: {
+            message,
+            requestedSchema: {
+              type: 'object',
+              properties: {
+                [fieldName]: {
+                  type: 'string',
+                  title: fieldName,
+                  description: fieldDescription,
+                  ...(defaultValue ? { default: defaultValue } : {}),
+                },
+              },
+              required: [fieldName],
             },
+            mode: 'form',
           },
-          required: [fieldName],
         },
-      });
+        relatedRequestId === null ? undefined : { relatedRequestId }
+      );
 
-      if (result?.action === 'accept' && result?.content?.[fieldName] != null) {
+      // The answer is client-supplied and no longer schema-checked by the SDK
+      // on this path, so hold it to the type we asked for.
+      if (result?.action === 'accept' && typeof result?.content?.[fieldName] === 'string') {
         return result.content[fieldName];
       }
       return defaultValue || null;
@@ -122,4 +242,14 @@ export class ElicitationHelper {
       return defaultValue || null;
     }
   }
+
+  /** @private The 2026-07-28 era has no server→client request channel. */
+  _modernEra(server) {
+    try {
+      const negotiated = server?.getNegotiatedProtocolVersion?.();
+      return typeof negotiated === 'string' && negotiated >= '2026-07-28';
+    } catch {
+      return false;
+    }
+  }
 }

package/src/core/SamplingClient.js

@@ -7,7 +7,9 @@
  * Fallback chain (applied in resolveCompletion):
  *   1. Ollama (local, no API key needed)
  *   2. Server-side API key (OPENAI_API_KEY / ANTHROPIC_API_KEY)
- *   3. MCP sampling request to client
+ *   3. MCP sampling request to client — DEPRECATED in MCP revision 2026-07-28
+ *      (SEP-2577); removal on or after 2027-07-28. Emits a one-line stderr
+ *      deprecation notice when it serves a completion.
  *   4. Error
  */
 
@@ -157,7 +159,11 @@ export class SamplingClient {
           includeContext: 'none',
         });
         const text = samplingResult?.content?.text || '';
-        if (text) return { text, provider: 'sampling' };
+        if (text) {
+          // stderr, never stdout — stdout is the JSON-RPC stream on stdio.
+          console.error('[deprecation] MCP sampling served this completion. Sampling was deprecated in MCP revision 2026-07-28 (SEP-2577); CrawlForge removes this fallback on or after 2027-07-28. Run Ollama or set OPENAI_API_KEY / ANTHROPIC_API_KEY.');
+          return { text, provider: 'sampling' };
+        }
       } catch (_samplingErr) {
         // Sampling not supported or failed
       }

package/src/core/analysis/ContentAnalyzer.js

@@ -28,7 +28,7 @@ const ContentAnalyzerSchema = z.object({
     maxKeywords: z.number().min(1).max(50).default(15),
     includeReadabilityMetrics: z.boolean().default(true),
     includeSentiment: z.boolean().default(true)
-  }).optional().default({})
+  }).optional().prefault({})
 });
 
 const AnalysisResult = z.object({

package/src/core/processing/BrowserProcessor.js

@@ -74,7 +74,7 @@ const BrowserProcessorSchema = z.object({
       enableTimezoneSpoof: z.boolean().default(true),
       enableGeoLocationSpoof: z.boolean().default(true)
     }).optional()
-  }).optional().default({})
+  }).optional().prefault({})
 });
 
 const BrowserResult = z.object({

package/src/core/processing/ContentProcessor.js

@@ -20,7 +20,7 @@ const ContentProcessorSchema = z.object({
     removeBoilerplate: z.boolean().default(true),
     preserveImageInfo: z.boolean().default(true),
     extractMetadata: z.boolean().default(true)
-  }).optional().default({})
+  }).optional().prefault({})
 });
 
 const ReadabilityResult = z.object({

package/src/core/processing/PDFProcessor.js

@@ -31,8 +31,8 @@ const PDFProcessorSchema = z.object({
     parseOptions: z.object({
       normalizeWhitespace: z.boolean().default(true),
       disableCombineTextItems: z.boolean().default(false)
-    }).optional().default({})
-  }).optional().default({})
+    }).optional().prefault({})
+  }).optional().prefault({})
 });
 
 const PDFResult = z.object({

package/src/server/registerTool.js

@@ -10,7 +10,7 @@
  *   validates `structuredContent` against the schema; legacy clients keep
  *   reading the JSON-stringified `content` for backward compatibility.
  *
- * @param {import('@modelcontextprotocol/sdk/server/mcp.js').McpServer} server
+ * @param {import('@modelcontextprotocol/server').McpServer} server
  * @param {Function} withAuth  — from makeWithAuth() in src/server/withAuth.js
  * @param {Object}  descriptor
  * @param {string}  descriptor.name         — tool name (MCP identifier)