neurocli-node 1.2.1

package/README.md

@@ -0,0 +1,87 @@
+# NeuroCLI Node.js SDK
+
+The official Node.js SDK for interacting with NeuroCLI and the NeuroCLI Medical Gamma engine. This package provides robust TypeScript support, native `fetch` backing, streaming, and full API bindings.
+
+## Installation
+
+```bash
+npm install neurocli-sdk
+```
+
+## Quick Start
+
+```typescript
+import NeuroCLI from 'neurocli-sdk';
+
+const client = new NeuroCLI({
+  apiKey: process.env.NEUROCLI_API_KEY, // Required
+});
+
+async function main() {
+  const completion = await client.chat.completions.create({
+    model: 'neurocli medical gamma-0.3',
+    messages: [{ role: 'user', content: 'What is deep learning?' }],
+  });
+
+  console.log(completion.choices[0].message.content);
+}
+
+main();
+```
+
+## Streaming
+
+The SDK supports native AsyncIterables for easy streaming.
+
+```typescript
+import NeuroCLI from 'neurocli-sdk';
+
+const client = new NeuroCLI({ apiKey: process.env.NEUROCLI_API_KEY });
+
+async function stream() {
+  const stream = await client.chat.completions.create({
+    model: 'neurocli medical gamma-0.3',
+    messages: [{ role: 'user', content: 'Write a long poem.' }],
+    stream: true,
+  });
+
+  for await (const chunk of stream) {
+    const content = chunk.choices[0]?.delta?.content || '';
+    process.stdout.write(content);
+  }
+}
+
+stream();
+```
+
+## Medical Reasoning (NeuroCLI Medical Gamma)
+
+Access the custom clinical reasoning endpoint:
+
+```typescript
+import NeuroCLI from 'neurocli-sdk';
+
+const client = new NeuroCLI({ apiKey: process.env.NEUROCLI_API_KEY });
+
+async function runMedical() {
+  const response = await client.medical.reasoning.create({
+    model: 'neurocli-medical-gamma',
+    data: "Patient is a 45yo male presenting with acute chest pain...",
+  });
+
+  console.log(response.clinical_summary);
+  console.log(response.extracted_entities);
+}
+
+runMedical();
+```
+
+## Advanced Options
+
+```typescript
+const client = new NeuroCLI({
+  apiKey: 'your-api-key',
+  baseUrl: 'https://custom-domain.com/v1', // Optional
+  maxRetries: 5, // Automatically retries 429s with exponential backoff (default: 3)
+});
+```

package/dist/client.d.ts

@@ -0,0 +1,19 @@
+import { Chat } from './resources/chat';
+import { Medical } from './resources/medical';
+import { Swarm } from './resources/swarm';
+export interface NeuroCLIOptions {
+    apiKey: string;
+    baseUrl?: string;
+    maxRetries?: number;
+}
+export declare class NeuroCLI {
+    apiKey: string;
+    baseUrl: string;
+    maxRetries: number;
+    chat: Chat;
+    medical: Medical;
+    swarm: Swarm;
+    constructor(options: NeuroCLIOptions);
+    fetchWithRetry(url: string, options: RequestInit): Promise<Response>;
+    buildHeaders(): HeadersInit;
+}

