snowglobe 0.4.11__tar.gz → 0.4.13__tar.gz

{snowglobe-0.4.11/src/snowglobe.egg-info → snowglobe-0.4.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snowglobe
-Version: 0.4.11
+Version: 0.4.13
 Summary: client server for usage with snowglobe experiments
 Author-email: Guardrails AI <contact@guardrailsai.com>
 License: MIT License
@@ -31,6 +31,7 @@ License-File: LICENSE
 Requires-Dist: typer>=0.9.0
 Requires-Dist: fastapi>=0.115.6
 Requires-Dist: uvicorn[standard]>=0.23.0
+Requires-Dist: openai>=1.55.2
 Requires-Dist: requests>=2.31.0
 Requires-Dist: pydantic>=2.11.5
 Requires-Dist: APScheduler==4.0.0a6
@@ -87,7 +88,7 @@ import os
 
 client = OpenAI(api_key=os.getenv("SNOWGLOBE_API_KEY"))
 
-def process_scenario(request: CompletionRequest) -> CompletionFunctionOutputs:
+def completion_fn(request: CompletionRequest) -> CompletionFunctionOutputs:
     """
     Process a scenario request from Snowglobe.
     

{snowglobe-0.4.11 → snowglobe-0.4.13}/README.md

@@ -42,7 +42,7 @@ import os
 
 client = OpenAI(api_key=os.getenv("SNOWGLOBE_API_KEY"))
 
-def process_scenario(request: CompletionRequest) -> CompletionFunctionOutputs:
+def completion_fn(request: CompletionRequest) -> CompletionFunctionOutputs:
     """
     Process a scenario request from Snowglobe.
     

{snowglobe-0.4.11 → snowglobe-0.4.13}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "snowglobe"
-version = "0.4.11"
+version = "0.4.13"
 authors = [
     {name = "Guardrails AI", email = "contact@guardrailsai.com"}
 ]
@@ -14,6 +14,7 @@ dependencies = [
     "typer>=0.9.0",
     "fastapi>=0.115.6",
     "uvicorn[standard]>=0.23.0",
+    "openai>=1.55.2",
     "requests>=2.31.0",
     "pydantic>=2.11.5",
     "APScheduler==4.0.0a6",

{snowglobe-0.4.11 → snowglobe-0.4.13}/src/snowglobe/client/src/app.py

@@ -26,7 +26,13 @@ from snowglobe.client.src.telemetry import trace_completion_fn, trace_risk_evalu
 
 from .cli_utils import info, shutdown_manager
 from .config import config, get_api_key_or_raise
-from .models import CompletionFunctionOutputs, CompletionRequest, RiskEvaluationRequest, SnowglobeData, SnowglobeMessage
+from .models import (
+    CompletionFunctionOutputs,
+    CompletionRequest,
+    RiskEvaluationRequest,
+    SnowglobeData,
+    SnowglobeMessage,
+)
 from .stats import initialize_stats, track_batch_completion
 from .utils import fetch_experiments, fetch_messages
 
@@ -130,13 +136,16 @@ async def process_application_heartbeat(app_id):
     try:
         prompt = "Hello from Snowglobe!"
         test_request = CompletionRequest(
-            messages=[SnowglobeMessage(
+            messages=[
+                SnowglobeMessage(
                     role="user",
                     content=prompt,
                     snowglobe_data=SnowglobeData(
                         conversation_id="test", test_id="test"
                     ),
-                )])
+                )
+            ]
+        )
         heartbeat_id = uuid.uuid4().hex
         agent = apps.get(app_id, {})
         agent_name = agent.get("name", "")
@@ -157,7 +166,11 @@ async def process_application_heartbeat(app_id):
         )
         async def run_completion_fn(completion_request: CompletionRequest):
             if asyncio.iscoroutinefunction(completion_fn):
-                response = await completion_fn(completion_request)
+                try:
+                    asyncio.get_running_loop()
+                    response = await completion_fn(completion_request)
+                except RuntimeError:
+                    response = asyncio.run(completion_fn(completion_request))
             else:
                 response = completion_fn(completion_request)
             return response
@@ -250,7 +263,11 @@ async def process_risk_evaluation(test, risk_name, simulation_name, agent_name):
     )
     async def run_risk_evaluation_fn(risk_evaluation_request: RiskEvaluationRequest):
         if asyncio.iscoroutinefunction(risks[risk_name]):
-            risk_evaluation = await risks[risk_name](risk_evaluation_request)
+            try:
+                asyncio.get_running_loop()
+                risk_evaluation = await risks[risk_name](risk_evaluation_request)
+            except RuntimeError:
+                risk_evaluation = asyncio.run(risks[risk_name](risk_evaluation_request))
         else:
             risk_evaluation = risks[risk_name](risk_evaluation_request)
         return risk_evaluation
