@aj-archipelago/cortex 1.1.30 → 1.1.32

package/config.js

@@ -154,6 +154,36 @@ var config = convict({
                 "maxReturnTokens": 4096,
                 "supportsStreaming": true
             },
+            "oai-o1-mini": {
+                "type": "OPENAI-REASONING",
+                "url": "https://api.openai.com/v1/chat/completions",
+                "headers": {
+                    "Authorization": "Bearer {{OPENAI_API_KEY}}",
+                    "Content-Type": "application/json"
+                },
+                "params": {
+                    "model": "o1-mini"
+                },
+                "requestsPerSecond": 10,
+                "maxTokenLength": 128000,
+                "maxReturnTokens": 65536,
+                "supportsStreaming": false
+            },
+            "oai-o1-preview": {
+                "type": "OPENAI-REASONING",
+                "url": "https://api.openai.com/v1/chat/completions",
+                "headers": {
+                    "Authorization": "Bearer {{OPENAI_API_KEY}}",
+                    "Content-Type": "application/json"
+                },
+                "params": {
+                    "model": "o1-preview"
+                },
+                "requestsPerSecond": 10,
+                "maxTokenLength": 128000,
+                "maxReturnTokens": 32768,
+                "supportsStreaming": false
+            },
             "azure-bing": {
                 "type": "AZURE-BING",
                 "url": "https://api.bing.microsoft.com/v7.0/search",

package/helper-apps/cortex-autogen/.funcignore

@@ -0,0 +1,8 @@
+.git*
+.vscode
+__azurite_db*__.json
+__blobstorage__
+__queuestorage__
+local.settings.json
+test
+.venv

package/helper-apps/cortex-autogen/Dockerfile

@@ -0,0 +1,10 @@
+FROM python:3.9-slim
+
+WORKDIR /app
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+CMD ["python", "main.py"]

package/helper-apps/cortex-autogen/OAI_CONFIG_LIST

@@ -0,0 +1,5 @@
+[
+    {
+        "model": "claude-3.5-sonnet"
+    }
+]

package/helper-apps/cortex-autogen/function_app.py

@@ -0,0 +1,32 @@
+import azure.functions as func
+import logging
+import json
+import autogen
+from autogen import AssistantAgent, UserProxyAgent, config_list_from_json
+from azure.storage.queue import QueueClient
+import os
+import tempfile
+import redis
+from myautogen import process_message
+
+app = func.FunctionApp()
+
+connection_string = os.environ["AZURE_STORAGE_CONNECTION_STRING"]
+queue_name = os.environ.get("QUEUE_NAME", "autogen-message-queue")
+queue_client = QueueClient.from_connection_string(connection_string, queue_name)
+
+redis_client = redis.from_url(os.environ['REDIS_CONNECTION_STRING'])
+channel = 'requestProgress'
+
+
+@app.queue_trigger(arg_name="msg", queue_name=queue_name, connection="AZURE_STORAGE_CONNECTION_STRING")
+def queue_trigger(msg: func.QueueMessage):
+    logging.info(f"Queue trigger Message ID: {msg.id}")
+    try:
+        message_data = json.loads(msg.get_body().decode('utf-8'))
+        if "requestId" not in message_data:
+            message_data['requestId'] = msg.id
+        process_message(message_data)
+
+    except Exception as e:
+        logging.error(f"Error processing message: {str(e)}")

package/helper-apps/cortex-autogen/host.json

@@ -0,0 +1,15 @@
+{
+  "version": "2.0",
+  "logging": {
+    "applicationInsights": {
+      "samplingSettings": {
+        "isEnabled": true,
+        "excludedTypes": "Request"
+      }
+    }
+  },
+  "extensionBundle": {
+    "id": "Microsoft.Azure.Functions.ExtensionBundle",
+    "version": "[4.*, 5.0.0)"
+  }
+}

package/helper-apps/cortex-autogen/main.py

@@ -0,0 +1,38 @@
+import os
+from azure.storage.queue import QueueClient
+import base64
+import json
+from myautogen import process_message
+import time
+
+def main():
+    print("Starting message processing loop")
+    connection_string = os.environ["AZURE_STORAGE_CONNECTION_STRING"]
+    queue_name = os.environ.get("QUEUE_NAME", "autogen-message-queue")
+
+    queue_client = QueueClient.from_connection_string(connection_string, queue_name)
+    
+    attempts = 0
+    max_attempts = 100
+    
+
+    while attempts < max_attempts:
+        messages = queue_client.receive_messages(messages_per_page=1)
+        
+        if messages:
+            for message in messages:
+                decoded_content = base64.b64decode(message.content).decode('utf-8')
+                message_data = json.loads(decoded_content)
+                if "requestId" not in message_data:
+                    message_data['requestId'] = message.id
+                process_message(message_data)
+                queue_client.delete_message(message)
+            attempts = 0  # Reset attempts if a message was processed
+        else:
+            attempts += 1
+            time.sleep(1)  # Wait for 1 second before checking again
+
+    print("No messages received after 100 attempts. Exiting.")
+
+if __name__ == "__main__":
+    main()

package/helper-apps/cortex-autogen/myautogen.py

@@ -0,0 +1,158 @@
+import azure.functions as func
+import logging
+import json
+import autogen
+from autogen import AssistantAgent, UserProxyAgent, config_list_from_json
+from azure.storage.queue import QueueClient
+import os
+import tempfile
+import redis
+from dotenv import load_dotenv
+import requests
+import pathlib
+
+load_dotenv()
+
+app = func.FunctionApp()
+
+connection_string = os.environ["AZURE_STORAGE_CONNECTION_STRING"]
+queue_name = os.environ.get("QUEUE_NAME", "autogen-message-queue")
+queue_client = QueueClient.from_connection_string(connection_string, queue_name)
+
+redis_client = redis.from_url(os.environ['REDIS_CONNECTION_STRING'])
+channel = 'requestProgress'
+
+def connect_redis():
+    if not redis_client.ping():
+        try:
+            redis_client.ping()
+        except redis.ConnectionError as e:
+            logging.error(f"Error reconnecting to Redis: {e}")
+            return False
+    return True
+
+def publish_request_progress(data):
+    if connect_redis():
+        try:
+            message = json.dumps(data)
+            logging.info(f"Publishing message {message} to channel {channel}")
+            redis_client.publish(channel, message)
+        except Exception as e:
+            logging.error(f"Error publishing message: {e}")
+
+
+def get_given_system_message():
+    env_context = os.environ.get("ENV_SYSTEM_MESSAGE_CONTEXT")
+    
+    if not env_context:
+        return read_local_file("prompt.txt")
+
+    if env_context.startswith(("http://", "https://")):
+        return fetch_from_url(env_context)
+
+    if pathlib.Path(env_context).suffix:
+        return read_local_file(env_context)
+
+    return env_context
+
+def read_local_file(filename):
+    try:
+        with open(filename, "r") as file:
+            return file.read()
+    except FileNotFoundError:
+        logging.error(f"{filename} not found")
+        return ""
+
+def fetch_from_url(url):
+    try:
+        response = requests.get(url)
+        response.raise_for_status()
+        return response.text
+    except requests.RequestException as e:
+        logging.error(f"Error fetching from URL: {e}")
+        return ""
+
+def process_message(message_data):
+    logging.info(f"Processing Message: {message_data}")
+    try:
+        message = message_data['message']
+        request_id = message_data.get('requestId') or msg.id
+
+        config_list = config_list_from_json(env_or_file="OAI_CONFIG_LIST")
+        base_url = os.environ.get("CORTEX_API_BASE_URL")
+        api_key = os.environ.get("CORTEX_API_KEY")
+        llm_config = {"config_list": config_list, "base_url": base_url, "api_key": api_key, "cache_seed": None}
+
+        with tempfile.TemporaryDirectory() as temp_dir:
+            code_executor = autogen.coding.LocalCommandLineCodeExecutor(work_dir=temp_dir)
+
+            message_count = 0
+            total_messages = 20 * 2
+            all_messages = []
+
+            def is_termination_msg(m):
+                content = m.get("content", "")
+                if message_count == 0:
+                    return False
+                return (m.get("role") == "assistant" and not content.strip()) or \
+                    content.rstrip().endswith("TERMINATE") or \
+                    "first message must use the" in content.lower() or \
+                    len(content.strip()) == 0
+
+            system_message_given = get_given_system_message()
+            system_message_assistant = AssistantAgent.DEFAULT_SYSTEM_MESSAGE 
+
+            if system_message_given:
+                system_message_assistant = f"{system_message_assistant}\n\n{system_message_given}"
+            else:
+                print("No extra system message given for assistant")
+
+            assistant = AssistantAgent("assistant", llm_config=llm_config, system_message=system_message_assistant)
+
+            user_proxy = UserProxyAgent(
+                "user_proxy",
+                system_message=system_message_given,
+                code_execution_config={"executor": code_executor},
+                human_input_mode="NEVER",
+                max_consecutive_auto_reply=20,
+                is_termination_msg=is_termination_msg,
+            )
+
+            original_assistant_send = assistant.send
+            original_user_proxy_send = user_proxy.send
+
+            def logged_send(sender, original_send, message, recipient, request_reply=None, silent=True):
+                nonlocal message_count, all_messages
+                logging.info(f"Message from {sender.name} to {recipient.name}: {message}")
+                message_count += 1
+                progress = min(message_count / total_messages, 1)
+                all_messages.append({"sender": sender.name, "message": message})
+                publish_request_progress({
+                    "requestId": request_id,
+                    "progress": progress,
+                    "info": message
+                })
+                return original_send(message, recipient, request_reply, silent)
+
+            assistant.send = lambda message, recipient, request_reply=None, silent=True: logged_send(assistant, original_assistant_send, message, recipient, request_reply, silent)
+            user_proxy.send = lambda message, recipient, request_reply=None, silent=True: logged_send(user_proxy, original_user_proxy_send, message, recipient, request_reply, silent)
+
+            chat_result = user_proxy.initiate_chat(assistant, message=message)
+
+            msg = all_messages[-3]["message"] if len(all_messages) >= 3 else ""
+            logging.info(f"####Final message: {msg}")            
+
+            publish_request_progress({
+                "requestId": request_id,
+                "progress": 1,
+                "data": msg
+            })
+
+    except Exception as e:
+        logging.error(f"Error processing message: {str(e)}")
+        if request_id:
+            publish_request_progress({
+                "requestId": request_id,
+                "progress": 1,
+                "error": str(e)
+            })

package/helper-apps/cortex-autogen/requirements.txt

@@ -0,0 +1,6 @@
+azure-storage-queue
+azure-functions
+pyautogen
+redis
+requests
+azure-storage-blob

package/helper-apps/cortex-autogen/sasfileuploader.py

@@ -0,0 +1,93 @@
+import os
+import sys
+from datetime import datetime, timedelta
+
+def install_azure_storage_blob():
+    print("Installing azure-storage-blob...")
+    import subprocess
+    subprocess.check_call([sys.executable, "-m", "pip", "install", "azure-storage-blob"])
+    print("azure-storage-blob installed successfully.")
+
+try:
+    from azure.storage.blob import BlobServiceClient, BlobClient, generate_blob_sas, BlobSasPermissions
+except ImportError:
+    install_azure_storage_blob()
+    from azure.storage.blob import BlobServiceClient, BlobClient, generate_blob_sas, BlobSasPermissions
+
+def generate_sas_url(blob_service_client, container_name, blob_name):
+    """
+    Generates a SAS URL for a blob.
+    """
+    sas_token = generate_blob_sas(
+        account_name=blob_service_client.account_name,
+        container_name=container_name,
+        blob_name=blob_name,
+        account_key=blob_service_client.credential.account_key,
+        permission=BlobSasPermissions(read=True, write=True),
+        expiry=datetime.utcnow() + timedelta(hours=1)
+    )
+    return f"https://{blob_service_client.account_name}.blob.core.windows.net/{container_name}/{blob_name}?{sas_token}"
+
+def upload_file_to_blob(file_path, sas_url):
+    """
+    Uploads a single file to Azure Blob Storage using a SAS URL.
+    """
+    try:
+        blob_client = BlobClient.from_blob_url(sas_url)
+        with open(file_path, "rb") as data:
+            blob_client.upload_blob(data, overwrite=True)
+        print(f"Successfully uploaded {os.path.basename(file_path)} to Azure Blob Storage.")
+        return True
+    except Exception as e:
+        print(f"Error uploading file: {e}")
+        return False
+
+def main():
+    # Get Azure Storage connection string from environment variable
+    connect_str = os.environ.get('AZURE_STORAGE_CONNECTION_STRING')
+    if not connect_str:
+        print("Error: AZURE_STORAGE_CONNECTION_STRING is not set in environment variables.")
+        sys.exit(1)
+
+    # Create the BlobServiceClient object
+    blob_service_client = BlobServiceClient.from_connection_string(connect_str)
+
+    # Get the container name from environment variable or use a default
+    container_name = os.environ.get('AZURE_BLOB_CONTAINER', 'testcontainer')
+
+    # Test file details
+    file_path = "/tmp/test_file.txt"
+    blob_name = "test_file.txt"
+
+    # Create a test file
+    with open(file_path, "w") as f:
+        f.write("This is a test file for Azure Blob Storage upload.")
+
+    print(f"Test file created at: {file_path}")
+
+    # Generate SAS URL
+    sas_url = generate_sas_url(blob_service_client, container_name, blob_name)
+    print(f"Generated SAS URL: {sas_url}")
+
+    # Upload file
+    if upload_file_to_blob(file_path, sas_url):
+        print("File upload completed successfully.")
+    else:
+        print("File upload failed.")
+
+    # Clean up the test file
+    os.remove(file_path)
+    print(f"Test file removed: {file_path}")
+
+    # Upload this script to Azure Blob Storage
+    script_path = os.path.abspath(__file__)
+    script_name = os.path.basename(script_path)
+    script_sas_url = generate_sas_url(blob_service_client, container_name, script_name)
+    
+    if upload_file_to_blob(script_path, script_sas_url):
+        print(f"Script uploaded successfully. You can access it at: {script_sas_url}")
+    else:
+        print("Failed to upload the script.")
+
+if __name__ == "__main__":
+    main()

package/helper-apps/cortex-file-handler/fileChunker.js

@@ -86,9 +86,16 @@ async function splitMediaFile(inputPath, chunkDurationInSeconds = 500) {
             // Extract the original file name from the URL
             const urlObj = new URL(inputPath);
             const originalFileName = path.basename(urlObj.pathname);
+            const maxLength = 200; // Set the maximum length for the filename
+            let truncatedFileName = originalFileName;
+            if (originalFileName.length > maxLength) {
+                const extension = path.extname(originalFileName); // Preserve the file extension
+                const basename = path.basename(originalFileName, extension); // Get the filename without the extension
+                truncatedFileName = basename.substring(0, maxLength) + extension; // Truncate the filename and append the extension
+            }
 
-            // Use the original file name when saving the downloaded file
-            const downloadPath = path.join(uniqueOutputPath, originalFileName);
+            // Use the original-truncated file name when saving the downloaded file
+            const downloadPath = path.join(uniqueOutputPath, truncatedFileName);
             await downloadFile(inputPath, downloadPath);
             inputPath = downloadPath;
         }

package/lib/requestExecutor.js

@@ -236,7 +236,7 @@ const makeRequest = async (cortexRequest) => {
             promises.push(selectedEndpoint.limiter.schedule({expiration: pathway.timeout * 1000 + 1000, id: `${requestId}_${uuidv4()}`},() => requestWithMonitor(selectedEndpoint, url, data, axiosConfigObj)));
         } else {
             if (streamRequested) {
-                logger.info(`>>> [${requestId}] ${model} does not support streaming - sending non-streaming request`);
+                logger.info(`>>> [${requestId}] ${model.name || 'This model'} does not support streaming - sending non-streaming request`);
                 axiosConfigObj.params.stream = false;
                 data.stream = false;
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aj-archipelago/cortex",
-  "version": "1.1.30",
+  "version": "1.1.32",
   "description": "Cortex is a GraphQL API for AI. It provides a simple, extensible interface for using AI services from OpenAI, Azure and others.",
   "private": false,
   "repository": {

package/server/graphql.js

@@ -77,6 +77,7 @@ const getTypedefs = (pathways) => {
         progress: Float
         status: String
         data: String
+        info: String
     }
 
     type Subscription {

package/server/modelExecutor.js

@@ -17,6 +17,7 @@ import OpenAiEmbeddingsPlugin from './plugins/openAiEmbeddingsPlugin.js';
 import OpenAIImagePlugin from './plugins/openAiImagePlugin.js';
 import OpenAIDallE3Plugin from './plugins/openAiDallE3Plugin.js';
 import OpenAIVisionPlugin from './plugins/openAiVisionPlugin.js';
+import OpenAIReasoningPlugin from './plugins/openAiReasoningPlugin.js';
 import GeminiChatPlugin from './plugins/geminiChatPlugin.js';
 import GeminiVisionPlugin from './plugins/geminiVisionPlugin.js';
 import Gemini15ChatPlugin from './plugins/gemini15ChatPlugin.js';
@@ -82,6 +83,9 @@ class ModelExecutor {
             case 'OPENAI-VISION':
                 plugin = new OpenAIVisionPlugin(pathway, model);
                 break;
+            case 'OPENAI-REASONING':
+                plugin = new OpenAIReasoningPlugin(pathway, model);
+                break;
             case 'GEMINI-CHAT':
                 plugin = new GeminiChatPlugin(pathway, model);
                 break;

package/server/plugins/openAiReasoningPlugin.js

@@ -0,0 +1,61 @@
+import OpenAIChatPlugin from './openAiChatPlugin.js';
+
+class OpenAIReasoningPlugin extends OpenAIChatPlugin {
+    
+    tryParseMessages(messages) {
+        let newMessages = [];
+
+        for (const message of messages) {
+            if (message.role === 'user' || message.role === 'assistant') {
+                newMessages.push({
+                    role: message.role,
+                    content: this.parseContent(message.content)
+                });
+            }
+            // System messages are simply ignored
+        }
+
+        messages.length = 0;
+        messages.push(...newMessages);
+    }
+
+    parseContent(content) {
+        if (typeof content === 'string') {
+            return [{ type: 'text', text: content }];
+        }
+        if (Array.isArray(content)) {
+            return content.map(item => {
+                if (typeof item === 'string') {
+                    return { type: 'text', text: item };
+                }
+                const { type, text } = item;
+                return { type, text: text || '' };
+            });
+        }
+        return [];
+    }
+
+    getRequestParameters(text, parameters, prompt) {
+        const requestParameters = super.getRequestParameters(text, parameters, prompt);
+
+        this.tryParseMessages(requestParameters.messages);
+
+        const modelMaxReturnTokens = this.getModelMaxReturnTokens();
+        const maxTokensPrompt = this.promptParameters.max_tokens;
+        const maxTokensModel = this.getModelMaxTokenLength() * (1 - this.getPromptTokenRatio());
+
+        const maxTokens = maxTokensPrompt || maxTokensModel;
+
+        requestParameters.max_completion_tokens = maxTokens ? Math.min(maxTokens, modelMaxReturnTokens) : modelMaxReturnTokens;
+        requestParameters.temperature = 1;
+
+        if (this.promptParameters.json) {
+            //requestParameters.response_format = { type: "json_object", }
+        }
+
+        return requestParameters;
+    }
+
+}
+
+export default OpenAIReasoningPlugin;

package/server/typeDef.js

@@ -36,8 +36,8 @@ const typeDef = (pathway) => {
 
   const typeName = fields ? `${objName}Result` : `String`;
 
-  const messageType = `input Message { role: String, content: String }`;
-  const multiMessageType = `input MultiMessage { role: String, content: [String] }`;
+  const messageType = `input Message { role: String, content: String, name: String }`;
+  const multiMessageType = `input MultiMessage { role: String, content: [String], name: String }`;
 
   const type = fields ? `type ${typeName} {
     ${fieldsStr}