semvec/pypi-packages huggingface dataset:
elizaos-plugin-shell 2.0.0a4
elizaOS Shell Plugin - Shell command execution with directory restrictions and history tracking
Requires Python: >=3.11
Keywords: agents, ai, command, elizaos, shell, terminal

# elizaOS Shell Plugin (Python)

A secure shell command execution plugin for elizaOS that allows agents to run terminal commands within a restricted directory with command history tracking.

## Installation

```bash
pip install elizaos-plugin-shell
```

## Features

- **Cross-platform support**: Works on Linux, macOS, and Windows
- **Directory restriction**: Commands are restricted to a specified directory for safety
- **Command filtering**: Configurable list of forbidden commands
- **Timeout protection**: Automatic termination of long-running commands
- **Command history**: Tracks command execution history per conversation
- **File operation tracking**: Monitors file creation, modification, and deletion
- **Type safe**: Full type annotations with Pydantic models

## Configuration

Set the following environment variables:

```bash
# Set the allowed directory (commands can only run here)
SHELL_ALLOWED_DIRECTORY=/path/to/safe/directory

# Optional: Set custom timeout in milliseconds (default: 30000)
SHELL_TIMEOUT=60000

# Optional: Add additional forbidden commands (comma-separated)
SHELL_FORBIDDEN_COMMANDS=rm,mv,cp,chmod,chown,shutdown,reboot
```

## Usage

```python
from elizaos_plugin_shell import ShellService, ShellConfig

# Load configuration
config = ShellConfig.from_env()

# Create service
service = ShellService(config)

# Execute a command
result = await service.execute_command("ls -la", conversation_id="conv-123")

if result.success:
    print(f"Output: {result.stdout}")
else:
    print(f"Error: {result.stderr}")

# Get command history
history = service.get_command_history("conv-123", limit=10)

# Clear history
service.clear_command_history("conv-123")
```

## Security

The plugin enforces several security measures:

1. **Directory Restriction**: All commands execute within `SHELL_ALLOWED_DIRECTORY`
2. **Forbidden Commands**: Dangerous commands are blocked by default
3. **Path Traversal Protection**: Blocks `../` and similar patterns
4. **No Shell Expansion**: Commands execute without dangerous shell interpretation
5. **Timeout Protection**: Commands auto-terminate after timeout

## License

MIT
elizaos-plugin-scratchpad 2.0.0a4
elizaOS Scratchpad Plugin - File-based persistent memory storage with markdown frontmatter and TF-IDF search
Requires Python: >=3.11
Keywords: agents, ai, elizaos, memory, notes, scratchpad

# elizaos-plugin-scratchpad

elizaOS Scratchpad Plugin - File-based persistent memory storage with markdown frontmatter and TF-IDF search

## Installation

```bash
pip install elizaos-plugin-scratchpad
```

## Part of elizaOS

