agentcore-cli 0.31.1__py3-none-any.whl

agentcore/primitives/_knowledge_base_wizard.py

@@ -0,0 +1,259 @@
+"""Prompt-based port of tui/screens/knowledge-base (AddKnowledgeBaseScreen + AddKnowledgeBaseFlow).
+
+Question order: name -> description -> data-source type -> source (S3 URI, or connector config as a
+file path / inline JSON) -> add another? (add / remove a captured source / done) -> confirm.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any
+
+import typer
+
+from agentcore.cli import interactive
+from agentcore.cli.commands.add._common import first_issue
+from agentcore.cli.naming import generate_unique_name
+from agentcore.lib.schemas.io.config_io import ConfigIO
+from agentcore.operations.knowledge_base.connector_config import flag_to_wire_type
+from agentcore.schema import KnowledgeBaseName, S3DataSource
+
+if TYPE_CHECKING:
+    from agentcore.primitives.knowledge_base import KnowledgeBasePrimitive
+
+# Sentinel prefix tagging a captured connector config whose value is inline JSON, not a path.
+INLINE_JSON_PREFIX = "\u0000inline-json:"
+
+DATA_SOURCE_TYPE_OPTIONS = [
+    ("s3", "Amazon S3 — documents in an S3 bucket"),
+    ("web-crawler", "Web Crawler — crawl and index web pages"),
+    ("confluence", "Confluence — Atlassian Confluence wiki"),
+    ("sharepoint", "SharePoint — Microsoft SharePoint documents"),
+    ("onedrive", "OneDrive — Microsoft OneDrive files"),
+    ("google-drive", "Google Drive — Google Drive files"),
+]
+DATA_SOURCE_TYPE_LABELS = {
+    "s3": "S3",
+    "web-crawler": "Web Crawler",
+    "confluence": "Confluence",
+    "sharepoint": "SharePoint",
+    "onedrive": "OneDrive",
+    "google-drive": "Google Drive",
+}
+
+
+@dataclass
+class CapturedDataSource:
+    data_source_type: str
+    value: str
+
+
+@dataclass
+class DataSourceGroup:
+    data_source_type: str
+    values: list[str]
+
+
+def is_inline_json_value(value: str) -> bool:
+    return value.startswith(INLINE_JSON_PREFIX)
+
+
+def strip_inline_json_prefix(value: str) -> str:
+    return value[len(INLINE_JSON_PREFIX) :] if is_inline_json_value(value) else value
+
+
+def group_data_sources(data_sources: list[CapturedDataSource]) -> list[DataSourceGroup]:
+    """Group by type, preserving first-seen-type order across groups and insertion order within."""
+    groups: list[DataSourceGroup] = []
+    index_by_type: dict[str, int] = {}
+    for ds in data_sources:
+        idx = index_by_type.get(ds.data_source_type)
+        if idx is None:
+            index_by_type[ds.data_source_type] = len(groups)
+            groups.append(DataSourceGroup(ds.data_source_type, [ds.value]))
+        else:
+            groups[idx].values.append(ds.value)
+    return groups
+
+
+def materialize_inline_connector_config(
+    kb_name: str, data_source_type: str, json_contents: str, config_io: ConfigIO | None = None
+) -> str:
+    """Write inline JSON to ``app/<kbName>/<type>-<n>.json`` (first free n); return the absolute path."""
+    parsed = json.loads(json_contents)  # parse first: never touch the filesystem on bad input
+    pretty = json.dumps(parsed, indent=2, ensure_ascii=False) + "\n"
+    project_root = os.path.dirname((config_io or ConfigIO()).get_config_root())
+    dest_dir = os.path.join(project_root, "app", kb_name)
+    os.makedirs(dest_dir, exist_ok=True)
+    n = 1
+    while True:
+        dest = os.path.join(dest_dir, f"{data_source_type}-{n}.json")
+        n += 1
+        if not os.path.exists(dest):
+            break
+    with open(dest, "w", encoding="utf-8") as fh:
+        fh.write(pretty)
+    return dest
+
+
+def validate_connector_config_input(value: str, pending_type: str) -> str | None:
+    """Port of makeConnectorConfigSchema: a file path, or inline JSON whose type matches."""
+    declared = flag_to_wire_type(pending_type)
+    if len(value) < 1:
+        return "Enter a connector config file path or paste the JSON contents"
+    trimmed = value.lstrip()
+    if not trimmed.startswith("{") and not trimmed.startswith("["):
+        return None
+    try:
+        parsed: Any = json.loads(trimmed)
+    except ValueError:
+        return "Looks like JSON but failed to parse. Check brackets and quoting."
+    if not parsed or not isinstance(parsed, dict):
+        return 'Connector config must be a JSON object (e.g. { "type": "WEB", ... }).'
+    if not isinstance(parsed.get("type"), str):
+        return 'Connector config is missing a string "type" field.'
+    if parsed["type"] != declared:
+        return f'Connector config "type" is "{parsed["type"]}" but you picked {pending_type} (expects "{declared}").'
+    return None
+
+
+def _validate_s3_uri(value: str) -> str | None:
+    if len(value) < 1 or first_issue(S3DataSource, {"type": "S3", "uri": value}):
+        return "Must be a valid s3://bucket[/prefix] URI"
+    return None
+
+
+def _display(ds: CapturedDataSource, kb_name: str | None = None) -> str:
+    if is_inline_json_value(ds.value):
+        return f"<inline JSON, will save under app/{kb_name or '<kb>'}/>" if kb_name is not None else "<inline JSON>"
+    return ds.value
+
+
+def run_add_knowledge_base_wizard(primitive: KnowledgeBasePrimitive) -> None:
+    from agentcore.primitives.knowledge_base import AddKnowledgeBaseOptions
+
+    existing = [r.name for r in primitive.get_removable()]
+    name = interactive.text(
+        "Knowledge base name",
+        default=generate_unique_name("MyKnowledgeBase", existing),
+        validate=lambda v: (
+            first_issue(KnowledgeBaseName, v) or ("Knowledge base name already exists" if v in existing else None)
+        ),
+    )
+    description = interactive.text("Description (optional, press Enter to skip)")
+
+    data_sources: list[CapturedDataSource] = []
+    step = "data-source-type"
+    pending_type = "s3"
+    while True:
+        if step == "data-source-type":
+            pending_type = interactive.select(
+                "Data source type"
+                + (
+                    " (pick the type of the first data source; you can mix types in this run)"
+                    if not data_sources
+                    else f" (next data source; {len(data_sources)} already captured)"
+                ),
+                [interactive.Choice(title, value) for value, title in DATA_SOURCE_TYPE_OPTIONS],
+            )
+            step = "sources"
+        elif step == "sources":
+            count = sum(1 for ds in data_sources if ds.data_source_type == pending_type)
+            if pending_type == "s3":
+                prompt = "S3 URI for data source (e.g. s3://my-bucket/docs/)" if count == 0 else f"S3 URI #{count + 1}"
+                value = interactive.text(prompt, validate=_validate_s3_uri)
+                data_sources.append(CapturedDataSource(pending_type, value))
+            else:
+                prompt = (
+                    f"Connector config for {pending_type} — paste JSON or enter a file path"
+                    if count == 0
+                    else f"Connector config #{count + 1}"
+                )
+                value = interactive.text(
+                    prompt, validate=lambda v, t=pending_type: validate_connector_config_input(v, t)
+                )
+                trimmed = value.lstrip()
+                is_inline = trimmed.startswith("{") or trimmed.startswith("[")
+                data_sources.append(
+                    CapturedDataSource(pending_type, f"{INLINE_JSON_PREFIX}{trimmed}" if is_inline else value)
+                )
+            step = "add-another"
+        elif step == "add-another":
+            types = len({ds.data_source_type for ds in data_sources})
+            choices = [interactive.Choice("Add another data source", "add-another")]
+            if len(data_sources) > 1:
+                choices.append(interactive.Choice("Remove a captured data source", "remove-source"))
+            choices.append(interactive.Choice("Done — review and submit", "done"))
+            picked = interactive.select(
+                f"Add another data source? (currently captured: {len(data_sources)} source(s) across {types} type(s))",
+                choices,
+            )
+            step = {"add-another": "data-source-type", "remove-source": "remove-source", "done": "confirm"}[picked]
+        elif step == "remove-source":
+            idx = interactive.select(
+                "Remove a captured data source",
+                [
+                    interactive.Choice(
+                        f"{DATA_SOURCE_TYPE_LABELS.get(ds.data_source_type, ds.data_source_type)}: {_display(ds)}", i
+                    )
+                    for i, ds in enumerate(data_sources)
+                ],
+            )
+            data_sources.pop(idx)
+            step = "add-another" if data_sources else "data-source-type"
+        else:  # confirm
+            typer.echo(f"  Name: {name}")
+            if description:
+                typer.echo(f"  Description: {description}")
+            typer.echo(f"  Data Sources ({len(data_sources)}):")
+            for ds in data_sources:
+                label = DATA_SOURCE_TYPE_LABELS.get(ds.data_source_type, ds.data_source_type)
+                typer.echo(f"    {label}: {_display(ds, name)}")
+            if interactive.confirm("Confirm", default=True):
+                break
+            step = "add-another"
+
+    # Flow: materialize inline JSON, then one primitive.add() per type group (first creates, rest append).
+    try:
+        materialized = [
+            CapturedDataSource(
+                ds.data_source_type,
+                materialize_inline_connector_config(name, ds.data_source_type, strip_inline_json_prefix(ds.value)),
+            )
+            if is_inline_json_value(ds.value)
+            else ds
+            for ds in data_sources
+        ]
+    except Exception as exc:  # noqa: BLE001
+        typer.echo("Failed to add knowledge base", err=True)
+        typer.echo(f"Failed to save inline connector config: {exc}", err=True)
+        raise typer.Exit(1) from None
+
+    groups = group_data_sources(materialized)
+    if not groups:
+        typer.echo("Failed to add knowledge base", err=True)
+        typer.echo("No data sources captured.", err=True)
+        raise typer.Exit(1)
+
+    total: list[str] = []
+    for i, grp in enumerate(groups):
+        is_s3 = grp.data_source_type == "s3"
+        result = primitive.add(
+            AddKnowledgeBaseOptions(
+                name=name,
+                description=description if i == 0 and description else None,
+                data_source_type=grp.data_source_type,
+                source=grp.values if is_s3 else [],
+                connector_config=[] if is_s3 else grp.values,
+            )
+        )
+        if not result.success:
+            typer.echo("Failed to add knowledge base", err=True)
+            typer.echo(f"Failed on {grp.data_source_type} group: {result.error}", err=True)
+            raise typer.Exit(1)
+        total.extend(result.value["newDataSources"])
+
+    typer.echo(f'Knowledge base "{name}" added')
+    typer.echo(f"{len(total)} data source(s). Run 'agentcore deploy' to create the KB and start ingestion.")

agentcore/primitives/_payment_wizard.py

@@ -0,0 +1,331 @@
+"""Interactive payment wizards: prompt-based port of tui/screens/payment (AddPaymentFlow,
+AddPaymentManagerScreen, AddPaymentConnectorScreen).
+
+Manager: auth type -> (CUSTOM_JWT: discovery URL, clients, audiences, scopes) -> name -> advanced
+(auto payment / budget / tool allowlist / network preferences) -> add a connector? -> confirm.
+Connector: manager (when several) -> setup -> credentials -> name -> confirm.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+import typer
+
+from agentcore.cli import interactive
+from agentcore.cli.commands.add._common import first_issue, js_url_ok
+from agentcore.cli.errors import get_error_message
+from agentcore.cli.naming import generate_unique_name
+from agentcore.lib.schemas.io.config_io import to_jsonable
+from agentcore.primitives.payment_validation import (
+    strip_wallet_auth_prefix,
+    validate_api_key_secret,
+    validate_authorization_private_key,
+    validate_wallet_secret,
+)
+
+if TYPE_CHECKING:
+    from agentcore.primitives.payment_connector import PaymentConnectorPrimitive
+    from agentcore.primitives.payment_manager import PaymentManagerPrimitive
+
+C = interactive.Choice
+
+
+def _err(check: Any) -> str | None:
+    return None if check is True else check
+
+
+def _csv(value: str) -> list[str] | None:
+    items = [s.strip() for s in value.split(",") if s.strip()]
+    return items or None
+
+
+def _mask(value: str) -> str:
+    return "****" + value[-4:] if len(value) > 8 else "••••••••"
+
+
+def _connector_names(primitive: Any, manager: str) -> list[str]:
+    try:
+        project = to_jsonable(primitive.read_project_spec())
+        m = next((p for p in project.get("payments") or [] if p["name"] == manager), None)
+        return [c["name"] for c in (m or {}).get("connectors") or []]
+    except Exception:  # noqa: BLE001
+        return []
+
+
+def _prompt_connector(manager: str, existing_connectors: list[str]) -> dict[str, Any]:
+    from agentcore.schema import PaymentConnectorName
+
+    setup = interactive.select(
+        "Choose connector setup (Select how the connector should obtain credentials)",
+        [
+            C("Quick Create with Coinbase", "quick-create", "Recommended - connect Coinbase after deployment"),
+            C("Coinbase CDP credentials", "coinbase-manual", "Use existing Coinbase Developer Platform credentials"),
+            C("Stripe + Privy credentials", "stripe-privy-manual", "Use existing Stripe and Privy credentials"),
+        ],
+    )
+    config: dict[str, Any] = {
+        "managerName": manager,
+        "provisionMode": "QUICK_CREATE" if setup == "quick-create" else "MANUAL",
+        "provider": "StripePrivy" if setup == "stripe-privy-manual" else "CoinbaseCDP",
+    }
+    if setup == "coinbase-manual":
+        config["apiKeyId"] = interactive.text(
+            "CDP API Key ID", secret=True, validate=lambda v: None if v.strip() else "API Key ID is required"
+        ).strip()
+        config["apiKeySecret"] = interactive.text(
+            "CDP API Key Secret", secret=True, validate=lambda v: _err(validate_api_key_secret(v))
+        ).strip()
+        config["walletSecret"] = interactive.text(
+            "CDP Wallet Secret", secret=True, validate=lambda v: _err(validate_wallet_secret(v))
+        ).strip()
+    elif setup == "stripe-privy-manual":
+        config["appId"] = interactive.text(
+            "Privy App ID", secret=True, validate=lambda v: None if v.strip() else "App ID is required"
+        ).strip()
+        config["appSecret"] = interactive.text(
+            "Privy App Secret", secret=True, validate=lambda v: None if v.strip() else "App Secret is required"
+        ).strip()
+        config["authorizationPrivateKey"] = strip_wallet_auth_prefix(
+            interactive.text(
+                "Authorization Private Key (ECDSA P-256)",
+                secret=True,
+                validate=lambda v: _err(validate_authorization_private_key(v)),
+            )
+        )
+        config["authorizationId"] = interactive.text(
+            "Authorization ID", secret=True, validate=lambda v: None if v.strip() else "Authorization ID is required"
+        ).strip()
+    base = "MyStripePrivyConnector" if config["provider"] == "StripePrivy" else "MyCdpConnector"
+    config["connectorName"] = interactive.text(
+        "Connector name",
+        default=generate_unique_name(base, existing_connectors),
+        validate=lambda v: (
+            first_issue(PaymentConnectorName, v)
+            or ("Connector name already exists in this manager" if v in existing_connectors else None)
+        ),
+    )
+    return config
+
+
+def _connector_fields(config: dict[str, Any]) -> list[tuple[str, str]]:
+    fields = [
+        ("Connector Name", config["connectorName"]),
+        ("Provisioning", "Quick Create" if config["provisionMode"] == "QUICK_CREATE" else "Manual"),
+        ("Provider", "Stripe + Privy" if config["provider"] == "StripePrivy" else "Coinbase CDP"),
+    ]
+    if config["provisionMode"] == "QUICK_CREATE":
+        return fields
+    if config["provider"] == "StripePrivy":
+        keys = (
+            ("App ID", "appId"),
+            ("App Secret", "appSecret"),
+            ("Auth Key", "authorizationPrivateKey"),
+            ("Auth ID", "authorizationId"),
+        )
+    else:
+        keys = (("API Key ID", "apiKeyId"), ("API Key Secret", "apiKeySecret"), ("Wallet Secret", "walletSecret"))
+    return fields + [(label, _mask(config[key])) for label, key in keys]
+
+
+def _connector_options(config: dict[str, Any]):  # type: ignore[no-untyped-def]
+    from agentcore.primitives.payment_connector import AddPaymentConnectorOptions
+
+    base = {"manager": config["managerName"], "name": config["connectorName"]}
+    if config["provisionMode"] == "QUICK_CREATE":
+        return AddPaymentConnectorOptions(**base, provider="CoinbaseCDP", provision_mode="QUICK_CREATE")
+    if config["provider"] == "StripePrivy":
+        return AddPaymentConnectorOptions(
+            **base,
+            provider="StripePrivy",
+            app_id=config["appId"],
+            app_secret=config["appSecret"],
+            authorization_private_key=config["authorizationPrivateKey"],
+            authorization_id=config["authorizationId"],
+        )
+    return AddPaymentConnectorOptions(
+        **base,
+        provider="CoinbaseCDP",
+        api_key_id=config["apiKeyId"],
+        api_key_secret=config["apiKeySecret"],
+        wallet_secret=config["walletSecret"],
+    )
+
+
+def run_add_payment_manager_wizard(primitive: PaymentManagerPrimitive) -> None:
+    from agentcore.primitives.payment_manager import AddPaymentManagerOptions
+    from agentcore.schema import DEFAULT_SPEND_LIMIT, PaymentManagerName
+
+    existing = primitive.get_existing_managers()
+    auth = interactive.select(
+        "Select authorization type (How users authenticate to the payment manager)",
+        [
+            C("AWS IAM", "AWS_IAM", "Use AWS IAM for authorization (default)"),
+            C("Custom JWT", "CUSTOM_JWT", "Use a custom JWT authorizer via OIDC discovery"),
+        ],
+    )
+    jwt: dict[str, Any] = {}
+    if auth == "CUSTOM_JWT":
+
+        def validate_url(value: str) -> str | None:
+            if not value.strip():
+                return "Discovery URL is required for Custom JWT"
+            return None if js_url_ok(value.strip()) else "Must be a valid URL"
+
+        jwt["discoveryUrl"] = interactive.text("OIDC Discovery URL", validate=validate_url).strip()
+        jwt["allowedClients"] = interactive.text("Allowed client IDs (comma-separated, leave empty to skip)")
+        jwt["allowedAudience"] = interactive.text("Allowed audiences (comma-separated, leave empty to skip)")
+        jwt["allowedScopes"] = interactive.text("Allowed scopes (comma-separated, leave empty to skip)")
+
+    name = interactive.text(
+        "Payment manager name",
+        default=generate_unique_name("MyPaymentManager", existing),
+        validate=lambda v: (
+            first_issue(PaymentManagerName, v) or ("Payment manager name already exists" if v in existing else None)
+        ),
+    )
+
+    spend_limit = DEFAULT_SPEND_LIMIT
+    advanced = interactive.checkbox(
+        "Advanced Configuration",
+        [
+            C("Auto Payment", "auto-payment"),
+            C(f"Edit Default Budget (Current: ${spend_limit})", "default-budget"),
+            C("Edit Tool Allowlist", "tool-allowlist"),
+            C("Edit Network Preferences", "network-preferences"),
+        ],
+        checked=["auto-payment"],
+    )
+    auto_payment = "auto-payment" in advanced
+    tool_allowlist: str | None = None
+    network_preferences: str | None = None
+    if "default-budget" in advanced:
+        typer.echo(f"Auto Payment: {'✓ Enabled' if auto_payment else '✗ Disabled'}")
+
+        def validate_limit(value: str) -> str | None:
+            if not value.strip():
+                return None
+            try:
+                num = float(value.strip())
+            except ValueError:
+                return "Must be a valid positive number"
+            return "Must be a valid positive number" if num != num or num < 0 else None
+
+        spend_limit = (
+            interactive.text("Default Spend Limit (USD)", default=spend_limit, validate=validate_limit) or "10.00"
+        )
+        typer.echo(
+            "Used only for sessions created by `invoke --auto-session`. It is not a deployed-agent budget — sessions "
+            "your agent creates at runtime set their own limit."
+        )
+    if "tool-allowlist" in advanced:
+        tool_allowlist = interactive.text("Tool Allowlist (comma-separated, leave empty to allow all)").strip() or None
+    if "network-preferences" in advanced:
+        network_preferences = (
+            interactive.text("Network Preferences (comma-separated, e.g. eip155:84532)").strip() or None
+        )
+
+    connector: dict[str, Any] | None = None
+    choice = interactive.select(
+        "Add a payment connector?",
+        [
+            C("Add a payment connector", "add-connector", "Link CoinbaseCDP or StripePrivy credentials"),
+            C("Skip for now", "skip"),
+        ],
+    )
+    if choice == "add-connector":
+        connector = _prompt_connector(name, [])
+
+    rows = [
+        ("Auth Type", auth),
+        ("Manager Name", name),
+        ("Auto Payment", "Enabled" if auto_payment else "Disabled"),
+        ("Default Spend Limit", f"${spend_limit}"),
+    ]
+    if tool_allowlist:
+        rows.append(("Tool Allowlist", tool_allowlist))
+    if network_preferences:
+        rows.append(("Network Preferences", network_preferences))
+    if connector:
+        rows += _connector_fields(connector)
+    if auto_payment:
+        rows.append(
+            (
+                "⚠ Warning",
+                f"Auto-payment ENABLED — agent settles 402s automatically up to ${spend_limit}/session with no "
+                "human approval",
+            )
+        )
+    if not connector:
+        rows.append(("⚠ Warning", "No connector — deploy will fail until you add one"))
+    for label, value in rows:
+        typer.echo(f"  {label}: {value}")
+    if not interactive.confirm("Create payment manager?", default=True):
+        typer.echo("Cancelled.")
+        return
+
+    custom = auth == "CUSTOM_JWT"
+    result = primitive.add(
+        AddPaymentManagerOptions(
+            name=name,
+            authorizer_type=auth,
+            discovery_url=jwt.get("discoveryUrl") if custom else None,
+            allowed_clients=_csv(jwt.get("allowedClients", "")) if custom else None,
+            allowed_audience=_csv(jwt.get("allowedAudience", "")) if custom else None,
+            allowed_scopes=_csv(jwt.get("allowedScopes", "")) if custom else None,
+            auto_payment=auto_payment,
+            default_spend_limit=spend_limit,
+            payment_tool_allowlist=_csv(tool_allowlist) if tool_allowlist else None,
+            network_preferences=_csv(network_preferences) if network_preferences else None,
+        )
+    )
+    if not result.success:
+        typer.echo(f"Error: {get_error_message(result.error)}", err=True)
+        raise typer.Exit(1)
+    if connector:
+        from agentcore.primitives.payment_connector import PRIMITIVE as connector_primitive
+
+        conn = connector_primitive.add(_connector_options(connector))
+        if not conn.success:
+            typer.echo(
+                f'Error: Manager "{name}" was created, but connector failed: {get_error_message(conn.error)}\n\n'
+                'Use "Add a payment connector" to retry adding the connector.',
+                err=True,
+            )
+            raise typer.Exit(1)
+        typer.echo(f'Payment manager "{name}" and connector "{connector["connectorName"]}" created')
+    else:
+        typer.echo(f'Payment manager "{name}" created')
+
+
+def run_add_payment_connector_wizard(primitive: PaymentConnectorPrimitive) -> None:
+    from agentcore.primitives.payment_manager import PRIMITIVE as manager_primitive
+
+    managers = manager_primitive.get_existing_managers()
+    if not managers:
+        typer.echo("Error: No payment managers exist. Create a manager first.", err=True)
+        raise typer.Exit(1)
+    manager = (
+        managers[0]
+        if len(managers) == 1
+        else interactive.select(
+            "Select payment manager (Which manager should this connector be added to?)",
+            [C(m, m) for m in managers],
+        )
+    )
+    config = _prompt_connector(manager, _connector_names(primitive, manager))
+    for label, value in [("Manager", manager), *_connector_fields(config)]:
+        typer.echo(f"  {label}: {value}")
+    if not interactive.confirm("Create payment connector?", default=True):
+        typer.echo("Cancelled.")
+        return
+    result = primitive.add(_connector_options(config))
+    if not result.success:
+        typer.echo(f"Error: {get_error_message(result.error)}", err=True)
+        raise typer.Exit(1)
+    typer.echo(f"Added payment connector: {result.value['connectorName']}")
+    if config["provisionMode"] == "QUICK_CREATE":
+        typer.echo("Run `agentcore deploy` to create the connector and receive its authorization URL.")
+
+
+__all__ = ["run_add_payment_connector_wizard", "run_add_payment_manager_wizard"]