dasein-core 0.2.4__tar.gz → 0.2.6__tar.gz

{dasein_core-0.2.4/src/dasein_core.egg-info → dasein_core-0.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dasein-core
-Version: 0.2.4
+Version: 0.2.6
 Summary: Universal memory for agentic AI. Attach a brain to any LangChain/LangGraph agent in a single line.
 Author-email: Dasein Team <support@dasein.ai>
 License: MIT

{dasein_core-0.2.4 → dasein_core-0.2.6}/examples/dasein_examples.ipynb

@@ -1,502 +1,502 @@
-{
-  "cells": [
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "# 🧠 Dasein Examples: Universal Memory for Agentic AI\n",
-        "\n",
-        "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/nickswami/dasein-core/blob/main/examples/dasein_examples.ipynb)\n",
-        "\n",
-        "This notebook demonstrates **Dasein** - a universal memory system that learns from your agent's execution history and automatically improves performance, reduces costs, and increases reliability.\n",
-        "\n",
-        "## What You'll Learn\n",
-        "\n",
-        "1. **SQL Agent** - Learn query patterns for database interactions\n",
-        "2. **Browser Agent** - Learn web scraping and navigation strategies\n",
-        "3. **Deep Research Agent** - Optimize multi-agent research workflows\n",
-        "\n",
-        "## Key Features\n",
-        "\n",
-        "- ✨ **Zero-friction integration** - Wrap any agent in one line\n",
-        "- 🧠 **Automatic learning** - Agents learn from successes and failures\n",
-        "- 📊 **Performance tracking** - See token usage, timing, and improvement metrics\n",
-        "- 🔄 **Retry logic** - Intelligent retry with learned optimizations\n",
-        "- ☁️ **Cloud-powered** - Distributed rule synthesis and storage\n"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Installation\n"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# Install Dasein and dependencies\n",
-        "!pip install -q dasein-core\n",
-        "\n",
-        "# For browser agent example (Use Case 2)\n",
-        "!pip install -q playwright\n",
-        "!playwright install chromium\n",
-        "\n",
-        "# For deep research agent (Use Case 3)\n",
-        "!pip install -q git+https://github.com/langchain-ai/open_deep_research.git\n"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Setup API Keys\n",
-        "\n",
-        "Replace the placeholders below with your actual API keys:\n",
-        "\n",
-        "- **GOOGLE_API_KEY**: Get from [Google AI Studio](https://makersuite.google.com/app/apikey)\n",
-        "- **TAVILY_API_KEY**: Get from [Tavily](https://tavily.com) (free tier available, 1000 searches/month)\n"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "import os\n",
-        "\n",
-        "# ⚠️ REPLACE THESE WITH YOUR ACTUAL API KEYS\n",
-        "os.environ[\"GOOGLE_API_KEY\"] = \"YOUR_GOOGLE_API_KEY_HERE\"\n",
-        "os.environ[\"TAVILY_API_KEY\"] = \"YOUR_TAVILY_API_KEY_HERE\"  # Only needed for Use Case 3\n",
-        "\n",
-        "# Suppress warnings\n",
-        "os.environ[\"GOOGLE_CLOUD_DISABLE_DIRECT_PATH\"] = \"true\"\n",
-        "\n",
-        "print(\"✅ API keys configured\")\n",
-        "print(\"\\n⚠️ Note: You may see dependency warnings in Colab - these are safe to ignore.\")\n",
-        "print(\"⚠️ Note: Brief timeout warnings on first run are normal (cold start) - services will activate automatically.\")\n"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "---\n",
-        "\n",
-        "# Use Case 1: SQL Agent with Learning\n",
-        "\n",
-        "This example demonstrates how Dasein learns SQL query patterns and improves database agent performance.\n",
-        "\n",
-        "**What Happens:**\n",
-        "1. **Baseline Run**: Agent queries the Chinook database without optimization\n",
-        "2. **Learning**: Dasein captures the execution trace and sends it to cloud services for rule synthesis\n",
-        "3. **Enhanced Run**: Agent runs again with learned rules injected, showing improved performance\n",
-        "\n",
-        "**Expected Improvements:**\n",
-        "- 30-50% reduction in tokens used\n",
-        "- Fewer SQL query iterations\n",
-        "- Better query formulation\n"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "import urllib.request\n",
-        "from pathlib import Path\n",
-        "\n",
-        "# Download Chinook sample database\n",
-        "db_path = Path(\"chinook.db\")\n",
-        "if not db_path.exists():\n",
-        "    print(\"Downloading Chinook database...\")\n",
-        "    urllib.request.urlretrieve(\n",
-        "        \"https://raw.githubusercontent.com/lerocha/chinook-database/master/ChinookDatabase/DataSources/Chinook_Sqlite.sqlite\",\n",
-        "        str(db_path)\n",
-        "    )\n",
-        "    print(\"✅ Database downloaded\")\n",
-        "else:\n",
-        "    print(\"✅ Database already exists\")\n"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "from langchain_community.utilities import SQLDatabase\n",
-        "from langchain_community.agent_toolkits import SQLDatabaseToolkit\n",
-        "from langchain_community.agent_toolkits.sql.base import create_sql_agent\n",
-        "from langchain_google_genai import ChatGoogleGenerativeAI\n",
-        "from dasein import cognate\n",
-        "\n",
-        "# Set up SQL agent\n",
-        "print(\"Setting up SQL agent...\")\n",
-        "db = SQLDatabase.from_uri(f\"sqlite:///{db_path}\")\n",
-        "llm = ChatGoogleGenerativeAI(model=\"gemini-2.5-flash\", temperature=0)\n",
-        "toolkit = SQLDatabaseToolkit(db=db, llm=llm)\n",
-        "agent = create_sql_agent(llm=llm, toolkit=toolkit, verbose=True, handle_parsing_errors=True)\n",
-        "\n",
-        "print(\"✅ SQL agent created\")\n"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# Wrap with Dasein for automatic learning and improvement\n",
-        "agent = cognate(\n",
-        "    agent,\n",
-        "    retry=2,  # Run twice: baseline + enhanced\n",
-        "    performance_tracking=True,  # Show improvement metrics\n",
-        "    verbose=False  # Set to True to see rule injection details\n",
-        ")\n",
-        "\n",
-        "# Run the query - Dasein handles everything automatically!\n",
-        "query = \"Which media format accounts for the highest number of individual line-item sales?\"\n",
-        "\n",
-        "print(f\"\\nQuery: {query}\\n\")\n",
-        "print(\"=\" * 70)\n",
-        "print(\"PHASE 1: Baseline run...\")\n",
-        "print(\"PHASE 2: Enhanced run with learned rules...\")\n",
-        "print(\"=\" * 70)\n",
-        "\n",
-        "result = agent.invoke({\"input\": query})\n",
-        "\n",
-        "print(f\"\\n✅ Final Answer: {result.get('output', '')}\")\n",
-        "print(\"\\n📊 Check the performance metrics above to see improvement!\")\n"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "---\n",
-        "\n",
-        "# Use Case 2: Browser Agent with Learning\n",
-        "\n",
-        "This example demonstrates how Dasein learns web scraping and navigation patterns.\n",
-        "\n",
-        "**What Happens:**\n",
-        "1. **Baseline Run**: Browser agent navigates to a website without optimization\n",
-        "2. **Learning**: Dasein learns which tools to use, navigation patterns, and element selection strategies\n",
-        "3. **Enhanced Run**: Agent runs again with learned rules, showing faster and more efficient browsing\n",
-        "\n",
-        "**Expected Improvements:**\n",
-        "- Fewer navigation steps\n",
-        "- Better tool selection\n",
-        "- More efficient element targeting\n",
-        "- Reduced token usage\n"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "from langchain_community.agent_toolkits import PlayWrightBrowserToolkit\n",
-        "from langchain_google_genai import ChatGoogleGenerativeAI\n",
-        "from langgraph.prebuilt import create_react_agent\n",
-        "from dasein import cognate\n",
-        "import asyncio\n",
-        "from playwright.async_api import async_playwright\n",
-        "\n",
-        "async def create_browser_agent():\n",
-        "    \"\"\"Create a Playwright browser agent.\"\"\"\n",
-        "    print(\"Setting up Playwright browser agent...\")\n",
-        "    \n",
-        "    # Create browser\n",
-        "    playwright = await async_playwright().start()\n",
-        "    async_browser = await playwright.chromium.launch(headless=True)\n",
-        "    \n",
-        "    # Create toolkit and tools\n",
-        "    toolkit = PlayWrightBrowserToolkit.from_browser(async_browser=async_browser)\n",
-        "    tools = toolkit.get_tools()\n",
-        "    \n",
-        "    print(f\"Available browser tools: {[tool.name for tool in tools]}\")\n",
-        "    \n",
-        "    # Create LLM\n",
-        "    llm = ChatGoogleGenerativeAI(\n",
-        "        model=\"gemini-2.5-flash\",\n",
-        "        temperature=0,\n",
-        "        request_timeout=180,\n",
-        "        max_retries=2\n",
-        "    )\n",
-        "    \n",
-        "    # Create agent\n",
-        "    agent_chain = create_react_agent(model=llm, tools=tools)\n",
-        "    agent_chain = agent_chain.with_config({\"recursion_limit\": 75})\n",
-        "    agent_chain.llm = llm  # Add LLM reference for Dasein\n",
-        "    \n",
-        "    print(\"✅ Browser agent created\")\n",
-        "    return agent_chain\n",
-        "\n",
-        "# Create the agent\n",
-        "browser_agent = await create_browser_agent()\n"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# Wrap with Dasein\n",
-        "browser_agent = cognate(\n",
-        "    browser_agent,\n",
-        "    retry=2,\n",
-        "    performance_tracking=True,\n",
-        "    verbose=False  # Set to True to see rule injection details\n",
-        ")\n",
-        "\n",
-        "# Test query\n",
-        "query = \"Go to https://python.langchain.com and find if there's a tutorial on creating a browsing agent.\"\n",
-        "\n",
-        "print(f\"\\nQuery: {query}\\n\")\n",
-        "print(\"=\" * 70)\n",
-        "print(\"PHASE 1: Baseline run...\")\n",
-        "print(\"PHASE 2: Enhanced run with learned rules...\")\n",
-        "print(\"=\" * 70)\n",
-        "\n",
-        "result = await browser_agent.ainvoke({\"messages\": [(\"user\", query)]})\n",
-        "\n",
-        "print(f\"\\n✅ Final Answer: {result}\")\n",
-        "print(\"\\n📊 Check the performance metrics above to see improvement!\")\n"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "---\n",
-        "\n",
-        "# Use Case 3: Deep Research Agent with Learning\n",
-        "\n",
-        "This example demonstrates Dasein with LangChain's **Open Deep Research Agent** - a complex multi-agent system that orchestrates research tasks.\n",
-        "\n",
-        "**What Happens:**\n",
-        "1. **Baseline Run**: Multi-agent research system runs without optimization\n",
-        "   - Supervisor delegates to sub-agents\n",
-        "   - Parallel research with Tavily search\n",
-        "   - Context accumulation and synthesis\n",
-        "   - Typically uses 15x more tokens than normal chat!\n",
-        "\n",
-        "2. **Learning**: Dasein learns:\n",
-        "   - Better search query formulation\n",
-        "   - Context filtering to reduce token bloat\n",
-        "   - Improved delegation strategies\n",
-        "   - Efficient tool usage patterns\n",
-        "\n",
-        "3. **Enhanced Run**: Agent runs with learned rules\n",
-        "\n",
-        "**Expected Improvements:**\n",
-        "- 20-40% reduction in tokens used\n",
-        "- Fewer redundant searches\n",
-        "- Better query formulation\n",
-        "- Faster convergence to quality results\n",
-        "\n",
-        "**Requirements:**\n",
-        "- TAVILY_API_KEY (free tier: 1000 searches/month)\n"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# Critical fix: Force LangChain to use Google GenAI instead of Vertex AI\n",
-        "from langchain.chat_models import base as chat_models_base\n",
-        "from langchain_google_genai import ChatGoogleGenerativeAI\n",
-        "\n",
-        "original_init_helper = chat_models_base._init_chat_model_helper\n",
-        "_model_cache = {}\n",
-        "_patch_logged = set()\n",
-        "\n",
-        "def patched_init_helper(*args, **kwargs):\n",
-        "    \"\"\"Force gemini models to use ChatGoogleGenerativeAI.\"\"\"\n",
-        "    model = kwargs.get('model', '')\n",
-        "    if not model and args:\n",
-        "        model = args[0] if len(args) > 0 and isinstance(args[0], str) else ''\n",
-        "    \n",
-        "    if model and 'gemini' in model.lower():\n",
-        "        if model not in _patch_logged:\n",
-        "            print(f\"🔧 Using ChatGoogleGenerativeAI for {model}\")\n",
-        "            _patch_logged.add(model)\n",
-        "        \n",
-        "        if model not in _model_cache:\n",
-        "            _model_cache[model] = ChatGoogleGenerativeAI(model=model)\n",
-        "        return _model_cache[model]\n",
-        "    return original_init_helper(*args, **kwargs)\n",
-        "\n",
-        "chat_models_base._init_chat_model_helper = patched_init_helper\n",
-        "print(\"✅ Patched LangChain to use Google GenAI\")\n"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "from open_deep_research.deep_researcher import deep_researcher_builder\n",
-        "from open_deep_research.configuration import Configuration\n",
-        "from dasein import cognate\n",
-        "import asyncio\n",
-        "\n",
-        "async def create_research_agent():\n",
-        "    \"\"\"Create Open Deep Research agent.\"\"\"\n",
-        "    print(\"Setting up Open Deep Research Agent...\")\n",
-        "    print(\"Source: https://github.com/langchain-ai/open_deep_research\\n\")\n",
-        "    \n",
-        "    # Configure with Gemini models and Tavily search\n",
-        "    config = Configuration(\n",
-        "        summarization_model=\"gemini-2.5-flash\",\n",
-        "        research_model=\"gemini-2.5-flash\",\n",
-        "        compression_model=\"gemini-2.5-flash\",\n",
-        "        final_report_model=\"gemini-2.5-flash\",\n",
-        "        allow_clarification=False,\n",
-        "        max_concurrent_research_units=2,\n",
-        "        max_researcher_iterations=4,\n",
-        "        max_react_tool_calls=8,\n",
-        "    )\n",
-        "    \n",
-        "    print(\"Configuration:\")\n",
-        "    print(f\"  - Models: {config.research_model}\")\n",
-        "    print(f\"  - Search API: Tavily\")\n",
-        "    print(f\"  - Max concurrent researchers: {config.max_concurrent_research_units}\\n\")\n",
-        "    \n",
-        "    # Create the deep researcher graph\n",
-        "    graph = deep_researcher_builder.compile()\n",
-        "    \n",
-        "    print(\"✅ Research agent created\\n\")\n",
-        "    print(\"Graph structure:\")\n",
-        "    print(\"  1. Brief Generation\")\n",
-        "    print(\"  2. Research Supervisor\")\n",
-        "    print(\"  3. Research Sub-Agents (parallel)\")\n",
-        "    print(\"  4. Report Writing\\n\")\n",
-        "    \n",
-        "    # Add LLM reference for Dasein\n",
-        "    graph.llm = ChatGoogleGenerativeAI(model=\"gemini-2.5-flash\", temperature=0)\n",
-        "    \n",
-        "    return graph\n",
-        "\n",
-        "# Create the research agent\n",
-        "research_agent = await create_research_agent()\n"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# Wrap with Dasein\n",
-        "research_agent = cognate(\n",
-        "    research_agent,\n",
-        "    retry=2,\n",
-        "    performance_tracking=True,\n",
-        "    verbose=False  # Set to True to see rule injection details\n",
-        ")\n",
-        "\n",
-        "# Research query\n",
-        "query = \"\"\"Research and compare LangChain vs LlamaIndex for building LLM applications.\n",
-        "\n",
-        "I want to understand:\n",
-        "1. Their core philosophies and approaches\n",
-        "2. Key features and strengths\n",
-        "3. Which use cases each is best suited for\n",
-        "\n",
-        "Provide a concise comparison with sources.\"\"\"\n",
-        "\n",
-        "print(f\"Research Query: {query}\\n\")\n",
-        "print(\"=\" * 70)\n",
-        "print(\"This will trigger:\")\n",
-        "print(\"  - Supervisor creating 2 sub-agents (one per framework)\")\n",
-        "print(\"  - Parallel research with Tavily search\")\n",
-        "print(\"  - Multiple search rounds per sub-agent\")\n",
-        "print(\"  - Synthesis and report writing\\n\")\n",
-        "print(\"PHASE 1: Baseline run...\")\n",
-        "print(\"PHASE 2: Enhanced run with learned rules...\")\n",
-        "print(\"=\" * 70)\n",
-        "\n",
-        "result = await research_agent.ainvoke(\n",
-        "    {\"messages\": [(\"user\", query)]},\n",
-        "    config={\n",
-        "        \"configurable\": {\n",
-        "            \"allow_clarification\": False,\n",
-        "            \"summarization_model\": \"gemini-2.5-flash\",\n",
-        "            \"research_model\": \"gemini-2.5-flash\",\n",
-        "        }\n",
-        "    }\n",
-        ")\n",
-        "\n",
-        "# Display report (truncated for readability)\n",
-        "report = str(result.get('report', result))\n",
-        "if len(report) > 500:\n",
-        "    print(f\"\\n✅ Research Report (truncated):\\n{report[:500]}...\\n[{len(report)} total chars]\")\n",
-        "else:\n",
-        "    print(f\"\\n✅ Research Report:\\n{report}\")\n",
-        "\n",
-        "print(\"\\n📊 Check the performance metrics above to see massive token savings!\")\n"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "---\n",
-        "\n",
-        "## Summary\n",
-        "\n",
-        "You've just seen **Dasein** in action across three different agent types:\n",
-        "\n",
-        "1. **SQL Agent** - Learned query optimization patterns\n",
-        "2. **Browser Agent** - Learned navigation and tool usage strategies\n",
-        "3. **Deep Research Agent** - Learned to optimize complex multi-agent workflows\n",
-        "\n",
-        "### Key Takeaways\n",
-        "\n",
-        "- ✨ **One-line integration**: `cognate(agent)` is all you need\n",
-        "- 🧠 **Automatic learning**: Agents improve themselves without manual rule engineering\n",
-        "- 📊 **Transparent metrics**: See exactly how much you're improving\n",
-        "- ☁️ **Cloud-powered**: Rules are stored and synthesized using distributed services\n",
-        "- 🔄 **Intelligent retry**: `retry=2` automatically runs baseline + enhanced\n",
-        "\n",
-        "### Next Steps\n",
-        "\n",
-        "1. **Try your own agents** - Dasein works with any LangChain/LangGraph agent\n",
-        "2. **Customize optimization** - Use the `weights` parameter to optimize for what matters to you\n",
-        "3. **Build rule libraries** - Run multiple times to accumulate learned rules\n",
-        "4. **Scale up** - The more you use Dasein, the smarter your agents become\n",
-        "\n",
-        "### Resources\n",
-        "\n",
-        "- 📖 [Documentation](https://github.com/nickswami/dasein-core#readme)\n",
-        "- 💻 [GitHub](https://github.com/nickswami/dasein-core)\n",
-        "- 💬 [Discord Community](https://discord.gg/dasein)\n",
-        "- 🐛 [Report Issues](https://github.com/nickswami/dasein-core/issues)\n",
-        "\n",
-        "---\n",
-        "\n",
-        "**Built with ❤️ for the agentic AI community**\n"
-      ]
-    }
-  ],
-  "metadata": {
-    "language_info": {
-      "name": "python"
-    }
-  },
-  "nbformat": 4,
-  "nbformat_minor": 2
-}
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "# 🧠 Dasein Examples: Universal Memory for Agentic AI\n",
+        "\n",
+        "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/nickswami/dasein-core/blob/main/examples/dasein_examples.ipynb)\n",
+        "\n",
+        "This notebook demonstrates **Dasein** - a universal memory system that learns from your agent's execution history and automatically improves performance, reduces costs, and increases reliability.\n",
+        "\n",
+        "## What You'll Learn\n",
+        "\n",
+        "1. **SQL Agent** - Learn query patterns for database interactions\n",
+        "2. **Browser Agent** - Learn web scraping and navigation strategies\n",
+        "3. **Deep Research Agent** - Optimize multi-agent research workflows\n",
+        "\n",
+        "## Key Features\n",
+        "\n",
+        "- ✨ **Zero-friction integration** - Wrap any agent in one line\n",
+        "- 🧠 **Automatic learning** - Agents learn from successes and failures\n",
+        "- 📊 **Performance tracking** - See token usage, timing, and improvement metrics\n",
+        "- 🔄 **Retry logic** - Intelligent retry with learned optimizations\n",
+        "- ☁️ **Cloud-powered** - Distributed rule synthesis and storage\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Installation\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Install Dasein and dependencies\n",
+        "!pip install -q dasein-core\n",
+        "\n",
+        "# For browser agent example (Use Case 2)\n",
+        "!pip install -q playwright\n",
+        "!playwright install chromium\n",
+        "\n",
+        "# For deep research agent (Use Case 3)\n",
+        "!pip install -q git+https://github.com/langchain-ai/open_deep_research.git\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Setup API Keys\n",
+        "\n",
+        "Replace the placeholders below with your actual API keys:\n",
+        "\n",
+        "- **GOOGLE_API_KEY**: Get from [Google AI Studio](https://makersuite.google.com/app/apikey)\n",
+        "- **TAVILY_API_KEY**: Get from [Tavily](https://tavily.com) (free tier available, 1000 searches/month)\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "import os\n",
+        "\n",
+        "# ⚠️ REPLACE THESE WITH YOUR ACTUAL API KEYS\n",
+        "os.environ[\"GOOGLE_API_KEY\"] = \"YOUR_GOOGLE_API_KEY_HERE\"\n",
+        "os.environ[\"TAVILY_API_KEY\"] = \"YOUR_TAVILY_API_KEY_HERE\"  # Only needed for Use Case 3\n",
+        "\n",
+        "# Suppress warnings\n",
+        "os.environ[\"GOOGLE_CLOUD_DISABLE_DIRECT_PATH\"] = \"true\"\n",
+        "\n",
+        "print(\"✅ API keys configured\")\n",
+        "print(\"\\n⚠️ Note: You may see dependency warnings in Colab - these are safe to ignore.\")\n",
+        "print(\"⚠️ Note: Brief timeout warnings on first run are normal (cold start) - services will activate automatically.\")\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "---\n",
+        "\n",
+        "# Use Case 1: SQL Agent with Learning\n",
+        "\n",
+        "This example demonstrates how Dasein learns SQL query patterns and improves database agent performance.\n",
+        "\n",
+        "**What Happens:**\n",
+        "1. **Baseline Run**: Agent queries the Chinook database without optimization\n",
+        "2. **Learning**: Dasein captures the execution trace and sends it to cloud services for rule synthesis\n",
+        "3. **Enhanced Run**: Agent runs again with learned rules injected, showing improved performance\n",
+        "\n",
+        "**Expected Improvements:**\n",
+        "- 30-50% reduction in tokens used\n",
+        "- Fewer SQL query iterations\n",
+        "- Better query formulation\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "import urllib.request\n",
+        "from pathlib import Path\n",
+        "\n",
+        "# Download Chinook sample database\n",
+        "db_path = Path(\"chinook.db\")\n",
+        "if not db_path.exists():\n",
+        "    print(\"Downloading Chinook database...\")\n",
+        "    urllib.request.urlretrieve(\n",
+        "        \"https://raw.githubusercontent.com/lerocha/chinook-database/master/ChinookDatabase/DataSources/Chinook_Sqlite.sqlite\",\n",
+        "        str(db_path)\n",
+        "    )\n",
+        "    print(\"✅ Database downloaded\")\n",
+        "else:\n",
+        "    print(\"✅ Database already exists\")\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from langchain_community.utilities import SQLDatabase\n",
+        "from langchain_community.agent_toolkits import SQLDatabaseToolkit\n",
+        "from langchain_community.agent_toolkits.sql.base import create_sql_agent\n",
+        "from langchain_google_genai import ChatGoogleGenerativeAI\n",
+        "from dasein import cognate\n",
+        "\n",
+        "# Set up SQL agent\n",
+        "print(\"Setting up SQL agent...\")\n",
+        "db = SQLDatabase.from_uri(f\"sqlite:///{db_path}\")\n",
+        "llm = ChatGoogleGenerativeAI(model=\"gemini-2.5-flash\", temperature=0)\n",
+        "toolkit = SQLDatabaseToolkit(db=db, llm=llm)\n",
+        "agent = create_sql_agent(llm=llm, toolkit=toolkit, verbose=True, handle_parsing_errors=True)\n",
+        "\n",
+        "print(\"✅ SQL agent created\")\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Wrap with Dasein for automatic learning and improvement\n",
+        "agent = cognate(\n",
+        "    agent,\n",
+        "    retry=2,  # Run twice: baseline + enhanced\n",
+        "    performance_tracking=True,  # Show improvement metrics\n",
+        "    verbose=False  # Set to True to see rule injection details\n",
+        ")\n",
+        "\n",
+        "# Run the query - Dasein handles everything automatically!\n",
+        "query = \"Which media format accounts for the highest number of individual line-item sales?\"\n",
+        "\n",
+        "print(f\"\\nQuery: {query}\\n\")\n",
+        "print(\"=\" * 70)\n",
+        "print(\"PHASE 1: Baseline run...\")\n",
+        "print(\"PHASE 2: Enhanced run with learned rules...\")\n",
+        "print(\"=\" * 70)\n",
+        "\n",
+        "result = agent.invoke({\"input\": query})\n",
+        "\n",
+        "print(f\"\\n✅ Final Answer: {result.get('output', '')}\")\n",
+        "print(\"\\n📊 Check the performance metrics above to see improvement!\")\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "---\n",
+        "\n",
+        "# Use Case 2: Browser Agent with Learning\n",
+        "\n",
+        "This example demonstrates how Dasein learns web scraping and navigation patterns.\n",
+        "\n",
+        "**What Happens:**\n",
+        "1. **Baseline Run**: Browser agent navigates to a website without optimization\n",
+        "2. **Learning**: Dasein learns which tools to use, navigation patterns, and element selection strategies\n",
+        "3. **Enhanced Run**: Agent runs again with learned rules, showing faster and more efficient browsing\n",
+        "\n",
+        "**Expected Improvements:**\n",
+        "- Fewer navigation steps\n",
+        "- Better tool selection\n",
+        "- More efficient element targeting\n",
+        "- Reduced token usage\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from langchain_community.agent_toolkits import PlayWrightBrowserToolkit\n",
+        "from langchain_google_genai import ChatGoogleGenerativeAI\n",
+        "from langgraph.prebuilt import create_react_agent\n",
+        "from dasein import cognate\n",
+        "import asyncio\n",
+        "from playwright.async_api import async_playwright\n",
+        "\n",
+        "async def create_browser_agent():\n",
+        "    \"\"\"Create a Playwright browser agent.\"\"\"\n",
+        "    print(\"Setting up Playwright browser agent...\")\n",
+        "    \n",
+        "    # Create browser\n",
+        "    playwright = await async_playwright().start()\n",
+        "    async_browser = await playwright.chromium.launch(headless=True)\n",
+        "    \n",
+        "    # Create toolkit and tools\n",
+        "    toolkit = PlayWrightBrowserToolkit.from_browser(async_browser=async_browser)\n",
+        "    tools = toolkit.get_tools()\n",
+        "    \n",
+        "    print(f\"Available browser tools: {[tool.name for tool in tools]}\")\n",
+        "    \n",
+        "    # Create LLM\n",
+        "    llm = ChatGoogleGenerativeAI(\n",
+        "        model=\"gemini-2.5-flash\",\n",
+        "        temperature=0,\n",
+        "        request_timeout=180,\n",
+        "        max_retries=2\n",
+        "    )\n",
+        "    \n",
+        "    # Create agent\n",
+        "    agent_chain = create_react_agent(model=llm, tools=tools)\n",
+        "    agent_chain = agent_chain.with_config({\"recursion_limit\": 75})\n",
+        "    agent_chain.llm = llm  # Add LLM reference for Dasein\n",
+        "    \n",
+        "    print(\"✅ Browser agent created\")\n",
+        "    return agent_chain\n",
+        "\n",
+        "# Create the agent\n",
+        "browser_agent = await create_browser_agent()\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Wrap with Dasein\n",
+        "browser_agent = cognate(\n",
+        "    browser_agent,\n",
+        "    retry=2,\n",
+        "    performance_tracking=True,\n",
+        "    verbose=False  # Set to True to see rule injection details\n",
+        ")\n",
+        "\n",
+        "# Test query\n",
+        "query = \"Go to the LangChain site (https://python.langchain.com). Is there a tutorial on how to create a browsing agent? If so where is it?\"\n",
+        "\n",
+        "print(f\"\\nQuery: {query}\\n\")\n",
+        "print(\"=\" * 70)\n",
+        "print(\"PHASE 1: Baseline run...\")\n",
+        "print(\"PHASE 2: Enhanced run with learned rules...\")\n",
+        "print(\"=\" * 70)\n",
+        "\n",
+        "result = await browser_agent.ainvoke({\"messages\": [(\"user\", query)]})\n",
+        "\n",
+        "print(f\"\\n✅ Final Answer: {result}\")\n",
+        "print(\"\\n📊 Check the performance metrics above to see improvement!\")\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "---\n",
+        "\n",
+        "# Use Case 3: Deep Research Agent with Learning\n",
+        "\n",
+        "This example demonstrates Dasein with LangChain's **Open Deep Research Agent** - a complex multi-agent system that orchestrates research tasks.\n",
+        "\n",
+        "**What Happens:**\n",
+        "1. **Baseline Run**: Multi-agent research system runs without optimization\n",
+        "   - Supervisor delegates to sub-agents\n",
+        "   - Parallel research with Tavily search\n",
+        "   - Context accumulation and synthesis\n",
+        "   - Typically uses 15x more tokens than normal chat!\n",
+        "\n",
+        "2. **Learning**: Dasein learns:\n",
+        "   - Better search query formulation\n",
+        "   - Context filtering to reduce token bloat\n",
+        "   - Improved delegation strategies\n",
+        "   - Efficient tool usage patterns\n",
+        "\n",
+        "3. **Enhanced Run**: Agent runs with learned rules\n",
+        "\n",
+        "**Expected Improvements:**\n",
+        "- 20-40% reduction in tokens used\n",
+        "- Fewer redundant searches\n",
+        "- Better query formulation\n",
+        "- Faster convergence to quality results\n",
+        "\n",
+        "**Requirements:**\n",
+        "- TAVILY_API_KEY (free tier: 1000 searches/month)\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Critical fix: Force LangChain to use Google GenAI instead of Vertex AI\n",
+        "from langchain.chat_models import base as chat_models_base\n",
+        "from langchain_google_genai import ChatGoogleGenerativeAI\n",
+        "\n",
+        "original_init_helper = chat_models_base._init_chat_model_helper\n",
+        "_model_cache = {}\n",
+        "_patch_logged = set()\n",
+        "\n",
+        "def patched_init_helper(*args, **kwargs):\n",
+        "    \"\"\"Force gemini models to use ChatGoogleGenerativeAI.\"\"\"\n",
+        "    model = kwargs.get('model', '')\n",
+        "    if not model and args:\n",
+        "        model = args[0] if len(args) > 0 and isinstance(args[0], str) else ''\n",
+        "    \n",
+        "    if model and 'gemini' in model.lower():\n",
+        "        if model not in _patch_logged:\n",
+        "            print(f\"🔧 Using ChatGoogleGenerativeAI for {model}\")\n",
+        "            _patch_logged.add(model)\n",
+        "        \n",
+        "        if model not in _model_cache:\n",
+        "            _model_cache[model] = ChatGoogleGenerativeAI(model=model)\n",
+        "        return _model_cache[model]\n",
+        "    return original_init_helper(*args, **kwargs)\n",
+        "\n",
+        "chat_models_base._init_chat_model_helper = patched_init_helper\n",
+        "print(\"✅ Patched LangChain to use Google GenAI\")\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from open_deep_research.deep_researcher import deep_researcher_builder\n",
+        "from open_deep_research.configuration import Configuration\n",
+        "from dasein import cognate\n",
+        "import asyncio\n",
+        "\n",
+        "async def create_research_agent():\n",
+        "    \"\"\"Create Open Deep Research agent.\"\"\"\n",
+        "    print(\"Setting up Open Deep Research Agent...\")\n",
+        "    print(\"Source: https://github.com/langchain-ai/open_deep_research\\n\")\n",
+        "    \n",
+        "    # Configure with Gemini models and Tavily search\n",
+        "    config = Configuration(\n",
+        "        summarization_model=\"gemini-2.5-flash\",\n",
+        "        research_model=\"gemini-2.5-flash\",\n",
+        "        compression_model=\"gemini-2.5-flash\",\n",
+        "        final_report_model=\"gemini-2.5-flash\",\n",
+        "        allow_clarification=False,\n",
+        "        max_concurrent_research_units=2,\n",
+        "        max_researcher_iterations=4,\n",
+        "        max_react_tool_calls=8,\n",
+        "    )\n",
+        "    \n",
+        "    print(\"Configuration:\")\n",
+        "    print(f\"  - Models: {config.research_model}\")\n",
+        "    print(f\"  - Search API: Tavily\")\n",
+        "    print(f\"  - Max concurrent researchers: {config.max_concurrent_research_units}\\n\")\n",
+        "    \n",
+        "    # Create the deep researcher graph\n",
+        "    graph = deep_researcher_builder.compile()\n",
+        "    \n",
+        "    print(\"✅ Research agent created\\n\")\n",
+        "    print(\"Graph structure:\")\n",
+        "    print(\"  1. Brief Generation\")\n",
+        "    print(\"  2. Research Supervisor\")\n",
+        "    print(\"  3. Research Sub-Agents (parallel)\")\n",
+        "    print(\"  4. Report Writing\\n\")\n",
+        "    \n",
+        "    # Add LLM reference for Dasein\n",
+        "    graph.llm = ChatGoogleGenerativeAI(model=\"gemini-2.5-flash\", temperature=0)\n",
+        "    \n",
+        "    return graph\n",
+        "\n",
+        "# Create the research agent\n",
+        "research_agent = await create_research_agent()\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Wrap with Dasein\n",
+        "research_agent = cognate(\n",
+        "    research_agent,\n",
+        "    retry=2,\n",
+        "    performance_tracking=True,\n",
+        "    verbose=False  # Set to True to see rule injection details\n",
+        ")\n",
+        "\n",
+        "# Research query\n",
+        "query = \"\"\"Research and compare LangChain vs LlamaIndex for building LLM applications.\n",
+        "\n",
+        "I want to understand:\n",
+        "1. Their core philosophies and approaches\n",
+        "2. Key features and strengths\n",
+        "3. Which use cases each is best suited for\n",
+        "\n",
+        "Provide a concise comparison with sources.\"\"\"\n",
+        "\n",
+        "print(f\"Research Query: {query}\\n\")\n",
+        "print(\"=\" * 70)\n",
+        "print(\"This will trigger:\")\n",
+        "print(\"  - Supervisor creating 2 sub-agents (one per framework)\")\n",
+        "print(\"  - Parallel research with Tavily search\")\n",
+        "print(\"  - Multiple search rounds per sub-agent\")\n",
+        "print(\"  - Synthesis and report writing\\n\")\n",
+        "print(\"PHASE 1: Baseline run...\")\n",
+        "print(\"PHASE 2: Enhanced run with learned rules...\")\n",
+        "print(\"=\" * 70)\n",
+        "\n",
+        "result = await research_agent.ainvoke(\n",
+        "    {\"messages\": [(\"user\", query)]},\n",
+        "    config={\n",
+        "        \"configurable\": {\n",
+        "            \"allow_clarification\": False,\n",
+        "            \"summarization_model\": \"gemini-2.5-flash\",\n",
+        "            \"research_model\": \"gemini-2.5-flash\",\n",
+        "        }\n",
+        "    }\n",
+        ")\n",
+        "\n",
+        "# Display report (truncated for readability)\n",
+        "report = str(result.get('report', result))\n",
+        "if len(report) > 500:\n",
+        "    print(f\"\\n✅ Research Report (truncated):\\n{report[:500]}...\\n[{len(report)} total chars]\")\n",
+        "else:\n",
+        "    print(f\"\\n✅ Research Report:\\n{report}\")\n",
+        "\n",
+        "print(\"\\n📊 Check the performance metrics above to see massive token savings!\")\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "---\n",
+        "\n",
+        "## Summary\n",
+        "\n",
+        "You've just seen **Dasein** in action across three different agent types:\n",
+        "\n",
+        "1. **SQL Agent** - Learned query optimization patterns\n",
+        "2. **Browser Agent** - Learned navigation and tool usage strategies\n",
+        "3. **Deep Research Agent** - Learned to optimize complex multi-agent workflows\n",
+        "\n",
+        "### Key Takeaways\n",
+        "\n",
+        "- ✨ **One-line integration**: `cognate(agent)` is all you need\n",
+        "- 🧠 **Automatic learning**: Agents improve themselves without manual rule engineering\n",
+        "- 📊 **Transparent metrics**: See exactly how much you're improving\n",
+        "- ☁️ **Cloud-powered**: Rules are stored and synthesized using distributed services\n",
+        "- 🔄 **Intelligent retry**: `retry=2` automatically runs baseline + enhanced\n",
+        "\n",
+        "### Next Steps\n",
+        "\n",
+        "1. **Try your own agents** - Dasein works with any LangChain/LangGraph agent\n",
+        "2. **Customize optimization** - Use the `weights` parameter to optimize for what matters to you\n",
+        "3. **Build rule libraries** - Run multiple times to accumulate learned rules\n",
+        "4. **Scale up** - The more you use Dasein, the smarter your agents become\n",
+        "\n",
+        "### Resources\n",
+        "\n",
+        "- 📖 [Documentation](https://github.com/nickswami/dasein-core#readme)\n",
+        "- 💻 [GitHub](https://github.com/nickswami/dasein-core)\n",
+        "- 💬 [Discord Community](https://discord.gg/dasein)\n",
+        "- 🐛 [Report Issues](https://github.com/nickswami/dasein-core/issues)\n",
+        "\n",
+        "---\n",
+        "\n",
+        "**Built with ❤️ for the agentic AI community**\n"
+      ]
+    }
+  ],
+  "metadata": {
+    "language_info": {
+      "name": "python"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 2
+}

{dasein_core-0.2.4 → dasein_core-0.2.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "dasein-core"
-version = "0.2.4"
+version = "0.2.6"
 description = "Universal memory for agentic AI. Attach a brain to any LangChain/LangGraph agent in a single line."
 readme = "README.md"
 requires-python = ">=3.8"

{dasein_core-0.2.4 → dasein_core-0.2.6}/src/dasein/api.py

@@ -2163,12 +2163,14 @@ Follow these rules when planning your actions."""
         tool_calls = len([step for step in trace if step.get('step_type') == 'tool_start'])
         total_turns = len(trace)
         
-        # Sum up tokens and time
+        # Sum up tokens and calculate average time
         input_tokens = sum(step.get('tokens_input', 0) for step in trace)
         output_tokens = sum(step.get('tokens_output', 0) for step in trace)
         total_tokens = input_tokens + output_tokens
         
-        trace_time_ms = sum(step.get('duration_ms', 0) for step in trace)
+        # Calculate average duration_ms across all steps that have timing data
+        durations = [step.get('duration_ms', 0) for step in trace if step.get('duration_ms', 0) > 0]
+        trace_time_ms = int(sum(durations) / len(durations)) if durations else 0
         
         # Calculate wall time from timestamps (they are ISO format strings)
         if len(trace) > 1:
@@ -2823,6 +2825,81 @@ Follow these rules when planning your actions."""
                     return getattr(agent, 'agent_id', None) or f"agent_{id(agent)}"
 
             agent_fingerprint = _minimal_agent_fingerprint(self._agent)
+            
+            # Extract tool metadata for Stage 3.5 tool grounding
+            def _extract_tool_metadata(agent):
+                """
+                Extract tool metadata (name, description, args_schema) from agent.
+                
+                CRITICAL: Extracts ALL available tools from the agent, not just tools used in trace.
+                Why: If agent used wrong tool (e.g., extract_text instead of get_elements), 
+                the trace won't show the correct tool. Stage 3.5 needs to see all options
+                to suggest better alternatives.
+                """
+                tools_metadata = []
+                tools_to_process = []
+                
+                # Get ALL tools from agent (LangChain or LangGraph) - not filtered by trace usage
+                tools_attr = getattr(agent, 'tools', None)
+                if tools_attr:
+                    try:
+                        tools_to_process = list(tools_attr)
+                    except Exception:
+                        pass
+                elif getattr(agent, 'toolkit', None):
+                    tk = getattr(agent, 'toolkit')
+                    tk_tools = getattr(tk, 'tools', None) or getattr(tk, 'get_tools', None)
+                    try:
+                        tools_to_process = list(tk_tools() if callable(tk_tools) else tk_tools or [])
+                    except Exception:
+                        pass
+                
+                # Also try LangGraph tools from compiled graph
+                if hasattr(agent, 'nodes') and 'tools' in agent.nodes:
+                    tools_node = agent.nodes['tools']
+                    if hasattr(tools_node, 'node') and hasattr(tools_node.node, 'steps'):
+                        for step in tools_node.node.steps:
+                            if hasattr(step, 'tools_by_name'):
+                                tools_to_process.extend(step.tools_by_name.values())
+                                break
+                
+                # Extract metadata from each tool
+                for tool in tools_to_process:
+                    try:
+                        tool_meta = {
+                            'name': getattr(tool, 'name', str(tool.__class__.__name__)),
+                            'description': getattr(tool, 'description', ''),
+                        }
+                        
+                        # Extract args_schema if available
+                        if hasattr(tool, 'args_schema') and tool.args_schema:
+                            try:
+                                # Try Pydantic v2 method
+                                if hasattr(tool.args_schema, 'model_json_schema'):
+                                    tool_meta['args_schema'] = tool.args_schema.model_json_schema()
+                                # Fallback to Pydantic v1 method
+                                elif hasattr(tool.args_schema, 'schema'):
+                                    tool_meta['args_schema'] = tool.args_schema.schema()
+                                else:
+                                    tool_meta['args_schema'] = {}
+                            except Exception:
+                                tool_meta['args_schema'] = {}
+                        else:
+                            tool_meta['args_schema'] = {}
+                        
+                        tools_metadata.append(tool_meta)
+                    except Exception as e:
+                        # Skip tools that fail to extract
+                        pass
+                
+                return tools_metadata
+            
+            tools_metadata = _extract_tool_metadata(self._agent)
+            print(f"[DASEIN] Extracted metadata for {len(tools_metadata)} tools")
+            if tools_metadata:
+                print(f"[DASEIN] Sample tool: {tools_metadata[0].get('name', 'unknown')}")
+            else:
+                print(f"[DASEIN] WARNING: No tools extracted! Agent type: {type(self._agent)}")
 
             response = self._service_adapter.synthesize_rules(
                 run_id=None,  # Will use stored run_id from pre-run phase
@@ -2837,7 +2914,8 @@ Follow these rules when planning your actions."""
                 agent_fingerprint=agent_fingerprint,  # Reuse fingerprint from pre-run (line 2613)
                 step_id=self._current_step_id,  # Pass step_id for parallel execution tracking
                 post_run_mode=self._post_run,  # Pass post_run mode ("full" or "kpi_only")
-                wait_for_synthesis=wait_for_synthesis  # Wait for synthesis on retry runs (except last)
+                wait_for_synthesis=wait_for_synthesis,  # Wait for synthesis on retry runs (except last)
+                tools_metadata=tools_metadata  # Tool metadata for Stage 3.5 tool grounding
             )
 
             # response is a dict from ServiceAdapter; handle accordingly

{dasein_core-0.2.4 → dasein_core-0.2.6}/src/dasein/services/post_run_client.py

@@ -32,6 +32,7 @@ class RuleSynthesisRequest:
     skip_synthesis: bool = False
     wait_for_synthesis: bool = False
     step_id: Optional[str] = None
+    tools_metadata: Optional[List[Dict[str, Any]]] = None  # Tool metadata for Stage 3.5 grounding
 
 
 @dataclass
@@ -95,6 +96,7 @@ class PostRunClient:
             "performance_tracking_id": request.performance_tracking_id,
             "skip_synthesis": request.skip_synthesis,
             "wait_for_synthesis": request.wait_for_synthesis,
+            "tools_metadata": request.tools_metadata or [],  # Tool metadata for Stage 3.5 grounding
         }
         
         logger.info(f"Synthesizing rules for run: {request.run_id}")

{dasein_core-0.2.4 → dasein_core-0.2.6}/src/dasein/services/service_adapter.py

@@ -95,7 +95,7 @@ class ServiceAdapter:
                         max_rules: Optional[int] = 5, performance_tracking_id: Optional[str] = None,
                         skip_synthesis: bool = False, agent_fingerprint: Optional[str] = None,
                         step_id: Optional[str] = None, post_run_mode: str = "full",
-                        wait_for_synthesis: bool = False) -> Dict[str, Any]:
+                        wait_for_synthesis: bool = False, tools_metadata: Optional[List[Dict[str, Any]]] = None) -> Dict[str, Any]:
         """
         Synthesize rules from run telemetry (replaces local rule synthesis)
         
@@ -138,7 +138,8 @@ class ServiceAdapter:
                 performance_tracking_id=performance_tracking_id,
                 skip_synthesis=should_skip_synthesis,
                 wait_for_synthesis=wait_for_synthesis,
-                step_id=step_id
+                step_id=step_id,
+                tools_metadata=tools_metadata
             )
             
             response = self.post_run_client.synthesize_rules(request)

{dasein_core-0.2.4 → dasein_core-0.2.6/src/dasein_core.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dasein-core
-Version: 0.2.4
+Version: 0.2.6
 Summary: Universal memory for agentic AI. Attach a brain to any LangChain/LangGraph agent in a single line.
 Author-email: Dasein Team <support@dasein.ai>
 License: MIT