@inference-gateway/sdk 0.3.0 → 0.3.3

package/CHANGELOG.md

@@ -1,3 +1,30 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+## [0.3.3](https://github.com/inference-gateway/typescript-sdk/compare/v0.3.2...v0.3.3) (2025-03-31)
+
+### 🐛 Bug Fixes
+
+* Update release configuration to include version bumping of the package.json ([3667690](https://github.com/inference-gateway/typescript-sdk/commit/36676909a923bc29d398ad814f0518fcc12080aa))
+
+## [0.3.2](https://github.com/inference-gateway/typescript-sdk/compare/v0.3.1...v0.3.2) (2025-03-31)
+
+### 👷 CI
+
+* Add npm ci step to install project dependencies in release workflow ([84791b1](https://github.com/inference-gateway/typescript-sdk/commit/84791b1e4c319f91798c456c783ded6e22da8f81))
+
+## [0.3.1](https://github.com/inference-gateway/typescript-sdk/compare/v0.3.0...v0.3.1) (2025-03-31)
+
+### ♻️ Improvements
+
+* Make the SDK OpenAI compatible ([#2](https://github.com/inference-gateway/typescript-sdk/issues/2)) ([31657b3](https://github.com/inference-gateway/typescript-sdk/commit/31657b358f34ccc39acc5994248a95127f1ea46a))
+
+### 👷 CI
+
+* Update GitHub Actions release workflow to use GitHub App token and improve release handling ([14835e8](https://github.com/inference-gateway/typescript-sdk/commit/14835e8f9289314f34e711c02faf865ad9af6d66))
+* Update release configuration for semantic-release plugins and rules to be consistent with other repos ([20bd3f8](https://github.com/inference-gateway/typescript-sdk/commit/20bd3f82c68d0b1ee1d07b4fa75eb67524db4fb8))
+
 ## [0.3.0](https://github.com/inference-gateway/typescript-sdk/compare/v0.2.0...v0.3.0) (2025-02-02)
 
 ### ✨ Features

package/README.md

@@ -1,16 +1,18 @@
-# Inference Gateway Typescript SDK
+# Inference Gateway TypeScript SDK
 
-An SDK written in Typescript for the [Inference Gateway](https://github.com/edenreich/inference-gateway).
+An SDK written in TypeScript for the [Inference Gateway](https://github.com/edenreich/inference-gateway).
 
-- [Inference Gateway Typescript SDK](#inference-gateway-typescript-sdk)
+- [Inference Gateway TypeScript SDK](#inference-gateway-typescript-sdk)
   - [Installation](#installation)
   - [Usage](#usage)
     - [Creating a Client](#creating-a-client)
-    - [Listing All Models](#listing-all-models)
-    - [List Models by Provider](#list-models-by-provider)
-    - [Generating Content](#generating-content)
-    - [Streaming Content](#streaming-content)
+    - [Listing Models](#listing-models)
+    - [Creating Chat Completions](#creating-chat-completions)
+    - [Streaming Chat Completions](#streaming-chat-completions)
+    - [Tool Calls](#tool-calls)
+    - [Proxying Requests](#proxying-requests)
     - [Health Check](#health-check)
+    - [Creating a Client with Custom Options](#creating-a-client-with-custom-options)
   - [Contributing](#contributing)
   - [License](#license)
 
@@ -22,152 +24,215 @@ Run `npm i @inference-gateway/sdk`.
 
 ### Creating a Client
 
+```typescript
+import { InferenceGatewayClient } from '@inference-gateway/sdk';
+
+// Create a client with default options
+const client = new InferenceGatewayClient({
+  baseURL: 'http://localhost:8080/v1',
+  apiKey: 'your-api-key', // Optional
+});
+```
+
+### Listing Models
+
+To list all available models:
+
+```typescript
+import { InferenceGatewayClient, Provider } from '@inference-gateway/sdk';
+
+const client = new InferenceGatewayClient({
+  baseURL: 'http://localhost:8080/v1',
+});
+
+try {
+  // List all models
+  const models = await client.listModels();
+  console.log('All models:', models);
+
+  // List models from a specific provider
+  const openaiModels = await client.listModels(Provider.OpenAI);
+  console.log('OpenAI models:', openaiModels);
+} catch (error) {
+  console.error('Error:', error);
+}
+```
+
+### Creating Chat Completions
+
+To generate content using a model:
+
 ```typescript
 import {
   InferenceGatewayClient,
-  Message,
+  MessageRole,
   Provider,
 } from '@inference-gateway/sdk';
 
-async function main() {
-  const client = new InferenceGatewayClient('http://localhost:8080');
-
-  try {
-    // List available models
-    const models = await client.listModels();
-    models.forEach((providerModels) => {
-      console.log(`Provider: ${providerModels.provider}`);
-      providerModels.models.forEach((model) => {
-        console.log(`Model: ${model.name}`);
-      });
-    });
-
-    // Generate content
-    const response = await client.generateContent({
-      provider: Provider.Ollama,
-      model: 'llama2',
+const client = new InferenceGatewayClient({
+  baseURL: 'http://localhost:8080/v1',
+});
+
+try {
+  const response = await client.createChatCompletion(
+    {
+      model: 'gpt-4o',
       messages: [
         {
           role: MessageRole.System,
-          content: 'You are a helpful llama',
+          content: 'You are a helpful assistant',
         },
         {
           role: MessageRole.User,
           content: 'Tell me a joke',
         },
       ],
-    });
-
-    console.log('Response:', response);
-  } catch (error) {
-    console.error('Error:', error);
-  }
-}
-
-main();
-```
-
-### Listing All Models
-
-To list all available models from all providers, use the `listModels` method:
+    },
+    Provider.OpenAI
+  ); // Provider is optional
 
-```typescript
-try {
-  const models = await client.listModels();
-  models.forEach((providerModels) => {
-    console.log(`Provider: ${providerModels.provider}`);
-    providerModels.models.forEach((model) => {
-      console.log(`Model: ${model.name}`);
-    });
-  });
+  console.log('Response:', response.choices[0].message.content);
 } catch (error) {
   console.error('Error:', error);
 }
 ```
 
-### List Models by Provider
+### Streaming Chat Completions
 
-To list all available models from a specific provider, use the `listModelsByProvider` method:
+To stream content from a model:
 
 ```typescript
+import {
+  InferenceGatewayClient,
+  MessageRole,
+  Provider,
+} from '@inference-gateway/sdk';
+
+const client = new InferenceGatewayClient({
+  baseURL: 'http://localhost:8080/v1',
+});
+
 try {
-  const providerModels = await client.listModelsByProvider(Provider.OpenAI);
-  console.log(`Provider: ${providerModels.provider}`);
-  providerModels.models.forEach((model) => {
-    console.log(`Model: ${model.name}`);
-  });
+  await client.streamChatCompletion(
+    {
+      model: 'llama-3.3-70b-versatile',
+      messages: [
+        {
+          role: MessageRole.User,
+          content: 'Tell me a story',
+        },
+      ],
+    },
+    {
+      onOpen: () => console.log('Stream opened'),
+      onContent: (content) => process.stdout.write(content),
+      onChunk: (chunk) => console.log('Received chunk:', chunk.id),
+      onFinish: () => console.log('\nStream completed'),
+      onError: (error) => console.error('Stream error:', error),
+    },
+    Provider.Groq // Provider is optional
+  );
 } catch (error) {
   console.error('Error:', error);
 }
 ```
 
-### Generating Content
+### Tool Calls
 
-To generate content using a model, use the `generateContent` method:
+To use tool calls with models that support them:
 
 ```typescript
 import {
   InferenceGatewayClient,
-  Message,
   MessageRole,
   Provider,
 } from '@inference-gateway/sdk';
 
-const client = new InferenceGatewayClient('http://localhost:8080');
+const client = new InferenceGatewayClient({
+  baseURL: 'http://localhost:8080/v1',
+});
 
-  const response = await client.generateContent({
-    provider: Provider.Ollama,
-    model: 'llama2',
-    messages: [
-      {
-        role: MessageRole.System,
-        content: 'You are a helpful llama',
-      },
-      {
-        role: MessageRole.User,
-        content: 'Tell me a joke',
+try {
+  await client.streamChatCompletion(
+    {
+      model: 'gpt-4o',
+      messages: [
+        {
+          role: MessageRole.User,
+          content: 'What's the weather in San Francisco?',
+        },
+      ],
+      tools: [
+        {
+          type: 'function',
+          function: {
+            name: 'get_weather',
+            parameters: {
+              type: 'object',
+              properties: {
+                location: {
+                  type: 'string',
+                  description: 'The city and state, e.g. San Francisco, CA',
+                },
+              },
+              required: ['location'],
+            },
+          },
+        },
+      ],
+    },
+    {
+      onTool: (toolCall) => {
+        console.log('Tool call:', toolCall.function.name);
+        console.log('Arguments:', toolCall.function.arguments);
       },
-    ],
-  });
-
-  console.log('Provider:', response.provider);
-  console.log('Response:', response.response);
+      onContent: (content) => process.stdout.write(content),
+      onFinish: () => console.log('\nStream completed'),
+    },
+    Provider.OpenAI
+  );
 } catch (error) {
   console.error('Error:', error);
 }
 ```
 
-### Streaming Content
+### Proxying Requests
 
-To stream content using a model, use the `streamContent` method:
+To proxy requests directly to a provider:
 
 ```typescript
-const client = new InferenceGatewayClient('http://localhost:8080');
-
-await client.generateContentStream(
-  {
-    provider: Provider.Groq,
-    model: 'deepseek-r1-distill-llama-70b',
-    messages: [
-      {
-        role: MessageRole.User,
-        content: 'Tell me a story',
-      },
-    ],
-  },
-  {
-    onMessageStart: (role) => console.log('Message started:', role),
-    onContentDelta: (content) => process.stdout.write(content),
-    onStreamEnd: () => console.log('\nStream completed'),
-  }
-);
+import { InferenceGatewayClient, Provider } from '@inference-gateway/sdk';
+
+const client = new InferenceGatewayClient({
+  baseURL: 'http://localhost:8080/v1',
+});
+
+try {
+  const response = await client.proxy(Provider.OpenAI, 'embeddings', {
+    method: 'POST',
+    body: JSON.stringify({
+      model: 'text-embedding-ada-002',
+      input: 'Hello world',
+    }),
+  });
+
+  console.log('Embeddings:', response);
+} catch (error) {
+  console.error('Error:', error);
+}
 ```
 
 ### Health Check
 
-To check if the Inference Gateway is running, use the `healthCheck` method:
+To check if the Inference Gateway is running:
 
 ```typescript
+import { InferenceGatewayClient } from '@inference-gateway/sdk';
+
+const client = new InferenceGatewayClient({
+  baseURL: 'http://localhost:8080/v1',
+});
+
 try {
   const isHealthy = await client.healthCheck();
   console.log('API is healthy:', isHealthy);
@@ -176,6 +241,26 @@ try {
 }
 ```
 
+### Creating a Client with Custom Options
+
+You can create a new client with custom options using the `withOptions` method:
+
+```typescript
+import { InferenceGatewayClient } from '@inference-gateway/sdk';
+
+const client = new InferenceGatewayClient({
+  baseURL: 'http://localhost:8080/v1',
+});
+
+// Create a new client with custom headers
+const clientWithHeaders = client.withOptions({
+  defaultHeaders: {
+    'X-Custom-Header': 'value',
+  },
+  timeout: 60000, // 60 seconds
+});
+```
+
 ## Contributing
 
 Please refer to the [CONTRIBUTING.md](CONTRIBUTING.md) file for information about how to get involved. We welcome issues, questions, and pull requests.

package/dist/src/client.d.ts

@@ -1,12 +1,46 @@
-import { GenerateContentOptions, GenerateContentRequest, GenerateContentResponse, Provider, ProviderModels } from './types';
+import { ChatCompletionRequest, ChatCompletionResponse, ChatCompletionStreamCallbacks, ListModelsResponse, Provider } from './types';
+export interface ClientOptions {
+    baseURL?: string;
+    apiKey?: string;
+    defaultHeaders?: Record<string, string>;
+    defaultQuery?: Record<string, string>;
+    timeout?: number;
+    fetch?: typeof globalThis.fetch;
+}
 export declare class InferenceGatewayClient {
-    private baseUrl;
-    private authToken?;
-    constructor(baseUrl: string, authToken?: string);
+    private baseURL;
+    private apiKey?;
+    private defaultHeaders;
+    private defaultQuery;
+    private timeout;
+    private fetchFn;
+    constructor(options?: ClientOptions);
+    /**
+     * Creates a new instance of the client with the given options merged with the existing options.
+     */
+    withOptions(options: ClientOptions): InferenceGatewayClient;
+    /**
+     * Makes a request to the API.
+     */
     private request;
-    listModels(): Promise<ProviderModels[]>;
-    listModelsByProvider(provider: Provider): Promise<ProviderModels>;
-    generateContent(params: GenerateContentRequest): Promise<GenerateContentResponse>;
-    generateContentStream(params: GenerateContentRequest, options?: GenerateContentOptions): Promise<void>;
+    /**
+     * Lists the currently available models.
+     */
+    listModels(provider?: Provider): Promise<ListModelsResponse>;
+    /**
+     * Creates a chat completion.
+     */
+    createChatCompletion(request: ChatCompletionRequest, provider?: Provider): Promise<ChatCompletionResponse>;
+    /**
+     * Creates a streaming chat completion.
+     */
+    streamChatCompletion(request: ChatCompletionRequest, callbacks: ChatCompletionStreamCallbacks, provider?: Provider): Promise<void>;
+    /**
+     * Proxy a request to a specific provider.
+     */
+    proxy<T = unknown>(provider: Provider, path: string, options?: RequestInit): Promise<T>;
+    /**
+     * Health check endpoint.
+     */
     healthCheck(): Promise<boolean>;
 }