strands-code-agent 0.1.0__py3-none-any.whl

strands_code_agent/__init__.py

@@ -0,0 +1,4 @@
+from strands_code_agent.code_agent import CodeAgent
+from strands_code_agent.toolkits import Toolkit
+
+__all__ = ["CodeAgent", "Toolkit"]

strands_code_agent/code_agent.py

@@ -0,0 +1,142 @@
+import tempfile
+
+from strands import Agent
+from jinja2 import Template
+
+from strands_code_agent.document_code import get_documentation
+from strands_code_agent.python_environments.local_sandboxed import SandboxedPythonInterpreter
+from strands_code_agent.imports import get_import_string, extract_imports
+
+
+CODE_AGENT_INSTRUCTIONS = """
+You are a code agent. You solve tasks by writing and executing Python code using the python_repl tool.
+
+The Python interpreter state resets completely with each new user message, but it persists across multiple tool invocations within a single response.
+You can perform multi-step computation within a single turn, but do not assume that results from a previous turn are still in memory.
+"""
+
+CODE_PREAMBLE_TEMPLATE = Template("""
+The python environment of the python_repl tool is initialised with the following code (you do not need to rewrite this code):
+```python
+{{CODE_PREAMBLE}}
+```
+""")
+
+TEMP_DIR_TEMPLATE = Template("""
+If you need to generate a file use this temporary directory: {{TEMP_DIR}}
+The user has no access to this temporary directory.
+""")
+
+DOMAIN_SPECIFIC_DOC_TEMPLATE = Template("""
+You can use the following Domain Specific Code:
+{{SYMBOLS_DOCUMENTATION}}
+""")
+
+
+class CodeAgent(Agent):
+    """A coding agent that extends Strands Agent with a sandboxed Python REPL and domain-specific symbol documentation.
+
+    CodeAgent wraps a :class:`PythonInterpreter` as a built-in ``python_repl`` tool and
+    assembles a system prompt from the provided toolkits. Each :class:`Toolkit` can contribute:
+
+    - **libraries** – module names authorized for import in the sandboxed interpreter.
+    - **initialization_code** – Python code executed at interpreter startup (e.g. imports, config).
+      Any modules imported in this code are automatically authorized.
+    - **usage_instructions** – free-text guidance appended to the system prompt.
+    - **domain_specific_code** – callable symbols whose source and docstrings are documented in
+      the system prompt and made available in the interpreter.
+
+    The interpreter state persists across tool invocations within a single agent turn but
+    resets completely between user messages.
+
+    Args:
+        system_prompt: Optional base system prompt prepended before the coding instructions.
+
+        tools: Additional tools to include alongside the built-in Python REPL.
+
+        toolkits: :class:`Toolkit` instances that supply libraries, initialization code,
+            usage instructions, and domain-specific symbols to the REPL environment.
+
+        tmp_dir: If ``True`` (default), creates a temporary directory under ``/tmp`` and
+            documents its path in the system prompt so the agent can write files there.
+
+        timeout_seconds: Maximum execution time in seconds for each ``python_repl``
+            invocation. Defaults to ``60``.
+
+        python_interpreter_class: The :class:`PythonInterpreter` subclass to use for
+            code execution. Defaults to :class:`ExecPythonInterpreter` (lightweight,
+            unrestricted ``exec()``-based). Use :class:`SandboxedPythonInterpreter`
+            for import restrictions and sandboxed execution.
+
+        **kwargs: Additional arguments forwarded to the Strands :class:`Agent` base class
+            (e.g. ``model``, ``callback_handler``).
+    """
+    def __init__(self,
+                 system_prompt:str|None=None,
+                 tools:list|None=None,
+                 toolkits:list|None=None,
+                 tmp_dir=True,
+                 timeout_seconds=60,
+                 python_interpreter_class=SandboxedPythonInterpreter,
+                 **kwargs):
+        authorized_imports = set()
+        initialization_code = []
+        usage_instructions = []
+        domain_specific_code = []
+        if toolkits is not None:
+            for toolkit in toolkits:
+                if toolkit.libraries is not None:
+                    authorized_imports.update(toolkit.libraries)
+                if toolkit.initialization_code is not None:
+                    initialization_code.append(toolkit.initialization_code.strip())
+                if toolkit.usage_instructions is not None:
+                    usage_instructions.append(toolkit.usage_instructions.strip())
+                if toolkit.domain_specific_code is not None:
+                    domain_specific_code.extend(toolkit.domain_specific_code)
+
+        additional_functions = {}
+        domain_specific_doc = ""
+        if domain_specific_code:
+            authorized_imports.update(sym.__module__ for sym in domain_specific_code if sym.__module__ != "__main__")
+            initialization_code.append(get_import_string(domain_specific_code))
+            sym_doc =  "\n".join([get_documentation(sym) for sym in domain_specific_code])
+            domain_specific_doc = DOMAIN_SPECIFIC_DOC_TEMPLATE.render(SYMBOLS_DOCUMENTATION=sym_doc)
+            additional_functions = {sym.__qualname__.split(".")[0]: sym for sym in domain_specific_code}
+        
+        code_preamble = "\n".join(initialization_code)
+        # Auto-authorize any modules imported in initialization code so users
+        # don't have to duplicate them in both `libraries` and `initialization_code`.
+        authorized_imports.update(extract_imports(code_preamble))
+        code_preamble_doc = CODE_PREAMBLE_TEMPLATE.render(CODE_PREAMBLE=code_preamble) if code_preamble else ""
+
+        tmp_dir_doc = ""
+        if tmp_dir:
+            self.tmp_dir = tempfile.mkdtemp(dir='/tmp')
+            tmp_dir_doc = TEMP_DIR_TEMPLATE.render(TEMP_DIR=self.tmp_dir)
+
+        system_prompt = '\n'.join([
+            system_prompt if system_prompt is not None else "",
+            CODE_AGENT_INSTRUCTIONS,
+            code_preamble_doc,
+            "\n".join(usage_instructions),
+            tmp_dir_doc,
+            domain_specific_doc
+        ])
+
+        self.python_repl = python_interpreter_class(
+            code_preamble,
+            authorized_imports=authorized_imports,
+            additional_functions=additional_functions,
+            timeout_seconds=timeout_seconds,
+        )
+        python_repl_tool = self.python_repl.get_tool()
+        if tools is not None:
+            tools.append(python_repl_tool)
+        else:
+            tools = [python_repl_tool]
+        
+        kwargs.update({
+            "system_prompt": system_prompt,
+            "tools": tools
+        })
+        super().__init__(**kwargs)