This is a Python plugin for the [elizaOS](https://github.com/elizaos/eliza) AI agent framework.

## License

MIT
elizaos-plugin-scheduling 2.0.0a4
ElizaOS plugin for scheduling and calendar coordination
Requires Python: >=3.11
Keywords: calendar, elizaos, ics, meetings, scheduling

# elizaos-plugin-scheduling

ElizaOS plugin for scheduling and calendar coordination

## Installation

```bash
pip install elizaos-plugin-scheduling
```

## Part of elizaOS

This is a Python plugin for the [elizaOS](https://github.com/elizaos/eliza) AI agent framework.

## License

MIT
elizaos-plugin-s3-storage 2.0.0a4
elizaOS S3 Storage Plugin - AWS S3 and S3-compatible storage integration
Requires Python: >=3.11
Keywords: aws, cloud-storage, elizaos, file-upload, s3, storage

# elizaOS S3 Storage Plugin (Python)

AWS S3 and S3-compatible storage integration for elizaOS agents.

## Installation

```bash
pip install elizaos-plugin-s3-storage
```

## Usage

```python
from elizaos_plugin_s3_storage import S3StorageClient, S3StorageConfig

# Create configuration
config = S3StorageConfig(
    access_key_id="your-access-key",
    secret_access_key="your-secret-key",
    region="us-east-1",
    bucket="your-bucket",
)

# Create client
async with S3StorageClient(config) as client:
    # Upload a file
    result = await client.upload_file("/path/to/file.txt")
    print(f"Uploaded to: {result.url}")

    # Upload JSON data
    result = await client.upload_json({"key": "value"}, filename="data.json")
    print(f"JSON uploaded to: {result.url}")

    # Generate signed URL
    url = await client.generate_signed_url("path/to/file.txt", expires_in=3600)
    print(f"Signed URL: {url}")
```

## Configuration

Environment variables:

- `AWS_ACCESS_KEY_ID`: AWS access key ID
- `AWS_SECRET_ACCESS_KEY`: AWS secret access key
- `AWS_REGION`: AWS region
- `AWS_S3_BUCKET`: S3 bucket name
- `AWS_S3_UPLOAD_PATH`: Optional upload path prefix
- `AWS_S3_ENDPOINT`: Optional custom S3 endpoint
- `AWS_S3_SSL_ENABLED`: Enable SSL for custom endpoint
- `AWS_S3_FORCE_PATH_STYLE`: Force path-style addressing

## Features

- Upload files and JSON data to S3
- Generate pre-signed URLs
- Support for S3-compatible services (MinIO, DigitalOcean Spaces, etc.)
- Async/await support
- Type-safe with Pydantic models

## License

MIT
elizaos-plugin-rss 2.0.0a4
elizaOS RSS Plugin - RSS and Atom feed integration for monitoring news feeds
Requires Python: >=3.11
Keywords: agents, ai, atom, elizaos, feed, news, rss

# elizaos-plugin-rss

Python implementation of the RSS plugin for elizaOS.

## Installation

```bash
pip install elizaos-plugin-rss
```

Or for development:

```bash
pip install -e ".[dev]"
```

## Usage

```python
from elizaos_plugin_rss import RssClient, RssConfig

# Create client
config = RssConfig()
client = RssClient(config)

# Fetch a feed
feed = await client.fetch_feed("https://news.ycombinator.com/rss")
print(f"Feed: {feed.title}")
print(f"Items: {len(feed.items)}")

for item in feed.items[:5]:
    print(f"  - {item.title}")
```

## Features

- Async HTTP client using httpx
- Type-safe with Pydantic models
- RSS 2.0 and Atom feed parsing
- Secure XML parsing with defusedxml
- Full feature parity with TypeScript and Rust implementations

## Development

```bash
# Install dev dependencies
pip install -e ".[dev]"

# Run tests
pytest

# Type checking
mypy elizaos_plugin_rss

# Linting
ruff check .
ruff format .
```

## License

MIT
elizaos-plugin-robot-voice 2.0.0a4
Retro 1980s SAM Text-to-Speech plugin for ElizaOS agents
Requires Python: >=3.10
Keywords: 1980s, elizaos, plugin, retro, sam, text-to-speech, tts, voice-synthesis

# Eliza Plugin Robot Voice (Python)

Python implementation of the SAM Text-to-Speech plugin.

## Installation

```bash
pip install -e .
```

## Usage

```python
from eliza_plugin_robot_voice import SamTTSService, SamTTSOptions

service = SamTTSService()
audio = service.generate_audio("Hello", SamTTSOptions(speed=72))
wav = service.create_wav_buffer(audio)
```

## Testing

```bash
pytest
```
elizaos-plugin-rlm 2.0.0a4
RLM (Recursive Language Model) plugin for elizaOS - enables processing of arbitrarily long contexts
Requires Python: >=3.11
Keywords: agent, ai, elizaos, long-context, plugin, recursive-language-model, rlm

# elizaos-plugin-rlm

RLM (Recursive Language Model) plugin for elizaOS - enables processing of arbitrarily long contexts

## Installation

```bash
pip install elizaos-plugin-rlm
```

## Part of elizaOS

This is a Python plugin for the [elizaOS](https://github.com/elizaos/eliza) AI agent framework.

## License

MIT
elizaos-plugin-prose 2.0.0a4
elizaOS OpenProse Plugin - A programming language for AI sessions and multi-agent orchestration
Requires Python: >=3.11
Keywords: agents, ai, elizaos, openprose, orchestration, workflow

# elizaos-plugin-prose

elizaOS OpenProse Plugin - A programming language for AI sessions and multi-agent orchestration

## Installation

```bash
pip install elizaos-plugin-prose
```

## Part of elizaOS

This is a Python plugin for the [elizaOS](https://github.com/elizaos/eliza) AI agent framework.

## License

MIT
elizaos-plugin-pdf 2.0.0a4
elizaOS PDF Plugin - PDF reading and text extraction
Requires Python: >=3.11
Keywords: document-processing, elizaos, pdf, text-extraction

# elizaOS PDF Plugin (Python)

PDF reading and text extraction for elizaOS agents.

## Installation

```bash
pip install elizaos-plugin-pdf
```

## Usage

```python
from elizaos_plugin_pdf import PdfClient

# Create client
client = PdfClient()

# Extract text from PDF file
text = await client.extract_text_from_file("document.pdf")
print(text)

# Extract text from PDF bytes
with open("document.pdf", "rb") as f:
    pdf_bytes = f.read()
text = await client.extract_text(pdf_bytes)
print(text)

# Get full document info
info = await client.get_document_info(pdf_bytes)
print(f"Pages: {info.page_count}")
print(f"Title: {info.metadata.title}")
for page in info.pages:
    print(f"Page {page.page_number}: {page.text[:100]}...")
```

## Features

- Extract text from PDF files
- Get document metadata (title, author, etc.)
- Page-by-page text extraction
- Configurable text cleaning
- Async/await support
- Type-safe with Pydantic models

## License

MIT
elizaos-plugin-openrouter 2.0.0a4
elizaOS OpenRouter Plugin - Multi-model AI gateway client for text and object generation
Requires Python: >=3.11
Keywords: agents, ai, elizaos, llm, multi-model, openrouter

# elizaOS Plugin OpenRouter (Python)

OpenRouter plugin for elizaOS - Multi-model AI gateway client for text and object generation.

## Installation

```bash
pip install elizaos-plugin-openrouter
```

## Usage

```python
from elizaos_plugin_openrouter import OpenRouterClient, OpenRouterConfig

# Create a client with API key
config = OpenRouterConfig.from_env()
client = OpenRouterClient(config)

# Generate text
response = await client.generate_text_large("What is the meaning of life?")
print(response.text)

# Generate embeddings
embedding = await client.generate_embedding("Hello, world!")
print(f"Embedding dimension: {len(embedding.embedding)}")
```

## Configuration

The client can be configured via environment variables:

| Variable                          | Description                           | Default                         |
| --------------------------------- | ------------------------------------- | ------------------------------- |
| `OPENROUTER_API_KEY`              | API key for authentication (required) | -                               |
| `OPENROUTER_BASE_URL`             | Base URL for the API                  | `https://openrouter.ai/api/v1`  |
| `OPENROUTER_SMALL_MODEL`          | Model for small text generation       | `google/gemini-2.0-flash-001`   |
| `OPENROUTER_LARGE_MODEL`          | Model for large text generation       | `google/gemini-2.5-flash`       |
| `OPENROUTER_EMBEDDING_MODEL`      | Model for embeddings                  | `openai/text-embedding-3-small` |
| `OPENROUTER_EMBEDDING_DIMENSIONS` | Embedding dimensions                  | `1536`                          |
| `OPENROUTER_TIMEOUT_SECONDS`      | Request timeout                       | `60`                            |

## Features

- **Text Generation**: Generate text using various models (Claude, GPT, Gemini, etc.)
- **Object Generation**: Generate structured JSON objects
- **Text Embeddings**: Generate embeddings for semantic search
- **Multi-Model Support**: Access 100+ models through a single API

## Requirements

- Python 3.11+
- OpenRouter API key (https://openrouter.ai)

## License

MIT
elizaos-plugin-openai 2.0.0a4
elizaOS OpenAI Plugin - OpenAI API integration for text, image, audio, and embeddings
Requires Python: >=3.11
Keywords: agents, ai, elizaos, embeddings, gpt, llm, openai

# elizaOS OpenAI Plugin (Python)

A type-safe async Python client for OpenAI APIs, designed for use with elizaOS.

## Features

- 🔒 **Strong typing** with Pydantic validation
- ⚡ **Async-first** using httpx
- 🎯 **Fail-fast** error handling - no silent failures
- 📝 **Full API coverage**:
  - Text generation (GPT-4, GPT-4o, etc.)
  - Embeddings (text-embedding-3-small, etc.)
  - Image generation (DALL-E)
  - Image description (GPT-4 Vision)
  - Audio transcription (Whisper)
  - Text-to-speech
  - Tokenization (tiktoken)

## Installation

```bash
pip install elizaos-plugin-openai
```

## Quick Start

```python
import asyncio
from elizaos_plugin_openai import OpenAIPlugin

async def main():
    # Create plugin (uses OPENAI_API_KEY env var by default)
    async with OpenAIPlugin() as plugin:
        # Generate text
        response = await plugin.generate_text_large(
            "Explain quantum computing in 2 sentences."
        )
        print(response)

        # Create embedding
        embedding = await plugin.create_embedding("Hello, world!")
        print(f"Embedding dimensions: {len(embedding)}")

        # Describe an image
        description = await plugin.describe_image(
            "https://example.com/image.jpg"
        )
        print(f"Title: {description.title}")
        print(f"Description: {description.description}")

asyncio.run(main())
```

## Configuration

```python
from elizaos_plugin_openai import OpenAIPlugin

plugin = OpenAIPlugin(
    api_key="sk-...",  # Or use OPENAI_API_KEY env var
    base_url="https://api.openai.com/v1",
    small_model="gpt-5-mini",
    large_model="gpt-5",
    embedding_model="text-embedding-3-small",
    embedding_dimensions=1536,
)
```

## Streaming

```python
async with OpenAIPlugin() as plugin:
    async for chunk in plugin.stream_text("Tell me a story..."):
        print(chunk, end="", flush=True)
```

## Tokenization

```python
from elizaos_plugin_openai import tokenize, detokenize, count_tokens

# Count tokens
count = count_tokens("Hello, world!", model="gpt-5")
print(f"Token count: {count}")

# Tokenize and detokenize
tokens = tokenize("Hello, world!", model="gpt-5")
text = detokenize(tokens, model="gpt-5")
```

## Error Handling

All API errors are raised as `OpenAIClientError`:

```python
from elizaos_plugin_openai import OpenAIPlugin, OpenAIClientError

async with OpenAIPlugin() as plugin:
    try:
        result = await plugin.generate_text_large("...")
    except OpenAIClientError as e:
        print(f"API error ({e.status_code}): {e}")
```

## License

MIT
elizaos-plugin-ollama 2.0.0a4
elizaOS Ollama Plugin - Local LLM client for text and object generation
Requires Python: >=3.11
Keywords: agents, ai, elizaos, llm, local-ai, ollama

# elizaOS Plugin Ollama (Python)

Ollama plugin for elizaOS - Local LLM client for text and object generation.

## Installation

```bash
pip install elizaos-plugin-ollama
```

## Usage

```python
from elizaos_plugin_ollama import OllamaClient, OllamaConfig

# Create a client with default configuration
config = OllamaConfig.from_env()
client = OllamaClient(config)

# Generate text
response = await client.generate_text_large("What is the meaning of life?")
print(response.text)

# Generate embeddings
embedding = await client.generate_embedding("Hello, world!")
print(f"Embedding dimension: {len(embedding.embedding)}")
```

## Configuration

The client can be configured via environment variables:

| Variable                 | Description                     | Default                   |
| ------------------------ | ------------------------------- | ------------------------- |
| `OLLAMA_API_ENDPOINT`    | Base URL for the Ollama API     | `http://localhost:11434`  |
| `OLLAMA_SMALL_MODEL`     | Model for small text generation | `gemma3:latest`           |
| `OLLAMA_LARGE_MODEL`     | Model for large text generation | `gemma3:latest`           |
| `OLLAMA_EMBEDDING_MODEL` | Model for embeddings            | `nomic-embed-text:latest` |
| `OLLAMA_TIMEOUT_SECONDS` | Request timeout                 | `300`                     |

## Features

- **Text Generation**: Generate text using small or large models
- **Object Generation**: Generate structured JSON objects
- **Text Embeddings**: Generate embeddings for semantic search
- **Model Management**: Automatic model downloading if not available locally

## Requirements

- Python 3.11+
- Running Ollama server (https://ollama.ai)

## License

MIT