bedrock-agentcore-starter-toolkit 0.1.3__py3-none-any.whl → 0.1.4__py3-none-any.whl

bedrock_agentcore_starter_toolkit/services/import_agent/utils.py

@@ -0,0 +1,417 @@
+"""Utility functions for Bedrock Agent import service."""
+
+import json
+import os
+import re
+import secrets
+import textwrap
+from typing import Any, Dict, List, Union
+
+
+def json_to_obj_fixed(json_string: str):
+    """Convert a JSON string to a Python object, handling common formatting issues."""
+    json_string = json_string.strip()
+    json_string = " ".join(json_string.split())
+
+    try:
+        output = json.loads(json_string)
+    except json.JSONDecodeError:
+        output = json_string
+
+    return output
+
+
+def fix_field(obj, field=None):
+    """Fixes the field in the object by converting it to a JSON object if it's a string."""
+    if field is None:
+        return json_to_obj_fixed(obj)
+    else:
+        # Create a new dict to avoid modifying the original
+        new_obj = obj.copy()
+        new_obj[field] = json_to_obj_fixed(obj[field])
+
+        return new_obj
+
+
+def clean_variable_name(text):
+    """Clean a string to create a valid Python variable name. Useful for cleaning Bedrock Agents fields."""
+    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 cleaned and cleaned[0].isdigit():
+        cleaned = f"_{cleaned}"
+
+    if not cleaned:
+        cleaned = "variable"
+
+    return cleaned
+
+
+def unindent_by_one(input_code, spaces_per_indent=4):
+    """Unindents the input code by one level of indentation.
+
+    Note: text dedent does not work as expected in this context, so we implement our own logic.
+
+    Args:
+        input_code (str): The code to unindent.
+        spaces_per_indent (int): The number of spaces per indentation level (default is 4).
+
+    Returns:
+        str: The unindented code.
+    """
+    lines = input_code.splitlines(True)  # Keep the line endings
+    # Process each line
+    unindented = []
+    for line in lines:
+        if line.strip():  # If line is not empty
+            current_indent = len(line) - len(line.lstrip())
+            # Remove one level of indentation if possible
+            if current_indent >= spaces_per_indent:
+                line = line[spaces_per_indent:]
+        unindented.append(line)
+
+    return "".join(unindented)
+
+
+def generate_pydantic_models(
+    schema_input: Union[Dict[str, Any], List[Dict[str, Any]], str],
+    root_model_name: str = "RequestModel",
+    content_type_annotation: str = "",
+) -> str:
+    """Generate Pydantic models from OpenAPI schema objects. Works recursively for nested objects.
+
+    Args:
+        schema_input: The OpenAPI schema, parameter object or parameter array as dictionary/list or JSON string
+        root_model_name: Name for the root model
+        content_type_annotation: Optional content type annotation for the root model
+
+    Returns:
+        String containing Python code for the Pydantic models
+    """
+    # Convert JSON string to dictionary/list if needed
+    if isinstance(schema_input, str):
+        try:
+            schema_input = json.loads(schema_input)
+        except json.JSONDecodeError as e:
+            raise ValueError(f"Invalid JSON input: {e}") from e
+
+    # Start with the imports
+    code = "\n"
+
+    # Dictionary to keep track of models we've created
+    models = {}
+
+    def clean_class_name(name: str) -> str:
+        """Create a valid Python class name."""
+        # Replace non-alphanumeric characters with underscores
+        cleaned = re.sub(r"[^a-zA-Z0-9]", "_", name)
+        # Ensure it starts with a letter
+        if cleaned and not cleaned[0].isalpha():
+            cleaned = "Model_" + cleaned
+        # Convert to CamelCase
+        return "".join(word.capitalize() for word in cleaned.split("_"))
+
+    def process_schema(schema_obj: Dict[str, Any], name: str) -> str:
+        """Process a schema object and return the model class name."""
+        # Handle schema wrapper
+        if "schema" in schema_obj:
+            schema_obj = schema_obj["schema"]
+
+        # Handle $ref
+        if "$ref" in schema_obj:
+            ref_name = schema_obj["$ref"].split("/")[-1]
+            return clean_class_name(ref_name)
+
+        obj_type = schema_obj.get("type")
+
+        # Default to object type if not specified
+        if obj_type is None:
+            obj_type = "object"
+
+        if obj_type == "object":
+            # Generate a valid Python class name
+            class_name = clean_class_name(name)
+
+            # Avoid duplicate model names
+            if class_name in models:
+                return class_name
+
+            properties = schema_obj.get("properties", {})
+            required = schema_obj.get("required", [])
+
+            class_def = f"class {class_name}(BaseModel):\n"
+
+            # Add content type annotation if provided
+            if content_type_annotation:
+                class_def += f'    content_type_annotation: Literal["{content_type_annotation}"]\n'
+
+            if "description" in schema_obj:
+                class_def += f'    """{schema_obj["description"]}"""\n'
+
+            if not properties:
+                class_def += "    pass\n"
+                models[class_name] = class_def
+                return class_name
+
+            for prop_name, prop_schema in properties.items():
+                field_type = get_type_hint(prop_schema, f"{name}_{prop_name}")
+
+                # Check if required
+                is_required = prop_name in required
+
+                # Build the field definition
+                if is_required:
+                    if "description" in prop_schema:
+                        field_def = f' = Field(description="{prop_schema["description"]}")'
+                    else:
+                        field_def = ""
+                else:
+                    field_type = f"Optional[{field_type}]"
+                    if "description" in prop_schema:
+                        field_def = f' = Field(None, description="{prop_schema["description"]}")'
+                    else:
+                        field_def = " = None"
+
+                class_def += f"    {prop_name}: {field_type}{field_def}\n"
+
+            models[class_name] = class_def
+            return class_name
+        elif obj_type == "array":
+            items = schema_obj.get("items", {})
+            item_type = get_type_hint(items, f"{name}_item")
+            return f"List[{item_type}]"
+        else:
+            return get_python_type(obj_type)
+
+    def get_type_hint(prop_schema: Dict[str, Any], name: str) -> str:
+        """Get the Python type hint for a property schema."""
+        if "$ref" in prop_schema:
+            ref_name = prop_schema["$ref"].split("/")[-1]
+            return clean_class_name(ref_name)
+
+        prop_type = prop_schema.get("type")
+
+        # Default to Any if type is not specified
+        if prop_type is None:
+            return "Any"
+
+        if prop_type == "object":
+            # This is a nested object, create a new model for it
+            return process_schema(prop_schema, name)
+        elif prop_type == "array":
+            items = prop_schema.get("items", {})
+            item_type = get_type_hint(items, name)
+            return f"List[{item_type}]"
+        else:
+            return get_python_type(prop_type)
+
+    def get_python_type(openapi_type: str) -> str:
+        """Convert OpenAPI type to Python type."""
+        type_mapping = {
+            "string": "str",
+            "integer": "int",
+            "number": "float",
+            "boolean": "bool",
+            "null": "None",
+            "object": "Dict[str, Any]",
+        }
+        return type_mapping.get(openapi_type, "Any")
+
+    def process_parameter_list(params: List[Dict[str, Any]], name: str) -> str:
+        """Process OpenAPI parameter array and create a model."""
+        class_name = clean_class_name(name)
+        if class_name in models:
+            return class_name
+
+        class_def = f"class {class_name}(BaseModel):\n"
+
+        if not params:
+            class_def += "    pass\n"
+            models[class_name] = class_def
+            return class_name
+
+        # Group parameters by 'in' value to potentially create separate models
+        param_groups = {}
+        for param in params:
+            param_in = param.get("in", "query")  # Default to query if not specified
+            if param_in not in param_groups:
+                param_groups[param_in] = []
+            param_groups[param_in].append(param)
+
+        # If only one type or specifically requested, create a single model
+        if len(param_groups) == 1 or name != "RequestModel":
+            for param in params:
+                param_name = param.get("name", "")
+                if not param_name:
+                    continue
+
+                # Get the parameter type
+                if "schema" in param:
+                    # OpenAPI 3.0 style
+                    field_type = get_type_hint(param["schema"], f"{name}_{param_name}")
+                else:
+                    # OpenAPI 2.0 style
+                    field_type = get_python_type(param.get("type", "string"))
+
+                # Check if required
+                is_required = param.get("required", False)
+
+                # Build the field definition
+                if is_required:
+                    if "description" in param:
+                        field_def = f' = Field(description="{param["description"]}")'
+                    else:
+                        field_def = ""
+                else:
+                    field_type = f"Optional[{field_type}]"
+                    if "description" in param:
+                        field_def = f' = Field(None, description="{param["description"]}")'
+                    else:
+                        field_def = " = None"
+
+                class_def += f"    {param_name}: {field_type}{field_def}\n"
+        else:
+            # Create separate models for each parameter type
+            for param_in, param_list in param_groups.items():
+                in_type_name = f"{name}_{param_in.capitalize()}Params"
+                in_class_name = process_parameter_list(param_list, in_type_name)
+                class_def += f"    {param_in}_params: {in_class_name}\n"
+
+        models[class_name] = class_def
+        return class_name
+
+    def process_parameter_dict(params: Dict[str, Dict[str, Any]], name: str) -> str:
+        """Process a dictionary of named parameters."""
+        class_name = clean_class_name(name)
+        if class_name in models:
+            return class_name
+
+        class_def = f"class {class_name}(BaseModel):\n"
+
+        if not params:
+            class_def += "    pass\n"
+            models[class_name] = class_def
+            return class_name
+
+        for param_name, param_def in params.items():
+            # Get the parameter type
+            if "schema" in param_def:
+                # OpenAPI 3.0 style
+                field_type = get_type_hint(param_def["schema"], f"{name}_{param_name}")
+            else:
+                # OpenAPI 2.0 style or simplified parameter
+                field_type = get_python_type(param_def.get("type", "string"))
+
+            # Check if required
+            is_required = param_def.get("required", False)
+
+            # Build the field definition
+            if is_required:
+                if "description" in param_def:
+                    field_def = f' = Field(description="{param_def["description"]}")'
+                else:
+                    field_def = ""
+            else:
+                field_type = f"Optional[{field_type}]"
+                if "description" in param_def:
+                    field_def = f' = Field(None, description="{param_def["description"]}")'
+                else:
+                    field_def = " = None"
+
+            class_def += f"    {param_name}: {field_type}{field_def}\n"
+
+        models[class_name] = class_def
+        return class_name
+
+    # Determine the type of input and process accordingly
+    if isinstance(schema_input, list):
+        # This is likely a parameter array
+        process_parameter_list(schema_input, root_model_name)
+    elif isinstance(schema_input, dict):
+        if "schema" in schema_input:
+            # This is likely a request body schema
+            process_schema(schema_input, root_model_name)
+        elif "parameters" in schema_input:
+            # This is an operation object with parameters
+            process_parameter_list(schema_input["parameters"], root_model_name)
+        elif all(isinstance(value, dict) and ("name" in value and "in" in value) for value in schema_input.values()):
+            # This appears to be a parameter dict with name/in properties
+            process_parameter_list(list(schema_input.values()), root_model_name)
+        elif all(isinstance(value, dict) for value in schema_input.values()):
+            # This appears to be a dictionary of named parameters
+            process_parameter_dict(schema_input, root_model_name)
+        else:
+            # Try to process as a schema object
+            process_schema({"type": "object", "properties": schema_input}, root_model_name)
+
+    # Add all models to the code
+    for model_code in models.values():
+        code += model_code + "\n\n"
+
+    code = code.rstrip() + "\n"
+    return textwrap.indent(code, "    "), clean_class_name(root_model_name)
+
+
+def prune_tool_name(tool_name: str, length=50) -> str:
+    """Prune tool name to avoid maxiumum of 64 characters. If it exceeds, truncate and append a random suffix."""
+    if len(tool_name) > length:
+        tool_name = tool_name[:length]
+        tool_name += f"_{secrets.token_hex(3)}"
+    return tool_name
+
+
+def get_template_fixtures(field: str = "orchestrationBasePrompts", group: str = "REACT_MULTI_ACTION") -> dict:
+    """Extract all templateFixtures from a specified field in template_fixtures_merged.json.
+
+    For orchestrationBasePrompts, uses the specified group (defaults to REACT_MULTI_ACTION).
+
+    Args:
+        field: The field to extract templateFixtures from (defaults to "orchestrationBasePrompts")
+        group: For orchestrationBasePrompts, which group to use (defaults to "REACT_MULTI_ACTION")
+
+    Returns:
+        Dict mapping fixture names to their template strings
+    """
+    project_root = os.path.dirname(os.path.abspath(__file__))
+    file_path = os.path.join(project_root, "assets", "template_fixtures_merged.json")
+    with open(file_path, "r", encoding="utf-8") as f:
+        data = json.load(f)
+
+    if field not in data:
+        raise ValueError(f"Field '{field}' not found in template_fixtures_merged.json")
+
+    field_data = data[field]
+
+    # For orchestrationBasePrompts, get the specified group's templateFixtures
+    if field == "orchestrationBasePrompts":
+        if group not in field_data:
+            raise ValueError(f"Group '{group}' not found in orchestrationBasePrompts")
+        fixtures = field_data[group].get("templateFixtures", {})
+    else:
+        # For other fields, get templateFixtures directly
+        fixtures = field_data.get("templateFixtures", {})
+
+    result = {}
+    for name, fixture in fixtures.items():
+        if isinstance(fixture, dict) and "template" in fixture:
+            result[name] = fixture["template"]
+
+    return result
+
+
+def safe_substitute_placeholders(template_str, substitutions):
+    """Safely substitute placeholders in a string, leaving non-matching placeholders unchanged."""
+    result = template_str
+    for key, value in substitutions.items():
+        # Only replace if the key exists in the substitutions dict
+        if key in template_str:
+            result = result.replace(key, value)
+    return result
+
+
+def get_base_dir(file):
+    """Get the base directory of the project."""
+    return os.path.dirname(os.path.dirname(os.path.abspath(file)))

