chore: bump praisonai version to 2.2.65 and add autogen-v4 dependencies

fix: Ensure agent names are valid Python identifiers for AutoGen v0.4

docker/Dockerfile

@@ -16,7 +16,7 @@ RUN mkdir -p /root/.praison
 # Install Python packages (using latest versions)
 RUN pip install --no-cache-dir \
     flask \
-    "praisonai>=2.2.63" \
+    "praisonai>=2.2.65" \
     "praisonai[api]" \
     gunicorn \
     markdown

docker/Dockerfile.chat

@@ -16,7 +16,7 @@ RUN mkdir -p /root/.praison
 # Install Python packages (using latest versions)
 RUN pip install --no-cache-dir \
     praisonai_tools \
-    "praisonai>=2.2.63" \
+    "praisonai>=2.2.65" \
     "praisonai[chat]" \
     "embedchain[github,youtube]"
 

docker/Dockerfile.dev

@@ -20,7 +20,7 @@ RUN mkdir -p /root/.praison
 # Install Python packages (using latest versions)
 RUN pip install --no-cache-dir \
     praisonai_tools \
-    "praisonai>=2.2.63" \
+    "praisonai>=2.2.65" \
     "praisonai[ui]" \
     "praisonai[chat]" \
     "praisonai[realtime]" \

docker/Dockerfile.ui

@@ -16,7 +16,7 @@ RUN mkdir -p /root/.praison
 # Install Python packages (using latest versions)
 RUN pip install --no-cache-dir \
     praisonai_tools \
-    "praisonai>=2.2.63" \
+    "praisonai>=2.2.65" \
     "praisonai[ui]" \
     "praisonai[crewai]"
 

docker/README.md

@@ -121,7 +121,7 @@ healthcheck:
 ## 📦 Package Versions
 
 All Docker images use consistent, up-to-date versions:
-- PraisonAI: `>=2.2.63`
+- PraisonAI: `>=2.2.65`
 - PraisonAI Agents: `>=0.0.92`
 - Python: `3.11-slim`
 
@@ -218,7 +218,7 @@ docker-compose up -d
 ### Version Pinning
 To use specific versions, update the Dockerfile:
 ```dockerfile
-RUN pip install "praisonai==2.2.63" "praisonaiagents==0.0.92"
+RUN pip install "praisonai==2.2.65" "praisonaiagents==0.0.92"
 ```
 
 ## 🌐 Production Deployment

examples/cookbooks/Programming_Code_Analysis_Agents/ZeroScript_AI_TestExecutor.ipynb

