@rdmind/rdmind 0.2.8-alpha.10 → 0.2.8-alpha.12

package/cli.js

@@ -148831,6 +148831,7 @@ var init_vertexAnthropicContentGenerator = __esm({
 // packages/core/src/core/codexContentGenerator.ts
 var codexContentGenerator_exports = {};
 __export(codexContentGenerator_exports, {
+  CodexApiError: () => CodexApiError,
   CodexContentGenerator: () => CodexContentGenerator
 });
 function extractBaseModel(model) {
@@ -149199,7 +149200,7 @@ function createGeminiResponse(responseId, parts, finishReason = FinishReason.STO
   }
   return response;
 }
-var CodexContentGenerator;
+var CodexApiError, CodexContentGenerator;
 var init_codexContentGenerator = __esm({
   "packages/core/src/core/codexContentGenerator.ts"() {
     "use strict";
@@ -149210,6 +149211,17 @@ var init_codexContentGenerator = __esm({
     init_loggers();
     init_types();
     init_openaiLogger();
+    CodexApiError = class extends Error {
+      constructor(code2, message, status) {
+        super(message);
+        this.code = code2;
+        this.status = status;
+        this.name = "CodexApiError";
+      }
+      static {
+        __name(this, "CodexApiError");
+      }
+    };
     CodexContentGenerator = class {
       static {
         __name(this, "CodexContentGenerator");
@@ -149311,8 +149323,20 @@ var init_codexContentGenerator = __esm({
         });
         if (!response.ok) {
           const errorText = await response.text();
-          throw new Error(
-            `Codex API request failed: ${response.status} - ${errorText}`
+          let errorCode = "unknown";
+          let errorMessage = errorText;
+          try {
+            const errorJson = JSON.parse(errorText);
+            if (errorJson.error) {
+              errorCode = errorJson.error.code || errorJson.error.type || "unknown";
+              errorMessage = errorJson.error.message || errorText;
+            }
+          } catch {
+          }
+          throw new CodexApiError(
+            errorCode,
+            `[Codex API Error] ${response.status} ${errorCode}: ${errorMessage}`,
+            response.status
           );
         }
         return response;
@@ -149359,12 +149383,20 @@ var init_codexContentGenerator = __esm({
           yieldCount: 0,
           totalLines: 0,
           skippedLines: 0,
-          firstRawChunk: ""
+          firstRawChunk: "",
+          lastRawDataSnippet: "",
+          finalEventType: "",
+          finalStatus: "",
+          finalOutputTypes: [],
+          finalOutputSummary: [],
+          finalExtractedTextLength: 0,
+          finalExtractedFunctionCallCount: 0
         };
         const toolCallArgs = /* @__PURE__ */ new Map();
         try {
           let isFirstChunk = true;
-          while (true) {
+          let streamFinished = false;
+          while (!streamFinished) {
             const { done, value } = await reader.read();
             if (done) break;
             const chunk = decoder.decode(value, { stream: true });
@@ -149385,18 +149417,33 @@ var init_codexContentGenerator = __esm({
               }
               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((content) => content.type)
+                    })) || [];
+                  }
                   const response = this.handleStreamEvent(
                     eventType,
                     data,
                     toolCallArgs,
-                    yieldState
+                    yieldState,
+                    streamDiag
                   );
                   if (response) {
                     streamDiag.yieldCount++;
@@ -149407,7 +149454,8 @@ var init_codexContentGenerator = __esm({
                       yieldState.hasYieldedFunctionCall = true;
                     yield response;
                   }
-                } catch {
+                } catch (e4) {
+                  if (e4 instanceof CodexApiError) throw e4;
                 }
               } else {
                 streamDiag.skippedLines++;
@@ -149427,7 +149475,7 @@ var init_codexContentGenerator = __esm({
           reader.releaseLock();
         }
       }
-      handleStreamEvent(event, data, toolCallArgs, yieldState) {
+      handleStreamEvent(event, data, toolCallArgs, yieldState, streamDiag) {
         switch (event) {
           case "response.reasoning_summary_text.delta": {
             return null;
@@ -149469,18 +149517,39 @@ var init_codexContentGenerator = __esm({
             }
             return null;
           }
+          case "error": {
+            const errData = data;
+            const code2 = errData["code"] || "unknown";
+            const message = errData["message"] || "Unknown API error";
+            throw new CodexApiError(code2, `[Codex API Error] ${code2}: ${message}`);
+          }
           case "response.completed":
           case "response.incomplete":
           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);
+            if (event === "response.failed") {
+              const respRecord = response;
+              const err = respRecord?.["error"];
+              const failCode = err?.code || "unknown";
+              const failMsg = err?.message || "Response failed without details";
+              throw new CodexApiError(
+                failCode,
+                `[Codex API Error] ${failCode}: ${failMsg}`
+              );
+            }
+            const finishReason = event === "response.incomplete" ? FinishReason.MAX_TOKENS : 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 });
+                  if (text) {
+                    parts.push({ text });
+                    if (streamDiag) {
+                      streamDiag.finalExtractedTextLength += text.length;
+                    }
+                  }
                 } else if (!yieldState.hasYieldedFunctionCall && item.type === "function_call" && item.arguments) {
                   try {
                     const args = JSON.parse(item.arguments);
@@ -149491,6 +149560,9 @@ var init_codexContentGenerator = __esm({
                         args
                       }
                     });
+                    if (streamDiag) {
+                      streamDiag.finalExtractedFunctionCallCount += 1;
+                    }
                   } catch {
                   }
                 }
@@ -161171,7 +161243,7 @@ __export(geminiContentGenerator_exports2, {
   createGeminiContentGenerator: () => createGeminiContentGenerator
 });
 function createGeminiContentGenerator(config2, gcConfig) {
-  const version2 = "0.2.8-alpha.10";
+  const version2 = "0.2.8-alpha.12";
   const userAgent2 = config2.userAgent || `QwenCode/${version2} (${process.platform}; ${process.arch})`;
   const baseHeaders = {
     "User-Agent": userAgent2
@@ -377151,7 +377223,7 @@ __name(getPackageJson, "getPackageJson");
 // packages/cli/src/utils/version.ts
 async function getCliVersion() {
   const pkgJson = await getPackageJson();
-  return "0.2.8-alpha.10";
+  return "0.2.8-alpha.12";
 }
 __name(getCliVersion, "getCliVersion");
 
@@ -447250,7 +447322,7 @@ var QwenAgent = class {
   async initialize(args) {
     this.clientCapabilities = args.clientCapabilities;
     const authMethods = buildAuthMethods();
-    const version2 = "0.2.8-alpha.10";
+    const version2 = "0.2.8-alpha.12";
     return {
       protocolVersion: PROTOCOL_VERSION,
       agentInfo: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rdmind/rdmind",
-  "version": "0.2.8-alpha.10",
+  "version": "0.2.8-alpha.12",
   "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.10"
+    "sandboxImageUri": "ghcr.io/qwenlm/qwen-code:0.2.8-alpha.12"
   },
   "publishConfig": {
     "access": "public"