@rdmind/rdmind 0.2.3-alpha.1 → 0.2.3-alpha.3

package/cli.js

@@ -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.1";
+  const version2 = "0.2.3-alpha.3";
   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);
@@ -222219,7 +223048,7 @@ Usage notes:
 });
 
 // packages/core/src/tools/redoc-fetch.ts
-var REDOC_API_TIMEOUT_MS, REDOC_API_URL, REDOC_URL_PATTERN, RedocFetchToolInvocation, RedocFetchTool;
+var REDOC_API_TIMEOUT_MS, REDOC_API_URL, REDOC_URL_PATTERN, IMAGE_DOWNLOAD_TIMEOUT_MS, MAX_IMAGE_SIZE_MB, RedocFetchToolInvocation, RedocFetchTool;
 var init_redoc_fetch = __esm({
   "packages/core/src/tools/redoc-fetch.ts"() {
     "use strict";
@@ -222228,9 +223057,12 @@ var init_redoc_fetch = __esm({
     init_core5();
     init_partUtils();
     init_models();
+    init_index_lite();
     REDOC_API_TIMEOUT_MS = 1e4;
     REDOC_API_URL = "https://athena-next.devops.xiaohongshu.com/api/media/query/redoc";
     REDOC_URL_PATTERN = /^https:\/\/docs\.xiaohongshu\.com\/doc\/([a-f0-9]+)$/;
+    IMAGE_DOWNLOAD_TIMEOUT_MS = 3e4;
+    MAX_IMAGE_SIZE_MB = 20;
     RedocFetchToolInvocation = class extends BaseToolInvocation {
       constructor(config2, params) {
         super(params);
@@ -222316,6 +223148,265 @@ var init_redoc_fetch = __esm({
           clearTimeout(timeoutId);
         }
       }
+      /**
+       * 解析文档内容并构建包含文本和图片（按原始顺序）的结构
+       */
+      async buildContentWithImages(content, signal) {
+        try {
+          const contentObj = JSON.parse(content);
+          if (!contentObj.children || !Array.isArray(contentObj.children)) {
+            return {
+              parts: [{ text: content }],
+              textContent: content,
+              imageCount: 0,
+              successCount: 0
+            };
+          }
+          const parts = [];
+          let textBuffer = [];
+          let imageCount = 0;
+          let successCount = 0;
+          const processNode = /* @__PURE__ */ __name(async (node, depth = 0) => {
+            if (!node) return;
+            if (node.type === "image" && node.url) {
+              imageCount++;
+              if (textBuffer.length > 0) {
+                parts.push({ text: textBuffer.join("\n") });
+                textBuffer = [];
+              }
+              console.debug(
+                `[RedocFetchTool] Downloading image ${imageCount} (depth ${depth}): ${node.url}`
+              );
+              const imageData = await this.downloadImageAsBase64(node.url, signal);
+              if (imageData) {
+                const imageCaption = `
+[\u56FE\u7247 ${imageCount}${node.width && node.height ? ` (${node.width}x${node.height})` : ""}]
+`;
+                parts.push({ text: imageCaption });
+                parts.push({
+                  inlineData: {
+                    data: imageData.data,
+                    mimeType: imageData.mimeType
+                  }
+                });
+                successCount++;
+                console.debug(
+                  `[RedocFetchTool] Image ${imageCount} downloaded successfully`
+                );
+              } else {
+                const placeholder = `
+[\u56FE\u7247 ${imageCount} - \u4E0B\u8F7D\u5931\u8D25: ${node.url}]
+`;
+                parts.push({ text: placeholder });
+                console.warn(
+                  `[RedocFetchTool] Failed to download image ${imageCount}: ${node.url}`
+                );
+              }
+              return;
+            }
+            if (node.children && Array.isArray(node.children)) {
+              if (node.type === "columns") {
+                textBuffer.push("\n[\u591A\u680F\u5E03\u5C40]");
+              } else if (node.type === "column") {
+                textBuffer.push("\n[\u680F\u76EE]");
+              }
+              for (const child of node.children) {
+                await processNode(child, depth + 1);
+              }
+              return;
+            }
+            const textContent3 = this.extractTextFromNode(node);
+            if (textContent3) {
+              textBuffer.push(textContent3);
+            }
+          }, "processNode");
+          for (const child of contentObj.children) {
+            await processNode(child, 0);
+          }
+          if (textBuffer.length > 0) {
+            parts.push({ text: textBuffer.join("\n") });
+          }
+          const extractAllText = /* @__PURE__ */ __name((node) => {
+            if (!node) return "";
+            if (node.type === "image") return "";
+            const nodeText = this.extractTextFromNode(node);
+            let childrenText = "";
+            if (node.children && Array.isArray(node.children)) {
+              childrenText = node.children.map((child) => extractAllText(child)).filter((text) => text).join("\n");
+            }
+            return [nodeText, childrenText].filter(Boolean).join("\n");
+          }, "extractAllText");
+          const textContent2 = contentObj.children.map((child) => extractAllText(child)).filter((text) => text).join("\n");
+          return {
+            parts,
+            textContent: textContent2,
+            imageCount,
+            successCount
+          };
+        } catch {
+          return {
+            parts: [{ text: content }],
+            textContent: content,
+            imageCount: 0,
+            successCount: 0
+          };
+        }
+      }
+      /**
+       * 从文档节点中提取文本内容（支持递归）
+       */
+      extractTextFromNode(node) {
+        if (!node) return "";
+        if (node.type === "image") return "";
+        switch (node.type) {
+          case "title":
+            return this.extractTextFromChildren(node.children, "# ");
+          case "h1":
+            return this.extractTextFromChildren(node.children, "## ");
+          case "h2":
+            return this.extractTextFromChildren(node.children, "### ");
+          case "h3":
+            return this.extractTextFromChildren(node.children, "#### ");
+          case "paragraph":
+            return this.extractTextFromChildren(node.children);
+          case "code":
+            return `\`\`\`
+${this.extractTextFromChildren(node.children)}
+\`\`\``;
+          case "numbered-list":
+          case "list":
+            return this.extractTextFromChildren(node.children, "- ");
+          case "block-quote":
+            return `> ${this.extractTextFromChildren(node.children)}`;
+          case "table":
+            return this.extractTableContent(node);
+          case "columns":
+          case "column":
+          case "table-cell-block":
+            if (node.children && Array.isArray(node.children)) {
+              return node.children.map((child) => this.extractTextFromNode(child)).filter((text) => text).join("\n");
+            }
+            return "";
+          default:
+            if (node.children) {
+              return this.extractTextFromChildren(node.children);
+            }
+            if (node.text) {
+              return node.text;
+            }
+            return "";
+        }
+      }
+      /**
+       * 从表格节点中提取文本内容
+       */
+      extractTableContent(tableNode) {
+        if (!tableNode.children || !Array.isArray(tableNode.children)) {
+          return "";
+        }
+        const rows = [];
+        for (const row of tableNode.children) {
+          if (row.type === "tr" && row.children) {
+            const cells = row.children.map((cell) => {
+              if (cell.type === "td") {
+                return this.extractTextFromNode(cell);
+              }
+              return "";
+            }).filter((text) => text);
+            if (cells.length > 0) {
+              rows.push("| " + cells.join(" | ") + " |");
+            }
+          }
+        }
+        return rows.join("\n");
+      }
+      /**
+       * 从子节点数组中提取文本
+       */
+      extractTextFromChildren(children, prefix = "") {
+        if (!children || !Array.isArray(children)) return "";
+        return children.map((child) => {
+          if (typeof child === "string") return child;
+          if (child.text) return prefix + child.text;
+          return this.extractTextFromNode(child);
+        }).join("");
+      }
+      /**
+       * 下载图片并转换为 Base64
+       */
+      async downloadImageAsBase64(url2, signal) {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(
+          () => controller.abort(),
+          IMAGE_DOWNLOAD_TIMEOUT_MS
+        );
+        try {
+          console.debug(`[RedocFetchTool] Downloading image from: ${url2}`);
+          const response = await fetch(url2, {
+            signal: controller.signal,
+            headers: {
+              "User-Agent": "Mozilla/5.0 (compatible; RDMind/1.0)"
+            }
+          });
+          if (!response.ok) {
+            console.warn(
+              `[RedocFetchTool] Failed to download image: ${response.status} ${response.statusText}`
+            );
+            return null;
+          }
+          const contentType = response.headers.get("content-type") || "";
+          const contentLength = response.headers.get("content-length");
+          if (contentLength) {
+            const sizeMB = parseInt(contentLength) / (1024 * 1024);
+            if (sizeMB > MAX_IMAGE_SIZE_MB) {
+              console.warn(
+                `[RedocFetchTool] Image too large: ${sizeMB.toFixed(2)}MB (max: ${MAX_IMAGE_SIZE_MB}MB)`
+              );
+              return null;
+            }
+          }
+          if (!contentType.startsWith("image/")) {
+            console.warn(
+              `[RedocFetchTool] URL does not return an image: ${contentType}`
+            );
+            return null;
+          }
+          const arrayBuffer = await response.arrayBuffer();
+          const buffer = Buffer.from(arrayBuffer);
+          const actualSizeMB = buffer.length / (1024 * 1024);
+          if (actualSizeMB > MAX_IMAGE_SIZE_MB) {
+            console.warn(
+              `[RedocFetchTool] Downloaded image too large: ${actualSizeMB.toFixed(2)}MB`
+            );
+            return null;
+          }
+          const base64Data = buffer.toString("base64");
+          let mimeType = contentType;
+          if (!mimeType || mimeType === "application/octet-stream") {
+            const urlPath = new URL(url2).pathname;
+            const detectedMime = index_lite_default.getType(urlPath);
+            if (detectedMime) {
+              mimeType = detectedMime;
+            }
+          }
+          console.debug(
+            `[RedocFetchTool] Successfully downloaded image: ${actualSizeMB.toFixed(2)}MB, type: ${mimeType}`
+          );
+          return {
+            data: base64Data,
+            mimeType
+          };
+        } catch (error2) {
+          if (error2 instanceof Error) {
+            console.warn(
+              `[RedocFetchTool] Error downloading image from ${url2}: ${error2.message}`
+            );
+          }
+          return null;
+        } finally {
+          clearTimeout(timeoutId);
+        }
+      }
       getDescription() {
         const displayPrompt = this.params.prompt.length > 100 ? this.params.prompt.substring(0, 97) + "..." : this.params.prompt;
         return `\u83B7\u53D6 Redoc \u6587\u6863\u5E76\u5206\u6790\uFF1A${displayPrompt}`;
@@ -222353,31 +223444,33 @@ var init_redoc_fetch = __esm({
           console.debug(
             `[RedocFetchTool] Processing content with prompt: "${this.params.prompt}"`
           );
+          const { parts, imageCount, successCount } = await this.buildContentWithImages(content, signal);
+          console.debug(
+            `[RedocFetchTool] Content parsed: ${imageCount} images found, ${successCount} downloaded successfully`
+          );
           const geminiClient = this.config.getGeminiClient();
-          let processedContent = content;
-          try {
-            const contentObj = JSON.parse(content);
-            if (contentObj.children && Array.isArray(contentObj.children)) {
-              processedContent = `\u6587\u6863\u7ED3\u6784\u5316\u5185\u5BB9\uFF08\u5305\u542B ${contentObj.children.length} \u4E2A\u5185\u5BB9\u5757\uFF09\uFF1A
-${content}`;
-            }
-          } catch (_e2) {
-            processedContent = content;
-          }
-          const fallbackPrompt = `\u8BF7\u6839\u636E\u7528\u6237\u7684\u95EE\u9898\u5206\u6790\u4EE5\u4E0B\u6587\u6863\u5185\u5BB9\uFF1A
+          const imageInfo = imageCount > 0 ? `
+
+\u6CE8\u610F\uFF1A\u6587\u6863\u4E2D\u5305\u542B ${imageCount} \u5F20\u56FE\u7247\uFF08\u6210\u529F\u52A0\u8F7D ${successCount} \u5F20\uFF09\uFF0C\u56FE\u7247\u5DF2\u6309\u539F\u59CB\u4F4D\u7F6E\u63D2\u5165\u5230\u6587\u6863\u5185\u5BB9\u4E2D\uFF0C\u8BF7\u7ED3\u5408\u4E0A\u4E0B\u6587\u548C\u56FE\u7247\u5185\u5BB9\u8FDB\u884C\u5206\u6790\u3002` : "";
+          const promptPart = {
+            text: `\u8BF7\u6839\u636E\u7528\u6237\u7684\u95EE\u9898\u5206\u6790\u4EE5\u4E0B\u6587\u6863\u5185\u5BB9\uFF1A
 
 \u7528\u6237\u95EE\u9898\uFF1A${this.params.prompt}
 
 \u6587\u6863\u6765\u6E90\uFF1A${this.params.url}
+${imageInfo}
 
-\u6587\u6863\u5185\u5BB9\uFF1A
----
-${processedContent}
----
+\u6587\u6863\u5185\u5BB9\u5982\u4E0B\uFF08\u6587\u672C\u548C\u56FE\u7247\u6309\u539F\u59CB\u987A\u5E8F\u6392\u5217\uFF09\uFF1A
+---`
+          };
+          const endPart = {
+            text: `---
 
-\u8BF7\u6839\u636E\u4E0A\u8FF0\u6587\u6863\u5185\u5BB9\u56DE\u7B54\u7528\u6237\u7684\u95EE\u9898\u3002`;
+\u8BF7\u6839\u636E\u4E0A\u8FF0\u6587\u6863\u5185\u5BB9\uFF08\u5305\u62EC\u6587\u672C\u548C\u56FE\u7247\uFF09\u56DE\u7B54\u7528\u6237\u7684\u95EE\u9898\u3002`
+          };
+          const allParts = [promptPart, ...parts, endPart];
           const result = await geminiClient.generateContent(
-            [{ role: "user", parts: [{ text: fallbackPrompt }] }],
+            [{ role: "user", parts: allParts }],
             {},
             signal,
             this.config.getModel() || DEFAULT_QWEN_MODEL
@@ -222386,9 +223479,10 @@ ${processedContent}
           console.debug(
             `[RedocFetchTool] Successfully processed Redoc content from ${this.params.url}`
           );
+          const displayMessage = imageCount > 0 ? `Redoc document from ${this.params.url} processed successfully (${successCount}/${imageCount} images loaded).` : `Redoc document from ${this.params.url} processed successfully.`;
           return {
             llmContent: resultText,
-            returnDisplay: `Redoc document from ${this.params.url} processed successfully.`
+            returnDisplay: displayMessage
           };
         } catch (e4) {
           const error2 = e4;
@@ -222406,7 +223500,7 @@ ${processedContent}
         super(
           _RedocFetchTool.Name,
           "RedocFetch",
-          "\u4ECE\u5C0F\u7EA2\u4E66 Redoc \u6587\u6863\u83B7\u53D6\u5185\u5BB9\u5E76\u4F7F\u7528 AI \u6A21\u578B\u5904\u7406\n- \u63A5\u53D7 Redoc \u6587\u6863 URL \u548C\u63D0\u793A\u8BCD\u4F5C\u4E3A\u8F93\u5165\n- \u4ECE URL \u4E2D\u63D0\u53D6\u6587\u6863 ID \u5E76\u901A\u8FC7 Redoc API \u83B7\u53D6\u5185\u5BB9\n- \u4F7F\u7528 AI \u6A21\u578B\u5904\u7406\u6587\u6863\u5185\u5BB9\u5E76\u56DE\u7B54\u7528\u6237\u95EE\u9898\n- \u8FD4\u56DE\u6A21\u578B\u5BF9\u5185\u5BB9\u7684\u54CD\u5E94\n- \u9002\u7528\u4E8E\u5404\u79CD\u7C7B\u578B\u7684\u5C0F\u7EA2\u4E66 Redoc \u6587\u6863\uFF08\u6280\u672F\u6587\u6863\u3001\u4EA7\u54C1\u6587\u6863\u3001\u8BBE\u8BA1\u6587\u6863\u7B49\uFF09\n\n\u4F7F\u7528\u8BF4\u660E:\n  - \u6B64\u5DE5\u5177\u4E13\u95E8\u9488\u5BF9\u683C\u5F0F\u4E3A https://docs.xiaohongshu.com/doc/{doc_id} \u7684 URL\n  - URL \u5FC5\u987B\u5305\u542B\u6709\u6548\u7684\u6587\u6863 ID\uFF0832 \u4F4D\u5341\u516D\u8FDB\u5236\u5B57\u7B26\u4E32\uFF09\n  - \u63D0\u793A\u8BCD\u5E94\u8BE5\u6E05\u6670\u63CF\u8FF0\u7528\u6237\u60F3\u4E86\u89E3\u6587\u6863\u7684\u54EA\u4E9B\u65B9\u9762\n  - \u6B64\u5DE5\u5177\u4E3A\u53EA\u8BFB\u5DE5\u5177\uFF0C\u4E0D\u4F1A\u4FEE\u6539\u4EFB\u4F55\u6587\u4EF6\n  - \u5982\u679C\u5185\u5BB9\u5F88\u5927\uFF0C\u7ED3\u679C\u53EF\u80FD\u4F1A\u88AB\u6458\u8981",
+          "\u4ECE\u5C0F\u7EA2\u4E66 Redoc \u6587\u6863\u83B7\u53D6\u5185\u5BB9\u5E76\u4F7F\u7528 AI \u6A21\u578B\u5904\u7406\n- \u63A5\u53D7 Redoc \u6587\u6863 URL \u548C\u63D0\u793A\u8BCD\u4F5C\u4E3A\u8F93\u5165\n- \u4ECE URL \u4E2D\u63D0\u53D6\u6587\u6863 ID \u5E76\u901A\u8FC7 Redoc API \u83B7\u53D6\u5185\u5BB9\n- \u81EA\u52A8\u63D0\u53D6\u6587\u6863\u4E2D\u7684\u56FE\u7247\u5E76\u4E0B\u8F7D\uFF0C\u652F\u6301\u56FE\u7247\u7406\u89E3\n- \u4F7F\u7528 AI \u6A21\u578B\u5904\u7406\u6587\u6863\u5185\u5BB9\uFF08\u5305\u542B\u6587\u672C\u548C\u56FE\u7247\uFF09\u5E76\u56DE\u7B54\u7528\u6237\u95EE\u9898\n- \u8FD4\u56DE\u6A21\u578B\u5BF9\u5185\u5BB9\u7684\u54CD\u5E94\n- \u9002\u7528\u4E8E\u5404\u79CD\u7C7B\u578B\u7684\u5C0F\u7EA2\u4E66 Redoc \u6587\u6863\uFF08\u6280\u672F\u6587\u6863\u3001\u4EA7\u54C1\u6587\u6863\u3001\u8BBE\u8BA1\u6587\u6863\u7B49\uFF09\n\n\u4F7F\u7528\u8BF4\u660E:\n  - \u6B64\u5DE5\u5177\u4E13\u95E8\u9488\u5BF9\u683C\u5F0F\u4E3A https://docs.xiaohongshu.com/doc/{doc_id} \u7684 URL\n  - URL \u5FC5\u987B\u5305\u542B\u6709\u6548\u7684\u6587\u6863 ID\uFF0832 \u4F4D\u5341\u516D\u8FDB\u5236\u5B57\u7B26\u4E32\uFF09\n  - \u63D0\u793A\u8BCD\u5E94\u8BE5\u6E05\u6670\u63CF\u8FF0\u7528\u6237\u60F3\u4E86\u89E3\u6587\u6863\u7684\u54EA\u4E9B\u65B9\u9762\n  - \u6B64\u5DE5\u5177\u4E3A\u53EA\u8BFB\u5DE5\u5177\uFF0C\u4E0D\u4F1A\u4FEE\u6539\u4EFB\u4F55\u6587\u4EF6\n  - \u5982\u679C\u6587\u6863\u5305\u542B\u56FE\u7247\uFF0C\u4F1A\u81EA\u52A8\u4E0B\u8F7D\u5E76\u53D1\u9001\u7ED9\u6A21\u578B\u8FDB\u884C\u7406\u89E3\n  - \u652F\u6301\u7684\u56FE\u7247\u683C\u5F0F\uFF1APNG\u3001JPEG\u3001GIF\u3001WEBP \u7B49\n  - \u5355\u5F20\u56FE\u7247\u6700\u5927 20MB",
           "fetch" /* Fetch */,
           {
             properties: {
@@ -258845,8 +259939,8 @@ var init_git_commit = __esm({
   "packages/core/src/generated/git-commit.ts"() {
     "use strict";
     init_esbuild_shims();
-    GIT_COMMIT_INFO = "73d256122";
-    CLI_VERSION = "0.2.3-alpha.1";
+    GIT_COMMIT_INFO = "982b367d4";
+    CLI_VERSION = "0.2.3-alpha.3";
   }
 });
 
@@ -359640,7 +360734,7 @@ __name(getPackageJson, "getPackageJson");
 // packages/cli/src/utils/version.ts
 async function getCliVersion() {
   const pkgJson = await getPackageJson();
-  return "0.2.3-alpha.1";
+  return "0.2.3-alpha.3";
 }
 __name(getCliVersion, "getCliVersion");
 
@@ -367370,7 +368464,7 @@ var formatDuration = /* @__PURE__ */ __name((milliseconds) => {
 
 // packages/cli/src/generated/git-commit.ts
 init_esbuild_shims();
-var GIT_COMMIT_INFO2 = "73d256122";
+var GIT_COMMIT_INFO2 = "982b367d4";
 
 // packages/cli/src/utils/systemInfo.ts
 async function getNpmVersion() {
@@ -375839,7 +376933,7 @@ async function buildSystemMessage(config2, sessionId, permissionMode, allowedBui
     model: config2.getModel(),
     permission_mode: permissionMode,
     slash_commands: slashCommands,
-    qwen_code_version: config2.getCliVersion() || "unknown",
+    rdmind_version: config2.getCliVersion() || "unknown",
     agents: agentNames
   };
   return systemMessage;
@@ -407172,6 +408266,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"
   }
 ];
 
@@ -425800,7 +426901,7 @@ var GeminiAgent = class {
       name: APPROVAL_MODE_INFO[mode].name,
       description: APPROVAL_MODE_INFO[mode].description
     }));
-    const version2 = "0.2.3-alpha.1";
+    const version2 = "0.2.3-alpha.3";
     return {
       protocolVersion: PROTOCOL_VERSION,
       agentInfo: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rdmind/rdmind",
-  "version": "0.2.3-alpha.1",
+  "version": "0.2.3-alpha.3",
   "description": "RDMind - AI-powered coding assistant",
   "type": "module",
   "main": "cli.js",
@@ -20,7 +20,7 @@
     "locales"
   ],
   "config": {
-    "sandboxImageUri": "ghcr.io/qwenlm/qwen-code:0.2.3-alpha.1"
+    "sandboxImageUri": "ghcr.io/qwenlm/qwen-code:0.2.3-alpha.3"
   },
   "publishConfig": {
     "access": "public"