Polacy nie gęsi swój język mają cz. II: Bielik lata z Agenturą, vLLM, MCP, assistant-ui i streamingiem.

git clone https://github.com/vllm-project/vllm.git
cd vllm
uv python install 3.12
uv venv --python 3.12
uv pip install -r requirements/cpu.txt
# w moim przypadku konieczne było dodanie jednej flagi:
# uv pip install --index-strategy unsafe-best-match -r requirements/cpu.txt
uv pip install -e .

uv python install 3.12
# 3.13 nie działa
uv tool install --python 3.12 vllm

uv tool install --python 3.12  huggingface-hub
hf auth login

git clone https://github.com/speakleash/bielik-tools

vllm serve "speakleash/Bielik-11B-v2.6-Instruct" \
    --enable-auto-tool-choice \
    --tool-parser-plugin ./bielik-tools/tools/bielik_vllm_tool_parser.py \
    --tool-call-parser bielik \
    --chat-template ./bielik-tools/tools/bielik_advanced_chat_template.jinja \
    --port 8000 --host 0.0.0.0 \
    --max-num-batched-tokens 32768

vllm serve "speakleash/Bielik-4.5B-v3.0-Instruct" \
    --enable-auto-tool-choice \
    --tool-parser-plugin ./bielik-tools/tools/bielik_vllm_tool_parser.py \
    --tool-call-parser bielik \
    --chat-template ./bielik-tools/tools/bielik_advanced_chat_template.jinja \
    --port 8000 --host 0.0.0.0 \
    --max-num-batched-tokens 32768

ifconfig en0 | grep inet
inet6 fe80::10b4:3cc6:e4b8:e5ec%en0 prefixlen 64 secured scopeid 0xe 
    inet 192.168.100.90 netmask 0xffffff00 broadcast 192.168.100.255

Menu -> Ustawienia -> Prywatność i Bezpieczeństwo -> Local Network

uv add openai openai-agents

# completions.py
from openai import OpenAI

BASE_URL: str = "http://192.168.100.90:8000/v1"

client = OpenAI(base_url=BASE_URL, api_key="...")

def main():
    completion = client.chat.completions.create(
        model="speakleash/Bielik-4.5B-v3.0-Instruct", # lub 4b
        messages=[
            {"role": "assistant", "content": "Mów niczym Herbert."},
            {
                "role": "user",
                "content": "Jaki jest sens życia?",
            },
        ],
    )
    print(completion.choices[0].message.content)


if __name__ == "__main__":
    main()

uv run python completions.py

# agent.py
import asyncio
import os

from agents import Agent, Runner, set_default_openai_api, set_default_openai_client
from openai import AsyncOpenAI


os.environ["OPENAI_BASE_URL"] = "http://192.168.100.90:8000/v1"
os.environ["OPENAI_API_KEY"] = "EMPTY"

model = "speakleash/Bielik-4.5B-v3.0-Instruct"

agent = Agent(
    name="Korepetytor",
    instructions="Pomagasz z matematyką. Dostajesz pytanie od użytkownika i odpowiadasz na nie. Wyjaśnij swoje rozumowanie i podaj przykłady.",
    model=model,
)


async def main():
    result = await Runner.run(agent, "Czym jest dodawanie?")
    print(result.final_output)

if __name__ == "__main__":
    asyncio.run(main())

# agent.py
import asyncio
from openai import AsyncOpenAI
from agents import Agent, Runner, OpenAIResponsesModel

async def main():
    openai_client = AsyncOpenAI(
        base_url="http://192.168.100.90:8000/v1",
        api_key="EMPTY",
    )

    agent = Agent(
        name="Korepetytor",
        instructions="Pomagasz z matematyką. Dostajesz pytanie od użytkownika i odpowiadasz na nie. Wyjaśnij swoje rozumowanie i podaj przykłady.",
        model=OpenAIResponsesModel(
            model="speakleash/Bielik-4.5B-v3.0-Instruct",
            openai_client=openai_client,
        ),
    )

    result = await Runner.run(agent, "Czym jest dodawanie?")
    print(result.final_output)

if __name__ == "__main__":
    asyncio.run(main())

uv run python agent.py

uv add fastmcp

from fastmcp import FastMCP
from datetime import datetime

mcp = FastMCP("My MCP Server")

@mcp.tool
def dzisiejsza_data() -> str: # czy tylko mnie funkcje po polsku mrożą?
    """ Zwraca dzisiejszą datę """

    return datetime.now().strftime("%Y-%m-%d")

