sambanova 1.0.0

package/README.md

@@ -0,0 +1,117 @@
+# Sambanova JavaScript/TypeScript Client
+
+A JavaScript/TypeScript client for the Sambanova AI API. This package provides an easy way to interact with Sambanova's language and vision models.
+
+## Installation
+
+```bash
+npm install sambanova-js
+```
+
+## Quick Start
+
+```javascript
+import { SambanovaClient } from 'sambanova-js';
+
+// Initialize the client
+const client = new SambanovaClient('YOUR_API_KEY');
+
+// Text completion
+async function textExample() {
+  const response = await client.chat([
+    { role: 'user', content: 'Hello!' }
+  ], {
+    model: 'Meta-Llama-3.2-3B-Instruct'
+  });
+  console.log(response.choices[0].message.content);
+}
+
+// Vision analysis
+async function visionExample() {
+  const response = await client.chat([
+    {
+      role: 'user',
+      content: [
+        { type: 'text', text: 'What is in this image?' },
+        { type: 'image_url', image_url: { url: 'your_image_url_here' }}
+      ]
+    }
+  ], {
+    model: 'Llama-3.2-11B-Vision-Instruct'
+  });
+  console.log(response.choices[0].message.content);
+}
+```
+
+## Features
+
+- Support for all Sambanova language and vision models
+- TypeScript support with full type definitions
+- Error handling and automatic retries
+- Streaming support
+- Vision model integration
+
+## Supported Models
+
+### Vision Models
+- `Llama-3.2-11B-Vision-Instruct`
+- `Llama-3.2-90B-Vision-Instruct`
+
+### Language Models
+- `Meta-Llama-3.1-8B-Instruct`
+- `Meta-Llama-3.1-70B-Instruct`
+- `Meta-Llama-3.1-405B-Instruct`
+- `Meta-Llama-3.2-1B-Instruct`
+- `Meta-Llama-3.2-3B-Instruct`
+
+## Advanced Usage
+
+### Streaming
+
+```javascript
+(async () => {
+  try {
+    for await (const chunk of client.streamChat([
+      { role: 'user', content: 'Tell me a story' }
+    ])) {
+      process.stdout.write(chunk.choices[0].message.content);
+    }
+  } catch (error) {
+    console.error('Stream Chat Error:', error);
+  }
+})();
+```
+
+### Error Handling
+
+```javascript
+import { SambanovaClient, SambanovaError } from 'sambanova-js';
+
+try {
+  const response = await client.chat([
+    { role: 'user', content: 'Hello' }
+  ]);
+  console.log(response.choices[0].message.content);
+} catch (error) {
+  if (error instanceof SambanovaError) {
+    console.error(`API Error: ${error.message} (Code: ${error.code})`);
+  } else {
+    console.error('Unexpected error:', error);
+  }
+}
+```
+
+## Configuration Options
+
+```javascript
+const client = new SambanovaClient('YOUR_API_KEY', {
+  baseUrl: 'https://api.sambanova.ai/v1',
+  defaultModel: 'Meta-Llama-3.2-3B-Instruct',
+  defaultRetryCount: 3,
+  defaultRetryDelay: 1000
+});
+```
+
+## License
+
+[MIT](LICENSE)

package/dist/client.d.ts

@@ -0,0 +1,18 @@
+import { ModelType, ChatMessage, ChatOptions, APIResponse } from './types';
+export declare class SambanovaClient {
+    private readonly apiKey;
+    private readonly baseUrl;
+    private readonly defaultModel;
+    private readonly defaultRetryCount;
+    private readonly defaultRetryDelay;
+    constructor(apiKey: string, options?: {
+        baseUrl?: string;
+        defaultModel?: ModelType;
+        defaultRetryCount?: number;
+        defaultRetryDelay?: number;
+    });
+    private makeRequest;
+    chat(messages: ChatMessage[], options?: ChatOptions): Promise<APIResponse>;
+    streamChat(messages: ChatMessage[], options?: ChatOptions): AsyncGenerator<APIResponse, void, unknown>;
+    private handleStreamResponse;
+}