@@ -312,7 +329,11 @@ async def process_test(test, completion_fn, app_id, simulation_name):
     )
     async def run_completion_fn(completion_request: CompletionRequest):
         if asyncio.iscoroutinefunction(completion_fn):
-            completionOutput = await completion_fn(completion_request)
+            try:
+                asyncio.get_running_loop()
+                completionOutput = await completion_fn(completion_request)
+            except RuntimeError:
+                completionOutput = asyncio.run(completion_fn(completion_request))
         else:
             completionOutput = completion_fn(completion_request)
         return completionOutput
@@ -791,14 +812,30 @@ async def lifespan(app: FastAPI):
                         finally:
                             sys.path = sys_path_backup
 
-                        if not hasattr(agent_module, "process_scenario"):
+                        completion_fn = None
+                        if hasattr(agent_module, "completion"):
+                            completion_fn = agent_module.completion
+                        elif hasattr(agent_module, "acompletion"):
+                            completion_fn = agent_module.acompletion
+                        # Check for legacy function names
+                        elif hasattr(agent_module, "completion_fn"):
+                            completion_fn = agent_module.completion_fn
+                            LOGGER.warning(
+                                f"Agent {filename} uses deprecated function 'completion_fn'. Please rename to 'completion'"
+                            )
+                        elif hasattr(agent_module, "process_scenario"):
+                            completion_fn = agent_module.process_scenario
+                            LOGGER.warning(
+                                f"Agent {filename} uses deprecated function 'process_scenario'. Please rename to 'completion' or 'acompletion'"
+                            )
+                        else:
                             LOGGER.warning(
-                                f"Agent {filename} does not have a process_scenario function"
+                                f"Agent {filename} does not have a completion or acompletion function"
                             )
                             continue
 
                         apps[app_id] = {
-                            "completion_fn": agent_module.process_scenario,
+                            "completion_fn": completion_fn,
                             "name": app_name,
                         }
 
@@ -836,17 +873,47 @@ async def lifespan(app: FastAPI):
                     )
                     sg_connect = importlib.util.module_from_spec(spec)
                     spec.loader.exec_module(sg_connect)
-                    if hasattr(sg_connect, "completion_fn"):
+                    if hasattr(sg_connect, "completion"):
+                        apps[config.APPLICATION_ID] = {
+                            "completion_fn": sg_connect.completion,
+                            "name": "Legacy Single Application",
+                        }
+                        LOGGER.info(
+                            f"Loaded legacy application with ID {config.APPLICATION_ID} for completions."
+                        )
+                    elif hasattr(sg_connect, "acompletion"):
+                        apps[config.APPLICATION_ID] = {
+                            "completion_fn": sg_connect.acompletion,
+                            "name": "Legacy Single Application",
+                        }
+                        LOGGER.info(
+                            f"Loaded legacy application with ID {config.APPLICATION_ID} for completions."
+                        )
+                    elif hasattr(sg_connect, "completion_fn"):
                         apps[config.APPLICATION_ID] = {
                             "completion_fn": sg_connect.completion_fn,
                             "name": "Legacy Single Application",
                         }
+                        LOGGER.warning(
+                            f"Legacy application with ID {config.APPLICATION_ID} uses deprecated function 'completion_fn'. Please rename to 'completion'"
+                        )
+                        LOGGER.info(
+                            f"Loaded legacy application with ID {config.APPLICATION_ID} for completions."
+                        )
+                    elif hasattr(sg_connect, "process_scenario"):
+                        apps[config.APPLICATION_ID] = {
+                            "completion_fn": sg_connect.process_scenario,
+                            "name": "Legacy Single Application",
+                        }
+                        LOGGER.warning(
+                            f"Legacy application with ID {config.APPLICATION_ID} uses deprecated function 'process_scenario'. Please rename to 'completion' or 'acompletion'"
+                        )
                         LOGGER.info(
                             f"Loaded legacy application with ID {config.APPLICATION_ID} for completions."
                         )
                     else:
                         LOGGER.error(
-                            f"Legacy application with ID {config.APPLICATION_ID} does not have a completion_fn."
+                            f"Legacy application with ID {config.APPLICATION_ID} does not have a completion or acompletion function."
                         )
     except Exception as e:
         LOGGER.error(f"Error loading applications: {e}")

{snowglobe-0.4.11 → snowglobe-0.4.13}/src/snowglobe/client/src/cli.py

