fastworkflow 2.16.0__py3-none-any.whl → 2.17.1__py3-none-any.whl

fastworkflow/run_fastapi_mcp/mcp_specific.py

@@ -0,0 +1,103 @@
+# pyright: reportUnusedFunction=false
+
+from fastapi_mcp import FastApiMCP
+
+def setup_mcp(
+    app,
+    session_manager,
+):
+    """Mount MCP to automatically convert FastAPI endpoints to MCP tools.
+
+    FastAPI endpoints are automatically exposed as MCP tools, except those in the exclude list.
+    
+    Key exposed tools:
+    - invoke_agent: Streaming agent invocation with NDJSON/SSE support (from /invoke_agent_stream)
+    - invoke_assistant: Assistant mode (deterministic execution)
+    - new_conversation, get_all_conversations, post_feedback, activate_conversation
+    
+    MCP Client Setup:
+    - MCP clients use pre-configured long-lived access tokens (generated via /admin/generate_mcp_token)
+    - Tokens are added to the MCP client configuration, not obtained via tool calls
+    - No need for initialize or refresh_token tools in MCP context
+    
+    Note: Prompt registration (format-command, clarify-params) is commented out
+    as fastapi-mcp 0.4.0 does not support custom prompts.
+    """
+
+    # =========================================================================
+    # Mount MCP (FastApiMCP will scan and find all FastAPI endpoints)
+    # =========================================================================
+    
+    # Exclude endpoints that should not be exposed as MCP tools:
+    # - root: HTML homepage endpoint
+    # - dump_all_conversations: Admin-only endpoint for dumping all user conversations
+    # - generate_mcp_token: Admin-only endpoint for generating long-lived MCP tokens
+    # - rest_initialize: Regular initialization (MCP clients use pre-configured tokens, don't need to initialize)
+    # - perform_action: Low-level action execution (use invoke_agent/invoke_assistant instead)
+    # - rest_invoke_agent: Non-streaming version (use "invoke_agent" streaming endpoint instead)
+    # - refresh_token: JWT token refresh (not needed for MCP since MCP uses long-lived tokens)
+    #
+    # Exposed MCP tools:
+    # - invoke_agent (operation_id) → /invoke_agent_stream endpoint (streaming with NDJSON/SSE support)
+    # - invoke_assistant: Assistant mode (deterministic execution)
+    # - new_conversation, get_all_conversations, post_feedback, activate_conversation
+    #
+    # Note: MCP clients are configured with long-lived access tokens generated via /admin/generate_mcp_token
+    mcp = FastApiMCP(
+        app, 
+        exclude_operations=[
+            "root", 
+            "dump_all_conversations",
+            "generate_mcp_token",
+            "rest_initialize",
+            "perform_action", 
+            "rest_invoke_agent",
+            "refresh_token"
+        ]
+    )
+    mcp.mount_http()
+
+    # Note: Prompt registration is not supported in fastapi-mcp 0.4.0
+    # The library automatically converts FastAPI endpoints to MCP tools,
+    # but does not provide a way to register custom prompts.
+    # Prompts may be added in a future version or via manual MCP server implementation.
+    
+    # TODO: Re-enable when fastapi-mcp supports prompts or implement custom prompt handler
+    # # Prompts
+    # mcp.add_prompt(
+    #     name="format-command",
+    #     description="Given command metadata and a user intent, format a single executable command with XML-tagged parameters.",
+    #     arguments=[{"name": "intent", "required": True}, {"name": "metadata", "required": True}],
+    #     handler=lambda intent, metadata: [
+    #         {
+    #             "role": "user",
+    #             "content": {
+    #                 "type": "text",
+    #                 "text": (
+    #                     f"Intent: {intent}\n\nMetadata:\n{metadata}\n\n"
+    #                     "Format a single command: command_name <param>value</param> ..."
+    #                 ),
+    #             },
+    #         }
+    #     ],
+    # )
+    #
+    # mcp.add_prompt(
+    #     name="clarify-params",
+    #     description="Compose a concise clarification question for missing parameters using the provided metadata.",
+    #     arguments=[{"name": "error_message", "required": True}, {"name": "metadata", "required": True}],
+    #     handler=lambda error_message, metadata: [
+    #         {
+    #             "role": "user",
+    #             "content": {
+    #                 "type": "text",
+    #                 "text": (
+    #                     f"{error_message}\n\nMetadata:\n{metadata}\n\n"
+    #                     "Ask one short question to request the missing parameters."
+    #                 ),
+    #             },
+    #         }
+    #     ],
+    # )
+
+