package/dist/client.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SambanovaClient = void 0;
+const utils_1 = require("./utils");
+const types_1 = require("./types");
+class SambanovaClient {
+    constructor(apiKey, options = {}) {
+        this.apiKey = apiKey;
+        this.baseUrl = options.baseUrl || 'https://api.sambanova.ai/v1';
+        this.defaultModel = options.defaultModel || 'Meta-Llama-3.2-3B-Instruct';
+        this.defaultRetryCount = options.defaultRetryCount || 3;
+        this.defaultRetryDelay = options.defaultRetryDelay || 1000;
+    }
+    async makeRequest(endpoint, data, retryCount = this.defaultRetryCount, stream = false) {
+        let lastError = null;
+        for (let attempt = 0; attempt <= retryCount; attempt++) {
+            try {
+                const response = await fetch(`${this.baseUrl}${endpoint}`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'Authorization': `Bearer ${this.apiKey}`
+                    },
+                    body: JSON.stringify(data)
+                });
+                if (!response.ok) {
+                    const errorData = await response.json();
+                    throw new types_1.SambanovaError(errorData.message || 'API request failed', response.status, errorData.code, errorData);
+                }
+                if (stream) {
+                    return response;
+                }
+                return await response.json();
+            }
+            catch (error) {
+                lastError = error;
+                if (attempt < retryCount) {
+                    await (0, utils_1.sleep)(this.defaultRetryDelay * Math.pow(2, attempt));
+                    continue;
+                }
+            }
+        }
+        throw lastError || new Error('Request failed after retries');
+    }
+    async chat(messages, options = {}) {
+        var _a, _b, _c;
+        const model = options.model || this.defaultModel;
+        messages.forEach(msg => (0, utils_1.validateMessage)(msg, (0, utils_1.isVisionModel)(model)));
+        const payload = {
+            model,
+            messages,
+            temperature: (_a = options.temperature) !== null && _a !== void 0 ? _a : 0.1,
+            top_p: (_b = options.top_p) !== null && _b !== void 0 ? _b : 0.1,
+            max_tokens: options.max_tokens,
+            stream: (_c = options.stream) !== null && _c !== void 0 ? _c : false
+        };
+        const response = await this.makeRequest('/chat/completions', payload, options.retry_count, payload.stream);
+        if (payload.stream && response instanceof Response) {
+            throw new Error('Stream response received in chat method. Use streamChat instead.');
+        }
+        return response;
+    }
+    async *streamChat(messages, options = {}) {
+        var _a, _b;
+        const model = options.model || this.defaultModel;
+        messages.forEach(msg => (0, utils_1.validateMessage)(msg, (0, utils_1.isVisionModel)(model)));
+        const payload = {
+            model,
+            messages,
+            temperature: (_a = options.temperature) !== null && _a !== void 0 ? _a : 0.1,
+            top_p: (_b = options.top_p) !== null && _b !== void 0 ? _b : 0.1,
+            max_tokens: options.max_tokens,
+            stream: true
+        };
+        const response = await this.makeRequest('/chat/completions', payload, options.retry_count, true);
+        // **Modified Check:**
+        if (!response ||
+            !('body' in response) ||
+            typeof response.body.getReader !== 'function') {
+            throw new Error('Expected a streaming response');
+        }
+        yield* this.handleStreamResponse(response);
+    }
+    async *handleStreamResponse(response) {
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = '';
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            let lines = buffer.split('\n');
+            buffer = lines.pop() || '';
+            for (const line of lines) {
+                const trimmedLine = line.trim();
+                if (trimmedLine.startsWith('data: ')) {
+                    const dataStr = trimmedLine.slice(6);
+                    if (dataStr === '[DONE]') {
+                        return;
+                    }
+                    try {
+                        const data = JSON.parse(dataStr);
+                        yield data;
+                    }
+                    catch (e) {
+                        console.error('Failed to parse stream data:', e);
+                    }
+                }
+            }
+        }
+        // Processing any remaining buffer
+        if (buffer.startsWith('data: ')) {
+            const dataStr = buffer.slice(6);
+            if (dataStr !== '[DONE]') {
+                try {
+                    const data = JSON.parse(dataStr);
+                    yield data;
+                }
+                catch (e) {
+                    console.error('Failed to parse stream data:', e);
+                }
+            }
+        }
+    }
+}
+exports.SambanovaClient = SambanovaClient;

