agent-webui 0.1.8__tar.gz

agent_webui-0.1.8/PKG-INFO

@@ -0,0 +1,57 @@
+Metadata-Version: 2.4
+Name: agent-webui
+Version: 0.1.8
+Summary: Agent Web Interface for Pydantic AI Agents
+Author-email: Audel Rouhi <knucklessg1@gmail.com>
+License: MIT
+Classifier: Development Status :: 4 - Beta
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Environment :: Console
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: bs4>=0.0.2
+Requires-Dist: fastapi>=0.117.1
+Requires-Dist: lancedb>=0.25.0
+Requires-Dist: langchain-text-splitters>=0.3.11
+Requires-Dist: logfire[fastapi,starlette]>=4.9.0
+Requires-Dist: markdown2>=2.5.4
+Requires-Dist: pip>=25.2
+Requires-Dist: pydantic-ai-slim[anthropic,cli,google,openai]>=1.14.0
+Requires-Dist: pyright>=1.1.405
+Requires-Dist: python-frontmatter>=1.1.0
+Requires-Dist: sentence-transformers>=5.1.1
+Requires-Dist: sse-starlette>=3.0.2
+Requires-Dist: starlette>=0.48.0
+Requires-Dist: uvicorn>=0.37.0
+Requires-Dist: watchfiles>=1.1.0
+
+# Agent WebUI
+
+_Version 0.1.8_
+
+A React-based chat interface for [Pydantic AI](https://ai.pydantic.dev/). This package powers the documentation assistant at [ai.pydantic.dev/web/](https://ai.pydantic.dev/web/).
+
+Built with [Vercel AI SDK](https://sdk.vercel.ai/) and designed to work with Pydantic AI's streaming chat API.
+
+## Features
+
+- Streaming message responses with reasoning display
+- Tool call visualization with collapsible input/output
+- Conversation persistence via localStorage
+- Dynamic model and tool selection
+- Dark/light theme support
+- Mobile-responsive sidebar
+
+## Development
+
+```sh
+pnpm install
+pnpm run dev:server  # start the Python backend (requires agent/ setup)
+pnpm run dev         # start the Vite dev server
+```
+
+## License
+
+MIT

agent_webui-0.1.8/README.md

@@ -0,0 +1,28 @@
+# Agent WebUI
+
+_Version 0.1.8_
+
+A React-based chat interface for [Pydantic AI](https://ai.pydantic.dev/). This package powers the documentation assistant at [ai.pydantic.dev/web/](https://ai.pydantic.dev/web/).
+
+Built with [Vercel AI SDK](https://sdk.vercel.ai/) and designed to work with Pydantic AI's streaming chat API.
+
+## Features
+
+- Streaming message responses with reasoning display
+- Tool call visualization with collapsible input/output
+- Conversation persistence via localStorage
+- Dynamic model and tool selection
+- Dark/light theme support
+- Mobile-responsive sidebar
+
+## Development
+
+```sh
+pnpm install
+pnpm run dev:server  # start the Python backend (requires agent/ setup)
+pnpm run dev         # start the Vite dev server
+```
+
+## License
+
+MIT

agent_webui-0.1.8/agent/agent_webui/agent.py

@@ -0,0 +1,57 @@
+from typing import Any, cast
+
+import pydantic_ai
+
+from agent_web.data import Repo, get_docs_dir, get_markdown, get_table_of_contents
+from agent_web.db import open_populated_table
+
+agent = pydantic_ai.Agent(
+    instructions="Help the user answer questions about two products ('repos'): Pydantic AI (pydantic-ai), an open source agent framework library, and Pydantic Logfire (logfire), an observability platform. Start by using the `search_docs` tool to search the relevant documentation and answer the question based on the search results. It uses a hybrid of semantic and keyword search, so writing either keywords or sentences may work. It's not searching google. Each search result starts with a path to a .md file. The file `foo/bar.md` corresponds to the URL `https://ai.pydantic.dev/foo/bar/` for Pydantic AI, `https://logfire.pydantic.dev/docs/foo/bar/` for Logfire. Include the URLs in your answer. The search results may not return complete files, or may not return the files you need. If they don't have what you need, you can use the `get_docs_file` tool. You probably only need to search once or twice, definitely not more than 3 times. The user doesn't see the search results, you need to actually return a summary of the info. To see the files that exist for the `get_docs_file` tool, along with a preview of the sections within, use the `get_table_of_contents` tool.",
+)
+
+agent.tool_plain(get_table_of_contents)
+
+
+@agent.tool_plain
+def get_docs_file(repo: Repo, filename: str):
+    """Get the full text of a documentation file by its filename, e.g. `foo/bar.md`."""
+    if not filename.endswith('.md'):
+        filename += '.md'
+    path = get_docs_dir(repo) / filename
+    if not path.exists():
+        return f'File {filename} does not exist'
+    return get_markdown(path)
+
+
+@agent.tool_plain
+def search_docs(repo: Repo, query: str):
+    results = cast(
+        list[dict[str, Any]],
+        open_populated_table(repo)
+        .search(  # type: ignore
+            query,
+            query_type='hybrid',
+            vector_column_name='vector',
+            fts_columns='text',
+        )
+        .limit(10)
+        .to_list(),
+    )
+    results = [
+        r
+        for r in results
+        if not any(
+            r != r2
+            and r['path'] == r2['path']
+            and r['headers'][: len(r2['headers'])] == r2['headers']
+            for r2 in results
+        )
+    ]
+
+    return '\n\n---------\n\n'.join(r['text'] for r in results)
+
+
+if __name__ == '__main__':
+    # print(agent.run_sync('how do i see errors').output)
+    # search_docs("logfire", "errors debugging view errors logs")
+    agent.to_cli_sync()

agent_webui-0.1.8/agent/agent_webui/api_extensions.py

@@ -0,0 +1,289 @@
+from __future__ import annotations
+
+import logging
+import re
+import shutil
+from pathlib import Path
+from typing import Any, Dict, List
+
+from fastapi import APIRouter, Request, UploadFile, File, HTTPException
+from fastapi.responses import FileResponse
+
+from agent_utilities.agent_utilities import get_agent_workspace
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(prefix='/api/enhanced')
+AGENT_WORKSPACE = get_agent_workspace()
+DEFAULT_AGENT_DIR = Path(__file__).parent / 'agent'
+
+# These will be provided by agent-utilities when the app is initialized
+workspace_helpers: Dict[str, Any] = {}
+
+
+def get_helper(name: str, fallback: Any = None):
+    helper = workspace_helpers.get(name)
+    if not helper:
+        logger.warning(
+            f"Helper '{name}' not found in workspace_helpers. Available: {list(workspace_helpers.keys())}"
+        )
+        return fallback
+    return helper
+
+
+def set_workspace_helpers(helpers: Dict[str, Any]):
+    global workspace_helpers
+    logger.info(f'Setting workspace helpers. Keys: {list(helpers.keys())}')
+    workspace_helpers = helpers
+
+
+@router.get('/info')
+async def get_info():
+    name = workspace_helpers.get('agent_name', 'Agent')
+    description = workspace_helpers.get('agent_description', 'AI Agent')
+    emoji = workspace_helpers.get('agent_emoji', '🤖')
+
+    user_emoji = '👤'
+    try:
+        content = workspace_helpers['load_workspace_file']('USER.md')
+        match = re.search(r'\* \*\*Emoji:\*\* (.*)', content)
+        if match:
+            user_emoji = match.group(1).strip()
+    except Exception:
+        pass
+
+    return {
+        'name': name,
+        'description': description,
+        'emoji': emoji,
+        'user_emoji': user_emoji,
+    }
+
+
+@router.get('/files')
+async def list_files():
+    load_files = get_helper('list_workspace_files')
+    if not load_files:
+        raise HTTPException(status_code=501, detail='File helpers not initialized')
+    return load_files()
+
+
+@router.get('/files/{filename}')
+async def get_file(filename: str):
+    # Check workspace first
+    load_file = get_helper('load_workspace_file')
+    content = load_file(filename) if load_file else ''
+
+    # Fallback to default template if content is empty and it's a core file
+    if not content and DEFAULT_AGENT_DIR.joinpath(filename).exists():
+        content = DEFAULT_AGENT_DIR.joinpath(filename).read_text(encoding='utf-8')
+
+    return {'content': content}
+
+
+@router.get('/config-files')
+async def list_config_files():
+    # Merge workspace files with default templates
+    list_files = get_helper('list_workspace_files')
+    workspace_files = set(list_files() if list_files else [])
+    default_files = set(f.name for f in DEFAULT_AGENT_DIR.glob('*.md') if f.is_file())
+
+    # We care about .md files and specifically mcp_config.json for configuration
+    all_files = sorted(list(workspace_files.union(default_files)))
+    config_files = [
+        f
+        for f in all_files
+        if (f.endswith('.md') and not f.endswith('_LOG.md')) or f == 'mcp_config.json'
+    ]
+
+    return config_files
+
+
+@router.put('/files/{filename}')
+async def update_file(filename: str, data: Dict[str, str]):
+    if not filename.endswith('.md') and not filename.endswith('.json'):
+        raise HTTPException(status_code=400, detail='Only .md and .json files allowed')
+    write_helper = get_helper(
+        'write_md_file'
+    )  # Using write_md_file for general writing for now
+    if not write_helper:
+        raise HTTPException(status_code=501, detail='Write helper not initialized')
+    write_helper(filename, data.get('content', ''))
+    return {'status': 'success'}
+
+
+@router.get('/skills')
+async def list_skills():
+    skills = workspace_helpers['list_skills']()
+    return sorted(skills, key=lambda x: x.get('name', '').lower())
+
+
+@router.post('/skills/{skill_id}/toggle')
+async def toggle_skill(skill_id: str):
+    return workspace_helpers['toggle_skill'](skill_id)
+
+
+@router.post('/reload')
+async def reload_agent(request: Request):
+    try:
+        workspace_helpers['initialize_workspace']()
+        # Find the reloadable app wrapper in the state
+        reloadable = getattr(request.app.state, 'reload_app', None)
+        if not reloadable:
+            raise HTTPException(
+                status_code=501, detail='Reloadable wrapper not found in app state'
+            )
+        reloadable.reload()
+        return {'status': 'success', 'message': 'Agent reloaded successfully'}
+    except Exception as e:
+        logger.error(f'Reload failed: {e}')
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+def parse_cron_table(content: str) -> List[Dict[str, Any]]:
+    tasks = []
+    lines = content.split('\n')
+    for line in lines:
+        if '|' in line and 'ID' not in line and '---' not in line:
+            parts = [p.strip() for p in line.split('|') if p.strip()]
+            if len(parts) >= 3:
+                tasks.append(
+                    {
+                        'id': parts[0],
+                        'name': parts[1],
+                        'schedule': parts[2],  # Interval in minutes or cron string
+                    }
+                )
+    return tasks
+
+
+def parse_cron_logs(content: str) -> List[Dict[str, Any]]:
+    logs = []
+    # Each entry starts with "### ["
+    parts = re.split(r'(?=^### \[)', content, flags=re.MULTILINE)
+
+    for part in parts:
+        if not part.strip() or not part.startswith('### ['):
+            continue
+
+        try:
+            # Format: ### [2026-03-07 05:32:11] Log Cleanup (`log-cleanup`)
+            header_match = re.search(r'^### \[(.*?)\] (.*?) \(`(.*?)`\)', part)
+            if header_match:
+                ts = header_match.group(1)
+                name = header_match.group(2)
+                tid = header_match.group(3)
+
+                # Output is after the header line, up to the separator "---"
+                body = part.split('\n\n', 1)[1] if '\n\n' in part else ''
+                output = body.split('\n---')[0].strip()
+
+                logs.append(
+                    {
+                        'timestamp': ts,
+                        'task_id': tid,
+                        'task_name': name,
+                        'status': 'success',  # Default for now
+                        'output': output,
+                    }
+                )
+        except Exception as e:
+            logger.debug(f'Error parsing log entry: {e}')
+
+    return logs[::-1]  # Newest first
+
+
+@router.get('/cron/calendar')
+async def get_cron_calendar():
+    get_cal = get_helper('get_cron_calendar')
+    tasks = get_cal() if get_cal else []
+    if not tasks:
+        # Try fallback to DEFAULT_AGENT_DIR/CRON.md
+        cron_path = DEFAULT_AGENT_DIR / 'CRON.md'
+        if cron_path.exists():
+            tasks = parse_cron_table(cron_path.read_text(encoding='utf-8'))
+    return tasks
+
+
+@router.get('/cron/logs')
+async def get_cron_logs():
+    get_logs = get_helper('get_cron_logs')
+    logs = get_logs() if get_logs else []
+
+    if not logs:
+        # Try fallback to DEFAULT_AGENT_DIR/CRON_LOG.md
+        log_path = DEFAULT_AGENT_DIR / 'CRON_LOG.md'
+        if log_path.exists():
+            logs = parse_cron_logs(log_path.read_text(encoding='utf-8'))
+    return logs
+
+
+@router.post('/upload')
+async def upload_file(file: UploadFile = File(...)):
+    get_workspace = get_helper('get_workspace_path')
+    if not get_workspace:
+        raise HTTPException(status_code=501, detail='Workspace helper not initialized')
+    workspace_dir = get_workspace('')
+    file_path = workspace_dir / file.filename
+    with open(file_path, 'wb') as buffer:
+        shutil.copyfileobj(file.file, buffer)
+    return {'filename': file.filename}
+
+
+@router.get('/agent-icon')
+async def get_agent_icon():
+    # Try to get custom icon from workspace first
+    get_path = workspace_helpers.get('get_workspace_path')
+    if get_path:
+        workspace_icon = get_path('icon.png')
+        if workspace_icon.exists():
+            return FileResponse(path=workspace_icon)
+
+    # Fallback to package icon
+    get_icon_p = workspace_helpers.get('get_agent_icon_path')
+    icon_path = get_icon_p() if get_icon_p else None
+    if not icon_path or not Path(icon_path).exists():
+        raise HTTPException(status_code=404, detail='Icon not found')
+    return FileResponse(path=icon_path)
+
+
+@router.get('/download/{filename}')
+async def download_file(filename: str):
+    get_workspace = get_helper('get_workspace_path')
+    if not get_workspace:
+        raise HTTPException(status_code=501, detail='Workspace helper not initialized')
+    workspace_dir = get_workspace('')
+    file_path = workspace_dir / filename
+    if not file_path.exists():
+        raise HTTPException(status_code=404, detail='File not found')
+    return FileResponse(path=file_path, filename=filename)
+
+
+@router.get('/chats')
+async def list_chats():
+    h = get_helper('list_chats')
+    return h() if h else []
+
+
+@router.get('/chats/{chat_id}')
+async def get_chat(chat_id: str):
+    h = get_helper('get_chat')
+    return h(chat_id) if h else None
+
+
+@router.post('/chats')
+async def save_chat(data: Dict[str, Any]):
+    h = get_helper('save_chat')
+    return h(data) if h else {'status': 'error'}
+
+
+@router.put('/chats/{chat_id}/title')
+async def update_chat_title(chat_id: str, data: Dict[str, Any]):
+    h = get_helper('update_chat_title')
+    return h(chat_id, data) if h else {'status': 'error'}
+
+
+@router.delete('/chats/{chat_id}')
+async def delete_chat(chat_id: str):
+    h = get_helper('delete_chat')
+    return h(chat_id) if h else {'status': 'error'}

agent_webui-0.1.8/agent/agent_webui/data.py

@@ -0,0 +1,103 @@
+import re
+from collections import Counter
+from pathlib import Path
+from typing import Any, Literal
+
+import frontmatter
+import markdown2
+from bs4 import BeautifulSoup
+from langchain_text_splitters import MarkdownHeaderTextSplitter
+
+Repo = Literal['pydantic-ai', 'logfire']
+repos: tuple[Repo, ...] = 'pydantic-ai', 'logfire'
+
+
+def get_docs_dir(repo: Repo) -> Path:
+    result = Path(__file__).parent.parent.parent.parent / repo / 'docs'
+    if not result.exists():
+        raise ValueError(f'This repo should live next to the {repo} repo')
+    return result
+
+
+IGNORED_FILES = 'release-notes.md', 'help.md', '/api/', '/legal/'
+
+
+def get_docs_files(repo: Repo) -> list[Path]:
+    return [
+        file
+        for file in get_docs_dir(repo).rglob('*.md')
+        if not any(ignored in str(file) for ignored in IGNORED_FILES)
+    ]
+
+
+def get_markdown(path: Path) -> str:
+    markdown_string = path.read_text()
+    markdown_string = frontmatter.loads(markdown_string).content
+    return markdown_string
+
+
+def get_table_of_contents(repo: Repo):
+    """Get a list of all docs files and a preview of the sections within."""
+    result = ''
+    for file in get_docs_files(repo):
+        markdown_string = get_markdown(file)
+        markdown_string = re.sub(
+            r'^```\w+ [^\n]+$', '```', markdown_string, flags=re.MULTILINE
+        )
+        html_output = markdown2.markdown(markdown_string, extras=['fenced-code-blocks'])  # type: ignore
+        soup = BeautifulSoup(html_output, 'html.parser')
+        headers = soup.find_all(['h1', 'h2', 'h3', 'h4'])
+        result += f'{file.relative_to(get_docs_dir(repo))}\n'
+        result += '\n'.join(
+            '#' * int(header.name[1]) + ' ' + header.get_text()  # type: ignore
+            for header in headers
+        )
+        result += '\n\n'
+    return result
+
+
+headers_to_split_on = [('#' * n, f'H{n}') for n in range(1, 7)]
+
+
+def get_docs_rows(repo: Repo) -> list[dict[str, Any]]:
+    data: list[dict[str, Any]] = []
+    for file in get_docs_files(repo):
+        markdown_document = get_markdown(file)
+        rel_path = str(file.relative_to(get_docs_dir(repo)))
+
+        unique: set[tuple[tuple[str, ...], str]] = set()
+        for num_headers in range(len(headers_to_split_on)):
+            splitter = MarkdownHeaderTextSplitter(headers_to_split_on[:num_headers])
+            splits = splitter.split_text(markdown_document)
+            for split in splits:
+                metadata: dict[str, Any] = split.metadata  # type: ignore
+                headers = [
+                    f'{prefix} {metadata[header_type]}'
+                    for prefix, header_type in headers_to_split_on
+                    if header_type in metadata
+                ]
+                content = '\n\n'.join([rel_path, *headers, split.page_content])
+                if len(content.encode()) > 16384:
+                    continue
+                unique.add((tuple(headers), content))
+
+        counts = Counter[tuple[str, ...]]()
+        for headers, content in sorted(unique):
+            counts[headers] += 1
+            count = str(counts[headers])
+            data.append(
+                dict(
+                    path=rel_path,
+                    headers=headers,
+                    text=content,
+                    count=count,
+                )
+            )
+
+    return data
+
+
+if __name__ == '__main__':
+    print(get_table_of_contents('logfire'))
+    rows = get_docs_rows('logfire')
+    print(f'Generated {len(rows)} rows')

agent_webui-0.1.8/agent/agent_webui/db.py

@@ -0,0 +1,42 @@
+import lancedb
+from lancedb.embeddings import get_registry
+from lancedb.pydantic import LanceModel, Vector  # type: ignore
+
+from chatbot.data import get_docs_rows, Repo
+
+db = lancedb.connect('/tmp/lancedb-pydantic-ai-chat')
+
+
+def create_table(repo: Repo):
+    embeddings = get_registry().get('sentence-transformers').create()  # type: ignore
+
+    class Documents(LanceModel):
+        path: str
+        headers: list[str]
+        count: int
+        text: str = embeddings.SourceField()  # type: ignore
+        vector: Vector(embeddings.ndims()) = embeddings.VectorField()  # type: ignore
+
+    table = db.create_table(repo, schema=Documents, mode='overwrite')  # type: ignore
+    table.create_fts_index('text')
+    return table
+
+
+def open_table(repo: Repo):
+    try:
+        return db.open_table(repo)
+    except ValueError:
+        return create_table(repo)
+
+
+def populate_table(repo: Repo):
+    table = open_table(repo)
+    rows = get_docs_rows(repo)
+    table.add(data=rows)  # type: ignore
+
+
+def open_populated_table(repo: Repo):
+    table = open_table(repo)
+    if table.count_rows() == 0:
+        populate_table(repo)
+    return table

agent_webui-0.1.8/agent/agent_webui/icon.png

@@ -0,0 +1,3 @@
+# icon.png
+
+(empty)

agent_webui-0.1.8/agent/agent_webui/server.py

@@ -0,0 +1,133 @@
+from __future__ import annotations as _annotations
+import os
+from pathlib import Path
+from typing import Any, Dict
+
+import logfire
+from fastapi import FastAPI
+from fastapi.staticfiles import StaticFiles
+from pydantic_ai import Agent
+
+from .api_extensions import router as enhanced_router, set_workspace_helpers
+
+# Configure logfire
+logfire.configure(send_to_logfire='if-token-present')
+logfire.instrument_pydantic_ai()
+
+__version__ = "0.1.8"
+
+def create_agent_web_app(
+    agent: Agent,
+    workspace_helpers: Dict[str, Any],
+    models: Dict[str, str] | None = None,
+    builtin_tools: list[Any] | None = None,
+    html_source: str | Path | None = None,
+) -> FastAPI:
+    """
+    Creates the agent-web FastAPI application, integrating Pydantic-AI's
+    built-in web UI with enhanced features for workspace management.
+    """
+    # Set helpers for the enhanced API
+    set_workspace_helpers(workspace_helpers)
+
+    # Filter models based on available API keys
+    default_models = {}
+    if os.getenv('ANTHROPIC_API_KEY'):
+        default_models['Claude Sonnet 3.5'] = 'anthropic:claude-3-5-sonnet-latest'
+    if os.getenv('OPENAI_API_KEY'):
+        default_models['GPT 4o'] = 'openai:gpt-4o'
+    if os.getenv('GOOGLE_API_KEY'):
+        default_models['Gemini 2.0 Pro'] = 'google-gla:gemini-2.0-pro'
+
+    # Check for Ollama / Local models
+    # We'll include Qwen 3 Coder if Ollama is configured
+    if os.getenv('OLLAMA_BASE_URL') or os.getenv('OLLAMA_HOST'):
+        default_models['Qwen 3 Coder'] = 'ollama:qwen3-coder'
+
+    if not default_models:
+        default_models['Test Model (Markdown Only)'] = 'test'
+
+    # Create the main FastAPI app
+    app = FastAPI(title='Agent Web Dashboard')
+
+    # Include the enhanced API routes
+    app.include_router(enhanced_router)
+
+    # Use Pydantic-AI's to_web to get their Starlette app
+    pydantic_app = agent.to_web(
+        models=models or default_models,
+        builtin_tools=builtin_tools,
+        html_source=html_source,
+    )
+
+    # Merge pydantic-ai routes into our main app
+    for route in pydantic_app.routes:
+        if hasattr(route, 'path'):
+            # Core API routes
+            if (
+                route.path.startswith('/chat')
+                or route.path.startswith('/configure')
+                or route.path.startswith('/api')
+            ):
+                app.routes.append(route)
+            # If html_source is provided, we also want Pydantic AI's UI routes (/ and /{id})
+            elif html_source and (route.path == '/' or route.path == '/{id}'):
+                app.routes.append(route)
+
+    dist_path = Path(__file__).parent / 'dist'
+
+    # Custom StaticFiles to handle SPA routing (fallback to index.html)
+    class SPAStaticFiles(StaticFiles):
+        async def get_response(self, path: str, scope):
+            try:
+                return await super().get_response(path, scope)
+            except _errors.HTTPException as ex:
+                if (
+                    ex.status_code == 404
+                    and not any(
+                        path.startswith(p) for p in ['api', 'chat', 'configure']
+                    )
+                    and '.' not in path
+                ):
+                    return await super().get_response('index.html', scope)
+                raise ex
+
+    from starlette import exceptions as _errors
+
+    # Mount our built React app (only if no custom html_source is provided)
+    if not html_source:
+        if dist_path.exists():
+            app.mount(
+                '/',
+                SPAStaticFiles(directory=str(dist_path), html=True),
+                name='dashboard',
+            )
+        else:
+            print(
+                f'Warning: Static assets not found at {dist_path}. Dashboard UI will not be served.'
+            )
+
+    logfire.instrument_starlette(app)
+    return app
+
+
+# For standalone testing
+if __name__ == '__main__':
+    from .agent import agent as test_agent
+
+    dummy_helpers = {
+        'agent_name': 'Test Agent',
+        'agent_description': 'A standalone test agent',
+        'agent_emoji': '🧪',
+        'get_workspace_path': lambda x: Path('/tmp') / x,
+        'load_workspace_file': lambda x: f'Content of {x}',
+        'write_md_file': lambda x, y: print(f'Writing {y} to {x}'),
+        'list_workspace_files': lambda: ['IDENTITY.md', 'USER.md'],
+        'list_skills': lambda: [],
+        'get_cron_calendar': lambda: [],
+        'get_agent_icon_path': lambda: None,
+    }
+    app = create_agent_web_app(test_agent, dummy_helpers)
+    import uvicorn
+
+    uvicorn.run(app, host='0.0.0.0', port=8000)

agent_webui-0.1.8/agent/agent_webui.egg-info/PKG-INFO

@@ -0,0 +1,57 @@
+Metadata-Version: 2.4
+Name: agent-webui
+Version: 0.1.8
+Summary: Agent Web Interface for Pydantic AI Agents
+Author-email: Audel Rouhi <knucklessg1@gmail.com>
+License: MIT
+Classifier: Development Status :: 4 - Beta
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Environment :: Console
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: bs4>=0.0.2
+Requires-Dist: fastapi>=0.117.1
+Requires-Dist: lancedb>=0.25.0
+Requires-Dist: langchain-text-splitters>=0.3.11
+Requires-Dist: logfire[fastapi,starlette]>=4.9.0
+Requires-Dist: markdown2>=2.5.4
+Requires-Dist: pip>=25.2
+Requires-Dist: pydantic-ai-slim[anthropic,cli,google,openai]>=1.14.0
+Requires-Dist: pyright>=1.1.405
+Requires-Dist: python-frontmatter>=1.1.0
+Requires-Dist: sentence-transformers>=5.1.1
+Requires-Dist: sse-starlette>=3.0.2
+Requires-Dist: starlette>=0.48.0
+Requires-Dist: uvicorn>=0.37.0
+Requires-Dist: watchfiles>=1.1.0
+
+# Agent WebUI
+
+_Version 0.1.8_
+
+A React-based chat interface for [Pydantic AI](https://ai.pydantic.dev/). This package powers the documentation assistant at [ai.pydantic.dev/web/](https://ai.pydantic.dev/web/).
+
+Built with [Vercel AI SDK](https://sdk.vercel.ai/) and designed to work with Pydantic AI's streaming chat API.
+
+## Features
+
+- Streaming message responses with reasoning display
+- Tool call visualization with collapsible input/output
+- Conversation persistence via localStorage
+- Dynamic model and tool selection
+- Dark/light theme support
+- Mobile-responsive sidebar
+
+## Development
+
+```sh
+pnpm install
+pnpm run dev:server  # start the Python backend (requires agent/ setup)
+pnpm run dev         # start the Vite dev server
+```
+
+## License
+
+MIT

agent_webui-0.1.8/agent/agent_webui.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+README.md
+pyproject.toml
+agent/agent_webui/__init__.py
+agent/agent_webui/agent.py
+agent/agent_webui/api_extensions.py
+agent/agent_webui/data.py
+agent/agent_webui/db.py
+agent/agent_webui/icon.png
+agent/agent_webui/server.py
+agent/agent_webui.egg-info/PKG-INFO
+agent/agent_webui.egg-info/SOURCES.txt
+agent/agent_webui.egg-info/dependency_links.txt
+agent/agent_webui.egg-info/requires.txt
+agent/agent_webui.egg-info/top_level.txt

agent_webui-0.1.8/agent/agent_webui.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

agent_webui-0.1.8/agent/agent_webui.egg-info/requires.txt

@@ -0,0 +1,15 @@
+bs4>=0.0.2
+fastapi>=0.117.1
+lancedb>=0.25.0
+langchain-text-splitters>=0.3.11
+logfire[fastapi,starlette]>=4.9.0
+markdown2>=2.5.4
+pip>=25.2
+pydantic-ai-slim[anthropic,cli,google,openai]>=1.14.0
+pyright>=1.1.405
+python-frontmatter>=1.1.0
+sentence-transformers>=5.1.1
+sse-starlette>=3.0.2
+starlette>=0.48.0
+uvicorn>=0.37.0
+watchfiles>=1.1.0

agent_webui-0.1.8/agent/agent_webui.egg-info/top_level.txt

@@ -0,0 +1 @@
+agent_webui

agent_webui-0.1.8/pyproject.toml

@@ -0,0 +1,53 @@
+[build-system]
+requires = ["setuptools>=80.9.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "agent-webui"
+version = "0.1.8"
+description = "Agent Web Interface for Pydantic AI Agents"
+readme = "README.md"
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "License :: OSI Approved :: MIT License",
+    "Environment :: Console",
+    "Operating System :: POSIX :: Linux",
+    "Programming Language :: Python :: 3"]
+requires-python = ">=3.10"
+dependencies = [
+    "bs4>=0.0.2",
+    "fastapi>=0.117.1",
+    "lancedb>=0.25.0",
+    "langchain-text-splitters>=0.3.11",
+    "logfire[fastapi,starlette]>=4.9.0",
+    "markdown2>=2.5.4",
+    "pip>=25.2",
+    "pydantic-ai-slim[anthropic,cli,google,openai]>=1.14.0",
+    "pyright>=1.1.405",
+    "python-frontmatter>=1.1.0",
+    "sentence-transformers>=5.1.1",
+    "sse-starlette>=3.0.2",
+    "starlette>=0.48.0",
+    "uvicorn>=0.37.0",
+    "watchfiles>=1.1.0",
+]
+
+[[project.authors]]
+name = "Audel Rouhi"
+email = "knucklessg1@gmail.com"
+
+[project.license]
+text = "MIT"
+
+[tool.ruff.format]
+docstring-code-format = false
+quote-style = "single"
+
+[tool.setuptools]
+include-package-data = true
+
+[tool.setuptools.package-data]
+agent_webui = ["dist/**", "icon.png"]
+
+[tool.setuptools.packages.find]
+where = ["agent"]

agent_webui-0.1.8/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+