strands_code_agent/document_code.py

@@ -0,0 +1,63 @@
+import inspect
+from typing import Callable, Type, Union
+
+
+def format_function(func, indent: str = "") -> str:
+    try:
+        sig = inspect.signature(func)
+        result = f"{indent}def {func.__name__}{sig}:\n"
+    except (ValueError, TypeError):
+        result = f"{indent}def {func.__name__}(...):\n"
+    
+    doc = inspect.getdoc(func)
+    if doc:
+        doc_lines = doc.split('\n')
+        result += f'{indent}    """\n'
+        for line in doc_lines:
+            result += f"{indent}    {line}\n"
+        result += f'{indent}    """\n'
+    
+    result += f"{indent}    ...\n"
+    return result
+
+
+def get_documentation(obj: Union[Callable, Type]) -> str:
+    """
+    Extract documentation from a Python function or class.
+    Returns formatted text suitable for a coding agent.
+    """
+    if inspect.isclass(obj):
+        # Class header with constructor signature
+        try:
+            sig = inspect.signature(obj)
+            output = f"class {obj.__name__}{sig}:\n"
+        except (ValueError, TypeError):
+            output = f"class {obj.__name__}:\n"
+        
+        # Class docstring
+        class_doc = inspect.getdoc(obj)
+        if class_doc:
+            output += '    """\n'
+            for line in class_doc.split('\n'):
+                output += f"    {line}\n"
+            output += '    """\n\n'
+        
+        # Methods (public + key dunder methods)
+        important_dunders = {
+            '__init__', '__call__', '__enter__', '__exit__',
+            '__iter__', '__next__', '__getitem__', '__setitem__',
+            '__len__', '__contains__', '__repr__', '__str__'
+        }
+        
+        for name, method in inspect.getmembers(obj, predicate=inspect.isfunction):
+            if name.startswith('_') and name not in important_dunders:
+                continue
+            output += format_function(method, indent="    ") + "\n"
+        
+        return output.rstrip() + "\n"
+    
+    elif callable(obj):
+        return format_function(obj)
+    
+    else:
+        raise TypeError(f"Expected a function or class, got {type(obj)}")

