@cydm/pie 1.0.29 → 1.0.31

package/dist/chunks/{chunk-L63BJMTT.js → chunk-BOFCKEV5.js}

@@ -3968,11 +3968,12 @@ var AgentSessionQueue = class {
         clearEditor: options.clearEditor ?? true,
         visibility: options.visibility ?? "user",
         deliveredToAgent: false,
+        deliverWhileStreaming: options.deliverWhileStreaming ?? true,
         messages: [message],
         createdAt: Date.now()
       };
       this.queuedInputs.push(queuedInput);
-      if (this.getIsStreaming()) {
+      if (this.getIsStreaming() && queuedInput.deliverWhileStreaming) {
         this.deliverToAgent(queuedInput);
       }
     }
@@ -4004,11 +4005,12 @@ var AgentSessionQueue = class {
       this.emitQueueChanged();
       return;
     }
-    const delivered = this.queuedInputs.shift();
-    if (delivered) {
+    const delivered = this.queuedInputs[0];
+    if (delivered?.deliveredToAgent) {
+      this.queuedInputs.shift();
       this.emit({ type: "queued_turn_dispatched", queuedInput: cloneQueuedInput(delivered) });
+      this.emitQueueChanged();
     }
-    this.emitQueueChanged();
   }
   clear() {
     if (this.queuedInputs.length === 0 && !this.agent.hasQueuedMessages()) {
@@ -4170,6 +4172,9 @@ var AgentSessionQueueDispatcher = class {
     });
   }
   resolvePending() {
+    if (this.dispatchTimer !== void 0) {
+      return;
+    }
     const resolve3 = this.resolvePendingDispatch;
     this.pendingDispatch = void 0;
     this.resolvePendingDispatch = void 0;
@@ -5662,7 +5667,7 @@ function createAskUserCapability() {
     {
       name: "ask_user_multi",
       label: "Ask User",
-      description: `Ask one or more questions with review and back navigation. Use this for all user questioning flows, including demonstrations that should actually ask the user instead of only describing the questionnaire. When you decide to use this tool, invoke it immediately. Do not print explanatory preambles, numbered plans, or example JSON in chat before calling it. For a generic demo such as '\u6F14\u793A\u4E00\u4E0B ask \u5DE5\u5177', '\u6F14\u793A\u4E00\u4E0B\u63D0\u95EE\u5DE5\u5177', or 'ask me', ask exactly one simple single-choice question with 3-5 explicit options so the user sees a selector instead of a free-text editor. Do not switch to an open-ended or multi-question flow unless the user explicitly asks for it. Prefer the shortest valid shape. For a single question, use {"question":"Choose a color","options":["Red","Blue","Green"]}. You may also use {"prompt":"Choose a color","options":[...]} for compatibility. For multiple questions, use \`questions\`. Question ids are optional and will be auto-generated.`,
+      description: 'Ask the user one or more structured questions with review/back navigation. Invoke it directly when you need user input; do not print example JSON first. For a simple demo, ask one single-choice question with 3-5 options. Prefer the shortest shape: {"question":"Choose a color","options":["Red","Blue","Green"]}. For multiple questions, use `questions`; ids are optional.',
       parameters: AskUserMultiParamsSchema,
       async execute(toolCallIdOrArgs, maybeArgs) {
         try {
@@ -5805,9 +5810,7 @@ function createAskUserCapability() {
       requiredInteractions: ["select_one", "confirm", "text_input", "multiline_input"],
       systemPromptAdditions: [
         "When the user asks you to ask questions, collect choices, or gather structured input, call `ask_user_multi` instead of describing the questions in plain text.",
-        "When demonstrating `ask_user_multi`, call it immediately instead of first printing explanations, plans, or example JSON.",
-        "When the user asks for a generic ask-tool demo, such as '\u6F14\u793A\u4E00\u4E0B ask \u5DE5\u5177', '\u6F14\u793A\u4E00\u4E0B\u63D0\u95EE\u5DE5\u5177', or 'ask me', ask exactly one simple single-choice question with explicit options so the interaction opens as a selector.",
-        "For a single question, prefer the shortest valid argument shape such as `question` plus optional `options`."
+        "When demonstrating `ask_user_multi`, call it immediately. For a generic demo, ask one simple single-choice question with explicit options."
       ]
     }),
     tools
@@ -6305,6 +6308,13 @@ var BINARY_MAGIC_PREFIX_BYTES = 8 * 1024;
 var MAX_INLINE_IMAGE_BYTES = 20 * 1024 * 1024;
 var MAX_CROSS_HOST_LINE_NUMBER = 2147483647;
 var INLINE_IMAGE_MIME_TYPES = /* @__PURE__ */ new Set(["image/png", "image/jpeg", "image/gif", "image/webp"]);
+function createReadErrorResult(message, details) {
+  return {
+    content: [{ type: "text", text: `read_file failed: ${message}` }],
+    details,
+    isError: true
+  };
+}
 function createReadTool(cwd, options) {
   const fs2 = getFileSystem();
   const fileObservationState = options?.fileObservationState ?? createFileObservationState();
@@ -6325,13 +6335,13 @@ function createReadTool(cwd, options) {
     execute: async (_toolCallId, params, signal) => {
       const { path: path4, root, offset, limit, question } = params;
       if (offset !== void 0 && (!Number.isSafeInteger(offset) || offset < 1 || offset > MAX_CROSS_HOST_LINE_NUMBER)) {
-        throw new Error(`Invalid read_file arguments: offset must be a positive safe integer no greater than ${MAX_CROSS_HOST_LINE_NUMBER}.`);
+        return createReadErrorResult(`Invalid arguments: offset must be a positive safe integer no greater than ${MAX_CROSS_HOST_LINE_NUMBER}.`);
       }
       if (limit !== void 0 && (!Number.isSafeInteger(limit) || limit < 1 || limit > MAX_CROSS_HOST_LINE_NUMBER)) {
-        throw new Error(`Invalid read_file arguments: limit must be a positive safe integer no greater than ${MAX_CROSS_HOST_LINE_NUMBER}.`);
+        return createReadErrorResult(`Invalid arguments: limit must be a positive safe integer no greater than ${MAX_CROSS_HOST_LINE_NUMBER}.`);
       }
       if (offset !== void 0 && limit !== void 0 && offset - 1 + limit > MAX_CROSS_HOST_LINE_NUMBER) {
-        throw new Error(`Invalid read_file arguments: offset and limit exceed the ${MAX_CROSS_HOST_LINE_NUMBER}-line cross-host range.`);
+        return createReadErrorResult(`Invalid arguments: offset and limit exceed the ${MAX_CROSS_HOST_LINE_NUMBER}-line cross-host range.`);
       }
       let absolutePath;
       try {
@@ -6339,11 +6349,11 @@ function createReadTool(cwd, options) {
       } catch (error) {
         const message = error instanceof Error ? error.message : String(error);
         if (/outside sandbox|outside root|escapes sandbox/i.test(message)) {
-          throw new Error(
+          return createReadErrorResult(
             `${message}. read_file is workspace-scoped; for intentional runtime logs or temporary files outside the workspace, use bash with a bounded command such as head, tail, sed -n, or cat on that path.`
           );
         }
-        throw error;
+        return createReadErrorResult(message);
       }
       return new Promise(
         (resolve3, reject) => {
@@ -6474,6 +6484,24 @@ function createReadTool(cwd, options) {
                 });
                 return;
               }
+              const textBinaryInfo = detectTextOnlyBinary(prefix, absolutePath, stat.size > prefix.length);
+              if (textBinaryInfo) {
+                resolve3({
+                  content: [{
+                    type: "text",
+                    text: `Cannot read binary file ${path4}: ${textBinaryInfo.mimeType}. Use a file-understanding handler for supported media/documents, or inspect metadata with a bounded shell command.`
+                  }],
+                  details: {
+                    understanding: {
+                      kind: textBinaryInfo.kind,
+                      mimeType: textBinaryInfo.mimeType,
+                      fallbackReason: "binary content is not safe to display as text"
+                    }
+                  },
+                  isError: true
+                });
+                return;
+              }
               const startLine = offset === void 0 ? 0 : offset - 1;
               const startLineDisplay = startLine + 1;
               const range2 = await fs2.readTextRange(absolutePath, {
@@ -6595,7 +6623,12 @@ Base directory: ${nodePath.dirname(absolutePath)}
               });
             } catch (error) {
               if (!aborted) {
-                reject(error);
+                const message = error instanceof Error ? error.message : String(error);
+                if (/aborted/i.test(message)) {
+                  reject(error);
+                  return;
+                }
+                resolve3(createReadErrorResult(message, { path: absolutePath }));
               }
             } finally {
               signal?.removeEventListener("abort", onAbort);
@@ -6725,7 +6758,10 @@ function looksLikeBinaryText(input) {
   return characters > 0 && suspiciousControls / characters > 0.02;
 }
 function detectTextOnlyBinary(input, filePath, prefixMayBeTruncated) {
-  return detectBinaryMagic(input) ?? detectBinaryKind(filePath) ?? (looksLikeBinary(input, prefixMayBeTruncated) ? { kind: "document", mimeType: "application/octet-stream" } : void 0);
+  const magicInfo = detectBinaryMagic(input);
+  if (magicInfo) return magicInfo;
+  if (!looksLikeBinary(input, prefixMayBeTruncated)) return void 0;
+  return detectBinaryKind(filePath) ?? { kind: "document", mimeType: "application/octet-stream" };
 }
 async function readImageInfo(path4, fs2) {
   if (typeof Buffer === "undefined") {
@@ -7176,6 +7212,25 @@ function createEditErrorResult(params) {
     isError: true
   };
 }
+function createEditThrownErrorResult(message, path4) {
+  return {
+    content: [{ type: "text", text: `edit_file failed: ${message}` }],
+    details: {
+      status: "error",
+      matchKind: "none",
+      changed: false,
+      path: path4,
+      diff: "",
+      oldTextOccurrences: 0,
+      newTextOccurrences: 0,
+      replaceAll: false,
+      replacedOccurrences: 0,
+      errorReason: "old_text_not_found",
+      recoveryHint: "Check the path and read the current file before retrying."
+    },
+    isError: true
+  };
+}
 function createEditTool(cwd, options) {
   const fs2 = getFileSystem();
   const fileObservationState = options?.fileObservationState ?? createFileObservationState();
@@ -7201,8 +7256,15 @@ function createEditTool(cwd, options) {
     parameters: editSchema,
     execute: async (_toolCallId, params, signal) => {
       const { path: path4, root } = params;
-      const replacements = validateEditArgs(params);
-      const absolutePath = resolveToCwd(path4, cwd, options, root);
+      let replacements;
+      let absolutePath;
+      try {
+        replacements = validateEditArgs(params);
+        absolutePath = resolveToCwd(path4, cwd, options, root);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return createEditThrownErrorResult(message, typeof path4 === "string" ? path4 : void 0);
+      }
       return new Promise((resolve3, reject) => {
         if (signal?.aborted) {
           reject(new Error("Operation aborted"));
@@ -7225,7 +7287,7 @@ function createEditTool(cwd, options) {
               await fs2.access(absolutePath);
             } catch {
               if (signal) signal.removeEventListener("abort", onAbort);
-              reject(new Error(`File not found: ${path4}`));
+              resolve3(createEditThrownErrorResult(`File not found: ${path4}`, path4));
               return;
             }
             throwIfAborted();
@@ -7377,7 +7439,12 @@ function createEditTool(cwd, options) {
               signal.removeEventListener("abort", onAbort);
             }
             if (!aborted) {
-              reject(error);
+              const message = error instanceof Error ? error.message : String(error);
+              if (/aborted/i.test(message)) {
+                reject(error);
+                return;
+              }
+              resolve3(createEditThrownErrorResult(message, path4));
             }
           }
         })();
@@ -9527,6 +9594,13 @@ var MAX_TEXT_GREP_TOTAL_BYTES = 64 * 1024 * 1024;
 var MAX_GREP_PATTERN_LENGTH = 512;
 var MAX_GREP_CONTEXT_LINES = 20;
 var MAX_GREP_RESULT_LIMIT = 1e3;
+function boundedErrorMessage(prefix, error, hint) {
+  const message = error instanceof Error ? error.message : String(error);
+  const text = `${prefix}: ${message}
+${hint}`;
+  return text.length > 1e3 ? `${text.slice(0, 1e3)}
+[error truncated]` : text;
+}
 var SKIP_DIRS = /* @__PURE__ */ new Set([".git", "node_modules", "__pycache__", ".svn", ".hg"]);
 var BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
   ".png",
@@ -9873,7 +9947,7 @@ function createGrepTextTool(cwd, options) {
   return {
     name: "grep_text",
     label: "grep_text",
-    description: `Search file contents for a bounded regex or literal pattern. ${pathResolutionDescription} Regex evaluation is isolated by hosts that support general expressions; other hosts require a repetition-free regex or literal=true. outputMode='content' returns matching lines with file paths and line numbers, outputMode='files_with_matches' returns matching file paths, and outputMode='count' returns per-file match counts. Output is truncated to ${DEFAULT_LIMIT2} results or ${DEFAULT_MAX_BYTES / 1024}KB (whichever is hit first). Long lines are truncated to ${GREP_MAX_LINE_LENGTH} chars.`,
+    description: `Search file contents with a bounded regex or literal pattern. ${pathResolutionDescription} Use literal=true for plain text or unsafe regexes. outputMode: content (matching lines), files_with_matches, or count. Output is capped at ${DEFAULT_LIMIT2} results or ${DEFAULT_MAX_BYTES / 1024}KB; long lines cap at ${GREP_MAX_LINE_LENGTH} chars.`,
     parameters: grepSchema,
     execute: async (_toolCallId, params, signal) => {
       const {
@@ -9888,8 +9962,17 @@ function createGrepTextTool(cwd, options) {
         offset: rawOffset,
         limit
       } = params;
-      assertGrepPatternLength(pattern);
-      const fileGlobMatcher = createGrepGlobMatcher(globPattern);
+      let fileGlobMatcher;
+      try {
+        assertGrepPatternLength(pattern);
+        fileGlobMatcher = createGrepGlobMatcher(globPattern);
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: boundedErrorMessage("grep_text failed", error, "Use literal=true for plain text, shorten the pattern, or narrow the glob.") }],
+          details: { searchIncomplete: true, safetyLimit: "io_error" },
+          isError: true
+        };
+      }
       return new Promise((resolve3, reject) => {
         if (signal?.aborted) {
           reject(new Error("Operation aborted"));
@@ -9912,7 +9995,12 @@ function createGrepTextTool(cwd, options) {
               const stat = await fs2.stat(searchPath);
               isDir = stat.isDirectory;
             } catch {
-              reject(new Error(`Path not found: ${searchPath}`));
+              resolve3({
+                content: [{ type: "text", text: `grep_text failed: Path not found: ${searchPath}
+Check the path or search from the workspace root.` }],
+                details: { searchIncomplete: true, safetyLimit: "io_error" },
+                isError: true
+              });
               return;
             }
             const isGitignored = await loadGitignoreMatcher(searchPath, fs2, {
@@ -9938,7 +10026,11 @@ function createGrepTextTool(cwd, options) {
               } else {
               }
             } catch (e) {
-              reject(new Error(`Invalid regex pattern: ${e.message}`));
+              resolve3({
+                content: [{ type: "text", text: boundedErrorMessage("grep_text failed: invalid regex pattern", e, "Use literal=true for plain text, or simplify the regex.") }],
+                details: { searchIncomplete: true, safetyLimit: "io_error" },
+                isError: true
+              });
               return;
             }
             let outputLines = [];
@@ -10174,7 +10266,16 @@ function createGrepTextTool(cwd, options) {
               details: Object.keys(details).length > 0 ? details : void 0
             });
           } catch (err) {
-            reject(err);
+            const message = err instanceof Error ? err.message : String(err);
+            if (/aborted/i.test(message)) {
+              reject(err);
+              return;
+            }
+            resolve3({
+              content: [{ type: "text", text: boundedErrorMessage("grep_text failed", err, "Check the path/pattern, use literal=true for plain text, or narrow the search.") }],
+              details: { searchIncomplete: true, safetyLimit: "io_error" },
+              isError: true
+            });
           } finally {
             await regexSession?.dispose();
             signal?.removeEventListener("abort", onAbort);
@@ -10191,6 +10292,13 @@ var MAX_RESULT_LIMIT2 = 1e4;
 var MAX_SCANNED_DIRECTORIES = 1e4;
 var MAX_SCANNED_FILES = 1e4;
 var MAX_DIRECTORY_ENTRIES = 1e4;
+function boundedFindError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  const text = `find_files failed: ${message}
+Shorten the pattern, remove unsupported glob syntax, or narrow the search path.`;
+  return text.length > 1e3 ? `${text.slice(0, 1e3)}
+[error truncated]` : text;
+}
 var SKIP_DIRS2 = /* @__PURE__ */ new Set(["node_modules", ".git", "__pycache__", ".svn", ".hg"]);
 function createFindFilesMatcher(pattern) {
   assertBoundedGlobPattern(pattern, "find_files pattern");
@@ -10358,7 +10466,16 @@ function createFindFilesTool(cwd, options) {
     parameters: findSchema,
     execute: async (_toolCallId, params, signal) => {
       const { pattern, path: searchDir, root, limit } = params;
-      const matchesPattern = createFindFilesMatcher(pattern);
+      let matchesPattern;
+      try {
+        matchesPattern = createFindFilesMatcher(pattern);
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: boundedFindError(error) }],
+          details: { searchIncomplete: true },
+          isError: true
+        };
+      }
       return new Promise((resolve3, reject) => {
         if (signal?.aborted) {
           reject(new Error("Operation aborted"));
@@ -10380,7 +10497,12 @@ function createFindFilesTool(cwd, options) {
               throw new Error(`Invalid find_files arguments: limit must be between 1 and ${MAX_RESULT_LIMIT2}.`);
             }
             if (!await fs2.exists(searchPath)) {
-              reject(new Error(`Path not found: ${searchPath}`));
+              resolve3({
+                content: [{ type: "text", text: `find_files failed: Path not found: ${searchPath}
+Check the path or search from the workspace root.` }],
+                details: { searchIncomplete: true },
+                isError: true
+              });
               return;
             }
             let results;
@@ -10447,7 +10569,16 @@ function createFindFilesTool(cwd, options) {
             });
           } catch (e) {
             signal?.removeEventListener("abort", onAbort);
-            reject(e);
+            const message = e instanceof Error ? e.message : String(e);
+            if (/aborted/i.test(message)) {
+              reject(e);
+              return;
+            }
+            resolve3({
+              content: [{ type: "text", text: boundedFindError(e) }],
+              details: { searchIncomplete: true },
+              isError: true
+            });
           }
         })();
       });
@@ -12645,10 +12776,19 @@ function createSharedWebFetchTool(deps = {}) {
 
 // ../../packages/shared-headless-capabilities/src/web-research.ts
 var webResearchSchema = Type.Object({
-  query: Type.String({
+  query: Type.Optional(Type.String({
     minLength: 2,
-    description: "The research question or topic. Use for end-to-end public web research."
-  }),
+    description: "Research/search query. For url fetch mode, use as an optional extraction prompt."
+  })),
+  url: Type.Optional(Type.String({
+    description: "Specific http(s) URL to fetch and read."
+  })),
+  mode: Type.Optional(Type.Union([
+    Type.Literal("research"),
+    Type.Literal("search")
+  ], {
+    description: "Default research searches and fetches cited sources. Use search for low-level provider search results."
+  })),
   allowed_domains: Type.Optional(Type.Array(Type.String({
     description: "Only include sources from these domains. Use only when the user explicitly asks to limit sources."
   }))),
@@ -12670,12 +12810,70 @@ function isRecord5(value) {
 function textFromResult(result) {
   return result.content.filter((item) => item.type === "text" && typeof item.text === "string").map((item) => item.text).join("\n").trim();
 }
+function makeEmptyResearchDetails(params) {
+  return {
+    query: params.query,
+    actualQueries: params.actualQueries ?? [],
+    sources: params.sources ?? [],
+    fetchedSources: params.fetchedSources ?? [],
+    providerAttempts: params.providerAttempts ?? [],
+    attempts: params.attempts ?? [],
+    qualityScore: params.qualityScore ?? 0,
+    warnings: params.warnings ?? [],
+    browserRequiredSources: params.browserRequiredSources ?? [],
+    routeRankReason: params.routeRankReason,
+    latencyMetrics: {
+      totalDurationMs: Date.now() - params.totalStartedAt,
+      searchDurationMs: params.searchDurationMs ?? 0,
+      fetchDurationMs: params.fetchDurationMs ?? 0,
+      browserDurationMs: params.browserDurationMs ?? 0
+    },
+    costEstimate: {
+      status: "unknown",
+      reason: "Provider usage is not yet normalized across web research search/fetch/browser routes."
+    }
+  };
+}
 function clamp(value, min, max) {
   return Math.min(max, Math.max(min, value));
 }
 function normalizeHost(hostname) {
   return hostname.toLowerCase().replace(/^www\./, "");
 }
+function normalizeDomainFilter(value) {
+  let domain = value.trim().toLowerCase();
+  if (!domain) return void 0;
+  domain = domain.replace(/^https?:\/\//i, "");
+  domain = domain.replace(/^[^@/]+@/, "");
+  domain = domain.split(/[/?#]/)[0] || "";
+  if (domain.startsWith("[") && domain.includes("]")) {
+    domain = domain.slice(1, domain.indexOf("]"));
+  } else {
+    domain = domain.split(":")[0] || "";
+  }
+  domain = domain.replace(/^\*\./, "").replace(/^www\./, "").replace(/\.$/, "");
+  return domain || void 0;
+}
+function hostMatchesDomainFilter(hostname, filter2) {
+  const host = normalizeHost(hostname);
+  const domain = normalizeDomainFilter(filter2);
+  if (!domain) return false;
+  return host === domain || host.endsWith(`.${domain}`);
+}
+function directUrlFilterFailure(url, input) {
+  const allowedDomains = input.allowed_domains?.length ? input.allowed_domains : void 0;
+  const blockedDomains = allowedDomains ? void 0 : input.blocked_domains?.length ? input.blocked_domains : void 0;
+  if (!allowedDomains && !blockedDomains) return void 0;
+  const parsed = parseResearchUrl(url);
+  if (!parsed) return `web_research URL mode only supports http(s) URLs: ${url}`;
+  if (allowedDomains && !allowedDomains.some((domain) => hostMatchesDomainFilter(parsed.hostname, domain))) {
+    return `web_research blocked ${url}: URL host is not in allowed_domains.`;
+  }
+  if (blockedDomains?.some((domain) => hostMatchesDomainFilter(parsed.hostname, domain))) {
+    return `web_research blocked ${url}: URL host matches blocked_domains.`;
+  }
+  return void 0;
+}
 function parseResearchUrl(value) {
   const trimmed = value.trim();
   const match2 = /^(https?):\/\/([^/?#]+)([^?#]*)?(\?[^#]*)?(#.*)?$/i.exec(trimmed);
@@ -12967,7 +13165,7 @@ function createSharedWebResearchTool(deps) {
   return {
     name: "web_research",
     label: "web_research",
-    description: "Run end-to-end public web research: plan search queries, search provider-native sources, fetch credible pages, and return a cited research pack. Use for general online research, current information, official docs, news, releases, issues, and webpage summaries. Use web_search/web_fetch directly only when you need precise low-level control. Do not use bash/curl/Python as a web research fallback.",
+    description: "Canonical web tool. For normal research, pass query. To read a known page, pass url. For low-level search results only, pass query with mode='search'. Use for current information, official docs, news, releases, issues, and webpage summaries. Do not use bash/curl/Python as a web fallback.",
     parameters: webResearchSchema,
     capabilityMetadata: {
       riskClass: "network",
@@ -12986,6 +13184,8 @@ function createSharedWebResearchTool(deps) {
       const rankedCandidates = sortCandidatesByHealth(activeCandidates, currentHealth);
       const routeRankReason = describeRouteRanking(rankedCandidates.length ? rankedCandidates : activeCandidates, currentHealth);
       const query = String(input.query || "").trim();
+      const directUrl = typeof input.url === "string" ? String(input.url).trim() : "";
+      const mode = input.mode === "search" ? "search" : "research";
       const maxSources = clamp(Math.floor(input.max_sources ?? 3), 1, 8);
       const searchAttemptTimeoutMs = Math.max(1e3, deps.searchAttemptTimeoutMs ?? deps.timeoutMs ?? DEFAULT_WEB_RESEARCH_SEARCH_ATTEMPT_TIMEOUT_MS);
       const fetchAttemptTimeoutMs = Math.max(1e3, deps.fetchAttemptTimeoutMs ?? DEFAULT_WEB_RESEARCH_FETCH_ATTEMPT_TIMEOUT_MS);
@@ -13003,6 +13203,242 @@ function createSharedWebResearchTool(deps) {
       let searchDurationMs = 0;
       let fetchDurationMs = 0;
       let browserDurationMs = 0;
+      if (directUrl) {
+        if (input.allowed_domains?.length && input.blocked_domains?.length) {
+          warnings.push("Both allowed_domains and blocked_domains were provided; web_research used allowed_domains and ignored blocked_domains for provider compatibility.");
+        }
+        const filterFailure = directUrlFilterFailure(directUrl, input);
+        if (filterFailure) {
+          return {
+            content: [{ type: "text", text: filterFailure }],
+            details: makeEmptyResearchDetails({
+              query: query || directUrl,
+              actualQueries: query ? [query] : [],
+              warnings,
+              routeRankReason,
+              totalStartedAt
+            }),
+            isError: true
+          };
+        }
+        onUpdate?.({
+          content: [{ type: "text", text: `Fetching URL: ${directUrl}` }],
+          details: makeEmptyResearchDetails({ query: query || directUrl, attempts, providerAttempts, totalStartedAt, routeRankReason })
+        });
+        const startedAt = Date.now();
+        const fetchResult = await runWithDeadline(
+          (childSignal) => webFetchTool.execute("web_research_fetch_direct", { url: directUrl, prompt: query || void 0 }, childSignal),
+          fetchAttemptTimeoutMs,
+          `web_research fetch attempt timed out after ${Math.ceil(fetchAttemptTimeoutMs / 1e3)} seconds`,
+          signal
+        ).catch((error) => ({
+          content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }],
+          details: {
+            url: directUrl,
+            sourceUrl: directUrl,
+            durationMs: Date.now() - startedAt,
+            failureCategory: "timeout"
+          },
+          isError: true
+        }));
+        fetchDurationMs = Date.now() - startedAt;
+        const fetchDetails = contentDetails(fetchResult);
+        const text = textFromResult(fetchResult);
+        const fetchedSource = fetchResult.isError ? void 0 : {
+          url: directUrl,
+          finalUrl: fetchDetails.finalUrl || directUrl,
+          title: fetchDetails.title || directUrl,
+          textExcerpt: excerpt(text),
+          score: 100,
+          scoreReasons: ["direct_url"],
+          extractionMethod: fetchDetails.extractionMethod,
+          citationAnchors: fetchDetails.citationAnchors,
+          requiresBrowser: fetchDetails.requiresBrowser,
+          failureCategory: fetchDetails.failureCategory
+        };
+        const attemptsForFetch = [{
+          phase: "fetch",
+          url: directUrl,
+          status: fetchResult.isError ? "failed" : "completed",
+          failureCategory: fetchDetails.failureCategory,
+          durationMs: fetchDurationMs
+        }];
+        if (fetchDetails.requiresBrowser) {
+          const browserSource = {
+            url: directUrl,
+            finalUrl: typeof fetchDetails.finalUrl === "string" ? fetchDetails.finalUrl : directUrl,
+            title: typeof fetchDetails.title === "string" ? fetchDetails.title : directUrl,
+            score: 100,
+            scoreReasons: ["direct_url"],
+            requiresBrowser: true,
+            failureCategory: fetchDetails.failureCategory
+          };
+          if (deps.renderedPageReader) {
+            const browserStartedAt = Date.now();
+            try {
+              onUpdate?.({
+                content: [{ type: "text", text: `Reading browser-rendered URL: ${fetchDetails.finalUrl || directUrl}` }],
+                details: makeEmptyResearchDetails({
+                  query: query || directUrl,
+                  actualQueries: query ? [query] : [],
+                  sources: [{ title: browserSource.title || directUrl, url: browserSource.finalUrl || directUrl }],
+                  attempts: attemptsForFetch,
+                  warnings,
+                  browserRequiredSources: [browserSource],
+                  routeRankReason,
+                  totalStartedAt,
+                  fetchDurationMs
+                })
+              });
+              const rendered = await runWithDeadline(
+                (childSignal) => deps.renderedPageReader({ url: fetchDetails.finalUrl || directUrl, query }, childSignal),
+                browserAttemptTimeoutMs,
+                `web_research browser reader timed out after ${Math.ceil(browserAttemptTimeoutMs / 1e3)} seconds`,
+                signal
+              );
+              browserDurationMs = Date.now() - browserStartedAt;
+              const renderedSource = {
+                url: directUrl,
+                finalUrl: rendered.finalUrl || rendered.url,
+                title: rendered.title || browserSource.title || directUrl,
+                textExcerpt: excerpt(rendered.text),
+                score: 100,
+                scoreReasons: ["direct_url"],
+                extractionMethod: "browser_rendered",
+                citationAnchors: rendered.citationAnchors,
+                requiresBrowser: false,
+                browserReadSummary: {
+                  screenshotPath: rendered.screenshotPath,
+                  consoleMessageCount: rendered.consoleMessages?.length,
+                  networkRequestCount: rendered.networkRequests?.length
+                }
+              };
+              const attemptsWithBrowser = [
+                ...attemptsForFetch,
+                { phase: "browser", url: rendered.finalUrl || rendered.url, status: "completed", durationMs: browserDurationMs }
+              ];
+              return {
+                content: [{ type: "text", text: formatResearchPack(query || directUrl, [renderedSource], warnings, []) }],
+                details: makeEmptyResearchDetails({
+                  query: query || directUrl,
+                  actualQueries: query ? [query] : [],
+                  sources: [{ title: renderedSource.title || directUrl, url: renderedSource.finalUrl || directUrl }],
+                  fetchedSources: [renderedSource],
+                  attempts: attemptsWithBrowser,
+                  warnings,
+                  qualityScore: 100,
+                  routeRankReason,
+                  totalStartedAt,
+                  fetchDurationMs,
+                  browserDurationMs
+                })
+              };
+            } catch (error) {
+              browserDurationMs = Date.now() - browserStartedAt;
+              attemptsForFetch.push({
+                phase: "browser",
+                url: fetchDetails.finalUrl || directUrl,
+                status: "failed",
+                failureCategory: "requires_browser",
+                warnings: [error instanceof Error ? error.message : String(error)],
+                durationMs: browserDurationMs
+              });
+              warnings.push(`Browser reader failed for ${fetchDetails.finalUrl || directUrl}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+          }
+          return {
+            content: [{ type: "text", text: `web_research could not read ${directUrl}: the page requires browser-rendered reading and no host browser reader completed.` }],
+            details: makeEmptyResearchDetails({
+              query: query || directUrl,
+              actualQueries: query ? [query] : [],
+              sources: [{ title: browserSource.title || directUrl, url: browserSource.finalUrl || directUrl }],
+              attempts: attemptsForFetch,
+              warnings,
+              browserRequiredSources: [browserSource],
+              routeRankReason,
+              totalStartedAt,
+              fetchDurationMs,
+              browserDurationMs
+            }),
+            isError: true
+          };
+        }
+        return {
+          content: fetchResult.content,
+          details: makeEmptyResearchDetails({
+            query: query || directUrl,
+            actualQueries: query ? [query] : [],
+            sources: [{ title: fetchDetails.title || directUrl, url: fetchDetails.finalUrl || directUrl }],
+            fetchedSources: fetchedSource ? [fetchedSource] : [],
+            attempts: attemptsForFetch,
+            warnings,
+            qualityScore: fetchedSource ? 100 : 0,
+            routeRankReason,
+            totalStartedAt,
+            fetchDurationMs
+          }),
+          isError: fetchResult.isError
+        };
+      }
+      if (mode === "search") {
+        if (!query) {
+          return {
+            content: [{ type: "text", text: "web_research search mode requires a non-empty query." }],
+            details: makeEmptyResearchDetails({ query, warnings: ["missing_query"], routeRankReason, totalStartedAt }),
+            isError: true
+          };
+        }
+        const startedAt = Date.now();
+        const allowedDomains = input.allowed_domains?.length ? input.allowed_domains : void 0;
+        const blockedDomains = allowedDomains ? void 0 : input.blocked_domains;
+        const result = await runWithDeadline(
+          (childSignal) => webSearchTool.execute("web_research_search_direct", {
+            query,
+            allowed_domains: allowedDomains,
+            blocked_domains: blockedDomains
+          }, childSignal),
+          searchAttemptTimeoutMs,
+          `web_research search attempt timed out after ${Math.ceil(searchAttemptTimeoutMs / 1e3)} seconds`,
+          signal
+        ).catch((error) => ({
+          content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }],
+          details: {
+            query,
+            requestedMode: deps.getMode?.() ?? "auto",
+            providerMode: "unavailable",
+            durationSeconds: (Date.now() - startedAt) / 1e3,
+            sourceCount: 0,
+            sources: [],
+            failureCategory: "timeout"
+          },
+          isError: true
+        }));
+        searchDurationMs = Date.now() - startedAt;
+        const searchDetails = contentDetails(result);
+        return {
+          content: result.content,
+          details: makeEmptyResearchDetails({
+            query,
+            actualQueries: searchDetails.actualQueries ?? [query],
+            sources: searchDetails.sources ?? [],
+            providerAttempts: searchDetails.attempts ?? [],
+            attempts: [{
+              phase: "search",
+              query,
+              status: result.isError ? "failed" : "completed",
+              failureCategory: searchDetails.failureCategory,
+              warnings: searchDetails.qualityWarnings,
+              durationMs: searchDurationMs
+            }],
+            warnings: searchDetails.qualityWarnings ?? [],
+            qualityScore: (searchDetails.sources?.length ?? 0) > 0 ? 50 : 0,
+            routeRankReason,
+            totalStartedAt,
+            searchDurationMs
+          }),
+          isError: result.isError
+        };
+      }
       if (!query) {
         return {
           content: [{ type: "text", text: "web_research requires a non-empty query." }],
@@ -13586,9 +14022,16 @@ function createCodeIntelTool(options) {
           isError: result.isError
         };
       } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
         return {
-          content: [{ type: "text", text: `code_intel failed: ${error instanceof Error ? error.message : String(error)}` }],
-          details: { operation: input.operation, projectRoot, path: input.path, provider: "lightweight" },
+          content: [{ type: "text", text: `code_intel failed: ${message}` }],
+          details: {
+            operation: input.operation,
+            projectRoot,
+            path: input.path,
+            provider: "unavailable",
+            fallbackReason: message
+          },
           isError: true
         };
       }
@@ -13659,5 +14102,6 @@ export {
   createSharedWebSearchTool,
   createSharedWebFetchTool,
   createSharedWebResearchTool,
+  createLightweightCodeIntelProvider,
   createCodeIntelTool
 };