flock-core 0.4.532__tar.gz → 0.4.533__tar.gz

{flock_core-0.4.532 → flock_core-0.4.533}/PKG-INFO

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

flock_core-0.4.533/docs/.codex/tool_set.md

@@ -0,0 +1,67 @@
+# Production Tool Set Switch Plan
+
+## Context
+- `FlockAgent.evaluate` currently always forwards `self.tools` to the evaluator; there is no concept of alternate tool bundles.
+- Orchestrated runs (`Flock.run_async` → `workflow.activities.run_agent`) do not pass per-run options beyond the initial inputs stored in `FlockContext`.
+- Web execution (`htmx_run_flock` → `run_current_flock_service`) and REST (`POST /run/flock`) both end up calling `Flock.run_async` with hard-coded parameters; HTML form/templates have no affordance for toggling tool usage.
+- Serialization (`FlockAgent.to_dict/from_dict` and `FlockSerializer`) only know about a single tool list, so persisted YAML/JSON would currently lose any secondary tool configuration.
+
+## Proposed Changes
+1. **Agent Model & Serialization**
+   - Introduce `production_tools: list[Callable] | None` on `FlockAgent` (excluded from serialization by default).
+   - Update `FlockAgent.to_dict/from_dict` plus `FlockSerializer` to persist and restore both tool collections.
+   - Add a helper such as `_resolve_tool_set(tool_set: Literal['dev','production'])` that returns the right list (dev list remains backward compatible default).
+
+2. **Execution Flow**
+   - Extend `FlockAgent.run/run_async/evaluate` signatures with `use_production_tools: bool = False` (keyword-only for clarity).
+   - Store the chosen tool set on the stack (no shared mutation) and have `evaluate` call the helper to pick the correct tool bundle when invoking the evaluator.
+   - Allow orchestrated runs to surface the choice via a new context variable (e.g. `FLOCK_TOOL_SET`) so that `workflow.activities.run_agent` can pass the flag when iterating agents.
+
+3. **Flock Orchestrator**
+   - Add the same boolean flag to `Flock.run/run_async` (and by extension `run_batch_async` if batch runs should support it), defaulting to dev tools.
+   - When initializing the context (`initialize_context`) persist the selection, and ensure both local (`run_local_workflow`) and Temporal execution paths propagate it down to each agent invocation.
+
+4. **API & Services**
+   - Extend `FlockAPIRequest` with `use_production_tools: bool = False`, update the REST handler to forward the flag into `_execute_flock_run_task`.
+   - Update `run_current_flock_service` and any other server-side helper that triggers `Flock.run_async` so the flag is threaded through.
+   - Review/adjust other entry points (CLI helpers, schedulers, shared-run flows) for calls to `Flock.run_async` or `FlockAgent.run_async` to either expose the flag or explicitly opt into dev tools.
+
+5. **Web UI**
+   - Modify `partials/_execution_form.html` to add a checkbox labelled for production tools.
+   - Add a confirmation modal/JS prompt before submitting when the checkbox is checked, ensuring HTMX submission includes the new form value.
+   - Adjust `htmx_run_flock` to parse the form flag and pass it to `run_current_flock_service`; update the rendered form state as needed.
+
+6. **Tool Registration Utilities**
+   - Update helper factories (`FlockFactory.create_default_agent`, editor service for agent CRUD) to accept and wire `production_tools` if provided so UI/editor flows can manage both sets without manual patching.
+
+## Validation Plan
+- Unit-style exercise: new test or dummied script ensuring an agent with distinct dev/prod tool lists executes the correct callable based on the flag.
+- Web layer smoke test: via HTMX form submission, confirm the checkbox toggles which tool is invoked (can be logged/printed during dev).
+- REST test: `uv run flock --web` and POST to `/ui/api/run/flock` with `use_production_tools=true`, verify response indicates production tool path.
+- Regression sweep: run `uv run pytest` (or a focused subset) to ensure serialization changes don’t break existing expectations.
+
+## Open Considerations
+- Confirm whether shared-run or batch workflows must surface the flag (requirement only mentions direct runs; plan assumes batch remains dev-only unless requested otherwise).
+- Decide how to handle agents lacking a production tool list when the flag is enabled (proposed behaviour: fall back to dev tools, plus warning log).
+- Ensure concurrency safety if multiple runs toggle tool sets concurrently—using per-call parameters instead of mutating agent state should avoid cross-talk.
+
+## Implementation Summary
+
+- **Agent Model Extensions**
+  - Added a `production_tools` field and runtime helper `_get_runtime_tools`, enabling evaluators to receive either the default or production list without mutating agent state (`src/flock/core/flock_agent.py#L100`, `src/flock/core/flock_agent.py#L334`).
+  - Serialization/deserialization updated to persist both tool collections, plus registration of production tools during flock export (`src/flock/core/flock_agent.py#L724`, `src/flock/core/flock_agent.py#L930`, `src/flock/core/serialization/flock_serializer.py#L262`).
+  - `FlockFactory.create_default_agent` accepts an optional production list for UI/editor flows (`src/flock/core/flock_factory.py#L398`).
+
+- **Execution Propagation**
+  - `Flock.run/run_async` now accept `use_production_tools`; the flag is stored in context via `initialize_context` for downstream consumers (`src/flock/core/flock.py#L465`, `src/flock/core/context/context_manager.py#L14`).
+  - Local and Temporal workflows read the shared context value before invoking each agent, ensuring chained agents share the same selection (`src/flock/workflow/activities.py#L68`, `src/flock/workflow/agent_execution_activity.py#L81`).
+
+- **API & UI Integration**
+  - REST model/endpoint extended with a `use_production_tools` boolean that is forwarded into flock execution (`src/flock/core/api/models.py#L17`, `src/flock/core/api/endpoints.py#L81`).
+  - Web execution form gains a confirmation-backed checkbox; HTMX handler and service propagate the flag to `Flock.run_async` (`src/flock/webapp/templates/partials/_execution_form.html#L37`, `src/flock/webapp/app/api/execution.py#L145`, `src/flock/webapp/app/services/flock_service.py#L249`).
+
+- **Testing & Example**
+  - Added `examples/02-core-concepts/10-production-tools-toggle.py`, a compact integration script that drives the new flag through `Flock.run` and prints tool usage, validated via `uv run` with model `openai/gpt-4.1`.
+
+- **Outcome**
+  - Agents default to development tools, but a run-wide toggle can switch all agents in the context to their production tool set, falling back gracefully when unspecified. The web UI and REST API surface the new control, while serialization keeps both tool bundles intact for config handoff.

