@siduri-x/brain 2.0.3 → 2.0.4

package/dist/index.js

@@ -156,6 +156,23 @@ class OpenAICompatibleBrain {
                     });
                     if (!response.ok) {
                         const status = response.status;
+                        let errorDetails = response.statusText || `HTTP ${status}`;
+                        try {
+                            if (typeof response.text === 'function') {
+                                const errorText = await response.text();
+                                try {
+                                    const parsed = JSON.parse(errorText);
+                                    errorDetails = parsed?.error?.message || parsed?.message || errorText;
+                                }
+                                catch {
+                                    if (errorText)
+                                        errorDetails = errorText;
+                                }
+                            }
+                        }
+                        catch {
+                            // fallback
+                        }
                         const retryHeader = response.headers?.get ? response.headers.get('retry-after') : undefined;
                         if (retryHeader) {
                             const parsedSec = parseInt(retryHeader, 10);
@@ -163,11 +180,11 @@ class OpenAICompatibleBrain {
                                 retryAfterSec = parsedSec;
                             }
                         }
-                        // Client authentication, forbidden, and bad request errors are fatal and should not be retried
-                        if (status === 400 || status === 401 || status === 403 || status === 404) {
-                            throw new Error(`Fatal upstream API error (${status}): ${response.statusText}`);
+                        // Client authentication, forbidden, insufficient credits, and bad request errors are fatal and should not be retried
+                        if (status === 400 || status === 401 || status === 402 || status === 403 || status === 404) {
+                            throw new Error(`Fatal upstream API error (${status}): ${errorDetails}`);
                         }
-                        throw new Error(`OpenRouter API error: ${response.statusText}`);
+                        throw new Error(`OpenRouter API error (${status}): ${errorDetails}`);
                     }
                     const data = await response.json();
                     const toolCall = data.choices?.[0]?.message?.tool_calls?.[0];
@@ -176,6 +193,14 @@ class OpenAICompatibleBrain {
                         const parsed = ResponsePlanSchema.parse(rawArgs);
                         return parsed;
                     }
+                    const directContent = data.choices?.[0]?.message?.content;
+                    if (typeof directContent === 'string' && directContent.trim().length > 0) {
+                        return {
+                            speech: directContent.trim(),
+                            language: 'en',
+                            internalMonologue: 'Direct completion without tool call',
+                        };
+                    }
                     throw new Error("No valid tool call returned from OpenRouter");
                 }
                 catch (e) {

package/dist/index.test.js

@@ -119,6 +119,31 @@ describe('OpenRouterBrain', () => {
         });
         await expect(fastTimeoutBrain.generatePlan(mockContext)).rejects.toThrow(/deadline/i);
     });
+    test('extracts detailed provider error message from upstream JSON body', async () => {
+        global.fetch.mockResolvedValue({
+            ok: false,
+            status: 402,
+            statusText: "Payment Required",
+            text: async () => JSON.stringify({ error: { message: "Provider balance exhausted. Please top up your account." } }),
+        });
+        await expect(brain.generatePlan(mockContext)).rejects.toThrow("Provider balance exhausted");
+        expect(global.fetch).toHaveBeenCalledTimes(1);
+    });
+    test('falls back gracefully to direct message content when model omits tool_calls', async () => {
+        global.fetch.mockResolvedValueOnce({
+            ok: true,
+            json: async () => ({
+                choices: [{
+                        message: {
+                            content: "Hello from direct completion!",
+                        },
+                    }],
+            }),
+        });
+        const plan = await brain.generatePlan(mockContext);
+        expect(plan.speech).toBe("Hello from direct completion!");
+        expect(plan.language).toBe("en");
+    });
 });
 describe('OpenAICompatibleBrain', () => {
     test('uses a configurable OpenAI-compatible endpoint', async () => {

package/organ-manifest.json

@@ -1,7 +1,7 @@
 {
   "name": "@siduri-x/brain",
   "organType": "brain",
-  "version": "2.0.2",
+  "version": "2.0.4",
   "displayName": "Brain (Cognition & Planning)",
   "description": "Provider-neutral LLM reasoning, response planning, and proposal generation",
   "entrypoint": "./dist/index.js",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@siduri-x/brain",
-  "version": "2.0.3",
+  "version": "2.0.4",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "dependencies": {