@@ -1,355 +1,355 @@
 {
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "id": "_T4g3t5sLoag"
-   },
-   "source": [
-    "# ZeroScript: AI-Powered Browser Test Automation using PraisonAI Agent & OpenAI"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "id": "O4PKfpalLsmn"
-   },
-   "source": [
-    "# Description"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "id": "CEG1pfumLysm"
-   },
-   "source": [
-    "AI-powered browser testing using PraisonAI Agent and OpenAI. Executes YAML-defined test cases, captures screenshots, logs interactions, and generates JSON reports. Ideal for intelligent, automated UI testing.\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "id": "lbgxOG4gL1Wf"
-   },
-   "source": [
-    "[![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/DhivyaBharathy-web/PraisonAI/blob/main/examples/cookbooks/ZeroScript_AI_TestExecutor.ipynb)\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "id": "WCJqMUzXIndh"
-   },
-   "source": [
-    "# Dependencies"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 34,
-   "metadata": {
-    "id": "9AQhJ59cJPmR"
-   },
-   "outputs": [],
-   "source": [
-    "!pip install --quiet praisonaiagents browser-use python-dotenv pyyaml openai\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "id": "QD-dF-6_It1z"
-   },
-   "source": [
-    "# Environment Setup"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 35,
-   "metadata": {
-    "colab": {
-     "base_uri": "https://localhost:8080/"
-    },
-    "id": "QkRQDli4JhCV",
-    "outputId": "4b8957ed-a37a-4b11-8585-3537a0437d40"
-   },
-   "outputs": [
+  "cells": [
     {
-     "data": {
-      "text/plain": [
-       "True"
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "_T4g3t5sLoag"
+      },
+      "source": [
+        "# ZeroScript: AI-Powered Browser Test Automation using PraisonAI Agent & OpenAI"
       ]
-     },
-     "execution_count": 35,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "import os\n",
-    "from dotenv import load_dotenv\n",
-    "\n",
-    "os.environ[\"OPENAI_API_KEY\"] = \"Enter your key\"  # replace with actual key\n",
-    "load_dotenv()\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "id": "ELuogWnrIw3o"
-   },
-   "source": [
-    "# Create my_secrets.py"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 36,
-   "metadata": {
-    "id": "sG6tO_v0Jm5N"
-   },
-   "outputs": [],
-   "source": [
-    "with open(\"my_secrets.py\", \"w\") as f:\n",
-    "    f.write('''sensitive_data = {\n",
-    "    \"username\": \"standard_user\",\n",
-    "    \"password\": \"secret_sauce\"\n",
-    "}''')\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "id": "rDB_viedIzRR"
-   },
-   "source": [
-    "# Create views.py"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 37,
-   "metadata": {
-    "id": "CtwcybdbJoV8"
-   },
-   "outputs": [],
-   "source": [
-    "with open(\"views.py\", \"w\") as f:\n",
-    "    f.write('''\n",
-    "from pydantic import BaseModel\n",
-    "\n",
-    "class TestResult(BaseModel):\n",
-    "    status: str\n",
-    "    message: str = \"\"\n",
-    "''')\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "id": "YTRmBpTiI1kd"
-   },
-   "source": [
-    "# Create agent.py"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 38,
-   "metadata": {
-    "id": "zdJJGt6TJpvr"
-   },
-   "outputs": [],
-   "source": [
-    "with open(\"agent.py\", \"w\") as f:\n",
-    "    f.write('''\n",
-    "import os\n",
-    "from praisonaiagents import Agent\n",
-    "from browser_use import Browser, BrowserConfig, Controller\n",
-    "from browser_use.browser.context import BrowserContext, BrowserContextConfig\n",
-    "from openai import OpenAI\n",
-    "from views import TestResult\n",
-    "from my_secrets import sensitive_data\n",
-    "\n",
-    "# Browser setup\n",
-    "browser = Browser(config=BrowserConfig(headless=True))\n",
-    "context_cfg = BrowserContextConfig(save_recording_path=\"data/recordings\")\n",
-    "controller = Controller(output_model=TestResult)\n",
-    "\n",
-    "async def browser_use(task: str):\n",
-    "    context = BrowserContext(browser=browser, config=context_cfg)\n",
-    "    agent = Agent(\n",
-    "        task=task,\n",
-    "        llm=OpenAI(api_key=os.getenv(\"OPENAI_API_KEY\"), model=\"gpt-4\"),\n",
-    "        browser_context=context,\n",
-    "        sensitive_data=sensitive_data,\n",
-    "        controller=controller,\n",
-    "        save_conversation_path=\"data/conversations/convo\",\n",
-    "        extend_system_message=(\n",
-    "            \"You are a professional software tester. Execute browser test steps precisely.\"\n",
-    "        )\n",
-    "    )\n",
-    "    response = await agent.run()\n",
-    "    await context.close()\n",
-    "    return response\n",
-    "''')\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "id": "-LZtQIE3I4-_"
-   },
-   "source": [
-    "# Create Sample Test YAML"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 39,
-   "metadata": {
-    "colab": {
-     "base_uri": "https://localhost:8080/"
     },
-    "id": "l1OdXYI-JreK",
-    "outputId": "62323fcd-c74f-498f-defc-2c170fa8983e"
-   },
-   "outputs": [
     {
-     "data": {
-      "text/plain": [
-       "350"
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "O4PKfpalLsmn"
+      },
+      "source": [
+        "# Description"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "CEG1pfumLysm"
+      },
+      "source": [
+        "AI-powered browser testing using PraisonAI Agent and OpenAI. Executes YAML-defined test cases, captures screenshots, logs interactions, and generates JSON reports. Ideal for intelligent, automated UI testing.\n",
+        "\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "lbgxOG4gL1Wf"
+      },
+      "source": [
+        "[![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/DhivyaBharathy-web/PraisonAI/blob/main/examples/cookbooks/ZeroScript_AI_TestExecutor.ipynb)\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "WCJqMUzXIndh"
+      },
+      "source": [
+        "# Dependencies"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 34,
+      "metadata": {
+        "id": "9AQhJ59cJPmR"
+      },
+      "outputs": [],
+      "source": [
+        "!pip install --quiet praisonaiagents browser-use python-dotenv pyyaml openai\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "QD-dF-6_It1z"
+      },
+      "source": [
+        "# Environment Setup"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 35,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "QkRQDli4JhCV",
+        "outputId": "4b8957ed-a37a-4b11-8585-3537a0437d40"
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "True"
+            ]
+          },
+          "execution_count": 35,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "import os\n",
+        "from dotenv import load_dotenv\n",
+        "\n",
+        "os.environ[\"OPENAI_API_KEY\"] = \"Enter your key\"  # replace with actual key\n",
+        "load_dotenv()\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "ELuogWnrIw3o"
+      },
+      "source": [
+        "# Create my_secrets.py"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 36,
+      "metadata": {
+        "id": "sG6tO_v0Jm5N"
+      },
+      "outputs": [],
+      "source": [
+        "with open(\"my_secrets.py\", \"w\") as f:\n",
+        "    f.write('''sensitive_data = {\n",
+        "    \"username\": \"standard_user\",\n",
+        "    \"password\": \"secret_sauce\"\n",
+        "}''')\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "rDB_viedIzRR"
+      },
+      "source": [
+        "# Create views.py"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 37,
+      "metadata": {
+        "id": "CtwcybdbJoV8"
+      },
+      "outputs": [],
+      "source": [
+        "with open(\"views.py\", \"w\") as f:\n",
+        "    f.write('''\n",
+        "from pydantic import BaseModel\n",
+        "\n",
+        "class TestResult(BaseModel):\n",
+        "    status: str\n",
+        "    message: str = \"\"\n",
+        "''')\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "YTRmBpTiI1kd"
+      },
+      "source": [
+        "# Create agent.py"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 38,
+      "metadata": {
+        "id": "zdJJGt6TJpvr"
+      },
+      "outputs": [],
+      "source": [
+        "with open(\"agent.py\", \"w\") as f:\n",
+        "    f.write('''\n",
+        "import os\n",
+        "from praisonaiagents import Agent\n",
+        "from browser_use import Browser, BrowserConfig, Controller\n",
+        "from browser_use.browser.context import BrowserContext, BrowserContextConfig\n",
+        "from openai import OpenAI\n",
+        "from views import TestResult\n",
+        "from my_secrets import sensitive_data\n",
+        "\n",
+        "# Browser setup\n",
+        "browser = Browser(config=BrowserConfig(headless=True))\n",
+        "context_cfg = BrowserContextConfig(save_recording_path=\"data/recordings\")\n",
+        "controller = Controller(output_model=TestResult)\n",
+        "\n",
+        "async def browser_use(task: str):\n",
+        "    context = BrowserContext(browser=browser, config=context_cfg)\n",
+        "    agent = Agent(\n",
+        "        task=task,\n",
+        "        llm=OpenAI(api_key=os.getenv(\"OPENAI_API_KEY\"), model=\"gpt-4\"),\n",
+        "        browser_context=context,\n",
+        "        sensitive_data=sensitive_data,\n",
+        "        controller=controller,\n",
+        "        save_conversation_path=\"data/conversations/convo\",\n",
+        "        extend_system_message=(\n",
+        "            \"You are a professional software tester. Execute browser test steps precisely.\"\n",
+        "        )\n",
+        "    )\n",
+        "    response = await agent.run()\n",
+        "    await context.close()\n",
+        "    return response\n",
+        "''')\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "-LZtQIE3I4-_"
+      },
+      "source": [
+        "# Create Sample Test YAML"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 39,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "l1OdXYI-JreK",
+        "outputId": "62323fcd-c74f-498f-defc-2c170fa8983e"
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "350"
+            ]
+          },
+          "execution_count": 39,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "from pathlib import Path\n",
+        "tests_dir = Path(\"tests\")\n",
+        "tests_dir.mkdir(exist_ok=True)\n",
+        "yaml_content = \"\"\"\n",
+        "hooks:\n",
+        "  beforeEach: |\n",
+        "    Navigate to https://www.saucedemo.com\n",
+        "  afterEach: |\n",
+        "    Take screenshot\n",
+        "\n",
+        "tests:\n",
+        "  - id: \"login_test_001\"\n",
+        "    name: \"Valid Login Test\"\n",
+        "    instructions: |\n",
+        "      1. Enter standard_user in username field\n",
+        "      2. Enter secret_sauce in password field\n",
+        "      3. Click login button\n",
+        "      4. Verify page contains text \"Products\"\n",
+        "\"\"\"\n",
+        "(Path(\"tests/login_test.yml\")).write_text(yaml_content)\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "sUjy-7OdI7p_"
+      },
+      "source": [
+        "# Run Tests"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 40,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "Agkiwh7xJtY3",
+        "outputId": "759aa77c-fd65-49b8-b239-550588059478"
+      },
+      "outputs": [
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "Exception ignored in: <function BrowserSession.__del__ at 0x7e2f540fb100>\n",
+            "Traceback (most recent call last):\n",
+            "  File \"/usr/local/lib/python3.11/dist-packages/browser_use/browser/session.py\", line 497, in __del__\n",
+            "    status = f'\ud83e\ude93 killing pid={self.browser_pid}...' if (self.browser_pid and owns_browser) else '\u2620\ufe0f'\n",
+            "                                                         ^^^^^^^^^^^^^^^^\n",
+            "  File \"/usr/local/lib/python3.11/dist-packages/pydantic/main.py\", line 991, in __getattr__\n",
+            "    raise AttributeError(f'{type(self).__name__!r} object has no attribute {item!r}')\n",
+            "AttributeError: 'BrowserSession' object has no attribute 'browser_pid'\n"
+          ]
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "\u2705 Report saved to data/reports/report_20250630_092319.json\n"
+          ]
+        }
+      ],
+      "source": [
+        "import asyncio, yaml, json, base64, shutil\n",
+        "from agent import browser_use, browser\n",
+        "from pathlib import Path\n",
+        "from datetime import datetime\n",
+        "\n",
+        "# Clean or create data dirs\n",
+        "for sub in [\"recordings\", \"conversations\", \"screenshots\", \"reports\"]:\n",
+        "    d = Path(\"data\") / sub\n",
+        "    if d.exists(): shutil.rmtree(d)\n",
+        "    d.mkdir(parents=True, exist_ok=True)\n",
+        "\n",
+        "async def execute_test_file(path):\n",
+        "    cfg = yaml.safe_load(Path(path).read_text())\n",
+        "    hooks, results = cfg.get(\"hooks\", {}), []\n",
+        "    for t in cfg[\"tests\"]:\n",
+        "        task = f\"{hooks.get('beforeEach','')}\\n{t['instructions']}\\n{hooks.get('afterEach','')}\"\n",
+        "        res = {\"id\": t[\"id\"], \"name\": t[\"name\"]}\n",
+        "        try:\n",
+        "            r = await browser_use(task)\n",
+        "            imgs = r.screenshots()\n",
+        "            if imgs:\n",
+        "                out = Path(\"data/screenshots\") / f\"{t['id']}.png\"\n",
+        "                out.write_bytes(base64.b64decode(imgs[-1]))\n",
+        "            result_obj = r.final_result() if hasattr(r, \"final_result\") else str(r)\n",
+        "            res[\"result\"] = result_obj.model_dump() if hasattr(result_obj, \"model_dump\") else str(result_obj)\n",
+        "        except Exception as e:\n",
+        "            res[\"error\"] = str(e)\n",
+        "        results.append(res)\n",
+        "    return results\n",
+        "\n",
+        "async def main():\n",
+        "    all_results = []\n",
+        "    for file in Path(\"tests\").glob(\"*.yml\"):\n",
+        "        all_results.extend(await execute_test_file(str(file)))\n",
+        "    report = Path(\"data/reports\") / f\"report_{datetime.now():%Y%m%d_%H%M%S}.json\"\n",
+        "    report.write_text(json.dumps(all_results, indent=2))\n",
+        "    await browser.close()\n",
+        "    print(f\"\u2705 Report saved to {report}\")\n",
+        "\n",
+        "await main()\n"
       ]
-     },
-     "execution_count": 39,
-     "metadata": {},
-     "output_type": "execute_result"
     }
-   ],
-   "source": [
-    "from pathlib import Path\n",
-    "tests_dir = Path(\"tests\")\n",
-    "tests_dir.mkdir(exist_ok=True)\n",
-    "yaml_content = \"\"\"\n",
-    "hooks:\n",
-    "  beforeEach: |\n",
-    "    Navigate to https://www.saucedemo.com\n",
-    "  afterEach: |\n",
-    "    Take screenshot\n",
-    "\n",
-    "tests:\n",
-    "  - id: \"login_test_001\"\n",
-    "    name: \"Valid Login Test\"\n",
-    "    instructions: |\n",
-    "      1. Enter standard_user in username field\n",
-    "      2. Enter secret_sauce in password field\n",
-    "      3. Click login button\n",
-    "      4. Verify page contains text \"Products\"\n",
-    "\"\"\"\n",
-    "(Path(\"tests/login_test.yml\")).write_text(yaml_content)\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "id": "sUjy-7OdI7p_"
-   },
-   "source": [
-    "# Run Tests"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 40,
-   "metadata": {
+  ],
+  "metadata": {
     "colab": {
-     "base_uri": "https://localhost:8080/"
+      "provenance": []
     },
-    "id": "Agkiwh7xJtY3",
-    "outputId": "759aa77c-fd65-49b8-b239-550588059478"
-   },
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Exception ignored in: <function BrowserSession.__del__ at 0x7e2f540fb100>\n",
-      "Traceback (most recent call last):\n",
-      "  File \"/usr/local/lib/python3.11/dist-packages/browser_use/browser/session.py\", line 497, in __del__\n",
-      "    status = f'🪓 killing pid={self.browser_pid}...' if (self.browser_pid and owns_browser) else '☠️'\n",
-      "                                                         ^^^^^^^^^^^^^^^^\n",
-      "  File \"/usr/local/lib/python3.11/dist-packages/pydantic/main.py\", line 991, in __getattr__\n",
-      "    raise AttributeError(f'{type(self).__name__!r} object has no attribute {item!r}')\n",
-      "AttributeError: 'BrowserSession' object has no attribute 'browser_pid'\n"
-     ]
+    "kernelspec": {
+      "display_name": "Python 3",
+      "name": "python3"
     },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "✅ Report saved to data/reports/report_20250630_092319.json\n"
-     ]
+    "language_info": {
+      "name": "python"
     }
-   ],
-   "source": [
-    "import asyncio, yaml, json, base64, shutil\n",
-    "from agent import browser_use, browser\n",
-    "from pathlib import Path\n",
-    "from datetime import datetime\n",
-    "\n",
-    "# Clean or create data dirs\n",
-    "for sub in [\"recordings\", \"conversations\", \"screenshots\", \"reports\"]:\n",
-    "    d = Path(\"data\") / sub\n",
-    "    if d.exists(): shutil.rmtree(d)\n",
-    "    d.mkdir(parents=True, exist_ok=True)\n",
-    "\n",
-    "async def execute_test_file(path):\n",
-    "    cfg = yaml.safe_load(Path(path).read_text())\n",
-    "    hooks, results = cfg.get(\"hooks\", {}), []\n",
-    "    for t in cfg[\"tests\"]:\n",
-    "        task = f\"{hooks.get('beforeEach','')}\\n{t['instructions']}\\n{hooks.get('afterEach','')}\"\n",
-    "        res = {\"id\": t[\"id\"], \"name\": t[\"name\"]}\n",
-    "        try:\n",
-    "            r = await browser_use(task)\n",
-    "            imgs = r.screenshots()\n",
-    "            if imgs:\n",
-    "                out = Path(\"data/screenshots\") / f\"{t['id']}.png\"\n",
-    "                out.write_bytes(base64.b64decode(imgs[-1]))\n",
-    "            result_obj = r.final_result() if hasattr(r, \"final_result\") else str(r)\n",
-    "            res[\"result\"] = result_obj.dict() if hasattr(result_obj, \"dict\") else str(result_obj)\n",
-    "        except Exception as e:\n",
-    "            res[\"error\"] = str(e)\n",
-    "        results.append(res)\n",
-    "    return results\n",
-    "\n",
-    "async def main():\n",
-    "    all_results = []\n",
-    "    for file in Path(\"tests\").glob(\"*.yml\"):\n",
-    "        all_results.extend(await execute_test_file(str(file)))\n",
-    "    report = Path(\"data/reports\") / f\"report_{datetime.now():%Y%m%d_%H%M%S}.json\"\n",
-    "    report.write_text(json.dumps(all_results, indent=2))\n",
-    "    await browser.close()\n",
-    "    print(f\"✅ Report saved to {report}\")\n",
-    "\n",
-    "await main()\n"
-   ]
-  }
- ],
- "metadata": {
-  "colab": {
-   "provenance": []
   },
-  "kernelspec": {
-   "display_name": "Python 3",
-   "name": "python3"
-  },
-  "language_info": {
-   "name": "python"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 0
-}
+  "nbformat": 4,
+  "nbformat_minor": 0
+}

examples/python/agents/router-agent-cost-optimization.py

@@ -0,0 +1,82 @@
+"""
+RouterAgent Cost Optimization Example
+
+This example demonstrates how to use RouterAgent for intelligent model selection
+based on cost optimization. The router agent automatically selects the most
+cost-effective model for different types of tasks while maintaining quality.
+
+Features demonstrated:
+- Cost-optimized model routing
+- Automatic model selection based on task complexity
+- Usage tracking and cost monitoring
+- Fallback mechanisms for reliability
+"""
+
+from praisonaiagents import Agent
+from praisonaiagents.agent.router_agent import RouterAgent
+from praisonaiagents.tools import duckduckgo
+
+# Define model options with cost considerations
+# Using different models for different complexity levels
+cheap_model = "gpt-4o-mini"  # For simple tasks
+balanced_model = "gpt-4o"    # For moderate complexity  
+premium_model = "claude-3-5-sonnet-20241022"  # For complex tasks
+
+# Create RouterAgent with cost optimization strategy
+router = RouterAgent(
+    name="CostOptimizedRouter",
+    role="Cost-Efficient Task Router",
+    goal="Route tasks to the most cost-effective model while maintaining quality",
+    backstory="You are a smart router that optimizes for cost-efficiency by selecting appropriate models based on task complexity.",
+    
+    # Model routing strategy - simple tasks to cheap models, complex to premium
+    models=[cheap_model, balanced_model, premium_model],
+    
+    # Routing logic - this could be enhanced with more sophisticated rules
+    instructions="""You are a cost-optimization router. For simple tasks like basic questions, 
+    definitions, or simple calculations, use the cheapest model. For moderate complexity tasks 
+    like writing, analysis, or research, use the balanced model. For complex tasks requiring 
+    deep reasoning, creativity, or specialized knowledge, use the premium model.""",
+    
+    tools=[duckduckgo],
+    verbose=True
+)
+
+# Example tasks of varying complexity levels
+
+# Simple task - should route to cheap model
+print("="*60)
+print("TESTING SIMPLE TASK (should use cheap model)")
+print("="*60)
+simple_result = router.start("What is the capital of France?")
+print(f"Simple task result: {simple_result}")
+
+# Moderate complexity task - should route to balanced model  
+print("\n" + "="*60)
+print("TESTING MODERATE TASK (should use balanced model)")
+print("="*60)
+moderate_result = router.start("Write a brief analysis of renewable energy trends in 2024")
+print(f"Moderate task result: {moderate_result}")
+
+# Complex task - should route to premium model
+print("\n" + "="*60) 
+print("TESTING COMPLEX TASK (should use premium model)")
+print("="*60)
+complex_result = router.start("Conduct a comprehensive strategic analysis of the impact of quantum computing on cybersecurity, including potential vulnerabilities and mitigation strategies")
+print(f"Complex task result: {complex_result}")
+
+# Research task with tool usage - should route appropriately
+print("\n" + "="*60)
+print("TESTING RESEARCH TASK WITH TOOLS")
+print("="*60)
+research_result = router.start("Research and analyze the latest developments in artificial intelligence regulation globally")
+print(f"Research task result: {research_result}")
+
+print("\n" + "="*80)
+print("COST OPTIMIZATION ROUTER DEMONSTRATION COMPLETED")
+print("="*80)
+print("The RouterAgent automatically selected appropriate models based on task complexity:")
+print("- Simple factual questions → Cheaper model (gpt-4o-mini)")  
+print("- Moderate analysis tasks → Balanced model (gpt-4o)")
+print("- Complex strategic analysis → Premium model (claude-3-5-sonnet)")
+print("- This approach optimizes costs while maintaining quality for each task type")

examples/python/api/secondary-market-research-api.py

@@ -440,7 +440,7 @@ async def generate_research(
         "message": "Report generation queued",
         "created_at": datetime.now().isoformat(),
         "updated_at": datetime.now().isoformat(),
-        "config": request.dict()
+        "config": request.model_dump()
     }
     
     # Create config object

examples/python/concepts/reasoning-extraction.py

@@ -31,7 +31,7 @@ def save_reasoning_chain(chain: ChainOfThought) -> str:
     """Save a chain of thought reasoning to analyze patterns."""
     filename = f"reasoning_{chain.problem[:20].replace(' ', '_')}.json"
     with open(filename, 'w') as f:
-        json.dump(chain.dict(), f, indent=2)
+        json.dump(chain.model_dump(), f, indent=2)
     return f"Reasoning chain saved to {filename}"
 
 # Example 1: Chain of Thought Agent

examples/python/guardrails/comprehensive-guardrails-example.py

@@ -0,0 +1,204 @@
+"""
+Comprehensive Guardrails Example
+
+This example demonstrates both function-based and LLM-based guardrails for validating
+agent outputs and ensuring quality, safety, and compliance.
+
+Features demonstrated:
+- Function-based validation guardrails
+- LLM-based content validation
+- Multiple validation criteria
+- Retry mechanisms with feedback
+- Quality assurance workflows
+"""
+
+from praisonaiagents import Agent, Task, PraisonAIAgents
+from praisonaiagents.task import TaskOutput
+from typing import Tuple, Any
+import re
+
+# Define function-based guardrails for different validation types
+
+def email_format_guardrail(task_output: TaskOutput) -> Tuple[bool, Any]:
+    """
+    Validates that the output contains properly formatted email addresses.
+    """
+    output_text = str(task_output.raw)
+    
+    # Email regex pattern
+    email_pattern = r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b'
+    emails_found = re.findall(email_pattern, output_text)
+    
+    if emails_found:
+        return True, task_output
+    else:
+        return False, "No valid email addresses found in the output. Please include at least one properly formatted email address."
+
+def word_count_guardrail(task_output: TaskOutput) -> Tuple[bool, Any]:
+    """
+    Validates that the output meets minimum word count requirements.
+    """
+    output_text = str(task_output.raw)
+    word_count = len(output_text.split())
+    
+    min_words = 50  # Minimum required words
+    
+    if word_count >= min_words:
+        return True, task_output
+    else:
+        return False, f"Output too short. Found {word_count} words but need at least {min_words} words. Please provide a more detailed response."
+
+def professional_tone_guardrail(task_output: TaskOutput) -> Tuple[bool, Any]:
+    """
+    Validates that the output maintains a professional tone.
+    """
+    output_text = str(task_output.raw).lower()
+    
+    # Check for unprofessional words/phrases
+    unprofessional_terms = ['stupid', 'dumb', 'sucks', 'terrible', 'awful', 'hate']
+    
+    for term in unprofessional_terms:
+        if term in output_text:
+            return False, f"Output contains unprofessional language ('{term}'). Please revise to maintain a professional tone."
+    
+    return True, task_output
+
+def factual_accuracy_guardrail(task_output: TaskOutput) -> Tuple[bool, Any]:
+    """
+    Validates that the output includes specific factual elements.
+    """
+    output_text = str(task_output.raw).lower()
+    
+    # Check for presence of factual indicators
+    factual_indicators = ['according to', 'research shows', 'studies indicate', 'data suggests', 'evidence']
+    
+    has_factual_backing = any(indicator in output_text for indicator in factual_indicators)
+    
+    if has_factual_backing:
+        return True, task_output
+    else:
+        return False, "Output lacks factual backing. Please include references to research, studies, or data to support your claims."
+
+# Create agents with different guardrail configurations
+
+# Agent with email format validation
+email_agent = Agent(
+    name="EmailAgent",
+    role="Business Communication Specialist",
+    goal="Create professional business communications with proper email formatting",
+    backstory="You are a professional communication specialist who ensures all business correspondence includes proper contact information.",
+    instructions="Always include properly formatted email addresses in your responses."
+)
+
+# Agent with word count validation  
+content_agent = Agent(
+    name="ContentAgent",
+    role="Content Writer",
+    goal="Create detailed, comprehensive content that meets length requirements",
+    backstory="You are a professional content writer who creates detailed, well-researched articles.",
+    instructions="Provide comprehensive, detailed responses with sufficient depth and explanation."
+)
+
+# Agent with professional tone validation
+business_agent = Agent(
+    name="BusinessAgent", 
+    role="Professional Advisor",
+    goal="Provide professional business advice with appropriate tone",
+    backstory="You are a seasoned business advisor who maintains professionalism in all communications.",
+    instructions="Maintain a professional, respectful tone in all communications."
+)
+
+# Agent with factual accuracy validation
+research_agent = Agent(
+    name="ResearchAgent",
+    role="Research Analyst", 
+    goal="Provide well-researched, fact-based analysis",
+    backstory="You are a research analyst who backs all claims with evidence and citations.",
+    instructions="Support all statements with references to research, studies, or credible data sources."
+)
+
+# Create tasks with specific guardrails
+
+# Task with email format guardrail
+email_task = Task(
+    name="email_communication",
+    description="Write a business proposal for a new software project, including contact information",
+    expected_output="Professional business proposal with contact email addresses",
+    agent=email_agent,
+    guardrail=email_format_guardrail,
+    max_retries=3
+)
+
+# Task with word count guardrail
+content_task = Task(
+    name="detailed_analysis", 
+    description="Write an analysis of cloud computing benefits for small businesses",
+    expected_output="Comprehensive analysis of cloud computing benefits (minimum 50 words)",
+    agent=content_agent,
+    guardrail=word_count_guardrail,
+    max_retries=3
+)
+
+# Task with professional tone guardrail
+business_task = Task(
+    name="professional_advice",
+    description="Provide advice on handling difficult client relationships",
+    expected_output="Professional advice maintaining appropriate business tone",
+    agent=business_agent,
+    guardrail=professional_tone_guardrail,
+    max_retries=3
+)
+
+# Task with factual accuracy guardrail
+research_task = Task(
+    name="research_report",
+    description="Analyze the impact of artificial intelligence on job markets",
+    expected_output="Research-backed analysis with citations and evidence",
+    agent=research_agent,
+    guardrail=factual_accuracy_guardrail,
+    max_retries=3
+)
+
+# LLM-based guardrail example
+llm_guardrail_agent = Agent(
+    name="LLMGuardrailAgent",
+    role="Content Quality Validator",
+    goal="Validate content quality using LLM-based assessment",
+    backstory="You are a quality assurance specialist who uses AI to validate content quality.",
+    instructions="Create marketing content that is engaging, accurate, and compliant with advertising standards."
+)
+
+# Task with LLM-based guardrail
+llm_guardrail_task = Task(
+    name="marketing_content",
+    description="Create a marketing email for a new fitness app targeting busy professionals",
+    expected_output="Engaging marketing email that is accurate and compliant",
+    agent=llm_guardrail_agent,
+    
+    # LLM-based guardrail using natural language validation
+    guardrail="Validate that this marketing content is: 1) Factually accurate with no false claims, 2) Compliant with advertising standards (no misleading statements), 3) Engaging and professional in tone, 4) Includes a clear call-to-action. If any criteria are not met, explain what needs to be improved.",
+    max_retries=2
+)
+
+# Execute tasks with guardrails
+agents = PraisonAIAgents(
+    agents=[email_agent, content_agent, business_agent, research_agent, llm_guardrail_agent],
+    tasks=[email_task, content_task, business_task, research_task, llm_guardrail_task],
+    verbose=True
+)
+
+print("="*80)
+print("EXECUTING TASKS WITH COMPREHENSIVE GUARDRAILS")
+print("="*80)
+
+result = agents.start()
+
+print("\n" + "="*80)
+print("GUARDRAILS DEMONSTRATION COMPLETED")
+print("="*80)
+print("This example demonstrated:")
+print("- Function-based validation (email format, word count, tone, factual accuracy)")
+print("- LLM-based content validation using natural language criteria")
+print("- Automatic retry mechanisms with specific feedback")
+print("- Quality assurance workflows for different content types")
+print("- Professional validation standards for business communications")

examples/python/knowledge/advanced-knowledge-management.py

@@ -0,0 +1,194 @@
+"""
+Advanced Knowledge Management Example
+
+This example demonstrates sophisticated knowledge management capabilities including
+advanced chunking strategies, reranking, and intelligent knowledge retrieval.
+
+Features demonstrated:
+- Advanced document chunking strategies
+- Vector store integration with ChromaDB
+- Knowledge-based question answering
+- Intelligent context retrieval
+- Document processing and management
+"""
+
+from praisonaiagents import Agent
+import tempfile
+import os
+
+# Create a sample knowledge document for demonstration
+sample_document = """
+# Artificial Intelligence in Healthcare
+
+## Introduction
+Artificial intelligence (AI) is revolutionizing healthcare by enabling more accurate diagnoses, 
+personalized treatments, and efficient healthcare delivery. This document explores the current 
+applications and future potential of AI in healthcare.
+
+## Current Applications
+
+### Medical Imaging
+AI algorithms, particularly deep learning models, have shown remarkable success in medical imaging:
+- Radiology: AI can detect cancers in mammograms with accuracy matching or exceeding radiologists
+- Ophthalmology: AI systems can diagnose diabetic retinopathy from retinal photographs
+- Pathology: AI assists in analyzing tissue samples for cancer detection
+
+### Drug Discovery
+AI is accelerating drug discovery processes:
+- Molecular design: AI predicts molecular properties and drug-target interactions
+- Clinical trials: AI optimizes patient recruitment and trial design
+- Repurposing: AI identifies new uses for existing drugs
+
+### Predictive Analytics
+Healthcare providers use AI for:
+- Risk stratification: Identifying patients at risk of complications
+- Early warning systems: Detecting deteriorating patient conditions
+- Resource planning: Optimizing staff schedules and equipment allocation
+
+## Challenges and Considerations
+
+### Data Privacy and Security
+Healthcare AI faces significant challenges:
+- Patient data protection and HIPAA compliance
+- Secure data sharing between institutions
+- Consent management for AI applications
+
+### Regulatory Approval
+AI medical devices require:
+- FDA approval for diagnostic tools
+- Clinical validation studies
+- Post-market surveillance
+
+### Ethical Considerations
+Important ethical aspects include:
+- Algorithmic bias and fairness
+- Transparency and explainability
+- Patient autonomy and informed consent
+
+## Future Directions
+
+### Personalized Medicine
+AI will enable:
+- Genomic-based treatment selection
+- Individualized drug dosing
+- Precision diagnostics
+
+### Integrated Healthcare Systems
+Future developments include:
+- AI-powered electronic health records
+- Interoperable AI systems across healthcare networks
+- Real-time decision support systems
+
+## Conclusion
+AI has tremendous potential to transform healthcare, but successful implementation requires
+addressing technical, regulatory, and ethical challenges while maintaining focus on patient safety
+and improved outcomes.
+"""
+
+# Save the sample document to a temporary file
+temp_dir = tempfile.mkdtemp()
+doc_path = os.path.join(temp_dir, "ai_healthcare_guide.txt")
+with open(doc_path, "w") as f:
+    f.write(sample_document)
+
+# Create an agent with advanced knowledge management configuration
+knowledge_agent = Agent(
+    name="AdvancedKnowledgeAgent",
+    role="Healthcare AI Knowledge Expert", 
+    goal="Provide comprehensive answers about AI in healthcare using advanced knowledge retrieval",
+    backstory="You are an expert in healthcare AI with access to comprehensive knowledge bases and advanced retrieval capabilities.",
+    
+    # Advanced knowledge configuration
+    knowledge=[doc_path],
+    knowledge_config={
+        "vector_store": {
+            "provider": "chroma",
+            "collection_name": "healthcare_ai_knowledge"
+        },
+        "chunking": {
+            "strategy": "semantic",  # Advanced semantic chunking
+            "chunk_size": 500,       # Optimal chunk size for retrieval
+            "chunk_overlap": 50,     # Overlap for context preservation
+            "separators": ["\n\n", "\n", ".", "!", "?"]  # Smart separators
+        },
+        "retrieval": {
+            "search_type": "similarity",
+            "k": 5,  # Retrieve top 5 most relevant chunks
+            "score_threshold": 0.7,  # Minimum relevance score
+            "rerank": True  # Enable reranking for better results
+        },
+        "embedding": {
+            "provider": "openai",
+            "model": "text-embedding-3-small",  # Efficient embedding model
+            "dimensions": 1536
+        }
+    },
+    
+    instructions="""You are an expert in healthcare AI. Use the knowledge base to provide 
+    comprehensive, accurate answers. Always cite specific information from the documents 
+    when possible. If the knowledge base doesn't contain sufficient information, clearly 
+    state this and provide general guidance based on your training.""",
+    
+    verbose=True
+)
+
+# Test advanced knowledge retrieval with various question types
+
+# Factual question about specific applications
+print("="*70)
+print("TESTING: Specific factual question about AI applications")
+print("="*70)
+factual_result = knowledge_agent.start(
+    "What are the current applications of AI in medical imaging according to the knowledge base?"
+)
+print(f"Factual query result:\n{factual_result}\n")
+
+# Complex analytical question requiring synthesis
+print("="*70)
+print("TESTING: Complex analytical question requiring synthesis")  
+print("="*70)
+analytical_result = knowledge_agent.start(
+    "What are the main challenges facing AI implementation in healthcare and how do they relate to each other?"
+)
+print(f"Analytical query result:\n{analytical_result}\n")
+
+# Specific detail extraction
+print("="*70)
+print("TESTING: Specific detail extraction")
+print("="*70)
+detail_result = knowledge_agent.start(
+    "What specific regulatory requirements does the document mention for AI medical devices?"
+)
+print(f"Detail extraction result:\n{detail_result}\n")
+
+# Future-oriented question requiring inference
+print("="*70)
+print("TESTING: Future-oriented question requiring inference")
+print("="*70)
+future_result = knowledge_agent.start(
+    "Based on the knowledge base, what integration capabilities will future AI healthcare systems have?"
+)
+print(f"Future-oriented query result:\n{future_result}\n")
+
+# Question about relationships and connections
+print("="*70)
+print("TESTING: Relationship and connection analysis")
+print("="*70)
+relationship_result = knowledge_agent.start(
+    "How do the ethical considerations mentioned relate to the regulatory approval process for AI in healthcare?"
+)
+print(f"Relationship analysis result:\n{relationship_result}\n")
+
+# Clean up temporary files
+import shutil
+shutil.rmtree(temp_dir)
+
+print("="*80)
+print("ADVANCED KNOWLEDGE MANAGEMENT DEMONSTRATION COMPLETED")
+print("="*80)
+print("This example demonstrated:")
+print("- Semantic chunking for better context preservation")
+print("- Advanced retrieval with reranking capabilities")
+print("- Multiple query types with intelligent responses")
+print("- Knowledge base integration with vector search")
+print("- Configurable embedding and retrieval parameters")

examples/python/processes/advanced-workflow-patterns.py

@@ -0,0 +1,282 @@
+"""
+Advanced Workflow Patterns Example
+
+This example demonstrates sophisticated workflow orchestration patterns including
+conditional routing, decision trees, loops, and complex multi-agent coordination.
+
+Features demonstrated:
+- Advanced workflow patterns with conditional routing
+- Decision trees and dynamic task routing
+- Loop-based processing with exit conditions
+- Complex agent coordination and handoffs
+- State-based workflow management
+"""
+
+from praisonaiagents import Agent, Task, PraisonAIAgents
+from praisonaiagents.tools import duckduckgo
+import random
+
+# Create specialized agents for complex workflow
+intake_agent = Agent(
+    name="IntakeAgent",
+    role="Request Intake Specialist",
+    goal="Classify and route incoming requests to appropriate specialists",
+    backstory="You are an intake specialist who categorizes requests and determines the appropriate workflow path.",
+    instructions="Analyze incoming requests and categorize them by type (research, analysis, technical, creative) and complexity (low, medium, high)."
+)
+
+research_agent = Agent(
+    name="ResearchAgent", 
+    role="Research Specialist",
+    goal="Conduct comprehensive research on assigned topics",
+    backstory="You are a research specialist who gathers and analyzes information from various sources.",
+    tools=[duckduckgo],
+    instructions="Conduct thorough research using available tools. Provide detailed findings with sources."
+)
+
+analysis_agent = Agent(
+    name="AnalysisAgent",
+    role="Data Analysis Expert",
+    goal="Analyze data and provide insights",
+    backstory="You are a data analysis expert who identifies patterns, trends, and actionable insights.",
+    instructions="Analyze provided data to identify key insights, trends, and recommendations."
+)
+
+technical_agent = Agent(
+    name="TechnicalAgent",
+    role="Technical Solutions Specialist", 
+    goal="Provide technical solutions and implementations",
+    backstory="You are a technical specialist who designs and implements technical solutions.",
+    instructions="Provide detailed technical solutions with implementation guidance and best practices."
+)
+
+creative_agent = Agent(
+    name="CreativeAgent",
+    role="Creative Content Specialist",
+    goal="Create engaging and creative content",
+    backstory="You are a creative specialist who develops engaging content and innovative solutions.",
+    instructions="Create original, engaging content that meets the specified requirements."
+)
+
+review_agent = Agent(
+    name="ReviewAgent",
+    role="Quality Review Specialist",
+    goal="Review work quality and provide feedback",
+    backstory="You are a quality reviewer who ensures all work meets high standards.",
+    instructions="Review completed work for quality, accuracy, and completeness. Provide specific feedback."
+)
+
+coordinator_agent = Agent(
+    name="CoordinatorAgent",
+    role="Workflow Coordinator",
+    goal="Coordinate complex workflows and manage handoffs",
+    backstory="You are a workflow coordinator who manages complex multi-agent processes.",
+    instructions="Coordinate workflow execution, manage handoffs between agents, and ensure successful completion."
+)
+
+# Define workflow state management
+workflow_state = {
+    "request_count": 0,
+    "completed_tasks": [],
+    "active_workflows": [],
+    "quality_threshold": 0.8
+}
+
+# Simulate incoming requests of different types
+sample_requests = [
+    {
+        "id": "REQ001",
+        "type": "market_research", 
+        "description": "Research emerging trends in sustainable technology",
+        "complexity": "medium",
+        "priority": "high"
+    },
+    {
+        "id": "REQ002",
+        "type": "technical_solution",
+        "description": "Design architecture for distributed AI system",
+        "complexity": "high", 
+        "priority": "medium"
+    },
+    {
+        "id": "REQ003",
+        "type": "creative_content",
+        "description": "Create marketing campaign for new product launch",
+        "complexity": "medium",
+        "priority": "high"
+    },
+    {
+        "id": "REQ004",
+        "type": "data_analysis",
+        "description": "Analyze customer behavior patterns from sales data",
+        "complexity": "low",
+        "priority": "low"
+    }
+]
+
+# Process each request through the advanced workflow
+for request in sample_requests:
+    print(f"\n{'='*80}")
+    print(f"PROCESSING REQUEST {request['id']}: {request['type'].upper()}")
+    print(f"Description: {request['description']}")
+    print(f"Complexity: {request['complexity']} | Priority: {request['priority']}")
+    print(f"{'='*80}")
+    
+    workflow_state["request_count"] += 1
+    workflow_state["active_workflows"].append(request["id"])
+    
+    # Step 1: Intake and Classification
+    intake_task = Task(
+        name=f"intake_{request['id']}",
+        description=f"Classify and route this request: {request['description']} (Type: {request['type']}, Complexity: {request['complexity']})",
+        expected_output="Request classification with recommended workflow path and agent assignment",
+        agent=intake_agent
+    )
+    
+    # Step 2: Route to appropriate specialist based on type
+    if request['type'] == 'market_research':
+        specialist_agent = research_agent
+        specialist_task_desc = f"Conduct comprehensive market research on: {request['description']}"
+    elif request['type'] == 'technical_solution':
+        specialist_agent = technical_agent
+        specialist_task_desc = f"Design technical solution for: {request['description']}"
+    elif request['type'] == 'creative_content':
+        specialist_agent = creative_agent
+        specialist_task_desc = f"Create creative content for: {request['description']}"
+    elif request['type'] == 'data_analysis':
+        specialist_agent = analysis_agent
+        specialist_task_desc = f"Analyze data for: {request['description']}"
+    else:
+        specialist_agent = research_agent  # Default fallback
+        specialist_task_desc = f"Process request: {request['description']}"
+    
+    specialist_task = Task(
+        name=f"specialist_{request['id']}",
+        description=specialist_task_desc,
+        expected_output="Comprehensive response addressing the request requirements",
+        agent=specialist_agent,
+        context=[intake_task]
+    )
+    
+    # Step 3: Quality Review with conditional routing
+    review_task = Task(
+        name=f"review_{request['id']}",
+        description=f"Review the quality of work completed for request {request['id']}. Assess if it meets standards or needs revision.",
+        expected_output="Quality assessment with pass/fail decision and specific feedback",
+        agent=review_agent,
+        context=[intake_task, specialist_task],
+        
+        # Conditional routing based on quality
+        task_type="decision",
+        condition={
+            "approved": [f"finalization_{request['id']}"],  # If approved, finalize
+            "needs_revision": [f"revision_{request['id']}"],  # If needs work, revise
+            "needs_escalation": [f"escalation_{request['id']}"]  # If complex, escalate
+        }
+    )
+    
+    # Step 4a: Revision Task (conditional)
+    revision_task = Task(
+        name=f"revision_{request['id']}",
+        description=f"Revise the work based on quality review feedback for request {request['id']}",
+        expected_output="Revised work addressing quality review feedback",
+        agent=specialist_agent,
+        context=[specialist_task, review_task]
+    )
+    
+    # Step 4b: Escalation Task (conditional)
+    escalation_task = Task(
+        name=f"escalation_{request['id']}",
+        description=f"Handle escalated request {request['id']} requiring additional expertise or coordination",
+        expected_output="Escalated response with enhanced solution approach",
+        agent=coordinator_agent,
+        context=[intake_task, specialist_task, review_task]
+    )
+    
+    # Step 5: Finalization and Coordination
+    finalization_task = Task(
+        name=f"finalization_{request['id']}",
+        description=f"Finalize and package the completed work for request {request['id']}",
+        expected_output="Final deliverable package with summary and next steps",
+        agent=coordinator_agent,
+        context=[intake_task, specialist_task, review_task]
+    )
+    
+    # Execute the workflow with conditional routing
+    workflow_agents = PraisonAIAgents(
+        agents=[
+            intake_agent, specialist_agent, review_agent, 
+            coordinator_agent
+        ],
+        tasks=[
+            intake_task, specialist_task, review_task,
+            revision_task,      # Conditional
+            escalation_task,    # Conditional  
+            finalization_task
+        ],
+        process="workflow",  # Use workflow process for conditional execution
+        verbose=True
+    )
+    
+    print(f"Executing advanced workflow for {request['id']}...")
+    result = workflow_agents.start()
+    
+    # Update workflow state
+    workflow_state["completed_tasks"].append(request["id"])
+    workflow_state["active_workflows"].remove(request["id"])
+    
+    # Simulate quality scoring
+    quality_score = random.uniform(0.75, 0.95)
+    
+    print(f"✅ Request {request['id']} completed with quality score: {quality_score:.2f}")
+    print(f"📋 Result preview: {str(result)[:150]}...")
+    
+    # Loop control - if we have processed enough requests, demonstrate loop exit
+    if workflow_state["request_count"] >= 2:
+        print(f"\n🔄 WORKFLOW LOOP CONTROL: Processed {workflow_state['request_count']} requests")
+        print("Checking if we should continue or exit based on workflow state...")
+        
+        # Example loop control logic
+        if workflow_state["request_count"] >= 4:
+            print("📊 Batch processing complete. Exiting workflow loop.")
+            break
+        else:
+            print("📈 Continuing with next request in the batch...")
+
+# Advanced Workflow Analytics and Summary
+print(f"\n{'='*80}")
+print("ADVANCED WORKFLOW PATTERNS SUMMARY")
+print(f"{'='*80}")
+
+print(f"📊 Workflow Statistics:")
+print(f"- Total Requests Processed: {workflow_state['request_count']}")
+print(f"- Completed Tasks: {len(workflow_state['completed_tasks'])}")
+print(f"- Active Workflows: {len(workflow_state['active_workflows'])}")
+
+print(f"\n🔀 Workflow Patterns Demonstrated:")
+print("- Dynamic request classification and routing")
+print("- Conditional task execution based on quality review")
+print("- Multi-path workflows (approval/revision/escalation)")
+print("- State-based workflow management")
+print("- Loop control with exit conditions")
+print("- Agent specialization and handoffs")
+
+print(f"\n⚙️ Advanced Features Used:")
+print("- Workflow process type with conditional routing")
+print("- Decision tasks with multiple outcome paths")
+print("- Context passing between related tasks")
+print("- State management across workflow iterations")
+print("- Quality-based routing decisions")
+print("- Scalable agent coordination patterns")
+
+print(f"\n🎯 Production Benefits:")
+print("- Handles complex, multi-step business processes")
+print("- Automatically routes work to appropriate specialists")
+print("- Implements quality gates and revision loops")
+print("- Scales to handle multiple concurrent workflows")
+print("- Provides visibility into workflow state and progress")
+print("- Enables sophisticated business process automation")
+
+print(f"\n{'='*80}")
+print("ADVANCED WORKFLOW DEMONSTRATION COMPLETED")
+print(f"{'='*80}")

examples/python/processes/hierarchical-process-example.py

@@ -0,0 +1,99 @@
+"""
+Hierarchical Process Example
+
+This example demonstrates how to create a hierarchical process where a manager agent
+delegates tasks to specialized worker agents. The manager orchestrates the workflow
+and each specialized agent performs their specific tasks.
+
+Features demonstrated:
+- Hierarchical agent structure with manager and workers  
+- Task delegation and coordination
+- Specialized agent roles with different capabilities
+- Process-level orchestration
+"""
+
+from praisonaiagents import Agent, Task, PraisonAIAgents
+from praisonaiagents.tools import duckduckgo
+
+# Create Manager Agent
+manager = Agent(
+    name="Manager",
+    role="Project Manager",
+    goal="Coordinate research and analysis tasks among specialized agents",
+    backstory="You are an experienced project manager who delegates tasks to specialized team members and synthesizes their work into a comprehensive report.",
+    instructions="You coordinate tasks between researchers and analysts. Delegate research to the researcher, data analysis to the analyst, and writing to the writer."
+)
+
+# Create Specialized Worker Agents
+researcher = Agent(
+    name="Researcher", 
+    role="Senior Researcher",
+    goal="Conduct thorough research on given topics",
+    backstory="You are a senior researcher with expertise in gathering and analyzing information from various sources.",
+    tools=[duckduckgo],
+    instructions="Conduct comprehensive research using web search. Provide detailed, factual information with sources."
+)
+
+data_analyst = Agent(
+    name="DataAnalyst",
+    role="Data Analyst", 
+    goal="Analyze trends and patterns in research data",
+    backstory="You are a skilled data analyst who can identify trends, patterns, and insights from research data.",
+    instructions="Analyze research data to identify key trends, patterns, and actionable insights. Provide data-driven conclusions."
+)
+
+writer = Agent(
+    name="Writer",
+    role="Technical Writer",
+    goal="Create well-structured reports and documentation", 
+    backstory="You are a technical writer who excels at creating clear, comprehensive reports from research and analysis.",
+    instructions="Create well-structured, professional reports that synthesize research findings and analysis into actionable insights."
+)
+
+# Define Hierarchical Tasks
+research_task = Task(
+    name="research_task",
+    description="Research the latest trends in artificial intelligence and machine learning for business applications",
+    expected_output="Comprehensive research report with current AI/ML trends, key players, and business applications",
+    agent=researcher
+)
+
+analysis_task = Task(
+    name="analysis_task", 
+    description="Analyze the research findings to identify the most promising AI/ML trends for business adoption",
+    expected_output="Analysis report highlighting top 5 AI/ML trends with business impact assessment",
+    agent=data_analyst,
+    context=[research_task]  # Depends on research task
+)
+
+writing_task = Task(
+    name="writing_task",
+    description="Create a final executive summary combining research and analysis into actionable business recommendations",
+    expected_output="Executive summary with strategic recommendations for AI/ML adoption",
+    agent=writer,
+    context=[research_task, analysis_task]  # Depends on both previous tasks
+)
+
+coordination_task = Task(
+    name="coordination_task",
+    description="Oversee the entire research project, ensure quality and coordination between all team members",
+    expected_output="Project oversight report confirming successful completion and quality of all deliverables",
+    agent=manager,
+    context=[research_task, analysis_task, writing_task]  # Oversees all tasks
+)
+
+# Create Hierarchical Process
+agents = PraisonAIAgents(
+    agents=[manager, researcher, data_analyst, writer],
+    tasks=[research_task, analysis_task, writing_task, coordination_task],
+    process="hierarchical",  # Hierarchical process type
+    verbose=True
+)
+
+# Execute Hierarchical Process
+result = agents.start()
+
+print("\n" + "="*50)
+print("HIERARCHICAL PROCESS COMPLETED")
+print("="*50)
+print(f"Final Result:\n{result}")

examples/python/sessions/comprehensive-session-management.py

@@ -0,0 +1,250 @@
+"""
+Comprehensive Session Management Example
+
+This example demonstrates advanced session management capabilities including
+session persistence, recovery, state management, and multi-session coordination.
+
+Features demonstrated:
+- Session creation and persistence
+- State management across sessions
+- Session recovery after interruption
+- Multi-user session coordination
+- Session-specific memory and knowledge
+"""
+
+from praisonaiagents import Agent, Task, PraisonAIAgents
+from praisonaiagents.session import Session
+from praisonaiagents.tools import duckduckgo
+import tempfile
+import os
+import json
+
+# Create a temporary directory for session storage
+session_dir = tempfile.mkdtemp()
+print(f"Session storage directory: {session_dir}")
+
+# Create agents for session-based workflows
+research_agent = Agent(
+    name="SessionResearcher",
+    role="Research Specialist",
+    goal="Conduct research while maintaining session context",
+    backstory="You are a research specialist who maintains context across multiple sessions and can resume work from where you left off.",
+    tools=[duckduckgo],
+    instructions="Conduct thorough research and maintain awareness of previous session context when available."
+)
+
+analysis_agent = Agent(
+    name="SessionAnalyst", 
+    role="Data Analyst",
+    goal="Analyze data while preserving session state",
+    backstory="You are a data analyst who can maintain analysis context across sessions and build upon previous work.",
+    instructions="Analyze research data and build upon any previous analysis from earlier sessions."
+)
+
+# Session 1: Initial Research Session
+print("="*70)
+print("SESSION 1: INITIAL RESEARCH SESSION")
+print("="*70)
+
+# Create first session
+session1 = Session(
+    session_id="research_project_001",
+    user_id="user_researcher_01",
+    storage_path=session_dir
+)
+
+# Create initial research task
+research_task1 = Task(
+    name="initial_research",
+    description="Research the latest trends in sustainable technology for manufacturing",
+    expected_output="Comprehensive research report on sustainable manufacturing technology trends",
+    agent=research_agent
+)
+
+# Create agents with session
+agents_session1 = PraisonAIAgents(
+    agents=[research_agent],
+    tasks=[research_task1],
+    session=session1,
+    verbose=True
+)
+
+# Execute first session
+print("Starting initial research session...")
+result1 = agents_session1.start()
+
+# Save session state
+session1.save()
+print(f"Session 1 completed and saved. Result preview: {str(result1)[:200]}...")
+
+# Session 2: Analysis Session (same user, continuation)
+print("\n" + "="*70)
+print("SESSION 2: ANALYSIS SESSION (CONTINUING WORK)")
+print("="*70)
+
+# Create second session for analysis
+session2 = Session(
+    session_id="research_project_002", 
+    user_id="user_researcher_01",  # Same user
+    storage_path=session_dir
+)
+
+# Load previous session context (simulating session recovery)
+# In real usage, you might load from database or persistent storage
+session2.set_state("previous_research_summary", str(result1)[:500])
+
+analysis_task = Task(
+    name="trend_analysis",
+    description="Analyze the research findings to identify the top 5 most promising sustainable manufacturing technologies",
+    expected_output="Analysis report with top 5 sustainable manufacturing technologies and their potential impact",
+    agent=analysis_agent,
+    # Pass context from previous session
+    context_variables={"previous_research": str(result1)}
+)
+
+agents_session2 = PraisonAIAgents(
+    agents=[analysis_agent],
+    tasks=[analysis_task], 
+    session=session2,
+    verbose=True
+)
+
+print("Starting analysis session with previous context...")
+result2 = agents_session2.start()
+
+# Save session state
+session2.save()
+print(f"Session 2 completed and saved. Result preview: {str(result2)[:200]}...")
+
+# Session 3: Recovery Demonstration
+print("\n" + "="*70)
+print("SESSION 3: RECOVERY DEMONSTRATION")
+print("="*70)
+
+# Simulate session recovery after interruption
+recovery_session = Session(
+    session_id="research_project_recovery",
+    user_id="user_researcher_01",
+    storage_path=session_dir
+)
+
+# Load state from previous sessions
+recovery_session.set_state("research_summary", str(result1)[:300])
+recovery_session.set_state("analysis_summary", str(result2)[:300])
+
+# Create a synthesis task that uses recovered session state
+synthesis_agent = Agent(
+    name="SynthesisAgent",
+    role="Research Synthesizer", 
+    goal="Synthesize research and analysis into actionable recommendations",
+    backstory="You synthesize research and analysis from multiple sessions into comprehensive recommendations.",
+    instructions="Use the session context to create comprehensive recommendations based on all previous work."
+)
+
+synthesis_task = Task(
+    name="synthesis_report",
+    description="Create a comprehensive synthesis report with actionable recommendations based on all previous research and analysis",
+    expected_output="Executive synthesis report with strategic recommendations",
+    agent=synthesis_agent,
+    # Access session state
+    context_variables={
+        "research_context": recovery_session.get_state("research_summary"),
+        "analysis_context": recovery_session.get_state("analysis_summary")
+    }
+)
+
+agents_recovery = PraisonAIAgents(
+    agents=[synthesis_agent],
+    tasks=[synthesis_task],
+    session=recovery_session,
+    verbose=True
+)
+
+print("Starting recovery session with full context from previous sessions...")
+result3 = agents_recovery.start()
+
+# Save final session
+recovery_session.save()
+print(f"Recovery session completed. Result preview: {str(result3)[:200]}...")
+
+# Session 4: Multi-User Coordination Demo
+print("\n" + "="*70) 
+print("SESSION 4: MULTI-USER COORDINATION DEMO")
+print("="*70)
+
+# Create sessions for different users working on the same project
+reviewer_session = Session(
+    session_id="peer_review_001",
+    user_id="user_reviewer_01",  # Different user
+    storage_path=session_dir
+)
+
+# Reviewer can access shared project context
+reviewer_session.set_state("shared_research", str(result1)[:400])
+reviewer_session.set_state("shared_analysis", str(result2)[:400])
+reviewer_session.set_state("shared_synthesis", str(result3)[:400])
+
+review_agent = Agent(
+    name="PeerReviewer",
+    role="Research Peer Reviewer",
+    goal="Provide expert peer review of research, analysis, and synthesis",
+    backstory="You are a peer reviewer who evaluates research quality and provides constructive feedback.",
+    instructions="Review all provided work and provide constructive feedback with specific suggestions for improvement."
+)
+
+review_task = Task(
+    name="peer_review",
+    description="Conduct peer review of the research project including research, analysis, and synthesis phases",
+    expected_output="Comprehensive peer review with specific feedback and recommendations for improvement",
+    agent=review_agent,
+    context_variables={
+        "research_to_review": reviewer_session.get_state("shared_research"),
+        "analysis_to_review": reviewer_session.get_state("shared_analysis"), 
+        "synthesis_to_review": reviewer_session.get_state("shared_synthesis")
+    }
+)
+
+agents_reviewer = PraisonAIAgents(
+    agents=[review_agent],
+    tasks=[review_task],
+    session=reviewer_session,
+    verbose=True
+)
+
+print("Starting peer review session by different user...")
+result4 = agents_reviewer.start()
+
+# Save reviewer session
+reviewer_session.save()
+print(f"Peer review session completed. Result preview: {str(result4)[:200]}...")
+
+# Session Summary and Cleanup
+print("\n" + "="*80)
+print("SESSION MANAGEMENT DEMONSTRATION SUMMARY")
+print("="*80)
+
+# Display session information
+print("Sessions created:")
+print(f"1. Research Session (ID: research_project_001, User: user_researcher_01)")
+print(f"2. Analysis Session (ID: research_project_002, User: user_researcher_01)")  
+print(f"3. Recovery Session (ID: research_project_recovery, User: user_researcher_01)")
+print(f"4. Review Session (ID: peer_review_001, User: user_reviewer_01)")
+
+print("\nSession capabilities demonstrated:")
+print("- Session persistence and state management")
+print("- Context passing between sessions")
+print("- Session recovery after interruption")
+print("- Multi-user session coordination")
+print("- State sharing across different users")
+print("- Session-specific task execution")
+
+# List session files created
+session_files = [f for f in os.listdir(session_dir) if f.endswith('.json')]
+print(f"\nSession files created: {len(session_files)}")
+for file in session_files:
+    print(f"  - {file}")
+
+# Cleanup
+import shutil
+shutil.rmtree(session_dir)
+print(f"\nCleanup completed. Temporary session directory removed.")

examples/python/tasks/advanced-task-management.py

@@ -0,0 +1,236 @@
+"""
+Advanced Task Management Example
+
+This example demonstrates sophisticated task management including conditional execution,
+validation feedback loops, dynamic task routing, and complex task dependencies.
+
+Features demonstrated:
+- Conditional task execution based on results
+- Validation feedback loops with retry mechanisms  
+- Dynamic task routing and decision trees
+- Complex task dependencies and context passing
+- Quality assurance workflows
+"""
+
+from praisonaiagents import Agent, Task, PraisonAIAgents
+from praisonaiagents.task import TaskOutput
+from praisonaiagents.tools import duckduckgo
+from typing import Tuple, Any
+import json
+
+# Define validation functions for task outputs
+def data_quality_validator(task_output: TaskOutput) -> Tuple[bool, Any]:
+    """
+    Validates data quality and completeness for research tasks.
+    """
+    output_text = str(task_output.raw).lower()
+    
+    # Check for key quality indicators
+    quality_indicators = [
+        'source', 'data', 'research', 'study', 'analysis',
+        'findings', 'results', 'conclusion', 'evidence'
+    ]
+    
+    found_indicators = sum(1 for indicator in quality_indicators if indicator in output_text)
+    
+    if found_indicators >= 4:  # Require at least 4 quality indicators
+        return True, task_output
+    else:
+        return False, f"Data quality insufficient. Found {found_indicators} quality indicators but need at least 4. Please include more research sources, data analysis, and evidence."
+
+def completeness_validator(task_output: TaskOutput) -> Tuple[bool, Any]:
+    """
+    Validates that the analysis is complete and comprehensive.
+    """
+    output_text = str(task_output.raw)
+    word_count = len(output_text.split())
+    
+    # Check for completeness indicators
+    has_introduction = 'introduction' in output_text.lower() or output_text.startswith(('In ', 'The ', 'This '))
+    has_conclusion = any(word in output_text.lower() for word in ['conclusion', 'summary', 'in summary', 'to conclude'])
+    sufficient_length = word_count >= 100
+    
+    if has_introduction and has_conclusion and sufficient_length:
+        return True, task_output
+    else:
+        missing = []
+        if not has_introduction:
+            missing.append("proper introduction")
+        if not has_conclusion:
+            missing.append("conclusion or summary")
+        if not sufficient_length:
+            missing.append(f"sufficient detail (need 100+ words, found {word_count})")
+        
+        return False, f"Analysis incomplete. Missing: {', '.join(missing)}. Please provide a more comprehensive response."
+
+# Create specialized agents for the workflow
+research_agent = Agent(
+    name="ResearchAgent",
+    role="Senior Research Analyst",
+    goal="Conduct comprehensive research and gather high-quality data",
+    backstory="You are a senior research analyst with expertise in data collection and analysis.",
+    tools=[duckduckgo],
+    instructions="Conduct thorough research using multiple sources. Provide detailed findings with proper citations and data analysis."
+)
+
+quality_checker = Agent(
+    name="QualityChecker", 
+    role="Quality Assurance Specialist",
+    goal="Validate research quality and completeness",
+    backstory="You are a QA specialist who ensures all research meets high standards of quality and completeness.",
+    instructions="Review research outputs for quality, accuracy, and completeness. Provide specific feedback for improvements."
+)
+
+analyst = Agent(
+    name="DataAnalyst",
+    role="Data Analysis Expert", 
+    goal="Analyze research data and identify key insights",
+    backstory="You are a data analysis expert who can identify patterns, trends, and actionable insights from research data.",
+    instructions="Analyze research data to identify key trends, patterns, and strategic insights. Provide data-driven recommendations."
+)
+
+decision_maker = Agent(
+    name="DecisionMaker",
+    role="Strategic Decision Maker",
+    goal="Make strategic decisions based on analysis results",
+    backstory="You are a strategic decision maker who evaluates analysis results and determines next steps.",
+    instructions="Review analysis results and make strategic decisions about whether to proceed, modify approach, or conduct additional research."
+)
+
+report_writer = Agent(
+    name="ReportWriter",
+    role="Executive Report Writer",
+    goal="Create comprehensive executive reports",
+    backstory="You are an executive report writer who synthesizes research and analysis into actionable business reports.",
+    instructions="Create comprehensive executive reports that synthesize research findings and analysis into clear, actionable recommendations."
+)
+
+# Define conditional task execution workflow
+
+# Initial research task with quality validation
+initial_research = Task(
+    name="initial_research",
+    description="Research the current state of renewable energy adoption in the business sector, including trends, challenges, and opportunities",
+    expected_output="Comprehensive research report on renewable energy adoption in business",
+    agent=research_agent,
+    guardrail=data_quality_validator,
+    max_retries=3
+)
+
+# Quality check task - conditional on research quality
+quality_check = Task(
+    name="quality_assessment",
+    description="Assess the quality and completeness of the research findings. Determine if additional research is needed.",
+    expected_output="Quality assessment report with go/no-go decision for proceeding to analysis",
+    agent=quality_checker,
+    context=[initial_research],
+    guardrail=completeness_validator,
+    max_retries=2
+)
+
+# Conditional task - only execute if quality check passes
+data_analysis = Task(
+    name="data_analysis",
+    description="Analyze the research data to identify key trends, market opportunities, and strategic recommendations for renewable energy adoption",
+    expected_output="Strategic analysis with key insights and recommendations",
+    agent=analyst,
+    context=[initial_research, quality_check],
+    
+    # Conditional execution based on quality check
+    task_type="decision",
+    condition={
+        "proceed": ["final_report"],  # If analysis is good, proceed to final report
+        "needs_more_research": ["additional_research"],  # If needs more data, do additional research
+        "insufficient_data": []  # If data is insufficient, stop workflow
+    }
+)
+
+# Additional research task (conditional execution)
+additional_research = Task(
+    name="additional_research", 
+    description="Conduct additional targeted research to fill gaps identified in the quality assessment",
+    expected_output="Supplementary research addressing identified gaps",
+    agent=research_agent,
+    context=[initial_research, quality_check],
+    tools=[duckduckgo],
+    guardrail=data_quality_validator,
+    max_retries=2
+)
+
+# Decision point task
+decision_task = Task(
+    name="strategic_decision",
+    description="Based on all available research and analysis, make a strategic decision about renewable energy investment recommendations",
+    expected_output="Strategic decision with clear reasoning and recommended next steps",
+    agent=decision_maker,
+    context=[initial_research, quality_check, data_analysis],
+    
+    # This task determines the workflow path
+    task_type="decision",
+    condition={
+        "high_confidence": ["final_report"],
+        "medium_confidence": ["risk_analysis"], 
+        "low_confidence": ["additional_research"]
+    }
+)
+
+# Risk analysis task (conditional)
+risk_analysis = Task(
+    name="risk_analysis",
+    description="Conduct detailed risk analysis for renewable energy investment recommendations",
+    expected_output="Comprehensive risk assessment with mitigation strategies",
+    agent=analyst,
+    context=[initial_research, data_analysis, decision_task]
+)
+
+# Final report task
+final_report = Task(
+    name="final_report",
+    description="Create a comprehensive executive report synthesizing all research, analysis, and strategic recommendations",
+    expected_output="Executive report with strategic recommendations for renewable energy adoption",
+    agent=report_writer,
+    context=[initial_research, quality_check, data_analysis, decision_task],
+    guardrail=completeness_validator,
+    max_retries=2
+)
+
+# Create workflow with conditional execution
+workflow = PraisonAIAgents(
+    agents=[research_agent, quality_checker, analyst, decision_maker, report_writer],
+    tasks=[
+        initial_research, 
+        quality_check, 
+        data_analysis, 
+        additional_research,  # Conditional
+        decision_task,
+        risk_analysis,        # Conditional
+        final_report
+    ],
+    process="workflow",  # Use workflow process for conditional execution
+    verbose=True
+)
+
+print("="*80)
+print("EXECUTING ADVANCED TASK MANAGEMENT WORKFLOW")
+print("="*80)
+print("This workflow includes:")
+print("- Quality validation with retry mechanisms")
+print("- Conditional task execution based on results")
+print("- Dynamic routing and decision points")
+print("- Complex task dependencies")
+print("="*80)
+
+# Execute the conditional workflow
+result = workflow.start()
+
+print("\n" + "="*80)
+print("ADVANCED TASK MANAGEMENT COMPLETED")
+print("="*80)
+print("This example demonstrated:")
+print("- Conditional task execution based on validation results")
+print("- Quality validation with specific feedback for improvements") 
+print("- Dynamic workflow routing with decision points")
+print("- Complex task dependencies and context passing")
+print("- Retry mechanisms with iterative improvement")
+print("- Multi-stage validation and quality assurance")
+print(f"\nFinal Result Summary:\n{result}")

examples/python/telemetry/production-telemetry-example.py

@@ -0,0 +1,286 @@
+"""
+Production Telemetry Example
+
+This example demonstrates comprehensive telemetry and monitoring setup for
+production AI agent systems, including metrics collection, performance tracking,
+and observability.
+
+Features demonstrated:
+- OpenTelemetry integration for distributed tracing
+- Custom metrics collection and monitoring
+- Performance tracking and analytics
+- Error tracking and alerting
+- Usage analytics and reporting
+"""
+
+from praisonaiagents import Agent, Task, PraisonAIAgents
+from praisonaiagents.tools import duckduckgo
+from praisonaiagents.telemetry import enable_telemetry
+import time
+import random
+from datetime import datetime
+
+# Initialize telemetry for production monitoring
+print("="*80)
+print("PRODUCTION TELEMETRY SETUP")
+print("="*80)
+
+# Configure telemetry (in production, you'd use actual telemetry backends)
+telemetry = enable_telemetry(
+    backend="opentelemetry",
+    config={
+        "service_name": "praisonai_production_agents",
+        "service_version": "1.0.0",
+        "environment": "production",
+        "export_console": True,  # For demo purposes
+        "export_file": True,     # Export to file for analysis
+        "sample_rate": 1.0,      # 100% sampling for demo
+        "attributes": {
+            "deployment": "cloud",
+            "region": "us-east-1",
+            "cluster": "main"
+        }
+    }
+)
+
+# Create agents for production workflow with telemetry
+customer_service_agent = Agent(
+    name="CustomerServiceAgent",
+    role="Customer Service Representative", 
+    goal="Provide excellent customer service with fast response times",
+    backstory="You are a customer service representative focused on resolving customer issues quickly and effectively.",
+    tools=[duckduckgo],
+    instructions="Provide helpful, accurate customer service responses. Research solutions when needed."
+)
+
+technical_support_agent = Agent(
+    name="TechnicalSupportAgent",
+    role="Technical Support Specialist",
+    goal="Resolve technical issues with detailed solutions",
+    backstory="You are a technical support specialist who provides detailed technical solutions and troubleshooting.",
+    instructions="Provide detailed technical solutions with step-by-step instructions."
+)
+
+quality_assurance_agent = Agent(
+    name="QualityAssuranceAgent", 
+    role="Quality Assurance Specialist",
+    goal="Ensure all customer interactions meet quality standards",
+    backstory="You review and assess the quality of customer service interactions to ensure high standards.",
+    instructions="Review customer service interactions and provide quality scores with detailed feedback."
+)
+
+# Production workflow simulation with telemetry tracking
+def simulate_customer_requests():
+    """Simulate various customer requests for telemetry demonstration"""
+    
+    customer_requests = [
+        {
+            "type": "billing_inquiry",
+            "complexity": "low",
+            "description": "Customer asking about their monthly bill charges",
+            "expected_duration": 30
+        },
+        {
+            "type": "technical_issue", 
+            "complexity": "high",
+            "description": "Customer experiencing connectivity issues with the service",
+            "expected_duration": 120
+        },
+        {
+            "type": "account_setup",
+            "complexity": "medium", 
+            "description": "New customer needs help setting up their account",
+            "expected_duration": 60
+        },
+        {
+            "type": "feature_question",
+            "complexity": "low",
+            "description": "Customer asking about product features and capabilities",
+            "expected_duration": 45
+        }
+    ]
+    
+    return customer_requests
+
+# Execute production workflow with comprehensive telemetry
+print("Starting production workflow with telemetry tracking...")
+
+customer_requests = simulate_customer_requests()
+
+for i, request in enumerate(customer_requests):
+    print(f"\n{'='*60}")
+    print(f"PROCESSING CUSTOMER REQUEST {i+1}: {request['type'].upper()}")
+    print(f"Complexity: {request['complexity']} | Expected Duration: {request['expected_duration']}s")
+    print(f"{'='*60}")
+    
+    # Start telemetry trace for this customer interaction
+    with telemetry.trace_operation(f"customer_request_{request['type']}") as trace:
+        
+        # Add custom attributes to the trace
+        trace.set_attributes({
+            "request.type": request['type'],
+            "request.complexity": request['complexity'],
+            "request.expected_duration": request['expected_duration'],
+            "customer.id": f"customer_{random.randint(1000, 9999)}",
+            "agent.assigned": "CustomerServiceAgent"
+        })
+        
+        start_time = time.time()
+        
+        # Create customer service task with telemetry
+        customer_task = Task(
+            name=f"customer_request_{i+1}",
+            description=request['description'],
+            expected_output="Professional customer service response with solution",
+            agent=customer_service_agent
+        )
+        
+        # Execute with telemetry tracking
+        try:
+            # Customer service response
+            with telemetry.trace_agent_execution("CustomerServiceAgent") as agent_trace:
+                agents = PraisonAIAgents(
+                    agents=[customer_service_agent],
+                    tasks=[customer_task],
+                    verbose=False  # Reduce verbosity for telemetry demo
+                )
+                
+                cs_result = agents.start()
+                agent_trace.set_attributes({
+                    "agent.response_length": len(str(cs_result)),
+                    "agent.tools_used": len(customer_service_agent.tools) if customer_service_agent.tools else 0
+                })
+            
+            # Technical support (if needed for high complexity)
+            if request['complexity'] == 'high':
+                with telemetry.trace_agent_execution("TechnicalSupportAgent") as tech_trace:
+                    tech_task = Task(
+                        name=f"technical_support_{i+1}",
+                        description=f"Provide detailed technical support for: {request['description']}",
+                        expected_output="Detailed technical solution with troubleshooting steps",
+                        agent=technical_support_agent,
+                        context=[customer_task]
+                    )
+                    
+                    tech_agents = PraisonAIAgents(
+                        agents=[technical_support_agent],
+                        tasks=[tech_task],
+                        verbose=False
+                    )
+                    
+                    tech_result = tech_agents.start()
+                    tech_trace.set_attributes({
+                        "agent.response_length": len(str(tech_result)),
+                        "agent.escalation": True
+                    })
+            
+            # Quality assurance check
+            with telemetry.trace_agent_execution("QualityAssuranceAgent") as qa_trace:
+                qa_task = Task(
+                    name=f"quality_check_{i+1}",
+                    description=f"Review the quality of customer service provided for: {request['description']}",
+                    expected_output="Quality assessment score and feedback",
+                    agent=quality_assurance_agent
+                )
+                
+                qa_agents = PraisonAIAgents(
+                    agents=[quality_assurance_agent],
+                    tasks=[qa_task],
+                    verbose=False
+                )
+                
+                qa_result = qa_agents.start()
+                
+                # Extract quality score (simulated)
+                quality_score = random.uniform(0.8, 1.0)  # Simulated score
+                qa_trace.set_attributes({
+                    "qa.score": quality_score,
+                    "qa.passed": quality_score >= 0.85
+                })
+            
+            # Calculate performance metrics
+            end_time = time.time()
+            duration = end_time - start_time
+            
+            # Record custom metrics
+            telemetry.record_metric("request_duration", duration, {
+                "request_type": request['type'],
+                "complexity": request['complexity']
+            })
+            
+            telemetry.record_metric("request_success", 1, {
+                "request_type": request['type']
+            })
+            
+            # Set final trace attributes
+            trace.set_attributes({
+                "request.duration_seconds": duration,
+                "request.status": "completed",
+                "request.quality_score": quality_score,
+                "request.escalated": request['complexity'] == 'high'
+            })
+            
+            print(f"✅ Request completed successfully in {duration:.2f}s (Quality: {quality_score:.2f})")
+            
+        except Exception as e:
+            # Record error metrics
+            telemetry.record_metric("request_error", 1, {
+                "request_type": request['type'],
+                "error_type": type(e).__name__
+            })
+            
+            trace.set_attributes({
+                "request.status": "error",
+                "request.error": str(e)
+            })
+            
+            print(f"❌ Request failed: {str(e)}")
+    
+    # Add some delay between requests
+    time.sleep(2)
+
+# Generate telemetry summary
+print(f"\n{'='*80}")
+print("TELEMETRY SUMMARY AND ANALYTICS")
+print(f"{'='*80}")
+
+# Simulated telemetry analytics (in production, this would come from your telemetry backend)
+print("📊 Performance Metrics:")
+print("- Total Requests Processed: 4")
+print("- Average Response Time: 3.2s")
+print("- Success Rate: 100%")
+print("- Quality Score Average: 0.91")
+print("- High Complexity Requests: 25%")
+
+print("\n📈 Usage Analytics:")
+print("- Most Common Request Type: technical_issue")
+print("- Peak Performance Window: All requests within SLA")
+print("- Agent Utilization: CustomerService (100%), TechnicalSupport (25%), QA (100%)")
+
+print("\n🔍 Observability Features Demonstrated:")
+print("- Distributed tracing across agent interactions")
+print("- Custom metrics for business KPIs")
+print("- Performance monitoring and SLA tracking")
+print("- Error tracking and alerting")
+print("- Quality assurance metrics")
+print("- User journey tracking")
+print("- Resource utilization monitoring")
+
+print("\n⚙️ Production Monitoring Setup:")
+print("- OpenTelemetry integration for standardized observability")
+print("- Custom metrics for business-specific KPIs") 
+print("- Trace correlation across multi-agent workflows")
+print("- Performance benchmarking against expected durations")
+print("- Quality scoring and automated validation")
+print("- Error categorization and alerting")
+
+print(f"\n{'='*80}")
+print("TELEMETRY DEMONSTRATION COMPLETED")
+print(f"{'='*80}")
+print("This example demonstrated comprehensive production telemetry including:")
+print("- Request tracing and performance monitoring")
+print("- Custom business metrics collection")
+print("- Quality assurance tracking")
+print("- Error handling and alerting")
+print("- Multi-agent workflow observability")
+print("- Production-ready monitoring patterns")

fix_notebook.py

@@ -0,0 +1,51 @@
+#!/usr/bin/env python3
+"""
+Script to fix the deprecated .dict() usage in Jupyter notebook
+"""
+import json
+import sys
+
+def fix_notebook():
+    notebook_path = "examples/cookbooks/Programming_Code_Analysis_Agents/ZeroScript_AI_TestExecutor.ipynb"
+    
+    try:
+        # Read the notebook
+        with open(notebook_path, 'r') as f:
+            notebook = json.load(f)
+        
+        # Find and fix the cell with .dict() usage
+        for cell in notebook.get('cells', []):
+            if cell.get('cell_type') == 'code':
+                source = cell.get('source', [])
+                # Convert source to string if it's a list
+                source_str = ''.join(source) if isinstance(source, list) else source
+                
+                # Check if this cell contains the problematic .dict() usage or hasattr check
+                if 'result_obj.dict()' in source_str or 'hasattr(result_obj, "dict")' in source_str:
+                    print(f"Found cell with .dict() usage, fixing...")
+                    # Replace .dict() with .model_dump() and fix hasattr check for backward compatibility
+                    fixed_source = source_str.replace('result_obj.dict()', 'result_obj.model_dump()').replace('hasattr(result_obj, "dict")', 'hasattr(result_obj, "model_dump")')
+                    
+                    # Convert back to list format if needed
+                    if isinstance(source, list):
+                        cell['source'] = fixed_source.splitlines(True)
+                    else:
+                        cell['source'] = fixed_source
+                    
+                    print("Fixed .dict() usage")
+                    break
+        
+        # Write the fixed notebook back
+        with open(notebook_path, 'w') as f:
+            json.dump(notebook, f, indent=2)
+        
+        print(f"Successfully updated {notebook_path}")
+        return True
+        
+    except Exception as e:
+        print(f"Error fixing notebook: {e}")
+        return False
+
+if __name__ == "__main__":
+    success = fix_notebook()
+    sys.exit(0 if success else 1)

src/praisonai-agents/gemini-basic.py

@@ -0,0 +1,25 @@
+from praisonaiagents import Agent
+
+def get_stock_price(company_name: str) -> str:
+    """
+    Get the stock price of a company
+    Args:
+        company_name (str): The name of the company
+    Returns:
+        str: The stock price of the company
+    """
+    return f"The stock price of {company_name} is 100"
+
+def multiply(a: int, b: int) -> int:
+    """
+    Multiply two numbers
+    """
+    return a * b
+
+agent = Agent(
+    instructions="You are a helpful assistant. You can use the tools provided to you to help the user.",
+    llm="gemini/gemini-2.5-pro",
+    tools=[get_stock_price, multiply]
+)
+
+result = agent.start("what is the stock price of Google? multiply the Google stock price with 2")

src/praisonai-agents/session_memory.py

@@ -0,0 +1,41 @@
+from praisonaiagents import Session
+
+# Create a session with ID
+session = Session(
+    session_id="chat_123",
+    user_id="user_456"
+)
+
+agent = session.Agent(
+    name="Assistant",
+    instructions="You are a helpful assistant with memory.",
+    llm="gemini/gemini-2.5-flash-lite-preview-06-17",
+    verbose=False,
+    memory=True
+)
+
+response1 = agent.chat("My name is John")
+
+print("response1", response1)
+
+response2 = agent.chat("What's my name?")
+
+print("response2", response2)
+
+session.save_state({"conversation_topic": "Names"})
+
+print("session", session)
+
+anotherSession = Session(session_id="chat_123")
+anotherSession.restore_state()
+
+anotherAgent = anotherSession.Agent(
+    name="Assistant",
+    instructions="You are a helpful assistant with memory.",
+    llm="gemini/gemini-2.5-flash-lite-preview-06-17",
+    verbose=False,
+    memory=True
+)
+
+response3 = anotherAgent.chat("What's my name?")
+print("response3", response3)

src/praisonai-agents/tests/example_callback.py

@@ -127,9 +127,9 @@ def main():
         verbose=True,
         allow_delegation=False,
         tools=[internet_search_tool],
-        llm="gpt-4o",
+        llm="gpt-4o-mini",
         markdown=True,
-        reflect_llm="gpt-4o",
+        reflect_llm="gpt-4o-mini",
         min_reflect=2,
         max_reflect=4
     )
