contextsynapse 1.0.0__py3-none-any.whl

contextsynapse/adapters/openai/tools.py

@@ -0,0 +1,206 @@
+"""
+AIContextDB OpenAI / Codex Adapter
+===================================
+Exposes AIContextDB operations as OpenAI function-calling tools,
+compatible with the Chat Completions API and Responses API.
+
+Thin wrapper over the Universal Tool Layer (contextsynapse.tools).
+All tool logic lives in contextcore/tools/ — this file only handles
+connection setup and format conversion.
+
+Usage:
+    from contextsynapse.adapters.openai import create_openai_tools, dispatch_tool_call
+
+    tools = create_openai_tools()          # OpenAI tool schemas
+    # Pass `tools` to openai.chat.completions.create(tools=tools, ...)
+
+    # When the model returns a tool_call, dispatch it:
+    result = dispatch_tool_call(tool_call.function.name, tool_call.function.arguments)
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+from datetime import datetime, timezone
+from typing import Any, Dict, List, Optional, Tuple
+
+from .._base import AIContextDBConnection
+
+logger = logging.getLogger(__name__)
+
+# ── Module-level state (lazy) ──────────────────────────────────────
+_conn: Optional[AIContextDBConnection] = None
+_agent_name: str = "codex"
+_agent_id: Optional[str] = None
+_api_key: Optional[str] = None
+_registry = None  # AgentRegistry instance
+_tool_context = None  # ToolContext for dispatch
+
+
+def _get_conn() -> AIContextDBConnection:
+    global _conn
+    if _conn is None:
+        _conn = AIContextDBConnection(namespace="default")
+    return _conn
+
+
+def _get_registry():
+    global _registry
+    if _registry is None:
+        from contextsynapse.context.store_factory import create_agent_registry
+        _registry = create_agent_registry()
+    return _registry
+
+
+def _ensure_registered(platform: str = "app") -> Tuple[str, str]:
+    global _agent_id, _api_key
+    if _agent_id and _api_key:
+        return _agent_id, _api_key
+    try:
+        registry = _get_registry()
+        agent, api_key = registry.register(
+            name=_agent_name, role="agent", platform=platform,
+            capabilities=["read", "write"],
+            metadata={"adapter": "openai", "registered_at": datetime.now(timezone.utc).isoformat()},
+        )
+        _agent_id = agent.agent_id
+        _api_key = api_key
+    except Exception as e:
+        logger.warning("Agent registration failed: %s", e)
+        _agent_id = _agent_name
+        _api_key = ""
+    return _agent_id, _api_key
+
+
+def _get_tool_context():
+    """Build or return the current ToolContext."""
+    global _tool_context
+    from contextsynapse.tools import ToolContext
+    _tool_context = ToolContext(
+        conn=_get_conn(),
+        agent_id=_agent_id or "unknown",
+        agent_name=_agent_name,
+    )
+    # Attach project if available
+    try:
+        from contextsynapse.project.team_tools import get_project
+        _tool_context.project = get_project()
+    except Exception:
+        pass
+    return _tool_context
+
+
+def configure(
+    namespace: str = "default",
+    agent_name: str = "codex",
+    platform: str = "app",
+    connection: Optional[AIContextDBConnection] = None,
+    daemon_url: Optional[str] = None,
+    auto_register: bool = True,
+    api_key: Optional[str] = None,
+    session_id: Optional[str] = None,
+) -> Dict[str, str]:
+    """Configure the adapter before use.
+
+    Preferred: pass api_key + session_id for secure session-based connection.
+    Legacy: pass namespace for direct graph access.
+    """
+    global _conn, _agent_name, _agent_id, _api_key
+
+    # Session-based connection (preferred)
+    if session_id and api_key:
+        from contextsynapse.context.session_resolver import resolve_session
+        resolved = resolve_session(session_id, api_key)
+        _agent_name = resolved.agent_name
+        _agent_id = resolved.agent_id
+        _api_key = api_key.split(":", 1)[1] if ":" in api_key else ""
+        _conn = AIContextDBConnection(namespace=resolved.graph_namespace)
+
+        # Init team tools with thread
+        try:
+            from contextsynapse.project.team_tools import init_team
+            from contextsynapse.project.graph import ProjectGraph
+            pg = ProjectGraph(resolved.graph_namespace, connection=_conn)
+            init_team(resolved.graph_namespace, agent_id=_agent_id,
+                      agent_name=_agent_name, project=pg, thread_id=resolved.thread_id)
+        except Exception:
+            pass
+
+        return {
+            "agent_id": resolved.agent_id,
+            "agent_name": resolved.agent_name,
+            "session_id": session_id,
+            "goal": resolved.goal,
+            "access_level": resolved.access_level,
+        }
+
+    # Legacy: direct namespace
+    _agent_name = agent_name
+    if connection is not None:
+        _conn = connection
+    else:
+        _conn = AIContextDBConnection(namespace=namespace, daemon_url=daemon_url)
+
+    result = {}
+    if auto_register:
+        agent_id, api_key_val = _ensure_registered(platform=platform)
+        result = {"agent_id": agent_id, "api_key": api_key_val}
+
+    return result
+
+
+# =====================================================================
+# Public API — delegates to Universal Tool Layer
+# =====================================================================
+
+def create_openai_tools(include_team: bool = True) -> List[Dict[str, Any]]:
+    """Return OpenAI-compatible tool schemas for AIContextDB.
+
+    Pass the returned list directly to openai.chat.completions.create(tools=...).
+    """
+    from contextsynapse.tools import ToolRegistry
+
+    categories = ["graph", "context", "gateway"]
+    if include_team:
+        categories.extend(["task", "workspace"])
+
+    return ToolRegistry.to_openai_schemas(categories)
+
+
+def init_project(project_name: str) -> str:
+    """Initialize a project graph for team collaboration."""
+    _ensure_registered()
+    from contextsynapse.tools import ToolRegistry
+    ctx = _get_tool_context()
+    return ToolRegistry.dispatch("init_project", ctx, {"project_name": project_name})
+
+
+def dispatch_tool_call(function_name: str, arguments: str) -> str:
+    """Execute a tool call returned by the OpenAI API.
+
+    Args:
+        function_name: The function name from tool_call.function.name
+        arguments: The JSON arguments from tool_call.function.arguments
+
+    Returns:
+        String result to send back as tool response.
+    """
+    from contextsynapse.tools import ToolRegistry
+
+    ctx = _get_tool_context()
+
+    try:
+        args = json.loads(arguments) if arguments else {}
+    except json.JSONDecodeError:
+        return f"Error: Invalid JSON arguments: {arguments}"
+
+    # Observe tool call for Context Relevance Gravity
+    try:
+        from contextsynapse.context.gravity import get_gravity
+        get_gravity().observe(ctx.agent_id or "unknown", function_name, args)
+    except Exception:
+        pass
+
+    return ToolRegistry.dispatch(function_name, ctx, args)

contextsynapse/adapters/pydantic_ai/__init__.py

@@ -0,0 +1,4 @@
+"""Pydantic AI adapter for AIContextDB."""
+from .tools import create_pydantic_ai_tools, graph_query_tool, graph_write_tool
+
+__all__ = ["create_pydantic_ai_tools", "graph_query_tool", "graph_write_tool"]

contextsynapse/adapters/pydantic_ai/tools.py

@@ -0,0 +1,36 @@
+"""
+Pydantic AI adapter — thin wrapper over Universal Tool Layer.
+
+Usage:
+    from contextsynapse.adapters.pydantic_ai.tools import create_pydantic_ai_tools
+    tools = create_pydantic_ai_tools(namespace="my-project")
+"""
+
+from __future__ import annotations
+
+import json
+from typing import List, Optional
+
+from contextsynapse.tools import ToolRegistry, ToolContext
+from contextsynapse.adapters._base import AIContextDBConnection
+
+
+def create_pydantic_ai_tools(
+    namespace: str = "default",
+    connection: Optional[AIContextDBConnection] = None,
+    categories: Optional[List[str]] = None,
+) -> list:
+    """Create Pydantic AI-compatible tools from the Universal Tool Registry."""
+    conn = connection or AIContextDBConnection(namespace=namespace)
+    ctx = ToolContext(conn=conn, agent_id="pydantic_ai", agent_name="pydantic_ai")
+
+    cats = categories or ["graph", "context", "task"]
+    tools = []
+    for td in ToolRegistry.by_category(*cats):
+        def _handler(_ctx=ctx, _td=td, **kwargs):
+            return _td.handler(_ctx, **kwargs)
+
+        _handler.__name__ = td.name
+        _handler.__doc__ = td.description
+        tools.append(_handler)
+    return tools

contextsynapse/adapters/swarm/__init__.py

@@ -0,0 +1,4 @@
+"""OpenAI Swarm / Agno adapter for AIContextDB."""
+from .tools import create_swarm_tools
+
+__all__ = ["create_swarm_tools"]

contextsynapse/adapters/swarm/tools.py

@@ -0,0 +1,44 @@
+"""
+Swarm / Agno adapter — thin wrapper over Universal Tool Layer.
+
+Swarm uses plain Python functions as tools.
+
+Usage:
+    from contextsynapse.adapters.swarm.tools import create_swarm_tools
+    functions = create_swarm_tools(namespace="my-project")
+"""
+
+from __future__ import annotations
+
+import json
+from typing import List, Optional
+
+from contextsynapse.tools import ToolRegistry, ToolContext
+from contextsynapse.adapters._base import AIContextDBConnection
+
+
+def create_swarm_tools(
+    namespace: str = "default",
+    connection: Optional[AIContextDBConnection] = None,
+    categories: Optional[List[str]] = None,
+) -> list:
+    """Create plain functions for Swarm/Agno from the Universal Tool Registry."""
+    conn = connection or AIContextDBConnection(namespace=namespace)
+    ctx = ToolContext(conn=conn, agent_id="swarm", agent_name="swarm")
+
+    cats = categories or ["graph", "context", "task"]
+    functions = []
+    for td in ToolRegistry.by_category(*cats):
+        def _fn(input_str="", _td=td, _ctx=ctx, **kwargs):
+            if kwargs:
+                return _td.handler(_ctx, **kwargs)
+            try:
+                args = json.loads(input_str) if input_str else {}
+            except (json.JSONDecodeError, AttributeError):
+                args = {_td.params[0].name: input_str} if _td.params else {}
+            return _td.handler(_ctx, **args)
+
+        _fn.__name__ = td.name
+        _fn.__doc__ = td.description
+        functions.append(_fn)
+    return functions

contextsynapse/agents/__init__.py

@@ -0,0 +1,6 @@
+"""
+Agent Platform — task dispatch, auto-capture, notifications, profiles.
+"""
+from .dispatcher import dispatch_goal, get_agent_profile, DEFAULT_PROFILES
+from .auto_capture import capture_tool_call
+from .notifications import notify_agents, get_pending_notifications

contextsynapse/agents/auto_capture.py

@@ -0,0 +1,80 @@
+"""
+Conversation Auto-Capture — automatically ingests agent activity into the graph.
+
+Every MCP tool call or API call captures:
+- What the agent searched for (search queries)
+- What the agent wrote (findings, decisions)
+- Tool usage patterns
+
+This runs passively — agents don't need to do anything special.
+The capture happens as a side-effect of tool dispatch.
+"""
+
+from __future__ import annotations
+
+import logging
+import uuid
+from datetime import datetime, timezone
+from typing import Any, Dict, Optional
+
+logger = logging.getLogger(__name__)
+
+
+def capture_tool_call(
+    agent_name: str,
+    agent_id: str,
+    tool_name: str,
+    params: Dict[str, Any],
+    result: str,
+    namespace: str,
+    db=None,
+):
+    """Capture a tool call as a lightweight Activity node.
+
+    Only captures meaningful activity — skips orient(), my_tasks(), etc.
+    """
+    # Skip noise — only capture substantive tool calls
+    SKIP_TOOLS = {"orient", "my_tasks", "list_tasks", "get_agent_context",
+                  "my_usage", "report_tokens", "get_tool_policy"}
+
+    if tool_name in SKIP_TOOLS:
+        return
+
+    # Skip if result is empty or error
+    if not result or result.startswith("Error:"):
+        return
+
+    # Determine activity type
+    if tool_name in ("search_nodes", "search", "rag_query", "rag_graph"):
+        activity_type = "search"
+        query = params.get("query", params.get("label", ""))
+        summary = f"Searched: {query}" if query else f"Searched graph"
+    elif tool_name in ("add_knowledge", "add_decision"):
+        activity_type = "write"
+        content = params.get("content", "")[:100]
+        summary = f"Wrote: {content}"
+    elif tool_name in ("add_task", "claim_task", "complete_task"):
+        activity_type = "task"
+        title = params.get("title", params.get("task_id", ""))
+        summary = f"Task: {tool_name.replace('_', ' ')} — {title}"
+    elif tool_name == "dispatch_goal":
+        activity_type = "dispatch"
+        summary = f"Dispatched goal: {params.get('goal', '')[:100]}"
+    else:
+        activity_type = "tool"
+        summary = f"Used {tool_name}"
+
+    # Store as lightweight provenance (not a full graph node — avoids noise)
+    try:
+        from ..context.propagation import get_propagator
+        get_propagator().propagate(
+            source_agent=agent_name or agent_id,
+            event_type=f"agent_{activity_type}",
+            content=summary,
+            namespace=namespace,
+            priority="info",
+        )
+    except Exception:
+        pass
+
+    logger.debug("[CAPTURE] %s: %s", agent_name, summary)

contextsynapse/agents/dispatcher.py

@@ -0,0 +1,299 @@
+"""
+Agent Task Dispatcher — Auto-decompose goals and assign to agents.
+
+Given a goal and a set of registered agents, the dispatcher:
+1. Decomposes the goal into tasks using LLM
+2. Matches tasks to agents based on profiles/capabilities
+3. Creates Task nodes assigned to specific agents
+4. Agents discover tasks via orient() or my_tasks()
+
+Usage:
+    from contextsynapse.agents.dispatcher import dispatch_goal
+
+    result = dispatch_goal(
+        goal="Analyze our codebase for security vulnerabilities",
+        session_id="abc123",
+        graph_registry=reg,
+        agent_registry=agent_reg,
+    )
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import uuid
+from datetime import datetime, timezone
+from typing import Any, Dict, List, Optional
+
+logger = logging.getLogger(__name__)
+
+
+# ── Agent Profiles ─────────────────────────────────────────────────────
+
+DEFAULT_PROFILES = {
+    "claude": {
+        "strengths": ["code review", "architecture", "debugging", "detailed analysis", "safety"],
+        "preferred_tasks": ["review code", "analyze architecture", "find bugs", "security audit"],
+        "speed": "thorough",
+    },
+    "chatgpt": {
+        "strengths": ["research", "writing", "brainstorming", "breadth", "summarization"],
+        "preferred_tasks": ["research topic", "write summary", "explore options", "draft document"],
+        "speed": "fast",
+    },
+    "gemini": {
+        "strengths": ["multimodal", "data analysis", "reasoning", "math"],
+        "preferred_tasks": ["analyze data", "process images", "calculate", "compare"],
+        "speed": "fast",
+    },
+}
+
+
+def get_agent_profile(agent, registry=None) -> Dict[str, Any]:
+    """Get the specialization profile for an agent.
+
+    Checks agent.metadata for a custom profile, falls back to defaults
+    based on agent name. Optionally enriches from registry capabilities.
+    """
+    metadata = agent.metadata if hasattr(agent, 'metadata') else {}
+    if isinstance(metadata, str):
+        try:
+            metadata = json.loads(metadata)
+        except Exception:
+            metadata = {}
+
+    # Custom profile in metadata
+    if metadata.get("profile"):
+        profile = metadata["profile"]
+    else:
+        # Match by name
+        name_lower = (agent.name if hasattr(agent, 'name') else "").lower()
+        profile = None
+        for key, default_profile in DEFAULT_PROFILES.items():
+            if key in name_lower:
+                profile = dict(default_profile)
+                break
+
+        if not profile:
+            profile = {
+                "strengths": ["general"],
+                "preferred_tasks": ["any"],
+                "speed": "normal",
+            }
+
+    # Enrich from registry capabilities if available
+    if registry:
+        try:
+            agent_name = (agent.name if hasattr(agent, 'name') else "").lower()
+            agents = registry.list_agents()
+            for reg_agent in agents:
+                reg_name = reg_agent.name if hasattr(reg_agent, 'name') else (reg_agent.get("name", "") if isinstance(reg_agent, dict) else "")
+                if reg_name.lower() == agent_name:
+                    caps = reg_agent.capabilities if hasattr(reg_agent, 'capabilities') else (reg_agent.get("capabilities", []) if isinstance(reg_agent, dict) else [])
+                    if isinstance(caps, str):
+                        caps = json.loads(caps)
+                    profile["strengths"] = list(set(profile.get("strengths", []) + caps))
+                    break
+        except Exception:
+            pass
+
+    return profile
+
+
+# ── Goal Decomposition ────────────────────────────────────────────────
+
+def decompose_goal(goal: str, agent_profiles: List[Dict], llm_fn=None) -> List[Dict]:
+    """Decompose a goal into tasks matched to agent capabilities.
+
+    Args:
+        goal: Natural language goal
+        agent_profiles: List of {"name": str, "strengths": [...]}
+        llm_fn: Optional LLM callable(prompt) -> str
+
+    Returns:
+        List of {"title": str, "description": str, "assigned_to": str, "priority": str}
+    """
+    agent_descriptions = "\n".join(
+        f"- {p['name']}: good at {', '.join(p.get('strengths', ['general']))}"
+        for p in agent_profiles
+    )
+
+    prompt = f"""Decompose this goal into 3-5 specific tasks and assign each to the best agent.
+
+GOAL: {goal}
+
+AVAILABLE AGENTS:
+{agent_descriptions}
+
+Rules:
+- Each task should be assigned to the agent whose strengths best match
+- Distribute work evenly — don't give everything to one agent
+- Tasks should be specific and actionable
+- Include a mix of research, analysis, and writing tasks
+
+Return ONLY a valid JSON array:
+[
+  {{"title": "task title", "description": "what to do", "assigned_to": "agent name", "priority": "high|medium|low"}},
+  ...
+]"""
+
+    if llm_fn:
+        try:
+            import re
+            response = llm_fn(prompt)
+            match = re.search(r'\[[\s\S]*\]', response)
+            if match:
+                return json.loads(match.group())
+        except Exception as e:
+            logger.warning("LLM decomposition failed: %s", e)
+
+    # Fallback: create one task per agent
+    tasks = []
+    for i, profile in enumerate(agent_profiles):
+        tasks.append({
+            "title": f"Research and analyze: {goal[:50]}",
+            "description": f"Focus on: {', '.join(profile.get('strengths', ['general'])[:2])}",
+            "assigned_to": profile["name"],
+            "priority": "high" if i == 0 else "medium",
+        })
+    return tasks
+
+
+# ── Dispatch Goal ─────────────────────────────────────────────────────
+
+def dispatch_goal(
+    goal: str,
+    session_id: str,
+    graph_registry=None,
+    agent_registry=None,
+    session_manager=None,
+    llm_fn=None,
+) -> Dict[str, Any]:
+    """Decompose a goal and create tasks assigned to registered agents.
+
+    Args:
+        goal: What needs to be accomplished
+        session_id: Session to create tasks in
+        graph_registry: GraphRegistry for graph access
+        agent_registry: AgentRegistry to find agents
+        session_manager: SessionManager for session lookup
+        llm_fn: Optional LLM callable
+
+    Returns:
+        {"tasks": [...], "agents": [...], "goal": str}
+    """
+    # Get session — tasks go to the runtime graph, not the atomic context
+    session = None
+    graph_ns = None
+    if session_manager:
+        session = session_manager.get_session(session_id)
+        if session:
+            # Use runtime_namespace for agent work (tasks, findings, actions)
+            graph_ns = getattr(session, 'runtime_namespace', '') or f"{session.graph_namespace}_rt"
+
+    if not graph_ns:
+        return {"error": "Session not found", "tasks": []}
+
+    # Get registered agents
+    agents = []
+    if agent_registry:
+        # Get agents assigned to this session
+        if session and session.config.get("assigned_agents"):
+            for aid in session.config["assigned_agents"]:
+                agent = agent_registry.get(aid)
+                if agent and agent.status == "active":
+                    agents.append(agent)
+
+        # If no assigned agents, get all active agents
+        if not agents:
+            try:
+                all_agents = agent_registry.list_agents() if hasattr(agent_registry, 'list_agents') else []
+                agents = [a for a in all_agents if a.status == "active"][:5]
+            except Exception:
+                pass
+
+    if not agents:
+        return {"error": "No agents available", "tasks": []}
+
+    # Build profiles
+    agent_profiles = []
+    for agent in agents:
+        profile = get_agent_profile(agent)
+        profile["name"] = agent.name
+        profile["agent_id"] = agent.agent_id
+        agent_profiles.append(profile)
+
+    logger.info("[DISPATCH] Goal: %s | Agents: %s", goal[:60],
+                [p["name"] for p in agent_profiles])
+
+    # Decompose goal into tasks
+    tasks = decompose_goal(goal, agent_profiles, llm_fn=llm_fn)
+
+    # Create task nodes in the graph
+    created = []
+    if graph_registry:
+        db = graph_registry.get_graph(graph_ns, load_if_missing=True)
+        if db:
+            from ..core.hybrid_graph_storage import GraphNode, GraphEdge
+
+            for task in tasks:
+                task_id = f"task_{uuid.uuid4().hex[:12]}"
+                props = {
+                    "title": task["title"],
+                    "description": task.get("description", ""),
+                    "assigned_to": task.get("assigned_to", ""),
+                    "priority": task.get("priority", "medium"),
+                    "status": "open",
+                    "created_by": "dispatcher",
+                    "created_at": datetime.now(timezone.utc).isoformat(),
+                    "goal": goal[:200],
+                    "session_id": session_id,
+                }
+                db.add_node(GraphNode(id=task_id, label="Task", properties=props))
+
+                created.append({
+                    "task_id": task_id,
+                    "title": task["title"],
+                    "assigned_to": task.get("assigned_to", ""),
+                    "priority": task.get("priority", "medium"),
+                })
+
+                logger.info("[DISPATCH] Created task: %s → %s", task["title"][:40], task.get("assigned_to", "?"))
+
+    # Publish all created tasks to stream for push-based delivery
+    try:
+        from ..project.task_stream import get_task_publisher
+        pub = get_task_publisher()
+        stream_tasks = [
+            {"task_id": t.get("task_id", t.get("id", "")),
+             "priority": {"critical": 3, "high": 2, "medium": 1, "low": 0}.get(t.get("priority", "medium"), 1),
+             "metadata": {"title": t.get("title", ""), "assigned_to": t.get("assigned_to", ""), "goal": goal}}
+            for t in created
+        ]
+        if stream_tasks:
+            pub.publish_batch(namespace=graph_ns, tasks=stream_tasks)
+    except Exception:
+        pass  # stream publishing must never break goal dispatch
+
+    # Notify agents (via propagation)
+    try:
+        from ..context.propagation import get_propagator
+        for task in created:
+            get_propagator().propagate(
+                source_agent="dispatcher",
+                event_type="task_assigned",
+                content=f"New task: {task['title']} (priority: {task['priority']})",
+                namespace=graph_ns,
+                priority="high",
+                target_agent=task["assigned_to"],
+            )
+    except Exception:
+        pass
+
+    return {
+        "goal": goal,
+        "tasks": created,
+        "agents": [{"name": p["name"], "strengths": p.get("strengths", [])} for p in agent_profiles],
+        "session_id": session_id,
+    }