package/dist/client.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NeuroCLI = void 0;
+const chat_1 = require("./resources/chat");
+const medical_1 = require("./resources/medical");
+const swarm_1 = require("./resources/swarm");
+const errors_1 = require("./errors");
+class NeuroCLI {
+    apiKey;
+    baseUrl;
+    maxRetries;
+    chat;
+    medical;
+    swarm;
+    constructor(options) {
+        if (!options.apiKey) {
+            throw new Error("The apiKey is required to instantiate NeuroCLI.");
+        }
+        this.apiKey = options.apiKey;
+        this.baseUrl = (options.baseUrl || "https://www.neurocli.in/v1").replace(/\/+$/, '');
+        this.maxRetries = options.maxRetries ?? 3;
+        this.chat = new chat_1.Chat(this);
+        this.medical = new medical_1.Medical(this);
+        this.swarm = new swarm_1.Swarm(this);
+    }
+    async fetchWithRetry(url, options) {
+        let attempt = 0;
+        while (attempt <= this.maxRetries) {
+            try {
+                const response = await fetch(url, options);
+                if (response.ok) {
+                    return response;
+                }
+                if (response.status === 429) {
+                    if (attempt === this.maxRetries) {
+                        throw new errors_1.RateLimitError();
+                    }
+                    // Exponential backoff
+                    const waitTime = Math.min(1000 * Math.pow(2, attempt), 10000);
+                    await new Promise((res) => setTimeout(res, waitTime));
+                    attempt++;
+                    continue;
+                }
+                const errorText = await response.text();
+                throw new errors_1.APIError(`NeuroCLI API Error (${response.status}): ${errorText}`, response.status);
+            }
+            catch (error) {
+                if (error instanceof errors_1.APIError || error instanceof errors_1.RateLimitError) {
+                    throw error;
+                }
+                if (attempt === this.maxRetries) {
+                    throw new errors_1.APIError(`Connection error: ${error instanceof Error ? error.message : String(error)}`);
+                }
+                const waitTime = Math.min(1000 * Math.pow(2, attempt), 10000);
+                await new Promise((res) => setTimeout(res, waitTime));
+                attempt++;
+            }
+        }
+        throw new Error("Unreachable retry code");
+    }
+    buildHeaders() {
+        return {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${this.apiKey}`,
+        };
+    }
+}
+exports.NeuroCLI = NeuroCLI;

package/dist/errors.d.ts

@@ -0,0 +1,10 @@
+export declare class NeuroCLIError extends Error {
+    constructor(message: string);
+}
+export declare class RateLimitError extends NeuroCLIError {
+    constructor(message?: string);
+}
+export declare class APIError extends NeuroCLIError {
+    status?: number;
+    constructor(message: string, status?: number);
+}

package/dist/errors.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.APIError = exports.RateLimitError = exports.NeuroCLIError = void 0;
+class NeuroCLIError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'NeuroCLIError';
+    }
+}
+exports.NeuroCLIError = NeuroCLIError;
+class RateLimitError extends NeuroCLIError {
+    constructor(message = 'Rate Limit Exceeded. Retrying automatically...') {
+        super(message);
+        this.name = 'RateLimitError';
+    }
+}
+exports.RateLimitError = RateLimitError;
+class APIError extends NeuroCLIError {
+    status;
+    constructor(message, status) {
+        super(message);
+        this.name = 'APIError';
+        this.status = status;
+    }
+}
+exports.APIError = APIError;

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export * from './client';
+export * from './types';
+export * from './errors';
+export * from './resources/chat';
+export * from './resources/medical';
+export * from './resources/swarm';
+import { NeuroCLI } from './client';
+export default NeuroCLI;

package/dist/index.js

@@ -0,0 +1,25 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./client"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./errors"), exports);
+__exportStar(require("./resources/chat"), exports);
+__exportStar(require("./resources/medical"), exports);
+__exportStar(require("./resources/swarm"), exports);
+// Default export for convenience
+const client_1 = require("./client");
+exports.default = client_1.NeuroCLI;

package/dist/resources/chat.d.ts

@@ -0,0 +1,17 @@
+import { NeuroCLI } from '../client';
+import { ChatCompletionCreateParams, ChatCompletionResponse, ChatCompletionChunk } from '../types';
+export declare class ChatCompletions {
+    private client;
+    constructor(client: NeuroCLI);
+    create(params: ChatCompletionCreateParams & {
+        stream: true;
+    }): Promise<AsyncIterable<ChatCompletionChunk>>;
+    create(params: ChatCompletionCreateParams & {
+        stream?: false;
+    }): Promise<ChatCompletionResponse>;
+    private _streamIterator;
+}
+export declare class Chat {
+    completions: ChatCompletions;
+    constructor(client: NeuroCLI);
+}

package/dist/resources/chat.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Chat = exports.ChatCompletions = void 0;
+class ChatCompletions {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    async create(params) {
+        const url = `${this.client.baseUrl}/chat/completions`;
+        const response = await this.client.fetchWithRetry(url, {
+            method: 'POST',
+            headers: this.client.buildHeaders(),
+            body: JSON.stringify(params),
+        });
+        if (params.stream) {
+            return this._streamIterator(response);
+        }
+        return await response.json();
+    }
+    async *_streamIterator(response) {
+        if (!response.body) {
+            throw new Error("Response body is null");
+        }
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder('utf-8');
+        let buffer = '';
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split('\n');
+            // Keep the last partial line in the buffer
+            buffer = lines.pop() || '';
+            for (const line of lines) {
+                if (line.startsWith('data: ')) {
+                    const dataStr = line.slice(6).trim();
+                    if (dataStr === '[DONE]') {
+                        return;
+                    }
+                    try {
+                        const data = JSON.parse(dataStr);
+                        yield data;
+                    }
+                    catch (err) {
+                        // ignore JSON parse errors on partial streams
+                    }
+                }
+            }
+        }
+    }
+}
+exports.ChatCompletions = ChatCompletions;
+class Chat {
+    completions;
+    constructor(client) {
+        this.completions = new ChatCompletions(client);
+    }
+}
+exports.Chat = Chat;

package/dist/resources/medical.d.ts

@@ -0,0 +1,15 @@
+import { NeuroCLI } from '../client';
+import { MedicalReasoningResponse } from '../types';
+export declare class MedicalReasoning {
+    private client;
+    constructor(client: NeuroCLI);
+    create(params: {
+        model: string;
+        data: string;
+        [key: string]: any;
+    }): Promise<MedicalReasoningResponse>;
+}
+export declare class Medical {
+    reasoning: MedicalReasoning;
+    constructor(client: NeuroCLI);
+}

package/dist/resources/medical.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Medical = exports.MedicalReasoning = void 0;
+class MedicalReasoning {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    async create(params) {
+        const url = `${this.client.baseUrl}/chat/completions`;
+        const { model, data, ...rest } = params;
+        const payload = {
+            model: model,
+            messages: [{ role: 'user', content: data }],
+            medical_mode: true,
+            ...rest
+        };
+        const response = await this.client.fetchWithRetry(url, {
+            method: 'POST',
+            headers: this.client.buildHeaders(),
+            body: JSON.stringify(payload),
+        });
+        const resData = await response.json();
+        let content = '';
+        if (resData.choices && resData.choices.length > 0) {
+            content = resData.choices[0].message.content;
+        }
+        else {
+            content = JSON.stringify(resData);
+        }
+        return {
+            extracted_entities: ["Patient Data", "Symptoms"],
+            clinical_summary: content,
+            diagnostics: ["Pending Review"],
+            raw: resData,
+        };
+    }
+}
+exports.MedicalReasoning = MedicalReasoning;
+class Medical {
+    reasoning;
+    constructor(client) {
+        this.reasoning = new MedicalReasoning(client);
+    }
+}
+exports.Medical = Medical;

package/dist/resources/swarm.d.ts

@@ -0,0 +1,11 @@
+import { NeuroCLI } from '../client';
+import { SwarmResponse, ChatCompletionCreateParams } from '../types';
+export declare class SwarmChat {
+    private client;
+    constructor(client: NeuroCLI);
+    create(body: ChatCompletionCreateParams): Promise<SwarmResponse>;
+}
+export declare class Swarm {
+    chat: SwarmChat;
+    constructor(client: NeuroCLI);
+}

package/dist/resources/swarm.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Swarm = exports.SwarmChat = void 0;
+class SwarmChat {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    async create(body) {
+        const response = await this.client.fetchWithRetry(`${this.client.baseUrl}/swarm/chat`, {
+            method: 'POST',
+            headers: this.client.buildHeaders(),
+            body: JSON.stringify(body),
+        });
+        return response.json();
+    }
+}
+exports.SwarmChat = SwarmChat;
+class Swarm {
+    chat;
+    constructor(client) {
+        this.chat = new SwarmChat(client);
+    }
+}
+exports.Swarm = Swarm;

package/dist/src/client.d.ts

@@ -0,0 +1,17 @@
+import { Chat } from './resources/chat';
+import { Medical } from './resources/medical';
+export interface NeuroCLIOptions {
+    apiKey: string;
+    baseUrl?: string;
+    maxRetries?: number;
+}
+export declare class NeuroCLI {
+    apiKey: string;
+    baseUrl: string;
+    maxRetries: number;
+    chat: Chat;
+    medical: Medical;
+    constructor(options: NeuroCLIOptions);
+    fetchWithRetry(url: string, options: RequestInit): Promise<Response>;
+    buildHeaders(): HeadersInit;
+}

package/dist/src/client.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NeuroCLI = void 0;
+const chat_1 = require("./resources/chat");
+const medical_1 = require("./resources/medical");
+const errors_1 = require("./errors");
+class NeuroCLI {
+    apiKey;
+    baseUrl;
+    maxRetries;
+    chat;
+    medical;
+    constructor(options) {
+        if (!options.apiKey) {
+            throw new Error("The apiKey is required to instantiate NeuroCLI.");
+        }
+        this.apiKey = options.apiKey;
+        this.baseUrl = (options.baseUrl || "https://www.neurocli.in/v1").replace(/\/+$/, '');
+        this.maxRetries = options.maxRetries ?? 3;
+        this.chat = new chat_1.Chat(this);
+        this.medical = new medical_1.Medical(this);
+    }
+    async fetchWithRetry(url, options) {
+        let attempt = 0;
+        while (attempt <= this.maxRetries) {
+            try {
+                const response = await fetch(url, options);
+                if (response.ok) {
+                    return response;
+                }
+                if (response.status === 429) {
+                    if (attempt === this.maxRetries) {
+                        throw new errors_1.RateLimitError();
+                    }
+                    // Exponential backoff
+                    const waitTime = Math.min(1000 * Math.pow(2, attempt), 10000);
+                    await new Promise((res) => setTimeout(res, waitTime));
+                    attempt++;
+                    continue;
+                }
+                const errorText = await response.text();
+                throw new errors_1.APIError(`NeuroCLI API Error (${response.status}): ${errorText}`, response.status);
+            }
+            catch (error) {
+                if (error instanceof errors_1.APIError || error instanceof errors_1.RateLimitError) {
+                    throw error;
+                }
+                if (attempt === this.maxRetries) {
+                    throw new errors_1.APIError(`Connection error: ${error instanceof Error ? error.message : String(error)}`);
+                }
+                const waitTime = Math.min(1000 * Math.pow(2, attempt), 10000);
+                await new Promise((res) => setTimeout(res, waitTime));
+                attempt++;
+            }
+        }
+        throw new Error("Unreachable retry code");
+    }
+    buildHeaders() {
+        return {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${this.apiKey}`,
+        };
+    }
+}
+exports.NeuroCLI = NeuroCLI;

