@herbertgao/pi-extensions 2026.8.11 → 2026.8.13

package/node_modules/pi-mcp-adapter/server-manager.ts

@@ -1,4 +1,4 @@
-import { mkdirSync } from "node:fs";
+import { mkdirSync, statSync } from "node:fs";
 import { isDeepStrictEqual } from "node:util";
 import {
   Client,
@@ -9,6 +9,7 @@ import {
   StreamableHTTPClientTransport,
   UnauthorizedError,
   type GetPromptResult,
+  type ListToolsResult,
   type ReadResourceResult,
   type CacheableRequestOptions,
   type RequestOptions,
@@ -128,6 +129,8 @@ export interface ServerConnection {
   transport: Transport;
   definition: ServerDefinition;
   tools: McpTool[];
+  /** Cache hints from the server's aggregated tools/list result. */
+  toolListHints?: Partial<Pick<ListToolsResult, "ttlMs" | "cacheScope">> | undefined;
   /** Monotonic guard against older refresh responses replacing newer notifications. */
   toolsRevision?: number;
   resources: McpResource[];
@@ -148,8 +151,20 @@ type MetadataListChangedListener = (serverName: string, reason: string) => void;
 
 export type ToolRefreshResult = "updated" | "unchanged" | "superseded" | "refresh-timeout";
 
+type ToolListCacheHints = Partial<Pick<ListToolsResult, "ttlMs" | "cacheScope">>;
+type ToolListResult = { tools: McpTool[]; hints?: ToolListCacheHints };
+
 const KEEP_ALIVE_REFRESH_TIMEOUT_MS = 5_000;
 
+export function isTransientHttpConnectError(error: unknown): boolean {
+  let current: unknown = error;
+  while (current instanceof Error) {
+    if (current instanceof SdkHttpError && current.status === 503) return true;
+    current = current.cause;
+  }
+  return false;
+}
+
 export class McpServerManager {
   private connections = new Map<string, ServerConnection>();
   private connectPromises = new Map<string, Promise<ServerConnection>>();
@@ -375,9 +390,9 @@ export class McpServerManager {
 
     const toolsRevision = expectedConnection.toolsRevision ?? 0;
     const refreshSignal = combineAbortSignals(healthOptions.signal, AbortSignal.timeout(timeout));
-    let tools: McpTool[];
+    let toolResult: ToolListResult;
     try {
-      tools = await this.fetchAllTools(expectedConnection.client, {
+      toolResult = await this.fetchAllTools(expectedConnection.client, {
         ...healthOptions,
         ...(refreshSignal ? { signal: refreshSignal } : {}),
         cacheMode: "refresh",
@@ -401,20 +416,30 @@ export class McpServerManager {
       return "superseded";
     }
 
-    if (isDeepStrictEqual(expectedConnection.tools, tools)) {
+    if (
+      isDeepStrictEqual(expectedConnection.tools, toolResult.tools) &&
+      isDeepStrictEqual(expectedConnection.toolListHints, toolResult.hints)
+    ) {
       this.retryPendingMetadataPublication(name, expectedConnection);
       return "unchanged";
     }
 
     const previousTools = expectedConnection.tools;
-    expectedConnection.tools = tools;
+    const previousToolListHints = expectedConnection.toolListHints;
+    expectedConnection.tools = toolResult.tools;
+    expectedConnection.toolListHints = toolResult.hints;
     expectedConnection.toolsRevision = toolsRevision + 1;
     try {
       await this.metadataListChangedListener?.(name, "keep-alive-refresh");
       this.pendingMetadataPublications.delete(name);
     } catch (error) {
-      if (this.connections.get(name) === expectedConnection && expectedConnection.tools === tools) {
+      if (
+        this.connections.get(name) === expectedConnection &&
+        expectedConnection.tools === toolResult.tools &&
+        expectedConnection.toolListHints === toolResult.hints
+      ) {
         expectedConnection.tools = previousTools;
+        expectedConnection.toolListHints = previousToolListHints;
         expectedConnection.toolsRevision = toolsRevision;
       }
       throw error;
@@ -488,7 +513,13 @@ export class McpServerManager {
     if (definition.command) {
       client = this.createClient(name, definition);
       let command = definition.command;
-      let args = (definition.args ?? []).map(interpolateEnvVars);
+      let args = (definition.args ?? []).map((argument) => interpolateEnvVars(argument));
+      const cwd = resolveConfigPath(definition.cwd) ?? this.defaultCwd;
+      if (cwd !== undefined) {
+        const cwdStats = statSync(cwd, { throwIfNoEntry: false });
+        if (!cwdStats) throw new Error(`MCP server "${name}" configured cwd does not exist: "${cwd}"`);
+        if (!cwdStats.isDirectory()) throw new Error(`MCP server "${name}" configured cwd is not a directory: "${cwd}"`);
+      }
 
       if (command === "npx" || command === "npm") {
         const resolved = await resolveNpxBinary(command, args, signal);
@@ -501,7 +532,6 @@ export class McpServerManager {
       throwIfAborted(signal);
 
       if (definition.pluginDataDir) mkdirSync(definition.pluginDataDir, { recursive: true });
-      const cwd = resolveConfigPath(definition.cwd) ?? this.defaultCwd;
       const stdioTransport = new StdioClientTransport({
         command,
         args,
@@ -588,12 +618,13 @@ export class McpServerManager {
 
       // Discover tools, resources, and prompts. Resource and prompt listing is
       // optional: only servers advertising the capability are queried.
-      const [tools, resources, promptResult] = await Promise.all([
+      const [toolResult, resources, promptResult] = await Promise.all([
         this.fetchAllTools(client, requestOptions),
         this.fetchAllResources(client, requestOptions),
         this.fetchAllPrompts(client, requestOptions),
       ]);
-      connection.tools = tools;
+      connection.tools = toolResult.tools;
+      connection.toolListHints = toolResult.hints;
       connection.resources = resources;
       connection.prompts = promptResult.prompts;
       connection.promptDiscoveryFailed = promptResult.failed;
@@ -651,6 +682,9 @@ export class McpServerManager {
 
   private async enrichHttpConnectionError(definition: ServerDefinition, error: unknown): Promise<Error> {
     const originalMessage = error instanceof Error ? error.message : String(error);
+    if (isTransientHttpConnectError(error)) {
+      return new Error(`${originalMessage} — endpoint is temporarily unavailable (HTTP 503)`, { cause: error });
+    }
     try {
       const probe = await probeMcpEndpoint(resolveServerUrl(definition)!);
       return new Error(`${originalMessage} — probe: ${probe.classification}`, { cause: error });
@@ -987,17 +1021,34 @@ export class McpServerManager {
     }
   }
 
-  private async fetchAllTools(client: Client, requestOptions?: CacheableRequestOptions): Promise<McpTool[]> {
+  private async fetchAllTools(client: Client, requestOptions?: CacheableRequestOptions): Promise<ToolListResult> {
     const allTools: McpTool[] = [];
     let cursor: string | undefined;
+    let hints: ToolListCacheHints | undefined;
+    let firstPage = true;
 
     do {
       const result = await client.listTools(cursor ? { cursor } : undefined, requestOptions);
+      if (firstPage) {
+        const ttlMs = typeof result.ttlMs === "number" && Number.isSafeInteger(result.ttlMs) && result.ttlMs >= 0
+          ? result.ttlMs
+          : undefined;
+        const cacheScope = result.cacheScope === "public" || result.cacheScope === "private"
+          ? result.cacheScope
+          : undefined;
+        if (ttlMs !== undefined || cacheScope !== undefined) {
+          hints = {
+            ...(ttlMs !== undefined ? { ttlMs } : {}),
+            ...(cacheScope !== undefined ? { cacheScope } : {}),
+          };
+        }
+        firstPage = false;
+      }
       allTools.push(...(result.tools ?? []));
       cursor = result.nextCursor;
     } while (cursor);
 
-    return allTools;
+    return { tools: allTools, ...(hints !== undefined ? { hints } : {}) };
   }
 
   private async fetchAllPrompts(

package/node_modules/pi-mcp-adapter/state.ts

@@ -3,12 +3,10 @@ import type { ConsentManager } from "./consent-manager.ts";
 import type { McpLifecycleManager } from "./lifecycle.ts";
 import type { McpServerManager } from "./server-manager.ts";
 import type { AuthStorageOptions } from "./mcp-auth.ts";
-import type { ToolMetadata, PromptMetadata, McpConfig, UiSessionMessages, UiStreamSummary } from "./types.ts";
+import type { ToolMetadata, PromptMetadata, McpConfig, UiSessionMessages, UiStreamSummary, McpStatusEventBus, UiServerHandle } from "./types.ts";
 import type { UiResourceHandler } from "./ui-resource-handler.ts";
-import type { UiServerHandle } from "./ui-server.ts";
 import type { McpRuntimeOwner } from "./runtime-owner.ts";
 import type { McpOAuthRuntime } from "./mcp-auth-flow.ts";
-import type { McpStatusEventBus } from "./mcp-status.ts";
 
 export interface CompletedUiSession {
   serverName: string;

package/node_modules/pi-mcp-adapter/tool-result-renderer.ts

@@ -4,7 +4,7 @@ import { type Component, Text, truncateToWidth, visibleWidth } from "@earendil-w
 type McpToolResultDetails = Record<string, unknown> & { error?: unknown };
 type McpToolContentBlock = AgentToolResult<McpToolResultDetails>["content"][number];
 
-interface RenderTheme {
+export interface RenderTheme {
   fg: (name: string, text: string) => string;
   bold?: (text: string) => string;
 }
@@ -28,7 +28,7 @@ interface McpToolRenderState {
   compactInputPreview?: string;
 }
 
-interface McpToolRenderContext {
+export interface McpToolRenderContext {
   isError: boolean;
   isPartial?: boolean;
   expanded?: boolean;
@@ -250,6 +250,13 @@ export function formatMcpDirectToolCallLines(
   return [displayName, formatJsonish(args, maxInputChars)];
 }
 
+export function formatMcpScriptToolCallLines(
+  args: { code: string },
+  maxInputChars = DEFAULT_MAX_CALL_INPUT_CHARS,
+): string[] {
+  return ["mcpScript", truncateText(args.code, maxInputChars)];
+}
+
 function renderToolCallLines(lines: string[], theme?: RenderTheme) {
   const activeTheme = theme ?? plainTheme;
   const [title = "mcp", ...rest] = lines;
@@ -314,6 +321,13 @@ export function createMcpDirectToolCallRenderer(displayName: string, options = r
   };
 }
 
+export function createMcpScriptToolCallRenderer(options = resolveMcpToolRenderOptions()) {
+  return (args: { code: string }, theme?: RenderTheme, context?: McpToolRenderContext) => {
+    if (shouldUseCompactFinalRender(options, context)) return new EmptyComponent();
+    return renderToolCallLines(formatMcpScriptToolCallLines(args), theme);
+  };
+}
+
 function blockToLines(block: McpToolContentBlock): string[] {
   if (block.type === "text") {
     return block.text.split("\n");

package/node_modules/pi-mcp-adapter/types.ts

@@ -1,5 +1,6 @@
 // types.ts - Core type definitions
 import type {
+  CallToolResult,
   ContentBlock as McpContentBlock,
   ListPromptsResult,
   ListResourcesResult,
@@ -7,7 +8,7 @@ import type {
   Transport as McpTransport,
 } from "@modelcontextprotocol/client";
 import type { TextContent, ImageContent } from "@earendil-works/pi-ai";
-import type { UiStreamMode } from "./ui-stream-types.ts";
+import type { UiStreamMode, UiStreamSummary } from "./ui-stream-types.ts";
 import type { UiToolVisibility } from "./ui-tool-visibility.ts";
 
 export type Transport = McpTransport;
@@ -43,6 +44,15 @@ export interface McpStatusSnapshot {
   readonly disabledCount: number;
 }
 
+/**
+ * Minimal event-bus surface the status publisher needs. Lives here (leaf
+ * module) so `state.ts` can reference it without importing `mcp-status.ts`,
+ * which imports the state type back — an import cycle at type level.
+ */
+export interface McpStatusEventBus {
+  emit(channel: string, data: unknown): void;
+}
+
 // Import sources for config
 export type ImportKind = 
   | "cursor" 
@@ -155,6 +165,30 @@ export interface UiHostContext {
 
 export type UiDisplayMode = "inline" | "fullscreen" | "pip";
 
+/**
+ * Live handle to a started UI tool session. Lives here (leaf module) so
+ * `state.ts` can reference it without importing `ui-server.ts`, which
+ * imports the state type back — an import cycle at type level.
+ */
+export interface UiServerHandle {
+  url: string;
+  port: number;
+  sessionToken: string;
+  serverName: string;
+  toolName: string;
+  viewer?: "browser" | "glimpse" | "suppressed";
+  windowOpen?: boolean;
+  close: (reason?: string) => void;
+  sendToolInput: (args: Record<string, unknown>) => void;
+  sendToolResult: (result: CallToolResult) => void;
+  sendResultPatch: (result: CallToolResult) => void;
+  sendToolCancelled: (reason: string) => void;
+  sendHostContext: (context: UiHostContext) => void;
+  /** Get accumulated messages from this session */
+  getSessionMessages: () => UiSessionMessages;
+  getStreamSummary: () => UiStreamSummary | undefined;
+}
+
 // Re-export stream types from the shared lightweight module.
 // This allows the example package to import stream schemas without pulling the full types.ts dependency graph.
 export {
@@ -506,6 +540,16 @@ export interface McpSettings {
   idleTimeout?: number; // minutes, default 10, 0 to disable
   requestTimeoutMs?: number; // milliseconds, overrides the SDK request timeout when > 0
   directTools?: boolean;
+  /**
+   * Validate direct-tool inputs against the advertised schema after recovering
+   * one JSON string layer for object and array properties. Defaults to false.
+   */
+  strictDirectToolArguments?: boolean;
+  /**
+   * Include the byte-bounded raw MCP result in direct-tool details. The default
+   * `lean` mode keeps the existing small details object.
+   */
+  directToolResultDetails?: "lean" | "bounded";
   /** Show the advisory when 75 or more direct tools resolve. Defaults to true. */
   warnOnLargeDirectTools?: boolean;
   /** Register the trusted MCP-only JavaScript scripting tool. Defaults to true; set false to hide it. */
@@ -642,6 +686,9 @@ export interface ServerCacheEntry {
   resources: CachedResource[];
   prompts?: CachedPrompt[];
   instructions?: string;
+  /** Server-level hints from the aggregated tools/list result. */
+  ttlMs?: ListToolsResult["ttlMs"];
+  cacheScope?: ListToolsResult["cacheScope"];
   cachedAt: number;
 }
 

package/node_modules/pi-mcp-adapter/ui-server.ts

@@ -35,10 +35,13 @@ import {
   type UiProxyRequestBody,
   type UiProxyResult,
   type UiResourceContent,
+  type UiServerHandle,
   type UiSessionMessages,
   type UiStreamSummary,
 } from "./types.ts";
 
+export type { UiServerHandle };
+
 const MAX_BODY_SIZE = 2 * 1024 * 1024;
 const ABANDONED_GRACE_MS = 60_000;
 const WATCHDOG_INTERVAL_MS = 5_000;
@@ -75,25 +78,6 @@ export interface UiServerOptions {
   onComplete?: (reason: string) => void;
 }
 
-export interface UiServerHandle {
-  url: string;
-  port: number;
-  sessionToken: string;
-  serverName: string;
-  toolName: string;
-  viewer?: "browser" | "glimpse" | "suppressed";
-  windowOpen?: boolean;
-  close: (reason?: string) => void;
-  sendToolInput: (args: Record<string, unknown>) => void;
-  sendToolResult: (result: CallToolResult) => void;
-  sendResultPatch: (result: CallToolResult) => void;
-  sendToolCancelled: (reason: string) => void;
-  sendHostContext: (context: UiHostContext) => void;
-  /** Get accumulated messages from this session */
-  getSessionMessages: () => UiSessionMessages;
-  getStreamSummary: () => UiStreamSummary | undefined;
-}
-
 export async function startUiServer(options: UiServerOptions): Promise<UiServerHandle> {
   const sessionToken = options.sessionToken ?? randomUUID();
   const uiResourceToken = randomUUID();

package/node_modules/pi-mcp-adapter/ui-session.ts

@@ -15,7 +15,8 @@ import {
   type UiStreamMode,
 } from "./types.ts";
 import { logger } from "./logger.ts";
-import { startUiServer, type UiServerHandle } from "./ui-server.ts";
+import { startUiServer } from "./ui-server.ts";
+import type { UiServerHandle } from "./types.ts";
 import { isGlimpseAvailable, openGlimpseWindow } from "./glimpse-ui.ts";
 import type { SessionRecoveryDeps } from "./session-recovery.ts";
 import { combineAbortSignals, isAbortError } from "./runtime-owner.ts";

package/node_modules/pi-mcp-adapter/utils.ts

@@ -71,18 +71,20 @@ export function getConfigPathFromArgv(): string | undefined {
   return undefined;
 }
 
-export function interpolateEnvVars(value: string): string {
+export function interpolateEnvVars(value: string): string;
+export function interpolateEnvVars(value: string, environment: NodeJS.ProcessEnv): string;
+export function interpolateEnvVars(value: string, environment: NodeJS.ProcessEnv = process.env): string {
   return value
-    .replace(/\$\{(\w+)\}/g, (_, name) => process.env[name] ?? "")
-    .replace(/\$env:(\w+)/g, (_, name) => process.env[name] ?? "")
-    .replace(/\{env:(\w+)\}/g, (_, name) => process.env[name] ?? "");
+    .replace(/\$\{(\w+)\}/g, (_, name) => environment[name] ?? "")
+    .replace(/\$env:(\w+)/g, (_, name) => environment[name] ?? "")
+    .replace(/\{env:(\w+)\}/g, (_, name) => environment[name] ?? "");
 }
 
-function getMissingEnvVars(value: string): string[] {
+function getMissingEnvVars(value: string, environment: NodeJS.ProcessEnv): string[] {
   const missing = new Set<string>();
   for (const match of value.matchAll(/\$\{(\w+)\}|\$env:(\w+)|\{env:(\w+)\}/g)) {
     const name = match[1] ?? match[2] ?? match[3];
-    if (name && process.env[name] === undefined) {
+    if (name && environment[name] === undefined) {
       missing.add(name);
     }
   }
@@ -99,17 +101,17 @@ export function toStringRecord(value: unknown): Record<string, string> | undefin
   return Object.keys(result).length > 0 ? result : undefined;
 }
 
-function interpolateSecretExpression(value: string): string {
-  if (value.startsWith("!!")) return interpolateEnvVars(value.slice(1));
-  return value.startsWith("!") ? value : interpolateEnvVars(value);
+function interpolateSecretExpression(value: string, environment: NodeJS.ProcessEnv): string {
+  if (value.startsWith("!!")) return interpolateEnvVars(value.slice(1), environment);
+  return value.startsWith("!") ? value : interpolateEnvVars(value, environment);
 }
 
-export function interpolateEnvRecord(values: Record<string, string> | undefined): Record<string, string> | undefined {
+export function interpolateEnvRecord(values: Record<string, string> | undefined, environment: NodeJS.ProcessEnv = process.env): Record<string, string> | undefined {
   if (!values) return undefined;
 
   return Object.fromEntries(Object.entries(values).map(([key, value]) => [
     key,
-    interpolateSecretExpression(value),
+    interpolateSecretExpression(value, environment),
   ]));
 }
 
@@ -164,18 +166,18 @@ export function resolveCommandSecretsRecord(
   ]));
 }
 
-export function resolveServerUrl(definition: Pick<ServerEntry, "url">): string | undefined {
+export function resolveServerUrl(definition: Pick<ServerEntry, "url">, environment: NodeJS.ProcessEnv = process.env): string | undefined {
   if (definition.url == null) return undefined;
   if (typeof definition.url !== "string") {
     throw new Error("MCP server URL must be a string");
   }
 
-  const missing = getMissingEnvVars(definition.url);
+  const missing = getMissingEnvVars(definition.url, environment);
   if (missing.length > 0) {
     throw new Error(`Missing environment variable${missing.length === 1 ? "" : "s"} in MCP server URL: ${missing.join(", ")}`);
   }
 
-  const resolved = interpolateEnvVars(definition.url);
+  const resolved = interpolateEnvVars(definition.url, environment);
   try {
     new URL(resolved);
   } catch (error) {
@@ -184,10 +186,10 @@ export function resolveServerUrl(definition: Pick<ServerEntry, "url">): string |
   return resolved;
 }
 
-export function resolveConfigPath(value: string | undefined): string | undefined {
+export function resolveConfigPath(value: string | undefined, environment: NodeJS.ProcessEnv = process.env): string | undefined {
   if (value === undefined) return undefined;
 
-  const resolved = interpolateEnvVars(value);
+  const resolved = interpolateEnvVars(value, environment);
   if (resolved === "~") return homedir();
   if (resolved.startsWith("~/") || resolved.startsWith("~\\")) {
     return join(homedir(), resolved.slice(2));
@@ -195,11 +197,11 @@ export function resolveConfigPath(value: string | undefined): string | undefined
   return resolved;
 }
 
-export function resolveBearerToken(definition: Pick<ServerEntry, "bearerToken" | "bearerTokenEnv">): string | undefined {
+export function resolveBearerToken(definition: Pick<ServerEntry, "bearerToken" | "bearerTokenEnv">, environment: NodeJS.ProcessEnv = process.env): string | undefined {
   if (definition.bearerToken !== undefined) {
-    return interpolateSecretExpression(definition.bearerToken);
+    return interpolateSecretExpression(definition.bearerToken, environment);
   }
-  return definition.bearerTokenEnv ? process.env[definition.bearerTokenEnv] : undefined;
+  return definition.bearerTokenEnv ? environment[definition.bearerTokenEnv] : undefined;
 }
 
 /** Remove OSC control strings, including payloads that have no terminator. */

package/node_modules/pi-web-access/CHANGELOG.md

@@ -4,6 +4,32 @@ All notable changes to this project will be documented in this file.
 
 ## [Unreleased]
 
+## [0.25.0] - 2026-08-25
+
+### Highlights
+- `web_search`, `source_check`, and `fetch_content` can now use an explicit HTTP(S) proxy for restricted networks.
+- `fetch_content` now gives useful GitHub PR and issue summaries, including comments, review threads, anchors, and truncation markers.
+- Gemini users can choose browser cookie profiles more predictably and can use Google Application Default Credentials for Gemini generate-content calls.
+- Kimi Code Plan users can run explicit Kimi web searches through Pi's `kimi-coding` login.
+- HTML extraction, missing-page guidance, and stored-content lookup are more reliable.
+
+### Added
+- Added an optional `proxy` parameter to `web_search`, `source_check`, and `fetch_content`. When set, search APIs, page fetches, and content extraction use `curl` through that proxy. Localhost and `NO_PROXY` hosts still bypass the proxy. A default proxy can also be set with `"proxy"` in `~/.pi/web-search.json`. Thanks to [@mystery4f](https://github.com/mystery4f) for PR #307.
+- Added deterministic Chromium cookie selection with `browserCookies.browser` and `browserCookies.profile`; arbitrary profile paths remain unsupported. Thanks to [@lmilojevicc](https://github.com/lmilojevicc) for issue #297.
+- Added GitHub PR and issue specialization in `fetch_content`, with `gh`-first metadata, bounded REST fallback, comment anchors, review threads, truncation markers, and the `githubPrIssue.enabled` opt-out (#294).
+- Added explicit-only Kimi Code Plan search using Pi's refreshed `kimi-coding` OAuth credentials. Thanks to [@lushangkan](https://github.com/lushangkan) for PR #275.
+- Added opt-in `searchRouting.useCurrentModel` routing for automatic searches. Official OpenAI GPT Responses models can now fund Hosted Search with their current endpoint, credentials, and headers before configured fallbacks. Thanks to [@nyankosama](https://github.com/nyankosama) for PR #293.
+- Added strict Hosted Search response validation and better fallback classification for unsupported Hosted Search tools.
+- Added current-model Hosted Search routing for official `openai-codex` GPT Responses models through the Codex Responses endpoint.
+- Added Google Application Default Credentials support for Gemini generate-content calls with `geminiAuth: "adc"`. This covers Gemini search, URL context, PDF, and inline-data extraction through Vertex AI. YouTube and local video analysis still require `GEMINI_API_KEY` because they use the Gemini Files API. Thanks to [@smazurov](https://github.com/smazurov) for PR #301.
+
+### Fixed
+- Added Defuddle as a local fallback when Readability and RSC extraction cannot recover useful HTML content. Thanks to [@tobru](https://github.com/tobru) for issue #300.
+- Kept Gemini ADC config and credential errors, GitHub PR/issue REST fallback failures, and Defuddle fallback failures visible instead of silently downgrading them.
+- Pointed definitive `fetch_content` 404/410 failures to search guidance instead of provider configuration. Thanks to [@Daniishkhan](https://github.com/Daniishkhan) for PR #308.
+- Improved Gemini Web browser-cookie diagnostics so `/google-account` shows sanitized attempted browser/profile entries and distinguishes missing required cookies, password-store access, and decryption failures. Thanks to [@lmilojevicc](https://github.com/lmilojevicc) for issue #296.
+- Made `get_search_content` tolerate bridge defaults when `findText` is supplied, while preserving ordinary pagination. Thanks to [@ZacharyQin](https://github.com/ZacharyQin) for PR #295.
+
 ## [0.24.2] - 2026-08-22
 
 ### Highlights