@rimori/react-client 0.1.0 → 0.2.0

package/dist/react-client/src/hooks/I18nHooks.d.ts

@@ -1,11 +0,0 @@
-import { TOptions } from '@rimori/client';
-type TranslatorFn = (key: string, options?: TOptions) => string;
-/**
- * Custom useTranslation hook that provides a translation function and indicates readiness
- * @returns An object containing the translation function (`t`) and a boolean (`ready`) indicating if the translator is initialized.
- */
-export declare function useTranslation(): {
-    t: TranslatorFn;
-    ready: boolean;
-};
-export {};

package/dist/react-client/src/hooks/I18nHooks.js

@@ -1,25 +0,0 @@
-import { useEffect, useState } from 'react';
-import { useRimori } from '../providers/PluginProvider';
-/**
- * Custom useTranslation hook that provides a translation function and indicates readiness
- * @returns An object containing the translation function (`t`) and a boolean (`ready`) indicating if the translator is initialized.
- */
-export function useTranslation() {
-    const { plugin } = useRimori();
-    const [translatorInstance, setTranslatorInstance] = useState(null);
-    useEffect(() => {
-        void plugin.getTranslator().then(setTranslatorInstance);
-    }, [plugin]);
-    const safeT = (key, options) => {
-        // return zero-width space if translator is not initialized to keep text space occupied
-        if (!translatorInstance)
-            return '\u200B'; // zero-width space
-        const result = translatorInstance.t(key, options);
-        if (!result) {
-            console.error(`Translation key not found: ${key}`);
-            return '\u200B'; // zero-width space
-        }
-        return result;
-    };
-    return { t: safeT, ready: translatorInstance !== null };
-}

package/dist/react-client/src/hooks/UseChatHook.d.ts

@@ -1,10 +0,0 @@
-import React from 'react';
-import { Tool } from '@rimori/client';
-import { Message } from '@rimori/client';
-export declare function useChat(tools?: Tool[]): {
-    messages: Message[];
-    append: (appendMessages: Message[]) => void;
-    isLoading: boolean;
-    setMessages: React.Dispatch<React.SetStateAction<Message[]>>;
-    lastMessage: Message | undefined;
-};

package/dist/react-client/src/hooks/UseChatHook.js

@@ -1,29 +0,0 @@
-import React from 'react';
-import { useRimori } from '../providers/PluginProvider';
-export function useChat(tools) {
-    const [messages, setMessages] = React.useState([]);
-    const [isLoading, setIsLoading] = React.useState(false);
-    const { ai } = useRimori();
-    const append = (appendMessages) => {
-        const allMessages = [...messages, ...appendMessages];
-        setMessages(allMessages);
-        ai.getSteamedText(allMessages, (id, message, finished, toolInvocations) => {
-            const lastMessage = messages[messages.length - 1];
-            setIsLoading(!finished);
-            if ((lastMessage === null || lastMessage === void 0 ? void 0 : lastMessage.id) === id) {
-                lastMessage.content = message;
-                setMessages([...messages, lastMessage]);
-            }
-            else {
-                setMessages([...allMessages, { id, role: 'assistant', content: message, toolCalls: toolInvocations }]);
-            }
-        }, tools);
-    };
-    return {
-        messages,
-        append,
-        isLoading,
-        setMessages,
-        lastMessage: messages[messages.length - 1],
-    };
-}

package/dist/react-client/src/plugin/ThemeSetter.js

@@ -1,19 +0,0 @@
-export function setTheme(theme) {
-    document.documentElement.classList.add('dark:text-gray-200');
-    if (isDarkTheme(theme)) {
-        document.documentElement.setAttribute('data-theme', 'dark');
-        document.documentElement.classList.add('dark', 'dark:bg-gray-950');
-        document.documentElement.style.background = 'hsl(var(--background))';
-    }
-}
-export function isDarkTheme(theme) {
-    // If no theme provided, try to get from URL as fallback (for standalone mode)
-    if (!theme) {
-        const urlParams = new URLSearchParams(window.location.search);
-        theme = urlParams.get('theme');
-    }
-    if (!theme || theme === 'system') {
-        return window.matchMedia && window.matchMedia('(prefers-color-scheme: dark)').matches;
-    }
-    return theme === 'dark';
-}

