strands-code-agent 0.1.0__tar.gz

strands_code_agent-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,19 @@
+name: Publish to PyPI
+
+on:
+  release:
+    types: [published]
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+      - run: pip install build
+      - run: python -m build
+      - uses: pypa/gh-action-pypi-publish@release/v1

strands_code_agent-0.1.0/.gitignore

@@ -0,0 +1,26 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.egg-info/
+dist/
+build/
+*.egg
+
+# Virtual environments
+.venv/
+venv/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Testing
+.pytest_cache/
+.coverage
+htmlcov/

strands_code_agent-0.1.0/CODE_OF_CONDUCT.md

@@ -0,0 +1,4 @@
+## Code of Conduct
+This project has adopted the [Amazon Open Source Code of Conduct](https://aws.github.io/code-of-conduct).
+For more information see the [Code of Conduct FAQ](https://aws.github.io/code-of-conduct-faq) or contact
+opensource-codeofconduct@amazon.com with any additional questions or comments.

strands_code_agent-0.1.0/CONTRIBUTING.md

@@ -0,0 +1,59 @@
+# Contributing Guidelines
+
+Thank you for your interest in contributing to our project. Whether it's a bug report, new feature, correction, or additional
+documentation, we greatly value feedback and contributions from our community.
+
+Please read through this document before submitting any issues or pull requests to ensure we have all the necessary
+information to effectively respond to your bug report or contribution.
+
+
+## Reporting Bugs/Feature Requests
+
+We welcome you to use the GitHub issue tracker to report bugs or suggest features.
+
+When filing an issue, please check existing open, or recently closed, issues to make sure somebody else hasn't already
+reported the issue. Please try to include as much information as you can. Details like these are incredibly useful:
+
+* A reproducible test case or series of steps
+* The version of our code being used
+* Any modifications you've made relevant to the bug
+* Anything unusual about your environment or deployment
+
+
+## Contributing via Pull Requests
+Contributions via pull requests are much appreciated. Before sending us a pull request, please ensure that:
+
+1. You are working against the latest source on the *main* branch.
+2. You check existing open, and recently merged, pull requests to make sure someone else hasn't addressed the problem already.
+3. You open an issue to discuss any significant work - we would hate for your time to be wasted.
+
+To send us a pull request, please:
+
+1. Fork the repository.
+2. Modify the source; please focus on the specific change you are contributing. If you also reformat all the code, it will be hard for us to focus on your change.
+3. Ensure local tests pass.
+4. Commit to your fork using clear commit messages.
+5. Send us a pull request, answering any default questions in the pull request interface.
+6. Pay attention to any automated CI failures reported in the pull request, and stay involved in the conversation.
+
+GitHub provides additional document on [forking a repository](https://help.github.com/articles/fork-a-repo/) and
+[creating a pull request](https://help.github.com/articles/creating-a-pull-request/).
+
+
+## Finding contributions to work on
+Looking at the existing issues is a great way to find something to contribute on. As our projects, by default, use the default GitHub issue labels (enhancement/bug/duplicate/help wanted/invalid/question/wontfix), looking at any 'help wanted' issues is a great place to start.
+
+
+## Code of Conduct
+This project has adopted the [Amazon Open Source Code of Conduct](https://aws.github.io/code-of-conduct).
+For more information see the [Code of Conduct FAQ](https://aws.github.io/code-of-conduct-faq) or contact
+opensource-codeofconduct@amazon.com with any additional questions or comments.
+
+
+## Security issue notifications
+If you discover a potential security issue in this project we ask that you notify AWS/Amazon Security via our [vulnerability reporting page](http://aws.amazon.com/security/vulnerability-reporting/). Please do **not** create a public github issue.
+
+
+## Licensing
+
+See the [LICENSE](LICENSE) file for our project's licensing. We will ask you to confirm the licensing of your contribution.

strands_code_agent-0.1.0/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.
+

strands_code_agent-0.1.0/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,137 @@
+# 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/pyproject.toml

@@ -0,0 +1,36 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "strands-code-agent"
+version = "0.1.0"
+description = "A coding agent built on Strands Agents SDK that uses code generation as the primary action interface"
+readme = "README.md"
+license = "MIT-0"
+requires-python = ">=3.10"
+authors = [
+    { name = "Emilio Monti" },
+]
+keywords = ["agents", "code-generation", "llm", "strands", "repl"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+dependencies = [
+    "strands-agents>=0.1.0",
+    "smolagents>=1.0.0",
+    "jinja2>=3.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/aws-samples/sample-strands-code-agent"
+Repository = "https://github.com/aws-samples/sample-strands-code-agent"
+Issues = "https://github.com/aws-samples/sample-strands-code-agent/issues"

strands_code_agent-0.1.0/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-0.1.0/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-0.1.0/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)}")