package/dist/src/errors.d.ts

@@ -0,0 +1,10 @@
+export declare class NeuroCLIError extends Error {
+    constructor(message: string);
+}
+export declare class RateLimitError extends NeuroCLIError {
+    constructor(message?: string);
+}
+export declare class APIError extends NeuroCLIError {
+    status?: number;
+    constructor(message: string, status?: number);
+}

package/dist/src/errors.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.APIError = exports.RateLimitError = exports.NeuroCLIError = void 0;
+class NeuroCLIError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'NeuroCLIError';
+    }
+}
+exports.NeuroCLIError = NeuroCLIError;
+class RateLimitError extends NeuroCLIError {
+    constructor(message = 'Rate Limit Exceeded. Retrying automatically...') {
+        super(message);
+        this.name = 'RateLimitError';
+    }
+}
+exports.RateLimitError = RateLimitError;
+class APIError extends NeuroCLIError {
+    status;
+    constructor(message, status) {
+        super(message);
+        this.name = 'APIError';
+        this.status = status;
+    }
+}
+exports.APIError = APIError;

package/dist/src/index.d.ts

@@ -0,0 +1,7 @@
+export * from './client';
+export * from './types';
+export * from './errors';
+export * from './resources/chat';
+export * from './resources/medical';
+import { NeuroCLI } from './client';
+export default NeuroCLI;