{flock_core-0.4.532 → flock_core-0.4.533}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "flock-core"
-version = "0.4.532"
+version = "0.4.533"
 description = "Declarative LLM Orchestration at Scale"
 readme = "README.md"
 authors = [

{flock_core-0.4.532 → flock_core-0.4.533}/src/flock/core/api/endpoints.py

@@ -78,7 +78,9 @@ def create_api_router() -> APIRouter:
             # For this refactoring step, let's assume a helper `_execute_flock_run` exists
             # that we can call.
 
-            async def _execute_flock_run_task(run_id_task, agent_name_task, inputs_task):
+            async def _execute_flock_run_task(
+                run_id_task, agent_name_task, inputs_task, use_production_tools_task
+            ):
                 # This is a simplified version of what was in FlockAPI._run_flock
                 try:
                     if agent_name_task not in flock_instance.agents:
@@ -89,7 +91,9 @@ def create_api_router() -> APIRouter:
                     typed_inputs = inputs_task # Simplified for now
 
                     result = await flock_instance.run_async(
-                        start_agent=agent_name_task, input=typed_inputs
+                        start_agent=agent_name_task,
+                        input=typed_inputs,
+                        use_production_tools=use_production_tools_task,
                     )
                     run_store.update_run_result(run_id_task, result)
                 except Exception as e_task:
@@ -106,6 +110,7 @@ def create_api_router() -> APIRouter:
                     run_id,
                     request_model.agent_name,
                     processed_inputs,
+                    request_model.use_production_tools,
                 )
                 run_store.update_run_status(run_id, "running")
                 response_data.status = "running"
