agentcore-cli 0.31.1__py3-none-any.whl

agentcore/operations/deploy/payment_connector_authorization.py

@@ -0,0 +1,106 @@
+"""Quick Create payment connector authorization notes (port of ``payment-connector-authorization.ts``)."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from dataclasses import dataclass
+from typing import Any
+
+from agentcore.aws import agentcore_payments
+from agentcore.cli.errors import get_error_message
+
+
+@dataclass
+class QuickCreateConnectorAuthorization:
+    manager_name: str
+    connector_name: str
+    connector_id: str | None = None
+    status: str | None = None
+    authorization_url: str | None = None
+    error: str | None = None
+
+
+def get_quick_create_connector_authorizations(
+    *, region: str, project_spec: Any, payments: Mapping[str, Any] | None = None
+) -> list[QuickCreateConnectorAuthorization]:
+    """Live status of each deployed Quick Create connector (errors captured per connector)."""
+    results: list[QuickCreateConnectorAuthorization] = []
+    for manager in project_spec.payments or []:
+        manager_state = (payments or {}).get(manager.name)
+        for connector in manager.connectors:
+            if connector.provision_mode != "QUICK_CREATE":
+                continue
+            connector_state = ((manager_state or {}).get("connectors") or {}).get(connector.name)
+            if not manager_state or not connector_state:
+                results.append(
+                    QuickCreateConnectorAuthorization(
+                        manager.name, connector.name, error="deployed connector identifiers were not found"
+                    )
+                )
+                continue
+            connector_id = connector_state["connectorId"]
+            try:
+                detail = agentcore_payments.get_payment_connector(
+                    region=region,
+                    payment_manager_id=manager_state["managerId"],
+                    payment_connector_id=connector_id,
+                )
+                if not detail:
+                    results.append(
+                        QuickCreateConnectorAuthorization(
+                            manager.name,
+                            connector.name,
+                            connector_id,
+                            error="connector was not found by the Payments service",
+                        )
+                    )
+                    continue
+                results.append(
+                    QuickCreateConnectorAuthorization(
+                        manager.name,
+                        connector.name,
+                        connector_id,
+                        status=detail.get("status"),
+                        authorization_url=detail.get("authorizationUrl"),
+                    )
+                )
+            except Exception as exc:  # noqa: BLE001
+                results.append(
+                    QuickCreateConnectorAuthorization(
+                        manager.name, connector.name, connector_id, error=get_error_message(exc)
+                    )
+                )
+    return results
+
+
+def format_quick_create_connector_authorization(result: QuickCreateConnectorAuthorization) -> str:
+    name = f"{result.manager_name}/{result.connector_name}"
+    if result.error:
+        return (
+            f'Payment connector "{name}" deployed, but its live status could not be retrieved: {result.error}. '
+            "Run `agentcore status` to retry."
+        )
+    if result.status == "PENDING_AUTHENTICATION" and result.authorization_url:
+        return f'Authorize payment connector "{name}": {result.authorization_url}'
+    if result.status == "PENDING_AUTHENTICATION":
+        return (
+            f'Payment connector "{name}" is pending authorization, but no authorization URL was returned. '
+            "Run `agentcore status` to retry."
+        )
+    if result.status == "READY":
+        return f'Payment connector "{name}" is ready.'
+    if result.status in ("AUTHENTICATION_EXPIRED", "AUTHENTICATION_FAILED"):
+        return (
+            f'Payment connector "{name}" is {result.status}. Remove and deploy it, then add and deploy it again '
+            "to generate a new authorization URL."
+        )
+    return (
+        f'Payment connector "{name}" status: {result.status or "unknown"}. Run `agentcore status` for the latest state.'
+    )
+
+
+__all__ = [
+    "QuickCreateConnectorAuthorization",
+    "format_quick_create_connector_authorization",
+    "get_quick_create_connector_authorizations",
+]

agentcore/operations/deploy/post_deploy_datasets.py

@@ -0,0 +1,96 @@
+"""Sync local dataset JSONL files to the service DRAFT (port of ``post-deploy-datasets.ts``).
+
+The push itself lives in ``operations/dataset`` (another area). It is resolved lazily so deploy
+works before that module lands; until then changed datasets report an error entry.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import os
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass, field
+from typing import Any, Literal
+
+
+@dataclass
+class DatasetSyncResultEntry:
+    dataset_name: str
+    status: Literal["synced", "skipped", "error"]
+    added: int | None = None
+    updated: int | None = None
+    deleted: int | None = None
+    error: str | None = None
+
+
+@dataclass
+class SyncDatasetsResult:
+    results: list[DatasetSyncResultEntry] = field(default_factory=list)
+    updated_datasets: dict[str, dict[str, Any]] = field(default_factory=dict)
+
+    @property
+    def has_errors(self) -> bool:
+        return any(r.status == "error" for r in self.results)
+
+
+def _file_hash(content: str) -> str:
+    return hashlib.sha256(content.encode("utf-8")).hexdigest()
+
+
+def _push_dataset(**kwargs: Any) -> Any:
+    try:
+        from agentcore.operations.dataset import push_dataset  # type: ignore[import-not-found]
+    except ImportError as exc:
+        raise RuntimeError("dataset push is not available (agentcore.operations.dataset is not ported yet)") from exc
+    return push_dataset(**kwargs)
+
+
+def _count(result: Any, name: str) -> int | None:
+    return result.get(name) if isinstance(result, Mapping) else getattr(result, name, None)
+
+
+def sync_datasets(
+    *,
+    region: str,
+    datasets: Sequence[Any],
+    deployed_datasets: Mapping[str, Mapping[str, Any]],
+    config_base_dir: str,
+) -> SyncDatasetsResult:
+    out = SyncDatasetsResult(updated_datasets={k: dict(v) for k, v in deployed_datasets.items()})
+    for dataset in datasets:
+        state = deployed_datasets.get(dataset.name)
+        if not state:
+            continue
+        try:
+            local_path = dataset.config.managed.location
+            absolute = os.path.abspath(os.path.join(config_base_dir, local_path))
+            with open(absolute, encoding="utf-8") as fh:
+                current_hash = _file_hash(fh.read())
+            if state.get("contentHash") == current_hash:
+                out.results.append(DatasetSyncResultEntry(dataset.name, "skipped"))
+                continue
+            push = _push_dataset(
+                region=region,
+                dataset_id=state["datasetId"],
+                local_file_path=local_path,
+                config_base_dir=config_base_dir,
+            )
+            # pushDataset rewrites the file with exampleIds; hash what is on disk now.
+            with open(absolute, encoding="utf-8") as fh:
+                post_hash = _file_hash(fh.read())
+            out.updated_datasets[dataset.name] = {**state, "contentHash": post_hash}
+            out.results.append(
+                DatasetSyncResultEntry(
+                    dataset.name,
+                    "synced",
+                    added=_count(push, "added"),
+                    updated=_count(push, "updated"),
+                    deleted=_count(push, "deleted"),
+                )
+            )
+        except Exception as exc:  # noqa: BLE001
+            out.results.append(DatasetSyncResultEntry(dataset.name, "error", error=str(exc)))
+    return out
+
+
+__all__ = ["DatasetSyncResultEntry", "SyncDatasetsResult", "sync_datasets"]