@@ -31,7 +31,7 @@ from .cli_utils import (
     graceful_shutdown,
     info,
     select_application_interactive,
-    select_stateful_interactive,
+    select_template_interactive,
     spinner,
     success,
     warning,
@@ -196,7 +196,7 @@ def test(
         if "default template response" in conn_message.lower():
             info("This is expected with the default template.")
             info(
-                "Please implement your application logic in the process_scenario function."
+                "Please implement your application logic in the completion or acompletion function."
             )
         else:
             info("Check your implementation and try again.")
@@ -214,10 +214,6 @@ def init(
         "-f",
         help="Path or filename (within project) for the agent wrapper",
     ),
-    # option for stateful agent
-    stateful: bool = typer.Option(
-        False, "--stateful", help="Initialize a stateful agent template"
-    ),
 ):
     """
     Initialize a new Snowglobe agent in the current directory
@@ -269,8 +265,8 @@ def init(
 
     success(f"Selected application: {app_name}")
 
-    # prompt user to confirm if stateful agent
-    user_stateful = select_stateful_interactive(stateful)
+    # prompt user to select template type
+    template_type = select_template_interactive()
     # Set up project structure
     with spinner("Setting up project structure"):
         pm.ensure_project_structure()
@@ -310,11 +306,16 @@ def init(
     file_path = pm.project_root / filename
 
     success(f"Using filename: {filename}")
-    # use the appopriate template based on stateful option
-    if user_stateful:
-        snowglobe_connect_template = stateful_snowglobe_connect_template
+    # use the appropriate template based on template type
+    if template_type == "sync":
+        snowglobe_connect_template = sync_snowglobe_connect_template
+    elif template_type == "async":
+        snowglobe_connect_template = async_snowglobe_connect_template
+    elif template_type == "socket":
+        snowglobe_connect_template = socket_snowglobe_connect_template
     else:
-        snowglobe_connect_template = stateless_snowglobe_connect_template
+        # Default fallback
+        snowglobe_connect_template = sync_snowglobe_connect_template
 
     # Ensure parent directories exist if a subpath was provided
     os.makedirs(file_path.parent, exist_ok=True)
@@ -334,13 +335,17 @@ def init(
     console.print(f"[dim]  {filename}\t- Your agent wrapper[/dim]")
 
     console.print()
+    console.print("📁 Your connection template is available at:")
+    console.print(f"[bold blue]{'*' * (len(filename) + 4)}[/bold blue]")
+    console.print(f"[bold blue]* {filename} *[/bold blue]")
+    console.print(f"[bold blue]{'*' * (len(filename) + 4)}[/bold blue]")
+    console.print(
+        "[bold yellow]Please change the code in the completion or acompletion function to implement your application logic.[/bold yellow]\n"
+    )
     info("Next steps:")
-    console.print("1. Edit the process_scenario function in your agent file:")
-    console.print(f"   [bold cyan]{filename}[/bold cyan]")
-    console.print("2. Implement your application logic")
-    console.print("3. Test your agent:")
+    console.print("1. Test your agent:")
     console.print("   [bold green]snowglobe-connect test[/bold green]")
-    console.print("4. Start the client:")
+    console.print("2. Start the client:")
     console.print("   [bold green]snowglobe-connect start[/bold green]")
 
     console.print()
@@ -368,12 +373,29 @@ def test_agent_wrapper(filename: str, app_id: str, app_name: str) -> Tuple[bool,
         finally:
             sys.path = sys_path_backup
 
-        if not hasattr(agent_module, "process_scenario"):
-            return False, "process_scenario function not found"
+        completion_fn = None
+
+        # Check for preferred function names first
+        if hasattr(agent_module, "completion"):
+            completion_fn = agent_module.completion
+        elif hasattr(agent_module, "acompletion"):
+            completion_fn = agent_module.acompletion
+        # Check for legacy function names
+        elif hasattr(agent_module, "completion_fn"):
+            completion_fn = agent_module.completion_fn
+            warning(
+                "Function 'completion_fn' is deprecated. Please rename to 'completion'"
+            )
+        elif hasattr(agent_module, "process_scenario"):
+            completion_fn = agent_module.process_scenario
+            warning(
+                "Function 'process_scenario' is deprecated. Please rename to 'completion' or 'acompletion'"
+            )
+        else:
+            return False, "completion or acompletion function not found"
 
-        process_scenario = agent_module.process_scenario
-        if not callable(process_scenario):
-            return False, "process_scenario is not callable"
+        if not callable(completion_fn):
+            return False, "completion function is not callable"
 
         # Test with a simple request
 
@@ -399,14 +421,18 @@ def test_agent_wrapper(filename: str, app_id: str, app_name: str) -> Tuple[bool,
             simulation_name=f"{app_name} CLI Test",
             span_type="snowglobe/cli-test",
         )
-        async def run_process_scenario(completion_request: CompletionRequest):
-            if asyncio.iscoroutinefunction(process_scenario):
-                response = asyncio.run(process_scenario(completion_request))
+        async def run_completion_fn(completion_request: CompletionRequest):
+            if asyncio.iscoroutinefunction(completion_fn):
+                try:
+                    asyncio.get_running_loop()
+                    response = await completion_fn(completion_request)
+                except RuntimeError:
+                    response = asyncio.run(completion_fn(completion_request))
             else:
-                response = process_scenario(completion_request)
+                response = completion_fn(completion_request)
             return response
 
-        response = asyncio.run(run_process_scenario(test_request))
+        response = asyncio.run(run_completion_fn(test_request))
 
         if hasattr(response, "response") and isinstance(response.response, str):
             if response.response == "Your response here":
@@ -473,84 +499,127 @@ def enhanced_error_handler(status_code: int, operation: str = "operation") -> No
         info("Please try again or contact support if the issue persists")
 
 
-stateless_snowglobe_connect_template = """from snowglobe.client import CompletionRequest, CompletionFunctionOutputs
-
+sync_snowglobe_connect_template = """from snowglobe.client import CompletionRequest, CompletionFunctionOutputs
+from openai import OpenAI
+import os
+client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
 
-def process_scenario(request: CompletionRequest) -> CompletionFunctionOutputs:
+def completion(request: CompletionRequest) -> CompletionFunctionOutputs:
     \"\"\"
     Process a scenario request from Snowglobe.
     
-    This function is called by the Snowglobe client to process requests. It should return a
+    This function is called by the Snowglobe client to process test requests. It should return a
     CompletionFunctionOutputs object with the response content.
+    
+    Args:
+        request (CompletionRequest): The request object containing messages for the test.
 
-    Example CompletionRequest:
-    CompletionRequest(
-        messages=[
-            SnowglobeMessage(role="user", content="Hello, how are you?", snowglobe_data=None),
-        ]
+    Returns:
+        CompletionFunctionOutputs: The response object with the generated content.
+    \"\"\"
+
+    # Process the request using the messages. Example using OpenAI:
+    messages = request.to_openai_messages(system_prompt="You are a helpful assistant.")
+    response = client.chat.completions.create(
+        model="gpt-4o-mini",
+        messages=messages
     )
+    return CompletionFunctionOutputs(response=response.choices[0].message.content)
+"""
 
-    Example CompletionFunctionOutputs:
-    CompletionFunctionOutputs(response="This is a string response from your application")
+async_snowglobe_connect_template = """from snowglobe.client import CompletionRequest, CompletionFunctionOutputs
+from openai import AsyncOpenAI
+import os
+client = AsyncOpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+
+async def acompletion(request: CompletionRequest) -> CompletionFunctionOutputs:
+    \"\"\"
+    Process a scenario request from Snowglobe.
+    
+    This function is called by the Snowglobe client to process test requests. It should return a
+    CompletionFunctionOutputs object with the response content.
     
     Args:
-        request (CompletionRequest): The request object containing the messages.
+        request (CompletionRequest): The request object containing messages for the test.
 
     Returns:
         CompletionFunctionOutputs: The response object with the generated content.
     \"\"\"
 
-    # Process the request using the messages. Example:
-    # messages = request.to_openai_messages()
-    # response = client.chat.completions.create(
-    #     model="gpt-4o-mini",
-    #     messages=messages
-    # )
-    return CompletionFunctionOutputs(response="Your response here")
-
+    # Process the request using the messages. Example using OpenAI:
+    messages = request.to_openai_messages(system_prompt="You are a helpful assistant.")
+    response = await client.chat.completions.create(
+        model="gpt-4o-mini",
+        messages=messages
+    )
+    return CompletionFunctionOutputs(response=response.choices[0].message.content)
 """
 
-stateful_snowglobe_connect_template = """
-# This file is auto-generated by the API client.
-
+socket_snowglobe_connect_template = """
 from snowglobe.client import CompletionRequest, CompletionFunctionOutputs
 import logging
 import websockets
 import json
+from openai import AsyncOpenAI
+
 LOGGER = logging.getLogger(__name__)
 socket_cache = {}
-async def completion_fn(request: CompletionRequest) -> CompletionFunctionOutputs:
-    # for debugging purposes
-    # print(f"Received request: {request.messages}")
-    
-    completion_messages = [{"role": msg.role, "content": msg.content} for msg in request.messages]
+openai_client = AsyncOpenAI()
+
+async def acompletion(request: CompletionRequest) -> CompletionFunctionOutputs:
+    \"\"\"
+    When dealing with a realtime socket, we need to create a socket for each conversation.
+    We store the socket in a cache and reuse it for the same conversation_id so that we can maintain the conversation context.
+    Swap out the websocket client for your preferred realtime client.
+
+    Args:
+        request (CompletionRequest): The request object containing messages for the test.
+
+    Returns:
+        CompletionFunctionOutputs: The response object with the generated content.
+    \"\"\"
+    conversation_id = request.get_conversation_id()
     
-    # check the socket cache for a socket for this conversation_id
-    conversation_id = request.messages[0].snowglobe_data.conversation_id
-    if conversation_id in socket_cache:
-        socket = socket_cache[conversation_id]
-    else:
-        # create a new socket connection 
-        # this is talking to a local socket/stateful server that you implemented
-        # update this or implement a way to connect to your actual server
-        socket = await websockets.connect("ws://localhost:9000/ws")
+    if conversation_id not in socket_cache:
+        socket = await websockets.connect(
+            "wss://api.openai.com/v1/realtime?model=gpt-4o-realtime-preview-2024-10-01&modalities=text",
+            additional_headers={
+                "Authorization": f"Bearer {openai_client.api_key}",
+                "OpenAI-Beta": "realtime=v1"
+            }
+        )
         socket_cache[conversation_id] = socket
+    else:
+        socket = socket_cache[conversation_id]
+    
+    # Send user message
+    messages = request.to_openai_messages()
+    user_message = messages[-1]["content"]
     
-    # send the request to the socket
     await socket.send(json.dumps({
-        "messages": completion_messages,
-        "conversation_id": conversation_id
+        "type": "conversation.item.create",
+        "session": {
+                "modalities": ["text"],  # Only text, no audio
+        },
+        "item": {
+            "type": "message",
+            "role": "user",
+            "content": [{"type": "input_text", "text": user_message}]
+        }
     }))
-
-    # wait for the response from the socket
-    response = await socket.recv()
-    response_data = json.loads(response)
-
-    # for debugging purposes
-    # print(f"Received response from socket: {response_data}")
     
-    # Example implementation, replace with actual logic
-    return CompletionFunctionOutputs(response=response_data.messages[0]["content"])
+    await socket.send(json.dumps({"type": "response.create"}))
+    
+    # Get response
+    response_content = ""
+    async for message in socket:
+        data = json.loads(message)
+        if data.get("type") == "response.audio_transcript.delta":
+            response_content += data.get("delta", "")
+        elif data.get("type") == "response.done":
+            break
+    
+    return CompletionFunctionOutputs(response=response_content)
 """
 
 
@@ -741,6 +810,159 @@ def auth(
     _poll_for_api_key(rc_path)
 
 
+@cli_app.command()
+def manage():
+    """
+    Manage saved app connections interactively
+    """
+    print("\n🔗 Manage Chatbot Connections\n")
+
+    pm = get_project_manager()
+
+    while True:
+        # Load current connections
+        agents = pm.list_agents()
+
+        if not agents:
+            print("💡 No connections found")
+            print("Run 'snowglobe-connect init' to create connections")
+            return
+
+        # Display connections
+        print(f"📱 Chatbot Connections ({len(agents)} total)")
+        print("-" * 60)
+        print(f"{'#':<3} {'File':<20} {'Chatbot Name':<20} {'Created':<12}")
+        print("-" * 60)
+
+        for i, (filename, agent_info) in enumerate(agents, 1):
+            app_name = agent_info.get("name", "Unknown")
+            created = agent_info.get("created", "Unknown")
+            # Format the created date
+            if "T" in created:
+                created = created.split("T")[0]
+
+            print(f"{i:<3} {filename:<20} {app_name:<20} {created:<12}")
+
+        print("-" * 60)
+        print("Commands:")
+        console.print(
+            f"- [bold green]1-{len(agents)}[/bold green] View connection details"
+        )
+        console.print("- [bold green]d[/bold green] Delete a connection")
+        console.print("- [bold green]q[/bold green] Quit")
+
+        try:
+            choice = input("").strip().lower()
+
+            if choice == "q":
+                print("✅ Session ended")
+                return
+            elif choice == "d":
+                # Delete mode
+                if not _handle_delete_mode(pm, agents):
+                    continue
+            elif choice.isdigit():
+                idx = int(choice)
+                if 1 <= idx <= len(agents):
+                    filename, agent_info = agents[idx - 1]
+                    _show_connection_details(filename, agent_info)
+                else:
+                    print(f"❌ Please choose between 1 and {len(agents)}")
+            else:
+                print("❌ Invalid choice. Use a number, 'd' to delete, or 'q' to quit")
+
+        except (KeyboardInterrupt, EOFError):
+            print("\n✅ Session ended")
+            return
+
+
+def _handle_delete_mode(pm, agents):
+    """Handle connection deletion workflow"""
+    print("\n🗑️  Delete Connection")
+    print("Select a connection to delete:")
+
+    # Show numbered list for deletion
+    for i, (filename, agent_info) in enumerate(agents, 1):
+        app_name = agent_info.get("name", "Unknown")
+        print(f"  {i}. {filename} ({app_name})")
+
+    try:
+        choice = (
+            input("\nSelect connection to delete (number or 'c' to cancel): ")
+            .strip()
+            .lower()
+        )
+
+        if choice == "c":
+            return True  # Continue with main menu
+        elif choice.isdigit():
+            idx = int(choice)
+            if 1 <= idx <= len(agents):
+                filename, agent_info = agents[idx - 1]
+                app_name = agent_info.get("name", "Unknown")
+
+                # Confirmation
+                print("\n⚠️  You are about to delete:")
+                print(f"   File: {filename}")
+                print(f"   Chatbot: {app_name}")
+
+                confirm = (
+                    input("\nAre you sure you want to delete this connection? (y/N): ")
+                    .strip()
+                    .lower()
+                )
+
+                if confirm == "y":
+                    # Remove from mapping
+                    pm.remove_agent_mapping(filename)
+
+                    # Ask if they want to delete the file too
+                    file_path = pm.project_root / filename
+                    if file_path.exists():
+                        delete_file = (
+                            input(
+                                f"Also delete the file '{filename}' from disk? (y/N): "
+                            )
+                            .strip()
+                            .lower()
+                        )
+                        if delete_file == "y":
+                            try:
+                                file_path.unlink()
+                                print(f"✅ Deleted connection and file: {filename}")
+                            except Exception as e:
+                                print(f"❌ Failed to delete file: {e}")
+                                print(f"✅ Connection mapping removed: {filename}")
+                        else:
+                            print(f"✅ Connection mapping removed: {filename}")
+                    else:
+                        print(f"✅ Connection mapping removed: {filename}")
+                else:
+                    print("💡 Delete cancelled")
+
+                return True  # Continue with main menu
+            else:
+                print(f"❌ Please choose between 1 and {len(agents)}")
+                return False  # Stay in delete mode
+        else:
+            print("❌ Invalid choice")
+            return False  # Stay in delete mode
+
+    except (KeyboardInterrupt, EOFError):
+        print("\n💡 Delete cancelled")
+        return True  # Continue with main menu
+
+
+def _show_connection_details(filename, agent_info):
+    """Show detailed information about a connection"""
+    print("\n📋 Connection Details")
+    print(f"  File: {filename}")
+    print(f"  Chatbot Name: {agent_info.get('name', 'Unknown')}")
+    print(f"  UUID: {agent_info.get('uuid', 'Unknown')}")
+    print(f"  Created: {agent_info.get('created', 'Unknown')}")
+    input("\nPress Enter to continue...")
+
+
 @cli_app.command()
 def start(
     verbose: bool = typer.Option(

{snowglobe-0.4.11 → snowglobe-0.4.13}/src/snowglobe/client/src/cli_utils.py

@@ -311,22 +311,49 @@ def check_auth_status() -> Tuple[bool, str, Dict[str, Any]]:
         return False, f"Connection error: {str(e)}", {}
 
 
-def select_stateful_interactive(
-    stateful: bool = False,
-) -> bool:
-    """Interactive prompt to confirm if the agent is stateful"""
+def select_template_interactive(
+    template: Optional[str] = None,
+) -> str:
+    """Interactive prompt to select template type"""
     if cli_state.json_output:
-        # For JSON mode, just return the default stateful value
-        return stateful
-    info(
-        "Some stateful agents such as ones that maintain communication over a websocket or convo specific completion endpoint require stateful integration."
+        # For JSON mode, return default or provided template
+        return template or "sync"
+
+    console.print("\n[bold cyan]📋 Select Integration Template:[/bold cyan]")
+    console.print(
+        "1. [bold green]Sync[/bold green] - Simple synchronous completion function"
+    )
+    console.print(
+        "   💡 Standard API calls, simple request-response patterns. Ex: OpenAI Client"
+    )
+    console.print(
+        "2. [bold yellow]Async[/bold yellow] - Asynchronous completion function"
     )
-    info(
-        "If your agent takes messages and completions on a single completion endpoint regardless of context, you can answer no to the following question."
+    console.print(
+        "   💡 Non-blocking operations, concurrent processing. Ex: OpenAI AsyncClient"
     )
-    if Confirm.ask("Would you like to initialize a stateful application?"):
-        return True
-    return False
+    console.print(
+        "3. [bold magenta]Socket[/bold magenta] - Real-time WebSocket/stateful connection"
+    )
+    console.print(
+        "   💡 Conversational agents, real-time streaming, stateful interactions. Ex: OpenAI Realtime Client"
+    )
+
+    from rich.prompt import Prompt
+
+    while True:
+        choice = Prompt.ask(
+            "\n[bold]Choose template[/bold]", choices=["1", "2", "3"], default="1"
+        )
+
+        if choice == "1":
+            return "sync"
+        elif choice == "2":
+            return "async"
+        elif choice == "3":
+            return "socket"
+        else:
+            error("Please choose 1, 2, or 3")
 
 
 def select_application_interactive(

{snowglobe-0.4.11 → snowglobe-0.4.13}/src/snowglobe/client/src/models.py

@@ -21,9 +21,25 @@ class CompletionFunctionOutputs(BaseModel):
 class CompletionRequest(BaseModel):
     messages: List[SnowglobeMessage]
 
-    def to_openai_messages(self) -> List[Dict]:
+    def to_openai_messages(self, system_prompt: Optional[str] = None) -> List[Dict]:
         """Return a list of OpenAI messages from the Snowglobe messages"""
-        return [{"role": msg.role, "content": msg.content} for msg in self.messages]
+        oai_messages = []
+
+        if system_prompt:
+            oai_messages.append({"role": "system", "content": system_prompt})
+
+        oai_messages.extend(
+            [{"role": msg.role, "content": msg.content} for msg in self.messages]
+        )
+        return oai_messages
+
+    def get_prompt(self) -> str:
+        """Return the prompt from the Snowglobe messages"""
+        return self.to_openai_messages(system_prompt=None)[-1]["content"]
+
+    def get_conversation_id(self) -> str:
+        """Return the conversation id from the Snowglobe messages"""
+        return self.messages[0].snowglobe_data.conversation_id
 
 
 class RiskEvaluationRequest(BaseModel):

{snowglobe-0.4.11 → snowglobe-0.4.13}/src/snowglobe/client/src/telemetry.py

@@ -33,7 +33,9 @@ def trace_completion_fn(
             current_user = w.current_user.me()
 
             formatted_sim_name = simulation_name.lower().replace(" ", "_")
-            default_experiment_name = f"/Users/{current_user.user_name}/{formatted_sim_name}"
+            default_experiment_name = (
+                f"/Users/{current_user.user_name}/{formatted_sim_name}"
+            )
 
             mlflow_experiment_name = (
                 os.getenv("MLFLOW_EXPERIMENT_NAME") or default_experiment_name
@@ -103,8 +105,10 @@ def trace_risk_evaluation_fn(
             current_user = w.current_user.me()
 
             formatted_sim_name = simulation_name.lower().replace(" ", "_")
-            default_experiment_name = f"/Users/{current_user.user_name}/{formatted_sim_name}"
-        
+            default_experiment_name = (
+                f"/Users/{current_user.user_name}/{formatted_sim_name}"
+            )
+
             mlflow_experiment_name = (
                 os.getenv("MLFLOW_EXPERIMENT_NAME") or default_experiment_name
             )

{snowglobe-0.4.11 → snowglobe-0.4.13}/src/snowglobe/client/src/utils.py

@@ -23,15 +23,18 @@ async def fetch_experiments(app_id: str = None) -> list[dict]:
         try:
             # get elapsed time for this request
             import time
+
             start_time = time.monotonic()
             experiments_response = await client.get(
-            experiments_url,
-            headers={"x-api-key": get_api_key_or_raise()},
-            timeout=60.0,  # Set timeout to 60 seconds
+                experiments_url,
+                headers={"x-api-key": get_api_key_or_raise()},
+                timeout=60.0,  # Set timeout to 60 seconds
             )
         except httpx.ConnectTimeout:
             elapsed_time = time.monotonic() - start_time
-            raise Exception(f"Warning: Connection timed out while fetching experiments. Elapsed time: {elapsed_time:.2f} seconds. Polling will continue. If this persists please contact Snowglobe support.")
+            raise Exception(
+                f"Warning: Connection timed out while fetching experiments. Elapsed time: {elapsed_time:.2f} seconds. Polling will continue. If this persists please contact Snowglobe support."
+            )
 
     if not experiments_response.status_code == 200:
         try:

{snowglobe-0.4.11 → snowglobe-0.4.13/src/snowglobe.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snowglobe
-Version: 0.4.11
+Version: 0.4.13
 Summary: client server for usage with snowglobe experiments
 Author-email: Guardrails AI <contact@guardrailsai.com>
 License: MIT License
@@ -31,6 +31,7 @@ License-File: LICENSE
 Requires-Dist: typer>=0.9.0
 Requires-Dist: fastapi>=0.115.6
 Requires-Dist: uvicorn[standard]>=0.23.0
+Requires-Dist: openai>=1.55.2
 Requires-Dist: requests>=2.31.0
 Requires-Dist: pydantic>=2.11.5
 Requires-Dist: APScheduler==4.0.0a6
@@ -87,7 +88,7 @@ import os
 
 client = OpenAI(api_key=os.getenv("SNOWGLOBE_API_KEY"))
 
-def process_scenario(request: CompletionRequest) -> CompletionFunctionOutputs:
+def completion_fn(request: CompletionRequest) -> CompletionFunctionOutputs:
     """
     Process a scenario request from Snowglobe.
     

{snowglobe-0.4.11 → snowglobe-0.4.13}/src/snowglobe.egg-info/requires.txt

@@ -1,6 +1,7 @@
 typer>=0.9.0
 fastapi>=0.115.6
 uvicorn[standard]>=0.23.0
+openai>=1.55.2
 requests>=2.31.0
 pydantic>=2.11.5
 APScheduler==4.0.0a6

{snowglobe-0.4.11 → snowglobe-0.4.13}/tests/test_cli.py

@@ -141,11 +141,11 @@ class TestCli(unittest.TestCase):
         "snowglobe.client.src.cli.select_application_interactive"
     )  # Mock application selection in cli module
     @mock.patch(
-        "snowglobe.client.src.cli.select_stateful_interactive"
-    )  # Mock application selection in cli module
+        "snowglobe.client.src.cli.select_template_interactive"
+    )  # Mock template selection in cli module
     def test_init(
         self,
-        mock_select_stateful,
+        mock_select_template,
         mock_select_app,
         mock_get_apps,
         mock_check_auth,
@@ -178,15 +178,15 @@ class TestCli(unittest.TestCase):
         ]
         mock_get_apps.return_value = (True, mock_applications, "Success")
 
