@intelliweave/embedded 1.8.64 → 1.9.66

package/dist/component/component.d.ts

@@ -1,82 +1,100 @@
-import { Optional } from 'utility-types';
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { Optional } from 'utility-types';
 
 /**
- * This class helps organize groups of tokenized text along with removing items when the window is full.
+ * Allows an MCP server to be used as a knowledge source for IntelliWeave.
  */
-declare class TokenWindow {
-    /** Token window size */
-    size: number;
-    /** Token groups */
-    groups: TokenWindowGroup<any>[];
-    /** Create a new group */
-    createGroup(id: string): TokenWindowGroup<unknown>;
-    /** Get a group */
-    group<CustomDataType>(id: string): TokenWindowGroup<CustomDataType> | undefined;
-    /** Calculate current tokens in all groups */
-    countTokens(): number;
-    /** Remove overflow from all groups. */
-    removeOverflow(): void;
-    /** Remove one overflow item. Returns null if no items were able to be removed. */
-    private removeOneItem;
-}
-/** A token group. */
-declare class TokenWindowGroup<CustomDataType> {
-    /** Group ID */
-    id: string;
-    /** List of items */
-    items: TokenWindowGroupItem<CustomDataType>[];
-    /**
-     * Weight controls how many items from this group should be kept in relation to the entire window. For example if all
-     * groups have a weight of 1, each group remove items equally if full. If one has a weight of 2 while the rest are 1,
-     * that group will be allowed to keep double the amount of items.
-     */
-    weight: number;
-    /** Current total token count, computed automatically. Don't update this value manually. */
-    tokenCount: number;
-    /** Group item separator */
-    separator: string;
-    /** Token count padding added to each item. */
-    private itemPadding;
-    /** Sets the token count padding added to each item. Useful if you don't know exactly what will be added by the LLM host. */
-    setItemPadding(padding: number): this;
-    /** Sort function */
-    private sortFunction;
-    /** Set sort function */
-    sortBy(sortFunction: (a: TokenWindowGroupItem<CustomDataType>, b: TokenWindowGroupItem<CustomDataType>) => number): this;
-    /** Set separator */
-    setSeparator(separator: string): this;
-    /** Set weight */
-    setWeight(weight: number): this;
-    /** Recalculate all tokens. Note this may take a while. */
-    recalculateTokens(): void;
-    /** Add an item to the group */
-    add(item: string | Omit<Optional<TokenWindowGroupItem<CustomDataType>, 'id' | 'dateAdded' | 'sortOrder'>, 'tokenCount'>): TokenWindowGroupItem<CustomDataType>;
-    /** Get all items as a string */
-    getAllAsString(): string;
-    /** Get all items. Doesn't return disabled items. */
-    getAll(): TokenWindowGroupItem<CustomDataType>[];
-    /** Remove all items from this group */
-    empty(): void;
-}
-/** Token group item */
-interface TokenWindowGroupItem<CustomDataType> {
-    /** Each item must have a unique ID. */
-    id: string;
-    /** The string content of the item */
-    content: string;
-    /** True if this item should never be removed */
-    cannotRemove?: boolean;
-    /** Sorting order. If not specified, uses dateAdded instead. */
-    sortOrder: number;
-    /** Date this item was added */
-    dateAdded: number;
-    /** Token count in the content */
-    tokenCount: number;
-    /** Anything to attach to this item */
-    customData?: CustomDataType;
-    /** If disabled, this item will not be included and will not add tot he token count. */
-    disabled?: boolean;
+declare class MCPKnowledgeClient {
+    /** MCP client */
+    client?: Client;
+    /** All tools discovered on the MCP server. Only available after connect() has completed. */
+    tools: Awaited<ReturnType<Client['listTools']>>['tools'];
+    /** All toold discovered, mapped to IntelliWeave knowledge base actions */
+    iwActions: KnowledgeBaseItem[];
+    /** Statistics */
+    stats: {
+        toolsCalled: number;
+    };
+    /** Configuration */
+    config: {
+        /** Source ID */
+        id?: string;
+        /** URL to the MCP server endpoint */
+        baseURL?: string;
+        /** Custom connection function. If specified, baseURL is optional. */
+        connect?: () => Promise<Client>;
+        /**
+         * The name of the tool which provides knowledge searching. If specified, the search() will exclude this function and instead
+         * call it and show returned results. If not specified, the search() will just return all tools.
+         */
+        searchToolName?: string;
+        /** Keep search function available for the AI to use. */
+        searchToolVisible?: boolean;
+    };
+    /** Constructor */
+    constructor(config: MCPKnowledgeClient['config']);
+    /** In-progress connection attempt */
+    private connectionPromise?;
+    /** Connect to the client */
+    connect(): Promise<Client<{
+        method: string;
+        params?: {
+            [x: string]: unknown;
+            _meta?: {
+                [x: string]: unknown;
+                progressToken?: string | number | undefined;
+            } | undefined;
+        } | undefined;
+    }, {
+        method: string;
+        params?: {
+            [x: string]: unknown;
+            _meta?: {
+                [x: string]: unknown;
+            } | undefined;
+        } | undefined;
+    }, {
+        [x: string]: unknown;
+        _meta?: {
+            [x: string]: unknown;
+        } | undefined;
+    }>>;
+    connectInternal(): Promise<Client<{
+        method: string;
+        params?: {
+            [x: string]: unknown;
+            _meta?: {
+                [x: string]: unknown;
+                progressToken?: string | number | undefined;
+            } | undefined;
+        } | undefined;
+    }, {
+        method: string;
+        params?: {
+            [x: string]: unknown;
+            _meta?: {
+                [x: string]: unknown;
+            } | undefined;
+        } | undefined;
+    }, {
+        [x: string]: unknown;
+        _meta?: {
+            [x: string]: unknown;
+        } | undefined;
+    }>>;
+    /** Disconnect from server */
+    disconnect(): Promise<void>;
+    /** Fetch list of tools from the MCP server */
+    private fetchTools;
+    /** Cache last search result */
+    lastSearchQuery: string;
+    lastSearchResults: KnowledgeBaseItem[];
+    /** Perform a search query */
+    search(query: string): Promise<KnowledgeBaseItem[]>;
+    /** Perform search using the configured search function */
+    private performSearchCall;
+    /** Perform tool call. */
+    private performToolCall;
 }
 
 // ==================================================================================================
@@ -246,208 +264,6 @@ interface JSONSchema7 {
     examples?: JSONSchema7Type | undefined;
 }
 
-/** ChatGPT config options */
-interface ChatGPTConfig {
-    /** API key */
-    apiKey: string;
-    /** Provider ID */
-    providerID?: string;
-    /** Endpoint URL if using a custom URL */
-    endpoint: string;
-    /** LLM model to use */
-    model: string;
-    /** System message to describe to the AI how to behave. */
-    systemMessage: string;
-    /** User ID used to uniquely identify users in ChatGPT's API */
-    userID: string;
-    /** If true, streams the text responses from the API */
-    stream: boolean;
-    /** Amount of estimated tokens to keep when trimming */
-    maxTokens: number;
-    /** Callback before the AI sends info to the LLM */
-    onBeforeMessageProcessing?: () => void;
-    /** Callback when a message from the AI is returned. If isChunk is true, it may be incomplete and be called again with more updates. */
-    onAIMessage?: (text: string, isChunk: boolean) => void;
-    /** Callback when the AI starts performing an action */
-    onAIToolStart?: (toolName: string, input: any) => void;
-}
-/** ChatGPT tool config */
-interface ChatGPTToolConfig {
-    /** Name of the tool */
-    name: string;
-    /** Description of the tool */
-    description: string;
-    /** Parameters for the tool */
-    params: JSONSchema7;
-    /** Callback function to process the tool */
-    callback: (params: any) => any;
-    /** If true, this tool call will be removed from the message history after it is executed. */
-    removeFromMessageHistory?: boolean;
-    /** If true, this item can be removed if there's not enough context available. */
-    canRemove?: boolean;
-    /** Misc app context */
-    [key: string]: any;
-}
-/** ChatGPT message */
-interface ChatGPTMessage {
-    /** Role of the message */
-    role: 'user' | 'assistant' | 'system' | 'tool';
-    /** Content of the message */
-    content: string;
-    /** Tool call ID */
-    tool_call_id?: string;
-    /** Tool calls made by the AI */
-    tool_calls?: any[];
-}
-/**
- * API for interacting with ChatGPT APIs.
- */
-declare class ChatGPT {
-    /** ID */
-    id: string;
-    /** Metadata */
-    metadata: any;
-    /** Config */
-    config: ChatGPTConfig;
-    /** The maximum tool calls in sequence the AI can make before an error is thrown. */
-    maxToolCallsPerMessage: number;
-    /** Statistics */
-    stats: {
-        /** Total tokens used this session */
-        tokensUsed: number;
-    };
-    /** Token window management */
-    tokenWindow: TokenWindow;
-    /** Token window group used for the context message */
-    get contextGroup(): TokenWindowGroup<any>;
-    /** Token window group used for tools / actions */
-    get toolGroup(): TokenWindowGroup<ChatGPTToolConfig>;
-    /** Token window group used for messages */
-    get messageGroup(): TokenWindowGroup<ChatGPTMessage>;
-    /** Constructor */
-    constructor(config: ChatGPTConfig);
-    /** Send a message, and get the response */
-    sendMessage(message: string): Promise<string>;
-    /** Insert a message as if the assistant has written it */
-    addAssistantMessage(message: string): void;
-    /** Insert a message sent from a user. Note that doing this instead of using `sendMessage()` means you'll need to manually call `await processMessages()` and then `getLatestMessage()` to get the response. */
-    addUserMessage(message: string): void;
-    /** Get all messages */
-    getMessages(): ChatGPTMessage[];
-    /** Get latest message */
-    getLatestMessage(): ChatGPTMessage | undefined;
-    /** @private Process messages in the chat history */
-    processMessages(): Promise<void>;
-    /** Trim message list */
-    trimMessages(): Promise<void>;
-    /** @private Send message list to the API and store the response */
-    sendToAPI(generatePayloadOnly?: boolean): Promise<any>;
-    /** Process incoming message from the AI. Can be used to respond to encoded actions in the text response. */
-    processIncomingMessage(message: string): void;
-    /** Register a tool. */
-    registerTool(tool: ChatGPTToolConfig): void;
-    /** @private Process a tool call request from the AI */
-    processToolCall(toolCall: any): Promise<void>;
-    /** Reset the conversation */
-    resetConversation(): void;
-}
-
-/**
- * Allows an MCP server to be used as a knowledge source for IntelliWeave.
- */
-declare class MCPKnowledgeClient {
-    /** MCP client */
-    client?: Client;
-    /** All tools discovered on the MCP server. Only available after connect() has completed. */
-    tools: Awaited<ReturnType<Client['listTools']>>['tools'];
-    /** All toold discovered, mapped to IntelliWeave knowledge base actions */
-    iwActions: KnowledgeBaseItem[];
-    /** Statistics */
-    stats: {
-        toolsCalled: number;
-    };
-    /** Configuration */
-    config: {
-        /** Source ID */
-        id?: string;
-        /** URL to the MCP server endpoint */
-        baseURL?: string;
-        /** Custom connection function. If specified, baseURL is optional. */
-        connect?: () => Promise<Client>;
-        /**
-         * The name of the tool which provides knowledge searching. If specified, the search() will exclude this function and instead
-         * call it and show returned results. If not specified, the search() will just return all tools.
-         */
-        searchToolName?: string;
-        /** Keep search function available for the AI to use. */
-        searchToolVisible?: boolean;
-    };
-    /** Constructor */
-    constructor(config: MCPKnowledgeClient['config']);
-    /** In-progress connection attempt */
-    private connectionPromise?;
-    /** Connect to the client */
-    connect(): Promise<Client<{
-        method: string;
-        params?: {
-            [x: string]: unknown;
-            _meta?: {
-                [x: string]: unknown;
-                progressToken?: string | number | undefined;
-            } | undefined;
-        } | undefined;
-    }, {
-        method: string;
-        params?: {
-            [x: string]: unknown;
-            _meta?: {
-                [x: string]: unknown;
-            } | undefined;
-        } | undefined;
-    }, {
-        [x: string]: unknown;
-        _meta?: {
-            [x: string]: unknown;
-        } | undefined;
-    }>>;
-    connectInternal(): Promise<Client<{
-        method: string;
-        params?: {
-            [x: string]: unknown;
-            _meta?: {
-                [x: string]: unknown;
-                progressToken?: string | number | undefined;
-            } | undefined;
-        } | undefined;
-    }, {
-        method: string;
-        params?: {
-            [x: string]: unknown;
-            _meta?: {
-                [x: string]: unknown;
-            } | undefined;
-        } | undefined;
-    }, {
-        [x: string]: unknown;
-        _meta?: {
-            [x: string]: unknown;
-        } | undefined;
-    }>>;
-    /** Disconnect from server */
-    disconnect(): Promise<void>;
-    /** Fetch list of tools from the MCP server */
-    private fetchTools;
-    /** Cache last search result */
-    lastSearchQuery: string;
-    lastSearchResults: KnowledgeBaseItem[];
-    /** Perform a search query */
-    search(query: string): Promise<KnowledgeBaseItem[]>;
-    /** Perform search using the configured search function */
-    private performSearchCall;
-    /** Perform tool call. */
-    private performToolCall;
-}
-
 /**
  * Register knowledge base sources and perform searches.
  */
@@ -635,7 +451,7 @@ declare class VoiceDetectionNode extends PCMReceiverNode {
     /** Loaded VAD model */
     private vad?;
     /** Sample rate */
-    get sampleRate(): 8000 | 16000;
+    get sampleRate(): 16000 | 8000;
     /** Number of samples */
     get numberOfSamples(): number;
     /** Number of sample chunks */
@@ -866,12 +682,179 @@ interface IntelliWeaveInstructConfig {
     callback?: (txt: string) => void;
 }
 
+/**
+ * This class helps organize groups of tokenized text along with removing items when the window is full.
+ */
+declare class TokenWindow {
+    /** Token window size */
+    size: number;
+    /** Token groups */
+    groups: TokenWindowGroup<any>[];
+    /** Create a new group */
+    createGroup(id: string): TokenWindowGroup<unknown>;
+    /** Get a group */
+    group<CustomDataType>(id: string): TokenWindowGroup<CustomDataType> | undefined;
+    /** Calculate current tokens in all groups */
+    countTokens(): number;
+    /** Remove overflow from all groups. */
+    removeOverflow(): void;
+    /** Remove one overflow item. Returns null if no items were able to be removed. */
+    private removeOneItem;
+}
+/** A token group. */
+declare class TokenWindowGroup<CustomDataType> {
+    /** Group ID */
+    id: string;
+    /** List of items */
+    items: TokenWindowGroupItem<CustomDataType>[];
+    /**
+     * Weight controls how many items from this group should be kept in relation to the entire window. For example if all
+     * groups have a weight of 1, each group remove items equally if full. If one has a weight of 2 while the rest are 1,
+     * that group will be allowed to keep double the amount of items.
+     */
+    weight: number;
+    /** Current total token count, computed automatically. Don't update this value manually. */
+    tokenCount: number;
+    /** Group item separator */
+    separator: string;
+    /** Token count padding added to each item. */
+    private itemPadding;
+    /** Sets the token count padding added to each item. Useful if you don't know exactly what will be added by the LLM host. */
+    setItemPadding(padding: number): this;
+    /** Sort function */
+    private sortFunction;
+    /** Set sort function */
+    sortBy(sortFunction: (a: TokenWindowGroupItem<CustomDataType>, b: TokenWindowGroupItem<CustomDataType>) => number): this;
+    /** Set separator */
+    setSeparator(separator: string): this;
+    /** Set weight */
+    setWeight(weight: number): this;
+    /** Recalculate all tokens. Note this may take a while. */
+    recalculateTokens(): void;
+    /** Add an item to the group */
+    add(item: string | Omit<Optional<TokenWindowGroupItem<CustomDataType>, 'id' | 'dateAdded' | 'sortOrder'>, 'tokenCount'>): TokenWindowGroupItem<CustomDataType>;
+    /** Get all items as a string */
+    getAllAsString(): string;
+    /** Get all items. Doesn't return disabled items. */
+    getAll(): TokenWindowGroupItem<CustomDataType>[];
+    /** Remove all items from this group */
+    empty(): void;
+}
+/** Token group item */
+interface TokenWindowGroupItem<CustomDataType> {
+    /** Each item must have a unique ID. */
+    id: string;
+    /** The string content of the item */
+    content: string;
+    /** True if this item should never be removed */
+    cannotRemove?: boolean;
+    /** Sorting order. If not specified, uses dateAdded instead. */
+    sortOrder: number;
+    /** Date this item was added */
+    dateAdded: number;
+    /** Token count in the content */
+    tokenCount: number;
+    /** Anything to attach to this item */
+    customData?: CustomDataType;
+    /** If disabled, this item will not be included and will not add tot he token count. */
+    disabled?: boolean;
+}
+
+/** Chat config options */
+interface ChatBaseConfig {
+    /** API key */
+    apiKey: string;
+    /** Provider ID */
+    providerID?: string;
+    /** Endpoint URL if using a custom URL */
+    endpoint: string;
+    /** LLM model to use */
+    model: string;
+    /** System message to describe to the AI how to behave. */
+    systemMessage: string;
+    /** User ID used to uniquely identify users in ChatGPT's API */
+    userID: string;
+    /** If true, streams the text responses from the API */
+    stream: boolean;
+    /** Amount of estimated tokens to keep when trimming */
+    maxTokens: number;
+    /** Callback before the AI sends info to the LLM */
+    onBeforeMessageProcessing?: () => void;
+    /** Callback when a message from the AI is returned. If isChunk is true, it may be incomplete and be called again with more updates. */
+    onAIMessage?: (text: string, isChunk: boolean) => void;
+    /** Callback when the AI starts performing an action */
+    onAIToolStart?: (toolName: string, input: any) => void;
+}
+/** Chat tool config */
+interface ChatBaseToolConfig {
+    /** Name of the tool, eg "perform_search" */
+    name: string;
+    /** Description of the tool */
+    description: string;
+    /** Parameters for the tool */
+    params: JSONSchema7;
+    /** Callback function to process the tool */
+    callback: (params: any) => any;
+    /** If true, this tool call will be removed from the message history after it is executed. */
+    removeFromMessageHistory?: boolean;
+    /** If true, this item can be removed if there's not enough context available. */
+    canRemove?: boolean;
+    /** Misc app context */
+    [key: string]: any;
+}
+/**
+ * API for interacting with chat APIs.
+ */
+declare class ChatBase<
+/** Format for messages in the token window */
+MessageFormat = any, 
+/** Optional extended config */
+ConfigFormat extends ChatBaseConfig = ChatBaseConfig> {
+    /** ID */
+    id: string;
+    /** Metadata */
+    metadata: any;
+    /** Config */
+    config: ConfigFormat;
+    /** The maximum tool calls in sequence the AI can make before an error is thrown. */
+    maxToolCallsPerMessage: number;
+    /** Statistics */
+    stats: {
+        /** Total tokens used this session */
+        tokensUsed: number;
+    };
+    /** Token window management */
+    tokenWindow: TokenWindow;
+    /** Token window group used for the context message */
+    get contextGroup(): TokenWindowGroup<any>;
+    /** Token window group used for tools / actions */
+    get toolGroup(): TokenWindowGroup<ChatBaseToolConfig>;
+    /** Token window group used for messages */
+    get messageGroup(): TokenWindowGroup<MessageFormat>;
+    /** Constructor */
+    constructor(config: ConfigFormat);
+    /** Send a message, and get the response */
+    sendMessage(message: string): Promise<string>;
+    /** Add a user message to the message history */
+    addUserMessage(message: string): void;
+    /** Add an assistant message to the message history */
+    addAssistantMessage(message: string): void;
+    /** Process incoming message from the AI. Can be used to respond to encoded actions in the text response. */
+    onBeforeIncomingMessage(message: MessageFormat): void;
+    /** Reset the conversation */
+    resetConversation(): void;
+    /** Trim message list */
+    trimMessages(): Promise<void>;
+    /** Register a tool. */
+    registerTool(tool: ChatBaseToolConfig): TokenWindowGroupItem<ChatBaseToolConfig>;
+}
+
 /** Persona config received from the hub */
 interface WebWeaverGPTConfig {
     /** ID */
     id: string;
-    /** ChatGPT config */
-    model: ChatGPTConfig;
+    /** Chat API config */
+    model: ChatBaseConfig;
     /** If true, message history will be sent to the IntelliWeave hub for analysis */
     analytics?: boolean;
     /** Persona name */
@@ -918,7 +901,7 @@ interface WebWeaverGPTConfig {
  * - event `webweaver_loaded` - Fired when the AI is loaded with a new configuration. This is a global event that is fired on the window object.
  * - event `webweaver_error` - Fired when an error occurs during loading. This is a global event that is fired on the window object.
  * - event `input` - Fired when the user sends a message to the AI.
- * - event `output` - Fired when the AI sends a message back to the user. If `event.detail.isChunk` is true, the message is incomplete and will be followed by more chunks.
+ * - event `output` - Fired when the AI sends a message back to the user. If `event.detail.isChunk` is true, the message is incomplete and will be followed by more events.
  * - event `toolstart` - Fired when the AI starts performing an action.
  * - event `tool` - Fired when the AI finishes performing an action.
  */
@@ -928,7 +911,7 @@ declare class IntelliWeave extends EventTarget {
     /** Callback when a message from the AI is returned. If isChunk is true, it may be incomplete and be called again with more updates. */
     onAIMessage?: (text: string, isChunk: boolean) => void;
     /** Callback when the AI starts performing an action */
-    onAIToolStart?: ChatGPTConfig['onAIToolStart'];
+    onAIToolStart?: ChatBaseConfig['onAIToolStart'];
     /** Current conversation ID */
     conversationID: string;
     /** Knowledge database interface */
@@ -944,11 +927,11 @@ declare class IntelliWeave extends EventTarget {
     /** Available LLMs */
     models: {
         id: string;
-        config: ChatGPTConfig;
+        config: ChatBaseConfig;
         priority?: number;
     }[];
     /** Current LLM */
-    currentModel?: ChatGPT;
+    currentModel?: ChatBase;
     /** The audio system. Set this to a new instance of AudioSystem to enable audio support */
     audio: AudioSystem | null;
     /** Silero VAD model blob */
@@ -978,7 +961,6 @@ declare class IntelliWeave extends EventTarget {
     getContextPrefix(): Promise<string>;
     /** Get system message to send to the AI */
     onBeforeMessageProcessing(): Promise<void>;
-    private _lastOutput?;
     /** @private Process incoming message from the AI. Can be used to respond to encoded actions in the text response. */
     processIncomingMessage(message: string, isChunk?: boolean): void;
     /** True if currently processing a message */
@@ -999,7 +981,7 @@ declare class IntelliWeave extends EventTarget {
     exportState(): {
         type: string;
         conversationID: string;
-        messages: (ChatGPTMessage | undefined)[] | undefined;
+        messages: any[] | undefined;
     };
     /** Import conversation state from JSON */
     importState(state: any): void;
@@ -1106,6 +1088,8 @@ declare class WebWeaverEmbed extends BaseComponent {
     resetConversation(): void;
     /** True if busy processing */
     private _isProcessing;
+    /** The element which will receive the current message from the AI */
+    currentOutputElement?: HTMLElement;
     /** Process input text from the user */
     processInput(inputText: string): Promise<void>;
     /** Called when the AI responds with some text */