if __name__ == "__main__":
    mcp.run(transport="http", port=8001)

import asyncio
from openai import AsyncOpenAI
from agents import Agent, Runner, OpenAIChatCompletionsModel
from agents.mcp import MCPServerStreamableHttp


mcp_helper_server = MCPServerStreamableHttp(
    name="My MCP Server",
    params={
        "url": "http://127.0.0.1:8001/mcp",
    },
)


async def main():
    openai_client = AsyncOpenAI(
        base_url="http://192.168.100.90:8000/v1",
        api_key="EMPTY",
    )
    async with mcp_helper_server:
        agent = Agent(
            name="Zegarmistrz światła purpurowy",
            instructions="Pomagasz z datą i czasem.",
            model=OpenAIChatCompletionsModel(
                model="speakleash/Bielik-4.5B-v3.0-Instruct",  # Your model name
                openai_client=openai_client,
            ),
            mcp_servers=[mcp_helper_server],
        )

        # Run the agent
        result = await Runner.run(agent, "Jaka jest dzisiejsza data?")
        print(result.final_output)

if __name__ == "__main__":
    asyncio.run(main())

**Dzisiejsza data to: 6 września 2025 roku.**

Obecna data to **„14 stycznia 2024”** (lub inna data w zależności od momentu, w którym zadajesz pytanie).

Jeśli potrzebujesz konkretnej daty, podaj proszę dokładną godzinę pytania.

import asyncio
from openai import AsyncOpenAI
from agents import Agent, Runner, OpenAIChatCompletionsModel
from agents.mcp import MCPServerStreamableHttp


mcp_helper_server = MCPServerStreamableHttp(
    name="My MCP Server",
    params={
        "url": "http://127.0.0.1:8001/mcp",
    },
)


async def main():
    openai_client = AsyncOpenAI(
        base_url="http://192.168.100.90:8000/v1",
        api_key="EMPTY",
    )
    async with mcp_helper_server:
        date_time_agent = Agent(
            name="Agent od daty i czasu",
            instructions="Pomagasz z obecną datą i czasem.",
            model=OpenAIChatCompletionsModel(
                model="speakleash/Bielik-4.5B-v3.0-Instruct",
                openai_client=openai_client,
            ),
            mcp_servers=[mcp_helper_server],
        )
        haiku_agent = Agent(
            name="Haiku generator",
            instructions="Generujesz haiku ale tylko 5 zdaniowe.",
            model=OpenAIChatCompletionsModel(
                model="speakleash/Bielik-4.5B-v3.0-Instruct",
                openai_client=openai_client,
            ),
        )
        orchestrator = Agent(
            name="Orchestrator",
            instructions="Organizujesz działanie agentów. Sam nie podejmuj akcji.",
            model=OpenAIChatCompletionsModel(
                model="speakleash/Bielik-4.5B-v3.0-Instruct",
                openai_client=openai_client,
            ),
            tools=[
                date_time_agent.as_tool(tool_name="date_time_agent", tool_description="Pomagasz z datą i czasem."), 
                haiku_agent.as_tool(tool_name="haiku_agent", tool_description="Generuje haiku ale tylko 5 zdaniowe.")
                ],
        )
        # Run the agent
        result = await Runner.run(orchestrator, "Powiedz jaka jest dzisiejsza data a potem wygeneruj haiku.")
        print(result.final_output)

if __name__ == "__main__":
    asyncio.run(main())

Oto współczesne haiku na podstawie dzisiejszej daty (2025-09-06):

**Obłoki suną**  
**Nad łąką w ciszę łka.**  
**Słońce powoli gaśnie.**  
**Czas do chaty wrócić.**  
**Noc w pełni zawsze wierzy.** 

Twoja ulubiona sytuacja z haiku została w nim uwzględniona!

        result = await Runner.run(agent, "....")
        print(result.final_output)

import asyncio
from openai import AsyncOpenAI
from agents import Agent, Runner, OpenAIChatCompletionsModel
from openai.types.responses import ResponseTextDeltaEvent
from agents.mcp import MCPServerStreamableHttp


mcp_helper_server = MCPServerStreamableHttp(
    name="My MCP Server",
    params={
        "url": "http://127.0.0.1:8001/mcp",
    },
)


