@aj-archipelago/cortex 1.3.61 → 1.3.63

package/helper-apps/cortex-autogen2/README.md

@@ -0,0 +1,183 @@
+## Cortex AutoGen: Advanced AI Agent System 🤖
+
+Multi-agent task automation with real code execution, Azure Storage Queue ingestion, Azure Blob uploads, and live progress via Redis.
+
+### Highlights
+- **Selector-based orchestration** with `SelectorGroupChat`
+- **Agents**: coder, code executor, cloud file uploader, presenter, terminator
+- **Real execution** in a sandboxed working directory (`CORTEX_WORK_DIR`)
+- **Azure native**: Queue (ingress) + Blob (files)
+- **Live progress** published to Redis (`info`, `progress`, optional `data`)
+
+### Architecture
+- Shared core in `task_processor.py` used by both the long-running worker (`main.py`) and the Azure Functions container (`function_app.py`).
+- Queue messages are Base64-encoded JSON; task text is read from `message` or `content`.
+
+## Quick Start
+
+### Prerequisites
+- Python 3.11+
+- Redis instance
+- Azure Storage account (Queue + Blob)
+- Docker (optional, for containerized Azure Functions local run)
+
+### 1) Set environment variables
+Create a `.env` in the project root:
+
+```dotenv
+# Core
+AZURE_STORAGE_CONNECTION_STRING=...
+AZURE_QUEUE_NAME=autogen-test-message-queue         # used by worker (main.py)
+AZURE_BLOB_CONTAINER=autogentempfiles
+REDIS_CONNECTION_STRING=redis://localhost:6379
+REDIS_CHANNEL=requestProgress
+
+# Models API
+CORTEX_API_KEY=...
+CORTEX_API_BASE_URL=http://host.docker.internal:4000/v1
+
+# Working directory for code execution (must be writable)
+CORTEX_WORK_DIR=/tmp/coding
+
+# Azure Functions variant uses QUEUE_NAME (not AZURE_QUEUE_NAME)
+QUEUE_NAME=autogen-test-message-queue
+```
+
+Keep secrets out of version control. You can also configure `local.settings.json` for local Functions.
+
+### 2) Install dependencies
+- Using Poetry:
+```bash
+poetry install
+```
+- Or with pip:
+```bash
+python -m venv .venv && source .venv/bin/activate   # project uses .venv
+pip install -r requirements.txt
+```
+
+### 3) Run the worker locally
+- Activate your virtualenv (`source .venv/bin/activate`) and ensure a clean worker state.
+- Recommended workflow (non-continuous, exits when queue is empty):
+```bash
+# Kill any previously running worker (module or script form)
+pkill -f "python -m src.cortex_autogen2.main" || true
+pkill -f "python main.py" || true
+CONTINUOUS_MODE=false python -m src.cortex_autogen2.main &
+# Alternative (direct script):
+# CONTINUOUS_MODE=false python main.py &
+```
+Tip: Use the module path variant if your repository layout exposes `src/cortex_autogen2` on `PYTHONPATH` (e.g., in a monorepo). Otherwise, run `python main.py` directly.
+
+Then send a task:
+```bash
+python send_task.py "create a simple PDF about cats"
+```
+
+Notes:
+- `CONTINUOUS_MODE=false` runs once and exits after the queue is empty.
+- Use background run `&` to keep logs visible in the current terminal.
+
+### 4) Run the worker in Docker (optional)
+Build and run the worker image using `Dockerfile.worker`:
+```bash
+docker build -f Dockerfile.worker -t cortex-autogen-worker .
+docker run --rm --env-file .env -e CORTEX_WORK_DIR=/app/coding --network host cortex-autogen-worker
+```
+
+### 5) Run the Azure Functions container locally (optional)
+Use Docker Compose and pass your `.env` so the container gets your variables:
+```bash
+docker compose --env-file .env up --build
+```
+This builds `Dockerfile` (Functions) and starts on port `7071` (mapped to container `80`).
+
+## Usage Details
+
+### Sending tasks
+`send_task.py` publishes a Base64-encoded JSON message with `content` to the queue defined by `AZURE_STORAGE_CONNECTION_STRING` and `AZURE_QUEUE_NAME` (or `QUEUE_NAME` for Functions).
+
+```bash
+python send_task.py "list the files in the current directory"
+# Override queue/connection if needed:
+python send_task.py "create a simple PDF about cats" --queue autogen-test-message-queue --connection "<AZURE_STORAGE_CONNECTION_STRING>"
+```
+
+Message format published to the queue (before Base64 encoding):
+```json
+{
+  "request_id": "<uuid>",
+  "message_id": "<uuid>",
+  "content": "<task text>"
+}
+```
+
+### Progress updates
+- Channel: set via `REDIS_CHANNEL` (recommend `requestProgress`)
+- Payload fields: `requestId`, `progress` (0-1), `info` (short status), optional `data` (final Markdown)
+- Final result publishes `progress=1.0` with `data` containing the Markdown for UI
+
+### Working directory
+- Code execution uses `CORTEX_WORK_DIR`. Defaults: `/home/site/wwwroot/coding` in Functions container; set to `/app/coding` in worker container; recommend `/tmp/coding` locally. Always use absolute paths within this directory.
+
+## Project Structure
+```
+cortex-autogen2/
+├── Dockerfile                  # Azure Functions container
+├── Dockerfile.worker           # Traditional worker container
+├── docker-compose.yml          # Local Functions container orchestrator
+├── main.py                     # Long-running worker
+├── function_app.py             # Azure Functions entry
+├── task_processor.py           # Shared processing logic
+├── host.json                   # Azure Functions host config
+├── local.settings.json         # Local Functions settings (do not commit secrets)
+├── requirements.txt            # Functions deps (pip)
+├── pyproject.toml, poetry.lock # Poetry project config
+├── send_task.py                # Queue task sender
+├── agents.py                   # Agent definitions
+├── services/
+│   ├── azure_queue.py
+│   └── redis_publisher.py
+└── tools/
+    ├── azure_blob_tools.py
+    ├── coding_tools.py
+    ├── download_tools.py
+    ├── file_tools.py
+    └── search_tools.py
+```
+
+## Environment variables reference
+| Name                           | Required | Default                         | Used by           | Description |
+|--------------------------------|----------|---------------------------------|-------------------|-------------|
+| `AZURE_STORAGE_CONNECTION_STRING` | Yes    | —                               | Worker/Functions  | Storage account connection string |
+| `AZURE_QUEUE_NAME`             | Yes (worker) | —                            | Worker            | Queue name for worker (`main.py`) |
+| `QUEUE_NAME`                   | Yes (Functions) | `autogen-message-queue`    | Functions         | Queue name for Functions (`function_app.py`) |
+| `AZURE_BLOB_CONTAINER`         | Yes      | —                               | Uploader tool     | Blob container for uploaded files |
+| `REDIS_CONNECTION_STRING`      | Yes      | —                               | Progress          | Redis connection string |
+| `REDIS_CHANNEL`                | Yes      | `requestProgress`               | Progress          | Redis pub/sub channel for progress |
+| `CORTEX_API_KEY`               | Yes      | —                               | Models            | API key for Cortex/OpenAI-style API |
+| `CORTEX_API_BASE_URL`          | No       | `http://host.docker.internal:4000/v1` | Models     | API base URL |
+| `CORTEX_WORK_DIR`              | No       | `/tmp/coding` or container path | Code executor     | Writable work dir for code execution |
+
+## Notes
+- Health endpoint referenced in `docker-compose.yml` is optional; if you add one, expose it under `/api/health` in the Functions app.
+- Do not commit `.env` or `local.settings.json` with secrets.
+ - On macOS, Docker's `network_mode: host` is not supported; remove it from `docker-compose.yml` if needed and rely on published ports and `host.docker.internal` for host access.
+
+## Troubleshooting
+- No tasks processed: verify `AZURE_QUEUE_NAME`/`QUEUE_NAME` and that messages are Base64-encoded JSON with `content` or `message`.
+- No progress visible: ensure `REDIS_CONNECTION_STRING` and `REDIS_CHANNEL` (e.g., `requestProgress`) are set, and network access to Redis.
+- Container cannot reach host services: use `--network host` on macOS/Linux and `host.docker.internal` URLs inside containers.
+
+## Contributing
+- Open a PR with clear description and include documentation updates when applicable.
+
+## Examples
+- Send a research/report task:
+```bash
+python send_task.py "Summarize the latest trends in AI agent frameworks with references"
+```
+- Generate and upload a file:
+```bash
+python send_task.py "Create a simple PDF about cats with 3 bullet points and upload it"
+```

