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

package/dist/playkit-sdk.d.ts

@@ -6,13 +6,28 @@ import EventEmitter from 'eventemitter3';
 /**
  * Message role in a conversation
  */
-type MessageRole = 'system' | 'user' | 'assistant';
+type MessageRole = 'system' | 'user' | 'assistant' | 'tool';
+/**
+ * Tool call made by the assistant
+ */
+interface ToolCall {
+    id: string;
+    type: 'function';
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
 /**
  * A message in a conversation
  */
 interface Message {
     role: MessageRole;
     content: string;
+    /** Tool calls made by the assistant (when role is 'assistant') */
+    tool_calls?: ToolCall[];
+    /** Tool call ID this message responds to (when role is 'tool') */
+    tool_call_id?: string;
 }
 /**
  * Generic API result wrapper
@@ -82,6 +97,17 @@ declare class PlayKitError extends Error {
  * Chat and text generation types
  */
 
+/**
+ * Tool definition for function calling
+ */
+interface ChatTool {
+    type: 'function';
+    function: {
+        name: string;
+        description: string;
+        parameters: Record<string, any>;
+    };
+}
 /**
  * Configuration for text generation
  */
@@ -100,6 +126,15 @@ interface ChatConfig {
     stop?: string[];
     /** Top-p sampling */
     topP?: number;
+    /** Tools available for the model to use */
+    tools?: ChatTool[];
+    /** Tool choice: 'auto', 'required', 'none', or specific tool */
+    tool_choice?: 'auto' | 'required' | 'none' | {
+        type: 'function';
+        function: {
+            name: string;
+        };
+    };
 }
 /**
  * Configuration for streaming text generation
@@ -121,7 +156,7 @@ interface ChatResult {
     /** Model used for generation */
     model: string;
     /** Finish reason */
-    finishReason: 'stop' | 'length' | 'content_filter' | 'null';
+    finishReason: 'stop' | 'length' | 'content_filter' | 'tool_calls' | 'null';
     /** Token usage information */
     usage?: {
         promptTokens: number;
@@ -132,6 +167,8 @@ interface ChatResult {
     id?: string;
     /** Timestamp of creation */
     created?: number;
+    /** Tool calls made by the model */
+    tool_calls?: ToolCall[];
 }
 /**
  * Configuration for structured output generation
@@ -176,6 +213,45 @@ interface StreamChunk {
     delta?: string;
     error?: string;
 }
+/**
+ * NPC Action parameter types
+ */
+type NpcActionParamType = 'string' | 'number' | 'boolean' | 'stringEnum';
+/**
+ * NPC Action parameter definition
+ */
+interface NpcActionParameter {
+    name: string;
+    description: string;
+    type: NpcActionParamType;
+    required?: boolean;
+    enumOptions?: string[];
+}
+/**
+ * NPC Action definition
+ */
+interface NpcAction {
+    actionName: string;
+    description: string;
+    parameters?: NpcActionParameter[];
+    enabled?: boolean;
+}
+/**
+ * NPC Action call result
+ */
+interface NpcActionCall {
+    id: string;
+    actionName: string;
+    arguments: Record<string, any>;
+}
+/**
+ * Response from NPC with actions
+ */
+interface NpcActionResponse {
+    text: string;
+    actionCalls: NpcActionCall[];
+    hasActions: boolean;
+}
 
 /**
  * Image generation types
@@ -469,6 +545,18 @@ declare class PlayerClient extends EventEmitter {
  * Chat provider for HTTP communication with chat API
  */
 
+/**
+ * Chat config with tools support
+ */
+interface ChatConfigWithTools extends ChatConfig {
+    tools?: ChatTool[];
+    tool_choice?: 'auto' | 'required' | 'none' | {
+        type: 'function';
+        function: {
+            name: string;
+        };
+    };
+}
 declare class ChatProvider {
     private authManager;
     private config;
@@ -487,16 +575,45 @@ declare class ChatProvider {
      * Make a streaming chat completion request
      */
     chatCompletionStream(chatConfig: ChatConfig): Promise<ReadableStreamDefaultReader<Uint8Array>>;
+    /**
+     * Make a chat completion request with tools (non-streaming)
+     */
+    chatCompletionWithTools(chatConfig: ChatConfigWithTools): Promise<ChatCompletionResponse>;
+    /**
+     * Make a streaming chat completion request with tools
+     */
+    chatCompletionWithToolsStream(chatConfig: ChatConfigWithTools): Promise<ReadableStreamDefaultReader<Uint8Array>>;
     /**
      * Generate structured output using JSON schema
+     * Uses the /chat endpoint with response_format for structured output
      */
-    generateStructured(schemaName: string, prompt: string, model?: string, temperature?: number): Promise<any>;
+    generateStructured(schemaName: string, prompt: string, model?: string, temperature?: number, schema?: Record<string, any>, schemaDescription?: string): Promise<any>;
 }
 
 /**
  * Chat client for AI text generation
  */
 
+/**
+ * Config for text generation with tools
+ */
+interface ChatWithToolsConfig extends ChatConfig {
+    tools: ChatTool[];
+    tool_choice?: 'auto' | 'required' | 'none' | {
+        type: 'function';
+        function: {
+            name: string;
+        };
+    };
+}
+/**
+ * Config for streaming text generation with tools
+ */
+interface ChatWithToolsStreamConfig extends ChatWithToolsConfig {
+    onChunk: (chunk: string) => void;
+    onComplete?: (result: ChatResult) => void;
+    onError?: (error: Error) => void;
+}
 declare class ChatClient {
     private provider;
     private model;
@@ -521,6 +638,15 @@ declare class ChatClient {
      * Simple chat with streaming
      */
     chatStream(message: string, onChunk: (chunk: string) => void, onComplete?: (fullText: string) => void, systemPrompt?: string): Promise<void>;
+    /**
+     * Generate text with tool calling support (non-streaming)
+     */
+    textGenerationWithTools(config: ChatWithToolsConfig): Promise<ChatResult>;
+    /**
+     * Generate text with tool calling support (streaming)
+     * Text streams first, complete result with tool_calls returned in onComplete
+     */
+    textGenerationWithToolsStream(config: ChatWithToolsStreamConfig): Promise<void>;
 }
 
 /**
@@ -605,8 +731,34 @@ declare class NPCClient extends EventEmitter {
     talkStream(message: string, onChunk: (chunk: string) => void, onComplete?: (fullText: string) => void): Promise<void>;
     /**
      * Talk with structured output
+     * @deprecated Use talkWithActions instead for NPC decision-making with actions
      */
     talkStructured<T = any>(message: string, schemaName: string): Promise<T>;
+    /**
+     * 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
+     */
+    talkWithActions(message: string, actions: NpcAction[]): Promise<NpcActionResponse>;
+    /**
+     * Talk to the NPC with actions (streaming)
+     * Text streams first, action calls are returned in onComplete
+     */
+    talkWithActionsStream(message: string, actions: NpcAction[], onChunk: (chunk: string) => void, onComplete?: (response: NpcActionResponse) => void): Promise<void>;
+    /**
+     * Report action results back to the conversation
+     * Call this after executing actions to let the NPC know the results
+     */
+    reportActionResults(results: Record<string, string>): void;
+    /**
+     * Report a single action result
+     */
+    reportActionResult(callId: string, result: string): void;
+    /**
+     * Parse tool arguments from JSON string
+     */
+    private parseToolArguments;
     /**
      * Get conversation history
      */