@@ -114,7 +119,10 @@ def create_api_router() -> APIRouter:
                     f"Running flock '{request_model.agent_name}' synchronously (run_id: {run_id})"
                 )
                 await _execute_flock_run_task(
-                     run_id, request_model.agent_name, processed_inputs
+                    run_id,
+                    request_model.agent_name,
+                    processed_inputs,
+                    request_model.use_production_tools,
                 )
                 response_data = run_store.get_run(run_id)
 

{flock_core-0.4.532 → flock_core-0.4.533}/src/flock/core/api/models.py

@@ -17,6 +17,10 @@ class FlockAPIRequest(BaseModel):
     async_run: bool = Field(
         default=False, description="Whether to run asynchronously"
     )
+    use_production_tools: bool = Field(
+        default=False,
+        description="If true, run agents with their production tool set where available",
+    )
 
 
 class FlockAPIResponse(BaseModel):

{flock_core-0.4.532 → flock_core-0.4.533}/src/flock/core/context/context_manager.py

@@ -7,6 +7,7 @@ from flock.core.context.context_vars import (
     FLOCK_LOCAL_DEBUG,
     FLOCK_MODEL,
     FLOCK_RUN_ID,
+    FLOCK_USE_PRODUCTION_TOOLS,
 )
 
 
@@ -17,6 +18,7 @@ def initialize_context(
     run_id: str,
     local_debug: bool,
     model: str,
+    use_production_tools: bool,
 ) -> None:
     """Initialize the FlockContext with standard variables before running an agent.
 
@@ -35,3 +37,4 @@ def initialize_context(
     context.run_id = run_id
     context.set_variable(FLOCK_RUN_ID, run_id)
     context.set_variable(FLOCK_MODEL, model)
+    context.set_variable(FLOCK_USE_PRODUCTION_TOOLS, use_production_tools)

{flock_core-0.4.532 → flock_core-0.4.533}/src/flock/core/context/context_vars.py

@@ -8,3 +8,4 @@ FLOCK_LAST_AGENT = "flock.last_agent"
 FLOCK_LAST_RESULT = "flock.last_result"
 FLOCK_MODEL = "flock.model"
 FLOCK_BATCH_SILENT_MODE = "flock.batch_silent"
+FLOCK_USE_PRODUCTION_TOOLS = "flock.use_production_tools"

{flock_core-0.4.532 → flock_core-0.4.533}/src/flock/core/flock.py

@@ -472,6 +472,8 @@ class Flock(BaseModel, Serializable):
         agents: list[FlockAgent] | None = None,
         servers: list[FlockMCPServerBase] | None = None,
         memo: dict[str, Any] | None = None,
+        *,
+        use_production_tools: bool = False,
     ) -> Box | dict:
         return self._run_sync(
             self.run_async(
@@ -483,6 +485,7 @@ class Flock(BaseModel, Serializable):
                 agents=agents,
                 servers=servers,
                 memo=memo,
+                use_production_tools=use_production_tools,
             )
         )
 
@@ -496,6 +499,8 @@ class Flock(BaseModel, Serializable):
         agents: list[FlockAgent] | None = None,
         servers: list[FlockMCPServerBase] | None = None,
         memo: dict[str, Any] | None = None,
+        *,
+        use_production_tools: bool = False,
     ) -> Box | dict:
         """Entry point for running an agent system asynchronously."""
         # Import here to allow forward reference resolution
@@ -588,6 +593,7 @@ class Flock(BaseModel, Serializable):
                     effective_run_id,
                     not self.enable_temporal,  # local_debug is inverse of enable_temporal
                     self.model or resolved_start_agent.model or DEFAULT_MODEL,
+                    use_production_tools,
                 )
                 # Add agent definitions to context for routing/serialization within workflow
                 for agent_name_iter, agent_instance_iter in self.agents.items():

{flock_core-0.4.532 → flock_core-0.4.533}/src/flock/core/flock_agent.py

@@ -94,9 +94,13 @@ class FlockAgent(BaseModel, Serializable, DSPyIntegrationMixin, ABC):
     tools: list[Callable[..., Any]] | None = (
         Field(  # Assume tools are always callable for serialization simplicity
             default=None,
-            description="List of callable tools the agent can use. These must be registered.",
+            description="List of callable tools the agent can use for development/default runs.",
         )
     )
+    production_tools: list[Callable[..., Any]] | None = Field(
+        default=None,
+        description="Optional list of callable tools to use when production tool set is enabled.",
+    )
     servers: list[str | FlockMCPServerBase] | None = Field(
         default=None,
         description="List of MCP Servers the agent can use to enhance its capabilities. These must be registered.",
@@ -151,6 +155,7 @@ class FlockAgent(BaseModel, Serializable, DSPyIntegrationMixin, ABC):
         input: SignatureType = None,
         output: SignatureType = None,
         tools: list[Callable[..., Any]] | None = None,
+        production_tools: list[Callable[..., Any]] | None = None,
         servers: list[str | FlockMCPServerBase] | None = None,
         evaluator: "FlockEvaluator | None" = None,
         handoff_router: "FlockRouter | None" = None,
@@ -168,6 +173,7 @@ class FlockAgent(BaseModel, Serializable, DSPyIntegrationMixin, ABC):
             input=input,  # Store the raw input spec
             output=output,  # Store the raw output spec
             tools=tools,
+            production_tools=production_tools,
             servers=servers,
             write_to_file=write_to_file,
             wait_for_input=wait_for_input,
@@ -325,7 +331,27 @@ class FlockAgent(BaseModel, Serializable, DSPyIntegrationMixin, ABC):
                 )
                 span.record_exception(module_error)
 
-    async def evaluate(self, inputs: dict[str, Any]) -> dict[str, Any]:
+    def _get_runtime_tools(self, use_production_tools: bool | None = None) -> list[Callable[..., Any]]:
+        """Select the tool list for the current run."""
+        if use_production_tools and self.production_tools:
+            logger.info(
+                "Using production tool set",
+                agent=self.name,
+                tool_count=len(self.production_tools),
+            )
+            return list(self.production_tools)
+
+        if use_production_tools and not self.production_tools:
+            logger.warning(
+                "Production tool set requested but not configured; falling back to default tools",
+                agent=self.name,
+            )
+
+        return list(self.tools or [])
+
+    async def evaluate(
+        self, inputs: dict[str, Any], *, use_production_tools: bool | None = None
+    ) -> dict[str, Any]:
         """Core evaluation logic, calling the assigned evaluator and modules."""
         if not self.evaluator:
             raise RuntimeError(
@@ -351,11 +377,7 @@ class FlockAgent(BaseModel, Serializable, DSPyIntegrationMixin, ABC):
             # Actual evaluation
             try:
                 # Pass registered tools if the evaluator needs them
-                registered_tools = []
-                if self.tools:
-                    # Ensure tools are actually retrieved/validated if needed by evaluator type
-                    # For now, assume evaluator handles tool resolution if necessary
-                    registered_tools = self.tools
+                registered_tools = self._get_runtime_tools(use_production_tools)
 
                 # Retrieve available mcp_tools if the evaluator needs them
                 mcp_tools = []
@@ -415,7 +437,10 @@ class FlockAgent(BaseModel, Serializable, DSPyIntegrationMixin, ABC):
 
                             async def _final_handler():
                                 return await self.evaluator.evaluate(
-                                    self, current_inputs, registered_tools
+                                    self,
+                                    current_inputs,
+                                    registered_tools,
+                                    mcp_tools=mcp_tools,
                                 )
 
                             idx = 0
@@ -434,20 +459,26 @@ class FlockAgent(BaseModel, Serializable, DSPyIntegrationMixin, ABC):
                         else:
                             # No pipeline registered, direct evaluation
                             result = await self.evaluator.evaluate(
-                                self, current_inputs, registered_tools
+                                self,
+                                current_inputs,
+                                registered_tools,
+                                mcp_tools=mcp_tools,
                             )
                     except ImportError:
                         # wd.di not installed – fall back
                         result = await self.evaluator.evaluate(
-                            self, current_inputs, registered_tools
+                            self,
+                            current_inputs,
+                            registered_tools,
+                            mcp_tools=mcp_tools,
                         )
                 else:
                     # No DI container – standard execution
                     result = await self.evaluator.evaluate(
                         self,
-                    current_inputs,
-                    registered_tools,
-                    mcp_tools=mcp_tools,
+                        current_inputs,
+                        registered_tools,
+                        mcp_tools=mcp_tools,
                     )
             except Exception as eval_error:
                 logger.error(
@@ -477,7 +508,9 @@ class FlockAgent(BaseModel, Serializable, DSPyIntegrationMixin, ABC):
             logger.debug(f"Evaluation completed for agent '{self.name}'")
             return current_result
 
-    def run(self, inputs: dict[str, Any]) -> dict[str, Any]:
+    def run(
+        self, inputs: dict[str, Any], *, use_production_tools: bool | None = None
+    ) -> dict[str, Any]:
         """Synchronous wrapper for run_async."""
         try:
             loop = asyncio.get_running_loop()
@@ -486,7 +519,9 @@ class FlockAgent(BaseModel, Serializable, DSPyIntegrationMixin, ABC):
         ):  # 'RuntimeError: There is no current event loop...'
             loop = asyncio.new_event_loop()
             asyncio.set_event_loop(loop)
-        return loop.run_until_complete(self.run_async(inputs))
+        return loop.run_until_complete(
+            self.run_async(inputs, use_production_tools=use_production_tools)
+        )
 
     def set_model(self, model: str):
         """Set the model for the agent and its evaluator."""
@@ -505,14 +540,18 @@ class FlockAgent(BaseModel, Serializable, DSPyIntegrationMixin, ABC):
                 f"Agent '{self.name}' has no evaluator to set model for."
             )
 
-    async def run_async(self, inputs: dict[str, Any]) -> dict[str, Any]:
+    async def run_async(
+        self, inputs: dict[str, Any], *, use_production_tools: bool | None = None
+    ) -> dict[str, Any]:
         """Asynchronous execution logic with lifecycle hooks."""
         with tracer.start_as_current_span("agent.run") as span:
             span.set_attribute("agent.name", self.name)
             span.set_attribute("inputs", str(inputs))
             try:
                 await self.initialize(inputs)
-                result = await self.evaluate(inputs)
+                result = await self.evaluate(
+                    inputs, use_production_tools=use_production_tools
+                )
                 await self.terminate(inputs, result)
                 span.set_attribute("result", str(result))
                 logger.info("Agent run completed", agent=self.name)
@@ -724,6 +763,7 @@ class FlockAgent(BaseModel, Serializable, DSPyIntegrationMixin, ABC):
             "modules",
             "handoff_router",
             "tools",
+            "production_tools",
             "servers",
         ]
 
@@ -869,6 +909,34 @@ class FlockAgent(BaseModel, Serializable, DSPyIntegrationMixin, ABC):
                     f"Added {len(serialized_tools)} tools to agent '{self.name}'"
                 )
 
+        if self.production_tools:
+            logger.debug(
+                f"Serializing {len(self.production_tools)} production tools for agent '{self.name}'"
+            )
+            serialized_prod_tools = []
+            for tool in self.production_tools:
+                if callable(tool) and not isinstance(tool, type):
+                    path_str = FlockRegistry.get_callable_path_string(tool)
+                    if path_str:
+                        func_name = path_str.split(".")[-1]
+                        serialized_prod_tools.append(func_name)
+                        logger.debug(
+                            f"Added production tool '{func_name}' (from path '{path_str}') to agent '{self.name}'"
+                        )
+                    else:
+                        logger.warning(
+                            f"Could not get path string for production tool {tool} in agent '{self.name}'. Skipping."
+                        )
+                else:
+                    logger.warning(
+                        f"Non-callable item found in production tools list for agent '{self.name}': {tool}. Skipping."
+                    )
+            if serialized_prod_tools:
+                data["production_tools"] = serialized_prod_tools
+                logger.debug(
+                    f"Added {len(serialized_prod_tools)} production tools to agent '{self.name}'"
+                )
+
         if is_descrition_callable:
             path_str = FlockRegistry.get_callable_path_string(self.description)
             if path_str:
@@ -930,6 +998,7 @@ class FlockAgent(BaseModel, Serializable, DSPyIntegrationMixin, ABC):
         component_configs = {}
         callable_configs = {}
         tool_config = []
+        production_tool_config = []
         servers_config = []
         agent_data = {}
 
@@ -945,6 +1014,7 @@ class FlockAgent(BaseModel, Serializable, DSPyIntegrationMixin, ABC):
             "output_callable",
         ]
         tool_key = "tools"
+        production_tool_key = "production_tools"
 
         servers_key = "mcp_servers"
 
@@ -955,10 +1025,13 @@ class FlockAgent(BaseModel, Serializable, DSPyIntegrationMixin, ABC):
                 callable_configs[key] = value
             elif key == tool_key and value is not None:
                 tool_config = value  # Expecting a list of names
+            elif key == production_tool_key and value is not None:
+                production_tool_config = value
             elif key == servers_key and value is not None:
                 servers_config = value  # Expecting a list of names
             elif key not in component_keys + callable_keys + [
                 tool_key,
+                production_tool_key,
                 servers_key,
             ]:  # Avoid double adding
                 agent_data[key] = value
@@ -1075,6 +1148,33 @@ class FlockAgent(BaseModel, Serializable, DSPyIntegrationMixin, ABC):
                         exc_info=True,
                     )
 
+        agent.production_tools = []
+        if production_tool_config:
+            logger.debug(
+                f"Deserializing {len(production_tool_config)} production tools for '{agent.name}'"
+            )
+            for tool_name_or_path in production_tool_config:
+                try:
+                    found_tool = registry.get_callable(tool_name_or_path)
+                    if found_tool and callable(found_tool):
+                        agent.production_tools.append(found_tool)
+                        logger.debug(
+                            f"Resolved and added production tool '{tool_name_or_path}' for agent '{agent.name}'"
+                        )
+                    else:
+                        logger.warning(
+                            f"Registry returned non-callable for production tool '{tool_name_or_path}' for agent '{agent.name}'. Skipping."
+                        )
+                except (ValueError) as e:
+                    logger.warning(
+                        f"Could not resolve production tool '{tool_name_or_path}' for agent '{agent.name}': {e}. Skipping."
+                    )
+                except Exception as e:
+                    logger.error(
+                        f"Unexpected error resolving production tool '{tool_name_or_path}' for agent '{agent.name}': {e}. Skipping.",
+                        exc_info=True,
+                    )
+
         # --- Deserialize Servers ---
         agent.servers = []  # Initialize Servers list.
         if servers_config:

{flock_core-0.4.532 → flock_core-0.4.533}/src/flock/core/flock_factory.py

@@ -398,6 +398,7 @@ class FlockFactory:
         input: SignatureType = None,
         output: SignatureType = None,
         tools: list[Callable[..., Any] | Any] | None = None,
+        production_tools: list[Callable[..., Any] | Any] | None = None,
         servers: list[str | FlockMCPServerBase] | None = None,
         use_cache: bool = True,
         enable_rich_tables: bool = False,
@@ -443,6 +444,7 @@ class FlockFactory:
             input=input,
             output=output,
             tools=tools,
+            production_tools=production_tools,
             servers=servers,
             model=model,
             description=description,

{flock_core-0.4.532 → flock_core-0.4.533}/src/flock/core/serialization/flock_serializer.py

@@ -262,6 +262,32 @@ class FlockSerializer:
                                         )
                                     )
 
+                production_tool_names = agent_data.get("production_tools")
+                if production_tool_names:
+                    logger.debug(
+                        f"Extracting production tool information from agent '{name}': {production_tool_names}"
+                    )
+                    prod_tool_objs = (
+                        agent_instance.production_tools
+                        if agent_instance.production_tools
+                        else []
+                    )
+                    for i, tool_name in enumerate(production_tool_names):
+                        if tool_name not in components and i < len(prod_tool_objs):
+                            tool = prod_tool_objs[i]
+                            if callable(tool) and not isinstance(tool, type):
+                                path_str = (
+                                    FlockRegistry.get_callable_path_string(tool)
+                                )
+                                if path_str:
+                                    logger.debug(
+                                        f"Adding production tool '{tool_name}' (from path '{path_str}') to components"
+                                    )
+                                    components[tool_name] = (
+                                        FlockSerializer._get_callable_definition(
+                                            path_str, tool_name, path_type
+                                        )
+                                    )
             except Exception as e:
                 logger.error(
                     f"Failed to serialize agent '{name}' within Flock: {e}",

{flock_core-0.4.532 → flock_core-0.4.533}/src/flock/webapp/app/api/execution.py

@@ -144,6 +144,9 @@ async def htmx_run_flock(
 
     form_data = await request.form()
     start_agent_name = form_data.get("start_agent_name")
+    use_production_flag = str(
+        form_data.get("use_production_tools", "")
+    ).lower() in {"true", "on", "1"}
 
     if not start_agent_name:
         logger.warning("HTMX Run (Regular): Starting agent not selected.")
@@ -204,7 +207,10 @@ async def htmx_run_flock(
             )
 
     result_data = await run_current_flock_service(
-        start_agent_name, inputs, request.app.state
+        start_agent_name,
+        inputs,
+        request.app.state,
+        use_production_tools=use_production_flag,
     )
 
     raw_json_for_template = json.dumps(

{flock_core-0.4.532 → flock_core-0.4.533}/src/flock/webapp/app/services/flock_service.py

@@ -250,9 +250,14 @@ async def run_current_flock_service(
     start_agent_name: str,
     inputs: dict[str, Any],
     app_state: Any,
+    *,
+    use_production_tools: bool = False,
 ) -> dict[str, Any]:
     """Runs the specified agent from the current flock instance in app_state."""
-    logger.info(f"Attempting to run agent: {start_agent_name} using flock from app_state.")
+    logger.info(
+        f"Attempting to run agent: {start_agent_name} using flock from app_state.",
+        use_production_tools=use_production_tools,
+    )
 
     current_flock: Flock | None = getattr(app_state, "flock_instance", None)
     run_store: RunStore | None = getattr(app_state, "run_store", None)
@@ -281,7 +286,10 @@ async def run_current_flock_service(
         logger.info(f"Executing agent '{start_agent_name}' from flock '{current_flock.name}' using app_state.")
         # Direct execution using the flock from app_state
         result = await current_flock.run_async(
-            start_agent=start_agent_name, input=inputs, box_result=False
+            start_agent=start_agent_name,
+            input=inputs,
+            box_result=False,
+            use_production_tools=use_production_tools,
         )
         # Store run details using the run_store from app_state
         if hasattr(run_store, "add_run_details"): # Check if RunStore has this method

{flock_core-0.4.532 → flock_core-0.4.533}/src/flock/webapp/templates/partials/_execution_form.html

@@ -34,6 +34,15 @@
             <progress indeterminate></progress> Loading input form...
         </div>
 
+        <fieldset style="margin-top: 1rem;">
+            <label style="display: flex; gap: 0.5rem; align-items: center;">
+                <input type="checkbox" name="use_production_tools" value="true"
+                    @change="if ($event.target.checked && !confirm('Use production tool set? These calls may access live systems.')) { $event.target.checked = false; }">
+                <span>Use production tool set</span>
+            </label>
+            <small>Production tools may connect to live services.</small>
+        </fieldset>
+
         <button type="submit" {% if not flock.agents %}disabled{% endif %}>Run Flock</button>
         <div id="share-agent-link-container" style="margin-top: 0.5rem;">
             <a href="#" id="shareAgentHtmxLink" hx-post="{{ url_for('htmx_generate_share_link') }}"
@@ -115,4 +124,4 @@
         // If there are other unrelated JavaScript functions in this script block,
         // they would remain.
     });
-</script>
+</script>

{flock_core-0.4.532 → flock_core-0.4.533}/src/flock/workflow/activities.py

@@ -6,7 +6,11 @@ from opentelemetry import trace
 from temporalio import activity
 
 from flock.core.context.context import FlockContext
-from flock.core.context.context_vars import FLOCK_CURRENT_AGENT, FLOCK_MODEL
+from flock.core.context.context_vars import (
+    FLOCK_CURRENT_AGENT,
+    FLOCK_MODEL,
+    FLOCK_USE_PRODUCTION_TOOLS,
+)
 from flock.core.flock_agent import FlockAgent
 from flock.core.flock_registry import get_registry
 from flock.core.flock_router import HandOffRequest
@@ -64,7 +68,19 @@ async def run_agent(context: FlockContext) -> dict:
                 with tracer.start_as_current_span("execute_agent") as exec_span:
                     logger.info("Executing agent", agent=agent.name)
                     try:
-                        result = await agent.run_async(agent_inputs)
+                        use_prod_tools = bool(
+                            context.get_variable(
+                                FLOCK_USE_PRODUCTION_TOOLS, False
+                            )
+                        )
+                        exec_span.set_attribute(
+                            "tools.selection",
+                            "production" if use_prod_tools else "dev",
+                        )
+                        result = await agent.run_async(
+                            agent_inputs,
+                            use_production_tools=use_prod_tools,
+                        )
                         exec_span.set_attribute("result", str(result))
                         logger.debug(
                             "Agent execution completed", agent=agent.name

{flock_core-0.4.532 → flock_core-0.4.533}/src/flock/workflow/agent_execution_activity.py

@@ -10,7 +10,10 @@ from temporalio import activity
 # Third-party imports only within activity functions if needed, or pass context
 # For core flock types, import directly
 from flock.core.context.context import FlockContext
-from flock.core.context.context_vars import FLOCK_MODEL
+from flock.core.context.context_vars import (
+    FLOCK_MODEL,
+    FLOCK_USE_PRODUCTION_TOOLS,
+)
 from flock.core.flock_agent import FlockAgent  # Import concrete class if needed
 from flock.core.flock_registry import get_registry
 from flock.core.flock_router import HandOffRequest
@@ -78,8 +81,17 @@ async def execute_single_agent(agent_name: str, context: FlockContext) -> dict:
         )
 
         try:
+            use_prod_tools = bool(
+                context.get_variable(FLOCK_USE_PRODUCTION_TOOLS, False)
+            )
+            span.set_attribute(
+                "tools.selection",
+                "production" if use_prod_tools else "dev",
+            )
             # Execute just this agent
-            result = await agent.run_async(agent_inputs)
+            result = await agent.run_async(
+                agent_inputs, use_production_tools=use_prod_tools
+            )
             # Avoid logging potentially large results directly to span attributes
             result_str = str(result)
             span.set_attribute("result.type", type(result).__name__)