fluxloop-cli 0.2.26__tar.gz → 0.2.28__tar.gz

{fluxloop_cli-0.2.26 → fluxloop_cli-0.2.28}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fluxloop-cli
-Version: 0.2.26
+Version: 0.2.28
 Summary: FluxLoop CLI for running agent simulations
 Author-email: FluxLoop Team <team@fluxloop.dev>
 License: Apache-2.0

{fluxloop_cli-0.2.26 → fluxloop_cli-0.2.28}/fluxloop_cli/__init__.py

@@ -2,7 +2,7 @@
 FluxLoop CLI - Command-line interface for running agent simulations.
 """
 
-__version__ = "0.2.26"
+__version__ = "0.2.28"
 
 from .main import app
 

{fluxloop_cli-0.2.26 → fluxloop_cli-0.2.28}/fluxloop_cli/commands/parse.py

@@ -75,6 +75,9 @@ class TraceSummary:
     duration_ms: float
     success: bool
     raw: dict
+    conversation: Optional[List[Dict[str, Any]]] = None
+    conversation_state: Optional[Dict[str, Any]] = None
+    termination_reason: Optional[str] = None
 
     def to_payload(self) -> dict:
         """Return a JSON-serialisable representation of the summary entry."""
@@ -88,6 +91,9 @@ class TraceSummary:
             "duration_ms": self.duration_ms,
             "success": self.success,
             "raw": self.raw,
+            "conversation": self.conversation,
+            "conversation_state": self.conversation_state,
+            "termination_reason": self.termination_reason,
         }
 
 
@@ -164,6 +170,9 @@ def _load_trace_summaries(path: Path) -> Iterable[TraceSummary]:
                 output_text=payload.get("output"),
                 duration_ms=payload.get("duration_ms", 0.0),
                 success=payload.get("success", False),
+                conversation=payload.get("conversation"),
+                conversation_state=payload.get("conversation_state"),
+                termination_reason=payload.get("termination_reason"),
                 raw=payload,
             )
 
@@ -214,6 +223,30 @@ def _format_markdown(
         f"{_format_json_block({'output': trace.output_text})}\n\n"
     )
 
+    conversation_section = ""
+    if trace.conversation:
+        conversation_lines = ["## Conversation\n"]
+        for entry in trace.conversation:
+            role = (entry.get("role") or "unknown").capitalize()
+            content = entry.get("content") or ""
+            source = entry.get("source")
+            metadata = entry.get("metadata") or {}
+            meta_bits: List[str] = []
+            if source:
+                meta_bits.append(f"source={source}")
+            actions = metadata.get("actions") or []
+            if actions:
+                meta_bits.append("actions=" + ", ".join(actions))
+            if metadata.get("closing"):
+                meta_bits.append("closing=true")
+            persona = metadata.get("persona")
+            if persona:
+                meta_bits.append(f"persona={persona}")
+            meta_suffix = f" _({' ; '.join(meta_bits)})_" if meta_bits else ""
+            conversation_lines.append(f"- **{role}**: {content}{meta_suffix}")
+        conversation_lines.append("")
+        conversation_section = "\n".join(conversation_lines)
+
     timeline_lines = ["## Timeline\n"]
 
     for index, obs in enumerate(observations_sorted, start=1):
@@ -238,7 +271,7 @@ def _format_markdown(
     if not observations_sorted:
         timeline_lines.append("(no observations recorded)\n")
 
-    return header + summary_section + "".join(timeline_lines)
+    return header + summary_section + conversation_section + "".join(timeline_lines)
 
 
 def _sort_observations(
@@ -278,12 +311,40 @@ def _build_structured_record(
         "success": summary_payload["success"],
         "summary": summary_payload,
         "timeline": timeline,
+        "conversation": trace.conversation or summary_payload.get("conversation") or [],
     }
 
+    def _maybe_decode_content(value: Any) -> Any:
+        if isinstance(value, str):
+            text = value.strip()
+            if text and text[0] in "{[" and text[-1] in "}]" and len(text) >= 2:
+                try:
+                    return json.loads(text)
+                except (json.JSONDecodeError, TypeError):
+                    return value
+        return value
+
     record["metrics"] = {
         "observation_count": len(timeline),
     }
 
+    if trace.conversation_state:
+        record["conversation_state"] = trace.conversation_state
+    if trace.termination_reason:
+        record["termination_reason"] = trace.termination_reason
+    if not record["conversation"] and trace.raw.get("conversation"):
+        record["conversation"] = trace.raw.get("conversation")
+    if record["conversation"]:
+        normalized_conversation: List[Dict[str, Any]] = []
+        for entry in record["conversation"]:
+            if not isinstance(entry, dict):
+                normalized_conversation.append(entry)
+                continue
+            normalized_entry = dict(entry)
+            normalized_entry["content"] = _maybe_decode_content(entry.get("content"))
+            normalized_conversation.append(normalized_entry)
+        record["conversation"] = normalized_conversation
+
     return record
 
 

{fluxloop_cli-0.2.26 → fluxloop_cli-0.2.28}/fluxloop_cli/commands/run.py

@@ -3,6 +3,7 @@ Run command for executing experiments and simulations.
 """
 
 import asyncio
