gobby 0.2.8__py3-none-any.whl → 0.2.11__py3-none-any.whl

gobby/llm/service.py

@@ -6,7 +6,9 @@ Gemini, LiteLLM) based on the multi-provider config structure with feature-speci
 provider routing.
 """
 
+import asyncio
 import logging
+from collections.abc import AsyncIterator
 from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
@@ -14,6 +16,7 @@ if TYPE_CHECKING:
         DaemonConfig,
     )
     from gobby.llm.base import LLMProvider
+    from gobby.llm.claude import ChatEvent
 
 logger = logging.getLogger(__name__)
 
@@ -234,3 +237,149 @@ class LLMService:
         enabled = self.enabled_providers
         initialized = self.initialized_providers
         return f"LLMService(enabled={enabled}, initialized={initialized})"
+
+    async def stream_chat(
+        self,
+        messages: list[dict[str, str]],
+        provider_name: str | None = None,
+        model: str | None = None,
+    ) -> AsyncIterator[str]:
+        """
+        Stream a chat response from the LLM.
+
+        Takes messages in OpenAI-style format and yields response chunks.
+        Currently simulates streaming by chunking the full response.
+        Real streaming support can be added per-provider later.
+
+        Args:
+            messages: List of message dicts with 'role' and 'content' keys
+            provider_name: Optional provider to use (defaults to default provider)
+            model: Optional model override
+
+        Yields:
+            String chunks of the response
+
+        Example:
+            messages = [
+                {"role": "system", "content": "You are helpful."},
+                {"role": "user", "content": "Hello!"}
+            ]
+            async for chunk in service.stream_chat(messages):
+                print(chunk, end="", flush=True)
+        """
+        # Get provider
+        if provider_name:
+            provider = self.get_provider(provider_name)
+        else:
+            provider = self.get_default_provider()
+
+        # Build prompt from messages
+        system_prompt = None
+        user_messages = []
+
+        for msg in messages:
+            role = msg.get("role", "user")
+            content = msg.get("content", "")
+
+            if role == "system":
+                system_prompt = content
+            else:
+                prefix = "User: " if role == "user" else "Assistant: "
+                user_messages.append(f"{prefix}{content}")
+
+        prompt = "\n\n".join(user_messages)
+        if user_messages:
+            prompt += "\n\nAssistant:"
+
+        # Generate full response
+        response = await provider.generate_text(
+            prompt=prompt,
+            system_prompt=system_prompt,
+            model=model,
+        )
+
+        # Simulate streaming by yielding words with small delays
+        # This provides a better UX while we add real streaming later
+        words = response.split(" ")
+        for i, word in enumerate(words):
+            if i > 0:
+                yield " "
+            yield word
+            # Small delay to simulate streaming (5-15ms per word)
+            await asyncio.sleep(0.008)
+
+    async def stream_chat_with_tools(
+        self,
+        messages: list[dict[str, str]],
+        allowed_tools: list[str],
+        model: str | None = None,
+        max_turns: int = 10,
+    ) -> AsyncIterator["ChatEvent"]:
+        """
+        Stream a chat response with MCP tool support.
+
+        Takes messages in OpenAI-style format and streams response events
+        including text chunks and tool call/result events.
+
+        This method uses the Claude provider's stream_with_mcp_tools(),
+        which requires subscription mode (Claude Agent SDK).
+
+        Args:
+            messages: List of message dicts with 'role' and 'content' keys
+            allowed_tools: List of allowed MCP tool patterns.
+                Tools should be in format "mcp__{server}__{tool}" or patterns
+                like "mcp__gobby-tasks__*" for all tools from a server.
+            model: Optional model override
+            max_turns: Maximum number of agentic turns (default: 10)
+
+        Yields:
+            ChatEvent: One of TextChunk, ToolCallEvent, ToolResultEvent, or DoneEvent.
+
+        Example:
+            >>> allowed_tools = ["mcp__gobby-tasks__*", "mcp__gobby-memory__*"]
+            >>> async for event in service.stream_chat_with_tools(messages, allowed_tools):
+            ...     if isinstance(event, TextChunk):
+            ...         print(event.content, end="")
+        """
+        from gobby.llm.claude import ClaudeLLMProvider, DoneEvent, TextChunk
+
+        # Get Claude provider (required for MCP tools)
+        try:
+            provider = self.get_provider("claude")
+        except ValueError:
+            yield TextChunk(content="Claude provider not configured. MCP tools require Claude.")
+            yield DoneEvent(tool_calls_count=0)
+            return
+
+        if not isinstance(provider, ClaudeLLMProvider):
+            yield TextChunk(content="MCP tools require Claude provider.")
+            yield DoneEvent(tool_calls_count=0)
+            return
+
+        # Build system prompt and user prompt from messages
+        system_prompt = None
+        user_messages = []
+
+        for msg in messages:
+            role = msg.get("role", "user")
+            content = msg.get("content", "")
+
+            if role == "system":
+                system_prompt = content
+            else:
+                prefix = "User: " if role == "user" else "Assistant: "
+                user_messages.append(f"{prefix}{content}")
+
+        prompt = "\n\n".join(user_messages)
+        if user_messages:
+            prompt += "\n\nAssistant:"
+
+        # Stream with MCP tools
+        async for event in provider.stream_with_mcp_tools(
+            prompt=prompt,
+            allowed_tools=allowed_tools,
+            system_prompt=system_prompt,
+            model=model,
+            max_turns=max_turns,
+        ):
+            yield event

gobby/mcp_proxy/importer.py

@@ -5,7 +5,6 @@ import re
 from typing import TYPE_CHECKING, Any
 
 from gobby.config.app import DaemonConfig
-from gobby.config.features import DEFAULT_IMPORT_MCP_SERVER_PROMPT
 from gobby.prompts import PromptLoader
 from gobby.storage.database import DatabaseProtocol
 from gobby.storage.mcp import LocalMCPManager
@@ -20,21 +19,6 @@ logger = logging.getLogger(__name__)
 # Pattern to detect placeholder secrets like <YOUR_API_KEY>
 SECRET_PLACEHOLDER_PATTERN = re.compile(r"<YOUR_[A-Z0-9_]+>")
 
-DEFAULT_GITHUB_FETCH_PROMPT = """Fetch the README from this GitHub repository and extract MCP server configuration:
-
-{github_url}
-
-If the URL doesn't point directly to a README, try to find and fetch the README.md file.
-
-After reading the documentation, extract the MCP server configuration as a JSON object."""
-
-DEFAULT_SEARCH_FETCH_PROMPT = """Search for MCP server: {search_query}
-
-Find the official documentation or GitHub repository for this MCP server.
-Then fetch and read the README or installation docs.
-
-After reading the documentation, extract the MCP server configuration as a JSON object."""
-
 
 class MCPServerImporter:
     """Handles importing MCP servers from various sources."""
@@ -73,11 +57,6 @@ class MCPServerImporter:
 
         self._loader = PromptLoader(project_dir=Path(project_path) if project_path else None)
 
-        # Register fallbacks
-        self._loader.register_fallback("import/github_fetch", lambda: DEFAULT_GITHUB_FETCH_PROMPT)
-        self._loader.register_fallback("import/search_fetch", lambda: DEFAULT_SEARCH_FETCH_PROMPT)
-        self._loader.register_fallback("import/system", lambda: DEFAULT_IMPORT_MCP_SERVER_PROMPT)
-
     async def import_from_project(
         self,
         source_project: str,
@@ -204,19 +183,11 @@ class MCPServerImporter:
 
             # Build prompt to fetch and extract config
             prompt_path = self.import_config.github_fetch_prompt_path or "import/github_fetch"
-            try:
-                prompt = self._loader.render(prompt_path, {"github_url": github_url})
-            except Exception as e:
-                logger.warning(f"Failed to load Github fetch prompt: {e}")
-                prompt = DEFAULT_GITHUB_FETCH_PROMPT.format(github_url=github_url)
+            prompt = self._loader.render(prompt_path, {"github_url": github_url})
 
             # Get system prompt
             sys_prompt_path = self.import_config.prompt_path or "import/system"
-            try:
-                system_prompt = self._loader.render(sys_prompt_path, {})
-            except Exception as e:
-                logger.warning(f"Failed to load import system prompt: {e}")
-                system_prompt = DEFAULT_IMPORT_MCP_SERVER_PROMPT
+            system_prompt = self._loader.render(sys_prompt_path, {})
 
             options = ClaudeAgentOptions(
                 system_prompt=system_prompt,
@@ -268,19 +239,11 @@ class MCPServerImporter:
 
             # Build prompt to search and extract config
             prompt_path = self.import_config.search_fetch_prompt_path or "import/search_fetch"
-            try:
-                prompt = self._loader.render(prompt_path, {"search_query": search_query})
-            except Exception as e:
-                logger.warning(f"Failed to load search fetch prompt: {e}")
-                prompt = DEFAULT_SEARCH_FETCH_PROMPT.format(search_query=search_query)
+            prompt = self._loader.render(prompt_path, {"search_query": search_query})
 
             # Get system prompt
             sys_prompt_path = self.import_config.prompt_path or "import/system"
-            try:
-                system_prompt = self._loader.render(sys_prompt_path, {})
-            except Exception as e:
-                logger.warning(f"Failed to load import system prompt: {e}")
-                system_prompt = DEFAULT_IMPORT_MCP_SERVER_PROMPT
+            system_prompt = self._loader.render(sys_prompt_path, {})
 
             options = ClaudeAgentOptions(
                 system_prompt=system_prompt,

gobby/mcp_proxy/instructions.py

@@ -6,33 +6,16 @@ These instructions are injected into the MCP server via FastMCP's `instructions`
 
 
 def build_gobby_instructions() -> str:
-    """Build XML-structured instructions for Gobby MCP server.
+    """Build compact instructions for Gobby MCP server.
 
-    These instructions teach agents how to use Gobby correctly.
-    Every agent connecting to Gobby receives these automatically.
-
-    The instructions cover:
-    - Session startup sequence
-    - Progressive tool disclosure pattern
-    - Progressive skill disclosure pattern
-    - Critical rules for task management
+    Provides minimal guidance for progressive tool disclosure, caching, and task rules.
+    Startup sequence and skill discovery are now handled via workflow injection.
 
     Returns:
-        XML-structured instructions string
+        XML-structured instructions string (~120 tokens)
     """
     return """<gobby_system>
 
-<startup>
-At the start of EVERY session:
-1. `list_mcp_servers()` — Discover available servers
-2. `list_skills()` — Discover available skills
-3. Session ID: Look for `Gobby Session Ref:` or `Gobby Session ID:` in your context.
-   If missing, call:
-   `call_tool("gobby-sessions", "get_current_session", {"external_id": "<your-session-id>", "source": "<cli-name>"})`
-
-Session and task references use `#N` format (e.g., `#1`, `#42`) which is project-scoped.
-</startup>
-
 <tool_discovery>
 NEVER assume tool schemas. Use progressive disclosure:
 1. `list_tools(server="...")` — Lightweight metadata (~100 tokens/tool)
@@ -40,12 +23,11 @@ NEVER assume tool schemas. Use progressive disclosure:
 3. `call_tool(server, tool, args)` — Execute
 </tool_discovery>
 
-<skill_discovery>
-Skills provide detailed guidance. Use progressive disclosure:
-1. `list_skills()` — Already done at startup
-2. `get_skill(name="...")` — Full content when needed
-3. `search_skills(query="...")` — Find by task description
-</skill_discovery>
+<caching>
+Schema fetches are cached per session. Once you call `get_tool_schema(server, tool)`,
+you can `call_tool` that same server:tool repeatedly WITHOUT re-fetching the schema.
+Do NOT call list_tools or get_tool_schema before every call_tool — only on first use.
+</caching>
 
 <rules>
 - Create/claim a task before using Edit, Write, or NotebookEdit tools

gobby/mcp_proxy/manager.py

@@ -684,6 +684,12 @@ class MCPClientManager:
 
     async def get_tool_input_schema(self, server_name: str, tool_name: str) -> dict[str, Any]:
         """Get full inputSchema for a specific tool."""
+        tool_info = await self.get_tool_info(server_name, tool_name)
+        input_schema = tool_info.get("inputSchema", {})
+        return cast(dict[str, Any], input_schema)
+
+    async def get_tool_info(self, server_name: str, tool_name: str) -> dict[str, Any]:
+        """Get full tool info including name, description, and inputSchema."""
 
         # This is an optimization. Instead of calling list_tools again,
         # we try to fetch it. But standard MCP list_tools returns everything.
@@ -696,9 +702,13 @@ class MCPClientManager:
             # tool might be an object or dict
             t_name = getattr(tool, "name", tool.get("name") if isinstance(tool, dict) else None)
             if t_name == tool_name:
-                # Return schema
-                if isinstance(tool, dict) and "inputSchema" in tool:
-                    return cast(dict[str, Any], tool["inputSchema"])
+                if isinstance(tool, dict):
+                    result: dict[str, Any] = {"name": t_name}
+                    if "description" in tool and tool["description"]:
+                        result["description"] = tool["description"]
+                    if "inputSchema" in tool:
+                        result["inputSchema"] = tool["inputSchema"]
+                    return result
 
         raise MCPError(f"Tool {tool_name} not found on server {server_name}")
 

gobby/mcp_proxy/models.py

@@ -41,6 +41,7 @@ class ToolProxyErrorCode(str, Enum):
     SERVER_NOT_FOUND = "SERVER_NOT_FOUND"
     SERVER_NOT_CONFIGURED = "SERVER_NOT_CONFIGURED"
     TOOL_NOT_FOUND = "TOOL_NOT_FOUND"
+    TOOL_BLOCKED = "TOOL_BLOCKED"
     INVALID_ARGUMENTS = "INVALID_ARGUMENTS"
     EXECUTION_ERROR = "EXECUTION_ERROR"
     CONNECTION_ERROR = "CONNECTION_ERROR"

gobby/mcp_proxy/registries.py

@@ -17,14 +17,18 @@ if TYPE_CHECKING:
     from gobby.memory.manager import MemoryManager
     from gobby.sessions.manager import SessionManager
     from gobby.storage.clones import LocalCloneManager
+    from gobby.storage.database import DatabaseProtocol
     from gobby.storage.inter_session_messages import InterSessionMessageManager
     from gobby.storage.merge_resolutions import MergeResolutionManager
+    from gobby.storage.pipelines import LocalPipelineExecutionManager
     from gobby.storage.session_messages import LocalSessionMessageManager
     from gobby.storage.sessions import LocalSessionManager
     from gobby.storage.tasks import LocalTaskManager
     from gobby.storage.worktrees import LocalWorktreeManager
     from gobby.sync.tasks import TaskSyncManager
     from gobby.tasks.validation import TaskValidator
+    from gobby.workflows.loader import WorkflowLoader
+    from gobby.workflows.pipeline_executor import PipelineExecutor
     from gobby.worktrees.git import WorktreeGitManager
     from gobby.worktrees.merge import MergeResolver
 
@@ -36,6 +40,7 @@ def setup_internal_registries(
     _session_manager: SessionManager | None = None,
     memory_manager: MemoryManager | None = None,
     task_manager: LocalTaskManager | None = None,
+    db: DatabaseProtocol | None = None,
     sync_manager: TaskSyncManager | None = None,
     task_validator: TaskValidator | None = None,
     message_manager: LocalSessionMessageManager | None = None,
@@ -51,6 +56,9 @@ def setup_internal_registries(
     project_id: str | None = None,
     tool_proxy_getter: Callable[[], ToolProxyService | None] | None = None,
     inter_session_message_manager: InterSessionMessageManager | None = None,
+    pipeline_executor: PipelineExecutor | None = None,
+    workflow_loader: WorkflowLoader | None = None,
+    pipeline_execution_manager: LocalPipelineExecutionManager | None = None,
 ) -> InternalRegistryManager:
     """
     Setup internal MCP registries (tasks, messages, memory, metrics, agents, worktrees).
