x64acp 0.1.0__tar.gz

x64acp-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,21 @@
+name: Publish to PyPI
+
+on:
+  release:
+    types: [published]
+
+permissions:
+  id-token: write
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    environment: pypi
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+      - run: pip install build
+      - run: python -m build
+      - uses: pypa/gh-action-pypi-publish@release/v1

x64acp-0.1.0/.gitignore

@@ -0,0 +1,9 @@
+.venv
+venv
+__pycache__
+.claude
+.ruff_cache
+.pytest_cache
+.mypy_cache
+/docs/plans
+dist

x64acp-0.1.0/CLAUDE.md

@@ -0,0 +1,72 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+x64acp is a Python SDK for building AI assistant servers. It provides WebSocket-based real-time communication, persistence (PostgreSQL/Cosmos DB), analytics, settings management, A2A (Agent-to-Agent) protocol support, and MCP client integration.
+
+## Commands
+
+```bash
+uv sync --all-extras        # Install all dependencies
+uv run poe test              # Run tests
+uv run poe test:cov          # Tests with coverage
+uv run poe check             # Lint (ruff)
+uv run poe check:fix         # Auto-fix lint issues
+uv run poe format            # Format code
+uv run poe format:imports    # Sort imports
+uv run poe typecheck         # Type check with mypy
+uv run poe pcu               # Check package updates
+uv run poe pcu:upgrade       # Upgrade packages
+```
+
+Run a single test: `uv run pytest tests/path/to/test.py::test_name -v`
+
+## Architecture
+
+### Core Flow
+
+`AssistantServer` is the entry point. It has two modes of operation:
+
+1. **WebSocket mode** (`server.handle(websocket, handler)`) — Long-lived connection. The `Router` parses incoming frames (`ClientToServer`) and dispatches them. When a user sends a message (`C2S_EventCreate`), the `AssistantHandlerPipeline` orchestrates thread/event/run creation, invokes the user-provided `AssistantHandler`, persists results, and broadcasts `ServerToClient` frames back.
+
+2. **Dispatch mode** (`server.dispatch(handler, ...)`) — Programmatic invocation without WebSocket. Returns a `DispatchStream` (async iterable of `AssistantEvent`) with `thread_id`, `event_id`, and `is_new_thread` available immediately before iteration.
+
+### Assistant Handler Contract
+
+AssistantHandlers are async generators with signature:
+```python
+async def handler(incoming, send, memory, analytics, settings) -> AsyncGenerator[AssistantEvent, None]:
+    yield send.text("response")
+```
+
+The five injected parameters (`AssistantIncoming`, `AssistantSend`, `AssistantMemory`, `AssistantAnalytics`, `AssistantSettings`) are constructed by `AssistantHandlerPipeline` per request.
+
+### Protocol Layer (`protocol/`)
+
+- `frames.py` — Pydantic models for all WebSocket frame types (C2S_* and S2C_*), discriminated by `type` field
+- `models.py` — Domain models: `Thread`, `ThreadEvent`, `Run`, content parts (internal vs wire C2S/S2C variants)
+- `parser.py` — JSON frame parsing/serialization using Pydantic `TypeAdapter`
+
+### Persistence (`persistence/`)
+
+`Persistence` is a Protocol (structural typing) with two implementations: `PostgresPersistence` (asyncpg + SQLAlchemy) and `CosmosPersistence`. Both handle threads, events, runs, settings, and analytics storage. Cosmos is lazily imported only when `database_type="cosmos"`.
+
+### Subsystems
+
+- **`broadcast.py`** — `BroadcastManager` pushes events/thread updates to subscribed WebSocket connections via `ConnectionRegistry`
+- **`registry.py`** — `ConnectionRegistry` maps WebSocket connections to assistant instance IDs
+- **`analytics/`** — `AnalyticsCollector` batches events and flushes to persistence + optional webhook; `AssistantAnalytics` is the handler-facing API
+- **`settings/`** — Schema-driven settings with `SettingsBroadcaster` for real-time sync to subscribed clients
+- **`a2a/`** — Agent-to-Agent protocol: `A2AServer` (FastAPI router for JSON-RPC) and `A2AClient`
+- **`mcp/`** — `MCPClient` connects to MCP-compliant tool servers over Streamable HTTP
+- **`handlers/knowledge.py`** — `AssistantKnowledge` for knowledge source selection by clients
+
+## Code Style
+
+- Python 3.11+, ruff for linting/formatting, line length 120
+- Quote style: double quotes
+- Ruff rules: E, F, I (isort), UP (pyupgrade)
+- `pytest-asyncio` with `asyncio_mode = "auto"` (no need for `@pytest.mark.asyncio`)
+- Pydantic v2 for all models; dataclasses for config objects