async def main():
    openai_client = AsyncOpenAI(
        base_url="http://192.168.100.90:8000/v1",
        api_key="EMPTY",
    )
    async with mcp_helper_server:
        agent = Agent(
            name="Korepetytor",
            instructions="Pomagasz z datą i czasem.",
            model=OpenAIChatCompletionsModel(
                model="speakleash/Bielik-4.5B-v3.0-Instruct",
                openai_client=openai_client,
            ),
            mcp_servers=[mcp_helper_server],
        )

        result = Runner.run_streamed(agent, input="Jaka jest dzisiejsza data?")
        async for event in result.stream_events():
            if event.type == "raw_response_event" and isinstance(event.data, ResponseTextDeltaEvent):
                print(event.data.delta, end="", flush=True)

if __name__ == "__main__":
    asyncio.run(main())

npx assistant-ui@latest create
# jako nazwę projektu dajemy 'frontend'
# żeby to wyżej zadziałało musimy mieć zainstalowane nodejs

// next.config.ts
import type { NextConfig } from "next";

const nextConfig: NextConfig = {
  async rewrites() {
    return [
      {
        source: '/stream',
        destination: 'http://localhost:8002/stream',
      },
    ];
  },
};

export default nextConfig;

// assistant.tsx
export const Assistant = () => {
  const runtime = useChatRuntime({
    transport: new AssistantChatTransport({
      api: "/api/chat",
    }),
  });

// assistant.tsx
export const Assistant = () => {
  const runtime = useChatRuntime({
    transport: new AssistantChatTransport({
      api: "/stream",
    }),
  });

npm run dev

{
    "tools": {},
    "id": "LCot9rqP2KsYY95f",
    "messages": [
        {
            "id": "X3FlmLD7Nk2NVzH6",
            "role": "user",
            "parts": [
                {
                    "type": "text",
                    "text": "Jaka jest dziś data?"
                }
            ]
        }
    ],
    "trigger": "submit-message"
}

data: {"type": "event_type", "payload": "data"}

data: {"type": "start", "messageId": "msg_123"}
data: {"type": "finish"}

data: {"type": "text-start", "id": "text_block_id"}
data: {"type": "text-delta", "id": "text_block_id", "delta": "fragment"}
data: {"type": "text-end", "id": "text_block_id"}

data: {"type": "tool-input-start", "toolCallId": "call_123", "toolName": "weather"}
data: {"type": "tool-input-delta", "toolCallId": "call_123", "inputTextDelta": "London"}
data: {"type": "tool-input-available", "toolCallId": "call_123", "input": {"city": "London"}}
data: {"type": "tool-output-available", "toolCallId": "call_123", "output": {"temp": 15}}

data: {"type": "data-weather", "data": {"temperature": 20}}
data: {"type": "source-url", "sourceId": "url1", "url": "https://example.com"}
data: {"type": "file", "url": "https://example.com/file.pdf", "mediaType": "application/pdf"}

data: {"type": "error", "errorText": "Connection failed"}
data: {"type": "reasoning-start", "id": "reasoning_123"}
data: {"type": "reasoning-delta", "id": "reasoning_123", "delta": "thinking..."}

uv add fastapi

# models.py
from pydantic import BaseModel, Field
from enum import Enum


class MessageRole(str, Enum):
    USER = "user"
    ASSISTANT = "assistant"
    SYSTEM = "system"


# Frontend format models
class MessagePart(BaseModel):
    type: str
    text: str | None = None  # Make text optional to handle tool execution parts

    # Optional fields for tool execution data
    tool_call_id: str | None = Field(None, alias="toolCallId")
    state: str | None = None
    output: dict | None = None
    data: dict | None = None


class FrontendMessage(BaseModel):
    id: str
    role: MessageRole   
    parts: list[MessagePart]

    def get_text_content(self) -> str:
        """Extract text content from parts array."""
        return " ".join([part.text for part in self.parts if part.type == "text" and part.text])


class StreamRequest(BaseModel):
    tools: dict
    id: str
    messages: list[FrontendMessage]
    trigger: str

    def to_input_list(self) -> list[dict]:
        """Convert messages to input list format for session."""
        result = []
        for msg in self.messages:
            text_content = msg.get_text_content()
            # Only include messages that have actual text content
            if text_content:
                result.append({"content": text_content, "role": msg.role})
        return result

# streaming/sse_formatter.py
import json
import uuid


class SSEFormatter:
    """Server-Sent Events formatter for streaming responses for vercel ai-sdk v5."""

    @staticmethod
    def format_sse_event(data: dict) -> str:
        """Format data as Server-Sent Event."""
        return f"data: {json.dumps(data)}\n\n"

    @classmethod
    def format_message_start(cls, message_id: str = None) -> str:
        """Format message start event."""
        if message_id is None:
            message_id = f"msg_{uuid.uuid4().hex[:8]}"
        return cls.format_sse_event({"type": "start", "messageId": message_id})

    @classmethod
    def format_text_start(cls, message_id: str) -> str:
        """Format text start event."""
        return cls.format_sse_event({"type": "text-start", "id": message_id})

    @classmethod
    def format_text_delta(cls, message_id: str, delta: str) -> str:
        """Format text delta event."""
        delta = delta.replace("\u2022", "-")
        return cls.format_sse_event({"type": "text-delta", "id": message_id, "delta": delta})

    @classmethod
    def format_text_end(cls, message_id: str) -> str:
        """Format text end event."""
        return cls.format_sse_event({"type": "text-end", "id": message_id})

    @classmethod
    def format_tool_input_start(cls, tool_call_id: str, tool_name: str) -> str:
        """Format tool input start event."""
        return cls.format_sse_event({"type": "tool-input-start", "toolCallId": tool_call_id, "toolName": tool_name})

    @classmethod
    def format_tool_input_delta(cls, tool_call_id: str, input_text_delta: str) -> str:
        """Format tool input delta event."""
        return cls.format_sse_event(
            {"type": "tool-input-delta", "toolCallId": tool_call_id, "inputTextDelta": input_text_delta}
        )

    @classmethod
    def format_tool_input_available(cls, tool_call_id: str, tool_name: str, input_data: dict) -> str:
        """Format tool input available event."""
        return cls.format_sse_event(
            {"type": "tool-input-available", "toolCallId": tool_call_id, "toolName": tool_name, "input": input_data}
        )

    @classmethod
    def format_tool_output_available(cls, tool_call_id: str, output: dict) -> str:
        """Format tool output available event."""
        return cls.format_sse_event({"type": "tool-output-available", "toolCallId": tool_call_id, "output": output})

    @classmethod
    def format_start_step(cls, step: int) -> str:
        """Format start step event."""
        return cls.format_sse_event({"type": "start-step", "step": step})

    @classmethod
    def format_finish_step(cls, step: int, finish_reason: str = "tool-calls") -> str:
        """Format finish step event."""
        return cls.format_sse_event({"type": "finish-step", "step": step, "finishReason": finish_reason})

    @classmethod
    def format_error(cls, error: str) -> str:
        """Format error event."""
        return cls.format_sse_event({"type": "error", "error": error})

    @classmethod
    def format_finish(cls) -> str:
        """Format finish event."""
        return cls.format_sse_event({"type": "finish"})

    @classmethod
    def format_done(cls) -> str:
        """Format stream termination."""
        return "data: [DONE]\n\n"

    @classmethod
    def generate_tool_call_id(cls, tool_name: str = None) -> str:
        """Generate unique tool call ID."""
        prefix = f"{tool_name}_" if tool_name else "call_"
        return f"{prefix}{uuid.uuid4().hex[:8]}"

# streaming/event_processor.py
import json
import logging
from openai.types.responses import ResponseTextDeltaEvent

logger = logging.getLogger(__name__)
from .sse_formatter import SSEFormatter


class StreamEventProcessor:
    """Processes streaming events from the agent runner."""

    def __init__(self):
        self.message_id = SSEFormatter.generate_tool_call_id("msg")
        self.active_tool_calls = []  # Use list to maintain order
        self.text_streaming = False

    @classmethod
    async def process_events(cls, result):
        """Main event processing loop."""
        processor = cls()

        # Send message start
        yield SSEFormatter.format_message_start(processor.message_id)


        async for event in result.stream_events():
            if event.type == "raw_response_event":
                chunk = processor._handle_raw_response_event(event)
                if chunk:
                    yield chunk
            elif event.type == "run_item_stream_event":
                chunk = processor._handle_run_item_event(event)
                if chunk:
                    yield chunk

        # End any active text streaming
        if processor.text_streaming:
            yield SSEFormatter.format_text_end(processor.message_id)

        # Send finish event then completion
        yield SSEFormatter.format_finish()
        yield SSEFormatter.format_done()

    def _handle_raw_response_event(self, event) -> str:
        """Handle text delta events."""
        if isinstance(event.data, ResponseTextDeltaEvent):
            # Start text streaming if not already started
            if not self.text_streaming:
                self.text_streaming = True
                return SSEFormatter.format_text_start(self.message_id) + SSEFormatter.format_text_delta(
                    self.message_id, event.data.delta
                )
            else:
                return SSEFormatter.format_text_delta(self.message_id, event.data.delta)
        return ""

    def _handle_run_item_event(self, event) -> str:
        """Handle run item events (tool calls and outputs)."""
        if event.item.type == "tool_call_item":
            return self._handle_tool_call_event(event)
        elif event.item.type == "tool_call_output_item":
            return self._handle_tool_output_event(event)
        return ""

    def _handle_tool_call_event(self, event) -> str:
        """Handle tool call events."""
        # End text streaming if active
        result = ""
        if self.text_streaming:
            result += SSEFormatter.format_text_end(self.message_id)
            self.text_streaming = False

        tool_name = self._extract_tool_name(event.item)
        tool_call_id = SSEFormatter.generate_tool_call_id(tool_name)

        # Store tool call info for later output handling
        self.active_tool_calls.append({"id": tool_call_id, "name": tool_name, "item": event.item})

        logger.debug(f"Tool called: {tool_name} with ID: {tool_call_id}")

        # Get tool input if available
        tool_input = self._extract_tool_input(event.item)

        result += SSEFormatter.format_tool_input_start(tool_call_id, tool_name)

        if tool_input:
            # For simplicity, send the entire input as available immediately
            result += SSEFormatter.format_tool_input_available(tool_call_id, tool_name, tool_input)

        return result

    def _handle_tool_output_event(self, event) -> str:
        """Handle tool output events."""
        # Use FIFO approach - match outputs to calls in order they were made
        tool_call_info = None

        # Get the first (oldest) pending tool call
        if self.active_tool_calls:
            tool_call_info = self.active_tool_calls.pop(0)  # Remove from list once matched

        if not tool_call_info:
            # Ultimate fallback if no pending tool calls
            tool_call_id = SSEFormatter.generate_tool_call_id()
        else:
            tool_call_id = tool_call_info["id"]

        output = getattr(event.item, "output", "No output")
        logger.debug(f"Tool output received: {len(str(output))} characters")

        # Try to parse output as JSON, otherwise use as string
        try:
            if isinstance(output, str):
                output_data = {"result": output}
            else:
                output_data = {"result": str(output)}
        except Exception:
            output_data = {"result": str(output)}

        return SSEFormatter.format_tool_output_available(tool_call_id, output_data)

    @classmethod
    def _extract_tool_name(cls, item) -> str:
        """Extract tool name from various item structures."""
        if hasattr(item, "raw_item"):
            raw_item = item.raw_item
            if hasattr(raw_item, "function") and hasattr(raw_item.function, "name"):
                return raw_item.function.name
            if hasattr(raw_item, "name"):
                return raw_item.name
            if hasattr(raw_item, "tool_name"):
                return raw_item.tool_name
            if hasattr(raw_item, "type"):
                return raw_item.type
        return "Unknown Tool"

    @classmethod
    def _extract_tool_input(cls, item) -> dict:
        """Extract tool input from item structure."""
        if hasattr(item, "raw_item"):
            raw_item = item.raw_item
            if hasattr(raw_item, "function") and hasattr(raw_item.function, "arguments"):
                try:
                    # Parse JSON arguments
                    args_str = raw_item.function.arguments
                    if isinstance(args_str, str):
                        return json.loads(args_str)
                    return args_str
                except json.JSONDecodeError:
                    return {"arguments": args_str}
            if hasattr(raw_item, "arguments"):
                return raw_item.arguments
            if hasattr(raw_item, "input"):
                return raw_item.input
        return {}

from fastapi import FastAPI, Request
from fastapi.responses import StreamingResponse
import uvicorn
from streaming.event_processor import StreamEventProcessor
from models import StreamRequest
from openai import AsyncOpenAI
from agents import Agent, Runner, OpenAIChatCompletionsModel
from agents.mcp import MCPServerStreamableHttp


mcp_helper_server = MCPServerStreamableHttp(
    name="My MCP Server",
    params={
        "url": "http://127.0.0.1:8001/mcp",
    },
)
openai_client = AsyncOpenAI(
    base_url="http://192.168.100.90:8000/v1",
    api_key="EMPTY",
)


app = FastAPI()

@app.post("/stream")
async def stream(stream_request: StreamRequest, request: Request):
    async def generate():
        async with mcp_helper_server:
            agent = Agent(
                name="Korepetytor",
                instructions="Pomagasz z datą i czasem.",
                model=OpenAIChatCompletionsModel(
                    model="speakleash/Bielik-4.5B-v3.0-Instruct",  # Your model name
                    openai_client=openai_client,
                ),
                mcp_servers=[mcp_helper_server],
            )

            # Get the latest message from the request
            latest_message = stream_request.messages[-1]
            input_text = latest_message.get_text_content()

            # Run the agent
            result = Runner.run_streamed(agent, input=input_text)
            async for chunk in StreamEventProcessor.process_events(result):
                if chunk:
                    yield chunk

    headers = {
        "Cache-Control": "no-cache",
        "Connection": "keep-alive",
        "x-vercel-ai-ui-message-stream": "v1"
    }

    return StreamingResponse(generate(), media_type="text/event-stream", headers=headers)

if __name__ == "__main__":
    uvicorn.run("api_server:app", host="0.0.0.0", port=8002, reload=True)

from fastapi import FastAPI, Request
from fastapi.responses import StreamingResponse
import uvicorn
import uuid
from streaming.event_processor import StreamEventProcessor
from models import StreamRequest
from openai import AsyncOpenAI
from agents import Agent, Runner, OpenAIChatCompletionsModel, SQLiteSession
from agents.mcp import MCPServerStreamableHttp


mcp_helper_server = MCPServerStreamableHttp(
    name="My MCP Server",
    params={
        "url": "http://127.0.0.1:8001/mcp",
    },
)
openai_client = AsyncOpenAI(
    base_url="http://192.168.100.90:8000/v1",
    api_key="EMPTY",
)


app = FastAPI()

class StreamHandler:
    @classmethod
    async def _create_session(cls, stream_request):
        """Create and initialize a session with stream request.

        Returns:
            tuple: (session, latest_message)
        """
        session = SQLiteSession(f"conversation_{uuid.uuid4()}")
        latest_message = stream_request.messages.pop()

        # Filter out empty messages before adding to session
        session_messages = stream_request.to_input_list()
        print(session_messages)
        filtered_messages = cls._filter_empty_messages(session_messages)
        await session.add_items(items=filtered_messages)

        return session, latest_message

    @classmethod
    def _filter_empty_messages(cls, messages):
        """Filter out messages with empty content."""
        return [msg for msg in messages if msg.get('content', '').strip()]

@app.post("/stream")
async def stream(stream_request: StreamRequest, request: Request):
    async def generate():
        async with mcp_helper_server:
            # Create session with conversation history
            session, latest_message = await StreamHandler._create_session(stream_request)

            agent = Agent(
                name="Korepetytor",
                instructions="Pomagasz z datą i czasem.",
                model=OpenAIChatCompletionsModel(
                    model="speakleash/Bielik-4.5B-v3.0-Instruct",
                    openai_client=openai_client,
                ),
                mcp_servers=[mcp_helper_server],
            )

            # Get input text from latest message
            input_text = latest_message.get_text_content()
            # Run the agent with session
            result = Runner.run_streamed(
                agent, 
                input=input_text,
                session=session
            )
            async for chunk in StreamEventProcessor.process_events(result):
                if chunk:
                    yield chunk

    headers = {
        "Cache-Control": "no-cache",
        "Connection": "keep-alive",
        "x-vercel-ai-ui-message-stream": "v1"
    }

    return StreamingResponse(generate(), media_type="text/event-stream", headers=headers)

if __name__ == "__main__":
    uvicorn.run("api_server:app", host="0.0.0.0", port=8002, reload=True)

"use client";

import { AssistantCloud, AssistantRuntimeProvider } from '@assistant-ui/react'
import {
  useChatRuntime,
  AssistantChatTransport,
} from "@assistant-ui/react-ai-sdk";
import { Thread } from "@/components/assistant-ui/thread";
import {
  SidebarInset,
  SidebarProvider,
  SidebarTrigger,
} from "@/components/ui/sidebar";
import { ThreadListSidebar } from "@/components/assistant-ui/threadlist-sidebar";
import { Separator } from "@/components/ui/separator";
import {
  Breadcrumb,
  BreadcrumbItem,
  BreadcrumbLink,
  BreadcrumbList,
  BreadcrumbPage,
  BreadcrumbSeparator,
} from "@/components/ui/breadcrumb";

const cloud = new AssistantCloud({
  baseUrl: twojadres,
  anonymous: true
})


export const Assistant = () => {
  const runtime = useChatRuntime({
    transport: new AssistantChatTransport({
      api: "/stream",
    }),
    cloud
  });
  ...... reszta pliku