package/helper-apps/cortex-autogen2/__init__.py

@@ -0,0 +1 @@
+ 

package/helper-apps/cortex-autogen2/agents.py

@@ -0,0 +1,131 @@
+from autogen_agentchat.agents import AssistantAgent, CodeExecutorAgent
+from autogen_ext.code_executors.local import LocalCommandLineCodeExecutor
+import os   
+from autogen_core.tools import FunctionTool
+from tools.azure_blob_tools import upload_file_to_azure_blob
+
+#AGENTS
+MAGENTIC_ONE_CODER_DESCRIPTION = "A helpful and general-purpose AI assistant that has strong language skills, Python skills, and Linux command line skills."
+
+MAGENTIC_ONE_CODER_SYSTEM_MESSAGE = """You are a helpful AI assistant.
+Solve tasks using your coding and language skills.
+In the following cases, suggest python code (in a python coding block) or shell script (in a sh coding block) for the user to execute.
+    1. When you need to collect info, use the code to output the info you need, for example, browse or search the web, download/read a file, print the content of a webpage or a file, get the current date/time, check the operating system. After sufficient info is printed and the task is ready to be solved based on your language skill, you can solve the task by yourself.
+    2. When you need to perform some task with code, use the code to perform the task and output the result. Finish the task smartly.
+Solve the task step by step if you need to. If a plan is not provided, explain your plan first. Be clear which step uses code, and which step uses your language skill.
+When using code, you must indicate the script type in the code block. The user cannot provide any other feedback or perform any other action beyond executing the code you suggest. The user can't modify your code. So do not suggest incomplete code which requires users to modify. Don't use a code block if it's not intended to be executed by the user.
+Don't include multiple code blocks in one response. Do not ask users to copy and paste the result. Instead, use the 'print' function for the output when relevant. Check the execution result returned by the user.
+If the result indicates there is an error, fix the error and output the code again. Suggest the full code instead of partial code or code changes. If the error can't be fixed or if the task is not solved even after the code is executed successfully, analyze the problem, revisit your assumption, collect additional info you need, and think of a different approach to try.
+When you find an answer, verify the answer carefully. Include verifiable evidence in your response if possible."""
+
+
+async def get_agents(default_model_client, big_model_client, small_model_client):
+    
+    #code executor
+    work_dir = os.getenv("CORTEX_WORK_DIR", "/home/site/wwwroot/coding")
+    code_executor = LocalCommandLineCodeExecutor(work_dir=work_dir, timeout=300)
+
+    #TOOLS
+    upload_file_to_cloud_tool = FunctionTool(upload_file_to_azure_blob, description="Upload files to the cloud. You must use absolute path to reference local files.")
+
+    coder_agent = AssistantAgent(
+        "coder_agent",
+        model_client=default_model_client,
+        description=MAGENTIC_ONE_CODER_DESCRIPTION,
+        system_message=MAGENTIC_ONE_CODER_SYSTEM_MESSAGE +  f"""
+            Save remote files images, videos, etc. in order to work with them locally. 
+            Make sure to log/print everything in code otherwise you will lose the context and cannot debug it. 
+            Make sure your code is perfect.
+            Never ask for user input or user to do anything.
+            Never ask questions.
+            Your are expert in coding, do wonders.
+            If you need to do advanced stuff you can do a project and run it.
+            You can split codes, build projects, run anything, coding is your strength in this task.
+            Take actionable verifiable small steps if needed.
+            Understand that pitfalls and find ways to overcome them.
+            Progress is important, do not get stuck in a loop, keep trying but do not repeat the same steps.
+            Current directory might be different from the one you think it is, use absolute path to reference files.
+            Code executor working directory is: {work_dir}
+            So you can only access files in this directory.
+            Always use absolute path to reference files as current directory might be different from the one you think it is.
+        """,
+    )
+
+    code_executor_agent = CodeExecutorAgent("code_executor", code_executor=code_executor)
+
+
+    terminator_agent = AssistantAgent(
+        "terminator_agent",
+        model_client=default_model_client,
+        description="A helpful assistant that can terminate.",
+        system_message="""You are a helpful assistant that can terminate. 
+            Original task must be completed in order to terminate.
+            Only output: TERMINATE, if completed.
+            If not completed, give the reason instead of TERMINATE.
+            Do not ask questions you are the terminator.
+            Always output in single line without any other text.
+            Do not give empty response.
+            In order to terminate:
+                - Task must be completed.
+                - All referenced local files must have been uploaded to the cloud and their public URLs retrieved and included in the final output.
+                - Presenter must have provided the final output.
+            All code must have been executed in order to terminate.
+            Deliverables must have been provided in order to terminate.
+            If you cannot terminate because of same reason after 3 attempts, terminate.
+            Example outputs:
+
+            TERMINATE
+
+            TASK NOT COMPLETED: missing missing missing
+        """,
+    )
+
+
+    presenter_agent = AssistantAgent(
+        "presenter_agent",
+        model_client=default_model_client,
+        description="A highly skilled and creative presentation specialist, responsible for crafting visually stunning and exceptionally informative final deliverables.",
+        system_message="""You are a highly skilled and creative presentation specialist, responsible for crafting visually stunning and exceptionally informative final deliverables.
+            Your goal is to transform raw task results into engaging, professional, and visually appealing presentations, primarily using Markdown.
+            
+            Here's what makes a great presentation:
+            - **Captivating Structure**: Start with a compelling summary, followed by well-organized sections with clear headings and subheadings.
+            - **Stunning Visuals**: Integrate relevant images, videos, and even diagrams (if applicable and possible via markdown) seamlessly to enhance understanding and engagement. Ensure visuals are high-quality and directly support the content.
+            **IMPORTANT: Actively look for `UPLOADED_FILES_SAS_URLS` provided in the input. If images or other visual assets are available via these URLs, you MUST incorporate them into your Markdown presentation. Describe and explain these visuals to the user, providing context and insights.**
+            - **Professional Aesthetics**: Utilize Markdown's full capabilities for formatting, including bolding, italics, lists, and tables, to create a clean, readable, and visually pleasing layout. Think about white space and information hierarchy.
+            - **Concise & Impactful Language**: Use persuasive and professional language. Avoid jargon where possible, or explain it clearly. Every word should contribute to clarity and impact.
+            - **User-Centric Design**: Remember that your output will be directly displayed in a React application. Focus on great UI/UX, ensuring the presentation is intuitive and easy for the end-user to consume.
+            - **Complete & Actionable**: Ensure all necessary information from the task is included, and if appropriate, guide the user towards next steps or key takeaways.
+            
+            Report must be a direct reply to the user's task. You are the final voice to the user, so make it perfect.
+            User does not have local access to the files, so you must provide direct URLs for any external resources (e.g., images uploaded to cloud storage).
+            When including downloadable assets, always look for and use the `download_url` provided in JSON outputs from the `file_cloud_uploader_agent`. These URLs are public and include necessary SAS tokens for access.
+            Crucially, your output should be a final, polished presentation of the task result, suitable for direct display in a user interface.
+            **Your report MUST only contain the direct result of the user's task. Absolutely NO explanations of how the task was accomplished, internal agent thought processes, or any operational details should be included. Do not mention which tools or agents were used, or how they were used to achieve the result.**
+            **Focus exclusively on delivering the requested information (e.g., image galleries, reports) and only include minimal, essential explanations directly related to the visuals or content.** For example, for an image gallery, provide brief descriptions for each image or a short overview of the gallery structure, but do not explain the steps taken by the agents or the internal workflow.
+            **Do not include extensive executive summaries, detailed operational breakdowns, or generic quick-start guides unless explicitly asked for.**
+            Do not include raw code snippets, internal thought processes, intermediate data, or any technical logs that are not part of the final, user-friendly deliverable.
+            **Absolutely DO NOT include instructions on how to run, save, or modify any code (e.g., "save as .py", "pip install", "python script.py").**
+            **DO NOT provide information about packaging, dependencies, or development workflows.**
+            Your output is for a non-technical end-user viewing it in a React app.
+            **CRITICAL: ONLY use URLs for any files (images, videos, documents, etc.) that are explicitly provided in the `UPLOADED_FILES_SAS_URLS` or directly within the `RESULT` content from other agents, specifically from the `file_cloud_uploader_agent`. If a valid, real URL is not provided, you MUST NOT include any placeholder, fake, or fabricated URLs. NEVER hallucinate or fabricate any links or content.**
+        """
+    )
+
+    file_cloud_uploader_agent = AssistantAgent(
+        "file_cloud_uploader_agent",
+        model_client=default_model_client,
+        tools=[upload_file_to_cloud_tool],
+        description="A helpful assistant that can upload files to the cloud.",
+        system_message=f"""You are a helpful assistant that can upload files to the cloud.
+            Upload referenced files to the cloud.
+            Use your tool to upload the files.
+            User does not have local access to the files so you must upload them to the cloud and provide the url.
+            Your current working directory for file operations is: {work_dir}.
+            When referencing local files for upload, **always prepend the '{work_dir}/' to the filename** to form the correct absolute path. For example, if a file is named 'test.text' in the working directory, the absolute path should be '{work_dir}/test.txt'.
+        """,
+    )
+    
+    agents = [coder_agent, code_executor_agent, file_cloud_uploader_agent, presenter_agent, terminator_agent]
+
+    return agents, presenter_agent 

