@rimori/client 1.1.9 → 1.2.0

package/dist/cli/scripts/release/release-config-upload.d.ts

@@ -0,0 +1,7 @@
+import { Config } from './release.js';
+/**
+ * Read and send the rimori configuration to the release endpoint
+ * @param config - Configuration object
+ */
+export declare function sendConfiguration(config: Config): Promise<string>;
+export declare function releasePlugin(config: Config, release_id: string): Promise<void>;

package/dist/cli/scripts/release/release-config-upload.js

@@ -0,0 +1,116 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import fs from 'fs';
+import path from 'path';
+import ts from 'typescript';
+/**
+ * Read and send the rimori configuration to the release endpoint
+ * @param config - Configuration object
+ */
+export function sendConfiguration(config) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const configPath = path.resolve('./rimori/rimori.config.ts');
+        // Check if config file exists
+        try {
+            yield fs.promises.access(configPath);
+        }
+        catch (e) {
+            throw new Error('Could not find rimori.config.ts in ./rimori/ directory');
+        }
+        try {
+            let configObject;
+            // Use TypeScript compiler to transpile and load
+            const configContent = yield fs.promises.readFile(configPath, 'utf8');
+            // Transpile TypeScript to JavaScript
+            const result = ts.transpile(configContent, {
+                target: ts.ScriptTarget.ES2020,
+                module: ts.ModuleKind.ES2020
+            });
+            // Create a temporary file to import the transpiled code
+            const tempFile = path.join(process.cwd(), 'temp_config.js');
+            yield fs.promises.writeFile(tempFile, result);
+            try {
+                // Use dynamic import to load the config
+                const config = yield import(`file://${tempFile}`);
+                configObject = config.default || config;
+                // Clean up temp file
+                yield fs.promises.unlink(tempFile);
+            }
+            catch (error) {
+                // Clean up temp file even on error
+                try {
+                    yield fs.promises.unlink(tempFile);
+                }
+                catch (e) { }
+                throw error;
+            }
+            if (!configObject) {
+                throw new Error('Configuration object is empty or undefined');
+            }
+            console.log(`🚀 Sending configuration...`);
+            const requestBody = {
+                config: configObject,
+                version: config.version,
+                plugin_id: config.plugin_id,
+                release_channel: config.release_channel,
+                rimori_client_version: config.rimori_client_version,
+            };
+            try {
+                const response = yield fetch(`${config.domain}/release`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'Authorization': `Bearer ${config.token}`
+                    },
+                    body: JSON.stringify(requestBody),
+                });
+                const responseText = yield response.text();
+                console.log('Configuration response status:', response.status);
+                console.log('Configuration response text:', responseText);
+                const responseData = JSON.parse(responseText);
+                if (response.ok) {
+                    console.log('✅ Configuration deployed successfully!');
+                    return responseData.release_id;
+                }
+                else {
+                    console.log('❌ Configuration failed!');
+                    console.log('Error:', responseData.error || 'Unknown error');
+                    console.log('Response data:', JSON.stringify(responseData, null, 2));
+                    throw new Error('Configuration upload failed');
+                }
+            }
+            catch (e) {
+                console.log("error", e);
+                throw new Error("Error sending configuration");
+            }
+        }
+        catch (error) {
+            console.error('❌ Error sending configuration:', error.message);
+            throw error;
+        }
+    });
+}
+export function releasePlugin(config, release_id) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const response = yield fetch(`${config.domain}/release/${release_id}/release`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${config.token}`
+            },
+            body: JSON.stringify({ plugin_id: config.plugin_id })
+        });
+        if (!response.ok) {
+            console.log("Response:", yield response.text());
+            throw new Error("Failed to release plugin");
+        }
+        console.log("✅ Plugin released successfully");
+    });
+}

package/dist/cli/scripts/release/release-db-update.d.ts

@@ -0,0 +1,6 @@
+import { Config } from "./release";
+/**
+ * Read and send the database configuration to the release endpoint
+ * @param config - Configuration object
+ */
+export default function dbUpdate(config: Config, release_id: string): Promise<void>;

package/dist/cli/scripts/release/release-db-update.js

@@ -0,0 +1,100 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import fs from 'fs';
+import path from 'path';
+import ts from 'typescript';
+/**
+ * Read and send the database configuration to the release endpoint
+ * @param config - Configuration object
+ */
+export default function dbUpdate(config, release_id) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const dbConfigPath = path.resolve('./rimori/db.config.ts');
+        // Check if db config file exists
+        try {
+            yield fs.promises.access(dbConfigPath);
+        }
+        catch (e) {
+            console.warn('Could not find db.config.ts in ./rimori/ directory. Skipping database configuration upload.');
+            return;
+        }
+        try {
+            let dbConfigObject;
+            // Use TypeScript compiler to transpile and load
+            const dbConfigContent = yield fs.promises.readFile(dbConfigPath, 'utf8');
+            // Transpile TypeScript to JavaScript
+            const result = ts.transpile(dbConfigContent, {
+                target: ts.ScriptTarget.ES2020,
+                module: ts.ModuleKind.ES2020
+            });
+            // Create a temporary file to import the transpiled code
+            const tempFile = path.join(process.cwd(), 'temp_db_config.js');
+            yield fs.promises.writeFile(tempFile, result);
+            try {
+                // Use dynamic import to load the db config
+                const dbConfig = yield import(`file://${tempFile}`);
+                dbConfigObject = Object.values(dbConfig);
+                // Clean up temp file
+                yield fs.promises.unlink(tempFile);
+            }
+            catch (error) {
+                // Clean up temp file even on error
+                try {
+                    yield fs.promises.unlink(tempFile);
+                }
+                catch (e) { }
+                throw error;
+            }
+            if (!dbConfigObject) {
+                throw new Error('Database configuration object is empty or undefined');
+            }
+            console.log(`🗄️ Sending database configuration...`);
+            const requestBody = {
+                db_config: dbConfigObject,
+                version: config.version,
+                release_channel: config.release_channel,
+                plugin_id: config.plugin_id,
+            };
+            const response = yield fetch(`${config.domain}/release/${release_id}/db`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': `Bearer ${config.token}`
+                },
+                body: JSON.stringify(requestBody),
+            }).catch((e) => {
+                console.log("error", e);
+                throw new Error("Error sending database configuration");
+            });
+            try {
+                const responseText = yield response.text().catch((e) => {
+                    console.log("error", e);
+                    throw new Error("Error sending database configuration");
+                });
+                const responseData = JSON.parse(responseText);
+                if (response.ok) {
+                    console.log('✅ Database configuration deployed successfully!');
+                }
+                else {
+                    console.log("responseData", responseData);
+                    throw new Error(responseData.message);
+                }
+            }
+            catch (e) {
+                console.log("error", e);
+                throw new Error("Error sending database configuration");
+            }
+        }
+        catch (error) {
+            console.error('❌ Error sending database configuration:', error.message);
+            throw error;
+        }
+    });
+}