package/dist/tests/client.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/client.test.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const client_1 = require("../client");
+const types_1 = require("../types");
+describe('SambanovaClient', () => {
+    const client = new client_1.SambanovaClient('test-api-key');
+    beforeEach(() => {
+        global.fetch = jest.fn();
+    });
+    afterEach(() => {
+        jest.resetAllMocks();
+    });
+    describe('chat', () => {
+        it('should successfully make a text chat request', async () => {
+            const mockResponse = {
+                id: 'test-id',
+                choices: [{
+                        message: { role: 'assistant', content: 'Hello!' },
+                        finish_reason: 'stop'
+                    }],
+                usage: { prompt_tokens: 10, completion_tokens: 5, total_tokens: 15 }
+            };
+            global.fetch.mockResolvedValueOnce({
+                ok: true,
+                json: () => Promise.resolve(mockResponse)
+            });
+            const result = await client.chat([
+                { role: 'user', content: 'Hi!' }
+            ]);
+            expect(result).toEqual(mockResponse);
+        });
+        it('should handle vision model requests correctly', async () => {
+            const mockResponse = {
+                id: 'test-id',
+                choices: [{
+                        message: { role: 'assistant', content: 'I see a cat in the image.' },
+                        finish_reason: 'stop'
+                    }],
+                usage: { prompt_tokens: 20, completion_tokens: 8, total_tokens: 28 }
+            };
+            global.fetch.mockResolvedValueOnce({
+                ok: true,
+                json: () => Promise.resolve(mockResponse)
+            });
+            const result = await client.chat([
+                {
+                    role: 'user',
+                    content: [
+                        { type: 'text', text: 'What do you see?' },
+                        { type: 'image_url', image_url: { url: 'base64...' } }
+                    ]
+                }
+            ], { model: 'Llama-3.2-11B-Vision-Instruct' });
+            expect(result).toEqual(mockResponse);
+        });
+        it('should retry on failure', async () => {
+            global.fetch
+                .mockRejectedValueOnce(new Error('Network error'))
+                .mockRejectedValueOnce(new Error('Network error'))
+                .mockResolvedValueOnce({
+                ok: true,
+                json: () => Promise.resolve({ id: 'test-id' })
+            });
+            const result = await client.chat([
+                { role: 'user', content: 'Hi!' }
+            ], { retry_count: 3 });
+            expect(global.fetch).toHaveBeenCalledTimes(3);
+            expect(result).toEqual({ id: 'test-id' });
+        });
+        it('should throw SambanovaError on API error', async () => {
+            global.fetch.mockResolvedValueOnce({
+                ok: false,
+                status: 400,
+                json: () => Promise.resolve({
+                    message: 'Invalid request',
+                    code: 'INVALID_REQUEST'
+                })
+            });
+            await expect(client.chat([{ role: 'user', content: 'Hi!' }], { retry_count: 0 } // this is 0 to prevent retries
+            )).rejects.toThrow(types_1.SambanovaError);
+        });
+    });
+    describe('streamChat', () => {
+        it('should handle streaming responses', async () => {
+            const mockReader = {
+                read: jest.fn()
+                    .mockResolvedValueOnce({
+                    done: false,
+                    value: new TextEncoder().encode('data: {"id":"1"}\n')
+                })
+                    .mockResolvedValueOnce({
+                    done: false,
+                    value: new TextEncoder().encode('data: {"id":"2"}\n')
+                })
+                    .mockResolvedValueOnce({ done: true })
+            };
+            global.fetch.mockResolvedValueOnce({
+                ok: true,
+                body: { getReader: () => mockReader }
+            });
+            const responses = [];
+            for await (const response of client.streamChat([
+                { role: 'user', content: 'Hi!' }
+            ])) {
+                responses.push(response);
+            }
+            expect(responses).toHaveLength(2);
+            expect(responses[0]).toEqual({ id: '1' });
+            expect(responses[1]).toEqual({ id: '2' });
+        });
+    });
+});

