flock-core 0.5.0b57__tar.gz → 0.5.0b59__tar.gz

{flock_core-0.5.0b57 → flock_core-0.5.0b59}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flock-core
-Version: 0.5.0b57
+Version: 0.5.0b59
 Summary: Add your description here
 Author-email: Andre Ratzenberger <andre.ratzenberger@whiteduck.de>
 License-File: LICENSE
@@ -44,7 +44,7 @@ Description-Content-Type: text/markdown
 
 > **Stop engineering prompts. Start declaring contracts.**
 
-Flock is a production-focused framework for orchestrating AI agents through **declarative type contracts** and **blackboard architecture**, proven patterns from distributed systems, decades of engaging with micro-service landscapes and classical AI, now applied to modern LLMs.
+Flock is a production-focused framework for orchestrating AI agents through **declarative type contracts** and **blackboard architecture**—proven patterns from distributed systems, decades of experience with microservice architectures, and classical AI—now applied to modern LLMs.
 
 
 
@@ -62,7 +62,8 @@ prompt = """You are an expert code reviewer. When you receive code, you should..
 
 # 500-line prompt that breaks when models update
 
-# How do I know that there isn't an even better prompt (you don't) -> proof of 'best possible performane' impossible
+# How do I know that there isn't an even better prompt? (you don't)
+# -> proving 'best possible performance' is impossible
 ```
 
 **🧪 Testing Nightmares**
@@ -88,12 +89,13 @@ workflow.add_edge("agent_b", "agent_c")
 **🧠 God object anti-pattern:**
 ```python
 # One orchestrator needs domain knowledge of 20+ agents to route correctly
-# Orchestrator 'guesses' next agent based on a natural language description. Hardly fit for critical systems.
+# Orchestrator 'guesses' next agent based on a natural language description.
+# Not suitable for critical systems.
 ```
 
 These aren't framework limitations, they're **architectural choices** that don't scale.
 
-Most issues are solvable, because decades of experience with micro services taught us hard lessons about decoupling, orchestration and reliability already. Let's use these learnings!
+These challenges are solvable—decades of experience with microservices have taught us hard lessons about decoupling, orchestration, and reliability. Let's apply those lessons!
 
 ---
 
@@ -105,8 +107,51 @@ Flock takes a different path, combining two proven patterns:
 
 **Traditional approach:**
 ```python
-prompt = "Analyze this bug report and return JSON with severity, category, hypothesis..."
-result = llm.invoke(prompt)  # Hope it works
+prompt = """You are an expert software engineer and bug analyst. Your task is to analyze bug reports and provide structured diagnostic information.
+
+INSTRUCTIONS:
+1. Read the bug report carefully
+2. Determine the severity level (must be exactly one of: Critical, High, Medium, Low)
+3. Classify the bug category (e.g., "performance", "security", "UI", "data corruption")
+4. Formulate a root cause hypothesis (minimum 50 characters)
+5. Assign a confidence score between 0.0 and 1.0
+
+OUTPUT FORMAT:
+You MUST return valid JSON with this exact structure:
+{
+  "severity": "string (Critical|High|Medium|Low)",
+  "category": "string",
+  "root_cause_hypothesis": "string (minimum 50 characters)",
+  "confidence_score": "number (0.0 to 1.0)"
+}
+
+VALIDATION RULES:
+- severity: Must be exactly one of: Critical, High, Medium, Low (case-sensitive)
+- category: Must be a single word or short phrase describing the bug type
+- root_cause_hypothesis: Must be at least 50 characters long and explain the likely cause
+- confidence_score: Must be a decimal number between 0.0 and 1.0 inclusive
+
+EXAMPLES:
+Input: "App crashes when user clicks submit button"
+Output: {"severity": "Critical", "category": "crash", "root_cause_hypothesis": "Null pointer exception in form validation logic when required fields are empty", "confidence_score": 0.85}
+
+Input: "Login button has wrong color"
+Output: {"severity": "Low", "category": "UI", "root_cause_hypothesis": "CSS class override not applied correctly in the theme configuration", "confidence_score": 0.9}
+
+IMPORTANT:
+- Do NOT include any explanatory text before or after the JSON
+- Do NOT use markdown code blocks (no ```json```)
+- Do NOT add comments in the JSON
+- Ensure the JSON is valid and parseable
+- If you cannot determine something, use your best judgment
+- Never return null values
+
+Now analyze this bug report:
+{bug_report_text}"""
+
+result = llm.invoke(prompt)  # 500-line prompt that breaks when models update
+# Then parse and hope it's valid JSON
+data = json.loads(result.content)  # Crashes in production 🔥
 ```
 
 **The Flock way:**
@@ -160,7 +205,7 @@ performance = flock.agent("perf").consumes(Scan).publishes(PerfAnalysis)
 - ✅ **Loose coupling** - Agents don't know about each other, just data types
 - ✅ **Scalable** - O(n) complexity, not O(n²) edges
 
-**This is not a new idea.** Blackboard architecture powered groundbreaking AI systems since the 1970s (Hearsay-II, HASP/SIAP, BB1). We're applying proven patterns to modern LLMs.
+**This is not a new idea.** Blackboard architecture has powered groundbreaking AI systems since the 1970s (Hearsay-II, HASP/SIAP, BB1). We're applying proven patterns to modern LLMs.
 
 ---
 
@@ -582,7 +627,7 @@ Flock uses a fundamentally different coordination pattern than most multi-agent
 ### What Works Today (v0.5.0)
 
 **✅ Production-ready core:**
-- more than 700 tests, with >75% coverage (>90% on critical paths)
+- More than 700 tests, with >75% coverage (>90% on critical paths)
 - Blackboard orchestrator with typed artifacts
 - Parallel + sequential execution (automatic)
 - Zero-trust security (5 visibility types)
@@ -628,7 +673,7 @@ We're not building a toy framework. We're building enterprise infrastructure for
 
 ### Flock 1.0 - Q4 2025 Release
 
-**We're confident to deliver all enterprise features by Q4 2025:**
+**We're confident we can deliver all enterprise features by Q4 2025:**
 
 **🏢 Enterprise Persistence**
 - Redis and PostgreSQL backends for durable blackboard state

{flock_core-0.5.0b57 → flock_core-0.5.0b59}/README.md

@@ -14,7 +14,7 @@
 
 > **Stop engineering prompts. Start declaring contracts.**
 
-Flock is a production-focused framework for orchestrating AI agents through **declarative type contracts** and **blackboard architecture**, proven patterns from distributed systems, decades of engaging with micro-service landscapes and classical AI, now applied to modern LLMs.
+Flock is a production-focused framework for orchestrating AI agents through **declarative type contracts** and **blackboard architecture**—proven patterns from distributed systems, decades of experience with microservice architectures, and classical AI—now applied to modern LLMs.
 
 
 
@@ -32,7 +32,8 @@ prompt = """You are an expert code reviewer. When you receive code, you should..
 
 # 500-line prompt that breaks when models update
 