package/dist/cli/scripts/release/release-file-upload.d.ts

@@ -0,0 +1,6 @@
+import { Config } from './release.js';
+/**
+ * Upload all files from a directory and its subdirectories to the release function
+ * @param config - Configuration object
+ */
+export declare function uploadDirectory(config: Config, release_id: string): Promise<void>;

package/dist/cli/scripts/release/release-file-upload.js

@@ -0,0 +1,136 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import fs from 'fs';
+import path from 'path';
+/**
+ * Upload all files from a directory and its subdirectories to the release function
+ * @param config - Configuration object
+ */
+export function uploadDirectory(config, release_id) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const relativePath = './dist';
+        console.log(`📁 Preparing to upload files from ${relativePath}...`);
+        // Check if dist directory exists
+        try {
+            yield fs.promises.access(relativePath);
+        }
+        catch (e) {
+            throw new Error(`Directory ${relativePath} does not exist. Make sure to build your plugin first.`);
+        }
+        // Get all files recursively
+        const files = yield getAllFiles(relativePath);
+        if (files.length === 0) {
+            console.log('⚠️ No files found to upload');
+            return;
+        }
+        console.log(`🚀 Uploading ${files.length} files...`);
+        // Create FormData
+        const formData = new FormData();
+        // Add version and release channel data
+        formData.append('version', config.version);
+        formData.append('release_channel', config.release_channel);
+        formData.append('plugin_id', config.plugin_id);
+        // Create path mapping with IDs as keys
+        const pathMapping = {};
+        for (let i = 0; i < files.length; i++) {
+            const filePath = files[i];
+            try {
+                const fileContent = yield fs.promises.readFile(filePath);
+                const relativePath = path.relative('./dist', filePath);
+                const contentType = getContentType(filePath);
+                // Generate unique ID for this file
+                const fileId = `file_${i}`;
+                // Add to path mapping using ID as key
+                pathMapping[fileId] = relativePath;
+                // Create a Blob with the file content and content type
+                const blob = new Blob([fileContent], { type: contentType });
+                // Add file to FormData with ID_filename format
+                const fileName = `${fileId}_${path.basename(filePath)}`;
+                formData.append('files', blob, fileName);
+            }
+            catch (error) {
+                console.error(`❌ Error reading file ${filePath}:`, error.message);
+                throw error;
+            }
+        }
+        // Add path mapping to FormData
+        formData.append('path_mapping', JSON.stringify(pathMapping));
+        // Upload to the release endpoint
+        const response = yield fetch(`${config.domain}/release/${release_id}/files`, {
+            method: 'POST',
+            headers: { 'Authorization': `Bearer ${config.token}` },
+            body: formData,
+        });
+        if (response.ok) {
+            console.log('✅ Files uploaded successfully!');
+        }
+        else {
+            const errorText = yield response.text();
+            console.log('❌ File upload failed!');
+            console.log('Response:', errorText);
+            throw new Error(`File upload failed with status ${response.status}`);
+        }
+    });
+}
+/**
+ * Recursively get all files from a directory
+ */
+function getAllFiles(dirPath) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const files = [];
+        function traverse(currentPath) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const entries = yield fs.promises.readdir(currentPath, { withFileTypes: true });
+                for (const entry of entries) {
+                    const fullPath = path.join(currentPath, entry.name);
+                    if (entry.isDirectory()) {
+                        yield traverse(fullPath);
+                    }
+                    else if (entry.isFile()) {
+                        files.push(fullPath);
+                    }
+                }
+            });
+        }
+        yield traverse(dirPath);
+        return files;
+    });
+}
+/**
+ * Get content type based on file extension
+ */
+function getContentType(filePath) {
+    var _a;
+    const ext = (_a = filePath.split('.').pop()) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+    const contentTypes = {
+        html: 'text/html',
+        css: 'text/css',
+        js: 'application/javascript',
+        json: 'application/json',
+        md: 'text/markdown',
+        txt: 'text/plain',
+        png: 'image/png',
+        jpg: 'image/jpeg',
+        jpeg: 'image/jpeg',
+        gif: 'image/gif',
+        svg: 'image/svg+xml',
+        pdf: 'application/pdf',
+        ico: 'image/x-icon',
+        mp3: 'audio/mpeg',
+        wav: 'audio/wav',
+        ogg: 'audio/ogg',
+        m4a: 'audio/mp4',
+        webp: 'image/webp',
+    };
+    const contentType = contentTypes[ext || ''];
+    if (!contentType)
+        throw new Error(`Unsupported file type: ${ext}`);
+    return contentType;
+}

