flock-core 0.5.0b19__py3-none-any.whl → 0.5.0b22__py3-none-any.whl

flock/components/evaluation/declarative_evaluation_component.py

@@ -1,7 +1,9 @@
 # src/flock/components/evaluation/declarative_evaluation_component.py
 """DeclarativeEvaluationComponent - DSPy-based evaluation using the unified component system."""
 
-from collections.abc import Generator
+from collections import OrderedDict
+from collections.abc import Callable, Generator
+from contextlib import nullcontext
 from typing import Any, Literal, override
 
 from temporalio import workflow
@@ -22,6 +24,73 @@ from flock.core.registry import flock_component
 logger = get_logger("components.evaluation.declarative")
 
 
+_live_patch_applied = False
+
+
+def _ensure_live_crop_above() -> None:
+    """Monkeypatch rich.live_render to support 'crop_above' overflow."""
+    global _live_patch_applied
+    if _live_patch_applied:
+        return
+    try:
+        from typing import Literal as _Literal
+
+        from rich import live_render as _lr
+    except Exception:
+        return
+
+    # Extend the accepted literal at runtime so type checks don't block the new option.
+    current_args = getattr(_lr.VerticalOverflowMethod, '__args__', ())
+    if 'crop_above' not in current_args:
+        _lr.VerticalOverflowMethod = _Literal['crop', 'crop_above', 'ellipsis', 'visible']  # type: ignore[assignment]
+
+    if getattr(_lr.LiveRender.__rich_console__, '_flock_crop_above', False):
+        _live_patch_applied = True
+        return
+
+    Segment = _lr.Segment
+    Text = _lr.Text
+    loop_last = _lr.loop_last
+
+    def _patched_rich_console(self, console, options):
+        renderable = self.renderable
+        style = console.get_style(self.style)
+        lines = console.render_lines(renderable, options, style=style, pad=False)
+        shape = Segment.get_shape(lines)
+
+        _, height = shape
+        max_height = options.size.height
+        if height > max_height:
+            if self.vertical_overflow == 'crop':
+                lines = lines[: max_height]
+                shape = Segment.get_shape(lines)
+            elif self.vertical_overflow == 'crop_above':
+                lines = lines[-max_height:]
+                shape = Segment.get_shape(lines)
+            elif self.vertical_overflow == 'ellipsis' and max_height > 0:
+                lines = lines[: (max_height - 1)]
+                overflow_text = Text(
+                    '...',
+                    overflow='crop',
+                    justify='center',
+                    end='',
+                    style='live.ellipsis',
+                )
+                lines.append(list(console.render(overflow_text)))
+                shape = Segment.get_shape(lines)
+        self._shape = shape
+
+        new_line = Segment.line()
+        for last, line in loop_last(lines):
+            yield from line
+            if not last:
+                yield new_line
+
+    _patched_rich_console._flock_crop_above = True  # type: ignore[attr-defined]
+    _lr.LiveRender.__rich_console__ = _patched_rich_console
+    _live_patch_applied = True
+
+
 class DeclarativeEvaluationConfig(AgentComponentConfig):
     """Configuration for the DeclarativeEvaluationComponent."""
 
@@ -32,6 +101,10 @@ class DeclarativeEvaluationConfig(AgentComponentConfig):
     max_tokens: int = 32000
     max_retries: int = 3
     max_tool_calls: int = 10
+    no_output: bool = Field(
+        default=False,
+        description="Disable output from the underlying DSPy program.",
+    )
     stream: bool = Field(
         default=False,
         description="Enable streaming output from the underlying DSPy program.",
@@ -52,6 +125,11 @@ class DeclarativeEvaluationConfig(AgentComponentConfig):
         default=None,
         description="Extraction LM for TwoStepAdapter when adapter='two_step'",
     )
+    stream_callbacks: list[Callable[..., Any] | Any] | None = None
+    stream_vertical_overflow: Literal["crop", "ellipsis", "crop_above", "visible"] = Field(
+        default="crop_above",
+        description=("Rich Live vertical overflow strategy; select how tall output is handled; 'crop_above' keeps the most recent rows visible."),
+    )
     kwargs: dict[str, Any] = Field(default_factory=dict)
 
 