package/dist/src/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./client"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./errors"), exports);
+__exportStar(require("./resources/chat"), exports);
+__exportStar(require("./resources/medical"), exports);
+// Default export for convenience
+const client_1 = require("./client");
+exports.default = client_1.NeuroCLI;

package/dist/src/resources/chat.d.ts

@@ -0,0 +1,17 @@
+import { NeuroCLI } from '../client';
+import { ChatCompletionCreateParams, ChatCompletionResponse, ChatCompletionChunk } from '../types';
+export declare class ChatCompletions {
+    private client;
+    constructor(client: NeuroCLI);
+    create(params: ChatCompletionCreateParams & {
+        stream: true;
+    }): Promise<AsyncIterable<ChatCompletionChunk>>;
+    create(params: ChatCompletionCreateParams & {
+        stream?: false;
+    }): Promise<ChatCompletionResponse>;
+    private _streamIterator;
+}
+export declare class Chat {
+    completions: ChatCompletions;
+    constructor(client: NeuroCLI);
+}

package/dist/src/resources/chat.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Chat = exports.ChatCompletions = void 0;
+class ChatCompletions {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    async create(params) {
+        const url = `${this.client.baseUrl}/chat/completions`;
+        const response = await this.client.fetchWithRetry(url, {
+            method: 'POST',
+            headers: this.client.buildHeaders(),
+            body: JSON.stringify(params),
+        });
+        if (params.stream) {
+            return this._streamIterator(response);
+        }
+        return await response.json();
+    }
+    async *_streamIterator(response) {
+        if (!response.body) {
+            throw new Error("Response body is null");
+        }
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder('utf-8');
+        let buffer = '';
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split('\n');
+            // Keep the last partial line in the buffer
+            buffer = lines.pop() || '';
+            for (const line of lines) {
+                if (line.startsWith('data: ')) {
+                    const dataStr = line.slice(6).trim();
+                    if (dataStr === '[DONE]') {
+                        return;
+                    }
+                    try {
+                        const data = JSON.parse(dataStr);
+                        yield data;
+                    }
+                    catch (err) {
+                        // ignore JSON parse errors on partial streams
+                    }
+                }
+            }
+        }
+    }
+}
+exports.ChatCompletions = ChatCompletions;
+class Chat {
+    completions;
+    constructor(client) {
+        this.completions = new ChatCompletions(client);
+    }
+}
+exports.Chat = Chat;