x64acp-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 0x0064 (github.com/0x0064)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

x64acp-0.1.0/PKG-INFO

@@ -0,0 +1,206 @@
+Metadata-Version: 2.4
+Name: x64acp
+Version: 0.1.0
+Summary: Agent Communication Protocol (ACP) Python SDK
+Project-URL: Repository, https://github.com/0x0064/x64acp-server
+Author-email: 0x0064 <user.frndvrgs@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: >=3.11
+Requires-Dist: aiosqlite>=0.22.1
+Requires-Dist: asyncpg>=0.31.0
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: pydantic>=2.12.5
+Requires-Dist: sqlalchemy>=2.0.48
+Provides-Extra: dev
+Requires-Dist: mypy>=1.19.1; extra == 'dev'
+Requires-Dist: poethepoet>=0.42.1; extra == 'dev'
+Requires-Dist: pytest-asyncio>=1.3.0; extra == 'dev'
+Requires-Dist: pytest>=9.0.2; extra == 'dev'
+Requires-Dist: ruff>=0.15.7; extra == 'dev'
+Description-Content-Type: text/markdown
+
+<img width="200" alt="x64acp-ember" src="https://github.com/user-attachments/assets/da0940dc-7270-4a52-b969-9d5b6d5fa0ea" />
+
+Agent Communication Protocol (ACP) Python SDK
+
+[Documentation](docs/) · [Examples](examples/)
+
+```python
+from x64acp import AssistantServer, AssistantServerConfig, AssistantSend, AssistantIncoming
+
+server = AssistantServer(config=AssistantServerConfig(
+    database_type="postgres",
+    database_host="localhost",
+    database_name="myapp",
+))
+
+async def my_handler(incoming: AssistantIncoming, send: AssistantSend, memory, analytics, settings, knowledge):
+    history = await memory.get_history(limit=20, format="openai")
+    yield send.run_start()
+    yield send.text("Hello! How can I help?")
+    yield send.run_end()
+
+# FastAPI
+@app.websocket("/ws")
+async def ws(websocket: WebSocket):
+    await websocket.accept()
+    await server.handle(websocket, my_handler)
+
+# Programmatic (HTTP, jobs, webhooks)
+stream = await server.dispatch(my_handler, assistant_id="my-assistant", message="Hi")
+async for event in stream:
+    print(event)
+```
+
+## Installation
+
+```bash
+uv add x64acp                    # add to your project
+
+uv sync --all-extras                    # setup with all optional
+uv run poe check                        # ruff lint
+uv run poe check:fix                    # ruff lint + auto-fix
+uv run poe format                       # ruff format
+uv run poe format:imports               # sort imports
+uv run poe typecheck                    # mypy type checking
+uv run poe test                         # pytest
+```
+
+Private package — installed as editable dependency:
+
+```toml
+# In consumer pyproject.toml:
+x64acp = { path = "../packages/x64acp", editable = true }
+```
+
+## Persistence
+
+| Backend | Config | Requires |
+|---------|--------|----------|
+| PostgreSQL | `database_type="postgres"` | `asyncpg` |
+| Azure Cosmos DB | `database_type="cosmos"` | `azure-cosmos` |
+
+Auto-migrates on startup (`database_auto_migrate=True`). Both backends implement the same `Persistence` protocol.
+
+## Authentication & Authorization
+
+```python
+class MyAuth:
+    async def authenticate(self, token: str, user: UserIdentity | None) -> UserIdentity | None:
+        ...  # validate JWT, return user or None to reject
+
+class MyAuthz:
+    async def authorize(self, user, tenant, action, resource) -> AuthorizationResult | None:
+        ...  # check permissions
+
+server = AssistantServer(config=AssistantServerConfig(
+    authentication=MyAuth(),
+    authorization=MyAuthz(),
+    ...
+))
+```
+
+- `Authentication` — called once per WebSocket connection, validated identity overrides client-sent fields
+- `Authorization` — called per-action for fine-grained access control
+- Both optional — when `None`, all connections and actions are accepted
+
+## Identity & Scoping
+
+All identity models use `extra="allow"` — attach any fields your application needs.
+
+| Model | Base Fields | Purpose |
+|-------|-------------|---------|
+| `UserIdentity` | `id` | Who sent the message |
+| `AssistantIdentity` | `id`, `name` | Which assistant responded |
+| `SystemContext` | `id` | System-level metadata (environment, version) |
+| `TenantScope` | *(none)* | Organization/workspace scoping |
+
+Thread scoping uses JSONB containment on `owner_tenant` and `owner_user` — the consumer controls scope granularity by what they put in `tenant` and `user` at connection time.
+
+## Handler API
+
+```python
+async def handler(
+    incoming: AssistantIncoming,    # message, content, context
+    send: AssistantSend,            # yield events back to client
+    memory: AssistantMemory,        # conversation history
+    analytics: AssistantAnalytics,  # track custom events
+    settings: AssistantSettings,    # runtime settings
+    knowledge: AssistantKnowledge,  # knowledge source selection
+) -> AsyncGenerator[AssistantEvent, None]:
+    yield send.text("response")
+    yield send.tool_transaction("search", {"q": "test"}, {"results": [...]})
+    yield send.analysis("sentiment", {"score": 0.8}, text="Positive sentiment")
+```
+
+### Send Methods
+
+| Method | Description |
+|--------|-------------|
+| `text(text)` | Text message |
+| `image(url, mime_type?, alt?)` | Image |
+| `document(url, filename, mime_type)` | Document |
+| `audio(url, mime_type, duration?)` | Audio |
+| `tool_call(name, args, display_name?, id?)` | Tool invocation |
+| `tool_result(name, result, args?, display_name?, id?)` | Tool output |
+| `tool_transaction(name, args, result, display_name?, id?)` | Combined call + result |
+| `run_start(blueprint_id?)` | Start a run |
+| `run_end(status?, error?)` | End a run |
+| `confirmation(confirmation_id, action_type, blocking, summary, details?)` | Request user confirmation |
+| `analysis(kind, metadata, *, text?)` | Structured analysis event |
+| `mention(assistant_id, text)` | Cross-assistant mention |
+| `skill_invoke(assistant_id, command, args?)` | Invoke skill on another assistant |
+| `update_thread(*, title?, metadata?)` | Update thread title/metadata |
+| `update_user_event(event_id, content)` | Update existing event content |
+
+### Memory
+
+```python
+history = await memory.get_history(limit=20, format="openai")
+# Formats: "openai", "anthropic", "google", "cohere", "voyage"
+
+raw_events = await memory.get_history_raw(limit=50, order="asc")
+```
+
+### Settings
+
+```python
+from x64acp.settings import SettingsSchema, SettingsScope, SettingsField, SettingsFieldType
+
+schema = SettingsSchema(scopes=[
+    SettingsScope(name="admin_assistant", visibility="admin", fields=[...]),
+    SettingsScope(name="user_thread", visibility="user", fields=[...]),
+])
+
+# In handler:
+value = await settings.resolve("mode", scopes=[("user_thread", thread_id), ("admin_assistant", "")])
+```
+
+Settings stored per `(assistant_id, scope, scope_id)`. Field types: `text`, `number`, `select`, `checkbox`, `textarea`, `password`, `email`, `date`, `image`.
+
+## Server API
+
+| Method | Returns | Description |
+|--------|---------|-------------|
+| `handle(ws, handler)` | `None` | WebSocket loop (blocks until disconnect) |
+| `dispatch(handler, assistant_id, message, **kwargs)` | `DispatchStream` | Programmatic handler execution |
+| `repository()` | `Repository` | CRUD for threads/events/runs |
+| `broadcast` | `BroadcastManager` | Real-time event broadcasting |
+| `memory(thread_id, assistant_id)` | `AssistantMemory` | Conversation history |
+| `settings(assistant_id)` | `AssistantSettings` | Runtime settings |
+| `analytics(assistant_id, **kwargs)` | `AssistantAnalytics` | Analytics tracking |
+| `upload(data, filename, mime_type)` | `str` | Stage file upload (returns `ref_id`) |
+| `close()` | `None` | Shutdown and release resources |
+
+## Env Variables
+
+```bash
+assistant_DATABASE_HOST=localhost
+assistant_DATABASE_PORT=5432
+assistant_DATABASE_USER=postgres
+assistant_DATABASE_NAME=
+assistant_DATABASE_PASSWORD=
+assistant_DATABASE_KEY=                 # Cosmos DB only
+assistant_DATABASE_SSL=false            # false, true, require, verify-ca, verify-full
+```