+import json
 import sys
 from pathlib import Path
 from typing import Optional
@@ -27,6 +28,16 @@ app = typer.Typer()
 console = Console()
 
 
+def _emit_progress_event(event: str, **payload: object) -> None:
+    """Emit a structured progress event to stderr for machine consumption."""
+    data = {"event": event, **payload}
+    try:
+        print(json.dumps(data, default=str), file=sys.stderr, flush=True)
+    except Exception:
+        # Fall back to repr if serialization fails
+        print({"event": event, **{k: repr(v) for k, v in payload.items()}}, file=sys.stderr, flush=True)
+
+
 @app.command()
 def experiment(
     config_file: Path = typer.Option(
@@ -227,9 +238,20 @@ def experiment(
     summary.add_row("Output", config.output_directory)
     
     console.print(summary)
+
+    _emit_progress_event(
+        "experiment_summary",
+        name=config.name,
+        iterations=config.iterations,
+        personas=len(config.personas),
+        total_runs=total_runs,
+        multi_turn_enabled=bool(config.multi_turn and config.multi_turn.enabled),
+        output_dir=config.output_directory,
+    )
     
     if dry_run:
         console.print("\n[yellow]Dry run mode - no execution will occur[/yellow]")
+        _emit_progress_event("experiment_status", status="dry_run", name=config.name)
         return
     
     # Confirm execution
@@ -243,13 +265,22 @@ def experiment(
             f"\nThis will execute {total_runs} runs."
         )
 
+    _emit_progress_event(
+        "experiment_ready",
+        name=config.name,
+        total_runs=total_runs,
+    )
+
     if not typer.confirm("Continue?"):
+        _emit_progress_event("experiment_status", status="aborted", reason="user_declined", name=config.name)
         raise typer.Abort()
     
     # Create runner
     # Run experiment with progress tracking
     console.print("\n[bold green]▶️ Starting experiment...[/bold green]\n")
 
+    _emit_progress_event("experiment_started", name=config.name, total_runs=total_runs)
+
     with Progress(
         SpinnerColumn(),
         TextColumn("[progress.description]{task.description}"),
@@ -277,6 +308,14 @@ def experiment(
 
         def _progress_callback():
             progress.advance(main_task)
+            task = progress.tasks[main_task]
+            _emit_progress_event(
+                "run_progress",
+                completed=int(task.completed),
+                total=int(task.total or 0),
+                description=task.description,
+                experiment=config.name,
+            )
 
         def _turn_progress_callback(
             current_turn: int,
@@ -295,6 +334,13 @@ def experiment(
                     description=description,
                     visible=False,
                 )
+                _emit_progress_event(
+                    "turn_progress",
+                    state="complete",
+                    current=min(clamped_turn, total),
+                    total=total,
+                experiment=config.name,
+                )
                 return
 
             if not progress.tasks[turn_task].visible:
@@ -313,6 +359,14 @@ def experiment(
                 completed=completed,
                 description=description,
             )
+            _emit_progress_event(
+                "turn_progress",
+                state="in_progress",
+                current=clamped_turn,
+                total=total,
+                preview=preview,
+                experiment=config.name,
+            )
 
         # Run experiment
         try:
@@ -324,12 +378,14 @@ def experiment(
             )
         except KeyboardInterrupt:
             console.print("\n[yellow]Experiment interrupted by user[/yellow]")
+            _emit_progress_event("experiment_status", status="interrupted", name=config.name)
             raise typer.Exit(1)
         except Exception as e:
             console.print(f"\n[red]Error during experiment:[/red] {e}")
             # Debug mode - show full traceback
             if "--debug" in sys.argv:
                 console.print_exception()
+            _emit_progress_event("experiment_status", status="error", error=str(e), name=config.name)
             raise typer.Exit(1)
     
     config.set_resolved_input_count(results.get("input_count", config.get_input_count()))
@@ -343,6 +399,15 @@ def experiment(
         )
 
     _display_results(results)
+    _emit_progress_event(
+        "experiment_status",
+        status="completed",
+        name=config.name,
+        total_runs=results.get("total_runs", total_runs),
+        successful=results.get("successful"),
+        failed=results.get("failed"),
+        success_rate=results.get("success_rate"),
+    )
 
 
 @app.command()

{fluxloop_cli-0.2.26 → fluxloop_cli-0.2.28}/fluxloop_cli/evaluation/engine/core.py

@@ -217,6 +217,12 @@ def _write_per_trace(results: List[TraceOutcome], path: Path) -> None:
                     if outcome.trace.get(key) is not None
                 },
             }
+            if outcome.trace.get("conversation") is not None:
+                payload["conversation"] = outcome.trace.get("conversation")
+            if outcome.trace.get("conversation_state") is not None:
+                payload["conversation_state"] = outcome.trace.get("conversation_state")
+            if outcome.trace.get("termination_reason") is not None:
+                payload["termination_reason"] = outcome.trace.get("termination_reason")
             handle.write(json.dumps(payload, ensure_ascii=False) + "\n")