@@ -142,7 +142,7 @@ def main():
         making complex tech topics interesting and easy to understand.""",
         verbose=True,
         allow_delegation=True,
-        llm="gpt-4o",
+        llm="gpt-4o-mini",
         tools=[],
         markdown=True
     )
@@ -195,7 +195,7 @@ def main():
         tasks=[task1, task2, task3, task4],
         verbose=True,
         process="sequential",
-        manager_llm="gpt-4o"
+        manager_llm="gpt-4o-mini"
     )
 
     agents.start()

src/praisonai-agents/tests/example_sequential.py

@@ -39,9 +39,9 @@ researcher = Agent(
     verbose=True,
     allow_delegation=False,
     tools=[internet_search_tool],
-    llm="gpt-4o",
+    llm="gpt-4o-mini",
     markdown=True,
-    reflect_llm="gpt-4o",
+    reflect_llm="gpt-4o-mini",
     min_reflect=2,
     max_reflect=4
 )
@@ -53,7 +53,7 @@ writer = Agent(
     making complex tech topics interesting and easy to understand.""",
     verbose=True,
     allow_delegation=True,
-    llm="gpt-4o",
+    llm="gpt-4o-mini",
     tools=[],
     markdown=True
 )
@@ -104,7 +104,7 @@ agents = PraisonAIAgents(
     tasks=[task1, task2, task3, task4],
     verbose=False,
     process="sequential",  # "sequential" or "hierarchical"
-    manager_llm="gpt-4o"
+    manager_llm="gpt-4o-mini"
 )
 
 result = agents.start()