package/dist/types.d.ts

@@ -0,0 +1,39 @@
+export type ModelType = 'Llama-3.2-11B-Vision-Instruct' | 'Meta-Llama-3.1-8B-Instruct' | 'Meta-Llama-3.1-70B-Instruct' | 'Meta-Llama-3.1-405B-Instruct' | 'Meta-Llama-3.2-1B-Instruct' | 'Meta-Llama-3.2-3B-Instruct' | 'Llama-3.2-90B-Vision-Instruct';
+export interface ChatMessage {
+    role: 'system' | 'user' | 'assistant';
+    content: string | MessageContent[];
+}
+export interface MessageContent {
+    type: 'text' | 'image_url';
+    text?: string;
+    image_url?: {
+        url: string;
+    };
+}
+export interface ChatOptions {
+    model?: ModelType;
+    temperature?: number;
+    top_p?: number;
+    max_tokens?: number;
+    stream?: boolean;
+    retry_count?: number;
+    retry_delay?: number;
+}
+export interface APIResponse {
+    id: string;
+    choices: Array<{
+        message: ChatMessage;
+        finish_reason: string;
+    }>;
+    usage: {
+        prompt_tokens: number;
+        completion_tokens: number;
+        total_tokens: number;
+    };
+}
+export declare class SambanovaError extends Error {
+    status?: number | undefined;
+    code?: string | undefined;
+    details?: any;
+    constructor(message: string, status?: number | undefined, code?: string | undefined, details?: any);
+}

package/dist/types.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SambanovaError = void 0;
+class SambanovaError extends Error {
+    constructor(message, status, code, details) {
+        super(message);
+        this.status = status;
+        this.code = code;
+        this.details = details;
+        this.name = 'SambanovaError';
+    }
+}
+exports.SambanovaError = SambanovaError;

package/dist/utils.d.ts

@@ -0,0 +1,4 @@
+import { ModelType, ChatMessage } from './types';
+export declare const sleep: (ms: number) => Promise<unknown>;
+export declare const isVisionModel: (model: ModelType) => boolean;
+export declare const validateMessage: (message: ChatMessage, isVision: boolean) => void;

package/dist/utils.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateMessage = exports.isVisionModel = exports.sleep = void 0;
+const types_1 = require("./types");
+const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+exports.sleep = sleep;
+const isVisionModel = (model) => {
+    return model.toLowerCase().includes('vision');
+};
+exports.isVisionModel = isVisionModel;
+const validateMessage = (message, isVision) => {
+    if (Array.isArray(message.content)) {
+        if (!isVision) {
+            throw new types_1.SambanovaError('Array content is only supported for vision models', 400, 'INVALID_MESSAGE_FORMAT');
+        }
+    }
+    else if (isVision) {
+        throw new types_1.SambanovaError('Vision models require array content format', 400, 'INVALID_MESSAGE_FORMAT');
+    }
+};
+exports.validateMessage = validateMessage;

package/jest.config.js

@@ -0,0 +1,13 @@
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  testMatch: [
+    '**/tests/**/*.test.ts', 
+    '**/__tests__/**/*.test.ts' 
+  ],
+  moduleFileExtensions: ['ts', 'js', 'json', 'node'],
+  rootDir: './', 
+  transform: {
+    '^.+\\.ts?$': 'ts-jest'
+  }
+};

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "sambanova",
+  "version": "1.0.0",
+  "description": "TypeScript/Javascript client for Sambanova AI API with comprehensive model support",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "test": "jest",
+    "lint": "eslint src/**/*.ts",
+    "prepare": "npm run build"
+  },
+  "keywords": [
+    "sambanova",
+    "ai",
+    "llm",
+    "vision",
+    "api",
+    "typescript"
+  ],
+  "author": "Aaditya Srivastava",
+  "license": "MIT",
+  "dependencies": {
+    "node-fetch": "^2.7.0"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.14",
+    "@types/node": "^16.18.119",
+    "@typescript-eslint/eslint-plugin": "^5.62.0",
+    "@typescript-eslint/parser": "^5.62.0",
+    "eslint": "^8.0.0",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.2.5",
+    "typescript": "^4.9.5"
+  }
+}