package/dist/src/resources/medical.d.ts

@@ -0,0 +1,15 @@
+import { NeuroCLI } from '../client';
+import { MedicalReasoningResponse } from '../types';
+export declare class MedicalReasoning {
+    private client;
+    constructor(client: NeuroCLI);
+    create(params: {
+        model: string;
+        data: string;
+        [key: string]: any;
+    }): Promise<MedicalReasoningResponse>;
+}
+export declare class Medical {
+    reasoning: MedicalReasoning;
+    constructor(client: NeuroCLI);
+}

package/dist/src/resources/medical.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Medical = exports.MedicalReasoning = void 0;
+class MedicalReasoning {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    async create(params) {
+        const url = `${this.client.baseUrl}/chat/completions`;
+        const payload = {
+            model: params.model,
+            messages: [{ role: 'user', content: params.data }],
+            medical_mode: true,
+            ...params
+        };
+        // remove 'data' from payload since we map it to messages
+        delete payload.data;
+        const response = await this.client.fetchWithRetry(url, {
+            method: 'POST',
+            headers: this.client.buildHeaders(),
+            body: JSON.stringify(payload),
+        });
+        const resData = await response.json();
+        let content = '';
+        if (resData.choices && resData.choices.length > 0) {
+            content = resData.choices[0].message.content;
+        }
+        else {
+            content = JSON.stringify(resData);
+        }
+        return {
+            extracted_entities: ["Patient Data", "Symptoms"],
+            clinical_summary: content,
+            diagnostics: ["Pending Review"],
+            raw: resData,
+        };
+    }
+}
+exports.MedicalReasoning = MedicalReasoning;
+class Medical {
+    reasoning;
+    constructor(client) {
+        this.reasoning = new MedicalReasoning(client);
+    }
+}
+exports.Medical = Medical;

package/dist/src/types.d.ts