src/praisonai-agents/tests/test_fix_comprehensive.py

@@ -57,7 +57,7 @@ print("=" * 60)
 
 agent_gpt4 = Agent(
     instructions="You are a helpful assistant. You can use the tools provided to you to help the user. When asked to multiply a stock price, first get the stock price, then multiply it.",
-    llm="gpt-4o",
+    llm="gpt-4o-mini",
     tools=[get_stock_price, multiply],
     verbose=True
 )

src/praisonai/praisonai.rb

@@ -3,8 +3,8 @@ class Praisonai < Formula
   
     desc "AI tools for various AI applications"
     homepage "https://github.com/MervinPraison/PraisonAI"
-    url "https://github.com/MervinPraison/PraisonAI/archive/refs/tags/v2.2.63.tar.gz"
-    sha256 `curl -sL https://github.com/MervinPraison/PraisonAI/archive/refs/tags/v2.2.63.tar.gz | shasum -a 256`.split.first
+    url "https://github.com/MervinPraison/PraisonAI/archive/refs/tags/v2.2.65.tar.gz"
+    sha256 `curl -sL https://github.com/MervinPraison/PraisonAI/archive/refs/tags/v2.2.65.tar.gz | shasum -a 256`.split.first
     license "MIT"
   
     depends_on "[email protected]"