fastworkflow/run_fastapi_mcp/redoc_2_standalone_html.py

@@ -0,0 +1,40 @@
+"""
+Script to export the ReDoc documentation page into a standalone HTML file.
+Created by https://github.com/pawamoy on https://github.com/Redocly/redoc/issues/726#issuecomment-645414239
+"""
+
+
+import json
+
+from services.run_fastapi.main import app
+
+HTML_TEMPLATE = """<!DOCTYPE html>
+<html>
+<head>
+    <meta http-equiv="content-type" content="text/html; charset=UTF-8">
+    <title>My Project - ReDoc</title>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <link rel="shortcut icon" href="https://fastapi.tiangolo.com/img/favicon.png">
+    <style>
+        body {
+            margin: 0;
+            padding: 0;
+        }
+    </style>
+    <style data-styled="" data-styled-version="4.4.1"></style>
+</head>
+<body>
+    <div id="redoc-container"></div>
+    <script src="https://cdn.jsdelivr.net/npm/redoc/bundles/redoc.standalone.js"> </script>
+    <script>
+        var spec = %s;
+        Redoc.init(spec, {}, document.getElementById("redoc-container"));
+    </script>
+</body>
+</html>
+"""
+
+if __name__ == "__main__":
+    with open("redoc.html", "w", encoding="utf-8") as fd:
+        print(HTML_TEMPLATE % json.dumps(app.openapi()), file=fd)

fastworkflow/run_fastapi_mcp/utils.py