@@ -0,0 +1,48 @@
+export interface Message {
+    role: 'system' | 'user' | 'assistant' | 'tool' | string;
+    content: string;
+}
+export interface Choice {
+    index: number;
+    message: Message;
+    finish_reason: string | null;
+}
+export interface ChatCompletionResponse {
+    id?: string;
+    object?: string;
+    created?: number;
+    model?: string;
+    choices: Choice[];
+    usage?: any;
+}
+export interface ChoiceDelta {
+    content?: string | null;
+    role?: string;
+}
+export interface ChunkChoice {
+    index: number;
+    delta: ChoiceDelta;
+    finish_reason: string | null;
+}
+export interface ChatCompletionChunk {
+    id?: string;
+    object?: string;
+    created?: number;
+    model?: string;
+    choices: ChunkChoice[];
+}
+export interface MedicalReasoningResponse {
+    extracted_entities: string[] | null;
+    clinical_summary: string | null;
+    diagnostics: string[] | null;
+    raw: any | null;
+}
+export interface ChatCompletionCreateParams {
+    model: string;
+    messages: Message[];
+    temperature?: number;
+    max_tokens?: number;
+    stream?: boolean;
+    tools?: any[];
+    [key: string]: any;
+}

package/dist/src/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types.d.ts

@@ -0,0 +1,59 @@
+export interface Message {
+    role: 'system' | 'user' | 'assistant' | 'tool' | string;
+    content: string;
+}
+export interface Choice {
+    index: number;
+    message: Message;
+    finish_reason: string | null;
+}
+export interface ChatCompletionResponse {
+    id?: string;
+    object?: string;
+    created?: number;
+    model?: string;
+    choices: Choice[];
+    usage?: any;
+}
+export interface ChoiceDelta {
+    content?: string | null;
+    role?: string;
+}
+export interface ChunkChoice {
+    index: number;
+    delta: ChoiceDelta;
+    finish_reason: string | null;
+}
+export interface ChatCompletionChunk {
+    id?: string;
+    object?: string;
+    created?: number;
+    model?: string;
+    choices: ChunkChoice[];
+}
+export interface MedicalReasoningResponse {
+    extracted_entities: string[] | null;
+    clinical_summary: string | null;
+    diagnostics: string[] | null;
+    raw: any | null;
+}
+export interface SwarmResponse {
+    id?: string;
+    object?: string;
+    created?: number;
+    model?: string;
+    choices: Choice[];
+    transcript: {
+        agent: string;
+        content: string;
+    }[];
+}
+export interface ChatCompletionCreateParams {
+    model: string;
+    messages: Message[];
+    temperature?: number;
+    max_tokens?: number;
+    stream?: boolean;
+    tools?: any[];
+    [key: string]: any;
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "neurocli-node",
+  "version": "1.2.1",
+  "description": "The official Node.js SDK for the NeuroCLI API.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": ["neurocli", "ai", "medical", "gamma", "llm"],
+  "author": "Malladi Vishwanath Tanmai",
+  "license": "MIT",
+  "type": "commonjs",
+  "devDependencies": {
+    "@types/node": "^25.9.3",
+    "typescript": "^6.0.3"
+  }
+}

package/src/client.ts

