agentweave-hub 0.34.1__tar.gz

agentweave_hub-0.34.1/PKG-INFO

@@ -0,0 +1,20 @@
+Metadata-Version: 2.4
+Name: agentweave-hub
+Version: 0.34.1
+Summary: AgentWeave Hub — self-hosted FastAPI server for multi-agent collaboration
+Requires-Python: >=3.11
+Requires-Dist: fastapi>=0.110
+Requires-Dist: uvicorn[standard]>=0.27
+Requires-Dist: sqlalchemy[asyncio]>=2.0
+Requires-Dist: aiosqlite>=0.20
+Requires-Dist: pydantic>=2.0
+Requires-Dist: pydantic-settings>=2.0
+Requires-Dist: alembic>=1.13
+Requires-Dist: fastmcp>=2.0
+Requires-Dist: sse-starlette>=2.0
+Requires-Dist: croniter>=2.0
+Requires-Dist: apscheduler>=3.10
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23; extra == "dev"
+Requires-Dist: httpx>=0.27; extra == "dev"

agentweave_hub-0.34.1/agentweave_hub.egg-info/PKG-INFO

@@ -0,0 +1,20 @@
+Metadata-Version: 2.4
+Name: agentweave-hub
+Version: 0.34.1
+Summary: AgentWeave Hub — self-hosted FastAPI server for multi-agent collaboration
+Requires-Python: >=3.11
+Requires-Dist: fastapi>=0.110
+Requires-Dist: uvicorn[standard]>=0.27
+Requires-Dist: sqlalchemy[asyncio]>=2.0
+Requires-Dist: aiosqlite>=0.20
+Requires-Dist: pydantic>=2.0
+Requires-Dist: pydantic-settings>=2.0
+Requires-Dist: alembic>=1.13
+Requires-Dist: fastmcp>=2.0
+Requires-Dist: sse-starlette>=2.0
+Requires-Dist: croniter>=2.0
+Requires-Dist: apscheduler>=3.10
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23; extra == "dev"
+Requires-Dist: httpx>=0.27; extra == "dev"

agentweave_hub-0.34.1/agentweave_hub.egg-info/SOURCES.txt

@@ -0,0 +1,86 @@
+pyproject.toml
+agentweave_hub.egg-info/PKG-INFO
+agentweave_hub.egg-info/SOURCES.txt
+agentweave_hub.egg-info/dependency_links.txt
+agentweave_hub.egg-info/entry_points.txt
+agentweave_hub.egg-info/requires.txt
+agentweave_hub.egg-info/top_level.txt
+hub/__init__.py
+hub/auth.py
+hub/config.py
+hub/main.py
+hub/mcp_server.py
+hub/scheduler.py
+hub/sse.py
+hub/utils.py
+hub/api/__init__.py
+hub/api/v1/__init__.py
+hub/api/v1/agent_chat.py
+hub/api/v1/agent_trigger.py
+hub/api/v1/agents.py
+hub/api/v1/events.py
+hub/api/v1/instructions.py
+hub/api/v1/jobs.py
+hub/api/v1/logs.py
+hub/api/v1/messages.py
+hub/api/v1/questions.py
+hub/api/v1/session_sync.py
+hub/api/v1/setup.py
+hub/api/v1/status.py
+hub/api/v1/tasks.py
+hub/data/roles/architect.md
+hub/data/roles/backend_dev.md
+hub/data/roles/code_reviewer.md
+hub/data/roles/data_engineer.md
+hub/data/roles/devops_engineer.md
+hub/data/roles/frontend_dev.md
+hub/data/roles/fullstack_dev.md
+hub/data/roles/ml_engineer.md
+hub/data/roles/project_manager.md
+hub/data/roles/qa_engineer.md
+hub/data/roles/roles.json
+hub/data/roles/security_engineer.md
+hub/data/roles/tech_lead.md
+hub/data/roles/technical_writer.md
+hub/db/__init__.py
+hub/db/engine.py
+hub/db/models.py
+hub/migrations/__init__.py
+hub/migrations/env.py
+hub/migrations/versions/0001_add_agent_outputs.py
+hub/migrations/versions/0002_add_event_severity.py
+hub/migrations/versions/0003_add_message_session_id.py
+hub/migrations/versions/0004_add_agent_table.py
+hub/migrations/versions/0005_add_agent_self_registration_columns.py
+hub/migrations/versions/0006_add_agent_config_column.py
+hub/migrations/versions/0007_add_job_run_error_summary.py
+hub/migrations/versions/0008_cap_job_run_error_summary.py
+hub/schemas/__init__.py
+hub/schemas/agents.py
+hub/schemas/common.py
+hub/schemas/jobs.py
+hub/schemas/logs.py
+hub/schemas/messages.py
+hub/schemas/questions.py
+hub/schemas/tasks.py
+hub/static/ui/index.html
+hub/static/ui/assets/index-B1rDiHmG.js
+hub/static/ui/assets/index-C8QibtKd.css
+tests/test_agent_chat.py
+tests/test_agents.py
+tests/test_agents_self_registered.py
+tests/test_auth.py
+tests/test_bola.py
+tests/test_instructions.py
+tests/test_jobs.py
+tests/test_jobs_crud.py
+tests/test_mcp_server.py
+tests/test_messages.py
+tests/test_migrations.py
+tests/test_pilot_mode.py
+tests/test_questions.py
+tests/test_runtime_diagnostics.py
+tests/test_setup.py
+tests/test_sse.py
+tests/test_status.py
+tests/test_tasks.py

