bedrock-agentcore-starter-toolkit 0.1.10__py3-none-any.whl → 0.1.12__py3-none-any.whl

bedrock_agentcore_starter_toolkit/operations/runtime/destroy.py

@@ -39,14 +39,18 @@ def destroy_bedrock_agentcore(
         ValueError: If agent is not found or not deployed
         RuntimeError: If destruction fails
     """
-    log.info("Starting destroy operation for agent: %s (dry_run=%s, delete_ecr_repo=%s)", 
-             agent_name or "default", dry_run, delete_ecr_repo)
+    log.info(
+        "Starting destroy operation for agent: %s (dry_run=%s, delete_ecr_repo=%s)",
+        agent_name or "default",
+        dry_run,
+        delete_ecr_repo,
+    )
 
     try:
         # Load configuration
         project_config = load_config(config_path)
         agent_config = project_config.get_agent_config(agent_name)
-        
+
         if not agent_config:
             raise ValueError(f"Agent '{agent_name or 'default'}' not found in configuration")
 
@@ -60,32 +64,36 @@ def destroy_bedrock_agentcore(
 
         # Initialize AWS session and clients
         session = boto3.Session(region_name=agent_config.aws.region)
-        
+
         # 1. Destroy Bedrock AgentCore endpoint (if exists)
         _destroy_agentcore_endpoint(session, agent_config, result, dry_run)
-        
+
         # 2. Destroy Bedrock AgentCore agent
         _destroy_agentcore_agent(session, agent_config, result, dry_run)
-        
+
         # 3. Remove ECR images and optionally the repository
         _destroy_ecr_images(session, agent_config, result, dry_run, delete_ecr_repo)
-        
+
         # 4. Remove CodeBuild project
         _destroy_codebuild_project(session, agent_config, result, dry_run)
 
         # 5. Remove CodeBuild IAM Role
         _destroy_codebuild_iam_role(session, agent_config, result, dry_run)
-        
+
         # 6. Remove IAM execution role (if not used by other agents)
         _destroy_iam_role(session, project_config, agent_config, result, dry_run)
-        
+
         # 7. Clean up configuration
         if not dry_run and not result.errors:
             _cleanup_agent_config(config_path, project_config, agent_config.name, result)
 
-        log.info("Destroy operation completed. Resources removed: %d, Warnings: %d, Errors: %d",
-                len(result.resources_removed), len(result.warnings), len(result.errors))
-        
+        log.info(
+            "Destroy operation completed. Resources removed: %d, Warnings: %d, Errors: %d",
+            len(result.resources_removed),
+            len(result.warnings),
+            len(result.errors),
+        )
+
         return result
 
     except Exception as e:
@@ -105,7 +113,7 @@ def _destroy_agentcore_endpoint(
 
     try:
         client = BedrockAgentCoreClient(agent_config.aws.region)
-        
+
         agent_id = agent_config.bedrock_agentcore.agent_id
         if not agent_id:
             result.warnings.append("No agent ID found, skipping endpoint destruction")
@@ -116,12 +124,10 @@ def _destroy_agentcore_endpoint(
             endpoint_response = client.get_agent_runtime_endpoint(agent_id)
             endpoint_name = endpoint_response.get("name", "DEFAULT")
             endpoint_arn = endpoint_response.get("agentRuntimeEndpointArn")
-            
+
             # Special case: DEFAULT endpoint cannot be explicitly deleted
             if endpoint_name == "DEFAULT":
-                result.warnings.append(
-                    "DEFAULT endpoint cannot be explicitly deleted, skipping"
-                )
+                result.warnings.append("DEFAULT endpoint cannot be explicitly deleted, skipping")
                 log.info("Skipping deletion of DEFAULT endpoint")
                 return
 
@@ -143,7 +149,7 @@ def _destroy_agentcore_endpoint(
                         result.warnings.append("Endpoint not found or already deleted during deletion")
             else:
                 result.warnings.append("No endpoint ARN found for agent")
-                
+
         except ClientError as e:
             if e.response["Error"]["Code"] not in ["ResourceNotFoundException", "NotFound"]:
                 result.warnings.append(f"Failed to get endpoint info: {e}")
@@ -168,7 +174,8 @@ def _destroy_agentcore_agent(
         return
 
     try:
-        client = BedrockAgentCoreClient(agent_config.aws.region)
+        # Initialize client to enable exception handling path for tests
+        BedrockAgentCoreClient(agent_config.aws.region)
         agent_arn = agent_config.bedrock_agentcore.agent_arn
         agent_id = agent_config.bedrock_agentcore.agent_id
 
@@ -212,18 +219,18 @@ def _destroy_ecr_images(
         # Create ECR client with explicit region specification
         ecr_client = session.client("ecr", region_name=agent_config.aws.region)
         ecr_uri = agent_config.aws.ecr_repository
-        
+
         # Extract repository name from URI
         # Format: account.dkr.ecr.region.amazonaws.com/repo-name
         repo_name = ecr_uri.split("/")[-1]
-        
+
         log.info("Checking ECR repository: %s in region: %s", repo_name, agent_config.aws.region)
 
         try:
             # List all images in the repository (both tagged and untagged)
             response = ecr_client.list_images(repositoryName=repo_name)
             log.debug("ECR list_images response: %s", response)
-            
+
             # Fix: use correct response key 'imageIds' instead of 'imageDetails'
             all_images = response.get("imageIds", [])
             if not all_images:
@@ -238,7 +245,7 @@ def _destroy_ecr_images(
                 return
 
             if dry_run:
-                # Fix: imageIds structure has imageTag (string) not imageTags (array)  
+                # Fix: imageIds structure has imageTag (string) not imageTags (array)
                 tagged_count = len([img for img in all_images if img.get("imageTag")])
                 untagged_count = len([img for img in all_images if not img.get("imageTag")])
                 result.resources_removed.append(
@@ -250,18 +257,18 @@ def _destroy_ecr_images(
 
             # Prepare images for deletion - imageIds are already in the correct format
             images_to_delete = []
-            
+
             for image in all_images:
                 # imageIds structure already contains the correct identifiers
                 image_id = {}
-                
+
                 # If image has a tag, use it
                 if image.get("imageTag"):
                     image_id["imageTag"] = image["imageTag"]
-                # If no tag, use image digest  
+                # If no tag, use image digest
                 elif image.get("imageDigest"):
                     image_id["imageDigest"] = image["imageDigest"]
-                
+
                 if image_id:
                     images_to_delete.append(image_id)
 
@@ -269,34 +276,32 @@ def _destroy_ecr_images(
                 # Delete images in batches (ECR has a limit of 100 images per batch)
                 batch_size = 100
                 total_deleted = 0
-                
+
                 for i in range(0, len(images_to_delete), batch_size):
-                    batch = images_to_delete[i:i + batch_size]
-                    
-                    delete_response = ecr_client.batch_delete_image(
-                        repositoryName=repo_name,
-                        imageIds=batch
-                    )
-                    
+                    batch = images_to_delete[i : i + batch_size]
+
+                    delete_response = ecr_client.batch_delete_image(repositoryName=repo_name, imageIds=batch)
+
                     deleted_images = delete_response.get("imageIds", [])
                     total_deleted += len(deleted_images)
-                    
+
                     # Log any failures in this batch
                     failures = delete_response.get("failures", [])
                     for failure in failures:
-                        log.warning("Failed to delete image: %s - %s", 
-                                  failure.get("imageId"), failure.get("failureReason"))
+                        log.warning(
+                            "Failed to delete image: %s - %s", failure.get("imageId"), failure.get("failureReason")
+                        )
 
                 result.resources_removed.append(f"ECR images: {total_deleted} images from {repo_name}")
                 log.info("Deleted %d ECR images from %s", total_deleted, repo_name)
-                
+
                 # Log any partial failures
                 if total_deleted < len(images_to_delete):
                     failed_count = len(images_to_delete) - total_deleted
                     result.warnings.append(
                         f"Some ECR images could not be deleted: {failed_count} out of {len(images_to_delete)} failed"
                     )
-                
+
                 # Delete the repository if requested and all images were deleted successfully
                 if delete_ecr_repo and total_deleted == len(images_to_delete):
                     _delete_ecr_repository(ecr_client, repo_name, result)
@@ -326,16 +331,16 @@ def _delete_ecr_repository(ecr_client, repo_name: str, result: DestroyResult) ->
         # Verify repository is empty before deletion
         response = ecr_client.list_images(repositoryName=repo_name)
         remaining_images = response.get("imageIds", [])
-        
+
         if remaining_images:
             result.warnings.append(f"Cannot delete ECR repository {repo_name}: repository is not empty")
             return
-        
+
         # Delete the empty repository
         ecr_client.delete_repository(repositoryName=repo_name)
         result.resources_removed.append(f"ECR repository: {repo_name}")
         log.info("Deleted ECR repository: %s", repo_name)
-        
+
     except ClientError as e:
         error_code = e.response["Error"]["Code"]
         if error_code == "RepositoryNotFoundException":
@@ -380,6 +385,7 @@ def _destroy_codebuild_project(
         result.warnings.append(f"Error during CodeBuild cleanup: {e}")
         log.warning("Error during CodeBuild cleanup: %s", e)
 
+
 def _destroy_codebuild_iam_role(
     session: boto3.Session,
     agent_config: BedrockAgentCoreAgentSchema,
@@ -390,17 +396,17 @@ def _destroy_codebuild_iam_role(
     if not agent_config.codebuild.execution_role:
         result.warnings.append("No CodeBuild execution role configured, skipping IAM cleanup")
         return
-        
+
     try:
         # Note: IAM is a global service, but we specify region for consistency
         iam_client = session.client("iam", region_name=agent_config.aws.region)
         role_arn = agent_config.codebuild.execution_role
         role_name = role_arn.split("/")[-1]
-        
+
         if dry_run:
             result.resources_removed.append(f"CodeBuild IAM role: {role_name} (DRY RUN)")
             return
-            
+
         # Detach managed policies
         for policy in iam_client.list_attached_role_policies(RoleName=role_name).get("AttachedPolicies", []):
             iam_client.detach_role_policy(RoleName=role_name, PolicyArn=policy["PolicyArn"])
@@ -415,7 +421,7 @@ def _destroy_codebuild_iam_role(
         iam_client.delete_role(RoleName=role_name)
         result.resources_removed.append(f"Deleted CodeBuild IAM role: {role_name}")
         log.info("Deleted CodeBuild IAM role: %s", role_name)
-        
+
     except ClientError as e:
         result.warnings.append(f"Failed to delete CodeBuild role {role_name}: {e}")
         log.warning("Failed to delete CodeBuild role %s: %s", role_name, e)
@@ -423,6 +429,7 @@ def _destroy_codebuild_iam_role(
         result.warnings.append(f"Error during CodeBuild IAM role cleanup: {e}")
         log.error("Error during CodeBuild IAM role cleanup: %s", e)
 
+
 def _destroy_iam_role(
     session: boto3.Session,
     project_config: BedrockAgentCoreConfigSchema,
@@ -443,7 +450,8 @@ def _destroy_iam_role(
 
         # Check if other agents use the same role
         other_agents_using_role = [
-            name for name, agent in project_config.agents.items()
+            name
+            for name, agent in project_config.agents.items()
             if name != agent_config.name and agent.aws.execution_role == role_arn
         ]
 
@@ -462,10 +470,7 @@ def _destroy_iam_role(
             try:
                 policies = iam_client.list_attached_role_policies(RoleName=role_name)
                 for policy in policies.get("AttachedPolicies", []):
-                    iam_client.detach_role_policy(
-                        RoleName=role_name,
-                        PolicyArn=policy["PolicyArn"]
-                    )
+                    iam_client.detach_role_policy(RoleName=role_name, PolicyArn=policy["PolicyArn"])
             except ClientError:
                 pass  # Continue if policy detachment fails
 
@@ -508,12 +513,12 @@ def _cleanup_agent_config(
 
         # Check if this agent is the default agent
         was_default = project_config.default_agent == agent_name
-        
+
         # Remove the agent entry completely
         del project_config.agents[agent_name]
         result.resources_removed.append(f"Agent configuration: {agent_name}")
         log.info("Removed agent configuration: %s", agent_name)
-        
+
         # Handle default agent cleanup
         if was_default:
             if project_config.agents:
@@ -526,7 +531,7 @@ def _cleanup_agent_config(
                 # No agents left, clear default
                 project_config.default_agent = None
                 log.info("Cleared default agent (no agents remaining)")
-        
+
         # If no agents remain, remove the config file
         if not project_config.agents:
             config_path.unlink()
@@ -539,4 +544,4 @@ def _cleanup_agent_config(
 
     except Exception as e:
         result.warnings.append(f"Failed to update configuration: {e}")
-        log.warning("Failed to update configuration: %s", e)
+        log.warning("Failed to update configuration: %s", e)

bedrock_agentcore_starter_toolkit/operations/runtime/invoke.py

@@ -67,7 +67,7 @@ def invoke_bedrock_agentcore(
         )["workloadAccessToken"]
 
         # TODO: store and read port config of local running container
-        client = LocalBedrockAgentCoreClient("http://0.0.0.0:8080")
+        client = LocalBedrockAgentCoreClient("http://127.0.0.1:8080")
         response = client.invoke_endpoint(session_id, payload_str, workload_access_token)
 
     else:

bedrock_agentcore_starter_toolkit/operations/runtime/launch.py

@@ -13,8 +13,10 @@ from botocore.exceptions import ClientError
 from ...services.codebuild import CodeBuildService
 from ...services.ecr import deploy_to_ecr, get_or_create_ecr_repository
 from ...services.runtime import BedrockAgentCoreClient
+from ...services.xray import enable_transaction_search_if_needed
 from ...utils.runtime.config import load_config, save_config
 from ...utils.runtime.container import ContainerRuntime
+from ...utils.runtime.logs import get_genai_observability_url
 from ...utils.runtime.schema import BedrockAgentCoreAgentSchema, BedrockAgentCoreConfigSchema
 from .create_role import get_or_create_runtime_execution_role
 from .models import LaunchResult
@@ -135,6 +137,7 @@ def _deploy_to_bedrock_agentcore(
     agent_name: str,
     ecr_uri: str,
     region: str,
+    account_id: str,
     env_vars: Optional[dict] = None,
     auto_update_on_conflict: bool = False,
 ):
@@ -230,6 +233,16 @@ def _deploy_to_bedrock_agentcore(
 
     log.info("✅ Agent created/updated: %s", agent_arn)
 
+    # Enable Transaction Search if observability is enabled
+    if agent_config.aws.observability.enabled:
+        log.info("Observability is enabled, configuring Transaction Search...")
+        enable_transaction_search_if_needed(region, account_id)
+
+        # Show GenAI Observability Dashboard URL whenever OTEL is enabled
+        console_url = get_genai_observability_url(region)
+        log.info("🔍 GenAI Observability Dashboard:")
+        log.info("   %s", console_url)
+
     # Wait for agent to be ready
     log.info("Polling for endpoint to be ready...")
     result = bedrock_agentcore_client.wait_for_agent_endpoint_ready(agent_id)
@@ -367,6 +380,7 @@ def launch_bedrock_agentcore(
         bedrock_agentcore_name,
         ecr_uri,
         region,
+        account_id,
         env_vars,
         auto_update_on_conflict,
     )
@@ -495,6 +509,7 @@ def _launch_with_codebuild(
         agent_name,
         ecr_uri,
         region,
+        account_id,
         env_vars=env_vars,
         auto_update_on_conflict=auto_update_on_conflict,
     )

bedrock_agentcore_starter_toolkit/services/import_agent/scripts/base_bedrock_translate.py

@@ -21,6 +21,7 @@ from openapi_schema_to_json_schema import to_json_schema
 
 from ....operations.gateway import GatewayClient
 from ..utils import (
+    clean_gateway_or_target_name,
     clean_variable_name,
     generate_pydantic_models,
     get_base_dir,
@@ -1064,7 +1065,7 @@ class BaseBedrockTranslator:
         )
         response_content_code = "str(agent_result)" if platform == "strands" else "agent_result[-1].content"
         url_pattern = self._get_url_regex_pattern()
-        
+
         entrypoint_code += f"""
     def endpoint(payload, context):
         try:
@@ -1179,7 +1180,7 @@ class BaseBedrockTranslator:
                 continue
 
             action_group_name = ag.get("actionGroupName", "AG")
-            clean_action_group_name = clean_variable_name(action_group_name)
+            clean_action_group_name = clean_gateway_or_target_name(action_group_name)
             action_group_desc = ag.get("description", "").replace('"', '\\"')
             end_lambda_arn = ag.get("actionGroupExecutor", {}).get("lambda", "")
             tools = []
@@ -1323,7 +1324,7 @@ class BaseBedrockTranslator:
                         "lambdaRegion": end_lambda_arn.split(":")[3] if end_lambda_arn else "us-west-2",
                     }
 