@@ -60,6 +68,7 @@ def setup_internal_registries(
         _session_manager: Session manager (reserved for future use)
         memory_manager: Memory manager for memory operations
         task_manager: Task storage manager
+        db: Database connection for registries that only need storage (skills, artifacts)
         sync_manager: Task sync manager for git sync
         task_validator: Task validator for validation
         message_manager: Message storage manager
@@ -75,6 +84,9 @@ def setup_internal_registries(
         tool_proxy_getter: Callable that returns ToolProxyService for routing
             tool calls in in-process agents. Called lazily during agent execution.
         inter_session_message_manager: Inter-session message manager for agent messaging
+        pipeline_executor: Pipeline executor for running pipelines
+        workflow_loader: Workflow loader for loading pipeline definitions
+        pipeline_execution_manager: Pipeline execution manager for tracking executions
 
     Returns:
         InternalRegistryManager containing all registries
@@ -143,6 +155,7 @@ def setup_internal_registries(
 
     workflows_registry = create_workflows_registry(
         session_manager=local_session_manager,
+        db=getattr(local_session_manager, "db", None) if local_session_manager else None,
     )
     manager.add_registry(workflows_registry)
     logger.debug("Workflows registry initialized")
@@ -190,6 +203,9 @@ def setup_internal_registries(
             git_manager=git_manager,
             clone_storage=clone_storage,
             clone_manager=clone_git_manager,
+            # For mode=self (workflow activation on caller session)
+            workflow_loader=workflow_loader,
+            db=db,
         )
 
         # Add inter-agent messaging tools if message manager and session manager are available
@@ -267,19 +283,64 @@ def setup_internal_registries(
         manager.add_registry(hub_registry)
         logger.debug("Hub registry initialized")
 
-    # Initialize skills registry using the existing database from task_manager
-    # to avoid creating a duplicate connection that would leak
-    if task_manager is not None:
+    # Initialize skills registry if database is available
+    if db is not None:
+        from gobby.config.skills import SkillsConfig
         from gobby.mcp_proxy.tools.skills import create_skills_registry
+        from gobby.skills.hubs import (
+            ClaudePluginsProvider,
+            ClawdHubProvider,
+            GitHubCollectionProvider,
+            HubManager,
+            SkillHubProvider,
+        )
+
+        # Get skills config (or use defaults)
+        skills_config = _config.skills if _config and hasattr(_config, "skills") else SkillsConfig()
+
+        # Create hub manager with configured hubs
+        hub_manager = HubManager(configs=skills_config.hubs)
+
+        # Register provider factories
+        hub_manager.register_provider_factory("clawdhub", ClawdHubProvider)
+        hub_manager.register_provider_factory("skillhub", SkillHubProvider)
+        hub_manager.register_provider_factory("github-collection", GitHubCollectionProvider)
+        hub_manager.register_provider_factory("claude-plugins", ClaudePluginsProvider)
 
         skills_registry = create_skills_registry(
-            db=task_manager.db,
+            db=db,
             project_id=project_id,
+            hub_manager=hub_manager,
         )
         manager.add_registry(skills_registry)
         logger.debug("Skills registry initialized")
     else:
-        logger.debug("Skills registry not initialized: task_manager is None")
+        logger.debug("Skills registry not initialized: db is None")
+
+    # Initialize artifacts registry if database is available
+    if db is not None:
+        from gobby.mcp_proxy.tools.artifacts import create_artifacts_registry
+
+        artifacts_registry = create_artifacts_registry(
+            db=db,
+            session_manager=local_session_manager,
+        )
+        manager.add_registry(artifacts_registry)
+        logger.debug("Artifacts registry initialized")
+    else:
+        logger.debug("Artifacts registry not initialized: db is None")
+
+    # Initialize pipelines registry if pipeline_executor is available
+    if pipeline_executor is not None:
+        from gobby.mcp_proxy.tools.pipelines import create_pipelines_registry
+
+        pipelines_registry = create_pipelines_registry(
+            loader=workflow_loader,
+            executor=pipeline_executor,
+            execution_manager=pipeline_execution_manager,
+        )
+        manager.add_registry(pipelines_registry)
+        logger.debug("Pipelines registry initialized")
 
     logger.info(f"Internal registries initialized: {len(manager)} registries")
     return manager

gobby/mcp_proxy/server.py

@@ -98,6 +98,7 @@ class GobbyDaemonTools:
         server_name: str,
         tool_name: str,
         arguments: dict[str, Any] | None = None,
+        session_id: str | None = None,
     ) -> Any:
         """Call a tool.
 
@@ -105,8 +106,11 @@ class GobbyDaemonTools:
         underlying service indicates an error. This ensures the MCP protocol
         properly signals errors to LLM clients instead of returning error dicts
         as successful responses.
+
+        When session_id is provided and a workflow is active, checks that the
+        tool is not blocked by the current workflow step's blocked_tools setting.
         """
-        result = await self.tool_proxy.call_tool(server_name, tool_name, arguments)
+        result = await self.tool_proxy.call_tool(server_name, tool_name, arguments, session_id)
 
         # Check if result indicates an error (ToolProxyService returns dict with success: False)
         if isinstance(result, dict) and result.get("success") is False:
@@ -382,7 +386,7 @@ class GobbyDaemonTools:
 
         Args:
             event_type: Hook event type (e.g., "session_start", "before_tool")
-            source: Source CLI to simulate (claude, gemini, codex)
+            source: Source CLI to simulate (claude, gemini, codex, cursor, windsurf, copilot)
             data: Optional additional data for the event
 
         Returns:

gobby/mcp_proxy/services/recommendation.py

@@ -15,22 +15,6 @@ logger = logging.getLogger("gobby.mcp.server")
 # Search mode type
 SearchMode = Literal["llm", "semantic", "hybrid"]
 
-DEFAULT_HYBRID_RERANK_PROMPT = """Re-rank the following tools for the task: "{task_description}"
-
-Candidates:
-{candidate_list}
-
-Select the best {top_k} tools. Return JSON:
-{{"recommendations": [{{"server": "...", "tool": "...", "reason": "..."}}]}}"""
-
-DEFAULT_LLM_PROMPT = """Recommend tools for the task: "{task_description}"
-
-Available Servers:
-{available_servers}
-
-Return JSON:
-{{"recommendations": [{{"server": "...", "tool": "...", "reason": "..."}}]}}"""
-
 
 class RecommendationService:
     """Service for recommending tools."""
@@ -49,10 +33,6 @@ class RecommendationService:
         self._project_id = project_id
         self._config = config
         self._loader = PromptLoader()
-        self._loader.register_fallback(
-            "features/recommend_hybrid", lambda: DEFAULT_HYBRID_RERANK_PROMPT
-        )
-        self._loader.register_fallback("features/recommend_llm", lambda: DEFAULT_LLM_PROMPT)
 
     def _get_config(self) -> RecommendToolsConfig:
         """Get config with fallback to defaults."""
@@ -181,10 +161,7 @@ class RecommendationService:
                 "candidate_list": candidate_list,
                 "top_k": top_k,
             }
-            try:
-                prompt = self._loader.render(prompt_path, context)
-            except Exception:
-                prompt = DEFAULT_HYBRID_RERANK_PROMPT.format(**context)
+            prompt = self._loader.render(prompt_path, context)
 
             provider = self._llm_service.get_default_provider()
             response = await provider.generate_text(prompt)
@@ -223,10 +200,7 @@ class RecommendationService:
                 "task_description": task_description,
                 "available_servers": ", ".join(available_servers),
             }
-            try:
-                prompt = self._loader.render(prompt_path, context)
-            except Exception:
-                prompt = DEFAULT_LLM_PROMPT.format(**context)
+            prompt = self._loader.render(prompt_path, context)
 
             provider = self._llm_service.get_default_provider()
             response = await provider.generate_text(prompt)

gobby/mcp_proxy/services/tool_filter.py

@@ -4,6 +4,8 @@ import logging
 from pathlib import Path
 from typing import TYPE_CHECKING, Any
 
+from gobby.workflows.definitions import WorkflowDefinition
+
 if TYPE_CHECKING:
     from gobby.storage.database import LocalDatabase
     from gobby.workflows.loader import WorkflowLoader
@@ -89,6 +91,11 @@ class ToolFilterService:
             logger.warning(f"Workflow '{state.workflow_name}' not found")
             return None
 
+        # Tool filtering only applies to step-based workflows
+        if not isinstance(definition, WorkflowDefinition):
+            logger.debug(f"Workflow '{state.workflow_name}' is not a step-based workflow")
+            return None
+
         step = definition.get_step(state.step)
         if not step:
             logger.warning(f"Step '{state.step}' not found in workflow '{state.workflow_name}'")

gobby/mcp_proxy/services/tool_proxy.py

@@ -208,6 +208,7 @@ class ToolProxyService:
         server_name: str,
         tool_name: str,
         arguments: dict[str, Any] | None = None,
+        session_id: str | None = None,
     ) -> Any:
         """Execute a tool with optional pre-validation.
 
@@ -218,9 +219,24 @@ class ToolProxyService:
         On execution error, includes fallback_suggestions if a fallback resolver
         is configured.
 
+        When session_id is provided and a workflow is active, checks that the
+        tool is not blocked by the current workflow step's blocked_tools setting.
+
         """
         args = arguments or {}
 