src/praisonai/praisonai/agents_generator.py

@@ -14,10 +14,13 @@ import importlib
 import importlib.util
 import os
 import logging
+import re
+import keyword
 
 # Framework-specific imports with availability checks
 CREWAI_AVAILABLE = False
 AUTOGEN_AVAILABLE = False
+AUTOGEN_V4_AVAILABLE = False
 PRAISONAI_TOOLS_AVAILABLE = False
 AGENTOPS_AVAILABLE = False
 PRAISONAI_AVAILABLE = False
@@ -41,6 +44,17 @@ try:
 except ImportError:
     pass
 
+try:
+    from autogen_agentchat.agents import AssistantAgent as AutoGenV4AssistantAgent
+    from autogen_ext.models.openai import OpenAIChatCompletionClient
+    from autogen_agentchat.teams import RoundRobinGroupChat
+    from autogen_agentchat.conditions import TextMentionTermination, MaxMessageTermination
+    from autogen_agentchat.messages import TextMessage
+    from autogen_core import CancellationToken
+    AUTOGEN_V4_AVAILABLE = True
+except ImportError:
+    pass
+
 try:
     import agentops
     AGENTOPS_AVAILABLE = True
@@ -70,6 +84,40 @@ os.environ["OTEL_SDK_DISABLED"] = "true"
 def noop(*args, **kwargs):
     pass
 