package/src/client.ts

@@ -0,0 +1,190 @@
+import { sleep, isVisionModel, validateMessage } from './utils';
+import {
+  ModelType,
+  ChatMessage,
+  ChatOptions,
+  APIResponse,
+  SambanovaError
+} from './types';
+
+export class SambanovaClient {
+  private readonly baseUrl: string;
+  private readonly defaultModel: ModelType;
+  private readonly defaultRetryCount: number;
+  private readonly defaultRetryDelay: number;
+
+  constructor(
+    private readonly apiKey: string,
+    options: {
+      baseUrl?: string;
+      defaultModel?: ModelType;
+      defaultRetryCount?: number;
+      defaultRetryDelay?: number;
+    } = {}
+  ) {
+    this.baseUrl = options.baseUrl || 'https://api.sambanova.ai/v1';
+    this.defaultModel = options.defaultModel || 'Meta-Llama-3.2-3B-Instruct';
+    this.defaultRetryCount = options.defaultRetryCount || 3;
+    this.defaultRetryDelay = options.defaultRetryDelay || 1000;
+  }
+
+  private async makeRequest(
+    endpoint: string,
+    data: any,
+    retryCount: number = this.defaultRetryCount,
+    stream: boolean = false
+  ): Promise<APIResponse | Response> {
+    let lastError: Error | null = null;
+    
+    for (let attempt = 0; attempt <= retryCount; attempt++) {
+      try {
+        const response = await fetch(`${this.baseUrl}${endpoint}`, {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${this.apiKey}`
+          },
+          body: JSON.stringify(data)
+        });
+
+        if (!response.ok) {
+          const errorData = await response.json();
+          throw new SambanovaError(
+            errorData.message || 'API request failed',
+            response.status,
+            errorData.code,
+            errorData
+          );
+        }
+
+        if (stream) {
+          return response;
+        }
+
+        return await response.json();
+      } catch (error) {
+        lastError = error as Error;
+        if (attempt < retryCount) {
+          await sleep(this.defaultRetryDelay * Math.pow(2, attempt));
+          continue;
+        }
+      }
+    }
+
+    throw lastError || new Error('Request failed after retries');
+  }
+
+  async chat(
+    messages: ChatMessage[],
+    options: ChatOptions = {}
+  ): Promise<APIResponse> {
+    const model = options.model || this.defaultModel;
+    
+    messages.forEach(msg => validateMessage(msg, isVisionModel(model)));
+
+    const payload = {
+      model,
+      messages,
+      temperature: options.temperature ?? 0.1,
+      top_p: options.top_p ?? 0.1,
+      max_tokens: options.max_tokens,
+      stream: options.stream ?? false
+    };
+
+    const response = await this.makeRequest(
+      '/chat/completions',
+      payload,
+      options.retry_count,
+      payload.stream
+    );
+
+    if (payload.stream && response instanceof Response) {
+      throw new Error('Stream response received in chat method. Use streamChat instead.');
+    }
+
+    return response as APIResponse;
+  }
+
+  async *streamChat(
+    messages: ChatMessage[],
+    options: ChatOptions = {}
+  ): AsyncGenerator<APIResponse, void, unknown> {
+    const model = options.model || this.defaultModel;
+    
+    messages.forEach(msg => validateMessage(msg, isVisionModel(model)));
+
+    const payload = {
+      model,
+      messages,
+      temperature: options.temperature ?? 0.1,
+      top_p: options.top_p ?? 0.1,
+      max_tokens: options.max_tokens,
+      stream: true 
+    };
+
+    const response = await this.makeRequest(
+      '/chat/completions',
+      payload,
+      options.retry_count,
+      true 
+    );
+
+    // **Modified Check:**
+    if (
+      !response ||
+      !('body' in response) ||
+      typeof (response as any).body.getReader !== 'function'
+    ) {
+      throw new Error('Expected a streaming response');
+    }
+
+    yield* this.handleStreamResponse(response as Response);
+  }
+
+  private async *handleStreamResponse(
+    response: Response
+  ): AsyncGenerator<APIResponse, void, unknown> {
+    const reader = response.body!.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      
+      buffer += decoder.decode(value, { stream: true });
+      let lines = buffer.split('\n');
+      
+      buffer = lines.pop() || '';
+      
+      for (const line of lines) {
+        const trimmedLine = line.trim();
+        if (trimmedLine.startsWith('data: ')) {
+          const dataStr = trimmedLine.slice(6);
+          if (dataStr === '[DONE]') {
+            return;
+          }
+          try {
+            const data = JSON.parse(dataStr);
+            yield data;
+          } catch (e) {
+            console.error('Failed to parse stream data:', e);
+          }
+        }
+      }
+    }
+
+    // Processing any remaining buffer
+    if (buffer.startsWith('data: ')) {
+      const dataStr = buffer.slice(6);
+      if (dataStr !== '[DONE]') {
+        try {
+          const data = JSON.parse(dataStr);
+          yield data;
+        } catch (e) {
+          console.error('Failed to parse stream data:', e);
+        }
+      }
+    }
+  }
+}

package/src/tests/client.test.ts

@@ -0,0 +1,135 @@
+import { SambanovaClient } from '../client';
+import { SambanovaError } from '../types';
+
+describe('SambanovaClient', () => {
+  const client = new SambanovaClient('test-api-key');
+
+  beforeEach(() => {
+    global.fetch = jest.fn();
+  });
+
+  afterEach(() => {
+    jest.resetAllMocks();
+  });
+
+  describe('chat', () => {
+    it('should successfully make a text chat request', async () => {
+      const mockResponse = {
+        id: 'test-id',
+        choices: [{
+          message: { role: 'assistant', content: 'Hello!' },
+          finish_reason: 'stop'
+        }],
+        usage: { prompt_tokens: 10, completion_tokens: 5, total_tokens: 15 }
+      };
+
+      (global.fetch as jest.Mock).mockResolvedValueOnce({
+        ok: true,
+        json: () => Promise.resolve(mockResponse)
+      });
+
+      const result = await client.chat([
+        { role: 'user', content: 'Hi!' }
+      ]);
+
+      expect(result).toEqual(mockResponse);
+    });
+
+    it('should handle vision model requests correctly', async () => {
+      const mockResponse = {
+        id: 'test-id',
+        choices: [{
+          message: { role: 'assistant', content: 'I see a cat in the image.' },
+          finish_reason: 'stop'
+        }],
+        usage: { prompt_tokens: 20, completion_tokens: 8, total_tokens: 28 }
+      };
+
+      (global.fetch as jest.Mock).mockResolvedValueOnce({
+        ok: true,
+        json: () => Promise.resolve(mockResponse)
+      });
+
+      const result = await client.chat([
+        {
+          role: 'user',
+          content: [
+            { type: 'text', text: 'What do you see?' },
+            { type: 'image_url', image_url: { url: 'base64...' } }
+          ]
+        }
+      ], { model: 'Llama-3.2-11B-Vision-Instruct' });
+
+      expect(result).toEqual(mockResponse);
+    });
+
+    it('should retry on failure', async () => {
+      (global.fetch as jest.Mock)
+        .mockRejectedValueOnce(new Error('Network error'))
+        .mockRejectedValueOnce(new Error('Network error'))
+        .mockResolvedValueOnce({
+          ok: true,
+          json: () => Promise.resolve({ id: 'test-id' })
+        });
+
+      const result = await client.chat([
+        { role: 'user', content: 'Hi!' }
+      ], { retry_count: 3 });
+
+      expect(global.fetch).toHaveBeenCalledTimes(3);
+      expect(result).toEqual({ id: 'test-id' });
+    });
+
+    it('should throw SambanovaError on API error', async () => {
+      (global.fetch as jest.Mock).mockResolvedValueOnce({
+        ok: false,
+        status: 400,
+        json: () => Promise.resolve({
+          message: 'Invalid request',
+          code: 'INVALID_REQUEST'
+        })
+      });
+    
+      await expect(
+        client.chat(
+          [{ role: 'user', content: 'Hi!' }],
+          { retry_count: 0 } // this is 0 to prevent retries
+        )
+      ).rejects.toThrow(SambanovaError);
+    });
+    
+  });
+
+  describe('streamChat', () => {
+    it('should handle streaming responses', async () => {
+      const mockReader = {
+        read: jest.fn()
+          .mockResolvedValueOnce({
+            done: false,
+            value: new TextEncoder().encode('data: {"id":"1"}\n')
+          })
+          .mockResolvedValueOnce({
+            done: false,
+            value: new TextEncoder().encode('data: {"id":"2"}\n')
+          })
+          .mockResolvedValueOnce({ done: true })
+      };
+
+      (global.fetch as jest.Mock).mockResolvedValueOnce({
+        ok: true,
+        body: { getReader: () => mockReader }
+      });
+
+      const responses = [];
+      for await (const response of client.streamChat([
+        { role: 'user', content: 'Hi!' }
+      ])) {
+        responses.push(response);
+      }
+
+      expect(responses).toHaveLength(2);
+      expect(responses[0]).toEqual({ id: '1' });
+      expect(responses[1]).toEqual({ id: '2' });
+    });
+  });
+});

package/src/types.ts

@@ -0,0 +1,56 @@
+export type ModelType = 
+  | 'Llama-3.2-11B-Vision-Instruct'
+  | 'Meta-Llama-3.1-8B-Instruct'
+  | 'Meta-Llama-3.1-70B-Instruct'
+  | 'Meta-Llama-3.1-405B-Instruct'
+  | 'Meta-Llama-3.2-1B-Instruct'
+  | 'Meta-Llama-3.2-3B-Instruct'
+  | 'Llama-3.2-90B-Vision-Instruct';
+
+export interface ChatMessage {
+  role: 'system' | 'user' | 'assistant';
+  content: string | MessageContent[];
+}
+
+export interface MessageContent {
+  type: 'text' | 'image_url';
+  text?: string;
+  image_url?: {
+    url: string;
+  };
+}
+
+export interface ChatOptions {
+  model?: ModelType;
+  temperature?: number;
+  top_p?: number;
+  max_tokens?: number;
+  stream?: boolean;
+  retry_count?: number;
+  retry_delay?: number;
+}
+
+export interface APIResponse {
+  id: string;
+  choices: Array<{
+    message: ChatMessage;
+    finish_reason: string;
+  }>;
+  usage: {
+    prompt_tokens: number;
+    completion_tokens: number;
+    total_tokens: number;
+  };
+}
+
+export class SambanovaError extends Error {
+  constructor(
+    message: string,
+    public status?: number,
+    public code?: string,
+    public details?: any
+  ) {
+    super(message);
+    this.name = 'SambanovaError';
+  }
+}

package/src/utils.ts

@@ -0,0 +1,25 @@
+import { ModelType, ChatMessage, SambanovaError } from './types';
+
+export const sleep = (ms: number) => new Promise(resolve => setTimeout(resolve, ms));
+
+export const isVisionModel = (model: ModelType): boolean => {
+  return model.toLowerCase().includes('vision');
+};
+
+export const validateMessage = (message: ChatMessage, isVision: boolean) => {
+  if (Array.isArray(message.content)) {
+    if (!isVision) {
+      throw new SambanovaError(
+        'Array content is only supported for vision models',
+        400,
+        'INVALID_MESSAGE_FORMAT'
+      );
+    }
+  } else if (isVision) {
+    throw new SambanovaError(
+      'Vision models require array content format',
+      400,
+      'INVALID_MESSAGE_FORMAT'
+    );
+  }
+};

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "es2018",
+    "module": "commonjs",
+    "declaration": true,
+    "outDir": "./dist",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "dist", "**/__tests__/*"]
+}