strands_code_agent/imports.py

@@ -0,0 +1,36 @@
+import ast
+from typing import Callable, Type, Union
+from collections import defaultdict
+
+
+def extract_imports(code: str) -> set[str]:
+    """Extract top-level module names from import statements in a code snippet."""
+    try:
+        tree = ast.parse(code)
+    except SyntaxError:
+        return set()
+    modules = set()
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Import):
+            for alias in node.names:
+                modules.add(alias.name)
+        elif isinstance(node, ast.ImportFrom):
+            if node.module:
+                modules.add(node.module)
+                for alias in node.names:
+                    modules.add(f"{node.module}.{alias.name}")
+    return modules
+
+
+def get_import_string(symbols: list[Union[Callable, Type]]) -> str:
+    """Generate minimal import statements for a list of symbols."""
+    by_module: dict[str, list[str]] = defaultdict(list)
+    for sym in symbols:
+        if sym.__module__ == "__main__":
+            continue
+        by_module[sym.__module__].append(sym.__qualname__.split(".")[0])
+
+    lines = []
+    for module, names in sorted(by_module.items()):
+        lines.append(f"from {module} import {', '.join(sorted(set(names)))}")
+    return "\n".join(lines)

strands_code_agent/python_environments/base.py

@@ -0,0 +1,44 @@
+from abc import ABC, abstractmethod
+
+from strands import tool
+
+
+STDOUT_LABEL = "STDOUT:\n"
+STDERR_LABEL = "STDERR:"
+
+
+class PythonInterpreter(ABC):
+    def __init__(self, state_initialization=None, stdout_label=STDOUT_LABEL, stderr_label=STDERR_LABEL, authorized_imports=None, additional_functions=None, timeout_seconds=60):
+        self.state_initialization = state_initialization
+        self.stdout_label = stdout_label
+        self.stderr_label = stderr_label
+
+    @abstractmethod
+    def clear_state(self):
+        ...
+
+    @abstractmethod
+    def execute_code(self, code) -> tuple[str, str]:
+        ...
+
+    def get_tool(self):
+        @tool
+        def python_repl(code: str) -> str:
+            """
+            Executes Python code in a REPL environment with state persistence.
+
+            Args:
+                code: The Python code to execute
+            """
+            stdout_output, stderr_output = self.execute_code(code)
+
+            observation = []
+            if stdout_output:
+                observation.append(f"{self.stdout_label}{stdout_output}")
+            if stderr_output:
+                observation.append(f"{self.stderr_label}{stderr_output}")
+            if not observation:
+                observation.append("Code executed successfully.")
+            return '\n'.join(observation)
+
+        return python_repl

strands_code_agent/python_environments/local_exec.py

@@ -0,0 +1,28 @@
+import io
+from contextlib import redirect_stdout, redirect_stderr
+
+from strands_code_agent.python_environments.base import PythonInterpreter, STDOUT_LABEL, STDERR_LABEL
+
+
+class ExecPythonInterpreter(PythonInterpreter):
+    def __init__(self, state_initialization=None, stdout_label=STDOUT_LABEL, stderr_label=STDERR_LABEL, **kwargs):
+        super().__init__(state_initialization, stdout_label, stderr_label)
+        
+        self.state = {}
+        if self.state_initialization:
+            self.execute_code(self.state_initialization)
+    
+    def clear_state(self):
+        self.state.clear()
+        if self.state_initialization:
+            self.execute_code(self.state_initialization)
+    
+    def execute_code(self, code):
+        stdout_buffer = io.StringIO()
+        stderr_buffer = io.StringIO()
+        try:
+            with redirect_stdout(stdout_buffer), redirect_stderr(stderr_buffer):
+                exec(code, self.state)
+        except Exception as e:
+            stderr_buffer.write(str(e))
+        return stdout_buffer.getvalue().strip(), stderr_buffer.getvalue().strip()

strands_code_agent/python_environments/local_sandboxed.py