x64acp-0.1.0/README.md

@@ -0,0 +1,184 @@
+<img width="200" alt="x64acp-ember" src="https://github.com/user-attachments/assets/da0940dc-7270-4a52-b969-9d5b6d5fa0ea" />
+
+Agent Communication Protocol (ACP) Python SDK
+
+[Documentation](docs/) · [Examples](examples/)
+
+```python
+from x64acp import AssistantServer, AssistantServerConfig, AssistantSend, AssistantIncoming
+
+server = AssistantServer(config=AssistantServerConfig(
+    database_type="postgres",
+    database_host="localhost",
+    database_name="myapp",
+))
+
+async def my_handler(incoming: AssistantIncoming, send: AssistantSend, memory, analytics, settings, knowledge):
+    history = await memory.get_history(limit=20, format="openai")
+    yield send.run_start()
+    yield send.text("Hello! How can I help?")
+    yield send.run_end()
+
+# FastAPI
+@app.websocket("/ws")
+async def ws(websocket: WebSocket):
+    await websocket.accept()
+    await server.handle(websocket, my_handler)
+
+# Programmatic (HTTP, jobs, webhooks)
+stream = await server.dispatch(my_handler, assistant_id="my-assistant", message="Hi")
+async for event in stream:
+    print(event)
+```
+
+## Installation
+
+```bash
+uv add x64acp                    # add to your project
+
+uv sync --all-extras                    # setup with all optional
+uv run poe check                        # ruff lint
+uv run poe check:fix                    # ruff lint + auto-fix
+uv run poe format                       # ruff format
+uv run poe format:imports               # sort imports
+uv run poe typecheck                    # mypy type checking
+uv run poe test                         # pytest
+```
+
+Private package — installed as editable dependency:
+
+```toml
+# In consumer pyproject.toml:
+x64acp = { path = "../packages/x64acp", editable = true }
+```
+
+## Persistence
+
+| Backend | Config | Requires |
+|---------|--------|----------|
+| PostgreSQL | `database_type="postgres"` | `asyncpg` |
+| Azure Cosmos DB | `database_type="cosmos"` | `azure-cosmos` |
+
+Auto-migrates on startup (`database_auto_migrate=True`). Both backends implement the same `Persistence` protocol.
+
+## Authentication & Authorization
+
+```python
+class MyAuth:
+    async def authenticate(self, token: str, user: UserIdentity | None) -> UserIdentity | None:
+        ...  # validate JWT, return user or None to reject
+
+class MyAuthz:
+    async def authorize(self, user, tenant, action, resource) -> AuthorizationResult | None:
+        ...  # check permissions
+
+server = AssistantServer(config=AssistantServerConfig(
+    authentication=MyAuth(),
+    authorization=MyAuthz(),
+    ...
+))
+```
+
+- `Authentication` — called once per WebSocket connection, validated identity overrides client-sent fields
+- `Authorization` — called per-action for fine-grained access control
+- Both optional — when `None`, all connections and actions are accepted
+
+## Identity & Scoping
+
+All identity models use `extra="allow"` — attach any fields your application needs.
+
+| Model | Base Fields | Purpose |
+|-------|-------------|---------|
+| `UserIdentity` | `id` | Who sent the message |
+| `AssistantIdentity` | `id`, `name` | Which assistant responded |
+| `SystemContext` | `id` | System-level metadata (environment, version) |
+| `TenantScope` | *(none)* | Organization/workspace scoping |
+
+Thread scoping uses JSONB containment on `owner_tenant` and `owner_user` — the consumer controls scope granularity by what they put in `tenant` and `user` at connection time.
+
+## Handler API
+
+```python
+async def handler(
+    incoming: AssistantIncoming,    # message, content, context
+    send: AssistantSend,            # yield events back to client
+    memory: AssistantMemory,        # conversation history
+    analytics: AssistantAnalytics,  # track custom events
+    settings: AssistantSettings,    # runtime settings
+    knowledge: AssistantKnowledge,  # knowledge source selection
+) -> AsyncGenerator[AssistantEvent, None]:
+    yield send.text("response")
+    yield send.tool_transaction("search", {"q": "test"}, {"results": [...]})
+    yield send.analysis("sentiment", {"score": 0.8}, text="Positive sentiment")
+```
+
+### Send Methods
+
+| Method | Description |
+|--------|-------------|
+| `text(text)` | Text message |
+| `image(url, mime_type?, alt?)` | Image |
+| `document(url, filename, mime_type)` | Document |
+| `audio(url, mime_type, duration?)` | Audio |
+| `tool_call(name, args, display_name?, id?)` | Tool invocation |
+| `tool_result(name, result, args?, display_name?, id?)` | Tool output |
+| `tool_transaction(name, args, result, display_name?, id?)` | Combined call + result |
+| `run_start(blueprint_id?)` | Start a run |
+| `run_end(status?, error?)` | End a run |
+| `confirmation(confirmation_id, action_type, blocking, summary, details?)` | Request user confirmation |
+| `analysis(kind, metadata, *, text?)` | Structured analysis event |
+| `mention(assistant_id, text)` | Cross-assistant mention |
+| `skill_invoke(assistant_id, command, args?)` | Invoke skill on another assistant |
+| `update_thread(*, title?, metadata?)` | Update thread title/metadata |
+| `update_user_event(event_id, content)` | Update existing event content |
+
+### Memory
+
+```python
+history = await memory.get_history(limit=20, format="openai")
+# Formats: "openai", "anthropic", "google", "cohere", "voyage"
+
+raw_events = await memory.get_history_raw(limit=50, order="asc")
+```
+
+### Settings
+
+```python
+from x64acp.settings import SettingsSchema, SettingsScope, SettingsField, SettingsFieldType
+
+schema = SettingsSchema(scopes=[
+    SettingsScope(name="admin_assistant", visibility="admin", fields=[...]),
+    SettingsScope(name="user_thread", visibility="user", fields=[...]),
+])
+
+# In handler:
+value = await settings.resolve("mode", scopes=[("user_thread", thread_id), ("admin_assistant", "")])
+```
+
+Settings stored per `(assistant_id, scope, scope_id)`. Field types: `text`, `number`, `select`, `checkbox`, `textarea`, `password`, `email`, `date`, `image`.
+
+## Server API
+
+| Method | Returns | Description |
+|--------|---------|-------------|
+| `handle(ws, handler)` | `None` | WebSocket loop (blocks until disconnect) |
+| `dispatch(handler, assistant_id, message, **kwargs)` | `DispatchStream` | Programmatic handler execution |
+| `repository()` | `Repository` | CRUD for threads/events/runs |
+| `broadcast` | `BroadcastManager` | Real-time event broadcasting |
+| `memory(thread_id, assistant_id)` | `AssistantMemory` | Conversation history |
+| `settings(assistant_id)` | `AssistantSettings` | Runtime settings |
+| `analytics(assistant_id, **kwargs)` | `AssistantAnalytics` | Analytics tracking |
+| `upload(data, filename, mime_type)` | `str` | Stage file upload (returns `ref_id`) |
+| `close()` | `None` | Shutdown and release resources |
+
+## Env Variables
+
+```bash
+assistant_DATABASE_HOST=localhost
+assistant_DATABASE_PORT=5432
+assistant_DATABASE_USER=postgres
+assistant_DATABASE_NAME=
+assistant_DATABASE_PASSWORD=
+assistant_DATABASE_KEY=                 # Cosmos DB only
+assistant_DATABASE_SSL=false            # false, true, require, verify-ca, verify-full
+```

