playkit-sdk 1.1.4-beta.3 → 1.2.0-beta

package/dist/playkit-sdk.umd.js

@@ -1,5 +1,5 @@
 /**
- * playkit-sdk v1.1.4-beta.3
+ * playkit-sdk v1.2.0-beta
  * PlayKit SDK for JavaScript
  * @license SEE LICENSE IN LICENSE
  */
@@ -371,6 +371,54 @@
 	    }
 	}
 
+	/**
+	 * Chat and text generation types
+	 */
+	/**
+	 * Helper to convert NpcAction to ChatTool
+	 */
+	function npcActionToTool(action) {
+	    var _a;
+	    const properties = {};
+	    const required = [];
+	    for (const param of action.parameters || []) {
+	        const propDef = { description: param.description };
+	        switch (param.type) {
+	            case 'string':
+	                propDef.type = 'string';
+	                break;
+	            case 'number':
+	                propDef.type = 'number';
+	                break;
+	            case 'boolean':
+	                propDef.type = 'boolean';
+	                break;
+	            case 'stringEnum':
+	                propDef.type = 'string';
+	                if ((_a = param.enumOptions) === null || _a === void 0 ? void 0 : _a.length) {
+	                    propDef.enum = param.enumOptions;
+	                }
+	                break;
+	        }
+	        properties[param.name] = propDef;
+	        if (param.required !== false) {
+	            required.push(param.name);
+	        }
+	    }
+	    return {
+	        type: 'function',
+	        function: {
+	            name: action.actionName,
+	            description: action.description,
+	            parameters: {
+	                type: 'object',
+	                properties,
+	                required,
+	            },
+	        },
+	    };
+	}
+
 	/**
 	 * Token storage with encryption using Web Crypto API
 	 * Stores tokens in localStorage with AES-128-GCM encryption
@@ -2807,30 +2855,199 @@
 	            throw new PlayKitError(error instanceof Error ? error.message : 'Unknown error', 'CHAT_STREAM_ERROR');
 	        }
 	    }
+	    /**
+	     * Make a chat completion request with tools (non-streaming)
+	     */
+	    async chatCompletionWithTools(chatConfig) {
+	        var _a, _b;
+	        const token = this.authManager.getToken();
+	        if (!token) {
+	            throw new PlayKitError('Not authenticated', 'NOT_AUTHENTICATED');
+	        }
+	        const model = chatConfig.model || this.config.defaultChatModel || 'gpt-4o-mini';
+	        const endpoint = `/ai/${this.config.gameId}/v1/chat`;
+	        const requestBody = {
+	            model,
+	            messages: chatConfig.messages,
+	            temperature: (_a = chatConfig.temperature) !== null && _a !== void 0 ? _a : 0.7,
+	            stream: false,
+	            max_tokens: chatConfig.maxTokens || null,
+	            seed: chatConfig.seed || null,
+	            stop: chatConfig.stop || null,
+	            top_p: chatConfig.topP || null,
+	        };
+	        // Add tools if provided
+	        if ((_b = chatConfig.tools) === null || _b === void 0 ? void 0 : _b.length) {
+	            requestBody.tools = chatConfig.tools;
+	        }
+	        if (chatConfig.tool_choice) {
+	            requestBody.tool_choice = chatConfig.tool_choice;
+	        }
+	        try {
+	            const response = await fetch(`${this.baseURL}${endpoint}`, {
+	                method: 'POST',
+	                headers: {
+	                    Authorization: `Bearer ${token}`,
+	                    'Content-Type': 'application/json',
+	                },
+	                body: JSON.stringify(requestBody),
+	            });
+	            if (!response.ok) {
+	                const error = await response.json().catch(() => ({ message: 'Chat request failed' }));
+	                const playKitError = new PlayKitError(error.message || 'Chat request failed', error.code, response.status);
+	                if (error.code === 'INSUFFICIENT_CREDITS' || response.status === 402) {
+	                    if (this.playerClient) {
+	                        await this.playerClient.handleInsufficientCredits(playKitError);
+	                    }
+	                }
+	                throw playKitError;
+	            }
+	            const result = await response.json();
+	            if (this.playerClient) {
+	                this.playerClient.checkBalanceAfterApiCall().catch(() => { });
+	            }
+	            return result;
+	        }
+	        catch (error) {
+	            if (error instanceof PlayKitError) {
+	                throw error;
+	            }
+	            throw new PlayKitError(error instanceof Error ? error.message : 'Unknown error', 'CHAT_ERROR');
+	        }
+	    }
+	    /**
+	     * Make a streaming chat completion request with tools
+	     */
+	    async chatCompletionWithToolsStream(chatConfig) {
+	        var _a, _b;
+	        const token = this.authManager.getToken();
+	        if (!token) {
+	            throw new PlayKitError('Not authenticated', 'NOT_AUTHENTICATED');
+	        }
+	        const model = chatConfig.model || this.config.defaultChatModel || 'gpt-4o-mini';
+	        const endpoint = `/ai/${this.config.gameId}/v1/chat`;
+	        const requestBody = {
+	            model,
+	            messages: chatConfig.messages,
+	            temperature: (_a = chatConfig.temperature) !== null && _a !== void 0 ? _a : 0.7,
+	            stream: true,
+	            max_tokens: chatConfig.maxTokens || null,
+	            seed: chatConfig.seed || null,
+	            stop: chatConfig.stop || null,
+	            top_p: chatConfig.topP || null,
+	        };
+	        // Add tools if provided
+	        if ((_b = chatConfig.tools) === null || _b === void 0 ? void 0 : _b.length) {
+	            requestBody.tools = chatConfig.tools;
+	        }
+	        if (chatConfig.tool_choice) {
+	            requestBody.tool_choice = chatConfig.tool_choice;
+	        }
+	        try {
+	            const response = await fetch(`${this.baseURL}${endpoint}`, {
+	                method: 'POST',
+	                headers: {
+	                    Authorization: `Bearer ${token}`,
+	                    'Content-Type': 'application/json',
+	                },
+	                body: JSON.stringify(requestBody),
+	            });
+	            if (!response.ok) {
+	                const error = await response.json().catch(() => ({ message: 'Chat stream request failed' }));
+	                const playKitError = new PlayKitError(error.message || 'Chat stream request failed', error.code, response.status);
+	                if (error.code === 'INSUFFICIENT_CREDITS' || response.status === 402) {
+	                    if (this.playerClient) {
+	                        await this.playerClient.handleInsufficientCredits(playKitError);
+	                    }
+	                }
+	                throw playKitError;
+	            }
+	            if (!response.body) {
+	                throw new PlayKitError('Response body is null', 'NO_RESPONSE_BODY');
+	            }
+	            if (this.playerClient) {
+	                this.playerClient.checkBalanceAfterApiCall().catch(() => { });
+	            }
+	            return response.body.getReader();
+	        }
+	        catch (error) {
+	            if (error instanceof PlayKitError) {
+	                throw error;
+	            }
+	            throw new PlayKitError(error instanceof Error ? error.message : 'Unknown error', 'CHAT_STREAM_ERROR');
+	        }
+	    }
 	    /**
 	     * Generate structured output using JSON schema
+	     * Uses the /chat endpoint with response_format for structured output
 	     */