@@ -0,0 +1,63 @@
+import warnings
+
+from smolagents.local_python_executor import LocalPythonExecutor
+
+from strands_code_agent.python_environments.base import PythonInterpreter, STDOUT_LABEL, STDERR_LABEL
+
+
+# Python builtins that smolagents' executor doesn't allow-list by default
+EXTRA_BUILTINS = {"repr": repr, "ascii": ascii, "ord": ord, "chr": chr, "hex": hex, "oct": oct, "bin": bin}
+
+
+class SandboxedPythonInterpreter(PythonInterpreter):
+    def __init__(self, state_initialization=None, stdout_label=STDOUT_LABEL, stderr_label=STDERR_LABEL, authorized_imports=None, additional_functions=None, timeout_seconds=60):
+        super().__init__(state_initialization, stdout_label, stderr_label)
+
+        self.authorized_imports = authorized_imports or []
+        self.additional_functions = {**EXTRA_BUILTINS, **(additional_functions or {})}
+        self.timeout_seconds = timeout_seconds
+
+        self._init_executor()
+
+    def _init_executor(self):
+        # smolagents' LocalPythonExecutor introspects all attributes of authorized modules
+        # via getattr(), which triggers DeprecationWarnings on access, not use.
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")
+            self.executor = LocalPythonExecutor(
+                additional_authorized_imports=self.authorized_imports,
+                additional_functions=self.additional_functions,
+                timeout_seconds=self.timeout_seconds,
+            )
+            self.executor.send_tools({})
+            if self.state_initialization:
+                self.executor(self.state_initialization)
+
+    def clear_state(self):
+        self._init_executor()
+
+    def execute_code(self, code):
+        stdout, stderr = "", ""
+        try:
+            result = self.executor(code)
+            stdout = result.logs.strip() if result.logs else ""
+        except Exception as e:
+            # Salvage any print output captured before the error
+            if hasattr(self.executor, "state") and "_print_outputs" in self.executor.state:
+                stdout = str(self.executor.state["_print_outputs"]).strip()
+            stderr = str(e)
+        return stdout, stderr
+    
+    def __str__(self) -> str:
+        buffer = []
+        if self.authorized_imports:
+            buffer.append(f"# Authorized Imports: {', '.join(self.authorized_imports)}")
+        if self.additional_functions:
+            buffer.append(f"# Additional Functions: {', '.join(self.additional_functions.keys())}")
+        if self.state_initialization:
+            buffer.append(f"""# Init Code:
+```python
+{self.state_initialization}
+```
+""")
+        return '\n'.join(buffer) if buffer else "Standard PythonInterpreter"

strands_code_agent/toolkits.py

@@ -0,0 +1,42 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class Toolkit:
+    """A toolkit that bundles libraries, initialization code, usage instructions, and domain-specific
+    symbols for use by a CodeAgent's Python REPL environment.
+
+    Args:
+        libraries: Library names to authorize as imports in the Python executor.
+        initialization_code: Python code snippet to run when initializing the environment.
+        usage_instructions: Extra instructions included in the system prompt about how to use the provided libraries.
+        domain_specific_code: Callable symbols to be fully imported and documented in the agent's context.
+    """
+    libraries: list[str] | None = None
+    initialization_code: str | None = None
+    usage_instructions: str | None = None
+    domain_specific_code: list | None = None
+
+
+VISUALIZATION_TOOLKIT = Toolkit(
+    libraries = ['matplotlib.*', 'seaborn.*'],
+    initialization_code = """
+# Visualization Libraries
+import matplotlib
+matplotlib.use('Agg')  # Use non-interactive backend
+import matplotlib.pyplot as plt
+import seaborn as sns
+""",
+    usage_instructions="""
+Do not try to show any matplotlib image: the python_repl tool executes the code in a sub-process without a GUI.
+""")
+
+
+DATA_ANALYSIS_TOOLKIT = Toolkit(
+    libraries = ['numpy.*', 'pandas.*', 'scipy.*', 'datetime'],
+    initialization_code = """
+from datetime import date, datetime, timedelta
+
+import numpy as np
+import pandas as pd
+""")

strands_code_agent/utils.py

@@ -0,0 +1,7 @@
+import base64
+
+
+def image_to_base64(image_path):
+    """Read an image file and return its contents as a base64-encoded string."""
+    with open(image_path, 'rb') as f:
+            return base64.b64encode(f.read()).decode('utf-8')

strands_code_agent-0.1.0.dist-info/METADATA