+def sanitize_agent_name_for_autogen_v4(name):
+    """
+    Sanitize agent name to be a valid Python identifier for AutoGen v0.4.
+    
+    Args:
+        name (str): The original agent name
+        
+    Returns:
+        str: A valid Python identifier
+    """
+    # Convert to string and replace invalid characters with underscores
+    sanitized = re.sub(r'[^a-zA-Z0-9_]', '_', str(name))
+    
+    # Collapse only very excessive underscores (5 or more) to reduce extreme cases
+    sanitized = re.sub(r'_{5,}', '_', sanitized)
+    
+    # Remove trailing underscores only if not part of a dunder pattern and only if singular
+    if sanitized.endswith('_') and not sanitized.endswith('__') and sanitized != '_':
+        sanitized = sanitized.rstrip('_')
+    
+    # Ensure it starts with a letter or underscore (not a digit)
+    if sanitized and sanitized[0].isdigit():
+        sanitized = 'agent_' + sanitized
+    
+    # Handle empty string or only invalid characters (including single underscore from all invalid chars)
+    if not sanitized or sanitized == '_':
+        sanitized = 'agent'
+    
+    # Check if it's a Python keyword and append underscore if so
+    if keyword.iskeyword(sanitized):
+        sanitized += '_'
+    
+    return sanitized
+
 def disable_crewai_telemetry():
     if CREWAI_AVAILABLE:
         for attr in dir(Telemetry):
@@ -123,8 +171,8 @@ class AgentsGenerator:
         # Validate framework availability
         if framework == "crewai" and not CREWAI_AVAILABLE:
             raise ImportError("CrewAI is not installed. Please install it with 'pip install praisonai[crewai]'")
-        elif framework == "autogen" and not AUTOGEN_AVAILABLE:
-            raise ImportError("AutoGen is not installed. Please install it with 'pip install praisonai[autogen]'")
+        elif framework == "autogen" and not (AUTOGEN_AVAILABLE or AUTOGEN_V4_AVAILABLE):
+            raise ImportError("AutoGen is not installed. Please install it with 'pip install praisonai[autogen]' for v0.2 or 'pip install praisonai[autogen-v4]' for v0.4")
         elif framework == "praisonai" and not PRAISONAI_AVAILABLE:
             raise ImportError("PraisonAI is not installed. Please install it with 'pip install praisonaiagents'")
 
@@ -316,11 +364,35 @@ class AgentsGenerator:
         framework = self.framework or config.get('framework')
 
         if framework == "autogen":
-            if not AUTOGEN_AVAILABLE:
-                raise ImportError("AutoGen is not installed. Please install it with 'pip install praisonai[autogen]'")
+            if not (AUTOGEN_AVAILABLE or AUTOGEN_V4_AVAILABLE):
+                raise ImportError("AutoGen is not installed. Please install it with 'pip install praisonai[autogen]' for v0.2 or 'pip install praisonai[autogen-v4]' for v0.4")
+            
+            # Choose autogen version based on availability and environment preference
+            # AUTOGEN_VERSION can be set to "v0.2" or "v0.4" to force a specific version
+            autogen_version = os.environ.get("AUTOGEN_VERSION", "auto").lower()
+            
+            use_v4 = False
+            if autogen_version == "v0.4" and AUTOGEN_V4_AVAILABLE:
+                use_v4 = True
+            elif autogen_version == "v0.2" and AUTOGEN_AVAILABLE:
+                use_v4 = False
+            elif autogen_version == "auto":
+                # Default preference: use v0.4 if available, fallback to v0.2
+                use_v4 = AUTOGEN_V4_AVAILABLE
+            else:
+                # Fallback to whatever is available
+                use_v4 = AUTOGEN_V4_AVAILABLE and not AUTOGEN_AVAILABLE
+            
             if AGENTOPS_AVAILABLE:
-                agentops.init(os.environ.get("AGENTOPS_API_KEY"), default_tags=["autogen"])
-            return self._run_autogen(config, topic, tools_dict)
+                version_tag = "autogen-v4" if use_v4 else "autogen-v2"
+                agentops.init(os.environ.get("AGENTOPS_API_KEY"), default_tags=[version_tag])
+            
+            if use_v4:
+                self.logger.info("Using AutoGen v0.4")
+                return self._run_autogen_v4(config, topic, tools_dict)
+            else:
+                self.logger.info("Using AutoGen v0.2")
+                return self._run_autogen(config, topic, tools_dict)
         elif framework == "praisonai":
             if not PRAISONAI_AVAILABLE:
                 raise ImportError("PraisonAI is not installed. Please install it with 'pip install praisonaiagents'")
@@ -407,6 +479,113 @@ class AgentsGenerator:
             
         return result
 
+    def _run_autogen_v4(self, config, topic, tools_dict):
+        """
+        Run agents using the AutoGen v0.4 framework with async, event-driven architecture.
+        
+        Args:
+            config (dict): Configuration dictionary
+            topic (str): The topic to process
+            tools_dict (dict): Dictionary of available tools
+            
+        Returns:
+            str: Result of the agent interactions
+        """
+        import asyncio
+        
+        async def run_autogen_v4_async():
+            # Create model client for v0.4
+            model_config = self.config_list[0] if self.config_list else {}
+            model_client = OpenAIChatCompletionClient(
+                model=model_config.get('model', 'gpt-4o'),
+                api_key=model_config.get('api_key', os.environ.get("OPENAI_API_KEY")),
+                base_url=model_config.get('base_url', "https://api.openai.com/v1")
+            )
+            
+            agents = []
+            combined_tasks = []
+            
+            # Create agents from config
+            for role, details in config['roles'].items():
+                # For AutoGen v0.4, ensure agent name is a valid Python identifier
+                agent_name = details['role'].format(topic=topic).replace("{topic}", topic)
+                agent_name = sanitize_agent_name_for_autogen_v4(agent_name)
+                backstory = details['backstory'].format(topic=topic)
+                
+                # Convert tools for v0.4 - simplified tool passing
+                agent_tools = []
+                for tool_name in details.get('tools', []):
+                    if tool_name in tools_dict:
+                        tool_instance = tools_dict[tool_name]
+                        # For v0.4, we can pass the tool's run method directly if it's callable
+                        if hasattr(tool_instance, 'run') and callable(tool_instance.run):
+                            agent_tools.append(tool_instance.run)
+                
+                # Create v0.4 AssistantAgent
+                assistant = AutoGenV4AssistantAgent(
+                    name=agent_name,
+                    system_message=backstory + ". Must reply with 'TERMINATE' when the task is complete.",
+                    model_client=model_client,
+                    tools=agent_tools,
+                    reflect_on_tool_use=True
+                )
+                
+                agents.append(assistant)
+                
+                # Collect all task descriptions for sequential execution
+                for task_name, task_details in details.get('tasks', {}).items():
+                    description_filled = task_details['description'].format(topic=topic)
+                    combined_tasks.append(description_filled)
+            
+            if not agents:
+                return "No agents created from configuration"
+            
+            # Create termination conditions
+            text_termination = TextMentionTermination("TERMINATE")
+            max_messages_termination = MaxMessageTermination(max_messages=20)
+            termination_condition = text_termination | max_messages_termination
+            
+            # Create RoundRobinGroupChat for parallel/sequential execution
+            group_chat = RoundRobinGroupChat(
+                agents,
+                termination_condition=termination_condition,
+                max_turns=len(agents) * 3  # Allow multiple rounds
+            )
+            
+            # Combine all tasks into a single task description
+            task_description = f"Topic: {topic}\n\nTasks to complete:\n" + "\n".join(
+                f"{i+1}. {task}" for i, task in enumerate(combined_tasks)
+            )
+            
+            # Run the group chat
+            try:
+                result = await group_chat.run(task=task_description)
+                
+                # Extract the final message content
+                if result.messages:
+                    final_message = result.messages[-1]
+                    if hasattr(final_message, 'content'):
+                        return f"### AutoGen v0.4 Output ###\n{final_message.content}"
+                    else:
+                        return f"### AutoGen v0.4 Output ###\n{str(final_message)}"
+                else:
+                    return "### AutoGen v0.4 Output ###\nNo messages generated"
+                    
+            except Exception as e:
+                self.logger.error(f"Error in AutoGen v0.4 execution: {str(e)}")
+                return f"### AutoGen v0.4 Error ###\n{str(e)}"
+            
+            finally:
+                # Close the model client
+                await model_client.close()
+        
+        # Run the async function
+        try:
+            return asyncio.run(run_autogen_v4_async())
+        except Exception as e:
+            self.logger.error(f"Error running AutoGen v0.4: {str(e)}")
+            return f"### AutoGen v0.4 Error ###\n{str(e)}"
+
     def _run_crewai(self, config, topic, tools_dict):
         """
         Run agents using the CrewAI framework.
@@ -437,7 +616,7 @@ class AgentsGenerator:
             llm_model = details.get('llm')
             if llm_model:
                 llm = PraisonAIModel(
-                    model=llm_model.get("model") or os.environ.get("MODEL_NAME") or "openai/gpt-4o",
+                    model=llm_model.get("model") or os.environ.get("MODEL_NAME") or "openai/gpt-4o-mini",
                     base_url=self.config_list[0].get('base_url') if self.config_list else None,
                     api_key=self.config_list[0].get('api_key') if self.config_list else None
                 ).get_model()
@@ -451,7 +630,7 @@ class AgentsGenerator:
             function_calling_llm_model = details.get('function_calling_llm')
             if function_calling_llm_model:
                 function_calling_llm = PraisonAIModel(
-                    model=function_calling_llm_model.get("model") or os.environ.get("MODEL_NAME") or "openai/gpt-4o",
+                    model=function_calling_llm_model.get("model") or os.environ.get("MODEL_NAME") or "openai/gpt-4o-mini",
                     base_url=self.config_list[0].get('base_url') if self.config_list else None,
                     api_key=self.config_list[0].get('api_key') if self.config_list else None
                 ).get_model()
@@ -567,8 +746,8 @@ class AgentsGenerator:
                 backstory=backstory_filled,
                 tools=tools_list,  # Pass the entire tools list to the agent
                 allow_delegation=details.get('allow_delegation', False),
-                llm=details.get('llm', {}).get("model") or os.environ.get("MODEL_NAME") or "openai/gpt-4o",
-                function_calling_llm=details.get('function_calling_llm', {}).get("model") or os.environ.get("MODEL_NAME") or "openai/gpt-4o",
+                llm=details.get('llm', {}).get("model") or os.environ.get("MODEL_NAME") or "openai/gpt-4o-mini",
+                function_calling_llm=details.get('function_calling_llm', {}).get("model") or os.environ.get("MODEL_NAME") or "openai/gpt-4o-mini",
                 max_iter=details.get('max_iter', 15),
                 max_rpm=details.get('max_rpm'),
                 max_execution_time=details.get('max_execution_time'),
@@ -577,7 +756,7 @@ class AgentsGenerator:
                 system_template=details.get('system_template'),
                 prompt_template=details.get('prompt_template'),
                 response_template=details.get('response_template'),
-                reflect_llm=details.get('reflect_llm', {}).get("model") or os.environ.get("MODEL_NAME") or "openai/gpt-4o",
+                reflect_llm=details.get('reflect_llm', {}).get("model") or os.environ.get("MODEL_NAME") or "openai/gpt-4o-mini",
                 min_reflect=details.get('min_reflect', 1),
                 max_reflect=details.get('max_reflect', 3),
             )
@@ -633,7 +812,7 @@ class AgentsGenerator:
                 tasks=tasks,
                 verbose=True,
                 process="hierarchical",
-                manager_llm=config.get('manager_llm') or os.environ.get("MODEL_NAME") or "openai/gpt-4o",
+                manager_llm=config.get('manager_llm') or os.environ.get("MODEL_NAME") or "openai/gpt-4o-mini",
                 memory=memory
             )
         else:

src/praisonai/praisonai/auto.py

@@ -32,6 +32,13 @@ try:
 except ImportError:
     pass
 
+try:
+    from autogen_agentchat.agents import AssistantAgent
+    from autogen_ext.models.openai import OpenAIChatCompletionClient
+    AUTOGEN_V4_AVAILABLE = True
+except ImportError:
+    AUTOGEN_V4_AVAILABLE = False
+
 try:
     from praisonai_tools import (
         CodeDocsSearchTool, CSVSearchTool, DirectorySearchTool, DOCXSearchTool,
@@ -73,10 +80,11 @@ class AutoGenerator:
 CrewAI is not installed. Please install with:
     pip install "praisonai[crewai]"
 """)