-	    async generateStructured(schemaName, prompt, model, temperature) {
+	    async generateStructured(schemaName, prompt, model, temperature, schema, schemaDescription) {
 	        var _a;
+	        const token = this.authManager.getToken();
+	        if (!token) {
+	            throw new PlayKitError('Not authenticated', 'NOT_AUTHENTICATED');
+	        }
+	        const modelToUse = model || this.config.defaultChatModel || 'gpt-4o-mini';
+	        const endpoint = `/ai/${this.config.gameId}/v1/chat`;
 	        const messages = [{ role: 'user', content: prompt }];
-	        const chatConfig = {
+	        const requestBody = {
+	            model: modelToUse,
 	            messages,
-	            model: model || this.config.defaultChatModel,
 	            temperature: temperature !== null && temperature !== void 0 ? temperature : 0.7,
+	            stream: false,
 	        };
-	        // Add schema information to the request
-	        // (Implementation depends on how the API handles structured output)
-	        const response = await this.chatCompletion(chatConfig);
-	        // Parse the response content as JSON
-	        const content = (_a = response.choices[0]) === null || _a === void 0 ? void 0 : _a.message.content;
-	        if (!content) {
-	            throw new PlayKitError('No content in response', 'NO_CONTENT');
+	        // Add response_format with json_schema if schema is provided
+	        if (schema) {
+	            requestBody.response_format = {
+	                type: 'json_schema',
+	                json_schema: {
+	                    name: schemaName,
+	                    description: schemaDescription || '',
+	                    schema: schema,
+	                    strict: true,
+	                },
+	            };
 	        }
 	        try {
-	            return JSON.parse(content);
+	            const response = await fetch(`${this.baseURL}${endpoint}`, {
+	                method: 'POST',
+	                headers: {
+	                    Authorization: `Bearer ${token}`,
+	                    'Content-Type': 'application/json',
+	                },
+	                body: JSON.stringify(requestBody),
+	            });
+	            if (!response.ok) {
+	                const error = await response.json().catch(() => ({ message: 'Structured generation failed' }));
+	                const playKitError = new PlayKitError(error.message || 'Structured generation failed', error.code, response.status);
+	                if (error.code === 'INSUFFICIENT_CREDITS' || response.status === 402) {
+	                    if (this.playerClient) {
+	                        await this.playerClient.handleInsufficientCredits(playKitError);
+	                    }
+	                }
+	                throw playKitError;
+	            }
+	            const result = await response.json();
+	            if (this.playerClient) {
+	                this.playerClient.checkBalanceAfterApiCall().catch(() => { });
+	            }
+	            // Parse the response content as JSON
+	            const content = (_a = result.choices[0]) === null || _a === void 0 ? void 0 : _a.message.content;
+	            if (!content) {
+	                throw new PlayKitError('No content in response', 'NO_CONTENT');
+	            }
+	            try {
+	                return JSON.parse(content);
+	            }
+	            catch (parseError) {
+	                throw new PlayKitError('Failed to parse structured output', 'PARSE_ERROR');
+	            }
 	        }
 	        catch (error) {
-	            throw new PlayKitError('Failed to parse structured output', 'PARSE_ERROR');
+	            if (error instanceof PlayKitError) {
+	                throw error;
+	            }
+	            throw new PlayKitError(error instanceof Error ? error.message : 'Unknown error', 'STRUCTURED_GENERATION_ERROR');
 	        }
 	    }
 	}
@@ -3186,6 +3403,56 @@
 	            onComplete,
 	        });
 	    }