@@ -0,0 +1,163 @@
+Metadata-Version: 2.4
+Name: strands-code-agent
+Version: 0.1.0
+Summary: A coding agent built on Strands Agents SDK that uses code generation as the primary action interface
+Project-URL: Homepage, https://github.com/aws-samples/sample-strands-code-agent
+Project-URL: Repository, https://github.com/aws-samples/sample-strands-code-agent
+Project-URL: Issues, https://github.com/aws-samples/sample-strands-code-agent/issues
+Author: Emilio Monti
+License-Expression: MIT-0
+License-File: LICENSE
+Keywords: agents,code-generation,llm,repl,strands
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Requires-Dist: jinja2>=3.0
+Requires-Dist: smolagents>=1.0.0
+Requires-Dist: strands-agents>=0.1.0
+Description-Content-Type: text/markdown
+
+# strands-code-agent
+
+A coding agent built on [Strands Agents SDK](https://github.com/strands-agents/sdk-python) that replaces the tool-calling paradigm with code generation as the agent's primary action interface. Rather than invoking structured tools by name and passing results through the conversation context, the agent writes Python code in a persistent REPL where domain capabilities (database queries, APIs, etc.) are exposed as importable library functions. This keeps intermediate data as native Python objects in memory and lets the agent compose multi-step logic in a single code block instead of orchestrating sequential tool calls. In empirical evaluations on the Data Agent Benchmark, this code-generation paradigm achieves higher accuracy (+7%) while consuming 78% fewer input tokens, completing tasks 56% faster, and requiring 35% fewer reasoning cycles compared to an equivalent tool-calling agent. The library makes it easy to configure the Python environment with the libraries and domain-specific code your agent needs.
+
+## Installation
+
+```bash
+pip install strands-code-agent
+```
+
+## Quick Start
+
+```python
+from strands_code_agent import CodeAgent
+
+agent = CodeAgent(system_prompt="You are a helpful data analyst.")
+
+response = agent("What is 2 ** 10?")
+```
+
+The agent receives a `python_repl` tool automatically and solves tasks by writing and executing Python code.
+
+## CodeAgent
+
+`CodeAgent` extends the Strands `Agent` with a built-in Python REPL and automatic system-prompt enrichment.
+
+| Parameter | Type | Description |
+|---|---|---|
+| `system_prompt` | `str \| None` | Base system prompt, extended with coding instructions. |
+| `tools` | `list \| None` | Additional tools alongside the built-in Python REPL. |
+| `toolkits` | `list[Toolkit] \| None` | Toolkits that configure the REPL environment (see below). |
+| `tmp_dir` | `bool` | If `True` (default), creates a temp directory and documents its path in the prompt. |
+| `python_interpreter_class` | `type[PythonInterpreter]` | The interpreter backend. Defaults to `SandboxedPythonInterpreter` (import restrictions via allowlist). Use `ExecPythonInterpreter` for lightweight unrestricted `exec()`-based execution. |
+| `**kwargs` | | Forwarded to the Strands `Agent` base class (e.g. `model`, `callback_handler`). |
+
+## Toolkit
+
+A `Toolkit` bundles everything the REPL needs for a specific domain. Each field influences the `CodeAgent` in a specific way:
+
+| Parameter | Type | Effect on `PythonInterpreter` | Effect on System Prompt |
+|---|---|---|---|
+| `libraries` | `list[str] \| None` | Added to `authorized_imports` — the REPL will only allow imports from this allowlist. | — |
+| `initialization_code` | `str \| None` | Prepended to `state_initialization` — runs before every Agent snippet. | Documented so the agent knows which symbols are pre-loaded. |
+| `usage_instructions` | `str \| None` | — | Appended as-is, giving the agent guidance on how to use the libraries. |
+| `domain_specific_code` | `list \| None` | Auto-imported in `state_initialization` (modules added to `authorized_imports`). | Full signature + docstring of each symbol is documented so the agent can use them. |
+
+### Example
+
+```python
+from strands_code_agent.toolkits import Toolkit
+
+VISUALIZATION_TOOLKIT = Toolkit(
+    # 1. libraries → PythonInterpreter.authorized_imports
+    #    Allows the REPL to import these modules.
+    #    Use "module.*" to allow a module and all its submodules.
+    libraries=["matplotlib.*", "seaborn.*"],
+
+    # 2. initialization_code → PythonInterpreter.state_initialization + System Prompt
+    #    Runs before user code; also shown in the prompt so the agent
+    #    knows plt and sns are already available.
+    initialization_code="""
+import matplotlib
+matplotlib.use('Agg')  # Use non-interactive backend
+import matplotlib.pyplot as plt
+import seaborn as sns
+""",
+
+    # 3. usage_instructions → System Prompt only
+    #    Tells the agent how to behave with these libraries.
+    usage_instructions="Do not try to show any matplotlib image: the python_repl tool executes the code in a sub-process without a GUI.",
+)
+```
+
+### Built-in Toolkits
+
+The library ships with ready-to-use toolkits:
+
+```python
+from strands_code_agent.toolkits import (
+    VISUALIZATION_TOOLKIT,   # matplotlib + seaborn (non-interactive backend)
+    DATA_ANALYSIS_TOOLKIT,   # numpy + pandas + scipy + datetime
+)
+```
+
+### Domain-Specific Code
+
+Pass your own functions or classes via `domain_specific_code`. The `CodeAgent` will:
+
+1. **Auto-import** them in `PythonInterpreter.state_initialization` (their modules are added to `authorized_imports`).
+2. **Document** each symbol's full signature and docstring in the **System Prompt**, so the agent knows how to call them.
+
+```python
+from strands_code_agent import CodeAgent, Toolkit
+
+def calculate_roi(investment: float, returns: float) -> float:
+    """Calculate return on investment as a percentage."""
+    return (returns - investment) / investment * 100
+
+
+agent = CodeAgent(
+    system_prompt="You are a finance assistant.",
+    toolkits=[
+        Toolkit(domain_specific_code=[calculate_roi])
+    ],
+)
+
+response = agent("What is the ROI if I invest 1000 and get back 1250?")
+```
+
+### Combining Toolkits
+
+```python
+from strands_code_agent import CodeAgent
+from strands_code_agent.toolkits import DATA_ANALYSIS_TOOLKIT, VISUALIZATION_TOOLKIT
+
+agent = CodeAgent(
+    system_prompt="You are a data analyst.",
+    toolkits=[DATA_ANALYSIS_TOOLKIT, VISUALIZATION_TOOLKIT],
+)
+```
+
+## Running Tests
+
+The test suite uses [pytest](https://docs.pytest.org/). Install it and run from the project root:
+
+```bash
+pip install pytest
+python -m pytest tests/ -v
+```
+
+## Security
+
+See [CONTRIBUTING](CONTRIBUTING.md#security-issue-notifications) for more information.
+
+## License
+
+This library is licensed under the MIT-0 License. See the LICENSE file.

strands_code_agent-0.1.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+strands_code_agent/__init__.py,sha256=roto57kfvRbs3o_mug5acxv5o-6I15EV3OePxd6YLcI,136
+strands_code_agent/code_agent.py,sha256=9fVA3PG3KuAczciulhpGxZL2GH7FpqL7t5h8jZqGZtw,6414
+strands_code_agent/document_code.py,sha256=s8VAI7rLk8T-fZ5RGYwJSAE8NhnY0kNdQe6jnRVMCfY,2065
+strands_code_agent/imports.py,sha256=KYVgl7VTq9OQhzMDFEe2OgdKy144tS3NshK5QAOgW7Y,1238
+strands_code_agent/toolkits.py,sha256=eo2apEyQ3NWCWYmisiN45uTLeDacnw61h_sDnfXhSl8,1444
+strands_code_agent/utils.py,sha256=YfRND-jJoNl3jX3hv_O7t5V8RAsDgy8GUtfixq2e2qs,230
+strands_code_agent/python_environments/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+strands_code_agent/python_environments/base.py,sha256=S5FAhCKmN4wpxAveRjsb1VQ75vfgCG0_tP_Me_5T1cI,1344
+strands_code_agent/python_environments/local_exec.py,sha256=fK9Xh830NvMDy7gMkSDc617WSzQ3BzsWvsmeOPbBLMA,1092
+strands_code_agent/python_environments/local_sandboxed.py,sha256=wvVY-I5Y0zgMqja7uSi4M6WfQiCW4NAiInimW3ABJP8,2667
+strands_code_agent-0.1.0.dist-info/METADATA,sha256=x5-ea4zYve9xrbuZL2WXlhli34HiZ_549ELr5nICgtc,7033
+strands_code_agent-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+strands_code_agent-0.1.0.dist-info/licenses/LICENSE,sha256=fLdQcTJS79HVeIN7qHhbYTGRCZBvDBC4etq3z0ut_EI,947
+strands_code_agent-0.1.0.dist-info/RECORD,,

strands_code_agent-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

strands_code_agent-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,17 @@
+MIT No Attribution
+
+Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+