-# How do I know that there isn't an even better prompt (you don't) -> proof of 'best possible performane' impossible
+# How do I know that there isn't an even better prompt? (you don't)
+# -> proving 'best possible performance' is impossible
 ```
 
 **🧪 Testing Nightmares**
@@ -58,12 +59,13 @@ workflow.add_edge("agent_b", "agent_c")
 **🧠 God object anti-pattern:**
 ```python
 # One orchestrator needs domain knowledge of 20+ agents to route correctly
-# Orchestrator 'guesses' next agent based on a natural language description. Hardly fit for critical systems.
+# Orchestrator 'guesses' next agent based on a natural language description.
+# Not suitable for critical systems.
 ```
 
 These aren't framework limitations, they're **architectural choices** that don't scale.
 
-Most issues are solvable, because decades of experience with micro services taught us hard lessons about decoupling, orchestration and reliability already. Let's use these learnings!
+These challenges are solvable—decades of experience with microservices have taught us hard lessons about decoupling, orchestration, and reliability. Let's apply those lessons!
 
 ---
 
@@ -75,8 +77,51 @@ Flock takes a different path, combining two proven patterns:
 
 **Traditional approach:**
 ```python
-prompt = "Analyze this bug report and return JSON with severity, category, hypothesis..."
-result = llm.invoke(prompt)  # Hope it works
+prompt = """You are an expert software engineer and bug analyst. Your task is to analyze bug reports and provide structured diagnostic information.
+
+INSTRUCTIONS:
+1. Read the bug report carefully
+2. Determine the severity level (must be exactly one of: Critical, High, Medium, Low)
+3. Classify the bug category (e.g., "performance", "security", "UI", "data corruption")
+4. Formulate a root cause hypothesis (minimum 50 characters)
+5. Assign a confidence score between 0.0 and 1.0
+
+OUTPUT FORMAT:
+You MUST return valid JSON with this exact structure:
+{
+  "severity": "string (Critical|High|Medium|Low)",
+  "category": "string",
+  "root_cause_hypothesis": "string (minimum 50 characters)",
+  "confidence_score": "number (0.0 to 1.0)"
+}
+
+VALIDATION RULES:
+- severity: Must be exactly one of: Critical, High, Medium, Low (case-sensitive)
+- category: Must be a single word or short phrase describing the bug type
+- root_cause_hypothesis: Must be at least 50 characters long and explain the likely cause
+- confidence_score: Must be a decimal number between 0.0 and 1.0 inclusive
+
+EXAMPLES:
+Input: "App crashes when user clicks submit button"
+Output: {"severity": "Critical", "category": "crash", "root_cause_hypothesis": "Null pointer exception in form validation logic when required fields are empty", "confidence_score": 0.85}
+
+Input: "Login button has wrong color"
+Output: {"severity": "Low", "category": "UI", "root_cause_hypothesis": "CSS class override not applied correctly in the theme configuration", "confidence_score": 0.9}
+
+IMPORTANT:
+- Do NOT include any explanatory text before or after the JSON
+- Do NOT use markdown code blocks (no ```json```)
+- Do NOT add comments in the JSON
+- Ensure the JSON is valid and parseable
+- If you cannot determine something, use your best judgment
+- Never return null values
+
+Now analyze this bug report:
+{bug_report_text}"""
+
+result = llm.invoke(prompt)  # 500-line prompt that breaks when models update
+# Then parse and hope it's valid JSON
+data = json.loads(result.content)  # Crashes in production 🔥
 ```
 
 **The Flock way:**
@@ -130,7 +175,7 @@ performance = flock.agent("perf").consumes(Scan).publishes(PerfAnalysis)
 - ✅ **Loose coupling** - Agents don't know about each other, just data types
 - ✅ **Scalable** - O(n) complexity, not O(n²) edges
 
-**This is not a new idea.** Blackboard architecture powered groundbreaking AI systems since the 1970s (Hearsay-II, HASP/SIAP, BB1). We're applying proven patterns to modern LLMs.
+**This is not a new idea.** Blackboard architecture has powered groundbreaking AI systems since the 1970s (Hearsay-II, HASP/SIAP, BB1). We're applying proven patterns to modern LLMs.
 
 ---
 
@@ -552,7 +597,7 @@ Flock uses a fundamentally different coordination pattern than most multi-agent
 ### What Works Today (v0.5.0)
 
 **✅ Production-ready core:**
-- more than 700 tests, with >75% coverage (>90% on critical paths)
+- More than 700 tests, with >75% coverage (>90% on critical paths)
 - Blackboard orchestrator with typed artifacts
 - Parallel + sequential execution (automatic)
 - Zero-trust security (5 visibility types)
@@ -598,7 +643,7 @@ We're not building a toy framework. We're building enterprise infrastructure for
 
 ### Flock 1.0 - Q4 2025 Release
 
-**We're confident to deliver all enterprise features by Q4 2025:**
+**We're confident we can deliver all enterprise features by Q4 2025:**
 
 **🏢 Enterprise Persistence**
 - Redis and PostgreSQL backends for durable blackboard state

flock_core-0.5.0b59/examples/03-the-dashboard/03-scale-test-100-agents.py

@@ -0,0 +1,130 @@
+"""
+Scale Test: 100 Agents Dashboard
+==================================
+This example creates 100 agents to test dashboard UI performance and layout algorithms
+with a large number of nodes. Perfect for stress-testing the visualization system.
+
+How to use:
+1. Run this script: `uv run examples/03-the-dashboard/03-scale-test-100-agents.py`
+2. Open http://localhost:8000 in your browser
+3. Right-click canvas → Auto Layout → Try different layout algorithms:
+   - Hierarchical (Vertical/Horizontal) - See how Dagre handles 100 nodes
+   - Circular - 100 nodes in a perfect circle
+   - Grid - 10x10 grid of agents
+   - Random - Stress test collision detection
+
+Expected behavior:
+- 100 agent nodes in the graph
+- Each agent consumes output from the previous agent (chain pattern)
+- Click "Show Controls" and publish a Signal to trigger the chain
+- Watch the cascade of activations across all 100 agents
+
+Performance expectations:
+- Layout algorithms should complete in <500ms
+- Graph should remain interactive with pan/zoom
+- WebSocket updates should handle 100+ nodes smoothly
+
+Use cases:
+- Test layout algorithm performance with large graphs
+- Verify UI remains responsive with many nodes
+- Validate WebSocket streaming with high node counts
+- Test context menu and interactions with crowded canvas
+"""
+
+import asyncio
+
+from pydantic import BaseModel
+
+from flock.orchestrator import Flock
+from flock.registry import flock_type
+
+
+# Simple signal artifact that gets passed through the chain
+@flock_type
+class Signal(BaseModel):
+    value: int
+    hop: int  # Track how many agents this signal has passed through
+
+
+# Create orchestrator
+flock = Flock("openai/gpt-4.1")
+
+# Create 100 agents in a chain
+# Agent 0 consumes Signal(hop=0)
+# Agent 1 consumes output from Agent 0 and produces Signal(hop=1)
+# Agent 2 consumes output from Agent 1 and produces Signal(hop=2)
+# ... and so on
+print("Creating 100 agents...")
+
+for i in range(100):
+    agent_name = f"agent_{i:03d}"  # agent_000, agent_001, etc.
+
+    # Create a unique type for this agent's output
+    # This allows us to chain agents: agent_0 -> agent_1 -> agent_2 -> ...
+    output_type_name = f"Signal{i:03d}"
+
+    # Dynamically create the output type
+    output_type = type(
+        output_type_name,
+        (Signal,),
+        {
+            "__module__": __name__,
+            "__annotations__": {"value": int, "hop": int},
+        },
+    )
+    flock_type(output_type)
+
+    # Determine what this agent consumes
+    if i == 0:
+        # First agent consumes the initial Signal
+        input_type = Signal
+    else:
+        # All other agents consume output from the previous agent
+        prev_output_type_name = f"Signal{i - 1:03d}"
+        input_type = globals().get(prev_output_type_name)
+        if input_type is None:
+            # Create the input type if it doesn't exist
+            input_type = type(
+                prev_output_type_name,
+                (Signal,),
+                {
+                    "__module__": __name__,
+                    "__annotations__": {"value": int, "hop": int},
+                },
+            )
+            flock_type(input_type)
+
+    # Register the output type in globals so subsequent agents can find it
+    globals()[output_type_name] = output_type
+
+    # Create the agent
+    agent = (
+        flock.agent(agent_name)
+        .description(f"Agent {i} in the chain - passes signal to next agent")
+        .consumes(input_type)
+        .publishes(output_type)
+    )
+
+    if (i + 1) % 10 == 0:
+        print(f"  Created {i + 1}/100 agents...")
+
+print("✅ All 100 agents created!")
+print("\n📊 Graph structure:")
+print("  - 100 agent nodes")
+print("  - 99 edges (chain: agent_000 → agent_001 → ... → agent_099)")
+print("  - Total nodes: 100")
+print("\n🎨 Try different layouts:")
+print("  - Hierarchical (Vertical): Long vertical chain")
+print("  - Hierarchical (Horizontal): Long horizontal chain")
+print("  - Circular: Perfect circle of 100 nodes")
+print("  - Grid: 10×10 organized grid")
+print("  - Random: Stress test collision detection")
+print("\n🚀 Starting dashboard...")
+
+
+# Run with dashboard
+async def main():
+    await flock.serve(dashboard=True)
+
+
+asyncio.run(main())

{flock_core-0.5.0b57 → flock_core-0.5.0b59}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "flock-core"
-version = "0.5.0b57"
+version = "0.5.0b59"
 description = "Add your description here"
 readme = "README.md"
 authors = [

{flock_core-0.5.0b57 → flock_core-0.5.0b59}/src/flock/dashboard/websocket.py

@@ -103,9 +103,9 @@ class WebSocketManager:
         # Store streaming output events for history (always, even if no clients)
         if isinstance(event, StreamingOutputEvent):
             self._streaming_history[event.agent_name].append(event)
-            logger.debug(
-                f"Stored streaming event for {event.agent_name}, history size: {len(self._streaming_history[event.agent_name])}"
-            )
+            # logger.debug(
+            #     f"Stored streaming event for {event.agent_name}, history size: {len(self._streaming_history[event.agent_name])}"
+            # )
 
         # If no clients, still log but don't broadcast
         if not self.clients:
@@ -115,11 +115,11 @@ class WebSocketManager:
             return
 
         # Log broadcast attempt
-        logger.debug(f"Broadcasting {type(event).__name__} to {len(self.clients)} client(s)")
+        # logger.debug(f"Broadcasting {type(event).__name__} to {len(self.clients)} client(s)")
 
         # Serialize event to JSON using Pydantic's model_dump_json
         message = event.model_dump_json()
-        logger.debug(f"Event JSON: {message[:200]}...")  # Log first 200 chars
+        # logger.debug(f"Event JSON: {message[:200]}...")  # Log first 200 chars
 
         # Broadcast to all clients concurrently
         # Use return_exceptions=True to handle client failures gracefully

{flock_core-0.5.0b57 → flock_core-0.5.0b59}/src/flock/frontend/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "flock-ui",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "flock-ui",
-      "version": "0.1.2",
+      "version": "0.1.3",
       "license": "ISC",
       "dependencies": {
         "@types/dagre": "^0.7.53",

{flock_core-0.5.0b57 → flock_core-0.5.0b59}/uv.lock

@@ -970,7 +970,7 @@ wheels = [
 
 [[package]]
 name = "flock-core"
-version = "0.5.0b57"
+version = "0.5.0b59"
 source = { editable = "." }
 dependencies = [
     { name = "devtools" },