n9router 0.4.34 → 0.4.36

package/app/open-sse/services/usage.js

@@ -58,13 +58,17 @@ const CLAUDE_CONFIG = {
  * @returns {Object} Usage data with quotas
  */
 export async function getUsageForProvider(connection, proxyOptions = null) {
-  const { provider, accessToken, apiKey, providerSpecificData } = connection;
+  const { provider, accessToken, apiKey, providerSpecificData, projectId } = connection;
+  const providerDataWithProjectId = {
+    ...(providerSpecificData || {}),
+    ...(projectId ? { projectId } : {}),
+  };
 
   switch (provider) {
     case "github":
       return await getGitHubUsage(accessToken, providerSpecificData, proxyOptions);
     case "gemini-cli":
-      return await getGeminiUsage(accessToken, providerSpecificData, proxyOptions);
+      return await getGeminiUsage(accessToken, providerDataWithProjectId, proxyOptions);
     case "antigravity":
       return await getAntigravityUsage(accessToken, providerSpecificData, proxyOptions);
     case "claude":
@@ -73,6 +77,8 @@ export async function getUsageForProvider(connection, proxyOptions = null) {
       return await getCodexUsage(accessToken, proxyOptions);
     case "kiro":
       return await getKiroUsage(accessToken, providerSpecificData, proxyOptions);
+    case "qoder":
+      return await getQoderUsage(accessToken, proxyOptions);
     case "qwen":
       return await getQwenUsage(accessToken, providerSpecificData);
     case "iflow":
@@ -222,18 +228,22 @@ async function getGeminiUsage(accessToken, providerSpecificData, proxyOptions =
   }
 
   try {
-    // Resolve project id: prefer connection-stored id, else loadCodeAssist lookup
-    let projectId = providerSpecificData?.projectId || null;
+    // Resolve project id: prefer connection-stored id, else loadCodeAssist lookup.
+    // #1271: OAuth save stores projectId on the connection, not providerSpecificData.
+    let projectId = normalizeCloudCodeProjectId(providerSpecificData?.projectId);
     let plan = "Free";
 
     if (!projectId) {
       const subInfo = await getGeminiSubscriptionInfo(accessToken, proxyOptions);
-      projectId = subInfo?.cloudaicompanionProject || null;
+      projectId = normalizeCloudCodeProjectId(subInfo?.cloudaicompanionProject);
       plan = subInfo?.currentTier?.name || plan;
     }
 
     if (!projectId) {
-      return { plan, message: "Gemini CLI project ID not available." };
+      return {
+        plan,
+        message: "Gemini CLI project ID not available. Reconnect Gemini CLI, or configure a Google Cloud project with Gemini Code Assist access before checking quota.",
+      };
     }
 
     const controller = new AbortController();
@@ -289,6 +299,14 @@ async function getGeminiUsage(accessToken, providerSpecificData, proxyOptions =
   }
 }
 
+function normalizeCloudCodeProjectId(project) {
+  if (typeof project === "string") return project.trim() || null;
+  if (project && typeof project === "object" && typeof project.id === "string") {
+    return project.id.trim() || null;
+  }
+  return null;
+}
+
 /**
  * Get Gemini CLI subscription info via loadCodeAssist
  */
@@ -305,11 +323,7 @@ async function getGeminiSubscriptionInfo(accessToken, proxyOptions = null) {
           "Content-Type": "application/json",
         },
         body: JSON.stringify({
-          metadata: {
-            ideType: "IDE_UNSPECIFIED",
-            platform: "PLATFORM_UNSPECIFIED",
-            pluginType: "GEMINI",
-          },
+          metadata: CLIENT_METADATA,
         }),
         signal: controller.signal,
       },
@@ -332,87 +346,121 @@ async function getAntigravityUsage(accessToken, providerSpecificData, proxyOptio
     // Fetch subscription info once — reuse for both projectId and plan
     const subscriptionInfo = await getAntigravitySubscriptionInfo(accessToken, proxyOptions);
     const projectId = subscriptionInfo?.cloudaicompanionProject || null;
+    const subscriptionTier = subscriptionInfo?.subscriptionTier || "Unknown";
 
-    // Fetch quota data with timeout
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), 10000); // 10s timeout
+    const endpoints = [
+      "https://daily-cloudcode-pa.sandbox.googleapis.com/v1internal:fetchAvailableModels",
+      "https://daily-cloudcode-pa.googleapis.com/v1internal:fetchAvailableModels",
+      "https://cloudcode-pa.googleapis.com/v1internal:fetchAvailableModels"
+    ];
 
-    let response;
-    try {
-      response = await proxyAwareFetch(ANTIGRAVITY_CONFIG.quotaApiUrl, {
-        method: "POST",
-        headers: {
-          "Authorization": `Bearer ${accessToken}`,
-          "User-Agent": ANTIGRAVITY_CONFIG.userAgent,
-          "Content-Type": "application/json",
-          "X-Client-Name": "antigravity",
-          "X-Client-Version": "1.107.0",
-          "x-request-source": "local", // MITM bypass
-        },
-        body: JSON.stringify({
-          ...(projectId ? { project: projectId } : {})
-        }),
-        signal: controller.signal,
-      }, proxyOptions);
-    } finally {
-      clearTimeout(timeoutId);
-    }
+    let response = null;
+    let responseData = null;
+    let fetchError = null;
 
-    if (response.status === 403) {
-      return {
-        message: "Antigravity quota API access forbidden. Chat may still work.",
-        quotas: {}
-      };
-    }
+    for (const url of endpoints) {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), 10000);
 
-    if (response.status === 401) {
-      return {
-        message: "Antigravity quota API authentication expired. Chat may still work.",
-        quotas: {}
-      };
+      let payload = projectId ? { project: projectId } : {};
+
+      try {
+        let res = await proxyAwareFetch(url, {
+          method: "POST",
+          headers: {
+            "Authorization": `Bearer ${accessToken}`,
+            "User-Agent": ANTIGRAVITY_CONFIG.userAgent,
+            "Content-Type": "application/json",
+            "X-Client-Name": "antigravity",
+            "X-Client-Version": "1.107.0",
+            "x-request-source": "local",
+          },
+          body: JSON.stringify(payload),
+          signal: controller.signal,
+        }, proxyOptions);
+
+        // 403 Forbidden check: if payload has project, retry without project ID on the SAME endpoint
+        if (res.status === 403 && payload.project) {
+          console.warn(`[Antigravity Quota] 403 Forbidden with project ID on ${url}, retrying without project ID...`);
+          res = await proxyAwareFetch(url, {
+            method: "POST",
+            headers: {
+              "Authorization": `Bearer ${accessToken}`,
+              "User-Agent": ANTIGRAVITY_CONFIG.userAgent,
+              "Content-Type": "application/json",
+              "X-Client-Name": "antigravity",
+              "X-Client-Version": "1.107.0",
+              "x-request-source": "local",
+            },
+            body: JSON.stringify({}),
+            signal: controller.signal,
+          }, proxyOptions);
+        }
+
+        if (res.status === 403) {
+          return {
+            plan: subscriptionTier,
+            message: "Antigravity quota API access forbidden.",
+            isForbidden: true,
+            quotas: {}
+          };
+        }
+
+        if (res.status === 401) {
+          return {
+            plan: subscriptionTier,
+            message: "Antigravity quota API authentication expired.",
+            isExpired: true,
+            quotas: {}
+          };
+        }
+
+        if (res.ok) {
+          response = res;
+          responseData = await res.json();
+          break; // Succeeded! Break the endpoints loop
+        } else {
+          const errText = await res.text();
+          fetchError = new Error(`HTTP ${res.status}: ${errText}`);
+        }
+      } catch (err) {
+        fetchError = err;
+      } finally {
+        clearTimeout(timeoutId);
+      }
     }
 
-    if (!response.ok) {
-      throw new Error(`Antigravity API error: ${response.status}`);
+    if (!response || !responseData) {
+      throw fetchError || new Error("Failed to fetch antigravity quota from all endpoints");
     }
 
-    const data = await response.json();
     const quotas = {};
-
-    // Parse model quotas (inspired by vscode-antigravity-cockpit)
-    if (data.models) {
-      // Filter only recommended/important models (must match PROVIDER_MODELS ag ids)
-      const importantModels = [
-        'gemini-3.5-flash-low',
-        'gemini-3-flash-agent',
-        'gemini-3.5-flash-extra-low',
-        'gemini-3.1-pro-low',
-        'gemini-pro-agent',
-        'claude-sonnet-4-6',
-        'claude-opus-4-6-thinking',
-        'gpt-oss-120b-medium',
-      ];
-
-      for (const [modelKey, info] of Object.entries(data.models)) {
-        // Skip models without quota info
+    if (responseData.models) {
+      // Like Antigravity-Manager, accept any model whose key starts with gemini, claude, gpt, image, or imagen
+      for (const [modelKey, info] of Object.entries(responseData.models)) {
         if (!info.quotaInfo) {
           continue;
         }
 
-        // Skip internal models and non-important models
-        if (info.isInternal || !importantModels.includes(modelKey)) {
+        const matchesTarget =
+          modelKey === "claude-opus-4-6-thinking" ||
+          modelKey === "claude-sonnet-4-6" ||
+          modelKey.startsWith("gemini-3.1-pro-") ||
+          modelKey === "gemini-3.1-pro" ||
+          modelKey.startsWith("gemini-3.5-") ||
+          modelKey === "gemini-3.5"||
+          modelKey === "gemini-3-flash-agent";
+
+        if (!matchesTarget) {
           continue;
         }
 
-        const remainingFraction = info.quotaInfo.remainingFraction || 0;
+        const remainingFraction = info.quotaInfo.remainingFraction != null ? info.quotaInfo.remainingFraction : 0;
         const remainingPercentage = remainingFraction * 100;
-
-        // Convert percentage to used/total for UI compatibility
-        const total = 1000; // Normalized base
+        const total = 1000;
         const remaining = Math.round(total * remainingFraction);
         const used = total - remaining;
 
-        // Use modelKey as key (matches PROVIDER_MODELS id)
         quotas[modelKey] = {
           used,
           total,
@@ -425,12 +473,12 @@ async function getAntigravityUsage(accessToken, providerSpecificData, proxyOptio
     }
 
     return {
-      plan: subscriptionInfo?.currentTier?.name || "Unknown",
+      plan: subscriptionTier,
       quotas,
       subscriptionInfo,
     };
   } catch (error) {
-    console.error("[Antigravity Usage] Error:", error.message, error.cause);
+    console.error("[Antigravity Usage] Error:", error.message);
     return { message: `Antigravity error: ${error.message}` };
   }
 }
@@ -447,33 +495,97 @@ async function getAntigravityProjectId(accessToken) {
   }
 }
 
+/**
+ * Check whether a tier string contains a recognizable keyword (ultra/pro/plus/free).
+ * Used to detect free accounts where currentTier.name is a generic label like "Antigravity".
+ */
+function isTierNormalizeable(value) {
+  if (!value) return false;
+  const lower = String(value).toLowerCase();
+  return lower.includes("ultra") || lower.includes("pro") || lower.includes("plus") || lower.includes("free") || lower.includes("restricted");
+}
+
 /**
  * Get Antigravity subscription info
  */
 async function getAntigravitySubscriptionInfo(accessToken, proxyOptions = null) {
-  const controller = new AbortController();
-  const timeoutId = setTimeout(() => controller.abort(), 10000); // 10s timeout
-  try {
-    const response = await proxyAwareFetch(ANTIGRAVITY_CONFIG.loadProjectApiUrl, {
-      method: "POST",
-      headers: {
-        "Authorization": `Bearer ${accessToken}`,
-        "User-Agent": ANTIGRAVITY_CONFIG.userAgent,
-        "Content-Type": "application/json",
-        "x-request-source": "local", // MITM bypass
-      },
-      body: JSON.stringify({ metadata: CLIENT_METADATA, mode: 1 }),
-      signal: controller.signal,
-    }, proxyOptions);
+  const urls = [
+    "https://daily-cloudcode-pa.sandbox.googleapis.com/v1internal:loadCodeAssist",
+    "https://daily-cloudcode-pa.googleapis.com/v1internal:loadCodeAssist",
+    "https://cloudcode-pa.googleapis.com/v1internal:loadCodeAssist"
+  ];
 
-    if (!response.ok) return null;
-    return await response.json();
-  } catch (error) {
-    console.error("[Antigravity Subscription] Error:", error.message);
-    return null;
-  } finally {
-    clearTimeout(timeoutId);
+  for (const url of urls) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 10000);
+    try {
+      const response = await proxyAwareFetch(url, {
+        method: "POST",
+        headers: {
+          "Authorization": `Bearer ${accessToken}`,
+          "User-Agent": ANTIGRAVITY_CONFIG.userAgent,
+          "Content-Type": "application/json",
+          "x-request-source": "local",
+        },
+        body: JSON.stringify({ metadata: CLIENT_METADATA, mode: 1 }),
+        signal: controller.signal,
+      }, proxyOptions);
+
+      if (response.ok) {
+        const data = await response.json();
+        const paidTier = data.paidTier;
+        const currentTier = data.currentTier;
+        const allowedTiers = data.allowedTiers;
+        const ineligibleTiers = data.ineligibleTiers;
+
+        let subscriptionTier = (paidTier?.name || paidTier?.id) || null;
+        const isIneligible = Array.isArray(ineligibleTiers) && ineligibleTiers.length > 0;
+
+        if (!subscriptionTier) {
+          if (!isIneligible) {
+            subscriptionTier = (currentTier?.name || currentTier?.id) || null;
+          } else {
+            if (Array.isArray(allowedTiers)) {
+              const defaultTier = allowedTiers.find(t => t.isDefault === true);
+              if (defaultTier) {
+                const nameOrId = defaultTier.name || defaultTier.id;
+                if (nameOrId) {
+                  subscriptionTier = `${nameOrId} (Restricted)`;
+                }
+              }
+            }
+          }
+        }
+
+        // If subscriptionTier resolved to a value that doesn't map to a known tier
+        // (e.g. free accounts return currentTier.name="Antigravity" which is unrecognized),
+        // fall back to currentTier.id (free accounts have id="free-tier") or force "Free".
+        // This mirrors Antigravity-Manager's catch-all: anything not "ultra"/"pro" → FREE.
+        if (subscriptionTier && !isTierNormalizeable(subscriptionTier)) {
+          const idFallback = currentTier?.id;
+          if (idFallback && isTierNormalizeable(idFallback)) {
+            subscriptionTier = idFallback; // e.g. "free-tier" → will normalize to "Free"
+          } else if (!paidTier) {
+            // No paid tier and name didn't normalize → treat as Free (catch-all like Antigravity-Manager)
+            subscriptionTier = "Free";
+          }
+        }
+
+        // If still no tier resolved but we have currentTier info → Free
+        if (!subscriptionTier && currentTier && !isIneligible) {
+          subscriptionTier = "Free";
+        }
+        
+        data.subscriptionTier = subscriptionTier;
+        return data;
+      }
+    } catch (error) {
+      console.error(`[Antigravity Subscription] Error fetching from ${url}:`, error.message);
+    } finally {
+      clearTimeout(timeoutId);
+    }
   }
+  return null;
 }
 
 /**
@@ -968,16 +1080,29 @@ async function getGlmUsage(apiKey, provider, proxyOptions = null) {
 }
 
 // ── MiniMax helpers ──────────────────────────────────────────────────────
-function isMiniMaxTextQuotaModel(modelName) {
-  const normalized = (modelName || "").trim().toLowerCase();
-  return normalized.startsWith("minimax-m") || normalized.startsWith("coding-plan");
-}
-
 function getMiniMaxField(model, snakeKey, camelKey) {
   if (!model || typeof model !== "object") return null;
   return model[snakeKey] ?? model[camelKey] ?? null;
 }
 
+function getMiniMaxModelName(model) {
+  return String(getMiniMaxField(model, "model_name", "modelName") || "").trim();
+}
+
+function formatMiniMaxQuotaName(model) {
+  const rawName = getMiniMaxModelName(model);
+  if (!rawName) return "MiniMax";
+
+  return rawName
+    .replace(/[_-]+/g, " ")
+    .replace(/\s+/g, " ")
+    .trim()
+    .replace(/\b\w/g, (ch) => ch.toUpperCase())
+    .replace(/\bTo\b/g, "to")
+    .replace(/\bTts\b/g, "TTS")
+    .replace(/\bHd\b/g, "HD");
+}
+
 function getMiniMaxSessionTotal(model) {
   return Math.max(0, Number(getMiniMaxField(model, "current_interval_total_count", "currentIntervalTotalCount")) || 0);
 }
@@ -986,11 +1111,8 @@ function getMiniMaxWeeklyTotal(model) {
   return Math.max(0, Number(getMiniMaxField(model, "current_weekly_total_count", "currentWeeklyTotalCount")) || 0);
 }
 
-function pickMiniMaxRepresentativeModel(models, getTotal) {
-  const withQuota = models.filter((m) => getTotal(m) > 0);
-  const pool = withQuota.length > 0 ? withQuota : models;
-  if (pool.length === 0) return null;
-  return pool.reduce((best, current) => (getTotal(current) > getTotal(best) ? current : best));
+function hasMiniMaxQuota(model) {
+  return getMiniMaxSessionTotal(model) > 0 || getMiniMaxWeeklyTotal(model) > 0;
 }
 
 function getMiniMaxResetAt(model, capturedAtMs, remainsSnake, remainsCamel, endSnake, endCamel) {
@@ -1013,6 +1135,19 @@ function buildMiniMaxQuota(total, count, resetAt, countMeansRemaining) {
   };
 }
 
+function addMiniMaxQuota(quotas, key, model, getTotal, countSnake, countCamel, resetArgs, countMeansRemaining) {
+  const total = getTotal(model);
+  if (total <= 0) return;
+
+  const count = Math.max(0, Number(getMiniMaxField(model, countSnake, countCamel)) || 0);
+  quotas[key] = buildMiniMaxQuota(
+    total,
+    count,
+    getMiniMaxResetAt(model, ...resetArgs),
+    countMeansRemaining
+  );
+}
+
 /**
  * MiniMax Token Plan / Coding Plan usage
  */
@@ -1066,34 +1201,37 @@ async function getMiniMaxUsage(apiKey, provider, proxyOptions = null) {
 
       const modelRemains = payload?.model_remains ?? payload?.modelRemains;
       const allModels = Array.isArray(modelRemains) ? modelRemains : [];
-      const textModels = allModels.filter((m) => isMiniMaxTextQuotaModel(String(getMiniMaxField(m, "model_name", "modelName"))));
+      const quotaModels = allModels.filter(hasMiniMaxQuota);
 
-      if (textModels.length === 0) {
-        return { message: "MiniMax connected. No text quota data was returned." };
+      if (quotaModels.length === 0) {
+        return { message: "MiniMax connected. No quota data was returned." };
       }
 
       const capturedAtMs = Date.now();
       const countMeansRemaining = usageUrl.includes("/coding_plan/remains");
       const quotas = {};
 
-      const sessionModel = pickMiniMaxRepresentativeModel(textModels, getMiniMaxSessionTotal);
-      if (sessionModel) {
-        const total = getMiniMaxSessionTotal(sessionModel);
-        const count = Math.max(0, Number(getMiniMaxField(sessionModel, "current_interval_usage_count", "currentIntervalUsageCount")) || 0);
-        quotas["session (5h)"] = buildMiniMaxQuota(
-          total, count,
-          getMiniMaxResetAt(sessionModel, capturedAtMs, "remains_time", "remainsTime", "end_time", "endTime"),
+      for (const model of quotaModels) {
+        const displayName = formatMiniMaxQuotaName(model);
+        addMiniMaxQuota(
+          quotas,
+          `${displayName} (5h)`,
+          model,
+          getMiniMaxSessionTotal,
+          "current_interval_usage_count",
+          "currentIntervalUsageCount",
+          [capturedAtMs, "remains_time", "remainsTime", "end_time", "endTime"],
           countMeansRemaining
         );
-      }
 
-      const weeklyModel = pickMiniMaxRepresentativeModel(textModels, getMiniMaxWeeklyTotal);
-      if (weeklyModel && getMiniMaxWeeklyTotal(weeklyModel) > 0) {
-        const total = getMiniMaxWeeklyTotal(weeklyModel);
-        const count = Math.max(0, Number(getMiniMaxField(weeklyModel, "current_weekly_usage_count", "currentWeeklyUsageCount")) || 0);
-        quotas["weekly (7d)"] = buildMiniMaxQuota(
-          total, count,
-          getMiniMaxResetAt(weeklyModel, capturedAtMs, "weekly_remains_time", "weeklyRemainsTime", "weekly_end_time", "weeklyEndTime"),
+        addMiniMaxQuota(
+          quotas,
+          `${displayName} (7d)`,
+          model,
+          getMiniMaxWeeklyTotal,
+          "current_weekly_usage_count",
+          "currentWeeklyUsageCount",
+          [capturedAtMs, "weekly_remains_time", "weeklyRemainsTime", "weekly_end_time", "weeklyEndTime"],
           countMeansRemaining
         );
       }
@@ -1111,3 +1249,65 @@ async function getMiniMaxUsage(apiKey, provider, proxyOptions = null) {
 
   return { message: lastErrorMessage ? `MiniMax connected. Unable to fetch usage: ${lastErrorMessage}` : "MiniMax connected. Unable to fetch usage." };
 }
+
+async function getQoderUsage(accessToken, proxyOptions = null) {
+  if (!accessToken) {
+    return { message: "Qoder usage unavailable: no access token" };
+  }
+  try {
+    const response = await proxyAwareFetch(
+      "https://openapi.qoder.sh/api/v2/quota/usage",
+      {
+        method: "GET",
+        headers: {
+          Authorization: `Bearer ${accessToken}`,
+          Accept: "application/json",
+        },
+      },
+      proxyOptions,
+    );
+    if (!response.ok) {
+      return { message: `Qoder connected. Usage fetch returned ${response.status}.` };
+    }
+    const body = await response.json().catch(() => null);
+    if (!body) {
+      return { message: "Qoder connected. Usage response was not JSON." };
+    }
+    // Quota records live under `quotas`; scalar metadata
+    // (totalUsagePercentage, isQuotaExceeded, expiresAt) are surfaced as
+    // siblings so the dashboard parser doesn't try to render them as rows.
+    const userQuota = body.userQuota || {};
+    const orgQuota = body.orgResourcePackage || {};
+    // Qoder publishes a single absolute reset timestamp (`expiresAt` in ms);
+    // surface it on every quota record as ISO so the table can render
+    // "resets at" alongside used/total.
+    const expiresAtMs = Number.isFinite(Number(body.expiresAt)) && Number(body.expiresAt) > 0
+      ? Number(body.expiresAt)
+      : null;
+    const resetAt = expiresAtMs ? new Date(expiresAtMs).toISOString() : null;
+    const quotas = {
+      user: {
+        total: Number(userQuota.total) || 0,
+        used: Number(userQuota.used) || 0,
+        remaining: Number(userQuota.remaining) || 0,
+        unit: userQuota.unit || "credits",
+        resetAt,
+      },
+      organization: {
+        total: Number(orgQuota.total) || 0,
+        used: Number(orgQuota.used) || 0,
+        remaining: Number(orgQuota.remaining) || 0,
+        unit: orgQuota.unit || "credits",
+        resetAt,
+      },
+    };
+    return {
+      quotas,
+      totalUsagePercentage: Number(body.totalUsagePercentage) || 0,
+      isQuotaExceeded: !!body.isQuotaExceeded,
+      expiresAt: expiresAtMs,
+    };
+  } catch (error) {
+    return { message: `Qoder connected. Unable to fetch usage: ${error.message}` };
+  }
+}

package/app/open-sse/translator/helpers/openaiHelper.js

@@ -18,6 +18,9 @@ export function filterToOpenAIFormat(body) {
   if (!body.messages || !Array.isArray(body.messages)) return body;
   
   body.messages = body.messages.map(msg => {
+    // Normalize developer role to system (many providers don't support developer)
+    if (msg.role === "developer") msg = { ...msg, role: "system" };
+    
     // Keep tool messages as-is (OpenAI format)
     if (msg.role === "tool") return msg;
     

package/app/open-sse/translator/request/openai-responses.js

@@ -29,10 +29,24 @@ export function openaiResponsesToOpenAIRequest(model, body, stream, credentials)
   // Group items by conversation turn
   let currentAssistantMsg = null;
   let pendingToolResults = [];
+  let pendingReasoning = "";
 
   const inputItems = normalizeResponsesInput(body.input);
   if (!inputItems) return body;
 
+  // Extract reasoning text from summary[].text or encrypted_content fallback
+  const extractReasoningText = (item) => {
+    if (Array.isArray(item.summary)) {
+      const txt = item.summary.map(s => s?.text || "").filter(Boolean).join("\n");
+      if (txt) return txt;
+    }
+    if (Array.isArray(item.content)) {
+      const txt = item.content.map(c => c?.text || "").filter(Boolean).join("\n");
+      if (txt) return txt;
+    }
+    return "";
+  };
+
   for (const item of inputItems) {
     // Determine item type - Droid CLI sends role-based items without 'type' field
     // Fallback: if no type but has role property, treat as message
@@ -64,7 +78,13 @@ export function openaiResponsesToOpenAIRequest(model, body, stream, credentials)
           return c;
         })
         : item.content;
-      result.messages.push({ role: item.role, content });
+      const msg = { role: item.role, content };
+      // Attach buffered reasoning to assistant turn (required by xiaomi-mimo thinking mode)
+      if (item.role === "assistant" && pendingReasoning) {
+        msg.reasoning_content = pendingReasoning;
+      }
+      pendingReasoning = "";
+      result.messages.push(msg);
     }
     else if (itemType === "function_call") {
       // Start or append to assistant message with tool_calls
@@ -74,6 +94,10 @@ export function openaiResponsesToOpenAIRequest(model, body, stream, credentials)
           content: null,
           tool_calls: []
         };
+        if (pendingReasoning) {
+          currentAssistantMsg.reasoning_content = pendingReasoning;
+          pendingReasoning = "";
+        }
       }
       // Skip items with empty/missing name — Codex/OpenAI reject nameless tool calls (#444)
       if (!item.name || typeof item.name !== "string" || item.name.trim() === "") continue;
@@ -107,7 +131,9 @@ export function openaiResponsesToOpenAIRequest(model, body, stream, credentials)
       });
     }
     else if (itemType === "reasoning") {
-      // Skip reasoning items - they are for display only
+      // Buffer reasoning text; attached to next assistant message/function_call
+      const txt = extractReasoningText(item);
+      if (txt) pendingReasoning = pendingReasoning ? `${pendingReasoning}\n${txt}` : txt;
       continue;
     }
   }