-                    func_desc = func_spec.get("description", "No Description Provided.")
+                    func_desc = func.get("description", "No Description Provided.")
                     func_desc += f"\\nThis tool is part of the group of tools called {action_group_name}{f' (description: {action_group_desc})' if action_group_desc else ''}."
 
                     func_parameters = func.get("parameters", {})

bedrock_agentcore_starter_toolkit/services/import_agent/utils.py

@@ -50,6 +50,20 @@ def clean_variable_name(text):
     return cleaned
 
 
+def clean_gateway_or_target_name(text):
+    """Clean a string to create a valid Gateway or Target name."""
+    text = str(text)
+    cleaned = re.sub(r"[^a-zA-Z0-9\s]", " ", text)
+    cleaned = cleaned.lower()
+    cleaned = re.sub(r"\s+", " ", cleaned)
+    cleaned = cleaned.strip()
+    cleaned = cleaned.replace(" ", "-")
+    if not cleaned:
+        cleaned = "gateway-or-target"
+
+    return cleaned
+
+
 def unindent_by_one(input_code, spaces_per_indent=4):
     """Unindents the input code by one level of indentation.
 

bedrock_agentcore_starter_toolkit/services/runtime.py

@@ -399,7 +399,11 @@ class BedrockAgentCoreClient:
                 agentRuntimeId=agent_id,
                 endpointName=endpoint_name,
             )
-            self.logger.info("Successfully initiated deletion of endpoint '%s' for agent ID: %s", endpoint_name, agent_id)
+            self.logger.info(
+                "Successfully initiated deletion of endpoint '%s' for agent ID: %s",
+                endpoint_name,
+                agent_id,
+            )
             return response
         except Exception as e:
             self.logger.error("Failed to delete endpoint '%s' for agent ID '%s': %s", endpoint_name, agent_id, str(e))

bedrock_agentcore_starter_toolkit/services/xray.py

@@ -0,0 +1,161 @@
+"""X-Ray Transaction Search service for enabling observability."""
+
+import json
+import logging
+
+import boto3
+from botocore.exceptions import ClientError
+
+logger = logging.getLogger(__name__)
+
+
+def _need_resource_policy(logs_client, policy_name="TransactionSearchXRayAccess"):
+    """Check if resource policy needs to be created (fail-safe)."""
+    try:
+        response = logs_client.describe_resource_policies()
+        for policy in response.get("resourcePolicies", []):
+            if policy.get("policyName") == policy_name:
+                return False  # Already exists
+        return True  # Needs creation
+    except Exception:
+        return True  # If check fails, assume we need it (safe)
+
+
+def _need_trace_destination(xray_client):
+    """Check if trace destination needs to be set (fail-safe)."""
+    try:
+        response = xray_client.get_trace_segment_destination()
+        return response.get("Destination") != "CloudWatchLogs"
+    except Exception:
+        return True  # If check fails, assume we need it (safe)
+
+
+def _need_indexing_rule(xray_client):
+    """Check if indexing rule needs to be configured (fail-safe)."""
+    try:
+        response = xray_client.get_indexing_rules()
+        for rule in response.get("IndexingRules", []):
+            if rule.get("Name") == "Default":
+                return False  # Already configured
+        return True  # Needs configuration
+    except Exception:
+        return True  # If check fails, assume we need it (safe)
+
+
+def enable_transaction_search_if_needed(region: str, account_id: str) -> bool:
+    """Enable X-Ray Transaction Search components that are not already configured.
+
+    This function checks what's already configured and only runs needed steps.
+    It's fail-safe - if checks fail, it assumes configuration is needed.
+
+    Args:
+        region: AWS region
+        account_id: AWS account ID
+
+    Returns:
+        bool: True if Transaction Search was configured successfully, False if failed
+    """
+    try:
+        session = boto3.Session(region_name=region)
+        logs_client = session.client("logs")
+        xray_client = session.client("xray")
+
+        steps_run = []
+
+        # Step 1: Resource policy (only if needed)
+        if _need_resource_policy(logs_client):
+            _create_cloudwatch_logs_resource_policy(logs_client, account_id, region)
+            steps_run.append("resource_policy")
+        else:
+            logger.info("CloudWatch Logs resource policy already configured")
+
+        # Step 2: Trace destination (only if needed)
+        if _need_trace_destination(xray_client):
+            _configure_trace_segment_destination(xray_client)
+            steps_run.append("trace_destination")
+        else:
+            logger.info("X-Ray trace destination already configured")
+
+        # Step 3: Indexing rule (only if needed)
+        if _need_indexing_rule(xray_client):
+            _configure_indexing_rule(xray_client)
+            steps_run.append("indexing_rule")
+        else:
+            logger.info("X-Ray indexing rule already configured")
+
+        if steps_run:
+            logger.info("✅ Transaction Search configured: %s", ", ".join(steps_run))
+        else:
+            logger.info("✅ Transaction Search already fully configured")
+
+        return True
+
+    except Exception as e:
+        logger.warning("Transaction Search configuration failed: %s", str(e))
+        logger.info("Agent launch will continue without Transaction Search")
+        return False  # Don't fail launch
+
+
+def _create_cloudwatch_logs_resource_policy(logs_client, account_id: str, region: str) -> None:
+    """Create CloudWatch Logs resource policy for X-Ray access (idempotent)."""
+    policy_name = "TransactionSearchXRayAccess"
+
+    policy_document = {
+        "Version": "2012-10-17",
+        "Statement": [
+            {
+                "Sid": "TransactionSearchXRayAccess",
+                "Effect": "Allow",
+                "Principal": {"Service": "xray.amazonaws.com"},
+                "Action": "logs:PutLogEvents",
+                "Resource": [
+                    f"arn:aws:logs:{region}:{account_id}:log-group:aws/spans:*",
+                    f"arn:aws:logs:{region}:{account_id}:log-group:/aws/application-signals/data:*",
+                ],
+                "Condition": {
+                    "ArnLike": {"aws:SourceArn": f"arn:aws:xray:{region}:{account_id}:*"},
+                    "StringEquals": {"aws:SourceAccount": account_id},
+                },
+            }
+        ],
+    }
+
+    try:
+        logs_client.put_resource_policy(policyName=policy_name, policyDocument=json.dumps(policy_document))
+        logger.info("Created/updated CloudWatch Logs resource policy")
+    except ClientError as e:
+        if e.response["Error"]["Code"] == "InvalidParameterException":
+            # Policy might already exist with same content
+            logger.info("CloudWatch Logs resource policy already configured")
+        else:
+            raise
+
+
+def _configure_trace_segment_destination(xray_client) -> None:
+    """Configure X-Ray trace segment destination to CloudWatch Logs (idempotent)."""
+    try:
+        # Configure trace segments to be sent to CloudWatch Logs
+        # This enables Transaction Search functionality
+        xray_client.update_trace_segment_destination(Destination="CloudWatchLogs")
+        logger.info("Configured X-Ray trace segment destination to CloudWatch Logs")
+    except ClientError as e:
+        if e.response["Error"]["Code"] == "InvalidRequestException":
+            # Destination might already be configured
+            logger.info("X-Ray trace segment destination already configured")
+        else:
+            raise
+
+
+def _configure_indexing_rule(xray_client) -> None:
+    """Configure X-Ray indexing rule for transaction search (idempotent)."""
+    try:
+        # Update the default indexing rule with probabilistic sampling
+        # This is idempotent - it will update the existing rule
+        xray_client.update_indexing_rule(Name="Default", Rule={"Probabilistic": {"DesiredSamplingPercentage": 1}})
+        logger.info("Updated X-Ray indexing rule for Transaction Search")
+    except ClientError as e:
+        if e.response["Error"]["Code"] == "InvalidRequestException":
+            # Rule might already be configured
+            logger.info("X-Ray indexing rule already configured")
+        else:
+            raise

bedrock_agentcore_starter_toolkit/utils/runtime/logs.py

@@ -4,6 +4,18 @@ from datetime import datetime, timezone
 from typing import Optional, Tuple
 
 
+def get_genai_observability_url(region: str) -> str:
+    """Get GenAI Observability Dashboard console URL.
+
+    Args:
+        region: The AWS region
+
+    Returns:
+        The GenAI Observability Dashboard console URL
+    """
+    return f"https://console.aws.amazon.com/cloudwatch/home?region={region}#gen-ai-observability/agent-core"
+
+
 def get_agent_log_paths(agent_id: str, endpoint_name: Optional[str] = None) -> Tuple[str, str]:
     """Get CloudWatch log group paths for an agent.