package/dist/cli/scripts/release/release.d.ts

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+/**
+ * Usage:
+ *   rimori-release <release_channel>
+ *
+ * Environment variables required:
+ *   RIMORI_TOKEN      - Your Rimori token
+ *   RIMORI_PLUGIN  - Your plugin ID
+ *
+ * Make sure to install dependencies:
+ *   npm install node-fetch form-data ts-node typescript
+ */
+import 'dotenv/config';
+declare const config: {
+    version: any;
+    release_channel: string;
+    plugin_id: any;
+    token: string;
+    domain: string;
+    rimori_client_version: any;
+};
+export type Config = typeof config;
+export {};

package/dist/cli/scripts/release/release.js

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+/**
+ * Usage:
+ *   rimori-release <release_channel>
+ *
+ * Environment variables required:
+ *   RIMORI_TOKEN      - Your Rimori token
+ *   RIMORI_PLUGIN  - Your plugin ID
+ *
+ * Make sure to install dependencies:
+ *   npm install node-fetch form-data ts-node typescript
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import 'dotenv/config';
+import fs from 'fs';
+import path from 'path';
+import dbUpdate from './release-db-update.js';
+import { uploadDirectory } from './release-file-upload.js';
+import { releasePlugin, sendConfiguration } from './release-config-upload.js';
+// Read version from package.json
+const packageJson = JSON.parse(fs.readFileSync(path.resolve('./package.json'), 'utf8'));
+const { version, r_id: pluginId } = packageJson;
+const RIMORI_TOKEN = process.env.RIMORI_TOKEN;
+if (!RIMORI_TOKEN)
+    throw new Error('RIMORI_TOKEN is not set');
+if (!pluginId)
+    throw new Error('The plugin id (r_id) is not set in package.json');
+const [releaseChannel] = process.argv.slice(2);
+if (!releaseChannel) {
+    console.error('Usage: rimori-release <release_channel>');
+    process.exit(1);
+}
+const config = {
+    version,
+    release_channel: releaseChannel,
+    plugin_id: pluginId,
+    token: RIMORI_TOKEN,
+    domain: process.env.RIMORI_BACKEND_URL || "https://api.rimori.se",
+    rimori_client_version: packageJson.dependencies['@rimori/client'].replace('^', ''),
+};
+/**
+ * Main release process
+ */
+function releaseProcess() {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            console.log(`🚀 Releasing ${config.plugin_id} to ${config.release_channel}...`);
+            // First send the configuration
+            const release_id = yield sendConfiguration(config);
+            yield dbUpdate(config, release_id);
+            // Then upload the files
+            yield uploadDirectory(config, release_id);
+            // Then release the plugin
+            yield releasePlugin(config, release_id);
+        }
+        catch (error) {
+            console.log("❌ Error:", error.message);
+            process.exit(1);
+        }
+    });
+}
+releaseProcess();

