@siduri-x/brain 1.0.1 → 1.0.3

package/dist/index.d.ts

@@ -3,10 +3,12 @@ export interface OpenAICompatibleBrainConfig {
     apiKey: string;
     model: string;
     baseUrl: string;
+    timeoutMs?: number;
 }
 export interface OpenRouterBrainConfig {
     apiKey: string;
     model: string;
+    timeoutMs?: number;
 }
 export declare class OpenAICompatibleBrain implements BrainOrgan {
     private config;

package/dist/index.js

@@ -104,44 +104,63 @@ class OpenAICompatibleBrain {
                 }
             }
         ];
+        const overallTimeoutMs = this.config.timeoutMs ?? 30000;
+        const overallController = new AbortController();
+        const overallTimer = setTimeout(() => {
+            overallController.abort(new Error(`Brain provider exceeded overall wall-clock deadline of ${overallTimeoutMs}ms`));
+        }, overallTimeoutMs);
         let retries = 3;
-        while (retries > 0) {
-            try {
-                const response = await fetch(`${this.config.baseUrl.replace(/\/+$/, '')}/chat/completions`, {
-                    method: "POST",
-                    headers: {
-                        "Authorization": `Bearer ${this.config.apiKey}`,
-                        "Content-Type": "application/json",
-                    },
-                    body: JSON.stringify({
-                        model: this.config.model,
-                        messages,
-                        tools,
-                        tool_choice: { type: "function", function: { name: "submitResponsePlan" } }
-                    })
-                });
-                if (!response.ok) {
-                    throw new Error(`OpenRouter API error: ${response.statusText}`);
+        let lastError;
+        try {
+            while (retries > 0) {
+                if (overallController.signal.aborted) {
+                    throw new Error(`Brain request aborted: overall deadline of ${overallTimeoutMs}ms exceeded`);
                 }
-                const data = await response.json();
-                const toolCall = data.choices?.[0]?.message?.tool_calls?.[0];
-                if (toolCall && toolCall.function.name === "submitResponsePlan") {
-                    const rawArgs = JSON.parse(toolCall.function.arguments);
-                    const parsed = ResponsePlanSchema.parse(rawArgs);
-                    return parsed;
+                try {
+                    const response = await fetch(`${this.config.baseUrl.replace(/\/+$/, '')}/chat/completions`, {
+                        method: "POST",
+                        headers: {
+                            "Authorization": `Bearer ${this.config.apiKey}`,
+                            "Content-Type": "application/json",
+                        },
+                        body: JSON.stringify({
+                            model: this.config.model,
+                            messages,
+                            tools,
+                            tool_choice: { type: "function", function: { name: "submitResponsePlan" } }
+                        }),
+                        signal: overallController.signal,
+                    });
+                    if (!response.ok) {
+                        throw new Error(`OpenRouter API error: ${response.statusText}`);
+                    }
+                    const data = await response.json();
+                    const toolCall = data.choices?.[0]?.message?.tool_calls?.[0];
+                    if (toolCall && toolCall.function.name === "submitResponsePlan") {
+                        const rawArgs = JSON.parse(toolCall.function.arguments);
+                        const parsed = ResponsePlanSchema.parse(rawArgs);
+                        return parsed;
+                    }
+                    throw new Error("No valid tool call returned from OpenRouter");
                 }
-                throw new Error("No valid tool call returned from OpenRouter");
-            }
-            catch (e) {
-                retries--;
-                if (retries === 0) {
-                    throw new Error("Failed to generate plan after retries: " + e.message);
+                catch (e) {
+                    lastError = e;
+                    if (overallController.signal.aborted) {
+                        throw new Error(`Brain request timed out after overall deadline of ${overallTimeoutMs}ms: ${e.message}`);
+                    }
+                    retries--;
+                    if (retries === 0) {
+                        throw new Error("Failed to generate plan after retries: " + e.message);
+                    }
+                    // backoff respecting remaining deadline
+                    await new Promise(r => setTimeout(r, 10));
                 }
-                // backoff
-                await new Promise(r => setTimeout(r, 10)); // keep test fast
             }
+            throw new Error(`Failed to generate plan after retries: ${lastError?.message || 'unknown error'}`);
+        }
+        finally {
+            clearTimeout(overallTimer);
         }
-        throw new Error("Failed to generate plan after retries");
     }
 }
 exports.OpenAICompatibleBrain = OpenAICompatibleBrain;

package/dist/index.test.js

@@ -88,6 +88,26 @@ describe('OpenRouterBrain', () => {
         await expect(brain.generatePlan(mockContext)).rejects.toThrow("Failed to generate plan after retries");
         expect(global.fetch).toHaveBeenCalledTimes(3);
     });
+    test('overall wall-clock deadline aborts slow / hanging requests', async () => {
+        const fastTimeoutBrain = new index_1.OpenRouterBrain({
+            apiKey: 'test-key',
+            model: 'test-model',
+            timeoutMs: 50,
+        });
+        // Mock fetch that hangs until aborted
+        global.fetch.mockImplementation((_url, init) => {
+            return new Promise((_resolve, reject) => {
+                if (init?.signal) {
+                    init.signal.addEventListener('abort', () => {
+                        const err = new Error('The operation was aborted');
+                        err.name = 'AbortError';
+                        reject(err);
+                    });
+                }
+            });
+        });
+        await expect(fastTimeoutBrain.generatePlan(mockContext)).rejects.toThrow(/deadline/i);
+    });
 });
 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": "1.0.1",
+  "version": "1.0.3",
   "displayName": "Brain (Cognition & Planning)",
   "description": "Provider-neutral LLM reasoning, response planning, and proposal generation",
   "entrypoint": "./dist/index.js",

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@siduri-x/brain",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "dependencies": {
     "zod": "^4.4.3",
-    "@siduri-x/core": "1.0.1"
+    "@siduri-x/core": "1.0.3"
   },
   "devDependencies": {
     "@types/jest": "^29.5.14",
@@ -18,7 +18,7 @@
   "license": "Apache-2.0",
   "repository": {
     "type": "git",
-    "url": "https://github.com/vxnuslabs/siduri-y",
+    "url": "https://github.com/vxnus-studio/siduri-x",
     "directory": "packages/organs/brain"
   },
   "publishConfig": {