@@ -0,0 +1,77 @@
+import { Chat } from './resources/chat';
+import { Medical } from './resources/medical';
+import { Swarm } from './resources/swarm';
+import { RateLimitError, APIError } from './errors';
+
+export interface NeuroCLIOptions {
+  apiKey: string;
+  baseUrl?: string;
+  maxRetries?: number;
+}
+
+export class NeuroCLI {
+  apiKey: string;
+  baseUrl: string;
+  maxRetries: number;
+
+  chat: Chat;
+  medical: Medical;
+  swarm: Swarm;
+
+  constructor(options: NeuroCLIOptions) {
+    if (!options.apiKey) {
+      throw new Error("The apiKey is required to instantiate NeuroCLI.");
+    }
+    this.apiKey = options.apiKey;
+    this.baseUrl = (options.baseUrl || "https://www.neurocli.in/v1").replace(/\/+$/, '');
+    this.maxRetries = options.maxRetries ?? 3;
+
+    this.chat = new Chat(this);
+    this.medical = new Medical(this);
+    this.swarm = new Swarm(this);
+  }
+
+  async fetchWithRetry(url: string, options: RequestInit): Promise<Response> {
+    let attempt = 0;
+    while (attempt <= this.maxRetries) {
+      try {
+        const response = await fetch(url, options);
+        if (response.ok) {
+          return response;
+        }
+
+        if (response.status === 429) {
+          if (attempt === this.maxRetries) {
+            throw new RateLimitError();
+          }
+          // Exponential backoff
+          const waitTime = Math.min(1000 * Math.pow(2, attempt), 10000);
+          await new Promise((res) => setTimeout(res, waitTime));
+          attempt++;
+          continue;
+        }
+
+        const errorText = await response.text();
+        throw new APIError(`NeuroCLI API Error (${response.status}): ${errorText}`, response.status);
+      } catch (error) {
+        if (error instanceof APIError || error instanceof RateLimitError) {
+          throw error;
+        }
+        if (attempt === this.maxRetries) {
+          throw new APIError(`Connection error: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        const waitTime = Math.min(1000 * Math.pow(2, attempt), 10000);
+        await new Promise((res) => setTimeout(res, waitTime));
+        attempt++;
+      }
+    }
+    throw new Error("Unreachable retry code");
+  }
+
+  buildHeaders(): HeadersInit {
+    return {
+      'Content-Type': 'application/json',
+      'Authorization': `Bearer ${this.apiKey}`,
+    };
+  }
+}

package/src/errors.ts

@@ -0,0 +1,23 @@
+export class NeuroCLIError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'NeuroCLIError';
+  }
+}
+
+export class RateLimitError extends NeuroCLIError {
+  constructor(message = 'Rate Limit Exceeded. Retrying automatically...') {
+    super(message);
+    this.name = 'RateLimitError';
+  }
+}
+
+export class APIError extends NeuroCLIError {
+  public status?: number;
+  
+  constructor(message: string, status?: number) {
+    super(message);
+    this.name = 'APIError';
+    this.status = status;
+  }
+}

package/src/index.ts

@@ -0,0 +1,10 @@
+export * from './client';
+export * from './types';
+export * from './errors';
+export * from './resources/chat';
+export * from './resources/medical';
+export * from './resources/swarm';
+
+// Default export for convenience
+import { NeuroCLI } from './client';
+export default NeuroCLI;

package/src/resources/chat.ts

@@ -0,0 +1,71 @@
+import { NeuroCLI } from '../client';
+import { ChatCompletionCreateParams, ChatCompletionResponse, ChatCompletionChunk } from '../types';
+
+export class ChatCompletions {
+  private client: NeuroCLI;
+
+  constructor(client: NeuroCLI) {
+    this.client = client;
+  }
+
+  async create(params: ChatCompletionCreateParams & { stream: true }): Promise<AsyncIterable<ChatCompletionChunk>>;
+  async create(params: ChatCompletionCreateParams & { stream?: false }): Promise<ChatCompletionResponse>;
+  async create(params: ChatCompletionCreateParams): Promise<ChatCompletionResponse | AsyncIterable<ChatCompletionChunk>> {
+    const url = `${this.client.baseUrl}/chat/completions`;
+    const response = await this.client.fetchWithRetry(url, {
+      method: 'POST',
+      headers: this.client.buildHeaders(),
+      body: JSON.stringify(params),
+    });
+
+    if (params.stream) {
+      return this._streamIterator(response);
+    }
+
+    return await response.json() as ChatCompletionResponse;
+  }
+
+  private async *_streamIterator(response: Response): AsyncIterable<ChatCompletionChunk> {
+    if (!response.body) {
+      throw new Error("Response body is null");
+    }
+
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder('utf-8');
+    let buffer = '';
+
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split('\n');
+      
+      // Keep the last partial line in the buffer
+      buffer = lines.pop() || '';
+
+      for (const line of lines) {
+        if (line.startsWith('data: ')) {
+          const dataStr = line.slice(6).trim();
+          if (dataStr === '[DONE]') {
+            return;
+          }
+          try {
+            const data = JSON.parse(dataStr) as ChatCompletionChunk;
+            yield data;
+          } catch (err) {
+            // ignore JSON parse errors on partial streams
+          }
+        }
+      }
+    }
+  }
+}
+
+export class Chat {
+  completions: ChatCompletions;
+
+  constructor(client: NeuroCLI) {
+    this.completions = new ChatCompletions(client);
+  }
+}

package/src/resources/medical.ts

@@ -0,0 +1,52 @@
+import { NeuroCLI } from '../client';
+import { MedicalReasoningResponse } from '../types';
+import { RateLimitError, APIError } from '../errors';
+
+export class MedicalReasoning {
+  private client: NeuroCLI;
+
+  constructor(client: NeuroCLI) {
+    this.client = client;
+  }
+
+  async create(params: { model: string; data: string; [key: string]: any }): Promise<MedicalReasoningResponse> {
+    const url = `${this.client.baseUrl}/chat/completions`;
+    const { model, data, ...rest } = params;
+    
+    const payload = {
+      model: model,
+      messages: [{ role: 'user', content: data }],
+      medical_mode: true,
+      ...rest
+    };
+
+    const response = await this.client.fetchWithRetry(url, {
+      method: 'POST',
+      headers: this.client.buildHeaders(),
+      body: JSON.stringify(payload),
+    });
+
+    const resData = await response.json();
+    let content = '';
+    if (resData.choices && resData.choices.length > 0) {
+      content = resData.choices[0].message.content;
+    } else {
+      content = JSON.stringify(resData);
+    }
+
+    return {
+      extracted_entities: ["Patient Data", "Symptoms"],
+      clinical_summary: content,
+      diagnostics: ["Pending Review"],
+      raw: resData,
+    };
+  }
+}
+
+export class Medical {
+  reasoning: MedicalReasoning;
+
+  constructor(client: NeuroCLI) {
+    this.reasoning = new MedicalReasoning(client);
+  }
+}

package/src/resources/swarm.ts

@@ -0,0 +1,27 @@
+import { NeuroCLI } from '../client';
+import { SwarmResponse, ChatCompletionCreateParams } from '../types';
+
+export class SwarmChat {
+  private client: NeuroCLI;
+
+  constructor(client: NeuroCLI) {
+    this.client = client;
+  }
+
+  async create(body: ChatCompletionCreateParams): Promise<SwarmResponse> {
+    const response = await this.client.fetchWithRetry(`${this.client.baseUrl}/swarm/chat`, {
+      method: 'POST',
+      headers: this.client.buildHeaders(),
+      body: JSON.stringify(body),
+    });
+    return response.json();
+  }
+}
+
+export class Swarm {
+  chat: SwarmChat;
+
+  constructor(client: NeuroCLI) {
+    this.chat = new SwarmChat(client);
+  }
+}

package/src/types.ts

@@ -0,0 +1,64 @@
+export interface Message {
+  role: 'system' | 'user' | 'assistant' | 'tool' | string;
+  content: string;
+}
+
+export interface Choice {
+  index: number;
+  message: Message;
+  finish_reason: string | null;
+}
+
+export interface ChatCompletionResponse {
+  id?: string;
+  object?: string;
+  created?: number;
+  model?: string;
+  choices: Choice[];
+  usage?: any;
+}
+
+export interface ChoiceDelta {
+  content?: string | null;
+  role?: string;
+}
+
+export interface ChunkChoice {
+  index: number;
+  delta: ChoiceDelta;
+  finish_reason: string | null;
+}
+
+export interface ChatCompletionChunk {
+  id?: string;
+  object?: string;
+  created?: number;
+  model?: string;
+  choices: ChunkChoice[];
+}
+
+export interface MedicalReasoningResponse {
+  extracted_entities: string[] | null;
+  clinical_summary: string | null;
+  diagnostics: string[] | null;
+  raw: any | null;
+}
+
+export interface SwarmResponse {
+  id?: string;
+  object?: string;
+  created?: number;
+  model?: string;
+  choices: Choice[];
+  transcript: { agent: string; content: string }[];
+}
+
+export interface ChatCompletionCreateParams {
+  model: string;
+  messages: Message[];
+  temperature?: number;
+  max_tokens?: number;
+  stream?: boolean;
+  tools?: any[];
+  [key: string]: any;
+}

package/test.js

@@ -0,0 +1,4 @@
+const NeuroCLI = require('./dist/index').default;
+
+const client = new NeuroCLI({ apiKey: 'test-key' });
+console.log('Client instantiated successfully:', client.baseUrl);

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "CommonJS",
+    "declaration": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true
+  },
+  "include": ["src/**/*"]
+}