agentbyte 0.5.0__tar.gz → 0.7.0__tar.gz

agentbyte-0.7.0/.github/skills/agentbyte-fastapi-sse-streaming/SKILL.md

@@ -0,0 +1,114 @@
+---
+name: agentbyte-fastapi-sse-streaming
+description: Guide for building or updating FastAPI-based Server-Sent Events streaming in Agentbyte, especially POST /chat/stream endpoints that use EventSourceResponse and ServerSentEvent for browser or curl clients.
+license: MIT
+---
+
+Use this skill when adding or maintaining FastAPI SSE streaming in Agentbyte, especially for `agentbyte.microwebui`.
+
+## Inputs to confirm
+- Whether the stream should stay on `POST` because the client sends a JSON body
+- Whether the frontend expects plain `data: <json>` SSE frames with no named SSE events
+- Whether session continuity requires `session_id` and `user_id` in the request body
+- Whether the stream should persist the final `AgentContext` and replayable event history
+
+## Pattern: Native FastAPI SSE for POST streaming
+
+Prefer FastAPI's built-in SSE support over manual `StreamingResponse` framing.
+
+```python
+from collections.abc import AsyncIterable
+from typing import Any
+
+from fastapi import FastAPI
+from fastapi.sse import EventSourceResponse, ServerSentEvent
+from pydantic import BaseModel
+
+app = FastAPI()
+
+
+class ChatRequest(BaseModel):
+    message: str
+    session_id: str | None = None
+    user_id: str | None = None
+    agent_name: str | None = None
+
+
+async def stream_events(request: ChatRequest) -> AsyncIterable[ServerSentEvent]:
+    for payload in [{"event_type": "task_start", "task": request.message}]:
+        yield ServerSentEvent(data=payload)
+
+
+@app.post("/chat/stream", response_class=EventSourceResponse)
+async def chat_stream(request: ChatRequest) -> AsyncIterable[ServerSentEvent]:
+    async for event in stream_events(request):
+        yield event
+```
+
+## Current Agentbyte pattern
+
+For `microwebui`, the stream generator:
+
+- resolves the selected agent
+- loads or creates `AgentContext` from `InMemorySessionStore`
+- runs `agent.run_stream(..., context=context, verbose=True, stream_tokens=True)`
+- yields `ServerSentEvent(data=event_payload)` for each streamed item
+- persists the final `AgentContext` plus stored event history when the final `AgentResponse` arrives
+
+The important point is that Agentbyte no longer manually builds:
+
+```python
+f"data: {json_payload}\\n\\n"
+```
+
+FastAPI now handles the SSE framing for us.
+
+## Request shape after the API is running
+
+For a live server on `127.0.0.1:8070`, use:
+
+```bash
+curl -N -X POST http://127.0.0.1:8070/chat/stream \
+  -H "Content-Type: application/json" \
+  -d '{
+    "message": "What is the weather in Prague?",
+    "session_id": "demo-session-1",
+    "user_id": "demo-user-1",
+    "agent_name": "weather_assistant"
+  }'
+```
+
+To test follow-up memory, reuse the same `session_id` and `user_id`:
+
+```bash
+curl -N -X POST http://127.0.0.1:8070/chat/stream \
+  -H "Content-Type: application/json" \
+  -d '{
+    "message": "Summarize the previous answer in one sentence.",
+    "session_id": "demo-session-1",
+    "user_id": "demo-user-1",
+    "agent_name": "weather_assistant"
+  }'
+```
+
+## Expected stream shape
+
+The browser or curl client still sees normal SSE frames such as:
+
+```text
+data: {"event_type":"task_start",...}
+
+data: {"event_type":"model_call",...}
+
+data: {"content":"...","role":"assistant",...}
+```
+
+The frontend can keep parsing `data: ` lines exactly as before.
+
+## Guardrails
+
+- For body-carrying chat streams, keep `POST` plus `fetch()`; browser `EventSource` is not a drop-in replacement because it does not send JSON request bodies.
+- When using native FastAPI SSE, yield `ServerSentEvent(data=...)` instead of manually formatting `data: ...\\n\\n`.
+- Keep the JSON payload shape stable unless the frontend/parser is updated in the same change set.
+- If memory is part of the demo, reuse the same `session_id` and `user_id` across follow-up requests.
+- Store replayable session events only after normalizing them to JSON-friendly payloads.

