@rdmind/rdmind 0.2.3-alpha.2 → 0.2.3-alpha.4

package/cli.js

@@ -26301,21 +26301,21 @@ var init_from = __esm({
     init_fetch_blob();
     ({ stat } = fs2);
     blobFromSync = /* @__PURE__ */ __name((path134, type) => fromBlob(statSync(path134), path134, type), "blobFromSync");
-    blobFrom = /* @__PURE__ */ __name((path134, type) => stat(path134).then((stat10) => fromBlob(stat10, path134, type)), "blobFrom");
-    fileFrom = /* @__PURE__ */ __name((path134, type) => stat(path134).then((stat10) => fromFile(stat10, path134, type)), "fileFrom");
+    blobFrom = /* @__PURE__ */ __name((path134, type) => stat(path134).then((stat11) => fromBlob(stat11, path134, type)), "blobFrom");
+    fileFrom = /* @__PURE__ */ __name((path134, type) => stat(path134).then((stat11) => fromFile(stat11, path134, type)), "fileFrom");
     fileFromSync = /* @__PURE__ */ __name((path134, type) => fromFile(statSync(path134), path134, type), "fileFromSync");
-    fromBlob = /* @__PURE__ */ __name((stat10, path134, type = "") => new fetch_blob_default([new BlobDataItem({
+    fromBlob = /* @__PURE__ */ __name((stat11, path134, type = "") => new fetch_blob_default([new BlobDataItem({
       path: path134,
-      size: stat10.size,
-      lastModified: stat10.mtimeMs,
+      size: stat11.size,
+      lastModified: stat11.mtimeMs,
       start: 0
     })], { type }), "fromBlob");
-    fromFile = /* @__PURE__ */ __name((stat10, path134, type = "") => new file_default([new BlobDataItem({
+    fromFile = /* @__PURE__ */ __name((stat11, path134, type = "") => new file_default([new BlobDataItem({
       path: path134,
-      size: stat10.size,
-      lastModified: stat10.mtimeMs,
+      size: stat11.size,
+      lastModified: stat11.mtimeMs,
       start: 0
-    })], basename(path134), { type, lastModified: stat10.mtimeMs }), "fromFile");
+    })], basename(path134), { type, lastModified: stat11.mtimeMs }), "fromFile");
     BlobDataItem = class _BlobDataItem {
       static {
         __name(this, "BlobDataItem");
@@ -123779,18 +123779,18 @@ var require_async = __commonJS({
       ];
     }, "defaultPaths");
     var defaultIsFile = /* @__PURE__ */ __name(function isFile3(file, cb) {
-      fs122.stat(file, function(err, stat10) {
+      fs122.stat(file, function(err, stat11) {
         if (!err) {
-          return cb(null, stat10.isFile() || stat10.isFIFO());
+          return cb(null, stat11.isFile() || stat11.isFIFO());
         }
         if (err.code === "ENOENT" || err.code === "ENOTDIR") return cb(null, false);
         return cb(err);
       });
     }, "isFile");
     var defaultIsDir = /* @__PURE__ */ __name(function isDirectory(dir, cb) {
-      fs122.stat(dir, function(err, stat10) {
+      fs122.stat(dir, function(err, stat11) {
         if (!err) {
-          return cb(null, stat10.isDirectory());
+          return cb(null, stat11.isDirectory());
         }
         if (err.code === "ENOENT" || err.code === "ENOTDIR") return cb(null, false);
         return cb(err);
@@ -124286,21 +124286,21 @@ var require_sync = __commonJS({
     }, "defaultPaths");
     var defaultIsFile = /* @__PURE__ */ __name(function isFile3(file) {
       try {
-        var stat10 = fs122.statSync(file, { throwIfNoEntry: false });
+        var stat11 = fs122.statSync(file, { throwIfNoEntry: false });
       } catch (e4) {
         if (e4 && (e4.code === "ENOENT" || e4.code === "ENOTDIR")) return false;
         throw e4;
       }
-      return !!stat10 && (stat10.isFile() || stat10.isFIFO());
+      return !!stat11 && (stat11.isFile() || stat11.isFIFO());
     }, "isFile");
     var defaultIsDir = /* @__PURE__ */ __name(function isDirectory(dir) {
       try {
-        var stat10 = fs122.statSync(dir, { throwIfNoEntry: false });
+        var stat11 = fs122.statSync(dir, { throwIfNoEntry: false });
       } catch (e4) {
         if (e4 && (e4.code === "ENOENT" || e4.code === "ENOTDIR")) return false;
         throw e4;
       }
-      return !!stat10 && stat10.isDirectory();
+      return !!stat11 && stat11.isDirectory();
     }, "isDirectory");
     var defaultRealpathSync = /* @__PURE__ */ __name(function realpathSync8(x3) {
       try {
@@ -124726,14 +124726,14 @@ var require_require_in_the_middle = __commonJS({
           moduleName2 = parsedPath.name;
           basedir = parsedPath.dir;
         } else {
-          const stat10 = moduleDetailsFromPath(filename);
-          if (stat10 === void 0) {
+          const stat11 = moduleDetailsFromPath(filename);
+          if (stat11 === void 0) {
             debug3("could not parse filename: %s", filename);
             return exports3;
           }
-          moduleName2 = stat10.name;
-          basedir = stat10.basedir;
-          const fullModuleName = resolveModuleName(stat10);
+          moduleName2 = stat11.name;
+          basedir = stat11.basedir;
+          const fullModuleName = resolveModuleName(stat11);
           debug3("resolved filename to module: %s (id: %s, resolved: %s, basedir: %s)", moduleName2, id, fullModuleName, basedir);
           let matchFound = false;
           if (hasWhitelist) {
@@ -124797,9 +124797,9 @@ var require_require_in_the_middle = __commonJS({
         }
       }
     };
-    function resolveModuleName(stat10) {
-      const normalizedPath = path134.sep !== "/" ? stat10.path.split(path134.sep).join("/") : stat10.path;
-      return path134.posix.join(stat10.name, normalizedPath).replace(normalize11, "");
+    function resolveModuleName(stat11) {
+      const normalizedPath = path134.sep !== "/" ? stat11.path.split(path134.sep).join("/") : stat11.path;
+      return path134.posix.join(stat11.name, normalizedPath).replace(normalize11, "");
     }
     __name(resolveModuleName, "resolveModuleName");
   }
@@ -133331,6 +133331,8 @@ var init_tokenLimits = __esm({
       // some Sonnet 3.7/Opus variants advertise 1M beta in docs
       [/^claude-sonnet-4.*$/, LIMITS["1m"]],
       [/^claude-opus-4.*$/, LIMITS["1m"]],
+      // Claude Opus 4, 4.1, 4.5 all have 200K context (using 1M as upper bound)
+      [/^claude-haiku-4.*$/, LIMITS["200k"]],
       // -------------------
       // Alibaba / Qwen
       // -------------------
@@ -146025,6 +146027,827 @@ var init_geminiContentGenerator = __esm({
   }
 });
 
+// packages/core/src/core/vertexAnthropicContentGenerator.ts
+var vertexAnthropicContentGenerator_exports = {};
+__export(vertexAnthropicContentGenerator_exports, {
+  VertexAnthropicContentGenerator: () => VertexAnthropicContentGenerator
+});
+var DefaultTelemetryService2, VertexAnthropicContentGenerator;
+var init_vertexAnthropicContentGenerator = __esm({
+  "packages/core/src/core/vertexAnthropicContentGenerator.ts"() {
+    "use strict";
+    init_esbuild_shims();
+    init_node();
+    init_errorHandler();
+    init_loggers();
+    init_types();
+    init_openaiLogger();
+    DefaultTelemetryService2 = class {
+      constructor(config2, enableLogging = false, loggingDir) {
+        this.config = config2;
+        this.enableLogging = enableLogging;
+        this.logger = new OpenAILogger(loggingDir);
+      }
+      static {
+        __name(this, "DefaultTelemetryService");
+      }
+      logger;
+      async logSuccess(context2, response, request4, rawResponse) {
+        const responseEvent = new ApiResponseEvent(
+          response.responseId || "unknown",
+          context2.model,
+          context2.duration,
+          context2.userPromptId,
+          context2.authType,
+          response.usageMetadata
+        );
+        logApiResponse(this.config, responseEvent);
+        if (this.enableLogging && request4 && rawResponse) {
+          await this.logger.logInteraction(request4, rawResponse);
+        }
+      }
+      async logError(context2, error2, request4) {
+        const errorMessage = error2 instanceof Error ? error2.message : String(error2);
+        const apiError = error2;
+        const errorEvent = new ApiErrorEvent(
+          apiError?.requestID || "unknown",
+          context2.model,
+          errorMessage,
+          context2.duration,
+          context2.userPromptId,
+          context2.authType,
+          apiError?.type,
+          apiError?.code
+        );
+        logApiError(this.config, errorEvent);
+        if (this.enableLogging && request4) {
+          await this.logger.logInteraction(request4, void 0, error2);
+        }
+      }
+      async logStreamingSuccess(context2, responses, request4, _chunks, combinedResponse) {
+        const finalUsageMetadata = responses.slice().reverse().find((r5) => r5.usageMetadata)?.usageMetadata;
+        const lastResponse = responses[responses.length - 1];
+        const responseEvent = new ApiResponseEvent(
+          lastResponse?.responseId || "unknown",
+          context2.model,
+          context2.duration,
+          context2.userPromptId,
+          context2.authType,
+          finalUsageMetadata
+        );
+        logApiResponse(this.config, responseEvent);
+        if (this.enableLogging && request4 && combinedResponse) {
+          await this.logger.logInteraction(request4, combinedResponse);
+        }
+      }
+    };
+    VertexAnthropicContentGenerator = class {
+      static {
+        __name(this, "VertexAnthropicContentGenerator");
+      }
+      baseUrl;
+      apiKey;
+      samplingParams;
+      reasoning;
+      cliConfig;
+      telemetryService;
+      errorHandler;
+      constructor(config2, cliConfig) {
+        this.baseUrl = config2.baseUrl || "";
+        this.apiKey = config2.apiKey || "";
+        this.samplingParams = config2.samplingParams;
+        this.reasoning = config2.reasoning;
+        this.cliConfig = cliConfig;
+        if (!this.apiKey) {
+          throw new Error("API key is required for Vertex Anthropic");
+        }
+        if (!this.baseUrl) {
+          throw new Error("Base URL is required for Vertex Anthropic");
+        }
+        if (cliConfig) {
+          this.telemetryService = new DefaultTelemetryService2(
+            cliConfig,
+            config2.enableOpenAILogging,
+            config2.openAILoggingDir
+          );
+        } else {
+          this.telemetryService = {
+            logSuccess: /* @__PURE__ */ __name(async () => {
+            }, "logSuccess"),
+            logError: /* @__PURE__ */ __name(async () => {
+            }, "logError"),
+            logStreamingSuccess: /* @__PURE__ */ __name(async () => {
+            }, "logStreamingSuccess")
+          };
+        }
+        this.errorHandler = new EnhancedErrorHandler(
+          (error2, _request) => this.shouldSuppressErrorLogging(error2, _request)
+        );
+      }
+      shouldSuppressErrorLogging(_error, _request) {
+        return false;
+      }
+      getRequestUrl(action) {
+        return `${this.baseUrl}:${action}`;
+      }
+      async fetchApi(url2, body, signal) {
+        const headers = {
+          "Content-Type": "application/json",
+          "api-key": this.apiKey
+        };
+        if (this.cliConfig?.getDebugMode()) {
+          console.debug(
+            `[VertexAnthropicContentGenerator] Request URL: ${url2}`
+          );
+          console.debug(
+            `[VertexAnthropicContentGenerator] Request body:`,
+            JSON.stringify(body, null, 2)
+          );
+        }
+        const response = await fetch(url2, {
+          method: "POST",
+          headers,
+          body: JSON.stringify(body),
+          signal
+        });
+        if (!response.ok) {
+          const errorText = await response.text();
+          if (this.cliConfig?.getDebugMode()) {
+            console.error(
+              `[VertexAnthropicContentGenerator] API Error (${response.status}):`,
+              errorText
+            );
+          }
+          throw new Error(
+            `Vertex Anthropic API request failed: ${response.status} ${response.statusText} - ${errorText}`
+          );
+        }
+        return response;
+      }
+      async convertGeminiRequestToVertexAnthropic(request4) {
+        const messages = [];
+        let systemInstruction;
+        if (request4.config?.systemInstruction) {
+          if (typeof request4.config.systemInstruction === "string") {
+            systemInstruction = request4.config.systemInstruction;
+          } else if ("parts" in request4.config.systemInstruction && Array.isArray(request4.config.systemInstruction.parts)) {
+            systemInstruction = request4.config.systemInstruction.parts.filter((p2) => typeof p2 === "object" && "text" in p2).map((p2) => p2.text).join("\n");
+          }
+        }
+        const contents = Array.isArray(request4.contents) ? request4.contents : [request4.contents];
+        for (const content of contents) {
+          if (typeof content === "string") {
+            messages.push({ role: "user", content });
+          } else if ("role" in content && "parts" in content && content.parts) {
+            const role = content.role === "model" ? "assistant" : "user";
+            const contentBlocks = this.convertPartsToAnthropicBlocks(content.parts);
+            if (contentBlocks.length > 0) {
+              if (contentBlocks.length === 1 && contentBlocks[0].type === "text") {
+                messages.push({ role, content: contentBlocks[0].text });
+              } else {
+                messages.push({ role, content: contentBlocks });
+              }
+            }
+          }
+        }
+        const temperature = this.samplingParams?.temperature ?? 1;
+        const thinking = this.buildThinkingConfig(request4);
+        const defaultMaxTokens = thinking ? thinking.budget_tokens + 16e3 : 1e4;
+        const maxTokens = this.samplingParams?.max_tokens ?? defaultMaxTokens;
+        const vertexRequest = {
+          anthropic_version: "vertex-2023-10-16",
+          messages,
+          max_tokens: maxTokens,
+          temperature
+        };
+        if (systemInstruction) {
+          vertexRequest.system = systemInstruction;
+        }
+        if (this.samplingParams?.top_p !== void 0) {
+          vertexRequest.top_p = this.samplingParams.top_p;
+        }
+        if (this.samplingParams?.top_k !== void 0) {
+          vertexRequest.top_k = this.samplingParams.top_k;
+        }
+        if (thinking) {
+          vertexRequest.thinking = thinking;
+        }
+        if (request4.config?.tools && request4.config.tools.length > 0) {
+          const tools = await this.convertGeminiToolsToAnthropic(
+            request4.config.tools
+          );
+          if (tools.length > 0) {
+            vertexRequest.tools = tools;
+          }
+        }
+        return vertexRequest;
+      }
+      buildThinkingConfig(request4) {
+        if (request4.config?.thinkingConfig?.includeThoughts === false) {
+          return void 0;
+        }
+        const reasoning = this.reasoning;
+        if (reasoning === false) {
+          return void 0;
+        }
+        if (reasoning?.budget_tokens !== void 0) {
+          return {
+            type: "enabled",
+            budget_tokens: reasoning.budget_tokens
+          };
+        }
+        const effort = reasoning?.effort ?? "medium";
+        const budgetTokens = effort === "low" ? 16e3 : effort === "high" ? 64e3 : 32e3;
+        return {
+          type: "enabled",
+          budget_tokens: budgetTokens
+        };
+      }
+      /**
+       * 将 Gemini Part 数组转换为 Anthropic 内容块数组
+       */
+      convertPartsToAnthropicBlocks(parts) {
+        const blocks = [];
+        for (const part of parts) {
+          const block2 = this.convertPartToAnthropicBlock(part);
+          if (block2) {
+            blocks.push(block2);
+          }
+        }
+        return blocks;
+      }
+      /**
+       * 将单个 Gemini Part 转换为 Anthropic 内容块
+       */
+      convertPartToAnthropicBlock(part) {
+        if ("text" in part && "thought" in part && part.thought) {
+          const thinkingBlock = {
+            type: "thinking",
+            thinking: part.text || ""
+          };
+          if ("thoughtSignature" in part && typeof part.thoughtSignature === "string") {
+            thinkingBlock.signature = part.thoughtSignature;
+          }
+          return thinkingBlock;
+        }
+        if ("text" in part && part.text && !("thought" in part && part.thought)) {
+          return { type: "text", text: part.text };
+        }
+        if (part.inlineData?.mimeType && part.inlineData?.data) {
+          const mimeType = part.inlineData.mimeType;
+          if (this.isSupportedImageMimeType(mimeType)) {
+            return {
+              type: "image",
+              source: {
+                type: "base64",
+                media_type: mimeType,
+                data: part.inlineData.data
+              }
+            };
+          }
+          if (mimeType === "application/pdf") {
+            return {
+              type: "document",
+              source: {
+                type: "base64",
+                media_type: "application/pdf",
+                data: part.inlineData.data
+              }
+            };
+          }
+          const displayName = part.inlineData.displayName ? ` (${part.inlineData.displayName})` : "";
+          return {
+            type: "text",
+            text: `[Unsupported media type: ${mimeType}${displayName}]`
+          };
+        }
+        if (part.fileData?.mimeType && part.fileData?.fileUri) {
+          return {
+            type: "text",
+            text: `[External file reference: ${part.fileData.fileUri}]`
+          };
+        }
+        if ("functionCall" in part && part.functionCall) {
+          return {
+            type: "tool_use",
+            id: part.functionCall.id || `tool_${Date.now()}`,
+            name: part.functionCall.name || "",
+            input: part.functionCall.args || {}
+          };
+        }
+        if ("functionResponse" in part && part.functionResponse) {
+          const response = part.functionResponse;
+          let content;
+          if (response.response) {
+            content = JSON.stringify(response.response);
+          } else {
+            content = "";
+          }
+          return {
+            type: "tool_result",
+            tool_use_id: response.id || "",
+            content
+          };
+        }
+        return null;
+      }
+      /**
+       * 检查是否是 Anthropic 支持的图片类型
+       */
+      isSupportedImageMimeType(mimeType) {
+        return mimeType === "image/jpeg" || mimeType === "image/png" || mimeType === "image/gif" || mimeType === "image/webp";
+      }
+      /**
+       * 将 Gemini 工具定义转换为 Anthropic 格式
+       * 参考 AnthropicContentConverter.convertGeminiToolsToAnthropic
+       */
+      async convertGeminiToolsToAnthropic(geminiTools) {
+        const tools = [];
+        if (!geminiTools) {
+          return tools;
+        }
+        for (const tool of geminiTools) {
+          let actualTool;
+          const toolObj = tool;
+          if ("tool" in toolObj && typeof toolObj["tool"] === "function") {
+            actualTool = await toolObj["tool"]();
+          } else {
+            actualTool = tool;
+          }
+          if (!actualTool.functionDeclarations) {
+            continue;
+          }
+          for (const func of actualTool.functionDeclarations) {
+            if (!func.name) continue;
+            let inputSchema;
+            if (func.parametersJsonSchema) {
+              inputSchema = {
+                ...func.parametersJsonSchema
+              };
+            } else if (func.parameters) {
+              inputSchema = func.parameters;
+            }
+            if (!inputSchema) {
+              inputSchema = { type: "object", properties: {} };
+            }
+            if (typeof inputSchema["type"] !== "string") {
+              inputSchema["type"] = "object";
+            }
+            tools.push({
+              name: func.name,
+              description: func.description,
+              input_schema: inputSchema
+            });
+          }
+        }
+        return tools;
+      }
+      convertVertexAnthropicResponseToGemini(response) {
+        const parts = [];
+        for (const content of response.content) {
+          if (content.type === "text" && content.text) {
+            parts.push({ text: content.text });
+          } else if (content.type === "thinking" && content.thinking) {
+            const thinkingPart = { text: content.thinking, thought: true };
+            if (content.signature) {
+              thinkingPart.thoughtSignature = content.signature;
+            }
+            parts.push(thinkingPart);
+          } else if (content.type === "tool_use" && content.name && content.id) {
+            parts.push({
+              functionCall: {
+                name: content.name,
+                args: content.input || {},
+                id: content.id
+              }
+            });
+          }
+        }
+        const result = {
+          responseId: response.id,
+          modelVersion: response.model,
+          candidates: [
+            {
+              content: {
+                parts,
+                role: "model"
+              },
+              index: 0,
+              finishReason: this.mapFinishReason(response.stop_reason),
+              safetyRatings: []
+            }
+          ],
+          promptFeedback: { safetyRatings: [] },
+          usageMetadata: {
+            promptTokenCount: response.usage.input_tokens,
+            candidatesTokenCount: response.usage.output_tokens,
+            totalTokenCount: response.usage.input_tokens + response.usage.output_tokens
+          }
+        };
+        return result;
+      }
+      mapFinishReason(stopReason) {
+        if (!stopReason) {
+          return void 0;
+        }
+        switch (stopReason) {
+          case "end_turn":
+            return FinishReason.STOP;
+          case "max_tokens":
+            return FinishReason.MAX_TOKENS;
+          case "stop_sequence":
+            return FinishReason.STOP;
+          case "tool_use":
+            return FinishReason.STOP;
+          default:
+            return FinishReason.OTHER;
+        }
+      }
+      /**
+       * 安全解析 JSON，失败时返回默认值
+       */
+      safeJsonParse(jsonStr, defaultValue) {
+        try {
+          return JSON.parse(jsonStr);
+        } catch {
+          return defaultValue;
+        }
+      }
+      async generateContent(request4, userPromptId) {
+        const startTime = Date.now();
+        const context2 = {
+          userPromptId,
+          model: request4.model,
+          authType: "xhs-sso",
+          startTime,
+          duration: 0,
+          isStreaming: false
+        };
+        try {
+          const url2 = this.getRequestUrl("rawPredict");
+          const body = await this.convertGeminiRequestToVertexAnthropic(request4);
+          const response = await this.fetchApi(
+            url2,
+            body,
+            request4.config?.abortSignal
+          );
+          const data = await response.json();
+          context2.duration = Date.now() - startTime;
+          const geminiResponse = this.convertVertexAnthropicResponseToGemini(data);
+          await this.telemetryService.logSuccess(context2, geminiResponse, body, data);
+          return geminiResponse;
+        } catch (error2) {
+          context2.duration = Date.now() - startTime;
+          await this.telemetryService.logError(context2, error2, request4);
+          return this.errorHandler.handle(error2, context2, request4);
+        }
+      }
+      async generateContentStream(request4, userPromptId) {
+        const startTime = Date.now();
+        const context2 = {
+          userPromptId,
+          model: request4.model,
+          authType: "xhs-sso",
+          startTime,
+          duration: 0,
+          isStreaming: true
+        };
+        try {
+          const url2 = this.getRequestUrl("streamRawPredict");
+          const baseBody = await this.convertGeminiRequestToVertexAnthropic(request4);
+          const body = {
+            ...baseBody,
+            stream: true
+          };
+          const response = await this.fetchApi(
+            url2,
+            body,
+            request4.config?.abortSignal
+          );
+          if (!response.body) {
+            throw new Error("Response body is null");
+          }
+          const stream2 = this.handleStream(response.body);
+          const collectedResponses = [];
+          return async function* () {
+            try {
+              for await (const chunk of stream2) {
+                collectedResponses.push(chunk);
+                yield chunk;
+              }
+              context2.duration = Date.now() - startTime;
+              const combinedResponse = this.combineResponses(collectedResponses);
+              await this.telemetryService.logStreamingSuccess(
+                context2,
+                collectedResponses,
+                body,
+                void 0,
+                combinedResponse
+              );
+            } catch (error2) {
+              context2.duration = Date.now() - startTime;
+              await this.telemetryService.logError(context2, error2, body);
+              throw error2;
+            }
+          }.call(this);
+        } catch (error2) {
+          context2.duration = Date.now() - startTime;
+          await this.telemetryService.logError(context2, error2, request4);
+          return this.errorHandler.handle(error2, context2, request4);
+        }
+      }
+      combineResponses(responses) {
+        if (responses.length === 0) {
+          return {};
+        }
+        const lastResponse = responses[responses.length - 1];
+        let combinedText = "";
+        for (const response of responses) {
+          if (response.candidates && response.candidates[0]?.content?.parts) {
+            for (const part of response.candidates[0].content.parts) {
+              if ("text" in part && part.text) {
+                combinedText += part.text;
+              }
+            }
+          }
+        }
+        return {
+          ...lastResponse,
+          candidates: lastResponse.candidates ? [
+            {
+              ...lastResponse.candidates[0],
+              content: {
+                ...lastResponse.candidates[0].content,
+                parts: [{ text: combinedText }]
+              }
+            }
+          ] : void 0
+        };
+      }
+      async *handleStream(body) {
+        const reader = body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        let currentEvent = "";
+        let messageId;
+        let model = "";
+        let cachedTokens = 0;
+        let promptTokens = 0;
+        let completionTokens = 0;
+        let finishReason;
+        const blocks = /* @__PURE__ */ new Map();
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done) break;
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split("\n");
+            buffer = lines.pop() || "";
+            for (const line of lines) {
+              const trimmedLine = line.trim();
+              if (!trimmedLine) {
+                currentEvent = "";
+                continue;
+              }
+              if (trimmedLine.startsWith("event: ")) {
+                currentEvent = trimmedLine.slice(7).trim();
+                continue;
+              }
+              if (trimmedLine.startsWith("data: ")) {
+                const dataStr = trimmedLine.slice(6).trim();
+                if (!dataStr || dataStr === "[DONE]") continue;
+                try {
+                  const data = JSON.parse(dataStr);
+                  const eventType = data.type || currentEvent;
+                  switch (eventType) {
+                    case "message_start": {
+                      if (data.message) {
+                        messageId = data.message.id ?? messageId;
+                        model = data.message.model ?? model;
+                        if (data.message.usage) {
+                          cachedTokens = data.message.usage.cache_read_input_tokens ?? 0;
+                          promptTokens = data.message.usage.input_tokens ?? 0;
+                        }
+                      }
+                      break;
+                    }
+                    case "content_block_start": {
+                      const index = data.index ?? 0;
+                      const type = String(data.content_block?.type || "text");
+                      const initialInput = type === "tool_use" && data.content_block?.input ? JSON.stringify(data.content_block.input) : "";
+                      const initialSignature = type === "thinking" && data.content_block?.signature ? String(data.content_block.signature) : "";
+                      if (this.cliConfig?.getDebugMode() && type === "tool_use") {
+                        console.debug(
+                          `[VertexAnthropicContentGenerator] Tool use block start:`,
+                          JSON.stringify({
+                            index,
+                            id: data.content_block?.id,
+                            name: data.content_block?.name,
+                            initialInput
+                          })
+                        );
+                      }
+                      blocks.set(index, {
+                        type,
+                        id: type === "tool_use" ? String(data.content_block?.id || "") : void 0,
+                        name: type === "tool_use" ? String(data.content_block?.name || "") : void 0,
+                        // SDK 兼容：如果初始 input 是空对象 {}，则设为空字符串
+                        // 实际参数通过后续的 input_json_delta 事件发送
+                        inputJson: initialInput !== "{}" ? initialInput : "",
+                        signature: initialSignature
+                      });
+                      break;
+                    }
+                    case "content_block_delta": {
+                      const deltaType = data.delta?.type;
+                      const index = data.index ?? 0;
+                      if (deltaType === "text_delta" && data.delta?.text) {
+                        const chunk = this.buildGeminiChunk(
+                          { text: data.delta.text },
+                          messageId,
+                          model
+                        );
+                        yield chunk;
+                      } else if (deltaType === "thinking_delta" && data.delta?.thinking) {
+                        const chunk = this.buildGeminiChunk(
+                          { text: data.delta.thinking, thought: true },
+                          messageId,
+                          model
+                        );
+                        yield chunk;
+                      } else if (deltaType === "input_json_delta" && data.delta?.partial_json) {
+                        const blockState = blocks.get(index);
+                        if (blockState) {
+                          blockState.inputJson += data.delta.partial_json;
+                          if (this.cliConfig?.getDebugMode()) {
+                            console.debug(
+                              `[VertexAnthropicContentGenerator] input_json_delta:`,
+                              data.delta.partial_json
+                            );
+                          }
+                        }
+                      } else if (deltaType === "signature_delta" && data.delta?.signature) {
+                        const blockState = blocks.get(index);
+                        if (blockState) {
+                          blockState.signature += data.delta.signature;
+                          const chunk = this.buildGeminiChunk(
+                            { thought: true, thoughtSignature: data.delta.signature },
+                            messageId,
+                            model
+                          );
+                          yield chunk;
+                        }
+                      }
+                      break;
+                    }
+                    case "content_block_stop": {
+                      const index = data.index ?? 0;
+                      const blockState = blocks.get(index);
+                      if (blockState?.type === "tool_use") {
+                        const args = this.safeJsonParse(blockState.inputJson || "{}", {});
+                        if (this.cliConfig?.getDebugMode()) {
+                          console.debug(
+                            `[VertexAnthropicContentGenerator] Tool use block stop:`,
+                            JSON.stringify({
+                              index,
+                              id: blockState.id,
+                              name: blockState.name,
+                              inputJson: blockState.inputJson,
+                              parsedArgs: args
+                            })
+                          );
+                        }
+                        const chunk = this.buildGeminiChunk(
+                          {
+                            functionCall: {
+                              id: blockState.id,
+                              name: blockState.name,
+                              args
+                            }
+                          },
+                          messageId,
+                          model
+                        );
+                        yield chunk;
+                      }
+                      blocks.delete(index);
+                      break;
+                    }
+                    case "message_delta": {
+                      if (data.delta?.stop_reason) {
+                        finishReason = data.delta.stop_reason;
+                      }
+                      if (data.usage?.output_tokens !== void 0) {
+                        completionTokens = data.usage.output_tokens;
+                      }
+                      if (finishReason || data.usage) {
+                        const chunk = this.buildGeminiChunk(
+                          void 0,
+                          messageId,
+                          model,
+                          finishReason,
+                          {
+                            cachedContentTokenCount: cachedTokens,
+                            promptTokenCount: cachedTokens + promptTokens,
+                            candidatesTokenCount: completionTokens,
+                            totalTokenCount: cachedTokens + promptTokens + completionTokens
+                          }
+                        );
+                        yield chunk;
+                      }
+                      break;
+                    }
+                    case "message_stop": {
+                      if (promptTokens || completionTokens) {
+                        const chunk = this.buildGeminiChunk(
+                          void 0,
+                          messageId,
+                          model,
+                          finishReason,
+                          {
+                            cachedContentTokenCount: cachedTokens,
+                            promptTokenCount: cachedTokens + promptTokens,
+                            candidatesTokenCount: completionTokens,
+                            totalTokenCount: cachedTokens + promptTokens + completionTokens
+                          }
+                        );
+                        yield chunk;
+                      }
+                      break;
+                    }
+                    default:
+                      break;
+                  }
+                } catch (error2) {
+                  if (this.cliConfig?.getDebugMode()) {
+                    console.error(
+                      `[VertexAnthropicContentGenerator] Failed to parse SSE data:`,
+                      dataStr,
+                      error2
+                    );
+                  }
+                }
+              }
+            }
+          }
+        } finally {
+          reader.releaseLock();
+        }
+      }
+      buildGeminiChunk(part, responseId, model, finishReason, usageMetadata) {
+        const response = new GenerateContentResponse();
+        response.responseId = responseId;
+        response.createTime = Date.now().toString();
+        response.modelVersion = model || "";
+        response.promptFeedback = { safetyRatings: [] };
+        let candidateParts = [];
+        if (part) {
+          if (part.functionCall) {
+            candidateParts = [
+              {
+                functionCall: {
+                  name: part.functionCall.name || "",
+                  args: part.functionCall.args || {},
+                  id: part.functionCall.id
+                }
+              }
+            ];
+          } else {
+            candidateParts = [part];
+          }
+        }
+        const mappedFinishReason = finishReason ? this.mapFinishReason(finishReason) : void 0;
+        response.candidates = [
+          {
+            content: {
+              parts: candidateParts,
+              role: "model"
+            },
+            index: 0,
+            safetyRatings: [],
+            ...mappedFinishReason ? { finishReason: mappedFinishReason } : {}
+          }
+        ];
+        if (usageMetadata) {
+          response.usageMetadata = usageMetadata;
+        }
+        return response;
+      }
+      async countTokens(request4) {
+        const content = JSON.stringify(request4.contents);
+        const totalTokens = Math.ceil(content.length / 4);
+        return { totalTokens };
+      }
+      async embedContent(_request) {
+        throw new Error("Vertex Anthropic does not support embeddings.");
+      }
+      useSummarizedThinking() {
+        return false;
+      }
+    };
+  }
+});
+
 // node_modules/@anthropic-ai/sdk/version.mjs
 var VERSION3;
 var init_version3 = __esm({
@@ -157557,7 +158380,7 @@ __export(geminiContentGenerator_exports2, {
   createGeminiContentGenerator: () => createGeminiContentGenerator
 });
 function createGeminiContentGenerator(config2, gcConfig) {
-  const version2 = "0.2.3-alpha.2";
+  const version2 = "0.2.3-alpha.4";
   const userAgent2 = config2.userAgent || `QwenCode/${version2} (${process.platform}; ${process.arch})`;
   const baseHeaders = {
     "User-Agent": userAgent2
@@ -157732,6 +158555,12 @@ async function createContentGenerator(generatorConfig, config2, isInitialAuth) {
     if (model.startsWith("gemini")) {
       const { GeminiContentGenerator: GeminiContentGenerator3 } = await Promise.resolve().then(() => (init_geminiContentGenerator(), geminiContentGenerator_exports));
       baseGenerator = new GeminiContentGenerator3(generatorConfig, config2);
+    } else if (model.startsWith("claude")) {
+      const { VertexAnthropicContentGenerator: VertexAnthropicContentGenerator2 } = await Promise.resolve().then(() => (init_vertexAnthropicContentGenerator(), vertexAnthropicContentGenerator_exports));
+      baseGenerator = new VertexAnthropicContentGenerator2(
+        generatorConfig,
+        config2
+      );
     } else {
       const { createOpenAIContentGenerator: createOpenAIContentGenerator2 } = await Promise.resolve().then(() => (init_openaiContentGenerator2(), openaiContentGenerator_exports));
       baseGenerator = createOpenAIContentGenerator2(generatorConfig, config2);
@@ -190463,12 +191292,12 @@ var require_src36 = __commonJS({
     function check2(path134, isFile3, isDirectory) {
       log(`checking %s`, path134);
       try {
-        const stat10 = fs_1.statSync(path134);
-        if (stat10.isFile() && isFile3) {
+        const stat11 = fs_1.statSync(path134);
+        if (stat11.isFile() && isFile3) {
           log(`[OK] path represents a file`);
           return true;
         }
-        if (stat10.isDirectory() && isDirectory) {
+        if (stat11.isDirectory() && isDirectory) {
           log(`[OK] path represents a directory`);
           return true;
         }
@@ -206564,16 +207393,16 @@ var require_windows = __commonJS({
       return false;
     }
     __name(checkPathExt, "checkPathExt");
-    function checkStat(stat10, path134, options2) {
-      if (!stat10.isSymbolicLink() && !stat10.isFile()) {
+    function checkStat(stat11, path134, options2) {
+      if (!stat11.isSymbolicLink() && !stat11.isFile()) {
         return false;
       }
       return checkPathExt(path134, options2);
     }
     __name(checkStat, "checkStat");
     function isexe(path134, options2, cb) {
-      fs122.stat(path134, function(er2, stat10) {
-        cb(er2, er2 ? false : checkStat(stat10, path134, options2));
+      fs122.stat(path134, function(er2, stat11) {
+        cb(er2, er2 ? false : checkStat(stat11, path134, options2));
       });
     }
     __name(isexe, "isexe");
@@ -206592,8 +207421,8 @@ var require_mode = __commonJS({
     isexe.sync = sync2;
     var fs122 = __require("fs");
     function isexe(path134, options2, cb) {
-      fs122.stat(path134, function(er2, stat10) {
-        cb(er2, er2 ? false : checkStat(stat10, options2));
+      fs122.stat(path134, function(er2, stat11) {
+        cb(er2, er2 ? false : checkStat(stat11, options2));
       });
     }
     __name(isexe, "isexe");
@@ -206601,14 +207430,14 @@ var require_mode = __commonJS({
       return checkStat(fs122.statSync(path134), options2);
     }
     __name(sync2, "sync");
-    function checkStat(stat10, options2) {
-      return stat10.isFile() && checkMode(stat10, options2);
+    function checkStat(stat11, options2) {
+      return stat11.isFile() && checkMode(stat11, options2);
     }
     __name(checkStat, "checkStat");
-    function checkMode(stat10, options2) {
-      var mod2 = stat10.mode;
-      var uid = stat10.uid;
-      var gid = stat10.gid;
+    function checkMode(stat11, options2) {
+      var mod2 = stat11.mode;
+      var uid = stat11.uid;
+      var gid = stat11.gid;
       var myUid = options2.uid !== void 0 ? options2.uid : process.getuid && process.getuid();
       var myGid = options2.gid !== void 0 ? options2.gid : process.getgid && process.getgid();
       var u2 = parseInt("100", 8);
@@ -207802,14 +208631,14 @@ var init_ide_client = __esm({
           lockFiles.map(async (file) => {
             const fullPath = path34.join(ideDir, file);
             try {
-              const stat10 = await fs34.promises.stat(fullPath);
+              const stat11 = await fs34.promises.stat(fullPath);
               const content = await fs34.promises.readFile(fullPath, "utf8");
               try {
                 const parsed = JSON.parse(content);
-                return { file, mtimeMs: stat10.mtimeMs, parsed };
+                return { file, mtimeMs: stat11.mtimeMs, parsed };
               } catch (e4) {
                 logger.debug("Failed to parse JSON from lock file: ", e4);
-                return { file, mtimeMs: stat10.mtimeMs, parsed: void 0 };
+                return { file, mtimeMs: stat11.mtimeMs, parsed: void 0 };
               }
             } catch (e4) {
               logger.debug("Failed to read/stat IDE lock file:", e4);
@@ -215943,6 +216772,19 @@ var init_mcp_client = __esm({
       getStatus() {
         return this.status;
       }
+      async readResource(uri, options2) {
+        if (this.status !== "connected" /* CONNECTED */) {
+          throw new Error("Client is not connected.");
+        }
+        if (this.client.getServerCapabilities()?.resources == null) {
+          throw new Error("MCP server does not support resources.");
+        }
+        return this.client.request(
+          { method: "resources/read", params: { uri } },
+          ReadResourceResultSchema,
+          options2
+        );
+      }
       updateStatus(status) {
         this.status = status;
         updateMCPServerStatus(this.serverName, status);
@@ -216065,6 +216907,59 @@ var init_mcp_client_manager = __esm({
         await Promise.all(discoveryPromises);
         this.discoveryState = "completed" /* COMPLETED */;
       }
+      /**
+       * Connects to a single MCP server and discovers its tools/prompts.
+       * The connected client is tracked so it can be closed by {@link stop}.
+       *
+       * This is primarily used for on-demand re-discovery flows (e.g. after OAuth).
+       */
+      async discoverMcpToolsForServer(serverName, cliConfig) {
+        const servers = populateMcpServerCommand(
+          this.cliConfig.getMcpServers() || {},
+          this.cliConfig.getMcpServerCommand()
+        );
+        const serverConfig = servers[serverName];
+        if (!serverConfig) {
+          return;
+        }
+        const existingClient = this.clients.get(serverName);
+        if (existingClient) {
+          try {
+            await existingClient.disconnect();
+          } catch (error2) {
+            console.error(
+              `Error stopping client '${serverName}': ${getErrorMessage(error2)}`
+            );
+          } finally {
+            this.clients.delete(serverName);
+            this.eventEmitter?.emit("mcp-client-update", this.clients);
+          }
+        }
+        const sdkCallback = isSdkMcpServerConfig(serverConfig) ? this.sendSdkMcpMessage : void 0;
+        const client = new McpClient(
+          serverName,
+          serverConfig,
+          this.toolRegistry,
+          this.cliConfig.getPromptRegistry(),
+          this.cliConfig.getWorkspaceContext(),
+          this.cliConfig.getDebugMode(),
+          sdkCallback
+        );
+        this.clients.set(serverName, client);
+        this.eventEmitter?.emit("mcp-client-update", this.clients);
+        try {
+          await client.connect();
+          await client.discover(cliConfig);
+        } catch (error2) {
+          console.error(
+            `Error during discovery for server '${serverName}': ${getErrorMessage(
+              error2
+            )}`
+          );
+        } finally {
+          this.eventEmitter?.emit("mcp-client-update", this.clients);
+        }
+      }
       /**
        * Stops all running local MCP servers and closes all client connections.
        * This is the cleanup method to be called on application exit.
@@ -216087,6 +216982,35 @@ var init_mcp_client_manager = __esm({
       getDiscoveryState() {
         return this.discoveryState;
       }
+      async readResource(serverName, uri, options2) {
+        let client = this.clients.get(serverName);
+        if (!client) {
+          const servers = populateMcpServerCommand(
+            this.cliConfig.getMcpServers() || {},
+            this.cliConfig.getMcpServerCommand()
+          );
+          const serverConfig = servers[serverName];
+          if (!serverConfig) {
+            throw new Error(`MCP server '${serverName}' is not configured.`);
+          }
+          const sdkCallback = isSdkMcpServerConfig(serverConfig) ? this.sendSdkMcpMessage : void 0;
+          client = new McpClient(
+            serverName,
+            serverConfig,
+            this.toolRegistry,
+            this.cliConfig.getPromptRegistry(),
+            this.cliConfig.getWorkspaceContext(),
+            this.cliConfig.getDebugMode(),
+            sdkCallback
+          );
+          this.clients.set(serverName, client);
+          this.eventEmitter?.emit("mcp-client-update", this.clients);
+        }
+        if (client.getStatus() !== "connected" /* CONNECTED */) {
+          await client.connect();
+        }
+        return client.readResource(uri, options2);
+      }
     };
   }
 });
@@ -216100,7 +217024,6 @@ var init_tool_registry = __esm({
     "use strict";
     init_esbuild_shims();
     init_tools();
-    init_mcp_client();
     init_mcp_client_manager();
     init_mcp_tool();
     import_shell_quote4 = __toESM(require_shell_quote(), 1);
@@ -216312,19 +217235,10 @@ Signal: Signal number or \`(none)\` if no signal was received.
           }
         }
         this.config.getPromptRegistry().removePromptsByServer(serverName);
-        const mcpServers = this.config.getMcpServers() ?? {};
-        const serverConfig = mcpServers[serverName];
-        if (serverConfig) {
-          await connectAndDiscover(
-            serverName,
-            serverConfig,
-            this,
-            this.config.getPromptRegistry(),
-            this.config.getDebugMode(),
-            this.config.getWorkspaceContext(),
-            this.config
-          );
-        }
+        await this.mcpClientManager.discoverMcpToolsForServer(
+          serverName,
+          this.config
+        );
       }
       async discoverAndRegisterToolsFromCommand() {
         const discoveryCmd = this.config.getToolDiscoveryCommand();
@@ -216488,6 +217402,23 @@ Signal: Signal number or \`(none)\` if no signal was received.
       getTool(name3) {
         return this.tools.get(name3);
       }
+      async readMcpResource(serverName, uri, options2) {
+        if (!this.config.isTrustedFolder()) {
+          throw new Error("MCP resources are unavailable in untrusted folders.");
+        }
+        return this.mcpClientManager.readResource(serverName, uri, options2);
+      }
+      /**
+       * Stops all MCP clients and cleans up resources.
+       * This method is idempotent and safe to call multiple times.
+       */
+      async stop() {
+        try {
+          await this.mcpClientManager.stop();
+        } catch (error2) {
+          console.error("Error stopping MCP clients:", error2);
+        }
+      }
     };
   }
 });
@@ -222124,7 +223055,7 @@ ${textContent2}
         return `Fetching content from ${this.params.url} and processing with prompt: "${displayPrompt}"`;
       }
       async shouldConfirmExecute() {
-        if (this.config.getApprovalMode() === "auto-edit" /* AUTO_EDIT */) {
+        if (this.config.getApprovalMode() === "auto-edit" /* AUTO_EDIT */ || this.config.getApprovalMode() === "plan" /* PLAN */) {
           return false;
         }
         const confirmationDetails = {
@@ -223028,7 +223959,7 @@ var init_web_search = __esm({
         return ` (Searching the web via ${provider})`;
       }
       async shouldConfirmExecute(_abortSignal) {
-        if (this.config.getApprovalMode() === "auto-edit" /* AUTO_EDIT */) {
+        if (this.config.getApprovalMode() === "auto-edit" /* AUTO_EDIT */ || this.config.getApprovalMode() === "plan" /* PLAN */) {
           return false;
         }
         const confirmationDetails = {
@@ -226211,8 +227142,8 @@ var init_esm21 = __esm({
         }
         return this._userIgnored(path134, stats);
       }
-      _isntIgnored(path134, stat10) {
-        return !this._isIgnored(path134, stat10);
+      _isntIgnored(path134, stat11) {
+        return !this._isIgnored(path134, stat11);
       }
       /**
        * Provides a set of common helpers and properties relating to symlink handling.
@@ -226513,9 +227444,15 @@ async function loadSkillsFromDir(baseDir) {
     return [];
   }
 }
+function normalizeSkillFileContent(content) {
+  let normalized2 = content.replace(/^\uFEFF/, "");
+  normalized2 = normalized2.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+  return normalized2;
+}
 function parseSkillContent(content, filePath) {
-  const frontmatterRegex = /^---\n([\s\S]*?)\n---\n([\s\S]*)$/;
-  const match2 = content.match(frontmatterRegex);
+  const normalizedContent = normalizeSkillFileContent(content);
+  const frontmatterRegex = /^---\n([\s\S]*?)\n---(?:\n|$)([\s\S]*)$/;
+  const match2 = normalizedContent.match(frontmatterRegex);
   if (!match2) {
     throw new Error("Invalid format: missing YAML frontmatter");
   }
@@ -226596,6 +227533,7 @@ var init_skill_load = __esm({
     init_yaml_parser();
     SKILL_MANIFEST_FILE = "SKILL.md";
     __name(loadSkillsFromDir, "loadSkillsFromDir");
+    __name(normalizeSkillFileContent, "normalizeSkillFileContent");
     __name(parseSkillContent, "parseSkillContent");
     __name(validateConfig, "validateConfig");
   }
@@ -226606,7 +227544,7 @@ import * as fs48 from "fs/promises";
 import * as fsSync3 from "fs";
 import * as path52 from "path";
 import * as os21 from "os";
-function normalizeSkillFileContent(content) {
+function normalizeSkillFileContent2(content) {
   let normalized2 = content.replace(/^\uFEFF/, "");
   normalized2 = normalized2.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
   return normalized2;
@@ -226820,7 +227758,7 @@ var init_skill_manager = __esm({
        */
       parseSkillContent(content, filePath, level) {
         try {
-          const normalizedContent = normalizeSkillFileContent(content);
+          const normalizedContent = normalizeSkillFileContent2(content);
           const frontmatterRegex = /^---\n([\s\S]*?)\n---(?:\n|$)([\s\S]*)$/;
           const match2 = normalizedContent.match(frontmatterRegex);
           if (!match2) {
@@ -226915,8 +227853,26 @@ var init_skill_manager = __esm({
           const entries = await fs48.readdir(baseDir, { withFileTypes: true });
           const skills = [];
           for (const entry of entries) {
-            if (!entry.isDirectory()) continue;
+            const isDirectory = entry.isDirectory();
+            const isSymlink = entry.isSymbolicLink();
+            if (!isDirectory && !isSymlink) continue;
             const skillDir = path52.join(baseDir, entry.name);
+            if (isSymlink) {
+              try {
+                const targetStat = await fs48.stat(skillDir);
+                if (!targetStat.isDirectory()) {
+                  console.warn(
+                    `Skipping symlink ${entry.name} that does not point to a directory`
+                  );
+                  continue;
+                }
+              } catch (error2) {
+                console.warn(
+                  `Skipping invalid symlink ${entry.name}: ${error2 instanceof Error ? error2.message : "Unknown error"}`
+                );
+                continue;
+              }
+            }
             const skillManifest = path52.join(skillDir, SKILL_MANIFEST_FILE2);
             try {
               await fs48.access(skillManifest);
@@ -227020,7 +227976,7 @@ var init_skill_manager = __esm({
         }
       }
     };
-    __name(normalizeSkillFileContent, "normalizeSkillFileContent");
+    __name(normalizeSkillFileContent2, "normalizeSkillFileContent");
   }
 });
 
@@ -230469,16 +231425,16 @@ var init_list = __esm({
       let fd;
       try {
         fd = fs51.openSync(file, "r");
-        const stat10 = fs51.fstatSync(fd);
+        const stat11 = fs51.fstatSync(fd);
         const readSize = opt.maxReadSize || 16 * 1024 * 1024;
-        if (stat10.size < readSize) {
-          const buf = Buffer.allocUnsafe(stat10.size);
-          const read3 = fs51.readSync(fd, buf, 0, stat10.size, 0);
+        if (stat11.size < readSize) {
+          const buf = Buffer.allocUnsafe(stat11.size);
+          const read3 = fs51.readSync(fd, buf, 0, stat11.size, 0);
           p2.end(read3 === buf.byteLength ? buf : buf.subarray(0, read3));
         } else {
           let pos2 = 0;
           const buf = Buffer.allocUnsafe(readSize);
-          while (pos2 < stat10.size) {
+          while (pos2 < stat11.size) {
             const bytesRead = fs51.readSync(fd, buf, 0, readSize, pos2);
             if (bytesRead === 0)
               break;
@@ -230503,13 +231459,13 @@ var init_list = __esm({
       const p2 = new Promise((resolve33, reject) => {
         parse14.on("error", reject);
         parse14.on("end", resolve33);
-        fs51.stat(file, (er2, stat10) => {
+        fs51.stat(file, (er2, stat11) => {
           if (er2) {
             reject(er2);
           } else {
             const stream2 = new ReadStream(file, {
               readSize,
-              size: stat10.size
+              size: stat11.size
             });
             stream2.on("error", reject);
             stream2.pipe(parse14);
@@ -230725,21 +231681,21 @@ var init_write_entry = __esm({
         return super.emit(ev, ...data);
       }
       [LSTAT]() {
-        fs52.lstat(this.absolute, (er2, stat10) => {
+        fs52.lstat(this.absolute, (er2, stat11) => {
           if (er2) {
             return this.emit("error", er2);
           }
-          this[ONLSTAT](stat10);
+          this[ONLSTAT](stat11);
         });
       }
-      [ONLSTAT](stat10) {
-        this.statCache.set(this.absolute, stat10);
-        this.stat = stat10;
-        if (!stat10.isFile()) {
-          stat10.size = 0;
+      [ONLSTAT](stat11) {
+        this.statCache.set(this.absolute, stat11);
+        this.stat = stat11;
+        if (!stat11.isFile()) {
+          stat11.size = 0;
         }
-        this.type = getType3(stat10);
-        this.emit("stat", stat10);
+        this.type = getType3(stat11);
+        this.emit("stat", stat11);
         this[PROCESS2]();
       }
       [PROCESS2]() {
@@ -231189,7 +232145,7 @@ var init_write_entry = __esm({
         return this;
       }
     };
-    getType3 = /* @__PURE__ */ __name((stat10) => stat10.isFile() ? "File" : stat10.isDirectory() ? "Directory" : stat10.isSymbolicLink() ? "SymbolicLink" : "Unsupported", "getType");
+    getType3 = /* @__PURE__ */ __name((stat11) => stat11.isFile() ? "File" : stat11.isDirectory() ? "Directory" : stat11.isSymbolicLink() ? "SymbolicLink" : "Unsupported", "getType");
   }
 });
 
@@ -231789,21 +232745,21 @@ var init_pack = __esm({
       [STAT](job) {
         job.pending = true;
         this[JOBS] += 1;
-        const stat10 = this.follow ? "stat" : "lstat";
-        fs53[stat10](job.absolute, (er2, stat11) => {
+        const stat11 = this.follow ? "stat" : "lstat";
+        fs53[stat11](job.absolute, (er2, stat12) => {
           job.pending = false;
           this[JOBS] -= 1;
           if (er2) {
             this.emit("error", er2);
           } else {
-            this[ONSTAT](job, stat11);
+            this[ONSTAT](job, stat12);
           }
         });
       }
-      [ONSTAT](job, stat10) {
-        this.statCache.set(job.absolute, stat10);
-        job.stat = stat10;
-        if (!this.filter(job.path, stat10)) {
+      [ONSTAT](job, stat11) {
+        this.statCache.set(job.absolute, stat11);
+        job.stat = stat11;
+        if (!this.filter(job.path, stat11)) {
           job.ignore = true;
         }
         this[PROCESS3]();
@@ -231985,8 +232941,8 @@ var init_pack = __esm({
       resume() {
       }
       [STAT](job) {
-        const stat10 = this.follow ? "statSync" : "lstatSync";
-        this[ONSTAT](job, fs53[stat10](job.absolute));
+        const stat11 = this.follow ? "statSync" : "lstatSync";
+        this[ONSTAT](job, fs53[stat11](job.absolute));
       }
       [READDIR](job) {
         this[ONREADDIR](job, fs53.readdirSync(job.absolute));
@@ -233286,11 +234242,11 @@ var init_extract = __esm({
     extractFileSync = /* @__PURE__ */ __name((opt) => {
       const u2 = new UnpackSync(opt);
       const file = opt.file;
-      const stat10 = fs58.statSync(file);
+      const stat11 = fs58.statSync(file);
       const readSize = opt.maxReadSize || 16 * 1024 * 1024;
       const stream2 = new ReadStreamSync(file, {
         readSize,
-        size: stat10.size
+        size: stat11.size
       });
       stream2.pipe(u2);
     }, "extractFileSync");
@@ -233301,13 +234257,13 @@ var init_extract = __esm({
       const p2 = new Promise((resolve33, reject) => {
         u2.on("error", reject);
         u2.on("close", resolve33);
-        fs58.stat(file, (er2, stat10) => {
+        fs58.stat(file, (er2, stat11) => {
           if (er2) {
             reject(er2);
           } else {
             const stream2 = new ReadStream(file, {
               readSize,
-              size: stat10.size
+              size: stat11.size
             });
             stream2.on("error", reject);
             stream2.pipe(u2);
@@ -233552,9 +234508,9 @@ var init_update = __esm({
       if (!opt.mtimeCache) {
         opt.mtimeCache = /* @__PURE__ */ new Map();
       }
-      opt.filter = filter4 ? (path134, stat10) => filter4(path134, stat10) && !/* c8 ignore start */
-      ((opt.mtimeCache?.get(path134) ?? stat10.mtime ?? 0) > (stat10.mtime ?? 0)) : (path134, stat10) => !/* c8 ignore start */
-      ((opt.mtimeCache?.get(path134) ?? stat10.mtime ?? 0) > (stat10.mtime ?? 0));
+      opt.filter = filter4 ? (path134, stat11) => filter4(path134, stat11) && !/* c8 ignore start */
+      ((opt.mtimeCache?.get(path134) ?? stat11.mtime ?? 0) > (stat11.mtime ?? 0)) : (path134, stat11) => !/* c8 ignore start */
+      ((opt.mtimeCache?.get(path134) ?? stat11.mtime ?? 0) > (stat11.mtime ?? 0));
     }, "mtimeFilter");
   }
 });
@@ -238339,8 +239295,8 @@ async function collectResources(resourcePaths, pluginRoot, destDir) {
       console.warn(`Resource path not found: ${resolvedPath}`);
       continue;
     }
-    const stat10 = fs63.statSync(resolvedPath);
-    if (stat10.isDirectory()) {
+    const stat11 = fs63.statSync(resolvedPath);
+    if (stat11.isDirectory()) {
       const dirName = path65.basename(resolvedPath);
       const parentDir = path65.dirname(resolvedPath);
       if (dirName === destFolderName && parentDir === pluginRoot) {
@@ -249145,12 +250101,6 @@ var init_config3 = __esm({
       getSessionId() {
         return this.sessionId;
       }
-      /**
-       * Releases resources owned by the config instance.
-       */
-      async shutdown() {
-        this.skillManager?.stopWatching();
-      }
       /**
        * Starts a new session and resets session-scoped services.
        */
@@ -249291,6 +250241,24 @@ var init_config3 = __esm({
       getToolRegistry() {
         return this.toolRegistry;
       }
+      /**
+       * Shuts down the Config and releases all resources.
+       * This method is idempotent and safe to call multiple times.
+       * It handles the case where initialization was not completed.
+       */
+      async shutdown() {
+        if (!this.initialized) {
+          return;
+        }
+        try {
+          this.skillManager?.stopWatching();
+          if (this.toolRegistry) {
+            await this.toolRegistry.stop();
+          }
+        } catch (error2) {
+          console.error("Error during Config shutdown:", error2);
+        }
+      }
       getPromptRegistry() {
         return this.promptRegistry;
       }
@@ -252778,12 +253746,12 @@ var require_resolve_symlink = __commonJS({
       fs_1.default.realpath(path134, (error2, resolvedPath) => {
         if (error2)
           return queue.dequeue(suppressErrors ? null : error2, state);
-        fs_1.default.stat(resolvedPath, (error3, stat10) => {
+        fs_1.default.stat(resolvedPath, (error3, stat11) => {
           if (error3)
             return queue.dequeue(suppressErrors ? null : error3, state);
-          if (stat10.isDirectory() && isRecursive(path134, resolvedPath, state))
+          if (stat11.isDirectory() && isRecursive(path134, resolvedPath, state))
             return queue.dequeue(null, state);
-          callback(stat10, resolvedPath);
+          callback(stat11, resolvedPath);
           queue.dequeue(null, state);
         });
       });
@@ -252793,10 +253761,10 @@ var require_resolve_symlink = __commonJS({
       queue.enqueue();
       try {
         const resolvedPath = fs_1.default.realpathSync(path134);
-        const stat10 = fs_1.default.statSync(resolvedPath);
-        if (stat10.isDirectory() && isRecursive(path134, resolvedPath, state))
+        const stat11 = fs_1.default.statSync(resolvedPath);
+        if (stat11.isDirectory() && isRecursive(path134, resolvedPath, state))
           return;
-        callback(stat10, resolvedPath);
+        callback(stat11, resolvedPath);
       } catch (e4) {
         if (!suppressErrors)
           throw e4;
@@ -253115,8 +254083,8 @@ var require_walker = __commonJS({
             this.walkDirectory(this.state, path134, path134, depth - 1, this.walk);
           } else if (this.resolveSymlink && entry.isSymbolicLink()) {
             let path134 = joinPath.joinPathWithBasePath(entry.name, directoryPath);
-            this.resolveSymlink(path134, this.state, (stat10, resolvedPath) => {
-              if (stat10.isDirectory()) {
+            this.resolveSymlink(path134, this.state, (stat11, resolvedPath) => {
+              if (stat11.isDirectory()) {
                 resolvedPath = (0, utils_1.normalizePath)(resolvedPath, this.state.options);
                 if (exclude && exclude(entry.name, useRealPaths ? resolvedPath : path134 + pathSeparator))
                   return;
@@ -255091,7 +256059,7 @@ var init_skills = __esm({
 import * as fs74 from "node:fs";
 import * as path79 from "node:path";
 import * as https5 from "node:https";
-import { stat as stat6 } from "node:fs/promises";
+import { stat as stat7 } from "node:fs/promises";
 function parseSourceAndPluginName(source2) {
   const urlSchemes = ["http://", "https://", "git@", "sso://"];
   let repoEndIndex = source2.length;
@@ -255220,7 +256188,7 @@ async function parseInstallSource(source2) {
     }
   } else {
     try {
-      await stat6(repo);
+      await stat7(repo);
       installMetadata = {
         source: repo,
         type: "local",
@@ -259110,8 +260078,8 @@ var init_git_commit = __esm({
   "packages/core/src/generated/git-commit.ts"() {
     "use strict";
     init_esbuild_shims();
-    GIT_COMMIT_INFO = "6bc19dab8";
-    CLI_VERSION = "0.2.3-alpha.2";
+    GIT_COMMIT_INFO = "1ebbd0090";
+    CLI_VERSION = "0.2.3-alpha.4";
   }
 });
 
@@ -359905,7 +360873,7 @@ __name(getPackageJson, "getPackageJson");
 // packages/cli/src/utils/version.ts
 async function getCliVersion() {
   const pkgJson = await getPackageJson();
-  return "0.2.3-alpha.2";
+  return "0.2.3-alpha.4";
 }
 __name(getCliVersion, "getCliVersion");
 
@@ -367635,7 +368603,7 @@ var formatDuration = /* @__PURE__ */ __name((milliseconds) => {
 
 // packages/cli/src/generated/git-commit.ts
 init_esbuild_shims();
-var GIT_COMMIT_INFO2 = "6bc19dab8";
+var GIT_COMMIT_INFO2 = "1ebbd0090";
 
 // packages/cli/src/utils/systemInfo.ts
 async function getNpmVersion() {
@@ -377402,6 +378370,161 @@ function parseAllAtCommands(query) {
   );
 }
 __name(parseAllAtCommands, "parseAllAtCommands");
+function getConfiguredMcpServerNames(config2) {
+  const names = new Set(Object.keys(config2.getMcpServers() ?? {}));
+  if (config2.getMcpServerCommand()) {
+    names.add("mcp");
+  }
+  return names;
+}
+__name(getConfiguredMcpServerNames, "getConfiguredMcpServerNames");
+function normalizeMcpResourceUri(serverName, resource) {
+  if (resource.includes("://")) {
+    return resource;
+  }
+  const cleaned = resource.startsWith("/") ? resource.slice(1) : resource;
+  return `${serverName}://${cleaned}`;
+}
+__name(normalizeMcpResourceUri, "normalizeMcpResourceUri");
+function splitLeadingToken(text) {
+  let i3 = 0;
+  while (i3 < text.length && /\s/.test(text[i3])) {
+    i3++;
+  }
+  if (i3 >= text.length) {
+    return null;
+  }
+  let token2 = "";
+  let inEscape = false;
+  while (i3 < text.length) {
+    const char = text[i3];
+    if (inEscape) {
+      token2 += char;
+      inEscape = false;
+      i3++;
+      continue;
+    }
+    if (char === "\\") {
+      inEscape = true;
+      i3++;
+      continue;
+    }
+    if (/[,\s;!?()[\]{}]/.test(char)) {
+      break;
+    }
+    if (char === ".") {
+      const nextChar = i3 + 1 < text.length ? text[i3 + 1] : "";
+      if (nextChar === "" || /\s/.test(nextChar)) {
+        break;
+      }
+    }
+    token2 += char;
+    i3++;
+  }
+  if (!token2) {
+    return null;
+  }
+  return { token: token2, rest: text.slice(i3) };
+}
+__name(splitLeadingToken, "splitLeadingToken");
+function extractMcpResourceAtReferences(parts, config2) {
+  const configuredServers = getConfiguredMcpServerNames(config2);
+  const refs = [];
+  const merged = [];
+  for (let i3 = 0; i3 < parts.length; i3++) {
+    const part = parts[i3];
+    if (part.type !== "atPath") {
+      merged.push(part);
+      continue;
+    }
+    const atText = part.content;
+    const colonIndex = atText.indexOf(":");
+    if (!atText.startsWith("@") || colonIndex <= 1) {
+      merged.push(part);
+      continue;
+    }
+    const serverName = atText.slice(1, colonIndex);
+    if (!configuredServers.has(serverName)) {
+      merged.push(part);
+      continue;
+    }
+    let resource = atText.slice(colonIndex + 1);
+    if (!resource) {
+      const next = parts[i3 + 1];
+      if (next?.type === "text") {
+        const tokenInfo = splitLeadingToken(next.content);
+        if (tokenInfo) {
+          resource = tokenInfo.token;
+          const remainingText = tokenInfo.rest;
+          parts[i3 + 1] = { type: "text", content: remainingText };
+        }
+      }
+    }
+    if (!resource) {
+      merged.push({ type: "text", content: atText });
+      continue;
+    }
+    const normalizedResource = resource.includes("://") ? resource : resource.startsWith("/") ? resource.slice(1) : resource;
+    const normalizedAtCommand = `@${serverName}:${normalizedResource}`;
+    refs.push({
+      atCommand: normalizedAtCommand,
+      serverName,
+      uri: normalizeMcpResourceUri(serverName, normalizedResource)
+    });
+    merged.push({ type: "atPath", content: normalizedAtCommand });
+  }
+  return {
+    parts: merged.filter(
+      (p2) => !(p2.type === "text" && p2.content.trim() === "")
+    ),
+    refs
+  };
+}
+__name(extractMcpResourceAtReferences, "extractMcpResourceAtReferences");
+function formatMcpResourceContents(raw2, limits) {
+  if (!raw2 || typeof raw2 !== "object") {
+    return "[Error: Invalid MCP resource response]";
+  }
+  const contents = raw2.contents;
+  if (!Array.isArray(contents)) {
+    return "[Error: Invalid MCP resource response]";
+  }
+  const parts = [];
+  for (const item of contents) {
+    if (!item || typeof item !== "object") {
+      continue;
+    }
+    const text = item.text;
+    const blob = item.blob;
+    const mimeType = item.mimeType;
+    if (typeof text === "string") {
+      parts.push(text);
+      continue;
+    }
+    if (typeof blob === "string") {
+      const mimeTypeLabel = typeof mimeType === "string" ? mimeType : "application/octet-stream";
+      parts.push(
+        `[Binary MCP resource omitted (mimeType: ${mimeTypeLabel}, bytes: ${blob.length})]`
+      );
+    }
+  }
+  let combined = parts.join("\n\n");
+  const maxLines = limits.maxLinesPerResource;
+  if (Number.isFinite(maxLines)) {
+    const lines = combined.split("\n");
+    if (lines.length > maxLines) {
+      combined = `${lines.slice(0, maxLines).join("\n")}
+[truncated]`;
+    }
+  }
+  const maxChars = limits.maxCharsPerResource;
+  if (Number.isFinite(maxChars) && combined.length > maxChars) {
+    combined = `${combined.slice(0, maxChars)}
+[truncated]`;
+  }
+  return combined;
+}
+__name(formatMcpResourceContents, "formatMcpResourceContents");
 async function handleAtCommand({
   query,
   config: config2,
@@ -377410,10 +378533,15 @@ async function handleAtCommand({
   messageId: userMessageTimestamp,
   signal
 }) {
-  const commandParts = parseAllAtCommands(query);
+  const parsedParts = parseAllAtCommands(query);
+  const { parts: commandParts, refs: mcpResourceRefs } = extractMcpResourceAtReferences(parsedParts, config2);
+  const mcpAtCommands = new Set(mcpResourceRefs.map((r5) => r5.atCommand));
   const atPathCommandParts = commandParts.filter(
     (part) => part.type === "atPath"
   );
+  const fileAtPathCommandParts = atPathCommandParts.filter(
+    (part) => !mcpAtCommands.has(part.content)
+  );
   if (atPathCommandParts.length === 0) {
     return { processedQuery: [{ text: query }], shouldProceed: true };
   }
@@ -377430,14 +378558,7 @@ async function handleAtCommand({
   const toolRegistry = config2.getToolRegistry();
   const readManyFilesTool = toolRegistry.getTool("read_many_files");
   const globTool = toolRegistry.getTool("glob");
-  if (!readManyFilesTool) {
-    addItem(
-      { type: "error", text: "Error: read_many_files tool not found." },
-      userMessageTimestamp
-    );
-    return { processedQuery: null, shouldProceed: false };
-  }
-  for (const atPathPart of atPathCommandParts) {
+  for (const atPathPart of fileAtPathCommandParts) {
     const originalAtPath = atPathPart.content;
     if (originalAtPath === "@") {
       onDebugMessage(
@@ -377597,7 +378718,7 @@ ${messages.join("\n")}`;
     console.log(message);
     onDebugMessage(message);
   }
-  if (pathSpecsToRead.length === 0) {
+  if (pathSpecsToRead.length === 0 && mcpResourceRefs.length === 0) {
     onDebugMessage("No valid file paths found in @ commands to read.");
     if (initialQueryText === "@" && query.trim() === "@") {
       return { processedQuery: [{ text: query }], shouldProceed: true };
@@ -377610,76 +378731,146 @@ ${messages.join("\n")}`;
     };
   }
   const processedQueryParts = [{ text: initialQueryText }];
-  const toolArgs = {
-    paths: pathSpecsToRead,
-    file_filtering_options: {
-      respect_git_ignore: respectFileIgnore.respectGitIgnore,
-      respect_rdmind_ignore: respectFileIgnore.respectRdmindIgnore
+  const toolDisplays = [];
+  if (pathSpecsToRead.length > 0) {
+    if (!readManyFilesTool) {
+      addItem(
+        { type: "error", text: "Error: read_many_files tool not found." },
+        userMessageTimestamp
+      );
+      return { processedQuery: null, shouldProceed: false };
     }
-    // Use configuration setting
-  };
-  let toolCallDisplay;
-  let invocation = void 0;
-  try {
-    invocation = readManyFilesTool.build(toolArgs);
-    const result = await invocation.execute(signal);
-    toolCallDisplay = {
-      callId: `client-read-${userMessageTimestamp}`,
-      name: readManyFilesTool.displayName,
-      description: invocation.getDescription(),
-      status: "Success" /* Success */,
-      resultDisplay: result.returnDisplay || `Successfully read: ${contentLabelsForDisplay.join(", ")}`,
-      confirmationDetails: void 0
-    };
-    if (Array.isArray(result.llmContent)) {
-      const fileContentRegex = /^--- (.*?) ---\n\n([\s\S]*?)\n\n$/;
-      processedQueryParts.push({
-        text: "\n--- Content from referenced files ---"
+    const toolArgs = {
+      paths: pathSpecsToRead,
+      file_filtering_options: {
+        respect_git_ignore: respectFileIgnore.respectGitIgnore,
+        respect_rdmind_ignore: respectFileIgnore.respectRdmindIgnore
+      }
+      // Use configuration setting
+    };
+    let invocation = void 0;
+    try {
+      invocation = readManyFilesTool.build(toolArgs);
+      const result = await invocation.execute(signal);
+      toolDisplays.push({
+        callId: `client-read-${userMessageTimestamp}`,
+        name: readManyFilesTool.displayName,
+        description: invocation.getDescription(),
+        status: "Success" /* Success */,
+        resultDisplay: result.returnDisplay || `Successfully read: ${contentLabelsForDisplay.join(", ")}`,
+        confirmationDetails: void 0
       });
-      for (const part of result.llmContent) {
-        if (typeof part === "string") {
-          const match2 = fileContentRegex.exec(part);
-          if (match2) {
-            const filePathSpecInContent = match2[1];
-            const fileActualContent = match2[2].trim();
-            processedQueryParts.push({
-              text: `
+      if (Array.isArray(result.llmContent)) {
+        const fileContentRegex = /^--- (.*?) ---\n\n([\s\S]*?)\n\n$/;
+        processedQueryParts.push({
+          text: "\n--- Content from referenced files ---"
+        });
+        for (const part of result.llmContent) {
+          if (typeof part === "string") {
+            const match2 = fileContentRegex.exec(part);
+            if (match2) {
+              const filePathSpecInContent = match2[1];
+              const fileActualContent = match2[2].trim();
+              processedQueryParts.push({
+                text: `
 Content from @${filePathSpecInContent}:
 `
-            });
-            processedQueryParts.push({ text: fileActualContent });
+              });
+              processedQueryParts.push({ text: fileActualContent });
+            } else {
+              processedQueryParts.push({ text: part });
+            }
           } else {
-            processedQueryParts.push({ text: part });
+            processedQueryParts.push(part);
           }
-        } else {
-          processedQueryParts.push(part);
         }
+      } else {
+        onDebugMessage(
+          "read_many_files tool returned no content or empty content."
+        );
       }
-    } else {
-      onDebugMessage(
-        "read_many_files tool returned no content or empty content."
+    } catch (error2) {
+      toolDisplays.push({
+        callId: `client-read-${userMessageTimestamp}`,
+        name: readManyFilesTool.displayName,
+        description: invocation?.getDescription() ?? "Error attempting to execute tool to read files",
+        status: "Error" /* Error */,
+        resultDisplay: `Error reading files (${contentLabelsForDisplay.join(", ")}): ${getErrorMessage(error2)}`,
+        confirmationDetails: void 0
+      });
+      addItem(
+        { type: "tool_group", tools: toolDisplays },
+        userMessageTimestamp
       );
+      return { processedQuery: null, shouldProceed: false };
     }
+  }
+  if (mcpResourceRefs.length > 0) {
+    const totalCharLimit = config2.getTruncateToolOutputThreshold();
+    const totalLineLimit = config2.getTruncateToolOutputLines();
+    const maxCharsPerResource = Number.isFinite(totalCharLimit) ? Math.floor(totalCharLimit / Math.max(1, mcpResourceRefs.length)) : Number.POSITIVE_INFINITY;
+    const maxLinesPerResource = Number.isFinite(totalLineLimit) ? Math.floor(totalLineLimit / Math.max(1, mcpResourceRefs.length)) : Number.POSITIVE_INFINITY;
+    processedQueryParts.push({
+      text: "\n--- Content from referenced MCP resources ---"
+    });
+    for (let i3 = 0; i3 < mcpResourceRefs.length; i3++) {
+      const ref = mcpResourceRefs[i3];
+      let resourceResult;
+      try {
+        if (signal.aborted) {
+          const error2 = new Error("MCP resource read aborted");
+          error2.name = "AbortError";
+          throw error2;
+        }
+        resourceResult = await toolRegistry.readMcpResource(
+          ref.serverName,
+          ref.uri,
+          { signal }
+        );
+        toolDisplays.push({
+          callId: `client-mcp-resource-${userMessageTimestamp}-${i3}`,
+          name: "McpResourceRead",
+          description: `Read MCP resource ${ref.uri} (server: ${ref.serverName})`,
+          status: "Success" /* Success */,
+          resultDisplay: `Read: ${ref.uri}`,
+          confirmationDetails: void 0
+        });
+      } catch (error2) {
+        toolDisplays.push({
+          callId: `client-mcp-resource-${userMessageTimestamp}-${i3}`,
+          name: "McpResourceRead",
+          description: `Read MCP resource ${ref.uri} (server: ${ref.serverName})`,
+          status: "Error" /* Error */,
+          resultDisplay: `Error reading MCP resource (${ref.uri}): ${getErrorMessage(error2)}`,
+          confirmationDetails: void 0
+        });
+        addItem(
+          { type: "tool_group", tools: toolDisplays },
+          userMessageTimestamp
+        );
+        return { processedQuery: null, shouldProceed: false };
+      }
+      processedQueryParts.push({
+        text: `
+Content from ${ref.atCommand}:
+`
+      });
+      processedQueryParts.push({
+        text: formatMcpResourceContents(resourceResult, {
+          maxCharsPerResource,
+          maxLinesPerResource
+        })
+      });
+    }
+    processedQueryParts.push({ text: "\n--- End of MCP resource content ---" });
+  }
+  if (toolDisplays.length > 0) {
     addItem(
-      { type: "tool_group", tools: [toolCallDisplay] },
-      userMessageTimestamp
-    );
-    return { processedQuery: processedQueryParts, shouldProceed: true };
-  } catch (error2) {
-    toolCallDisplay = {
-      callId: `client-read-${userMessageTimestamp}`,
-      name: readManyFilesTool.displayName,
-      description: invocation?.getDescription() ?? "Error attempting to execute tool to read files",
-      status: "Error" /* Error */,
-      resultDisplay: `Error reading files (${contentLabelsForDisplay.join(", ")}): ${getErrorMessage(error2)}`,
-      confirmationDetails: void 0
-    };
-    addItem(
-      { type: "tool_group", tools: [toolCallDisplay] },
+      { type: "tool_group", tools: toolDisplays },
       userMessageTimestamp
     );
-    return { processedQuery: null, shouldProceed: false };
   }
+  return { processedQuery: processedQueryParts, shouldProceed: true };
 }
 __name(handleAtCommand, "handleAtCommand");
 
@@ -407437,6 +408628,13 @@ var XHS_SSO_MODELS = [
     baseUrl: "https://runway.devops.xiaohongshu.com/openai/moonshot/v1",
     contextWindow: "256K",
     description: "\u5728 Agent\u3001\u4EE3\u7801\u3001\u89C6\u89C9\u7406\u89E3\u53CA\u4E00\u7CFB\u5217\u901A\u7528\u667A\u80FD\u4EFB\u52A1\u4E0A\u53D6\u5F97\u5F00\u6E90 SoTA \u8868\u73B0"
+  },
+  {
+    id: "claude-opus-4-5@20251101",
+    displayName: "Claude Opus 4.5",
+    baseUrl: "https://runway.devops.rednote.life/openai/google/anthropic/v1",
+    contextWindow: "200K",
+    description: "Anthropic \u6700\u5F3A\u5927\u7684\u6A21\u578B\uFF0C\u64C5\u957F\u590D\u6742\u63A8\u7406\u548C\u4EE3\u7801\u751F\u6210"
   }
 ];
 
@@ -426065,7 +427263,7 @@ var GeminiAgent = class {
       name: APPROVAL_MODE_INFO[mode].name,
       description: APPROVAL_MODE_INFO[mode].description
     }));
-    const version2 = "0.2.3-alpha.2";
+    const version2 = "0.2.3-alpha.4";
     return {
       protocolVersion: PROTOCOL_VERSION,
       agentInfo: {