solace-agent-mesh 1.1.0__py3-none-any.whl → 1.3.0__py3-none-any.whl

solace_agent_mesh/cli/__init__.py

@@ -1 +1 @@
-__version__ = "1.1.0"
+__version__ = "1.3.0"

solace_agent_mesh/cli/commands/add_cmd/agent_cmd.py

@@ -1,23 +1,37 @@
 import json
+import sys
 from pathlib import Path
 
 import click
 import yaml
 
-from config_portal.backend.common import (
-    AGENT_DEFAULTS,
-    USE_DEFAULT_SHARED_ARTIFACT,
-    USE_DEFAULT_SHARED_SESSION,
-)
+from config_portal.backend.common import AGENT_DEFAULTS, USE_DEFAULT_SHARED_ARTIFACT
 
 from ...utils import (
     ask_if_not_provided,
+    ask_yes_no_question,
+    create_and_validate_database,
     get_formatted_names,
     indent_multiline_string,
     load_template,
 )
 from .web_add_agent_step import launch_add_agent_web_portal
 
+DATABASE_URL_KEY = "database_url"
+
+
+def _append_to_env_file(project_root: Path, key: str, value: str):
+    env_path = project_root / ".env"
+    try:
+        with open(env_path, "a", encoding="utf-8") as f:
+            f.write(f'\n{key}="{value}"\n')
+        return True
+    except OSError as e:
+        click.echo(
+            click.style(f"Error appending to .env file: {e}", fg="red"), err=True
+        )
+        return False
+
 
 def _write_agent_yaml_from_data(
     agent_name_input: str, config_options: dict, project_root: Path
@@ -39,17 +53,27 @@ def _write_agent_yaml_from_data(
     try:
         modified_content = load_template("agent_template.yaml")
         session_service_type_opt = config_options.get("session_service_type")
-        if (
-            session_service_type_opt
-            and session_service_type_opt != USE_DEFAULT_SHARED_SESSION
-        ):
+        if session_service_type_opt and session_service_type_opt != "memory":
             type_val = session_service_type_opt
             behavior_val = config_options.get(
                 "session_service_behavior", AGENT_DEFAULTS["session_service_behavior"]
             )
-            session_service_block = (
-                f'\n        type: "{type_val}"\n'
-                f'        default_behavior: "{behavior_val}"'
+
+            session_service_lines = [
+                f'type: "{type_val}"',
+                f'default_behavior: "{behavior_val}"',
+            ]
+
+            if type_val == "sql":
+                database_url_placeholder = (
+                    f"${{{formatted_names['SNAKE_UPPER_CASE_NAME']}_DATABASE_URL}}"
+                )
+                session_service_lines.append(
+                    f'database_url: "{database_url_placeholder}"'
+                )
+
+            session_service_block = "\n" + "\n".join(
+                [f"        {line}" for line in session_service_lines]
             )
         else:
             session_service_block = "*default_session_service"
@@ -70,25 +94,9 @@ def _write_agent_yaml_from_data(
                 )
                 custom_artifact_lines.append(f'base_path: "{base_path_val}"')
             elif type_val == "s3":
-                bucket_name_val = config_options.get(
-                    "artifact_service_bucket_name",
-                    AGENT_DEFAULTS.get("artifact_service_bucket_name", ""),
-                )
-                custom_artifact_lines.append(f'bucket_name: "{bucket_name_val}"')
-
-                endpoint_url_val = config_options.get(
-                    "artifact_service_endpoint_url",
-                    AGENT_DEFAULTS.get("artifact_service_endpoint_url", ""),
-                )
-                if endpoint_url_val:
-                    custom_artifact_lines.append(f'endpoint_url: "{endpoint_url_val}"')
-
-                region_val = config_options.get(
-                    "artifact_service_region",
-                    AGENT_DEFAULTS.get("artifact_service_region", "us-east-1"),
-                )
-                if region_val:
-                    custom_artifact_lines.append(f'region: "{region_val}"')
+                custom_artifact_lines.append("bucket_name: ${S3_BUCKET_NAME}")
+                custom_artifact_lines.append("endpoint_url: ${S3_ENDPOINT_URL:-}")
+                custom_artifact_lines.append("region: ${S3_REGION}")
             custom_artifact_lines.append(f"artifact_scope: {scope_val}")
             artifact_service_block = "\n" + "\n".join(
                 [f"        {line}" for line in custom_artifact_lines]
@@ -187,7 +195,9 @@ def _write_agent_yaml_from_data(
 
         replacements = {
             "__AGENT_NAME__": agent_name_camel,
-            "__AGENT_SPACED_NAME__": get_formatted_names(agent_name_camel).get("SPACED_CAPITALIZED_NAME"),
+            "__AGENT_SPACED_NAME__": get_formatted_names(agent_name_camel).get(
+                "SPACED_CAPITALIZED_NAME"
+            ),
             "__NAMESPACE__": config_options.get(
                 "namespace", AGENT_DEFAULTS["namespace"]
             ),
@@ -283,6 +293,12 @@ def _write_agent_yaml_from_data(
 
         for placeholder, value in replacements.items():
             modified_content = modified_content.replace(placeholder, str(value))
+        if config_options.get(DATABASE_URL_KEY):
+            env_key = f"{formatted_names['SNAKE_UPPER_CASE_NAME']}_DATABASE_URL"
+            if not _append_to_env_file(
+                project_root, env_key, config_options[DATABASE_URL_KEY]
+            ):
+                return False, "Failed to write to .env file.", ""
 
         with open(agent_config_file_path, "w", encoding="utf-8") as f:
             f.write(modified_content)
@@ -370,17 +386,68 @@ def create_agent_config(
         "Session service type",
         AGENT_DEFAULTS["session_service_type"],
         skip_interactive,
-        choices=[USE_DEFAULT_SHARED_SESSION, "memory", "vertex_rag"],
+        choices=["sql", "memory", "vertex_rag"],
+    )
+
+    if collected_options.get("session_service_type") == "sql":
+        if DATABASE_URL_KEY not in collected_options:
+            use_own_db = False
+            if not skip_interactive:
+                use_own_db = ask_yes_no_question(
+                    f"Do you want to use your own database for the '{agent_name_camel_case}' agent?\n"
+                    f"  (If no, SQLite embedded database will be used)",
+                    default=False,
+                )
+
+            if use_own_db:
+                database_url = ask_if_not_provided(
+                    collected_options,
+                    DATABASE_URL_KEY,
+                    f"Enter the full database URL for the {agent_name_camel_case} agent (e.g., postgresql://user:pass@host/db)",
+                    none_interactive=skip_interactive,
+                )
+                collected_options[DATABASE_URL_KEY] = database_url
+            else:
+                data_dir = project_root / "data"
+                data_dir.mkdir(exist_ok=True)
+                db_file = data_dir / f"{formatted_names['SNAKE_CASE_NAME']}.db"
+                database_url = f"sqlite:///{db_file.resolve()}"
+                click.echo(
+                    f"  Using default SQLite database for {agent_name_camel_case} agent: {db_file}"
+                )
+                collected_options[DATABASE_URL_KEY] = database_url
+
+        try:
+            db_url = collected_options.get(DATABASE_URL_KEY)
+            if not db_url:
+                error_msg = "Database URL was not provided or determined despite SQL session service being selected."
+                click.echo(
+                    click.style(f"Internal Error: {error_msg}", fg="red"), err=True
+                )
+                raise ValueError(error_msg)
+
+            click.echo(f"  Validating database: {db_url}")
+            create_and_validate_database(
+                db_url, f"{agent_name_camel_case} agent database"
+            )
+        except Exception as e:
+            click.echo(
+                click.style(
+                    f"Error validating database URL '{collected_options.get(DATABASE_URL_KEY)}': {e}",
+                    fg="red",
+                ),
+                err=True,
+            )
+            return False
+
+    collected_options["session_service_behavior"] = ask_if_not_provided(
+        collected_options,
+        "session_service_behavior",
+        "Session service behavior",
+        AGENT_DEFAULTS["session_service_behavior"],
+        skip_interactive,
+        choices=["PERSISTENT", "RUN_BASED"],
     )
-    if collected_options["session_service_type"] != USE_DEFAULT_SHARED_SESSION:
-        collected_options["session_service_behavior"] = ask_if_not_provided(
-            collected_options,
-            "session_service_behavior",
-            "Session service behavior",
-            AGENT_DEFAULTS["session_service_behavior"],
-            skip_interactive,
-            choices=["PERSISTENT", "RUN_BASED"],
-        )
 
     collected_options["artifact_service_type"] = ask_if_not_provided(
         collected_options,
@@ -469,7 +536,9 @@ def create_agent_config(
         skip_interactive,
     )
     collected_options["agent_card_default_input_modes"] = [
-        mode.strip() for mode in default_input_modes_str.split(",") if mode.strip()
+        mode.strip()
+        for mode in (default_input_modes_str or "").split(",")
+        if mode.strip()
     ]
 
     default_output_modes_str = ask_if_not_provided(
@@ -480,7 +549,9 @@ def create_agent_config(
         skip_interactive,
     )
     collected_options["agent_card_default_output_modes"] = [
-        mode.strip() for mode in default_output_modes_str.split(",") if mode.strip()
+        mode.strip()
+        for mode in (default_output_modes_str or "").split(",")
+        if mode.strip()
     ]
 
     collected_options["agent_card_skills_str"] = ask_if_not_provided(
@@ -514,8 +585,9 @@ def create_agent_config(
         ",".join(AGENT_DEFAULTS["inter_agent_communication_allow_list"]),
         skip_interactive,
     )
+    allow_list_items = (allow_list_str or "").split(",")
     collected_options["inter_agent_communication_allow_list"] = [
-        item.strip() for item in allow_list_str.split(",") if item.strip()
+        item.strip() for item in allow_list_items if item.strip()
     ]
 
     deny_list_str = ask_if_not_provided(
@@ -525,8 +597,9 @@ def create_agent_config(
         ",".join(AGENT_DEFAULTS["inter_agent_communication_deny_list"]),
         skip_interactive,
     )
+    deny_list_items = (deny_list_str or "").split(",")
     collected_options["inter_agent_communication_deny_list"] = [
-        item.strip() for item in deny_list_str.split(",") if item.strip()
+        item.strip() for item in deny_list_items if item.strip()
     ]
 
     collected_options["inter_agent_communication_timeout"] = ask_if_not_provided(
@@ -546,7 +619,7 @@ def create_agent_config(
         skip_interactive,
     )
     try:
-        tools_list = json.loads(tools_json_str)
+        tools_list = json.loads(tools_json_str or "[]")
         if not isinstance(tools_list, list):
             tools_list = []
             if not skip_interactive:
@@ -595,7 +668,7 @@ def create_agent_config(
 @click.option("--instruction", help="Custom instruction for the agent.")
 @click.option(
     "--session-service-type",
-    type=click.Choice(["memory", "vertex_rag"]),
+    type=click.Choice(["sql", "memory", "vertex_rag"]),
     help="Session service type.",
 )
 @click.option(
@@ -603,6 +676,9 @@ def create_agent_config(
     type=click.Choice(["PERSISTENT", "RUN_BASED"]),
     help="Session service behavior.",
 )
+@click.option(
+    "--database-url", help="Database URL for session service (if type is 'sql')."
+)
 @click.option(
     "--artifact-service-type",
     type=click.Choice(["memory", "filesystem", "gcs", "s3"]),
@@ -714,3 +790,4 @@ def add_agent(name: str, gui: bool = False, **kwargs):
                 ),
                 err=True,
             )
+            sys.exit(1)

solace_agent_mesh/cli/commands/eval_cmd.py

@@ -1,10 +1,23 @@
 import click
+import pkg_resources
 from pathlib import Path
 
 from evaluation.run import main as run_evaluation_main
 from cli.utils import error_exit, load_template
 
 
+def _ensure_sam_rest_gateway_installed():
+    """Checks if the sam-rest-gateway package is installed."""
+    try:
+        pkg_resources.get_distribution("sam-rest-gateway")
+    except pkg_resources.DistributionNotFound:
+        error_exit(
+            "Error: 'sam-rest-gateway' is not installed. "
+            "Please install it using: "
+            'pip install "sam-rest-gateway @ git+https://github.com/SolaceLabs/solace-agent-mesh-core-plugins#subdirectory=sam-rest-gateway"'
+        )
+
+
 def _ensure_eval_backend_config_exists():
     """Checks for eval_backend.yaml and creates it from a template if missing."""
     project_root = Path.cwd()
@@ -62,6 +75,7 @@ def eval_cmd(test_suite_config_path, verbose):
             fg="blue",
         )
     )
+    _ensure_sam_rest_gateway_installed()
     _ensure_eval_backend_config_exists()
     try:
         run_evaluation_main(test_suite_config_path, verbose=verbose)

solace_agent_mesh/cli/commands/init_cmd/__init__.py

@@ -1,17 +1,17 @@
-import click
 from pathlib import Path
 
+import click
+
 from ...utils import ask_yes_no_question
-from .web_init_step import perform_web_init
+from .broker_step import broker_setup_step
+from .database_step import database_setup_step
 from .directory_step import create_project_directories
+from .env_step import ENV_DEFAULTS, create_env_file
+from .orchestrator_step import ORCHESTRATOR_DEFAULTS as O_DEFAULTS
+from .orchestrator_step import create_orchestrator_config
 from .project_files_step import create_project_files
-from .env_step import create_env_file, ENV_DEFAULTS
-from .broker_step import broker_setup_step
-from .orchestrator_step import (
-    create_orchestrator_config,
-    ORCHESTRATOR_DEFAULTS as O_DEFAULTS,
-)
-from .webui_gateway_step import create_webui_gateway_config, WEBUI_GATEWAY_DEFAULTS
+from .web_init_step import perform_web_init
+from .webui_gateway_step import WEBUI_GATEWAY_DEFAULTS, create_webui_gateway_config
 
 
 def _get_flat_orchestrator_defaults():
@@ -19,10 +19,8 @@ def _get_flat_orchestrator_defaults():
     flat_defaults = {}
     flat_defaults["agent_name"] = O_DEFAULTS["agent_name"]
     flat_defaults["supports_streaming"] = O_DEFAULTS["supports_streaming"]
-    flat_defaults["session_service_type"] = O_DEFAULTS["session_service"]["type"]
-    flat_defaults["session_service_behavior"] = O_DEFAULTS["session_service"][
-        "default_behavior"
-    ]
+    flat_defaults["session_service_type"] = "memory"
+    flat_defaults["session_service_behavior"] = "PERSISTENT"
     flat_defaults["artifact_service_type"] = O_DEFAULTS["artifact_service"]["type"]
     flat_defaults["artifact_service_base_path"] = O_DEFAULTS["artifact_service"][
         "base_path"
@@ -30,9 +28,15 @@ def _get_flat_orchestrator_defaults():
     flat_defaults["artifact_service_scope"] = O_DEFAULTS["artifact_service"][
         "artifact_scope"
     ]
-    flat_defaults["artifact_service_bucket_name"] = O_DEFAULTS["artifact_service"].get("bucket_name", "")
-    flat_defaults["artifact_service_endpoint_url"] = O_DEFAULTS["artifact_service"].get("endpoint_url", "")
-    flat_defaults["artifact_service_region"] = O_DEFAULTS["artifact_service"].get("region", "us-east-1")
+    flat_defaults["artifact_service_bucket_name"] = O_DEFAULTS["artifact_service"].get(
+        "bucket_name", ""
+    )
+    flat_defaults["artifact_service_endpoint_url"] = O_DEFAULTS["artifact_service"].get(
+        "endpoint_url", ""
+    )
+    flat_defaults["artifact_service_region"] = O_DEFAULTS["artifact_service"].get(
+        "region", "us-east-1"
+    )
     flat_defaults["artifact_handling_mode"] = O_DEFAULTS["artifact_handling_mode"]
     flat_defaults["enable_embed_resolution"] = O_DEFAULTS["enable_embed_resolution"]
     flat_defaults["enable_artifact_content_instruction"] = O_DEFAULTS[
@@ -124,6 +128,9 @@ def run_init_flow(skip_interactive: bool, use_web_based_init_flag: bool, **cli_o
             default=True,
         )
 
+    project_root = Path.cwd()
+    click.echo(f"Project will be initialized in: {project_root}")
+
     if actual_use_web_init:
         if skip_interactive:
             click.echo(
@@ -136,10 +143,7 @@ def run_init_flow(skip_interactive: bool, use_web_based_init_flag: bool, **cli_o
             options = perform_web_init(options)
             skip_interactive = True
 
-    project_root = Path.cwd()
-    click.echo(f"Project will be initialized in: {project_root}")
-
-    shared_post_data_gathering_steps = [
+    steps = [
         ("Broker Setup", broker_setup_step),
         (
             "Project Directory Setup",
@@ -161,20 +165,20 @@ def run_init_flow(skip_interactive: bool, use_web_based_init_flag: bool, **cli_o
                 project_root, opts, skip, defs
             ),
         ),
+        (
+            "Database Setup",
+            lambda opts, defs, skip: database_setup_step(project_root, opts, skip),
+        ),
         (
             ".env File Creation",
             lambda opts, defs, skip: create_env_file(project_root, opts, skip),
         ),
     ]
 
-    current_steps_sequence = shared_post_data_gathering_steps
-
     step_count = 0
-    total_display_steps = len(
-        [s_name for s_name, _ in current_steps_sequence if s_name]
-    )
+    total_display_steps = len([s_name for s_name, _ in steps if s_name])
 
-    for step_name, step_function in current_steps_sequence:
+    for step_name, step_function in steps:
         if step_name:
             step_count += 1
             click.echo(
@@ -256,7 +260,7 @@ def run_init_flow(skip_interactive: bool, use_web_based_init_flag: bool, **cli_o
 )
 @click.option(
     "--session-service-type",
-    type=click.Choice(["memory", "vertex_rag"]),
+    type=click.Choice(["memory", "vertex_rag", "sql"]),
     help="Session service type.",
 )
 @click.option(
@@ -371,10 +375,16 @@ def run_init_flow(skip_interactive: bool, use_web_based_init_flag: bool, **cli_o
 )
 @click.option("--webui-fastapi-host", type=str, help="Host for Web UI FastAPI server.")
 @click.option("--webui-fastapi-port", type=int, help="Port for Web UI FastAPI server.")
-@click.option("--webui-fastapi-https-port", type=int, help="HTTPS port for Web UI FastAPI server.")
+@click.option(
+    "--webui-fastapi-https-port", type=int, help="HTTPS port for Web UI FastAPI server."
+)
 @click.option("--webui-ssl-keyfile", type=str, help="SSL key file path for Web UI.")
-@click.option("--webui-ssl-certfile", type=str, help="SSL certificate file path for Web UI.")
-@click.option("--webui-ssl-keyfile-password", type=str, help="SSL key file passphrase for Web UI.")
+@click.option(
+    "--webui-ssl-certfile", type=str, help="SSL certificate file path for Web UI."
+)
+@click.option(
+    "--webui-ssl-keyfile-password", type=str, help="SSL key file passphrase for Web UI."
+)
 @click.option(
     "--webui-enable-embed-resolution",
     is_flag=True,
@@ -395,11 +405,23 @@ def run_init_flow(skip_interactive: bool, use_web_based_init_flag: bool, **cli_o
     default=None,
     help="Enable feedback collection in Web UI.",
 )
+@click.option(
+    "--web-ui-gateway-database-url",
+    type=str,
+    help="Database URL for the WebUI Gateway.",
+)
+@click.option(
+    "--orchestrator-database-url",
+    type=str,
+    help="Database URL for the Orchestrator.",
+)
 def init(**kwargs):
     """
     Initialize a new Solace application project.
     Creates a directory structure, default configuration files, and a .env file.
     """
+    use_web_based_init_val = kwargs.get("gui", False)
+
     if kwargs.get("dev_mode_flag"):
         if kwargs.get("broker_type") is None:
             kwargs["broker_type"] = "dev"
@@ -419,4 +441,4 @@ def init(**kwargs):
         skip_interactive=skip_interactive_val,
         use_web_based_init_flag=use_web_based_init_val,
         **kwargs,
-    )
+    )

solace_agent_mesh/cli/commands/init_cmd/database_step.py

@@ -0,0 +1,91 @@
+from pathlib import Path
+
+import click
+
+from ...utils import (
+    ask_if_not_provided,
+    ask_yes_no_question,
+    create_and_validate_database,
+)
+
+
+def prompt_for_db_credentials(
+    options: dict, db_type: str, skip_interactive: bool
+) -> str:
+    if skip_interactive:
+        db_url = options.get(f"{db_type}_database_url")
+        if not db_url:
+            raise ValueError(
+                f"Database URL for {db_type} is required in non-interactive mode"
+            )
+        return db_url
+
+    # Ask which database type to use
+    db_backend = ask_if_not_provided(
+        {},
+        "db_backend",
+        f"Which database would you like to use for {db_type}?",
+        choices=["sqlite", "postgresql"],
+        default="sqlite",
+    )
+
+    if db_backend == "postgresql":
+        db_url = ask_if_not_provided(
+            options,
+            f"{db_type}_database_url",
+            f"Enter the PostgreSQL URL for {db_type} (e.g., postgresql://user:pass@host:5432/dbname)",
+            none_interactive=skip_interactive,
+        )
+    else:
+        # Use SQLite as fallback/default
+        return None  # Will be handled by the SQLite setup logic
+
+    return db_url
+
+
+def database_setup_step(
+    project_root: Path, options: dict, skip_interactive: bool
+) -> bool:
+    click.echo("Setting up database(s)...")
+
+    db_configs = []
+    if options.get("add_webui_gateway"):
+        db_configs.append(
+            ("gateway", "web_ui_gateway_database_url", "webui_gateway.db")
+        )
+    if options.get("use_orchestrator_db"):
+        kebab_name = options.get("agent_name", "orchestrator").lower().replace("_", "-")
+        db_configs.append(
+            ("orchestrator", "orchestrator_database_url", f"{kebab_name}.db")
+        )
+
+    for db_type, url_key, default_filename in db_configs:
+        if options.get(url_key):
+            database_url = options[url_key]
+            click.echo(f"  Using provided database URL for {db_type}.")
+        else:
+            use_own_db = False
+            if not skip_interactive:
+                use_own_db = ask_yes_no_question(
+                    f"Do you want to use your own database for the {db_type}?",
+                    default=False,
+                )
+
+            if use_own_db:
+                database_url = prompt_for_db_credentials(
+                    options, db_type, skip_interactive
+                )
+            else:
+                data_dir = project_root / "data"
+                data_dir.mkdir(exist_ok=True)
+                db_file = data_dir / default_filename
+                database_url = f"sqlite:///{db_file.resolve()}"
+                click.echo(f"  Using default SQLite database for {db_type}: {db_file}")
+
+        options[url_key] = database_url
+
+        # Create and validate database connection
+        create_and_validate_database(database_url, f"{url_key} database")
+
+    click.echo("  Database setup complete.")
+    return True

solace_agent_mesh/cli/commands/init_cmd/env_step.py

@@ -18,6 +18,8 @@ ENV_DEFAULTS = {
     "FASTAPI_PORT": "8000",
     "FASTAPI_HTTPS_PORT": "8443",
     "ENABLE_EMBED_RESOLUTION": "true",
+    "WEB_UI_GATEWAY_DATABASE_URL": "sqlite:///data/webui_gateway.db",
+    "ORCHESTRATOR_DATABASE_URL": "sqlite:///data/orchestrator.db",
     "SSL_KEYFILE": "",
     "SSL_CERTFILE": "",
     "SSL_KEYFILE_PASSWORD": "",
@@ -39,28 +41,28 @@ def create_env_file(project_root: Path, options: dict, skip_interactive: bool) -
 
     env_params_config = [
         (
-            "llm_endpoint_url",
+            "llm_service_endpoint",
             "LLM_SERVICE_ENDPOINT",
             "Enter LLM Service Endpoint URL",
             False,
             "LLM_SERVICE_ENDPOINT",
         ),
         (
-            "llm_api_key",
+            "llm_service_api_key",
             "LLM_SERVICE_API_KEY",
             "Enter LLM Service API Key",
             True,
             "LLM_SERVICE_API_KEY",
         ),
         (
-            "llm_planning_model_name",
+            "llm_service_planning_model_name",
             "LLM_SERVICE_PLANNING_MODEL_NAME",
             "Enter LLM Planning Model Name (e.g., openai/gpt-4o)",
             False,
             "LLM_SERVICE_PLANNING_MODEL_NAME",
         ),
         (
-            "llm_general_model_name",
+            "llm_service_general_model_name",
             "LLM_SERVICE_GENERAL_MODEL_NAME",
             "Enter LLM General Model Name (e.g., openai/gpt-3.5-turbo)",
             False,
@@ -134,28 +136,28 @@ def create_env_file(project_root: Path, options: dict, skip_interactive: bool) -
             "FASTAPI_HTTPS_PORT",
             "Enter Web UI FastAPI HTTPS Port",
             False,
-            "FASTAPI_HTTPS_PORT"
+            "FASTAPI_HTTPS_PORT",
         ),
         (
             "webui_ssl_keyfile",
             "SSL_KEYFILE",
             "Enter SSL Key File Path",
             False,
-            "SSL_KEYFILE"
+            "SSL_KEYFILE",
         ),
         (
             "webui_ssl_certfile",
             "SSL_CERTFILE",
             "Enter SSL Certificate File Path",
             False,
-            "SSL_CERTFILE"
+            "SSL_CERTFILE",
         ),
         (
             "webui_ssl_keyfile_password",
             "SSL_KEYFILE_PASSWORD",
             "Enter SSL Key File Passphrase",
             True,
-            "SSL_KEYFILE_PASSWORD"
+            "SSL_KEYFILE_PASSWORD",
         ),
         (
             "webui_enable_embed_resolution",
@@ -207,6 +209,15 @@ def create_env_file(project_root: Path, options: dict, skip_interactive: bool) -
         )
         env_vars_to_write[env_name] = options.get(opt_key)
 
+    if options.get("web_ui_gateway_database_url"):
+        env_vars_to_write["WEB_UI_GATEWAY_DATABASE_URL"] = options[
+            "web_ui_gateway_database_url"
+        ]
+    if options.get("orchestrator_database_url"):
+        env_vars_to_write["ORCHESTRATOR_DATABASE_URL"] = options[
+            "orchestrator_database_url"
+        ]
+
     if (
         env_vars_to_write.get("NAMESPACE")
         and env_vars_to_write["NAMESPACE"] != ENV_DEFAULTS.get("NAMESPACE")