@ai-foundry/llm-sdk/dist/services/providers/azure-openai.service.js

This is just another SDK for the common LLM API providers.

import { LLMApiService } from '../llm-api.service';
import { isString } from '../../helpers/validation.helpers';
export class AzureOpenAIService extends LLMApiService {
    // Fields for endpoint-based configuration
    #apiKey;
    #deployment;
    #endpoint;
    #apiVersion;
    // Fields for URL-based configuration
    #url;
    #headers;
    constructor(params) {
        super();
        this.#apiVersion = params.apiVersion || '2025-01-01-preview';
        if ('url' in params && 'headers' in params) {
            if ('endpoint' in params || 'deployment' in params || 'apiKey' in params) {
                throw new Error('Invalid parameters: provide either { apiKey, deployment, endpoint } or { url, headers }');
            }
            // Using URL and headers configuration
            this.#url = params.url;
            this.#headers = params.headers;
        }
        else if ('endpoint' in params && 'deployment' in params && 'apiKey' in params) {
            if ('url' in params || 'headers' in params) {
                throw new Error('Invalid parameters: provide either { apiKey, deployment, endpoint } or { url, headers }');
            }
            // Using endpoint-based configuration; apiKey is optional here.
            this.#apiKey = params.apiKey;
            this.#endpoint = params.endpoint;
            this.#deployment = params.deployment;
        }
        else {
            throw new Error('Invalid parameters: provide either { apiKey, deployment, endpoint } or { url, headers }');
        }
    }
    getURL() {
        const apiBaseUrl = this.#url || `${this.#endpoint}/openai/deployments/${this.#deployment}`;
        return `${apiBaseUrl}/chat/completions?api-version=${this.#apiVersion}`;
    }
    getHeaders() {
        if (this.#headers) {
            return this.#headers;
        }
        return this.#apiKey ? { 'api-key': this.#apiKey } : {};
    }
    formatToolCallPayload(tool) {
        return {
            type: 'function',
            function: {
                name: tool.name,
                description: tool.description,
                parameters: tool.parameters,
                ...(tool.strict ? { strict: tool.strict } : {})
            }
        };
    }
    formatMessagePayload(message) {
        if (message.role === 'system') {
            return { role: message.role, content: message.content };
        }
        else if (message.role === 'user') {
            if (Array.isArray(message.content)) {
                const content = message.content.map((part) => {
                    if (part.type === 'text') {
                        const textPart = { type: 'text', text: part.text };
                        return textPart;
                    }
                    else if (part.type === 'image' && isString(part.image)) {
                        const imagePart = { type: 'image_url', image_url: { url: part.image } };
                        return imagePart;
                    }
                    else {
                        throw new Error(`Invalid part type in user message: ${part}`);
                    }
                });
                return { role: message.role, content };
            }
            else {
                return { role: message.role, content: message.content };
            }
        }
        else if (message.role === 'assistant') {
            if (message.content) {
                return { role: message.role, content: message.content };
            }
            else if (Array.isArray(message.toolCalls) && message.toolCalls.length > 0) {
                const toolCalls = message.toolCalls.map((toolCall) => {
                    return {
                        id: toolCall.toolCallId,
                        type: 'function',
                        function: {
                            name: toolCall.name,
                            arguments: toolCall.arguments
                        }
                    };
                });
                return { role: message.role, content: null, tool_calls: toolCalls };
            }
            else {
                return { role: message.role, content: message.content };
            }
        }
        else if (message.role === 'tool') {
            return { role: message.role, content: message.content, tool_call_id: message.toolCallId };
        }
        else {
            throw new Error(`Invalid message role: ${message}`);
        }
    }
    formatOptionsPayload(options) {
        return {
            ...(options.maxTokens ? { max_tokens: options.maxTokens } : {}),
            ...(options.temperature ? { temperature: options.temperature } : {}),
            ...(options.topP ? { top_p: options.topP } : {}),
            ...(options.frequencyPenalty ? { frequency_penalty: options.frequencyPenalty } : {}),
            ...(options.presencePenalty ? { presence_penalty: options.presencePenalty } : {}),
            ...(options.stopSequences ? { stop: options.stopSequences } : {}),
            ...(options.seed ? { seed: options.seed } : {})
        };
    }
    parseAssistantResponse(data) {
        const responseData = data;
        return {
            message: {
                role: 'assistant',
                content: responseData.choices[0].message.content,
                ...(responseData.choices[0].message.tool_calls
                    ? {
                        toolCalls: responseData.choices[0].message.tool_calls.map((toolCall) => {
                            return {
                                type: 'function',
                                toolCallId: toolCall.id,
                                name: toolCall.function.name,
                                arguments: toolCall.function.arguments
                            };
                        })
                    }
                    : {})
            },
            usage: {
                promptTokens: responseData.usage.prompt_tokens,
                completionTokens: responseData.usage.completion_tokens,
                totalTokens: responseData.usage.total_tokens
            },
            finishReason: responseData.choices[0].finish_reason
        };
    }
}
//# sourceMappingURL=azure-openai.service.js.map