agentweave_hub-0.34.1/agentweave_hub.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

agentweave_hub-0.34.1/agentweave_hub.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+agentweave-hub = hub.main:run

agentweave_hub-0.34.1/agentweave_hub.egg-info/requires.txt

@@ -0,0 +1,16 @@
+fastapi>=0.110
+uvicorn[standard]>=0.27
+sqlalchemy[asyncio]>=2.0
+aiosqlite>=0.20
+pydantic>=2.0
+pydantic-settings>=2.0
+alembic>=1.13
+fastmcp>=2.0
+sse-starlette>=2.0
+croniter>=2.0
+apscheduler>=3.10
+
+[dev]
+pytest>=8
+pytest-asyncio>=0.23
+httpx>=0.27

agentweave_hub-0.34.1/agentweave_hub.egg-info/top_level.txt

@@ -0,0 +1 @@
+hub

agentweave_hub-0.34.1/hub/__init__.py

@@ -0,0 +1,3 @@
+"""AgentWeave Hub — FastAPI server package."""
+
+__version__ = "0.1.0"

agentweave_hub-0.34.1/hub/api/__init__.py

@@ -0,0 +1 @@
+"""API package."""

agentweave_hub-0.34.1/hub/api/v1/__init__.py

@@ -0,0 +1,32 @@
+"""Compose all v1 routers."""
+
+from fastapi import APIRouter
+
+from .messages import router as messages_router
+from .tasks import router as tasks_router
+from .questions import router as questions_router
+from .status import router as status_router
+from .events import router as events_router
+from .logs import router as logs_router
+from .agents import router as agents_router
+from .agent_trigger import router as agent_trigger_router
+from .agent_chat import router as agent_chat_router
+from .session_sync import router as session_sync_router
+from .jobs import router as jobs_router
+from .setup import router as setup_router
+from .instructions import router as instructions_router
+
+v1_router = APIRouter(prefix="/api/v1")
+v1_router.include_router(messages_router)
+v1_router.include_router(tasks_router)
+v1_router.include_router(questions_router)
+v1_router.include_router(status_router)
+v1_router.include_router(events_router)
+v1_router.include_router(logs_router)
+v1_router.include_router(agents_router)
+v1_router.include_router(agent_trigger_router)
+v1_router.include_router(agent_chat_router)
+v1_router.include_router(session_sync_router)
+v1_router.include_router(jobs_router)
+v1_router.include_router(setup_router)
+v1_router.include_router(instructions_router)

agentweave_hub-0.34.1/hub/api/v1/agent_chat.py