package/dist/cli/types/DatabaseTypes.d.ts

@@ -0,0 +1,103 @@
+/**
+ * Supported database column data types for table schema definitions.
+ */
+type DbColumnType = 'decimal' | 'integer' | 'text' | 'boolean' | 'json' | 'timestamp' | 'uuid';
+/**
+ * Foreign key relationship configuration with cascade delete support.
+ * Defines a relationship where the source record is deleted when the destination record is deleted.
+ */
+interface ForeignKeyRelation {
+    /** The target table that this column references */
+    references_table: string;
+    /** The target column in the referenced table (defaults to 'id') */
+    references_column?: string;
+    /** Whether to cascade delete when the referenced record is deleted */
+    on_delete_cascade: boolean;
+}
+/**
+ * Database column definition with support for types, constraints, and relationships.
+ */
+export interface DbColumnDefinition {
+    /** The data type of the column */
+    type: DbColumnType;
+    /** Human-readable description of the column's purpose */
+    description: string;
+    /** Whether the column can contain null values */
+    nullable?: boolean;
+    /** Whether the column has a unique constraint */
+    unique?: boolean;
+    /** Default value for the column. can also use sql functions like now(), auth.uid() or gen_random_uuid() */
+    default_value?: string | number | boolean;
+    /** Array of allowed values for enumerated columns */
+    /** Foreign key relationship configuration */
+    foreign_key?: ForeignKeyRelation;
+    /** The name of the column before it was renamed. */
+    old_name?: string;
+    /** Whether the column is deprecated. The column gets renamed to column_name_old. To fully remove the column, first set deprecated to true and then after a release, remove the column from the table definition. */
+    deprecated?: boolean;
+    /** Whether the column is a primary key */
+    /** Restrictions for the column. If the column is restricted, the permission is further restricted. E.g. if the column is restricted to user, then the user can only read the column if they have the right permission.
+     * Example: Denying users to update the column, but allowing the moderator to update the column.
+    */
+    restrict?: {
+        /** Restrictions for the user */
+        user: Partial<Omit<DbPermissionDefinition, 'delete'>>;
+        /** Restrictions for the moderator */
+        moderator?: Partial<Omit<DbPermissionDefinition, 'delete'>>;
+    };
+}
+/**
+ * Base table structure that all database tables inherit.
+ * Includes standard audit fields for tracking creation and ownership.
+ */
+interface BaseTableStructure {
+    /** Unique identifier for the record */
+    id: DbColumnDefinition;
+    /** Timestamp when the record was created */
+    created_at: DbColumnDefinition;
+    /** ID of the user who created the record */
+    created_by: DbColumnDefinition;
+}
+/**
+ * Complete database table schema definition.
+ * Defines the structure, constraints, and relationships for a database table.
+ */
+export interface DbTableDefinition {
+    /** Name of the database table */
+    table_name: string;
+    /** Description of the table's purpose and usage */
+    description: string;
+    /** Permissions for the table */
+    permissions: {
+        user: DbPermissionDefinition;
+        moderator?: DbPermissionDefinition;
+    };
+    /** Column definitions for the table */
+    columns: {
+        [column_name: string]: DbColumnDefinition;
+    };
+}
+/**
+ * Permission definition for a database table.
+ * NONE means the action is not allowed.
+ * OWN means only do the action on your own records.
+ * ALL means do the action on all records.
+ *
+ * Defines the permissions for a database table.
+ */
+export type DbPermission = "NONE" | "OWN" | "ALL";
+/**
+ * Permission definition for a database table.
+ * Defines the permissions for a database table.
+ */
+export interface DbPermissionDefinition {
+    read: DbPermission;
+    insert: DbPermission;
+    update: DbPermission;
+    delete: DbPermission;
+}
+/**
+ * Full table definition that includes automatically generated fields.
+ */
+export type FullTable<T extends Record<string, DbColumnDefinition>> = T & BaseTableStructure;
+export {};