@@ -0,0 +1,427 @@
+import asyncio
+import os
+import queue
+import time
+from dataclasses import dataclass
+from typing import Any, Optional
+
+from fastapi import HTTPException, status, Depends
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+from jose import JWTError
+from pydantic import BaseModel, field_validator
+
+import fastworkflow
+from fastworkflow.utils.logging import logger
+
+from .conversation_store import ConversationStore, restore_history_from_turns
+from .jwt_manager import verify_token
+
+
+# ============================================================================
+# Data Models (aligned with FastWorkflow canonical types)
+# ============================================================================
+
+class InitializationRequest(BaseModel):
+    """Request to initialize a FastWorkflow session for a user"""
+    user_id: str
+    stream_format: Optional[str] = None  # "ndjson" | "sse" (default ndjson)
+
+
+class TokenResponse(BaseModel):
+    """JWT token pair returned from initialization or token refresh"""
+    access_token: str
+    refresh_token: str
+    token_type: str = "bearer"
+    expires_in: int  # Access token expiration in seconds
+
+
+class SessionData(BaseModel):
+    """Validated session data extracted from JWT token"""
+    user_id: str
+    token_type: str  # "access" or "refresh"
+    issued_at: int  # Unix timestamp
+    expires_at: int  # Unix timestamp
+    jti: str  # JWT ID (unique token identifier)
+
+
+class InvokeRequest(BaseModel):
+    """
+    Request to invoke agent or assistant.
+    Requires user_id to be passed in the Authorization header (via JWT token).
+    """
+    user_query: str
+    timeout_seconds: int = 60
+
+
+class PerformActionRequest(BaseModel):
+    """
+    Request to perform a specific action.
+    Requires user_id to be passed in the Authorization header (via JWT token).
+    """
+    action: dict[str, Any]  # Will be converted to fastworkflow.Action
+    timeout_seconds: int = 60
+
+
+class PostFeedbackRequest(BaseModel):
+    """
+    Request to post feedback on the latest turn.
+    Requires user_id to be passed in the Authorization header (via JWT token).
+    
+    Note: binary_or_numeric_score accepts numeric values (float).
+    Boolean values (True/False) are automatically converted to 1.0/0.0.
+    """
+    binary_or_numeric_score: Optional[float] = None
+    nl_feedback: Optional[str] = None
+
+    @field_validator('nl_feedback')
+    @classmethod
+    def validate_feedback_presence(cls, v, info):
+        """Ensure at least one feedback field is provided"""
+        if v is None and info.data.get('binary_or_numeric_score') is None:
+            raise ValueError("At least one of binary_or_numeric_score or nl_feedback must be provided")
+        return v
+
+
+class ActivateConversationRequest(BaseModel):
+    """
+    Request to activate a conversation by ID.
+    Requires user_id to be passed in the Authorization header (via JWT token).
+    """
+    conversation_id: int
+
+
+class DumpConversationsRequest(BaseModel):
+    """Admin request to dump all conversations"""
+    output_folder: str
+
+
+class GenerateMCPTokenRequest(BaseModel):
+    """Request to generate a long-lived MCP token"""
+    user_id: str
+    expires_days: int = 365
+
+
+# class CommandOutputWithTraces(BaseModel):
+#     """CommandOutput extended with optional traces for HTTP responses"""
+#     command_responses: list[dict[str, Any]]
+#     workflow_name: str = ""
+#     context: str = ""
+#     command_name: str = ""
+#     command_parameters: str = ""
+#     success: bool = True
+#     traces: Optional[list[dict[str, Any]]] = None
+
+
+# ============================================================================
+# Helper Functions
+# ============================================================================
+
+# Create HTTPBearer security scheme instance
+# This integrates with FastAPI's OpenAPI/Swagger UI to provide the "Authorize" button
+http_bearer = HTTPBearer(
+    scheme_name="BearerAuth",
+    description="JWT Bearer token obtained from /initialize or /refresh_token endpoint",
+    auto_error=True
+)
+
+def get_session_from_jwt(
+    credentials: HTTPAuthorizationCredentials = Depends(http_bearer)
+) -> SessionData:
+    """
+    FastAPI dependency to extract and validate session data from JWT Bearer token.
+    
+    This dependency integrates with FastAPI's security system and Swagger UI:
+    - Shows the "Authorize" button in Swagger UI
+    - Automatically handles "Bearer " prefix (no need to type it manually)
+    - Validates token format and presence
+    
+    Args:
+        credentials: HTTPAuthorizationCredentials from the Authorization header.
+                    FastAPI automatically extracts and validates the Bearer token format.
+        
+    Returns:
+        SessionData: Validated session data extracted from the JWT token
+        
+    Raises:
+        HTTPException: If the Authorization header is missing, malformed, or contains an invalid/expired token
+        
+    Example:
+        Use as a dependency in FastAPI endpoints:
+        ```python
+        @app.post("/endpoint")
+        async def endpoint(session: SessionData = Depends(get_session_from_jwt)):
+            # Use session.user_id, session.token_type, etc.
+            pass
+        ```
+        
+    HTTP Request Example:
+        ```bash
+        curl -X POST "http://localhost:8000/endpoint" \\
+             -H "Authorization: Bearer eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9..." \\
+             -H "Content-Type: application/json" \\
+             -d '{"data": "value"}'
+        ```
+    
+    Swagger UI Usage:
+        1. Click the "Authorize" button (lock icon)
+        2. Enter ONLY your JWT token (without "Bearer " prefix)
+        3. Swagger UI automatically adds the "Bearer " prefix
+    """
+    # Extract token from credentials (already validated by HTTPBearer)
+    token = credentials.credentials
+    
+    # Verify and decode token
+    try:
+        payload = verify_token(token, expected_type="access")
+        
+        # Extract session data from payload
+        return SessionData(
+            user_id=payload["sub"],
+            token_type=payload["type"],
+            issued_at=payload["iat"],
+            expires_at=payload["exp"],
+            jti=payload["jti"]
+        )
+        
+    except JWTError as e:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail=f"Invalid or expired token: {str(e)}",
+            headers={"WWW-Authenticate": "Bearer"}
+        )
+    except KeyError as e:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail=f"Token missing required claim: {str(e)}",
+            headers={"WWW-Authenticate": "Bearer"}
+        )
+
+
+async def ensure_user_runtime_exists(
+    user_id: str,
+    session_manager: 'UserSessionManager',
+    workflow_path: str,
+    context: Optional[dict] = None,
+    startup_command: Optional[str] = None,
+    startup_action: Optional['fastworkflow.Action'] = None,
+    stream_format: str = "ndjson"
+) -> None:
+    """
+    Ensure a user runtime exists in the session manager. If not, create it.
+    
+    This function encapsulates the session creation logic from the initialize endpoint,
+    allowing it to be reused across different parts of the application without duplicating code.
+    
+    Args:
+        user_id: The user identifier
+        session_manager: The UserSessionManager instance
+        workflow_path: Path to the workflow directory (validated at server startup)
+        context: Optional workflow context dictionary
+        startup_command: Optional startup command
+        startup_action: Optional startup action
+        stream_format: Stream format preference ("ndjson" or "sse", default "ndjson")
+        
+    Raises:
+        HTTPException: If session creation fails
+    """
+    # Check if user already has an active session
+    existing_runtime = await session_manager.get_session(user_id)
+    if existing_runtime:
+        logger.debug(f"Session for user_id {user_id} already exists, skipping creation")
+        return
+    
+    logger.info(f"Creating new session for user_id: {user_id}")
+    
+    # Resolve conversation store base folder from SPEEDDICT_FOLDERNAME/user_conversations
+    conv_base_folder = get_userconversations_dir()
+
+    # Create conversation store for this user
+    conversation_store = ConversationStore(user_id, conv_base_folder)
+
+    # Create ChatSession in agent mode (forced)
+    chat_session = fastworkflow.ChatSession(run_as_agent=True)
+
+    # Restore last conversation if it exists; else start new
+    conv_id_to_restore = None
+    if conv_id_to_restore := conversation_store.get_last_conversation_id():
+        conversation = conversation_store.get_conversation(conv_id_to_restore)
+        if not conversation:
+            # this means a new conversation was started but not saved
+            conv_id_to_restore = conv_id_to_restore-1
+            conversation = conversation_store.get_conversation(conv_id_to_restore)
+        
+        if conversation:
+            # Restore the conversation history from saved turns
+            restored_history = restore_history_from_turns(conversation["turns"])
+            chat_session._conversation_history = restored_history
+            logger.info(f"Restored conversation {conv_id_to_restore} for user {user_id}")
+        else:
+            logger.info(f"No conversations available for user {user_id}, starting new")
+            conv_id_to_restore = None
+
+    # Start the workflow
+    chat_session.start_workflow(
+        workflow_folderpath=workflow_path,
+        workflow_context=context,
+        startup_command=startup_command,
+        startup_action=startup_action,
+        keep_alive=True
+    )
+
+    # Create and store user runtime
+    await session_manager.create_session(
+        user_id=user_id,
+        chat_session=chat_session,
+        conversation_store=conversation_store,
+        active_conversation_id=conv_id_to_restore,
+        stream_format=stream_format
+    )
+
+    logger.info(f"Successfully created session for user_id: {user_id}")
+    
+    # Wait for workflow to be ready (background thread sets status to RUNNING)
+    import asyncio
+    import time
+    max_wait = 5  # seconds
+    wait_start = time.time()
+    from fastworkflow.chat_session import SessionStatus
+    while chat_session._status != SessionStatus.RUNNING and time.time() - wait_start < max_wait:
+        await asyncio.sleep(0.1)
+    
+    if chat_session._status != SessionStatus.RUNNING:
+        logger.warning(f"Workflow not fully started after {max_wait}s, status={chat_session._status}")
+
+
+def get_userconversations_dir() -> str:
+    """
+    Return SPEEDDICT_FOLDERNAME/user_conversations, creating the directory if missing.
+    fastworkflow is injected to avoid circular imports and to access get_env_var.
+    """
+    speedict_foldername = fastworkflow.get_env_var("SPEEDDICT_FOLDERNAME")
+    user_conversations_dir = os.path.join(speedict_foldername, "user_conversations")
+    os.makedirs(user_conversations_dir, exist_ok=True)
+    return user_conversations_dir
+
+
+async def wait_for_command_output(
+    runtime: 'UserRuntime',
+    timeout_seconds: int
+) -> 'fastworkflow.CommandOutput':
+    """Wait for command output from the queue with timeout"""
+    start_time = time.time()
+
+    while time.time() - start_time < timeout_seconds:
+        try:
+            return runtime.chat_session.command_output_queue.get(timeout=0.5)
+        except queue.Empty:
+            await asyncio.sleep(0.1)
+            continue
+
+    raise HTTPException(
+        status_code=status.HTTP_504_GATEWAY_TIMEOUT,
+        detail=f"Command execution timed out after {timeout_seconds} seconds"
+    )
+
+
+def collect_trace_events(runtime: 'UserRuntime') -> list[dict[str, Any]]:
+    """Drain and collect all trace events from the queue"""
+    traces = []
+    
+    while True:
+        try:
+            evt = runtime.chat_session.command_trace_queue.get_nowait()
+            traces.append({
+                "direction": evt.direction.value if hasattr(evt.direction, 'value') else str(evt.direction),
+                "raw_command": evt.raw_command,
+                "command_name": evt.command_name,
+                "parameters": evt.parameters,
+                "response_text": evt.response_text,
+                "success": evt.success,
+                "timestamp_ms": evt.timestamp_ms
+            })
+        except queue.Empty:
+            break
+    
+    return traces
+
+
+# ============================================================================
+# Session Management
+# ============================================================================
+
+@dataclass
+class UserRuntime:
+    """Per-user runtime state"""
+    user_id: str
+    active_conversation_id: int
+    chat_session: 'fastworkflow.ChatSession'
+    lock: asyncio.Lock
+    conversation_store: 'ConversationStore'
+    stream_format: str = "ndjson"  # "ndjson" | "sse"
+
+
+class UserSessionManager:
+    """Process-wide manager for user sessions"""
+    
+    def __init__(self):
+        self._sessions: dict[str, UserRuntime] = {}
+        self._lock = asyncio.Lock()
+    
+    async def get_session(self, user_id: str) -> Optional[UserRuntime]:
+        """Get a session by user_id"""
+        async with self._lock:
+            return self._sessions.get(user_id)
+    
+    async def create_session(
+        self,
+        user_id: str,
+        chat_session: 'fastworkflow.ChatSession',
+        conversation_store: 'ConversationStore',
+        active_conversation_id: Optional[int] = None,
+        stream_format: str = "ndjson"
+    ) -> UserRuntime:
+        """Create or update a session"""
+        async with self._lock:            
+            runtime = UserRuntime(
+                user_id=user_id,
+                active_conversation_id=active_conversation_id or 0,
+                chat_session=chat_session,
+                lock=asyncio.Lock(),
+                conversation_store=conversation_store,
+                stream_format=stream_format
+            )
+            self._sessions[user_id] = runtime
+            return runtime
+    
+    async def remove_session(self, user_id: str) -> None:
+        """Remove a session"""
+        async with self._lock:
+            if user_id in self._sessions:
+                del self._sessions[user_id]
+
+
+# ============================================================================
+# Helper Functions
+# ============================================================================
+
+def save_conversation_incremental(runtime: UserRuntime, extract_turns_func, logger) -> None:
+    """
+    Save conversation turns incrementally after each turn (without generating topic/summary).
+    This provides crash protection - all turns except the last will be preserved.
+    """
+    # Extract turns from conversation history
+    if turns := extract_turns_func(runtime.chat_session.conversation_history):
+        # Initialize conversation ID for first conversation if needed
+        if runtime.active_conversation_id == 0:
+            # This is the first conversation for this session
+            # Reserve ID 1 and use it
+            runtime.active_conversation_id = runtime.conversation_store.reserve_next_conversation_id()
+            logger.debug(f"Initialized first conversation with ID {runtime.active_conversation_id} for user {runtime.user_id}")
+        
+        # Save turns using the active conversation ID
+        runtime.conversation_store.save_conversation_turns(
+            runtime.active_conversation_id, turns
+        )
+        logger.debug(f"Incrementally saved {len(turns)} turn(s) to conversation {runtime.active_conversation_id}")
+
+