package/dist/react-client/src/providers/PluginProvider.d.ts

@@ -1,12 +0,0 @@
-import React, { ReactNode } from 'react';
-import { RimoriClient } from '@rimori/client';
-interface PluginProviderProps {
-    children: ReactNode;
-    pluginId: string;
-    settings?: {
-        disableContextMenu?: boolean;
-    };
-}
-export declare const PluginProvider: React.FC<PluginProviderProps>;
-export declare const useRimori: () => RimoriClient;
-export {};

package/dist/react-client/src/providers/PluginProvider.js

@@ -1,142 +0,0 @@
-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 { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { createContext, useContext, useEffect, useState } from 'react';
-import { EventBusHandler, RimoriClient, StandaloneClient } from '@rimori/client';
-import ContextMenu from '../components/ContextMenu';
-const PluginContext = createContext(null);
-export const PluginProvider = ({ children, pluginId, settings }) => {
-    const [plugin, setPlugin] = useState(null);
-    const [standaloneClient, setStandaloneClient] = useState(false);
-    const [applicationMode, setApplicationMode] = useState(null);
-    const [theme, setTheme] = useState(null);
-    const isSidebar = applicationMode === 'sidebar';
-    const isSettings = applicationMode === 'settings';
-    useEffect(() => {
-        initEventBus(pluginId);
-        // Check if we're in an iframe context - if not, we're standalone
-        const standaloneDetected = window === window.parent;
-        if (standaloneDetected && !standaloneClient) {
-            StandaloneClient.getInstance().then((client) => {
-                client.needsLogin().then((needLogin) => setStandaloneClient(needLogin ? client : true));
-            });
-        }
-        if ((!standaloneDetected && !plugin) || (standaloneDetected && standaloneClient === true)) {
-            RimoriClient.getInstance(pluginId).then((client) => {
-                setPlugin(client);
-                // Get applicationMode and theme from MessageChannel query params
-                if (!standaloneDetected) {
-                    const mode = client.getQueryParam('applicationMode');
-                    const themeParam = client.getQueryParam('rm_theme');
-                    setApplicationMode(mode);
-                    setTheme(themeParam);
-                }
-            });
-        }
-    }, [pluginId, standaloneClient]);
-    //route change
-    useEffect(() => {
-        if (!plugin)
-            return;
-        //sidebar pages should not report url changes
-        if (isSidebar)
-            return;
-        let lastHash = window.location.hash;
-        const emitUrlChange = (url) => plugin.event.emit('session.triggerUrlChange', { url });
-        const interval = setInterval(() => {
-            if (lastHash === window.location.hash)
-                return;
-            lastHash = window.location.hash;
-            // console.log('url changed:', lastHash);
-            emitUrlChange(lastHash);
-        }, 1000);
-        emitUrlChange(lastHash);
-        return () => clearInterval(interval);
-    }, [plugin]);
-    if (standaloneClient instanceof StandaloneClient) {
-        return (_jsx(StandaloneAuth, { onLogin: (email, password) => __awaiter(void 0, void 0, void 0, function* () {
-                if (yield standaloneClient.login(email, password))
-                    setStandaloneClient(true);
-            }) }));
-    }
-    if (!plugin) {
-        return '';
-    }
-    return (_jsxs(PluginContext.Provider, { value: plugin, children: [!(settings === null || settings === void 0 ? void 0 : settings.disableContextMenu) && !isSidebar && !isSettings && _jsx(ContextMenu, { client: plugin }), children] }));
-};
-export const useRimori = () => {
-    const context = useContext(PluginContext);
-    if (context === null) {
-        throw new Error('useRimori must be used within an PluginProvider');
-    }
-    return context;
-};
-function getUrlParam(name) {
-    // First try to get from URL hash query params (for compatibility)
-    const hashParts = window.location.hash.split('?');
-    if (hashParts.length > 1) {
-        const hashParams = new URLSearchParams(hashParts[1]);
-        const hashValue = hashParams.get(name);
-        if (hashValue)
-            return hashValue;
-    }
-    // Fallback to regular URL search params
-    const url = new URL(window.location.href);
-    return url.searchParams.get(name);
-}
-function initEventBus(pluginId) {
-    // For now, use URL fallback for EventBus naming - this will be updated once MessageChannel is ready
-    const isSidebar = getUrlParam('applicationMode') === 'sidebar';
-    EventBusHandler.getInstance('Plugin EventBus ' + pluginId + ' ' + (isSidebar ? 'sidebar' : 'main'));
-}
-function StandaloneAuth({ onLogin }) {
-    const [user, setUser] = useState('');
-    const [password, setPassword] = useState('');
-    return (_jsx("div", { style: {
-            position: 'fixed',
-            inset: 0,
-            display: 'flex',
-            alignItems: 'center',
-            justifyContent: 'center',
-            backgroundColor: 'rgba(0, 0, 0, 0.5)',
-        }, children: _jsxs("div", { style: {
-                backgroundColor: '#343534',
-                padding: '1rem',
-                borderRadius: '0.5rem',
-                width: '500px',
-                flexDirection: 'column',
-                display: 'flex',
-                alignItems: 'center',
-                justifyContent: 'center',
-            }, children: [_jsx("p", { style: { fontSize: '2rem', fontWeight: 'bold', marginBottom: '1rem', textAlign: 'center' }, children: "Rimori Login" }), _jsx("p", { style: { marginBottom: '1rem', textAlign: 'center' }, children: "Please login with your Rimori developer account for this plugin to be able to access the Rimori platform the same it will operate in the Rimori platform." }), _jsx("input", { style: {
-                        marginBottom: '1rem',
-                        width: '100%',
-                        padding: '0.5rem',
-                        borderRadius: '0.5rem',
-                        border: 'none',
-                        backgroundColor: '#444444',
-                    }, type: "email", placeholder: "Email", onChange: (e) => setUser(e.target.value) }), _jsx("input", { style: {
-                        marginBottom: '1rem',
-                        width: '100%',
-                        padding: '0.5rem',
-                        borderRadius: '0.5rem',
-                        border: 'none',
-                        backgroundColor: '#444444',
-                    }, type: "password", placeholder: "Password", onChange: (e) => setPassword(e.target.value) }), _jsx("button", { style: {
-                        marginBottom: '1rem',
-                        width: '100%',
-                        padding: '0.5rem',
-                        borderRadius: '0.5rem',
-                        border: 'none',
-                        backgroundColor: '#928358',
-                    }, onClick: () => {
-                        onLogin(user, password);
-                    }, children: "Login" })] }) }));
-}

package/dist/react-client/src/utils/PluginUtils.d.ts

@@ -1,2 +0,0 @@
-export declare function isFullscreen(): boolean;
-export declare function triggerFullscreen(onStateChange: (isFullscreen: boolean) => void, selector?: string): void;

package/dist/react-client/src/utils/PluginUtils.js

@@ -1,23 +0,0 @@
-export function isFullscreen() {
-    return !!document.fullscreenElement;
-}
-export function triggerFullscreen(onStateChange, selector) {
-    document.addEventListener('fullscreenchange', () => {
-        onStateChange(isFullscreen());
-    });
-    try {
-        const ref = document.querySelector(selector || '#root');
-        if (!isFullscreen()) {
-            // @ts-ignore
-            ref.requestFullscreen() || ref.webkitRequestFullscreen();
-        }
-        else {
-            // @ts-ignore
-            document.exitFullscreen() || document.webkitExitFullscreen();
-        }
-    }
-    catch (error) {
-        console.error('Failed to enter fullscreen', error.message);
-    }
-    onStateChange(isFullscreen());
-}

package/dist/rimori-client/src/cli/types/DatabaseTypes.d.ts

@@ -1,103 +0,0 @@
-/**
- * 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/rimori-client/src/cli/types/DatabaseTypes.js

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

package/dist/rimori-client/src/controller/AIController.d.ts

@@ -1,15 +0,0 @@
-import { Tool } from '../fromRimori/PluginTypes';
-export interface ToolInvocation {
-    toolCallId: string;
-    toolName: string;
-    args: Record<string, string>;
-}
-export interface Message {
-    id?: string;
-    role: 'user' | 'assistant' | 'system';
-    content: string;
-    toolCalls?: ToolInvocation[];
-}
-export declare function generateText(backendUrl: string, messages: Message[], tools: Tool[], token: string): Promise<any>;
-export type OnLLMResponse = (id: string, response: string, finished: boolean, toolInvocations?: ToolInvocation[]) => void;
-export declare function streamChatGPT(backendUrl: string, messages: Message[], tools: Tool[], onResponse: OnLLMResponse, token: string): Promise<void>;

package/dist/rimori-client/src/controller/AIController.js

@@ -1,255 +0,0 @@
-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());
-    });
-};
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-export function generateText(backendUrl, messages, tools, token) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const response = yield fetch(`${backendUrl}/ai/llm`, {
-            method: 'POST',
-            body: JSON.stringify({ messages, tools }),
-            headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
-        });
-        return yield response.json();
-    });
-}
-export function streamChatGPT(backendUrl, messages, tools, onResponse, token) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const messageId = Math.random().toString(36).substring(3);
-        const currentMessages = [...messages];
-        console.log('Starting streamChatGPT with:', {
-            messageId,
-            messageCount: messages.length,
-            toolCount: tools.length,
-            backendUrl,
-        });
-        while (true) {
-            const messagesForApi = currentMessages.map((_a) => {
-                var { id } = _a, rest = __rest(_a, ["id"]);
-                return rest;
-            });
-            try {
-                const response = yield fetch(`${backendUrl}/ai/llm`, {
-                    method: 'POST',
-                    body: JSON.stringify({ messages: messagesForApi, tools, stream: true }),
-                    headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
-                });
-                if (!response.ok) {
-                    throw new Error(`HTTP error! status: ${response.status}`);
-                }
-                if (!response.body) {
-                    console.error('No response body.');
-                    return;
-                }
-                const reader = response.body.getReader();
-                const decoder = new TextDecoder('utf-8');
-                let content = '';
-                let done = false;
-                const toolInvocations = [];
-                let currentTextId = '';
-                let isToolCallMode = false;
-                let buffer = ''; // Buffer for incomplete chunks
-                while (!done) {
-                    const { value, done: readerDone } = yield reader.read();
-                    if (value) {
-                        const chunk = decoder.decode(value, { stream: true });
-                        buffer += chunk;
-                        // Split by lines, but handle incomplete lines
-                        const lines = buffer.split('\n');
-                        // Keep the last line in buffer if it's incomplete
-                        if (lines.length > 1) {
-                            buffer = lines.pop() || '';
-                        }
-                        for (const line of lines) {
-                            if (line.trim() === '')
-                                continue;
-                            // Handle the new streaming format
-                            if (line.startsWith('data: ')) {
-                                const dataStr = line.substring(6); // Remove 'data: ' prefix
-                                // Handle [DONE] marker
-                                if (dataStr === '[DONE]') {
-                                    done = true;
-                                    break;
-                                }
-                                try {
-                                    const data = JSON.parse(dataStr);
-                                    // Log the first message to understand the format
-                                    if (!content && !isToolCallMode) {
-                                        // console.log('First stream message received:', data);
-                                    }
-                                    switch (data.type) {
-                                        case 'start':
-                                            // Stream started, no action needed
-                                            // console.log('Stream started');
-                                            break;
-                                        case 'start-step':
-                                            // Step started, no action needed
-                                            // console.log('Step started');
-                                            break;
-                                        case 'reasoning-start':
-                                            // Reasoning started, no action needed
-                                            console.log('Reasoning started:', data.id);
-                                            break;
-                                        case 'reasoning-end':
-                                            // Reasoning ended, no action needed
-                                            console.log('Reasoning ended:', data.id);
-                                            break;
-                                        case 'text-start':
-                                            // Text generation started, store the ID
-                                            currentTextId = data.id;
-                                            console.log('Text generation started:', data.id);
-                                            break;
-                                        case 'text-delta':
-                                            // Text delta received, append to content
-                                            if (data.delta) {
-                                                content += data.delta;
-                                                onResponse(messageId, content, false);
-                                            }
-                                            break;
-                                        case 'text-end':
-                                            // Text generation ended
-                                            console.log('Text generation ended:', data.id);
-                                            break;
-                                        case 'finish-step':
-                                            // Step finished, no action needed
-                                            // console.log('Step finished');
-                                            break;
-                                        case 'finish':
-                                            // Stream finished
-                                            // console.log('Stream finished');
-                                            done = true;
-                                            break;
-                                        // Additional message types that might be present in the AI library
-                                        case 'tool-call':
-                                        case 'tool-input-available': //for now input calls should be handled the same way as tool calls
-                                            // Tool call initiated
-                                            console.log('Tool call initiated:', data);
-                                            isToolCallMode = true;
-                                            if (data.toolCallId && data.toolName && (data.args || data.input)) {
-                                                toolInvocations.push({
-                                                    toolCallId: data.toolCallId,
-                                                    toolName: data.toolName,
-                                                    args: data.args || data.input,
-                                                });
-                                            }
-                                            break;
-                                        case 'tool-input-delta': //for now input calls should be handled the same way as tool calls
-                                        case 'tool-call-delta':
-                                            // Tool call delta (for streaming tool calls)
-                                            console.log('Tool call delta:', data);
-                                            break;
-                                        case 'tool-call-end':
-                                            // Tool call completed
-                                            console.log('Tool call completed:', data);
-                                            break;
-                                        case 'tool-result':
-                                            // Tool execution result
-                                            console.log('Tool result:', data);
-                                            break;
-                                        case 'error':
-                                            // Error occurred
-                                            console.error('Stream error:', data);
-                                            break;
-                                        case 'usage':
-                                            // Usage information
-                                            console.log('Usage info:', data);
-                                            break;
-                                        case 'model':
-                                            // Model information
-                                            console.log('Model info:', data);
-                                            break;
-                                        case 'stop':
-                                            // Stop signal
-                                            console.log('Stop signal received');
-                                            done = true;
-                                            break;
-                                        default:
-                                            // Unknown type, log for debugging
-                                            console.log('Unknown stream type:', data.type, data);
-                                            break;
-                                    }
-                                }
-                                catch (error) {
-                                    console.error('Error parsing stream data:', error, dataStr);
-                                }
-                            }
-                        }
-                    }
-                    if (readerDone) {
-                        done = true;
-                    }
-                }
-                // Check if we have content or if this was a tool call response
-                if (content || toolInvocations.length > 0) {
-                    currentMessages.push({
-                        id: messageId,
-                        role: 'assistant',
-                        content: content,
-                        toolCalls: toolInvocations.length > 0 ? toolInvocations : undefined,
-                    });
-                }
-                // Handle tool call scenario if tools were provided
-                if (tools.length > 0 && toolInvocations.length > 0) {
-                    console.log('Tool calls detected, executing tools...');
-                    const toolResults = [];
-                    for (const toolInvocation of toolInvocations) {
-                        const tool = tools.find((t) => t.name === toolInvocation.toolName);
-                        if (tool && tool.execute) {
-                            try {
-                                const result = yield tool.execute(toolInvocation.args);
-                                toolResults.push({
-                                    id: Math.random().toString(36).substring(3),
-                                    role: 'user',
-                                    content: `Tool '${toolInvocation.toolName}' returned: ${JSON.stringify(result)}`,
-                                });
-                            }
-                            catch (error) {
-                                console.error(`Error executing tool ${toolInvocation.toolName}:`, error);
-                                toolResults.push({
-                                    id: Math.random().toString(36).substring(3),
-                                    role: 'user',
-                                    content: `Tool '${toolInvocation.toolName}' failed with error: ${error}`,
-                                });
-                            }
-                        }
-                    }
-                    if (toolResults.length > 0) {
-                        currentMessages.push(...toolResults);
-                        // Continue the loop to handle the next response
-                        continue;
-                    }
-                }
-                // Since the new format doesn't seem to support tool calls in the same way,
-                // we'll assume the stream is complete when we reach the end
-                // If tools are provided and no content was generated, this might indicate a tool call
-                if (tools.length > 0 && !content && !isToolCallMode) {
-                    // This might be a tool call scenario, but we need more information
-                    // For now, we'll just finish the stream
-                    console.log('No content generated, but tools provided - might be tool call scenario');
-                }
-                onResponse(messageId, content, true, toolInvocations);
-                return;
-            }
-            catch (error) {
-                console.error('Error in streamChatGPT:', error);
-                onResponse(messageId, `Error: ${error instanceof Error ? error.message : String(error)}`, true, []);
-                return;
-            }
-        }
-    });
-}