@@ -165,7 +243,7 @@ class DeclarativeEvaluationComponent(
                 return await self._execute_standard(agent_task, inputs, agent)
 
     async def _execute_streaming(self, signature, agent_task, inputs: dict[str, Any], agent: Any, console) -> dict[str, Any]:
-        """Execute DSPy program in streaming mode (from original implementation)."""
+        """Execute DSPy program in streaming mode with rich table updates."""
         logger.info(f"Evaluating agent '{agent.name}' with async streaming.")
 
         if not callable(agent_task):
@@ -177,7 +255,9 @@ class DeclarativeEvaluationComponent(
         try:
             for name, field in signature.output_fields.items():
                 if field.annotation is str:
-                    listeners.append(dspy.streaming.StreamListener(signature_field_name=name))
+                    listeners.append(
+                        dspy.streaming.StreamListener(signature_field_name=name)
+                    )
         except Exception:
             listeners = []
 
@@ -188,56 +268,148 @@ class DeclarativeEvaluationComponent(
         )
         stream_generator: Generator = streaming_task(**inputs)
 
-        console.print("\n")
+        from collections import defaultdict
+
+        from rich.live import Live
+
+        signature_order = []
+        try:
+            signature_order = list(signature.output_fields.keys())
+        except Exception:
+            signature_order = []
+
+        display_data: OrderedDict[str, Any] = OrderedDict()
+        for key in inputs:
+            display_data[key] = inputs[key]
+
+        for field_name in signature_order:
+            if field_name not in display_data:
+                display_data[field_name] = ""
+
+        stream_buffers: defaultdict[str, list[str]] = defaultdict(list)
+
+        formatter = theme_dict = styles = agent_label = None
+        live_cm = nullcontext()
+        overflow_mode = self.config.stream_vertical_overflow
+        initial_panel = None
+        if not self.config.no_output:
+            _ensure_live_crop_above()
+            (
+                formatter,
+                theme_dict,
+                styles,
+                agent_label,
+            ) = self._prepare_stream_formatter(agent)
+            initial_panel = formatter.format_result(
+                display_data, agent_label, theme_dict, styles
+            )
+            live_cm = Live(
+                initial_panel,
+                console=console,
+                refresh_per_second=400,
+                transient=False,
+                vertical_overflow=overflow_mode,
+            )
+
         final_result: dict[str, Any] | None = None
-        async for value in stream_generator:
-            # Handle DSPy streaming artifacts
-            try:
-                from dspy.streaming import StatusMessage, StreamResponse
-                from litellm import ModelResponseStream
-                import dspy as _d
-            except Exception:
-                StatusMessage = object  # type: ignore
-                StreamResponse = object  # type: ignore
-                ModelResponseStream = object  # type: ignore
-                _d = None
-
-            if isinstance(value, StatusMessage):
-                # Optionally surface status to console
-                console.print(f"[status] {getattr(value, 'message', '')}")
-                continue
-            if isinstance(value, StreamResponse):
-                token = getattr(value, "token", None)
-                if token:
-                    console.print(token, end="")
-                continue
-            if isinstance(value, ModelResponseStream):
-                # Raw model chunk; print minimal content if available for debug
+
+        with live_cm as live:
+            def _refresh_panel() -> None:
+                if formatter is None or live is None:
+                    return
+                live.update(
+                    formatter.format_result(
+                        display_data, agent_label, theme_dict, styles
+                    )
+                )
+
+            async for value in stream_generator:
                 try:
-                    chunk = value
-                    text = chunk.choices[0].delta.content or ""
-                    if text:
-                        console.print(text, end="")
+                    import dspy as _d
+                    from dspy.streaming import StatusMessage, StreamResponse
+                    from litellm import ModelResponseStream
                 except Exception:
-                    pass
-                continue
-            if _d and isinstance(value, _d.Prediction):
-                # Final prediction
-                result_dict, cost, lm_history = self._process_result(value, inputs)
-                self._cost = cost
-                self._lm_history = lm_history
-                final_result = result_dict
-
-        console.print("\n")
+                    StatusMessage = object  # type: ignore
+                    StreamResponse = object  # type: ignore
+                    ModelResponseStream = object  # type: ignore
+                    _d = None
+
+                if isinstance(value, StatusMessage):
+                    message = getattr(value, "message", "")
+                    if message and live is not None:
+                        live.console.log(f"[status] {message}")
+                    continue
+
+                if isinstance(value, StreamResponse):
+                    for callback in self.config.stream_callbacks or []:
+                        try:
+                            callback(value)
+                        except Exception as e:
+                            logger.warning(f"Stream callback error: {e}")
+                    token = getattr(value, "chunk", None)
+                    signature_field = getattr(value, "signature_field_name", None)
+                    if signature_field:
+                        if signature_field not in display_data:
+                            display_data[signature_field] = ""
+                        if token:
+                            stream_buffers[signature_field].append(str(token))
+                            display_data[signature_field] = "".join(
+                                stream_buffers[signature_field]
+                            )
+                        if formatter is not None:
+                            _refresh_panel()
+                    continue
+
+                if isinstance(value, ModelResponseStream):
+                    try:
+                        chunk = value
+                        text = chunk.choices[0].delta.content or ""
+                        if text and live is not None:
+                            live.console.log(text)
+                    except Exception:
+                        pass
+                    continue
+
+                if _d and isinstance(value, _d.Prediction):
+                    result_dict, cost, lm_history = self._process_result(
+                        value, inputs
+                    )
+                    self._cost = cost
+                    self._lm_history = lm_history
+                    final_result = result_dict
+
+                    if formatter is not None:
+                        ordered_final = OrderedDict()
+                        for key in inputs:
+                            if key in final_result:
+                                ordered_final[key] = final_result[key]
+                        for field_name in signature_order:
+                            if field_name in final_result:
+                                ordered_final[field_name] = final_result[field_name]
+                        for key, val in final_result.items():
+                            if key not in ordered_final:
+                                ordered_final[key] = val
+                        display_data.clear()
+                        display_data.update(ordered_final)
+                        _refresh_panel()
+
         if final_result is None:
             raise RuntimeError("Streaming did not yield a final prediction.")
-        final_result = self.filter_reasoning(
+
+        filtered_result = self.filter_reasoning(
             final_result, self.config.include_reasoning
         )
-        return self.filter_thought_process(
-            final_result, self.config.include_thought_process
+        filtered_result = self.filter_thought_process(
+            filtered_result, self.config.include_thought_process
         )
 
+        if not self.config.no_output:
+            context = getattr(agent, "context", None)
+            if context is not None:
+                context.state["_flock_stream_live_active"] = True
+
+        return filtered_result
+
     async def _execute_standard(self, agent_task, inputs: dict[str, Any], agent: Any) -> dict[str, Any]:
         """Execute DSPy program in standard mode (from original implementation)."""
         logger.info(f"Evaluating agent '{agent.name}' without streaming.")
@@ -261,6 +433,62 @@ class DeclarativeEvaluationComponent(
             )
             raise RuntimeError(f"Evaluation failed: {e}") from e
 
+    def _prepare_stream_formatter(
+        self, agent: Any
+    ) -> tuple[Any, dict[str, Any], dict[str, Any], str]:
+        """Build formatter + theme metadata for streaming tables."""
+        import pathlib
+
+        from flock.core.logging.formatters.themed_formatter import (
+            ThemedAgentResultFormatter,
+            create_pygments_syntax_theme,
+            get_default_styles,
+            load_syntax_theme_from_file,
+            load_theme_from_file,
+        )
+        from flock.core.logging.formatters.themes import OutputTheme
+
+        stream_theme = OutputTheme.afterglow
+        output_component = None
+        try:
+            output_component = agent.get_component("output_formatter")
+        except Exception:
+            output_component = None
+        if output_component and getattr(output_component, "config", None):
+            stream_theme = getattr(
+                output_component.config, "theme", stream_theme
+            )
+
+        formatter = ThemedAgentResultFormatter(theme=stream_theme)
+
+        themes_dir = pathlib.Path(__file__).resolve().parents[2] / "themes"
+        theme_filename = stream_theme.value
+        if not theme_filename.endswith(".toml"):
+            theme_filename = f"{theme_filename}.toml"
+        theme_path = themes_dir / theme_filename
+
+        try:
+            theme_dict = load_theme_from_file(theme_path)
+        except Exception:
+            fallback_path = themes_dir / "afterglow.toml"
+            theme_dict = load_theme_from_file(fallback_path)
+            theme_path = fallback_path
+
+        styles = get_default_styles(theme_dict)
+        formatter.styles = styles
+        try:
+            syntax_theme = load_syntax_theme_from_file(theme_path)
+            formatter.syntax_style = create_pygments_syntax_theme(syntax_theme)
+        except Exception:
+            formatter.syntax_style = None
+
+        model_label = getattr(agent, "model", None) or self.config.model or ""
+        agent_label = (
+            agent.name if not model_label else f"{agent.name} - {model_label}"
+        )
+
+        return formatter, theme_dict, styles, agent_label
+
     def filter_thought_process(
         self, result_dict: dict[str, Any], include_thought_process: bool
     ) -> dict[str, Any]:

flock/components/utility/output_utility_component.py

@@ -146,11 +146,23 @@ class OutputUtilityComponent(UtilityComponent):
         """Format and display the output."""
         logger.debug("Formatting and displaying output")
 
+        streaming_live_handled = False
+        if context:
+            streaming_live_handled = bool(
+                context.get_variable("_flock_stream_live_active", False)
+            )
+            if streaming_live_handled:
+                context.state.pop("_flock_stream_live_active", None)
+
         # Determine if output should be suppressed
         is_silent = self.config.no_output or (
             context and context.get_variable(FLOCK_BATCH_SILENT_MODE, False)
         )
 
+        if streaming_live_handled:
+            logger.debug("Skipping static table because streaming rendered live output.")
+            return result
+
         if is_silent:
             logger.debug("Output suppressed (config or batch silent mode).")
             return result  # Skip console output

flock/core/agent/default_agent.py

@@ -8,7 +8,7 @@ and composes the standard components under the hood.
 from __future__ import annotations
 
 from collections.abc import Callable
-from typing import Any
+from typing import Any, Literal
 
 from flock.components.utility.metrics_utility_component import (
     MetricsUtilityComponent,
@@ -46,7 +46,9 @@ class DefaultAgent(FlockAgent):
         max_tokens: int | None = None,
         max_tool_calls: int = 0,
         max_retries: int = 2,
-        stream: bool = False,
+        stream: bool = True,
+        stream_callbacks: list[Callable[..., Any] | Any] | None = None,
+        stream_vertical_overflow: Literal["crop", "ellipsis", "crop_above", "visible"] = "crop_above",
         include_thought_process: bool = False,
         include_reasoning: bool = False,
         # Output utility parameters
@@ -84,6 +86,8 @@ class DefaultAgent(FlockAgent):
             max_tool_calls: Maximum number of tool calls per evaluation
             max_retries: Maximum retries for failed LLM calls
             stream: Whether to enable streaming responses
+            stream_callbacks: Optional callbacks invoked with each streaming chunk
+            stream_vertical_overflow: Rich Live overflow handling ('ellipsis', 'crop', 'crop_above', 'visible')
             include_thought_process: Include reasoning in output
             include_reasoning: Include detailed reasoning steps
             enable_rich_tables: Enable rich table formatting for output
@@ -119,7 +123,10 @@ class DefaultAgent(FlockAgent):
             temperature=temperature,
             max_tool_calls=max_tool_calls,
             max_retries=max_retries,
+            no_output=no_output,
             stream=stream,
+            stream_callbacks=stream_callbacks,
+            stream_vertical_overflow=stream_vertical_overflow,
             include_thought_process=include_thought_process,
             include_reasoning=include_reasoning,
         )

flock/core/util/cli_helper.py

@@ -51,7 +51,7 @@ def init_console(clear_screen: bool = True, show_banner: bool = True, model: str
 │ ▒█▀▀▀ █░░ █▀▀█ █▀▀ █░█ │
 │ ▒█▀▀▀ █░░ █░░█ █░░ █▀▄ │
 │ ▒█░░░ ▀▀▀ ▀▀▀▀ ▀▀▀ ▀░▀ │
-╰━━━━━━━━v{__version__}━━━━━━━━╯
+╰━━━━━━━━v{__version__}━━━━━━━╯
 🦆     🐤    🐧     🐓
 """,
         justify="center",
@@ -63,11 +63,11 @@ def init_console(clear_screen: bool = True, show_banner: bool = True, model: str
     if show_banner:
         console.print(banner_text)
         console.print(
-            "[italic]'Magpie'[/] milestone - [bold]white duck GmbH[/] - [cyan]https://whiteduck.de[/]\n"
+            "[italic]'Kea'[/] milestone - [bold]white duck GmbH[/] - [cyan]https://whiteduck.de[/]\n"
         )
 
     if model:
-        console.print(f"[italic]Global Model:[/] {model}")
+        console.print(f"[italic]Global Model:[/] {model}\n")
 
 
 def display_banner_no_version():

flock/webapp/app/api/execution.py

@@ -1,6 +1,8 @@
 # src/flock/webapp/app/api/execution.py
+import asyncio
 import html
 import json
+import uuid
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Literal
 
@@ -12,7 +14,7 @@ from fastapi import (  # Ensure Form and HTTPException are imported
     Request,
 )
 from fastapi.encoders import jsonable_encoder
-from fastapi.responses import FileResponse, HTMLResponse
+from fastapi.responses import FileResponse, HTMLResponse, StreamingResponse
 from fastapi.templating import Jinja2Templates
 from werkzeug.utils import secure_filename
 
@@ -40,10 +42,6 @@ from flock.webapp.app.dependencies import (
 )
 
 # Service function now takes app_state
-from flock.webapp.app.services.flock_service import (
-    run_current_flock_service,
-    # get_current_flock_instance IS NO LONGER IMPORTED
-)
 from flock.webapp.app.services.sharing_store import SharedLinkStoreInterface
 
 router = APIRouter()
@@ -59,6 +57,183 @@ def markdown_filter(text):
 templates.env.filters["markdown"] = markdown_filter
 
 
+class ExecutionStreamManager:
+    """In-memory tracker for live streaming sessions."""
+
+    def __init__(self) -> None:
+        self._sessions: dict[str, asyncio.Queue] = {}
+        self._lock = asyncio.Lock()
+
+    async def create_session(self) -> tuple[str, asyncio.Queue]:
+        run_id = uuid.uuid4().hex
+        queue: asyncio.Queue = asyncio.Queue()
+        async with self._lock:
+            self._sessions[run_id] = queue
+        return run_id, queue
+
+    async def get_queue(self, run_id: str) -> asyncio.Queue | None:
+        async with self._lock:
+            return self._sessions.get(run_id)
+
+    async def remove_session(self, run_id: str) -> None:
+        async with self._lock:
+            self._sessions.pop(run_id, None)
+
+
+execution_stream_manager = ExecutionStreamManager()
+stream_logger = get_flock_logger("webapp.execution.stream")
+
+
+async def _execute_agent_with_stream(
+    run_id: str,
+    queue: asyncio.Queue,
+    start_agent_name: str,
+    inputs: dict[str, Any],
+    app_state: Any,
+    template_context: dict[str, Any],
+) -> None:
+    """Run the requested agent while forwarding streaming chunks to the UI."""
+
+    completed = False
+
+    def emit(payload: dict[str, Any]) -> None:
+        try:
+            queue.put_nowait(payload)
+        except asyncio.QueueFull:
+            stream_logger.warning(
+                "Dropping streaming payload for run %s due to full queue", run_id
+            )
+
+    async def terminate_with_error(message: str) -> None:
+        emit({"type": "error", "message": message})
+        await finalize_stream()
+
+    async def finalize_stream() -> None:
+        nonlocal completed
+        if not completed:
+            emit({"type": "complete"})
+            completed = True
+        await queue.put(None)
+
+    current_flock: "Flock | None" = getattr(app_state, "flock_instance", None)
+    run_store: RunStore | None = getattr(app_state, "run_store", None)
+
+    if not current_flock:
+        stream_logger.error("Stream run aborted: no flock loaded in app state.")
+        await terminate_with_error("No Flock loaded in the application.")
+        return
+
+    agent = current_flock.agents.get(start_agent_name)
+    if not agent:
+        stream_logger.error(
+            "Stream run aborted: agent '%s' not found in flock '%s'.",
+            start_agent_name,
+            current_flock.name,
+        )
+        await terminate_with_error(
+            f"Agent '{html.escape(str(start_agent_name))}' not found."
+        )
+        return
+
+    evaluator = getattr(agent, "evaluator", None)
+    previous_callbacks: list[Any] | None = None
+    original_stream_setting: bool | None = None
+
+    if evaluator is not None:
+        previous_callbacks = list(evaluator.config.stream_callbacks or [])
+        original_stream_setting = getattr(evaluator.config, "stream", False)
+
+        def stream_callback(message: Any) -> None:
+            chunk = getattr(message, "chunk", None)
+            signature_field = getattr(message, "signature_field_name", None)
+            if chunk is None:
+                return
+            emit(
+                {
+                    "type": "token",
+                    "chunk": str(chunk),
+                    "field": signature_field,
+                }
+            )
+
+        evaluator.config.stream_callbacks = [
+            *previous_callbacks,
+            stream_callback,
+        ]
+        if not original_stream_setting:
+            evaluator.config.stream = True
+    else:
+        emit(
+            {
+                "type": "status",
+                "message": "Streaming not available for this agent; results will appear when the run completes.",
+            }
+        )
+
+    try:
+        emit(
+            {
+                "type": "status",
+                "message": f"Running agent '{start_agent_name}'...",
+            }
+        )
+        result_data = await current_flock.run_async(
+            agent=start_agent_name, input=inputs, box_result=False
+        )
+
+        if run_store and hasattr(run_store, "add_run_details"):
+            run_identifier = (
+                result_data.get("run_id", run_id)
+                if isinstance(result_data, dict)
+                else run_id
+            )
+            run_store.add_run_details(
+                run_id=run_identifier,
+                agent_name=start_agent_name,
+                inputs=inputs,
+                outputs=result_data,
+            )
+
+        encoded_result = jsonable_encoder(result_data)
+        raw_json = json.dumps(
+            encoded_result, indent=2, ensure_ascii=False
+        ).replace("\\n", "\n")
+
+        template = templates.get_template("partials/_results_display.html")
+        final_html = template.render(
+            {
+                **template_context,
+                "result": result_data,
+                "result_raw_json": raw_json,
+            }
+        )
+
+        emit(
+            {
+                "type": "final",
+                "html": final_html,
+                "result": encoded_result,
+                "raw_json": raw_json,
+            }
+        )
+    except Exception as exc:  # pragma: no cover - defensive logging
+        stream_logger.error(
+            "Streamed execution for agent '%s' failed: %s",
+            start_agent_name,
+            exc,
+            exc_info=True,
+        )
+        await terminate_with_error(f"An error occurred: {html.escape(str(exc))}")
+        return
+    finally:
+        if evaluator is not None:
+            if previous_callbacks is not None:
+                evaluator.config.stream_callbacks = previous_callbacks
+            if original_stream_setting is not None:
+                evaluator.config.stream = original_stream_setting
+    await finalize_stream()
+
+
 @router.get("/htmx/execution-form-content", response_class=HTMLResponse)
 async def htmx_get_execution_form_content(
     request: Request,
@@ -203,35 +378,68 @@ async def htmx_run_flock(
                 f"<p class='error'>Error processing inputs for {html.escape(str(start_agent_name))}: {html.escape(str(e_parse))}</p>"
             )
 
-    result_data = await run_current_flock_service(
-        start_agent_name, inputs, request.app.state
-    )
+    run_id, queue = await execution_stream_manager.create_session()
+    stream_url = str(request.url_for("htmx_stream_run", run_id=run_id))
+    root_path = request.scope.get("root_path", "")
 
-    raw_json_for_template = json.dumps(
-        jsonable_encoder(
-            result_data
-        ),  # ← converts every nested BaseModel, datetime, etc.
-        indent=2,
-        ensure_ascii=False,
+    template_context = {
+        "request": request,
+        "feedback_endpoint": f"{root_path}/ui/api/flock/htmx/feedback",
+        "share_id": None,
+        "flock_name": current_flock_from_state.name,
+        "agent_name": start_agent_name,
+        "flock_definition": current_flock_from_state.to_yaml(),
+    }
+
+    asyncio.create_task(
+        _execute_agent_with_stream(
+            run_id=run_id,
+            queue=queue,
+            start_agent_name=start_agent_name,
+            inputs=inputs,
+            app_state=request.app.state,
+            template_context=template_context,
+        )
     )
-    # Unescape newlines for proper display in HTML <pre> tag
-    result_data_raw_json_str = raw_json_for_template.replace("\\n", "\n")
-    root_path = request.scope.get("root_path", "")
+
     return templates.TemplateResponse(
-        "partials/_results_display.html",
+        "partials/_streaming_results_container.html",
         {
             "request": request,
-            "result": result_data,
-            "result_raw_json": result_data_raw_json_str,
-            "feedback_endpoint": f"{root_path}/ui/api/flock/htmx/feedback",
-            "share_id": None,
-            "flock_name": current_flock_from_state.name,
+            "run_id": run_id,
+            "stream_url": stream_url,
             "agent_name": start_agent_name,
-            "flock_definition": current_flock_from_state.to_yaml(),
+            "flock_name": current_flock_from_state.name,
         },
     )
 
 
+@router.get("/htmx/run-stream/{run_id}")
+async def htmx_stream_run(run_id: str):
+    """Server-Sent Events endpoint streaming live agent output."""
+
+    queue = await execution_stream_manager.get_queue(run_id)
+    if queue is None:
+        return HTMLResponse(
+            "<p class='error'>Streaming session not found or already closed.</p>",
+            status_code=404,
+        )
+
+    async def event_generator():
+        try:
+            while True:
+                payload = await queue.get()
+                if payload is None:
+                    yield "event: close\ndata: {}\n\n"
+                    break
+                data = json.dumps(payload, ensure_ascii=False)
+                yield f"data: {data}\n\n"
+        finally:
+            await execution_stream_manager.remove_session(run_id)
+
+    return StreamingResponse(event_generator(), media_type="text/event-stream")
+
+
 # --- NEW ENDPOINT FOR SHARED RUNS ---
 @router.post("/htmx/run-shared", response_class=HTMLResponse)
 async def htmx_run_shared_flock(

flock/webapp/templates/partials/_streaming_results_container.html

@@ -0,0 +1,195 @@
+<div id="streaming-results-wrapper"
+     data-run-id="{{ run_id }}"
+     data-stream-url="{{ stream_url }}"
+     data-target-id="results-display"
+     data-agent-name="{{ agent_name }}">
+    <header style="margin-bottom: 0.75rem;">
+        <h5 style="margin: 0;">Streaming {{ agent_name }}</h5>
+        <p style="margin: 0; color: var(--pico-muted-color);">Live output appears below while the agent runs.</p>
+    </header>
+
+    <p class="error" data-role="error" hidden></p>
+    <div class="stream-output" data-role="output" style="min-height: 8rem; white-space: normal; word-break: break-word; font-family: var(--pico-code-font-family, monospace);">Connecting to agent…</div>
+    <div data-role="progress" style="margin-top: 0.5rem;" role="status">
+        <progress indeterminate></progress> Streaming response…
+    </div>
+</div>
+
+<script>
+(function () {
+    const script = document.currentScript;
+    if (!script) {
+        return;
+    }
+    const wrapper = script.previousElementSibling;
+    if (!(wrapper instanceof HTMLElement)) {
+        return;
+    }
+    if (wrapper.dataset.streamInit === '1') {
+        return;
+    }
+    wrapper.dataset.streamInit = '1';
+
+    const streamUrl = wrapper.dataset.streamUrl;
+    const runId = wrapper.dataset.runId;
+    const targetId = wrapper.dataset.targetId || 'results-display';
+
+    const outputEl = wrapper.querySelector('[data-role="output"]');
+    const errorEl = wrapper.querySelector('[data-role="error"]');
+    const progressEl = wrapper.querySelector('[data-role="progress"]');
+
+    if (!streamUrl || !runId || !(outputEl instanceof HTMLElement)) {
+        if (errorEl instanceof HTMLElement) {
+            errorEl.textContent = 'Streaming setup failed due to missing metadata.';
+            errorEl.hidden = false;
+        }
+        if (progressEl instanceof HTMLElement) {
+            progressEl.hidden = true;
+        }
+        return;
+    }
+
+    let plainText = outputEl instanceof HTMLElement ? outputEl.textContent || '' : '';
+    let source;
+    const fieldValues = new Map();
+    let latestStatus = '';
+
+    function escapeHtml(value) {
+        return value.replace(/[&<>"']/g, (char) => ({
+            '&': '&amp;',
+            '<': '&lt;',
+            '>': '&gt;',
+            '"': '&quot;',
+            "'": '&#39;',
+        })[char]);
+    }
+
+    function renderTableCell(value) {
+        return escapeHtml(value).replace(/\n/g, '<br>');
+    }
+
+    function renderStream() {
+        if (!(outputEl instanceof HTMLElement)) {
+            return;
+        }
+        if (fieldValues.size > 0) {
+            outputEl.style.whiteSpace = 'normal';
+            let rows = '';
+            fieldValues.forEach((value, field) => {
+                rows += `<tr><td class="stream-field" style="white-space: nowrap; padding-right: 1rem; vertical-align: top;">${escapeHtml(field)}</td><td>${renderTableCell(value)}</td></tr>`;
+            });
+            if (latestStatus) {
+                rows += `<tr class="stream-status"><td class="stream-field" style="white-space: nowrap; padding-right: 1rem; vertical-align: top;">status</td><td>${escapeHtml(latestStatus)}</td></tr>`;
+            }
+            outputEl.innerHTML = `<table class="structured-table streaming-table" style="width:100%; border-collapse: collapse; table-layout: auto;"><tbody>${rows}</tbody></table>`;
+        } else {
+            outputEl.style.whiteSpace = 'pre-wrap';
+            outputEl.textContent = plainText;
+        }
+    }
+
+    function showError(message) {
+        if (errorEl instanceof HTMLElement) {
+            errorEl.textContent = message;
+            errorEl.hidden = false;
+        }
+        if (progressEl instanceof HTMLElement) {
+            progressEl.hidden = true;
+        }
+    }
+
+    function closeStream() {
+        if (source) {
+            source.close();
+            source = undefined;
+        }
+        if (progressEl instanceof HTMLElement) {
+            progressEl.hidden = true;
+        }
+        renderStream();
+    }
+
+    function renderFinal(html, rawJson) {
+        const target = document.getElementById(targetId);
+        if (!target) {
+            return;
+        }
+        target.innerHTML = html;
+        if (window.htmx) {
+            window.htmx.process(target);
+        }
+        if (window.Prism) {
+            window.Prism.highlightAllUnder(target);
+        }
+        if (outputEl instanceof HTMLElement) {
+            outputEl.textContent = '';
+        }
+    }
+
+    try {
+        source = new EventSource(streamUrl);
+    } catch (err) {
+        console.error('Failed to start EventSource', err);
+        showError('Failed to connect for streaming.');
+        return;
+    }
+
+    source.onmessage = (event) => {
+        if (!event.data) {
+            return;
+        }
+        let payload;
+        try {
+            payload = JSON.parse(event.data);
+        } catch (err) {
+            console.warn('Unable to parse streaming payload', err);
+            return;
+        }
+
+        switch (payload.type) {
+            case 'token':
+                if (typeof payload.chunk === 'string') {
+                    if (payload.field) {
+                        const existing = fieldValues.get(payload.field) || '';
+                        fieldValues.set(payload.field, existing + payload.chunk);
+                    } else {
+                        plainText = (plainText === 'Connecting to agent…' ? '' : plainText) + payload.chunk;
+                    }
+                    renderStream();
+                }
+                break;
+            case 'status':
+                if (payload.message) {
+                    latestStatus = payload.message;
+                    if (fieldValues.size === 0) {
+                        plainText = (plainText === 'Connecting to agent…' ? '' : plainText);
+                        if (plainText && !plainText.endsWith('\n')) {
+                            plainText += '\n';
+                        }
+                        plainText += payload.message + '\n';
+                    }
+                    renderStream();
+                }
+                break;
+            case 'error':
+                showError(payload.message || 'An unexpected error occurred while streaming.');
+                closeStream();
+                break;
+            case 'final':
+                closeStream();
+                renderFinal(payload.html || '', payload.raw_json || payload.rawJson);
+                break;
+            case 'complete':
+                closeStream();
+                break;
+            default:
+                break;
+        }
+    };
+
+    source.onerror = () => {
+        showError('Connection lost while streaming.');
+        closeStream();
+    };
+})();
+</script>

{flock_core-0.5.0b19.dist-info → flock_core-0.5.0b22.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flock-core
-Version: 0.5.0b19
+Version: 0.5.0b22
 Summary: Declarative LLM Orchestration at Scale
 Author-email: Andre Ratzenberger <andre.ratzenberger@whiteduck.de>
 License-File: LICENSE

{flock_core-0.5.0b19.dist-info → flock_core-0.5.0b22.dist-info}/RECORD

@@ -27,7 +27,7 @@ flock/cli/yaml_editor.py,sha256=K3N0bh61G1TSDAZDnurqW9e_-hO6CtSQKXQqlDhCjVo,1252
 flock/cli/assets/release_notes.md,sha256=bqnk50jxM3w5uY44Dc7MkdT8XmRREFxrVBAG9XCOSSU,4896
 flock/components/__init__.py,sha256=qDcaP0O7_b5RlUEXluqwskpKCkhM73kSMeNXReze63M,963
 flock/components/evaluation/__init__.py,sha256=_M3UlRFeNN90fEny6byt5VdLDE5o5khbd0EPT0o9S9k,303
-flock/components/evaluation/declarative_evaluation_component.py,sha256=OXuJlH7TTQAy3upg3K68oSr4cS89XlSty2GeM3l6fDs,11606
+flock/components/evaluation/declarative_evaluation_component.py,sha256=a-RPCcpdXq66XFSPYite2OYwC_5Cnckf4VQK1ie1E-w,20269
 flock/components/routing/__init__.py,sha256=BH_pFm9T6bUuf8HH4byDJ0dO0fzEVHv9m-ghUdDVdm0,542
 flock/components/routing/conditional_routing_component.py,sha256=WqZLMz-0Dhfb97xvttNrJCIVe6FNMLEQ2m4KQTDpIbI,21374
 flock/components/routing/default_routing_component.py,sha256=ZHt2Kjf-GHB5n7evU5NSGeQJ1Wuims5soeMswqaUb1E,3370
@@ -35,7 +35,7 @@ flock/components/routing/llm_routing_component.py,sha256=SAaOFjlnhnenM6QEBn3WIpj
 flock/components/utility/__init__.py,sha256=JRj932upddjzZMWs1avOupEFr_GZNu21ac66Rhw_XgY,532
 flock/components/utility/memory_utility_component.py,sha256=26Io61bbCGjD8UQ4BltMA5RLkMXp8tQoQmddXbQSrzA,20183
 flock/components/utility/metrics_utility_component.py,sha256=Mck_sFCkfXvNpoSgW2N_WOLnjxazzx8jh79tIx5zJhw,24635
-flock/components/utility/output_utility_component.py,sha256=c4K_PL3bGqdyy_v6dnOrmTqV-MkWKAB2w0HS8kzg82k,7613
+flock/components/utility/output_utility_component.py,sha256=TdHhY5qJJDUk-_LK54zAFMSG_Zafe-UiEkwiJwPjfh0,8063
 flock/core/__init__.py,sha256=OkjsVjRkAB-I6ibeTKVikZ3MxLIcTIzWKphHTbzbr7s,3231
 flock/core/flock.py,sha256=wRycQlGeaq-Vd75mFpPe02qyWTOEyXthT873iBhA3TI,23388
 flock/core/flock_agent.py,sha256=4Vdhyk-rdsPEuN3xYBsLBBsfpklad6bNj_it9r6XIDc,12868
@@ -43,7 +43,7 @@ flock/core/flock_factory.py,sha256=Z6GJpYXN9_DXuOqvBH9ir0SMoUw78DkWhrhkm90luAQ,2
 flock/core/flock_scheduler.py,sha256=ng_s7gyijmc-AmYvBn5rtg61CSUZiIkXPRSlA1xO6VQ,8766
 flock/core/flock_server_manager.py,sha256=tM_nOs37vAbEvxmhwy_DL2JPvgFViWroNxrRSu5MfUQ,4523
 flock/core/agent/__init__.py,sha256=l32KFMJnC_gidMXpAXK8-OX228bWOhNc8OY_NzXm59Q,515
-flock/core/agent/default_agent.py,sha256=W5ewr4l4adjZjstcCvr6S8r2EnrmH0wFOVEtA8OQprI,6962
+flock/core/agent/default_agent.py,sha256=924SWDx8axJ57JCWREZuLzV8039Wt_-5WIBNTvx479Y,7483
 flock/core/agent/flock_agent_components.py,sha256=LamOgpRC7wDKuU3d6enDG0UFlNxyKPErLpH7SQ_Pi74,4539
 flock/core/agent/flock_agent_execution.py,sha256=pdOddBGv8y1P89Ix8XFWa1eW9i3bWjOYiQQxeY2K0yo,4217
 flock/core/agent/flock_agent_integration.py,sha256=fnxzEA8-gIopHwD1de8QKt2A7Ilb1iH5Koxk1uiASas,10737
@@ -125,7 +125,7 @@ flock/core/serialization/json_encoder.py,sha256=gAKj2zU_8wQiNvdkby2hksSA4fbPNwTj
 flock/core/serialization/secure_serializer.py,sha256=n5-zRvvXddgJv1FFHsaQ2wuYdL3WUSGPvG_LGaffEJo,6144
 flock/core/serialization/serializable.py,sha256=qlv8TsTqRuklXiNuCMrvro5VKz764xC2i3FlgLJSkdk,12129
 flock/core/serialization/serialization_utils.py,sha256=kxsuWy-8kFBcihHQvSOSNYp96ZPKxBMnasyRTtvIktY,15532
-flock/core/util/cli_helper.py,sha256=w8N7UJZOdOFhkcUSSusnL22JDlmJGgWmH0DgO--j-5c,50057
+flock/core/util/cli_helper.py,sha256=upRcEvWdGTrZvaKhi701PtFyW-Wp_B8PY3Gt0QY9szY,50053
 flock/core/util/file_path_utils.py,sha256=Odf7uU32C-x1KNighbNERSiMtkzW4h8laABIoFK7A5M,6246
 flock/core/util/hydrator.py,sha256=qRfVTDBEwqv1-ET2D4s5NI25f-UA_tGsoAmt5jaJMDI,10693
 flock/core/util/input_resolver.py,sha256=t3C98xz_-LGnDH0YeWQyV8yKZrls-_ekOYR-IKrAXDs,6232
@@ -490,7 +490,7 @@ flock/webapp/app/theme_mapper.py,sha256=QzWwLWpED78oYp3FjZ9zxv1KxCyj43m8MZ0fhfzz
 flock/webapp/app/utils.py,sha256=RF8DMKKAj1XPmm4txUdo2OdswI1ATQ7cqUm6G9JFDzA,2942
 flock/webapp/app/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 flock/webapp/app/api/agent_management.py,sha256=5xqO94QjjAYvxImyjKV9EGUQOvo4n3eqs7pGwGPSQJ4,10394
-flock/webapp/app/api/execution.py,sha256=OzTjCP5CxAGdD2YrX7vI2qkQejqikX9Jn8_sq2o6yKA,18163
+flock/webapp/app/api/execution.py,sha256=D-gqeF0JRZ_9TZTuf1-7gLIPL-p8F9Qp66CjVgJKSlw,24758
 flock/webapp/app/api/flock_management.py,sha256=1o-6-36kTnUjI3am_BqLpdrcz0aqFXrxE-hQHIFcCsg,4869
 flock/webapp/app/api/registry_viewer.py,sha256=IoInxJiRR0yFlecG_l2_eRc6l35RQQyEDMG9BcBkipY,1020
 flock/webapp/app/services/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -542,6 +542,7 @@ flock/webapp/templates/partials/_settings_view.html,sha256=f2h9jnDv8-JRkDzsbk_1o
 flock/webapp/templates/partials/_share_chat_link_snippet.html,sha256=N83lNAbkZiDfzZYviKwURPGGErSZhRlxnNzUqXsB7lE,793
 flock/webapp/templates/partials/_share_link_snippet.html,sha256=6en9lOdtu8FwVbtmkJzSQpHQ1WFXHnCbe84FDgAEF3U,1533
 flock/webapp/templates/partials/_sidebar.html,sha256=yfhEcF3xKI5j1c3iq46mU8mmPvgyvCHXe6xT7vsE6KM,4984
+flock/webapp/templates/partials/_streaming_results_container.html,sha256=WVp_IafF1_4puyfs3ueIJ16ehZHiMDBADUXRoZJ1_Yo,6684
 flock/webapp/templates/partials/_structured_data_view.html,sha256=TEaXcMGba9ruxEc_MLxygIO1qWcuSTo1FnosFtGSKWI,2101
 flock/webapp/templates/partials/_theme_preview.html,sha256=THeMYTXzgzHJxzWqaTtUhmJyBZT3saLRAa6wzZa4qnk,1347
 flock/workflow/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -551,8 +552,8 @@ flock/workflow/agent_execution_activity.py,sha256=0exwmeWKYXXxdUqDf4YaUVpn0zl06S
 flock/workflow/flock_workflow.py,sha256=sKFsRIL_bDGonXSNhK1zwu6UechghC_PihJJMidI-VI,9139
 flock/workflow/temporal_config.py,sha256=3_8O7SDEjMsSMXsWJBfnb6XTp0TFaz39uyzSlMTSF_I,3988
 flock/workflow/temporal_setup.py,sha256=KR6MlWOrpMtv8NyhaIPAsfl4tjobt81OBByQvg8Kw-Y,1948
-flock_core-0.5.0b19.dist-info/METADATA,sha256=IIENs1thHIvHmhkyhR3G62jimiMS7_ImCmVLv3AKAlQ,9997
-flock_core-0.5.0b19.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-flock_core-0.5.0b19.dist-info/entry_points.txt,sha256=rWaS5KSpkTmWySURGFZk6PhbJ87TmvcFQDi2uzjlagQ,37
-flock_core-0.5.0b19.dist-info/licenses/LICENSE,sha256=iYEqWy0wjULzM9GAERaybP4LBiPeu7Z1NEliLUdJKSc,1072
-flock_core-0.5.0b19.dist-info/RECORD,,
+flock_core-0.5.0b22.dist-info/METADATA,sha256=OQrcZ9gIQRqbbhfU0RSIbo7auCybTmemyee39C6XWHc,9997
+flock_core-0.5.0b22.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+flock_core-0.5.0b22.dist-info/entry_points.txt,sha256=rWaS5KSpkTmWySURGFZk6PhbJ87TmvcFQDi2uzjlagQ,37
+flock_core-0.5.0b22.dist-info/licenses/LICENSE,sha256=iYEqWy0wjULzM9GAERaybP4LBiPeu7Z1NEliLUdJKSc,1072
+flock_core-0.5.0b22.dist-info/RECORD,,