{fastworkflow-2.16.0.dist-info → fastworkflow-2.17.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fastworkflow
-Version: 2.16.0
+Version: 2.17.1
 Summary: A framework for rapidly building large-scale, deterministic, interactive workflows with a fault-tolerant, conversational UX
 License: Apache-2.0
 Keywords: fastworkflow,ai,workflow,llm,openai

{fastworkflow-2.16.0.dist-info → fastworkflow-2.17.1.dist-info}/RECORD

@@ -7,7 +7,7 @@ fastworkflow/_workflows/command_metadata_extraction/_commands/ErrorCorrection/ab
 fastworkflow/_workflows/command_metadata_extraction/_commands/ErrorCorrection/you_misunderstood.py,sha256=VHfhwlqc1ceG9P_wL8Fl7dpJA2UlcSrcXhz7zZU9NpA,2517
 fastworkflow/_workflows/command_metadata_extraction/_commands/IntentDetection/go_up.py,sha256=K526OAf5ks95SwqVdRNVxLM_AWDfA1qXbkNYq0dANwg,1889
 fastworkflow/_workflows/command_metadata_extraction/_commands/IntentDetection/reset_context.py,sha256=xvInu6uDw0YRUHVXNyTZphSr75f8QiQgFwDtv7SlE9o,1346
-fastworkflow/_workflows/command_metadata_extraction/_commands/IntentDetection/what_can_i_do.py,sha256=9I9Y1VRvmiqft7vkz_8gGgCYTesMzBvP58wef3sjLZM,6593
+fastworkflow/_workflows/command_metadata_extraction/_commands/IntentDetection/what_can_i_do.py,sha256=KEYZ8qJG9j_93ycy2CbRdvoqJZ5FawmwjDyRlXWMNeM,6887
 fastworkflow/_workflows/command_metadata_extraction/_commands/IntentDetection/what_is_current_context.py,sha256=S5RQLr62Q2MnKU85nw4IW_ueAK_FXvhcY9gXajFxujg,1464
 fastworkflow/_workflows/command_metadata_extraction/_commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fastworkflow/_workflows/command_metadata_extraction/_commands/wildcard.py,sha256=Sqpc2hwM-DgmsqiHu3OoOuqo3XnHLkFlmyYCJA8nj_8,7843
@@ -35,13 +35,13 @@ fastworkflow/build/navigator_stub_generator.py,sha256=_DSvHC6r1xWQiFHtUgPhI51nQf
 fastworkflow/build/pydantic_model_generator.py,sha256=oNyoANyUWBpHG-fE3tGL911RNvDzQXjxAm0ssvuXUH4,1854
 fastworkflow/build/utterance_generator.py,sha256=UrtkF0wyAZ1hiFitHX0g8w7Wh-D0leLCrP1aUACSfHo,299
 fastworkflow/cache_matching.py,sha256=OoB--1tO6-O4BKCuCrUbB0CkUr76J62K4VAf6MShi-w,7984
-fastworkflow/chat_session.py,sha256=p8n2rQx3mhZ_DoRb14sRbp0PGKidMS6H2wwC1TNPxnM,31592
+fastworkflow/chat_session.py,sha256=mduwtY27MV5YcabUbaFDXyRalVVNLUpp7ZFNiOV9ewc,31627
 fastworkflow/cli.py,sha256=li9OFT05sxqz4BZJc9byKAeTmomjLfsWMVuy0OiRGSs,18953
-fastworkflow/command_context_model.py,sha256=nWxLP3TR7WJr3yWCedqcdFOxo_kwae_mS3VRN2cOmK8,13437
+fastworkflow/command_context_model.py,sha256=bQadDB_IH2lc0br46IT07Iej_j2KrAMderiVKqU7gno,15914
 fastworkflow/command_directory.py,sha256=aJ6UQCwevfF11KbcQB2Qz6mQ7Kj91pZtvHmQY6JFnao,29030
 fastworkflow/command_executor.py,sha256=WTSrukv6UDQfWUDSNleIQ1TxwDnAQIKIimh4sQVwnig,8457
 fastworkflow/command_interfaces.py,sha256=PWIKlcp0G8nmYl0vkrg1o6QzJL0pxXkfrn1joqTa0eU,460
-fastworkflow/command_metadata_api.py,sha256=KtidE3PM9HYfY-nmEXZ8Y4nnaw2qn23p_gvwFVT3F8Y,39770
+fastworkflow/command_metadata_api.py,sha256=J5ltiwOhFRf1fggm8yWziKPrZA3trKt_rkyBtSS0H3I,42233
 fastworkflow/command_routing.py,sha256=R7194pcY0d2VHzmCu9ALacm1UvNuIRIvTn8mLp-EZIM,17219
 fastworkflow/docs/context_modules_prd.txt,sha256=9wvs3LgNoIVXAczo1sXBIV4YmFqVhzC2ja1T3K7FG04,2199
 fastworkflow/examples/extended_workflow_example/README.md,sha256=2O0O4Bg--fwF98YDScnkNCUL3PcH8KpX2p6I1cwNWeg,2864
@@ -144,7 +144,15 @@ fastworkflow/mcp_server.py,sha256=NxbLSKf2MA4lAHVcm6ZfiVuOjVO6IeV5Iw17wImFbxQ,88
 fastworkflow/model_pipeline_training.py,sha256=P_9wrYSfJVSYCTu8VEPkgXJ16eH58LLCK4rCRbRFAVg,46740
 fastworkflow/refine/__main__.py,sha256=bDLpPNMcdp8U4EFnMdjxx1sPDQCZuEJoBURr2KebTng,3398
 fastworkflow/run/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-fastworkflow/run/__main__.py,sha256=e3gTjcQwYuEz12LZIdL5w48aMRJ-42MdlyapINj7XWk,12430
+fastworkflow/run/__main__.py,sha256=XmybAsr1MnCx8tzvhWxtBT7xu2Om3PVZFtABXavPccU,12075
+fastworkflow/run_fastapi_mcp/README.md,sha256=H3XcMNxDcOdGnHNODGe8U7b9s7loiHo-rEZqs-NXzn8,8024
+fastworkflow/run_fastapi_mcp/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fastworkflow/run_fastapi_mcp/conversation_store.py,sha256=OuS6Yq5noXrNn5jPwld_KueVi53Jlpa0qvF_vLUIbgg,13516
+fastworkflow/run_fastapi_mcp/jwt_manager.py,sha256=fV5cKgYKluBk3l3ZepTSY3MgN0OopyH6oh8G_ncFQ4k,8166
+fastworkflow/run_fastapi_mcp/main.py,sha256=JmgfViu2jpHBYvjx0DJ4QEU3D56CZJXnD1yo_8hzAq4,48148
+fastworkflow/run_fastapi_mcp/mcp_specific.py,sha256=RdOPcPn68KlxNSM9Vb2yeYEDNGoNTcKZq-AC0cd86cw,4506
+fastworkflow/run_fastapi_mcp/redoc_2_standalone_html.py,sha256=oYWn30O-xKX6pVjunCeLupyOM2DbeZ3QgFj-F2LalOE,1191
+fastworkflow/run_fastapi_mcp/utils.py,sha256=GGwX3DEghY4TWntSwvrGvOwaiE_vxh_tCdXT6pA2gP4,15525
 fastworkflow/train/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fastworkflow/train/__main__.py,sha256=AeGja42d0QhslQkxvDVigIluxxL7DYLdQPXYFOKQ7QA,8536
 fastworkflow/train/generate_synthetic.py,sha256=sTDk-E5ewkS4o-0LJeofiEv4uXGpqdGcFRYKY_Yf36Y,5322
@@ -168,8 +176,8 @@ fastworkflow/utils/startup_progress.py,sha256=9icSdnpFAxzIq0sUliGpNaH0Efvrt5lDtG
 fastworkflow/workflow.py,sha256=37gn7e3ct-gdGw43zS6Ab_ADoJJBO4eJW2PywfUpjEg,18825
 fastworkflow/workflow_agent.py,sha256=-RXoHXH-vrEh6AWC6iYAwwR9CvaRynYuu-KrzOPCJbg,16348
 fastworkflow/workflow_inheritance_model.py,sha256=Pp-qSrQISgPfPjJVUfW84pc7HLmL2evuq0UVIYR51K0,7974
-fastworkflow-2.16.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-fastworkflow-2.16.0.dist-info/METADATA,sha256=Mno8E51bhYTFQ4P7YRzmd71rjOBm_niCOKnFsTGmJNs,30336
-fastworkflow-2.16.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-fastworkflow-2.16.0.dist-info/entry_points.txt,sha256=m8HqoPzCyaZLAx-V5X8MJgw3Lx3GiPDlxNEZ7K-Gb-U,54
-fastworkflow-2.16.0.dist-info/RECORD,,
+fastworkflow-2.17.1.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+fastworkflow-2.17.1.dist-info/METADATA,sha256=LynPWVIi_Br9ZTWr7aTnvzhFDnBeSyfC2TxgMJ3y2dg,30336
+fastworkflow-2.17.1.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+fastworkflow-2.17.1.dist-info/entry_points.txt,sha256=m8HqoPzCyaZLAx-V5X8MJgw3Lx3GiPDlxNEZ7K-Gb-U,54
+fastworkflow-2.17.1.dist-info/RECORD,,