@@ -0,0 +1,234 @@
+"""Agent chat endpoints — GET /api/v1/agent/{agent}/chat/{session_id}"""
+
+from datetime import datetime, timedelta, timezone
+from typing import List, Optional, Tuple
+
+from fastapi import APIRouter, Depends, HTTPException, Query, status
+from pydantic import BaseModel
+from sqlalchemy import func, select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from ...auth import get_project
+from ...db.engine import get_session
+from ...db.models import AgentOutput, Message
+
+router = APIRouter(prefix="/agent", tags=["agent-chat"])
+
+
+class ChatMessage(BaseModel):
+    id: str
+    role: str  # 'user' or 'agent'
+    content: str
+    timestamp: datetime
+
+
+class ChatHistoryResponse(BaseModel):
+    session_id: str
+    agent: str
+    messages: List[ChatMessage]
+
+
+@router.get("/{agent}/chat/{session_id}", response_model=ChatHistoryResponse)
+async def get_chat_history(
+    agent: str,
+    session_id: str,
+    project: Tuple[str, str] = Depends(get_project),
+    session: AsyncSession = Depends(get_session),
+):
+    """Get conversation history for a specific agent session.
+
+    Returns messages between user and agent for the given session,
+    including both direct messages and agent output.
+    """
+    project_id, _ = project
+
+    # Get agent outputs for this session
+    output_q = (
+        select(AgentOutput)
+        .where(
+            AgentOutput.project_id == project_id,
+            AgentOutput.agent == agent,
+            AgentOutput.session_id == session_id,
+        )
+        .order_by(AgentOutput.timestamp.asc())
+    )
+    output_result = await session.execute(output_q)
+    session_outputs = output_result.scalars().all()
+
+    # Build time window for this session (used for untagged messages)
+    session_first_ts = min((o.timestamp for o in session_outputs), default=None)
+    session_last_ts = max((o.timestamp for o in session_outputs), default=None)
+
+    # Get all user messages to this agent
+    msg_q = (
+        select(Message)
+        .where(
+            Message.project_id == project_id,
+            Message.recipient == agent,
+            Message.sender == "user",
+        )
+        .order_by(Message.timestamp.asc())
+    )
+    msg_result = await session.execute(msg_q)
+    user_messages = msg_result.scalars().all()
+
+    # Get first-output timestamps for all OTHER sessions (used for Tier 3 attribution)
+    other_starts_q = (
+        select(func.min(AgentOutput.timestamp))
+        .where(
+            AgentOutput.project_id == project_id,
+            AgentOutput.agent == agent,
+            AgentOutput.session_id.isnot(None),
+            AgentOutput.session_id != session_id,
+        )
+        .group_by(AgentOutput.session_id)
+    )
+    other_starts_result = await session.execute(other_starts_q)
+    other_first_timestamps = [row[0] for row in other_starts_result.all() if row[0] is not None]
+
+    messages: List[ChatMessage] = []
+
+    for msg in user_messages:
+        content = msg.content or ""
+
+        # 1. Exact match by session_id column (post-migration resume messages)
+        if msg.session_id == session_id:
+            messages.append(
+                ChatMessage(
+                    id=msg.id,
+                    role="user",
+                    content=(
+                        content.split("\n\n[Session:")[0] if "[Session:" in content else content
+                    ),
+                    timestamp=msg.timestamp,
+                )
+            )
+            continue
+
+        # 2. Fallback: content tag match (pre-migration resume messages)
+        if f"[Session: {session_id}]" in content:
+            messages.append(
+                ChatMessage(
+                    id=msg.id,
+                    role="user",
+                    content=(
+                        content.split("\n\n[Session:")[0] if "[Session:" in content else content
+                    ),
+                    timestamp=msg.timestamp,
+                )
+            )
+            continue
+
+        # 3. Untagged messages (new-session messages with session_id=None).
+        #    Only include if they fall within this session's time window AND no other
+        #    session started closer to the message (nearest-session wins, prevents
+        #    messages from previous new-sessions bleeding into the current one).
+        if msg.session_id is None and "[Session:" not in content:
+            if session_first_ts is not None and session_last_ts is not None:
+                in_window = (
+                    session_first_ts - timedelta(minutes=5) <= msg.timestamp <= session_last_ts
+                )
+                # Exclude if another session started between this message and the current session
+                closer_session_exists = any(
+                    msg.timestamp <= other_ts < session_first_ts
+                    for other_ts in other_first_timestamps
+                )
+                if in_window and not closer_session_exists:
+                    messages.append(
+                        ChatMessage(
+                            id=msg.id,
+                            role="user",
+                            content=content,
+                            timestamp=msg.timestamp,
+                        )
+                    )
+
+    # Add agent outputs for this session
+    for output in session_outputs:
+        messages.append(
+            ChatMessage(
+                id=output.id,
+                role="agent",
+                content=output.content,
+                timestamp=output.timestamp,
+            )
+        )
+
+    # Sort by timestamp
+    messages.sort(key=lambda m: m.timestamp)
+
+    return ChatHistoryResponse(
+        session_id=session_id,
+        agent=agent,
+        messages=messages,
+    )
+
+
+@router.get("/{agent}/chat", response_model=List[ChatMessage])
+async def get_recent_chat(
+    agent: str,
+    limit: int = Query(50, ge=1, le=500),
+    project: Tuple[str, str] = Depends(get_project),
+    session: AsyncSession = Depends(get_session),
+):
+    """Get recent chat messages with an agent across all sessions.
+
+    Returns the most recent messages between user and agent,
+    useful for a general chat view without session filtering.
+    """
+    project_id, _ = project
+
+    # Get recent messages from user to agent
+    msg_q = (
+        select(Message)
+        .where(
+            Message.project_id == project_id,
+            Message.recipient == agent,
+            Message.sender == "user",
+        )
+        .order_by(Message.timestamp.desc())
+        .limit(limit)
+    )
+    msg_result = await session.execute(msg_q)
+    user_messages = msg_result.scalars().all()
+
+    # Get recent agent outputs
+    output_q = (
+        select(AgentOutput)
+        .where(
+            AgentOutput.project_id == project_id,
+            AgentOutput.agent == agent,
+        )
+        .order_by(AgentOutput.timestamp.desc())
+        .limit(limit)
+    )
+    output_result = await session.execute(output_q)
+    agent_outputs = output_result.scalars().all()
+
+    # Build chat messages
+    messages: List[ChatMessage] = []
+
+    for msg in user_messages:
+        content = msg.content or ""
+        messages.append(
+            ChatMessage(
+                id=msg.id,
+                role="user",
+                content=content.split("\n\n[Session:")[0] if "[Session:" in content else content,
+                timestamp=msg.timestamp,
+            )
+        )
+
+    for output in agent_outputs:
+        messages.append(
+            ChatMessage(
+                id=output.id,
+                role="agent",
+                content=output.content,
+                timestamp=output.timestamp,
+            )
+        )
+
+    # Sort by timestamp and limit
+    messages.sort(key=lambda m: m.timestamp)
+    return messages[-limit:]