langflow-base-nightly 0.5.0.dev38__py3-none-any.whl → 0.5.1.dev0__py3-none-any.whl

langflow/alembic/versions/0882f9657f22_encrypt_existing_mcp_auth_settings_.py

@@ -0,0 +1,122 @@
+"""Encrypt existing MCP auth_settings credentials
+
+Revision ID: 0882f9657f22
+Revises: 1cb603706752
+Create Date: 2025-08-21 20:11:26.504681
+
+"""
+import json
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+import sqlmodel
+from sqlalchemy.engine.reflection import Inspector
+from langflow.utils import migration
+
+
+# revision identifiers, used by Alembic.
+revision: str = '0882f9657f22'
+down_revision: Union[str, None] = '1cb603706752'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    """Encrypt sensitive fields in existing auth_settings data."""
+    conn = op.get_bind()
+    
+    # Import encryption utilities
+    try:
+        from langflow.services.auth.mcp_encryption import encrypt_auth_settings
+        from langflow.services.deps import get_settings_service
+        
+        # Check if the folder table exists
+        inspector = sa.inspect(conn)
+        if 'folder' not in inspector.get_table_names():
+            return
+            
+        # Query all folders with auth_settings
+        result = conn.execute(
+            sa.text("SELECT id, auth_settings FROM folder WHERE auth_settings IS NOT NULL")
+        )
+        
+        # Encrypt auth_settings for each folder
+        for row in result:
+            folder_id = row.id
+            auth_settings = row.auth_settings
+            
+            if auth_settings:
+                try:
+                    # Parse JSON if it's a string
+                    if isinstance(auth_settings, str):
+                        auth_settings_dict = json.loads(auth_settings)
+                    else:
+                        auth_settings_dict = auth_settings
+                    
+                    # Encrypt sensitive fields
+                    encrypted_settings = encrypt_auth_settings(auth_settings_dict)
+                    
+                    # Update the record with encrypted data
+                    if encrypted_settings:
+                        conn.execute(
+                            sa.text("UPDATE folder SET auth_settings = :auth_settings WHERE id = :id"),
+                            {"auth_settings": json.dumps(encrypted_settings), "id": folder_id}
+                        )
+                except Exception as e:
+                    # Log the error but continue with other records
+                    print(f"Warning: Failed to encrypt auth_settings for folder {folder_id}: {e}")
+                    
+    except ImportError as e:
+        # If encryption utilities are not available, skip the migration
+        print(f"Warning: Encryption utilities not available, skipping encryption migration: {e}")
+
+
+def downgrade() -> None:
+    """Decrypt sensitive fields in auth_settings data (for rollback)."""
+    conn = op.get_bind()
+    
+    # Import decryption utilities
+    try:
+        from langflow.services.auth.mcp_encryption import decrypt_auth_settings
+        from langflow.services.deps import get_settings_service
+        
+        # Check if the folder table exists
+        inspector = sa.inspect(conn)
+        if 'folder' not in inspector.get_table_names():
+            return
+            
+        # Query all folders with auth_settings
+        result = conn.execute(
+            sa.text("SELECT id, auth_settings FROM folder WHERE auth_settings IS NOT NULL")
+        )
+        
+        # Decrypt auth_settings for each folder
+        for row in result:
+            folder_id = row.id
+            auth_settings = row.auth_settings
+            
+            if auth_settings:
+                try:
+                    # Parse JSON if it's a string
+                    if isinstance(auth_settings, str):
+                        auth_settings_dict = json.loads(auth_settings)
+                    else:
+                        auth_settings_dict = auth_settings
+                    
+                    # Decrypt sensitive fields
+                    decrypted_settings = decrypt_auth_settings(auth_settings_dict)
+                    
+                    # Update the record with decrypted data
+                    if decrypted_settings:
+                        conn.execute(
+                            sa.text("UPDATE folder SET auth_settings = :auth_settings WHERE id = :id"),
+                            {"auth_settings": json.dumps(decrypted_settings), "id": folder_id}
+                        )
+                except Exception as e:
+                    # Log the error but continue with other records
+                    print(f"Warning: Failed to decrypt auth_settings for folder {folder_id}: {e}")
+                    
+    except ImportError as e:
+        # If decryption utilities are not available, skip the migration
+        print(f"Warning: Decryption utilities not available, skipping decryption migration: {e}")

langflow/api/router.py

@@ -13,6 +13,7 @@ from langflow.api.v1 import (
     mcp_projects_router,
     mcp_router,
     monitor_router,
+    openai_responses_router,
     projects_router,
     starter_projects_router,
     store_router,
@@ -50,6 +51,7 @@ router_v1.include_router(knowledge_bases_router)
 router_v1.include_router(mcp_router)
 router_v1.include_router(voice_mode_router)
 router_v1.include_router(mcp_projects_router)
+router_v1.include_router(openai_responses_router)
 
 router_v2.include_router(files_router_v2)
 router_v2.include_router(mcp_router_v2)

langflow/api/v1/__init__.py

@@ -9,6 +9,7 @@ from langflow.api.v1.login import router as login_router
 from langflow.api.v1.mcp import router as mcp_router
 from langflow.api.v1.mcp_projects import router as mcp_projects_router
 from langflow.api.v1.monitor import router as monitor_router
+from langflow.api.v1.openai_responses import router as openai_responses_router
 from langflow.api.v1.projects import router as projects_router
 from langflow.api.v1.starter_projects import router as starter_projects_router
 from langflow.api.v1.store import router as store_router
@@ -29,6 +30,7 @@ __all__ = [
     "mcp_projects_router",
     "mcp_router",
     "monitor_router",
+    "openai_responses_router",
     "projects_router",
     "starter_projects_router",
     "store_router",

langflow/api/v1/endpoints.py

@@ -116,6 +116,7 @@ async def simple_run_flow(
     stream: bool = False,
     api_key_user: User | None = None,
     event_manager: EventManager | None = None,
+    context: dict | None = None,
 ):
     validate_input_and_tweaks(input_request)
     try:
@@ -127,7 +128,9 @@ async def simple_run_flow(
             raise ValueError(msg)
         graph_data = flow.data.copy()
         graph_data = process_tweaks(graph_data, input_request.tweaks or {}, stream=stream)
-        graph = Graph.from_payload(graph_data, flow_id=flow_id_str, user_id=str(user_id), flow_name=flow.name)
+        graph = Graph.from_payload(
+            graph_data, flow_id=flow_id_str, user_id=str(user_id), flow_name=flow.name, context=context
+        )
         inputs = None
         if input_request.input_value is not None:
             inputs = [
@@ -228,6 +231,7 @@ async def run_flow_generator(
     api_key_user: User | None,
     event_manager: EventManager,
     client_consumed_queue: asyncio.Queue,
+    context: dict | None = None,
 ) -> None:
     """Executes a flow asynchronously and manages event streaming to the client.
 
@@ -240,6 +244,7 @@ async def run_flow_generator(
         api_key_user (User | None): Optional authenticated user running the flow
         event_manager (EventManager): Manages the streaming of events to the client
         client_consumed_queue (asyncio.Queue): Tracks client consumption of events
+        context (dict | None): Optional context to pass to the flow
 
     Events Generated:
         - "add_message": Sent when new messages are added during flow execution
@@ -260,6 +265,7 @@ async def run_flow_generator(
             stream=True,
             api_key_user=api_key_user,
             event_manager=event_manager,
+            context=context,
         )
         event_manager.on_end(data={"result": result.model_dump()})
         await client_consumed_queue.get()