agentcore/operations/deploy/post_deploy_knowledge_bases.py

@@ -0,0 +1,104 @@
+"""Auto-ingest knowledge bases whose data sources changed (port of ``post-deploy-knowledge-bases.ts``)."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import threading
+from collections.abc import Callable, Mapping, Sequence
+from dataclasses import dataclass, field
+from typing import Any, Literal
+
+from agentcore.operations import ingest
+
+
+@dataclass
+class AutoIngestEntry:
+    knowledge_base_name: str
+    status: Literal["started", "skipped", "error"]
+    started_job_count: int | None = None
+    reason: str | None = None
+    error: str | None = None
+    new_sources_hash: str | None = None
+
+
+@dataclass
+class AutoIngestKnowledgeBasesResult:
+    results: list[AutoIngestEntry] = field(default_factory=list)
+
+    @property
+    def has_errors(self) -> bool:
+        return any(r.status == "error" for r in self.results)
+
+
+def compute_sources_hash(kb: Any, project_root: str | None = None) -> str:
+    """SHA-256 over each data source's identity + config (S3: URI; connectors: normalized file JSON)."""
+    parts = []
+    for ds in kb.data_sources:
+        if ds.type == "S3":
+            parts.append(ds.uri)
+            continue
+        path = ds.connector_config_file
+        if project_root:
+            try:
+                with open(os.path.join(project_root, path), encoding="utf-8") as fh:
+                    normalized = json.dumps(json.load(fh), separators=(",", ":"), ensure_ascii=False)
+                parts.append(f"{path}:{normalized}")
+                continue
+            except (OSError, ValueError):
+                pass
+        parts.append(path)
+    return hashlib.sha256("\n".join(parts).encode("utf-8")).hexdigest()
+
+
+def auto_ingest_knowledge_bases(
+    *,
+    region: str,
+    knowledge_bases: Sequence[Any],
+    deployed_knowledge_bases: Mapping[str, Mapping[str, Any]],
+    target_name: str,
+    deployed_state: Any,
+    previous_knowledge_bases: Mapping[str, Mapping[str, Any]] | None = None,
+    project_root: str | None = None,
+    on_progress: Callable[[str], None] | None = None,
+    signal: threading.Event | None = None,
+) -> AutoIngestKnowledgeBasesResult:
+    out = AutoIngestKnowledgeBasesResult()
+    for kb in knowledge_bases:
+        deployed = deployed_knowledge_bases.get(kb.name)
+        if not deployed:
+            out.results.append(
+                AutoIngestEntry(kb.name, "skipped", reason="KB not present in deployed state (CFN outputs missing)")
+            )
+            continue
+        if not deployed.get("dataSources"):
+            out.results.append(AutoIngestEntry(kb.name, "skipped", reason="no data sources recorded"))
+            continue
+        new_hash = compute_sources_hash(kb, project_root)
+        previous_hash = ((previous_knowledge_bases or {}).get(kb.name) or {}).get("sourcesHash")
+        if previous_hash and previous_hash == new_hash:
+            out.results.append(AutoIngestEntry(kb.name, "skipped", reason="no changes to data sources"))
+            continue
+        result = ingest.run_kb_ingestion_by_name(
+            ingest.RunKbIngestionInput(
+                knowledge_base_name=kb.name,
+                deployed_state=deployed_state,
+                target_name=target_name,
+                region=region,
+                on_progress=on_progress,
+                signal=signal,
+            )
+        )
+        if not result.success:
+            out.results.append(AutoIngestEntry(kb.name, "error", error=str(result.error)))
+            continue
+        out.results.append(
+            AutoIngestEntry(
+                kb.name, "started", started_job_count=len(result.value.started_jobs), new_sources_hash=new_hash
+            )
+        )
+    return out
+
+
+__all__ = ["AutoIngestEntry", "AutoIngestKnowledgeBasesResult", "auto_ingest_knowledge_bases", "compute_sources_hash"]