bedrock_agentcore_starter_toolkit/utils/runtime/templates/execution_role_policy.json.j2

@@ -87,7 +87,8 @@
       "Effect": "Allow",
       "Action": [
         "bedrock:InvokeModel",
-        "bedrock:InvokeModelWithResponseStream"
+        "bedrock:InvokeModelWithResponseStream",
+        "bedrock:ApplyGuardrail"
       ],
       "Resource": [
         "arn:aws:bedrock:*::foundation-model/*",

{bedrock_agentcore_starter_toolkit-0.1.3.dist-info → bedrock_agentcore_starter_toolkit-0.1.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bedrock-agentcore-starter-toolkit
-Version: 0.1.3
+Version: 0.1.4
 Summary: A starter toolkit for using Bedrock AgentCore
 Project-URL: Homepage, https://github.com/aws/bedrock-agentcore-starter-toolkit
 Project-URL: Bug Tracker, https://github.com/aws/bedrock-agentcore-starter-toolkit/issues
@@ -21,17 +21,23 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.10
+Requires-Dist: autopep8>=2.3.2
 Requires-Dist: bedrock-agentcore>=0.1.1
 Requires-Dist: boto3>=1.39.7
 Requires-Dist: botocore>=1.39.7
 Requires-Dist: docstring-parser<1.0,>=0.15
 Requires-Dist: httpx>=0.28.1
 Requires-Dist: jinja2>=3.1.6
+Requires-Dist: openapi-spec-validator>=0.7.2
+Requires-Dist: prance>=25.4.8.0
 Requires-Dist: prompt-toolkit>=3.0.51
+Requires-Dist: py-openapi-schema-to-json-schema>=0.0.3
 Requires-Dist: pydantic<3.0.0,>=2.0.0
 Requires-Dist: pyyaml>=6.0.2
+Requires-Dist: questionary>=2.1.0
 Requires-Dist: requests>=2.25.0
-Requires-Dist: rich<15.0.0,>=14.0.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: ruamel-yaml>=0.18.14
 Requires-Dist: toml>=0.10.2
 Requires-Dist: typer>=0.16.0
 Requires-Dist: typing-extensions<5.0.0,>=4.13.2
@@ -121,6 +127,20 @@ agentcore invoke '{"prompt": "Hello from Bedrock AgentCore!"}'
 - 🌐 **Browser** - Fast, secure cloud-based browser for web automation
 - 📊 **Observability** - Real-time monitoring and tracing with OpenTelemetry support
 
+## ➡️ Importing from Bedrock Agents
+
+Import from Bedrock Agents to AgentCore using the `import-agent` utility.
+
+```bash
+# Launch the import-agent workflow
+agentcore import-agent
+```
+
+This will generate an equivalent Langchain or Strands agent in `./output`, leveraging AgentCore primitives, and provide an option to deploy the agent to AgentCore Runtime. See additional documentation on this utility:
+- [Quickstart Guide](https://github.com/aws/bedrock-agentcore-starter-toolkit/blob/main/documentation/docs/user-guide/import-agent/quickstart.md)
+- [Utility Overview](https://github.com/aws/bedrock-agentcore-starter-toolkit/blob/main/documentation/docs/user-guide/import-agent/overview.md)
+
+
 ## 📚 About Amazon Bedrock AgentCore
 
 Amazon Bedrock AgentCore enables you to deploy and operate highly effective agents securely, at scale using any framework and model. With AgentCore, developers can accelerate AI agents into production with enterprise-grade scale, reliability, and security. The platform provides:

{bedrock_agentcore_starter_toolkit-0.1.3.dist-info → bedrock_agentcore_starter_toolkit-0.1.4.dist-info}/RECORD

@@ -1,8 +1,13 @@
 bedrock_agentcore_starter_toolkit/__init__.py,sha256=tN3-JWKvxk4ZSJQJIHQ4mMsDtt8J_cDCz-drcGU9USA,120
-bedrock_agentcore_starter_toolkit/cli/cli.py,sha256=r_SNlkUH5L6Cbvv17ssjd4McKP9gwgQhCTFULN0G0kA,875
+bedrock_agentcore_starter_toolkit/cli/__init__.py,sha256=WuIWfHtJKD9gQA-mE49bq8OHGb0Ugt8upRGaOp6-H90,62
+bedrock_agentcore_starter_toolkit/cli/cli.py,sha256=h7lb9htskppokMShmrfzna_8qic49q0nYG6BCWY13fQ,965
 bedrock_agentcore_starter_toolkit/cli/common.py,sha256=R9ZRKmW9gq7u7gkTiCUOTCQTno2lXnsplnq2x0-k2v8,1311
 bedrock_agentcore_starter_toolkit/cli/gateway/__init__.py,sha256=8IZ0kSe6Kz5s2j-SBsoc6qy04MbK85RMTQwZCiR2wmo,68
 bedrock_agentcore_starter_toolkit/cli/gateway/commands.py,sha256=3DuXCvqXlmHU2cmjGzDruyc2Fkrpgoi158myj0vc3nA,3265
+bedrock_agentcore_starter_toolkit/cli/import_agent/README.md,sha256=e7WJz4dagYU2HrGmgSr6Skk7gl_Um8pGKlGKCSAF9rk,2291
+bedrock_agentcore_starter_toolkit/cli/import_agent/__init__.py,sha256=tyM3dXM3Tce3me6roMG4N3nsrfpj3jgCJne5fbobvmI,54
+bedrock_agentcore_starter_toolkit/cli/import_agent/agent_info.py,sha256=V0fZEbV76_H3gmkA17yscyJ8UdcMAquzNqENQ9DXdHA,9477
+bedrock_agentcore_starter_toolkit/cli/import_agent/commands.py,sha256=vpA66fGwKf6cxBelT3Yb_Af5Ow3AMquGLIDe-tBLjmc,22419
 bedrock_agentcore_starter_toolkit/cli/runtime/__init__.py,sha256=0zKPPoYThoDIr3DZhIQJavq5nVTKRsgcE1s9--wx118,60
 bedrock_agentcore_starter_toolkit/cli/runtime/commands.py,sha256=4Mk4ZjlgzYA55Zt--wCDxC84pgso7hpDhdLIUn1f3CI,33141
 bedrock_agentcore_starter_toolkit/cli/runtime/configuration_manager.py,sha256=5TJK80uzA1ARh263smLfthw1t5Ona3bAtdO1pE7OfNo,5808
@@ -12,7 +17,7 @@ bedrock_agentcore_starter_toolkit/notebook/runtime/bedrock_agentcore.py,sha256=U
 bedrock_agentcore_starter_toolkit/operations/__init__.py,sha256=L7sCNjfZviiVVoh2f3NEs2sbjNqFkmIRI3ZPYMMWMz0,51
 bedrock_agentcore_starter_toolkit/operations/gateway/README.md,sha256=aJla3qAaZmM0b4t9q4lQYqfamAugU0FyyzsufFMRi_A,8192
 bedrock_agentcore_starter_toolkit/operations/gateway/__init__.py,sha256=5Qo1GeN-DghNp9g0coFUs7WpUJDboJoidOVs-5Co7fo,233
-bedrock_agentcore_starter_toolkit/operations/gateway/client.py,sha256=0Jot4RkhrM2nVKEEcOQH4ThkaXuR4UaHaVXD8vxpEpA,20030
+bedrock_agentcore_starter_toolkit/operations/gateway/client.py,sha256=dLSuM2jwEMMkCfkpHNQ-BEZdM64TN5UorvPjFBULI1k,20029
 bedrock_agentcore_starter_toolkit/operations/gateway/constants.py,sha256=0_4J6BN4VAE4-XTQhPTEACkhilRrFqu_iKiuHSm2pYk,4610
 bedrock_agentcore_starter_toolkit/operations/gateway/create_lambda.py,sha256=MQsBJfUj26zBh7LqYWLoekHuvbAHIJE8qcXwrmJOhM0,2875
 bedrock_agentcore_starter_toolkit/operations/gateway/create_role.py,sha256=a38JE28PbdRabskTgLXsiqHqWS1vt06jxEEGneYPO_g,3145
@@ -24,9 +29,20 @@ bedrock_agentcore_starter_toolkit/operations/runtime/invoke.py,sha256=ZcPXI7Zx7N
 bedrock_agentcore_starter_toolkit/operations/runtime/launch.py,sha256=vG6SFKVWtKNtxIkpDA9tHlvHDs1LYA4_t-M_RUXXfyo,19206
 bedrock_agentcore_starter_toolkit/operations/runtime/models.py,sha256=Qr45hc73a25cqmiSErq9-degckPXuVhnENyDSshU_mU,3673
 bedrock_agentcore_starter_toolkit/operations/runtime/status.py,sha256=tpOtzAq1S3z_7baxR_WOT8Avo3MtWKGpelVOOfb-uMA,2516
+bedrock_agentcore_starter_toolkit/services/__init__.py,sha256=s7QtYYFCCX2ff0gZHUdDxCDI3zhUq0fPsjevZbF9xdA,66
 bedrock_agentcore_starter_toolkit/services/codebuild.py,sha256=i5VbjqAWrPsPwLUdGSWI-_beqFHPqN3FnVLKM4s3rSo,13445
 bedrock_agentcore_starter_toolkit/services/ecr.py,sha256=nW9wIZcXI6amZeLVSmM9F6awVBQP1-zrFXTozSNEDjo,2805
 bedrock_agentcore_starter_toolkit/services/runtime.py,sha256=TPN2eElh-X-svPpVHn_dHF0Fzl1kAqUIgVSlG_vHaPc,18353
+bedrock_agentcore_starter_toolkit/services/import_agent/__init__.py,sha256=ig-xanZqA3oJdRTucYz9xF9_2yi31ADRVIKFsnIw_l4,68
+bedrock_agentcore_starter_toolkit/services/import_agent/utils.py,sha256=ErY-J0hClJbt5D-pQ99ma-1Fll35tHjqOttM-h0bKKw,15675
+bedrock_agentcore_starter_toolkit/services/import_agent/assets/memory_manager_template.py,sha256=RKrtTxir5XxyMg6cim4CAEbguaxb4mg1Qb31pd7D_kY,7892
+bedrock_agentcore_starter_toolkit/services/import_agent/assets/requirements_langchain.j2,sha256=gZcpxIW0D4qSU6hNPSRZ75zBB6ES7IZj1G-mrfEJG1s,181
+bedrock_agentcore_starter_toolkit/services/import_agent/assets/requirements_strands.j2,sha256=ZAWzCFwdj8Mbq8aBGO3Jnxz0G8XJZPNpIsPf_2Jetfk,100
+bedrock_agentcore_starter_toolkit/services/import_agent/assets/template_fixtures_merged.json,sha256=Xem7jS8n96QEyHBmnPAvWHM4AyTLyma7Nq9sCVHuXJA,175239
+bedrock_agentcore_starter_toolkit/services/import_agent/scripts/__init__.py,sha256=UmhcnsfIo2P1Z9VAJ6Ua2mSkxs4BOeTxgFMcgQXQWCQ,79
+bedrock_agentcore_starter_toolkit/services/import_agent/scripts/base_bedrock_translate.py,sha256=xAqf0Rrhb4QWE_6WBk98NkQdHbCyy2uFzKbiw_9cWA4,72520
+bedrock_agentcore_starter_toolkit/services/import_agent/scripts/bedrock_to_langchain.py,sha256=xwoZcmZ27CfYohwSfLIgbFxa2ubiBFhvufgQEWZkmLk,14950
+bedrock_agentcore_starter_toolkit/services/import_agent/scripts/bedrock_to_strands.py,sha256=eC3v2Ts7B_RUGl4bkUim2uFYYuZZYP9syYBlylJ2gXs,14642
 bedrock_agentcore_starter_toolkit/utils/endpoints.py,sha256=1gIDRd1oO1fymYpiedVit7m6zl5k6N8Ns9N-2ix7ZaE,1153
 bedrock_agentcore_starter_toolkit/utils/logging_config.py,sha256=NtZDyndNKCAbz7jZ0leb13bb3UmjjRUTSVwI8MMlOfw,2191
 bedrock_agentcore_starter_toolkit/utils/runtime/config.py,sha256=qRQid59rD3zJ0d0hcBY4-8R52PNIWEIUt9iR3biuz_c,4495
@@ -37,11 +53,11 @@ bedrock_agentcore_starter_toolkit/utils/runtime/policy_template.py,sha256=CgER7Y
 bedrock_agentcore_starter_toolkit/utils/runtime/schema.py,sha256=gZ0zPvry-ZkXwqUEAy6Izz1RJvmZaXA6a2twnSdk1AY,6418
 bedrock_agentcore_starter_toolkit/utils/runtime/templates/Dockerfile.j2,sha256=ti33aLVoqSfdbBUohxSK-ad1Qb_h7AoO_bkFcgik4UA,1166
 bedrock_agentcore_starter_toolkit/utils/runtime/templates/dockerignore.template,sha256=b_70sBi0MwkTuA9TqxPqFcWK7TcmpaXBJ6M2Ipox65Q,691
-bedrock_agentcore_starter_toolkit/utils/runtime/templates/execution_role_policy.json.j2,sha256=eFPp6sl7TS7p_FSdCqSMkXNZnDg-ahg9rhufT71A0SQ,2477
+bedrock_agentcore_starter_toolkit/utils/runtime/templates/execution_role_policy.json.j2,sha256=kBNIDrILAx4ZGUxB_ExZAYxTKENfwNFVc7eifiD8z9U,2511
 bedrock_agentcore_starter_toolkit/utils/runtime/templates/execution_role_trust_policy.json.j2,sha256=PPJF6Ofq70W5DUE0NlbmnZjw5RkgepPgkskxEgEG28o,473
-bedrock_agentcore_starter_toolkit-0.1.3.dist-info/METADATA,sha256=iX0FQeMib-MtEBtK6nBnp-3nSk8_el-QjlN_8fG_fBk,6198
-bedrock_agentcore_starter_toolkit-0.1.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-bedrock_agentcore_starter_toolkit-0.1.3.dist-info/entry_points.txt,sha256=Tf94DkUf2Tp8P7p8MEXLxre7A7Pp_XNukteiz0wHnk8,77
-bedrock_agentcore_starter_toolkit-0.1.3.dist-info/licenses/LICENSE.txt,sha256=nNPOMinitYdtfbhdQgsPgz1UowBznU6QVN3Xs0pSTKU,10768
-bedrock_agentcore_starter_toolkit-0.1.3.dist-info/licenses/NOTICE.txt,sha256=rkBsg8DbKqfIoQbveqX9foR4uJPUVAokbkr02pRPilE,8674
-bedrock_agentcore_starter_toolkit-0.1.3.dist-info/RECORD,,
+bedrock_agentcore_starter_toolkit-0.1.4.dist-info/METADATA,sha256=4QvHTT1QQzcZwwXiq8jj9d_uWFhRTCfrbYSyV_f0gQM,7120
+bedrock_agentcore_starter_toolkit-0.1.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+bedrock_agentcore_starter_toolkit-0.1.4.dist-info/entry_points.txt,sha256=Tf94DkUf2Tp8P7p8MEXLxre7A7Pp_XNukteiz0wHnk8,77
+bedrock_agentcore_starter_toolkit-0.1.4.dist-info/licenses/LICENSE.txt,sha256=nNPOMinitYdtfbhdQgsPgz1UowBznU6QVN3Xs0pSTKU,10768
+bedrock_agentcore_starter_toolkit-0.1.4.dist-info/licenses/NOTICE.txt,sha256=rkBsg8DbKqfIoQbveqX9foR4uJPUVAokbkr02pRPilE,8674
+bedrock_agentcore_starter_toolkit-0.1.4.dist-info/RECORD,,