saving-codeacts
Save executed Python code as reusable tools in the gentools package. Use when preserving successful code executions for later reuse. Covers creating package structure (api.py, impl.py), defining Pydantic output models, and implementing the run() interface.
When & Why to Use This Skill
This Claude skill facilitates the transformation of ephemeral Python code executions into persistent, reusable tools. By automating the creation of a standardized package structure—including Pydantic-powered API definitions and implementation layers—it ensures that successful code logic is preserved, type-safe, and easily integrated into future agentic workflows. It streamlines the transition from experimental code to production-ready modular components.
Use Cases
- Converting successful ad-hoc data processing scripts into permanent, reusable tools for future automated tasks.
- Standardizing custom API integrations by generating structured Pydantic models and clear run() interfaces for better type safety.
- Building a modular library of specialized utility functions (e.g., file parsers, web scrapers) that can be shared across different agentic projects.
- Improving code maintainability by separating public API definitions from internal implementation details in a structured gentools package.
| name | saving-codeacts |
|---|---|
| description | Save executed Python code as reusable tools in the gentools package. Use when preserving successful code executions for later reuse. Covers creating package structure (api.py, impl.py), defining Pydantic output models, and implementing the run() interface. |
Saving Code Actions as Reusable Tools
Save executed Python code as a tool for later reuse.
Package Structure
gentools/<category>/<tool>/
├── __init__.py # Empty file
├── api.py # Public interface with structured models
└── impl.py # Implementation details
Procedure
1. Create Package Directory
mkdir -p gentools/<category>/<tool>
Create empty __init__.py files in both <category> and <tool> directories.
2. Define Tool API (api.py)
from __future__ import annotations
from pydantic import BaseModel, Field
class OutputModel(BaseModel):
"""Description of output."""
field: type = Field(..., title="Description")
def run(param1: type, param2: type = default) -> OutputModel:
"""Tool description.
Args:
param1: Description
param2: Description (default: value)
Returns:
OutputModel with structured data
"""
from .impl import implementation_function
return implementation_function(param1, param2)
Requirements:
- Define Pydantic models for structured output
- Create
run()function with typed parameters - Use lazy import from
impl.pyinsiderun() - Include comprehensive docstring
- Export
OutputModelandruningentools/<category>/<tool>/__init__.py:
from .api import OutputModel, run
__all__ = ["OutputModel", "run"]
3. Implement Details (impl.py)
from __future__ import annotations
from mcptools.<category>.<tool> import Params, run_parsed
from .api import OutputModel
def implementation_function(param1: type, param2: type) -> OutputModel:
"""Implementation description."""
# Use tools from mcptools or gentools packages
result = run_parsed(Params(...))
# Transform and return structured output
return OutputModel(field=result.data)
Requirements:
- Import tools from
mcptoolsorgentoolspackages - Import models from
api.py - Return structured models defined in
api.py
4. Test the Tool
from gentools.<category>.<tool>.api import run
result = run(param1=value1, param2=value2)
print(result)
Best Practices
- Separation: Keep API clean; hide complexity in implementation
- Type Safety: Use Pydantic models for all outputs
- Modularity: Break complex logic into smaller functions
- Defaults: Provide sensible defaults for optional parameters