+	    /**
+	     * Generate text with tool calling support (non-streaming)
+	     */
+	    async textGenerationWithTools(config) {
+	        const chatConfig = Object.assign(Object.assign({}, config), { model: config.model || this.model });
+	        const response = await this.provider.chatCompletionWithTools(chatConfig);
+	        const choice = response.choices[0];
+	        if (!choice) {
+	            throw new Error('No choices in response');
+	        }
+	        return {
+	            content: choice.message.content || '',
+	            model: response.model,
+	            finishReason: choice.finish_reason,
+	            usage: response.usage
+	                ? {
+	                    promptTokens: response.usage.prompt_tokens,
+	                    completionTokens: response.usage.completion_tokens,
+	                    totalTokens: response.usage.total_tokens,
+	                }
+	                : undefined,
+	            id: response.id,
+	            created: response.created,
+	            tool_calls: choice.message.tool_calls,
+	        };
+	    }
+	    /**
+	     * Generate text with tool calling support (streaming)
+	     * Text streams first, complete result with tool_calls returned in onComplete
+	     */
+	    async textGenerationWithToolsStream(config) {
+	        const chatConfig = Object.assign(Object.assign({}, config), { model: config.model || this.model });
+	        const reader = await this.provider.chatCompletionWithToolsStream(chatConfig);
+	        let fullContent = '';
+	        let toolCalls = [];
+	        await StreamParser.streamWithCallbacks(reader, (chunk) => {
+	            fullContent += chunk;
+	            config.onChunk(chunk);
+	        }, () => {
+	            // On complete, provide full result
+	            if (config.onComplete) {
+	                config.onComplete({
+	                    content: fullContent,
+	                    model: chatConfig.model || this.model,
+	                    finishReason: toolCalls.length > 0 ? 'tool_calls' : 'stop',
+	                    tool_calls: toolCalls.length > 0 ? toolCalls : undefined,
+	                });
+	            }
+	        }, config.onError);
+	    }
 	}
 
 	/**
@@ -3335,8 +3602,10 @@
 	    }
 	    /**
 	     * Talk with structured output
+	     * @deprecated Use talkWithActions instead for NPC decision-making with actions
 	     */
 	    async talkStructured(message, schemaName) {
+	        console.warn('[NPCClient] talkStructured is deprecated. Use talkWithActions instead for NPC decision-making with actions.');
 	        // Add user message to history
 	        const userMessage = { role: 'user', content: message };
 	        this.history.push(userMessage);
@@ -3356,6 +3625,153 @@
 	        this.trimHistory();
 	        return result;
 	    }