{agentbyte-0.5.0 → agentbyte-0.7.0}/CHANGELOG.md

@@ -4,6 +4,45 @@ All notable changes to Agentbyte are documented in this file.
 
 The format follows Keep a Changelog principles and semantic versioning.
 
+## [0.7.0] - 2026-04-09
+
+### Added
+
+- Added a new bundled Copilot skill: `agentbyte-fastapi-sse-streaming`, covering FastAPI native SSE setup, `ServerSentEvent` usage, and copy-ready `curl` requests for testing a running `/chat/stream` endpoint.
+
+### Changed
+
+- Switched `agentbyte.microwebui` from manual SSE string framing to FastAPI's native `EventSourceResponse` and `ServerSentEvent` support while keeping the existing frontend event payload contract intact.
+- Refined the bundled `microwebui` frontend with a scrollable chat feed, updated visual styling, and a lightweight live "thinking" panel inside the main conversation view during streamed runs.
+- Expanded the Chapter 8 web study notes to document browser-generated `session_id` / `user_id` handling, user-scoped session listing, and why `microwebui` moved from manual SSE framing to FastAPI's built-in SSE support.
+
+## [0.6.1] - 2026-04-09
+
+### Changed
+
+- Improved ASCII diagrams in web study topics (`docs/study/04-web_topics/`) for better visual clarity: construction flow, session lifecycle, startup sequence, session switching, and example runtime flow now use box-drawing characters for enhanced readability.
+
+## [0.6.0] - 2026-04-09
+
+### Added
+
+- Added `agentbyte.microwebui`, a new lightweight built-in web UI module for small agent demos with a simple `serve(entities=[...], port=...)` interface.
+- Added a bundled vanilla frontend for `microwebui` with agent discovery, in-memory session switching, stored event-stream reload, and a live debug panel.
+- Added `examples/microwebui_agents.py`, a one-file example that defines multiple agents locally and serves them through the new `microwebui` module.
+- Added multiple demo agent patterns for the Chapter 8-style experience: weather, travel, and packing assistants sharing the same model client and weather tool.
+
+### Changed
+
+- Promoted the working Chapter 8 FastAPI + SSE prototype into the reusable `agentbyte.microwebui` package instead of keeping it only under `examples/`.
+- Updated the root example run path so `make run-microwebui-example` launches the new one-file `microwebui` demo.
+- Updated package build metadata so the bundled `microwebui` frontend ships in installable artifacts.
+
+### Fixed
+
+- Removed the redundant wheel include rule for `microwebui` UI assets, eliminating duplicate archive entries during builds while preserving install-time asset availability.
+- Fixed `microwebui` request-model binding so `POST /chat/stream` accepts the frontend payload correctly after installation.
+- Fixed stale in-browser session handling so a restarted server automatically falls back to a fresh in-memory session instead of repeatedly probing a dead session id.
+
 ## [0.5.0] - 2026-04-08
 
 ### Added