-        # Mock user selecting the first application
+        # Mock user selecting the first application and sync template
         mock_select_app.return_value = mock_applications[0]
-        mock_select_stateful.return_value = False
+        mock_select_template.return_value = "sync"
         # Run the init command in a temporary directory
         with tempfile.TemporaryDirectory() as tmpdir:
             with mock.patch("os.getcwd", return_value=tmpdir):
                 with mock.patch.dict(os.environ, {"SNOWGLOBE_API_KEY": "test_api_key"}):
                     # Run the init command (pass default values for typer options)
-                    cli.init(file=None, stateful=False)
+                    cli.init(file=None)
 
                 # Verify authentication was checked
                 mock_check_auth.assert_called_once()
@@ -240,9 +240,12 @@ class TestCli(unittest.TestCase):
                 )
 
                 # Check for required function definition
-                self.assertIn(
-                    "def process_scenario(request: CompletionRequest) -> CompletionFunctionOutputs:",
-                    agent_content,
+                self.assertTrue(
+                    "def completion(request: CompletionRequest) -> CompletionFunctionOutputs:"
+                    in agent_content
+                    or "def acompletion(request: CompletionRequest) -> CompletionFunctionOutputs:"
+                    in agent_content,
+                    "Agent file should contain either completion or acompletion function",
                 )
 
                 # Check that the file is valid Python (can be parsed)
@@ -264,10 +267,10 @@ class TestCli(unittest.TestCase):
     @mock.patch("snowglobe.client.src.cli.check_auth_status")
     @mock.patch("snowglobe.client.src.cli.get_remote_applications")
     @mock.patch("snowglobe.client.src.cli.select_application_interactive")
-    @mock.patch("snowglobe.client.src.cli.select_stateful_interactive")
+    @mock.patch("snowglobe.client.src.cli.select_template_interactive")
     def test_init_with_file_option_creates_nested_path_and_mapping(
         self,
-        mock_select_stateful,
+        mock_select_template,
         mock_select_app,
         mock_get_apps,
         mock_check_auth,
@@ -291,7 +294,7 @@ class TestCli(unittest.TestCase):
         ]
         mock_get_apps.return_value = (True, mock_applications, "Success")
         mock_select_app.return_value = mock_applications[0]
-        mock_select_stateful.return_value = False  # Default to stateless
+        mock_select_template.return_value = "sync"  # Default to sync template
 
         runner = CliRunner()
 
@@ -460,7 +463,7 @@ class TestCli(unittest.TestCase):
         ) as mock_test_wrapper:
             mock_test_wrapper.return_value = (
                 False,
-                "Missing process_scenario function",
+                "Missing completion function",
             )
 
             with self.assertRaises(typer.Exit) as cm:
@@ -504,29 +507,29 @@ class TestCli(unittest.TestCase):
                 self.assertFalse(result)
                 # Should fail during module loading
 
-            # Test Case 17: Missing process_scenario function
+            # Test Case 17: Missing completion function
             no_func_file = os.path.join(tmpdir, "no_func.py")
             with open(no_func_file, "w") as f:
-                f.write("# Valid Python but no process_scenario function\npass\n")
+                f.write("# Valid Python but no completion function\npass\n")
 
             with mock.patch("os.getcwd", return_value=tmpdir):
                 result, message = cli.test_agent_wrapper(
                     "no_func.py", "test_123", "Test App"
                 )
                 self.assertFalse(result)
-                self.assertIn("process_scenario function not found", message)
+                self.assertIn("completion or acompletion function not found", message)
 
-            # Test Case 18: Non-callable process_scenario
+            # Test Case 18: Non-callable completion function
             non_callable_file = os.path.join(tmpdir, "non_callable.py")
             with open(non_callable_file, "w") as f:
-                f.write("process_scenario = 'not a function'\n")
+                f.write("completion = 'not a function'\n")
 
             with mock.patch("os.getcwd", return_value=tmpdir):
                 result, message = cli.test_agent_wrapper(
                     "non_callable.py", "test_123", "Test App"
                 )
                 self.assertFalse(result)
-                self.assertIn("process_scenario is not callable", message)
+                self.assertIn("completion function is not callable", message)
 
             # Test Case 19: Valid agent with default template response
             template_file = os.path.join(tmpdir, "template.py")
@@ -535,7 +538,7 @@ class TestCli(unittest.TestCase):
                     """
 from snowglobe.client import CompletionRequest, CompletionFunctionOutputs
 
-def process_scenario(request):
+def completion(request):
     return CompletionFunctionOutputs(response="Your response here")
 """
                 )