+	    /**
+	     * Talk to the NPC with available actions (non-streaming)
+	     * @param message The message to send
+	     * @param actions List of actions the NPC can perform
+	     * @returns Response containing text and any action calls
+	     */
+	    async talkWithActions(message, actions) {
+	        // Add user message to history
+	        const userMessage = { role: 'user', content: message };
+	        this.history.push(userMessage);
+	        // Convert NpcActions to ChatTools
+	        const tools = actions
+	            .filter(a => a && a.enabled !== false)
+	            .map(a => npcActionToTool(a));
+	        // Build messages array with system prompt
+	        const messages = [
+	            { role: 'system', content: this.systemPrompt },
+	            ...this.history,
+	        ];
+	        // Generate response with tools
+	        const result = await this.chatClient.textGenerationWithTools({
+	            messages,
+	            temperature: this.temperature,
+	            tools,
+	            tool_choice: 'auto',
+	        });
+	        // Build response
+	        const response = {
+	            text: result.content || '',
+	            actionCalls: [],
+	            hasActions: false,
+	        };
+	        // Extract tool calls if any
+	        if (result.tool_calls) {
+	            response.actionCalls = result.tool_calls.map(tc => ({
+	                id: tc.id,
+	                actionName: tc.function.name,
+	                arguments: this.parseToolArguments(tc.function.arguments),
+	            }));
+	            response.hasActions = response.actionCalls.length > 0;
+	        }
+	        // Add assistant response to history
+	        const assistantMessage = {
+	            role: 'assistant',
+	            content: response.text,
+	            tool_calls: result.tool_calls,
+	        };
+	        this.history.push(assistantMessage);
+	        this.trimHistory();
+	        this.emit('response', response.text);
+	        if (response.hasActions) {
+	            this.emit('actions', response.actionCalls);
+	        }
+	        return response;
+	    }
+	    /**
+	     * Talk to the NPC with actions (streaming)
+	     * Text streams first, action calls are returned in onComplete
+	     */
+	    async talkWithActionsStream(message, actions, onChunk, onComplete) {
+	        // Add user message to history
+	        const userMessage = { role: 'user', content: message };
+	        this.history.push(userMessage);
+	        // Convert NpcActions to ChatTools
+	        const tools = actions
+	            .filter(a => a && a.enabled !== false)
+	            .map(a => npcActionToTool(a));
+	        // Build messages array with system prompt
+	        const messages = [
+	            { role: 'system', content: this.systemPrompt },
+	            ...this.history,
+	        ];
+	        // Generate response with tools (streaming)
+	        await this.chatClient.textGenerationWithToolsStream({
+	            messages,
+	            temperature: this.temperature,
+	            tools,
+	            tool_choice: 'auto',
+	            onChunk,
+	            onComplete: (result) => {
+	                // Build response
+	                const response = {
+	                    text: result.content || '',
+	                    actionCalls: [],
+	                    hasActions: false,
+	                };
+	                // Extract tool calls if any
+	                if (result.tool_calls) {
+	                    response.actionCalls = result.tool_calls.map(tc => ({
+	                        id: tc.id,
+	                        actionName: tc.function.name,
+	                        arguments: this.parseToolArguments(tc.function.arguments),
+	                    }));
+	                    response.hasActions = response.actionCalls.length > 0;
+	                }
+	                // Add assistant response to history
+	                const assistantMessage = {
+	                    role: 'assistant',
+	                    content: response.text,
+	                    tool_calls: result.tool_calls,
+	                };
+	                this.history.push(assistantMessage);
+	                this.trimHistory();
+	                this.emit('response', response.text);
+	                if (response.hasActions) {
+	                    this.emit('actions', response.actionCalls);
+	                }
+	                if (onComplete) {
+	                    onComplete(response);
+	                }
+	            },
+	        });
+	    }
+	    /**
+	     * Report action results back to the conversation
+	     * Call this after executing actions to let the NPC know the results
+	     */
+	    reportActionResults(results) {
+	        for (const [callId, result] of Object.entries(results)) {
+	            this.history.push({
+	                role: 'tool',
+	                tool_call_id: callId,
+	                content: result,
+	            });
+	        }
+	    }
+	    /**
+	     * Report a single action result
+	     */
+	    reportActionResult(callId, result) {
+	        this.history.push({
+	            role: 'tool',
+	            tool_call_id: callId,
+	            content: result,
+	        });
+	    }
+	    /**
+	     * Parse tool arguments from JSON string
+	     */
+	    parseToolArguments(args) {
+	        try {
+	            return JSON.parse(args);
+	        }
+	        catch (_a) {
+	            return {};
+	        }
+	    }
 	    /**
 	     * Get conversation history
 	     */
@@ -3499,12 +3915,27 @@
 	                    }
 	                }
 	                catch (error) {
-	                    // If token is invalid, logout and re-throw error
+	                    // If token is invalid, logout and restart auth flow
 	                    if (this.config.debug) {
 	                        console.error('[PlayKitSDK] Token validation failed:', error);
 	                    }
 	                    await this.authManager.logout();
-	                    throw new Error('Token validation failed: ' + (error instanceof Error ? error.message : String(error)));
+	                    // Auto-restart login flow in browser environment
+	                    if (typeof window !== 'undefined') {
+	                        if (this.config.debug) {
+	                            console.log('[PlayKitSDK] Restarting authentication flow...');
+	                        }
+	                        const useExternalAuth = this.config.authMethod === 'external-auth';
+	                        await this.authManager.startAuthFlow(useExternalAuth);
+	                        // Retry getting player info after re-authentication
+	                        await this.playerClient.getPlayerInfo();
+	                        if (this.config.debug) {
+	                            console.log('[PlayKitSDK] Re-authentication successful, token validated');
+	                        }
+	                    }
+	                    else {
+	                        throw new Error('Token validation failed: ' + (error instanceof Error ? error.message : String(error)));
+	                    }
 	                }
 	            }
 	            this.emit('ready');