x64acp-0.1.0/examples/fastapi_anthropic.py

@@ -0,0 +1,120 @@
+import os
+
+from anthropic import AsyncAnthropic
+from fastapi import FastAPI, WebSocket
+
+from x64acp import (
+    AssistantServer,
+    AssistantServerConfig,
+    SettingsField,
+    SettingsFieldType,
+    SettingsSchema,
+    SettingsScope,
+    SettingsSelectOption,
+)
+
+app = FastAPI()
+
+settings_schema = SettingsSchema(
+    scopes=[
+        SettingsScope(
+            name="admin_assistant",
+            visibility="admin",
+            fields=[
+                SettingsField(
+                    id="model",
+                    type=SettingsFieldType.SELECT,
+                    label="Model",
+                    required=True,
+                    default="claude-sonnet-4-20250514",
+                    options=[
+                        SettingsSelectOption(value="claude-sonnet-4-20250514", label="Claude Sonnet 4"),
+                        SettingsSelectOption(value="claude-opus-4-20250514", label="Claude Opus 4"),
+                        SettingsSelectOption(value="claude-haiku-4-20250514", label="Claude Haiku 4"),
+                    ],
+                ),
+                SettingsField(
+                    id="max_tokens",
+                    type=SettingsFieldType.NUMBER,
+                    label="Max Tokens",
+                    required=True,
+                    default=1024,
+                    min=1,
+                    max=4096,
+                ),
+            ],
+        ),
+        SettingsScope(
+            name="user_thread",
+            visibility="user",
+            fields=[
+                SettingsField(
+                    id="system_prompt",
+                    type=SettingsFieldType.TEXTAREA,
+                    label="System Prompt",
+                    required=True,
+                    default="You are a helpful assistant.",
+                    rows=4,
+                ),
+            ],
+        ),
+    ]
+)
+
+assistant_server = AssistantServer(
+    AssistantServerConfig(
+        database_type="postgres",
+        database_name="assistant",
+        settings_schema=settings_schema,
+    )
+)
+client = AsyncAnthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))
+
+
+async def anthropic_assistant(incoming, send, memory, analytics, settings, knowledge):
+    yield send.run_start()
+
+    model = await settings.get("model", scope="admin_assistant")
+    max_tokens = await settings.get("max_tokens", scope="admin_assistant")
+    system_prompt = await settings.resolve(
+        "system_prompt",
+        scopes=[("user_thread", incoming.context.thread_id), ("admin_assistant", "")],
+    )
+
+    await analytics.track("llm.request", data={"model": model})
+
+    history = await memory.get_history(limit=20, format="anthropic")
+
+    messages = list(history)
+    messages.append({"role": "user", "content": incoming.message})
+
+    result = await client.messages.create(
+        model=model,
+        max_tokens=int(max_tokens),
+        system=system_prompt,
+        messages=messages,
+    )
+
+    await analytics.track(
+        "llm.response",
+        data={
+            "model": model,
+            "input_tokens": result.usage.input_tokens,
+            "output_tokens": result.usage.output_tokens,
+        },
+    )
+
+    yield send.text(result.content[0].text)
+    yield send.update_thread(title=incoming.message[:60])
+    yield send.run_end()
+
+
+@app.websocket("/ws")
+async def websocket_endpoint(websocket: WebSocket):
+    await websocket.accept()
+    await assistant_server.handle(websocket, anthropic_assistant)
+
+
+@app.on_event("shutdown")
+async def shutdown():
+    await assistant_server.close()

x64acp-0.1.0/examples/fastapi_basic.py

@@ -0,0 +1,30 @@
+from fastapi import FastAPI, WebSocket
+
+from x64acp import AssistantServer, AssistantServerConfig
+
+app = FastAPI()
+assistant_server = AssistantServer(
+    AssistantServerConfig(
+        database_type="postgres",
+        database_name="assistant",
+        assistant_name="Echo Bot",
+    )
+)
+
+
+async def echo_assistant(incoming, send, memory, analytics, settings, knowledge):
+    yield send.run_start()
+    yield send.text(f"You said: {incoming.message}")
+    yield send.update_thread(title=incoming.message[:60])
+    yield send.run_end()
+
+
+@app.websocket("/ws")
+async def websocket_endpoint(websocket: WebSocket):
+    await websocket.accept()
+    await assistant_server.handle(websocket, echo_assistant)
+
+
+@app.on_event("shutdown")
+async def shutdown():
+    await assistant_server.close()