+        # Check workflow tool restrictions if session_id provided
+        if session_id and self._tool_filter:
+            is_allowed, reason = self._tool_filter.is_tool_allowed(tool_name, session_id)
+            if not is_allowed:
+                return {
+                    "success": False,
+                    "error": reason,
+                    "error_code": ToolProxyErrorCode.TOOL_BLOCKED.value,
+                    "server_name": server_name,
+                    "tool_name": tool_name,
+                }
+
         # Pre-validate arguments if enabled
         if self._validate_arguments and args:
             schema_result = await self.get_tool_schema(server_name, tool_name)
@@ -361,6 +377,7 @@ class ToolProxyService:
         self,
         tool_name: str,
         arguments: dict[str, Any] | None = None,
+        session_id: str | None = None,
     ) -> Any:
         """
         Call a tool by name, automatically resolving the server.
@@ -371,6 +388,7 @@ class ToolProxyService:
         Args:
             tool_name: Name of the tool to call
             arguments: Tool arguments
+            session_id: Optional session ID for workflow tool restriction checks
 
         Returns:
             Tool execution result, or error dict if tool not found
@@ -386,4 +404,4 @@ class ToolProxyService:
             }
 
         logger.debug(f"Routing tool '{tool_name}' to server '{server_name}'")
-        return await self.call_tool(server_name, tool_name, arguments)
+        return await self.call_tool(server_name, tool_name, arguments, session_id)