@inference-gateway/sdk 0.3.0 → 0.3.2

package/dist/src/client.js

@@ -2,106 +2,201 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InferenceGatewayClient = void 0;
 class InferenceGatewayClient {
-    baseUrl;
-    authToken;
-    constructor(baseUrl, authToken) {
-        this.baseUrl = baseUrl.replace(/\/$/, '');
-        this.authToken = authToken;
+    baseURL;
+    apiKey;
+    defaultHeaders;
+    defaultQuery;
+    timeout;
+    fetchFn;
+    constructor(options = {}) {
+        this.baseURL = options.baseURL || 'http://localhost:8080/v1';
+        this.apiKey = options.apiKey;
+        this.defaultHeaders = options.defaultHeaders || {};
+        this.defaultQuery = options.defaultQuery || {};
+        this.timeout = options.timeout || 30000;
+        this.fetchFn = options.fetch || globalThis.fetch;
     }
-    async request(path, options = {}) {
+    /**
+     * Creates a new instance of the client with the given options merged with the existing options.
+     */
+    withOptions(options) {
+        return new InferenceGatewayClient({
+            baseURL: options.baseURL || this.baseURL,
+            apiKey: options.apiKey || this.apiKey,
+            defaultHeaders: { ...this.defaultHeaders, ...options.defaultHeaders },
+            defaultQuery: { ...this.defaultQuery, ...options.defaultQuery },
+            timeout: options.timeout || this.timeout,
+            fetch: options.fetch || this.fetchFn,
+        });
+    }
+    /**
+     * Makes a request to the API.
+     */
+    async request(path, options = {}, query = {}) {
         const headers = new Headers({
             'Content-Type': 'application/json',
+            ...this.defaultHeaders,
             ...options.headers,
         });
-        if (this.authToken) {
-            headers.set('Authorization', `Bearer ${this.authToken}`);
+        if (this.apiKey) {
+            headers.set('Authorization', `Bearer ${this.apiKey}`);
         }
-        const response = await fetch(`${this.baseUrl}${path}`, {
-            ...options,
-            headers,
+        // Combine default query parameters with provided ones
+        const queryParams = new URLSearchParams({
+            ...this.defaultQuery,
+            ...query,
         });
-        if (!response.ok) {
-            const error = await response.json();
-            throw new Error(error.error || `HTTP error! status: ${response.status}`);
+        const queryString = queryParams.toString();
+        const url = `${this.baseURL}${path}${queryString ? `?${queryString}` : ''}`;
+        const controller = new AbortController();
+        const timeoutId = globalThis.setTimeout(() => controller.abort(), this.timeout);
+        try {
+            const response = await this.fetchFn(url, {
+                ...options,
+                headers,
+                signal: controller.signal,
+            });
+            if (!response.ok) {
+                const error = (await response.json());
+                throw new Error(error.error || `HTTP error! status: ${response.status}`);
+            }
+            return response.json();
+        }
+        finally {
+            globalThis.clearTimeout(timeoutId);
         }
-        return response.json();
-    }
-    async listModels() {
-        return this.request('/llms');
     }
-    async listModelsByProvider(provider) {
-        return this.request(`/llms/${provider}`);
+    /**
+     * Lists the currently available models.
+     */
+    async listModels(provider) {
+        const query = {};
+        if (provider) {
+            query.provider = provider;
+        }
+        return this.request('/models', { method: 'GET' }, query);
     }
-    async generateContent(params) {
-        return this.request(`/llms/${params.provider}/generate`, {
+    /**
+     * Creates a chat completion.
+     */
+    async createChatCompletion(request, provider) {
+        const query = {};
+        if (provider) {
+            query.provider = provider;
+        }
+        return this.request('/chat/completions', {
             method: 'POST',
-            body: JSON.stringify({
-                model: params.model,
-                messages: params.messages,
-            }),
-        });
+            body: JSON.stringify(request),
+        }, query);
     }
-    async generateContentStream(params, options) {
-        const response = await fetch(`${this.baseUrl}/llms/${params.provider}/generate`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                ...(this.authToken && { Authorization: `Bearer ${this.authToken}` }),
-            },
-            body: JSON.stringify({
-                model: params.model,
-                messages: params.messages,
-                stream: true,
-                ssevents: true,
-            }),
+    /**
+     * Creates a streaming chat completion.
+     */
+    async streamChatCompletion(request, callbacks, provider) {
+        const query = {};
+        if (provider) {
+            query.provider = provider;
+        }
+        const queryParams = new URLSearchParams({
+            ...this.defaultQuery,
+            ...query,
         });
-        if (!response.ok) {
-            const error = await response.json();
-            throw new Error(error.error || `HTTP error! status: ${response.status}`);
+        const queryString = queryParams.toString();
+        const url = `${this.baseURL}/chat/completions${queryString ? `?${queryString}` : ''}`;
+        const headers = new Headers({
+            'Content-Type': 'application/json',
+            ...this.defaultHeaders,
+        });
+        if (this.apiKey) {
+            headers.set('Authorization', `Bearer ${this.apiKey}`);
         }
-        const reader = response.body?.getReader();
-        if (!reader)
-            throw new Error('Response body is not readable');
-        const decoder = new TextDecoder();
-        while (true) {
-            const { done, value } = await reader.read();
-            if (done)
-                break;
-            const events = decoder.decode(value).split('\n\n');
-            for (const event of events) {
-                if (!event.trim())
-                    continue;
-                const [eventType, ...data] = event.split('\n');
-                const eventData = JSON.parse(data.join('\n').replace('data: ', ''));
-                switch (eventType.replace('event: ', '')) {
-                    case 'message-start':
-                        options?.onMessageStart?.(eventData.role);
-                        break;
-                    case 'stream-start':
-                        options?.onStreamStart?.();
-                        break;
-                    case 'content-start':
-                        options?.onContentStart?.();
-                        break;
-                    case 'content-delta':
-                        options?.onContentDelta?.(eventData.content);
-                        break;
-                    case 'content-end':
-                        options?.onContentEnd?.();
-                        break;
-                    case 'message-end':
-                        options?.onMessageEnd?.();
-                        break;
-                    case 'stream-end':
-                        options?.onStreamEnd?.();
-                        break;
+        const controller = new AbortController();
+        const timeoutId = globalThis.setTimeout(() => controller.abort(), this.timeout);
+        try {
+            const response = await this.fetchFn(url, {
+                method: 'POST',
+                headers,
+                body: JSON.stringify({
+                    ...request,
+                    stream: true,
+                }),
+                signal: controller.signal,
+            });
+            if (!response.ok) {
+                const error = (await response.json());
+                throw new Error(error.error || `HTTP error! status: ${response.status}`);
+            }
+            if (!response.body) {
+                throw new Error('Response body is not readable');
+            }
+            callbacks.onOpen?.();
+            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 });
+                const lines = buffer.split('\n');
+                buffer = lines.pop() || '';
+                for (const line of lines) {
+                    if (line.startsWith('data: ')) {
+                        const data = line.slice(5).trim();
+                        if (data === '[DONE]') {
+                            callbacks.onFinish?.(null);
+                            return;
+                        }
+                        try {
+                            const chunk = JSON.parse(data);
+                            callbacks.onChunk?.(chunk);
+                            const content = chunk.choices[0]?.delta?.content;
+                            if (content) {
+                                callbacks.onContent?.(content);
+                            }
+                            const toolCalls = chunk.choices[0]?.delta?.tool_calls;
+                            if (toolCalls && toolCalls.length > 0) {
+                                const toolCall = {
+                                    id: toolCalls[0].id || '',
+                                    type: 'function',
+                                    function: {
+                                        name: toolCalls[0].function?.name || '',
+                                        arguments: toolCalls[0].function?.arguments || '',
+                                    },
+                                };
+                                callbacks.onTool?.(toolCall);
+                            }
+                        }
+                        catch (e) {
+                            globalThis.console.error('Error parsing SSE data:', e);
+                        }
+                    }
                 }
             }
         }
+        catch (error) {
+            const apiError = {
+                error: error.message || 'Unknown error',
+            };
+            callbacks.onError?.(apiError);
+            throw error;
+        }
+        finally {
+            globalThis.clearTimeout(timeoutId);
+        }
+    }
+    /**
+     * Proxy a request to a specific provider.
+     */
+    async proxy(provider, path, options = {}) {
+        return this.request(`/proxy/${provider}/${path}`, options);
     }
+    /**
+     * Health check endpoint.
+     */
     async healthCheck() {
         try {
-            await this.request('/health');
+            await this.fetchFn(`${this.baseURL.replace('/v1', '')}/health`);
             return true;
         }
         catch {

package/dist/src/types/index.d.ts

@@ -2,46 +2,127 @@ export declare enum Provider {
     Ollama = "ollama",
     Groq = "groq",
     OpenAI = "openai",
-    Google = "google",
     Cloudflare = "cloudflare",
     Cohere = "cohere",
-    Anthropic = "anthropic"
+    Anthropic = "anthropic",
+    DeepSeek = "deepseek"
 }
 export declare enum MessageRole {
     System = "system",
     User = "user",
-    Assistant = "assistant"
+    Assistant = "assistant",
+    Tool = "tool"
 }
 export interface Message {
     role: MessageRole;
     content: string;
+    tool_calls?: ChatCompletionMessageToolCall[];
+    tool_call_id?: string;
 }
 export interface Model {
+    id: string;
+    object: string;
+    created: number;
+    owned_by: string;
+}
+export interface ListModelsResponse {
+    object: string;
+    data: Model[];
+}
+export interface ChatCompletionMessageToolCallFunction {
     name: string;
+    arguments: string;
+}
+export interface ChatCompletionMessageToolCall {
+    id: string;
+    type: 'function';
+    function: ChatCompletionMessageToolCallFunction;
+}
+export interface ChatCompletionMessageToolCallChunk {
+    index: number;
+    id?: string;
+    type?: string;
+    function?: {
+        name?: string;
+        arguments?: string;
+    };
 }
-export interface ProviderModels {
-    provider: Provider;
-    models: Model[];
+export interface FunctionParameters {
+    type: string;
+    properties?: Record<string, unknown>;
+    required?: string[];
 }
-export interface GenerateContentRequest {
-    provider: Provider;
+export interface FunctionObject {
+    description?: string;
+    name: string;
+    parameters: FunctionParameters;
+    strict?: boolean;
+}
+export interface ChatCompletionTool {
+    type: 'function';
+    function: FunctionObject;
+}
+export interface ChatCompletionRequest {
     model: string;
     messages: Message[];
+    max_tokens?: number;
+    stream?: boolean;
+    stream_options?: ChatCompletionStreamOptions;
+    tools?: ChatCompletionTool[];
+    temperature?: number;
+    top_p?: number;
+    top_k?: number;
 }
-export interface GenerateContentResponse {
-    provider: string;
-    response: {
-        role: 'assistant';
-        model: string;
-        content: string;
-    };
+export interface ChatCompletionStreamOptions {
+    include_usage?: boolean;
+}
+export interface ChatCompletionChoice {
+    finish_reason: 'stop' | 'length' | 'tool_calls' | 'content_filter' | 'function_call';
+    index: number;
+    message: Message;
+    logprobs?: Record<string, unknown>;
+}
+export interface CompletionUsage {
+    prompt_tokens: number;
+    completion_tokens: number;
+    total_tokens: number;
+}
+export interface ChatCompletionResponse {
+    id: string;
+    choices: ChatCompletionChoice[];
+    created: number;
+    model: string;
+    object: string;
+    usage?: CompletionUsage;
+}
+export interface ChatCompletionStreamChoice {
+    delta: ChatCompletionStreamResponseDelta;
+    finish_reason: 'stop' | 'length' | 'tool_calls' | 'content_filter' | 'function_call' | null;
+    index: number;
+    logprobs?: Record<string, unknown>;
+}
+export interface ChatCompletionStreamResponseDelta {
+    content?: string;
+    tool_calls?: ChatCompletionMessageToolCallChunk[];
+    role?: MessageRole;
+    refusal?: string;
+}
+export interface ChatCompletionStreamResponse {
+    id: string;
+    choices: ChatCompletionStreamChoice[];
+    created: number;
+    model: string;
+    object: string;
+    usage?: CompletionUsage;
+}
+export interface ChatCompletionStreamCallbacks {
+    onOpen?: () => void;
+    onChunk?: (chunk: ChatCompletionStreamResponse) => void;
+    onContent?: (content: string) => void;
+    onTool?: (toolCall: ChatCompletionMessageToolCall) => void;
+    onFinish?: (response: ChatCompletionStreamResponse) => void;
+    onError?: (error: Error) => void;
 }
-export interface GenerateContentOptions {
-    onMessageStart?: (role: string) => void;
-    onStreamStart?: () => void;
-    onContentStart?: () => void;
-    onContentDelta?: (content: string) => void;
-    onContentEnd?: () => void;
-    onMessageEnd?: () => void;
-    onStreamEnd?: () => void;
+export interface Error {
+    error: string;
 }

package/dist/src/types/index.js

@@ -6,14 +6,15 @@ var Provider;
     Provider["Ollama"] = "ollama";
     Provider["Groq"] = "groq";
     Provider["OpenAI"] = "openai";
-    Provider["Google"] = "google";
     Provider["Cloudflare"] = "cloudflare";
     Provider["Cohere"] = "cohere";
     Provider["Anthropic"] = "anthropic";
+    Provider["DeepSeek"] = "deepseek";
 })(Provider || (exports.Provider = Provider = {}));
 var MessageRole;
 (function (MessageRole) {
     MessageRole["System"] = "system";
     MessageRole["User"] = "user";
     MessageRole["Assistant"] = "assistant";
+    MessageRole["Tool"] = "tool";
 })(MessageRole || (exports.MessageRole = MessageRole = {}));