-        elif framework == "autogen" and not AUTOGEN_AVAILABLE:
+        elif framework == "autogen" and not (AUTOGEN_AVAILABLE or AUTOGEN_V4_AVAILABLE):
             raise ImportError("""
 AutoGen is not installed. Please install with:
-    pip install "praisonai[autogen]"
+    pip install "praisonai[autogen]" for v0.2
+    pip install "praisonai[autogen-v4]" for v0.4
 """)
         elif framework == "praisonai" and not PRAISONAI_AVAILABLE:
             raise ImportError("""
@@ -86,14 +94,21 @@ Praisonai is not installed. Please install with:
 
         # Only show tools message if using a framework and tools are needed
         if (framework in ["crewai", "autogen"]) and not PRAISONAI_TOOLS_AVAILABLE:
-            logging.warning(f"""
+            if framework == "autogen":
+                logging.warning("""
+Tools are not available for autogen. To use tools, install:
+    pip install "praisonai[autogen]" for v0.2
+    pip install "praisonai[autogen-v4]" for v0.4
+""")
+            else:
+                logging.warning(f"""
 Tools are not available for {framework}. To use tools, install:
     pip install "praisonai[{framework}]"
 """)
 
         # Support multiple environment variable patterns for better compatibility
         # Priority order: MODEL_NAME > OPENAI_MODEL_NAME for model selection
-        model_name = os.environ.get("MODEL_NAME") or os.environ.get("OPENAI_MODEL_NAME", "gpt-4o")
+        model_name = os.environ.get("MODEL_NAME") or os.environ.get("OPENAI_MODEL_NAME", "gpt-4o-mini")
         
         # Priority order for base_url: OPENAI_BASE_URL > OPENAI_API_BASE > OLLAMA_API_BASE
         # OPENAI_BASE_URL is the standard OpenAI SDK environment variable

src/praisonai/praisonai/chainlit_ui.py

@@ -16,7 +16,7 @@ logging.basicConfig(level=os.environ.get('LOGLEVEL', 'INFO').upper(), format='%(
 framework = "crewai"
 config_list = [
             {
-                'model': os.environ.get("OPENAI_MODEL_NAME", "gpt-4o"),
+                'model': os.environ.get("OPENAI_MODEL_NAME", "gpt-4o-mini"),
                 'base_url': os.environ.get("OPENAI_API_BASE", "https://api.openai.com/v1"),
                 'api_key': os.environ.get("OPENAI_API_KEY", "")
             }

src/praisonai/praisonai/cli.py

@@ -124,7 +124,7 @@ class PraisonAI:
         # Create config_list with AutoGen compatibility
         # Support multiple environment variable patterns for better compatibility
         # Priority order: MODEL_NAME > OPENAI_MODEL_NAME for model selection
-        model_name = os.environ.get("MODEL_NAME") or os.environ.get("OPENAI_MODEL_NAME", "gpt-4o")
+        model_name = os.environ.get("MODEL_NAME") or os.environ.get("OPENAI_MODEL_NAME", "gpt-4o-mini")
         
         # Priority order for base_url: OPENAI_BASE_URL > OPENAI_API_BASE > OLLAMA_API_BASE
         # OPENAI_BASE_URL is the standard OpenAI SDK environment variable

src/praisonai/praisonai/deploy.py

@@ -57,7 +57,7 @@ class CloudDeployer:
             file.write("FROM python:3.11-slim\n")
             file.write("WORKDIR /app\n")
             file.write("COPY . .\n")
-            file.write("RUN pip install flask praisonai==2.2.63 gunicorn markdown\n")
+            file.write("RUN pip install flask praisonai==2.2.65 gunicorn markdown\n")
             file.write("EXPOSE 8080\n")
             file.write('CMD ["gunicorn", "-b", "0.0.0.0:8080", "api:app"]\n')
             
@@ -91,7 +91,7 @@ class CloudDeployer:
     
     def set_environment_variables(self):
         """Sets environment variables with fallback to .env values or defaults."""
-        os.environ["OPENAI_MODEL_NAME"] = os.getenv("OPENAI_MODEL_NAME", "gpt-4o")
+        os.environ["OPENAI_MODEL_NAME"] = os.getenv("OPENAI_MODEL_NAME", "gpt-4o-mini")
         os.environ["OPENAI_API_KEY"] = os.getenv("OPENAI_API_KEY", "Enter your API key")
         os.environ["OPENAI_API_BASE"] = os.getenv("OPENAI_API_BASE", "https://api.openai.com/v1")
 
@@ -110,7 +110,7 @@ class CloudDeployer:
 
         This method sets environment variables for the application. It uses the `os.environ` dictionary to set the following environment variables:
 
-        - `OPENAI_MODEL_NAME`: The name of the OpenAI model to use. If not specified in the .env file, it defaults to "gpt-4o".
+        - `OPENAI_MODEL_NAME`: The name of the OpenAI model to use. If not specified in the .env file, it defaults to "gpt-4o-mini".
         - `OPENAI_API_KEY`: The API key for accessing the OpenAI API. If not specified in the .env file, it defaults to "Enter your API key".
         - `OPENAI_API_BASE`: The base URL for the OpenAI API. If not specified in the .env file, it defaults to "https://api.openai.com/v1".
         """

src/praisonai/praisonai/inc/models.py

@@ -44,7 +44,7 @@ class PraisonAIModel:
             base_url (str, optional): The base URL for the OpenAI API. Defaults to None.
             api_key (str, optional): The explicit API key to use. Takes precedence over environment variables. Defaults to None.
         """
-        self.model =  model or os.getenv("OPENAI_MODEL_NAME", "gpt-4o")
+        self.model =  model or os.getenv("OPENAI_MODEL_NAME", "gpt-4o-mini")
         if self.model.startswith("openai/"):
             self.api_key_var = "OPENAI_API_KEY"
             self.base_url = base_url or "https://api.openai.com/v1"

src/praisonai/praisonai/ui/agents.py

@@ -10,7 +10,7 @@ from praisonaiagents import Agent, Task, PraisonAIAgents, register_display_callb
 framework = "praisonai"
 config_list = [
     {
-        'model': os.environ.get("OPENAI_MODEL_NAME", "gpt-4o"),
+        'model': os.environ.get("OPENAI_MODEL_NAME", "gpt-4o-mini"),
         'base_url': os.environ.get("OPENAI_API_BASE", "https://api.openai.com/v1"),
         'api_key': os.environ.get("OPENAI_API_KEY", "")
     }

src/praisonai/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "PraisonAI"
-version = "2.2.63"
+version = "2.2.65"
 description = "PraisonAI is an AI Agents Framework with Self Reflection. PraisonAI application combines PraisonAI Agents, AutoGen, and CrewAI into a low-code solution for building and managing multi-agent LLM systems, focusing on simplicity, customisation, and efficient human-agent collaboration."
 readme = "README.md"
 license = ""
@@ -92,10 +92,17 @@ call = [
 train = []
 crewai = ["crewai>=0.32.0", "praisonai-tools>=0.0.22"]
 autogen = ["pyautogen==0.2.29", "praisonai-tools>=0.0.22", "crewai"]
+autogen-v4 = [
+    "autogen-agentchat>=0.4.0", 
+    "autogen-ext[openai]>=0.4.0", 
+    "autogen-core>=0.4.0",
+    "praisonai-tools>=0.0.22", 
+    "crewai"
+]
 
 [tool.poetry]
 name = "PraisonAI"
-version = "2.2.63"
+version = "2.2.65"
 description = "PraisonAI is an AI Agents Framework with Self Reflection. PraisonAI application combines PraisonAI Agents, AutoGen, and CrewAI into a low-code solution for building and managing multi-agent LLM systems, focusing on simplicity, customisation, and efficient human-agent collaboration."
 authors = ["Mervin Praison"]
 license = ""
@@ -119,6 +126,9 @@ instructor = ">=1.3.3"
 PyYAML = ">=6.0"
 mcp = ">=1.6.0"
 pyautogen = {version = "==0.2.29", optional = true}
+autogen-agentchat = {version = ">=0.4.0", optional = true}
+autogen-ext = {version = ">=0.4.0", optional = true}
+autogen-core = {version = ">=0.4.0", optional = true}
 crewai = {version = ">=0.32.0", optional = true}
 praisonai-tools = {version = ">=0.0.22", optional = true}
 chainlit = {version = "==2.5.5", optional = true}
@@ -277,6 +287,7 @@ call = [
 ]
 crewai = ["crewai", "praisonai-tools"]
 autogen = ["pyautogen", "praisonai-tools", "crewai"]
+autogen-v4 = ["autogen-agentchat", "autogen-ext", "autogen-core", "praisonai-tools", "crewai"]
 
 [tool.poetry-dynamic-versioning]
 enable = true

src/praisonai/tests/test_double_api_fix.py

@@ -25,7 +25,7 @@ def test_streaming_with_tools():
     """Test that streaming with tools makes only one API call."""
     
     # Initialize LLM
-    llm = LLM(model="gpt-4o", verbose=True)
+    llm = LLM(model="gpt-4o-mini", verbose=True)
     
     # Track API calls
     api_call_count = 0
@@ -100,7 +100,7 @@ def test_streaming_with_tools():
 def test_non_streaming_with_tools():
     """Test non-streaming mode with tools."""
     
-    llm = LLM(model="gpt-4o", verbose=False)
+    llm = LLM(model="gpt-4o-mini", verbose=False)
     
     api_call_count = 0
     
@@ -152,7 +152,7 @@ def test_provider_detection():
     
     # Test different providers
     providers_to_test = [
-        ("gpt-4o", True, "OpenAI GPT-4o"),
+        ("gpt-4o-mini", True, "OpenAI GPT-4o-mini"),
         ("gpt-3.5-turbo", True, "OpenAI GPT-3.5"),
         ("claude-3-5-sonnet", True, "Anthropic Claude"),
         ("gemini-2.0-flash", True, "Google Gemini"),

src/praisonai/uv.lock

@@ -335,6 +335,54 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/ac/d1/800ab8dfe15f00836b8d1ea41f68f5e4731a96e8fc19548993996f3b5728/auth0_python-4.9.0-py3-none-any.whl", hash = "sha256:6440c7f74dfd669d9f5cdfe9bb44c4c3b230ce98a82353f55a387e90241fbf5b", size = 135349, upload-time = "2025-04-01T09:31:35.538Z" },
 ]
 
+[[package]]
+name = "autogen-agentchat"
+version = "0.6.4"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "autogen-core" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c3/9a/89e3b4456ba543593aef37e2ed38b52b374d0b43db87a3494490e20aa29e/autogen_agentchat-0.6.4.tar.gz", hash = "sha256:a50ba1a97f3881693084677807756714f237da89fd481207e6d139c930b2b3f8", size = 137817, upload-time = "2025-07-09T17:48:32.868Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/92/bc/3cc970d370d3dff4e83cf4008062e129c997b879cf721efce5a381cbb953/autogen_agentchat-0.6.4-py3-none-any.whl", hash = "sha256:441f884af0eb9edb953451b0ec06077ac782a7d60d591ce7ea57d94fefad2098", size = 114245, upload-time = "2025-07-09T17:48:31.48Z" },
+]
+
+[[package]]
+name = "autogen-core"
+version = "0.6.4"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "jsonref" },
+    { name = "opentelemetry-api" },
+    { name = "pillow" },
+    { name = "protobuf" },
+    { name = "pydantic" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/9b/9c/36411364e8d02b292d4ff79823c0e15ebca9e055b1f9e57169562763f6c3/autogen_core-0.6.4.tar.gz", hash = "sha256:0c0ea2aa2794d5ec28e55eb2385480761e591f07c34dbd814feb71a21407aa0d", size = 99761, upload-time = "2025-07-09T17:48:57.136Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/75/40/7621973ad47912186f165ad02290d446b0e1a001ea79b5d3874eef8486cf/autogen_core-0.6.4-py3-none-any.whl", hash = "sha256:49bce7e2fb24aee5e577e5e32faa6e440dfcdd472f653e5eaa5a640eb908dd35", size = 101394, upload-time = "2025-07-09T17:48:55.246Z" },
+]
+
+[[package]]
+name = "autogen-ext"
+version = "0.6.4"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "autogen-core" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/45/87/8872f3fbaea54cac11114935a2e497213ff40333b79cc1c9856e4b1de0c5/autogen_ext-0.6.4.tar.gz", hash = "sha256:ed153aa896723186ca9c5db42b3ec998d010cba503fee21d70548efb7bf9f0bb", size = 368319, upload-time = "2025-07-09T17:48:54.886Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/95/49/8d5a78e0072530151f4347743a231634e4af8f1772b17b767f3070de8ba6/autogen_ext-0.6.4-py3-none-any.whl", hash = "sha256:9a1a74bb671b791a5c2e3bf3038ba7c6d0d4825d98bd393b3e0a980ae83db893", size = 317109, upload-time = "2025-07-09T17:48:53.361Z" },
+]
+
+[package.optional-dependencies]
+openai = [
+    { name = "aiofiles" },
+    { name = "openai" },
+    { name = "tiktoken" },
+]
+
 [[package]]
 name = "backoff"
 version = "2.2.1"
@@ -4000,7 +4048,7 @@ wheels = [
 
 [[package]]
 name = "praisonai"
-version = "2.2.63"
+version = "2.2.65"
 source = { editable = "." }
 dependencies = [
     { name = "instructor" },
@@ -4030,6 +4078,13 @@ autogen = [
     { name = "praisonai-tools" },
     { name = "pyautogen" },
 ]
+autogen-v4 = [
+    { name = "autogen-agentchat" },
+    { name = "autogen-core" },
+    { name = "autogen-ext", extra = ["openai"] },
+    { name = "crewai" },
+    { name = "praisonai-tools" },
+]
 call = [
     { name = "fastapi" },
     { name = "flaml", extra = ["automl"] },
@@ -4107,6 +4162,9 @@ requires-dist = [
     { name = "aiosqlite", marker = "extra == 'code'", specifier = ">=0.20.0" },
     { name = "aiosqlite", marker = "extra == 'realtime'", specifier = ">=0.20.0" },
     { name = "aiosqlite", marker = "extra == 'ui'", specifier = ">=0.20.0" },
+    { name = "autogen-agentchat", marker = "extra == 'autogen-v4'", specifier = ">=0.4.0" },
+    { name = "autogen-core", marker = "extra == 'autogen-v4'", specifier = ">=0.4.0" },
+    { name = "autogen-ext", extras = ["openai"], marker = "extra == 'autogen-v4'", specifier = ">=0.4.0" },
     { name = "chainlit", marker = "extra == 'chat'", specifier = "==2.5.5" },
     { name = "chainlit", marker = "extra == 'code'", specifier = "==2.5.5" },
     { name = "chainlit", marker = "extra == 'realtime'", specifier = "==2.5.5" },
@@ -4115,6 +4173,7 @@ requires-dist = [
     { name = "crawl4ai", marker = "extra == 'code'", specifier = ">=0.6.0" },
     { name = "crawl4ai", marker = "extra == 'realtime'", specifier = ">=0.6.0" },
     { name = "crewai", marker = "extra == 'autogen'" },
+    { name = "crewai", marker = "extra == 'autogen-v4'" },
     { name = "crewai", marker = "extra == 'crewai'", specifier = ">=0.32.0" },
     { name = "duckduckgo-search", marker = "extra == 'realtime'", specifier = ">=6.3.0" },
     { name = "fastapi", marker = "extra == 'api'", specifier = ">=0.115.0" },
@@ -4141,6 +4200,7 @@ requires-dist = [
     { name = "playwright", marker = "extra == 'code'", specifier = ">=1.47.0" },
     { name = "plotly", marker = "extra == 'realtime'", specifier = ">=5.24.0" },
     { name = "praisonai-tools", marker = "extra == 'autogen'", specifier = ">=0.0.22" },
+    { name = "praisonai-tools", marker = "extra == 'autogen-v4'", specifier = ">=0.0.22" },
     { name = "praisonai-tools", marker = "extra == 'crewai'", specifier = ">=0.0.22" },
     { name = "praisonaiagents", specifier = ">=0.0.136" },
     { name = "pyautogen", marker = "extra == 'autogen'", specifier = "==0.2.29" },
@@ -4168,7 +4228,7 @@ requires-dist = [
     { name = "websockets", marker = "extra == 'realtime'", specifier = ">=12.0" },
     { name = "yfinance", marker = "extra == 'realtime'", specifier = ">=0.2.44" },
 ]
-provides-extras = ["ui", "gradio", "api", "agentops", "google", "openai", "anthropic", "cohere", "chat", "code", "realtime", "call", "train", "crewai", "autogen"]
+provides-extras = ["ui", "gradio", "api", "agentops", "google", "openai", "anthropic", "cohere", "chat", "code", "realtime", "call", "train", "crewai", "autogen", "autogen-v4"]
 
 [[package]]
 name = "praisonai-tools"
@@ -5676,35 +5736,38 @@ wheels = [
 
 [[package]]
 name = "tiktoken"
-version = "0.7.0"
+version = "0.9.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "regex" },
     { name = "requests" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/c4/4a/abaec53e93e3ef37224a4dd9e2fc6bb871e7a538c2b6b9d2a6397271daf4/tiktoken-0.7.0.tar.gz", hash = "sha256:1077266e949c24e0291f6c350433c6f0971365ece2b173a23bc3b9f9defef6b6", size = 33437, upload-time = "2024-05-13T18:03:28.793Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/ea/cf/756fedf6981e82897f2d570dd25fa597eb3f4459068ae0572d7e888cfd6f/tiktoken-0.9.0.tar.gz", hash = "sha256:d02a5ca6a938e0490e1ff957bc48c8b078c88cb83977be1625b1fd8aac792c5d", size = 35991, upload-time = "2025-02-14T06:03:01.003Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/96/10/28d59d43d72a0ebd4211371d0bf10c935cdecbb62b812ae04c58bfc37d96/tiktoken-0.7.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:485f3cc6aba7c6b6ce388ba634fbba656d9ee27f766216f45146beb4ac18b25f", size = 961465, upload-time = "2024-05-13T18:02:31.978Z" },
-    { url = "https://files.pythonhosted.org/packages/f8/0c/d4125348dedd1f8f38e3f85245e7fc38858ffc77c9b7edfb762a8191ba0b/tiktoken-0.7.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:e54be9a2cd2f6d6ffa3517b064983fb695c9a9d8aa7d574d1ef3c3f931a99225", size = 906849, upload-time = "2024-05-13T18:02:33.535Z" },
-    { url = "https://files.pythonhosted.org/packages/b9/ab/f9c7675747f259d133d66065106cf732a7c2bef6043062fbca8e011f7f4d/tiktoken-0.7.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:79383a6e2c654c6040e5f8506f3750db9ddd71b550c724e673203b4f6b4b4590", size = 1048795, upload-time = "2024-05-13T18:02:35.411Z" },
-    { url = "https://files.pythonhosted.org/packages/e7/8c/7d1007557b343d5cf18349802e94d3a14397121e9105b4661f8cd753f9bf/tiktoken-0.7.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5d4511c52caacf3c4981d1ae2df85908bd31853f33d30b345c8b6830763f769c", size = 1080866, upload-time = "2024-05-13T18:02:37.583Z" },
-    { url = "https://files.pythonhosted.org/packages/72/40/61d6354cb64a563fce475a2907039be9fe809ca5f801213856353b01a35b/tiktoken-0.7.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:13c94efacdd3de9aff824a788353aa5749c0faee1fbe3816df365ea450b82311", size = 1092776, upload-time = "2024-05-13T18:02:39.51Z" },
-    { url = "https://files.pythonhosted.org/packages/f2/6c/83ca40527d072739f0704b9f59b325786c444ca63672a77cb69adc8181f7/tiktoken-0.7.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:8e58c7eb29d2ab35a7a8929cbeea60216a4ccdf42efa8974d8e176d50c9a3df5", size = 1142591, upload-time = "2024-05-13T18:02:40.793Z" },
-    { url = "https://files.pythonhosted.org/packages/ec/1f/a5d72755118e9e1b62cdf3ef9138eb83d49088f3cb37a9540025c81c0e75/tiktoken-0.7.0-cp310-cp310-win_amd64.whl", hash = "sha256:21a20c3bd1dd3e55b91c1331bf25f4af522c525e771691adbc9a69336fa7f702", size = 798864, upload-time = "2024-05-13T18:02:42.567Z" },
-    { url = "https://files.pythonhosted.org/packages/22/eb/57492b2568eea1d546da5cc1ae7559d924275280db80ba07e6f9b89a914b/tiktoken-0.7.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:10c7674f81e6e350fcbed7c09a65bca9356eaab27fb2dac65a1e440f2bcfe30f", size = 961468, upload-time = "2024-05-13T18:02:43.788Z" },
-    { url = "https://files.pythonhosted.org/packages/30/ef/e07dbfcb2f85c84abaa1b035a9279575a8da0236305491dc22ae099327f7/tiktoken-0.7.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:084cec29713bc9d4189a937f8a35dbdfa785bd1235a34c1124fe2323821ee93f", size = 907005, upload-time = "2024-05-13T18:02:45.327Z" },
-    { url = "https://files.pythonhosted.org/packages/ea/9b/f36db825b1e9904c3a2646439cb9923fc1e09208e2e071c6d9dd64ead131/tiktoken-0.7.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:811229fde1652fedcca7c6dfe76724d0908775b353556d8a71ed74d866f73f7b", size = 1049183, upload-time = "2024-05-13T18:02:46.574Z" },
-    { url = "https://files.pythonhosted.org/packages/61/b4/b80d1fe33015e782074e96bbbf4108ccd283b8deea86fb43c15d18b7c351/tiktoken-0.7.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:86b6e7dc2e7ad1b3757e8a24597415bafcfb454cebf9a33a01f2e6ba2e663992", size = 1080830, upload-time = "2024-05-13T18:02:48.444Z" },
-    { url = "https://files.pythonhosted.org/packages/2a/40/c66ff3a21af6d62a7e0ff428d12002c4e0389f776d3ff96dcaa0bb354eee/tiktoken-0.7.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1063c5748be36344c7e18c7913c53e2cca116764c2080177e57d62c7ad4576d1", size = 1092967, upload-time = "2024-05-13T18:02:50.006Z" },
-    { url = "https://files.pythonhosted.org/packages/2e/80/f4c9e255ff236e6a69ce44b927629cefc1b63d3a00e2d1c9ed540c9492d2/tiktoken-0.7.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:20295d21419bfcca092644f7e2f2138ff947a6eb8cfc732c09cc7d76988d4a89", size = 1142682, upload-time = "2024-05-13T18:02:51.814Z" },
-    { url = "https://files.pythonhosted.org/packages/b1/10/c04b4ff592a5f46b28ebf4c2353f735c02ae7f0ce1b165d00748ced6467e/tiktoken-0.7.0-cp311-cp311-win_amd64.whl", hash = "sha256:959d993749b083acc57a317cbc643fb85c014d055b2119b739487288f4e5d1cb", size = 799009, upload-time = "2024-05-13T18:02:53.057Z" },
-    { url = "https://files.pythonhosted.org/packages/1d/46/4cdda4186ce900608f522da34acf442363346688c71b938a90a52d7b84cc/tiktoken-0.7.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:71c55d066388c55a9c00f61d2c456a6086673ab7dec22dd739c23f77195b1908", size = 960446, upload-time = "2024-05-13T18:02:54.409Z" },
-    { url = "https://files.pythonhosted.org/packages/b6/30/09ced367d280072d7a3e21f34263dfbbf6378661e7a0f6414e7c18971083/tiktoken-0.7.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:09ed925bccaa8043e34c519fbb2f99110bd07c6fd67714793c21ac298e449410", size = 906652, upload-time = "2024-05-13T18:02:56.25Z" },
-    { url = "https://files.pythonhosted.org/packages/e6/7b/c949e4954441a879a67626963dff69096e3c774758b9f2bb0853f7b4e1e7/tiktoken-0.7.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:03c6c40ff1db0f48a7b4d2dafeae73a5607aacb472fa11f125e7baf9dce73704", size = 1047904, upload-time = "2024-05-13T18:02:57.707Z" },
-    { url = "https://files.pythonhosted.org/packages/50/81/1842a22f15586072280364c2ab1e40835adaf64e42fe80e52aff921ee021/tiktoken-0.7.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d20b5c6af30e621b4aca094ee61777a44118f52d886dbe4f02b70dfe05c15350", size = 1079836, upload-time = "2024-05-13T18:02:59.009Z" },
-    { url = "https://files.pythonhosted.org/packages/6d/87/51a133a3d5307cf7ae3754249b0faaa91d3414b85c3d36f80b54d6817aa6/tiktoken-0.7.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:d427614c3e074004efa2f2411e16c826f9df427d3c70a54725cae860f09e4bf4", size = 1092472, upload-time = "2024-05-13T18:03:00.597Z" },
-    { url = "https://files.pythonhosted.org/packages/a5/1f/c93517dc6d3b2c9e988b8e24f87a8b2d4a4ab28920a3a3f3ea338397ae0c/tiktoken-0.7.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:8c46d7af7b8c6987fac9b9f61041b452afe92eb087d29c9ce54951280f899a97", size = 1141881, upload-time = "2024-05-13T18:03:02.743Z" },
-    { url = "https://files.pythonhosted.org/packages/bf/4b/48ca098cb580c099b5058bf62c4cb5e90ca6130fa43ef4df27088536245b/tiktoken-0.7.0-cp312-cp312-win_amd64.whl", hash = "sha256:0bc603c30b9e371e7c4c7935aba02af5994a909fc3c0fe66e7004070858d3f8f", size = 799281, upload-time = "2024-05-13T18:03:04.036Z" },
+    { url = "https://files.pythonhosted.org/packages/64/f3/50ec5709fad61641e4411eb1b9ac55b99801d71f1993c29853f256c726c9/tiktoken-0.9.0-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:586c16358138b96ea804c034b8acf3f5d3f0258bd2bc3b0227af4af5d622e382", size = 1065770, upload-time = "2025-02-14T06:02:01.251Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/f8/5a9560a422cf1755b6e0a9a436e14090eeb878d8ec0f80e0cd3d45b78bf4/tiktoken-0.9.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:d9c59ccc528c6c5dd51820b3474402f69d9a9e1d656226848ad68a8d5b2e5108", size = 1009314, upload-time = "2025-02-14T06:02:02.869Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/20/3ed4cfff8f809cb902900ae686069e029db74567ee10d017cb254df1d598/tiktoken-0.9.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f0968d5beeafbca2a72c595e8385a1a1f8af58feaebb02b227229b69ca5357fd", size = 1143140, upload-time = "2025-02-14T06:02:04.165Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/95/cc2c6d79df8f113bdc6c99cdec985a878768120d87d839a34da4bd3ff90a/tiktoken-0.9.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:92a5fb085a6a3b7350b8fc838baf493317ca0e17bd95e8642f95fc69ecfed1de", size = 1197860, upload-time = "2025-02-14T06:02:06.268Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/6c/9c1a4cc51573e8867c9381db1814223c09ebb4716779c7f845d48688b9c8/tiktoken-0.9.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:15a2752dea63d93b0332fb0ddb05dd909371ededa145fe6a3242f46724fa7990", size = 1259661, upload-time = "2025-02-14T06:02:08.889Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/4c/22eb8e9856a2b1808d0a002d171e534eac03f96dbe1161978d7389a59498/tiktoken-0.9.0-cp310-cp310-win_amd64.whl", hash = "sha256:26113fec3bd7a352e4b33dbaf1bd8948de2507e30bd95a44e2b1156647bc01b4", size = 894026, upload-time = "2025-02-14T06:02:12.841Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/ae/4613a59a2a48e761c5161237fc850eb470b4bb93696db89da51b79a871f1/tiktoken-0.9.0-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:f32cc56168eac4851109e9b5d327637f15fd662aa30dd79f964b7c39fbadd26e", size = 1065987, upload-time = "2025-02-14T06:02:14.174Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/86/55d9d1f5b5a7e1164d0f1538a85529b5fcba2b105f92db3622e5d7de6522/tiktoken-0.9.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:45556bc41241e5294063508caf901bf92ba52d8ef9222023f83d2483a3055348", size = 1009155, upload-time = "2025-02-14T06:02:15.384Z" },
+    { url = "https://files.pythonhosted.org/packages/03/58/01fb6240df083b7c1916d1dcb024e2b761213c95d576e9f780dfb5625a76/tiktoken-0.9.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:03935988a91d6d3216e2ec7c645afbb3d870b37bcb67ada1943ec48678e7ee33", size = 1142898, upload-time = "2025-02-14T06:02:16.666Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/73/41591c525680cd460a6becf56c9b17468d3711b1df242c53d2c7b2183d16/tiktoken-0.9.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8b3d80aad8d2c6b9238fc1a5524542087c52b860b10cbf952429ffb714bc1136", size = 1197535, upload-time = "2025-02-14T06:02:18.595Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/7c/1069f25521c8f01a1a182f362e5c8e0337907fae91b368b7da9c3e39b810/tiktoken-0.9.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:b2a21133be05dc116b1d0372af051cd2c6aa1d2188250c9b553f9fa49301b336", size = 1259548, upload-time = "2025-02-14T06:02:20.729Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/07/c67ad1724b8e14e2b4c8cca04b15da158733ac60136879131db05dda7c30/tiktoken-0.9.0-cp311-cp311-win_amd64.whl", hash = "sha256:11a20e67fdf58b0e2dea7b8654a288e481bb4fc0289d3ad21291f8d0849915fb", size = 893895, upload-time = "2025-02-14T06:02:22.67Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/e5/21ff33ecfa2101c1bb0f9b6df750553bd873b7fb532ce2cb276ff40b197f/tiktoken-0.9.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:e88f121c1c22b726649ce67c089b90ddda8b9662545a8aeb03cfef15967ddd03", size = 1065073, upload-time = "2025-02-14T06:02:24.768Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/03/a95e7b4863ee9ceec1c55983e4cc9558bcfd8f4f80e19c4f8a99642f697d/tiktoken-0.9.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:a6600660f2f72369acb13a57fb3e212434ed38b045fd8cc6cdd74947b4b5d210", size = 1008075, upload-time = "2025-02-14T06:02:26.92Z" },
+    { url = "https://files.pythonhosted.org/packages/40/10/1305bb02a561595088235a513ec73e50b32e74364fef4de519da69bc8010/tiktoken-0.9.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:95e811743b5dfa74f4b227927ed86cbc57cad4df859cb3b643be797914e41794", size = 1140754, upload-time = "2025-02-14T06:02:28.124Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/40/da42522018ca496432ffd02793c3a72a739ac04c3794a4914570c9bb2925/tiktoken-0.9.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:99376e1370d59bcf6935c933cb9ba64adc29033b7e73f5f7569f3aad86552b22", size = 1196678, upload-time = "2025-02-14T06:02:29.845Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/41/1e59dddaae270ba20187ceb8aa52c75b24ffc09f547233991d5fd822838b/tiktoken-0.9.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:badb947c32739fb6ddde173e14885fb3de4d32ab9d8c591cbd013c22b4c31dd2", size = 1259283, upload-time = "2025-02-14T06:02:33.838Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/64/b16003419a1d7728d0d8c0d56a4c24325e7b10a21a9dd1fc0f7115c02f0a/tiktoken-0.9.0-cp312-cp312-win_amd64.whl", hash = "sha256:5a62d7a25225bafed786a524c1b9f0910a1128f4232615bf3f8257a73aaa3b16", size = 894897, upload-time = "2025-02-14T06:02:36.265Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/11/09d936d37f49f4f494ffe660af44acd2d99eb2429d60a57c71318af214e0/tiktoken-0.9.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:2b0e8e05a26eda1249e824156d537015480af7ae222ccb798e5234ae0285dbdb", size = 1064919, upload-time = "2025-02-14T06:02:37.494Z" },
+    { url = "https://files.pythonhosted.org/packages/80/0e/f38ba35713edb8d4197ae602e80837d574244ced7fb1b6070b31c29816e0/tiktoken-0.9.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:27d457f096f87685195eea0165a1807fae87b97b2161fe8c9b1df5bd74ca6f63", size = 1007877, upload-time = "2025-02-14T06:02:39.516Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/82/9197f77421e2a01373e27a79dd36efdd99e6b4115746ecc553318ecafbf0/tiktoken-0.9.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2cf8ded49cddf825390e36dd1ad35cd49589e8161fdcb52aa25f0583e90a3e01", size = 1140095, upload-time = "2025-02-14T06:02:41.791Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/bb/4513da71cac187383541facd0291c4572b03ec23c561de5811781bbd988f/tiktoken-0.9.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cc156cb314119a8bb9748257a2eaebd5cc0753b6cb491d26694ed42fc7cb3139", size = 1195649, upload-time = "2025-02-14T06:02:43Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/5c/74e4c137530dd8504e97e3a41729b1103a4ac29036cbfd3250b11fd29451/tiktoken-0.9.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:cd69372e8c9dd761f0ab873112aba55a0e3e506332dd9f7522ca466e817b1b7a", size = 1258465, upload-time = "2025-02-14T06:02:45.046Z" },
+    { url = "https://files.pythonhosted.org/packages/de/a8/8f499c179ec900783ffe133e9aab10044481679bb9aad78436d239eee716/tiktoken-0.9.0-cp313-cp313-win_amd64.whl", hash = "sha256:5ea0edb6f83dc56d794723286215918c1cde03712cbbafa0348b33448faf5b95", size = 894669, upload-time = "2025-02-14T06:02:47.341Z" },
 ]
 
 [[package]]

test_backward_compatibility.py

@@ -0,0 +1,113 @@
+#!/usr/bin/env python3
+"""
+Test the backward compatibility fix for Pydantic .dict() → .model_dump() migration
+"""
+
+class MockPydanticV1:
+    """Mock Pydantic v1 model that has .dict() but not .model_dump()"""
+    def __init__(self, data):
+        self.data = data
+    
+    def dict(self):
+        return self.data
+    
+    def __str__(self):
+        return str(self.data)
+
+class MockPydanticV2:
+    """Mock Pydantic v2 model that has both .dict() and .model_dump()"""
+    def __init__(self, data):
+        self.data = data
+    
+    def dict(self):
+        return self.data
+    
+    def model_dump(self):
+        return self.data
+        
+    def __str__(self):
+        return str(self.data)
+
+class MockNonPydantic:
+    """Mock non-Pydantic object"""
+    def __init__(self, data):
+        self.data = data
+    
+    def __str__(self):
+        return str(self.data)
+
+def test_notebook_backward_compatibility():
+    """Test the fixed notebook logic with different object types"""
+    
+    print("Testing notebook backward compatibility fix...")
+    
+    # Test cases
+    test_objects = [
+        ("Pydantic v1 mock", MockPydanticV1({"test": "data1"})),
+        ("Pydantic v2 mock", MockPydanticV2({"test": "data2"})),
+        ("Non-Pydantic object", MockNonPydantic({"test": "data3"})),
+        ("String object", "just a string"),
+        ("None object", None),
+    ]
+    
+    for name, result_obj in test_objects:
+        print(f"\nTesting {name}:")
+        
+        # This is the fixed logic from the notebook
+        try:
+            result = result_obj.model_dump() if hasattr(result_obj, "model_dump") else str(result_obj)
+            print(f"  ✅ Success: {result}")
+        except Exception as e:
+            print(f"  ❌ Failed: {e}")
+            return False
+    
+    print("\n✅ All backward compatibility tests passed!")
+    return True
+
+def test_api_files_syntax():
+    """Test that the API files have valid syntax"""
+    
+    print("\nTesting API files syntax...")
+    
+    files_to_check = [
+        "examples/python/concepts/reasoning-extraction.py",
+        "examples/python/api/secondary-market-research-api.py"
+    ]
+    
+    for file_path in files_to_check:
+        try:
+            print(f"  Checking {file_path}...")
+            with open(file_path, 'r') as f:
+                code = f.read()
+            
+            # Check that .model_dump() is used instead of .dict()
+            if '.dict()' in code and 'result_obj.dict()' in code:
+                print(f"  ❌ Found remaining .dict() usage in {file_path}")
+                return False
+            
+            # Compile the code to check syntax
+            compile(code, file_path, 'exec')
+            print(f"  ✅ {file_path} has valid syntax")
+            
+        except Exception as e:
+            print(f"  ❌ Error checking {file_path}: {e}")
+            return False
+    
+    print("✅ All API files have valid syntax!")
+    return True
+
+if __name__ == "__main__":
+    print("=" * 60)
+    print("TESTING BACKWARD COMPATIBILITY FIXES")
+    print("=" * 60)
+    
+    success = True
+    success &= test_notebook_backward_compatibility()
+    success &= test_api_files_syntax()
+    
+    if success:
+        print("\n🎉 All backward compatibility tests passed!")
+        print("The fixes ensure compatibility with both Pydantic v1 and v2")
+    else:
+        print("\n❌ Some tests failed")
+        exit(1)

test_simple.py

@@ -0,0 +1,148 @@
+#!/usr/bin/env python3
+
+# Simple test to check if the fixed files work correctly
+import sys
+import warnings
+
+def test_fixed_files():
+    """Test the files that had .dict() usage to ensure they work with .model_dump()"""
+    print("Testing fixed files...")
+    
+    try:
+        # Test 1: Import and test the reasoning extraction functionality
+        print("Testing reasoning-extraction.py imports...")
+        import json
+        from pydantic import BaseModel
+        
+        # Create a dummy ChainOfThought class to test our fix
+        class ChainOfThought(BaseModel):
+            problem: str
+            reasoning_steps: list = []
+            solution: str = ""
+        
+        def save_reasoning_chain(chain: ChainOfThought) -> str:
+            """Save a chain of thought reasoning to analyze patterns."""
+            filename = f"reasoning_{chain.problem[:20].replace(' ', '_')}.json"
+            with open(filename, 'w') as f:
+                json.dump(chain.model_dump(), f, indent=2)  # This was the fix
+            return f"Reasoning chain saved to {filename}"
+        
+        # Test the fixed function
+        test_chain = ChainOfThought(
+            problem="Test problem for validation",
+            reasoning_steps=["Step 1", "Step 2"],
+            solution="Test solution"
+        )
+        result = save_reasoning_chain(test_chain)
+        print(f"✅ reasoning-extraction.py fix works: {result}")
+        
+        # Test 2: Test the API fix (MarketResearchRequest simulation)
+        print("Testing secondary-market-research-api.py fix...")
+        
+        class MarketResearchRequest(BaseModel):
+            company: str
+            geography: str
+            market_segment: str = "general"
+        
+        def test_api_serialization(request: MarketResearchRequest):
+            """Test the fixed API serialization"""
+            from datetime import datetime
+            job_status = {
+                "status": "queued",
+                "progress": 0,
+                "message": "Report generation queued",
+                "created_at": datetime.now().isoformat(),
+                "updated_at": datetime.now().isoformat(),
+                "config": request.model_dump()  # This was the fix
+            }
+            return job_status
+        
+        test_request = MarketResearchRequest(
+            company="Test Company",
+            geography="Global",
+            market_segment="tech"
+        )
+        api_result = test_api_serialization(test_request)
+        print(f"✅ secondary-market-research-api.py fix works: {api_result['config']}")
+        
+        print("\n✅ All Pydantic .dict() → .model_dump() fixes are working correctly!")
+        return True
+        
+    except Exception as e:
+        print(f"❌ Error testing fixes: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+def test_import_praisonaiagents():
+    """Test basic PraisonAI Agents import"""
+    try:
+        print("Testing PraisonAI Agents import...")
+        from praisonaiagents import Agent
+        print("✅ Successfully imported PraisonAI Agents")
+        
+        # Try to create an agent without LLM call
+        agent = Agent(
+            instructions="Test agent for validation",
+            tools=[]
+        )
+        print("✅ Successfully created agent instance")
+        return True
+    except Exception as e:
+        print(f"❌ Error importing or creating agent: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+def test_litellm_deprecation():
+    """Test for litellm deprecation warnings"""
+    try:
+        # Capture warnings to see if we've reduced them
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter("always")
+            
+            # Try to import litellm
+            import litellm
+            print("✅ LiteLLM imported successfully")
+            
+            # Check for any deprecation warnings caught
+            pydantic_warnings = [warning for warning in w if 'pydantic' in str(warning.message).lower() and 'dict' in str(warning.message).lower()]
+            
+            if pydantic_warnings:
+                print(f"⚠️  Found {len(pydantic_warnings)} Pydantic dict() deprecation warnings:")
+                for warning in pydantic_warnings:
+                    print(f"   - {warning.message}")
+            else:
+                print("✅ No Pydantic dict() deprecation warnings detected during import")
+                
+        return True
+        
+    except Exception as e:
+        print(f"❌ Error testing litellm: {e}")
+        return False
+
+if __name__ == "__main__":
+    print("=" * 60)
+    print("TESTING DEPRECATION WARNING FIXES")
+    print("=" * 60)
+    
+    success = True
+    
+    # Test our fixed files
+    success &= test_fixed_files()
+    print()
+    
+    # Test basic imports
+    success &= test_import_praisonaiagents()
+    print()
+    
+    # Test for remaining warnings
+    success &= test_litellm_deprecation()
+    print()
+    
+    if success:
+        print("✅ All tests passed! Deprecation warnings should be resolved.")
+        sys.exit(0)
+    else:
+        print("❌ Some tests failed. Please check the output above.")
+        sys.exit(1)