package/helper-apps/cortex-autogen2/docker-compose.yml

@@ -0,0 +1,20 @@
+services:
+  cortex-autogen-function:
+    build:
+      context: .
+      dockerfile: Dockerfile
+      platforms:
+        - linux/amd64
+    ports:
+      - "7071:80"
+    environment:
+      - CORTEX_API_BASE_URL=http://host.docker.internal:4000/v1
+      - REDIS_CONNECTION_STRING=redis://host.docker.internal:6379
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:80/api/health"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 60s
+    restart: unless-stopped
+    network_mode: host

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

@@ -0,0 +1,55 @@
+import azure.functions as func
+import logging
+import json
+from azure.storage.queue import QueueClient
+import os
+import redis
+from task_processor import process_queue_message
+# from agents import process_message
+
+# logging.getLogger().setLevel(logging.WARNING)
+logging.getLogger().setLevel(logging.INFO)
+
+app = func.FunctionApp()
+
+connection_string = os.environ["AZURE_STORAGE_CONNECTION_STRING"]
+queue_name = os.environ.get("AZURE_QUEUE_NAME") or os.environ.get("QUEUE_NAME", "autogen-message-queue")
+logging.info(f"📦 Using Azure Storage Queue name: {queue_name}")
+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):
+    """Queue trigger function to process Cortex AutoGen tasks."""
+    logging.info(f"🔍 QUEUE_TRIGGER: Processing message {msg.id}")
+    
+    try:
+        message_body = msg.get_body().decode('utf-8')
+        message_data = {
+            "id": msg.id,
+            "content": message_body,
+            "pop_receipt": None,
+            "dequeue_count": msg.dequeue_count
+        }
+        
+        logging.info(f"🔍 QUEUE_TRIGGER: Content: {message_data['content'][:100]}...")
+        
+        # Process the message synchronously
+        import asyncio
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        try:
+            result = loop.run_until_complete(process_queue_message(message_data))
+            if result:
+                logging.info(f"✅ QUEUE_TRIGGER: Message {msg.id} processed successfully")
+            else:
+                logging.warning(f"⚠️ QUEUE_TRIGGER: Message {msg.id} returned no result")
+        finally:
+            loop.close()
+            
+    except Exception as e:
+        logging.error(f"❌ QUEUE_TRIGGER: Error processing message {msg.id}: {e}", exc_info=True)
+        raise

