@rdmind/rdmind 0.2.8-alpha.9 → 0.2.8

package/cli.js

@@ -134348,7 +134348,8 @@ var init_loggingContentGenerator = __esm({
                 combinedParts.push({
                   text: part.text,
                   ...part.thought ? { thought: true } : {},
-                  ...part.thoughtSignature ? { thoughtSignature: part.thoughtSignature } : {}
+                  ...part.thoughtSignature ? { thoughtSignature: part.thoughtSignature } : {},
+                  ..."codexReasoningItem" in part && part.codexReasoningItem ? { codexReasoningItem: part.codexReasoningItem } : {}
                 });
               }
               continue;
@@ -148869,6 +148870,45 @@ function buildCodexInput(contents, systemInstruction, modalities) {
 }
 function convertContentToCodexMessages(content, modalities) {
   const messages = [];
+  const convertCodexReasoningItem = /* @__PURE__ */ __name((rawItem, fallbackText, fallbackSignature) => {
+    if (!rawItem || typeof rawItem !== "object") {
+      if (!fallbackSignature) {
+        return null;
+      }
+      return {
+        type: "reasoning",
+        summary: [{ type: "summary_text", text: fallbackText }],
+        encrypted_content: fallbackSignature
+      };
+    }
+    const raw2 = rawItem;
+    const type = raw2["type"];
+    if (type !== "reasoning") {
+      return null;
+    }
+    const normalized2 = {
+      type: "reasoning",
+      id: typeof raw2["id"] === "string" ? raw2["id"] : void 0,
+      status: typeof raw2["status"] === "string" || raw2["status"] === null ? raw2["status"] : void 0,
+      encrypted_content: typeof raw2["encrypted_content"] === "string" || raw2["encrypted_content"] === null ? raw2["encrypted_content"] : fallbackSignature
+    };
+    if (Array.isArray(raw2["summary"])) {
+      normalized2.summary = raw2["summary"].filter(
+        (summaryItem) => typeof summaryItem === "object" && summaryItem !== null
+      ).map((summaryItem) => ({
+        ...summaryItem,
+        type: summaryItem["type"] === "summary_text" ? "summary_text" : "summary_text",
+        text: typeof summaryItem["text"] === "string" ? summaryItem["text"] : ""
+      }));
+    }
+    if (Array.isArray(raw2["content"])) {
+      normalized2.content = raw2["content"].filter((contentItem) => typeof contentItem === "object" && contentItem).map((contentItem) => ({ ...contentItem }));
+    }
+    if (!normalized2.summary || normalized2.summary.length === 0) {
+      normalized2.summary = [{ type: "summary_text", text: fallbackText }];
+    }
+    return normalized2;
+  }, "convertCodexReasoningItem");
   if (!content) return messages;
   if (typeof content === "string") {
     if (content.trim()) {
@@ -148886,7 +148926,21 @@ function convertContentToCodexMessages(content, modalities) {
       const partObj = part;
       if ("text" in partObj && typeof partObj["text"] === "string") {
         const text = partObj["text"];
-        if (!partObj["thought"]) {
+        const isThought = Boolean(partObj["thought"]);
+        const thoughtSignature = typeof partObj["thoughtSignature"] === "string" ? partObj["thoughtSignature"] : void 0;
+        const codexReasoningItem = "codexReasoningItem" in partObj ? partObj["codexReasoningItem"] : void 0;
+        if (isThought) {
+          if (role === "assistant") {
+            const reasoningMessage = convertCodexReasoningItem(
+              codexReasoningItem,
+              text,
+              thoughtSignature
+            );
+            if (reasoningMessage) {
+              messages.push(reasoningMessage);
+            }
+          }
+        } else {
           messages.push({ role, content: text });
         }
       }
@@ -149142,11 +149196,66 @@ function mapCodexStatusToFinishReason(status) {
       return FinishReason.STOP;
   }
 }
+function finalizeStreamResponse(response, streamState) {
+  const finalResponse = convertCodexResponseToGemini(response);
+  const shouldKeepThoughtPartsOnly = streamState.sawOutputTextDelta || streamState.sawFunctionCallChunk;
+  if (!finalResponse.candidates?.length) {
+    return finalResponse;
+  }
+  finalResponse.candidates = [
+    {
+      ...finalResponse.candidates[0] || {
+        index: 0,
+        content: { role: "model", parts: [] },
+        safetyRatings: []
+      },
+      content: {
+        role: "model",
+        parts: finalResponse.candidates[0]?.content?.parts?.flatMap((part) => {
+          if (shouldKeepThoughtPartsOnly && !part.thought) {
+            return [];
+          }
+          if (streamState.sawReasoningSummaryTextDelta && part.thought) {
+            return [
+              {
+                ...part,
+                text: ""
+              }
+            ];
+          }
+          return [part];
+        }) || []
+      }
+    }
+  ];
+  return finalResponse;
+}
 function convertCodexResponseToGemini(response) {
   const parts = [];
   if (response.output && Array.isArray(response.output)) {
     for (const item of response.output) {
       if (item.type === "reasoning") {
+        const summaryText = item.summary?.map((summaryItem) => summaryItem.text).filter(Boolean).join("") || "";
+        if (summaryText || item.encrypted_content) {
+          const thoughtPart = {
+            text: summaryText,
+            thought: true
+          };
+          if (item.encrypted_content) {
+            thoughtPart.thoughtSignature = item.encrypted_content;
+          }
+          thoughtPart.codexReasoningItem = {
+            type: "reasoning",
+            id: item.id,
+            status: item.status,
+            content: Array.isArray(item.content) ? item.content.map((contentItem) => ({
+              ...contentItem
+            })) : void 0,
+            summary: item.summary?.map((summaryItem) => ({ ...summaryItem })),
+            encrypted_content: item.encrypted_content
+          };
+          parts.push(thoughtPart);
+        }
         continue;
       }
       if (item.type === "message" && item.content) {
@@ -149301,14 +149410,25 @@ var init_codexContentGenerator = __esm({
         };
       }
       async fetchApi(request4) {
-        const response = await fetch(this.baseUrl, {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json",
-            "api-key": this.apiKey
-          },
-          body: JSON.stringify(request4)
-        });
+        let response;
+        try {
+          response = await fetch(this.baseUrl, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              "api-key": this.apiKey
+            },
+            body: JSON.stringify(request4)
+          });
+        } catch (err) {
+          const cause = err instanceof Error ? err.cause : void 0;
+          const code2 = cause && typeof cause === "object" && "code" in cause ? cause.code : void 0;
+          const msg = cause instanceof Error ? cause.message : String(cause ?? err);
+          throw new Error(
+            `Codex API network error: fetch failed (${code2 ?? "unknown"}). ${msg}`,
+            { cause: err }
+          );
+        }
         if (!response.ok) {
           const errorText = await response.text();
           throw new Error(
@@ -149329,7 +149449,8 @@ var init_codexContentGenerator = __esm({
           model,
           input,
           stream: stream2,
-          store: true,
+          store: false,
+          include: ["reasoning.encrypted_content"],
           truncation: "auto",
           temperature: this.samplingParams?.temperature ?? 1,
           top_p: this.samplingParams?.top_p,
@@ -149353,49 +149474,96 @@ var init_codexContentGenerator = __esm({
         const decoder = new TextDecoder();
         let buffer = "";
         let currentEvent = "";
-        const yieldState = { hasYieldedText: false, hasYieldedFunctionCall: false };
+        const streamDiag = {
+          eventTypes: [],
+          totalLines: 0,
+          skippedLines: 0,
+          firstRawChunk: "",
+          lastRawDataSnippet: "",
+          finalEventType: "",
+          finalStatus: "",
+          finalOutputTypes: [],
+          finalOutputSummary: [],
+          streamErrors: []
+        };
+        let streamFinished = false;
         const toolCallArgs = /* @__PURE__ */ new Map();
+        const streamState = {
+          sawReasoningSummaryTextDelta: false,
+          sawOutputTextDelta: false,
+          sawFunctionCallChunk: false
+        };
         try {
-          while (true) {
+          let isFirstChunk = true;
+          while (!streamFinished) {
             const { done, value } = await reader.read();
             if (done) break;
-            buffer += decoder.decode(value, { stream: true });
+            const chunk = decoder.decode(value, { stream: true });
+            if (isFirstChunk) {
+              streamDiag.firstRawChunk = chunk.slice(0, 500);
+              isFirstChunk = false;
+            }
+            buffer += chunk;
             const lines = buffer.split("\n");
             buffer = lines.pop() || "";
             for (const line of lines) {
               const trimmed2 = line.trim();
               if (!trimmed2) continue;
+              streamDiag.totalLines++;
               if (trimmed2.startsWith("event: ")) {
                 currentEvent = trimmed2.slice(7).trim();
                 continue;
               }
               if (trimmed2.startsWith("data: ")) {
                 const dataStr = trimmed2.slice(6).trim();
-                if (dataStr === "[DONE]") return;
+                if (dataStr === "[DONE]") {
+                  streamFinished = true;
+                  break;
+                }
                 try {
                   const data = JSON.parse(dataStr);
+                  streamDiag.lastRawDataSnippet = dataStr.slice(0, 1e3);
                   const eventType = currentEvent || data.type || "";
+                  if (eventType && !streamDiag.eventTypes.includes(eventType)) {
+                    streamDiag.eventTypes.push(eventType);
+                  }
+                  if (eventType === "response.completed" || eventType === "response.incomplete" || eventType === "response.failed") {
+                    const finalResponse = data.response;
+                    streamDiag.finalEventType = eventType;
+                    streamDiag.finalStatus = finalResponse?.status ?? "";
+                    streamDiag.finalOutputTypes = finalResponse?.output?.map((item) => item.type) ?? [];
+                    streamDiag.finalOutputSummary = finalResponse?.output?.map((item) => ({
+                      type: item.type,
+                      contentTypes: item.content?.map(
+                        (c4) => typeof c4 === "object" && c4 && "type" in c4 ? c4.type : void 0
+                      ).filter((type) => typeof type === "string")
+                    })) ?? [];
+                  }
+                  if (eventType === "error") {
+                    const errPayload = data;
+                    const nested = errPayload["error"];
+                    const code2 = errPayload["code"] || nested?.code || nested?.type || "unknown";
+                    const message = errPayload["message"] || nested?.message || JSON.stringify(data);
+                    streamDiag.streamErrors.push({ code: code2, message });
+                  }
                   const response = this.handleStreamEvent(
-                    eventType,
+                    currentEvent,
                     data,
                     toolCallArgs,
-                    yieldState
+                    streamState
                   );
                   if (response) {
-                    const parts = response.candidates?.[0]?.content?.parts;
-                    if (parts?.some((p2) => p2.text))
-                      yieldState.hasYieldedText = true;
-                    if (parts?.some((p2) => p2.functionCall))
-                      yieldState.hasYieldedFunctionCall = true;
                     yield response;
                   }
                 } catch {
                 }
+              } else {
+                streamDiag.skippedLines++;
               }
             }
           }
           context2.duration = Date.now() - context2.startTime;
-          await this.logStreamingSuccess(context2, request4);
+          await this.logStreamingSuccess(context2, request4, streamDiag);
         } catch (error40) {
           context2.duration = Date.now() - context2.startTime;
           await this.logError(context2, error40, request4);
@@ -149404,14 +149572,23 @@ var init_codexContentGenerator = __esm({
           reader.releaseLock();
         }
       }
-      handleStreamEvent(event, data, toolCallArgs, yieldState) {
+      handleStreamEvent(event, data, toolCallArgs, streamState) {
         switch (event) {
           case "response.reasoning_summary_text.delta": {
-            return null;
+            const text = data.delta;
+            if (!text) return null;
+            streamState.sawReasoningSummaryTextDelta = true;
+            return createGeminiResponse(data.item_id || "unknown", [
+              {
+                text,
+                thought: true
+              }
+            ]);
           }
           case "response.output_text.delta": {
             const text = data.delta;
             if (!text) return null;
+            streamState.sawOutputTextDelta = true;
             return createGeminiResponse(data.item_id || "unknown", [{ text }]);
           }
           case "response.function_call_arguments.delta": {
@@ -149435,6 +149612,7 @@ var init_codexContentGenerator = __esm({
                   const callId = item.call_id || item.id || accumulated?.id || `call_${Date.now()}`;
                   const name3 = item.name || accumulated?.name || "unknown";
                   toolCallArgs.delete(index);
+                  streamState.sawFunctionCallChunk = true;
                   return createGeminiResponse(data.item_id || "unknown", [
                     {
                       functionCall: { id: callId, name: name3, args }
@@ -149446,44 +149624,29 @@ var init_codexContentGenerator = __esm({
             }
             return null;
           }
-          case "response.completed":
-          case "response.incomplete":
+          case "response.completed": {
+            const response = data.response;
+            if (response) {
+              return finalizeStreamResponse(response, streamState);
+            }
+            return createGeminiResponse("final", []);
+          }
+          case "response.incomplete": {
+            const response = data.response;
+            if (response) {
+              return finalizeStreamResponse(response, streamState);
+            }
+            return createGeminiResponse("final", [], FinishReason.MAX_TOKENS);
+          }
           case "response.failed": {
             const response = data.response;
-            const finishReason = event === "response.incomplete" ? FinishReason.MAX_TOKENS : event === "response.failed" ? FinishReason.FINISH_REASON_UNSPECIFIED : mapCodexStatusToFinishReason(response?.status);
-            const usage2 = response?.usage;
-            const parts = [];
-            if (response?.output) {
-              for (const item of response.output) {
-                if (!yieldState.hasYieldedText && item.type === "message" && item.content) {
-                  const text = item.content.map((c4) => c4.text).filter(Boolean).join("");
-                  if (text) parts.push({ text });
-                } else if (!yieldState.hasYieldedFunctionCall && item.type === "function_call" && item.arguments) {
-                  try {
-                    const args = JSON.parse(item.arguments);
-                    parts.push({
-                      functionCall: {
-                        id: item.call_id || item.id || `call_${Date.now()}`,
-                        name: item.name || "unknown",
-                        args
-                      }
-                    });
-                  } catch {
-                  }
-                }
-              }
+            if (response) {
+              return finalizeStreamResponse(response, streamState);
             }
             return createGeminiResponse(
-              response?.id || "final",
-              parts,
-              finishReason,
-              usage2 ? {
-                promptTokenCount: usage2.input_tokens,
-                candidatesTokenCount: usage2.output_tokens,
-                totalTokenCount: usage2.total_tokens,
-                cachedContentTokenCount: usage2.input_tokens_details?.cached_tokens,
-                thoughtsTokenCount: usage2.output_tokens_details?.reasoning_tokens
-              } : void 0
+              "final",
+              [],
+              FinishReason.FINISH_REASON_UNSPECIFIED
             );
           }
           default:
@@ -149527,7 +149690,7 @@ var init_codexContentGenerator = __esm({
           await this.logger.logInteraction(request4, void 0, error40);
         }
       }
-      async logStreamingSuccess(context2, request4) {
+      async logStreamingSuccess(context2, request4, diagnostics) {
         if (!this.cliConfig) return;
         const event = new ApiResponseEvent(
           "unknown",
@@ -149539,7 +149702,10 @@ var init_codexContentGenerator = __esm({
         );
         logApiResponse(this.cliConfig, event);
         if (this.enableOpenAILogging && this.logger) {
-          await this.logger.logInteraction(request4, { streamed: true });
+          await this.logger.logInteraction(request4, {
+            streamed: true,
+            ...diagnostics ?? {}
+          });
         }
       }
     };
@@ -149554,6 +149720,7 @@ var init_codexContentGenerator = __esm({
     __name(convertTools, "convertTools");
     __name(convertGeminiSchemaToOpenAI, "convertGeminiSchemaToOpenAI");
     __name(mapCodexStatusToFinishReason, "mapCodexStatusToFinishReason");
+    __name(finalizeStreamResponse, "finalizeStreamResponse");
     __name(convertCodexResponseToGemini, "convertCodexResponseToGemini");
     __name(createGeminiResponse, "createGeminiResponse");
   }
@@ -161145,7 +161312,7 @@ __export(geminiContentGenerator_exports2, {
   createGeminiContentGenerator: () => createGeminiContentGenerator
 });
 function createGeminiContentGenerator(config2, gcConfig) {
-  const version2 = "0.2.8-alpha.9";
+  const version2 = "0.2.8";
   const userAgent2 = config2.userAgent || `QwenCode/${version2} (${process.platform}; ${process.arch})`;
   const baseHeaders = {
     "User-Agent": userAgent2
@@ -163095,6 +163262,12 @@ This error was probably caused by cyclic schema references in one of the followi
           if (thoughtContentPart && thoughtSignature) {
             thoughtContentPart.thoughtSignature = thoughtSignature;
           }
+          const codexReasoningItem = allModelParts.find(
+            (part) => part && typeof part === "object" && "thought" in part && part.thought && "codexReasoningItem" in part
+          );
+          if (thoughtContentPart && codexReasoningItem?.codexReasoningItem) {
+            thoughtContentPart.codexReasoningItem = codexReasoningItem.codexReasoningItem;
+          }
         }
         const contentParts = allModelParts.filter((part) => !part.thought);
         const consolidatedHistoryParts = [];
@@ -377125,7 +377298,7 @@ __name(getPackageJson, "getPackageJson");
 // packages/cli/src/utils/version.ts
 async function getCliVersion() {
   const pkgJson = await getPackageJson();
-  return "0.2.8-alpha.9";
+  return "0.2.8";
 }
 __name(getCliVersion, "getCliVersion");
 
@@ -384848,7 +385021,7 @@ var formatDuration = /* @__PURE__ */ __name((milliseconds) => {
 
 // packages/cli/src/generated/git-commit.ts
 init_esbuild_shims();
-var GIT_COMMIT_INFO = "32931e816";
+var GIT_COMMIT_INFO = "4ebf619b1";
 
 // packages/cli/src/utils/systemInfo.ts
 async function getNpmVersion() {
@@ -426223,13 +426396,6 @@ var XHS_SSO_MODELS = [
     contextWindow: "272K",
     description: "\u7528\u4E8E\u5904\u7406\u590D\u6742\u4E13\u4E1A\u5DE5\u4F5C\u7684\u524D\u6CBF\u6A21\u578B (\u63A8\u7406\u5F3A\u5EA6\u4E2D)"
   },
-  {
-    id: "gpt-5.4(xhigh)",
-    displayName: "gpt-5.4(xhigh)",
-    baseUrl: "https://runway.devops.rednote.life/openai/v1/responses?api-version=v1",
-    contextWindow: "272K",
-    description: "\u7528\u4E8E\u5904\u7406\u590D\u6742\u4E13\u4E1A\u5DE5\u4F5C\u7684\u524D\u6CBF\u6A21\u578B (\u63A8\u7406\u5F3A\u5EA6\u6781\u9AD8)"
-  },
   {
     id: "gpt-5.3-codex(medium)",
     displayName: "gpt-5.3-codex(medium)",
@@ -426293,13 +426459,13 @@ var XHS_SSO_MODELS = [
     contextWindow: "200K",
     description: "\u667A\u8C31\u65B0\u4E00\u4EE3\u7684\u65D7\u8230\u57FA\u5EA7\u6A21\u578B\uFF0C\u9762\u5411 Agentic Engineering \u6253\u9020\uFF0C\u5BF9\u9F50 Claude Opus 4.5"
   },
-  {
-    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"
-  },
+  // {
+  //   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 最强大的模型，擅长复杂推理和代码生成',
+  // },
   {
     id: "Kimi-K2.5",
     displayName: "Kimi-K2.5",
@@ -447224,7 +447390,7 @@ var QwenAgent = class {
   async initialize(args) {
     this.clientCapabilities = args.clientCapabilities;
     const authMethods = buildAuthMethods();
-    const version2 = "0.2.8-alpha.9";
+    const version2 = "0.2.8";
     return {
       protocolVersion: PROTOCOL_VERSION,
       agentInfo: {

package/package.json

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