flock-core 0.5.8__py3-none-any.whl → 0.5.10__py3-none-any.whl

flock/engines/examples/simple_batch_engine.py

@@ -21,7 +21,9 @@ class BatchSummary(BaseModel):
     """Output payload describing the batch that was processed."""
 
     batch_size: int = Field(description="Number of items included in this evaluation")
-    values: list[int] = Field(description="Original values processed", default_factory=list)
+    values: list[int] = Field(
+        description="Original values processed", default_factory=list
+    )
 
 
 class SimpleBatchEngine(EngineComponent):
@@ -32,7 +34,9 @@ class SimpleBatchEngine(EngineComponent):
     can verify that all artifacts were processed together.
     """
 
-    async def evaluate(self, agent, ctx, inputs: EvalInputs, output_group) -> EvalResult:
+    async def evaluate(
+        self, agent, ctx, inputs: EvalInputs, output_group
+    ) -> EvalResult:
         """Process single item or batch with auto-detection.
 
         Auto-detects batch mode via ctx.is_batch flag (set by orchestrator when
@@ -57,7 +61,9 @@ class SimpleBatchEngine(EngineComponent):
                 return EvalResult.empty()
 
             batch_size = len(items)
-            summary = BatchSummary(batch_size=batch_size, values=[item.value for item in items])
+            summary = BatchSummary(
+                batch_size=batch_size, values=[item.value for item in items]
+            )
 
             state = dict(inputs.state)
             state["batch_size"] = summary.batch_size

flock/examples.py

@@ -50,7 +50,9 @@ def announce(tagline: Tagline) -> dict[str, str]:
 
 
 class MovieEngine(EngineComponent):
-    async def evaluate(self, agent, ctx, inputs: EvalInputs, output_group) -> EvalResult:
+    async def evaluate(
+        self, agent, ctx, inputs: EvalInputs, output_group
+    ) -> EvalResult:
         idea = Idea(**inputs.artifacts[0].payload)
         synopsis = f"{idea.topic} told as a {idea.genre} adventure."
         movie = Movie(fun_title=idea.topic.upper(), runtime=120, synopsis=synopsis)
@@ -63,7 +65,9 @@ class MovieEngine(EngineComponent):
 
 
 class TaglineEngine(EngineComponent):
-    async def evaluate(self, agent, ctx, inputs: EvalInputs, output_group) -> EvalResult:
+    async def evaluate(
+        self, agent, ctx, inputs: EvalInputs, output_group
+    ) -> EvalResult:
         movie = Movie(**inputs.artifacts[0].payload)
         tagline = Tagline(line=f"Don't miss {movie.fun_title}!")
         artifact = Artifact(

flock/frontend/src/services/indexeddb.test.ts

@@ -117,7 +117,7 @@ describe('IndexedDBService', () => {
         max_concurrency: 1,
         consumes_types: ['Idea'],
         from_agents: [],
-        channels: [],
+        tags: [],
         run_history: [],
         total_runs: 0,
         total_errors: 0,
@@ -140,7 +140,7 @@ describe('IndexedDBService', () => {
         max_concurrency: 1,
         consumes_types: ['Idea'],
         from_agents: [],
-        channels: [],
+        tags: [],
         run_history: [],
         total_runs: 0,
         total_errors: 0,
@@ -168,7 +168,7 @@ describe('IndexedDBService', () => {
         max_concurrency: 1,
         consumes_types: [],
         from_agents: [],
-        channels: [],
+        tags: [],
         run_history: [],
         total_runs: 0,
         total_errors: 0,
@@ -612,7 +612,7 @@ describe('IndexedDBService', () => {
         max_concurrency: 1,
         consumes_types: [],
         from_agents: [],
-        channels: [],
+        tags: [],
         run_history: [],
         total_runs: 0,
         total_errors: 0,

flock/frontend/src/services/indexeddb.ts

@@ -46,7 +46,7 @@ interface AgentRecord {
   max_concurrency: number;
   consumes_types: string[];
   from_agents: string[];
-  channels: string[];
+  tags: string[];
   run_history: string[]; // [run_id] - last 100 runs
   total_runs: number;
   total_errors: number;

flock/helper/cli_helper.py

@@ -41,9 +41,22 @@ def display_hummingbird():
 
 def init_console(clear_screen: bool = True, show_banner: bool = True, model: str = ""):
     """Display the Flock banner."""
+    import sys
+
     from rich.console import Console
     from rich.syntax import Text
 
+    if sys.platform == "win32":
+        try:
+            sys.stdout.reconfigure(encoding="utf-8")
+            sys.stderr.reconfigure(encoding="utf-8")
+        except AttributeError:
+            # Python < 3.7
+            import codecs
+
+            sys.stdout = codecs.getwriter("utf-8")(sys.stdout.buffer, "strict")
+            sys.stderr = codecs.getwriter("utf-8")(sys.stderr.buffer, "strict")
+
     console = Console()
     banner_text = Text(
         f"""
@@ -52,7 +65,7 @@ def init_console(clear_screen: bool = True, show_banner: bool = True, model: str
 │ ▒█▀▀▀ █░░ █▀▀█ █▀▀ █░█ │
 │ ▒█▀▀▀ █░░ █░░█ █░░ █▀▄ │
 │ ▒█░░░ ▀▀▀ ▀▀▀▀ ▀▀▀ ▀░▀ │
-╰━━━━━━━━━v{__version__}━━━━━━━━━╯
+╰━━━━━━━━━v{__version__}━━━━━━━━╯
 🦆     🐤    🐧     🐓
 """,
         justify="center",

flock/logging/auto_trace.py

@@ -9,7 +9,12 @@ from flock.logging.trace_and_logged import _trace_filter_config, traced_and_logg
 
 
 # Check if auto-tracing is enabled via environment variable
-ENABLE_AUTO_TRACE = os.getenv("FLOCK_AUTO_TRACE", "true").lower() in {"true", "1", "yes", "on"}
+ENABLE_AUTO_TRACE = os.getenv("FLOCK_AUTO_TRACE", "true").lower() in {
+    "true",
+    "1",
+    "yes",
+    "on",
+}
 
 
 # Parse trace filter configuration from environment variables

flock/logging/formatters/enum_builder.py

@@ -10,7 +10,9 @@ theme_folder = pathlib.Path(__file__).parent.parent.parent / "themes"
 if not theme_folder.exists():
     raise FileNotFoundError(f"Theme folder not found: {theme_folder}")
 
-theme_files = [pathlib.Path(f.path).stem for f in os.scandir(theme_folder) if f.is_file()]
+theme_files = [
+    pathlib.Path(f.path).stem for f in os.scandir(theme_folder) if f.is_file()
+]
 
 theme_enum_entries = {}
 for theme in theme_files:

flock/logging/formatters/theme_builder.py

@@ -47,15 +47,13 @@ def generate_default_rich_block(theme: dict | None = None) -> dict[str, Any]:
     """
 
     def random_background():
-        return random.choice(
-            [
-                f"{normal_black}",
-                f"{normal_blue}",
-                f"{primary_background}",
-                f"{selection_background}",
-                f"{cursor_cursor}",
-            ]
-        )
+        return random.choice([
+            f"{normal_black}",
+            f"{normal_blue}",
+            f"{primary_background}",
+            f"{selection_background}",
+            f"{cursor_cursor}",
+        ])
 
     if theme is not None:
         bright = theme["colors"].get("bright", {})
@@ -148,12 +146,21 @@ def generate_default_rich_block(theme: dict | None = None) -> dict[str, Any]:
     # Non-color layout properties, randomly chosen.
     default_non_color_props = {
         "table_show_lines": random.choice([True, False]),
-        "table_box": random.choice(
-            ["ROUNDED", "SIMPLE", "SQUARE", "MINIMAL", "HEAVY", "DOUBLE_EDGE"]
-        ),
+        "table_box": random.choice([
+            "ROUNDED",
+            "SIMPLE",
+            "SQUARE",
+            "MINIMAL",
+            "HEAVY",
+            "DOUBLE_EDGE",
+        ]),
         "panel_padding": random.choice([[1, 2], [1, 1], [2, 2], [0, 2]]),
         "panel_title_align": random.choice(["left", "center", "right"]),
-        "table_row_styles": random.choice([["", "dim"], ["", "italic"], ["", "underline"]]),
+        "table_row_styles": random.choice([
+            ["", "dim"],
+            ["", "italic"],
+            ["", "underline"],
+        ]),
     }
     # Extra table layout properties (non-content).
     default_extra_table_props = {
@@ -275,9 +282,13 @@ def create_rich_renderable(
             sub_tables = []
             for i, item in enumerate(value):
                 sub_tables.append(f"[bold]Item {i + 1}[/bold]")
-                sub_tables.append(create_rich_renderable(item, level + 1, theme, styles))
+                sub_tables.append(
+                    create_rich_renderable(item, level + 1, theme, styles)
+                )
             return Group(*sub_tables)
-        rendered_items = [create_rich_renderable(item, level + 1, theme, styles) for item in value]
+        rendered_items = [
+            create_rich_renderable(item, level + 1, theme, styles) for item in value
+        ]
         if all(isinstance(item, str) for item in rendered_items):
             return "\n".join(rendered_items)
         return Group(*rendered_items)
@@ -422,7 +433,9 @@ def theme_builder():
     samples = []
     for i, rich_block in enumerate(sample_rich_blocks):
         # Build a sample theme: copy the chosen theme and override its [rich] block.
-        sample_theme = dict(chosen_theme)  # shallow copy (good enough if colors remain unchanged)
+        sample_theme = dict(
+            chosen_theme
+        )  # shallow copy (good enough if colors remain unchanged)
         sample_theme["rich"] = rich_block
         sample_table = generate_sample_table(sample_theme, dummy_data)
         samples.append((sample_theme, sample_table))
@@ -445,7 +458,9 @@ def theme_builder():
         return
 
     # Ask for file name to save the chosen theme.
-    filename = console.input("\nEnter a filename to save the chosen theme (e.g. mytheme.toml): ")
+    filename = console.input(
+        "\nEnter a filename to save the chosen theme (e.g. mytheme.toml): "
+    )
     save_path = themes_dir / filename
     save_theme(chosen_sample_theme, save_path)
     console.print(f"\n[green]Theme saved as {save_path}.[/green]")

flock/logging/formatters/themed_formatter.py

@@ -141,13 +141,22 @@ def generate_default_rich_block(theme: dict | None = None) -> dict[str, Any]:
     # Randomly choose non color properties.
     default_non_color_props = {
         "table_show_lines": random.choice([True, False]),
-        "table_box": random.choice(
-            ["ROUNDED", "SIMPLE", "SQUARE", "MINIMAL", "HEAVY", "DOUBLE_EDGE"]
-        ),
+        "table_box": random.choice([
+            "ROUNDED",
+            "SIMPLE",
+            "SQUARE",
+            "MINIMAL",
+            "HEAVY",
+            "DOUBLE_EDGE",
+        ]),
         "panel_padding": random.choice([[1, 2], [1, 1], [2, 2], [0, 2]]),
         "panel_title_align": random.choice(["left", "center", "right"]),
         # Add table_row_styles property.
-        "table_row_styles": random.choice([["", "dim"], ["", "italic"], ["", "underline"]]),
+        "table_row_styles": random.choice([
+            ["", "dim"],
+            ["", "italic"],
+            ["", "underline"],
+        ]),
     }
     # Extra table layout properties (non content properties).
     default_extra_table_props = {
@@ -294,7 +303,9 @@ def create_rich_renderable(
             for i, item in enumerate(value):
                 sub_tables.append(f"[bold]Item {i + 1}[/bold]")
                 sub_tables.append(
-                    create_rich_renderable(item, level + 1, theme, styles, max_length=max_length)
+                    create_rich_renderable(
+                        item, level + 1, theme, styles, max_length=max_length
+                    )
                 )
             return Group(*sub_tables)
         rendered_items = [
@@ -311,7 +322,10 @@ def create_rich_renderable(
     s = str(value).strip()
     if max_length > 0 and len(s) > max_length:
         omitted = len(s) - max_length
-        s = s[:max_length] + f"[bold bright_yellow]...(+{omitted}chars)[/bold bright_yellow]"
+        s = (
+            s[:max_length]
+            + f"[bold bright_yellow]...(+{omitted}chars)[/bold bright_yellow]"
+        )
     if isinstance(value, str) and "\n" in value:
         return f"\n{s}\n"
     return s
@@ -343,20 +357,18 @@ def load_syntax_theme_from_file(filepath: str) -> dict:
 
 def create_rich_syntax_theme(syntax_theme: dict) -> Theme:
     """Convert a syntax theme dict to a Rich-compatible Theme."""
-    return Theme(
-        {
-            "background": f"on {syntax_theme['background']}",
-            "text": syntax_theme["text"],
-            "keyword": f"bold {syntax_theme['keyword']}",
-            "builtin": f"bold {syntax_theme['builtin']}",
-            "string": syntax_theme["string"],
-            "name": syntax_theme["name"],
-            "number": syntax_theme["number"],
-            "operator": syntax_theme["operator"],
-            "punctuation": syntax_theme["punctuation"],
-            "error": f"bold {syntax_theme['error']}",
-        }
-    )
+    return Theme({
+        "background": f"on {syntax_theme['background']}",
+        "text": syntax_theme["text"],
+        "keyword": f"bold {syntax_theme['keyword']}",
+        "builtin": f"bold {syntax_theme['builtin']}",
+        "string": syntax_theme["string"],
+        "name": syntax_theme["name"],
+        "number": syntax_theme["number"],
+        "operator": syntax_theme["operator"],
+        "punctuation": syntax_theme["punctuation"],
+        "error": f"bold {syntax_theme['error']}",
+    })
 
 
 def create_pygments_syntax_theme(syntax_theme: dict) -> PygmentsSyntaxTheme:
@@ -485,7 +497,9 @@ class ThemedAgentResultFormatter:
         theme = self.theme
         themes_dir = pathlib.Path(__file__).parent.parent.parent / "themes"
         all_themes = list(themes_dir.glob("*.toml"))
-        theme = theme.value + ".toml" if not theme.value.endswith(".toml") else theme.value
+        theme = (
+            theme.value + ".toml" if not theme.value.endswith(".toml") else theme.value
+        )
         theme = pathlib.Path(__file__).parent.parent.parent / "themes" / theme
 
         if pathlib.Path(theme) not in all_themes:
@@ -495,7 +509,9 @@ class ThemedAgentResultFormatter:
 
         styles = get_default_styles(theme_dict)
         self.styles = styles
-        self.syntax_style = create_pygments_syntax_theme(load_syntax_theme_from_file(theme))
+        self.syntax_style = create_pygments_syntax_theme(
+            load_syntax_theme_from_file(theme)
+        )
 
         console = Console()
         for item in result:

flock/logging/logging.py

@@ -177,7 +177,9 @@ def custom_format(record):
     # MAX_LENGTH = 500 # Example value
     if len(message) > MAX_LENGTH:
         truncated_chars = len(message) - MAX_LENGTH
-        message = message[:MAX_LENGTH] + f"<yellow>...+({truncated_chars} chars)</yellow>"
+        message = (
+            message[:MAX_LENGTH] + f"<yellow>...+({truncated_chars} chars)</yellow>"
+        )
 
     # Determine if category needs bolding (can refine this logic)
     needs_bold = category in BOLD_CATEGORIES
@@ -262,7 +264,10 @@ logging.basicConfig(level=LOG_LEVELS["ERROR"])  # Default to ERROR level for fal
 
 
 def get_default_severity(
-    level: Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL", "NO_LOGS", "SUCCESS"] | int,
+    level: Literal[
+        "DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL", "NO_LOGS", "SUCCESS"
+    ]
+    | int,
 ) -> int:
     """Get the default severity for a given level."""
     if isinstance(level, str):
@@ -272,13 +277,18 @@ def get_default_severity(
 
 
 def configure_logging(
-    flock_level: Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL", "NO_LOGS", "SUCCESS"]
+    flock_level: Literal[
+        "DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL", "NO_LOGS", "SUCCESS"
+    ]
     | int,
-    external_level: Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL", "NO_LOGS", "SUCCESS"]
+    external_level: Literal[
+        "DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL", "NO_LOGS", "SUCCESS"
+    ]
     | int,
     specific_levels: dict[
         str,
-        Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL", "NO_LOGS", "SUCCESS"] | int,
+        Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL", "NO_LOGS", "SUCCESS"]
+        | int,
     ]
     | None = None,
 ) -> None:
@@ -378,7 +388,9 @@ class FlockLogger:
         """Truncate a message if it exceeds max_length and add truncation indicator."""
         if len(message) > max_length:
             truncated_chars = len(message) - max_length
-            return message[:max_length] + f"...<yellow>+({truncated_chars} chars)</yellow>"
+            return (
+                message[:max_length] + f"...<yellow>+({truncated_chars} chars)</yellow>"
+            )
         return message
 
     def debug(
@@ -565,7 +577,9 @@ def truncate_for_logging(obj, max_item_length=100, max_items=10):
     if isinstance(obj, dict):
         if len(obj) > max_items:
             return {
-                k: truncate_for_logging(v) for i, (k, v) in enumerate(obj.items()) if i < max_items
+                k: truncate_for_logging(v)
+                for i, (k, v) in enumerate(obj.items())
+                if i < max_items
             }
         return {k: truncate_for_logging(v) for k, v in obj.items()}
     if isinstance(obj, list):

flock/logging/telemetry.py

@@ -137,7 +137,9 @@ class TelemetryConfig:
                     collector_endpoint=self.jaeger_endpoint,
                 )
             else:
-                raise ValueError("Invalid JAEGER_TRANSPORT specified. Use 'grpc' or 'http'.")
+                raise ValueError(
+                    "Invalid JAEGER_TRANSPORT specified. Use 'grpc' or 'http'."
+                )
 
             span_processors.append(SimpleSpanProcessor(jaeger_exporter))
 
@@ -168,12 +170,16 @@ class TelemetryConfig:
 
         # If a file path is provided, add the custom file exporter.
         if self.file_export_name and self.enable_file:
-            file_exporter = FileSpanExporter(self.local_logging_dir, self.file_export_name)
+            file_exporter = FileSpanExporter(
+                self.local_logging_dir, self.file_export_name
+            )
             span_processors.append(SimpleSpanProcessor(file_exporter))
 
         # If a SQLite database path is provided, ensure the DB exists and add the SQLite exporter.
         if self.sqlite_db_name and self.enable_sql:
-            sqlite_exporter = SqliteTelemetryExporter(self.local_logging_dir, self.sqlite_db_name)
+            sqlite_exporter = SqliteTelemetryExporter(
+                self.local_logging_dir, self.sqlite_db_name
+            )
             span_processors.append(SimpleSpanProcessor(sqlite_exporter))
 
         # If a DuckDB database path is provided, add the DuckDB exporter.

flock/logging/telemetry_exporter/duckdb_exporter.py

@@ -23,7 +23,9 @@ class DuckDBSpanExporter(TelemetryExporter):
     The database is a single file with zero configuration required.
     """
 
-    def __init__(self, dir: str, db_name: str = "traces.duckdb", ttl_days: int | None = None):
+    def __init__(
+        self, dir: str, db_name: str = "traces.duckdb", ttl_days: int | None = None
+    ):
         """Initialize the DuckDB exporter.
 
         Args:
@@ -68,9 +70,13 @@ class DuckDBSpanExporter(TelemetryExporter):
             # Create indexes for common query patterns
             conn.execute("CREATE INDEX IF NOT EXISTS idx_trace_id ON spans(trace_id)")
             conn.execute("CREATE INDEX IF NOT EXISTS idx_service ON spans(service)")
-            conn.execute("CREATE INDEX IF NOT EXISTS idx_start_time ON spans(start_time)")
+            conn.execute(
+                "CREATE INDEX IF NOT EXISTS idx_start_time ON spans(start_time)"
+            )
             conn.execute("CREATE INDEX IF NOT EXISTS idx_name ON spans(name)")
-            conn.execute("CREATE INDEX IF NOT EXISTS idx_created_at ON spans(created_at)")
+            conn.execute(
+                "CREATE INDEX IF NOT EXISTS idx_created_at ON spans(created_at)"
+            )
 
         # Cleanup old traces if TTL is configured
         if self.ttl_days is not None:
@@ -121,28 +127,24 @@ class DuckDBSpanExporter(TelemetryExporter):
 
         # Serialize complex fields to JSON
         attributes_json = json.dumps(dict(span.attributes or {}))
-        events_json = json.dumps(
-            [
-                {
-                    "name": event.name,
-                    "timestamp": event.timestamp,
-                    "attributes": dict(event.attributes or {}),
-                }
-                for event in span.events
-            ]
-        )
-        links_json = json.dumps(
-            [
-                {
-                    "context": {
-                        "trace_id": format(link.context.trace_id, "032x"),
-                        "span_id": format(link.context.span_id, "016x"),
-                    },
-                    "attributes": dict(link.attributes or {}),
-                }
-                for link in span.links
-            ]
-        )
+        events_json = json.dumps([
+            {
+                "name": event.name,
+                "timestamp": event.timestamp,
+                "attributes": dict(event.attributes or {}),
+            }
+            for event in span.events
+        ])
+        links_json = json.dumps([
+            {
+                "context": {
+                    "trace_id": format(link.context.trace_id, "032x"),
+                    "span_id": format(link.context.span_id, "016x"),
+                },
+                "attributes": dict(link.attributes or {}),
+            }
+            for link in span.links
+        ])
         resource_json = json.dumps(dict(span.resource.attributes.items()))
 
         # Get parent span ID if exists

flock/logging/trace_and_logged.py

@@ -20,7 +20,9 @@ class TraceFilterConfig:
 
     def __init__(self):
         self.services: set[str] | None = None  # Whitelist: only trace these services
-        self.ignore_operations: set[str] = set()  # Blacklist: never trace these operations
+        self.ignore_operations: set[str] = (
+            set()
+        )  # Blacklist: never trace these operations
 
     def should_trace(self, service: str, operation: str) -> bool:
         """Check if an operation should be traced based on filters.
@@ -74,17 +76,22 @@ def _serialize_value(value, max_depth=10, current_depth=0):
 
         # Handle lists/tuples
         if isinstance(value, (list, tuple)):
-            return [_serialize_value(item, max_depth, current_depth + 1) for item in value]
+            return [
+                _serialize_value(item, max_depth, current_depth + 1) for item in value
+            ]
 
         # Handle dicts
         if isinstance(value, dict):
             return {
-                str(k): _serialize_value(v, max_depth, current_depth + 1) for k, v in value.items()
+                str(k): _serialize_value(v, max_depth, current_depth + 1)
+                for k, v in value.items()
             }
 
         # Handle sets
         if isinstance(value, set):
-            return [_serialize_value(item, max_depth, current_depth + 1) for item in value]
+            return [
+                _serialize_value(item, max_depth, current_depth + 1) for item in value
+            ]
 
         # For custom objects with __dict__, serialize their attributes
         if hasattr(value, "__dict__"):
@@ -277,7 +284,9 @@ def traced_and_logged(func):
                 # Capture output value as JSON
                 try:
                     serialized_result = _serialize_value(result)
-                    span.set_attribute("output.value", json.dumps(serialized_result, default=str))
+                    span.set_attribute(
+                        "output.value", json.dumps(serialized_result, default=str)
+                    )
                 except Exception as e:
                     span.set_attribute("output.value", str(result))
                     span.set_attribute("output.serialization_error", str(e))

flock/mcp/__init__.py

@@ -28,16 +28,13 @@ Example Usage:
     orchestrator.add_mcp(
         name="filesystem",
         connection_params=StdioServerParameters(
-            command="uvx",
-            args=["mcp-server-filesystem", "/tmp"]
-        )
+            command="uvx", args=["mcp-server-filesystem", "/tmp"]
+        ),
     )
 
     # Build agent with MCP access
     agent = (
-        orchestrator.agent("file_agent")
-        .with_mcps(["filesystem"])
-        .build()
+        orchestrator.agent("file_agent").with_mcps(["filesystem"]).build()
     )
     ```
 """