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

package/dist/playkit-sdk.cjs.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
  */
@@ -24,6 +24,54 @@ class PlayKitError extends Error {
     }
 }
 
+/**
+ * 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
@@ -2460,30 +2508,199 @@ class ChatProvider {
             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');
         }
     }
 }
@@ -2839,6 +3056,56 @@ class ChatClient {
             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);
+    }
 }
 
 /**
@@ -2988,8 +3255,10 @@ class NPCClient extends EventEmitter {
     }
     /**
      * 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);
@@ -3009,6 +3278,153 @@ class NPCClient extends EventEmitter {
         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
      */
@@ -3152,12 +3568,27 @@ class PlayKitSDK extends EventEmitter {
                     }
                 }
                 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');