package/helper-apps/cortex-autogen2/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-autogen2/main.py

@@ -0,0 +1,126 @@
+import asyncio
+import os
+import sys
+import json
+import base64
+import logging
+from services.azure_queue import get_queue_service
+from task_processor import TaskProcessor
+
+# Add the parent directory of 'src' to sys.path to allow imports like 'from cortex_autogen2.tools import ...'
+# This is crucial when running main.py directly from outside the 'src' directory.
+current_dir = os.path.dirname(os.path.abspath(__file__))
+project_root = os.path.abspath(os.path.join(current_dir, '..', '..'))
+if project_root not in sys.path:
+    sys.path.insert(0, project_root)
+
+# Load environment variables
+from dotenv import load_dotenv
+load_dotenv()
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logging.getLogger("azure.core.pipeline.policies.http_logging_policy").setLevel(logging.WARNING)
+logger = logging.getLogger(__name__)
+
+
+async def process_task(task_id: str, task_content: str, processor: TaskProcessor) -> None:
+    """Process a single task using the TaskProcessor."""
+    await processor.process_task(task_id, task_content)
+
+
+
+async def main():
+    """
+    Main function to continuously process tasks from the Azure queue.
+    """
+    
+    continuous_mode = os.getenv("CONTINUOUS_MODE", "true").lower() == "true"
+    logger.info(f"🚀 Starting AutoGen Worker, continuous_mode: {continuous_mode}")
+
+    # Add a small initial delay in non-continuous mode to allow tasks to be enqueued
+    if not continuous_mode:
+        await asyncio.sleep(1)
+
+    try:
+        azure_queue = await get_queue_service()
+        processor = TaskProcessor()
+        await processor.initialize()
+
+        try:
+            while True:  # Continuous loop
+                try:
+                    message = await azure_queue.get_task()
+                    if message:
+                        task_id = message.get("id")
+                        pop_receipt = message.get("pop_receipt")
+                        
+                        if not task_id or not pop_receipt:
+                            logger.error(f"❌ Invalid message format: {message}")
+                            # Delete the invalid message to prevent infinite retry
+                            if task_id and pop_receipt:
+                                await azure_queue.delete_task(task_id, pop_receipt)
+                            continue
+                        
+                        raw_content = message.get("content") or message.get("message")
+                        if not raw_content:
+                            logger.error(f"❌ Message has no content: {message}")
+                            await azure_queue.delete_task(task_id, pop_receipt)
+                            continue
+                        
+                        try:
+                            decoded_content = base64.b64decode(raw_content).decode('utf-8')
+                            task_data = json.loads(decoded_content)
+                        except (json.JSONDecodeError, TypeError, ValueError) as e:
+                            logger.warning(f"⚠️ Failed to decode as base64, trying as raw JSON: {e}")
+                            try:
+                                task_data = json.loads(raw_content)
+                            except json.JSONDecodeError as e2:
+                                logger.error(f"❌ Failed to parse message content: {e2}")
+                                await azure_queue.delete_task(task_id, pop_receipt)
+                                continue
+                        
+                        # Fix: Check message field first, then content field
+                        task_content = task_data.get("message") or task_data.get("content")
+                        if not task_content:
+                            logger.error(f"❌ No task content found in: {task_data}")
+                            await azure_queue.delete_task(task_id, pop_receipt)
+                            continue
+                        
+                        logger.info(f"📩 Received task: {task_content}...")
+                        
+                        await process_task(task_id, task_content, processor)
+
+                        await azure_queue.delete_task(task_id, pop_receipt)
+                        logger.info(f"✅ Task {task_id} processed successfully.")
+                    else:
+                        if continuous_mode:
+                            logger.info("⏳ No tasks in queue. Waiting 3 seconds...")
+                            await asyncio.sleep(3)  # Wait before checking again
+                        else:
+                            logger.info("📭 No tasks in queue. Exiting (non-continuous mode).")
+                            break
+                            
+                except Exception as e:
+                    logger.error(f"❌ Error processing task: {e}")
+                    if continuous_mode:
+                        logger.info("📝 Continuing to next task...")
+                        await asyncio.sleep(5)  # Brief pause before retrying
+                    else:
+                        raise  # Re-raise in non-continuous mode
+                        
+        finally:
+            await processor.close()
+            logger.info("🔌 Connections closed. Worker shutting down.")
+
+    except Exception as e:
+        logger.error(f"❌ Error in main loop: {e}")
+        raise
+
+
+if __name__ == "__main__":
+    asyncio.run(main()) 
+
+
+
+