{agentbyte-0.5.0 → agentbyte-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentbyte
-Version: 0.5.0
+Version: 0.7.0
 Summary: A toolkit for designing multiagent systems
 Project-URL: Homepage, https://gitlab.com/pyninja/aiengineering/agentbyte
 Project-URL: Repository, https://gitlab.com/pyninja/aiengineering/agentbyte
@@ -51,21 +51,46 @@ Provides-Extra: viz
 Requires-Dist: graphviz>=0.21; extra == 'viz'
 Provides-Extra: webui
 Requires-Dist: fastapi>=0.135.2; extra == 'webui'
-Requires-Dist: uvicorn>=0.42.0; extra == 'webui'
+Requires-Dist: uvicorn[standard]>=0.44.0; extra == 'webui'
 Description-Content-Type: text/markdown
 
 <p align="center">
-  <img src="https://gitlab.com/pyninja/aiengineering/agentbyte/-/raw/v0.5.0/logo/agent-byte-avatar-low.png" alt="Agentbyte" width="200"/>
+  <img src="https://gitlab.com/pyninja/aiengineering/agentbyte/-/raw/v0.7.0/logo/agent-byte-avatar-low.png" alt="Agentbyte" width="200"/>
 </p>
 
 # Agentbyte
 
 Agentbyte is an observability-first agentic AI framework for building and studying multiagent systems with a learning-first, implementation-oriented workflow.
 
-Current release: **0.5.0**
+Current release: **0.7.0**
 
 Repository: [gitlab.com/pyninja/aiengineering/agentbyte](https://gitlab.com/pyninja/aiengineering/agentbyte)
 
+## What's New in 0.7.0
+
+**MicroWebUI streaming polish + bundled SSE skill**
+
+- Switched `agentbyte.microwebui` streaming to FastAPI's native SSE support with `EventSourceResponse` and `ServerSentEvent`, while preserving the existing frontend wire contract.
+- Refined the bundled `microwebui` frontend with a scrollable chat window and a lightweight live "thinking" trace during streamed runs.
+- Added a new bundled Copilot skill, `agentbyte-fastapi-sse-streaming`, covering FastAPI SSE setup and copy-ready `curl` examples for `/chat/stream`.
+- Expanded the Chapter 8 web study topics to explain browser-generated `session_id` / `user_id` flow, session-list filtering, and the manual-SSE to native-SSE migration.
+
+## What's New in 0.6.1
+
+**Study topic documentation polish**
+
+- Improved ASCII diagrams in web study topics with clearer visual hierarchy and flow using box-drawing characters.
+
+## What's New in 0.6.0
+
+**MicroWebUI + Chapter 8 demo promotion**
+
+- Added `agentbyte.microwebui` with a small built-in `serve(entities=[...], port=...)` interface for lightweight agent demos.
+- Promoted the working Chapter 8 FastAPI + SSE example into the reusable `microwebui` module instead of keeping it only as an `examples/app/` prototype.
+- Added a bundled vanilla HTML frontend for `microwebui` with agent discovery, in-memory sessions, stored event history reload, and a live debug panel.
+- Added a one-file launcher example, `examples/microwebui_agents.py`, showing the picoagents-style flow of defining agents locally and passing them to `serve(...)`.
+- Fixed `microwebui` packaging so the bundled frontend ships correctly in the installable wheel without duplicate archive entries.
+
 ## What's New in 0.5.0
 
 **Workflow Runtime — Spec 08 complete (8 sub-specs)**

{agentbyte-0.5.0 → agentbyte-0.7.0}/README.md

@@ -1,15 +1,40 @@
 <p align="center">
-  <img src="https://gitlab.com/pyninja/aiengineering/agentbyte/-/raw/v0.5.0/logo/agent-byte-avatar-low.png" alt="Agentbyte" width="200"/>
+  <img src="https://gitlab.com/pyninja/aiengineering/agentbyte/-/raw/v0.7.0/logo/agent-byte-avatar-low.png" alt="Agentbyte" width="200"/>
 </p>
 
 # Agentbyte
 
 Agentbyte is an observability-first agentic AI framework for building and studying multiagent systems with a learning-first, implementation-oriented workflow.
 
-Current release: **0.5.0**
+Current release: **0.7.0**
 
 Repository: [gitlab.com/pyninja/aiengineering/agentbyte](https://gitlab.com/pyninja/aiengineering/agentbyte)
 
+## What's New in 0.7.0
+
+**MicroWebUI streaming polish + bundled SSE skill**
+
+- Switched `agentbyte.microwebui` streaming to FastAPI's native SSE support with `EventSourceResponse` and `ServerSentEvent`, while preserving the existing frontend wire contract.
+- Refined the bundled `microwebui` frontend with a scrollable chat window and a lightweight live "thinking" trace during streamed runs.
+- Added a new bundled Copilot skill, `agentbyte-fastapi-sse-streaming`, covering FastAPI SSE setup and copy-ready `curl` examples for `/chat/stream`.
+- Expanded the Chapter 8 web study topics to explain browser-generated `session_id` / `user_id` flow, session-list filtering, and the manual-SSE to native-SSE migration.
+
+## What's New in 0.6.1
+
+**Study topic documentation polish**
+
+- Improved ASCII diagrams in web study topics with clearer visual hierarchy and flow using box-drawing characters.
+
+## What's New in 0.6.0
+
+**MicroWebUI + Chapter 8 demo promotion**
+
+- Added `agentbyte.microwebui` with a small built-in `serve(entities=[...], port=...)` interface for lightweight agent demos.
+- Promoted the working Chapter 8 FastAPI + SSE example into the reusable `microwebui` module instead of keeping it only as an `examples/app/` prototype.
+- Added a bundled vanilla HTML frontend for `microwebui` with agent discovery, in-memory sessions, stored event history reload, and a live debug panel.
+- Added a one-file launcher example, `examples/microwebui_agents.py`, showing the picoagents-style flow of defining agents locally and passing them to `serve(...)`.
+- Fixed `microwebui` packaging so the bundled frontend ships correctly in the installable wheel without duplicate archive entries.
+
 ## What's New in 0.5.0
 
 **Workflow Runtime — Spec 08 complete (8 sub-specs)**

{agentbyte-0.5.0 → agentbyte-0.7.0}/pyproject.toml

@@ -42,7 +42,7 @@ azureopenai = [
 ]
 webui = [
     "fastapi>=0.135.2",
-    "uvicorn>=0.42.0",
+    "uvicorn[standard]>=0.44.0",
 ]
 viz = [
     "graphviz>=0.21",
@@ -91,7 +91,7 @@ packages = ["src/agentbyte"]
 ".github/skills" = "agentbyte/skills"
 
 [tool.hatch.build.targets.sdist]
-include = ["/src", "/tests", "/README.md", "/LICENSE", "/CHANGELOG.md", "/.github/skills", "/src/agentbyte/webui/ui"]
+include = ["/src", "/tests", "/README.md", "/LICENSE", "/CHANGELOG.md", "/.github/skills", "/src/agentbyte/webui/ui", "/src/agentbyte/microwebui/ui"]
 
 [dependency-groups]
 aws = [
@@ -126,7 +126,7 @@ viz = [
 ]
 webui = [
     "fastapi>=0.135.2",
-    "uvicorn>=0.42.0",
+    "uvicorn[standard]>=0.44.0",
 ]
 
 [tool.pytest.ini_options]

{agentbyte-0.5.0 → agentbyte-0.7.0}/src/agentbyte/__about__.py

@@ -1,2 +1,2 @@
-__version__ = "0.5.0"
+__version__ = "0.7.0"
 VERSION = __version__

agentbyte-0.7.0/src/agentbyte/microwebui/__init__.py

@@ -0,0 +1,9 @@
+"""Minimal built-in web UI for small Agentbyte demos."""
+
+from agentbyte.microwebui.server import MicroWebUIServer, create_app, serve
+
+__all__ = [
+    "MicroWebUIServer",
+    "create_app",
+    "serve",
+]

agentbyte-0.7.0/src/agentbyte/microwebui/server.py

@@ -0,0 +1,307 @@
+"""Minimal FastAPI-based web UI for small Agentbyte demos."""
+
+from __future__ import annotations
+
+import json
+from collections.abc import Iterable, Sequence
+from pathlib import Path
+from typing import Any
+from uuid import uuid4
+
+from agentbyte import InMemorySessionStore
+from agentbyte.agents import Agent, AgentResponse
+from agentbyte.context import AgentContext
+from pydantic import BaseModel
+
+EVENT_STREAM_KEY = "microwebui_event_stream"
+RUN_COUNTER_KEY = "microwebui_run_counter"
+UI_INDEX = Path(__file__).resolve().parent / "ui" / "index.html"
+
+
+def _require_fastapi() -> tuple[Any, Any, Any, Any, Any]:
+    try:
+        from fastapi import FastAPI, HTTPException
+        from fastapi.responses import FileResponse
+        from fastapi.sse import EventSourceResponse, ServerSentEvent
+    except ImportError as exc:
+        raise RuntimeError(
+            "Agentbyte microwebui requires optional dependencies. "
+            "Install with `uv sync --extra webui` or `pip install agentbyte[webui]`."
+        ) from exc
+    return FastAPI, HTTPException, FileResponse, EventSourceResponse, ServerSentEvent
+
+
+class ChatRequest(BaseModel):
+    """Incoming chat payload."""
+
+    message: str
+    session_id: str | None = None
+    agent_name: str | None = None
+    user_id: str | None = None
+
+
+class AgentSummary(BaseModel):
+    """Compact agent metadata for the discovery dropdown."""
+
+    name: str
+    description: str
+    default: bool = False
+
+
+class SessionSummary(BaseModel):
+    """Compact session metadata for the session picker."""
+
+    session_id: str
+    message_count: int
+    created_at: str | None = None
+    updated_at: str | None = None
+    preview: str | None = None
+
+
+class SessionEvent(BaseModel):
+    """Stored SSE-style event payload for a past run."""
+
+    run_index: int
+    run_label: str
+    prompt: str
+    agent_name: str
+    event: dict[str, Any]
+
+
+def _serialize_stream_item(item: Any) -> str:
+    """Serialize Agentbyte stream items to JSON for SSE output."""
+    if hasattr(item, "model_dump_json"):
+        return item.model_dump_json()
+
+    if hasattr(item, "model_dump"):
+        return json.dumps(item.model_dump(mode="json"))
+
+    return json.dumps(
+        {
+            "event_type": "unknown",
+            "content": str(item),
+            "python_type": type(item).__name__,
+        }
+    )
+
+
+def _parse_stream_item(item: Any) -> dict[str, Any]:
+    """Parse a stream item into a JSON-friendly dict."""
+    return json.loads(_serialize_stream_item(item))
+
+
+def _iter_visible_messages(context: AgentContext) -> Iterable[dict[str, Any]]:
+    """Yield user/assistant/tool messages with JSON-friendly shape."""
+    for message in context.messages:
+        if hasattr(message, "model_dump"):
+            yield message.model_dump(mode="json")
+
+
+def _session_preview(context: AgentContext) -> str | None:
+    """Return a short preview for a stored session."""
+    for message in context.messages:
+        role = getattr(message, "role", None)
+        content = getattr(message, "content", None)
+        if role == "user" and content:
+            return str(content)[:72]
+    return None
+
+
+def _stored_event_stream(context: AgentContext) -> list[dict[str, Any]]:
+    """Return the stored event stream list from session metadata."""
+    events = context.metadata.get(EVENT_STREAM_KEY, [])
+    return events if isinstance(events, list) else []
+
+
+def _next_run_index(context: AgentContext) -> int:
+    """Return the next run index for this stored session."""
+    current_value = context.metadata.get(RUN_COUNTER_KEY, 0)
+    return int(current_value) + 1
+
+
+class MicroWebUIServer:
+    """Serve a small multi-agent web UI from a list of Agent objects."""
+
+    def __init__(self, entities: Sequence[Agent]) -> None:
+        if not entities:
+            raise ValueError("microwebui requires at least one agent")
+
+        self.entities = list(entities)
+        self.entity_lookup = {entity.name: entity for entity in self.entities}
+        self.session_store = InMemorySessionStore()
+
+    def default_agent(self) -> Agent:
+        """Return the first registered agent as the default selection."""
+        return self.entities[0]
+
+    def resolve_agent(self, agent_name: str | None, http_exception: Any) -> Agent:
+        """Resolve a requested agent name or fall back to the default agent."""
+        if agent_name is None:
+            return self.default_agent()
+
+        agent = self.entity_lookup.get(agent_name)
+        if agent is None:
+            raise http_exception(status_code=404, detail=f"Unknown agent: {agent_name}")
+        return agent
+
+    async def stream_agent_events(
+        self,
+        message: str,
+        session_id: str | None,
+        agent_name: str | None,
+        user_id: str | None,
+        http_exception: Any,
+        server_sent_event: Any,
+    ):
+        """Stream agent execution as SSE and persist emitted events in memory."""
+        selected_agent = self.resolve_agent(agent_name, http_exception)
+        effective_session_id = session_id or str(uuid4())
+        context = await self.session_store.get(effective_session_id)
+        if context is None:
+            context = AgentContext(session_id=effective_session_id, user_id=user_id)
+        else:
+            context.session_id = effective_session_id
+            if user_id is not None:
+                context.user_id = user_id
+
+        current_run_index = _next_run_index(context)
+        current_run_events: list[SessionEvent] = []
+
+        async for event in selected_agent.run_stream(
+            message,
+            context=context,
+            verbose=True,
+            stream_tokens=True,
+        ):
+            event_payload = _parse_stream_item(event)
+            current_run_events.append(
+                SessionEvent(
+                    run_index=current_run_index,
+                    run_label=f"Run {current_run_index}",
+                    prompt=message,
+                    agent_name=selected_agent.name,
+                    event=event_payload,
+                )
+            )
+            if isinstance(event, AgentResponse):
+                event.context.metadata[EVENT_STREAM_KEY] = [
+                    *_stored_event_stream(event.context),
+                    *(stored_event.model_dump(mode="json") for stored_event in current_run_events),
+                ]
+                event.context.metadata[RUN_COUNTER_KEY] = current_run_index
+                await self.session_store.save(effective_session_id, event.context)
+            yield server_sent_event(data=event_payload)
+
+    def create_app(self) -> Any:
+        """Build the FastAPI application for the microwebui server."""
+        FastAPI, HTTPException, FileResponse, EventSourceResponse, ServerSentEvent = (
+            _require_fastapi()
+        )
+
+        app = FastAPI(title="Agentbyte MicroWebUI")
+
+        @app.post("/chat/stream", response_class=EventSourceResponse)
+        async def chat_stream(request: ChatRequest) -> Any:
+            async for event in self.stream_agent_events(
+                request.message,
+                request.session_id,
+                request.agent_name,
+                request.user_id,
+                HTTPException,
+                ServerSentEvent,
+            ):
+                yield event
+
+        @app.get("/api/agents")
+        async def list_agents() -> list[AgentSummary]:
+            default_name = self.default_agent().name
+            return [
+                AgentSummary(
+                    name=agent.name,
+                    description=getattr(agent, "description", "") or "",
+                    default=agent.name == default_name,
+                )
+                for agent in self.entities
+            ]
+
+        @app.get("/api/sessions")
+        async def list_sessions(user_id: str | None = None) -> list[SessionSummary]:
+            session_items = (
+                await self.session_store.list_by_user(user_id)
+                if user_id
+                else await self.session_store.list()
+            )
+            sessions = [
+                SessionSummary(
+                    session_id=session_id,
+                    message_count=len(context.messages),
+                    created_at=context.created_at.isoformat() if context.created_at else None,
+                    updated_at=context.updated_at.isoformat() if context.updated_at else None,
+                    preview=_session_preview(context),
+                )
+                for session_id, context in session_items
+            ]
+            sessions.sort(
+                key=lambda session: session.updated_at or session.created_at or "",
+                reverse=True,
+            )
+            return sessions
+
+        @app.get("/api/sessions/{session_id}")
+        async def get_session(session_id: str) -> dict[str, Any]:
+            context = await self.session_store.get(session_id)
+            if context is None:
+                raise HTTPException(status_code=404, detail="Session not found")
+
+            return {
+                "session_id": session_id,
+                "message_count": len(context.messages),
+                "context": context.model_dump(mode="json"),
+                "visible_messages": list(_iter_visible_messages(context)),
+            }
+
+        @app.get("/api/sessions/{session_id}/events")
+        async def get_session_events(session_id: str) -> dict[str, Any]:
+            context = await self.session_store.get(session_id)
+            if context is None:
+                raise HTTPException(status_code=404, detail="Session not found")
+
+            events = _stored_event_stream(context)
+            return {
+                "session_id": session_id,
+                "event_count": len(events),
+                "events": events,
+            }
+
+        @app.get("/")
+        async def serve_frontend() -> Any:
+            return FileResponse(UI_INDEX)
+
+        return app
+
+    def serve(self, host: str = "127.0.0.1", port: int = 8070) -> None:
+        """Run the microwebui application with uvicorn."""
+        try:
+            import uvicorn
+        except ImportError as exc:
+            raise RuntimeError(
+                "Agentbyte microwebui requires optional dependencies. "
+                "Install with `uv sync --extra webui` or `pip install agentbyte[webui]`."
+            ) from exc
+
+        print(f"Starting Agentbyte MicroWebUI on http://{host}:{port}/")
+        uvicorn.run(self.create_app(), host=host, port=port)
+
+
+def create_app(entities: Sequence[Agent]) -> Any:
+    """Create a FastAPI app for the given list of agents."""
+    return MicroWebUIServer(entities).create_app()
+
+
+def serve(
+    entities: Sequence[Agent],
+    host: str = "127.0.0.1",
+    port: int = 8070,
+) -> None:
+    """Serve a minimal built-in web UI for the given list of agents."""
+    MicroWebUIServer(entities).serve(host=host, port=port)