agentcore/operations/deploy/post_deploy_observability.py

@@ -0,0 +1,28 @@
+"""Post-deploy CloudWatch Transaction Search setup (port of ``post-deploy-observability.ts``)."""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+
+from agentcore.aws import transaction_search
+from agentcore.lib.result import Err, Ok, ok
+from agentcore.lib.schemas.io.global_config import read_global_config_sync
+
+
+def setup_transaction_search(
+    *, region: str, account_id: str, agent_names: Sequence[str], has_gateways: bool = False
+) -> Ok[None] | Err[Exception]:
+    """Enable Transaction Search (idempotent). Disabled via ``disableTransactionSearch`` in global config."""
+    if not agent_names and not has_gateways:
+        return ok()
+    config = read_global_config_sync()
+    if config.get("disableTransactionSearch"):
+        return ok()
+    index_percentage = config.get("transactionSearchIndexPercentage", 100)
+    result = transaction_search.enable_transaction_search(region, account_id, index_percentage)
+    if not result.success:
+        return Err(result.error)
+    return ok()
+
+
+__all__ = ["setup_transaction_search"]

agentcore/operations/deploy/post_deploy_online_evals.py

@@ -0,0 +1,60 @@
+"""Enable newly deployed online eval configs (port of ``post-deploy-online-evals.ts``).
+
+CFN can't set EnableOnCreate on ``AWS::BedrockAgentCore::OnlineEvaluationConfig``, so configs
+deploy DISABLED and are enabled here. Callers pass only newly deployed configs.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass, field
+from typing import Any, Literal
+
+from agentcore.aws import agentcore_control
+
+
+@dataclass
+class OnlineEvalEnableResult:
+    config_name: str
+    status: Literal["enabled", "skipped", "error"]
+    error: str | None = None
+
+
+@dataclass
+class EnableOnlineEvalsResult:
+    results: list[OnlineEvalEnableResult] = field(default_factory=list)
+
+    @property
+    def has_errors(self) -> bool:
+        return any(r.status == "error" for r in self.results)
+
+
+def enable_online_eval_configs(
+    *, region: str, online_eval_configs: Sequence[Any], deployed_online_eval_configs: Mapping[str, Mapping[str, Any]]
+) -> EnableOnlineEvalsResult:
+    out = EnableOnlineEvalsResult()
+    for config in online_eval_configs:
+        if config.enable_on_create is False:
+            out.results.append(OnlineEvalEnableResult(config.name, "skipped"))
+            continue
+        deployed = deployed_online_eval_configs.get(config.name)
+        if not deployed:
+            out.results.append(
+                OnlineEvalEnableResult(
+                    config.name, "error", f'Online eval config "{config.name}" not found in deployed state'
+                )
+            )
+            continue
+        try:
+            agentcore_control.update_online_eval_execution_status(
+                region=region,
+                online_evaluation_config_id=deployed["onlineEvaluationConfigId"],
+                execution_status="ENABLED",
+            )
+            out.results.append(OnlineEvalEnableResult(config.name, "enabled"))
+        except Exception as exc:  # noqa: BLE001
+            out.results.append(OnlineEvalEnableResult(config.name, "error", str(exc)))
+    return out
+
+
+__all__ = ["EnableOnlineEvalsResult", "OnlineEvalEnableResult", "enable_online_eval_configs"]