package/dist/cli/types/DatabaseTypes.js

@@ -0,0 +1,2 @@
+// Database table structure definitions
+export {};

package/dist/components/ai/Assistant.js

@@ -10,7 +10,7 @@ import { getFirstMessages } from './utils';
 export function AssistantChat({ avatarImageUrl, voiceId, onComplete, autoStartConversation }) {
     var _a;
     const [oralCommunication, setOralCommunication] = React.useState(true);
-    const { llm, event } = usePlugin();
+    const { ai: llm, event } = usePlugin();
     const sender = useMemo(() => new MessageSender(llm.getVoice, voiceId), []);
     const { messages, append, isLoading, setMessages } = useChat();
     const lastAssistantMessage = (_a = [...messages].filter((m) => m.role === 'assistant').pop()) === null || _a === void 0 ? void 0 : _a.content;
@@ -37,15 +37,15 @@ export function AssistantChat({ avatarImageUrl, voiceId, onComplete, autoStartCo
     const lastMessage = messages[messages.length - 1];
     useEffect(() => {
         console.log("lastMessage", lastMessage);
-        const toolInvocations = lastMessage === null || lastMessage === void 0 ? void 0 : lastMessage.toolInvocations;
+        const toolInvocations = lastMessage === null || lastMessage === void 0 ? void 0 : lastMessage.toolCalls;
         if (toolInvocations && toolInvocations.length > 0) {
             console.log("toolInvocations", toolInvocations);
             onComplete(toolInvocations[0].args);
         }
     }, [lastMessage]);
-    if ((lastMessage === null || lastMessage === void 0 ? void 0 : lastMessage.toolInvocations) && lastMessage.toolInvocations.length > 0) {
+    if ((lastMessage === null || lastMessage === void 0 ? void 0 : lastMessage.toolCalls) && lastMessage.toolCalls.length > 0) {
         console.log("lastMessage test2", lastMessage);
-        const args = lastMessage.toolInvocations[0].args;
+        const args = lastMessage.toolCalls[0].args;
         const success = args.explanationUnderstood === "TRUE" || args.studentKnowsTopic === "TRUE";
         return _jsxs("div", { className: "px-5 pt-5 overflow-y-auto text-center", style: { height: "478px" }, children: [_jsx("h1", { className: 'text-center mt-5 mb-5', children: success ? "Great job!" : "You failed" }), _jsx("p", { children: args.improvementHints })] });
     }

package/dist/components/ai/Avatar.d.ts

@@ -1,4 +1,4 @@
-import { Tool } from '../../controller/AIController';
+import { Tool } from '../../fromRimori/PluginTypes';
 import { FirstMessages } from './utils';
 interface Props {
     voiceId: any;
@@ -8,6 +8,7 @@ interface Props {
     isDarkTheme?: boolean;
     children?: React.ReactNode;
     autoStartConversation?: FirstMessages;
+    className?: string;
 }
-export declare function Avatar({ avatarImageUrl, voiceId, agentTools, autoStartConversation, children, isDarkTheme, circleSize }: Props): import("react/jsx-runtime").JSX.Element;
+export declare function Avatar({ avatarImageUrl, voiceId, agentTools, autoStartConversation, children, isDarkTheme, circleSize, className }: Props): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/components/ai/Avatar.js

@@ -6,11 +6,11 @@ import { CircleAudioAvatar } from './EmbeddedAssistent/CircleAudioAvatar';
 import { useChat } from '../../hooks/UseChatHook';
 import { usePlugin } from '../../components';
 import { getFirstMessages } from './utils';
-export function Avatar({ avatarImageUrl, voiceId, agentTools, autoStartConversation, children, isDarkTheme = false, circleSize = "300px" }) {
-    const { llm, event } = usePlugin();
+export function Avatar({ avatarImageUrl, voiceId, agentTools, autoStartConversation, children, isDarkTheme = false, circleSize = "300px", className }) {
+    const { ai, event } = usePlugin();
     const [agentReplying, setAgentReplying] = useState(false);
     const [isProcessingMessage, setIsProcessingMessage] = useState(false);
-    const sender = useMemo(() => new MessageSender(llm.getVoice, voiceId), []);
+    const sender = useMemo(() => new MessageSender(ai.getVoice, voiceId), [voiceId]);
     const { messages, append, isLoading, lastMessage, setMessages } = useChat(agentTools);
     useEffect(() => {
         console.log("messages", messages);
@@ -33,13 +33,18 @@ export function Avatar({ avatarImageUrl, voiceId, agentTools, autoStartConversat
         else if (autoStartConversation.userMessage) {
             append([{ role: 'user', content: autoStartConversation.userMessage, id: messages.length.toString() }]);
         }
-    }, []);
+    }, [autoStartConversation]);
     useEffect(() => {
         if ((lastMessage === null || lastMessage === void 0 ? void 0 : lastMessage.role) === 'assistant') {
             sender.handleNewText(lastMessage.content, isLoading);
+            if (lastMessage.toolCalls) {
+                console.log("unlocking mic", lastMessage);
+                setAgentReplying(false);
+                setIsProcessingMessage(false);
+            }
         }
     }, [lastMessage, isLoading]);
-    return (_jsxs("div", { className: 'pb-8', children: [_jsx(CircleAudioAvatar, { width: circleSize, className: 'mx-auto', imageUrl: avatarImageUrl, isDarkTheme: isDarkTheme }), children, _jsx(VoiceRecorder, { iconSize: '300', disabled: agentReplying, loading: isProcessingMessage, onVoiceRecorded: (message) => {
+    return (_jsxs("div", { className: `md:pb-8 ${className || ''}`, children: [_jsx(CircleAudioAvatar, { width: circleSize, className: 'mx-auto', imageUrl: avatarImageUrl, isDarkTheme: isDarkTheme }), children, _jsx(VoiceRecorder, { iconSize: '30', className: 'w-16 h-16 shadow-lg rounded-full bg-gray-400 dark:bg-gray-800', disabled: agentReplying, loading: isProcessingMessage, enablePushToTalk: true, onVoiceRecorded: (message) => {
                     setAgentReplying(true);
                     append([{ role: 'user', content: "Message(" + Math.floor((messages.length + 1) / 2) + "): " + message, id: messages.length.toString() }]);
                 }, onRecordingStatusChange: (running) => !running && setIsProcessingMessage(true) })] }));

package/dist/components/ai/EmbeddedAssistent/CircleAudioAvatar.js

@@ -1,6 +1,6 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { useEffect, useRef } from 'react';
-import { EventBus } from '../../../plugin/fromRimori/EventBus';
+import { EventBus } from '../../../fromRimori/EventBus';
 export function CircleAudioAvatar({ imageUrl, className, isDarkTheme = false, width = "150px" }) {
     const canvasRef = useRef(null);
     const currentLoudnessRef = useRef(0);