@inference-gateway/sdk 0.3.4 → 0.4.0-rc.1

package/CHANGELOG.md

@@ -2,6 +2,28 @@
 
 All notable changes to this project will be documented in this file.
 
+## [0.4.0-rc.1](https://github.com/inference-gateway/typescript-sdk/compare/v0.3.5-rc.1...v0.4.0-rc.1) (2025-03-31)
+
+### ✨ Features
+
+* Add reasoning_content field to chunk message in OpenAPI specification ([4de08ed](https://github.com/inference-gateway/typescript-sdk/commit/4de08ed46f6078f77838bd9c4bae5e46eb12476c))
+
+## [0.3.5-rc.1](https://github.com/inference-gateway/typescript-sdk/compare/v0.3.4...v0.3.5-rc.1) (2025-03-31)
+
+### ♻️ Improvements
+
+* Update type exports and add type generation task ([919679e](https://github.com/inference-gateway/typescript-sdk/commit/919679eac8142e25b5abcefd63ae00bc187f2a67))
+
+### 🐛 Bug Fixes
+
+* Correct regex pattern for release candidate branches in configuration ([33db013](https://github.com/inference-gateway/typescript-sdk/commit/33db013392c8a1a15cc5a3bebb0f4c6d58a73d41))
+* Update release configuration to correctly match release candidate branches ([03d91e1](https://github.com/inference-gateway/typescript-sdk/commit/03d91e1d94d1fc11e50a535ba131ef2ca089653e))
+
+### 🔧 Miscellaneous
+
+* Remove unnecessary line from .gitattributes ([66407b4](https://github.com/inference-gateway/typescript-sdk/commit/66407b4cba0bf96af457dbb66818f48da3a4abda))
+* Update .gitattributes to mark generated types as linguist-generated ([67f3d68](https://github.com/inference-gateway/typescript-sdk/commit/67f3d682ba1e131f9e416c45e097c76dfeec4bf6))
+
 ## [0.3.4](https://github.com/inference-gateway/typescript-sdk/compare/v0.3.3...v0.3.4) (2025-03-31)
 
 ### ♻️ Improvements

package/dist/src/client.d.ts

@@ -1,4 +1,12 @@
-import { ChatCompletionRequest, ChatCompletionResponse, ChatCompletionStreamCallbacks, ListModelsResponse, Provider } from './types';
+import type { Provider, SchemaChatCompletionMessageToolCall, SchemaCreateChatCompletionRequest, SchemaCreateChatCompletionResponse, SchemaCreateChatCompletionStreamResponse, SchemaError, SchemaListModelsResponse } from './types/generated';
+interface ChatCompletionStreamCallbacks {
+    onOpen?: () => void;
+    onChunk?: (chunk: SchemaCreateChatCompletionStreamResponse) => void;
+    onContent?: (content: string) => void;
+    onTool?: (toolCall: SchemaChatCompletionMessageToolCall) => void;
+    onFinish?: (response: SchemaCreateChatCompletionStreamResponse | null) => void;
+    onError?: (error: SchemaError) => void;
+}
 export interface ClientOptions {
     baseURL?: string;
     apiKey?: string;
@@ -26,15 +34,15 @@ export declare class InferenceGatewayClient {
     /**
      * Lists the currently available models.
      */
-    listModels(provider?: Provider): Promise<ListModelsResponse>;
+    listModels(provider?: Provider): Promise<SchemaListModelsResponse>;
     /**
      * Creates a chat completion.
      */
-    createChatCompletion(request: ChatCompletionRequest, provider?: Provider): Promise<ChatCompletionResponse>;
+    createChatCompletion(request: SchemaCreateChatCompletionRequest, provider?: Provider): Promise<SchemaCreateChatCompletionResponse>;
     /**
      * Creates a streaming chat completion.
      */
-    streamChatCompletion(request: ChatCompletionRequest, callbacks: ChatCompletionStreamCallbacks, provider?: Provider): Promise<void>;
+    streamChatCompletion(request: SchemaCreateChatCompletionRequest, callbacks: ChatCompletionStreamCallbacks, provider?: Provider): Promise<void>;
     /**
      * Proxy a request to a specific provider.
      */
@@ -44,3 +52,4 @@ export declare class InferenceGatewayClient {
      */
     healthCheck(): Promise<boolean>;
 }
+export {};

package/dist/src/client.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InferenceGatewayClient = void 0;
+const generated_1 = require("./types/generated");
 class InferenceGatewayClient {
     baseURL;
     apiKey;
@@ -57,7 +58,7 @@ class InferenceGatewayClient {
                 signal: controller.signal,
             });
             if (!response.ok) {
-                const error = (await response.json());
+                const error = await response.json();
                 throw new Error(error.error || `HTTP error! status: ${response.status}`);
             }
             return response.json();
@@ -123,7 +124,7 @@ class InferenceGatewayClient {
                 signal: controller.signal,
             });
             if (!response.ok) {
-                const error = (await response.json());
+                const error = await response.json();
                 throw new Error(error.error || `HTTP error! status: ${response.status}`);
             }
             if (!response.body) {
@@ -158,7 +159,7 @@ class InferenceGatewayClient {
                             if (toolCalls && toolCalls.length > 0) {
                                 const toolCall = {
                                     id: toolCalls[0].id || '',
-                                    type: 'function',
+                                    type: generated_1.ChatCompletionToolType.function,
                                     function: {
                                         name: toolCalls[0].function?.name || '',
                                         arguments: toolCalls[0].function?.arguments || '',

package/dist/src/index.d.ts

@@ -1,2 +1,2 @@
 export * from './client';
-export * from './types';
+export * from './types/generated';

package/dist/src/index.js

@@ -15,4 +15,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./client"), exports);
-__exportStar(require("./types"), exports);
+__exportStar(require("./types/generated"), exports);

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

@@ -0,0 +1,743 @@
+/**
+ * This file was auto-generated by openapi-typescript.
+ * Do not make direct changes to the file.
+ */
+export interface paths {
+    '/models': {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Lists the currently available models, and provides basic information about each one such as the owner and availability.
+         * @description Lists the currently available models, and provides basic information
+         *     about each one such as the owner and availability.
+         *
+         */
+        get: operations['listModels'];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    '/chat/completions': {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Create a chat completion
+         * @description Generates a chat completion based on the provided input.
+         *     The completion can be streamed to the client as it is generated.
+         *
+         */
+        post: operations['createChatCompletion'];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    '/proxy/{provider}/{path}': {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                provider: components['schemas']['Provider'];
+                /** @description The remaining path to proxy to the provider */
+                path: string;
+            };
+            cookie?: never;
+        };
+        /**
+         * Proxy GET request to provider
+         * @description Proxy GET request to provider
+         *     The request body depends on the specific provider and endpoint being called.
+         *     If you decide to use this approach, please follow the provider-specific documentations.
+         *
+         */
+        get: operations['proxyGet'];
+        /**
+         * Proxy PUT request to provider
+         * @description Proxy PUT request to provider
+         *     The request body depends on the specific provider and endpoint being called.
+         *     If you decide to use this approach, please follow the provider-specific documentations.
+         *
+         */
+        put: operations['proxyPut'];
+        /**
+         * Proxy POST request to provider
+         * @description Proxy POST request to provider
+         *     The request body depends on the specific provider and endpoint being called.
+         *     If you decide to use this approach, please follow the provider-specific documentations.
+         *
+         */
+        post: operations['proxyPost'];
+        /**
+         * Proxy DELETE request to provider
+         * @description Proxy DELETE request to provider
+         *     The request body depends on the specific provider and endpoint being called.
+         *     If you decide to use this approach, please follow the provider-specific documentations.
+         *
+         */
+        delete: operations['proxyDelete'];
+        options?: never;
+        head?: never;
+        /**
+         * Proxy PATCH request to provider
+         * @description Proxy PATCH request to provider
+         *     The request body depends on the specific provider and endpoint being called.
+         *     If you decide to use this approach, please follow the provider-specific documentations.
+         *
+         */
+        patch: operations['proxyPatch'];
+        trace?: never;
+    };
+    '/health': {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Health check
+         * @description Health check endpoint
+         *     Returns a 200 status code if the service is healthy
+         *
+         */
+        get: operations['healthCheck'];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+}
+export type webhooks = Record<string, never>;
+export interface components {
+    schemas: {
+        /** @enum {string} */
+        Provider: Provider;
+        /** @description Provider-specific response format. Examples:
+         *
+         *     OpenAI GET /v1/models?provider=openai response:
+         *     ```json
+         *     {
+         *       "provider": "openai",
+         *       "object": "list",
+         *       "data": [
+         *         {
+         *           "id": "gpt-4",
+         *           "object": "model",
+         *           "created": 1687882410,
+         *           "owned_by": "openai",
+         *           "served_by": "openai"
+         *         }
+         *       ]
+         *     }
+         *     ```
+         *
+         *     Anthropic GET /v1/models?provider=anthropic response:
+         *     ```json
+         *     {
+         *       "provider": "anthropic",
+         *       "object": "list",
+         *       "data": [
+         *         {
+         *           "id": "gpt-4",
+         *           "object": "model",
+         *           "created": 1687882410,
+         *           "owned_by": "openai",
+         *           "served_by": "openai"
+         *         }
+         *       ]
+         *     }
+         *     ```
+         *      */
+        ProviderSpecificResponse: Record<string, never>;
+        /**
+         * @description Authentication type for providers
+         * @enum {string}
+         */
+        ProviderAuthType: ProviderAuthType;
+        SSEvent: {
+            /** @enum {string} */
+            event?: SSEventEvent;
+            /** Format: byte */
+            data?: string;
+            retry?: number;
+        };
+        Endpoints: {
+            models?: string;
+            chat?: string;
+        };
+        Error: {
+            error?: string;
+        };
+        /**
+         * @description Role of the message sender
+         * @enum {string}
+         */
+        MessageRole: MessageRole;
+        /** @description Message structure for provider requests */
+        Message: {
+            role: components['schemas']['MessageRole'];
+            content: string;
+            tool_calls?: components['schemas']['ChatCompletionMessageToolCall'][];
+            tool_call_id?: string;
+            reasoning?: string;
+            reasoning_content?: string;
+        };
+        /** @description Common model information */
+        Model: {
+            id?: string;
+            object?: string;
+            /** Format: int64 */
+            created?: number;
+            owned_by?: string;
+            served_by?: components['schemas']['Provider'];
+        };
+        /** @description Response structure for listing models */
+        ListModelsResponse: {
+            provider?: components['schemas']['Provider'];
+            object?: string;
+            /** @default [] */
+            data: components['schemas']['Model'][];
+        };
+        FunctionObject: {
+            /** @description A description of what the function does, used by the model to choose when and how to call the function. */
+            description?: string;
+            /** @description The name of the function to be called. Must be a-z, A-Z, 0-9, or contain underscores and dashes, with a maximum length of 64. */
+            name: string;
+            parameters?: components['schemas']['FunctionParameters'];
+            /**
+             * @description Whether to enable strict schema adherence when generating the function call. If set to true, the model will follow the exact schema defined in the `parameters` field. Only a subset of JSON Schema is supported when `strict` is `true`. Learn more about Structured Outputs in the [function calling guide](docs/guides/function-calling).
+             * @default false
+             */
+            strict: boolean;
+        };
+        ChatCompletionTool: {
+            type: components['schemas']['ChatCompletionToolType'];
+            function: components['schemas']['FunctionObject'];
+        };
+        /** @description The parameters the functions accepts, described as a JSON Schema object. See the [guide](/docs/guides/function-calling) for examples, and the [JSON Schema reference](https://json-schema.org/understanding-json-schema/) for documentation about the format.
+         *     Omitting `parameters` defines a function with an empty parameter list. */
+        FunctionParameters: {
+            /** @description The type of the parameters. Currently, only `object` is supported. */
+            type?: string;
+            /** @description The properties of the parameters. */
+            properties?: Record<string, never>;
+            /** @description The required properties of the parameters. */
+            required?: string[];
+        };
+        /**
+         * @description The type of the tool. Currently, only `function` is supported.
+         * @enum {string}
+         */
+        ChatCompletionToolType: ChatCompletionToolType;
+        /** @description Usage statistics for the completion request. */
+        CompletionUsage: {
+            /**
+             * Format: int64
+             * @description Number of tokens in the generated completion.
+             * @default 0
+             */
+            completion_tokens: number;
+            /**
+             * Format: int64
+             * @description Number of tokens in the prompt.
+             * @default 0
+             */
+            prompt_tokens: number;
+            /**
+             * Format: int64
+             * @description Total number of tokens used in the request (prompt + completion).
+             * @default 0
+             */
+            total_tokens: number;
+        };
+        /** @description Options for streaming response. Only set this when you set `stream: true`.
+         *      */
+        ChatCompletionStreamOptions: {
+            /**
+             * @description If set, an additional chunk will be streamed before the `data: [DONE]` message. The `usage` field on this chunk shows the token usage statistics for the entire request, and the `choices` field will always be an empty array. All other chunks will also include a `usage` field, but with a null value.
+             *
+             * @default true
+             */
+            include_usage: boolean;
+        };
+        CreateChatCompletionRequest: {
+            /** @description Model ID to use */
+            model: string;
+            /** @description A list of messages comprising the conversation so far.
+             *      */
+            messages: components['schemas']['Message'][];
+            /** @description An upper bound for the number of tokens that can be generated for a completion, including visible output tokens and reasoning tokens.
+             *      */
+            max_tokens?: number;
+            /**
+             * @description If set to true, the model response data will be streamed to the client as it is generated using [server-sent events](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events#Event_stream_format).
+             *
+             * @default false
+             */
+            stream: boolean;
+            stream_options?: components['schemas']['ChatCompletionStreamOptions'];
+            /** @description A list of tools the model may call. Currently, only functions are supported as a tool. Use this to provide a list of functions the model may generate JSON inputs for. A max of 128 functions are supported.
+             *      */
+            tools?: components['schemas']['ChatCompletionTool'][];
+        };
+        /** @description The function that the model called. */
+        ChatCompletionMessageToolCallFunction: {
+            /** @description The name of the function to call. */
+            name: string;
+            /** @description The arguments to call the function with, as generated by the model in JSON format. Note that the model does not always generate valid JSON, and may hallucinate parameters not defined by your function schema. Validate the arguments in your code before calling your function. */
+            arguments: string;
+        };
+        ChatCompletionMessageToolCall: {
+            /** @description The ID of the tool call. */
+            id: string;
+            type: components['schemas']['ChatCompletionToolType'];
+            function: components['schemas']['ChatCompletionMessageToolCallFunction'];
+        };
+        ChatCompletionChoice: {
+            /**
+             * @description The reason the model stopped generating tokens. This will be `stop` if the model hit a natural stop point or a provided stop sequence,
+             *     `length` if the maximum number of tokens specified in the request was reached,
+             *     `content_filter` if content was omitted due to a flag from our content filters,
+             *     `tool_calls` if the model called a tool.
+             *
+             * @enum {string}
+             */
+            finish_reason: ChatCompletionChoiceFinish_reason;
+            /** @description The index of the choice in the list of choices. */
+            index: number;
+            message: components['schemas']['Message'];
+        };
+        ChatCompletionStreamChoice: {
+            delta: components['schemas']['ChatCompletionStreamResponseDelta'];
+            /** @description Log probability information for the choice. */
+            logprobs?: {
+                /** @description A list of message content tokens with log probability information. */
+                content: components['schemas']['ChatCompletionTokenLogprob'][];
+                /** @description A list of message refusal tokens with log probability information. */
+                refusal: components['schemas']['ChatCompletionTokenLogprob'][];
+            };
+            finish_reason: components['schemas']['FinishReason'];
+            /** @description The index of the choice in the list of choices. */
+            index: number;
+        };
+        /** @description Represents a chat completion response returned by model, based on the provided input. */
+        CreateChatCompletionResponse: {
+            /** @description A unique identifier for the chat completion. */
+            id: string;
+            /** @description A list of chat completion choices. Can be more than one if `n` is greater than 1. */
+            choices: components['schemas']['ChatCompletionChoice'][];
+            /** @description The Unix timestamp (in seconds) of when the chat completion was created. */
+            created: number;
+            /** @description The model used for the chat completion. */
+            model: string;
+            /** @description The object type, which is always `chat.completion`. */
+            object: string;
+            usage?: components['schemas']['CompletionUsage'];
+        };
+        /** @description A chat completion delta generated by streamed model responses. */
+        ChatCompletionStreamResponseDelta: {
+            /** @description The contents of the chunk message. */
+            content?: string;
+            /** @description The reasoning content of the chunk message. */
+            reasoning_content?: string;
+            tool_calls?: components['schemas']['ChatCompletionMessageToolCallChunk'][];
+            role?: components['schemas']['MessageRole'];
+            /** @description The refusal message generated by the model. */
+            refusal?: string;
+        };
+        ChatCompletionMessageToolCallChunk: {
+            index: number;
+            /** @description The ID of the tool call. */
+            id?: string;
+            /** @description The type of the tool. Currently, only `function` is supported. */
+            type?: string;
+            function?: {
+                /** @description The name of the function to call. */
+                name?: string;
+                /** @description The arguments to call the function with, as generated by the model in JSON format. Note that the model does not always generate valid JSON, and may hallucinate parameters not defined by your function schema. Validate the arguments in your code before calling your function. */
+                arguments?: string;
+            };
+        };
+        ChatCompletionTokenLogprob: {
+            /** @description The token. */
+            token: string;
+            /** @description The log probability of this token, if it is within the top 20 most likely tokens. Otherwise, the value `-9999.0` is used to signify that the token is very unlikely. */
+            logprob: number;
+            /** @description A list of integers representing the UTF-8 bytes representation of the token. Useful in instances where characters are represented by multiple tokens and their byte representations must be combined to generate the correct text representation. Can be `null` if there is no bytes representation for the token. */
+            bytes: number[];
+            /** @description List of the most likely tokens and their log probability, at this token position. In rare cases, there may be fewer than the number of requested `top_logprobs` returned. */
+            top_logprobs: {
+                /** @description The token. */
+                token: string;
+                /** @description The log probability of this token, if it is within the top 20 most likely tokens. Otherwise, the value `-9999.0` is used to signify that the token is very unlikely. */
+                logprob: number;
+                /** @description A list of integers representing the UTF-8 bytes representation of the token. Useful in instances where characters are represented by multiple tokens and their byte representations must be combined to generate the correct text representation. Can be `null` if there is no bytes representation for the token. */
+                bytes: number[];
+            }[];
+        };
+        /**
+         * @description The reason the model stopped generating tokens. This will be `stop` if the model hit a natural stop point or a provided stop sequence,
+         *     `length` if the maximum number of tokens specified in the request was reached,
+         *     `content_filter` if content was omitted due to a flag from our content filters,
+         *     `tool_calls` if the model called a tool.
+         *
+         * @enum {string}
+         */
+        FinishReason: ChatCompletionChoiceFinish_reason;
+        /** @description Represents a streamed chunk of a chat completion response returned
+         *     by the model, based on the provided input.
+         *      */
+        CreateChatCompletionStreamResponse: {
+            /** @description A unique identifier for the chat completion. Each chunk has the same ID. */
+            id: string;
+            /** @description A list of chat completion choices. Can contain more than one elements if `n` is greater than 1. Can also be empty for the
+             *     last chunk if you set `stream_options: {"include_usage": true}`.
+             *      */
+            choices: components['schemas']['ChatCompletionStreamChoice'][];
+            /** @description The Unix timestamp (in seconds) of when the chat completion was created. Each chunk has the same timestamp. */
+            created: number;
+            /** @description The model to generate the completion. */
+            model: string;
+            /** @description This fingerprint represents the backend configuration that the model runs with.
+             *     Can be used in conjunction with the `seed` request parameter to understand when backend changes have been made that might impact determinism.
+             *      */
+            system_fingerprint?: string;
+            /** @description The object type, which is always `chat.completion.chunk`. */
+            object: string;
+            usage?: components['schemas']['CompletionUsage'];
+        };
+        Config: unknown;
+    };
+    responses: {
+        /** @description Bad request */
+        BadRequest: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                'application/json': components['schemas']['Error'];
+            };
+        };
+        /** @description Unauthorized */
+        Unauthorized: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                'application/json': components['schemas']['Error'];
+            };
+        };
+        /** @description Internal server error */
+        InternalError: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                'application/json': components['schemas']['Error'];
+            };
+        };
+        /** @description ProviderResponse depends on the specific provider and endpoint being called
+         *     If you decide to use this approach, please follow the provider-specific documentations.
+         *      */
+        ProviderResponse: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                'application/json': components['schemas']['ProviderSpecificResponse'];
+            };
+        };
+    };
+    parameters: never;
+    requestBodies: {
+        /** @description ProviderRequest depends on the specific provider and endpoint being called
+         *     If you decide to use this approach, please follow the provider-specific documentations.
+         *      */
+        ProviderRequest: {
+            content: {
+                'application/json': {
+                    model?: string;
+                    messages?: {
+                        role?: string;
+                        content?: string;
+                    }[];
+                    /**
+                     * Format: float
+                     * @default 0.7
+                     */
+                    temperature?: number;
+                };
+            };
+        };
+        /** @description ProviderRequest depends on the specific provider and endpoint being called
+         *     If you decide to use this approach, please follow the provider-specific documentations.
+         *      */
+        CreateChatCompletionRequest: {
+            content: {
+                'application/json': components['schemas']['CreateChatCompletionRequest'];
+            };
+        };
+    };
+    headers: never;
+    pathItems: never;
+}
+export type SchemaProvider = components['schemas']['Provider'];
+export type SchemaProviderSpecificResponse = components['schemas']['ProviderSpecificResponse'];
+export type SchemaProviderAuthType = components['schemas']['ProviderAuthType'];
+export type SchemaSsEvent = components['schemas']['SSEvent'];
+export type SchemaEndpoints = components['schemas']['Endpoints'];
+export type SchemaError = components['schemas']['Error'];
+export type SchemaMessageRole = components['schemas']['MessageRole'];
+export type SchemaMessage = components['schemas']['Message'];
+export type SchemaModel = components['schemas']['Model'];
+export type SchemaListModelsResponse = components['schemas']['ListModelsResponse'];
+export type SchemaFunctionObject = components['schemas']['FunctionObject'];
+export type SchemaChatCompletionTool = components['schemas']['ChatCompletionTool'];
+export type SchemaFunctionParameters = components['schemas']['FunctionParameters'];
+export type SchemaChatCompletionToolType = components['schemas']['ChatCompletionToolType'];
+export type SchemaCompletionUsage = components['schemas']['CompletionUsage'];
+export type SchemaChatCompletionStreamOptions = components['schemas']['ChatCompletionStreamOptions'];
+export type SchemaCreateChatCompletionRequest = components['schemas']['CreateChatCompletionRequest'];
+export type SchemaChatCompletionMessageToolCallFunction = components['schemas']['ChatCompletionMessageToolCallFunction'];
+export type SchemaChatCompletionMessageToolCall = components['schemas']['ChatCompletionMessageToolCall'];
+export type SchemaChatCompletionChoice = components['schemas']['ChatCompletionChoice'];
+export type SchemaChatCompletionStreamChoice = components['schemas']['ChatCompletionStreamChoice'];
+export type SchemaCreateChatCompletionResponse = components['schemas']['CreateChatCompletionResponse'];
+export type SchemaChatCompletionStreamResponseDelta = components['schemas']['ChatCompletionStreamResponseDelta'];
+export type SchemaChatCompletionMessageToolCallChunk = components['schemas']['ChatCompletionMessageToolCallChunk'];
+export type SchemaChatCompletionTokenLogprob = components['schemas']['ChatCompletionTokenLogprob'];
+export type SchemaFinishReason = components['schemas']['FinishReason'];
+export type SchemaCreateChatCompletionStreamResponse = components['schemas']['CreateChatCompletionStreamResponse'];
+export type SchemaConfig = components['schemas']['Config'];
+export type ResponseBadRequest = components['responses']['BadRequest'];
+export type ResponseUnauthorized = components['responses']['Unauthorized'];
+export type ResponseInternalError = components['responses']['InternalError'];
+export type ResponseProviderResponse = components['responses']['ProviderResponse'];
+export type RequestBodyProviderRequest = components['requestBodies']['ProviderRequest'];
+export type RequestBodyCreateChatCompletionRequest = components['requestBodies']['CreateChatCompletionRequest'];
+export type $defs = Record<string, never>;
+export interface operations {
+    listModels: {
+        parameters: {
+            query?: {
+                /** @description Specific provider to query (optional) */
+                provider?: components['schemas']['Provider'];
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description List of available models */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    'application/json': components['schemas']['ListModelsResponse'];
+                };
+            };
+            401: components['responses']['Unauthorized'];
+            500: components['responses']['InternalError'];
+        };
+    };
+    createChatCompletion: {
+        parameters: {
+            query?: {
+                /** @description Specific provider to use (default determined by model) */
+                provider?: components['schemas']['Provider'];
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: components['requestBodies']['CreateChatCompletionRequest'];
+        responses: {
+            /** @description Successful response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    'application/json': components['schemas']['CreateChatCompletionResponse'];
+                    'text/event-stream': components['schemas']['SSEvent'];
+                };
+            };
+            400: components['responses']['BadRequest'];
+            401: components['responses']['Unauthorized'];
+            500: components['responses']['InternalError'];
+        };
+    };
+    proxyGet: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                provider: components['schemas']['Provider'];
+                /** @description The remaining path to proxy to the provider */
+                path: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components['responses']['ProviderResponse'];
+            400: components['responses']['BadRequest'];
+            401: components['responses']['Unauthorized'];
+            500: components['responses']['InternalError'];
+        };
+    };
+    proxyPut: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                provider: components['schemas']['Provider'];
+                /** @description The remaining path to proxy to the provider */
+                path: string;
+            };
+            cookie?: never;
+        };
+        requestBody: components['requestBodies']['ProviderRequest'];
+        responses: {
+            200: components['responses']['ProviderResponse'];
+            400: components['responses']['BadRequest'];
+            401: components['responses']['Unauthorized'];
+            500: components['responses']['InternalError'];
+        };
+    };
+    proxyPost: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                provider: components['schemas']['Provider'];
+                /** @description The remaining path to proxy to the provider */
+                path: string;
+            };
+            cookie?: never;
+        };
+        requestBody: components['requestBodies']['ProviderRequest'];
+        responses: {
+            200: components['responses']['ProviderResponse'];
+            400: components['responses']['BadRequest'];
+            401: components['responses']['Unauthorized'];
+            500: components['responses']['InternalError'];
+        };
+    };
+    proxyDelete: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                provider: components['schemas']['Provider'];
+                /** @description The remaining path to proxy to the provider */
+                path: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: components['responses']['ProviderResponse'];
+            400: components['responses']['BadRequest'];
+            401: components['responses']['Unauthorized'];
+            500: components['responses']['InternalError'];
+        };
+    };
+    proxyPatch: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                provider: components['schemas']['Provider'];
+                /** @description The remaining path to proxy to the provider */
+                path: string;
+            };
+            cookie?: never;
+        };
+        requestBody: components['requestBodies']['ProviderRequest'];
+        responses: {
+            200: components['responses']['ProviderResponse'];
+            400: components['responses']['BadRequest'];
+            401: components['responses']['Unauthorized'];
+            500: components['responses']['InternalError'];
+        };
+    };
+    healthCheck: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Health check successful */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+}
+export declare enum Provider {
+    ollama = "ollama",
+    groq = "groq",
+    openai = "openai",
+    cloudflare = "cloudflare",
+    cohere = "cohere",
+    anthropic = "anthropic",
+    deepseek = "deepseek"
+}
+export declare enum ProviderAuthType {
+    bearer = "bearer",
+    xheader = "xheader",
+    query = "query",
+    none = "none"
+}
+export declare enum SSEventEvent {
+    message_start = "message-start",
+    stream_start = "stream-start",
+    content_start = "content-start",
+    content_delta = "content-delta",
+    content_end = "content-end",
+    message_end = "message-end",
+    stream_end = "stream-end"
+}
+export declare enum MessageRole {
+    system = "system",
+    user = "user",
+    assistant = "assistant",
+    tool = "tool"
+}
+export declare enum ChatCompletionToolType {
+    function = "function"
+}
+export declare enum ChatCompletionChoiceFinish_reason {
+    stop = "stop",
+    length = "length",
+    tool_calls = "tool_calls",
+    content_filter = "content_filter",
+    function_call = "function_call"
+}

package/dist/src/types/generated/index.js

@@ -0,0 +1,53 @@
+"use strict";
+/**
+ * This file was auto-generated by openapi-typescript.
+ * Do not make direct changes to the file.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChatCompletionChoiceFinish_reason = exports.ChatCompletionToolType = exports.MessageRole = exports.SSEventEvent = exports.ProviderAuthType = exports.Provider = void 0;
+var Provider;
+(function (Provider) {
+    Provider["ollama"] = "ollama";
+    Provider["groq"] = "groq";
+    Provider["openai"] = "openai";
+    Provider["cloudflare"] = "cloudflare";
+    Provider["cohere"] = "cohere";
+    Provider["anthropic"] = "anthropic";
+    Provider["deepseek"] = "deepseek";
+})(Provider || (exports.Provider = Provider = {}));
+var ProviderAuthType;
+(function (ProviderAuthType) {
+    ProviderAuthType["bearer"] = "bearer";
+    ProviderAuthType["xheader"] = "xheader";
+    ProviderAuthType["query"] = "query";
+    ProviderAuthType["none"] = "none";
+})(ProviderAuthType || (exports.ProviderAuthType = ProviderAuthType = {}));
+var SSEventEvent;
+(function (SSEventEvent) {
+    SSEventEvent["message_start"] = "message-start";
+    SSEventEvent["stream_start"] = "stream-start";
+    SSEventEvent["content_start"] = "content-start";
+    SSEventEvent["content_delta"] = "content-delta";
+    SSEventEvent["content_end"] = "content-end";
+    SSEventEvent["message_end"] = "message-end";
+    SSEventEvent["stream_end"] = "stream-end";
+})(SSEventEvent || (exports.SSEventEvent = SSEventEvent = {}));
+var MessageRole;
+(function (MessageRole) {
+    MessageRole["system"] = "system";
+    MessageRole["user"] = "user";
+    MessageRole["assistant"] = "assistant";
+    MessageRole["tool"] = "tool";
+})(MessageRole || (exports.MessageRole = MessageRole = {}));
+var ChatCompletionToolType;
+(function (ChatCompletionToolType) {
+    ChatCompletionToolType["function"] = "function";
+})(ChatCompletionToolType || (exports.ChatCompletionToolType = ChatCompletionToolType = {}));
+var ChatCompletionChoiceFinish_reason;
+(function (ChatCompletionChoiceFinish_reason) {
+    ChatCompletionChoiceFinish_reason["stop"] = "stop";
+    ChatCompletionChoiceFinish_reason["length"] = "length";
+    ChatCompletionChoiceFinish_reason["tool_calls"] = "tool_calls";
+    ChatCompletionChoiceFinish_reason["content_filter"] = "content_filter";
+    ChatCompletionChoiceFinish_reason["function_call"] = "function_call";
+})(ChatCompletionChoiceFinish_reason || (exports.ChatCompletionChoiceFinish_reason = ChatCompletionChoiceFinish_reason = {}));

package/dist/tests/client.test.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const client_1 = require("@/client");
-const types_1 = require("@/types");
+const generated_1 = require("@/types/generated");
 const web_1 = require("node:stream/web");
 const node_util_1 = require("node:util");
 describe('InferenceGatewayClient', () => {
@@ -26,12 +26,14 @@ describe('InferenceGatewayClient', () => {
                         object: 'model',
                         created: 1686935002,
                         owned_by: 'openai',
+                        served_by: generated_1.Provider.openai,
                     },
                     {
                         id: 'llama-3.3-70b-versatile',
                         object: 'model',
                         created: 1723651281,
                         owned_by: 'groq',
+                        served_by: generated_1.Provider.groq,
                     },
                 ],
             };
@@ -62,7 +64,7 @@ describe('InferenceGatewayClient', () => {
                 ok: true,
                 json: () => Promise.resolve(mockResponse),
             });
-            const result = await client.listModels(types_1.Provider.OpenAI);
+            const result = await client.listModels(generated_1.Provider.openai);
             expect(result).toEqual(mockResponse);
             expect(mockFetch).toHaveBeenCalledWith('http://localhost:8080/v1/models?provider=openai', expect.objectContaining({
                 method: 'GET',
@@ -76,7 +78,7 @@ describe('InferenceGatewayClient', () => {
                 status: 404,
                 json: () => Promise.resolve({ error: errorMessage }),
             });
-            await expect(client.listModels(types_1.Provider.OpenAI)).rejects.toThrow(errorMessage);
+            await expect(client.listModels(generated_1.Provider.openai)).rejects.toThrow(errorMessage);
         });
     });
     describe('createChatCompletion', () => {
@@ -84,9 +86,10 @@ describe('InferenceGatewayClient', () => {
             const mockRequest = {
                 model: 'gpt-4o',
                 messages: [
-                    { role: types_1.MessageRole.System, content: 'You are a helpful assistant' },
-                    { role: types_1.MessageRole.User, content: 'Hello' },
+                    { role: generated_1.MessageRole.system, content: 'You are a helpful assistant' },
+                    { role: generated_1.MessageRole.user, content: 'Hello' },
                 ],
+                stream: false,
             };
             const mockResponse = {
                 id: 'chatcmpl-123',
@@ -97,10 +100,10 @@ describe('InferenceGatewayClient', () => {
                     {
                         index: 0,
                         message: {
-                            role: types_1.MessageRole.Assistant,
+                            role: generated_1.MessageRole.assistant,
                             content: 'Hello! How can I help you today?',
                         },
-                        finish_reason: 'stop',
+                        finish_reason: generated_1.ChatCompletionChoiceFinish_reason.stop,
                     },
                 ],
                 usage: {
@@ -123,7 +126,8 @@ describe('InferenceGatewayClient', () => {
         it('should create a chat completion with a specific provider', async () => {
             const mockRequest = {
                 model: 'claude-3-opus-20240229',
-                messages: [{ role: types_1.MessageRole.User, content: 'Hello' }],
+                messages: [{ role: generated_1.MessageRole.user, content: 'Hello' }],
+                stream: false,
             };
             const mockResponse = {
                 id: 'chatcmpl-456',
@@ -134,10 +138,10 @@ describe('InferenceGatewayClient', () => {
                     {
                         index: 0,
                         message: {
-                            role: types_1.MessageRole.Assistant,
+                            role: generated_1.MessageRole.assistant,
                             content: 'Hello! How can I assist you today?',
                         },
-                        finish_reason: 'stop',
+                        finish_reason: generated_1.ChatCompletionChoiceFinish_reason.stop,
                     },
                 ],
                 usage: {
@@ -150,7 +154,7 @@ describe('InferenceGatewayClient', () => {
                 ok: true,
                 json: () => Promise.resolve(mockResponse),
             });
-            const result = await client.createChatCompletion(mockRequest, types_1.Provider.Anthropic);
+            const result = await client.createChatCompletion(mockRequest, generated_1.Provider.anthropic);
             expect(result).toEqual(mockResponse);
             expect(mockFetch).toHaveBeenCalledWith('http://localhost:8080/v1/chat/completions?provider=anthropic', expect.objectContaining({
                 method: 'POST',
@@ -162,7 +166,8 @@ describe('InferenceGatewayClient', () => {
         it('should handle streaming chat completions', async () => {
             const mockRequest = {
                 model: 'gpt-4o',
-                messages: [{ role: types_1.MessageRole.User, content: 'Hello' }],
+                messages: [{ role: generated_1.MessageRole.user, content: 'Hello' }],
+                stream: true,
             };
             const mockStream = new web_1.TransformStream();
             const writer = mockStream.writable.getWriter();
@@ -179,7 +184,6 @@ describe('InferenceGatewayClient', () => {
                 onError: jest.fn(),
             };
             const streamPromise = client.streamChatCompletion(mockRequest, callbacks);
-            // Simulate SSE events
             await writer.write(encoder.encode('data: {"id":"chatcmpl-123","object":"chat.completion.chunk","created":1677652288,"model":"gpt-4o","choices":[{"index":0,"delta":{"role":"assistant"},"finish_reason":null}]}\n\n' +
                 'data: {"id":"chatcmpl-123","object":"chat.completion.chunk","created":1677652288,"model":"gpt-4o","choices":[{"index":0,"delta":{"content":"Hello"},"finish_reason":null}]}\n\n' +
                 'data: {"id":"chatcmpl-123","object":"chat.completion.chunk","created":1677652288,"model":"gpt-4o","choices":[{"index":0,"delta":{"content":"!"},"finish_reason":null}]}\n\n' +
@@ -205,28 +209,20 @@ describe('InferenceGatewayClient', () => {
                 model: 'gpt-4o',
                 messages: [
                     {
-                        role: types_1.MessageRole.User,
+                        role: generated_1.MessageRole.user,
                         content: 'What is the weather in San Francisco?',
                     },
                 ],
                 tools: [
                     {
-                        type: 'function',
+                        type: generated_1.ChatCompletionToolType.function,
                         function: {
                             name: 'get_weather',
-                            parameters: {
-                                type: 'object',
-                                properties: {
-                                    location: {
-                                        type: 'string',
-                                        description: 'The city and state, e.g. San Francisco, CA',
-                                    },
-                                },
-                                required: ['location'],
-                            },
+                            strict: true,
                         },
                     },
                 ],
+                stream: true,
             };
             const mockStream = new web_1.TransformStream();
             const writer = mockStream.writable.getWriter();
@@ -254,13 +250,14 @@ describe('InferenceGatewayClient', () => {
             await streamPromise;
             expect(callbacks.onOpen).toHaveBeenCalledTimes(1);
             expect(callbacks.onChunk).toHaveBeenCalledTimes(6);
-            expect(callbacks.onTool).toHaveBeenCalledTimes(4); // Called for each chunk with tool_calls
+            expect(callbacks.onTool).toHaveBeenCalledTimes(4);
             expect(callbacks.onFinish).toHaveBeenCalledTimes(1);
         });
         it('should handle errors in streaming chat completions', async () => {
             const mockRequest = {
                 model: 'gpt-4o',
-                messages: [{ role: types_1.MessageRole.User, content: 'Hello' }],
+                messages: [{ role: generated_1.MessageRole.user, content: 'Hello' }],
+                stream: true,
             };
             mockFetch.mockResolvedValueOnce({
                 ok: false,
@@ -281,7 +278,7 @@ describe('InferenceGatewayClient', () => {
                 ok: true,
                 json: () => Promise.resolve(mockResponse),
             });
-            const result = await client.proxy(types_1.Provider.OpenAI, 'embeddings', {
+            const result = await client.proxy(generated_1.Provider.openai, 'embeddings', {
                 method: 'POST',
                 body: JSON.stringify({
                     model: 'text-embedding-ada-002',
@@ -325,7 +322,6 @@ describe('InferenceGatewayClient', () => {
             });
             expect(newClient).toBeInstanceOf(client_1.InferenceGatewayClient);
             expect(newClient).not.toBe(originalClient);
-            // We can't directly test private properties, but we can test behavior
             mockFetch.mockResolvedValueOnce({
                 ok: true,
                 json: () => Promise.resolve({}),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inference-gateway/sdk",
-  "version": "0.3.4",
+  "version": "0.4.0-rc.1",
   "description": "An SDK written in Typescript for the [Inference Gateway](https://github.com/inference-gateway/inference-gateway).",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",

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

@@ -1,130 +0,0 @@
-export declare enum Provider {
-    Ollama = "ollama",
-    Groq = "groq",
-    OpenAI = "openai",
-    Cloudflare = "cloudflare",
-    Cohere = "cohere",
-    Anthropic = "anthropic",
-    DeepSeek = "deepseek"
-}
-export declare enum MessageRole {
-    System = "system",
-    User = "user",
-    Assistant = "assistant",
-    Tool = "tool"
-}
-export interface Message {
-    role: MessageRole;
-    content: string;
-    reasoning_content?: string;
-    reasoning?: 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 FunctionParameters {
-    type: string;
-    properties?: Record<string, unknown>;
-    required?: string[];
-}
-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 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 Error {
-    error: string;
-}

package/dist/src/types/index.js

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MessageRole = exports.Provider = void 0;
-var Provider;
-(function (Provider) {
-    Provider["Ollama"] = "ollama";
-    Provider["Groq"] = "groq";
-    Provider["OpenAI"] = "openai";
-    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 = {}));