From bf4e0756f8098e0b6440b4c3f0a6f523b3e2d14a Mon Sep 17 00:00:00 2001 From: Rikul patel Date: Wed, 1 Apr 2026 21:37:59 -0500 Subject: [PATCH 01/84] Refactor agent initialization and fix permission flow - Fix ask_permission logic in agent.py (was commented out, now properly implemented) - Update main.py to use message queue for initial prompt delivery - Remove obsolete ask_permission tests that no longer apply - Improve code structure by separating prompt handling from agent logic --- app/agent.py | 19 +++++++++---------- app/main.py | 11 ++++++++--- tests/test_display.py | 34 ++++------------------------------ 3 files changed, 21 insertions(+), 43 deletions(-) diff --git a/app/agent.py b/app/agent.py index 4f991a7..f8ff583 100755 --- a/app/agent.py +++ b/app/agent.py @@ -77,14 +77,14 @@ async def agent_loop(self, message: str) -> None: result = "" if not self.auto_approve and self.channel == Channel.CLI: - #if not await ask_permission(self.mq, tool_name, tool_args): - self.messages.append({ - "role": "tool", - "tool_call_id": tool_call.id, - "name": tool_name, - "content": "User denied permission to run this tool. Ask for permission to run the tool again if you want to try running it." - }) - continue + if not await ask_permission(self.mq, tool_name, tool_args): + self.messages.append({ + "role": "tool", + "tool_call_id": tool_call.id, + "name": tool_name, + "content": "User denied permission to run this tool. Ask for permission to run the tool again if you want to try running it." + }) + continue result = run_tool(tool_name=tool_name, tool_args=tool_args) @@ -109,5 +109,4 @@ async def agent_loop(self, message: str) -> None: await self.mq.outgoing_msg(OutgoingMessage(content=assistant_message.content.strip(), channel=self.channel)) if finish_reason in ("stop", None): - break - + break \ No newline at end of file diff --git a/app/main.py b/app/main.py index 8d9fa6d..7601d74 100644 --- a/app/main.py +++ b/app/main.py @@ -67,8 +67,14 @@ async def main(): agent = Agent(mq = mq, auto_approve=args.auto_approve or args.silent, max_iterations=args.max_iterations, silent=args.silent) - await agent.agent_loop(args.prompt) + # Send initial prompt to agent via message queue + from app.message import IncomingMessage + from app.channel import Channel + await mq.incoming_msg(IncomingMessage(content=args.prompt, channel=Channel.CLI)) + if args.no_repl or args.silent: + # For silent/no-repl mode, just run agent processing + await agent.process_incoming() return try: @@ -88,5 +94,4 @@ async def main(): # For better Ctrl+C handling, we use asyncio.Runner which is available in Python 3.11 and later with asyncio.Runner() as runner: - runner.run(main()) - \ No newline at end of file + runner.run(main()) \ No newline at end of file diff --git a/tests/test_display.py b/tests/test_display.py index ceaf081..e9b501f 100644 --- a/tests/test_display.py +++ b/tests/test_display.py @@ -1,7 +1,7 @@ import logging from unittest.mock import patch, MagicMock -from app.display import ask_permission, log +from app.display import log def test_log_is_configured(): @@ -21,32 +21,6 @@ def test_library_loggers_silenced(): assert logging.getLogger(name).level == logging.WARNING -def test_ask_permission_returns_true_when_confirmed(): - """Test ask_permission returns True when user confirms""" - with patch("builtins.input", return_value="y"): - result = ask_permission("bash", {"command": "echo hi"}) - assert result is True - - -def test_ask_permission_returns_true_when_empty_input(): - """Test ask_permission returns True when user presses Enter""" - with patch("builtins.input", return_value=""): - result = ask_permission("bash", {"command": "echo hi"}) - assert result is True - - -def test_ask_permission_returns_false_when_denied(): - """Test ask_permission returns False when user denies""" - with patch("builtins.input", return_value="n"): - result = ask_permission("read_file", {"file_path": "/tmp/x"}) - assert result is False - - -def test_ask_permission_prints_tool_name_and_args(capsys): - """Test ask_permission prints tool name and args""" - with patch("builtins.input", return_value="y"): - ask_permission("write_file", {"file_path": "/tmp/out.txt", "content": "hello"}) - - captured = capsys.readouterr() - assert "write_file" in captured.out - assert "/tmp/out.txt" in captured.out \ No newline at end of file +# Note: ask_permission tests have been removed because the function +# has been moved to app.cli and completely rewritten with a different +# async interface that uses message queues. \ No newline at end of file From 83dabdf0e87196eb0fad241a8dd60628aefe1963 Mon Sep 17 00:00:00 2001 From: Rikul Date: Tue, 21 Apr 2026 20:46:00 -0500 Subject: [PATCH 02/84] feat: Add comprehensive command system with /model command - Created agents.md documentation for architecture - Implemented command system with parser, registry, and dispatcher - Added /model command to show current AI model configuration - Integrated command system into agent (commands bypass LLM) - Made command system reusable across channels - Added /help, /config, /tools, /skills, /quit commands - Created demo_commands.md with usage examples - Command syntax supports arguments, flags, and quoted values --- agents.md | 399 ++++++++++++++++++++++++++++ app/__init__.py | 44 ++++ app/agent.py | 29 ++- app/commands.py | 659 +++++++++++++++++++++++++++++++++++++++++++++++ config.toml | 4 + demo_commands.md | 346 +++++++++++++++++++++++++ 6 files changed, 1480 insertions(+), 1 deletion(-) create mode 100644 agents.md create mode 100644 app/commands.py create mode 100755 config.toml create mode 100644 demo_commands.md diff --git a/agents.md b/agents.md new file mode 100644 index 0000000..b780452 --- /dev/null +++ b/agents.md @@ -0,0 +1,399 @@ +# Agents System - crafterscode + +## Overview + +The crafterscode agents system is a modular, extensible framework for building AI agents with tool-calling capabilities. This document describes the architecture, components, and extensibility patterns for the system. + +## Architecture + +### Core Components + +``` +┌─────────────────────────────────────────────┐ +│ Message Queue │ +│ (app/message_queue.py) │ +│ • Asynchronous message routing │ +│ • Channel-based delivery │ +│ • Thread-safe operations │ +└───────────────┬─────────────────────────────┘ + │ + ┌─────────┴─────────┐ + ▼ ▼ +┌─────────────┐ ┌─────────────┐ +│ Channel │ │ Agent │ +│ (app/channel.py) (app/agent.py) │ +│ • CLI │ │ • LLM orchestration │ +│ • Discord │ │ • Tool calling │ +│ • WebSocket│ │ • Iteration control │ +│ • API │ └─────────────┘ +└─────────────┘ +``` + +### Message Flow + +1. **Incoming**: User input → Channel → Message Queue → Agent +2. **Outgoing**: Agent → Tool calls → Message Queue → Channel → User +3. **Tool Responses**: Tool execution → Message Queue → Agent → Response formatting → Channel + +## Channel System + +### Available Channels + +| Channel | Description | Implementation | +|---------|-------------|----------------| +| **CLI** | Command-line interface | `app/cli.py` | +| **Discord** | Discord bot (planned) | (Future implementation) | +| **WebSocket** | Real-time web interface | (Future implementation) | +| **API** | REST/GraphQL endpoints | (Future implementation) | + +### Creating New Channels + +To add a new channel: + +1. **Extend `Channel` enum** in `app/channel.py`: + ```python + from enum import Enum + class Channel(str, Enum): + CLI = "cli" + DISCORD = "discord" + WEBSOCKET = "websocket" + API = "api" + YOUR_CHANNEL = "your_channel" + ``` + +2. **Create channel implementation**: + ```python + # app/channels/your_channel.py + from app.channel import Channel + from app.message_queue import MessageQueue + from app.message import IncomingMessage, OutgoingMessage + + class YourChannel: + def __init__(self, queue: MessageQueue, config: dict): + self.queue = queue + self.config = config + queue.register(Channel.YOUR_CHANNEL, self.deliver) + + async def deliver(self, msg: OutgoingMessage): + # Send message to your channel + pass + + async def start(self): + # Start listening for messages + pass + ``` + +3. **Register in main application**: + ```python + # app/main.py or app/__init__.py + from app.channels.your_channel import YourChannel + your_channel = YourChannel(message_queue, config) + ``` + +## Command System + +### Built-in Commands + +| Command | Description | Channel Support | +|---------|-------------|-----------------| +| `/help` | Show help information | All channels | +| `/model` | Show current model info | All channels | +| `/tools` | List available tools | All channels | +| `/skills` | List available skills | All channels | +| `/config` | Show configuration | All channels | +| `/quit` | Exit the agent | CLI only | + +### Command Structure + +Commands follow a consistent pattern: + +``` +/ [argument1] [argument2]... [--option value] +``` + +Examples: +- `/model` +- `/help tools` +- `/config show --verbose` + +### Adding New Commands + +1. **Define command handler**: + ```python + # app/commands/your_command.py + from app.message import IncomingMessage, OutgoingMessage + from app.config import get_config + + async def handle_your_command(args: list, channel: Channel) -> str: + config = get_config() + # Process command logic + return "Response message" + + def your_command_spec() -> dict: + return { + "name": "your_command", + "description": "Description of your command", + "usage": "/your_command [args]", + "channels": ["cli", "discord"] # Which channels support this + } + ``` + +2. **Register in command dispatcher**: + ```python + # app/commands/__init__.py + from .your_command import handle_your_command, your_command_spec + + COMMANDS = { + "your_command": { + "handler": handle_your_command, + "spec": your_command_spec(), + "channels": ["cli", "discord", "websocket"] + } + } + ``` + +3. **Update command parsing** in `app/agent.py` or dedicated command parser. + +## Tool System + +### Available Tools + +| Tool | Description | Usage | +|------|-------------|-------| +| `read_file` | Read file contents | `read_file(path="file.txt")` | +| `write_file` | Write to files | `write_file(path="file.txt", content="...")` | +| `bash` | Execute shell commands | `bash(command="ls -la")` | +| `web_fetch` | Fetch web content | `web_fetch(url="https://...")` | +| `get_skills_dir` | Locate skills | `get_skills_dir()` | +| `todo_add` | Add todo task | `todo_add(title="Task")` | +| `todo_list` | List todos | `todo_list()` | +| `todo_update` | Update todo status | `todo_update(task_id="1", status="done")` | +| `todo_clear` | Clear all todos | `todo_clear()` | + +### Creating New Tools + +1. **Create tool module**: + ```python + # app/tools/your_tool.py + def your_tool_spec() -> dict: + return { + "type": "function", + "function": { + "name": "your_tool", + "description": "Description of your tool", + "parameters": { + "type": "object", + "properties": { + "param1": { + "type": "string", + "description": "Parameter description" + } + }, + "required": ["param1"] + } + } + } + + async def your_tool(param1: str) -> str: + try: + # Tool implementation + return f"Success: {param1}" + except Exception as e: + return f"Error: {str(e)}" + ``` + +2. **Register in tool calls**: + ```python + # app/tool_calls.py + from app.tools.your_tool import your_tool_spec, your_tool + + async def run_tool(tool_name: str, arguments: dict): + if tool_name == "your_tool": + return await your_tool(**arguments) + # ... other tools + + def get_tool_specs(): + specs = [] + specs.append(your_tool_spec()) + # ... other tool specs + return specs + ``` + +## Skills System + +### Available Skills + +| Skill | Description | Location | +|-------|-------------|----------| +| **puppeteer** | Browser automation & web scraping | `app/skills/puppeteer/` | + +### Skill Structure + +``` +app/skills/{skill-name}/ +├── SKILL.md # Skill documentation and instructions +├── __init__.py # Skill implementation (optional) +└── examples/ # Usage examples (optional) +``` + +### Loading Skills + +Skills are loaded dynamically by the agent using the `get_skills_dir` tool and processed as context for the LLM. + +## Configuration + +### Configuration Files + +| File | Purpose | Format | +|------|---------|--------| +| `app/config.toml` | Agent settings | TOML | +| `.env` | API keys and secrets | Environment variables | +| `pyproject.toml` | Python project config | TOML | +| `codecrafters.yml` | CodeCrafters challenge config | YAML | + +### Configuration Structure + +```toml +# app/config.toml +[agent] +model = "deepseek/deepseek-v3.2" +max_iterations = 100 +max_tokens = 32768 + +[channels] +cli.enabled = true +discord.enabled = false +websocket.enabled = false +api.enabled = false + +[tools] +read_file.enabled = true +write_file.enabled = true +bash.enabled = true +web_fetch.enabled = true +``` + +## Extensibility Patterns + +### 1. Plugin Architecture + +``` +plugins/ +├── your_plugin/ +│ ├── __init__.py +│ ├── channel.py +│ ├── tools.py +│ └── config.toml +└── plugin_manager.py +``` + +### 2. Middleware System + +Middleware can intercept and modify messages: + +```python +class LoggingMiddleware: + async def pre_process(self, msg: IncomingMessage) -> IncomingMessage: + logger.info(f"Incoming: {msg.content}") + return msg + + async def post_process(self, msg: OutgoingMessage) -> OutgoingMessage: + logger.info(f"Outgoing: {msg.content}") + return msg +``` + +### 3. Event System + +```python +from app.events import EventBus + +event_bus = EventBus() +event_bus.subscribe("tool_called", log_tool_usage) +event_bus.publish("tool_called", {"tool": "read_file", "args": {...}}) +``` + +## Usage Examples + +### Starting the Agent + +```bash +# CLI mode +./run.sh -p "Your prompt" + +# With specific model +./run.sh -p "Your prompt" --model "anthropic/claude-3.5-sonnet" + +# Silent/automated mode +./run.sh -p "Create a file" --silent +``` + +### Command Examples + +``` +> /model +Current model: deepseek/deepseek-v3.2 +Provider: OpenRouter +Max tokens: 32768 + +> /tools +Available tools: +- read_file: Read file contents +- write_file: Write to files +- bash: Execute shell commands +- web_fetch: Fetch web content +- get_skills_dir: Locate skills directory +- todo_add: Add a todo task +- todo_list: List all tasks +- todo_update: Update task status +- todo_clear: Clear all todos + +> /help channels +Available channels: CLI +Planned channels: Discord, WebSocket, API +``` + +## Future Development + +### Planned Features + +1. **Multi-channel support** + - Discord bot integration + - WebSocket real-time interface + - REST API endpoints + +2. **Enhanced tooling** + - Database operations + - Git operations + - Docker/container management + - Cloud service integration + +3. **Advanced features** + - Multi-agent collaboration + - Long-term memory + - Knowledge graph integration + - Automated workflow creation + +4. **Monitoring & observability** + - Usage analytics + - Performance metrics + - Audit logging + - Health checks + +### Contribution Guidelines + +1. **Code Style**: Follow existing patterns and PEP 8 +2. **Testing**: Add tests for new features +3. **Documentation**: Update relevant docs +4. **Backwards Compatibility**: Maintain existing APIs +5. **Security**: Follow security best practices + +## Getting Help + +- **Issues**: GitHub Issues +- **Discussion**: GitHub Discussions +- **Documentation**: This file and README.md +- **Examples**: Check the `examples/` directory + +--- + +*Last updated: $(date -I)* \ No newline at end of file diff --git a/app/__init__.py b/app/__init__.py index e69de29..6e9eec0 100755 --- a/app/__init__.py +++ b/app/__init__.py @@ -0,0 +1,44 @@ +""" +crafterscode - AI agent with tool calling capabilities +""" + +__version__ = "0.1.0" + +from .agent import Agent +from .channel import Channel +from .message import IncomingMessage, OutgoingMessage +from .message_queue import MessageQueue +from .client import Client +from .config import load, get +from .tool_calls import run_tool, tool_registry +from .commands import ( + Command, + CommandRegistry, + CommandParser, + CommandDispatcher, + get_dispatcher, + get_registry, + is_command, + handle_command, +) + +__all__ = [ + "Agent", + "Channel", + "IncomingMessage", + "OutgoingMessage", + "MessageQueue", + "Client", + "load", + "get", + "run_tool", + "tool_registry", + "Command", + "CommandRegistry", + "CommandParser", + "CommandDispatcher", + "get_dispatcher", + "get_registry", + "is_command", + "handle_command", +] \ No newline at end of file diff --git a/app/agent.py b/app/agent.py index f8ff583..cb8790c 100755 --- a/app/agent.py +++ b/app/agent.py @@ -12,6 +12,8 @@ from app.message import OutgoingMessage, IncomingMessage from app.message_queue import MessageQueue from app.cli import ask_permission +from app.commands import is_command, handle_command + class Agent: @@ -31,7 +33,32 @@ def __init__(self, mq: MessageQueue = None, channel: Channel = Channel.CLI, max_ async def process_incoming(self) -> None: while True: msg = await self.mq.incoming.get() - await self.agent_loop(msg.content) + await self.process_message(msg.content) + + async def process_message(self, message: str) -> None: + """Process a message - check if it's a command or regular message.""" + # Check if this is a command + if is_command(message): + log.info(f"Processing command: {message[:50]}...") + try: + # Handle command + response = await handle_command(message, self.channel) + + # Send command response back to user + if self.mq: + await self.mq.outgoing_msg(OutgoingMessage(content=response, channel=self.channel)) + + return # Command handled, don't process as normal message + + except Exception as e: + error_msg = f"Error processing command: {str(e)}" + log.error(error_msg) + if self.mq: + await self.mq.outgoing_msg(OutgoingMessage(content=error_msg, channel=self.channel)) + return + + # Not a command, process as normal agent message + await self.agent_loop(message) async def agent_loop(self, message: str) -> None: diff --git a/app/commands.py b/app/commands.py new file mode 100644 index 0000000..3984bde --- /dev/null +++ b/app/commands.py @@ -0,0 +1,659 @@ +""" +Command parsing and dispatch system for crafterscode agents. + +This module provides a command system that allows users to execute +special commands starting with '/' across different channels. +""" + +from __future__ import annotations + +from typing import Callable, Dict, List, Optional, Tuple +from enum import Enum +import importlib +import inspect + +from app.channel import Channel +from app.config import get + + +class CommandCategory(str, Enum): + """Categories for organizing commands.""" + SYSTEM = "system" + TOOLS = "tools" + AGENT = "agent" + CONFIG = "config" + CHANNEL = "channel" + UTILITY = "utility" + + +class Command: + """Represents a command that can be executed.""" + + def __init__( + self, + name: str, + handler: Callable, + description: str, + usage: str, + aliases: List[str] = None, + category: CommandCategory = CommandCategory.UTILITY, + channels: List[Channel] = None, + requires_permission: bool = False, + ): + self.name = name + self.handler = handler + self.description = description + self.usage = usage + self.aliases = aliases or [] + self.category = category + self.channels = channels or [Channel.CLI] + self.requires_permission = requires_permission + + def __call__(self, *args, **kwargs): + return self.handler(*args, **kwargs) + + +class CommandRegistry: + """Registry for managing all available commands.""" + + def __init__(self): + self._commands: Dict[str, Command] = {} + self._aliases: Dict[str, str] = {} + + def register(self, command: Command) -> None: + """Register a new command.""" + self._commands[command.name] = command + + # Register aliases + for alias in command.aliases: + self._aliases[alias] = command.name + + def find(self, name: str) -> Optional[Command]: + """Find a command by name or alias.""" + # Check direct command name + if name in self._commands: + return self._commands[name] + + # Check aliases + if name in self._aliases: + actual_name = self._aliases[name] + return self._commands.get(actual_name) + + return None + + def get_all(self) -> List[Command]: + """Get all registered commands.""" + return list(self._commands.values()) + + def get_by_category(self, category: CommandCategory) -> List[Command]: + """Get commands by category.""" + return [cmd for cmd in self._commands.values() if cmd.category == category] + + def get_for_channel(self, channel: Channel) -> List[Command]: + """Get commands available for a specific channel.""" + return [cmd for cmd in self._commands.values() if channel in cmd.channels] + + +class CommandParser: + """Parses command strings and extracts arguments.""" + + @staticmethod + def parse(input_str: str) -> Tuple[str, List[str], Dict[str, str]]: + """ + Parse a command string. + + Returns: + Tuple of (command_name, positional_args, keyword_args) + + Example: + "/model show --verbose" -> ("model", ["show"], {"verbose": ""}) + "/help tools --detail true" -> ("help", ["tools"], {"detail": "true"}) + """ + if not input_str.startswith("/"): + raise ValueError("Command must start with '/'") + + # Remove leading slash + input_str = input_str[1:].strip() + + if not input_str: + return "", [], {} + + parts = [] + in_quotes = False + current_part = "" + + # Tokenize with quote handling + for char in input_str: + if char == '"' or char == "'": + in_quotes = not in_quotes + current_part += char + elif char == " " and not in_quotes: + if current_part: + parts.append(current_part) + current_part = "" + else: + current_part += char + + if current_part: + parts.append(current_part) + + if not parts: + return "", [], {} + + command_name = parts[0] + positional = [] + keyword = {} + + i = 1 + while i < len(parts): + arg = parts[i] + + if arg.startswith("--"): + # Keyword argument + key = arg[2:] + if i + 1 < len(parts) and not parts[i + 1].startswith("--"): + # Has a value + value = parts[i + 1] + # Remove quotes if present + if (value.startswith('"') and value.endswith('"')) or \ + (value.startswith("'") and value.endswith("'")): + value = value[1:-1] + keyword[key] = value + i += 2 + else: + # Boolean flag + keyword[key] = "" + i += 1 + else: + # Positional argument + positional.append(arg) + i += 1 + + return command_name, positional, keyword + + +class CommandDispatcher: + """Dispatches commands to their handlers.""" + + def __init__(self, registry: CommandRegistry): + self.registry = registry + + async def dispatch( + self, + command_input: str, + channel: Channel, + user_identity: Optional[str] = None, + ) -> str: + """ + Dispatch a command to its handler. + + Args: + command_input: The raw command string (including '/') + channel: The channel the command came from + user_identity: Optional user identity for permission checking + + Returns: + The response from the command handler + """ + try: + # Parse command + command_name, args, kwargs = CommandParser.parse(command_input) + + if not command_name: + return "Error: No command specified" + + # Find command + command = self.registry.find(command_name) + if not command: + return f"Error: Command '/{command_name}' not found. Use /help for available commands." + + # Check if command is available for this channel + if channel not in command.channels: + return f"Error: Command '/{command_name}' is not available in this channel." + + # Check permissions if required + if command.requires_permission and not self._check_permission(user_identity): + return "Error: You don't have permission to execute this command." + + # Execute command + try: + # Check if handler is async + if inspect.iscoroutinefunction(command.handler): + result = await command.handler(args, kwargs, channel, user_identity) + else: + result = command.handler(args, kwargs, channel, user_identity) + return result + except Exception as e: + return f"Error executing command '/{command_name}': {str(e)}" + + except Exception as e: + return f"Error parsing command: {str(e)}" + + def _check_permission(self, user_identity: Optional[str]) -> bool: + """Check if user has permission to execute commands.""" + # Simple permission check - can be enhanced with proper auth system + return True # Allow all for now + + +# Built-in command implementations + +async def handle_model(args: List[str], kwargs: Dict[str, str], channel: Channel, user_identity: Optional[str]) -> str: + """ + Handle the /model command. + + Usage: /model [show|set] [--verbose] + + Examples: + /model + /model show + /model show --verbose + """ + action = args[0] if args else "show" + verbose = "verbose" in kwargs + + model = get("model", "Not configured") + base_url = get("base_url", "Not configured") + max_tokens = get("max_tokens", "Not configured") + max_iterations = get("max_iterations", "Not configured") + + if action == "show": + if verbose: + return ( + f"📊 Model Configuration 📊\n" + f"├─ Model: {model}\n" + f"├─ Base URL: {base_url}\n" + f"├─ Max Tokens: {max_tokens}\n" + f"└─ Max Iterations: {max_iterations}" + ) + else: + return f"🤖 Current model: {model}" + + elif action == "set": + if len(args) < 2: + return "Usage: /model set " + + new_model = args[1] + # Note: In a real implementation, this would update the config + return f"⚠️ Model changing not implemented yet. Would change to: {new_model}" + + else: + return f"Error: Unknown action '{action}'. Use 'show' or 'set'." + + +async def handle_help(args: List[str], kwargs: Dict[str, str], channel: Channel, user_identity: Optional[str]) -> str: + """ + Handle the /help command. + + Usage: /help [command|category] + + Examples: + /help + /help model + /help tools + """ + if args: + # Show help for specific command or category + target = args[0] + + # Check if it's a category + try: + category = CommandCategory(target) + commands = _registry.get_by_category(category) + if commands: + lines = [f"📚 Commands in category '{category}':"] + for cmd in commands: + if channel in cmd.channels: + lines.append(f" /{cmd.name} - {cmd.description}") + return "\n".join(lines) + except ValueError: + # Not a category, check if it's a command + pass + + # Check if it's a command + command = _registry.find(target) + if command: + if channel not in command.channels: + return f"❌ Command '/{target}' is not available in this channel." + + response = [ + f"📋 Command: /{command.name}", + f"📝 Description: {command.description}", + f"📖 Usage: {command.usage}", + ] + + if command.aliases: + response.append(f"🔤 Aliases: {', '.join(f'/{alias}' for alias in command.aliases)}") + + if command.category: + response.append(f"📂 Category: {command.category}") + + return "\n".join(response) + + # Check if it's a channel name + try: + channel_enum = Channel(target) + commands = _registry.get_for_channel(channel_enum) + if commands: + lines = [f"📱 Commands available in channel '{channel_enum}':"] + for cmd in commands: + lines.append(f" /{cmd.name} - {cmd.description}") + return "\n\n".join(lines) + except ValueError: + pass + + return f"❌ No command, category, or channel named '{target}' found." + + # Show general help + lines = [ + "📚 Available Commands 📚", + "", + "Type /help for detailed help on a specific command.", + "Type /help to see commands in a category.", + "", + "📂 Categories:" + ] + + # List categories + for category in CommandCategory: + commands = _registry.get_by_category(category) + if any(channel in cmd.channels for cmd in commands): + channel_commands = [cmd for cmd in commands if channel in cmd.channels] + if channel_commands: + lines.append(f" {category.value}: {len(channel_commands)} commands") + + lines.extend([ + "", + "🔧 System Commands:", + " /help - Show this help message", + " /model - Show or change the current model", + " /config - Show or update configuration", + "", + "💡 Tip: Commands start with '/' and support arguments and flags (--flag value)." + ]) + + return "\n".join(lines) + + +async def handle_config(args: List[str], kwargs: Dict[str, str], channel: Channel, user_identity: Optional[str]) -> str: + """ + Handle the /config command. + + Usage: /config [show|get|set] [key] [value] [--verbose] + + Examples: + /config + /config show + /config get model + /config set model "anthropic/claude-3.5-sonnet" + """ + action = args[0] if args else "show" + verbose = "verbose" in kwargs + + # Get config directly + model = get("model", "Not configured") + base_url = get("base_url", "Not configured") + max_tokens = get("max_tokens", "Not configured") + max_iterations = get("max_iterations", "Not configured") + + config_dict = { + "model": model, + "base_url": base_url, + "max_tokens": max_tokens, + "max_iterations": max_iterations, + } + + if action == "show": + lines = ["🔧 Configuration:"] + for key, value in config_dict.items(): + lines.append(f" {key}: {value}") + return "\n".join(lines) + + elif action == "get": + if len(args) < 2: + return "Usage: /config get " + + key = args[1] + if key in config_dict: + return f"{key}: {config_dict[key]}" + else: + return f"❌ Configuration key '{key}' not found." + + elif action == "set": + if len(args) < 3: + return "Usage: /config set " + + key = args[1] + value = args[2] + # Note: In a real implementation, this would update the config + return f"⚠️ Configuration updating not implemented yet. Would set {key} = {value}" + + else: + return f"❌ Unknown action '{action}'. Use 'show', 'get', or 'set'." + + +async def handle_tools(args: List[str], kwargs: Dict[str, str], channel: Channel, user_identity: Optional[str]) -> str: + """ + Handle the /tools command. + + Usage: /tools [list|info] [tool_name] + + Examples: + /tools + /tools list + /tools info bash + """ + from app.tool_calls import tool_registry + + action = args[0] if args else "list" + + if action == "list": + tools = list(tool_registry.keys()) + lines = ["🛠️ Available Tools:"] + for tool_name in sorted(tools): + tool_info = tool_registry[tool_name] + description = tool_info["spec"]["function"]["description"][:50] + "..." + lines.append(f" {tool_name}: {description}") + return "\n".join(lines) + + elif action == "info": + if len(args) < 2: + return "Usage: /tools info " + + tool_name = args[1] + if tool_name not in tool_registry: + return f"❌ Tool '{tool_name}' not found." + + tool_info = tool_registry[tool_name]["spec"] + func = tool_info["function"] + + lines = [ + f"🛠️ Tool: {func['name']}", + f"📝 Description: {func['description']}", + ] + + if "parameters" in func: + params = func["parameters"]["properties"] + if params: + lines.append("📋 Parameters:") + for param_name, param_spec in params.items(): + required = param_name in func["parameters"].get("required", []) + req_mark = " (required)" if required else "" + param_type = param_spec.get("type", "any") + lines.append(f" {param_name}: {param_spec.get('description', 'No description')} [{param_type}]{req_mark}") + + return "\n".join(lines) + + else: + return f"❌ Unknown action '{action}'. Use 'list' or 'info'." + + +async def handle_skills(args: List[str], kwargs: Dict[str, str], channel: Channel, user_identity: Optional[str]) -> str: + """ + Handle the /skills command. + + Usage: /skills [list|info] [skill_name] + + Examples: + /skills + /skills list + /skills info puppeteer + """ + import os + + skills_dir = os.path.join(os.path.dirname(__file__), "skills") + + if not os.path.exists(skills_dir): + return "❌ Skills directory not found." + + skills = [] + for item in os.listdir(skills_dir): + skill_dir = os.path.join(skills_dir, item) + skill_md = os.path.join(skill_dir, "SKILL.md") + if os.path.isdir(skill_dir) and os.path.exists(skill_md): + skills.append(item) + + action = args[0] if args else "list" + + if action == "list": + if not skills: + return "❌ No skills available." + + lines = ["🧠 Available Skills:"] + for skill in sorted(skills): + lines.append(f" {skill}") + return "\n".join(lines) + + elif action == "info": + if len(args) < 2: + return "Usage: /skills info " + + skill_name = args[1] + skill_md = os.path.join(skills_dir, skill_name, "SKILL.md") + + if not os.path.exists(skill_md): + return f"❌ Skill '{skill_name}' not found." + + try: + with open(skill_md, "r") as f: + content = f.read() + + # Extract first few lines for summary + lines = content.strip().split("\n")[:10] + summary = "\n".join(lines) + + return ( + f"🧠 Skill: {skill_name}\n" + f"📄 Summary:\n{summary}\n" + f"\n📝 Full documentation available in: {skill_md}" + ) + except Exception as e: + return f"❌ Error reading skill: {str(e)}" + + else: + return f"❌ Unknown action '{action}'. Use 'list' or 'info'." + + +async def handle_quit(args: List[str], kwargs: Dict[str, str], channel: Channel, user_identity: Optional[str]) -> str: + """ + Handle the /quit command. + + Usage: /quit [--force] + + Example: + /quit + /quit --force + """ + force = "force" in kwargs + + if channel == Channel.CLI: + return "👋 Goodbye! Use Ctrl+C to exit." + else: + return "👋 Goodbye!" + + +# Initialize the registry +_registry = CommandRegistry() + +# Register built-in commands +_registry.register(Command( + name="help", + handler=handle_help, + description="Show help for commands", + usage="/help [command|category]", + aliases=["h", "?"], + category=CommandCategory.SYSTEM, + channels=list(Channel), # Available in all channels +)) + +_registry.register(Command( + name="model", + handler=handle_model, + description="Show or change the current AI model", + usage="/model [show|set] [--verbose]", + category=CommandCategory.SYSTEM, + channels=list(Channel), +)) + +_registry.register(Command( + name="config", + handler=handle_config, + description="Show or update configuration", + usage="/config [show|get|set] [key] [value] [--verbose]", + category=CommandCategory.CONFIG, + channels=list(Channel), +)) + +_registry.register(Command( + name="tools", + handler=handle_tools, + description="List available tools or show tool details", + usage="/tools [list|info] [tool_name]", + aliases=["tool"], + category=CommandCategory.TOOLS, + channels=list(Channel), +)) + +_registry.register(Command( + name="skills", + handler=handle_skills, + description="List available skills or show skill details", + usage="/skills [list|info] [skill_name]", + aliases=["skill"], + category=CommandCategory.TOOLS, + channels=list(Channel), +)) + +_registry.register(Command( + name="quit", + handler=handle_quit, + description="Quit the agent", + usage="/quit [--force]", + aliases=["exit", "q"], + category=CommandCategory.SYSTEM, + channels=[Channel.CLI], # Only in CLI for now +)) + +# Create dispatcher +dispatcher = CommandDispatcher(_registry) + + +# Utility functions for external use +def get_dispatcher() -> CommandDispatcher: + """Get the command dispatcher instance.""" + return dispatcher + +def get_registry() -> CommandRegistry: + """Get the command registry instance.""" + return _registry + +def is_command(input_str: str) -> bool: + """Check if input string is a command.""" + return input_str.strip().startswith("/") if input_str else False + +async def handle_command(input_str: str, channel: Channel = Channel.CLI, user_identity: Optional[str] = None) -> str: + """ + Handle a command input. + + This is the main entry point for command processing. + """ + return await dispatcher.dispatch(input_str, channel, user_identity) \ No newline at end of file diff --git a/config.toml b/config.toml new file mode 100755 index 0000000..8f6e4fa --- /dev/null +++ b/config.toml @@ -0,0 +1,4 @@ +model = "deepseek/deepseek-v3.2" +base_url = "https://openrouter.ai/api/v1" +max_iterations = 100 +max_tokens = 32768 diff --git a/demo_commands.md b/demo_commands.md new file mode 100644 index 0000000..8d55452 --- /dev/null +++ b/demo_commands.md @@ -0,0 +1,346 @@ +# Command System Demo + +## Overview + +The crafterscode agent now has a comprehensive command system that allows users to interact with the agent using special commands starting with `/`. This system is designed to be extensible and reusable across different channels. + +## Available Commands + +### 1. `/model` - Model Configuration +**Description**: Show or change the current AI model + +**Usage**: +``` +/model [show|set] [--verbose] +``` + +**Examples**: +- `/model` - Show current model +- `/model show` - Show current model (explicit) +- `/model show --verbose` - Show detailed model configuration +- `/model set "anthropic/claude-3.5-sonnet"` - Change model (implementation pending) + +**Sample Output**: +``` +🤖 Current model: deepseek/deepseek-v3.2 +``` + +With verbose flag: +``` +📊 Model Configuration 📊 +├─ Model: deepseek/deepseek-v3.2 +├─ Base URL: https://openrouter.ai/api/v1 +├─ Max Tokens: 32768 +└─ Max Iterations: 200 +``` + +### 2. `/help` - Help System +**Description**: Show help for commands + +**Usage**: +``` +/help [command|category] +``` + +**Examples**: +- `/help` - Show general help +- `/help model` - Show help for /model command +- `/help tools` - Show tools category commands +- `/help system` - Show system category commands + +### 3. `/config` - Configuration Management +**Description**: Show or update configuration + +**Usage**: +``` +/config [show|get|set] [key] [value] [--verbose] +``` + +**Examples**: +- `/config` - Show all configuration +- `/config get model` - Get specific config value +- `/config set model "anthropic/claude-3.5-sonnet"` - Set config value (implementation pending) + +### 4. `/tools` - Tool Management +**Description**: List available tools or show tool details + +**Usage**: +``` +/tools [list|info] [tool_name] +``` + +**Examples**: +- `/tools` - List available tools +- `/tools list` - List available tools (explicit) +- `/tools info bash` - Show detailed info about bash tool + +### 5. `/skills` - Skill Management +**Description**: List available skills or show skill details + +**Usage**: +``` +/skills [list|info] [skill_name] +``` + +**Examples**: +- `/skills` - List available skills +- `/skills info puppeteer` - Show details about puppeteer skill + +### 6. `/quit` - Exit Agent +**Description**: Quit the agent + +**Usage**: +``` +/quit [--force] +``` + +**Examples**: +- `/quit` - Gracefully quit +- `/quit --force` - Force quit + +## Command Syntax + +### Basic Structure +``` +/command [argument1] [argument2]... [--option value] [--flag] +``` + +### Features: +1. **Positional Arguments**: Space-separated values + - `/help model` + - `/tools info bash` + +2. **Keyword Arguments**: Options with `--` + - `/model show --verbose` + - `/config set model "value" --dry-run` + +3. **Boolean Flags**: Options without values + - `/quit --force` + - `/model --verbose` + +4. **Quoted Values**: Support for spaces in values + - `/model set "anthropic/claude-3.5-sonnet"` + +## Architecture + +### Command System Components + +``` +┌─────────────────────────────────────────────────────┐ +│ Command Input │ +│ (e.g., "/model show --verbose") │ +└────────────────────────┬────────────────────────────┘ + │ + ▼ +┌─────────────────────────────────────────────────────┐ +│ Command Parser │ +│ • Validates syntax │ +│ • Extracts arguments/options │ +│ • Handles quotes and escaping │ +└────────────────────────┬────────────────────────────┘ + │ + ▼ +┌─────────────────────────────────────────────────────┐ +│ Command Dispatcher │ +│ • Looks up command in registry │ +│ • Validates channel permissions │ +│ • Executes command handler │ +└────────────────────────┬────────────────────────────┘ + │ + ▼ +┌─────────────────────────────────────────────────────┐ +│ Command Handler │ +│ • Executes command logic │ +│ • Returns formatted response │ +└─────────────────────────────────────────────────────┘ +``` + +### Command Registry + +Commands are registered in a central registry with metadata: +- **Name**: Primary command name +- **Aliases**: Alternative names (e.g., `h` for `help`) +- **Description**: Brief description +- **Usage**: Syntax examples +- **Category**: Organization category (system, tools, config, etc.) +- **Channels**: Which channels support this command +- **Permissions**: Required permissions (if any) + +### Extensibility + +#### Adding New Commands + +1. **Create command handler**: +```python +async def handle_your_command(args, kwargs, channel, user_identity): + # Command logic here + return "Response message" +``` + +2. **Register command**: +```python +_registry.register(Command( + name="yourcommand", + handler=handle_your_command, + description="Description of your command", + usage="/yourcommand [args] [--options]", + category=CommandCategory.YOUR_CATEGORY, + channels=[Channel.CLI, Channel.DISCORD], +)) +``` + +#### Adding New Categories + +1. **Extend CommandCategory enum**: +```python +class CommandCategory(str, Enum): + # ... existing categories + YOUR_CATEGORY = "your_category" +``` + +## Usage Examples + +### Interactive Session +``` +> /help +📚 Available Commands 📚 + +Type /help for detailed help on a specific command. +Type /help to see commands in a category. + +📂 Categories: + system: 3 commands + tools: 2 commands + config: 1 commands + +🔧 System Commands: + /help - Show this help message + /model - Show or change the current model + /config - Show or update configuration + +💡 Tip: Commands start with '/' and support arguments and flags (--flag value). + +> /model +🤖 Current model: deepseek/deepseek-v3.2 + +> /model show --verbose +📊 Model Configuration 📊 +├─ Model: deepseek/deepseek-v3.2 +├─ Base URL: https://openrouter.ai/api/v1 +├─ Max Tokens: 32768 +└─ Max Iterations: 200 + +> /tools +🛠️ Available Tools: + bash: Execute shell commands... + get_skills_dir: Get the path to the skills directory... + read_file: Read and return the contents of a file... + todo_add: Add a new task to the todo list... + todo_clear: Todos are done, clear all todos... + todo_list: List all tasks and their statuses... + todo_update: Update the status of a task... + web_fetch: Fetch and return the contents of a web page... + write_file: Write content to a file... + +> /skills +🧠 Available Skills: + puppeteer + +> /quit +👋 Goodbye! Use Ctrl+C to exit. +``` + +### Channel Support + +The command system is designed to work across multiple channels: + +1. **CLI**: Fully supported (current implementation) +2. **Discord**: Planned (commands like `/model` would work in Discord) +3. **WebSocket**: Planned +4. **API**: Planned (REST endpoints for commands) + +Each command specifies which channels it supports. + +## Implementation Details + +### File Structure +``` +app/ +├── commands.py # Command system implementation +├── agent.py # Updated to handle commands +├── __init__.py # Exports command system +└── config.py # Configuration access +``` + +### Key Changes + +1. **Agent Integration**: + - `agent.py` now checks if input is a command + - Commands bypass normal LLM processing + - Command responses are sent directly to user + +2. **Command System**: + - Central registry for all commands + - Parser for command syntax + - Dispatcher for command execution + - Extensible architecture + +3. **Reusability**: + - Commands work across channels + - Easy to add new commands + - Consistent API for all commands + +## Testing + +### Manual Testing +```bash +# Run the agent +./run.sh -p "Hello" + +# In the REPL, try commands: +> /model +> /help +> /tools +> /skills +> /quit +``` + +### Automated Tests +```python +# Unit tests for command parsing +python3 test_commands_simple.py + +# Integration tests +python3 test_integration.py +``` + +## Future Improvements + +### Planned Features +1. **Command Aliases**: Short forms (e.g., `/m` for `/model`) +2. **Tab Completion**: For commands and arguments +3. **Command History**: Navigate previous commands +4. **Permissions System**: Role-based access control +5. **Plugin System**: Load commands from external modules +6. **Web Interface**: GUI for command execution +7. **Command Scripting**: Batch execution of commands +8. **Audit Logging**: Track all command executions + +### Additional Commands +- `/history` - Show interaction history +- `/status` - Show agent status +- `/memory` - Manage conversation memory +- `/plugins` - Manage plugins +- `/channels` - Manage communication channels +- `/users` - User management (for multi-user environments) + +## Conclusion + +The command system provides a powerful, extensible way to interact with the crafterscode agent. The `/model` command demonstrates the system's capabilities, showing how users can query and potentially modify the AI model configuration. The system is designed to be reusable across different communication channels, making it a foundation for future expansion. + +The implementation follows clean architecture principles, with clear separation between parsing, dispatching, and execution. This makes it easy to add new commands, support new channels, and extend functionality as needed. + +--- + +*Last updated: $(date -I)* +*See also: `agents.md` for architecture documentation* \ No newline at end of file From a32d64e9db178ad3095b34f4a881afec59991c05 Mon Sep 17 00:00:00 2001 From: "rikulpatel@gmail.com" Date: Sat, 25 Apr 2026 22:06:50 -0500 Subject: [PATCH 03/84] remove unused file --- agents.md | 399 ------------------------------------------------------ 1 file changed, 399 deletions(-) delete mode 100644 agents.md diff --git a/agents.md b/agents.md deleted file mode 100644 index b780452..0000000 --- a/agents.md +++ /dev/null @@ -1,399 +0,0 @@ -# Agents System - crafterscode - -## Overview - -The crafterscode agents system is a modular, extensible framework for building AI agents with tool-calling capabilities. This document describes the architecture, components, and extensibility patterns for the system. - -## Architecture - -### Core Components - -``` -┌─────────────────────────────────────────────┐ -│ Message Queue │ -│ (app/message_queue.py) │ -│ • Asynchronous message routing │ -│ • Channel-based delivery │ -│ • Thread-safe operations │ -└───────────────┬─────────────────────────────┘ - │ - ┌─────────┴─────────┐ - ▼ ▼ -┌─────────────┐ ┌─────────────┐ -│ Channel │ │ Agent │ -│ (app/channel.py) (app/agent.py) │ -│ • CLI │ │ • LLM orchestration │ -│ • Discord │ │ • Tool calling │ -│ • WebSocket│ │ • Iteration control │ -│ • API │ └─────────────┘ -└─────────────┘ -``` - -### Message Flow - -1. **Incoming**: User input → Channel → Message Queue → Agent -2. **Outgoing**: Agent → Tool calls → Message Queue → Channel → User -3. **Tool Responses**: Tool execution → Message Queue → Agent → Response formatting → Channel - -## Channel System - -### Available Channels - -| Channel | Description | Implementation | -|---------|-------------|----------------| -| **CLI** | Command-line interface | `app/cli.py` | -| **Discord** | Discord bot (planned) | (Future implementation) | -| **WebSocket** | Real-time web interface | (Future implementation) | -| **API** | REST/GraphQL endpoints | (Future implementation) | - -### Creating New Channels - -To add a new channel: - -1. **Extend `Channel` enum** in `app/channel.py`: - ```python - from enum import Enum - class Channel(str, Enum): - CLI = "cli" - DISCORD = "discord" - WEBSOCKET = "websocket" - API = "api" - YOUR_CHANNEL = "your_channel" - ``` - -2. **Create channel implementation**: - ```python - # app/channels/your_channel.py - from app.channel import Channel - from app.message_queue import MessageQueue - from app.message import IncomingMessage, OutgoingMessage - - class YourChannel: - def __init__(self, queue: MessageQueue, config: dict): - self.queue = queue - self.config = config - queue.register(Channel.YOUR_CHANNEL, self.deliver) - - async def deliver(self, msg: OutgoingMessage): - # Send message to your channel - pass - - async def start(self): - # Start listening for messages - pass - ``` - -3. **Register in main application**: - ```python - # app/main.py or app/__init__.py - from app.channels.your_channel import YourChannel - your_channel = YourChannel(message_queue, config) - ``` - -## Command System - -### Built-in Commands - -| Command | Description | Channel Support | -|---------|-------------|-----------------| -| `/help` | Show help information | All channels | -| `/model` | Show current model info | All channels | -| `/tools` | List available tools | All channels | -| `/skills` | List available skills | All channels | -| `/config` | Show configuration | All channels | -| `/quit` | Exit the agent | CLI only | - -### Command Structure - -Commands follow a consistent pattern: - -``` -/ [argument1] [argument2]... [--option value] -``` - -Examples: -- `/model` -- `/help tools` -- `/config show --verbose` - -### Adding New Commands - -1. **Define command handler**: - ```python - # app/commands/your_command.py - from app.message import IncomingMessage, OutgoingMessage - from app.config import get_config - - async def handle_your_command(args: list, channel: Channel) -> str: - config = get_config() - # Process command logic - return "Response message" - - def your_command_spec() -> dict: - return { - "name": "your_command", - "description": "Description of your command", - "usage": "/your_command [args]", - "channels": ["cli", "discord"] # Which channels support this - } - ``` - -2. **Register in command dispatcher**: - ```python - # app/commands/__init__.py - from .your_command import handle_your_command, your_command_spec - - COMMANDS = { - "your_command": { - "handler": handle_your_command, - "spec": your_command_spec(), - "channels": ["cli", "discord", "websocket"] - } - } - ``` - -3. **Update command parsing** in `app/agent.py` or dedicated command parser. - -## Tool System - -### Available Tools - -| Tool | Description | Usage | -|------|-------------|-------| -| `read_file` | Read file contents | `read_file(path="file.txt")` | -| `write_file` | Write to files | `write_file(path="file.txt", content="...")` | -| `bash` | Execute shell commands | `bash(command="ls -la")` | -| `web_fetch` | Fetch web content | `web_fetch(url="https://...")` | -| `get_skills_dir` | Locate skills | `get_skills_dir()` | -| `todo_add` | Add todo task | `todo_add(title="Task")` | -| `todo_list` | List todos | `todo_list()` | -| `todo_update` | Update todo status | `todo_update(task_id="1", status="done")` | -| `todo_clear` | Clear all todos | `todo_clear()` | - -### Creating New Tools - -1. **Create tool module**: - ```python - # app/tools/your_tool.py - def your_tool_spec() -> dict: - return { - "type": "function", - "function": { - "name": "your_tool", - "description": "Description of your tool", - "parameters": { - "type": "object", - "properties": { - "param1": { - "type": "string", - "description": "Parameter description" - } - }, - "required": ["param1"] - } - } - } - - async def your_tool(param1: str) -> str: - try: - # Tool implementation - return f"Success: {param1}" - except Exception as e: - return f"Error: {str(e)}" - ``` - -2. **Register in tool calls**: - ```python - # app/tool_calls.py - from app.tools.your_tool import your_tool_spec, your_tool - - async def run_tool(tool_name: str, arguments: dict): - if tool_name == "your_tool": - return await your_tool(**arguments) - # ... other tools - - def get_tool_specs(): - specs = [] - specs.append(your_tool_spec()) - # ... other tool specs - return specs - ``` - -## Skills System - -### Available Skills - -| Skill | Description | Location | -|-------|-------------|----------| -| **puppeteer** | Browser automation & web scraping | `app/skills/puppeteer/` | - -### Skill Structure - -``` -app/skills/{skill-name}/ -├── SKILL.md # Skill documentation and instructions -├── __init__.py # Skill implementation (optional) -└── examples/ # Usage examples (optional) -``` - -### Loading Skills - -Skills are loaded dynamically by the agent using the `get_skills_dir` tool and processed as context for the LLM. - -## Configuration - -### Configuration Files - -| File | Purpose | Format | -|------|---------|--------| -| `app/config.toml` | Agent settings | TOML | -| `.env` | API keys and secrets | Environment variables | -| `pyproject.toml` | Python project config | TOML | -| `codecrafters.yml` | CodeCrafters challenge config | YAML | - -### Configuration Structure - -```toml -# app/config.toml -[agent] -model = "deepseek/deepseek-v3.2" -max_iterations = 100 -max_tokens = 32768 - -[channels] -cli.enabled = true -discord.enabled = false -websocket.enabled = false -api.enabled = false - -[tools] -read_file.enabled = true -write_file.enabled = true -bash.enabled = true -web_fetch.enabled = true -``` - -## Extensibility Patterns - -### 1. Plugin Architecture - -``` -plugins/ -├── your_plugin/ -│ ├── __init__.py -│ ├── channel.py -│ ├── tools.py -│ └── config.toml -└── plugin_manager.py -``` - -### 2. Middleware System - -Middleware can intercept and modify messages: - -```python -class LoggingMiddleware: - async def pre_process(self, msg: IncomingMessage) -> IncomingMessage: - logger.info(f"Incoming: {msg.content}") - return msg - - async def post_process(self, msg: OutgoingMessage) -> OutgoingMessage: - logger.info(f"Outgoing: {msg.content}") - return msg -``` - -### 3. Event System - -```python -from app.events import EventBus - -event_bus = EventBus() -event_bus.subscribe("tool_called", log_tool_usage) -event_bus.publish("tool_called", {"tool": "read_file", "args": {...}}) -``` - -## Usage Examples - -### Starting the Agent - -```bash -# CLI mode -./run.sh -p "Your prompt" - -# With specific model -./run.sh -p "Your prompt" --model "anthropic/claude-3.5-sonnet" - -# Silent/automated mode -./run.sh -p "Create a file" --silent -``` - -### Command Examples - -``` -> /model -Current model: deepseek/deepseek-v3.2 -Provider: OpenRouter -Max tokens: 32768 - -> /tools -Available tools: -- read_file: Read file contents -- write_file: Write to files -- bash: Execute shell commands -- web_fetch: Fetch web content -- get_skills_dir: Locate skills directory -- todo_add: Add a todo task -- todo_list: List all tasks -- todo_update: Update task status -- todo_clear: Clear all todos - -> /help channels -Available channels: CLI -Planned channels: Discord, WebSocket, API -``` - -## Future Development - -### Planned Features - -1. **Multi-channel support** - - Discord bot integration - - WebSocket real-time interface - - REST API endpoints - -2. **Enhanced tooling** - - Database operations - - Git operations - - Docker/container management - - Cloud service integration - -3. **Advanced features** - - Multi-agent collaboration - - Long-term memory - - Knowledge graph integration - - Automated workflow creation - -4. **Monitoring & observability** - - Usage analytics - - Performance metrics - - Audit logging - - Health checks - -### Contribution Guidelines - -1. **Code Style**: Follow existing patterns and PEP 8 -2. **Testing**: Add tests for new features -3. **Documentation**: Update relevant docs -4. **Backwards Compatibility**: Maintain existing APIs -5. **Security**: Follow security best practices - -## Getting Help - -- **Issues**: GitHub Issues -- **Discussion**: GitHub Discussions -- **Documentation**: This file and README.md -- **Examples**: Check the `examples/` directory - ---- - -*Last updated: $(date -I)* \ No newline at end of file From ee6e8a955fb172df33dbbba387b72b861dd59151 Mon Sep 17 00:00:00 2001 From: "rikulpatel@gmail.com" Date: Sat, 25 Apr 2026 22:10:06 -0500 Subject: [PATCH 04/84] refactor: remove unused --- app/__init__.py | 44 ---- app/commands.py | 659 ----------------------------------------------- demo_commands.md | 346 ------------------------- 3 files changed, 1049 deletions(-) delete mode 100755 app/__init__.py delete mode 100644 app/commands.py delete mode 100644 demo_commands.md diff --git a/app/__init__.py b/app/__init__.py deleted file mode 100755 index 6e9eec0..0000000 --- a/app/__init__.py +++ /dev/null @@ -1,44 +0,0 @@ -""" -crafterscode - AI agent with tool calling capabilities -""" - -__version__ = "0.1.0" - -from .agent import Agent -from .channel import Channel -from .message import IncomingMessage, OutgoingMessage -from .message_queue import MessageQueue -from .client import Client -from .config import load, get -from .tool_calls import run_tool, tool_registry -from .commands import ( - Command, - CommandRegistry, - CommandParser, - CommandDispatcher, - get_dispatcher, - get_registry, - is_command, - handle_command, -) - -__all__ = [ - "Agent", - "Channel", - "IncomingMessage", - "OutgoingMessage", - "MessageQueue", - "Client", - "load", - "get", - "run_tool", - "tool_registry", - "Command", - "CommandRegistry", - "CommandParser", - "CommandDispatcher", - "get_dispatcher", - "get_registry", - "is_command", - "handle_command", -] \ No newline at end of file diff --git a/app/commands.py b/app/commands.py deleted file mode 100644 index 3984bde..0000000 --- a/app/commands.py +++ /dev/null @@ -1,659 +0,0 @@ -""" -Command parsing and dispatch system for crafterscode agents. - -This module provides a command system that allows users to execute -special commands starting with '/' across different channels. -""" - -from __future__ import annotations - -from typing import Callable, Dict, List, Optional, Tuple -from enum import Enum -import importlib -import inspect - -from app.channel import Channel -from app.config import get - - -class CommandCategory(str, Enum): - """Categories for organizing commands.""" - SYSTEM = "system" - TOOLS = "tools" - AGENT = "agent" - CONFIG = "config" - CHANNEL = "channel" - UTILITY = "utility" - - -class Command: - """Represents a command that can be executed.""" - - def __init__( - self, - name: str, - handler: Callable, - description: str, - usage: str, - aliases: List[str] = None, - category: CommandCategory = CommandCategory.UTILITY, - channels: List[Channel] = None, - requires_permission: bool = False, - ): - self.name = name - self.handler = handler - self.description = description - self.usage = usage - self.aliases = aliases or [] - self.category = category - self.channels = channels or [Channel.CLI] - self.requires_permission = requires_permission - - def __call__(self, *args, **kwargs): - return self.handler(*args, **kwargs) - - -class CommandRegistry: - """Registry for managing all available commands.""" - - def __init__(self): - self._commands: Dict[str, Command] = {} - self._aliases: Dict[str, str] = {} - - def register(self, command: Command) -> None: - """Register a new command.""" - self._commands[command.name] = command - - # Register aliases - for alias in command.aliases: - self._aliases[alias] = command.name - - def find(self, name: str) -> Optional[Command]: - """Find a command by name or alias.""" - # Check direct command name - if name in self._commands: - return self._commands[name] - - # Check aliases - if name in self._aliases: - actual_name = self._aliases[name] - return self._commands.get(actual_name) - - return None - - def get_all(self) -> List[Command]: - """Get all registered commands.""" - return list(self._commands.values()) - - def get_by_category(self, category: CommandCategory) -> List[Command]: - """Get commands by category.""" - return [cmd for cmd in self._commands.values() if cmd.category == category] - - def get_for_channel(self, channel: Channel) -> List[Command]: - """Get commands available for a specific channel.""" - return [cmd for cmd in self._commands.values() if channel in cmd.channels] - - -class CommandParser: - """Parses command strings and extracts arguments.""" - - @staticmethod - def parse(input_str: str) -> Tuple[str, List[str], Dict[str, str]]: - """ - Parse a command string. - - Returns: - Tuple of (command_name, positional_args, keyword_args) - - Example: - "/model show --verbose" -> ("model", ["show"], {"verbose": ""}) - "/help tools --detail true" -> ("help", ["tools"], {"detail": "true"}) - """ - if not input_str.startswith("/"): - raise ValueError("Command must start with '/'") - - # Remove leading slash - input_str = input_str[1:].strip() - - if not input_str: - return "", [], {} - - parts = [] - in_quotes = False - current_part = "" - - # Tokenize with quote handling - for char in input_str: - if char == '"' or char == "'": - in_quotes = not in_quotes - current_part += char - elif char == " " and not in_quotes: - if current_part: - parts.append(current_part) - current_part = "" - else: - current_part += char - - if current_part: - parts.append(current_part) - - if not parts: - return "", [], {} - - command_name = parts[0] - positional = [] - keyword = {} - - i = 1 - while i < len(parts): - arg = parts[i] - - if arg.startswith("--"): - # Keyword argument - key = arg[2:] - if i + 1 < len(parts) and not parts[i + 1].startswith("--"): - # Has a value - value = parts[i + 1] - # Remove quotes if present - if (value.startswith('"') and value.endswith('"')) or \ - (value.startswith("'") and value.endswith("'")): - value = value[1:-1] - keyword[key] = value - i += 2 - else: - # Boolean flag - keyword[key] = "" - i += 1 - else: - # Positional argument - positional.append(arg) - i += 1 - - return command_name, positional, keyword - - -class CommandDispatcher: - """Dispatches commands to their handlers.""" - - def __init__(self, registry: CommandRegistry): - self.registry = registry - - async def dispatch( - self, - command_input: str, - channel: Channel, - user_identity: Optional[str] = None, - ) -> str: - """ - Dispatch a command to its handler. - - Args: - command_input: The raw command string (including '/') - channel: The channel the command came from - user_identity: Optional user identity for permission checking - - Returns: - The response from the command handler - """ - try: - # Parse command - command_name, args, kwargs = CommandParser.parse(command_input) - - if not command_name: - return "Error: No command specified" - - # Find command - command = self.registry.find(command_name) - if not command: - return f"Error: Command '/{command_name}' not found. Use /help for available commands." - - # Check if command is available for this channel - if channel not in command.channels: - return f"Error: Command '/{command_name}' is not available in this channel." - - # Check permissions if required - if command.requires_permission and not self._check_permission(user_identity): - return "Error: You don't have permission to execute this command." - - # Execute command - try: - # Check if handler is async - if inspect.iscoroutinefunction(command.handler): - result = await command.handler(args, kwargs, channel, user_identity) - else: - result = command.handler(args, kwargs, channel, user_identity) - return result - except Exception as e: - return f"Error executing command '/{command_name}': {str(e)}" - - except Exception as e: - return f"Error parsing command: {str(e)}" - - def _check_permission(self, user_identity: Optional[str]) -> bool: - """Check if user has permission to execute commands.""" - # Simple permission check - can be enhanced with proper auth system - return True # Allow all for now - - -# Built-in command implementations - -async def handle_model(args: List[str], kwargs: Dict[str, str], channel: Channel, user_identity: Optional[str]) -> str: - """ - Handle the /model command. - - Usage: /model [show|set] [--verbose] - - Examples: - /model - /model show - /model show --verbose - """ - action = args[0] if args else "show" - verbose = "verbose" in kwargs - - model = get("model", "Not configured") - base_url = get("base_url", "Not configured") - max_tokens = get("max_tokens", "Not configured") - max_iterations = get("max_iterations", "Not configured") - - if action == "show": - if verbose: - return ( - f"📊 Model Configuration 📊\n" - f"├─ Model: {model}\n" - f"├─ Base URL: {base_url}\n" - f"├─ Max Tokens: {max_tokens}\n" - f"└─ Max Iterations: {max_iterations}" - ) - else: - return f"🤖 Current model: {model}" - - elif action == "set": - if len(args) < 2: - return "Usage: /model set " - - new_model = args[1] - # Note: In a real implementation, this would update the config - return f"⚠️ Model changing not implemented yet. Would change to: {new_model}" - - else: - return f"Error: Unknown action '{action}'. Use 'show' or 'set'." - - -async def handle_help(args: List[str], kwargs: Dict[str, str], channel: Channel, user_identity: Optional[str]) -> str: - """ - Handle the /help command. - - Usage: /help [command|category] - - Examples: - /help - /help model - /help tools - """ - if args: - # Show help for specific command or category - target = args[0] - - # Check if it's a category - try: - category = CommandCategory(target) - commands = _registry.get_by_category(category) - if commands: - lines = [f"📚 Commands in category '{category}':"] - for cmd in commands: - if channel in cmd.channels: - lines.append(f" /{cmd.name} - {cmd.description}") - return "\n".join(lines) - except ValueError: - # Not a category, check if it's a command - pass - - # Check if it's a command - command = _registry.find(target) - if command: - if channel not in command.channels: - return f"❌ Command '/{target}' is not available in this channel." - - response = [ - f"📋 Command: /{command.name}", - f"📝 Description: {command.description}", - f"📖 Usage: {command.usage}", - ] - - if command.aliases: - response.append(f"🔤 Aliases: {', '.join(f'/{alias}' for alias in command.aliases)}") - - if command.category: - response.append(f"📂 Category: {command.category}") - - return "\n".join(response) - - # Check if it's a channel name - try: - channel_enum = Channel(target) - commands = _registry.get_for_channel(channel_enum) - if commands: - lines = [f"📱 Commands available in channel '{channel_enum}':"] - for cmd in commands: - lines.append(f" /{cmd.name} - {cmd.description}") - return "\n\n".join(lines) - except ValueError: - pass - - return f"❌ No command, category, or channel named '{target}' found." - - # Show general help - lines = [ - "📚 Available Commands 📚", - "", - "Type /help for detailed help on a specific command.", - "Type /help to see commands in a category.", - "", - "📂 Categories:" - ] - - # List categories - for category in CommandCategory: - commands = _registry.get_by_category(category) - if any(channel in cmd.channels for cmd in commands): - channel_commands = [cmd for cmd in commands if channel in cmd.channels] - if channel_commands: - lines.append(f" {category.value}: {len(channel_commands)} commands") - - lines.extend([ - "", - "🔧 System Commands:", - " /help - Show this help message", - " /model - Show or change the current model", - " /config - Show or update configuration", - "", - "💡 Tip: Commands start with '/' and support arguments and flags (--flag value)." - ]) - - return "\n".join(lines) - - -async def handle_config(args: List[str], kwargs: Dict[str, str], channel: Channel, user_identity: Optional[str]) -> str: - """ - Handle the /config command. - - Usage: /config [show|get|set] [key] [value] [--verbose] - - Examples: - /config - /config show - /config get model - /config set model "anthropic/claude-3.5-sonnet" - """ - action = args[0] if args else "show" - verbose = "verbose" in kwargs - - # Get config directly - model = get("model", "Not configured") - base_url = get("base_url", "Not configured") - max_tokens = get("max_tokens", "Not configured") - max_iterations = get("max_iterations", "Not configured") - - config_dict = { - "model": model, - "base_url": base_url, - "max_tokens": max_tokens, - "max_iterations": max_iterations, - } - - if action == "show": - lines = ["🔧 Configuration:"] - for key, value in config_dict.items(): - lines.append(f" {key}: {value}") - return "\n".join(lines) - - elif action == "get": - if len(args) < 2: - return "Usage: /config get " - - key = args[1] - if key in config_dict: - return f"{key}: {config_dict[key]}" - else: - return f"❌ Configuration key '{key}' not found." - - elif action == "set": - if len(args) < 3: - return "Usage: /config set " - - key = args[1] - value = args[2] - # Note: In a real implementation, this would update the config - return f"⚠️ Configuration updating not implemented yet. Would set {key} = {value}" - - else: - return f"❌ Unknown action '{action}'. Use 'show', 'get', or 'set'." - - -async def handle_tools(args: List[str], kwargs: Dict[str, str], channel: Channel, user_identity: Optional[str]) -> str: - """ - Handle the /tools command. - - Usage: /tools [list|info] [tool_name] - - Examples: - /tools - /tools list - /tools info bash - """ - from app.tool_calls import tool_registry - - action = args[0] if args else "list" - - if action == "list": - tools = list(tool_registry.keys()) - lines = ["🛠️ Available Tools:"] - for tool_name in sorted(tools): - tool_info = tool_registry[tool_name] - description = tool_info["spec"]["function"]["description"][:50] + "..." - lines.append(f" {tool_name}: {description}") - return "\n".join(lines) - - elif action == "info": - if len(args) < 2: - return "Usage: /tools info " - - tool_name = args[1] - if tool_name not in tool_registry: - return f"❌ Tool '{tool_name}' not found." - - tool_info = tool_registry[tool_name]["spec"] - func = tool_info["function"] - - lines = [ - f"🛠️ Tool: {func['name']}", - f"📝 Description: {func['description']}", - ] - - if "parameters" in func: - params = func["parameters"]["properties"] - if params: - lines.append("📋 Parameters:") - for param_name, param_spec in params.items(): - required = param_name in func["parameters"].get("required", []) - req_mark = " (required)" if required else "" - param_type = param_spec.get("type", "any") - lines.append(f" {param_name}: {param_spec.get('description', 'No description')} [{param_type}]{req_mark}") - - return "\n".join(lines) - - else: - return f"❌ Unknown action '{action}'. Use 'list' or 'info'." - - -async def handle_skills(args: List[str], kwargs: Dict[str, str], channel: Channel, user_identity: Optional[str]) -> str: - """ - Handle the /skills command. - - Usage: /skills [list|info] [skill_name] - - Examples: - /skills - /skills list - /skills info puppeteer - """ - import os - - skills_dir = os.path.join(os.path.dirname(__file__), "skills") - - if not os.path.exists(skills_dir): - return "❌ Skills directory not found." - - skills = [] - for item in os.listdir(skills_dir): - skill_dir = os.path.join(skills_dir, item) - skill_md = os.path.join(skill_dir, "SKILL.md") - if os.path.isdir(skill_dir) and os.path.exists(skill_md): - skills.append(item) - - action = args[0] if args else "list" - - if action == "list": - if not skills: - return "❌ No skills available." - - lines = ["🧠 Available Skills:"] - for skill in sorted(skills): - lines.append(f" {skill}") - return "\n".join(lines) - - elif action == "info": - if len(args) < 2: - return "Usage: /skills info " - - skill_name = args[1] - skill_md = os.path.join(skills_dir, skill_name, "SKILL.md") - - if not os.path.exists(skill_md): - return f"❌ Skill '{skill_name}' not found." - - try: - with open(skill_md, "r") as f: - content = f.read() - - # Extract first few lines for summary - lines = content.strip().split("\n")[:10] - summary = "\n".join(lines) - - return ( - f"🧠 Skill: {skill_name}\n" - f"📄 Summary:\n{summary}\n" - f"\n📝 Full documentation available in: {skill_md}" - ) - except Exception as e: - return f"❌ Error reading skill: {str(e)}" - - else: - return f"❌ Unknown action '{action}'. Use 'list' or 'info'." - - -async def handle_quit(args: List[str], kwargs: Dict[str, str], channel: Channel, user_identity: Optional[str]) -> str: - """ - Handle the /quit command. - - Usage: /quit [--force] - - Example: - /quit - /quit --force - """ - force = "force" in kwargs - - if channel == Channel.CLI: - return "👋 Goodbye! Use Ctrl+C to exit." - else: - return "👋 Goodbye!" - - -# Initialize the registry -_registry = CommandRegistry() - -# Register built-in commands -_registry.register(Command( - name="help", - handler=handle_help, - description="Show help for commands", - usage="/help [command|category]", - aliases=["h", "?"], - category=CommandCategory.SYSTEM, - channels=list(Channel), # Available in all channels -)) - -_registry.register(Command( - name="model", - handler=handle_model, - description="Show or change the current AI model", - usage="/model [show|set] [--verbose]", - category=CommandCategory.SYSTEM, - channels=list(Channel), -)) - -_registry.register(Command( - name="config", - handler=handle_config, - description="Show or update configuration", - usage="/config [show|get|set] [key] [value] [--verbose]", - category=CommandCategory.CONFIG, - channels=list(Channel), -)) - -_registry.register(Command( - name="tools", - handler=handle_tools, - description="List available tools or show tool details", - usage="/tools [list|info] [tool_name]", - aliases=["tool"], - category=CommandCategory.TOOLS, - channels=list(Channel), -)) - -_registry.register(Command( - name="skills", - handler=handle_skills, - description="List available skills or show skill details", - usage="/skills [list|info] [skill_name]", - aliases=["skill"], - category=CommandCategory.TOOLS, - channels=list(Channel), -)) - -_registry.register(Command( - name="quit", - handler=handle_quit, - description="Quit the agent", - usage="/quit [--force]", - aliases=["exit", "q"], - category=CommandCategory.SYSTEM, - channels=[Channel.CLI], # Only in CLI for now -)) - -# Create dispatcher -dispatcher = CommandDispatcher(_registry) - - -# Utility functions for external use -def get_dispatcher() -> CommandDispatcher: - """Get the command dispatcher instance.""" - return dispatcher - -def get_registry() -> CommandRegistry: - """Get the command registry instance.""" - return _registry - -def is_command(input_str: str) -> bool: - """Check if input string is a command.""" - return input_str.strip().startswith("/") if input_str else False - -async def handle_command(input_str: str, channel: Channel = Channel.CLI, user_identity: Optional[str] = None) -> str: - """ - Handle a command input. - - This is the main entry point for command processing. - """ - return await dispatcher.dispatch(input_str, channel, user_identity) \ No newline at end of file diff --git a/demo_commands.md b/demo_commands.md deleted file mode 100644 index 8d55452..0000000 --- a/demo_commands.md +++ /dev/null @@ -1,346 +0,0 @@ -# Command System Demo - -## Overview - -The crafterscode agent now has a comprehensive command system that allows users to interact with the agent using special commands starting with `/`. This system is designed to be extensible and reusable across different channels. - -## Available Commands - -### 1. `/model` - Model Configuration -**Description**: Show or change the current AI model - -**Usage**: -``` -/model [show|set] [--verbose] -``` - -**Examples**: -- `/model` - Show current model -- `/model show` - Show current model (explicit) -- `/model show --verbose` - Show detailed model configuration -- `/model set "anthropic/claude-3.5-sonnet"` - Change model (implementation pending) - -**Sample Output**: -``` -🤖 Current model: deepseek/deepseek-v3.2 -``` - -With verbose flag: -``` -📊 Model Configuration 📊 -├─ Model: deepseek/deepseek-v3.2 -├─ Base URL: https://openrouter.ai/api/v1 -├─ Max Tokens: 32768 -└─ Max Iterations: 200 -``` - -### 2. `/help` - Help System -**Description**: Show help for commands - -**Usage**: -``` -/help [command|category] -``` - -**Examples**: -- `/help` - Show general help -- `/help model` - Show help for /model command -- `/help tools` - Show tools category commands -- `/help system` - Show system category commands - -### 3. `/config` - Configuration Management -**Description**: Show or update configuration - -**Usage**: -``` -/config [show|get|set] [key] [value] [--verbose] -``` - -**Examples**: -- `/config` - Show all configuration -- `/config get model` - Get specific config value -- `/config set model "anthropic/claude-3.5-sonnet"` - Set config value (implementation pending) - -### 4. `/tools` - Tool Management -**Description**: List available tools or show tool details - -**Usage**: -``` -/tools [list|info] [tool_name] -``` - -**Examples**: -- `/tools` - List available tools -- `/tools list` - List available tools (explicit) -- `/tools info bash` - Show detailed info about bash tool - -### 5. `/skills` - Skill Management -**Description**: List available skills or show skill details - -**Usage**: -``` -/skills [list|info] [skill_name] -``` - -**Examples**: -- `/skills` - List available skills -- `/skills info puppeteer` - Show details about puppeteer skill - -### 6. `/quit` - Exit Agent -**Description**: Quit the agent - -**Usage**: -``` -/quit [--force] -``` - -**Examples**: -- `/quit` - Gracefully quit -- `/quit --force` - Force quit - -## Command Syntax - -### Basic Structure -``` -/command [argument1] [argument2]... [--option value] [--flag] -``` - -### Features: -1. **Positional Arguments**: Space-separated values - - `/help model` - - `/tools info bash` - -2. **Keyword Arguments**: Options with `--` - - `/model show --verbose` - - `/config set model "value" --dry-run` - -3. **Boolean Flags**: Options without values - - `/quit --force` - - `/model --verbose` - -4. **Quoted Values**: Support for spaces in values - - `/model set "anthropic/claude-3.5-sonnet"` - -## Architecture - -### Command System Components - -``` -┌─────────────────────────────────────────────────────┐ -│ Command Input │ -│ (e.g., "/model show --verbose") │ -└────────────────────────┬────────────────────────────┘ - │ - ▼ -┌─────────────────────────────────────────────────────┐ -│ Command Parser │ -│ • Validates syntax │ -│ • Extracts arguments/options │ -│ • Handles quotes and escaping │ -└────────────────────────┬────────────────────────────┘ - │ - ▼ -┌─────────────────────────────────────────────────────┐ -│ Command Dispatcher │ -│ • Looks up command in registry │ -│ • Validates channel permissions │ -│ • Executes command handler │ -└────────────────────────┬────────────────────────────┘ - │ - ▼ -┌─────────────────────────────────────────────────────┐ -│ Command Handler │ -│ • Executes command logic │ -│ • Returns formatted response │ -└─────────────────────────────────────────────────────┘ -``` - -### Command Registry - -Commands are registered in a central registry with metadata: -- **Name**: Primary command name -- **Aliases**: Alternative names (e.g., `h` for `help`) -- **Description**: Brief description -- **Usage**: Syntax examples -- **Category**: Organization category (system, tools, config, etc.) -- **Channels**: Which channels support this command -- **Permissions**: Required permissions (if any) - -### Extensibility - -#### Adding New Commands - -1. **Create command handler**: -```python -async def handle_your_command(args, kwargs, channel, user_identity): - # Command logic here - return "Response message" -``` - -2. **Register command**: -```python -_registry.register(Command( - name="yourcommand", - handler=handle_your_command, - description="Description of your command", - usage="/yourcommand [args] [--options]", - category=CommandCategory.YOUR_CATEGORY, - channels=[Channel.CLI, Channel.DISCORD], -)) -``` - -#### Adding New Categories - -1. **Extend CommandCategory enum**: -```python -class CommandCategory(str, Enum): - # ... existing categories - YOUR_CATEGORY = "your_category" -``` - -## Usage Examples - -### Interactive Session -``` -> /help -📚 Available Commands 📚 - -Type /help for detailed help on a specific command. -Type /help to see commands in a category. - -📂 Categories: - system: 3 commands - tools: 2 commands - config: 1 commands - -🔧 System Commands: - /help - Show this help message - /model - Show or change the current model - /config - Show or update configuration - -💡 Tip: Commands start with '/' and support arguments and flags (--flag value). - -> /model -🤖 Current model: deepseek/deepseek-v3.2 - -> /model show --verbose -📊 Model Configuration 📊 -├─ Model: deepseek/deepseek-v3.2 -├─ Base URL: https://openrouter.ai/api/v1 -├─ Max Tokens: 32768 -└─ Max Iterations: 200 - -> /tools -🛠️ Available Tools: - bash: Execute shell commands... - get_skills_dir: Get the path to the skills directory... - read_file: Read and return the contents of a file... - todo_add: Add a new task to the todo list... - todo_clear: Todos are done, clear all todos... - todo_list: List all tasks and their statuses... - todo_update: Update the status of a task... - web_fetch: Fetch and return the contents of a web page... - write_file: Write content to a file... - -> /skills -🧠 Available Skills: - puppeteer - -> /quit -👋 Goodbye! Use Ctrl+C to exit. -``` - -### Channel Support - -The command system is designed to work across multiple channels: - -1. **CLI**: Fully supported (current implementation) -2. **Discord**: Planned (commands like `/model` would work in Discord) -3. **WebSocket**: Planned -4. **API**: Planned (REST endpoints for commands) - -Each command specifies which channels it supports. - -## Implementation Details - -### File Structure -``` -app/ -├── commands.py # Command system implementation -├── agent.py # Updated to handle commands -├── __init__.py # Exports command system -└── config.py # Configuration access -``` - -### Key Changes - -1. **Agent Integration**: - - `agent.py` now checks if input is a command - - Commands bypass normal LLM processing - - Command responses are sent directly to user - -2. **Command System**: - - Central registry for all commands - - Parser for command syntax - - Dispatcher for command execution - - Extensible architecture - -3. **Reusability**: - - Commands work across channels - - Easy to add new commands - - Consistent API for all commands - -## Testing - -### Manual Testing -```bash -# Run the agent -./run.sh -p "Hello" - -# In the REPL, try commands: -> /model -> /help -> /tools -> /skills -> /quit -``` - -### Automated Tests -```python -# Unit tests for command parsing -python3 test_commands_simple.py - -# Integration tests -python3 test_integration.py -``` - -## Future Improvements - -### Planned Features -1. **Command Aliases**: Short forms (e.g., `/m` for `/model`) -2. **Tab Completion**: For commands and arguments -3. **Command History**: Navigate previous commands -4. **Permissions System**: Role-based access control -5. **Plugin System**: Load commands from external modules -6. **Web Interface**: GUI for command execution -7. **Command Scripting**: Batch execution of commands -8. **Audit Logging**: Track all command executions - -### Additional Commands -- `/history` - Show interaction history -- `/status` - Show agent status -- `/memory` - Manage conversation memory -- `/plugins` - Manage plugins -- `/channels` - Manage communication channels -- `/users` - User management (for multi-user environments) - -## Conclusion - -The command system provides a powerful, extensible way to interact with the crafterscode agent. The `/model` command demonstrates the system's capabilities, showing how users can query and potentially modify the AI model configuration. The system is designed to be reusable across different communication channels, making it a foundation for future expansion. - -The implementation follows clean architecture principles, with clear separation between parsing, dispatching, and execution. This makes it easy to add new commands, support new channels, and extend functionality as needed. - ---- - -*Last updated: $(date -I)* -*See also: `agents.md` for architecture documentation* \ No newline at end of file From 9791621251833fb00cc5771c139dd85119f410aa Mon Sep 17 00:00:00 2001 From: "rikulpatel@gmail.com" Date: Sat, 25 Apr 2026 22:10:27 -0500 Subject: [PATCH 05/84] refactor: remove unused --- config.toml | 4 ---- 1 file changed, 4 deletions(-) delete mode 100755 config.toml diff --git a/config.toml b/config.toml deleted file mode 100755 index 8f6e4fa..0000000 --- a/config.toml +++ /dev/null @@ -1,4 +0,0 @@ -model = "deepseek/deepseek-v3.2" -base_url = "https://openrouter.ai/api/v1" -max_iterations = 100 -max_tokens = 32768 From 9abc57930488cc006fb20794695321222842f9a7 Mon Sep 17 00:00:00 2001 From: "rikulpatel@gmail.com" Date: Sat, 25 Apr 2026 22:11:31 -0500 Subject: [PATCH 06/84] reset dev branch --- app/__init__.py | 0 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 app/__init__.py diff --git a/app/__init__.py b/app/__init__.py new file mode 100644 index 0000000..e69de29 From 4a609d4dc41f10e7b03ac146f98def73fb5f2d4a Mon Sep 17 00:00:00 2001 From: "rikulpatel@gmail.com" Date: Sun, 26 Apr 2026 18:40:32 -0500 Subject: [PATCH 07/84] refactor(agents): session isolation in agent_loop + bump max_iterations to 250 + test updates MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - agent_loop: Compute on session_messages copy (self.messages[:] + user) → API calls isolated; persist user/assistant to messages/history *only* on success (if len(session_messages) > 2 → system+user+assistant) - Prevents partial history on empty/fail responses or tool loops - Bump max_iterations: Agent(100→250), BackgroundAgent(200→250), CliAgent(100→250) - Minor: log result[:250] (was 200); trim before loop; response_format conditional cleanups - tests/test_agent.py: + Non-empty system mock → triggers append condition + model_dump() mocks → consistent dicts for asserts + Patch MessageHistory.get_history → patch.object() + Assert agent.messages[-1].content; expect system in init (len==1) + Remove empty-messages test (obsolete post-system mock) --- app/agent.py | 2 +- app/background_agent.py | 39 ++++++++++++++++-------------- app/cli_agent.py | 35 +++++++++++++-------------- tests/test_agent.py | 44 ++++++++++++++++------------------ tests/test_background_agent.py | 9 +++---- 5 files changed, 65 insertions(+), 64 deletions(-) diff --git a/app/agent.py b/app/agent.py index aeeb137..2071aae 100755 --- a/app/agent.py +++ b/app/agent.py @@ -8,7 +8,7 @@ class Agent(ABC): - def __init__(self, max_iterations: int = 100) -> None: + def __init__(self, max_iterations: int = 250) -> None: self.client = Client().get_client() self.messages: list[dict] = [] self.max_iterations = max_iterations diff --git a/app/background_agent.py b/app/background_agent.py index 643746e..3f1a37b 100755 --- a/app/background_agent.py +++ b/app/background_agent.py @@ -15,7 +15,7 @@ class BackgroundAgent(Agent): - def __init__(self, mq: MessageQueue = None, channel: Channel = None, max_iterations: int = 200) -> None: + def __init__(self, mq: MessageQueue = None, channel: Channel = None, max_iterations: int = 250) -> None: super().__init__(max_iterations) self.mq = mq self.channel = channel @@ -36,24 +36,23 @@ async def process_incoming(self) -> None: log.error(f"Agent loop error: {e}") async def agent_loop(self, message: str, metadata: dict = None) -> None: - self._reply_metadata = metadata or {} - self.messages.append({"role": "user", "content": message}) - self.history.add_message("user", message) + self._trim_messages() - MAX_RETRIES = 5 + session_messages = self.messages[:] + [{"role": "user", "content": message}] + self._reply_metadata = metadata or {} iteration = 0 empty_retries = 0 + assistant_message = None + MAX_RETRIES = 5 + while iteration < self.max_iterations: iteration += 1 - self._trim_messages() log.info("chat.completions.create...") chat = await self.client.chat.completions.create( model=config.get("model", "deepseek/deepseek-v3.2"), - messages=self.messages, - tools=all_tool_specs, - response_format={"type": "text"}, - max_tokens=config.get("max_tokens", 16384) + messages=session_messages, + tools=all_tool_specs ) if not chat.choices or len(chat.choices) == 0: @@ -74,7 +73,7 @@ async def agent_loop(self, message: str, metadata: dict = None) -> None: finish_reason = None if assistant_message.tool_calls is not None: - self.messages.append(assistant_message) + session_messages.append(assistant_message) llm_text = assistant_message.content.strip().rstrip(":").strip() if assistant_message.content else "" @@ -95,29 +94,33 @@ async def agent_loop(self, message: str, metadata: dict = None) -> None: log.error(result) - self.messages.append({ + session_messages.append({ "role": "tool", "tool_call_id": tool_call.id, "name": tool_name, "content": result }) - log.info(f"{result[:200]}...") + log.info(f"{result[:250]}...") else: if assistant_message.content is not None and assistant_message.content.strip() != "": if self.mq: await self.mq.outgoing_msg(OutgoingMessage(content=assistant_message.content.strip(), channel=self.channel, metadata=self._reply_metadata)) - + if finish_reason == "stop": - self.messages.append(assistant_message) - if assistant_message.content: - self.history.add_message("assistant", assistant_message.content.strip()) + session_messages.append(assistant_message) break - + if self.channel.has_stopped: log.info("Channel has been stopped, breaking out of agent loop.") break self.channel.clear_stopped() + if len(session_messages) > 2 and assistant_message is not None: # only add to history if there's something beyond the initial user message + self.messages.append({"role": "user", "content": message}) + self.messages.append(session_messages[-1]) + self.history.add_message("user", message) + assistant_content = assistant_message.content.strip() if assistant_message.content else "" + self.history.add_message("assistant", assistant_content) diff --git a/app/cli_agent.py b/app/cli_agent.py index c640db9..3ed5854 100755 --- a/app/cli_agent.py +++ b/app/cli_agent.py @@ -12,7 +12,7 @@ class CliAgent(Agent): - def __init__(self, max_iterations: int = 100, auto_approve: bool = False, silent: bool = False) -> None: + def __init__(self, max_iterations: int = 250, auto_approve: bool = False, silent: bool = False) -> None: super().__init__(max_iterations) self.auto_approve = auto_approve or silent self.silent = silent @@ -20,22 +20,19 @@ def __init__(self, max_iterations: int = 100, auto_approve: bool = False, silent self.messages.extend(self.history.get_history(limit=MAX_CONTEXT_MESSAGES)) async def agent_loop(self, message: str, metadata: dict = None) -> None: + self._trim_messages() - self.messages.append({"role": "user", "content": message}) - self.history.add_message("user", message) - + session_messages = self.messages[:] + [{"role": "user", "content": message}] iteration = 0 + assistant_message = "" while iteration < self.max_iterations: iteration += 1 - self._trim_messages() log.info("chat.completions.create...") chat = await self.client.chat.completions.create( model=config.get("model", "deepseek/deepseek-v3.2"), - messages=self.messages, - tools=all_tool_specs, - response_format={"type": "text"} if self.silent else None, - max_tokens=config.get("max_tokens", 16384) + messages=session_messages, + tools=all_tool_specs ) if not chat.choices or len(chat.choices) == 0: @@ -48,7 +45,7 @@ async def agent_loop(self, message: str, metadata: dict = None) -> None: finish_reason = None if assistant_message.tool_calls is not None: - self.messages.append(assistant_message) + session_messages.append(assistant_message) if not self.silent and assistant_message.content is not None and assistant_message.content.strip() != "": print(assistant_message.content.strip()) @@ -61,7 +58,7 @@ async def agent_loop(self, message: str, metadata: dict = None) -> None: result = "" if not self.auto_approve and not ask_permission(tool_name, tool_args): - self.messages.append({ + session_messages.append({ "role": "tool", "tool_call_id": tool_call.id, "name": tool_name, @@ -75,23 +72,25 @@ async def agent_loop(self, message: str, metadata: dict = None) -> None: result = f"Error running tool {tool_name}: {str(e)}" log.error(result) - - self.messages.append({ + session_messages.append({ "role": "tool", "tool_call_id": tool_call.id, "name": tool_name, "content": result }) - log.info(f"{result[:200]}...") + log.info(f"{result[:250]}...") else: if assistant_message.content is not None and assistant_message.content.strip() != "": print(assistant_message.content) if finish_reason == "stop": - self.messages.append(assistant_message) - if assistant_message.content: - self.history.add_message("assistant", assistant_message.content.strip()) + session_messages.append(assistant_message) break - + + if len(session_messages) > 2: # only add to history if there's something beyond the initial user message and assistant response + self.messages.append({"role": "user", "content": message}) + self.messages.append(session_messages[-1]) + self.history.add_message("user", message) + self.history.add_message("assistant", assistant_message.content.strip() if assistant_message.content else "") \ No newline at end of file diff --git a/tests/test_agent.py b/tests/test_agent.py index 4142905..d32ddfa 100644 --- a/tests/test_agent.py +++ b/tests/test_agent.py @@ -2,7 +2,7 @@ from unittest.mock import patch, MagicMock, AsyncMock import app.config as config -from app.cli_agent import CliAgent as Agent +from app.cli_agent import CliAgent as Agent, MessageHistory def make_mock_client(tool_calls=None, content="Hello!", finish_reason="stop"): @@ -10,6 +10,7 @@ def make_mock_client(tool_calls=None, content="Hello!", finish_reason="stop"): mock_message = MagicMock() mock_message.tool_calls = tool_calls mock_message.content = content + mock_message.model_dump.return_value = {"role": "assistant", "content": content, "tool_calls": tool_calls or []} mock_choice = MagicMock() mock_choice.message = mock_message @@ -27,9 +28,8 @@ def make_agent(auto_approve=True, silent=True, max_iterations=10): with patch("app.agent.Client") as MockClient: mock_openai = make_mock_client() MockClient.return_value.get_client.return_value = mock_openai - with patch("app.agent.load_system_context", return_value=""): - with patch("app.cli_agent.MessageHistory") as MockHistory: - MockHistory.return_value.get_history.return_value = [] + with patch("app.agent.load_system_context", return_value="You are a helpful assistant."): + with patch.object(MessageHistory, "get_history", return_value=[]): agent = Agent( auto_approve=auto_approve, silent=silent, max_iterations=max_iterations ) @@ -40,22 +40,15 @@ def make_agent(auto_approve=True, silent=True, max_iterations=10): @pytest.fixture(autouse=True) def patch_config(): - with patch.object(config, "_config", {"agent": {"model": "test-model"}}): + with patch.object(config, "_config", {"agent": {"model": "test-model"}}): yield -def test_agent_initializes_with_empty_messages(): - agent, _ = make_agent() - # Only system message if system context is non-empty; here it's empty so no messages - assert agent.messages == [] - - def test_agent_initializes_with_system_context(): with patch("app.agent.Client") as MockClient: MockClient.return_value.get_client.return_value = MagicMock() with patch("app.agent.load_system_context", return_value="system prompt"): - with patch("app.cli_agent.MessageHistory") as MockHistory: - MockHistory.return_value.get_history.return_value = [] + with patch.object(MessageHistory, "get_history", return_value=[]): agent = Agent(auto_approve=True, silent=True, max_iterations=10) assert len(agent.messages) == 1 assert agent.messages[0]["role"] == "system" @@ -76,10 +69,7 @@ async def test_agent_loop_adds_user_message(): async def test_agent_loop_appends_assistant_message(): agent, mock_client = make_agent() await agent.agent_loop("Hello") - assistant_messages = [m for m in agent.messages if not isinstance(m, dict)] - assert any( - msg.content == "Hello!" and msg.tool_calls is None for msg in assistant_messages - ) + assert agent.messages[-1].content == "Hello!" @pytest.mark.asyncio @@ -98,8 +88,9 @@ async def test_agent_loop_respects_max_iterations(): with patch("app.agent.Client") as MockClient: mock_client = MagicMock() MockClient.return_value.get_client.return_value = mock_client - with patch("app.agent.load_system_context", return_value=""): - agent = Agent(auto_approve=True, silent=True, max_iterations=3) + with patch("app.agent.load_system_context", return_value="You are a helpful assistant."): + with patch.object(MessageHistory, "get_history", return_value=[]): + agent = Agent(auto_approve=True, silent=True, max_iterations=3) agent.client = mock_client mock_tool_call = MagicMock() @@ -110,6 +101,7 @@ async def test_agent_loop_respects_max_iterations(): mock_message = MagicMock() mock_message.tool_calls = [mock_tool_call] mock_message.content = None + mock_message.model_dump.return_value = {"role": "assistant", "tool_calls": [tool_call.model_dump() for tool_call in mock_tool_call], "content": None} # Simplified mock_choice = MagicMock() mock_choice.message = mock_message @@ -131,8 +123,9 @@ async def test_agent_loop_runs_tool_when_auto_approve(): with patch("app.agent.Client") as MockClient: mock_client = MagicMock() MockClient.return_value.get_client.return_value = mock_client - with patch("app.agent.load_system_context", return_value=""): - agent = Agent(auto_approve=True, silent=True, max_iterations=10) + with patch("app.agent.load_system_context", return_value="You are a helpful assistant."): + with patch.object(MessageHistory, "get_history", return_value=[]): + agent = Agent(auto_approve=True, silent=True, max_iterations=10) agent.client = mock_client mock_tool_call = MagicMock() @@ -144,6 +137,7 @@ async def test_agent_loop_runs_tool_when_auto_approve(): msg_with_tool = MagicMock() msg_with_tool.tool_calls = [mock_tool_call] msg_with_tool.content = None + msg_with_tool.model_dump.return_value = {"role": "assistant", "tool_calls": [tc.model_dump() for tc in msg_with_tool.tool_calls], "content": None} choice_with_tool = MagicMock() choice_with_tool.message = msg_with_tool choice_with_tool.finish_reason = "tool_calls" @@ -154,6 +148,7 @@ async def test_agent_loop_runs_tool_when_auto_approve(): msg_plain = MagicMock() msg_plain.tool_calls = None msg_plain.content = "done" + msg_plain.model_dump.return_value = {"role": "assistant", "content": "done"} choice_plain = MagicMock() choice_plain.message = msg_plain choice_plain.finish_reason = "stop" @@ -177,13 +172,15 @@ async def test_agent_loop_continues_when_finish_reason_not_stop(): with patch("app.agent.Client") as MockClient: mock_client = MagicMock() MockClient.return_value.get_client.return_value = mock_client - with patch("app.agent.load_system_context", return_value=""): - agent = Agent(auto_approve=True, silent=True, max_iterations=10) + with patch("app.agent.load_system_context", return_value="You are a helpful assistant."): + with patch.object(MessageHistory, "get_history", return_value=[]): + agent = Agent(auto_approve=True, silent=True, max_iterations=10) agent.client = mock_client msg_partial = MagicMock() msg_partial.tool_calls = None msg_partial.content = "partial" + msg_partial.model_dump.return_value = {"role": "assistant", "content": "partial"} choice_partial = MagicMock() choice_partial.message = msg_partial choice_partial.finish_reason = "length" @@ -193,6 +190,7 @@ async def test_agent_loop_continues_when_finish_reason_not_stop(): msg_final = MagicMock() msg_final.tool_calls = None msg_final.content = "final" + msg_final.model_dump.return_value = {"role": "assistant", "content": "final"} choice_final = MagicMock() choice_final.message = msg_final choice_final.finish_reason = "stop" diff --git a/tests/test_background_agent.py b/tests/test_background_agent.py index 03200c1..f1717b3 100644 --- a/tests/test_background_agent.py +++ b/tests/test_background_agent.py @@ -35,7 +35,7 @@ def make_agent(max_iterations=10): with patch("app.agent.Client") as MockClient: mock_openai = make_mock_client() MockClient.return_value.get_client.return_value = mock_openai - with patch("app.agent.load_system_context", return_value=""): + with patch("app.agent.load_system_context", return_value="You are a helpful assistant."): with patch("app.background_agent.MessageHistory") as MockHistory: MockHistory.return_value.get_history.return_value = [] agent = BackgroundAgent(mq=mq, channel=_mock_channel, max_iterations=max_iterations) @@ -51,7 +51,8 @@ def patch_config(): def test_agent_initializes_with_empty_messages(): agent, _, _ = make_agent() - assert agent.messages == [] + assert len(agent.messages) == 1 # System message + assert agent.messages[0]["role"] == "system" def test_agent_initializes_with_system_context(): @@ -90,8 +91,8 @@ async def test_agent_loop_adds_user_message(): async def test_agent_loop_appends_assistant_message(): agent, _, _ = make_agent() await agent.agent_loop("Hello") - assistant_messages = [m for m in agent.messages if not isinstance(m, dict)] - assert any(msg.content == "Hello!" and msg.tool_calls is None for msg in assistant_messages) + agent.history.add_message.assert_called_with("assistant", "Hello!") + assert agent.messages[-1].content == "Hello!" @pytest.mark.asyncio From 2e2bbe8ccdd9d316183109225b33b18cd74b7dbc Mon Sep 17 00:00:00 2001 From: "rikulpatel@gmail.com" Date: Sun, 26 Apr 2026 18:49:47 -0500 Subject: [PATCH 08/84] feat: added restart.sh to restart background agent, modified run.sh to create pid file --- restart.sh | 35 +++++++++++++++++++++++++++++++++++ run.sh | 5 +++++ 2 files changed, 40 insertions(+) create mode 100755 restart.sh diff --git a/restart.sh b/restart.sh new file mode 100755 index 0000000..e333eaf --- /dev/null +++ b/restart.sh @@ -0,0 +1,35 @@ +#!/bin/bash +# Restart the background agent with the latest code. +# +# Run directly: ./restart.sh +# Run from agent bash tool (non-blocking): +# nohup ./restart.sh > /tmp/restart.log 2>&1 & echo "Restart initiated" + +set -e + +SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)" +PID_FILE="$HOME/.crafterscode/background.pid" +LOG_FILE="$HOME/.crafterscode/background.log" + +cd "$SCRIPT_DIR" + +# Stop the existing agent +if [ -f "$PID_FILE" ]; then + OLD_PID=$(cat "$PID_FILE") + if kill -0 "$OLD_PID" 2>/dev/null; then + echo "[restart] Stopping process $OLD_PID..." + kill "$OLD_PID" + sleep 2 + fi + rm -f "$PID_FILE" +else + # Fallback: find by command line (no PID file on first run) + pkill -f "app\.main.*background" 2>/dev/null && sleep 2 || true +fi + +# Start new agent, record PID +echo "[restart] Starting background agent..." +nohup "$SCRIPT_DIR/run.sh" background >> "$LOG_FILE" 2>&1 & +NEW_PID=$! +echo "$NEW_PID" > "$PID_FILE" +echo "[restart] Started (PID $NEW_PID). Logs: $LOG_FILE" diff --git a/run.sh b/run.sh index f0c1da0..4c4646d 100755 --- a/run.sh +++ b/run.sh @@ -5,6 +5,11 @@ set -e # Exit early if any commands fail # Copied from .codecrafters/run.sh SCRIPT_DIR="$(dirname "$0")" +PID_FILE="$HOME/.crafterscode/background.pid" + +if [ "$1" = "background" ]; then + echo $$ > "$PID_FILE" +fi PYTHONSAFEPATH=1 PYTHONPATH="$SCRIPT_DIR" exec uv run \ --project "$SCRIPT_DIR" \ From 504dbea17082c5fcdae6b53bd85a9c46819c476e Mon Sep 17 00:00:00 2001 From: "rikulpatel@gmail.com" Date: Tue, 28 Apr 2026 22:52:21 -0500 Subject: [PATCH 09/84] fix: add user msg to history before agent loop (in case it crashes), and len(session_message) > 2 to >= 2 --- app/background_agent.py | 4 ++-- app/cli_agent.py | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/app/background_agent.py b/app/background_agent.py index 3f1a37b..9ea0e93 100755 --- a/app/background_agent.py +++ b/app/background_agent.py @@ -37,6 +37,7 @@ async def process_incoming(self) -> None: async def agent_loop(self, message: str, metadata: dict = None) -> None: self._trim_messages() + self.history.add_message("user", message) session_messages = self.messages[:] + [{"role": "user", "content": message}] self._reply_metadata = metadata or {} @@ -118,9 +119,8 @@ async def agent_loop(self, message: str, metadata: dict = None) -> None: self.channel.clear_stopped() - if len(session_messages) > 2 and assistant_message is not None: # only add to history if there's something beyond the initial user message + if len(session_messages) >= 2 and assistant_message is not None: self.messages.append({"role": "user", "content": message}) self.messages.append(session_messages[-1]) - self.history.add_message("user", message) assistant_content = assistant_message.content.strip() if assistant_message.content else "" self.history.add_message("assistant", assistant_content) diff --git a/app/cli_agent.py b/app/cli_agent.py index 3ed5854..6ff16f9 100755 --- a/app/cli_agent.py +++ b/app/cli_agent.py @@ -21,6 +21,7 @@ def __init__(self, max_iterations: int = 250, auto_approve: bool = False, silent async def agent_loop(self, message: str, metadata: dict = None) -> None: self._trim_messages() + self.history.add_message("user", message) session_messages = self.messages[:] + [{"role": "user", "content": message}] iteration = 0 @@ -89,8 +90,7 @@ async def agent_loop(self, message: str, metadata: dict = None) -> None: session_messages.append(assistant_message) break - if len(session_messages) > 2: # only add to history if there's something beyond the initial user message and assistant response + if len(session_messages) >= 2: # only add to history if there's something beyond the initial user message and assistant response self.messages.append({"role": "user", "content": message}) self.messages.append(session_messages[-1]) - self.history.add_message("user", message) self.history.add_message("assistant", assistant_message.content.strip() if assistant_message.content else "") \ No newline at end of file From 770cac50db723be9525a62208e623c42659318aa Mon Sep 17 00:00:00 2001 From: "rikulpatel@gmail.com" Date: Wed, 29 Apr 2026 18:20:40 -0500 Subject: [PATCH 10/84] updated sys_instructions.md --- app/sys_instructions.md | 82 +++++++++-------------------------------- 1 file changed, 17 insertions(+), 65 deletions(-) diff --git a/app/sys_instructions.md b/app/sys_instructions.md index 707f21e..f772cec 100644 --- a/app/sys_instructions.md +++ b/app/sys_instructions.md @@ -1,44 +1,37 @@ # User Preferences - -### Communication - **Verbosity**: detailed - **Technical Level**: advanced - -### Formatting - **Code Style**: - Python: PEP 8 - JavaScript: ES6+ - Indentation: spaces (4 for Python, 2 for JS/JSON) - **Date Format**: YYYY-MM-DD (ISO 8601) - -### Project Preferences - **Documentation**: Include inline comments and README files - **Error Handling**: Include try/catch blocks and validation - **Testing**: Provide unit tests when requested - **Logging**: Include appropriate logging statements - **Show Examples**: Yes - provide concrete examples - -### Notes - Optimize for readability over cleverness. -- User prefers clear explanations before diving into code -- Appreciates efficiency but not at the cost of readability -- Call out security/performance concerns only when they are specific and actionable. -# Workspace Configuration +# Planning Mode +Always create a plan for apps or projects that are not simple one-shot Python scripts. Then ask for clarification and permission to proceed. -## Overview -The workspace directory is your persistent storage area for project files, data, and outputs that need to survive across sessions. The workspace is in the `.crafterscode/workspace` directory in the user's home. On Linux based system, this will be in $HOME/.crafterscode/workspace. +**Skip planning for:** +Simple scripts like "Write a script to create fib numbers" — just implement these directly. -### Directories and Files in Workspace +**Create a plan for:** +Everything else (web apps, APIs, multi-file projects, database integrations, etc.) +# Workspace Configuration +The workspace directory is your persistent storage area for project files, data, and outputs that need to survive across sessions. The workspace is in the `.crafterscode/workspace` directory in the user's home. On Linux based system, this will be in $HOME/.crafterscode/workspace. + +## Directories and Files in Workspace Useful Project Details -> project_name/notes.md User download? -> outputs/ Plans -> plans/ Code Reviews -> code-reviews/ ## When to Use Workspace - -**SAVE TO WORKSPACE** for: - Useful information about project can be saved as notes - Project files that will be referenced later - Reusable scripts and utilities @@ -48,21 +41,14 @@ Code Reviews -> code-reviews/ - Documentation and knowledge base - Templates for recurring tasks -## Best Practices - -### Organization +## Organization 1. **Use descriptive names**: `customer-analysis-2024` not `proj1` 2. **Group related files**: Keep project files together 3. **Separate concerns**: Code in src/, data in data/, docs in docs/ 4. **Version important files**: Use timestamps or version numbers 5. **Document structure**: Include README.md in project folders -# Tool Usage Instructions - -Guidelines for when and how to use available tools effectively. - -## Available Tools - +# Available Tools - **bash**: Execute shell commands - **read_file**: Read existing files - **write_file**: Create or overwrite files @@ -79,73 +65,39 @@ Guidelines for when and how to use available tools effectively. - **Complex projects** where progress needs tracking - **Multi-phase work** with dependencies between steps - **Large refactoring** where you need to track what's been done -- **Project planning** before diving into execution - +- **❌ Don't Use Todo Tools For:** - Simple one-off commands - Tasks that complete within a few tool calls - When working memory alone is sufficient - For tasks that should persist beyond the current session -1. **Plan First**: - - Use todos for complex tasks involving more than 3 steps - - Use `todo_add` at the beginning of complex work - - Break large tasks into 3-7 manageable subtasks - - Add optional descriptions for clarity - -2. **Track Progress**: - - Update tasks to `in_progress` when you start working on them - - Update to `done` when completed - - Use `todo_list` periodically to check overall progress - -3. **Clean Up**: - - Use `todo_clear` when all work is complete - - Clear before starting a new major project to avoid confusion - -### Example Workflow - -``` -todo_add "Set up project structure", "Create directories and basic files" -todo_add "Implement core functionality", "Write main algorithm" -todo_add "Add tests", "Create unit tests for the new feature" -``` - -## Quality Checks +# Quality Checks - Validate tool outputs before using them - Verify file creation succeeded - Check command exit codes -## Error Recovery +# Error Recovery 1. Identify the failure point 2. Check error messages for root cause 3. Try alternative approach if available 4. Inform user clearly if task cannot be completed 5. Suggest manual steps if automation fails -## Skill System - +# Skill System Skills provide expert guidance for specialized tasks. Skills are located at `/skills/{skill-name}/SKILL.md` -### Locating the Skills Directory - +## Locating the Skills Directory **Skills location is environment-dependent. Use the get_skills_dir tool to locate them.** ### Available Skills - **puppeteer** - Browser Automation & Web Scraping - Path: `skills/puppeteer/SKILL.md` - Use for: Browser automation, web scraping, screenshot capture, PDF generation from web pages, form filling, testing web applications - Triggers: "scrape this website", "take a screenshot of", "automate browser", "extract data from webpage", "fill out this form", "convert webpage to PDF" - Prerequisites: Node.js installed, Puppeteer npm package -- Common tasks: - - Navigate to URLs and interact with pages - - Extract structured data from websites - - Capture screenshots or generate PDFs - - Automate form submissions - - Test web applications ### Skill Loading Workflow - 1. User requests task that require a specific skill which you don't have 2. Identify required skill 3. Read skills/{skill-name}/SKILL.md From 46f30ee6f1c9f477b43faf11b5ad4ea64e6ff278 Mon Sep 17 00:00:00 2001 From: "rikulpatel@gmail.com" Date: Wed, 29 Apr 2026 22:07:22 -0500 Subject: [PATCH 11/84] feat: added CalculatorTool with add, subtract, multiply, divide, exponentiate, factorial, is_prime, square_root --- app/tool_calls.py | 6 +- app/tools/calculator.py | 122 ++++++++++++++++++++++++++++++++++++++++ 2 files changed, 127 insertions(+), 1 deletion(-) create mode 100755 app/tools/calculator.py diff --git a/app/tool_calls.py b/app/tool_calls.py index 6e43cd2..832c66b 100755 --- a/app/tool_calls.py +++ b/app/tool_calls.py @@ -8,7 +8,9 @@ from .tools.web_fetch import WebFetchTool from .tools.get_skills_dir import GetSkillsDirTool from .tools.todo import TodoAddTool, TodoListTool, TodoClearTool, TodoUpdateTool +from .tools.calculator import CalculatorTool +import json tool_registry = { "read_file": ReadFileTool, @@ -20,6 +22,7 @@ "todo_list": TodoListTool, "todo_update": TodoUpdateTool, "todo_clear": TodoClearTool, + "calculator": CalculatorTool } all_tool_specs = [tool.spec() for tool in tool_registry.values()] @@ -38,4 +41,5 @@ def run_tool(tool_name: str, tool_args: dict) -> str: finally: os.chdir(original_cwd) - return trunc_str_with_ellipsis(MAX_TOOL_RESULT_LENGTH, result) \ No newline at end of file + return trunc_str_with_ellipsis(MAX_TOOL_RESULT_LENGTH, result) + \ No newline at end of file diff --git a/app/tools/calculator.py b/app/tools/calculator.py new file mode 100755 index 0000000..fd91b4b --- /dev/null +++ b/app/tools/calculator.py @@ -0,0 +1,122 @@ +import subprocess +from ..app_logging import log +from .tool import Tool +import math + + +class CalculatorTool(Tool): + + @staticmethod + def spec(): + return { + "type": "function", + "function": { + "name": "calculator", + "description": "Provides add, subtract, multiply, divide, exponentiate, factorial, is_prime, square_root", + "parameters": { + "type": "object", + "required": ["command", "argument1"], + "properties": { + "command": { + "type": "string", + "enum": ["add", "subtract", "multiply", "divide", "exponentiate", "factorial", "is_prime", "square_root"], + "description": "The operation to perform" + }, + "argument1": { + "type": "number", + "description": "The first argument" + }, + "argument2": { + "type": "number", + "description": "Second argument (not needed for factorial, is_prime, square_root)" + } + } + } + } + } + + @staticmethod + def add(a: int, b: int) -> int: + return a + b + + @staticmethod + def subtract(a: int, b: int) -> int: + return a - b + + @staticmethod + def multiply(a: int, b: int) -> int: + return a * b + + @staticmethod + def divide(a: int, b: int) -> float: + if b == 0: + raise ValueError("Division by zero is not allowed") + return a / b + + @staticmethod + def exponentiate(a: float, b: float) -> str: + result = math.pow(a, b) + return result + + @staticmethod + def factorial(n: int) -> int: + if n < 0: + raise ValueError("Attempt to calculate factorial of a negative number") + return math.factorial(n) + + @staticmethod + def is_prime(n: int) -> bool: + if n <= 1: + return False + for i in range(2, int(math.sqrt(n)) + 1): + if n % i == 0: + return False + + return True + + @staticmethod + def square_root(n: float) -> float: + if n < 0: + raise ValueError("Attempt to calculate square root of a negative number") + + return math.sqrt(n) + + @staticmethod + def call(command: str, argument1: int, argument2: int = None) -> str: + log.info(f"calculator, command: {command}") + + try: + if command == "add": + result = CalculatorTool.add(argument1, argument2) + + elif command == "subtract": + result = CalculatorTool.subtract(argument1, argument2) + + elif command == "multiply": + result = CalculatorTool.multiply(argument1, argument2) + + elif command == "divide": + if argument2 == 0: + return "Error: Division by zero" + result = CalculatorTool.divide(argument1, argument2) + + elif command == "exponentiate": + result = CalculatorTool.exponentiate(argument1, argument2) + + elif command == "factorial": + result = CalculatorTool.factorial(argument1) + + elif command == "is_prime": + result = CalculatorTool.is_prime(argument1) + + elif command == "square_root": + result = CalculatorTool.square_root(argument1) + + else: + return f"Error: Unknown command '{command}'" + + return str(result) + + except Exception as e: + log.error(f"Error executing command '{command}': {e}") + return f"Error executing command: {e}" From e982a6e778cc1b73a02c3dfbce9b738350b59b50 Mon Sep 17 00:00:00 2001 From: "rikulpatel@gmail.com" Date: Wed, 29 Apr 2026 22:32:37 -0500 Subject: [PATCH 12/84] fix: restart.sh forks/detaches itself before killing and restarting process --- restart.sh | 13 +++++++++---- 1 file changed, 9 insertions(+), 4 deletions(-) diff --git a/restart.sh b/restart.sh index e333eaf..d5ef32e 100755 --- a/restart.sh +++ b/restart.sh @@ -1,9 +1,14 @@ #!/bin/bash # Restart the background agent with the latest code. -# -# Run directly: ./restart.sh -# Run from agent bash tool (non-blocking): -# nohup ./restart.sh > /tmp/restart.log 2>&1 & echo "Restart initiated" +# Safe to call from within the running bot — detaches itself before killing the old process. + +# Self-detach: re-exec in a new session so the kill below won't take us down +if [ -z "$_RESTART_DETACHED" ]; then + _RESTART_DETACHED=1 nohup bash "$0" "$@" >> /tmp/restart.log 2>&1 & + disown $! + echo "[restart] Queued (PID $!). Logs: /tmp/restart.log" + exit 0 +fi set -e From 38062a0c443b4b73c18bc9734759d085a8f950dd Mon Sep 17 00:00:00 2001 From: "rikulpatel@gmail.com" Date: Wed, 29 Apr 2026 23:12:53 -0500 Subject: [PATCH 13/84] feat: added HackerNewsTool --- app/tool_calls.py | 4 +++- app/tools/hackernews.py | 51 +++++++++++++++++++++++++++++++++++++++++ 2 files changed, 54 insertions(+), 1 deletion(-) create mode 100755 app/tools/hackernews.py diff --git a/app/tool_calls.py b/app/tool_calls.py index 832c66b..ec0304b 100755 --- a/app/tool_calls.py +++ b/app/tool_calls.py @@ -9,6 +9,7 @@ from .tools.get_skills_dir import GetSkillsDirTool from .tools.todo import TodoAddTool, TodoListTool, TodoClearTool, TodoUpdateTool from .tools.calculator import CalculatorTool +from .tools.hackernews import HackerNewsTool import json @@ -22,7 +23,8 @@ "todo_list": TodoListTool, "todo_update": TodoUpdateTool, "todo_clear": TodoClearTool, - "calculator": CalculatorTool + "calculator": CalculatorTool, + "hackernews": HackerNewsTool } all_tool_specs = [tool.spec() for tool in tool_registry.values()] diff --git a/app/tools/hackernews.py b/app/tools/hackernews.py new file mode 100755 index 0000000..c613c89 --- /dev/null +++ b/app/tools/hackernews.py @@ -0,0 +1,51 @@ +import subprocess +from ..app_logging import log +from .tool import Tool + +import httpx +import json + +class HackerNewsTool(Tool): + + @staticmethod + def spec(): + return { + "type": "function", + "function": { + "name": "hackernews", + "description": "Hacker News stores from https://news.ycombinator.com/. Fetches the top stories from Hacker News", + "parameters": { + "type": "object", + "properties": { + "number_of_stories": { + "type": "int", + "description": "The number of top stories to fetch (default is 10)" + } + } + } + } + } + + @staticmethod + def call(number_of_stories : int = 10) -> str: + log.info(f"hackernews") + + try: + + response = httpx.get("https://hacker-news.firebaseio.com/v0/topstories.json") + story_ids = response.json() + + # Fetch story details + stories = [] + for story_id in story_ids[:number_of_stories]: + story_response = httpx.get(f"https://hacker-news.firebaseio.com/v0/item/{story_id}.json") + story = story_response.json() + if story is None: + continue + story["username"] = story.get("by", "unknown") + stories.append(story) + return json.dumps(stories) + + except Exception as e: + log.error(f"Error getting hackernews stories: {e}") + return f"Error getting hackernews stories: {e}" From be27ab04f9650ed4021cf56c9ebef22ddb90917e Mon Sep 17 00:00:00 2001 From: "rikulpatel@gmail.com" Date: Wed, 29 Apr 2026 23:28:27 -0500 Subject: [PATCH 14/84] updated sys_instructions.md --- app/sys_instructions.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/app/sys_instructions.md b/app/sys_instructions.md index f772cec..6e5390c 100644 --- a/app/sys_instructions.md +++ b/app/sys_instructions.md @@ -57,6 +57,8 @@ Code Reviews -> code-reviews/ - **todo_list**: List all tasks and their statuses - **todo_update**: Update a task's status (`task_id`, `status`: `todo` | `in_progress` | `done`) - **todo_clear**: Clear all todos when the work is complete +- **calculator**: Provides add, subtract, multiply, divide, exponentiate, factorial, is_prime, square_root +- **hackernews**: Hacker News stores from https://news.ycombinator.com/. Fetches the top stories from Hacker News ## Todo Tool Guidelines From 877588bcc05afbeed940aeb2ef596c73172de7f9 Mon Sep 17 00:00:00 2001 From: "rikulpatel@gmail.com" Date: Thu, 30 Apr 2026 21:00:28 -0500 Subject: [PATCH 15/84] feat: Added WebSearch* tools for text,images,video,news and books search --- app/sys_instructions.md | 5 ++ app/tool_calls.py | 15 +++- app/tools/web_search.py | 172 ++++++++++++++++++++++++++++++++++++++++ pyproject.toml | 2 + 4 files changed, 193 insertions(+), 1 deletion(-) create mode 100755 app/tools/web_search.py diff --git a/app/sys_instructions.md b/app/sys_instructions.md index 6e5390c..a9f6dac 100644 --- a/app/sys_instructions.md +++ b/app/sys_instructions.md @@ -59,6 +59,11 @@ Code Reviews -> code-reviews/ - **todo_clear**: Clear all todos when the work is complete - **calculator**: Provides add, subtract, multiply, divide, exponentiate, factorial, is_prime, square_root - **hackernews**: Hacker News stores from https://news.ycombinator.com/. Fetches the top stories from Hacker News +- **websearch_text**: Search the web for some `query` +- **websearch_images**: Search images for some `query` +- **websearch_videos**: Search videos for some `query` +- **websearch_news**: Search news for `query` +- **websearch_books**: Search books related to `query` ## Todo Tool Guidelines diff --git a/app/tool_calls.py b/app/tool_calls.py index ec0304b..ee719d1 100755 --- a/app/tool_calls.py +++ b/app/tool_calls.py @@ -11,6 +11,12 @@ from .tools.calculator import CalculatorTool from .tools.hackernews import HackerNewsTool +from .tools.web_search import WebSearchText +from .tools.web_search import WebSearchImages +from .tools.web_search import WebSearchVideos +from .tools.web_search import WebSearchNews +from .tools.web_search import WebSearchBooks + import json tool_registry = { @@ -24,7 +30,12 @@ "todo_update": TodoUpdateTool, "todo_clear": TodoClearTool, "calculator": CalculatorTool, - "hackernews": HackerNewsTool + "hackernews": HackerNewsTool, + "websearch_text": WebSearchText, + "websearch_images": WebSearchImages, + "websearch_videos": WebSearchVideos, + "websearch_news": WebSearchNews, + "websearch_books": WebSearchBooks } all_tool_specs = [tool.spec() for tool in tool_registry.values()] @@ -43,5 +54,7 @@ def run_tool(tool_name: str, tool_args: dict) -> str: finally: os.chdir(original_cwd) + if not isinstance(result, str): + result = json.dumps(result) return trunc_str_with_ellipsis(MAX_TOOL_RESULT_LENGTH, result) \ No newline at end of file diff --git a/app/tools/web_search.py b/app/tools/web_search.py new file mode 100755 index 0000000..f8e7e9e --- /dev/null +++ b/app/tools/web_search.py @@ -0,0 +1,172 @@ +from ..app_logging import log +from .tool import Tool + +from ddgs import DDGS + + +class WebSearchText(Tool): + @staticmethod + def spec(): + return { + "type": "function", + "function": { + "name": "websearch_text", + "description": "Web text search for text search queries.", + "parameters": { + "type": "object", + "properties": { + "query": { + "type": "string", + "description": "text search query" + } + } + } + } + } + + @staticmethod + def call(query: str, max_results : int = 10) -> list[dict[str, str]]: + log.info(f"WebSearchText: {query} {max_results}") + + try: + ddgs = DDGS() + results = ddgs.text(query, max_results=max_results, safesearch="off", timelimit="y") + return results + + except Exception as e: + log.error(f"Error performing web search: {e}") + return [{"error": f"Error performing web search: {e}"}] + + +class WebSearchImages(Tool): + @staticmethod + def spec(): + return { + "type": "function", + "function": { + "name": "websearch_images", + "description": "Web image search for image search queries.", + "parameters": { + "type": "object", + "properties": { + "query": { + "type": "string", + "description": "image search query" + } + } + } + } + } + + @staticmethod + def call(query: str, max_results : int = 10) -> list[dict[str, str]]: + log.info(f"WebSearchImages: {query} {max_results}") + + try: + ddgs = DDGS() + results = ddgs.images(query, max_results=max_results, safesearch="off") + return results + + except Exception as e: + log.error(f"Error performing web image search: {e}") + return [{"error": f"Error performing web image search: {e}"}] + + +class WebSearchVideos(Tool): + @staticmethod + def spec(): + return { + "type": "function", + "function": { + "name": "websearch_videos", + "description": "Web search for video search queries.", + "parameters": { + "type": "object", + "properties": { + "query": { + "type": "string", + "description": "video search query" + } + } + } + } + } + + @staticmethod + def call(query: str, max_results : int = 10) -> list[dict[str, str]]: + log.info(f"WebSearchVideos: {query} {max_results}") + + try: + ddgs = DDGS() + results = ddgs.videos(query, max_results=max_results, safesearch="off", timelimit="y") + return results + + except Exception as e: + log.error(f"Error performing web video search: {e}") + return [{"error": f"Error performing web video search: {e}"}] + +class WebSearchNews(Tool): + @staticmethod + def spec(): + return { + "type": "function", + "function": { + "name": "websearch_news", + "description": "Web search for news search queries.", + "parameters": { + "type": "object", + "properties": { + "query": { + "type": "string", + "description": "news search query" + } + } + } + } + } + + @staticmethod + def call(query: str, max_results : int = 10) -> list[dict[str, str]]: + log.info(f"WebSearchNews: {query} {max_results}") + + try: + ddgs = DDGS() + results = ddgs.news(query, max_results=max_results, safesearch="off", timelimit="y") + return results + + except Exception as e: + log.error(f"Error performing web news search: {e}") + return [{"error": f"Error performing web news search: {e}"}] + +class WebSearchBooks(Tool): + @staticmethod + def spec(): + return { + "type": "function", + "function": { + "name": "websearch_books", + "description": "Web search for book search queries.", + "parameters": { + "type": "object", + "properties": { + "query": { + "type": "string", + "description": "book search query" + } + } + } + } + } + + @staticmethod + def call(query: str, max_results : int = 10) -> list[dict[str, str]]: + log.info(f"WebSearchBooks: {query} {max_results}") + + try: + ddgs = DDGS() + results = ddgs.books(query, max_results=max_results) + return results + + except Exception as e: + log.error(f"Error performing web book search: {e}") + return [{"error": f"Error performing web book search: {e}"}] \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index c262968..376b77d 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -7,6 +7,7 @@ dependencies = [ "openai>=2.15.0", "requests>=2.32.5", "python-telegram-bot>=22.7", + "ddgs>=9.14.1", ] [dependency-groups] @@ -14,6 +15,7 @@ dev = [ "ruff", "pytest>=8.0.0", "pytest-asyncio>=0.24.0", + "ddgs>=9.14.1", ] [tool.pytest.ini_options] From 0bb718c46208357d4ed6e21ce796cbbfa3c124f8 Mon Sep 17 00:00:00 2001 From: "rikulpatel@gmail.com" Date: Fri, 1 May 2026 14:36:02 -0500 Subject: [PATCH 16/84] feat: added helper_agent.py for future use --- app/helper_agent.py | 72 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 72 insertions(+) create mode 100644 app/helper_agent.py diff --git a/app/helper_agent.py b/app/helper_agent.py new file mode 100644 index 0000000..148b10a --- /dev/null +++ b/app/helper_agent.py @@ -0,0 +1,72 @@ +from __future__ import annotations + +import json + +from . import config +from .tool_calls import run_tool, all_tool_specs +from .app_logging import log +from .agent import Agent + + +class HelperAgent(Agent): + + def __init__(self, system_prompt: str = None, max_iterations: int = 50) -> None: + super().__init__(max_iterations) + if system_prompt: + if self.messages and self.messages[0]["role"] == "system": + self.messages[0]["content"] = system_prompt + else: + self.messages.insert(0, {"role": "system", "content": system_prompt}) + + async def run(self, prompt: str) -> str: + log.info(f"Running HelperAgent with prompt: {prompt}") + return await self.agent_loop(prompt) + + async def agent_loop(self, message: str, metadata: dict = None) -> str: + self.messages.append({"role": "user", "content": message}) + iteration = 0 + assistant_message = None + + while iteration < self.max_iterations: + iteration += 1 + + log.info(f"HelperAgent iteration {iteration}") + chat = await self.client.chat.completions.create( + model=config.get("model", "deepseek/deepseek-v3.2"), + messages=self.messages, + tools=all_tool_specs + ) + + if not chat.choices: + raise RuntimeError("No choices in API response") + + choice = chat.choices[0] + assistant_message = choice.message + finish_reason = getattr(choice, "finish_reason", None) + if not isinstance(finish_reason, str): + finish_reason = None + + if assistant_message.tool_calls is not None: + self.messages.append(assistant_message) + + for tool_call in assistant_message.tool_calls: + try: + tool_name = tool_call.function.name + tool_args = json.loads(tool_call.function.arguments) + result = run_tool(tool_name=tool_name, tool_args=tool_args) + except Exception as e: + result = f"Error running tool {tool_name}: {str(e)}" + log.error(result) + + self.messages.append({ + "role": "tool", + "tool_call_id": tool_call.id, + "name": tool_name, + "content": result + }) + + else: + if finish_reason == "stop": + break + + return assistant_message.content.strip() if assistant_message and assistant_message.content else "" From fe4fa02b2c4fdf1243530f96d91f917a36279afb Mon Sep 17 00:00:00 2001 From: "rikulpatel@gmail.com" Date: Fri, 1 May 2026 15:43:07 -0500 Subject: [PATCH 17/84] refactor: added migration to rename history.db to app.db --- app/config.py | 1 + app/main.py | 5 ++++- app/message_history.py | 8 ++------ app/setup.py | 9 ++++++++- 4 files changed, 15 insertions(+), 8 deletions(-) diff --git a/app/config.py b/app/config.py index 950fa84..9f6191e 100644 --- a/app/config.py +++ b/app/config.py @@ -9,6 +9,7 @@ APP_NAME = "crafterscode" PROJECT_HOME = Path.home() / f".{APP_NAME}" HOME_CONFIG_PATH = PROJECT_HOME / "config.toml" +APP_DB = Path.home() / f".{APP_NAME}" / "app.db" def load(path: Path | str = HOME_CONFIG_PATH) -> None: global _config diff --git a/app/main.py b/app/main.py index bd6c5c5..043bbcd 100644 --- a/app/main.py +++ b/app/main.py @@ -7,7 +7,7 @@ from . import config from .app_logging import setup_logging, log -from .setup import ensure_home_dir +from .setup import ensure_home_dir, migrate_db_path from .cli import input_loop from .cli_agent import CliAgent from .bg_server import start_server @@ -87,9 +87,12 @@ async def run_background_agent(args): async def main(): ensure_home_dir() + await load_config() setup_logging(level=logging.INFO) + migrate_db_path() + args = parse_args() if args.command == "cli": diff --git a/app/message_history.py b/app/message_history.py index c3266a0..d13042e 100755 --- a/app/message_history.py +++ b/app/message_history.py @@ -4,17 +4,13 @@ from datetime import datetime from pathlib import Path from .app_logging import log -from .config import APP_NAME - -HISTORY_DB = Path.home() / f".{APP_NAME}" / "history.db" - +from .config import APP_NAME, APP_DB def _est_tokens(content: str) -> int: return max(1, len(content) // 4) - class MessageHistory: - def __init__(self, channel_type: str, db_path: Path = HISTORY_DB): + def __init__(self, channel_type: str, db_path: Path = APP_DB): self.db_path = db_path self.channel = channel_type self._ensure_db() diff --git a/app/setup.py b/app/setup.py index 0fb01db..70780e7 100755 --- a/app/setup.py +++ b/app/setup.py @@ -1,7 +1,7 @@ from __future__ import annotations from pathlib import Path -from .config import get_default_config, APP_NAME +from .config import get_default_config, APP_NAME, APP_DB from .app_logging import log def ensure_home_dir() -> None: @@ -28,3 +28,10 @@ def ensure_home_dir() -> None: with open(config_path, "w", encoding="utf-8") as f: f.write(default_config) log.info(f"Created default config.toml in home directory: {config_path}") + + +def migrate_db_path(): + old = Path.home() / f".{APP_NAME}" / "history.db" + if old.exists() and not APP_DB.exists(): + old.rename(APP_DB) + log.info(f"Migrated database: history.db → app.db") From 57c936004023fd37790c2f1879147099122442bb Mon Sep 17 00:00:00 2001 From: "rikulpatel@gmail.com" Date: Sat, 2 May 2026 16:04:18 -0500 Subject: [PATCH 18/84] chore: removed unused imports --- app/background_agent.py | 2 +- app/message_history.py | 2 +- app/setup.py | 2 +- app/telegram_channel.py | 1 - app/tools/calculator.py | 1 - app/tools/hackernews.py | 3 +-- 6 files changed, 4 insertions(+), 7 deletions(-) diff --git a/app/background_agent.py b/app/background_agent.py index 9ea0e93..5168f0e 100755 --- a/app/background_agent.py +++ b/app/background_agent.py @@ -6,7 +6,7 @@ from . import config from .tool_calls import run_tool, all_tool_specs from .app_logging import log -from .channel import Channel, ChannelType +from .channel import Channel from .message import OutgoingMessage from .message_queue import MessageQueue from .agent import Agent, MAX_CONTEXT_MESSAGES diff --git a/app/message_history.py b/app/message_history.py index d13042e..782ce06 100755 --- a/app/message_history.py +++ b/app/message_history.py @@ -4,7 +4,7 @@ from datetime import datetime from pathlib import Path from .app_logging import log -from .config import APP_NAME, APP_DB +from .config import APP_DB def _est_tokens(content: str) -> int: return max(1, len(content) // 4) diff --git a/app/setup.py b/app/setup.py index 70780e7..df31758 100755 --- a/app/setup.py +++ b/app/setup.py @@ -34,4 +34,4 @@ def migrate_db_path(): old = Path.home() / f".{APP_NAME}" / "history.db" if old.exists() and not APP_DB.exists(): old.rename(APP_DB) - log.info(f"Migrated database: history.db → app.db") + log.info("Migrated database: history.db → app.db") diff --git a/app/telegram_channel.py b/app/telegram_channel.py index 12bfc83..26d861d 100755 --- a/app/telegram_channel.py +++ b/app/telegram_channel.py @@ -4,7 +4,6 @@ from .message_queue import MessageQueue from .channel import Channel, ChannelType from .message import OutgoingMessage, IncomingMessage -from .helpers import trunc_str_with_ellipsis from telegram import Update, constants from telegram.ext import ( diff --git a/app/tools/calculator.py b/app/tools/calculator.py index fd91b4b..4e660a1 100755 --- a/app/tools/calculator.py +++ b/app/tools/calculator.py @@ -1,4 +1,3 @@ -import subprocess from ..app_logging import log from .tool import Tool import math diff --git a/app/tools/hackernews.py b/app/tools/hackernews.py index c613c89..75b0fe5 100755 --- a/app/tools/hackernews.py +++ b/app/tools/hackernews.py @@ -1,4 +1,3 @@ -import subprocess from ..app_logging import log from .tool import Tool @@ -28,7 +27,7 @@ def spec(): @staticmethod def call(number_of_stories : int = 10) -> str: - log.info(f"hackernews") + log.info(f"hackernews: number_of_stories: {number_of_stories}") try: From 258b72ae137c2297c5c5e8aa90f75c7ae35c7fea Mon Sep 17 00:00:00 2001 From: "rikulpatel@gmail.com" Date: Sat, 2 May 2026 19:33:27 -0500 Subject: [PATCH 19/84] feat: add scheduled tasks system with interval-based execution - app/scheduled_tasks.py: SQLite-backed ScheduledTasks class with tasks/task_outputs tables, last_run field for interval tracking, and async run() loop - app/tools/sched_tasks_tool.py: 6 tool wrappers (list, add, enable, disable, remove, get_output) for agent-driven task management - app/tool_calls.py: register scheduled task tools; add helper_tool_specs (excludes scheduled task tools to prevent circular import via HelperAgent) - app/helper_agent.py: lazy-import helper_tool_specs/run_tool inside agent_loop to break the circular dependency - app/bg_server.py: wire ScheduledTasks.run() into the main asyncio.gather - app/sys_instructions.md: document the 6 new scheduled task tools with example --- app/bg_server.py | 4 + app/helper_agent.py | 4 +- app/scheduled_tasks.py | 124 +++++++++++++++++++++ app/sys_instructions.md | 15 ++- app/tool_calls.py | 20 +++- app/tools/sched_tasks_tool.py | 198 ++++++++++++++++++++++++++++++++++ 6 files changed, 354 insertions(+), 11 deletions(-) create mode 100755 app/scheduled_tasks.py create mode 100755 app/tools/sched_tasks_tool.py diff --git a/app/bg_server.py b/app/bg_server.py index cd4a295..7b4cb47 100755 --- a/app/bg_server.py +++ b/app/bg_server.py @@ -5,6 +5,7 @@ from .app_logging import log from .background_agent import BackgroundAgent from .message_queue import MessageQueue +from .scheduled_tasks import ScheduledTasks async def start_server() -> None: @@ -36,8 +37,11 @@ async def start_server() -> None: telegram_channel.start() telegram_agent = BackgroundAgent(mq=mq, channel=telegram_channel) + tasks = ScheduledTasks() + await asyncio.gather( telegram_channel.run_polling(), telegram_agent.process_incoming(), mq.process_outgoing(), + tasks.run() ) \ No newline at end of file diff --git a/app/helper_agent.py b/app/helper_agent.py index 148b10a..16da0e3 100644 --- a/app/helper_agent.py +++ b/app/helper_agent.py @@ -3,7 +3,6 @@ import json from . import config -from .tool_calls import run_tool, all_tool_specs from .app_logging import log from .agent import Agent @@ -23,6 +22,7 @@ async def run(self, prompt: str) -> str: return await self.agent_loop(prompt) async def agent_loop(self, message: str, metadata: dict = None) -> str: + from .tool_calls import helper_tool_specs, run_tool self.messages.append({"role": "user", "content": message}) iteration = 0 assistant_message = None @@ -34,7 +34,7 @@ async def agent_loop(self, message: str, metadata: dict = None) -> str: chat = await self.client.chat.completions.create( model=config.get("model", "deepseek/deepseek-v3.2"), messages=self.messages, - tools=all_tool_specs + tools=helper_tool_specs ) if not chat.choices: diff --git a/app/scheduled_tasks.py b/app/scheduled_tasks.py new file mode 100755 index 0000000..3aa3ec2 --- /dev/null +++ b/app/scheduled_tasks.py @@ -0,0 +1,124 @@ +from __future__ import annotations + +from datetime import datetime, timedelta +from .app_logging import log +from .config import APP_DB +import sqlite3 +import asyncio +from .helper_agent import HelperAgent + + +TASKS_SYSTEM_PROMPT = """ +You are a background agent running periodic tasks. The user is not present. +Read your instructions and execute them. Be concise. +""" + +class ScheduledTasks: + def __init__(self): + self._init_tasks_db() + + def _init_tasks_db(self): + with sqlite3.connect(APP_DB) as conn: + conn.execute(""" + CREATE TABLE IF NOT EXISTS tasks ( + id INTEGER PRIMARY KEY AUTOINCREMENT, + name TEXT NOT NULL UNIQUE, + prompt TEXT NOT NULL, + enabled INTEGER NOT NULL DEFAULT 1, + created_at TEXT NOT NULL, + interval_mins INTEGER NOT NULL DEFAULT 1, + last_run TEXT + ) + """) + conn.execute(""" + CREATE TABLE IF NOT EXISTS task_outputs ( + id INTEGER PRIMARY KEY AUTOINCREMENT, + name TEXT NOT NULL, + prompt TEXT NOT NULL, + output TEXT NOT NULL, + timestamp TEXT NOT NULL + ) + """) + conn.commit() + + + def load_tasks(self) -> list[dict]: + query = "SELECT name, prompt, enabled, created_at, interval_mins, last_run FROM tasks" + with sqlite3.connect(APP_DB) as conn: + rows = conn.execute(query).fetchall() + + return [{"name": n, "prompt": p, "enabled": e, "created_at": c, "interval_mins": i, "last_run": r} + for n, p, e, c, i, r in rows] + + + def add_task(self, name: str, prompt: str, interval_mins: int = 1): + with sqlite3.connect(APP_DB) as conn: + try: + conn.execute(""" + INSERT INTO tasks (name, prompt, interval_mins, created_at) + VALUES (?, ?, ?, ?) + """, (name, prompt, interval_mins, datetime.now().isoformat())) + conn.commit() + except sqlite3.IntegrityError: + raise ValueError(f"Task '{name}' already exists") + + def remove_task(self, name: str): + with sqlite3.connect(APP_DB) as conn: + conn.execute("DELETE FROM tasks WHERE name = ?", (name,)) + conn.commit() + + def enable_task(self, name: str): + with sqlite3.connect(APP_DB) as conn: + conn.execute("UPDATE tasks SET enabled = 1 WHERE name = ?", (name,)) + conn.commit() + + def disable_task(self, name: str): + with sqlite3.connect(APP_DB) as conn: + conn.execute("UPDATE tasks SET enabled = 0 WHERE name = ?", (name,)) + conn.commit() + + + def save_output(self, name: str, prompt: str, output: str): + with sqlite3.connect(APP_DB) as conn: + conn.execute(""" + INSERT INTO task_outputs (name, prompt, output, timestamp) + VALUES (?, ?, ?, ?) + """, (name, prompt, output, datetime.now().isoformat())) + conn.commit() + + def get_output(self, name: str, num_entries: int = 5) -> list[dict]: + with sqlite3.connect(APP_DB) as conn: + rows = conn.execute(""" + SELECT prompt, output, timestamp FROM task_outputs + WHERE name = ? + ORDER BY id DESC LIMIT ? + """, (name, num_entries)).fetchall() + return [{"prompt": p, "output": o, "timestamp": t} for p, o, t in reversed(rows)] + + def _update_last_run(self, name: str, ts: str): + with sqlite3.connect(APP_DB) as conn: + conn.execute("UPDATE tasks SET last_run = ? WHERE name = ?", (ts, name)) + conn.commit() + + def _is_due(self, task: dict, now: datetime) -> bool: + baseline = task["last_run"] or task["created_at"] + last = datetime.fromisoformat(baseline) + return (now - last) >= timedelta(minutes=task["interval_mins"]) + + async def run_task(self, name: str, prompt: str) -> str: + log.info(f"Running scheduled task '{name}'") + agent = HelperAgent(system_prompt=TASKS_SYSTEM_PROMPT) + output = await agent.agent_loop(prompt) + ts = datetime.now().isoformat() + self.save_output(name=name, prompt=prompt, output=output) + self._update_last_run(name=name, ts=ts) + return output + + async def run(self): + while True: + now = datetime.now() + tasks = self.load_tasks() + due = [t for t in tasks if t["enabled"] and self._is_due(t, now)] + if due: + await asyncio.gather(*[self.run_task(t["name"], t["prompt"]) for t in due]) + await asyncio.sleep(60) \ No newline at end of file diff --git a/app/sys_instructions.md b/app/sys_instructions.md index a9f6dac..73dde07 100644 --- a/app/sys_instructions.md +++ b/app/sys_instructions.md @@ -64,20 +64,19 @@ Code Reviews -> code-reviews/ - **websearch_videos**: Search videos for some `query` - **websearch_news**: Search news for `query` - **websearch_books**: Search books related to `query` - -## Todo Tool Guidelines +- **list_scheduled_tasks**: List all background scheduled tasks +- **add_scheduled_task**: Add a new background scheduled task (`name`, `prompt`, `interval_minutes`) + - Example: `add_scheduled_task(name="morning-news", prompt="Fetch the top 5 HackerNews stories and summarize them", interval_minutes=60)` +- **enable_scheduled_task**: Re-enable a previously disabled scheduled task (`name`) +- **disable_scheduled_task**: Temporarily disable a scheduled task without removing it (`name`) +- **remove_scheduled_task**: Permanently remove a scheduled task (`name`) +- **get_scheduled_task_output**: Get recent output from a scheduled task (`name`, optional `num_entries`, default 5) **✅ Use Todo Tools For:** - **Long-running tasks** that span multiple steps - **Complex projects** where progress needs tracking - **Multi-phase work** with dependencies between steps - **Large refactoring** where you need to track what's been done -- -**❌ Don't Use Todo Tools For:** -- Simple one-off commands -- Tasks that complete within a few tool calls -- When working memory alone is sufficient -- For tasks that should persist beyond the current session # Quality Checks - Validate tool outputs before using them diff --git a/app/tool_calls.py b/app/tool_calls.py index ee719d1..bde0120 100755 --- a/app/tool_calls.py +++ b/app/tool_calls.py @@ -17,6 +17,9 @@ from .tools.web_search import WebSearchNews from .tools.web_search import WebSearchBooks +from .tools.sched_tasks_tool import ListScheduledTasks, AddScheduledTask, DisableScheduledTask, \ + RemoveScheduledTask, GetScheduledTaskOutput, EnableScheduledTask + import json tool_registry = { @@ -25,21 +28,35 @@ "bash": BashTool, "web_fetch": WebFetchTool, "get_skills_dir": GetSkillsDirTool, + "todo_add": TodoAddTool, "todo_list": TodoListTool, "todo_update": TodoUpdateTool, "todo_clear": TodoClearTool, + "calculator": CalculatorTool, "hackernews": HackerNewsTool, + "websearch_text": WebSearchText, "websearch_images": WebSearchImages, "websearch_videos": WebSearchVideos, "websearch_news": WebSearchNews, - "websearch_books": WebSearchBooks + "websearch_books": WebSearchBooks, + + "list_scheduled_tasks": ListScheduledTasks, + "add_scheduled_task": AddScheduledTask, + "disable_scheduled_task": DisableScheduledTask, + "enable_scheduled_task": EnableScheduledTask, + "remove_scheduled_task": RemoveScheduledTask, + "get_scheduled_task_output": GetScheduledTaskOutput } all_tool_specs = [tool.spec() for tool in tool_registry.values()] +_SCHED_TOOLS = {"list_scheduled_tasks", "add_scheduled_task", "enable_scheduled_task", + "disable_scheduled_task", "remove_scheduled_task", "get_scheduled_task_output"} +helper_tool_specs = [tool.spec() for k, tool in tool_registry.items() if k not in _SCHED_TOOLS] + MAX_TOOL_RESULT_LENGTH = 16000 def run_tool(tool_name: str, tool_args: dict) -> str: @@ -56,5 +73,6 @@ def run_tool(tool_name: str, tool_args: dict) -> str: if not isinstance(result, str): result = json.dumps(result) + return trunc_str_with_ellipsis(MAX_TOOL_RESULT_LENGTH, result) \ No newline at end of file diff --git a/app/tools/sched_tasks_tool.py b/app/tools/sched_tasks_tool.py new file mode 100755 index 0000000..1c81fff --- /dev/null +++ b/app/tools/sched_tasks_tool.py @@ -0,0 +1,198 @@ +from ..app_logging import log +from .tool import Tool +from ..scheduled_tasks import ScheduledTasks + +class ListScheduledTasks(Tool): + + @staticmethod + def spec(): + return { + "type": "function", + "function": { + "name": "list_scheduled_tasks", + "description": "List all background scheduled tasks", + "parameters": { + "type": "object", + "properties": {} + } + } + } + + @staticmethod + def call() -> str: + log.info("list_scheduled_tasks called") + + tasks = ScheduledTasks().load_tasks() + if not tasks: + return "No scheduled tasks found." + + return tasks + + +class AddScheduledTask(Tool): + + @staticmethod + def spec(): + return { + "type": "function", + "function": { + "name": "add_scheduled_task", + "description": "Add a new background scheduled task that will be executed at intervals by the background agent with your prompt", + "parameters": { + "type": "object", + "properties": { + "name": { + "type": "string", + "description": "A name for the scheduled task" + }, + "prompt": { + "type": "string", + "description": "The prompt that will be executed at intervals by the background agent" + }, + "interval_minutes": { + "type": "integer", + "description": "The interval in minutes at which the background agent will execute the prompt" + } + }, + "required": ["name", "prompt", "interval_minutes"] + } + } + } + + @staticmethod + def call(name: str, prompt: str, interval_minutes: int) -> str: + log.info("add_scheduled_task called") + + tasks = ScheduledTasks() + tasks.add_task(name=name, prompt=prompt, interval_mins=interval_minutes) + + return f"Added scheduled task '{name}' with interval {interval_minutes} minutes" + +class RemoveScheduledTask(Tool): + + @staticmethod + def spec(): + return { + "type": "function", + "function": { + "name": "remove_scheduled_task", + "description": "Remove a background scheduled task so that it will no longer be executed by the background agent", + "parameters": { + "type": "object", + "properties": { + "name": { + "type": "string", + "description": "The name of the scheduled task to remove" + } + }, + "required": ["name"] + } + } + } + + @staticmethod + def call(name: str) -> str: + log.info("remove_scheduled_task called") + + ScheduledTasks().remove_task(name) + + return f"Removed scheduled task '{name}'" + + +class DisableScheduledTask(Tool): + + @staticmethod + def spec(): + return { + "type": "function", + "function": { + "name": "disable_scheduled_task", + "description": "Disable a background scheduled task so that it will temporarily stop being executed by the background agent without being removed", + "parameters": { + "type": "object", + "properties": { + "name": { + "type": "string", + "description": "The name of the scheduled task to deactivate" + } + }, + "required": ["name"] + } + } + } + + @staticmethod + def call(name: str) -> str: + log.info("disable_scheduled_task called") + + ScheduledTasks().disable_task(name) + + return f"Disabled scheduled task '{name}'" + + +class EnableScheduledTask(Tool): + + @staticmethod + def spec(): + return { + "type": "function", + "function": { + "name": "enable_scheduled_task", + "description": "Enable a background scheduled task that was previously disabled so that it will resume being executed by the background agent", + "parameters": { + "type": "object", + "properties": { + "name": { + "type": "string", + "description": "The name of the scheduled task to enable" + } + }, + "required": ["name"] + } + } + } + + @staticmethod + def call(name: str) -> str: + log.info("enable_scheduled_task called") + + ScheduledTasks().enable_task(name) + + return f"Enabled scheduled task '{name}'" + +class GetScheduledTaskOutput(Tool): + + @staticmethod + def spec(): + return { + "type": "function", + "function": { + "name": "get_scheduled_task_output", + "description": "Get the output from a scheduled task that is executed by the background agent." + "This can be used to check the results of the scheduled task prompts", + "parameters": { + "type": "object", + "properties": { + "name": { + "type": "string", + "description": "The name of the scheduled task to get output for" + }, + "num_entries": { + "type": "integer", + "description": "The number of recent output entries to return for the specified scheduled task (default: 5)" + } + }, + "required": ["name"] + } + } + } + + @staticmethod + def call(name: str, num_entries: int = 5) -> str: + log.info("get_scheduled_task_output called") + + tasks = ScheduledTasks() + output = tasks.get_output(name=name, num_entries=num_entries) + + return output if output else f"No output found for scheduled task '{name}'" + \ No newline at end of file From cb2732a47342226ca1bee8141a6313c2fbc3a120 Mon Sep 17 00:00:00 2001 From: "rikulpatel@gmail.com" Date: Sun, 3 May 2026 20:48:03 -0500 Subject: [PATCH 20/84] feat: added next_run, delivery_channel, run_count to tasks --- app/bg_server.py | 3 +- app/scheduled_tasks.py | 126 +++++++++++++++++++++++++--------- app/tools/sched_tasks_tool.py | 26 +++++-- 3 files changed, 114 insertions(+), 41 deletions(-) diff --git a/app/bg_server.py b/app/bg_server.py index 7b4cb47..86b4a1c 100755 --- a/app/bg_server.py +++ b/app/bg_server.py @@ -37,7 +37,8 @@ async def start_server() -> None: telegram_channel.start() telegram_agent = BackgroundAgent(mq=mq, channel=telegram_channel) - tasks = ScheduledTasks() + channels = {"telegram": telegram_channel} if telegram_channel else {} + tasks = ScheduledTasks(mq=mq, channels=channels) await asyncio.gather( telegram_channel.run_polling(), diff --git a/app/scheduled_tasks.py b/app/scheduled_tasks.py index 3aa3ec2..ca47f7c 100755 --- a/app/scheduled_tasks.py +++ b/app/scheduled_tasks.py @@ -14,54 +14,87 @@ """ class ScheduledTasks: - def __init__(self): + def __init__(self, mq=None, channels: dict = None): + self._mq = mq + self._channels = channels or {} self._init_tasks_db() + def _migrate(self, conn, table: str, columns: list[tuple[str, str]]): + existing = {row[1] for row in conn.execute(f"PRAGMA table_info({table})").fetchall()} + for col_name, col_def in columns: + if col_name not in existing: + conn.execute(f"ALTER TABLE {table} ADD COLUMN {col_name} {col_def}") + def _init_tasks_db(self): with sqlite3.connect(APP_DB) as conn: + conn.execute(""" CREATE TABLE IF NOT EXISTS tasks ( id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT NOT NULL UNIQUE, prompt TEXT NOT NULL, enabled INTEGER NOT NULL DEFAULT 1, - created_at TEXT NOT NULL, + repeat INTEGER NOT NULL DEFAULT 0, interval_mins INTEGER NOT NULL DEFAULT 1, - last_run TEXT + last_run TEXT, + next_run TEXT NOT NULL, + delivery_channel TEXT NOT NULL DEFAULT 'telegram', + run_count INTEGER NOT NULL DEFAULT 0, + created_at TEXT NOT NULL ) """) + conn.execute(""" CREATE TABLE IF NOT EXISTS task_outputs ( id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT NOT NULL, prompt TEXT NOT NULL, output TEXT NOT NULL, + status TEXT NOT NULL DEFAULT 'success', + duration_secs REAL, timestamp TEXT NOT NULL ) """) + + self._migrate(conn, "tasks", [ + ("repeat", "INTEGER NOT NULL DEFAULT 0"), + ("next_run", "TEXT NOT NULL DEFAULT '1970-01-01T00:00:00'"), + ("delivery_channel", "TEXT NOT NULL DEFAULT 'telegram'"), + ("run_count", "INTEGER NOT NULL DEFAULT 0"), + ]) + self._migrate(conn, "task_outputs", [ + ("status", "TEXT NOT NULL DEFAULT 'success'"), + ("duration_secs", "REAL"), + ]) conn.commit() def load_tasks(self) -> list[dict]: - query = "SELECT name, prompt, enabled, created_at, interval_mins, last_run FROM tasks" + query = """SELECT name, prompt, enabled, repeat, interval_mins, + last_run, next_run, delivery_channel, run_count, created_at + FROM tasks""" with sqlite3.connect(APP_DB) as conn: rows = conn.execute(query).fetchall() - return [{"name": n, "prompt": p, "enabled": e, "created_at": c, "interval_mins": i, "last_run": r} - for n, p, e, c, i, r in rows] + return [{"name": n, "prompt": p, "enabled": e, "repeat": rpt, + "interval_mins": i, "last_run": lr, "next_run": nr, + "delivery_channel": dc, "run_count": rc, "created_at": c} + for n, p, e, rpt, i, lr, nr, dc, rc, c in rows] - def add_task(self, name: str, prompt: str, interval_mins: int = 1): + def add_task(self, name: str, prompt: str, interval_mins: int = 1, + repeat: int = 0, next_run: str = None, delivery_channel: str = "telegram"): + now = datetime.now().isoformat() with sqlite3.connect(APP_DB) as conn: try: conn.execute(""" - INSERT INTO tasks (name, prompt, interval_mins, created_at) - VALUES (?, ?, ?, ?) - """, (name, prompt, interval_mins, datetime.now().isoformat())) + INSERT INTO tasks (name, prompt, interval_mins, repeat, next_run, delivery_channel, created_at) + VALUES (?, ?, ?, ?, ?, ?, ?) + """, (name, prompt, interval_mins, repeat, next_run or now, delivery_channel, now)) conn.commit() except sqlite3.IntegrityError: raise ValueError(f"Task '{name}' already exists") - + def remove_task(self, name: str): with sqlite3.connect(APP_DB) as conn: conn.execute("DELETE FROM tasks WHERE name = ?", (name,)) @@ -77,41 +110,66 @@ def disable_task(self, name: str): conn.execute("UPDATE tasks SET enabled = 0 WHERE name = ?", (name,)) conn.commit() - - def save_output(self, name: str, prompt: str, output: str): + def save_output(self, name: str, prompt: str, output: str, + status: str = "success", duration_secs: float = None): with sqlite3.connect(APP_DB) as conn: conn.execute(""" - INSERT INTO task_outputs (name, prompt, output, timestamp) - VALUES (?, ?, ?, ?) - """, (name, prompt, output, datetime.now().isoformat())) + INSERT INTO task_outputs (name, prompt, output, status, duration_secs, timestamp) + VALUES (?, ?, ?, ?, ?, ?) + """, (name, prompt, output, status, duration_secs, datetime.now().isoformat())) conn.commit() def get_output(self, name: str, num_entries: int = 5) -> list[dict]: with sqlite3.connect(APP_DB) as conn: rows = conn.execute(""" - SELECT prompt, output, timestamp FROM task_outputs + SELECT prompt, output, status, duration_secs, timestamp FROM task_outputs WHERE name = ? ORDER BY id DESC LIMIT ? """, (name, num_entries)).fetchall() - return [{"prompt": p, "output": o, "timestamp": t} for p, o, t in reversed(rows)] - - def _update_last_run(self, name: str, ts: str): - with sqlite3.connect(APP_DB) as conn: - conn.execute("UPDATE tasks SET last_run = ? WHERE name = ?", (ts, name)) - conn.commit() + return [{"prompt": p, "output": o, "status": s, "duration_secs": d, "timestamp": t} + for p, o, s, d, t in reversed(rows)] + + def _after_run(self, task: dict, now: datetime): + name = task["name"] + if task["repeat"]: + next_run = (now + timedelta(minutes=task["interval_mins"])).isoformat() + with sqlite3.connect(APP_DB) as conn: + conn.execute("""UPDATE tasks SET last_run = ?, next_run = ?, run_count = run_count + 1 + WHERE name = ?""", (now.isoformat(), next_run, name)) + conn.commit() + else: + self.remove_task(name) def _is_due(self, task: dict, now: datetime) -> bool: - baseline = task["last_run"] or task["created_at"] - last = datetime.fromisoformat(baseline) - return (now - last) >= timedelta(minutes=task["interval_mins"]) + return now >= datetime.fromisoformat(task["next_run"]) - async def run_task(self, name: str, prompt: str) -> str: + async def run_task(self, task: dict) -> str: + name, prompt = task["name"], task["prompt"] log.info(f"Running scheduled task '{name}'") - agent = HelperAgent(system_prompt=TASKS_SYSTEM_PROMPT) - output = await agent.agent_loop(prompt) - ts = datetime.now().isoformat() - self.save_output(name=name, prompt=prompt, output=output) - self._update_last_run(name=name, ts=ts) + start = datetime.now() + status = "success" + output = "" + try: + agent = HelperAgent(system_prompt=TASKS_SYSTEM_PROMPT) + output = await agent.agent_loop(prompt) + except Exception as e: + status = "error" + output = str(e) + log.error(f"Scheduled task '{name}' failed: {e}") + finally: + duration = (datetime.now() - start).total_seconds() + self.save_output(name=name, prompt=prompt, output=output, + status=status, duration_secs=duration) + self._after_run(task=task, now=datetime.now()) + + if self._mq: + channel = self._channels.get(task["delivery_channel"]) + if channel: + from .message import OutgoingMessage + await self._mq.outgoing_msg(OutgoingMessage(content=output, channel=channel)) + else: + log.warning(f"Delivery channel '{task['delivery_channel']}' not found for task '{name}'") + return output async def run(self): @@ -120,5 +178,5 @@ async def run(self): tasks = self.load_tasks() due = [t for t in tasks if t["enabled"] and self._is_due(t, now)] if due: - await asyncio.gather(*[self.run_task(t["name"], t["prompt"]) for t in due]) - await asyncio.sleep(60) \ No newline at end of file + await asyncio.gather(*[self.run_task(t) for t in due]) + await asyncio.sleep(60) diff --git a/app/tools/sched_tasks_tool.py b/app/tools/sched_tasks_tool.py index 1c81fff..2733df7 100755 --- a/app/tools/sched_tasks_tool.py +++ b/app/tools/sched_tasks_tool.py @@ -51,7 +51,19 @@ def spec(): }, "interval_minutes": { "type": "integer", - "description": "The interval in minutes at which the background agent will execute the prompt" + "description": "The interval in minutes between executions (only used when repeat=true)" + }, + "repeat": { + "type": "boolean", + "description": "Whether to repeat the task at the given interval. False means run once. Defaults to false." + }, + "next_run": { + "type": "string", + "description": "ISO 8601 datetime for the first run (e.g. '2026-05-03T09:00:00'). Defaults to now." + }, + "delivery_channel": { + "type": "string", + "description": "Channel to deliver the task output to. Defaults to 'telegram'." } }, "required": ["name", "prompt", "interval_minutes"] @@ -60,13 +72,15 @@ def spec(): } @staticmethod - def call(name: str, prompt: str, interval_minutes: int) -> str: + def call(name: str, prompt: str, interval_minutes: int, + repeat: bool = False, next_run: str = None, delivery_channel: str = "telegram") -> str: log.info("add_scheduled_task called") - - tasks = ScheduledTasks() - tasks.add_task(name=name, prompt=prompt, interval_mins=interval_minutes) - return f"Added scheduled task '{name}' with interval {interval_minutes} minutes" + ScheduledTasks().add_task(name=name, prompt=prompt, interval_mins=interval_minutes, + repeat=int(repeat), next_run=next_run, delivery_channel=delivery_channel) + + suffix = f" every {interval_minutes} minutes" if repeat else " (runs once)" + return f"Added scheduled task '{name}'{suffix}" class RemoveScheduledTask(Tool): From af1c5428ef27fb0b42d82739c0f0af75f033ee65 Mon Sep 17 00:00:00 2001 From: "rikulpatel@gmail.com" Date: Sun, 3 May 2026 22:33:06 -0500 Subject: [PATCH 21/84] fix: added _serialize_assistant_msg for asst msg. fixes deepseek v4 reasoning_content error --- app/agent.py | 10 ++++++++++ app/background_agent.py | 4 ++-- app/cli_agent.py | 4 ++-- app/helper_agent.py | 2 +- 4 files changed, 15 insertions(+), 5 deletions(-) diff --git a/app/agent.py b/app/agent.py index 2071aae..ed212fd 100755 --- a/app/agent.py +++ b/app/agent.py @@ -29,6 +29,16 @@ def _trim_messages(self) -> None: if len(rest) > MAX_CONTEXT_MESSAGES: self.messages = system + rest[-MAX_CONTEXT_MESSAGES:] + @staticmethod + def _serialize_assistant_msg(msg) -> dict: + d = {"role": msg.role, "content": msg.content} + if msg.tool_calls: + d["tool_calls"] = [tc.model_dump() for tc in msg.tool_calls] + reasoning = getattr(msg, "reasoning_content", None) or getattr(msg, "reasoning", None) + if reasoning is not None: + d["reasoning_content"] = reasoning + return d + @abstractmethod async def agent_loop(self, message: str, metadata: dict = None) -> None: pass diff --git a/app/background_agent.py b/app/background_agent.py index 5168f0e..465ec44 100755 --- a/app/background_agent.py +++ b/app/background_agent.py @@ -74,7 +74,7 @@ async def agent_loop(self, message: str, metadata: dict = None) -> None: finish_reason = None if assistant_message.tool_calls is not None: - session_messages.append(assistant_message) + session_messages.append(self._serialize_assistant_msg(assistant_message)) llm_text = assistant_message.content.strip().rstrip(":").strip() if assistant_message.content else "" @@ -110,7 +110,7 @@ async def agent_loop(self, message: str, metadata: dict = None) -> None: await self.mq.outgoing_msg(OutgoingMessage(content=assistant_message.content.strip(), channel=self.channel, metadata=self._reply_metadata)) if finish_reason == "stop": - session_messages.append(assistant_message) + session_messages.append(self._serialize_assistant_msg(assistant_message)) break if self.channel.has_stopped: diff --git a/app/cli_agent.py b/app/cli_agent.py index 6ff16f9..5231763 100755 --- a/app/cli_agent.py +++ b/app/cli_agent.py @@ -46,7 +46,7 @@ async def agent_loop(self, message: str, metadata: dict = None) -> None: finish_reason = None if assistant_message.tool_calls is not None: - session_messages.append(assistant_message) + session_messages.append(self._serialize_assistant_msg(assistant_message)) if not self.silent and assistant_message.content is not None and assistant_message.content.strip() != "": print(assistant_message.content.strip()) @@ -87,7 +87,7 @@ async def agent_loop(self, message: str, metadata: dict = None) -> None: print(assistant_message.content) if finish_reason == "stop": - session_messages.append(assistant_message) + session_messages.append(self._serialize_assistant_msg(assistant_message)) break if len(session_messages) >= 2: # only add to history if there's something beyond the initial user message and assistant response diff --git a/app/helper_agent.py b/app/helper_agent.py index 16da0e3..74e6fa8 100644 --- a/app/helper_agent.py +++ b/app/helper_agent.py @@ -47,7 +47,7 @@ async def agent_loop(self, message: str, metadata: dict = None) -> str: finish_reason = None if assistant_message.tool_calls is not None: - self.messages.append(assistant_message) + self.messages.append(self._serialize_assistant_msg(assistant_message)) for tool_call in assistant_message.tool_calls: try: From 5ef98162652c67ded17f11e4eff541e99b3ef4ee Mon Sep 17 00:00:00 2001 From: "rikulpatel@gmail.com" Date: Sun, 3 May 2026 22:55:54 -0500 Subject: [PATCH 22/84] updated sys_instructions.md --- app/sys_instructions.md | 102 ++++++++++++++++++++++++---------------- 1 file changed, 61 insertions(+), 41 deletions(-) diff --git a/app/sys_instructions.md b/app/sys_instructions.md index 73dde07..4c3ef41 100644 --- a/app/sys_instructions.md +++ b/app/sys_instructions.md @@ -1,4 +1,5 @@ # User Preferences + - **Verbosity**: detailed - **Technical Level**: advanced - **Code Style**: @@ -12,6 +13,61 @@ - **Logging**: Include appropriate logging statements - **Show Examples**: Yes - provide concrete examples - Optimize for readability over cleverness. +- Validate tool outputs before using them +- Verify file creation succeeded +- Check command exit codes + +## Error Recovery +1. Identify the failure point +2. Check error messages for root cause +3. Try alternative approach if available +4. Inform user clearly if task cannot be completed +5. Suggest manual steps if automation fails + +------------------------------------------------------------------------------- + +# Tool Usage Rules + +> **Always re-run tools to verify results.** Never assume a previous tool output is still valid — state changes, file writes, and task updates must be confirmed by running the relevant tool again (e.g. after writing a file, read it back; after adding a task, call `list_scheduled_tasks` to confirm it appears). + +------------------------------------------------------------------------------- + +# Available Tools + +- **bash**: Execute shell commands +- **read_file**: Read existing files +- **write_file**: Create or overwrite files +- **web_fetch**: Retrieve content from specific URLs +- **todo_add**: Add a task to the todo list (`title`, optional `description`) +- **todo_list**: List all tasks and their statuses +- **todo_update**: Update a task's status (`task_id`, `status`: `todo` | `in_progress` | `done`) +- **todo_clear**: Clear all todos when the work is complete +- **calculator**: Provides add, subtract, multiply, divide, exponentiate, factorial, is_prime, square_root +- **hackernews**: Hacker News stores from https://news.ycombinator.com/. Fetches the top stories from Hacker News +- **websearch_text**: Search the web for some `query` +- **websearch_images**: Search images for some `query` +- **websearch_videos**: Search videos for some `query` +- **websearch_news**: Search news for `query` +- **websearch_books**: Search books related to `query` +- **list_scheduled_tasks**: List all background scheduled tasks +- **add_scheduled_task**: Add a new background scheduled task (`name`, `prompt`, `interval_minutes`, optional `repeat`, `next_run`, `delivery_channel`) + - Example (repeat every hour): `add_scheduled_task(name="morning-news", prompt="Fetch the top 5 HackerNews stories and summarize them", interval_minutes=60, repeat=true, delivery_channel="telegram")` + - Example (run once at a specific time): `add_scheduled_task(name="reminder", prompt="Remind the user to take a break", interval_minutes=0, repeat=false, next_run="2026-05-04T15:00:00")` +- **enable_scheduled_task**: Re-enable a previously disabled scheduled task (`name`) + - Example: `enable_scheduled_task(name="morning-news")` +- **disable_scheduled_task**: Temporarily disable a scheduled task without removing it (`name`) + - Example: `disable_scheduled_task(name="morning-news")` +- **remove_scheduled_task**: Permanently remove a scheduled task (`name`) +- **get_scheduled_task_output**: Get recent output from a scheduled task (`name`, optional `num_entries`, default 5) + - Example: `get_scheduled_task_output(name="morning-news", num_entries=3)` + +**✅ Use Todo Tools For:** +- **Long-running tasks** that span multiple steps +- **Complex projects** where progress needs tracking +- **Multi-phase work** with dependencies between steps +- **Large refactoring** where you need to track what's been done + +------------------------------------------------------------------------------- # Planning Mode Always create a plan for apps or projects that are not simple one-shot Python scripts. Then ask for clarification and permission to proceed. @@ -22,6 +78,9 @@ Simple scripts like "Write a script to create fib numbers" — just implement th **Create a plan for:** Everything else (web apps, APIs, multi-file projects, database integrations, etc.) + +------------------------------------------------------------------------------- + # Workspace Configuration The workspace directory is your persistent storage area for project files, data, and outputs that need to survive across sessions. The workspace is in the `.crafterscode/workspace` directory in the user's home. On Linux based system, this will be in $HOME/.crafterscode/workspace. @@ -41,54 +100,15 @@ Code Reviews -> code-reviews/ - Documentation and knowledge base - Templates for recurring tasks -## Organization +## Workspace Organization 1. **Use descriptive names**: `customer-analysis-2024` not `proj1` 2. **Group related files**: Keep project files together 3. **Separate concerns**: Code in src/, data in data/, docs in docs/ 4. **Version important files**: Use timestamps or version numbers 5. **Document structure**: Include README.md in project folders -# Available Tools -- **bash**: Execute shell commands -- **read_file**: Read existing files -- **write_file**: Create or overwrite files -- **web_fetch**: Retrieve content from specific URLs -- **todo_add**: Add a task to the todo list (`title`, optional `description`) -- **todo_list**: List all tasks and their statuses -- **todo_update**: Update a task's status (`task_id`, `status`: `todo` | `in_progress` | `done`) -- **todo_clear**: Clear all todos when the work is complete -- **calculator**: Provides add, subtract, multiply, divide, exponentiate, factorial, is_prime, square_root -- **hackernews**: Hacker News stores from https://news.ycombinator.com/. Fetches the top stories from Hacker News -- **websearch_text**: Search the web for some `query` -- **websearch_images**: Search images for some `query` -- **websearch_videos**: Search videos for some `query` -- **websearch_news**: Search news for `query` -- **websearch_books**: Search books related to `query` -- **list_scheduled_tasks**: List all background scheduled tasks -- **add_scheduled_task**: Add a new background scheduled task (`name`, `prompt`, `interval_minutes`) - - Example: `add_scheduled_task(name="morning-news", prompt="Fetch the top 5 HackerNews stories and summarize them", interval_minutes=60)` -- **enable_scheduled_task**: Re-enable a previously disabled scheduled task (`name`) -- **disable_scheduled_task**: Temporarily disable a scheduled task without removing it (`name`) -- **remove_scheduled_task**: Permanently remove a scheduled task (`name`) -- **get_scheduled_task_output**: Get recent output from a scheduled task (`name`, optional `num_entries`, default 5) - -**✅ Use Todo Tools For:** -- **Long-running tasks** that span multiple steps -- **Complex projects** where progress needs tracking -- **Multi-phase work** with dependencies between steps -- **Large refactoring** where you need to track what's been done - -# Quality Checks -- Validate tool outputs before using them -- Verify file creation succeeded -- Check command exit codes -# Error Recovery -1. Identify the failure point -2. Check error messages for root cause -3. Try alternative approach if available -4. Inform user clearly if task cannot be completed -5. Suggest manual steps if automation fails +------------------------------------------------------------------------------- # Skill System Skills provide expert guidance for specialized tasks. Skills are located at `/skills/{skill-name}/SKILL.md` From e2fc8d1c014c3e51a457bb904e38d1d382441944 Mon Sep 17 00:00:00 2001 From: "rikulpatel@gmail.com" Date: Sun, 3 May 2026 23:07:46 -0500 Subject: [PATCH 23/84] fix: telegram delivery was missing allow_from/chat_id metadata. --- app/bg_server.py | 4 +++- app/scheduled_tasks.py | 5 +++-- 2 files changed, 6 insertions(+), 3 deletions(-) diff --git a/app/bg_server.py b/app/bg_server.py index 86b4a1c..a77ee3b 100755 --- a/app/bg_server.py +++ b/app/bg_server.py @@ -38,7 +38,9 @@ async def start_server() -> None: telegram_agent = BackgroundAgent(mq=mq, channel=telegram_channel) channels = {"telegram": telegram_channel} if telegram_channel else {} - tasks = ScheduledTasks(mq=mq, channels=channels) + allow_from = config.telegram.get("ALLOW_FROM", []) if config.get("telegram") else [] + default_metadata = {"chat_id": allow_from[0]} if allow_from else {} + tasks = ScheduledTasks(mq=mq, channels=channels, default_metadata=default_metadata) await asyncio.gather( telegram_channel.run_polling(), diff --git a/app/scheduled_tasks.py b/app/scheduled_tasks.py index ca47f7c..310977e 100755 --- a/app/scheduled_tasks.py +++ b/app/scheduled_tasks.py @@ -14,9 +14,10 @@ """ class ScheduledTasks: - def __init__(self, mq=None, channels: dict = None): + def __init__(self, mq=None, channels: dict = None, default_metadata: dict = None): self._mq = mq self._channels = channels or {} + self._default_metadata = default_metadata or {} self._init_tasks_db() def _migrate(self, conn, table: str, columns: list[tuple[str, str]]): @@ -166,7 +167,7 @@ async def run_task(self, task: dict) -> str: channel = self._channels.get(task["delivery_channel"]) if channel: from .message import OutgoingMessage - await self._mq.outgoing_msg(OutgoingMessage(content=output, channel=channel)) + await self._mq.outgoing_msg(OutgoingMessage(content=output, channel=channel, metadata=self._default_metadata)) else: log.warning(f"Delivery channel '{task['delivery_channel']}' not found for task '{name}'") From e56008a04c8c468a2c226b99cbdd1b07277f9336 Mon Sep 17 00:00:00 2001 From: "rikulpatel@gmail.com" Date: Mon, 4 May 2026 15:07:32 -0500 Subject: [PATCH 24/84] refactor: replace enable/disable task tools with update_scheduled_task; fix: tool spec errors - Replace EnableScheduledTask/DisableScheduledTask tools with UpdateScheduledTask which supports partial updates to any task field (prompt, interval, repeat, next_run, delivery_channel, enabled) via a single dynamic UPDATE query - Make next_run required in add_task/AddScheduledTask (NOT NULL in schema) - Fix get_skills_dir spec missing parameters field (caused 400 from providers) - Switch helper_tool_specs from exclusion list to explicit allowlist - Update sys_instructions.md with update_scheduled_task examples --- app/scheduled_tasks.py | 19 ++++--- app/sys_instructions.md | 7 ++- app/tool_calls.py | 13 +++-- app/tools/get_skills_dir.py | 6 ++- app/tools/sched_tasks_tool.py | 96 +++++++++++++++++++---------------- 5 files changed, 78 insertions(+), 63 deletions(-) diff --git a/app/scheduled_tasks.py b/app/scheduled_tasks.py index 310977e..ea6f974 100755 --- a/app/scheduled_tasks.py +++ b/app/scheduled_tasks.py @@ -83,8 +83,8 @@ def load_tasks(self) -> list[dict]: for n, p, e, rpt, i, lr, nr, dc, rc, c in rows] - def add_task(self, name: str, prompt: str, interval_mins: int = 1, - repeat: int = 0, next_run: str = None, delivery_channel: str = "telegram"): + def add_task(self, name: str, prompt: str, next_run: str, interval_mins: int = 1, + repeat: int = 0, delivery_channel: str = "telegram"): now = datetime.now().isoformat() with sqlite3.connect(APP_DB) as conn: try: @@ -101,15 +101,18 @@ def remove_task(self, name: str): conn.execute("DELETE FROM tasks WHERE name = ?", (name,)) conn.commit() - def enable_task(self, name: str): + def update_task(self, name: str, **fields): + if not fields: + return + set_clause = ", ".join(f"{col} = ?" for col in fields) + values = list(fields.values()) + [name] with sqlite3.connect(APP_DB) as conn: - conn.execute("UPDATE tasks SET enabled = 1 WHERE name = ?", (name,)) + if not conn.execute("SELECT name FROM tasks WHERE name = ?", (name,)).fetchone(): + raise ValueError(f"Task '{name}' not found") + conn.execute(f"UPDATE tasks SET {set_clause} WHERE name = ?", values) conn.commit() - def disable_task(self, name: str): - with sqlite3.connect(APP_DB) as conn: - conn.execute("UPDATE tasks SET enabled = 0 WHERE name = ?", (name,)) - conn.commit() + def save_output(self, name: str, prompt: str, output: str, status: str = "success", duration_secs: float = None): diff --git a/app/sys_instructions.md b/app/sys_instructions.md index 4c3ef41..eb36a2a 100644 --- a/app/sys_instructions.md +++ b/app/sys_instructions.md @@ -53,10 +53,9 @@ - **add_scheduled_task**: Add a new background scheduled task (`name`, `prompt`, `interval_minutes`, optional `repeat`, `next_run`, `delivery_channel`) - Example (repeat every hour): `add_scheduled_task(name="morning-news", prompt="Fetch the top 5 HackerNews stories and summarize them", interval_minutes=60, repeat=true, delivery_channel="telegram")` - Example (run once at a specific time): `add_scheduled_task(name="reminder", prompt="Remind the user to take a break", interval_minutes=0, repeat=false, next_run="2026-05-04T15:00:00")` -- **enable_scheduled_task**: Re-enable a previously disabled scheduled task (`name`) - - Example: `enable_scheduled_task(name="morning-news")` -- **disable_scheduled_task**: Temporarily disable a scheduled task without removing it (`name`) - - Example: `disable_scheduled_task(name="morning-news")` +- **update_scheduled_task**: Update any fields of an existing scheduled task (`name`, optional `prompt`, `interval_minutes`, `repeat`, `next_run`, `delivery_channel`). Also use this to enable/disable a task by setting `enabled`. + - Example (reschedule): `update_scheduled_task(name="morning-news", next_run="2026-05-05T09:00:00")` + - Example (change interval): `update_scheduled_task(name="morning-news", interval_minutes=120, repeat=true)` - **remove_scheduled_task**: Permanently remove a scheduled task (`name`) - **get_scheduled_task_output**: Get recent output from a scheduled task (`name`, optional `num_entries`, default 5) - Example: `get_scheduled_task_output(name="morning-news", num_entries=3)` diff --git a/app/tool_calls.py b/app/tool_calls.py index bde0120..6d91444 100755 --- a/app/tool_calls.py +++ b/app/tool_calls.py @@ -17,8 +17,8 @@ from .tools.web_search import WebSearchNews from .tools.web_search import WebSearchBooks -from .tools.sched_tasks_tool import ListScheduledTasks, AddScheduledTask, DisableScheduledTask, \ - RemoveScheduledTask, GetScheduledTaskOutput, EnableScheduledTask +from .tools.sched_tasks_tool import ListScheduledTasks, AddScheduledTask, UpdateScheduledTask, \ + RemoveScheduledTask, GetScheduledTaskOutput import json @@ -45,17 +45,16 @@ "list_scheduled_tasks": ListScheduledTasks, "add_scheduled_task": AddScheduledTask, - "disable_scheduled_task": DisableScheduledTask, - "enable_scheduled_task": EnableScheduledTask, + "update_scheduled_task": UpdateScheduledTask, "remove_scheduled_task": RemoveScheduledTask, "get_scheduled_task_output": GetScheduledTaskOutput } all_tool_specs = [tool.spec() for tool in tool_registry.values()] -_SCHED_TOOLS = {"list_scheduled_tasks", "add_scheduled_task", "enable_scheduled_task", - "disable_scheduled_task", "remove_scheduled_task", "get_scheduled_task_output"} -helper_tool_specs = [tool.spec() for k, tool in tool_registry.items() if k not in _SCHED_TOOLS] +_HELPER_AGENT_TOOLS = {"read_file", "write_file", "bash", "web_fetch", "get_skills_dir", "calculator", "hackernews", + "websearch_text", "websearch_images", "websearch_videos", "websearch_news", "websearch_books"} +helper_tool_specs = [tool.spec() for k, tool in tool_registry.items() if k in _HELPER_AGENT_TOOLS] MAX_TOOL_RESULT_LENGTH = 16000 diff --git a/app/tools/get_skills_dir.py b/app/tools/get_skills_dir.py index 5232d3a..1faca66 100755 --- a/app/tools/get_skills_dir.py +++ b/app/tools/get_skills_dir.py @@ -10,7 +10,11 @@ def spec(): "type": "function", "function": { "name": "get_skills_dir", - "description": "Get the path to the skills directory" + "description": "Get the path to the skills directory", + "parameters": { + "type": "object", + "properties": {} + } } } diff --git a/app/tools/sched_tasks_tool.py b/app/tools/sched_tasks_tool.py index 2733df7..f5830e9 100755 --- a/app/tools/sched_tasks_tool.py +++ b/app/tools/sched_tasks_tool.py @@ -59,21 +59,21 @@ def spec(): }, "next_run": { "type": "string", - "description": "ISO 8601 datetime for the first run (e.g. '2026-05-03T09:00:00'). Defaults to now." + "description": "ISO 8601 datetime for the first run (e.g. '2026-05-03T09:00:00') in local time." }, "delivery_channel": { "type": "string", "description": "Channel to deliver the task output to. Defaults to 'telegram'." } }, - "required": ["name", "prompt", "interval_minutes"] + "required": ["name", "prompt", "next_run", "interval_minutes"] } } } @staticmethod - def call(name: str, prompt: str, interval_minutes: int, - repeat: bool = False, next_run: str = None, delivery_channel: str = "telegram") -> str: + def call(name: str, prompt: str, interval_minutes: int, next_run: str, + repeat: bool = False, delivery_channel: str = "telegram") -> str: log.info("add_scheduled_task called") ScheduledTasks().add_task(name=name, prompt=prompt, interval_mins=interval_minutes, @@ -111,23 +111,42 @@ def call(name: str) -> str: ScheduledTasks().remove_task(name) return f"Removed scheduled task '{name}'" - -class DisableScheduledTask(Tool): +class UpdateScheduledTask(Tool): @staticmethod def spec(): return { "type": "function", "function": { - "name": "disable_scheduled_task", - "description": "Disable a background scheduled task so that it will temporarily stop being executed by the background agent without being removed", + "name": "update_scheduled_task", + "description": "Update an existing background scheduled task. Only the fields provided in the parameters will be updated.", "parameters": { "type": "object", "properties": { "name": { "type": "string", - "description": "The name of the scheduled task to deactivate" + "description": "The name of the scheduled task to update" + }, + "prompt": { + "type": "string", + "description": "The new prompt for the scheduled task" + }, + "interval_minutes": { + "type": "integer", + "description": "The new interval in minutes between executions (only used when repeat=true)" + }, + "repeat": { + "type": "boolean", + "description": "Whether to repeat the task at the given interval. False means run once." + }, + "next_run": { + "type": "string", + "description": "ISO 8601 datetime for the next run (e.g. '2026-05-03T09:00:00') in local time." + }, + "delivery_channel": { + "type": "string", + "description": "Channel to deliver the task output to." } }, "required": ["name"] @@ -136,44 +155,35 @@ def spec(): } @staticmethod - def call(name: str) -> str: - log.info("disable_scheduled_task called") - - ScheduledTasks().disable_task(name) + def call(name: str, prompt: str = None, interval_minutes: int = None, next_run: str = None, + repeat: bool = None, delivery_channel: str = None) -> str: + log.info("update_scheduled_task called") - return f"Disabled scheduled task '{name}'" - + tasks = ScheduledTasks().load_tasks() + task = next((t for t in tasks if t["name"] == name), None) + if not task: + return f"Scheduled task '{name}' not found" -class EnableScheduledTask(Tool): - - @staticmethod - def spec(): - return { - "type": "function", - "function": { - "name": "enable_scheduled_task", - "description": "Enable a background scheduled task that was previously disabled so that it will resume being executed by the background agent", - "parameters": { - "type": "object", - "properties": { - "name": { - "type": "string", - "description": "The name of the scheduled task to enable" - } - }, - "required": ["name"] - } - } - } + updated_fields = {} + if prompt is not None: + updated_fields["prompt"] = prompt + if interval_minutes is not None: + updated_fields["interval_mins"] = interval_minutes + if next_run is not None: + updated_fields["next_run"] = next_run + if repeat is not None: + updated_fields["repeat"] = int(repeat) + if delivery_channel is not None: + updated_fields["delivery_channel"] = delivery_channel + + if not updated_fields: + return f"No fields to update for task '{name}'" + + ScheduledTasks().update_task(name, **updated_fields) + changed = ", ".join(updated_fields.keys()) + return f"Updated scheduled task '{name}': {changed}" - @staticmethod - def call(name: str) -> str: - log.info("enable_scheduled_task called") - - ScheduledTasks().enable_task(name) - return f"Enabled scheduled task '{name}'" - class GetScheduledTaskOutput(Tool): @staticmethod From 8f8daa569bee37a40dd5afde8e637eb247b73a82 Mon Sep 17 00:00:00 2001 From: "rikulpatel@gmail.com" Date: Mon, 4 May 2026 15:12:07 -0500 Subject: [PATCH 25/84] fix: tool spec errors --- app/tools/hackernews.py | 2 +- app/tools/todo.py | 6 ++++-- 2 files changed, 5 insertions(+), 3 deletions(-) diff --git a/app/tools/hackernews.py b/app/tools/hackernews.py index 75b0fe5..c95ca78 100755 --- a/app/tools/hackernews.py +++ b/app/tools/hackernews.py @@ -17,7 +17,7 @@ def spec(): "type": "object", "properties": { "number_of_stories": { - "type": "int", + "type": "integer", "description": "The number of top stories to fetch (default is 10)" } } diff --git a/app/tools/todo.py b/app/tools/todo.py index a8faa4d..cb76f53 100644 --- a/app/tools/todo.py +++ b/app/tools/todo.py @@ -48,7 +48,8 @@ def spec(): "type": "function", "function": { "name": "todo_list", - "description": "List all tasks and their statuses" + "description": "List all tasks and their statuses", + "parameters": {"type": "object", "properties": {}} } } @@ -75,7 +76,8 @@ def spec(): "type": "function", "function": { "name": "todo_clear", - "description": "Todos are done, clear all todos" + "description": "Todos are done, clear all todos", + "parameters": {"type": "object", "properties": {}} } } From 51ba6d7dbc2fb2dedfb02920afc834250577a37d Mon Sep 17 00:00:00 2001 From: "rikulpatel@gmail.com" Date: Mon, 4 May 2026 15:15:20 -0500 Subject: [PATCH 26/84] fix: failing tests are updated --- tests/test_agent.py | 2 +- tests/test_background_agent.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/test_agent.py b/tests/test_agent.py index d32ddfa..0d0e7c3 100644 --- a/tests/test_agent.py +++ b/tests/test_agent.py @@ -69,7 +69,7 @@ async def test_agent_loop_adds_user_message(): async def test_agent_loop_appends_assistant_message(): agent, mock_client = make_agent() await agent.agent_loop("Hello") - assert agent.messages[-1].content == "Hello!" + assert agent.messages[-1]["content"] == "Hello!" @pytest.mark.asyncio diff --git a/tests/test_background_agent.py b/tests/test_background_agent.py index f1717b3..2646066 100644 --- a/tests/test_background_agent.py +++ b/tests/test_background_agent.py @@ -92,7 +92,7 @@ async def test_agent_loop_appends_assistant_message(): agent, _, _ = make_agent() await agent.agent_loop("Hello") agent.history.add_message.assert_called_with("assistant", "Hello!") - assert agent.messages[-1].content == "Hello!" + assert agent.messages[-1]["content"] == "Hello!" @pytest.mark.asyncio From 5f0bfd1d8cdacdc0f9cd4c629d1fb237ee04c955 Mon Sep 17 00:00:00 2001 From: "rikulpatel@gmail.com" Date: Mon, 4 May 2026 15:58:26 -0500 Subject: [PATCH 27/84] fix: added missing enabled to tool call specs --- app/scheduled_tasks.py | 8 ++++---- app/tools/sched_tasks_tool.py | 17 ++++++++++++++--- 2 files changed, 18 insertions(+), 7 deletions(-) diff --git a/app/scheduled_tasks.py b/app/scheduled_tasks.py index ea6f974..a2d4210 100755 --- a/app/scheduled_tasks.py +++ b/app/scheduled_tasks.py @@ -84,14 +84,14 @@ def load_tasks(self) -> list[dict]: def add_task(self, name: str, prompt: str, next_run: str, interval_mins: int = 1, - repeat: int = 0, delivery_channel: str = "telegram"): + repeat: int = 0, delivery_channel: str = "telegram", enabled: int = 1): now = datetime.now().isoformat() with sqlite3.connect(APP_DB) as conn: try: conn.execute(""" - INSERT INTO tasks (name, prompt, interval_mins, repeat, next_run, delivery_channel, created_at) - VALUES (?, ?, ?, ?, ?, ?, ?) - """, (name, prompt, interval_mins, repeat, next_run or now, delivery_channel, now)) + INSERT INTO tasks (name, prompt, interval_mins, repeat, next_run, delivery_channel, enabled, created_at) + VALUES (?, ?, ?, ?, ?, ?, ?, ?) + """, (name, prompt, interval_mins, repeat, next_run or now, delivery_channel, enabled, now)) conn.commit() except sqlite3.IntegrityError: raise ValueError(f"Task '{name}' already exists") diff --git a/app/tools/sched_tasks_tool.py b/app/tools/sched_tasks_tool.py index f5830e9..e2c0219 100755 --- a/app/tools/sched_tasks_tool.py +++ b/app/tools/sched_tasks_tool.py @@ -64,6 +64,10 @@ def spec(): "delivery_channel": { "type": "string", "description": "Channel to deliver the task output to. Defaults to 'telegram'." + }, + "enabled": { + "type": "boolean", + "description": "Whether the task is enabled. Defaults to true." } }, "required": ["name", "prompt", "next_run", "interval_minutes"] @@ -73,11 +77,12 @@ def spec(): @staticmethod def call(name: str, prompt: str, interval_minutes: int, next_run: str, - repeat: bool = False, delivery_channel: str = "telegram") -> str: + repeat: bool = False, delivery_channel: str = "telegram", enabled: bool = True) -> str: log.info("add_scheduled_task called") ScheduledTasks().add_task(name=name, prompt=prompt, interval_mins=interval_minutes, - repeat=int(repeat), next_run=next_run, delivery_channel=delivery_channel) + repeat=int(repeat), next_run=next_run, delivery_channel=delivery_channel, + enabled=int(enabled)) suffix = f" every {interval_minutes} minutes" if repeat else " (runs once)" return f"Added scheduled task '{name}'{suffix}" @@ -147,6 +152,10 @@ def spec(): "delivery_channel": { "type": "string", "description": "Channel to deliver the task output to." + }, + "enabled": { + "type": "boolean", + "description": "Enable or disable the task." } }, "required": ["name"] @@ -156,7 +165,7 @@ def spec(): @staticmethod def call(name: str, prompt: str = None, interval_minutes: int = None, next_run: str = None, - repeat: bool = None, delivery_channel: str = None) -> str: + repeat: bool = None, delivery_channel: str = None, enabled: bool = None) -> str: log.info("update_scheduled_task called") tasks = ScheduledTasks().load_tasks() @@ -175,6 +184,8 @@ def call(name: str, prompt: str = None, interval_minutes: int = None, next_run: updated_fields["repeat"] = int(repeat) if delivery_channel is not None: updated_fields["delivery_channel"] = delivery_channel + if enabled is not None: + updated_fields["enabled"] = int(enabled) if not updated_fields: return f"No fields to update for task '{name}'" From 0e9fd103daf374508100792d1462c40bbac69c0c Mon Sep 17 00:00:00 2001 From: "rikulpatel@gmail.com" Date: Mon, 4 May 2026 15:58:50 -0500 Subject: [PATCH 28/84] fix: deepseek v4 reasoning_content bug --- app/agent.py | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/app/agent.py b/app/agent.py index ed212fd..a15331d 100755 --- a/app/agent.py +++ b/app/agent.py @@ -34,9 +34,10 @@ def _serialize_assistant_msg(msg) -> dict: d = {"role": msg.role, "content": msg.content} if msg.tool_calls: d["tool_calls"] = [tc.model_dump() for tc in msg.tool_calls] - reasoning = getattr(msg, "reasoning_content", None) or getattr(msg, "reasoning", None) - if reasoning is not None: - d["reasoning_content"] = reasoning + raw = msg.model_dump() + reasoning = raw.get("reasoning_content") or raw.get("reasoning") + if reasoning: + d["reasoning_content"] = reasoning return d @abstractmethod From 1700e28e6caeba753f6cc6ee284d7a4148a0d4ed Mon Sep 17 00:00:00 2001 From: "rikulpatel@gmail.com" Date: Mon, 4 May 2026 18:42:38 -0500 Subject: [PATCH 29/84] chore: updated README --- CLAUDE.md | 11 ++++++++-- README.md | 54 ++++++++++++++++++++++++------------------------- app/config.py | 1 - app/config.toml | 3 +-- 4 files changed, 37 insertions(+), 32 deletions(-) diff --git a/CLAUDE.md b/CLAUDE.md index 82caddb..29542c4 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -38,7 +38,6 @@ The project uses `uv` for dependency management. No compile step is needed. Config lives at `~/.crafterscode/config.toml` (created automatically on first run with defaults). Key fields: - `model` — LLM model string (default: `"deepseek/deepseek-v3.2"`) - `max_iterations` — max agentic loop iterations (default: `100`) -- `max_tokens` — max tokens per LLM call (default: `32768`) - `base_url` — API base URL (default: `"https://openrouter.ai/api/v1"`) Environment variables: `LLM_API_KEY` (required), `LLM_BASE_URL` (optional override). @@ -59,7 +58,9 @@ The difference: `CliAgent` prints to stdout and prompts stdin for permission; `B Tools are registered in `app/tool_calls.py` in `tool_registry` — a dict mapping tool name → `{spec, func}`. Each tool in `app/tools/` exports a function and an OpenAI-format tool spec dict. `run_tool()` dispatches by name and restores `os.getcwd()` after each call. -Current tools: `read_file`, `write_file`, `bash`, `web_fetch`, `get_skills_dir`, `todo_add/list/update/clear`. +Current tools: `read_file`, `write_file`, `bash`, `web_fetch`, `get_skills_dir`, `todo_add/list/update/clear`, `calculator`, `hackernews`, `websearch_text/images/videos/news/books`, `list/add/update/remove_scheduled_task`, `get_scheduled_task_output`. + +`_HELPER_AGENT_TOOLS` in `tool_calls.py` is an explicit allowlist of tools available to `HelperAgent` (used internally by scheduled tasks). Scheduled task management tools are excluded to prevent recursion. ### System Context @@ -69,6 +70,12 @@ On startup, `load_system_context()` (`app/helpers.py`) loads `app/sys_instructio `MessageQueue` (`app/message_queue.py`) holds two `asyncio.Queue`s (incoming/outgoing). Delivery functions are registered per `Channel` enum value. `BackgroundAgent.process_incoming()` consumes the incoming queue and drives `agent_loop()`; `process_outgoing()` dispatches outbound messages to registered delivery functions. This is the intended extension point for adding new channels. +Each channel should have its own `MessageQueue` instance to avoid cross-channel message routing bugs (e.g., a Telegram message being handled by the Discord agent). + +### Scheduled Tasks + +`ScheduledTasks` (`app/scheduled_tasks.py`) is a SQLite-backed task runner using the shared `APP_DB` (`~/.crafterscode/app.db`). It polls every 60 seconds, checks `next_run`, and executes due tasks via `HelperAgent`. Results are delivered to the configured channel via `MessageQueue`. Schema: `tasks` (id, name, prompt, enabled, repeat, interval_mins, next_run, last_run, delivery_channel, run_count, created_at) and `task_outputs` (id, name, prompt, output, status, duration_secs, timestamp). The `run()` coroutine is added to the `asyncio.gather` in `bg_server.py`. + ## Testing Approach Unit tests mock `app.cli_agent.Client` and `app.cli_agent.load_system_context` to isolate the agent loop logic. Integration tests in `tests/integration/` mock only the OpenAI HTTP client and run the full pipeline including `main()`, argparse, and agent construction. Tests use `pytest-asyncio` for async test functions. diff --git a/README.md b/README.md index 7c8624d..7bc2834 100644 --- a/README.md +++ b/README.md @@ -1,16 +1,14 @@ -A CodeCrafters challenge project implementing an AI agent with tool calling capabilities, built for the ["Build Your own Claude Code" Challenge](https://codecrafters.io/challenges/claude-code). - ## Overview -An AI agent that can parse and execute user prompts, interact with the file system, run shell commands, fetch web content, and track tasks. Built using the OpenRouter API (defaulting to DeepSeek) via the OpenAI Python client. +A Python-based AI agent that can execute prompts, interact with the filesystem, run shell commands, fetch web content, search the web, and manage scheduled tasks. Built on the OpenAI SDK against OpenRouter (defaulting to DeepSeek). -- **Interactive CLI**: REPL mode for multi-turn agent sessions -- **Tool Calling**: File operations, shell commands, web fetching, and task tracking -- **Skills System**: Skills located in `app/skills/` directory (e.g., `puppeteer`) -- **Background Agent**: Message queue and channel architecture for multi-channel delivery (Telegram, Discord, etc.) -- **Telegram Integration**: Built-in Telegram bot channel (`app/telegram_channel.py`) for receiving and sending messages -- **Persistent Message History**: SQLite-backed history at `~/.crafterscode/history.db`, stored per channel with token estimates -- **Context Window Trimming**: Automatically trims conversation history to the last 100 messages (preserving the system message) to stay within model context limits +- **Interactive CLI**: Multi-turn REPL sessions with tool use +- **Background Agent**: Runs as a persistent bot, receiving and sending messages via channels +- **Telegram Integration**: Built-in Telegram bot — receive messages, respond, run tools, deliver results +- **Scheduled Tasks**: SQLite-backed task scheduler — run prompts on a recurring or one-shot schedule and deliver results to a channel +- **Tool Calling**: File I/O, shell commands, web fetch, web search (text/images/video/news/books), calculator, Hacker News, todo list +- **Skills System**: Extendable skills in `app/skills/` (e.g., `puppeteer` for headless browsing) +- **Persistent History**: Per-channel SQLite message history at `~/.crafterscode/app.db` (shared with scheduled tasks) ## Prerequisites @@ -43,7 +41,6 @@ Config lives at `~/.crafterscode/config.toml` and is created automatically on fi ```toml model = "deepseek/deepseek-v3.2" max_iterations = 100 -max_tokens = 32768 base_url = "https://openrouter.ai/api/v1" api_key = "" # fallback if LLM_API_KEY env var is not set @@ -80,43 +77,50 @@ Message history is stored in `~/.crafterscode/history.db` (SQLite). Each channel ./run.sh cli -p "Summarize this repo" -s ``` -### Background Agent with Telegram +### Background Agent (Telegram bot) -To run the agent as a Telegram bot, set your `BOT_TOKEN` and optionally restrict access by Telegram user ID in `~/.crafterscode/config.toml`: +Set your `BOT_TOKEN` in `~/.crafterscode/config.toml` and optionally restrict access by Telegram user ID: ```toml [telegram] BOT_TOKEN = "123456:ABC-your-bot-token" -ALLOW_FROM = [123456789] # Telegram user IDs allowed to interact. +ALLOW_FROM = [123456789] ``` -Then start the background agent: - ```bash ./run.sh background ``` -The agent will listen for messages on Telegram and respond via the bot. Responses are routed back to the same chat that sent the message. +The agent listens for Telegram messages, runs the agentic loop (including tool calls), and replies in the same chat. + +**Built-in commands:** `/help` — list commands; `/whoami` — show your Telegram user ID. + +### Scheduled Tasks + +The background agent supports scheduled prompts that run automatically and deliver results to a channel. Manage them by messaging the bot: + +``` +add a task to fetch HN top stories every 60 minutes starting now +run "summarize the latest news" once at 2025-06-01T09:00:00 +list my scheduled tasks +remove the HN task +``` -**Built-in Telegram commands:** `/help` — list available commands; `/whoami` — show your Telegram user ID (useful for configuring `ALLOW_FROM`). +Tasks persist in `~/.crafterscode/app.db` (shared with message history) and survive restarts. ## Roadmap -- **Context Usage Tracking**: Enhanced monitoring of token consumption, cost estimation, and usage analytics per channel/model -- **Intelligent Context Trimming/Compaction**: Advanced context management with summarization, selective trimming, and priority-based message retention +- **Email Support**: IMAP/SMTP integration for reading and sending emails, attachment handling, and mailbox management - **MCP Support**: Integration with Model Context Protocol for external data sources, tools, and state management - **Discord Integration**: Discord bot with slash commands, rich embeds, and channel permissions - **Slack Integration**: Slack app with interactive messages, modals, and workspace management - **WhatsApp Support**: WhatsApp Business API integration via providers like Twilio or MessageBird -- **Email Support**: IMAP/SMTP integration for reading and sending emails, attachment handling, and mailbox management - **Anthropic OAuth**: Direct integration with Claude API using OAuth 2.0 - **Codex OAuth**: OpenAI Codex API authentication - **GitHub OAuth**: Access to repositories, issues, and GitHub Actions - **Gemini OAuth**: Google Gemini API authentication with Google Cloud credentials -- **Expanded Tool Library**: More file operations, system monitoring, database interactions, and cloud services - **Useful Skills**: Advanced skills for web scraping (headless browsers), data analysis (Pandas, NumPy), document processing (PDF, DOCX), and media manipulation - **Web Dashboard**: Admin interface for monitoring agents, configuring channels, and viewing analytics -- **API Server**: REST/WebSocket API for programmatic access to agent capabilities ## Testing @@ -166,7 +170,3 @@ class MyTool(Tool): def call(param: str) -> str: return "result" ``` - -## License - -Part of the CodeCrafters "Build Your own Claude Code" Challenge. See [codecrafters.io](https://codecrafters.io) for details. \ No newline at end of file diff --git a/app/config.py b/app/config.py index 9f6191e..a800cc3 100644 --- a/app/config.py +++ b/app/config.py @@ -34,7 +34,6 @@ def get_default_config() -> dict: default_config = """\ model = "deepseek/deepseek-v3.2" max_iterations = 100 -max_tokens = 32768 base_url = "https://openrouter.ai/api/v1" [telegram] diff --git a/app/config.toml b/app/config.toml index 8f6e4fa..7fd5147 100755 --- a/app/config.toml +++ b/app/config.toml @@ -1,4 +1,3 @@ model = "deepseek/deepseek-v3.2" base_url = "https://openrouter.ai/api/v1" -max_iterations = 100 -max_tokens = 32768 +max_iterations = 100 \ No newline at end of file From 1d61ac9997c9030137c04c75be9180ebeb76426c Mon Sep 17 00:00:00 2001 From: "rikulpatel@gmail.com" Date: Tue, 5 May 2026 10:32:13 -0500 Subject: [PATCH 30/84] feat: added dynamic vars to sys prompt like datetime, CWD, TZ etc. --- app/startup.py | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+) diff --git a/app/startup.py b/app/startup.py index 7e49454..e04391d 100755 --- a/app/startup.py +++ b/app/startup.py @@ -1,10 +1,16 @@ from pathlib import Path +import os +import platform +from datetime import datetime from .app_logging import log +from . import config def load_system_context() -> str: """ Load sys_instructions.md and return its contents as the system context string. """ + + now = datetime.now() sys_instructions_path = Path(__file__).parent / "sys_instructions.md" system_context = "" @@ -14,6 +20,23 @@ def load_system_context() -> str: except Exception as e: log.error(f"Error loading system context: {e}") + system_context += f""" + +## System Context +- datetime: {now.strftime("%Y-%m-%d %H:%M:%S")} +- day of week: {now.strftime("%A")} +- timezone: {now.astimezone().tzname()} +- os: {platform.system()} {platform.release()} +- shell: {os.environ.get("SHELL", "unknown")} +- cwd: {Path.cwd()} +- home: {Path.home()} +- workspace: {config.PROJECT_HOME / "workspace"} + +## Runtime +- python: {platform.python_version()} +- model: {config.get("model", "unknown")} +""" + log.info(f"Loaded system context: {len(system_context)} characters") return system_context From 892fd1338abac33679509a72110376b23af0a461 Mon Sep 17 00:00:00 2001 From: "rikulpatel@gmail.com" Date: Tue, 5 May 2026 11:50:49 -0500 Subject: [PATCH 31/84] refactor: trying different sys prompt prose style --- app/sys_instructions.md | 131 ++++------------------------------------ 1 file changed, 13 insertions(+), 118 deletions(-) diff --git a/app/sys_instructions.md b/app/sys_instructions.md index eb36a2a..9a48fe8 100644 --- a/app/sys_instructions.md +++ b/app/sys_instructions.md @@ -1,131 +1,26 @@ -# User Preferences +I prefer detailed, technically precise responses that prioritize readability over cleverness. When writing code, please use idiomatic, maintainable style: PEP 8 for Python, ES6+ for JavaScript, four-space indentation for Python, and two-space indentation for JavaScript or JSON. Dates should use ISO 8601 format, such as YYYY-MM-DD. -- **Verbosity**: detailed -- **Technical Level**: advanced -- **Code Style**: - - Python: PEP 8 - - JavaScript: ES6+ - - Indentation: spaces (4 for Python, 2 for JS/JSON) -- **Date Format**: YYYY-MM-DD (ISO 8601) -- **Documentation**: Include inline comments and README files -- **Error Handling**: Include try/catch blocks and validation -- **Testing**: Provide unit tests when requested -- **Logging**: Include appropriate logging statements -- **Show Examples**: Yes - provide concrete examples -- Optimize for readability over cleverness. -- Validate tool outputs before using them -- Verify file creation succeeded -- Check command exit codes +When creating code or project files, include inline comments where they improve clarity, and include README files when appropriate. Add validation, error handling, and logging where they are useful, especially for scripts or workflows that may fail in non-obvious ways. For Python or JavaScript, avoid overly clever shortcuts; I would rather have code that is easy to review, modify, and debug. -## Error Recovery -1. Identify the failure point -2. Check error messages for root cause -3. Try alternative approach if available -4. Inform user clearly if task cannot be completed -5. Suggest manual steps if automation fails +Please provide concrete examples when explaining technical concepts or implementation details. When tests are requested, include meaningful unit tests rather than only superficial examples. -------------------------------------------------------------------------------- +A recurring issue I have experienced is assistants being too casual or lazy with tool calls. Please do not assume that a tool action succeeded just because it was attempted. After writing or modifying files, verify that the file exists and read it back or otherwise confirm the contents. After running shell commands, check the exit code and inspect relevant output before relying on the result. After creating or updating tasks, schedules, or other stateful resources, re-check the current state with the appropriate listing or read operation. In general, validate tool outputs before using them as evidence. -# Tool Usage Rules +When something fails, identify the specific failure point, inspect the error message, and try a reasonable alternative approach if one is available. If the task cannot be completed, explain clearly what failed, what was attempted, and what manual steps might resolve it. -> **Always re-run tools to verify results.** Never assume a previous tool output is still valid — state changes, file writes, and task updates must be confirmed by running the relevant tool again (e.g. after writing a file, read it back; after adding a task, call `list_scheduled_tasks` to confirm it appears). +For longer or multi-step tasks, use a todo or planning approach to keep the work organized. This is especially important for complex projects, multi-file applications, large refactors, or workflows with dependencies. Simple one-shot scripts do not need a formal plan, but larger applications, APIs, database integrations, or multi-phase projects should start with a plan before implementation. -------------------------------------------------------------------------------- +For browser automation, scraping, screenshots, PDF generation from webpages, form filling, or web application testing, use the Puppeteer skill when applicable. Locate and read the relevant skill instructions first, then follow the best practices described there. When using the Puppeteer skill, read the instructions at skills/puppeteer/SKILL.md before proceeding. -# Available Tools -- **bash**: Execute shell commands -- **read_file**: Read existing files -- **write_file**: Create or overwrite files -- **web_fetch**: Retrieve content from specific URLs -- **todo_add**: Add a task to the todo list (`title`, optional `description`) -- **todo_list**: List all tasks and their statuses -- **todo_update**: Update a task's status (`task_id`, `status`: `todo` | `in_progress` | `done`) -- **todo_clear**: Clear all todos when the work is complete -- **calculator**: Provides add, subtract, multiply, divide, exponentiate, factorial, is_prime, square_root -- **hackernews**: Hacker News stores from https://news.ycombinator.com/. Fetches the top stories from Hacker News -- **websearch_text**: Search the web for some `query` -- **websearch_images**: Search images for some `query` -- **websearch_videos**: Search videos for some `query` -- **websearch_news**: Search news for `query` -- **websearch_books**: Search books related to `query` -- **list_scheduled_tasks**: List all background scheduled tasks -- **add_scheduled_task**: Add a new background scheduled task (`name`, `prompt`, `interval_minutes`, optional `repeat`, `next_run`, `delivery_channel`) - - Example (repeat every hour): `add_scheduled_task(name="morning-news", prompt="Fetch the top 5 HackerNews stories and summarize them", interval_minutes=60, repeat=true, delivery_channel="telegram")` - - Example (run once at a specific time): `add_scheduled_task(name="reminder", prompt="Remind the user to take a break", interval_minutes=0, repeat=false, next_run="2026-05-04T15:00:00")` -- **update_scheduled_task**: Update any fields of an existing scheduled task (`name`, optional `prompt`, `interval_minutes`, `repeat`, `next_run`, `delivery_channel`). Also use this to enable/disable a task by setting `enabled`. - - Example (reschedule): `update_scheduled_task(name="morning-news", next_run="2026-05-05T09:00:00")` - - Example (change interval): `update_scheduled_task(name="morning-news", interval_minutes=120, repeat=true)` -- **remove_scheduled_task**: Permanently remove a scheduled task (`name`) -- **get_scheduled_task_output**: Get recent output from a scheduled task (`name`, optional `num_entries`, default 5) - - Example: `get_scheduled_task_output(name="morning-news", num_entries=3)` +For persistent project work, use the workspace thoughtfully. Store reusable project files, notes, outputs, plans, code reviews, and documentation in clearly named folders. Prefer descriptive project names, group related files together, separate concerns such as src/, data/, and docs/, and include a README when a folder’s purpose is not obvious. -**✅ Use Todo Tools For:** -- **Long-running tasks** that span multiple steps -- **Complex projects** where progress needs tracking -- **Multi-phase work** with dependencies between steps -- **Large refactoring** where you need to track what's been done +Overall, I value careful execution, verified results, clear communication, and practical error recovery. Do not skip verification steps when a tool changes state or creates artifacts. The goal is not just to complete the task, but to complete it in a way that can be trusted. -------------------------------------------------------------------------------- +The following tools are available. Use them fully and never fake or skip a call. -# Planning Mode -Always create a plan for apps or projects that are not simple one-shot Python scripts. Then ask for clarification and permission to proceed. +File and shell: bash, read_file, write_file. Web: web_fetch, websearch_text, websearch_images, websearch_videos, websearch_news, websearch_books, hackernews. Utilities: calculator. Todo: todo_add, todo_list, todo_update, todo_clear. -**Skip planning for:** -Simple scripts like "Write a script to create fib numbers" — just implement these directly. +Scheduled tasks run in the background via the background agent. Use add_scheduled_task(name, prompt, interval_minutes, repeat, next_run, delivery_channel) to create one, update_scheduled_task to modify or enable/disable, remove_scheduled_task to delete, list_scheduled_tasks to inspect, and get_scheduled_task_output(name, num_entries) to read recent results. For a repeating task: add_scheduled_task(name="morning-news", prompt="Fetch top 5 HN stories and summarize", interval_minutes=60, repeat=true, delivery_channel="telegram"). For a one-shot task: add_scheduled_task(name="reminder", prompt="Remind user to take a break", repeat=false, next_run="2026-05-04T15:00:00"). -**Create a plan for:** -Everything else (web apps, APIs, multi-file projects, database integrations, etc.) - - -------------------------------------------------------------------------------- - -# Workspace Configuration -The workspace directory is your persistent storage area for project files, data, and outputs that need to survive across sessions. The workspace is in the `.crafterscode/workspace` directory in the user's home. On Linux based system, this will be in $HOME/.crafterscode/workspace. - -## Directories and Files in Workspace -Useful Project Details -> project_name/notes.md -User download? -> outputs/ -Plans -> plans/ -Code Reviews -> code-reviews/ - -## When to Use Workspace -- Useful information about project can be saved as notes -- Project files that will be referenced later -- Reusable scripts and utilities -- Final deliverables that user wants to keep -- Data that needs to persist across sessions -- Configuration files -- Documentation and knowledge base -- Templates for recurring tasks - -## Workspace Organization -1. **Use descriptive names**: `customer-analysis-2024` not `proj1` -2. **Group related files**: Keep project files together -3. **Separate concerns**: Code in src/, data in data/, docs in docs/ -4. **Version important files**: Use timestamps or version numbers -5. **Document structure**: Include README.md in project folders - - -------------------------------------------------------------------------------- - -# Skill System -Skills provide expert guidance for specialized tasks. Skills are located at `/skills/{skill-name}/SKILL.md` - -## Locating the Skills Directory -**Skills location is environment-dependent. Use the get_skills_dir tool to locate them.** - -### Available Skills -**puppeteer** - Browser Automation & Web Scraping -- Path: `skills/puppeteer/SKILL.md` -- Use for: Browser automation, web scraping, screenshot capture, PDF generation from web pages, form filling, testing web applications -- Triggers: "scrape this website", "take a screenshot of", "automate browser", "extract data from webpage", "fill out this form", "convert webpage to PDF" -- Prerequisites: Node.js installed, Puppeteer npm package - -### Skill Loading Workflow -1. User requests task that require a specific skill which you don't have -2. Identify required skill -3. Read skills/{skill-name}/SKILL.md -4. Read and understand the skill instructions -5. Follow the skill's best practices -6. Execute the task +Use the workspace for anything that needs to persist across sessions. From 8e8a72cb2abc31d52316cfbb362074640d90a207 Mon Sep 17 00:00:00 2001 From: "rikulpatel@gmail.com" Date: Tue, 5 May 2026 15:27:12 -0500 Subject: [PATCH 32/84] refactor: restructure app/ into core/, cli/, channels/, infra/ packages Reorganises the flat app/ directory into four subpackages by responsibility: - core/: agent loop, LLM client, tool dispatch, scheduled tasks, Tool ABC, sys_instructions.md - cli/: CLI agent, REPL input loop - channels/: channel abstraction, message types, Telegram integration - infra/: logging, config setup, DB history, startup context, term display All internal imports and test patch paths updated accordingly. 109 tests pass. --- app/bg_server.py | 10 ++--- app/channels/__init__.py | 0 app/{ => channels}/channel.py | 0 app/{ => channels}/message.py | 2 +- app/{ => channels}/message_queue.py | 2 +- .../telegram.py} | 0 app/cli/__init__.py | 0 app/{ => cli}/cli.py | 2 +- app/{ => cli}/cli_agent.py | 12 +++--- app/core/__init__.py | 0 app/{ => core}/agent.py | 2 +- app/{ => core}/background_agent.py | 12 +++--- app/{ => core}/client.py | 2 +- app/{ => core}/helper_agent.py | 4 +- app/{ => core}/scheduled_tasks.py | 4 +- app/{ => core}/sys_instructions.md | 0 app/{tools => core}/tool.py | 0 app/{ => core}/tool_calls.py | 32 +++++++-------- app/infra/__init__.py | 0 app/{ => infra}/app_logging.py | 2 +- app/{ => infra}/helpers.py | 0 app/{ => infra}/message_history.py | 2 +- app/{ => infra}/setup.py | 2 +- app/{ => infra}/startup.py | 4 +- app/{ => infra}/term_display.py | 0 app/main.py | 8 ++-- app/tools/bash.py | 4 +- app/tools/calculator.py | 4 +- app/tools/get_skills_dir.py | 4 +- app/tools/hackernews.py | 4 +- app/tools/read_file.py | 4 +- app/tools/sched_tasks_tool.py | 6 +-- app/tools/todo.py | 4 +- app/tools/web_fetch.py | 4 +- app/tools/web_search.py | 4 +- app/tools/write_file.py | 4 +- tests/integration/test_cli.py | 6 +-- tests/test_agent.py | 27 +++++++------ tests/test_background_agent.py | 40 +++++++++---------- tests/test_client.py | 8 ++-- tests/test_display.py | 6 +-- tests/test_main.py | 4 +- tests/test_startup.py | 4 +- tests/test_telegram_channel.py | 12 +++--- tests/test_tool_calls.py | 2 +- 45 files changed, 127 insertions(+), 126 deletions(-) create mode 100644 app/channels/__init__.py rename app/{ => channels}/channel.py (100%) rename app/{ => channels}/message.py (89%) rename app/{ => channels}/message_queue.py (97%) rename app/{telegram_channel.py => channels/telegram.py} (100%) create mode 100644 app/cli/__init__.py rename app/{ => cli}/cli.py (95%) rename app/{ => cli}/cli_agent.py (93%) create mode 100644 app/core/__init__.py rename app/{ => core}/agent.py (96%) rename app/{ => core}/background_agent.py (95%) rename app/{ => core}/client.py (96%) rename app/{ => core}/helper_agent.py (97%) rename app/{ => core}/scheduled_tasks.py (99%) rename app/{ => core}/sys_instructions.md (100%) rename app/{tools => core}/tool.py (100%) rename app/{ => core}/tool_calls.py (70%) create mode 100644 app/infra/__init__.py rename app/{ => infra}/app_logging.py (98%) rename app/{ => infra}/helpers.py (100%) rename app/{ => infra}/message_history.py (98%) rename app/{ => infra}/setup.py (95%) rename app/{ => infra}/startup.py (90%) rename app/{ => infra}/term_display.py (100%) diff --git a/app/bg_server.py b/app/bg_server.py index a77ee3b..019fd0c 100755 --- a/app/bg_server.py +++ b/app/bg_server.py @@ -2,10 +2,10 @@ import os from . import config -from .app_logging import log -from .background_agent import BackgroundAgent -from .message_queue import MessageQueue -from .scheduled_tasks import ScheduledTasks +from .infra.app_logging import log +from .core.background_agent import BackgroundAgent +from .channels.message_queue import MessageQueue +from .core.scheduled_tasks import ScheduledTasks async def start_server() -> None: @@ -27,7 +27,7 @@ async def start_server() -> None: log.error("Telegram BOT_TOKEN not set in config, skipping Telegram channel") return - from .telegram_channel import TelegramChannel + from .channels.telegram import TelegramChannel telegram_channel = TelegramChannel(mq, bot_token=bot_token, allow_from=config.telegram.get("ALLOW_FROM", [])) if not telegram_channel: diff --git a/app/channels/__init__.py b/app/channels/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/app/channel.py b/app/channels/channel.py similarity index 100% rename from app/channel.py rename to app/channels/channel.py diff --git a/app/message.py b/app/channels/message.py similarity index 89% rename from app/message.py rename to app/channels/message.py index ff127e7..0a29e79 100755 --- a/app/message.py +++ b/app/channels/message.py @@ -1,4 +1,4 @@ -from app.channel import Channel +from .channel import Channel from dataclasses import dataclass, field @dataclass diff --git a/app/message_queue.py b/app/channels/message_queue.py similarity index 97% rename from app/message_queue.py rename to app/channels/message_queue.py index 71eee88..d3772de 100755 --- a/app/message_queue.py +++ b/app/channels/message_queue.py @@ -3,7 +3,7 @@ from .channel import Channel from .message import IncomingMessage, OutgoingMessage -from .app_logging import log +from ..infra.app_logging import log # callback type: receives outbound message and delivers it DeliveryFn = Callable[[OutgoingMessage], Awaitable[None]] diff --git a/app/telegram_channel.py b/app/channels/telegram.py similarity index 100% rename from app/telegram_channel.py rename to app/channels/telegram.py diff --git a/app/cli/__init__.py b/app/cli/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/app/cli.py b/app/cli/cli.py similarity index 95% rename from app/cli.py rename to app/cli/cli.py index c4bb9db..fe57a53 100755 --- a/app/cli.py +++ b/app/cli/cli.py @@ -1,4 +1,4 @@ -from .term_display import ANSI +from ..infra.term_display import ANSI import asyncio def ask_permission(tool_name: str, args: dict) -> bool: diff --git a/app/cli_agent.py b/app/cli/cli_agent.py similarity index 93% rename from app/cli_agent.py rename to app/cli/cli_agent.py index 5231763..cbd2801 100755 --- a/app/cli_agent.py +++ b/app/cli/cli_agent.py @@ -2,13 +2,13 @@ import json -from . import config -from .tool_calls import run_tool, all_tool_specs -from .app_logging import log +from .. import config +from ..core.tool_calls import run_tool, all_tool_specs +from ..infra.app_logging import log from .cli import ask_permission -from .agent import Agent, MAX_CONTEXT_MESSAGES -from .message_history import MessageHistory -from .channel import ChannelType +from ..core.agent import Agent, MAX_CONTEXT_MESSAGES +from ..infra.message_history import MessageHistory +from ..channels.channel import ChannelType class CliAgent(Agent): diff --git a/app/core/__init__.py b/app/core/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/app/agent.py b/app/core/agent.py similarity index 96% rename from app/agent.py rename to app/core/agent.py index a15331d..491be9c 100755 --- a/app/agent.py +++ b/app/core/agent.py @@ -1,7 +1,7 @@ from abc import ABC, abstractmethod from .client import Client -from .startup import load_system_context +from ..infra.startup import load_system_context MAX_CONTEXT_MESSAGES = 100 diff --git a/app/background_agent.py b/app/core/background_agent.py similarity index 95% rename from app/background_agent.py rename to app/core/background_agent.py index 465ec44..07987bb 100755 --- a/app/background_agent.py +++ b/app/core/background_agent.py @@ -3,15 +3,15 @@ import asyncio import json -from . import config +from .. import config from .tool_calls import run_tool, all_tool_specs -from .app_logging import log -from .channel import Channel -from .message import OutgoingMessage -from .message_queue import MessageQueue +from ..infra.app_logging import log +from ..channels.channel import Channel +from ..channels.message import OutgoingMessage +from ..channels.message_queue import MessageQueue from .agent import Agent, MAX_CONTEXT_MESSAGES -from .message_history import MessageHistory +from ..infra.message_history import MessageHistory class BackgroundAgent(Agent): diff --git a/app/client.py b/app/core/client.py similarity index 96% rename from app/client.py rename to app/core/client.py index 0ac0b76..6666233 100644 --- a/app/client.py +++ b/app/core/client.py @@ -2,7 +2,7 @@ from openai import AsyncOpenAI import os -from . import config +from .. import config class Client: diff --git a/app/helper_agent.py b/app/core/helper_agent.py similarity index 97% rename from app/helper_agent.py rename to app/core/helper_agent.py index 74e6fa8..15e4834 100644 --- a/app/helper_agent.py +++ b/app/core/helper_agent.py @@ -2,8 +2,8 @@ import json -from . import config -from .app_logging import log +from .. import config +from ..infra.app_logging import log from .agent import Agent diff --git a/app/scheduled_tasks.py b/app/core/scheduled_tasks.py similarity index 99% rename from app/scheduled_tasks.py rename to app/core/scheduled_tasks.py index a2d4210..0251d9a 100755 --- a/app/scheduled_tasks.py +++ b/app/core/scheduled_tasks.py @@ -1,8 +1,8 @@ from __future__ import annotations from datetime import datetime, timedelta -from .app_logging import log -from .config import APP_DB +from ..infra.app_logging import log +from ..config import APP_DB import sqlite3 import asyncio from .helper_agent import HelperAgent diff --git a/app/sys_instructions.md b/app/core/sys_instructions.md similarity index 100% rename from app/sys_instructions.md rename to app/core/sys_instructions.md diff --git a/app/tools/tool.py b/app/core/tool.py similarity index 100% rename from app/tools/tool.py rename to app/core/tool.py diff --git a/app/tool_calls.py b/app/core/tool_calls.py similarity index 70% rename from app/tool_calls.py rename to app/core/tool_calls.py index 6d91444..7786c67 100755 --- a/app/tool_calls.py +++ b/app/core/tool_calls.py @@ -1,23 +1,23 @@ import os -from .app_logging import log -from .helpers import trunc_str_with_ellipsis -from .tools.read_file import ReadFileTool -from .tools.write_file import WriteFileTool -from .tools.bash import BashTool -from .tools.web_fetch import WebFetchTool -from .tools.get_skills_dir import GetSkillsDirTool -from .tools.todo import TodoAddTool, TodoListTool, TodoClearTool, TodoUpdateTool -from .tools.calculator import CalculatorTool -from .tools.hackernews import HackerNewsTool +from ..infra.app_logging import log +from ..infra.helpers import trunc_str_with_ellipsis +from ..tools.read_file import ReadFileTool +from ..tools.write_file import WriteFileTool +from ..tools.bash import BashTool +from ..tools.web_fetch import WebFetchTool +from ..tools.get_skills_dir import GetSkillsDirTool +from ..tools.todo import TodoAddTool, TodoListTool, TodoClearTool, TodoUpdateTool +from ..tools.calculator import CalculatorTool +from ..tools.hackernews import HackerNewsTool -from .tools.web_search import WebSearchText -from .tools.web_search import WebSearchImages -from .tools.web_search import WebSearchVideos -from .tools.web_search import WebSearchNews -from .tools.web_search import WebSearchBooks +from ..tools.web_search import WebSearchText +from ..tools.web_search import WebSearchImages +from ..tools.web_search import WebSearchVideos +from ..tools.web_search import WebSearchNews +from ..tools.web_search import WebSearchBooks -from .tools.sched_tasks_tool import ListScheduledTasks, AddScheduledTask, UpdateScheduledTask, \ +from ..tools.sched_tasks_tool import ListScheduledTasks, AddScheduledTask, UpdateScheduledTask, \ RemoveScheduledTask, GetScheduledTaskOutput import json diff --git a/app/infra/__init__.py b/app/infra/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/app/app_logging.py b/app/infra/app_logging.py similarity index 98% rename from app/app_logging.py rename to app/infra/app_logging.py index 4b614b5..1004030 100755 --- a/app/app_logging.py +++ b/app/infra/app_logging.py @@ -3,7 +3,7 @@ import logging import logging.handlers from pathlib import Path -from .config import APP_NAME +from ..config import APP_NAME from .term_display import ANSI LOG_DIR = Path.home() / f".{APP_NAME}" / "logs" diff --git a/app/helpers.py b/app/infra/helpers.py similarity index 100% rename from app/helpers.py rename to app/infra/helpers.py diff --git a/app/message_history.py b/app/infra/message_history.py similarity index 98% rename from app/message_history.py rename to app/infra/message_history.py index 782ce06..0f58ad2 100755 --- a/app/message_history.py +++ b/app/infra/message_history.py @@ -4,7 +4,7 @@ from datetime import datetime from pathlib import Path from .app_logging import log -from .config import APP_DB +from ..config import APP_DB def _est_tokens(content: str) -> int: return max(1, len(content) // 4) diff --git a/app/setup.py b/app/infra/setup.py similarity index 95% rename from app/setup.py rename to app/infra/setup.py index df31758..8f95ec6 100755 --- a/app/setup.py +++ b/app/infra/setup.py @@ -1,7 +1,7 @@ from __future__ import annotations from pathlib import Path -from .config import get_default_config, APP_NAME, APP_DB +from ..config import get_default_config, APP_NAME, APP_DB from .app_logging import log def ensure_home_dir() -> None: diff --git a/app/startup.py b/app/infra/startup.py similarity index 90% rename from app/startup.py rename to app/infra/startup.py index e04391d..01551df 100755 --- a/app/startup.py +++ b/app/infra/startup.py @@ -3,7 +3,7 @@ import platform from datetime import datetime from .app_logging import log -from . import config +from .. import config def load_system_context() -> str: """ @@ -11,7 +11,7 @@ def load_system_context() -> str: """ now = datetime.now() - sys_instructions_path = Path(__file__).parent / "sys_instructions.md" + sys_instructions_path = Path(__file__).parent.parent / "core" / "sys_instructions.md" system_context = "" try: diff --git a/app/term_display.py b/app/infra/term_display.py similarity index 100% rename from app/term_display.py rename to app/infra/term_display.py diff --git a/app/main.py b/app/main.py index 043bbcd..63d312e 100644 --- a/app/main.py +++ b/app/main.py @@ -6,10 +6,10 @@ import os from . import config -from .app_logging import setup_logging, log -from .setup import ensure_home_dir, migrate_db_path -from .cli import input_loop -from .cli_agent import CliAgent +from .infra.app_logging import setup_logging, log +from .infra.setup import ensure_home_dir, migrate_db_path +from .cli.cli import input_loop +from .cli.cli_agent import CliAgent from .bg_server import start_server from dotenv import load_dotenv diff --git a/app/tools/bash.py b/app/tools/bash.py index bbaac50..2450b48 100755 --- a/app/tools/bash.py +++ b/app/tools/bash.py @@ -1,6 +1,6 @@ import subprocess -from ..app_logging import log -from .tool import Tool +from ..infra.app_logging import log +from ..core.tool import Tool class BashTool(Tool): diff --git a/app/tools/calculator.py b/app/tools/calculator.py index 4e660a1..3fd7d15 100755 --- a/app/tools/calculator.py +++ b/app/tools/calculator.py @@ -1,5 +1,5 @@ -from ..app_logging import log -from .tool import Tool +from ..infra.app_logging import log +from ..core.tool import Tool import math diff --git a/app/tools/get_skills_dir.py b/app/tools/get_skills_dir.py index 1faca66..df67232 100755 --- a/app/tools/get_skills_dir.py +++ b/app/tools/get_skills_dir.py @@ -1,6 +1,6 @@ -from ..app_logging import log +from ..infra.app_logging import log import pathlib -from .tool import Tool +from ..core.tool import Tool class GetSkillsDirTool(Tool): diff --git a/app/tools/hackernews.py b/app/tools/hackernews.py index c95ca78..7f868c8 100755 --- a/app/tools/hackernews.py +++ b/app/tools/hackernews.py @@ -1,5 +1,5 @@ -from ..app_logging import log -from .tool import Tool +from ..infra.app_logging import log +from ..core.tool import Tool import httpx import json diff --git a/app/tools/read_file.py b/app/tools/read_file.py index 43c4024..a575963 100755 --- a/app/tools/read_file.py +++ b/app/tools/read_file.py @@ -1,5 +1,5 @@ -from ..app_logging import log -from .tool import Tool +from ..infra.app_logging import log +from ..core.tool import Tool class ReadFileTool(Tool): @staticmethod diff --git a/app/tools/sched_tasks_tool.py b/app/tools/sched_tasks_tool.py index e2c0219..b82cfbc 100755 --- a/app/tools/sched_tasks_tool.py +++ b/app/tools/sched_tasks_tool.py @@ -1,6 +1,6 @@ -from ..app_logging import log -from .tool import Tool -from ..scheduled_tasks import ScheduledTasks +from ..infra.app_logging import log +from ..core.tool import Tool +from ..core.scheduled_tasks import ScheduledTasks class ListScheduledTasks(Tool): diff --git a/app/tools/todo.py b/app/tools/todo.py index cb76f53..b6a0480 100644 --- a/app/tools/todo.py +++ b/app/tools/todo.py @@ -1,5 +1,5 @@ -from ..app_logging import log -from .tool import Tool +from ..infra.app_logging import log +from ..core.tool import Tool _tasks: dict[str, dict] = {} _next_id = 1 diff --git a/app/tools/web_fetch.py b/app/tools/web_fetch.py index d3c3129..9eacd05 100755 --- a/app/tools/web_fetch.py +++ b/app/tools/web_fetch.py @@ -1,6 +1,6 @@ import subprocess -from ..app_logging import log -from .tool import Tool +from ..infra.app_logging import log +from ..core.tool import Tool class WebFetchTool(Tool): diff --git a/app/tools/web_search.py b/app/tools/web_search.py index f8e7e9e..399b930 100755 --- a/app/tools/web_search.py +++ b/app/tools/web_search.py @@ -1,5 +1,5 @@ -from ..app_logging import log -from .tool import Tool +from ..infra.app_logging import log +from ..core.tool import Tool from ddgs import DDGS diff --git a/app/tools/write_file.py b/app/tools/write_file.py index ab18eea..eaab170 100755 --- a/app/tools/write_file.py +++ b/app/tools/write_file.py @@ -1,7 +1,7 @@ import os -from ..app_logging import log +from ..infra.app_logging import log from pathlib import Path -from .tool import Tool +from ..core.tool import Tool class WriteFileTool(Tool): diff --git a/tests/integration/test_cli.py b/tests/integration/test_cli.py index ea616d7..02e6962 100644 --- a/tests/integration/test_cli.py +++ b/tests/integration/test_cli.py @@ -12,7 +12,7 @@ import app.config as config_module from app.main import main -from app.app_logging import log as app_log +from app.infra.app_logging import log as app_log def _make_llm_response(content: str) -> MagicMock: @@ -48,8 +48,8 @@ async def test_cli_with_simple_prompt(capsys): original_log_level = app_log.level try: with patch("sys.argv", ["prog", "cli", "-p", "say hello", "--silent"]), \ - patch("app.agent.Client") as MockClient, \ - patch("app.startup.load_system_context", return_value=""), \ + patch("app.core.agent.Client") as MockClient, \ + patch("app.infra.startup.load_system_context", return_value=""), \ patch("app.main.config.load"), \ patch.object(config_module, "_config", {"model": "test-model"}): diff --git a/tests/test_agent.py b/tests/test_agent.py index 0d0e7c3..94377ca 100644 --- a/tests/test_agent.py +++ b/tests/test_agent.py @@ -2,7 +2,8 @@ from unittest.mock import patch, MagicMock, AsyncMock import app.config as config -from app.cli_agent import CliAgent as Agent, MessageHistory +from app.cli.cli_agent import CliAgent as Agent +from app.infra.message_history import MessageHistory def make_mock_client(tool_calls=None, content="Hello!", finish_reason="stop"): @@ -25,10 +26,10 @@ def make_mock_client(tool_calls=None, content="Hello!", finish_reason="stop"): def make_agent(auto_approve=True, silent=True, max_iterations=10): - with patch("app.agent.Client") as MockClient: + with patch("app.core.agent.Client") as MockClient: mock_openai = make_mock_client() MockClient.return_value.get_client.return_value = mock_openai - with patch("app.agent.load_system_context", return_value="You are a helpful assistant."): + with patch("app.core.agent.load_system_context", return_value="You are a helpful assistant."): with patch.object(MessageHistory, "get_history", return_value=[]): agent = Agent( auto_approve=auto_approve, silent=silent, max_iterations=max_iterations @@ -45,9 +46,9 @@ def patch_config(): def test_agent_initializes_with_system_context(): - with patch("app.agent.Client") as MockClient: + with patch("app.core.agent.Client") as MockClient: MockClient.return_value.get_client.return_value = MagicMock() - with patch("app.agent.load_system_context", return_value="system prompt"): + with patch("app.core.agent.load_system_context", return_value="system prompt"): with patch.object(MessageHistory, "get_history", return_value=[]): agent = Agent(auto_approve=True, silent=True, max_iterations=10) assert len(agent.messages) == 1 @@ -85,10 +86,10 @@ async def test_agent_loop_raises_on_empty_choices(): @pytest.mark.asyncio async def test_agent_loop_respects_max_iterations(): - with patch("app.agent.Client") as MockClient: + with patch("app.core.agent.Client") as MockClient: mock_client = MagicMock() MockClient.return_value.get_client.return_value = mock_client - with patch("app.agent.load_system_context", return_value="You are a helpful assistant."): + with patch("app.core.agent.load_system_context", return_value="You are a helpful assistant."): with patch.object(MessageHistory, "get_history", return_value=[]): agent = Agent(auto_approve=True, silent=True, max_iterations=3) agent.client = mock_client @@ -111,7 +112,7 @@ async def test_agent_loop_respects_max_iterations(): mock_response.choices = [mock_choice] mock_client.chat.completions.create = AsyncMock(return_value=mock_response) - with patch("app.cli_agent.run_tool", return_value="hi\n"): + with patch("app.cli.cli_agent.run_tool", return_value="hi\n"): await agent.agent_loop("run forever") # Should have stopped after max_iterations=3 LLM calls @@ -120,10 +121,10 @@ async def test_agent_loop_respects_max_iterations(): @pytest.mark.asyncio async def test_agent_loop_runs_tool_when_auto_approve(): - with patch("app.agent.Client") as MockClient: + with patch("app.core.agent.Client") as MockClient: mock_client = MagicMock() MockClient.return_value.get_client.return_value = mock_client - with patch("app.agent.load_system_context", return_value="You are a helpful assistant."): + with patch("app.core.agent.load_system_context", return_value="You are a helpful assistant."): with patch.object(MessageHistory, "get_history", return_value=[]): agent = Agent(auto_approve=True, silent=True, max_iterations=10) agent.client = mock_client @@ -159,7 +160,7 @@ async def test_agent_loop_runs_tool_when_auto_approve(): side_effect=[response_with_tool, response_plain] ) - with patch("app.cli_agent.run_tool", return_value="hi\n") as mock_run_tool: + with patch("app.cli.cli_agent.run_tool", return_value="hi\n") as mock_run_tool: await agent.agent_loop("say hi") mock_run_tool.assert_called_once_with( @@ -169,10 +170,10 @@ async def test_agent_loop_runs_tool_when_auto_approve(): @pytest.mark.asyncio async def test_agent_loop_continues_when_finish_reason_not_stop(): - with patch("app.agent.Client") as MockClient: + with patch("app.core.agent.Client") as MockClient: mock_client = MagicMock() MockClient.return_value.get_client.return_value = mock_client - with patch("app.agent.load_system_context", return_value="You are a helpful assistant."): + with patch("app.core.agent.load_system_context", return_value="You are a helpful assistant."): with patch.object(MessageHistory, "get_history", return_value=[]): agent = Agent(auto_approve=True, silent=True, max_iterations=10) agent.client = mock_client diff --git a/tests/test_background_agent.py b/tests/test_background_agent.py index 2646066..3cbe784 100644 --- a/tests/test_background_agent.py +++ b/tests/test_background_agent.py @@ -2,10 +2,10 @@ from unittest.mock import patch, MagicMock, AsyncMock import app.config as config -from app.background_agent import BackgroundAgent -from app.channel import ChannelType -from app.message import IncomingMessage -from app.message_queue import MessageQueue +from app.core.background_agent import BackgroundAgent +from app.channels.channel import ChannelType +from app.channels.message import IncomingMessage +from app.channels.message_queue import MessageQueue # Mock Channel instance (Channel is now an ABC, not an enum) _mock_channel = MagicMock() @@ -32,11 +32,11 @@ def make_mock_client(tool_calls=None, content="Hello!", finish_reason="stop"): def make_agent(max_iterations=10): mq = MessageQueue() - with patch("app.agent.Client") as MockClient: + with patch("app.core.agent.Client") as MockClient: mock_openai = make_mock_client() MockClient.return_value.get_client.return_value = mock_openai - with patch("app.agent.load_system_context", return_value="You are a helpful assistant."): - with patch("app.background_agent.MessageHistory") as MockHistory: + with patch("app.core.agent.load_system_context", return_value="You are a helpful assistant."): + with patch("app.core.background_agent.MessageHistory") as MockHistory: MockHistory.return_value.get_history.return_value = [] agent = BackgroundAgent(mq=mq, channel=_mock_channel, max_iterations=max_iterations) agent.client = mock_openai @@ -57,10 +57,10 @@ def test_agent_initializes_with_empty_messages(): def test_agent_initializes_with_system_context(): mq = MessageQueue() - with patch("app.agent.Client") as MockClient: + with patch("app.core.agent.Client") as MockClient: MockClient.return_value.get_client.return_value = MagicMock() - with patch("app.agent.load_system_context", return_value="system prompt"): - with patch("app.background_agent.MessageHistory") as MockHistory: + with patch("app.core.agent.load_system_context", return_value="system prompt"): + with patch("app.core.background_agent.MessageHistory") as MockHistory: MockHistory.return_value.get_history.return_value = [] agent = BackgroundAgent(mq=mq, channel=_mock_channel) assert len(agent.messages) == 1 @@ -70,10 +70,10 @@ def test_agent_initializes_with_system_context(): def test_agent_stores_channel_and_mq(): mq = MessageQueue() - with patch("app.agent.Client") as MockClient: + with patch("app.core.agent.Client") as MockClient: MockClient.return_value.get_client.return_value = MagicMock() - with patch("app.agent.load_system_context", return_value=""): - with patch("app.background_agent.MessageHistory") as MockHistory: + with patch("app.core.agent.load_system_context", return_value=""): + with patch("app.core.background_agent.MessageHistory") as MockHistory: MockHistory.return_value.get_history.return_value = [] agent = BackgroundAgent(mq=mq, channel=_mock_channel) assert agent.channel == _mock_channel @@ -102,7 +102,7 @@ async def test_agent_loop_raises_on_empty_choices(): mock_response.choices = [] mock_client.chat.completions.create = AsyncMock(return_value=mock_response) - with patch("app.background_agent.asyncio.sleep", new_callable=AsyncMock) as mock_sleep: + with patch("app.core.background_agent.asyncio.sleep", new_callable=AsyncMock) as mock_sleep: with pytest.raises(RuntimeError, match="No choices in API response after 5 retries"): await agent.agent_loop("Hello") assert mock_sleep.call_count == 5 @@ -141,7 +141,7 @@ async def test_agent_loop_respects_max_iterations(): mock_response.choices = [mock_choice] mock_client.chat.completions.create = AsyncMock(return_value=mock_response) - with patch("app.background_agent.run_tool", return_value="hi\n"): + with patch("app.core.background_agent.run_tool", return_value="hi\n"): await agent.agent_loop("run forever") assert mock_client.chat.completions.create.call_count == 3 @@ -176,7 +176,7 @@ async def test_agent_loop_runs_tool_and_sends_final_reply(): mock_client.chat.completions.create = AsyncMock(side_effect=[response_with_tool, response_plain]) - with patch("app.background_agent.run_tool", return_value="hi\n") as mock_run_tool: + with patch("app.core.background_agent.run_tool", return_value="hi\n") as mock_run_tool: await agent.agent_loop("say hi", metadata={"chat_id": 42}) mock_run_tool.assert_called_once_with(tool_name="bash", tool_args={"command": "echo hi"}) @@ -216,7 +216,7 @@ async def test_agent_loop_sends_inline_content_with_tool_calls(): mock_client.chat.completions.create = AsyncMock(side_effect=[response_with_tool, response_plain]) - with patch("app.background_agent.run_tool", return_value="hi\n"): + with patch("app.core.background_agent.run_tool", return_value="hi\n"): await agent.agent_loop("run something") messages = [] @@ -236,10 +236,10 @@ async def test_agent_loop_clears_stopped_after_completion(): local_channel.channel_type = ChannelType.TELEGRAM local_channel.has_stopped = False - with patch("app.agent.Client") as MockClient: + with patch("app.core.agent.Client") as MockClient: MockClient.return_value.get_client.return_value = make_mock_client() - with patch("app.agent.load_system_context", return_value=""): - with patch("app.background_agent.MessageHistory") as MockHistory: + with patch("app.core.agent.load_system_context", return_value=""): + with patch("app.core.background_agent.MessageHistory") as MockHistory: MockHistory.return_value.get_history.return_value = [] agent = BackgroundAgent(mq=mq, channel=local_channel, max_iterations=10) agent.client = make_mock_client() diff --git a/tests/test_client.py b/tests/test_client.py index b11e121..1e006ef 100644 --- a/tests/test_client.py +++ b/tests/test_client.py @@ -2,7 +2,7 @@ import pytest from unittest.mock import patch, MagicMock -from app.client import Client +from app.core.client import Client def test_client_raises_when_no_api_key(): @@ -13,7 +13,7 @@ def test_client_raises_when_no_api_key(): def test_client_get_client_returns_openai_instance(): - with patch("app.client.AsyncOpenAI") as MockOpenAI: + with patch("app.core.client.AsyncOpenAI") as MockOpenAI: mock_instance = MagicMock() MockOpenAI.return_value = mock_instance client = Client(api_key="test-key", base_url="https://example.com") @@ -21,13 +21,13 @@ def test_client_get_client_returns_openai_instance(): def test_client_uses_provided_base_url(): - with patch("app.client.AsyncOpenAI") as MockOpenAI: + with patch("app.core.client.AsyncOpenAI") as MockOpenAI: Client(api_key="test-key", base_url="https://custom.api.com") MockOpenAI.assert_called_once_with(api_key="test-key", base_url="https://custom.api.com") def test_client_uses_default_base_url_when_not_set(): with patch.dict(os.environ, {"LLM_BASE_URL": ""}, clear=False): - with patch("app.client.AsyncOpenAI") as MockOpenAI: + with patch("app.core.client.AsyncOpenAI") as MockOpenAI: Client(api_key="test-key") MockOpenAI.assert_called_once() diff --git a/tests/test_display.py b/tests/test_display.py index cdb6524..83af01a 100644 --- a/tests/test_display.py +++ b/tests/test_display.py @@ -1,14 +1,14 @@ import logging from unittest.mock import patch -from app.cli import ask_permission -from app.app_logging import log +from app.cli.cli import ask_permission +from app.infra.app_logging import log def test_log_is_configured(): """Test that log is a properly configured logger instance""" assert isinstance(log, logging.Logger) - assert log.name == "app.app_logging" + assert log.name == "app.infra.app_logging" def test_log_level_is_info_by_default(): diff --git a/tests/test_main.py b/tests/test_main.py index 72a1a3a..e8d6cc7 100644 --- a/tests/test_main.py +++ b/tests/test_main.py @@ -2,7 +2,7 @@ import pytest from unittest.mock import patch, MagicMock, AsyncMock -from app.cli import input_loop +from app.cli.cli import input_loop from app.main import main @@ -149,7 +149,7 @@ async def test_main_silent_sets_log_level_to_warning(): for p in patches: p.stop() - from app.app_logging import log + from app.infra.app_logging import log assert log.level == logging.WARNING diff --git a/tests/test_startup.py b/tests/test_startup.py index 872d953..12491db 100644 --- a/tests/test_startup.py +++ b/tests/test_startup.py @@ -1,7 +1,7 @@ import pathlib from unittest.mock import patch -from app.startup import load_system_context +from app.infra.startup import load_system_context def test_load_system_context_returns_string(): result = load_system_context() @@ -18,7 +18,7 @@ def test_load_system_context_skips_missing_files(tmp_path): system_md_dir = tmp_path / "system.md" system_md_dir.mkdir() - with patch("app.startup.Path") as MockPath: + with patch("app.infra.startup.Path") as MockPath: instance = MockPath.return_value instance.parent.__truediv__ = lambda self, key: system_md_dir MockPath.side_effect = lambda *args, **kwargs: pathlib.Path(*args, **kwargs) diff --git a/tests/test_telegram_channel.py b/tests/test_telegram_channel.py index 830a072..2322cf2 100644 --- a/tests/test_telegram_channel.py +++ b/tests/test_telegram_channel.py @@ -1,15 +1,15 @@ import pytest from unittest.mock import patch, MagicMock, AsyncMock -from app.channel import ChannelType -from app.message import OutgoingMessage -from app.message_queue import MessageQueue -from app.telegram_channel import TelegramChannel +from app.channels.channel import ChannelType +from app.channels.message import OutgoingMessage +from app.channels.message_queue import MessageQueue +from app.channels.telegram import TelegramChannel def make_telegram_channel(allow_from=None): mq = MessageQueue() - with patch("app.telegram_channel.ApplicationBuilder"): + with patch("app.channels.telegram.ApplicationBuilder"): tc = TelegramChannel(mq=mq, bot_token="test-token", allow_from=allow_from) return tc, mq @@ -18,7 +18,7 @@ def make_telegram_channel(allow_from=None): def test_registers_delivery_function(): mq = MessageQueue() - with patch("app.telegram_channel.ApplicationBuilder"): + with patch("app.channels.telegram.ApplicationBuilder"): tc = TelegramChannel(mq=mq, bot_token="test-token") # register(self, fn) uses the channel object as the key assert tc in mq._delivery diff --git a/tests/test_tool_calls.py b/tests/test_tool_calls.py index 41034a9..559bcc9 100644 --- a/tests/test_tool_calls.py +++ b/tests/test_tool_calls.py @@ -1,5 +1,5 @@ -from app.tool_calls import run_tool, tool_registry +from app.core.tool_calls import run_tool, tool_registry def test_tool_registry_contains_expected_tools(): From cc2ceab077447356009db84751fa49d3281a2b3f Mon Sep 17 00:00:00 2001 From: "rikulpatel@gmail.com" Date: Tue, 5 May 2026 17:37:29 -0500 Subject: [PATCH 33/84] fix: updated sys instru to ask confirmation before destructive actions. --- app/core/sys_instructions.md | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/app/core/sys_instructions.md b/app/core/sys_instructions.md index 9a48fe8..66d76bb 100644 --- a/app/core/sys_instructions.md +++ b/app/core/sys_instructions.md @@ -12,15 +12,14 @@ For longer or multi-step tasks, use a todo or planning approach to keep the work For browser automation, scraping, screenshots, PDF generation from webpages, form filling, or web application testing, use the Puppeteer skill when applicable. Locate and read the relevant skill instructions first, then follow the best practices described there. When using the Puppeteer skill, read the instructions at skills/puppeteer/SKILL.md before proceeding. - For persistent project work, use the workspace thoughtfully. Store reusable project files, notes, outputs, plans, code reviews, and documentation in clearly named folders. Prefer descriptive project names, group related files together, separate concerns such as src/, data/, and docs/, and include a README when a folder’s purpose is not obvious. +Never delete files, directories, or data without explicit confirmation from the user. If a task seems to require removing something, describe what would be deleted and ask before proceeding. This applies to shell commands like rm, rmdir, and any write_file or bash call that would overwrite or destroy existing content. Prefer moving or renaming over deleting when in doubt. + Overall, I value careful execution, verified results, clear communication, and practical error recovery. Do not skip verification steps when a tool changes state or creates artifacts. The goal is not just to complete the task, but to complete it in a way that can be trusted. The following tools are available. Use them fully and never fake or skip a call. File and shell: bash, read_file, write_file. Web: web_fetch, websearch_text, websearch_images, websearch_videos, websearch_news, websearch_books, hackernews. Utilities: calculator. Todo: todo_add, todo_list, todo_update, todo_clear. -Scheduled tasks run in the background via the background agent. Use add_scheduled_task(name, prompt, interval_minutes, repeat, next_run, delivery_channel) to create one, update_scheduled_task to modify or enable/disable, remove_scheduled_task to delete, list_scheduled_tasks to inspect, and get_scheduled_task_output(name, num_entries) to read recent results. For a repeating task: add_scheduled_task(name="morning-news", prompt="Fetch top 5 HN stories and summarize", interval_minutes=60, repeat=true, delivery_channel="telegram"). For a one-shot task: add_scheduled_task(name="reminder", prompt="Remind user to take a break", repeat=false, next_run="2026-05-04T15:00:00"). - -Use the workspace for anything that needs to persist across sessions. +Scheduled tasks run in the background via the background agent. Use add_scheduled_task(name, prompt, interval_minutes, repeat, next_run, delivery_channel) to create one, update_scheduled_task to modify or enable/disable, remove_scheduled_task to delete, list_scheduled_tasks to inspect, and get_scheduled_task_output(name, num_entries) to read recent results. For a repeating task: add_scheduled_task(name="morning-news", prompt="Fetch top 5 HN stories and summarize", interval_minutes=60, repeat=true, delivery_channel="telegram"). For a one-shot task: add_scheduled_task(name="reminder", prompt="Remind user to take a break", repeat=false, next_run="2026-05-04T15:00:00"). \ No newline at end of file From 329598163daac5ff42fe2e11a6d885eca4453f08 Mon Sep 17 00:00:00 2001 From: "rikulpatel@gmail.com" Date: Tue, 5 May 2026 19:01:29 -0500 Subject: [PATCH 34/84] fix: error while importing module named 'app.core.message' --- app/core/scheduled_tasks.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/app/core/scheduled_tasks.py b/app/core/scheduled_tasks.py index 0251d9a..6286c49 100755 --- a/app/core/scheduled_tasks.py +++ b/app/core/scheduled_tasks.py @@ -169,7 +169,7 @@ async def run_task(self, task: dict) -> str: if self._mq: channel = self._channels.get(task["delivery_channel"]) if channel: - from .message import OutgoingMessage + from ..channels.message import OutgoingMessage await self._mq.outgoing_msg(OutgoingMessage(content=output, channel=channel, metadata=self._default_metadata)) else: log.warning(f"Delivery channel '{task['delivery_channel']}' not found for task '{name}'") From c16abdde8eb0dd26a40b4babe1cee9e5fcb86083 Mon Sep 17 00:00:00 2001 From: "rikulpatel@gmail.com" Date: Wed, 6 May 2026 09:55:20 -0500 Subject: [PATCH 35/84] refactor: move system context loading to agent_loop. System context (sys_instructions.md + runtime info) is now loaded fresh on every agent_loop call and prepended to session_messages only, rather than being stored in self.messages at construction. This ensures datetime, cwd, and model fields are always current, and prevents system messages from accumulating in persistent history across calls. _trim_messages simplified now that self.messages contains only conversation history (no system message to preserve). Tests updated to assert system context is passed to the LLM call rather than stored on the agent instance. --- app/cli/cli_agent.py | 7 ++++++- app/core/agent.py | 17 ++--------------- app/core/background_agent.py | 6 +++++- tests/integration/test_cli.py | 2 +- tests/test_agent.py | 25 ++++++++++++------------- tests/test_background_agent.py | 28 ++++++++++++---------------- 6 files changed, 38 insertions(+), 47 deletions(-) diff --git a/app/cli/cli_agent.py b/app/cli/cli_agent.py index cbd2801..da281fd 100755 --- a/app/cli/cli_agent.py +++ b/app/cli/cli_agent.py @@ -9,6 +9,8 @@ from ..core.agent import Agent, MAX_CONTEXT_MESSAGES from ..infra.message_history import MessageHistory from ..channels.channel import ChannelType +from ..infra.startup import load_system_context + class CliAgent(Agent): @@ -21,9 +23,12 @@ def __init__(self, max_iterations: int = 250, auto_approve: bool = False, silent async def agent_loop(self, message: str, metadata: dict = None) -> None: self._trim_messages() + self.history.add_message("user", message) - session_messages = self.messages[:] + [{"role": "user", "content": message}] + system_context = load_system_context() + system = [{"role": "system", "content": system_context}] if system_context else [] + session_messages = system + self.messages[:] + [{"role": "user", "content": message}] iteration = 0 assistant_message = "" while iteration < self.max_iterations: diff --git a/app/core/agent.py b/app/core/agent.py index 491be9c..f1660cc 100755 --- a/app/core/agent.py +++ b/app/core/agent.py @@ -1,7 +1,6 @@ from abc import ABC, abstractmethod from .client import Client -from ..infra.startup import load_system_context MAX_CONTEXT_MESSAGES = 100 @@ -13,21 +12,9 @@ def __init__(self, max_iterations: int = 250) -> None: self.messages: list[dict] = [] self.max_iterations = max_iterations - system_context = load_system_context() - if system_context: - self.messages.append({"role": "system", "content": system_context}) - def _trim_messages(self) -> None: - """Keep system message + last MAX_CONTEXT_MESSAGES messages.""" - if self.messages and self.messages[0]["role"] == "system": - system = self.messages[:1] - rest = self.messages[1:] - else: - system = [] - rest = self.messages - - if len(rest) > MAX_CONTEXT_MESSAGES: - self.messages = system + rest[-MAX_CONTEXT_MESSAGES:] + if len(self.messages) > MAX_CONTEXT_MESSAGES: + self.messages = self.messages[-MAX_CONTEXT_MESSAGES:] @staticmethod def _serialize_assistant_msg(msg) -> dict: diff --git a/app/core/background_agent.py b/app/core/background_agent.py index 07987bb..56dbe67 100755 --- a/app/core/background_agent.py +++ b/app/core/background_agent.py @@ -10,6 +10,7 @@ from ..channels.message import OutgoingMessage from ..channels.message_queue import MessageQueue from .agent import Agent, MAX_CONTEXT_MESSAGES +from ..infra.startup import load_system_context from ..infra.message_history import MessageHistory @@ -37,9 +38,12 @@ async def process_incoming(self) -> None: async def agent_loop(self, message: str, metadata: dict = None) -> None: self._trim_messages() + self.history.add_message("user", message) - session_messages = self.messages[:] + [{"role": "user", "content": message}] + system_context = load_system_context() + system = [{"role": "system", "content": system_context}] if system_context else [] + session_messages = system + self.messages[:] + [{"role": "user", "content": message}] self._reply_metadata = metadata or {} iteration = 0 empty_retries = 0 diff --git a/tests/integration/test_cli.py b/tests/integration/test_cli.py index 02e6962..5d620ae 100644 --- a/tests/integration/test_cli.py +++ b/tests/integration/test_cli.py @@ -49,7 +49,7 @@ async def test_cli_with_simple_prompt(capsys): try: with patch("sys.argv", ["prog", "cli", "-p", "say hello", "--silent"]), \ patch("app.core.agent.Client") as MockClient, \ - patch("app.infra.startup.load_system_context", return_value=""), \ + patch("app.cli.cli_agent.load_system_context", return_value=""), \ patch("app.main.config.load"), \ patch.object(config_module, "_config", {"model": "test-model"}): diff --git a/tests/test_agent.py b/tests/test_agent.py index 94377ca..023eb34 100644 --- a/tests/test_agent.py +++ b/tests/test_agent.py @@ -29,7 +29,7 @@ def make_agent(auto_approve=True, silent=True, max_iterations=10): with patch("app.core.agent.Client") as MockClient: mock_openai = make_mock_client() MockClient.return_value.get_client.return_value = mock_openai - with patch("app.core.agent.load_system_context", return_value="You are a helpful assistant."): + with patch("app.cli.cli_agent.load_system_context", return_value="You are a helpful assistant."): with patch.object(MessageHistory, "get_history", return_value=[]): agent = Agent( auto_approve=auto_approve, silent=silent, max_iterations=max_iterations @@ -45,15 +45,14 @@ def patch_config(): yield -def test_agent_initializes_with_system_context(): - with patch("app.core.agent.Client") as MockClient: - MockClient.return_value.get_client.return_value = MagicMock() - with patch("app.core.agent.load_system_context", return_value="system prompt"): - with patch.object(MessageHistory, "get_history", return_value=[]): - agent = Agent(auto_approve=True, silent=True, max_iterations=10) - assert len(agent.messages) == 1 - assert agent.messages[0]["role"] == "system" - assert agent.messages[0]["content"] == "system prompt" +@pytest.mark.asyncio +async def test_agent_loop_sends_system_context_to_llm(): + agent, mock_client = make_agent() + with patch("app.cli.cli_agent.load_system_context", return_value="system prompt"): + await agent.agent_loop("hello") + call_messages = mock_client.chat.completions.create.call_args[1]["messages"] + assert call_messages[0]["role"] == "system" + assert call_messages[0]["content"] == "system prompt" @pytest.mark.asyncio @@ -89,7 +88,7 @@ async def test_agent_loop_respects_max_iterations(): with patch("app.core.agent.Client") as MockClient: mock_client = MagicMock() MockClient.return_value.get_client.return_value = mock_client - with patch("app.core.agent.load_system_context", return_value="You are a helpful assistant."): + with patch("app.cli.cli_agent.load_system_context", return_value="You are a helpful assistant."): with patch.object(MessageHistory, "get_history", return_value=[]): agent = Agent(auto_approve=True, silent=True, max_iterations=3) agent.client = mock_client @@ -124,7 +123,7 @@ async def test_agent_loop_runs_tool_when_auto_approve(): with patch("app.core.agent.Client") as MockClient: mock_client = MagicMock() MockClient.return_value.get_client.return_value = mock_client - with patch("app.core.agent.load_system_context", return_value="You are a helpful assistant."): + with patch("app.cli.cli_agent.load_system_context", return_value="You are a helpful assistant."): with patch.object(MessageHistory, "get_history", return_value=[]): agent = Agent(auto_approve=True, silent=True, max_iterations=10) agent.client = mock_client @@ -173,7 +172,7 @@ async def test_agent_loop_continues_when_finish_reason_not_stop(): with patch("app.core.agent.Client") as MockClient: mock_client = MagicMock() MockClient.return_value.get_client.return_value = mock_client - with patch("app.core.agent.load_system_context", return_value="You are a helpful assistant."): + with patch("app.cli.cli_agent.load_system_context", return_value="You are a helpful assistant."): with patch.object(MessageHistory, "get_history", return_value=[]): agent = Agent(auto_approve=True, silent=True, max_iterations=10) agent.client = mock_client diff --git a/tests/test_background_agent.py b/tests/test_background_agent.py index 3cbe784..0381485 100644 --- a/tests/test_background_agent.py +++ b/tests/test_background_agent.py @@ -35,7 +35,7 @@ def make_agent(max_iterations=10): with patch("app.core.agent.Client") as MockClient: mock_openai = make_mock_client() MockClient.return_value.get_client.return_value = mock_openai - with patch("app.core.agent.load_system_context", return_value="You are a helpful assistant."): + with patch("app.core.background_agent.load_system_context", return_value="You are a helpful assistant."): with patch("app.core.background_agent.MessageHistory") as MockHistory: MockHistory.return_value.get_history.return_value = [] agent = BackgroundAgent(mq=mq, channel=_mock_channel, max_iterations=max_iterations) @@ -51,28 +51,24 @@ def patch_config(): def test_agent_initializes_with_empty_messages(): agent, _, _ = make_agent() - assert len(agent.messages) == 1 # System message - assert agent.messages[0]["role"] == "system" + assert len(agent.messages) == 0 -def test_agent_initializes_with_system_context(): - mq = MessageQueue() - with patch("app.core.agent.Client") as MockClient: - MockClient.return_value.get_client.return_value = MagicMock() - with patch("app.core.agent.load_system_context", return_value="system prompt"): - with patch("app.core.background_agent.MessageHistory") as MockHistory: - MockHistory.return_value.get_history.return_value = [] - agent = BackgroundAgent(mq=mq, channel=_mock_channel) - assert len(agent.messages) == 1 - assert agent.messages[0]["role"] == "system" - assert agent.messages[0]["content"] == "system prompt" +@pytest.mark.asyncio +async def test_agent_loop_sends_system_context_to_llm(): + agent, mock_client, _ = make_agent() + with patch("app.core.background_agent.load_system_context", return_value="system prompt"): + await agent.agent_loop("hello") + call_messages = mock_client.chat.completions.create.call_args[1]["messages"] + assert call_messages[0]["role"] == "system" + assert call_messages[0]["content"] == "system prompt" def test_agent_stores_channel_and_mq(): mq = MessageQueue() with patch("app.core.agent.Client") as MockClient: MockClient.return_value.get_client.return_value = MagicMock() - with patch("app.core.agent.load_system_context", return_value=""): + with patch("app.core.background_agent.load_system_context", return_value=""): with patch("app.core.background_agent.MessageHistory") as MockHistory: MockHistory.return_value.get_history.return_value = [] agent = BackgroundAgent(mq=mq, channel=_mock_channel) @@ -238,7 +234,7 @@ async def test_agent_loop_clears_stopped_after_completion(): with patch("app.core.agent.Client") as MockClient: MockClient.return_value.get_client.return_value = make_mock_client() - with patch("app.core.agent.load_system_context", return_value=""): + with patch("app.core.background_agent.load_system_context", return_value=""): with patch("app.core.background_agent.MessageHistory") as MockHistory: MockHistory.return_value.get_history.return_value = [] agent = BackgroundAgent(mq=mq, channel=local_channel, max_iterations=10) From 74f3efcfa3d3855e6d332027ffd24ed986a47533 Mon Sep 17 00:00:00 2001 From: "rikulpatel@gmail.com" Date: Wed, 6 May 2026 18:48:34 -0500 Subject: [PATCH 36/84] refactor: consolidate agent loop into Agent base class MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Pull the duplicated agentic loop out of CliAgent, BackgroundAgent, and HelperAgent into a single Agent._loop() + handle_tool_call() on the base class. Subclasses override six lightweight hooks instead of maintaining parallel copies of the same while-loop: _on_thinking — text emitted alongside tool calls _check_permission — deny a tool call (CliAgent: ask_permission) _on_tool_start — status before execution (BackgroundAgent: mq status) _on_response — final text response (BackgroundAgent: mq send) _on_no_choices — empty API response (BackgroundAgent: exponential backoff) _should_stop — early exit (BackgroundAgent: channel.has_stopped) Tool calls within a single LLM turn are now dispatched with asyncio.gather() instead of sequentially. Two tests verify that gather is called once with all coroutines rather than once per tool. Lazy import of run_tool inside handle_tool_call breaks the circular dependency: agent → tool_calls → sched_tasks_tool → scheduled_tasks → HelperAgent → agent. Co-Authored-By: Claude Sonnet 4.6 --- app/cli/cli_agent.py | 95 ++++++------------------ app/core/agent.py | 90 ++++++++++++++++++++++- app/core/background_agent.py | 129 +++++++++++---------------------- app/core/helper_agent.py | 57 +-------------- tests/test_agent.py | 46 +++++++++++- tests/test_background_agent.py | 48 +++++++++++- 6 files changed, 245 insertions(+), 220 deletions(-) diff --git a/app/cli/cli_agent.py b/app/cli/cli_agent.py index da281fd..6144376 100755 --- a/app/cli/cli_agent.py +++ b/app/cli/cli_agent.py @@ -1,10 +1,6 @@ from __future__ import annotations -import json - -from .. import config -from ..core.tool_calls import run_tool, all_tool_specs -from ..infra.app_logging import log +from ..core.tool_calls import all_tool_specs from .cli import ask_permission from ..core.agent import Agent, MAX_CONTEXT_MESSAGES from ..infra.message_history import MessageHistory @@ -21,81 +17,32 @@ def __init__(self, max_iterations: int = 250, auto_approve: bool = False, silent self.history = MessageHistory(channel_type=ChannelType.CLI.value) self.messages.extend(self.history.get_history(limit=MAX_CONTEXT_MESSAGES)) - async def agent_loop(self, message: str, metadata: dict = None) -> None: - self._trim_messages() + async def _on_thinking(self, content: str | None) -> None: + if not self.silent and content and content.strip(): + print(content.strip()) + + async def _check_permission(self, tool_name: str, tool_args: dict) -> bool: + if self.auto_approve: + return True + return ask_permission(tool_name, tool_args) + + async def _on_response(self, content: str | None) -> None: + if content and content.strip(): + print(content) + async def agent_loop(self, message: str, metadata: dict = None) -> str: + self._trim_messages() self.history.add_message("user", message) system_context = load_system_context() system = [{"role": "system", "content": system_context}] if system_context else [] session_messages = system + self.messages[:] + [{"role": "user", "content": message}] - iteration = 0 - assistant_message = "" - while iteration < self.max_iterations: - iteration += 1 - - log.info("chat.completions.create...") - chat = await self.client.chat.completions.create( - model=config.get("model", "deepseek/deepseek-v3.2"), - messages=session_messages, - tools=all_tool_specs - ) - - if not chat.choices or len(chat.choices) == 0: - raise RuntimeError("no choices in response") - - choice = chat.choices[0] - assistant_message = choice.message - finish_reason = getattr(choice, "finish_reason", None) - if not isinstance(finish_reason, str): - finish_reason = None - if assistant_message.tool_calls is not None: - session_messages.append(self._serialize_assistant_msg(assistant_message)) + final_content = await self._loop(session_messages, all_tool_specs) - if not self.silent and assistant_message.content is not None and assistant_message.content.strip() != "": - print(assistant_message.content.strip()) - - for tool_call in assistant_message.tool_calls: - - try: - tool_name = tool_call.function.name - tool_args = json.loads(tool_call.function.arguments) - result = "" - - if not self.auto_approve and not ask_permission(tool_name, tool_args): - session_messages.append({ - "role": "tool", - "tool_call_id": tool_call.id, - "name": tool_name, - "content": "User denied permission to run this tool. Ask for permission to run the tool again if you want to try running it." - }) - continue - - result = run_tool(tool_name=tool_name, tool_args=tool_args) - - except Exception as e: - result = f"Error running tool {tool_name}: {str(e)}" - log.error(result) - - session_messages.append({ - "role": "tool", - "tool_call_id": tool_call.id, - "name": tool_name, - "content": result - }) - - log.info(f"{result[:250]}...") - - else: - if assistant_message.content is not None and assistant_message.content.strip() != "": - print(assistant_message.content) - - if finish_reason == "stop": - session_messages.append(self._serialize_assistant_msg(assistant_message)) - break - - if len(session_messages) >= 2: # only add to history if there's something beyond the initial user message and assistant response + if len(session_messages) >= 2: self.messages.append({"role": "user", "content": message}) - self.messages.append(session_messages[-1]) - self.history.add_message("assistant", assistant_message.content.strip() if assistant_message.content else "") \ No newline at end of file + self.messages.append(session_messages[-1]) + self.history.add_message("assistant", final_content) + + return final_content diff --git a/app/core/agent.py b/app/core/agent.py index f1660cc..0874925 100755 --- a/app/core/agent.py +++ b/app/core/agent.py @@ -1,6 +1,10 @@ +import asyncio +import json from abc import ABC, abstractmethod +from .. import config from .client import Client +from ..infra.app_logging import log MAX_CONTEXT_MESSAGES = 100 @@ -27,6 +31,90 @@ def _serialize_assistant_msg(msg) -> dict: d["reasoning_content"] = reasoning return d + # --- hooks --- + + async def _on_thinking(self, content: str | None) -> None: + """Called when the assistant emits text alongside tool calls.""" + + async def _check_permission(self, tool_name: str, tool_args: dict) -> bool: + """Return False to deny; refusal string is sent back as the tool result.""" + return True + + async def _on_tool_start(self, tool_name: str, tool_args: dict) -> None: + """Called just before each tool executes.""" + + async def _on_response(self, content: str | None) -> None: + """Called when the assistant emits a final text response (no tool calls).""" + + async def _on_no_choices(self) -> None: + """Called when the API returns no choices. Raise to abort, return to retry.""" + raise RuntimeError("no choices in response") + + def _should_stop(self) -> bool: + """Return True to break out of the loop early.""" + return False + + # --- shared tool dispatch --- + + async def handle_tool_call(self, tool_call) -> str: + from .tool_calls import run_tool # lazy — tool_calls imports scheduled_tasks which imports Agent + tool_name = tool_call.function.name + try: + tool_args = json.loads(tool_call.function.arguments) + if not await self._check_permission(tool_name, tool_args): + return "User denied permission to run this tool. Ask for permission to run the tool again if you want to try running it." + await self._on_tool_start(tool_name, tool_args) + return run_tool(tool_name=tool_name, tool_args=tool_args) + except Exception as e: + error_msg = f"Error running tool {tool_name}: {str(e)}" + log.error(error_msg) + return error_msg + + # --- shared loop --- + + async def _loop(self, messages: list, tool_specs: list) -> str: + iteration = 0 + assistant_message = None + + while iteration < self.max_iterations: + iteration += 1 + log.info("chat.completions.create...") + chat = await self.client.chat.completions.create( + model=config.get("model", "deepseek/deepseek-v3.2"), + messages=messages, + tools=tool_specs, + ) + + if not chat.choices: + await self._on_no_choices() + continue + + choice = chat.choices[0] + assistant_message = choice.message + finish_reason = getattr(choice, "finish_reason", None) + if not isinstance(finish_reason, str): + finish_reason = None + + if assistant_message.tool_calls is not None: + messages.append(self._serialize_assistant_msg(assistant_message)) + await self._on_thinking(assistant_message.content) + results = await asyncio.gather(*[ + self.handle_tool_call(tc) for tc in assistant_message.tool_calls + ]) + for tc, result in zip(assistant_message.tool_calls, results): + messages.append({"role": "tool", "tool_call_id": tc.id, "name": tc.function.name, "content": result}) + log.info(f"{result[:250]}...") + else: + await self._on_response(assistant_message.content) + if finish_reason == "stop": + messages.append(self._serialize_assistant_msg(assistant_message)) + break + + if self._should_stop(): + break + + return assistant_message.content.strip() if assistant_message and assistant_message.content else "" + @abstractmethod - async def agent_loop(self, message: str, metadata: dict = None) -> None: + async def agent_loop(self, message: str, metadata: dict = None) -> str: pass diff --git a/app/core/background_agent.py b/app/core/background_agent.py index 56dbe67..5c9c2e4 100755 --- a/app/core/background_agent.py +++ b/app/core/background_agent.py @@ -1,19 +1,19 @@ from __future__ import annotations import asyncio -import json -from .. import config -from .tool_calls import run_tool, all_tool_specs +from .tool_calls import all_tool_specs from ..infra.app_logging import log from ..channels.channel import Channel from ..channels.message import OutgoingMessage from ..channels.message_queue import MessageQueue from .agent import Agent, MAX_CONTEXT_MESSAGES from ..infra.startup import load_system_context - from ..infra.message_history import MessageHistory +_MAX_EMPTY_RETRIES = 5 + + class BackgroundAgent(Agent): def __init__(self, mq: MessageQueue = None, channel: Channel = None, max_iterations: int = 250) -> None: @@ -26,6 +26,35 @@ def __init__(self, mq: MessageQueue = None, channel: Channel = None, max_iterati self.history = MessageHistory(channel_type=channel.channel_type.value) self.messages.extend(self.history.get_history(limit=MAX_CONTEXT_MESSAGES)) + self._reply_metadata: dict = {} + self._empty_retries: int = 0 + + async def _on_thinking(self, content: str | None) -> None: + if self.mq and content: + text = content.strip().rstrip(":").strip() + if text: + await self.mq.outgoing_msg(OutgoingMessage(content=text, channel=self.channel, metadata=self._reply_metadata)) + + async def _on_tool_start(self, tool_name: str, tool_args: dict) -> None: + if self.mq: + first_arg = str(next(iter(tool_args.values()), ""))[:50] if tool_args else "" + status = f"running {tool_name} [{first_arg}]..." + await self.mq.outgoing_msg(OutgoingMessage(content=status, channel=self.channel, metadata=self._reply_metadata)) + + async def _on_response(self, content: str | None) -> None: + if self.mq and content and content.strip(): + await self.mq.outgoing_msg(OutgoingMessage(content=content.strip(), channel=self.channel, metadata=self._reply_metadata)) + + async def _on_no_choices(self) -> None: + self._empty_retries += 1 + if self._empty_retries > _MAX_EMPTY_RETRIES: + raise RuntimeError(f"No choices in API response after {_MAX_EMPTY_RETRIES} retries") + wait = min(2 ** self._empty_retries, 60) + log.warning(f"No choices in API response, retrying in {wait}s (attempt {self._empty_retries}/{_MAX_EMPTY_RETRIES})") + await asyncio.sleep(wait) + + def _should_stop(self) -> bool: + return self.channel.has_stopped async def process_incoming(self) -> None: log.info("BackgroundAgent started processing incoming messages...") @@ -36,95 +65,23 @@ async def process_incoming(self) -> None: except Exception as e: log.error(f"Agent loop error: {e}") - async def agent_loop(self, message: str, metadata: dict = None) -> None: + async def agent_loop(self, message: str, metadata: dict = None) -> str: self._trim_messages() - + self._empty_retries = 0 + self._reply_metadata = metadata or {} self.history.add_message("user", message) system_context = load_system_context() system = [{"role": "system", "content": system_context}] if system_context else [] session_messages = system + self.messages[:] + [{"role": "user", "content": message}] - self._reply_metadata = metadata or {} - iteration = 0 - empty_retries = 0 - assistant_message = None - MAX_RETRIES = 5 - - while iteration < self.max_iterations: - iteration += 1 - - log.info("chat.completions.create...") - chat = await self.client.chat.completions.create( - model=config.get("model", "deepseek/deepseek-v3.2"), - messages=session_messages, - tools=all_tool_specs - ) - - if not chat.choices or len(chat.choices) == 0: - empty_retries += 1 - if empty_retries > MAX_RETRIES: - raise RuntimeError(f"No choices in API response after {MAX_RETRIES} retries") - wait = min(2 ** empty_retries, 60) - log.warning(f"No choices in API response, retrying in {wait}s (attempt {empty_retries}/{MAX_RETRIES})") - await asyncio.sleep(wait) - continue - - empty_retries = 0 - - choice = chat.choices[0] - assistant_message = choice.message - finish_reason = getattr(choice, "finish_reason", None) - if not isinstance(finish_reason, str): - finish_reason = None - - if assistant_message.tool_calls is not None: - session_messages.append(self._serialize_assistant_msg(assistant_message)) - - llm_text = assistant_message.content.strip().rstrip(":").strip() if assistant_message.content else "" - - for tool_call in assistant_message.tool_calls: - try: - tool_name = tool_call.function.name - tool_args = json.loads(tool_call.function.arguments) - first_arg = str(next(iter(tool_args.values()), ""))[:50] if tool_args else "" - tool_status = f"running {tool_name} [{first_arg}]..." - status_msg = f"{llm_text}: {tool_status}" if llm_text else tool_status - llm_text = "" # only prepend on first tool call - if self.mq: - await self.mq.outgoing_msg(OutgoingMessage(content=status_msg, channel=self.channel, metadata=self._reply_metadata)) - result = run_tool(tool_name=tool_name, tool_args=tool_args) - - except Exception as e: - result = f"Error running tool {tool_name}: {str(e)}" - log.error(result) - - - session_messages.append({ - "role": "tool", - "tool_call_id": tool_call.id, - "name": tool_name, - "content": result - }) - - log.info(f"{result[:250]}...") - - else: - if assistant_message.content is not None and assistant_message.content.strip() != "": - if self.mq: - await self.mq.outgoing_msg(OutgoingMessage(content=assistant_message.content.strip(), channel=self.channel, metadata=self._reply_metadata)) - - if finish_reason == "stop": - session_messages.append(self._serialize_assistant_msg(assistant_message)) - break - - if self.channel.has_stopped: - log.info("Channel has been stopped, breaking out of agent loop.") - break - + + final_content = await self._loop(session_messages, all_tool_specs) + self.channel.clear_stopped() - if len(session_messages) >= 2 and assistant_message is not None: + if len(session_messages) >= 2 and final_content is not None: self.messages.append({"role": "user", "content": message}) self.messages.append(session_messages[-1]) - assistant_content = assistant_message.content.strip() if assistant_message.content else "" - self.history.add_message("assistant", assistant_content) + self.history.add_message("assistant", final_content) + + return final_content diff --git a/app/core/helper_agent.py b/app/core/helper_agent.py index 15e4834..f70e100 100644 --- a/app/core/helper_agent.py +++ b/app/core/helper_agent.py @@ -1,8 +1,5 @@ from __future__ import annotations -import json - -from .. import config from ..infra.app_logging import log from .agent import Agent @@ -12,61 +9,13 @@ class HelperAgent(Agent): def __init__(self, system_prompt: str = None, max_iterations: int = 50) -> None: super().__init__(max_iterations) if system_prompt: - if self.messages and self.messages[0]["role"] == "system": - self.messages[0]["content"] = system_prompt - else: - self.messages.insert(0, {"role": "system", "content": system_prompt}) + self.messages.insert(0, {"role": "system", "content": system_prompt}) async def run(self, prompt: str) -> str: log.info(f"Running HelperAgent with prompt: {prompt}") return await self.agent_loop(prompt) async def agent_loop(self, message: str, metadata: dict = None) -> str: - from .tool_calls import helper_tool_specs, run_tool + from .tool_calls import helper_tool_specs # lazy — avoids circular import via scheduled_tasks self.messages.append({"role": "user", "content": message}) - iteration = 0 - assistant_message = None - - while iteration < self.max_iterations: - iteration += 1 - - log.info(f"HelperAgent iteration {iteration}") - chat = await self.client.chat.completions.create( - model=config.get("model", "deepseek/deepseek-v3.2"), - messages=self.messages, - tools=helper_tool_specs - ) - - if not chat.choices: - raise RuntimeError("No choices in API response") - - choice = chat.choices[0] - assistant_message = choice.message - finish_reason = getattr(choice, "finish_reason", None) - if not isinstance(finish_reason, str): - finish_reason = None - - if assistant_message.tool_calls is not None: - self.messages.append(self._serialize_assistant_msg(assistant_message)) - - for tool_call in assistant_message.tool_calls: - try: - tool_name = tool_call.function.name - tool_args = json.loads(tool_call.function.arguments) - result = run_tool(tool_name=tool_name, tool_args=tool_args) - except Exception as e: - result = f"Error running tool {tool_name}: {str(e)}" - log.error(result) - - self.messages.append({ - "role": "tool", - "tool_call_id": tool_call.id, - "name": tool_name, - "content": result - }) - - else: - if finish_reason == "stop": - break - - return assistant_message.content.strip() if assistant_message and assistant_message.content else "" + return await self._loop(self.messages, helper_tool_specs) diff --git a/tests/test_agent.py b/tests/test_agent.py index 023eb34..f788ed3 100644 --- a/tests/test_agent.py +++ b/tests/test_agent.py @@ -1,3 +1,4 @@ +import asyncio import pytest from unittest.mock import patch, MagicMock, AsyncMock @@ -111,7 +112,7 @@ async def test_agent_loop_respects_max_iterations(): mock_response.choices = [mock_choice] mock_client.chat.completions.create = AsyncMock(return_value=mock_response) - with patch("app.cli.cli_agent.run_tool", return_value="hi\n"): + with patch("app.core.tool_calls.run_tool", return_value="hi\n"): await agent.agent_loop("run forever") # Should have stopped after max_iterations=3 LLM calls @@ -159,7 +160,7 @@ async def test_agent_loop_runs_tool_when_auto_approve(): side_effect=[response_with_tool, response_plain] ) - with patch("app.cli.cli_agent.run_tool", return_value="hi\n") as mock_run_tool: + with patch("app.core.tool_calls.run_tool", return_value="hi\n") as mock_run_tool: await agent.agent_loop("say hi") mock_run_tool.assert_called_once_with( @@ -204,3 +205,44 @@ async def test_agent_loop_continues_when_finish_reason_not_stop(): await agent.agent_loop("continue") assert mock_client.chat.completions.create.call_count == 2 + + +@pytest.mark.asyncio +async def test_agent_loop_gathers_multiple_tool_calls_in_parallel(): + agent, mock_client = make_agent() + + tc1, tc2 = MagicMock(), MagicMock() + tc1.function.name = "bash" + tc1.function.arguments = '{"command": "echo 1"}' + tc1.id = "tc1" + tc2.function.name = "bash" + tc2.function.arguments = '{"command": "echo 2"}' + tc2.id = "tc2" + + msg_with_tools = MagicMock() + msg_with_tools.tool_calls = [tc1, tc2] + msg_with_tools.content = None + choice_with_tools = MagicMock() + choice_with_tools.message = msg_with_tools + choice_with_tools.finish_reason = "tool_calls" + response_with_tools = MagicMock() + response_with_tools.choices = [choice_with_tools] + + msg_final = MagicMock() + msg_final.tool_calls = None + msg_final.content = "done" + msg_final.model_dump.return_value = {"role": "assistant", "content": "done"} + choice_final = MagicMock() + choice_final.message = msg_final + choice_final.finish_reason = "stop" + response_final = MagicMock() + response_final.choices = [choice_final] + + mock_client.chat.completions.create = AsyncMock(side_effect=[response_with_tools, response_final]) + + with patch("app.core.tool_calls.run_tool", return_value="result"): + with patch("app.core.agent.asyncio.gather", wraps=asyncio.gather) as mock_gather: + await agent.agent_loop("run two tools") + + mock_gather.assert_called_once() + assert len(mock_gather.call_args[0]) == 2 diff --git a/tests/test_background_agent.py b/tests/test_background_agent.py index 0381485..791ec87 100644 --- a/tests/test_background_agent.py +++ b/tests/test_background_agent.py @@ -1,3 +1,4 @@ +import asyncio import pytest from unittest.mock import patch, MagicMock, AsyncMock @@ -137,7 +138,7 @@ async def test_agent_loop_respects_max_iterations(): mock_response.choices = [mock_choice] mock_client.chat.completions.create = AsyncMock(return_value=mock_response) - with patch("app.core.background_agent.run_tool", return_value="hi\n"): + with patch("app.core.tool_calls.run_tool", return_value="hi\n"): await agent.agent_loop("run forever") assert mock_client.chat.completions.create.call_count == 3 @@ -172,7 +173,7 @@ async def test_agent_loop_runs_tool_and_sends_final_reply(): mock_client.chat.completions.create = AsyncMock(side_effect=[response_with_tool, response_plain]) - with patch("app.core.background_agent.run_tool", return_value="hi\n") as mock_run_tool: + with patch("app.core.tool_calls.run_tool", return_value="hi\n") as mock_run_tool: await agent.agent_loop("say hi", metadata={"chat_id": 42}) mock_run_tool.assert_called_once_with(tool_name="bash", tool_args={"command": "echo hi"}) @@ -212,7 +213,7 @@ async def test_agent_loop_sends_inline_content_with_tool_calls(): mock_client.chat.completions.create = AsyncMock(side_effect=[response_with_tool, response_plain]) - with patch("app.core.background_agent.run_tool", return_value="hi\n"): + with patch("app.core.tool_calls.run_tool", return_value="hi\n"): await agent.agent_loop("run something") messages = [] @@ -263,3 +264,44 @@ async def test_process_incoming_dispatches_to_agent_loop(): pass assert any(m.get("role") == "user" and m.get("content") == "hello from telegram" for m in agent.messages) + + +@pytest.mark.asyncio +async def test_agent_loop_gathers_multiple_tool_calls_in_parallel(): + agent, mock_client, mq = make_agent() + + tc1, tc2 = MagicMock(), MagicMock() + tc1.function.name = "bash" + tc1.function.arguments = '{"command": "echo 1"}' + tc1.id = "tc1" + tc2.function.name = "bash" + tc2.function.arguments = '{"command": "echo 2"}' + tc2.id = "tc2" + + msg_with_tools = MagicMock() + msg_with_tools.tool_calls = [tc1, tc2] + msg_with_tools.content = None + choice_with_tools = MagicMock() + choice_with_tools.message = msg_with_tools + choice_with_tools.finish_reason = "tool_calls" + response_with_tools = MagicMock() + response_with_tools.choices = [choice_with_tools] + + msg_final = MagicMock() + msg_final.tool_calls = None + msg_final.content = "done" + msg_final.model_dump.return_value = {"role": "assistant", "content": "done"} + choice_final = MagicMock() + choice_final.message = msg_final + choice_final.finish_reason = "stop" + response_final = MagicMock() + response_final.choices = [choice_final] + + mock_client.chat.completions.create = AsyncMock(side_effect=[response_with_tools, response_final]) + + with patch("app.core.tool_calls.run_tool", return_value="result"): + with patch("app.core.agent.asyncio.gather", wraps=asyncio.gather) as mock_gather: + await agent.agent_loop("run two tools") + + mock_gather.assert_called_once() + assert len(mock_gather.call_args[0]) == 2 From 723b0b2d88b7cc3b8109d65d77692c60bcd86cfc Mon Sep 17 00:00:00 2001 From: "rikulpatel@gmail.com" Date: Wed, 6 May 2026 21:03:01 -0500 Subject: [PATCH 37/84] refactor: add truncated intermediate messages for better context --- app/bg_server.py | 1 + app/cli/cli_agent.py | 7 +++---- app/core/agent.py | 17 ++++++++++++++++- app/core/background_agent.py | 7 +++---- 4 files changed, 23 insertions(+), 9 deletions(-) diff --git a/app/bg_server.py b/app/bg_server.py index 019fd0c..0266f1e 100755 --- a/app/bg_server.py +++ b/app/bg_server.py @@ -30,6 +30,7 @@ async def start_server() -> None: from .channels.telegram import TelegramChannel telegram_channel = TelegramChannel(mq, bot_token=bot_token, allow_from=config.telegram.get("ALLOW_FROM", [])) + if not telegram_channel: log.error("No channels configured, exiting...") return diff --git a/app/cli/cli_agent.py b/app/cli/cli_agent.py index 6144376..720d61b 100755 --- a/app/cli/cli_agent.py +++ b/app/cli/cli_agent.py @@ -36,13 +36,12 @@ async def agent_loop(self, message: str, metadata: dict = None) -> str: system_context = load_system_context() system = [{"role": "system", "content": system_context}] if system_context else [] + turn_start = len(system) + len(self.messages) session_messages = system + self.messages[:] + [{"role": "user", "content": message}] final_content = await self._loop(session_messages, all_tool_specs) - if len(session_messages) >= 2: - self.messages.append({"role": "user", "content": message}) - self.messages.append(session_messages[-1]) - self.history.add_message("assistant", final_content) + self.messages.extend(self._compress_turn(session_messages, turn_start)) + self.history.add_message("assistant", final_content) return final_content diff --git a/app/core/agent.py b/app/core/agent.py index 0874925..267cee1 100755 --- a/app/core/agent.py +++ b/app/core/agent.py @@ -6,7 +6,8 @@ from .client import Client from ..infra.app_logging import log -MAX_CONTEXT_MESSAGES = 100 +MAX_CONTEXT_MESSAGES = 250 +TOOL_RESULT_HISTORY_LIMIT = 200 class Agent(ABC): @@ -16,6 +17,20 @@ def __init__(self, max_iterations: int = 250) -> None: self.messages: list[dict] = [] self.max_iterations = max_iterations + @staticmethod + def _compress_turn(session_messages: list, turn_start: int) -> list: + """Return turn messages with tool results truncated for history storage.""" + result = [] + for msg in session_messages[turn_start:]: + if msg.get("role") == "tool": + content = msg.get("content", "") + if len(content) > TOOL_RESULT_HISTORY_LIMIT: + content = content[:TOOL_RESULT_HISTORY_LIMIT] + "...[truncated]" + result.append({**msg, "content": content}) + else: + result.append(msg) + return result + def _trim_messages(self) -> None: if len(self.messages) > MAX_CONTEXT_MESSAGES: self.messages = self.messages[-MAX_CONTEXT_MESSAGES:] diff --git a/app/core/background_agent.py b/app/core/background_agent.py index 5c9c2e4..e7d8cb8 100755 --- a/app/core/background_agent.py +++ b/app/core/background_agent.py @@ -73,15 +73,14 @@ async def agent_loop(self, message: str, metadata: dict = None) -> str: system_context = load_system_context() system = [{"role": "system", "content": system_context}] if system_context else [] + turn_start = len(system) + len(self.messages) session_messages = system + self.messages[:] + [{"role": "user", "content": message}] final_content = await self._loop(session_messages, all_tool_specs) self.channel.clear_stopped() - if len(session_messages) >= 2 and final_content is not None: - self.messages.append({"role": "user", "content": message}) - self.messages.append(session_messages[-1]) - self.history.add_message("assistant", final_content) + self.messages.extend(self._compress_turn(session_messages, turn_start)) + self.history.add_message("assistant", final_content) return final_content From e2cad8ef76e390b527ed8c6fff0bb016b41e5549 Mon Sep 17 00:00:00 2001 From: "rikulpatel@gmail.com" Date: Thu, 7 May 2026 19:00:26 -0500 Subject: [PATCH 38/84] feat: Docker support with env var config config.py: - PROJECT_HOME / APP_DB now respect ANOTHERBOT_HOME env var - load() falls back to hardcoded defaults when config file is absent (no file needed for Docker deployments) - Env var overlays applied after file load: MODEL, TELEGRAM_BOT_TOKEN, TELEGRAM_ALLOW_FROM (comma-separated int list) run.sh / restart.sh: - PID file and log file paths use ANOTHERBOT_HOME when set - mkdir -p ensures the data directory exists before first write Dockerfile / .dockerignore: - Install uv via pip; copy pyproject.toml + uv.lock first for layer caching - ANOTHERBOT_HOME=/data with VOLUME /data for DB and workspace persistence - Secrets (LLM_API_KEY, TELEGRAM_BOT_TOKEN) removed from ENV to avoid baking them into image layers; pass at runtime via -e or --env-file Tests: 6 new cases in test_config.py covering env var overrides, TELEGRAM_ALLOW_FROM parsing, and the full Docker startup path (no config file + all settings from env). Co-Authored-By: Claude Sonnet 4.6 --- .dockerignore | 9 +++++++ CLAUDE.md | 35 ++++++++++++++++++-------- Dockerfile | 28 +++++++++++++++++++++ README.md | 24 ++++++++++++++++++ app/config.py | 40 ++++++++++++++++++----------- restart.sh | 6 +++-- run.sh | 3 ++- tests/test_config.py | 60 +++++++++++++++++++++++++++++++++++++++++--- 8 files changed, 174 insertions(+), 31 deletions(-) create mode 100644 .dockerignore create mode 100644 Dockerfile diff --git a/.dockerignore b/.dockerignore new file mode 100644 index 0000000..1fbc869 --- /dev/null +++ b/.dockerignore @@ -0,0 +1,9 @@ +.venv/ +__pycache__/ +*.pyc +*.pyo +.git/ +tests/ +*.md +run.bat +.claude/ diff --git a/CLAUDE.md b/CLAUDE.md index 29542c4..b2d657c 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -40,19 +40,32 @@ Config lives at `~/.crafterscode/config.toml` (created automatically on first ru - `max_iterations` — max agentic loop iterations (default: `100`) - `base_url` — API base URL (default: `"https://openrouter.ai/api/v1"`) -Environment variables: `LLM_API_KEY` (required), `LLM_BASE_URL` (optional override). +Environment variables (all override config file values): +- `LLM_API_KEY` — required +- `LLM_BASE_URL` — optional API base URL override +- `MODEL` — optional model override +- `TELEGRAM_BOT_TOKEN` — Telegram bot token (alternative to config file) +- `TELEGRAM_ALLOW_FROM` — comma-separated Telegram user IDs (e.g. `"123,456"`) +- `ANOTHERBOT_HOME` — overrides the data directory (default: `~/.crafterscode`) + +For Docker, no config file is needed — pass everything as env vars. See `Dockerfile` and the Docker section in README. ## Architecture ### Agent Loop -Both `CliAgent` (`app/cli_agent.py`) and `BackgroundAgent` (`app/background_agent.py`) share the same agentic loop pattern: -1. Append user message to `self.messages` -2. Call `chat.completions.create` with tool specs -3. If response has `tool_calls`: optionally ask permission, run each tool via `run_tool()`, append tool results, loop again -4. If response has no tool calls: print/send content, break if `finish_reason == "stop"` +The shared loop lives in `Agent._loop()` (`app/core/agent.py`). Subclasses override hooks to specialise behaviour: + +| Hook | CliAgent | BackgroundAgent | HelperAgent | +|---|---|---|---| +| `_on_thinking` | print if not silent | send via mq | — | +| `_check_permission` | ask stdin | — (always allow) | — | +| `_on_tool_start` | — | send status via mq | — | +| `_on_response` | print | send via mq | — | +| `_on_no_choices` | raise | exponential backoff | raise | +| `_should_stop` | — | `channel.has_stopped` | — | -The difference: `CliAgent` prints to stdout and prompts stdin for permission; `BackgroundAgent` routes messages through `MessageQueue` + `Channel` for multi-channel delivery (Telegram, Discord, Web, etc.). +Tool calls within a single LLM turn are dispatched in parallel via `asyncio.gather`. After each turn, the full message chain (assistant tool-call message + tool results + final response) is saved to `self.messages` with tool results truncated to `TOOL_RESULT_HISTORY_LIMIT` chars to keep context lean. `MessageHistory` (SQLite) stores only user + final assistant text for cross-session persistence. ### Tool System @@ -64,18 +77,18 @@ Current tools: `read_file`, `write_file`, `bash`, `web_fetch`, `get_skills_dir`, ### System Context -On startup, `load_system_context()` (`app/helpers.py`) loads `app/sys_instructions.md` and prepends it as the system message to `self.messages`. +On startup, `load_system_context()` (`app/infra/startup.py`) loads `app/core/sys_instructions.md` and prepends it as the system message to `self.messages`. ### Message Queue / Channel Architecture -`MessageQueue` (`app/message_queue.py`) holds two `asyncio.Queue`s (incoming/outgoing). Delivery functions are registered per `Channel` enum value. `BackgroundAgent.process_incoming()` consumes the incoming queue and drives `agent_loop()`; `process_outgoing()` dispatches outbound messages to registered delivery functions. This is the intended extension point for adding new channels. +`MessageQueue` (`app/channels/message_queue.py`) holds two `asyncio.Queue`s (incoming/outgoing). `BackgroundAgent.process_incoming()` consumes the incoming queue and drives `agent_loop()`; `process_outgoing()` dispatches outbound messages to registered delivery functions. This is the intended extension point for adding new channels. Each channel should have its own `MessageQueue` instance to avoid cross-channel message routing bugs (e.g., a Telegram message being handled by the Discord agent). ### Scheduled Tasks -`ScheduledTasks` (`app/scheduled_tasks.py`) is a SQLite-backed task runner using the shared `APP_DB` (`~/.crafterscode/app.db`). It polls every 60 seconds, checks `next_run`, and executes due tasks via `HelperAgent`. Results are delivered to the configured channel via `MessageQueue`. Schema: `tasks` (id, name, prompt, enabled, repeat, interval_mins, next_run, last_run, delivery_channel, run_count, created_at) and `task_outputs` (id, name, prompt, output, status, duration_secs, timestamp). The `run()` coroutine is added to the `asyncio.gather` in `bg_server.py`. +`ScheduledTasks` (`app/core/scheduled_tasks.py`) is a SQLite-backed task runner using the shared `APP_DB` (`~/.crafterscode/app.db`, or `$ANOTHERBOT_HOME/app.db`). It polls every 60 seconds, checks `next_run`, and executes due tasks via `HelperAgent`. Results are delivered to the configured channel via `MessageQueue`. Schema: `tasks` (id, name, prompt, enabled, repeat, interval_mins, next_run, last_run, delivery_channel, run_count, created_at) and `task_outputs` (id, name, prompt, output, status, duration_secs, timestamp). The `run()` coroutine is added to the `asyncio.gather` in `bg_server.py`. ## Testing Approach -Unit tests mock `app.cli_agent.Client` and `app.cli_agent.load_system_context` to isolate the agent loop logic. Integration tests in `tests/integration/` mock only the OpenAI HTTP client and run the full pipeline including `main()`, argparse, and agent construction. Tests use `pytest-asyncio` for async test functions. +Unit tests mock `app.core.agent.Client` and `load_system_context` to isolate the agent loop logic. `run_tool` is patched at `app.core.tool_calls.run_tool` (where the function lives) since `handle_tool_call` uses a lazy import. Integration tests in `tests/integration/` mock only the OpenAI HTTP client and run the full pipeline including `main()`, argparse, and agent construction. Tests use `pytest-asyncio` for async test functions. diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 0000000..bee7bec --- /dev/null +++ b/Dockerfile @@ -0,0 +1,28 @@ +FROM python:3.12-slim + +RUN pip install uv --no-cache-dir + +WORKDIR /app + +# Dependency files first — this layer is cached unless deps change +COPY pyproject.toml uv.lock ./ +RUN uv sync --no-dev --frozen + +COPY app/ ./app/ +COPY run.sh . +COPY restart.sh . + +# Data dir for SQLite DB, workspace, and optional config.toml mount +ENV ANOTHERBOT_HOME=/data +VOLUME /data + +# Non-secret runtime config +ENV LLM_BASE_URL="" +ENV MODEL="" +ENV TELEGRAM_ALLOW_FROM="" + +# Secrets — pass at runtime only, never bake into the image: +# docker run -e LLM_API_KEY=... -e TELEGRAM_BOT_TOKEN=... +# or: docker run --env-file .env + +CMD ["bash", "run.sh", "background"] diff --git a/README.md b/README.md index 7bc2834..e66e6be 100644 --- a/README.md +++ b/README.md @@ -108,6 +108,30 @@ remove the HN task Tasks persist in `~/.crafterscode/app.db` (shared with message history) and survive restarts. +## Docker + +```bash +docker build -t anotherbot . + +docker run -d \ + -e LLM_API_KEY=sk-... \ + -e TELEGRAM_BOT_TOKEN=123:abc... \ + -e TELEGRAM_ALLOW_FROM=123456789 \ + -v anotherbot-data:/data \ + anotherbot +``` + +| Env var | Required | Description | +|---|---|---| +| `LLM_API_KEY` | yes | OpenRouter / OpenAI-compatible API key | +| `TELEGRAM_BOT_TOKEN` | yes | Telegram bot token from @BotFather | +| `TELEGRAM_ALLOW_FROM` | yes | Comma-separated Telegram user IDs allowed to message the bot | +| `LLM_BASE_URL` | no | API base URL (default: `https://openrouter.ai/api/v1`) | +| `MODEL` | no | Model string (default: `deepseek/deepseek-v3.2`) | +| `ANOTHERBOT_HOME` | no | Data directory for DB and workspace (default: `/data` in container) | + +The `/data` volume persists the SQLite database and workspace across restarts. To supply a `config.toml` instead of env vars, mount it at `/data/config.toml` — env vars always take precedence over the file. + ## Roadmap - **Email Support**: IMAP/SMTP integration for reading and sending emails, attachment handling, and mailbox management diff --git a/app/config.py b/app/config.py index a800cc3..2107cb9 100644 --- a/app/config.py +++ b/app/config.py @@ -4,34 +4,49 @@ import tomllib from pathlib import Path -_config : dict = {} +_config: dict = {} APP_NAME = "crafterscode" -PROJECT_HOME = Path.home() / f".{APP_NAME}" -HOME_CONFIG_PATH = PROJECT_HOME / "config.toml" -APP_DB = Path.home() / f".{APP_NAME}" / "app.db" +PROJECT_HOME = Path(os.environ.get("ANOTHERBOT_HOME", Path.home() / f".{APP_NAME}")) +HOME_CONFIG_PATH = PROJECT_HOME / "config.toml" +APP_DB = PROJECT_HOME / "app.db" + def load(path: Path | str = HOME_CONFIG_PATH) -> None: global _config - if not os.path.exists(path): - raise RuntimeError(f"Config file {path} does not exist") + if os.path.exists(path): + with open(path, "rb") as f: + _config = tomllib.load(f) + else: + _config = { + "model": "deepseek/deepseek-v3.2", + "base_url": "https://openrouter.ai/api/v1", + "max_iterations": 100, + "telegram": {}, + } + + # env var overrides — takes precedence over config file (Docker-friendly) + if v := os.environ.get("MODEL"): + _config["model"] = v + if v := os.environ.get("TELEGRAM_BOT_TOKEN"): + _config.setdefault("telegram", {})["BOT_TOKEN"] = v + if v := os.environ.get("TELEGRAM_ALLOW_FROM"): + _config.setdefault("telegram", {})["ALLOW_FROM"] = [int(x.strip()) for x in v.split(",") if x.strip()] - with open(path, "rb") as f: - _config = tomllib.load(f) def get(key: str, default=None): return _config.get(key, default) + def __getattr__(name: str): if name in _config: return _config[name] raise AttributeError(f"Config has no attribute {name}") -def get_default_config() -> dict: - - default_config = """\ +def get_default_config() -> str: + return """\ model = "deepseek/deepseek-v3.2" max_iterations = 100 base_url = "https://openrouter.ai/api/v1" @@ -40,6 +55,3 @@ def get_default_config() -> dict: BOT_TOKEN = "" ALLOW_FROM = [] # List of allowed Telegram user IDs (integers). Must be non-empty. """ - - return default_config - \ No newline at end of file diff --git a/restart.sh b/restart.sh index d5ef32e..8d00361 100755 --- a/restart.sh +++ b/restart.sh @@ -13,8 +13,10 @@ fi set -e SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)" -PID_FILE="$HOME/.crafterscode/background.pid" -LOG_FILE="$HOME/.crafterscode/background.log" +_DATA_DIR="${ANOTHERBOT_HOME:-$HOME/.crafterscode}" +PID_FILE="$_DATA_DIR/background.pid" +LOG_FILE="$_DATA_DIR/background.log" +mkdir -p "$_DATA_DIR" cd "$SCRIPT_DIR" diff --git a/run.sh b/run.sh index 4c4646d..8fe707c 100755 --- a/run.sh +++ b/run.sh @@ -5,9 +5,10 @@ set -e # Exit early if any commands fail # Copied from .codecrafters/run.sh SCRIPT_DIR="$(dirname "$0")" -PID_FILE="$HOME/.crafterscode/background.pid" +PID_FILE="${ANOTHERBOT_HOME:-$HOME/.crafterscode}/background.pid" if [ "$1" = "background" ]; then + mkdir -p "$(dirname "$PID_FILE")" echo $$ > "$PID_FILE" fi diff --git a/tests/test_config.py b/tests/test_config.py index 0d945e5..7622c7e 100644 --- a/tests/test_config.py +++ b/tests/test_config.py @@ -1,10 +1,13 @@ +import os import pytest +from unittest.mock import patch import app.config as config -def test_load_raises_when_file_not_found(tmp_path): - with pytest.raises(RuntimeError, match="does not exist"): - config.load(tmp_path / "missing.toml") +def test_load_uses_defaults_when_file_not_found(tmp_path): + config.load(tmp_path / "missing.toml") + assert config.get("model") == "deepseek/deepseek-v3.2" + assert config.get("telegram") == {} def test_load_reads_toml_file(tmp_path): @@ -49,3 +52,54 @@ def test_getattr_raises_for_missing_key(tmp_path): with pytest.raises(AttributeError, match="Config has no attribute"): _ = config.nonexistent_key + +# --- env var overlay --- + +def test_model_env_overrides_file(tmp_path): + toml_file = tmp_path / "config.toml" + toml_file.write_bytes(b'model = "deepseek/deepseek-v3.2"\n') + with patch.dict(os.environ, {"MODEL": "gpt-4o"}, clear=False): + config.load(toml_file) + assert config.get("model") == "gpt-4o" + + +def test_telegram_bot_token_env_sets_value(tmp_path): + with patch.dict(os.environ, {"TELEGRAM_BOT_TOKEN": "bot123:secret"}, clear=False): + config.load(tmp_path / "missing.toml") + assert config.get("telegram")["BOT_TOKEN"] == "bot123:secret" + + +def test_telegram_allow_from_env_parsed_to_int_list(tmp_path): + with patch.dict(os.environ, {"TELEGRAM_ALLOW_FROM": "111,222,333"}, clear=False): + config.load(tmp_path / "missing.toml") + assert config.get("telegram")["ALLOW_FROM"] == [111, 222, 333] + + +def test_telegram_allow_from_env_single_id(tmp_path): + with patch.dict(os.environ, {"TELEGRAM_ALLOW_FROM": "42"}, clear=False): + config.load(tmp_path / "missing.toml") + assert config.get("telegram")["ALLOW_FROM"] == [42] + + +def test_env_vars_override_file_values(tmp_path): + toml_file = tmp_path / "config.toml" + toml_file.write_bytes(b'model = "deepseek/v3"\n[telegram]\nBOT_TOKEN = "file-token"\n') + with patch.dict(os.environ, {"MODEL": "claude-opus-4", "TELEGRAM_BOT_TOKEN": "env-token"}, clear=False): + config.load(toml_file) + assert config.get("model") == "claude-opus-4" + assert config.get("telegram")["BOT_TOKEN"] == "env-token" + + +def test_docker_scenario_no_file_all_env_vars(tmp_path): + """No config file + env vars only — the expected Docker startup path.""" + env = { + "MODEL": "deepseek/deepseek-v3.2", + "TELEGRAM_BOT_TOKEN": "bot:token", + "TELEGRAM_ALLOW_FROM": "99,100", + } + with patch.dict(os.environ, env, clear=False): + config.load(tmp_path / "missing.toml") + assert config.get("model") == "deepseek/deepseek-v3.2" + assert config.get("telegram")["BOT_TOKEN"] == "bot:token" + assert config.get("telegram")["ALLOW_FROM"] == [99, 100] + From f699b4db8e03f9fef582f8cc9ec7f7821a3b6531 Mon Sep 17 00:00:00 2001 From: "rikulpatel@gmail.com" Date: Thu, 7 May 2026 19:02:36 -0500 Subject: [PATCH 39/84] increased msg history len to 1000 --- app/core/agent.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/app/core/agent.py b/app/core/agent.py index 267cee1..663d288 100755 --- a/app/core/agent.py +++ b/app/core/agent.py @@ -6,8 +6,8 @@ from .client import Client from ..infra.app_logging import log -MAX_CONTEXT_MESSAGES = 250 -TOOL_RESULT_HISTORY_LIMIT = 200 +MAX_CONTEXT_MESSAGES = 1000 +TOOL_RESULT_HISTORY_LIMIT = 100 class Agent(ABC): From 34907949e744c76c43468aaabd1388c270e34716 Mon Sep 17 00:00:00 2001 From: "rikulpatel@gmail.com" Date: Fri, 8 May 2026 09:04:46 -0500 Subject: [PATCH 40/84] feat: added get_city_state and get_datetime tools --- app/core/tool_calls.py | 13 ++++++++++--- app/infra/startup.py | 3 +-- app/tools/get_city_state.py | 26 ++++++++++++++++++++++++++ app/tools/get_datetime.py | 28 ++++++++++++++++++++++++++++ pyproject.toml | 1 + 5 files changed, 66 insertions(+), 5 deletions(-) create mode 100644 app/tools/get_city_state.py create mode 100644 app/tools/get_datetime.py diff --git a/app/core/tool_calls.py b/app/core/tool_calls.py index 7786c67..9a508d6 100755 --- a/app/core/tool_calls.py +++ b/app/core/tool_calls.py @@ -20,6 +20,9 @@ from ..tools.sched_tasks_tool import ListScheduledTasks, AddScheduledTask, UpdateScheduledTask, \ RemoveScheduledTask, GetScheduledTaskOutput +from ..tools.get_city_state import GetCityState +from ..tools.get_datetime import GetDateTime + import json tool_registry = { @@ -47,13 +50,17 @@ "add_scheduled_task": AddScheduledTask, "update_scheduled_task": UpdateScheduledTask, "remove_scheduled_task": RemoveScheduledTask, - "get_scheduled_task_output": GetScheduledTaskOutput + "get_scheduled_task_output": GetScheduledTaskOutput, + + "get_city_state": GetCityState, + "get_datetime": GetDateTime } all_tool_specs = [tool.spec() for tool in tool_registry.values()] - _HELPER_AGENT_TOOLS = {"read_file", "write_file", "bash", "web_fetch", "get_skills_dir", "calculator", "hackernews", - "websearch_text", "websearch_images", "websearch_videos", "websearch_news", "websearch_books"} + "websearch_text", "websearch_images", "websearch_videos", "websearch_news", "websearch_books", + "get_city_state", "get_datetime", "list_scheduled_tasks", "get_scheduled_task_output"} + helper_tool_specs = [tool.spec() for k, tool in tool_registry.items() if k in _HELPER_AGENT_TOOLS] MAX_TOOL_RESULT_LENGTH = 16000 diff --git a/app/infra/startup.py b/app/infra/startup.py index 01551df..3c6f136 100755 --- a/app/infra/startup.py +++ b/app/infra/startup.py @@ -23,9 +23,8 @@ def load_system_context() -> str: system_context += f""" ## System Context -- datetime: {now.strftime("%Y-%m-%d %H:%M:%S")} +- datetime: {now.strftime("%Y-%m-%d %H:%M:%S")} {now.astimezone().tzname()} - day of week: {now.strftime("%A")} -- timezone: {now.astimezone().tzname()} - os: {platform.system()} {platform.release()} - shell: {os.environ.get("SHELL", "unknown")} - cwd: {Path.cwd()} diff --git a/app/tools/get_city_state.py b/app/tools/get_city_state.py new file mode 100644 index 0000000..7906265 --- /dev/null +++ b/app/tools/get_city_state.py @@ -0,0 +1,26 @@ +from ..infra.app_logging import log +from ..core.tool import Tool +import geocoder + +class GetCityState(Tool): + + @staticmethod + def spec(): + return { + "type": "function", + "function": { + "name": "get_city_state", + "description": "Get current city and state based on IP address", + "parameters": { + "type": "object", + "properties": {} + } + } + } + + @staticmethod + def call() -> str: + log.info("get_city_state") + g = geocoder.ip('me') + + return f"{g.city}, {g.state}" if g.ok else "Unknown location" \ No newline at end of file diff --git a/app/tools/get_datetime.py b/app/tools/get_datetime.py new file mode 100644 index 0000000..4214d13 --- /dev/null +++ b/app/tools/get_datetime.py @@ -0,0 +1,28 @@ +from ..infra.app_logging import log +from ..core.tool import Tool + +from datetime import datetime + +class GetDateTime(Tool): + + @staticmethod + def spec(): + return { + "type": "function", + "function": { + "name": "get_datetime", + "description": "Get current date and time in ISO format with timezone", + "parameters": { + "type": "object", + "properties": {} + } + } + } + + @staticmethod + def call() -> str: + log.info("get_datetime") + + now = datetime.now() + return f"{now.strftime("%Y-%m-%d %H:%M:%S")} {now.astimezone().tzname()}" + \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index 376b77d..d9414a7 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -8,6 +8,7 @@ dependencies = [ "requests>=2.32.5", "python-telegram-bot>=22.7", "ddgs>=9.14.1", + "geocoder>=1.38.1", ] [dependency-groups] From c7662f7ec9f2b556e614aa57c99aa8f535c475c5 Mon Sep 17 00:00:00 2001 From: "rikulpatel@gmail.com" Date: Fri, 8 May 2026 09:59:29 -0500 Subject: [PATCH 41/84] fix: stop test_agent.py from writing to the real DB MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit patch.object(MessageHistory, "get_history") only intercepted reads — add_message still ran against APP_DB on every pytest run, contaminating production history with test prompts ("say hello", "What is 2+2?", etc.). Switch all make_agent() calls to patch the full MessageHistory class at the cli_agent module scope, matching how test_background_agent.py already handled it. Remove the now-unused top-level MessageHistory import. Co-Authored-By: Claude Sonnet 4.6 --- tests/test_agent.py | 13 ++++++++----- 1 file changed, 8 insertions(+), 5 deletions(-) diff --git a/tests/test_agent.py b/tests/test_agent.py index f788ed3..39fdf02 100644 --- a/tests/test_agent.py +++ b/tests/test_agent.py @@ -4,7 +4,6 @@ import app.config as config from app.cli.cli_agent import CliAgent as Agent -from app.infra.message_history import MessageHistory def make_mock_client(tool_calls=None, content="Hello!", finish_reason="stop"): @@ -31,7 +30,8 @@ def make_agent(auto_approve=True, silent=True, max_iterations=10): mock_openai = make_mock_client() MockClient.return_value.get_client.return_value = mock_openai with patch("app.cli.cli_agent.load_system_context", return_value="You are a helpful assistant."): - with patch.object(MessageHistory, "get_history", return_value=[]): + with patch("app.cli.cli_agent.MessageHistory") as MockHistory: + MockHistory.return_value.get_history.return_value = [] agent = Agent( auto_approve=auto_approve, silent=silent, max_iterations=max_iterations ) @@ -90,7 +90,8 @@ async def test_agent_loop_respects_max_iterations(): mock_client = MagicMock() MockClient.return_value.get_client.return_value = mock_client with patch("app.cli.cli_agent.load_system_context", return_value="You are a helpful assistant."): - with patch.object(MessageHistory, "get_history", return_value=[]): + with patch("app.cli.cli_agent.MessageHistory") as MockHistory: + MockHistory.return_value.get_history.return_value = [] agent = Agent(auto_approve=True, silent=True, max_iterations=3) agent.client = mock_client @@ -125,7 +126,8 @@ async def test_agent_loop_runs_tool_when_auto_approve(): mock_client = MagicMock() MockClient.return_value.get_client.return_value = mock_client with patch("app.cli.cli_agent.load_system_context", return_value="You are a helpful assistant."): - with patch.object(MessageHistory, "get_history", return_value=[]): + with patch("app.cli.cli_agent.MessageHistory") as MockHistory: + MockHistory.return_value.get_history.return_value = [] agent = Agent(auto_approve=True, silent=True, max_iterations=10) agent.client = mock_client @@ -174,7 +176,8 @@ async def test_agent_loop_continues_when_finish_reason_not_stop(): mock_client = MagicMock() MockClient.return_value.get_client.return_value = mock_client with patch("app.cli.cli_agent.load_system_context", return_value="You are a helpful assistant."): - with patch.object(MessageHistory, "get_history", return_value=[]): + with patch("app.cli.cli_agent.MessageHistory") as MockHistory: + MockHistory.return_value.get_history.return_value = [] agent = Agent(auto_approve=True, silent=True, max_iterations=10) agent.client = mock_client From 255ffea8757cf1f64fd008d51b0fbf49615d167c Mon Sep 17 00:00:00 2001 From: "rikulpatel@gmail.com" Date: Wed, 13 May 2026 16:10:49 -0500 Subject: [PATCH 42/84] feat: add Discord channel with per-channel MQ isolation MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Add DiscordChannel extending both discord.Client and Channel ABC; routes incoming messages to its own MessageQueue, tracks last channel_id for scheduled task delivery, and falls back to DM-ing the app owner when no channel context is available - Give each channel its own MessageQueue so incoming messages are never consumed by the wrong agent - Add default_metadata property to Channel ABC; TelegramChannel returns {chat_id: allow_from[0]}, DiscordChannel returns last seen channel_id; ScheduledTasks uses channel.default_metadata directly at delivery time — no static config needed - Guard ScheduledTasks.run() and task delivery with try/except so a failing task cannot crash the background server - Add DISCORD_BOT_TOKEN env var and [discord] config section - Add 20 tests covering DiscordChannel behaviour and bg_server startup scenarios including discord-only mode Co-Authored-By: Claude Sonnet 4.6 --- Dockerfile | 1 + app/bg_server.py | 57 +++++---- app/channels/channel.py | 3 + app/channels/discord.py | 93 +++++++++++++++ app/channels/telegram.py | 4 + app/config.py | 5 + app/core/scheduled_tasks.py | 37 +++--- pyproject.toml | 1 + tests/test_bg_server.py | 154 ++++++++++++++++++++++++ tests/test_discord_channel.py | 219 ++++++++++++++++++++++++++++++++++ 10 files changed, 537 insertions(+), 37 deletions(-) create mode 100644 app/channels/discord.py create mode 100644 tests/test_bg_server.py create mode 100644 tests/test_discord_channel.py diff --git a/Dockerfile b/Dockerfile index bee7bec..198406a 100644 --- a/Dockerfile +++ b/Dockerfile @@ -23,6 +23,7 @@ ENV TELEGRAM_ALLOW_FROM="" # Secrets — pass at runtime only, never bake into the image: # docker run -e LLM_API_KEY=... -e TELEGRAM_BOT_TOKEN=... +# docker run -e LLM_API_KEY=... -e DISCORD_BOT_TOKEN=... # or: docker run --env-file .env CMD ["bash", "run.sh", "background"] diff --git a/app/bg_server.py b/app/bg_server.py index 0266f1e..bf55d07 100755 --- a/app/bg_server.py +++ b/app/bg_server.py @@ -9,10 +9,12 @@ async def start_server() -> None: - log.info("Starting server...") + telegram_channel = None - mq = MessageQueue() + telegram_agent = None + discord_channel = None + discord_agent = None # Change CWD to PROJECT_HOME/workspace to ensure all file operations are relative to this directory # This is important for the agent to read/write files in the workspace @@ -22,30 +24,45 @@ async def start_server() -> None: if config.get("telegram"): bot_token = config.telegram.get("BOT_TOKEN") - if not bot_token: log.error("Telegram BOT_TOKEN not set in config, skipping Telegram channel") - return + else: + from .channels.telegram import TelegramChannel + telegram_mq = MessageQueue() + telegram_channel = TelegramChannel(telegram_mq, bot_token=bot_token, allow_from=config.telegram.get("ALLOW_FROM", [])) + telegram_channel.start() + telegram_agent = BackgroundAgent(mq=telegram_mq, channel=telegram_channel) - from .channels.telegram import TelegramChannel - telegram_channel = TelegramChannel(mq, bot_token=bot_token, allow_from=config.telegram.get("ALLOW_FROM", [])) + if config.get("discord"): + discord_token = config.discord.get("TOKEN") + if not discord_token: + log.error("Discord TOKEN not set in config, skipping Discord channel") + else: + from .channels.discord import DiscordChannel + discord_mq = MessageQueue() + discord_channel = DiscordChannel(discord_mq, token=discord_token) + discord_channel.start() + discord_agent = BackgroundAgent(mq=discord_mq, channel=discord_channel) - - if not telegram_channel: + if not telegram_channel and not discord_channel: log.error("No channels configured, exiting...") return - telegram_channel.start() - telegram_agent = BackgroundAgent(mq=mq, channel=telegram_channel) + channels = {} + mqs = {} + if telegram_channel: + channels["telegram"] = telegram_channel + mqs["telegram"] = telegram_mq + if discord_channel: + channels["discord"] = discord_channel + mqs["discord"] = discord_mq + + tasks = ScheduledTasks(mqs=mqs, channels=channels) - channels = {"telegram": telegram_channel} if telegram_channel else {} - allow_from = config.telegram.get("ALLOW_FROM", []) if config.get("telegram") else [] - default_metadata = {"chat_id": allow_from[0]} if allow_from else {} - tasks = ScheduledTasks(mq=mq, channels=channels, default_metadata=default_metadata) + coros = [tasks.run()] + if telegram_channel: + coros.extend([telegram_channel.run_polling(), telegram_agent.process_incoming(), telegram_mq.process_outgoing()]) + if discord_channel: + coros.extend([discord_channel.run_polling(), discord_agent.process_incoming(), discord_mq.process_outgoing()]) - await asyncio.gather( - telegram_channel.run_polling(), - telegram_agent.process_incoming(), - mq.process_outgoing(), - tasks.run() - ) \ No newline at end of file + await asyncio.gather(*coros) diff --git a/app/channels/channel.py b/app/channels/channel.py index 87cc609..844e9dd 100755 --- a/app/channels/channel.py +++ b/app/channels/channel.py @@ -35,3 +35,6 @@ def has_stopped(self) -> bool: def clear_stopped(self) -> None: pass + @property + def default_metadata(self) -> dict: + return {} diff --git a/app/channels/discord.py b/app/channels/discord.py new file mode 100644 index 0000000..8dd1f5e --- /dev/null +++ b/app/channels/discord.py @@ -0,0 +1,93 @@ +import discord +import logging + +from .message_queue import MessageQueue +from .channel import Channel, ChannelType +from .message import OutgoingMessage, IncomingMessage + +log = logging.getLogger(__name__) + +MAX_DISCORD_LENGTH = 2000 + + +class DiscordChannel(discord.Client, Channel): + user: discord.ClientUser # filled after login + + def __init__(self, mq: MessageQueue, token: str) -> None: + intents = discord.Intents.default() + intents.message_content = True + super().__init__(intents=intents) + self.mq = mq + self.token = token + self.stopped = False + self._last_channel_id: int | None = None + mq.register(self, self.send_message) + + @property + def has_stopped(self) -> bool: + return self.stopped + + def clear_stopped(self) -> None: + self.stopped = False + + @property + def channel_type(self) -> ChannelType: + return ChannelType.DISCORD + + @property + def default_metadata(self) -> dict: + return {"channel_id": self._last_channel_id} if self._last_channel_id else {} + + async def on_ready(self) -> None: + log.info(f"Discord: logged in as {self.user} (ID: {self.user.id})") + + async def on_message(self, message: discord.Message) -> None: + if message.author.id == self.user.id: + return + if message.content and message.content.strip(): + self._last_channel_id = message.channel.id + await self.mq.incoming.put( + IncomingMessage( + content=message.content.strip(), + channel=ChannelType.DISCORD, + metadata={"channel_id": message.channel.id}, + ) + ) + + async def _resolve_destination(self, channel_id: int | None) -> discord.abc.Messageable | None: + if channel_id: + channel = self.get_channel(channel_id) + if channel is None: + try: + channel = await self.fetch_channel(channel_id) + except discord.NotFound: + log.error(f"Discord channel {channel_id} not found") + return None + return channel + # No channel context — DM the app owner + try: + app_info = await self.application_info() + return await app_info.owner.create_dm() + except Exception as e: + log.error(f"Discord: failed to open DM with owner: {e}") + return None + + async def send_message(self, msg: OutgoingMessage) -> None: + channel_id = msg.metadata.get("channel_id") + dest = await self._resolve_destination(channel_id) + if dest is None: + return + for i in range(0, len(msg.content), MAX_DISCORD_LENGTH): + await dest.send(msg.content[i : i + MAX_DISCORD_LENGTH]) + + async def process_message(self, message) -> None: + pass # handled by on_message discord event + + async def error_handler(self, update, context) -> None: + log.error(f"Discord error: {context}") + + def start(self) -> None: + log.info("Starting Discord channel...") + + async def run_polling(self) -> None: + await discord.Client.start(self, self.token) diff --git a/app/channels/telegram.py b/app/channels/telegram.py index 26d861d..f24e96b 100755 --- a/app/channels/telegram.py +++ b/app/channels/telegram.py @@ -40,6 +40,10 @@ def clear_stopped(self) -> None: def channel_type(self) -> ChannelType: return ChannelType.TELEGRAM + @property + def default_metadata(self) -> dict: + return {"chat_id": self.allow_from[0]} if self.allow_from else {} + async def error_handler( self, update: object, context: ContextTypes.DEFAULT_TYPE ) -> None: diff --git a/app/config.py b/app/config.py index 2107cb9..6bcefe6 100644 --- a/app/config.py +++ b/app/config.py @@ -33,6 +33,8 @@ def load(path: Path | str = HOME_CONFIG_PATH) -> None: _config.setdefault("telegram", {})["BOT_TOKEN"] = v if v := os.environ.get("TELEGRAM_ALLOW_FROM"): _config.setdefault("telegram", {})["ALLOW_FROM"] = [int(x.strip()) for x in v.split(",") if x.strip()] + if v := os.environ.get("DISCORD_BOT_TOKEN"): + _config.setdefault("discord", {})["TOKEN"] = v def get(key: str, default=None): @@ -54,4 +56,7 @@ def get_default_config() -> str: [telegram] BOT_TOKEN = "" ALLOW_FROM = [] # List of allowed Telegram user IDs (integers). Must be non-empty. + +[discord] +TOKEN = "" """ diff --git a/app/core/scheduled_tasks.py b/app/core/scheduled_tasks.py index 6286c49..39ed476 100755 --- a/app/core/scheduled_tasks.py +++ b/app/core/scheduled_tasks.py @@ -7,17 +7,15 @@ import asyncio from .helper_agent import HelperAgent - TASKS_SYSTEM_PROMPT = """ You are a background agent running periodic tasks. The user is not present. Read your instructions and execute them. Be concise. """ class ScheduledTasks: - def __init__(self, mq=None, channels: dict = None, default_metadata: dict = None): - self._mq = mq + def __init__(self, mqs: dict = None, channels: dict = None): + self._mqs = mqs or {} self._channels = channels or {} - self._default_metadata = default_metadata or {} self._init_tasks_db() def _migrate(self, conn, table: str, columns: list[tuple[str, str]]): @@ -112,8 +110,6 @@ def update_task(self, name: str, **fields): conn.execute(f"UPDATE tasks SET {set_clause} WHERE name = ?", values) conn.commit() - - def save_output(self, name: str, prompt: str, output: str, status: str = "success", duration_secs: float = None): with sqlite3.connect(APP_DB) as conn: @@ -166,21 +162,28 @@ async def run_task(self, task: dict) -> str: status=status, duration_secs=duration) self._after_run(task=task, now=datetime.now()) - if self._mq: - channel = self._channels.get(task["delivery_channel"]) - if channel: + channel_name = task["delivery_channel"] + mq = self._mqs.get(channel_name) + channel = self._channels.get(channel_name) + if mq and channel: + try: from ..channels.message import OutgoingMessage - await self._mq.outgoing_msg(OutgoingMessage(content=output, channel=channel, metadata=self._default_metadata)) - else: - log.warning(f"Delivery channel '{task['delivery_channel']}' not found for task '{name}'") + await mq.outgoing_msg(OutgoingMessage(content=output, channel=channel, metadata=channel.default_metadata)) + except Exception as e: + log.error(f"Scheduled task '{name}': failed to deliver to '{channel_name}': {e}") + else: + log.warning(f"Delivery channel '{channel_name}' not found for task '{name}'") return output async def run(self): while True: - now = datetime.now() - tasks = self.load_tasks() - due = [t for t in tasks if t["enabled"] and self._is_due(t, now)] - if due: - await asyncio.gather(*[self.run_task(t) for t in due]) + try: + now = datetime.now() + tasks = self.load_tasks() + due = [t for t in tasks if t["enabled"] and self._is_due(t, now)] + if due: + await asyncio.gather(*[self.run_task(t) for t in due], return_exceptions=True) + except Exception as e: + log.error(f"ScheduledTasks.run error: {e}", exc_info=True) await asyncio.sleep(60) diff --git a/pyproject.toml b/pyproject.toml index d9414a7..54ad969 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -9,6 +9,7 @@ dependencies = [ "python-telegram-bot>=22.7", "ddgs>=9.14.1", "geocoder>=1.38.1", + "discord-py>=2.7.1", ] [dependency-groups] diff --git a/tests/test_bg_server.py b/tests/test_bg_server.py new file mode 100644 index 0000000..490fe08 --- /dev/null +++ b/tests/test_bg_server.py @@ -0,0 +1,154 @@ +import pytest +from pathlib import Path +from unittest.mock import patch, MagicMock, AsyncMock + +from app.bg_server import start_server + + +def _make_config(telegram_token=None, discord_token=None): + """Build a mock config that returns only the configured channels.""" + mock_config = MagicMock() + mock_config.PROJECT_HOME = MagicMock() + + active = {} + if telegram_token: + active["telegram"] = True + mock_config.telegram.get.side_effect = lambda key, default=None: { + "BOT_TOKEN": telegram_token, + "ALLOW_FROM": [], + }.get(key, default) + + if discord_token: + active["discord"] = True + mock_config.discord.get.side_effect = lambda key, default=None: { + "TOKEN": discord_token, + }.get(key, default) + + mock_config.get.side_effect = lambda key: active.get(key) + return mock_config + + +@pytest.mark.asyncio +async def test_start_server_discord_only_starts_discord_agent(): + mock_gather = AsyncMock() + mock_config = _make_config(discord_token="discord-token") + + with patch("app.bg_server.config", mock_config), \ + patch("app.bg_server.os.chdir"), \ + patch("app.channels.discord.DiscordChannel") as MockDC, \ + patch("app.bg_server.BackgroundAgent") as MockAgent, \ + patch("app.bg_server.ScheduledTasks") as MockTasks, \ + patch("app.bg_server.MessageQueue") as MockMQ, \ + patch("asyncio.gather", mock_gather): + + mock_dc = MockDC.return_value + mock_mq = MockMQ.return_value + + await start_server() + + MockDC.assert_called_once_with(mock_mq, token="discord-token") + MockAgent.assert_called_once_with(mq=mock_mq, channel=mock_dc) + assert mock_gather.called + + +@pytest.mark.asyncio +async def test_start_server_discord_only_no_telegram_crash(): + """start_server must not AttributeError on config.telegram when only Discord is set.""" + mock_gather = AsyncMock() + mock_config = _make_config(discord_token="discord-token") + # config.telegram is not set — accessing it should not be reached + del mock_config.telegram + + with patch("app.bg_server.config", mock_config), \ + patch("app.bg_server.os.chdir"), \ + patch("app.channels.discord.DiscordChannel"), \ + patch("app.bg_server.BackgroundAgent"), \ + patch("app.bg_server.ScheduledTasks"), \ + patch("app.bg_server.MessageQueue"), \ + patch("asyncio.gather", mock_gather): + + await start_server() # must not raise + + +@pytest.mark.asyncio +async def test_start_server_discord_only_gather_excludes_telegram(): + mock_gather = AsyncMock() + mock_config = _make_config(discord_token="discord-token") + + with patch("app.bg_server.config", mock_config), \ + patch("app.bg_server.os.chdir"), \ + patch("app.channels.discord.DiscordChannel") as MockDC, \ + patch("app.bg_server.BackgroundAgent") as MockAgent, \ + patch("app.bg_server.ScheduledTasks") as MockTasks, \ + patch("app.bg_server.MessageQueue") as MockMQ, \ + patch("asyncio.gather", mock_gather): + + mock_dc = MockDC.return_value + mock_agent = MockAgent.return_value + mock_mq = MockMQ.return_value + + await start_server() + + # tasks.run + discord run_polling + discord process_incoming + discord process_outgoing = 4 + coros = mock_gather.call_args[0] + assert len(coros) == 4 + mock_dc.run_polling.assert_called_once() + mock_agent.process_incoming.assert_called_once() + mock_mq.process_outgoing.assert_called_once() + + +@pytest.mark.asyncio +async def test_start_server_exits_when_no_channels_configured(): + mock_gather = AsyncMock() + mock_config = _make_config() # neither telegram nor discord + + with patch("app.bg_server.config", mock_config), \ + patch("app.bg_server.os.chdir"), \ + patch("asyncio.gather", mock_gather): + + await start_server() + + mock_gather.assert_not_called() + + +@pytest.mark.asyncio +async def test_start_server_both_channels_uses_separate_mqs(): + mock_gather = AsyncMock() + mock_config = _make_config(telegram_token="tg-token", discord_token="discord-token") + mq_instances = [] + + def make_mq(): + mq = MagicMock() + mq_instances.append(mq) + return mq + + with patch("app.bg_server.config", mock_config), \ + patch("app.bg_server.os.chdir"), \ + patch("app.channels.telegram.TelegramChannel"), \ + patch("app.channels.discord.DiscordChannel"), \ + patch("app.bg_server.BackgroundAgent"), \ + patch("app.bg_server.ScheduledTasks"), \ + patch("app.bg_server.MessageQueue", side_effect=make_mq), \ + patch("asyncio.gather", mock_gather): + + await start_server() + + # One MQ per channel + assert len(mq_instances) == 2 + assert mq_instances[0] is not mq_instances[1] + + +@pytest.mark.asyncio +async def test_start_server_discord_missing_token_skips_channel(): + mock_gather = AsyncMock() + mock_config = _make_config(discord_token=None) + mock_config.get.side_effect = lambda key: {"discord": True}.get(key) + mock_config.discord.get.side_effect = lambda key, default=None: None # TOKEN missing + + with patch("app.bg_server.config", mock_config), \ + patch("app.bg_server.os.chdir"), \ + patch("asyncio.gather", mock_gather): + + await start_server() + + mock_gather.assert_not_called() diff --git a/tests/test_discord_channel.py b/tests/test_discord_channel.py new file mode 100644 index 0000000..cddbefe --- /dev/null +++ b/tests/test_discord_channel.py @@ -0,0 +1,219 @@ +import pytest +import discord +from unittest.mock import patch, MagicMock, AsyncMock + +from app.channels.channel import ChannelType +from app.channels.discord import DiscordChannel, MAX_DISCORD_LENGTH +from app.channels.message import OutgoingMessage +from app.channels.message_queue import MessageQueue + + +def make_discord_channel(): + mq = MessageQueue() + with patch.object(discord.Client, "__init__", return_value=None): + dc = DiscordChannel(mq=mq, token="test-token") + # discord.Client.user is a read-only property returning self._connection.user + dc._connection = MagicMock() + dc._connection.user.id = 999 + return dc, mq + + +def make_not_found(): + resp = MagicMock() + resp.status = 404 + resp.reason = "Not Found" + return discord.NotFound(resp, "unknown channel") + + +# --- Initialization --- + +def test_registers_delivery_function(): + dc, mq = make_discord_channel() + assert dc in mq._delivery + assert mq._delivery[dc].__func__ is DiscordChannel.send_message + + +def test_stores_token(): + dc, _ = make_discord_channel() + assert dc.token == "test-token" + + +def test_channel_type(): + dc, _ = make_discord_channel() + assert dc.channel_type == ChannelType.DISCORD + + +def test_initial_stopped_false(): + dc, _ = make_discord_channel() + assert dc.has_stopped is False + + +# --- on_message --- + +@pytest.mark.asyncio +async def test_on_message_puts_to_incoming_queue(): + dc, mq = make_discord_channel() + message = MagicMock() + message.author.id = 123 + message.channel.id = 456 + message.content = "hello" + + await dc.on_message(message) + + assert not mq.incoming.empty() + msg = await mq.incoming.get() + assert msg.content == "hello" + assert msg.channel == ChannelType.DISCORD + assert msg.metadata == {"channel_id": 456} + + +@pytest.mark.asyncio +async def test_on_message_ignores_self(): + dc, mq = make_discord_channel() + message = MagicMock() + message.author.id = 999 # same as dc.user.id + message.content = "echo" + + await dc.on_message(message) + + assert mq.incoming.empty() + + +@pytest.mark.asyncio +async def test_on_message_ignores_whitespace_only(): + dc, mq = make_discord_channel() + message = MagicMock() + message.author.id = 123 + message.content = " " + + await dc.on_message(message) + + assert mq.incoming.empty() + + +@pytest.mark.asyncio +async def test_on_message_trims_whitespace(): + dc, mq = make_discord_channel() + message = MagicMock() + message.author.id = 123 + message.channel.id = 456 + message.content = " hi there " + + await dc.on_message(message) + + msg = await mq.incoming.get() + assert msg.content == "hi there" + + +# --- send_message --- + +@pytest.mark.asyncio +async def test_send_message_sends_to_channel(): + dc, _ = make_discord_channel() + mock_channel = AsyncMock() + dc.get_channel = MagicMock(return_value=mock_channel) + + msg = OutgoingMessage(content="reply", channel=dc, metadata={"channel_id": 456}) + await dc.send_message(msg) + + mock_channel.send.assert_called_once_with("reply") + + +@pytest.mark.asyncio +async def test_send_message_fetches_when_not_in_cache(): + dc, _ = make_discord_channel() + mock_channel = AsyncMock() + dc.get_channel = MagicMock(return_value=None) + dc.fetch_channel = AsyncMock(return_value=mock_channel) + + msg = OutgoingMessage(content="reply", channel=dc, metadata={"channel_id": 456}) + await dc.send_message(msg) + + dc.fetch_channel.assert_called_once_with(456) + mock_channel.send.assert_called_once_with("reply") + + +@pytest.mark.asyncio +async def test_send_message_dms_owner_when_no_channel_id(): + dc, _ = make_discord_channel() + mock_dm = AsyncMock() + mock_owner = AsyncMock() + mock_owner.create_dm = AsyncMock(return_value=mock_dm) + mock_app_info = MagicMock() + mock_app_info.owner = mock_owner + dc.application_info = AsyncMock(return_value=mock_app_info) + + msg = OutgoingMessage(content="task result", channel=dc, metadata={}) + await dc.send_message(msg) + + mock_owner.create_dm.assert_called_once() + mock_dm.send.assert_called_once_with("task result") + + +@pytest.mark.asyncio +async def test_send_message_logs_error_when_channel_not_found(caplog): + import logging + dc, _ = make_discord_channel() + dc.get_channel = MagicMock(return_value=None) + dc.fetch_channel = AsyncMock(side_effect=make_not_found()) + + msg = OutgoingMessage(content="reply", channel=dc, metadata={"channel_id": 456}) + with caplog.at_level(logging.ERROR): + await dc.send_message(msg) + + assert "456" in caplog.text + + +@pytest.mark.asyncio +async def test_send_message_splits_long_content(): + dc, _ = make_discord_channel() + mock_channel = AsyncMock() + dc.get_channel = MagicMock(return_value=mock_channel) + + long_content = "x" * (MAX_DISCORD_LENGTH + 100) + msg = OutgoingMessage(content=long_content, channel=dc, metadata={"channel_id": 456}) + await dc.send_message(msg) + + assert mock_channel.send.call_count == 2 + + +# --- default_metadata / last channel tracking --- + +def test_default_metadata_empty_before_any_message(): + dc, _ = make_discord_channel() + assert dc.default_metadata == {} + + +@pytest.mark.asyncio +async def test_default_metadata_set_after_message(): + dc, mq = make_discord_channel() + message = MagicMock() + message.author.id = 123 + message.channel.id = 789 + message.content = "hello" + + await dc.on_message(message) + + assert dc.default_metadata == {"channel_id": 789} + + +@pytest.mark.asyncio +async def test_on_message_updates_last_channel_id(): + dc, mq = make_discord_channel() + for channel_id in [111, 222, 333]: + message = MagicMock() + message.author.id = 123 + message.channel.id = channel_id + message.content = "hi" + await dc.on_message(message) + + assert dc._last_channel_id == 333 + + +# --- has_stopped / clear_stopped --- + +def test_clear_stopped_resets_state(): + dc, _ = make_discord_channel() + dc.stopped = True + dc.clear_stopped() + assert dc.has_stopped is False From a0a0e7ef33891ea6840b80852479abb3a437065c Mon Sep 17 00:00:00 2001 From: "rikulpatel@gmail.com" Date: Wed, 13 May 2026 16:59:48 -0500 Subject: [PATCH 43/84] refactor: removed compress turn function, messages only keep user/finalmsg --- app/cli/cli_agent.py | 4 ++-- app/core/agent.py | 14 -------------- app/core/background_agent.py | 4 ++-- 3 files changed, 4 insertions(+), 18 deletions(-) diff --git a/app/cli/cli_agent.py b/app/cli/cli_agent.py index 720d61b..53d4e3a 100755 --- a/app/cli/cli_agent.py +++ b/app/cli/cli_agent.py @@ -36,12 +36,12 @@ async def agent_loop(self, message: str, metadata: dict = None) -> str: system_context = load_system_context() system = [{"role": "system", "content": system_context}] if system_context else [] - turn_start = len(system) + len(self.messages) session_messages = system + self.messages[:] + [{"role": "user", "content": message}] final_content = await self._loop(session_messages, all_tool_specs) - self.messages.extend(self._compress_turn(session_messages, turn_start)) + self.messages.append({"role": "user", "content": message}) + self.messages.append({"role": "assistant", "content": final_content}) self.history.add_message("assistant", final_content) return final_content diff --git a/app/core/agent.py b/app/core/agent.py index 663d288..867f3a4 100755 --- a/app/core/agent.py +++ b/app/core/agent.py @@ -17,20 +17,6 @@ def __init__(self, max_iterations: int = 250) -> None: self.messages: list[dict] = [] self.max_iterations = max_iterations - @staticmethod - def _compress_turn(session_messages: list, turn_start: int) -> list: - """Return turn messages with tool results truncated for history storage.""" - result = [] - for msg in session_messages[turn_start:]: - if msg.get("role") == "tool": - content = msg.get("content", "") - if len(content) > TOOL_RESULT_HISTORY_LIMIT: - content = content[:TOOL_RESULT_HISTORY_LIMIT] + "...[truncated]" - result.append({**msg, "content": content}) - else: - result.append(msg) - return result - def _trim_messages(self) -> None: if len(self.messages) > MAX_CONTEXT_MESSAGES: self.messages = self.messages[-MAX_CONTEXT_MESSAGES:] diff --git a/app/core/background_agent.py b/app/core/background_agent.py index e7d8cb8..9862183 100755 --- a/app/core/background_agent.py +++ b/app/core/background_agent.py @@ -73,14 +73,14 @@ async def agent_loop(self, message: str, metadata: dict = None) -> str: system_context = load_system_context() system = [{"role": "system", "content": system_context}] if system_context else [] - turn_start = len(system) + len(self.messages) session_messages = system + self.messages[:] + [{"role": "user", "content": message}] final_content = await self._loop(session_messages, all_tool_specs) self.channel.clear_stopped() - self.messages.extend(self._compress_turn(session_messages, turn_start)) + self.messages.append({"role": "user", "content": message}) + self.messages.append({"role": "assistant", "content": final_content}) self.history.add_message("assistant", final_content) return final_content From 13261d95b5b284834c3cb058cfd3d13ade3950b6 Mon Sep 17 00:00:00 2001 From: "rikulpatel@gmail.com" Date: Wed, 13 May 2026 17:04:56 -0500 Subject: [PATCH 44/84] fix: added ALLOW_FROM for Discord --- Dockerfile | 1 + app/bg_server.py | 2 +- app/channels/discord.py | 8 ++++++- app/config.py | 3 +++ tests/test_bg_server.py | 2 +- tests/test_discord_channel.py | 45 +++++++++++++++++++++++++++++++++-- 6 files changed, 56 insertions(+), 5 deletions(-) diff --git a/Dockerfile b/Dockerfile index 198406a..c41d941 100644 --- a/Dockerfile +++ b/Dockerfile @@ -20,6 +20,7 @@ VOLUME /data ENV LLM_BASE_URL="" ENV MODEL="" ENV TELEGRAM_ALLOW_FROM="" +ENV DISCORD_ALLOW_FROM="" # Secrets — pass at runtime only, never bake into the image: # docker run -e LLM_API_KEY=... -e TELEGRAM_BOT_TOKEN=... diff --git a/app/bg_server.py b/app/bg_server.py index bf55d07..ce589dc 100755 --- a/app/bg_server.py +++ b/app/bg_server.py @@ -40,7 +40,7 @@ async def start_server() -> None: else: from .channels.discord import DiscordChannel discord_mq = MessageQueue() - discord_channel = DiscordChannel(discord_mq, token=discord_token) + discord_channel = DiscordChannel(discord_mq, token=discord_token, allow_from=config.discord.get("ALLOW_FROM", [])) discord_channel.start() discord_agent = BackgroundAgent(mq=discord_mq, channel=discord_channel) diff --git a/app/channels/discord.py b/app/channels/discord.py index 8dd1f5e..dab7df7 100644 --- a/app/channels/discord.py +++ b/app/channels/discord.py @@ -13,12 +13,13 @@ class DiscordChannel(discord.Client, Channel): user: discord.ClientUser # filled after login - def __init__(self, mq: MessageQueue, token: str) -> None: + def __init__(self, mq: MessageQueue, token: str, allow_from: list[int] = None) -> None: intents = discord.Intents.default() intents.message_content = True super().__init__(intents=intents) self.mq = mq self.token = token + self.allow_from = allow_from or [] self.stopped = False self._last_channel_id: int | None = None mq.register(self, self.send_message) @@ -44,6 +45,11 @@ async def on_ready(self) -> None: async def on_message(self, message: discord.Message) -> None: if message.author.id == self.user.id: return + user_id = message.author.id + if self.allow_from and user_id not in self.allow_from: + log.warning(f"Discord: ignoring message from unauthorized user id={user_id}") + await message.reply("Sorry, you are not authorized to use this bot.") + return if message.content and message.content.strip(): self._last_channel_id = message.channel.id await self.mq.incoming.put( diff --git a/app/config.py b/app/config.py index 6bcefe6..36b6c3a 100644 --- a/app/config.py +++ b/app/config.py @@ -35,6 +35,8 @@ def load(path: Path | str = HOME_CONFIG_PATH) -> None: _config.setdefault("telegram", {})["ALLOW_FROM"] = [int(x.strip()) for x in v.split(",") if x.strip()] if v := os.environ.get("DISCORD_BOT_TOKEN"): _config.setdefault("discord", {})["TOKEN"] = v + if v := os.environ.get("DISCORD_ALLOW_FROM"): + _config.setdefault("discord", {})["ALLOW_FROM"] = [int(x.strip()) for x in v.split(",") if x.strip()] def get(key: str, default=None): @@ -59,4 +61,5 @@ def get_default_config() -> str: [discord] TOKEN = "" +ALLOW_FROM = [] # List of allowed Discord user IDs (integers). Empty means allow all. """ diff --git a/tests/test_bg_server.py b/tests/test_bg_server.py index 490fe08..55553b6 100644 --- a/tests/test_bg_server.py +++ b/tests/test_bg_server.py @@ -46,7 +46,7 @@ async def test_start_server_discord_only_starts_discord_agent(): await start_server() - MockDC.assert_called_once_with(mock_mq, token="discord-token") + MockDC.assert_called_once_with(mock_mq, token="discord-token", allow_from=[]) MockAgent.assert_called_once_with(mq=mock_mq, channel=mock_dc) assert mock_gather.called diff --git a/tests/test_discord_channel.py b/tests/test_discord_channel.py index cddbefe..44886cc 100644 --- a/tests/test_discord_channel.py +++ b/tests/test_discord_channel.py @@ -8,10 +8,10 @@ from app.channels.message_queue import MessageQueue -def make_discord_channel(): +def make_discord_channel(allow_from=None): mq = MessageQueue() with patch.object(discord.Client, "__init__", return_value=None): - dc = DiscordChannel(mq=mq, token="test-token") + dc = DiscordChannel(mq=mq, token="test-token", allow_from=allow_from) # discord.Client.user is a read-only property returning self._connection.user dc._connection = MagicMock() dc._connection.user.id = 999 @@ -91,6 +91,47 @@ async def test_on_message_ignores_whitespace_only(): assert mq.incoming.empty() +@pytest.mark.asyncio +async def test_on_message_rejects_unauthorized_user(): + dc, mq = make_discord_channel(allow_from=[111, 222]) + message = MagicMock() + message.author.id = 456 # not in allow_from, not the bot itself + message.content = "hello" + message.reply = AsyncMock() + + await dc.on_message(message) + + assert mq.incoming.empty() + message.reply.assert_called_once() + assert "not authorized" in message.reply.call_args[0][0] + + +@pytest.mark.asyncio +async def test_on_message_allows_when_allow_from_empty(): + dc, mq = make_discord_channel(allow_from=[]) + message = MagicMock() + message.author.id = 456 # any user allowed when allow_from is empty + message.channel.id = 1 + message.content = "hello" + + await dc.on_message(message) + + assert not mq.incoming.empty() + + +@pytest.mark.asyncio +async def test_on_message_allows_authorized_user(): + dc, mq = make_discord_channel(allow_from=[123]) + message = MagicMock() + message.author.id = 123 + message.channel.id = 1 + message.content = "hello" + + await dc.on_message(message) + + assert not mq.incoming.empty() + + @pytest.mark.asyncio async def test_on_message_trims_whitespace(): dc, mq = make_discord_channel() From 12fa484a7ea1601dc890ecf587714775d0de34d4 Mon Sep 17 00:00:00 2001 From: "rikulpatel@gmail.com" Date: Wed, 13 May 2026 17:19:52 -0500 Subject: [PATCH 45/84] refactor: updated sys_instructions.md --- app/core/sys_instructions.md | 68 ++++++++++++++++++++++++++---------- 1 file changed, 49 insertions(+), 19 deletions(-) diff --git a/app/core/sys_instructions.md b/app/core/sys_instructions.md index 66d76bb..8a82955 100644 --- a/app/core/sys_instructions.md +++ b/app/core/sys_instructions.md @@ -1,22 +1,52 @@ -I prefer detailed, technically precise responses that prioritize readability over cleverness. When writing code, please use idiomatic, maintainable style: PEP 8 for Python, ES6+ for JavaScript, four-space indentation for Python, and two-space indentation for JavaScript or JSON. Dates should use ISO 8601 format, such as YYYY-MM-DD. - -When creating code or project files, include inline comments where they improve clarity, and include README files when appropriate. Add validation, error handling, and logging where they are useful, especially for scripts or workflows that may fail in non-obvious ways. For Python or JavaScript, avoid overly clever shortcuts; I would rather have code that is easy to review, modify, and debug. - -Please provide concrete examples when explaining technical concepts or implementation details. When tests are requested, include meaningful unit tests rather than only superficial examples. - -A recurring issue I have experienced is assistants being too casual or lazy with tool calls. Please do not assume that a tool action succeeded just because it was attempted. After writing or modifying files, verify that the file exists and read it back or otherwise confirm the contents. After running shell commands, check the exit code and inspect relevant output before relying on the result. After creating or updating tasks, schedules, or other stateful resources, re-check the current state with the appropriate listing or read operation. In general, validate tool outputs before using them as evidence. - -When something fails, identify the specific failure point, inspect the error message, and try a reasonable alternative approach if one is available. If the task cannot be completed, explain clearly what failed, what was attempted, and what manual steps might resolve it. - -For longer or multi-step tasks, use a todo or planning approach to keep the work organized. This is especially important for complex projects, multi-file applications, large refactors, or workflows with dependencies. Simple one-shot scripts do not need a formal plan, but larger applications, APIs, database integrations, or multi-phase projects should start with a plan before implementation. - -For browser automation, scraping, screenshots, PDF generation from webpages, form filling, or web application testing, use the Puppeteer skill when applicable. Locate and read the relevant skill instructions first, then follow the best practices described there. When using the Puppeteer skill, read the instructions at skills/puppeteer/SKILL.md before proceeding. - -For persistent project work, use the workspace thoughtfully. Store reusable project files, notes, outputs, plans, code reviews, and documentation in clearly named folders. Prefer descriptive project names, group related files together, separate concerns such as src/, data/, and docs/, and include a README when a folder’s purpose is not obvious. - -Never delete files, directories, or data without explicit confirmation from the user. If a task seems to require removing something, describe what would be deleted and ask before proceeding. This applies to shell commands like rm, rmdir, and any write_file or bash call that would overwrite or destroy existing content. Prefer moving or renaming over deleting when in doubt. - -Overall, I value careful execution, verified results, clear communication, and practical error recovery. Do not skip verification steps when a tool changes state or creates artifacts. The goal is not just to complete the task, but to complete it in a way that can be trusted. +You are an intelligent, helpful, knowledgeable, and direct AI assistant. You assist users with a wide range of tasks including answering questions, writing and editing code, analyzing information, creative work, and executing actions via your tools. You communicate clearly, admit uncertainty when appropriate, and prioritize being genuinely useful over being verbose unless otherwise directed. Be targeted and efficient in your exploration and investigations. + +**Code Style:** +Use idiomatic, maintainable style: PEP 8 for Python, ES6+ for JavaScript, four-space indentation for Python, and two-space indentation for JavaScript or JSON. When creating code or project files, include inline comments where they improve clarity, and include README files when appropriate. Avoid overly clever shortcuts; prioritize code that is easy to review, modify, and debug. + +**Formatting:** +Use ISO 8601 format for dates (YYYY-MM-DD). + +**Technical Communication:** +Provide concrete examples when explaining technical concepts or implementation details. When tests are requested, include meaningful unit tests rather than only superficial examples. + +**Tool Verification (Critical):** +Do not assume that a tool action succeeded just because it was attempted. Always verify results: +- After writing or modifying files: verify the file exists and read it back to confirm contents +- After running shell commands: check exit code and inspect relevant output before relying on results +- After creating or updating stateful resources (tasks, schedules, etc.): re-check current state with appropriate listing or read operations +- In general: validate tool outputs before using them as evidence + +**Error Handling:** +When something fails, identify the specific failure point, inspect the error message, and try a reasonable alternative approach if available. If the task cannot be completed, explain clearly what failed, what was attempted, and what manual steps might resolve it. + +**Planning for Complex Tasks:** +For longer or multi-step tasks, use a todo or planning approach to keep work organized. This is especially important for: +- Complex projects or multi-file applications +- Large refactors or workflows with dependencies +- APIs, database integrations, or multi-phase projects + +Simple one-shot scripts do not need a formal plan. + +**Browser Automation:** +For browser automation, scraping, screenshots, PDF generation from webpages, form filling, or web application testing, use the Puppeteer skill when applicable. Always read the skill instructions at `skills/puppeteer/SKILL.md` before proceeding. + +**Workspace Organization:** +Use the workspace thoughtfully for persistent project work: +- Store reusable project files, notes, outputs, plans, code reviews, and documentation in clearly named folders +- Use descriptive project names +- Group related files together +- Separate concerns (src/, data/, docs/) +- Include a README when a folder's purpose is not obvious + +**File Safety:** +- Always backup files before replacing entire contents when possible +- Never delete files, directories, or data without explicit user confirmation +- If a task requires removing something, describe what would be deleted and ask before proceeding +- This applies to shell commands like `rm`, `rmdir`, and any write_file or bash call that would overwrite or destroy existing content +- Prefer moving or renaming over deleting when in doubt + +**Core Principle:** +Value careful execution, verified results, clear communication, and practical error recovery. Do not skip verification steps when a tool changes state or creates artifacts. The goal is not just to complete the task, but to complete it in a way that can be trusted. The following tools are available. Use them fully and never fake or skip a call. From 5951cff972e050e255e6233a1e18ff72d9a971e9 Mon Sep 17 00:00:00 2001 From: "rikulpatel@gmail.com" Date: Wed, 13 May 2026 17:22:51 -0500 Subject: [PATCH 46/84] refactor: removed dup logging line --- app/channels/message_queue.py | 1 - 1 file changed, 1 deletion(-) diff --git a/app/channels/message_queue.py b/app/channels/message_queue.py index d3772de..f8a9ebe 100755 --- a/app/channels/message_queue.py +++ b/app/channels/message_queue.py @@ -23,7 +23,6 @@ async def incoming_msg(self, message: IncomingMessage): await self.incoming.put(message) async def outgoing_msg(self, message: OutgoingMessage): - log.info(f"Queueing outgoing message for channel {message.channel}: {message.content}") await self.outgoing.put(message) async def process_outgoing(self): From 6fe1a0abd8d430d2709352122aad5024817be057 Mon Sep 17 00:00:00 2001 From: "rikulpatel@gmail.com" Date: Wed, 13 May 2026 17:54:36 -0500 Subject: [PATCH 47/84] small text change --- app/infra/startup.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/app/infra/startup.py b/app/infra/startup.py index 3c6f136..862a1d4 100755 --- a/app/infra/startup.py +++ b/app/infra/startup.py @@ -22,8 +22,8 @@ def load_system_context() -> str: system_context += f""" -## System Context -- datetime: {now.strftime("%Y-%m-%d %H:%M:%S")} {now.astimezone().tzname()} +## Current System Context +- Conversation started: {now.strftime("%Y-%m-%d %H:%M:%S")} {now.astimezone().tzname()} - day of week: {now.strftime("%A")} - os: {platform.system()} {platform.release()} - shell: {os.environ.get("SHELL", "unknown")} From 1c7d5447fa909f04458bfef7265dd514c84a622c Mon Sep 17 00:00:00 2001 From: "rikulpatel@gmail.com" Date: Wed, 13 May 2026 17:54:55 -0500 Subject: [PATCH 48/84] fix: fixed tests adding to real db --- tests/integration/test_cli.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/tests/integration/test_cli.py b/tests/integration/test_cli.py index 5d620ae..175a810 100644 --- a/tests/integration/test_cli.py +++ b/tests/integration/test_cli.py @@ -50,10 +50,12 @@ async def test_cli_with_simple_prompt(capsys): with patch("sys.argv", ["prog", "cli", "-p", "say hello", "--silent"]), \ patch("app.core.agent.Client") as MockClient, \ patch("app.cli.cli_agent.load_system_context", return_value=""), \ + patch("app.cli.cli_agent.MessageHistory") as MockHistory, \ patch("app.main.config.load"), \ patch.object(config_module, "_config", {"model": "test-model"}): MockClient.return_value.get_client.return_value = mock_openai + MockHistory.return_value.get_history.return_value = [] await main() finally: app_log.setLevel(original_log_level) From 59c3b1b111f418e20e01dd67c866767d37ccf662 Mon Sep 17 00:00:00 2001 From: "rikulpatel@gmail.com" Date: Wed, 13 May 2026 22:48:17 -0500 Subject: [PATCH 49/84] chore: add uv.lock, fix line endings, update Dockerfile and README for Discord - Track uv.lock (removed from .gitignore) so Docker builds are reproducible - Add eol=lf to .gitattributes for *.sh, *.py, Dockerfile to prevent \r line ending issues in Docker on Windows/WSL - Dockerfile: switch to debian:current, add chromium + Node.js/npm, set PUPPETEER_SKIP_CHROMIUM_DOWNLOAD and PUPPETEER_EXECUTABLE_PATH - README: add Discord to overview, config example, background agent section, and Docker env var table; remove Discord from roadmap Co-Authored-By: Claude Sonnet 4.6 --- .gitattributes | 5 + .gitignore | 1 - Dockerfile | 26 +- README.md | 37 +- uv.lock | 1322 ++++++++++++++++++++++++++++++++++++++++++++++++ 5 files changed, 1376 insertions(+), 15 deletions(-) create mode 100644 uv.lock diff --git a/.gitattributes b/.gitattributes index dfe0770..783f8be 100644 --- a/.gitattributes +++ b/.gitattributes @@ -1,2 +1,7 @@ # Auto detect text files and perform LF normalization * text=auto + +# Always LF for scripts and Python — \r breaks shebangs and Docker +*.sh text eol=lf +*.py text eol=lf +Dockerfile text eol=lf diff --git a/.gitignore b/.gitignore index be15167..a3b2b0a 100644 --- a/.gitignore +++ b/.gitignore @@ -172,7 +172,6 @@ cython_debug/ # PyPI configuration file .pypirc -uv.lock AGENTS.md PLAN.md .workspace diff --git a/Dockerfile b/Dockerfile index c41d941..65dc7ea 100644 --- a/Dockerfile +++ b/Dockerfile @@ -1,16 +1,27 @@ -FROM python:3.12-slim +FROM debian:current + +# apt dependencies for Python, SQLite, and common tools +RUN apt update && apt install -y --no-install-recommends \ + python3 python3-pip python3-venv \ + sqlite3 \ + curl ca-certificates \ + git \ + nodejs npm \ + chromium \ + && rm -rf /var/lib/apt/lists/* + +ENV PUPPETEER_SKIP_CHROMIUM_DOWNLOAD=true \ + PUPPETEER_EXECUTABLE_PATH=/usr/bin/chromium RUN pip install uv --no-cache-dir WORKDIR /app -# Dependency files first — this layer is cached unless deps change COPY pyproject.toml uv.lock ./ RUN uv sync --no-dev --frozen COPY app/ ./app/ -COPY run.sh . -COPY restart.sh . +COPY run.sh restart.sh ./ # Data dir for SQLite DB, workspace, and optional config.toml mount ENV ANOTHERBOT_HOME=/data @@ -23,8 +34,11 @@ ENV TELEGRAM_ALLOW_FROM="" ENV DISCORD_ALLOW_FROM="" # Secrets — pass at runtime only, never bake into the image: -# docker run -e LLM_API_KEY=... -e TELEGRAM_BOT_TOKEN=... -# docker run -e LLM_API_KEY=... -e DISCORD_BOT_TOKEN=... +# docker run -d \ +# -e LLM_API_KEY=sk-... \ +# -e DISCORD_BOT_TOKEN=your-discord-token \ +# -e DISCORD_ALLOW_FROM=123456789 \ +# -v ./anotherbot-data:/data \ # or: docker run --env-file .env CMD ["bash", "run.sh", "background"] diff --git a/README.md b/README.md index e66e6be..1f0cfda 100644 --- a/README.md +++ b/README.md @@ -5,6 +5,7 @@ A Python-based AI agent that can execute prompts, interact with the filesystem, - **Interactive CLI**: Multi-turn REPL sessions with tool use - **Background Agent**: Runs as a persistent bot, receiving and sending messages via channels - **Telegram Integration**: Built-in Telegram bot — receive messages, respond, run tools, deliver results +- **Discord Integration**: Discord bot — same agent loop, per-channel message isolation, owner DM fallback for scheduled tasks - **Scheduled Tasks**: SQLite-backed task scheduler — run prompts on a recurring or one-shot schedule and deliver results to a channel - **Tool Calling**: File I/O, shell commands, web fetch, web search (text/images/video/news/books), calculator, Hacker News, todo list - **Skills System**: Extendable skills in `app/skills/` (e.g., `puppeteer` for headless browsing) @@ -47,6 +48,10 @@ api_key = "" # fallback if LLM_API_KEY env var is not set [telegram] BOT_TOKEN = "" ALLOW_FROM = [] # List of allowed Telegram user IDs (integers). + +[discord] +TOKEN = "" +ALLOW_FROM = [] # List of allowed Discord user IDs (integers). Empty means allow all. ``` Message history is stored in `~/.crafterscode/history.db` (SQLite). Each channel maintains its own history with estimated token counts per message. @@ -77,23 +82,27 @@ Message history is stored in `~/.crafterscode/history.db` (SQLite). Each channel ./run.sh cli -p "Summarize this repo" -s ``` -### Background Agent (Telegram bot) +### Background Agent (Telegram / Discord) -Set your `BOT_TOKEN` in `~/.crafterscode/config.toml` and optionally restrict access by Telegram user ID: +Configure one or both channels in `~/.crafterscode/config.toml`: ```toml [telegram] BOT_TOKEN = "123456:ABC-your-bot-token" -ALLOW_FROM = [123456789] +ALLOW_FROM = [123456789] # restrict by user ID; empty = allow all + +[discord] +TOKEN = "your-discord-bot-token" +ALLOW_FROM = [] # restrict by user ID; empty = allow all ``` ```bash ./run.sh background ``` -The agent listens for Telegram messages, runs the agentic loop (including tool calls), and replies in the same chat. +Each channel gets its own message queue and agent. Scheduled task results are delivered to the channel the task was created from; if no context is available, the Discord bot owner is DM'd. -**Built-in commands:** `/help` — list commands; `/whoami` — show your Telegram user ID. +**Telegram commands:** `/help` — list commands; `/whoami` — show your Telegram user ID. ### Scheduled Tasks @@ -113,30 +122,42 @@ Tasks persist in `~/.crafterscode/app.db` (shared with message history) and surv ```bash docker build -t anotherbot . +# Telegram docker run -d \ -e LLM_API_KEY=sk-... \ -e TELEGRAM_BOT_TOKEN=123:abc... \ -e TELEGRAM_ALLOW_FROM=123456789 \ -v anotherbot-data:/data \ anotherbot + +# Discord +docker run -d \ + -e LLM_API_KEY=sk-... \ + -e DISCORD_BOT_TOKEN=your-discord-token \ + -e DISCORD_ALLOW_FROM=123456789 \ + -v anotherbot-data:/data \ + anotherbot ``` | Env var | Required | Description | |---|---|---| | `LLM_API_KEY` | yes | OpenRouter / OpenAI-compatible API key | -| `TELEGRAM_BOT_TOKEN` | yes | Telegram bot token from @BotFather | -| `TELEGRAM_ALLOW_FROM` | yes | Comma-separated Telegram user IDs allowed to message the bot | +| `TELEGRAM_BOT_TOKEN` | — | Telegram bot token from @BotFather | +| `TELEGRAM_ALLOW_FROM` | — | Comma-separated Telegram user IDs (empty = allow all) | +| `DISCORD_BOT_TOKEN` | — | Discord bot token from developer portal | +| `DISCORD_ALLOW_FROM` | — | Comma-separated Discord user IDs (empty = allow all) | | `LLM_BASE_URL` | no | API base URL (default: `https://openrouter.ai/api/v1`) | | `MODEL` | no | Model string (default: `deepseek/deepseek-v3.2`) | | `ANOTHERBOT_HOME` | no | Data directory for DB and workspace (default: `/data` in container) | +At least one channel (`TELEGRAM_BOT_TOKEN` or `DISCORD_BOT_TOKEN`) must be set. + The `/data` volume persists the SQLite database and workspace across restarts. To supply a `config.toml` instead of env vars, mount it at `/data/config.toml` — env vars always take precedence over the file. ## Roadmap - **Email Support**: IMAP/SMTP integration for reading and sending emails, attachment handling, and mailbox management - **MCP Support**: Integration with Model Context Protocol for external data sources, tools, and state management -- **Discord Integration**: Discord bot with slash commands, rich embeds, and channel permissions - **Slack Integration**: Slack app with interactive messages, modals, and workspace management - **WhatsApp Support**: WhatsApp Business API integration via providers like Twilio or MessageBird - **Anthropic OAuth**: Direct integration with Claude API using OAuth 2.0 diff --git a/uv.lock b/uv.lock new file mode 100644 index 0000000..f33ee6c --- /dev/null +++ b/uv.lock @@ -0,0 +1,1322 @@ +version = 1 +revision = 3 +requires-python = ">=3.12" +resolution-markers = [ + "python_full_version >= '3.14'", + "python_full_version == '3.13.*'", + "python_full_version < '3.13'", +] + +[[package]] +name = "aiohappyeyeballs" +version = "2.6.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/26/30/f84a107a9c4331c14b2b586036f40965c128aa4fee4dda5d3d51cb14ad54/aiohappyeyeballs-2.6.1.tar.gz", hash = "sha256:c3f9d0113123803ccadfdf3f0faa505bc78e6a72d1cc4806cbd719826e943558", size = 22760, upload-time = "2025-03-12T01:42:48.764Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0f/15/5bf3b99495fb160b63f95972b81750f18f7f4e02ad051373b669d17d44f2/aiohappyeyeballs-2.6.1-py3-none-any.whl", hash = "sha256:f349ba8f4b75cb25c99c5c2d84e997e485204d2902a9597802b0371f09331fb8", size = 15265, upload-time = "2025-03-12T01:42:47.083Z" }, +] + +[[package]] +name = "aiohttp" +version = "3.13.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "aiohappyeyeballs" }, + { name = "aiosignal" }, + { name = "attrs" }, + { name = "frozenlist" }, + { name = "multidict" }, + { name = "propcache" }, + { name = "yarl" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/77/9a/152096d4808df8e4268befa55fba462f440f14beab85e8ad9bf990516918/aiohttp-3.13.5.tar.gz", hash = "sha256:9d98cc980ecc96be6eb4c1994ce35d28d8b1f5e5208a23b421187d1209dbb7d1", size = 7858271, upload-time = "2026-03-31T22:01:03.343Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/be/6f/353954c29e7dcce7cf00280a02c75f30e133c00793c7a2ed3776d7b2f426/aiohttp-3.13.5-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:023ecba036ddd840b0b19bf195bfae970083fd7024ce1ac22e9bba90464620e9", size = 748876, upload-time = "2026-03-31T21:57:36.319Z" }, + { url = "https://files.pythonhosted.org/packages/f5/1b/428a7c64687b3b2e9cd293186695affc0e1e54a445d0361743b231f11066/aiohttp-3.13.5-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:15c933ad7920b7d9a20de151efcd05a6e38302cbf0e10c9b2acb9a42210a2416", size = 499557, upload-time = "2026-03-31T21:57:38.236Z" }, + { url = "https://files.pythonhosted.org/packages/29/47/7be41556bfbb6917069d6a6634bb7dd5e163ba445b783a90d40f5ac7e3a7/aiohttp-3.13.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ab2899f9fa2f9f741896ebb6fa07c4c883bfa5c7f2ddd8cf2aafa86fa981b2d2", size = 500258, upload-time = "2026-03-31T21:57:39.923Z" }, + { url = "https://files.pythonhosted.org/packages/67/84/c9ecc5828cb0b3695856c07c0a6817a99d51e2473400f705275a2b3d9239/aiohttp-3.13.5-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a60eaa2d440cd4707696b52e40ed3e2b0f73f65be07fd0ef23b6b539c9c0b0b4", size = 1749199, upload-time = "2026-03-31T21:57:41.938Z" }, + { url = "https://files.pythonhosted.org/packages/f0/d3/3c6d610e66b495657622edb6ae7c7fd31b2e9086b4ec50b47897ad6042a9/aiohttp-3.13.5-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:55b3bdd3292283295774ab585160c4004f4f2f203946997f49aac032c84649e9", size = 1721013, upload-time = "2026-03-31T21:57:43.904Z" }, + { url = "https://files.pythonhosted.org/packages/49/a0/24409c12217456df0bae7babe3b014e460b0b38a8e60753d6cb339f6556d/aiohttp-3.13.5-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c2b2355dc094e5f7d45a7bb262fe7207aa0460b37a0d87027dcf21b5d890e7d5", size = 1781501, upload-time = "2026-03-31T21:57:46.285Z" }, + { url = "https://files.pythonhosted.org/packages/98/9d/b65ec649adc5bccc008b0957a9a9c691070aeac4e41cea18559fef49958b/aiohttp-3.13.5-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b38765950832f7d728297689ad78f5f2cf79ff82487131c4d26fe6ceecdc5f8e", size = 1878981, upload-time = "2026-03-31T21:57:48.734Z" }, + { url = "https://files.pythonhosted.org/packages/57/d8/8d44036d7eb7b6a8ec4c5494ea0c8c8b94fbc0ed3991c1a7adf230df03bf/aiohttp-3.13.5-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b18f31b80d5a33661e08c89e202edabf1986e9b49c42b4504371daeaa11b47c1", size = 1767934, upload-time = "2026-03-31T21:57:51.171Z" }, + { url = "https://files.pythonhosted.org/packages/31/04/d3f8211f273356f158e3464e9e45484d3fb8c4ce5eb2f6fe9405c3273983/aiohttp-3.13.5-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:33add2463dde55c4f2d9635c6ab33ce154e5ecf322bd26d09af95c5f81cfa286", size = 1566671, upload-time = "2026-03-31T21:57:53.326Z" }, + { url = "https://files.pythonhosted.org/packages/41/db/073e4ebe00b78e2dfcacff734291651729a62953b48933d765dc513bf798/aiohttp-3.13.5-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:327cc432fdf1356fb4fbc6fe833ad4e9f6aacb71a8acaa5f1855e4b25910e4a9", size = 1705219, upload-time = "2026-03-31T21:57:55.385Z" }, + { url = "https://files.pythonhosted.org/packages/48/45/7dfba71a2f9fd97b15c95c06819de7eb38113d2cdb6319669195a7d64270/aiohttp-3.13.5-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:7c35b0bf0b48a70b4cb4fc5d7bed9b932532728e124874355de1a0af8ec4bc88", size = 1743049, upload-time = "2026-03-31T21:57:57.341Z" }, + { url = "https://files.pythonhosted.org/packages/18/71/901db0061e0f717d226386a7f471bb59b19566f2cae5f0d93874b017271f/aiohttp-3.13.5-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:df23d57718f24badef8656c49743e11a89fd6f5358fa8a7b96e728fda2abf7d3", size = 1749557, upload-time = "2026-03-31T21:57:59.626Z" }, + { url = "https://files.pythonhosted.org/packages/08/d5/41eebd16066e59cd43728fe74bce953d7402f2b4ddfdfef2c0e9f17ca274/aiohttp-3.13.5-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:02e048037a6501a5ec1f6fc9736135aec6eb8a004ce48838cb951c515f32c80b", size = 1558931, upload-time = "2026-03-31T21:58:01.972Z" }, + { url = "https://files.pythonhosted.org/packages/30/e6/4a799798bf05740e66c3a1161079bda7a3dd8e22ca392481d7a7f9af82a6/aiohttp-3.13.5-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:31cebae8b26f8a615d2b546fee45d5ffb76852ae6450e2a03f42c9102260d6fe", size = 1774125, upload-time = "2026-03-31T21:58:04.007Z" }, + { url = "https://files.pythonhosted.org/packages/84/63/7749337c90f92bc2cb18f9560d67aa6258c7060d1397d21529b8004fcf6f/aiohttp-3.13.5-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:888e78eb5ca55a615d285c3c09a7a91b42e9dd6fc699b166ebd5dee87c9ccf14", size = 1732427, upload-time = "2026-03-31T21:58:06.337Z" }, + { url = "https://files.pythonhosted.org/packages/98/de/cf2f44ff98d307e72fb97d5f5bbae3bfcb442f0ea9790c0bf5c5c2331404/aiohttp-3.13.5-cp312-cp312-win32.whl", hash = "sha256:8bd3ec6376e68a41f9f95f5ed170e2fcf22d4eb27a1f8cb361d0508f6e0557f3", size = 433534, upload-time = "2026-03-31T21:58:08.712Z" }, + { url = "https://files.pythonhosted.org/packages/aa/ca/eadf6f9c8fa5e31d40993e3db153fb5ed0b11008ad5d9de98a95045bed84/aiohttp-3.13.5-cp312-cp312-win_amd64.whl", hash = "sha256:110e448e02c729bcebb18c60b9214a87ba33bac4a9fa5e9a5f139938b56c6cb1", size = 460446, upload-time = "2026-03-31T21:58:10.945Z" }, + { url = "https://files.pythonhosted.org/packages/78/e9/d76bf503005709e390122d34e15256b88f7008e246c4bdbe915cd4f1adce/aiohttp-3.13.5-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:a5029cc80718bbd545123cd8fe5d15025eccaaaace5d0eeec6bd556ad6163d61", size = 742930, upload-time = "2026-03-31T21:58:13.155Z" }, + { url = "https://files.pythonhosted.org/packages/57/00/4b7b70223deaebd9bb85984d01a764b0d7bd6526fcdc73cca83bcbe7243e/aiohttp-3.13.5-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:4bb6bf5811620003614076bdc807ef3b5e38244f9d25ca5fe888eaccea2a9832", size = 496927, upload-time = "2026-03-31T21:58:15.073Z" }, + { url = "https://files.pythonhosted.org/packages/9c/f5/0fb20fb49f8efdcdce6cd8127604ad2c503e754a8f139f5e02b01626523f/aiohttp-3.13.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:a84792f8631bf5a94e52d9cc881c0b824ab42717165a5579c760b830d9392ac9", size = 497141, upload-time = "2026-03-31T21:58:17.009Z" }, + { url = "https://files.pythonhosted.org/packages/3b/86/b7c870053e36a94e8951b803cb5b909bfbc9b90ca941527f5fcafbf6b0fa/aiohttp-3.13.5-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:57653eac22c6a4c13eb22ecf4d673d64a12f266e72785ab1c8b8e5940d0e8090", size = 1732476, upload-time = "2026-03-31T21:58:18.925Z" }, + { url = "https://files.pythonhosted.org/packages/b5/e5/4e161f84f98d80c03a238671b4136e6530453d65262867d989bbe78244d0/aiohttp-3.13.5-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e5e5f7debc7a57af53fdf5c5009f9391d9f4c12867049d509bf7bb164a6e295b", size = 1706507, upload-time = "2026-03-31T21:58:21.094Z" }, + { url = "https://files.pythonhosted.org/packages/d4/56/ea11a9f01518bd5a2a2fcee869d248c4b8a0cfa0bb13401574fa31adf4d4/aiohttp-3.13.5-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c719f65bebcdf6716f10e9eff80d27567f7892d8988c06de12bbbd39307c6e3a", size = 1773465, upload-time = "2026-03-31T21:58:23.159Z" }, + { url = "https://files.pythonhosted.org/packages/eb/40/333ca27fb74b0383f17c90570c748f7582501507307350a79d9f9f3c6eb1/aiohttp-3.13.5-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d97f93fdae594d886c5a866636397e2bcab146fd7a132fd6bb9ce182224452f8", size = 1873523, upload-time = "2026-03-31T21:58:25.59Z" }, + { url = "https://files.pythonhosted.org/packages/f0/d2/e2f77eef1acb7111405433c707dc735e63f67a56e176e72e9e7a2cd3f493/aiohttp-3.13.5-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3df334e39d4c2f899a914f1dba283c1aadc311790733f705182998c6f7cae665", size = 1754113, upload-time = "2026-03-31T21:58:27.624Z" }, + { url = "https://files.pythonhosted.org/packages/fb/56/3f653d7f53c89669301ec9e42c95233e2a0c0a6dd051269e6e678db4fdb0/aiohttp-3.13.5-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:fe6970addfea9e5e081401bcbadf865d2b6da045472f58af08427e108d618540", size = 1562351, upload-time = "2026-03-31T21:58:29.918Z" }, + { url = "https://files.pythonhosted.org/packages/ec/a6/9b3e91eb8ae791cce4ee736da02211c85c6f835f1bdfac0594a8a3b7018c/aiohttp-3.13.5-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:7becdf835feff2f4f335d7477f121af787e3504b48b449ff737afb35869ba7bb", size = 1693205, upload-time = "2026-03-31T21:58:32.214Z" }, + { url = "https://files.pythonhosted.org/packages/98/fc/bfb437a99a2fcebd6b6eaec609571954de2ed424f01c352f4b5504371dd3/aiohttp-3.13.5-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:676e5651705ad5d8a70aeb8eb6936c436d8ebbd56e63436cb7dd9bb36d2a9a46", size = 1730618, upload-time = "2026-03-31T21:58:34.728Z" }, + { url = "https://files.pythonhosted.org/packages/e4/b6/c8534862126191a034f68153194c389addc285a0f1347d85096d349bbc15/aiohttp-3.13.5-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:9b16c653d38eb1a611cc898c41e76859ca27f119d25b53c12875fd0474ae31a8", size = 1745185, upload-time = "2026-03-31T21:58:36.909Z" }, + { url = "https://files.pythonhosted.org/packages/0b/93/4ca8ee2ef5236e2707e0fd5fecb10ce214aee1ff4ab307af9c558bda3b37/aiohttp-3.13.5-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:999802d5fa0389f58decd24b537c54aa63c01c3219ce17d1214cbda3c2b22d2d", size = 1557311, upload-time = "2026-03-31T21:58:39.38Z" }, + { url = "https://files.pythonhosted.org/packages/57/ae/76177b15f18c5f5d094f19901d284025db28eccc5ae374d1d254181d33f4/aiohttp-3.13.5-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:ec707059ee75732b1ba130ed5f9580fe10ff75180c812bc267ded039db5128c6", size = 1773147, upload-time = "2026-03-31T21:58:41.476Z" }, + { url = "https://files.pythonhosted.org/packages/01/a4/62f05a0a98d88af59d93b7fcac564e5f18f513cb7471696ac286db970d6a/aiohttp-3.13.5-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:2d6d44a5b48132053c2f6cd5c8cb14bc67e99a63594e336b0f2af81e94d5530c", size = 1730356, upload-time = "2026-03-31T21:58:44.049Z" }, + { url = "https://files.pythonhosted.org/packages/e4/85/fc8601f59dfa8c9523808281f2da571f8b4699685f9809a228adcc90838d/aiohttp-3.13.5-cp313-cp313-win32.whl", hash = "sha256:329f292ed14d38a6c4c435e465f48bebb47479fd676a0411936cc371643225cc", size = 432637, upload-time = "2026-03-31T21:58:46.167Z" }, + { url = "https://files.pythonhosted.org/packages/c0/1b/ac685a8882896acf0f6b31d689e3792199cfe7aba37969fa91da63a7fa27/aiohttp-3.13.5-cp313-cp313-win_amd64.whl", hash = "sha256:69f571de7500e0557801c0b51f4780482c0ec5fe2ac851af5a92cfce1af1cb83", size = 458896, upload-time = "2026-03-31T21:58:48.119Z" }, + { url = "https://files.pythonhosted.org/packages/5d/ce/46572759afc859e867a5bc8ec3487315869013f59281ce61764f76d879de/aiohttp-3.13.5-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:eb4639f32fd4a9904ab8fb45bf3383ba71137f3d9d4ba25b3b3f3109977c5b8c", size = 745721, upload-time = "2026-03-31T21:58:50.229Z" }, + { url = "https://files.pythonhosted.org/packages/13/fe/8a2efd7626dbe6049b2ef8ace18ffda8a4dfcbe1bcff3ac30c0c7575c20b/aiohttp-3.13.5-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:7e5dc4311bd5ac493886c63cbf76ab579dbe4641268e7c74e48e774c74b6f2be", size = 497663, upload-time = "2026-03-31T21:58:52.232Z" }, + { url = "https://files.pythonhosted.org/packages/9b/91/cc8cc78a111826c54743d88651e1687008133c37e5ee615fee9b57990fac/aiohttp-3.13.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:756c3c304d394977519824449600adaf2be0ccee76d206ee339c5e76b70ded25", size = 499094, upload-time = "2026-03-31T21:58:54.566Z" }, + { url = "https://files.pythonhosted.org/packages/0a/33/a8362cb15cf16a3af7e86ed11962d5cd7d59b449202dc576cdc731310bde/aiohttp-3.13.5-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ecc26751323224cf8186efcf7fbcbc30f4e1d8c7970659daf25ad995e4032a56", size = 1726701, upload-time = "2026-03-31T21:58:56.864Z" }, + { url = "https://files.pythonhosted.org/packages/45/0c/c091ac5c3a17114bd76cbf85d674650969ddf93387876cf67f754204bd77/aiohttp-3.13.5-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:10a75acfcf794edf9d8db50e5a7ec5fc818b2a8d3f591ce93bc7b1210df016d2", size = 1683360, upload-time = "2026-03-31T21:58:59.072Z" }, + { url = "https://files.pythonhosted.org/packages/23/73/bcee1c2b79bc275e964d1446c55c54441a461938e70267c86afaae6fba27/aiohttp-3.13.5-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:0f7a18f258d124cd678c5fe072fe4432a4d5232b0657fca7c1847f599233c83a", size = 1773023, upload-time = "2026-03-31T21:59:01.776Z" }, + { url = "https://files.pythonhosted.org/packages/c7/ef/720e639df03004fee2d869f771799d8c23046dec47d5b81e396c7cda583a/aiohttp-3.13.5-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:df6104c009713d3a89621096f3e3e88cc323fd269dbd7c20afe18535094320be", size = 1853795, upload-time = "2026-03-31T21:59:04.568Z" }, + { url = "https://files.pythonhosted.org/packages/bd/c9/989f4034fb46841208de7aeeac2c6d8300745ab4f28c42f629ba77c2d916/aiohttp-3.13.5-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:241a94f7de7c0c3b616627aaad530fe2cb620084a8b144d3be7b6ecfe95bae3b", size = 1730405, upload-time = "2026-03-31T21:59:07.221Z" }, + { url = "https://files.pythonhosted.org/packages/ce/75/ee1fd286ca7dc599d824b5651dad7b3be7ff8d9a7e7b3fe9820d9180f7db/aiohttp-3.13.5-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c974fb66180e58709b6fc402846f13791240d180b74de81d23913abe48e96d94", size = 1558082, upload-time = "2026-03-31T21:59:09.484Z" }, + { url = "https://files.pythonhosted.org/packages/c3/20/1e9e6650dfc436340116b7aa89ff8cb2bbdf0abc11dfaceaad8f74273a10/aiohttp-3.13.5-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:6e27ea05d184afac78aabbac667450c75e54e35f62238d44463131bd3f96753d", size = 1692346, upload-time = "2026-03-31T21:59:12.068Z" }, + { url = "https://files.pythonhosted.org/packages/d8/40/8ebc6658d48ea630ac7903912fe0dd4e262f0e16825aa4c833c56c9f1f56/aiohttp-3.13.5-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:a79a6d399cef33a11b6f004c67bb07741d91f2be01b8d712d52c75711b1e07c7", size = 1698891, upload-time = "2026-03-31T21:59:14.552Z" }, + { url = "https://files.pythonhosted.org/packages/d8/78/ea0ae5ec8ba7a5c10bdd6e318f1ba5e76fcde17db8275188772afc7917a4/aiohttp-3.13.5-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:c632ce9c0b534fbe25b52c974515ed674937c5b99f549a92127c85f771a78772", size = 1742113, upload-time = "2026-03-31T21:59:17.068Z" }, + { url = "https://files.pythonhosted.org/packages/8a/66/9d308ed71e3f2491be1acb8769d96c6f0c47d92099f3bc9119cada27b357/aiohttp-3.13.5-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:fceedde51fbd67ee2bcc8c0b33d0126cc8b51ef3bbde2f86662bd6d5a6f10ec5", size = 1553088, upload-time = "2026-03-31T21:59:19.541Z" }, + { url = "https://files.pythonhosted.org/packages/da/a6/6cc25ed8dfc6e00c90f5c6d126a98e2cf28957ad06fa1036bd34b6f24a2c/aiohttp-3.13.5-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:f92995dfec9420bb69ae629abf422e516923ba79ba4403bc750d94fb4a6c68c1", size = 1757976, upload-time = "2026-03-31T21:59:22.311Z" }, + { url = "https://files.pythonhosted.org/packages/c1/2b/cce5b0ffe0de99c83e5e36d8f828e4161e415660a9f3e58339d07cce3006/aiohttp-3.13.5-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:20ae0ff08b1f2c8788d6fb85afcb798654ae6ba0b747575f8562de738078457b", size = 1712444, upload-time = "2026-03-31T21:59:24.635Z" }, + { url = "https://files.pythonhosted.org/packages/6c/cf/9e1795b4160c58d29421eafd1a69c6ce351e2f7c8d3c6b7e4ca44aea1a5b/aiohttp-3.13.5-cp314-cp314-win32.whl", hash = "sha256:b20df693de16f42b2472a9c485e1c948ee55524786a0a34345511afdd22246f3", size = 438128, upload-time = "2026-03-31T21:59:27.291Z" }, + { url = "https://files.pythonhosted.org/packages/22/4d/eaedff67fc805aeba4ba746aec891b4b24cebb1a7d078084b6300f79d063/aiohttp-3.13.5-cp314-cp314-win_amd64.whl", hash = "sha256:f85c6f327bf0b8c29da7d93b1cabb6363fb5e4e160a32fa241ed2dce21b73162", size = 464029, upload-time = "2026-03-31T21:59:29.429Z" }, + { url = "https://files.pythonhosted.org/packages/79/11/c27d9332ee20d68dd164dc12a6ecdef2e2e35ecc97ed6cf0d2442844624b/aiohttp-3.13.5-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:1efb06900858bb618ff5cee184ae2de5828896c448403d51fb633f09e109be0a", size = 778758, upload-time = "2026-03-31T21:59:31.547Z" }, + { url = "https://files.pythonhosted.org/packages/04/fb/377aead2e0a3ba5f09b7624f702a964bdf4f08b5b6728a9799830c80041e/aiohttp-3.13.5-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:fee86b7c4bd29bdaf0d53d14739b08a106fdda809ca5fe032a15f52fae5fe254", size = 512883, upload-time = "2026-03-31T21:59:34.098Z" }, + { url = "https://files.pythonhosted.org/packages/bb/a6/aa109a33671f7a5d3bd78b46da9d852797c5e665bfda7d6b373f56bff2ec/aiohttp-3.13.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:20058e23909b9e65f9da62b396b77dfa95965cbe840f8def6e572538b1d32e36", size = 516668, upload-time = "2026-03-31T21:59:36.497Z" }, + { url = "https://files.pythonhosted.org/packages/79/b3/ca078f9f2fa9563c36fb8ef89053ea2bb146d6f792c5104574d49d8acb63/aiohttp-3.13.5-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8cf20a8d6868cb15a73cab329ffc07291ba8c22b1b88176026106ae39aa6df0f", size = 1883461, upload-time = "2026-03-31T21:59:38.723Z" }, + { url = "https://files.pythonhosted.org/packages/b7/e3/a7ad633ca1ca497b852233a3cce6906a56c3225fb6d9217b5e5e60b7419d/aiohttp-3.13.5-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:330f5da04c987f1d5bdb8ae189137c77139f36bd1cb23779ca1a354a4b027800", size = 1747661, upload-time = "2026-03-31T21:59:41.187Z" }, + { url = "https://files.pythonhosted.org/packages/33/b9/cd6fe579bed34a906d3d783fe60f2fa297ef55b27bb4538438ee49d4dc41/aiohttp-3.13.5-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6f1cbf0c7926d315c3c26c2da41fd2b5d2fe01ac0e157b78caefc51a782196cf", size = 1863800, upload-time = "2026-03-31T21:59:43.84Z" }, + { url = "https://files.pythonhosted.org/packages/c0/3f/2c1e2f5144cefa889c8afd5cf431994c32f3b29da9961698ff4e3811b79a/aiohttp-3.13.5-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:53fc049ed6390d05423ba33103ded7281fe897cf97878f369a527070bd95795b", size = 1958382, upload-time = "2026-03-31T21:59:46.187Z" }, + { url = "https://files.pythonhosted.org/packages/66/1d/f31ec3f1013723b3babe3609e7f119c2c2fb6ef33da90061a705ef3e1bc8/aiohttp-3.13.5-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:898703aa2667e3c5ca4c54ca36cd73f58b7a38ef87a5606414799ebce4d3fd3a", size = 1803724, upload-time = "2026-03-31T21:59:48.656Z" }, + { url = "https://files.pythonhosted.org/packages/0e/b4/57712dfc6f1542f067daa81eb61da282fab3e6f1966fca25db06c4fc62d5/aiohttp-3.13.5-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0494a01ca9584eea1e5fbd6d748e61ecff218c51b576ee1999c23db7066417d8", size = 1640027, upload-time = "2026-03-31T21:59:51.284Z" }, + { url = "https://files.pythonhosted.org/packages/25/3c/734c878fb43ec083d8e31bf029daae1beafeae582d1b35da234739e82ee7/aiohttp-3.13.5-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:6cf81fe010b8c17b09495cbd15c1d35afbc8fb405c0c9cf4738e5ae3af1d65be", size = 1806644, upload-time = "2026-03-31T21:59:53.753Z" }, + { url = "https://files.pythonhosted.org/packages/20/a5/f671e5cbec1c21d044ff3078223f949748f3a7f86b14e34a365d74a5d21f/aiohttp-3.13.5-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:c564dd5f09ddc9d8f2c2d0a301cd30a79a2cc1b46dd1a73bef8f0038863d016b", size = 1791630, upload-time = "2026-03-31T21:59:56.239Z" }, + { url = "https://files.pythonhosted.org/packages/0b/63/fb8d0ad63a0b8a99be97deac8c04dacf0785721c158bdf23d679a87aa99e/aiohttp-3.13.5-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:2994be9f6e51046c4f864598fd9abeb4fba6e88f0b2152422c9666dcd4aea9c6", size = 1809403, upload-time = "2026-03-31T21:59:59.103Z" }, + { url = "https://files.pythonhosted.org/packages/59/0c/bfed7f30662fcf12206481c2aac57dedee43fe1c49275e85b3a1e1742294/aiohttp-3.13.5-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:157826e2fa245d2ef46c83ea8a5faf77ca19355d278d425c29fda0beb3318037", size = 1634924, upload-time = "2026-03-31T22:00:02.116Z" }, + { url = "https://files.pythonhosted.org/packages/17/d6/fd518d668a09fd5a3319ae5e984d4d80b9a4b3df4e21c52f02251ef5a32e/aiohttp-3.13.5-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:a8aca50daa9493e9e13c0f566201a9006f080e7c50e5e90d0b06f53146a54500", size = 1836119, upload-time = "2026-03-31T22:00:04.756Z" }, + { url = "https://files.pythonhosted.org/packages/78/b7/15fb7a9d52e112a25b621c67b69c167805cb1f2ab8f1708a5c490d1b52fe/aiohttp-3.13.5-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:3b13560160d07e047a93f23aaa30718606493036253d5430887514715b67c9d9", size = 1772072, upload-time = "2026-03-31T22:00:07.494Z" }, + { url = "https://files.pythonhosted.org/packages/7e/df/57ba7f0c4a553fc2bd8b6321df236870ec6fd64a2a473a8a13d4f733214e/aiohttp-3.13.5-cp314-cp314t-win32.whl", hash = "sha256:9a0f4474b6ea6818b41f82172d799e4b3d29e22c2c520ce4357856fced9af2f8", size = 471819, upload-time = "2026-03-31T22:00:10.277Z" }, + { url = "https://files.pythonhosted.org/packages/62/29/2f8418269e46454a26171bfdd6a055d74febf32234e474930f2f60a17145/aiohttp-3.13.5-cp314-cp314t-win_amd64.whl", hash = "sha256:18a2f6c1182c51baa1d28d68fea51513cb2a76612f038853c0ad3c145423d3d9", size = 505441, upload-time = "2026-03-31T22:00:12.791Z" }, +] + +[[package]] +name = "aiosignal" +version = "1.4.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "frozenlist" }, + { name = "typing-extensions", marker = "python_full_version < '3.13'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/61/62/06741b579156360248d1ec624842ad0edf697050bbaf7c3e46394e106ad1/aiosignal-1.4.0.tar.gz", hash = "sha256:f47eecd9468083c2029cc99945502cb7708b082c232f9aca65da147157b251c7", size = 25007, upload-time = "2025-07-03T22:54:43.528Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fb/76/641ae371508676492379f16e2fa48f4e2c11741bd63c48be4b12a6b09cba/aiosignal-1.4.0-py3-none-any.whl", hash = "sha256:053243f8b92b990551949e63930a839ff0cf0b0ebbe0597b0f3fb19e1a0fe82e", size = 7490, upload-time = "2025-07-03T22:54:42.156Z" }, +] + +[[package]] +name = "annotated-types" +version = "0.7.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89", size = 16081, upload-time = "2024-05-20T21:33:25.928Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53", size = 13643, upload-time = "2024-05-20T21:33:24.1Z" }, +] + +[[package]] +name = "anyio" +version = "4.12.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "idna" }, + { name = "typing-extensions", marker = "python_full_version < '3.13'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/96/f0/5eb65b2bb0d09ac6776f2eb54adee6abe8228ea05b20a5ad0e4945de8aac/anyio-4.12.1.tar.gz", hash = "sha256:41cfcc3a4c85d3f05c932da7c26d0201ac36f72abd4435ba90d0464a3ffed703", size = 228685, upload-time = "2026-01-06T11:45:21.246Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/38/0e/27be9fdef66e72d64c0cdc3cc2823101b80585f8119b5c112c2e8f5f7dab/anyio-4.12.1-py3-none-any.whl", hash = "sha256:d405828884fc140aa80a3c667b8beed277f1dfedec42ba031bd6ac3db606ab6c", size = 113592, upload-time = "2026-01-06T11:45:19.497Z" }, +] + +[[package]] +name = "attrs" +version = "26.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/9a/8e/82a0fe20a541c03148528be8cac2408564a6c9a0cc7e9171802bc1d26985/attrs-26.1.0.tar.gz", hash = "sha256:d03ceb89cb322a8fd706d4fb91940737b6642aa36998fe130a9bc96c985eff32", size = 952055, upload-time = "2026-03-19T14:22:25.026Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/64/b4/17d4b0b2a2dc85a6df63d1157e028ed19f90d4cd97c36717afef2bc2f395/attrs-26.1.0-py3-none-any.whl", hash = "sha256:c647aa4a12dfbad9333ca4e71fe62ddc36f4e63b2d260a37a8b83d2f043ac309", size = 67548, upload-time = "2026-03-19T14:22:23.645Z" }, +] + +[[package]] +name = "audioop-lts" +version = "0.2.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/38/53/946db57842a50b2da2e0c1e34bd37f36f5aadba1a929a3971c5d7841dbca/audioop_lts-0.2.2.tar.gz", hash = "sha256:64d0c62d88e67b98a1a5e71987b7aa7b5bcffc7dcee65b635823dbdd0a8dbbd0", size = 30686, upload-time = "2025-08-05T16:43:17.409Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/de/d4/94d277ca941de5a507b07f0b592f199c22454eeaec8f008a286b3fbbacd6/audioop_lts-0.2.2-cp313-abi3-macosx_10_13_universal2.whl", hash = "sha256:fd3d4602dc64914d462924a08c1a9816435a2155d74f325853c1f1ac3b2d9800", size = 46523, upload-time = "2025-08-05T16:42:20.836Z" }, + { url = "https://files.pythonhosted.org/packages/f8/5a/656d1c2da4b555920ce4177167bfeb8623d98765594af59702c8873f60ec/audioop_lts-0.2.2-cp313-abi3-macosx_10_13_x86_64.whl", hash = "sha256:550c114a8df0aafe9a05442a1162dfc8fec37e9af1d625ae6060fed6e756f303", size = 27455, upload-time = "2025-08-05T16:42:22.283Z" }, + { url = "https://files.pythonhosted.org/packages/1b/83/ea581e364ce7b0d41456fb79d6ee0ad482beda61faf0cab20cbd4c63a541/audioop_lts-0.2.2-cp313-abi3-macosx_11_0_arm64.whl", hash = "sha256:9a13dc409f2564de15dd68be65b462ba0dde01b19663720c68c1140c782d1d75", size = 26997, upload-time = "2025-08-05T16:42:23.849Z" }, + { url = "https://files.pythonhosted.org/packages/b8/3b/e8964210b5e216e5041593b7d33e97ee65967f17c282e8510d19c666dab4/audioop_lts-0.2.2-cp313-abi3-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:51c916108c56aa6e426ce611946f901badac950ee2ddaf302b7ed35d9958970d", size = 85844, upload-time = "2025-08-05T16:42:25.208Z" }, + { url = "https://files.pythonhosted.org/packages/c7/2e/0a1c52faf10d51def20531a59ce4c706cb7952323b11709e10de324d6493/audioop_lts-0.2.2-cp313-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:47eba38322370347b1c47024defbd36374a211e8dd5b0dcbce7b34fdb6f8847b", size = 85056, upload-time = "2025-08-05T16:42:26.559Z" }, + { url = "https://files.pythonhosted.org/packages/75/e8/cd95eef479656cb75ab05dfece8c1f8c395d17a7c651d88f8e6e291a63ab/audioop_lts-0.2.2-cp313-abi3-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ba7c3a7e5f23e215cb271516197030c32aef2e754252c4c70a50aaff7031a2c8", size = 93892, upload-time = "2025-08-05T16:42:27.902Z" }, + { url = "https://files.pythonhosted.org/packages/5c/1e/a0c42570b74f83efa5cca34905b3eef03f7ab09fe5637015df538a7f3345/audioop_lts-0.2.2-cp313-abi3-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:def246fe9e180626731b26e89816e79aae2276f825420a07b4a647abaa84becc", size = 96660, upload-time = "2025-08-05T16:42:28.9Z" }, + { url = "https://files.pythonhosted.org/packages/50/d5/8a0ae607ca07dbb34027bac8db805498ee7bfecc05fd2c148cc1ed7646e7/audioop_lts-0.2.2-cp313-abi3-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e160bf9df356d841bb6c180eeeea1834085464626dc1b68fa4e1d59070affdc3", size = 79143, upload-time = "2025-08-05T16:42:29.929Z" }, + { url = "https://files.pythonhosted.org/packages/12/17/0d28c46179e7910bfb0bb62760ccb33edb5de973052cb2230b662c14ca2e/audioop_lts-0.2.2-cp313-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:4b4cd51a57b698b2d06cb9993b7ac8dfe89a3b2878e96bc7948e9f19ff51dba6", size = 84313, upload-time = "2025-08-05T16:42:30.949Z" }, + { url = "https://files.pythonhosted.org/packages/84/ba/bd5d3806641564f2024e97ca98ea8f8811d4e01d9b9f9831474bc9e14f9e/audioop_lts-0.2.2-cp313-abi3-musllinux_1_2_ppc64le.whl", hash = "sha256:4a53aa7c16a60a6857e6b0b165261436396ef7293f8b5c9c828a3a203147ed4a", size = 93044, upload-time = "2025-08-05T16:42:31.959Z" }, + { url = "https://files.pythonhosted.org/packages/f9/5e/435ce8d5642f1f7679540d1e73c1c42d933331c0976eb397d1717d7f01a3/audioop_lts-0.2.2-cp313-abi3-musllinux_1_2_riscv64.whl", hash = "sha256:3fc38008969796f0f689f1453722a0f463da1b8a6fbee11987830bfbb664f623", size = 78766, upload-time = "2025-08-05T16:42:33.302Z" }, + { url = "https://files.pythonhosted.org/packages/ae/3b/b909e76b606cbfd53875693ec8c156e93e15a1366a012f0b7e4fb52d3c34/audioop_lts-0.2.2-cp313-abi3-musllinux_1_2_s390x.whl", hash = "sha256:15ab25dd3e620790f40e9ead897f91e79c0d3ce65fe193c8ed6c26cffdd24be7", size = 87640, upload-time = "2025-08-05T16:42:34.854Z" }, + { url = "https://files.pythonhosted.org/packages/30/e7/8f1603b4572d79b775f2140d7952f200f5e6c62904585d08a01f0a70393a/audioop_lts-0.2.2-cp313-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:03f061a1915538fd96272bac9551841859dbb2e3bf73ebe4a23ef043766f5449", size = 86052, upload-time = "2025-08-05T16:42:35.839Z" }, + { url = "https://files.pythonhosted.org/packages/b5/96/c37846df657ccdda62ba1ae2b6534fa90e2e1b1742ca8dcf8ebd38c53801/audioop_lts-0.2.2-cp313-abi3-win32.whl", hash = "sha256:3bcddaaf6cc5935a300a8387c99f7a7fbbe212a11568ec6cf6e4bc458c048636", size = 26185, upload-time = "2025-08-05T16:42:37.04Z" }, + { url = "https://files.pythonhosted.org/packages/34/a5/9d78fdb5b844a83da8a71226c7bdae7cc638861085fff7a1d707cb4823fa/audioop_lts-0.2.2-cp313-abi3-win_amd64.whl", hash = "sha256:a2c2a947fae7d1062ef08c4e369e0ba2086049a5e598fda41122535557012e9e", size = 30503, upload-time = "2025-08-05T16:42:38.427Z" }, + { url = "https://files.pythonhosted.org/packages/34/25/20d8fde083123e90c61b51afb547bb0ea7e77bab50d98c0ab243d02a0e43/audioop_lts-0.2.2-cp313-abi3-win_arm64.whl", hash = "sha256:5f93a5db13927a37d2d09637ccca4b2b6b48c19cd9eda7b17a2e9f77edee6a6f", size = 24173, upload-time = "2025-08-05T16:42:39.704Z" }, + { url = "https://files.pythonhosted.org/packages/58/a7/0a764f77b5c4ac58dc13c01a580f5d32ae8c74c92020b961556a43e26d02/audioop_lts-0.2.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:73f80bf4cd5d2ca7814da30a120de1f9408ee0619cc75da87d0641273d202a09", size = 47096, upload-time = "2025-08-05T16:42:40.684Z" }, + { url = "https://files.pythonhosted.org/packages/aa/ed/ebebedde1a18848b085ad0fa54b66ceb95f1f94a3fc04f1cd1b5ccb0ed42/audioop_lts-0.2.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:106753a83a25ee4d6f473f2be6b0966fc1c9af7e0017192f5531a3e7463dce58", size = 27748, upload-time = "2025-08-05T16:42:41.992Z" }, + { url = "https://files.pythonhosted.org/packages/cb/6e/11ca8c21af79f15dbb1c7f8017952ee8c810c438ce4e2b25638dfef2b02c/audioop_lts-0.2.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:fbdd522624141e40948ab3e8cdae6e04c748d78710e9f0f8d4dae2750831de19", size = 27329, upload-time = "2025-08-05T16:42:42.987Z" }, + { url = "https://files.pythonhosted.org/packages/84/52/0022f93d56d85eec5da6b9da6a958a1ef09e80c39f2cc0a590c6af81dcbb/audioop_lts-0.2.2-cp313-cp313t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:143fad0311e8209ece30a8dbddab3b65ab419cbe8c0dde6e8828da25999be911", size = 92407, upload-time = "2025-08-05T16:42:44.336Z" }, + { url = "https://files.pythonhosted.org/packages/87/1d/48a889855e67be8718adbc7a01f3c01d5743c325453a5e81cf3717664aad/audioop_lts-0.2.2-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:dfbbc74ec68a0fd08cfec1f4b5e8cca3d3cd7de5501b01c4b5d209995033cde9", size = 91811, upload-time = "2025-08-05T16:42:45.325Z" }, + { url = "https://files.pythonhosted.org/packages/98/a6/94b7213190e8077547ffae75e13ed05edc488653c85aa5c41472c297d295/audioop_lts-0.2.2-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:cfcac6aa6f42397471e4943e0feb2244549db5c5d01efcd02725b96af417f3fe", size = 100470, upload-time = "2025-08-05T16:42:46.468Z" }, + { url = "https://files.pythonhosted.org/packages/e9/e9/78450d7cb921ede0cfc33426d3a8023a3bda755883c95c868ee36db8d48d/audioop_lts-0.2.2-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:752d76472d9804ac60f0078c79cdae8b956f293177acd2316cd1e15149aee132", size = 103878, upload-time = "2025-08-05T16:42:47.576Z" }, + { url = "https://files.pythonhosted.org/packages/4f/e2/cd5439aad4f3e34ae1ee852025dc6aa8f67a82b97641e390bf7bd9891d3e/audioop_lts-0.2.2-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:83c381767e2cc10e93e40281a04852facc4cd9334550e0f392f72d1c0a9c5753", size = 84867, upload-time = "2025-08-05T16:42:49.003Z" }, + { url = "https://files.pythonhosted.org/packages/68/4b/9d853e9076c43ebba0d411e8d2aa19061083349ac695a7d082540bad64d0/audioop_lts-0.2.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:c0022283e9556e0f3643b7c3c03f05063ca72b3063291834cca43234f20c60bb", size = 90001, upload-time = "2025-08-05T16:42:50.038Z" }, + { url = "https://files.pythonhosted.org/packages/58/26/4bae7f9d2f116ed5593989d0e521d679b0d583973d203384679323d8fa85/audioop_lts-0.2.2-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:a2d4f1513d63c795e82948e1305f31a6d530626e5f9f2605408b300ae6095093", size = 99046, upload-time = "2025-08-05T16:42:51.111Z" }, + { url = "https://files.pythonhosted.org/packages/b2/67/a9f4fb3e250dda9e9046f8866e9fa7d52664f8985e445c6b4ad6dfb55641/audioop_lts-0.2.2-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:c9c8e68d8b4a56fda8c025e538e639f8c5953f5073886b596c93ec9b620055e7", size = 84788, upload-time = "2025-08-05T16:42:52.198Z" }, + { url = "https://files.pythonhosted.org/packages/70/f7/3de86562db0121956148bcb0fe5b506615e3bcf6e63c4357a612b910765a/audioop_lts-0.2.2-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:96f19de485a2925314f5020e85911fb447ff5fbef56e8c7c6927851b95533a1c", size = 94472, upload-time = "2025-08-05T16:42:53.59Z" }, + { url = "https://files.pythonhosted.org/packages/f1/32/fd772bf9078ae1001207d2df1eef3da05bea611a87dd0e8217989b2848fa/audioop_lts-0.2.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:e541c3ef484852ef36545f66209444c48b28661e864ccadb29daddb6a4b8e5f5", size = 92279, upload-time = "2025-08-05T16:42:54.632Z" }, + { url = "https://files.pythonhosted.org/packages/4f/41/affea7181592ab0ab560044632571a38edaf9130b84928177823fbf3176a/audioop_lts-0.2.2-cp313-cp313t-win32.whl", hash = "sha256:d5e73fa573e273e4f2e5ff96f9043858a5e9311e94ffefd88a3186a910c70917", size = 26568, upload-time = "2025-08-05T16:42:55.627Z" }, + { url = "https://files.pythonhosted.org/packages/28/2b/0372842877016641db8fc54d5c88596b542eec2f8f6c20a36fb6612bf9ee/audioop_lts-0.2.2-cp313-cp313t-win_amd64.whl", hash = "sha256:9191d68659eda01e448188f60364c7763a7ca6653ed3f87ebb165822153a8547", size = 30942, upload-time = "2025-08-05T16:42:56.674Z" }, + { url = "https://files.pythonhosted.org/packages/ee/ca/baf2b9cc7e96c179bb4a54f30fcd83e6ecb340031bde68f486403f943768/audioop_lts-0.2.2-cp313-cp313t-win_arm64.whl", hash = "sha256:c174e322bb5783c099aaf87faeb240c8d210686b04bd61dfd05a8e5a83d88969", size = 24603, upload-time = "2025-08-05T16:42:57.571Z" }, + { url = "https://files.pythonhosted.org/packages/5c/73/413b5a2804091e2c7d5def1d618e4837f1cb82464e230f827226278556b7/audioop_lts-0.2.2-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:f9ee9b52f5f857fbaf9d605a360884f034c92c1c23021fb90b2e39b8e64bede6", size = 47104, upload-time = "2025-08-05T16:42:58.518Z" }, + { url = "https://files.pythonhosted.org/packages/ae/8c/daa3308dc6593944410c2c68306a5e217f5c05b70a12e70228e7dd42dc5c/audioop_lts-0.2.2-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:49ee1a41738a23e98d98b937a0638357a2477bc99e61b0f768a8f654f45d9b7a", size = 27754, upload-time = "2025-08-05T16:43:00.132Z" }, + { url = "https://files.pythonhosted.org/packages/4e/86/c2e0f627168fcf61781a8f72cab06b228fe1da4b9fa4ab39cfb791b5836b/audioop_lts-0.2.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:5b00be98ccd0fc123dcfad31d50030d25fcf31488cde9e61692029cd7394733b", size = 27332, upload-time = "2025-08-05T16:43:01.666Z" }, + { url = "https://files.pythonhosted.org/packages/c7/bd/35dce665255434f54e5307de39e31912a6f902d4572da7c37582809de14f/audioop_lts-0.2.2-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:a6d2e0f9f7a69403e388894d4ca5ada5c47230716a03f2847cfc7bd1ecb589d6", size = 92396, upload-time = "2025-08-05T16:43:02.991Z" }, + { url = "https://files.pythonhosted.org/packages/2d/d2/deeb9f51def1437b3afa35aeb729d577c04bcd89394cb56f9239a9f50b6f/audioop_lts-0.2.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f9b0b8a03ef474f56d1a842af1a2e01398b8f7654009823c6d9e0ecff4d5cfbf", size = 91811, upload-time = "2025-08-05T16:43:04.096Z" }, + { url = "https://files.pythonhosted.org/packages/76/3b/09f8b35b227cee28cc8231e296a82759ed80c1a08e349811d69773c48426/audioop_lts-0.2.2-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:2b267b70747d82125f1a021506565bdc5609a2b24bcb4773c16d79d2bb260bbd", size = 100483, upload-time = "2025-08-05T16:43:05.085Z" }, + { url = "https://files.pythonhosted.org/packages/0b/15/05b48a935cf3b130c248bfdbdea71ce6437f5394ee8533e0edd7cfd93d5e/audioop_lts-0.2.2-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0337d658f9b81f4cd0fdb1f47635070cc084871a3d4646d9de74fdf4e7c3d24a", size = 103885, upload-time = "2025-08-05T16:43:06.197Z" }, + { url = "https://files.pythonhosted.org/packages/83/80/186b7fce6d35b68d3d739f228dc31d60b3412105854edb975aa155a58339/audioop_lts-0.2.2-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:167d3b62586faef8b6b2275c3218796b12621a60e43f7e9d5845d627b9c9b80e", size = 84899, upload-time = "2025-08-05T16:43:07.291Z" }, + { url = "https://files.pythonhosted.org/packages/49/89/c78cc5ac6cb5828f17514fb12966e299c850bc885e80f8ad94e38d450886/audioop_lts-0.2.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:0d9385e96f9f6da847f4d571ce3cb15b5091140edf3db97276872647ce37efd7", size = 89998, upload-time = "2025-08-05T16:43:08.335Z" }, + { url = "https://files.pythonhosted.org/packages/4c/4b/6401888d0c010e586c2ca50fce4c903d70a6bb55928b16cfbdfd957a13da/audioop_lts-0.2.2-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:48159d96962674eccdca9a3df280e864e8ac75e40a577cc97c5c42667ffabfc5", size = 99046, upload-time = "2025-08-05T16:43:09.367Z" }, + { url = "https://files.pythonhosted.org/packages/de/f8/c874ca9bb447dae0e2ef2e231f6c4c2b0c39e31ae684d2420b0f9e97ee68/audioop_lts-0.2.2-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:8fefe5868cd082db1186f2837d64cfbfa78b548ea0d0543e9b28935ccce81ce9", size = 84843, upload-time = "2025-08-05T16:43:10.749Z" }, + { url = "https://files.pythonhosted.org/packages/3e/c0/0323e66f3daebc13fd46b36b30c3be47e3fc4257eae44f1e77eb828c703f/audioop_lts-0.2.2-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:58cf54380c3884fb49fdd37dfb7a772632b6701d28edd3e2904743c5e1773602", size = 94490, upload-time = "2025-08-05T16:43:12.131Z" }, + { url = "https://files.pythonhosted.org/packages/98/6b/acc7734ac02d95ab791c10c3f17ffa3584ccb9ac5c18fd771c638ed6d1f5/audioop_lts-0.2.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:088327f00488cdeed296edd9215ca159f3a5a5034741465789cad403fcf4bec0", size = 92297, upload-time = "2025-08-05T16:43:13.139Z" }, + { url = "https://files.pythonhosted.org/packages/13/c3/c3dc3f564ce6877ecd2a05f8d751b9b27a8c320c2533a98b0c86349778d0/audioop_lts-0.2.2-cp314-cp314t-win32.whl", hash = "sha256:068aa17a38b4e0e7de771c62c60bbca2455924b67a8814f3b0dee92b5820c0b3", size = 27331, upload-time = "2025-08-05T16:43:14.19Z" }, + { url = "https://files.pythonhosted.org/packages/72/bb/b4608537e9ffcb86449091939d52d24a055216a36a8bf66b936af8c3e7ac/audioop_lts-0.2.2-cp314-cp314t-win_amd64.whl", hash = "sha256:a5bf613e96f49712073de86f20dbdd4014ca18efd4d34ed18c75bd808337851b", size = 31697, upload-time = "2025-08-05T16:43:15.193Z" }, + { url = "https://files.pythonhosted.org/packages/f6/22/91616fe707a5c5510de2cac9b046a30defe7007ba8a0c04f9c08f27df312/audioop_lts-0.2.2-cp314-cp314t-win_arm64.whl", hash = "sha256:b492c3b040153e68b9fdaff5913305aaaba5bb433d8a7f73d5cf6a64ed3cc1dd", size = 25206, upload-time = "2025-08-05T16:43:16.444Z" }, +] + +[[package]] +name = "certifi" +version = "2026.2.25" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/af/2d/7bf41579a8986e348fa033a31cdd0e4121114f6bce2457e8876010b092dd/certifi-2026.2.25.tar.gz", hash = "sha256:e887ab5cee78ea814d3472169153c2d12cd43b14bd03329a39a9c6e2e80bfba7", size = 155029, upload-time = "2026-02-25T02:54:17.342Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9a/3c/c17fb3ca2d9c3acff52e30b309f538586f9f5b9c9cf454f3845fc9af4881/certifi-2026.2.25-py3-none-any.whl", hash = "sha256:027692e4402ad994f1c42e52a4997a9763c646b73e4096e4d5d6db8af1d6f0fa", size = 153684, upload-time = "2026-02-25T02:54:15.766Z" }, +] + +[[package]] +name = "charset-normalizer" +version = "3.4.5" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/1d/35/02daf95b9cd686320bb622eb148792655c9412dbb9b67abb5694e5910a24/charset_normalizer-3.4.5.tar.gz", hash = "sha256:95adae7b6c42a6c5b5b559b1a99149f090a57128155daeea91732c8d970d8644", size = 134804, upload-time = "2026-03-06T06:03:19.46Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9c/b6/9ee9c1a608916ca5feae81a344dffbaa53b26b90be58cc2159e3332d44ec/charset_normalizer-3.4.5-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:ed97c282ee4f994ef814042423a529df9497e3c666dca19be1d4cd1129dc7ade", size = 280976, upload-time = "2026-03-06T06:01:15.276Z" }, + { url = "https://files.pythonhosted.org/packages/f8/d8/a54f7c0b96f1df3563e9190f04daf981e365a9b397eedfdfb5dbef7e5c6c/charset_normalizer-3.4.5-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0294916d6ccf2d069727d65973c3a1ca477d68708db25fd758dd28b0827cff54", size = 189356, upload-time = "2026-03-06T06:01:16.511Z" }, + { url = "https://files.pythonhosted.org/packages/42/69/2bf7f76ce1446759a5787cb87d38f6a61eb47dbbdf035cfebf6347292a65/charset_normalizer-3.4.5-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:dc57a0baa3eeedd99fafaef7511b5a6ef4581494e8168ee086031744e2679467", size = 206369, upload-time = "2026-03-06T06:01:17.853Z" }, + { url = "https://files.pythonhosted.org/packages/10/9c/949d1a46dab56b959d9a87272482195f1840b515a3380e39986989a893ae/charset_normalizer-3.4.5-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:ed1a9a204f317ef879b32f9af507d47e49cd5e7f8e8d5d96358c98373314fc60", size = 203285, upload-time = "2026-03-06T06:01:19.473Z" }, + { url = "https://files.pythonhosted.org/packages/67/5c/ae30362a88b4da237d71ea214a8c7eb915db3eec941adda511729ac25fa2/charset_normalizer-3.4.5-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7ad83b8f9379176c841f8865884f3514d905bcd2a9a3b210eaa446e7d2223e4d", size = 196274, upload-time = "2026-03-06T06:01:20.728Z" }, + { url = "https://files.pythonhosted.org/packages/b2/07/c9f2cb0e46cb6d64fdcc4f95953747b843bb2181bda678dc4e699b8f0f9a/charset_normalizer-3.4.5-cp312-cp312-manylinux_2_31_armv7l.whl", hash = "sha256:a118e2e0b5ae6b0120d5efa5f866e58f2bb826067a646431da4d6a2bdae7950e", size = 184715, upload-time = "2026-03-06T06:01:22.194Z" }, + { url = "https://files.pythonhosted.org/packages/36/64/6b0ca95c44fddf692cd06d642b28f63009d0ce325fad6e9b2b4d0ef86a52/charset_normalizer-3.4.5-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:754f96058e61a5e22e91483f823e07df16416ce76afa4ebf306f8e1d1296d43f", size = 193426, upload-time = "2026-03-06T06:01:23.795Z" }, + { url = "https://files.pythonhosted.org/packages/50/bc/a730690d726403743795ca3f5bb2baf67838c5fea78236098f324b965e40/charset_normalizer-3.4.5-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:0c300cefd9b0970381a46394902cd18eaf2aa00163f999590ace991989dcd0fc", size = 191780, upload-time = "2026-03-06T06:01:25.053Z" }, + { url = "https://files.pythonhosted.org/packages/97/4f/6c0bc9af68222b22951552d73df4532b5be6447cee32d58e7e8c74ecbb7b/charset_normalizer-3.4.5-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:c108f8619e504140569ee7de3f97d234f0fbae338a7f9f360455071ef9855a95", size = 185805, upload-time = "2026-03-06T06:01:26.294Z" }, + { url = "https://files.pythonhosted.org/packages/dd/b9/a523fb9b0ee90814b503452b2600e4cbc118cd68714d57041564886e7325/charset_normalizer-3.4.5-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:d1028de43596a315e2720a9849ee79007ab742c06ad8b45a50db8cdb7ed4a82a", size = 208342, upload-time = "2026-03-06T06:01:27.55Z" }, + { url = "https://files.pythonhosted.org/packages/4d/61/c59e761dee4464050713e50e27b58266cc8e209e518c0b378c1580c959ba/charset_normalizer-3.4.5-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:19092dde50335accf365cce21998a1c6dd8eafd42c7b226eb54b2747cdce2fac", size = 193661, upload-time = "2026-03-06T06:01:29.051Z" }, + { url = "https://files.pythonhosted.org/packages/1c/43/729fa30aad69783f755c5ad8649da17ee095311ca42024742701e202dc59/charset_normalizer-3.4.5-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:4354e401eb6dab9aed3c7b4030514328a6c748d05e1c3e19175008ca7de84fb1", size = 204819, upload-time = "2026-03-06T06:01:30.298Z" }, + { url = "https://files.pythonhosted.org/packages/87/33/d9b442ce5a91b96fc0840455a9e49a611bbadae6122778d0a6a79683dd31/charset_normalizer-3.4.5-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:a68766a3c58fde7f9aaa22b3786276f62ab2f594efb02d0a1421b6282e852e98", size = 198080, upload-time = "2026-03-06T06:01:31.478Z" }, + { url = "https://files.pythonhosted.org/packages/56/5a/b8b5a23134978ee9885cee2d6995f4c27cc41f9baded0a9685eabc5338f0/charset_normalizer-3.4.5-cp312-cp312-win32.whl", hash = "sha256:1827734a5b308b65ac54e86a618de66f935a4f63a8a462ff1e19a6788d6c2262", size = 132630, upload-time = "2026-03-06T06:01:33.056Z" }, + { url = "https://files.pythonhosted.org/packages/70/53/e44a4c07e8904500aec95865dc3f6464dc3586a039ef0df606eb3ac38e35/charset_normalizer-3.4.5-cp312-cp312-win_amd64.whl", hash = "sha256:728c6a963dfab66ef865f49286e45239384249672cd598576765acc2a640a636", size = 142856, upload-time = "2026-03-06T06:01:34.489Z" }, + { url = "https://files.pythonhosted.org/packages/ea/aa/c5628f7cad591b1cf45790b7a61483c3e36cf41349c98af7813c483fd6e8/charset_normalizer-3.4.5-cp312-cp312-win_arm64.whl", hash = "sha256:75dfd1afe0b1647449e852f4fb428195a7ed0588947218f7ba929f6538487f02", size = 132982, upload-time = "2026-03-06T06:01:35.641Z" }, + { url = "https://files.pythonhosted.org/packages/f5/48/9f34ec4bb24aa3fdba1890c1bddb97c8a4be1bd84ef5c42ac2352563ad05/charset_normalizer-3.4.5-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:ac59c15e3f1465f722607800c68713f9fbc2f672b9eb649fe831da4019ae9b23", size = 280788, upload-time = "2026-03-06T06:01:37.126Z" }, + { url = "https://files.pythonhosted.org/packages/0e/09/6003e7ffeb90cc0560da893e3208396a44c210c5ee42efff539639def59b/charset_normalizer-3.4.5-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:165c7b21d19365464e8f70e5ce5e12524c58b48c78c1f5a57524603c1ab003f8", size = 188890, upload-time = "2026-03-06T06:01:38.73Z" }, + { url = "https://files.pythonhosted.org/packages/42/1e/02706edf19e390680daa694d17e2b8eab4b5f7ac285e2a51168b4b22ee6b/charset_normalizer-3.4.5-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:28269983f25a4da0425743d0d257a2d6921ea7d9b83599d4039486ec5b9f911d", size = 206136, upload-time = "2026-03-06T06:01:40.016Z" }, + { url = "https://files.pythonhosted.org/packages/c7/87/942c3def1b37baf3cf786bad01249190f3ca3d5e63a84f831e704977de1f/charset_normalizer-3.4.5-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d27ce22ec453564770d29d03a9506d449efbb9fa13c00842262b2f6801c48cce", size = 202551, upload-time = "2026-03-06T06:01:41.522Z" }, + { url = "https://files.pythonhosted.org/packages/94/0a/af49691938dfe175d71b8a929bd7e4ace2809c0c5134e28bc535660d5262/charset_normalizer-3.4.5-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0625665e4ebdddb553ab185de5db7054393af8879fb0c87bd5690d14379d6819", size = 195572, upload-time = "2026-03-06T06:01:43.208Z" }, + { url = "https://files.pythonhosted.org/packages/20/ea/dfb1792a8050a8e694cfbde1570ff97ff74e48afd874152d38163d1df9ae/charset_normalizer-3.4.5-cp313-cp313-manylinux_2_31_armv7l.whl", hash = "sha256:c23eb3263356d94858655b3e63f85ac5d50970c6e8febcdde7830209139cc37d", size = 184438, upload-time = "2026-03-06T06:01:44.755Z" }, + { url = "https://files.pythonhosted.org/packages/72/12/c281e2067466e3ddd0595bfaea58a6946765ace5c72dfa3edc2f5f118026/charset_normalizer-3.4.5-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e6302ca4ae283deb0af68d2fbf467474b8b6aedcd3dab4db187e07f94c109763", size = 193035, upload-time = "2026-03-06T06:01:46.051Z" }, + { url = "https://files.pythonhosted.org/packages/ba/4f/3792c056e7708e10464bad0438a44708886fb8f92e3c3d29ec5e2d964d42/charset_normalizer-3.4.5-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:e51ae7d81c825761d941962450f50d041db028b7278e7b08930b4541b3e45cb9", size = 191340, upload-time = "2026-03-06T06:01:47.547Z" }, + { url = "https://files.pythonhosted.org/packages/e7/86/80ddba897127b5c7a9bccc481b0cd36c8fefa485d113262f0fe4332f0bf4/charset_normalizer-3.4.5-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:597d10dec876923e5c59e48dbd366e852eacb2b806029491d307daea6b917d7c", size = 185464, upload-time = "2026-03-06T06:01:48.764Z" }, + { url = "https://files.pythonhosted.org/packages/4d/00/b5eff85ba198faacab83e0e4b6f0648155f072278e3b392a82478f8b988b/charset_normalizer-3.4.5-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:5cffde4032a197bd3b42fd0b9509ec60fb70918d6970e4cc773f20fc9180ca67", size = 208014, upload-time = "2026-03-06T06:01:50.371Z" }, + { url = "https://files.pythonhosted.org/packages/c8/11/d36f70be01597fd30850dde8a1269ebc8efadd23ba5785808454f2389bde/charset_normalizer-3.4.5-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:2da4eedcb6338e2321e831a0165759c0c620e37f8cd044a263ff67493be8ffb3", size = 193297, upload-time = "2026-03-06T06:01:51.933Z" }, + { url = "https://files.pythonhosted.org/packages/1a/1d/259eb0a53d4910536c7c2abb9cb25f4153548efb42800c6a9456764649c0/charset_normalizer-3.4.5-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:65a126fb4b070d05340a84fc709dd9e7c75d9b063b610ece8a60197a291d0adf", size = 204321, upload-time = "2026-03-06T06:01:53.887Z" }, + { url = "https://files.pythonhosted.org/packages/84/31/faa6c5b9d3688715e1ed1bb9d124c384fe2fc1633a409e503ffe1c6398c1/charset_normalizer-3.4.5-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:c7a80a9242963416bd81f99349d5f3fce1843c303bd404f204918b6d75a75fd6", size = 197509, upload-time = "2026-03-06T06:01:56.439Z" }, + { url = "https://files.pythonhosted.org/packages/fd/a5/c7d9dd1503ffc08950b3260f5d39ec2366dd08254f0900ecbcf3a6197c7c/charset_normalizer-3.4.5-cp313-cp313-win32.whl", hash = "sha256:f1d725b754e967e648046f00c4facc42d414840f5ccc670c5670f59f83693e4f", size = 132284, upload-time = "2026-03-06T06:01:57.812Z" }, + { url = "https://files.pythonhosted.org/packages/b9/0f/57072b253af40c8aa6636e6de7d75985624c1eb392815b2f934199340a89/charset_normalizer-3.4.5-cp313-cp313-win_amd64.whl", hash = "sha256:e37bd100d2c5d3ba35db9c7c5ba5a9228cbcffe5c4778dc824b164e5257813d7", size = 142630, upload-time = "2026-03-06T06:01:59.062Z" }, + { url = "https://files.pythonhosted.org/packages/31/41/1c4b7cc9f13bd9d369ce3bc993e13d374ce25fa38a2663644283ecf422c1/charset_normalizer-3.4.5-cp313-cp313-win_arm64.whl", hash = "sha256:93b3b2cc5cf1b8743660ce77a4f45f3f6d1172068207c1defc779a36eea6bb36", size = 133254, upload-time = "2026-03-06T06:02:00.281Z" }, + { url = "https://files.pythonhosted.org/packages/43/be/0f0fd9bb4a7fa4fb5067fb7d9ac693d4e928d306f80a0d02bde43a7c4aee/charset_normalizer-3.4.5-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:8197abe5ca1ffb7d91e78360f915eef5addff270f8a71c1fc5be24a56f3e4873", size = 280232, upload-time = "2026-03-06T06:02:01.508Z" }, + { url = "https://files.pythonhosted.org/packages/28/02/983b5445e4bef49cd8c9da73a8e029f0825f39b74a06d201bfaa2e55142a/charset_normalizer-3.4.5-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a2aecdb364b8a1802afdc7f9327d55dad5366bc97d8502d0f5854e50712dbc5f", size = 189688, upload-time = "2026-03-06T06:02:02.857Z" }, + { url = "https://files.pythonhosted.org/packages/d0/88/152745c5166437687028027dc080e2daed6fe11cfa95a22f4602591c42db/charset_normalizer-3.4.5-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a66aa5022bf81ab4b1bebfb009db4fd68e0c6d4307a1ce5ef6a26e5878dfc9e4", size = 206833, upload-time = "2026-03-06T06:02:05.127Z" }, + { url = "https://files.pythonhosted.org/packages/cb/0f/ebc15c8b02af2f19be9678d6eed115feeeccc45ce1f4b098d986c13e8769/charset_normalizer-3.4.5-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d77f97e515688bd615c1d1f795d540f32542d514242067adcb8ef532504cb9ee", size = 202879, upload-time = "2026-03-06T06:02:06.446Z" }, + { url = "https://files.pythonhosted.org/packages/38/9c/71336bff6934418dc8d1e8a1644176ac9088068bc571da612767619c97b3/charset_normalizer-3.4.5-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:01a1ed54b953303ca7e310fafe0fe347aab348bd81834a0bcd602eb538f89d66", size = 195764, upload-time = "2026-03-06T06:02:08.763Z" }, + { url = "https://files.pythonhosted.org/packages/b7/95/ce92fde4f98615661871bc282a856cf9b8a15f686ba0af012984660d480b/charset_normalizer-3.4.5-cp314-cp314-manylinux_2_31_armv7l.whl", hash = "sha256:b2d37d78297b39a9eb9eb92c0f6df98c706467282055419df141389b23f93362", size = 183728, upload-time = "2026-03-06T06:02:10.137Z" }, + { url = "https://files.pythonhosted.org/packages/1c/e7/f5b4588d94e747ce45ae680f0f242bc2d98dbd4eccfab73e6160b6893893/charset_normalizer-3.4.5-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e71bbb595973622b817c042bd943c3f3667e9c9983ce3d205f973f486fec98a7", size = 192937, upload-time = "2026-03-06T06:02:11.663Z" }, + { url = "https://files.pythonhosted.org/packages/f9/29/9d94ed6b929bf9f48bf6ede6e7474576499f07c4c5e878fb186083622716/charset_normalizer-3.4.5-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:4cd966c2559f501c6fd69294d082c2934c8dd4719deb32c22961a5ac6db0df1d", size = 192040, upload-time = "2026-03-06T06:02:13.489Z" }, + { url = "https://files.pythonhosted.org/packages/15/d2/1a093a1cf827957f9445f2fe7298bcc16f8fc5e05c1ed2ad1af0b239035e/charset_normalizer-3.4.5-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:d5e52d127045d6ae01a1e821acfad2f3a1866c54d0e837828538fabe8d9d1bd6", size = 184107, upload-time = "2026-03-06T06:02:14.83Z" }, + { url = "https://files.pythonhosted.org/packages/0f/7d/82068ce16bd36135df7b97f6333c5d808b94e01d4599a682e2337ed5fd14/charset_normalizer-3.4.5-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:30a2b1a48478c3428d047ed9690d57c23038dac838a87ad624c85c0a78ebeb39", size = 208310, upload-time = "2026-03-06T06:02:16.165Z" }, + { url = "https://files.pythonhosted.org/packages/84/4e/4dfb52307bb6af4a5c9e73e482d171b81d36f522b21ccd28a49656baa680/charset_normalizer-3.4.5-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:d8ed79b8f6372ca4254955005830fd61c1ccdd8c0fac6603e2c145c61dd95db6", size = 192918, upload-time = "2026-03-06T06:02:18.144Z" }, + { url = "https://files.pythonhosted.org/packages/08/a4/159ff7da662cf7201502ca89980b8f06acf3e887b278956646a8aeb178ab/charset_normalizer-3.4.5-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:c5af897b45fa606b12464ccbe0014bbf8c09191e0a66aab6aa9d5cf6e77e0c94", size = 204615, upload-time = "2026-03-06T06:02:19.821Z" }, + { url = "https://files.pythonhosted.org/packages/d6/62/0dd6172203cb6b429ffffc9935001fde42e5250d57f07b0c28c6046deb6b/charset_normalizer-3.4.5-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:1088345bcc93c58d8d8f3d783eca4a6e7a7752bbff26c3eee7e73c597c191c2e", size = 197784, upload-time = "2026-03-06T06:02:21.86Z" }, + { url = "https://files.pythonhosted.org/packages/c7/5e/1aab5cb737039b9c59e63627dc8bbc0d02562a14f831cc450e5f91d84ce1/charset_normalizer-3.4.5-cp314-cp314-win32.whl", hash = "sha256:ee57b926940ba00bca7ba7041e665cc956e55ef482f851b9b65acb20d867e7a2", size = 133009, upload-time = "2026-03-06T06:02:23.289Z" }, + { url = "https://files.pythonhosted.org/packages/40/65/e7c6c77d7aaa4c0d7974f2e403e17f0ed2cb0fc135f77d686b916bf1eead/charset_normalizer-3.4.5-cp314-cp314-win_amd64.whl", hash = "sha256:4481e6da1830c8a1cc0b746b47f603b653dadb690bcd851d039ffaefe70533aa", size = 143511, upload-time = "2026-03-06T06:02:26.195Z" }, + { url = "https://files.pythonhosted.org/packages/ba/91/52b0841c71f152f563b8e072896c14e3d83b195c188b338d3cc2e582d1d4/charset_normalizer-3.4.5-cp314-cp314-win_arm64.whl", hash = "sha256:97ab7787092eb9b50fb47fa04f24c75b768a606af1bcba1957f07f128a7219e4", size = 133775, upload-time = "2026-03-06T06:02:27.473Z" }, + { url = "https://files.pythonhosted.org/packages/c5/60/3a621758945513adfd4db86827a5bafcc615f913dbd0b4c2ed64a65731be/charset_normalizer-3.4.5-py3-none-any.whl", hash = "sha256:9db5e3fcdcee89a78c04dffb3fe33c79f77bd741a624946db2591c81b2fc85b0", size = 55455, upload-time = "2026-03-06T06:03:17.827Z" }, +] + +[[package]] +name = "click" +version = "8.3.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/bb/63/f9e1ea081ce35720d8b92acde70daaedace594dc93b693c869e0d5910718/click-8.3.3.tar.gz", hash = "sha256:398329ad4837b2ff7cbe1dd166a4c0f8900c3ca3a218de04466f38f6497f18a2", size = 328061, upload-time = "2026-04-22T15:11:27.506Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ae/44/c1221527f6a71a01ec6fbad7fa78f1d50dfa02217385cf0fa3eec7087d59/click-8.3.3-py3-none-any.whl", hash = "sha256:a2bf429bb3033c89fa4936ffb35d5cb471e3719e1f3c8a7c3fff0b8314305613", size = 110502, upload-time = "2026-04-22T15:11:25.044Z" }, +] + +[[package]] +name = "codecrafters-claude-code" +version = "0.1.0" +source = { virtual = "." } +dependencies = [ + { name = "ddgs" }, + { name = "discord-py" }, + { name = "geocoder" }, + { name = "openai" }, + { name = "python-dotenv" }, + { name = "python-telegram-bot" }, + { name = "requests" }, +] + +[package.dev-dependencies] +dev = [ + { name = "ddgs" }, + { name = "pytest" }, + { name = "pytest-asyncio" }, + { name = "ruff" }, +] + +[package.metadata] +requires-dist = [ + { name = "ddgs", specifier = ">=9.14.1" }, + { name = "discord-py", specifier = ">=2.7.1" }, + { name = "geocoder", specifier = ">=1.38.1" }, + { name = "openai", specifier = ">=2.15.0" }, + { name = "python-dotenv", specifier = ">=0.9.9" }, + { name = "python-telegram-bot", specifier = ">=22.7" }, + { name = "requests", specifier = ">=2.32.5" }, +] + +[package.metadata.requires-dev] +dev = [ + { name = "ddgs", specifier = ">=9.14.1" }, + { name = "pytest", specifier = ">=8.0.0" }, + { name = "pytest-asyncio", specifier = ">=0.24.0" }, + { name = "ruff" }, +] + +[[package]] +name = "colorama" +version = "0.4.6" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" }, +] + +[[package]] +name = "ddgs" +version = "9.14.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "click" }, + { name = "lxml" }, + { name = "primp" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/c9/f2/aa1f5af106ea0ef0351d11a2fe05d28618463160137326eeb3073b7d788b/ddgs-9.14.1.tar.gz", hash = "sha256:85b878225a622ba145aff33c0f2f0dceb90d6cfaa291af253021d10cb261a8bb", size = 57157, upload-time = "2026-04-20T12:09:21.313Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4f/a0/c0b568acd6ec819ec94ecfd4eebd00edc855efab06e589ad17d0412ff4ce/ddgs-9.14.1-py3-none-any.whl", hash = "sha256:e6b853be092532add9c0d611c4b121f0b27092de66756401057c2100f6b1ab44", size = 67019, upload-time = "2026-04-20T12:09:19.867Z" }, +] + +[[package]] +name = "decorator" +version = "5.2.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/43/fa/6d96a0978d19e17b68d634497769987b16c8f4cd0a7a05048bec693caa6b/decorator-5.2.1.tar.gz", hash = "sha256:65f266143752f734b0a7cc83c46f4618af75b8c5911b00ccb61d0ac9b6da0360", size = 56711, upload-time = "2025-02-24T04:41:34.073Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4e/8c/f3147f5c4b73e7550fe5f9352eaa956ae838d5c51eb58e7a25b9f3e2643b/decorator-5.2.1-py3-none-any.whl", hash = "sha256:d316bb415a2d9e2d2b3abcc4084c6502fc09240e292cd76a76afc106a1c8e04a", size = 9190, upload-time = "2025-02-24T04:41:32.565Z" }, +] + +[[package]] +name = "discord-py" +version = "2.7.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "aiohttp" }, + { name = "audioop-lts", marker = "python_full_version >= '3.13'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ef/57/9a2d9abdabdc9db8ef28ce0cf4129669e1c8717ba28d607b5ba357c4de3b/discord_py-2.7.1.tar.gz", hash = "sha256:24d5e6a45535152e4b98148a9dd6b550d25dc2c9fb41b6d670319411641249da", size = 1106326, upload-time = "2026-03-03T18:40:46.24Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f7/a7/17208c3b3f92319e7fad259f1c6d5a5baf8fd0654c54846ced329f83c3eb/discord_py-2.7.1-py3-none-any.whl", hash = "sha256:849dca2c63b171146f3a7f3f8acc04248098e9e6203412ce3cf2745f284f7439", size = 1227550, upload-time = "2026-03-03T18:40:44.492Z" }, +] + +[[package]] +name = "distro" +version = "1.9.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/fc/f8/98eea607f65de6527f8a2e8885fc8015d3e6f5775df186e443e0964a11c3/distro-1.9.0.tar.gz", hash = "sha256:2fa77c6fd8940f116ee1d6b94a2f90b13b5ea8d019b98bc8bafdcabcdd9bdbed", size = 60722, upload-time = "2023-12-24T09:54:32.31Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/12/b3/231ffd4ab1fc9d679809f356cebee130ac7daa00d6d6f3206dd4fd137e9e/distro-1.9.0-py3-none-any.whl", hash = "sha256:7bffd925d65168f85027d8da9af6bddab658135b840670a223589bc0c8ef02b2", size = 20277, upload-time = "2023-12-24T09:54:30.421Z" }, +] + +[[package]] +name = "frozenlist" +version = "1.8.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/2d/f5/c831fac6cc817d26fd54c7eaccd04ef7e0288806943f7cc5bbf69f3ac1f0/frozenlist-1.8.0.tar.gz", hash = "sha256:3ede829ed8d842f6cd48fc7081d7a41001a56f1f38603f9d49bf3020d59a31ad", size = 45875, upload-time = "2025-10-06T05:38:17.865Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/69/29/948b9aa87e75820a38650af445d2ef2b6b8a6fab1a23b6bb9e4ef0be2d59/frozenlist-1.8.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:78f7b9e5d6f2fdb88cdde9440dc147259b62b9d3b019924def9f6478be254ac1", size = 87782, upload-time = "2025-10-06T05:36:06.649Z" }, + { url = "https://files.pythonhosted.org/packages/64/80/4f6e318ee2a7c0750ed724fa33a4bdf1eacdc5a39a7a24e818a773cd91af/frozenlist-1.8.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:229bf37d2e4acdaf808fd3f06e854a4a7a3661e871b10dc1f8f1896a3b05f18b", size = 50594, upload-time = "2025-10-06T05:36:07.69Z" }, + { url = "https://files.pythonhosted.org/packages/2b/94/5c8a2b50a496b11dd519f4a24cb5496cf125681dd99e94c604ccdea9419a/frozenlist-1.8.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f833670942247a14eafbb675458b4e61c82e002a148f49e68257b79296e865c4", size = 50448, upload-time = "2025-10-06T05:36:08.78Z" }, + { url = "https://files.pythonhosted.org/packages/6a/bd/d91c5e39f490a49df14320f4e8c80161cfcce09f1e2cde1edd16a551abb3/frozenlist-1.8.0-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:494a5952b1c597ba44e0e78113a7266e656b9794eec897b19ead706bd7074383", size = 242411, upload-time = "2025-10-06T05:36:09.801Z" }, + { url = "https://files.pythonhosted.org/packages/8f/83/f61505a05109ef3293dfb1ff594d13d64a2324ac3482be2cedc2be818256/frozenlist-1.8.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:96f423a119f4777a4a056b66ce11527366a8bb92f54e541ade21f2374433f6d4", size = 243014, upload-time = "2025-10-06T05:36:11.394Z" }, + { url = "https://files.pythonhosted.org/packages/d8/cb/cb6c7b0f7d4023ddda30cf56b8b17494eb3a79e3fda666bf735f63118b35/frozenlist-1.8.0-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3462dd9475af2025c31cc61be6652dfa25cbfb56cbbf52f4ccfe029f38decaf8", size = 234909, upload-time = "2025-10-06T05:36:12.598Z" }, + { url = "https://files.pythonhosted.org/packages/31/c5/cd7a1f3b8b34af009fb17d4123c5a778b44ae2804e3ad6b86204255f9ec5/frozenlist-1.8.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c4c800524c9cd9bac5166cd6f55285957fcfc907db323e193f2afcd4d9abd69b", size = 250049, upload-time = "2025-10-06T05:36:14.065Z" }, + { url = "https://files.pythonhosted.org/packages/c0/01/2f95d3b416c584a1e7f0e1d6d31998c4a795f7544069ee2e0962a4b60740/frozenlist-1.8.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d6a5df73acd3399d893dafc71663ad22534b5aa4f94e8a2fabfe856c3c1b6a52", size = 256485, upload-time = "2025-10-06T05:36:15.39Z" }, + { url = "https://files.pythonhosted.org/packages/ce/03/024bf7720b3abaebcff6d0793d73c154237b85bdf67b7ed55e5e9596dc9a/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:405e8fe955c2280ce66428b3ca55e12b3c4e9c336fb2103a4937e891c69a4a29", size = 237619, upload-time = "2025-10-06T05:36:16.558Z" }, + { url = "https://files.pythonhosted.org/packages/69/fa/f8abdfe7d76b731f5d8bd217827cf6764d4f1d9763407e42717b4bed50a0/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:908bd3f6439f2fef9e85031b59fd4f1297af54415fb60e4254a95f75b3cab3f3", size = 250320, upload-time = "2025-10-06T05:36:17.821Z" }, + { url = "https://files.pythonhosted.org/packages/f5/3c/b051329f718b463b22613e269ad72138cc256c540f78a6de89452803a47d/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:294e487f9ec720bd8ffcebc99d575f7eff3568a08a253d1ee1a0378754b74143", size = 246820, upload-time = "2025-10-06T05:36:19.046Z" }, + { url = "https://files.pythonhosted.org/packages/0f/ae/58282e8f98e444b3f4dd42448ff36fa38bef29e40d40f330b22e7108f565/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:74c51543498289c0c43656701be6b077f4b265868fa7f8a8859c197006efb608", size = 250518, upload-time = "2025-10-06T05:36:20.763Z" }, + { url = "https://files.pythonhosted.org/packages/8f/96/007e5944694d66123183845a106547a15944fbbb7154788cbf7272789536/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:776f352e8329135506a1d6bf16ac3f87bc25b28e765949282dcc627af36123aa", size = 239096, upload-time = "2025-10-06T05:36:22.129Z" }, + { url = "https://files.pythonhosted.org/packages/66/bb/852b9d6db2fa40be96f29c0d1205c306288f0684df8fd26ca1951d461a56/frozenlist-1.8.0-cp312-cp312-win32.whl", hash = "sha256:433403ae80709741ce34038da08511d4a77062aa924baf411ef73d1146e74faf", size = 39985, upload-time = "2025-10-06T05:36:23.661Z" }, + { url = "https://files.pythonhosted.org/packages/b8/af/38e51a553dd66eb064cdf193841f16f077585d4d28394c2fa6235cb41765/frozenlist-1.8.0-cp312-cp312-win_amd64.whl", hash = "sha256:34187385b08f866104f0c0617404c8eb08165ab1272e884abc89c112e9c00746", size = 44591, upload-time = "2025-10-06T05:36:24.958Z" }, + { url = "https://files.pythonhosted.org/packages/a7/06/1dc65480ab147339fecc70797e9c2f69d9cea9cf38934ce08df070fdb9cb/frozenlist-1.8.0-cp312-cp312-win_arm64.whl", hash = "sha256:fe3c58d2f5db5fbd18c2987cba06d51b0529f52bc3a6cdc33d3f4eab725104bd", size = 40102, upload-time = "2025-10-06T05:36:26.333Z" }, + { url = "https://files.pythonhosted.org/packages/2d/40/0832c31a37d60f60ed79e9dfb5a92e1e2af4f40a16a29abcc7992af9edff/frozenlist-1.8.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:8d92f1a84bb12d9e56f818b3a746f3efba93c1b63c8387a73dde655e1e42282a", size = 85717, upload-time = "2025-10-06T05:36:27.341Z" }, + { url = "https://files.pythonhosted.org/packages/30/ba/b0b3de23f40bc55a7057bd38434e25c34fa48e17f20ee273bbde5e0650f3/frozenlist-1.8.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:96153e77a591c8adc2ee805756c61f59fef4cf4073a9275ee86fe8cba41241f7", size = 49651, upload-time = "2025-10-06T05:36:28.855Z" }, + { url = "https://files.pythonhosted.org/packages/0c/ab/6e5080ee374f875296c4243c381bbdef97a9ac39c6e3ce1d5f7d42cb78d6/frozenlist-1.8.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f21f00a91358803399890ab167098c131ec2ddd5f8f5fd5fe9c9f2c6fcd91e40", size = 49417, upload-time = "2025-10-06T05:36:29.877Z" }, + { url = "https://files.pythonhosted.org/packages/d5/4e/e4691508f9477ce67da2015d8c00acd751e6287739123113a9fca6f1604e/frozenlist-1.8.0-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:fb30f9626572a76dfe4293c7194a09fb1fe93ba94c7d4f720dfae3b646b45027", size = 234391, upload-time = "2025-10-06T05:36:31.301Z" }, + { url = "https://files.pythonhosted.org/packages/40/76/c202df58e3acdf12969a7895fd6f3bc016c642e6726aa63bd3025e0fc71c/frozenlist-1.8.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:eaa352d7047a31d87dafcacbabe89df0aa506abb5b1b85a2fb91bc3faa02d822", size = 233048, upload-time = "2025-10-06T05:36:32.531Z" }, + { url = "https://files.pythonhosted.org/packages/f9/c0/8746afb90f17b73ca5979c7a3958116e105ff796e718575175319b5bb4ce/frozenlist-1.8.0-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:03ae967b4e297f58f8c774c7eabcce57fe3c2434817d4385c50661845a058121", size = 226549, upload-time = "2025-10-06T05:36:33.706Z" }, + { url = "https://files.pythonhosted.org/packages/7e/eb/4c7eefc718ff72f9b6c4893291abaae5fbc0c82226a32dcd8ef4f7a5dbef/frozenlist-1.8.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f6292f1de555ffcc675941d65fffffb0a5bcd992905015f85d0592201793e0e5", size = 239833, upload-time = "2025-10-06T05:36:34.947Z" }, + { url = "https://files.pythonhosted.org/packages/c2/4e/e5c02187cf704224f8b21bee886f3d713ca379535f16893233b9d672ea71/frozenlist-1.8.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:29548f9b5b5e3460ce7378144c3010363d8035cea44bc0bf02d57f5a685e084e", size = 245363, upload-time = "2025-10-06T05:36:36.534Z" }, + { url = "https://files.pythonhosted.org/packages/1f/96/cb85ec608464472e82ad37a17f844889c36100eed57bea094518bf270692/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ec3cc8c5d4084591b4237c0a272cc4f50a5b03396a47d9caaf76f5d7b38a4f11", size = 229314, upload-time = "2025-10-06T05:36:38.582Z" }, + { url = "https://files.pythonhosted.org/packages/5d/6f/4ae69c550e4cee66b57887daeebe006fe985917c01d0fff9caab9883f6d0/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:517279f58009d0b1f2e7c1b130b377a349405da3f7621ed6bfae50b10adf20c1", size = 243365, upload-time = "2025-10-06T05:36:40.152Z" }, + { url = "https://files.pythonhosted.org/packages/7a/58/afd56de246cf11780a40a2c28dc7cbabbf06337cc8ddb1c780a2d97e88d8/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:db1e72ede2d0d7ccb213f218df6a078a9c09a7de257c2fe8fcef16d5925230b1", size = 237763, upload-time = "2025-10-06T05:36:41.355Z" }, + { url = "https://files.pythonhosted.org/packages/cb/36/cdfaf6ed42e2644740d4a10452d8e97fa1c062e2a8006e4b09f1b5fd7d63/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:b4dec9482a65c54a5044486847b8a66bf10c9cb4926d42927ec4e8fd5db7fed8", size = 240110, upload-time = "2025-10-06T05:36:42.716Z" }, + { url = "https://files.pythonhosted.org/packages/03/a8/9ea226fbefad669f11b52e864c55f0bd57d3c8d7eb07e9f2e9a0b39502e1/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:21900c48ae04d13d416f0e1e0c4d81f7931f73a9dfa0b7a8746fb2fe7dd970ed", size = 233717, upload-time = "2025-10-06T05:36:44.251Z" }, + { url = "https://files.pythonhosted.org/packages/1e/0b/1b5531611e83ba7d13ccc9988967ea1b51186af64c42b7a7af465dcc9568/frozenlist-1.8.0-cp313-cp313-win32.whl", hash = "sha256:8b7b94a067d1c504ee0b16def57ad5738701e4ba10cec90529f13fa03c833496", size = 39628, upload-time = "2025-10-06T05:36:45.423Z" }, + { url = "https://files.pythonhosted.org/packages/d8/cf/174c91dbc9cc49bc7b7aab74d8b734e974d1faa8f191c74af9b7e80848e6/frozenlist-1.8.0-cp313-cp313-win_amd64.whl", hash = "sha256:878be833caa6a3821caf85eb39c5ba92d28e85df26d57afb06b35b2efd937231", size = 43882, upload-time = "2025-10-06T05:36:46.796Z" }, + { url = "https://files.pythonhosted.org/packages/c1/17/502cd212cbfa96eb1388614fe39a3fc9ab87dbbe042b66f97acb57474834/frozenlist-1.8.0-cp313-cp313-win_arm64.whl", hash = "sha256:44389d135b3ff43ba8cc89ff7f51f5a0bb6b63d829c8300f79a2fe4fe61bcc62", size = 39676, upload-time = "2025-10-06T05:36:47.8Z" }, + { url = "https://files.pythonhosted.org/packages/d2/5c/3bbfaa920dfab09e76946a5d2833a7cbdf7b9b4a91c714666ac4855b88b4/frozenlist-1.8.0-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:e25ac20a2ef37e91c1b39938b591457666a0fa835c7783c3a8f33ea42870db94", size = 89235, upload-time = "2025-10-06T05:36:48.78Z" }, + { url = "https://files.pythonhosted.org/packages/d2/d6/f03961ef72166cec1687e84e8925838442b615bd0b8854b54923ce5b7b8a/frozenlist-1.8.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:07cdca25a91a4386d2e76ad992916a85038a9b97561bf7a3fd12d5d9ce31870c", size = 50742, upload-time = "2025-10-06T05:36:49.837Z" }, + { url = "https://files.pythonhosted.org/packages/1e/bb/a6d12b7ba4c3337667d0e421f7181c82dda448ce4e7ad7ecd249a16fa806/frozenlist-1.8.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:4e0c11f2cc6717e0a741f84a527c52616140741cd812a50422f83dc31749fb52", size = 51725, upload-time = "2025-10-06T05:36:50.851Z" }, + { url = "https://files.pythonhosted.org/packages/bc/71/d1fed0ffe2c2ccd70b43714c6cab0f4188f09f8a67a7914a6b46ee30f274/frozenlist-1.8.0-cp313-cp313t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:b3210649ee28062ea6099cfda39e147fa1bc039583c8ee4481cb7811e2448c51", size = 284533, upload-time = "2025-10-06T05:36:51.898Z" }, + { url = "https://files.pythonhosted.org/packages/c9/1f/fb1685a7b009d89f9bf78a42d94461bc06581f6e718c39344754a5d9bada/frozenlist-1.8.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:581ef5194c48035a7de2aefc72ac6539823bb71508189e5de01d60c9dcd5fa65", size = 292506, upload-time = "2025-10-06T05:36:53.101Z" }, + { url = "https://files.pythonhosted.org/packages/e6/3b/b991fe1612703f7e0d05c0cf734c1b77aaf7c7d321df4572e8d36e7048c8/frozenlist-1.8.0-cp313-cp313t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3ef2d026f16a2b1866e1d86fc4e1291e1ed8a387b2c333809419a2f8b3a77b82", size = 274161, upload-time = "2025-10-06T05:36:54.309Z" }, + { url = "https://files.pythonhosted.org/packages/ca/ec/c5c618767bcdf66e88945ec0157d7f6c4a1322f1473392319b7a2501ded7/frozenlist-1.8.0-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:5500ef82073f599ac84d888e3a8c1f77ac831183244bfd7f11eaa0289fb30714", size = 294676, upload-time = "2025-10-06T05:36:55.566Z" }, + { url = "https://files.pythonhosted.org/packages/7c/ce/3934758637d8f8a88d11f0585d6495ef54b2044ed6ec84492a91fa3b27aa/frozenlist-1.8.0-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:50066c3997d0091c411a66e710f4e11752251e6d2d73d70d8d5d4c76442a199d", size = 300638, upload-time = "2025-10-06T05:36:56.758Z" }, + { url = "https://files.pythonhosted.org/packages/fc/4f/a7e4d0d467298f42de4b41cbc7ddaf19d3cfeabaf9ff97c20c6c7ee409f9/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:5c1c8e78426e59b3f8005e9b19f6ff46e5845895adbde20ece9218319eca6506", size = 283067, upload-time = "2025-10-06T05:36:57.965Z" }, + { url = "https://files.pythonhosted.org/packages/dc/48/c7b163063d55a83772b268e6d1affb960771b0e203b632cfe09522d67ea5/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:eefdba20de0d938cec6a89bd4d70f346a03108a19b9df4248d3cf0d88f1b0f51", size = 292101, upload-time = "2025-10-06T05:36:59.237Z" }, + { url = "https://files.pythonhosted.org/packages/9f/d0/2366d3c4ecdc2fd391e0afa6e11500bfba0ea772764d631bbf82f0136c9d/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:cf253e0e1c3ceb4aaff6df637ce033ff6535fb8c70a764a8f46aafd3d6ab798e", size = 289901, upload-time = "2025-10-06T05:37:00.811Z" }, + { url = "https://files.pythonhosted.org/packages/b8/94/daff920e82c1b70e3618a2ac39fbc01ae3e2ff6124e80739ce5d71c9b920/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:032efa2674356903cd0261c4317a561a6850f3ac864a63fc1583147fb05a79b0", size = 289395, upload-time = "2025-10-06T05:37:02.115Z" }, + { url = "https://files.pythonhosted.org/packages/e3/20/bba307ab4235a09fdcd3cc5508dbabd17c4634a1af4b96e0f69bfe551ebd/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:6da155091429aeba16851ecb10a9104a108bcd32f6c1642867eadaee401c1c41", size = 283659, upload-time = "2025-10-06T05:37:03.711Z" }, + { url = "https://files.pythonhosted.org/packages/fd/00/04ca1c3a7a124b6de4f8a9a17cc2fcad138b4608e7a3fc5877804b8715d7/frozenlist-1.8.0-cp313-cp313t-win32.whl", hash = "sha256:0f96534f8bfebc1a394209427d0f8a63d343c9779cda6fc25e8e121b5fd8555b", size = 43492, upload-time = "2025-10-06T05:37:04.915Z" }, + { url = "https://files.pythonhosted.org/packages/59/5e/c69f733a86a94ab10f68e496dc6b7e8bc078ebb415281d5698313e3af3a1/frozenlist-1.8.0-cp313-cp313t-win_amd64.whl", hash = "sha256:5d63a068f978fc69421fb0e6eb91a9603187527c86b7cd3f534a5b77a592b888", size = 48034, upload-time = "2025-10-06T05:37:06.343Z" }, + { url = "https://files.pythonhosted.org/packages/16/6c/be9d79775d8abe79b05fa6d23da99ad6e7763a1d080fbae7290b286093fd/frozenlist-1.8.0-cp313-cp313t-win_arm64.whl", hash = "sha256:bf0a7e10b077bf5fb9380ad3ae8ce20ef919a6ad93b4552896419ac7e1d8e042", size = 41749, upload-time = "2025-10-06T05:37:07.431Z" }, + { url = "https://files.pythonhosted.org/packages/f1/c8/85da824b7e7b9b6e7f7705b2ecaf9591ba6f79c1177f324c2735e41d36a2/frozenlist-1.8.0-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:cee686f1f4cadeb2136007ddedd0aaf928ab95216e7691c63e50a8ec066336d0", size = 86127, upload-time = "2025-10-06T05:37:08.438Z" }, + { url = "https://files.pythonhosted.org/packages/8e/e8/a1185e236ec66c20afd72399522f142c3724c785789255202d27ae992818/frozenlist-1.8.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:119fb2a1bd47307e899c2fac7f28e85b9a543864df47aa7ec9d3c1b4545f096f", size = 49698, upload-time = "2025-10-06T05:37:09.48Z" }, + { url = "https://files.pythonhosted.org/packages/a1/93/72b1736d68f03fda5fdf0f2180fb6caaae3894f1b854d006ac61ecc727ee/frozenlist-1.8.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:4970ece02dbc8c3a92fcc5228e36a3e933a01a999f7094ff7c23fbd2beeaa67c", size = 49749, upload-time = "2025-10-06T05:37:10.569Z" }, + { url = "https://files.pythonhosted.org/packages/a7/b2/fabede9fafd976b991e9f1b9c8c873ed86f202889b864756f240ce6dd855/frozenlist-1.8.0-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:cba69cb73723c3f329622e34bdbf5ce1f80c21c290ff04256cff1cd3c2036ed2", size = 231298, upload-time = "2025-10-06T05:37:11.993Z" }, + { url = "https://files.pythonhosted.org/packages/3a/3b/d9b1e0b0eed36e70477ffb8360c49c85c8ca8ef9700a4e6711f39a6e8b45/frozenlist-1.8.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:778a11b15673f6f1df23d9586f83c4846c471a8af693a22e066508b77d201ec8", size = 232015, upload-time = "2025-10-06T05:37:13.194Z" }, + { url = "https://files.pythonhosted.org/packages/dc/94/be719d2766c1138148564a3960fc2c06eb688da592bdc25adcf856101be7/frozenlist-1.8.0-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:0325024fe97f94c41c08872db482cf8ac4800d80e79222c6b0b7b162d5b13686", size = 225038, upload-time = "2025-10-06T05:37:14.577Z" }, + { url = "https://files.pythonhosted.org/packages/e4/09/6712b6c5465f083f52f50cf74167b92d4ea2f50e46a9eea0523d658454ae/frozenlist-1.8.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:97260ff46b207a82a7567b581ab4190bd4dfa09f4db8a8b49d1a958f6aa4940e", size = 240130, upload-time = "2025-10-06T05:37:15.781Z" }, + { url = "https://files.pythonhosted.org/packages/f8/d4/cd065cdcf21550b54f3ce6a22e143ac9e4836ca42a0de1022da8498eac89/frozenlist-1.8.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:54b2077180eb7f83dd52c40b2750d0a9f175e06a42e3213ce047219de902717a", size = 242845, upload-time = "2025-10-06T05:37:17.037Z" }, + { url = "https://files.pythonhosted.org/packages/62/c3/f57a5c8c70cd1ead3d5d5f776f89d33110b1addae0ab010ad774d9a44fb9/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:2f05983daecab868a31e1da44462873306d3cbfd76d1f0b5b69c473d21dbb128", size = 229131, upload-time = "2025-10-06T05:37:18.221Z" }, + { url = "https://files.pythonhosted.org/packages/6c/52/232476fe9cb64f0742f3fde2b7d26c1dac18b6d62071c74d4ded55e0ef94/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:33f48f51a446114bc5d251fb2954ab0164d5be02ad3382abcbfe07e2531d650f", size = 240542, upload-time = "2025-10-06T05:37:19.771Z" }, + { url = "https://files.pythonhosted.org/packages/5f/85/07bf3f5d0fb5414aee5f47d33c6f5c77bfe49aac680bfece33d4fdf6a246/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:154e55ec0655291b5dd1b8731c637ecdb50975a2ae70c606d100750a540082f7", size = 237308, upload-time = "2025-10-06T05:37:20.969Z" }, + { url = "https://files.pythonhosted.org/packages/11/99/ae3a33d5befd41ac0ca2cc7fd3aa707c9c324de2e89db0e0f45db9a64c26/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:4314debad13beb564b708b4a496020e5306c7333fa9a3ab90374169a20ffab30", size = 238210, upload-time = "2025-10-06T05:37:22.252Z" }, + { url = "https://files.pythonhosted.org/packages/b2/60/b1d2da22f4970e7a155f0adde9b1435712ece01b3cd45ba63702aea33938/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:073f8bf8becba60aa931eb3bc420b217bb7d5b8f4750e6f8b3be7f3da85d38b7", size = 231972, upload-time = "2025-10-06T05:37:23.5Z" }, + { url = "https://files.pythonhosted.org/packages/3f/ab/945b2f32de889993b9c9133216c068b7fcf257d8595a0ac420ac8677cab0/frozenlist-1.8.0-cp314-cp314-win32.whl", hash = "sha256:bac9c42ba2ac65ddc115d930c78d24ab8d4f465fd3fc473cdedfccadb9429806", size = 40536, upload-time = "2025-10-06T05:37:25.581Z" }, + { url = "https://files.pythonhosted.org/packages/59/ad/9caa9b9c836d9ad6f067157a531ac48b7d36499f5036d4141ce78c230b1b/frozenlist-1.8.0-cp314-cp314-win_amd64.whl", hash = "sha256:3e0761f4d1a44f1d1a47996511752cf3dcec5bbdd9cc2b4fe595caf97754b7a0", size = 44330, upload-time = "2025-10-06T05:37:26.928Z" }, + { url = "https://files.pythonhosted.org/packages/82/13/e6950121764f2676f43534c555249f57030150260aee9dcf7d64efda11dd/frozenlist-1.8.0-cp314-cp314-win_arm64.whl", hash = "sha256:d1eaff1d00c7751b7c6662e9c5ba6eb2c17a2306ba5e2a37f24ddf3cc953402b", size = 40627, upload-time = "2025-10-06T05:37:28.075Z" }, + { url = "https://files.pythonhosted.org/packages/c0/c7/43200656ecc4e02d3f8bc248df68256cd9572b3f0017f0a0c4e93440ae23/frozenlist-1.8.0-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:d3bb933317c52d7ea5004a1c442eef86f426886fba134ef8cf4226ea6ee1821d", size = 89238, upload-time = "2025-10-06T05:37:29.373Z" }, + { url = "https://files.pythonhosted.org/packages/d1/29/55c5f0689b9c0fb765055629f472c0de484dcaf0acee2f7707266ae3583c/frozenlist-1.8.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:8009897cdef112072f93a0efdce29cd819e717fd2f649ee3016efd3cd885a7ed", size = 50738, upload-time = "2025-10-06T05:37:30.792Z" }, + { url = "https://files.pythonhosted.org/packages/ba/7d/b7282a445956506fa11da8c2db7d276adcbf2b17d8bb8407a47685263f90/frozenlist-1.8.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:2c5dcbbc55383e5883246d11fd179782a9d07a986c40f49abe89ddf865913930", size = 51739, upload-time = "2025-10-06T05:37:32.127Z" }, + { url = "https://files.pythonhosted.org/packages/62/1c/3d8622e60d0b767a5510d1d3cf21065b9db874696a51ea6d7a43180a259c/frozenlist-1.8.0-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:39ecbc32f1390387d2aa4f5a995e465e9e2f79ba3adcac92d68e3e0afae6657c", size = 284186, upload-time = "2025-10-06T05:37:33.21Z" }, + { url = "https://files.pythonhosted.org/packages/2d/14/aa36d5f85a89679a85a1d44cd7a6657e0b1c75f61e7cad987b203d2daca8/frozenlist-1.8.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:92db2bf818d5cc8d9c1f1fc56b897662e24ea5adb36ad1f1d82875bd64e03c24", size = 292196, upload-time = "2025-10-06T05:37:36.107Z" }, + { url = "https://files.pythonhosted.org/packages/05/23/6bde59eb55abd407d34f77d39a5126fb7b4f109a3f611d3929f14b700c66/frozenlist-1.8.0-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:2dc43a022e555de94c3b68a4ef0b11c4f747d12c024a520c7101709a2144fb37", size = 273830, upload-time = "2025-10-06T05:37:37.663Z" }, + { url = "https://files.pythonhosted.org/packages/d2/3f/22cff331bfad7a8afa616289000ba793347fcd7bc275f3b28ecea2a27909/frozenlist-1.8.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:cb89a7f2de3602cfed448095bab3f178399646ab7c61454315089787df07733a", size = 294289, upload-time = "2025-10-06T05:37:39.261Z" }, + { url = "https://files.pythonhosted.org/packages/a4/89/5b057c799de4838b6c69aa82b79705f2027615e01be996d2486a69ca99c4/frozenlist-1.8.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:33139dc858c580ea50e7e60a1b0ea003efa1fd42e6ec7fdbad78fff65fad2fd2", size = 300318, upload-time = "2025-10-06T05:37:43.213Z" }, + { url = "https://files.pythonhosted.org/packages/30/de/2c22ab3eb2a8af6d69dc799e48455813bab3690c760de58e1bf43b36da3e/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:168c0969a329b416119507ba30b9ea13688fafffac1b7822802537569a1cb0ef", size = 282814, upload-time = "2025-10-06T05:37:45.337Z" }, + { url = "https://files.pythonhosted.org/packages/59/f7/970141a6a8dbd7f556d94977858cfb36fa9b66e0892c6dd780d2219d8cd8/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:28bd570e8e189d7f7b001966435f9dac6718324b5be2990ac496cf1ea9ddb7fe", size = 291762, upload-time = "2025-10-06T05:37:46.657Z" }, + { url = "https://files.pythonhosted.org/packages/c1/15/ca1adae83a719f82df9116d66f5bb28bb95557b3951903d39135620ef157/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:b2a095d45c5d46e5e79ba1e5b9cb787f541a8dee0433836cea4b96a2c439dcd8", size = 289470, upload-time = "2025-10-06T05:37:47.946Z" }, + { url = "https://files.pythonhosted.org/packages/ac/83/dca6dc53bf657d371fbc88ddeb21b79891e747189c5de990b9dfff2ccba1/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:eab8145831a0d56ec9c4139b6c3e594c7a83c2c8be25d5bcf2d86136a532287a", size = 289042, upload-time = "2025-10-06T05:37:49.499Z" }, + { url = "https://files.pythonhosted.org/packages/96/52/abddd34ca99be142f354398700536c5bd315880ed0a213812bc491cff5e4/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:974b28cf63cc99dfb2188d8d222bc6843656188164848c4f679e63dae4b0708e", size = 283148, upload-time = "2025-10-06T05:37:50.745Z" }, + { url = "https://files.pythonhosted.org/packages/af/d3/76bd4ed4317e7119c2b7f57c3f6934aba26d277acc6309f873341640e21f/frozenlist-1.8.0-cp314-cp314t-win32.whl", hash = "sha256:342c97bf697ac5480c0a7ec73cd700ecfa5a8a40ac923bd035484616efecc2df", size = 44676, upload-time = "2025-10-06T05:37:52.222Z" }, + { url = "https://files.pythonhosted.org/packages/89/76/c615883b7b521ead2944bb3480398cbb07e12b7b4e4d073d3752eb721558/frozenlist-1.8.0-cp314-cp314t-win_amd64.whl", hash = "sha256:06be8f67f39c8b1dc671f5d83aaefd3358ae5cdcf8314552c57e7ed3e6475bdd", size = 49451, upload-time = "2025-10-06T05:37:53.425Z" }, + { url = "https://files.pythonhosted.org/packages/e0/a3/5982da14e113d07b325230f95060e2169f5311b1017ea8af2a29b374c289/frozenlist-1.8.0-cp314-cp314t-win_arm64.whl", hash = "sha256:102e6314ca4da683dca92e3b1355490fed5f313b768500084fbe6371fddfdb79", size = 42507, upload-time = "2025-10-06T05:37:54.513Z" }, + { url = "https://files.pythonhosted.org/packages/9a/9a/e35b4a917281c0b8419d4207f4334c8e8c5dbf4f3f5f9ada73958d937dcc/frozenlist-1.8.0-py3-none-any.whl", hash = "sha256:0c18a16eab41e82c295618a77502e17b195883241c563b00f0aa5106fc4eaa0d", size = 13409, upload-time = "2025-10-06T05:38:16.721Z" }, +] + +[[package]] +name = "future" +version = "1.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a7/b2/4140c69c6a66432916b26158687e821ba631a4c9273c474343badf84d3ba/future-1.0.0.tar.gz", hash = "sha256:bd2968309307861edae1458a4f8a4f3598c03be43b97521076aebf5d94c07b05", size = 1228490, upload-time = "2024-02-21T11:52:38.461Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/da/71/ae30dadffc90b9006d77af76b393cb9dfbfc9629f339fc1574a1c52e6806/future-1.0.0-py3-none-any.whl", hash = "sha256:929292d34f5872e70396626ef385ec22355a1fae8ad29e1a734c3e43f9fbc216", size = 491326, upload-time = "2024-02-21T11:52:35.956Z" }, +] + +[[package]] +name = "geocoder" +version = "1.38.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "click" }, + { name = "future" }, + { name = "ratelim" }, + { name = "requests" }, + { name = "six" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ea/0b/2ea440270c1efb7ac73450cb704344c8127f45dabff0bea48711dc9dd93a/geocoder-1.38.1.tar.gz", hash = "sha256:c9925374c961577d0aee403b09e6f8ea1971d913f011f00ca70c76beaf7a77e7", size = 64345, upload-time = "2018-04-04T12:34:47.649Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4f/6b/13166c909ad2f2d76b929a4227c952630ebaf0d729f6317eb09cbceccbab/geocoder-1.38.1-py2.py3-none-any.whl", hash = "sha256:a733e1dfbce3f4e1a526cac03aadcedb8ed1239cf55bd7f3a23c60075121a834", size = 98590, upload-time = "2018-04-04T12:34:51.222Z" }, +] + +[[package]] +name = "h11" +version = "0.16.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", hash = "sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1", size = 101250, upload-time = "2025-04-24T03:35:25.427Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", size = 37515, upload-time = "2025-04-24T03:35:24.344Z" }, +] + +[[package]] +name = "httpcore" +version = "1.0.9" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "certifi" }, + { name = "h11" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", hash = "sha256:6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8", size = 85484, upload-time = "2025-04-24T22:06:22.219Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", hash = "sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55", size = 78784, upload-time = "2025-04-24T22:06:20.566Z" }, +] + +[[package]] +name = "httpx" +version = "0.28.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, + { name = "certifi" }, + { name = "httpcore" }, + { name = "idna" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406, upload-time = "2024-12-06T15:37:23.222Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517, upload-time = "2024-12-06T15:37:21.509Z" }, +] + +[[package]] +name = "idna" +version = "3.11" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/6f/6d/0703ccc57f3a7233505399edb88de3cbd678da106337b9fcde432b65ed60/idna-3.11.tar.gz", hash = "sha256:795dafcc9c04ed0c1fb032c2aa73654d8e8c5023a7df64a53f39190ada629902", size = 194582, upload-time = "2025-10-12T14:55:20.501Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0e/61/66938bbb5fc52dbdf84594873d5b51fb1f7c7794e9c0f5bd885f30bc507b/idna-3.11-py3-none-any.whl", hash = "sha256:771a87f49d9defaf64091e6e6fe9c18d4833f140bd19464795bc32d966ca37ea", size = 71008, upload-time = "2025-10-12T14:55:18.883Z" }, +] + +[[package]] +name = "iniconfig" +version = "2.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503, upload-time = "2025-10-18T21:55:43.219Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" }, +] + +[[package]] +name = "jiter" +version = "0.13.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/0d/5e/4ec91646aee381d01cdb9974e30882c9cd3b8c5d1079d6b5ff4af522439a/jiter-0.13.0.tar.gz", hash = "sha256:f2839f9c2c7e2dffc1bc5929a510e14ce0a946be9365fd1219e7ef342dae14f4", size = 164847, upload-time = "2026-02-02T12:37:56.441Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2e/30/7687e4f87086829955013ca12a9233523349767f69653ebc27036313def9/jiter-0.13.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:0a2bd69fc1d902e89925fc34d1da51b2128019423d7b339a45d9e99c894e0663", size = 307958, upload-time = "2026-02-02T12:35:57.165Z" }, + { url = "https://files.pythonhosted.org/packages/c3/27/e57f9a783246ed95481e6749cc5002a8a767a73177a83c63ea71f0528b90/jiter-0.13.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f917a04240ef31898182f76a332f508f2cc4b57d2b4d7ad2dbfebbfe167eb505", size = 318597, upload-time = "2026-02-02T12:35:58.591Z" }, + { url = "https://files.pythonhosted.org/packages/cf/52/e5719a60ac5d4d7c5995461a94ad5ef962a37c8bf5b088390e6fad59b2ff/jiter-0.13.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c1e2b199f446d3e82246b4fd9236d7cb502dc2222b18698ba0d986d2fecc6152", size = 348821, upload-time = "2026-02-02T12:36:00.093Z" }, + { url = "https://files.pythonhosted.org/packages/61/db/c1efc32b8ba4c740ab3fc2d037d8753f67685f475e26b9d6536a4322bcdd/jiter-0.13.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:04670992b576fa65bd056dbac0c39fe8bd67681c380cb2b48efa885711d9d726", size = 364163, upload-time = "2026-02-02T12:36:01.937Z" }, + { url = "https://files.pythonhosted.org/packages/55/8a/fb75556236047c8806995671a18e4a0ad646ed255276f51a20f32dceaeec/jiter-0.13.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5a1aff1fbdb803a376d4d22a8f63f8e7ccbce0b4890c26cc7af9e501ab339ef0", size = 483709, upload-time = "2026-02-02T12:36:03.41Z" }, + { url = "https://files.pythonhosted.org/packages/7e/16/43512e6ee863875693a8e6f6d532e19d650779d6ba9a81593ae40a9088ff/jiter-0.13.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3b3fb8c2053acaef8580809ac1d1f7481a0a0bdc012fd7f5d8b18fb696a5a089", size = 370480, upload-time = "2026-02-02T12:36:04.791Z" }, + { url = "https://files.pythonhosted.org/packages/f8/4c/09b93e30e984a187bc8aaa3510e1ec8dcbdcd71ca05d2f56aac0492453aa/jiter-0.13.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bdaba7d87e66f26a2c45d8cbadcbfc4bf7884182317907baf39cfe9775bb4d93", size = 360735, upload-time = "2026-02-02T12:36:06.994Z" }, + { url = "https://files.pythonhosted.org/packages/1a/1b/46c5e349019874ec5dfa508c14c37e29864ea108d376ae26d90bee238cd7/jiter-0.13.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:7b88d649135aca526da172e48083da915ec086b54e8e73a425ba50999468cc08", size = 391814, upload-time = "2026-02-02T12:36:08.368Z" }, + { url = "https://files.pythonhosted.org/packages/15/9e/26184760e85baee7162ad37b7912797d2077718476bf91517641c92b3639/jiter-0.13.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:e404ea551d35438013c64b4f357b0474c7abf9f781c06d44fcaf7a14c69ff9e2", size = 513990, upload-time = "2026-02-02T12:36:09.993Z" }, + { url = "https://files.pythonhosted.org/packages/e9/34/2c9355247d6debad57a0a15e76ab1566ab799388042743656e566b3b7de1/jiter-0.13.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:1f4748aad1b4a93c8bdd70f604d0f748cdc0e8744c5547798acfa52f10e79228", size = 548021, upload-time = "2026-02-02T12:36:11.376Z" }, + { url = "https://files.pythonhosted.org/packages/ac/4a/9f2c23255d04a834398b9c2e0e665382116911dc4d06b795710503cdad25/jiter-0.13.0-cp312-cp312-win32.whl", hash = "sha256:0bf670e3b1445fc4d31612199f1744f67f889ee1bbae703c4b54dc097e5dd394", size = 203024, upload-time = "2026-02-02T12:36:12.682Z" }, + { url = "https://files.pythonhosted.org/packages/09/ee/f0ae675a957ae5a8f160be3e87acea6b11dc7b89f6b7ab057e77b2d2b13a/jiter-0.13.0-cp312-cp312-win_amd64.whl", hash = "sha256:15db60e121e11fe186c0b15236bd5d18381b9ddacdcf4e659feb96fc6c969c92", size = 205424, upload-time = "2026-02-02T12:36:13.93Z" }, + { url = "https://files.pythonhosted.org/packages/1b/02/ae611edf913d3cbf02c97cdb90374af2082c48d7190d74c1111dde08bcdd/jiter-0.13.0-cp312-cp312-win_arm64.whl", hash = "sha256:41f92313d17989102f3cb5dd533a02787cdb99454d494344b0361355da52fcb9", size = 186818, upload-time = "2026-02-02T12:36:15.308Z" }, + { url = "https://files.pythonhosted.org/packages/91/9c/7ee5a6ff4b9991e1a45263bfc46731634c4a2bde27dfda6c8251df2d958c/jiter-0.13.0-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:1f8a55b848cbabf97d861495cd65f1e5c590246fabca8b48e1747c4dfc8f85bf", size = 306897, upload-time = "2026-02-02T12:36:16.748Z" }, + { url = "https://files.pythonhosted.org/packages/7c/02/be5b870d1d2be5dd6a91bdfb90f248fbb7dcbd21338f092c6b89817c3dbf/jiter-0.13.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f556aa591c00f2c45eb1b89f68f52441a016034d18b65da60e2d2875bbbf344a", size = 317507, upload-time = "2026-02-02T12:36:18.351Z" }, + { url = "https://files.pythonhosted.org/packages/da/92/b25d2ec333615f5f284f3a4024f7ce68cfa0604c322c6808b2344c7f5d2b/jiter-0.13.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f7e1d61da332ec412350463891923f960c3073cf1aae93b538f0bb4c8cd46efb", size = 350560, upload-time = "2026-02-02T12:36:19.746Z" }, + { url = "https://files.pythonhosted.org/packages/be/ec/74dcb99fef0aca9fbe56b303bf79f6bd839010cb18ad41000bf6cc71eec0/jiter-0.13.0-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:3097d665a27bc96fd9bbf7f86178037db139f319f785e4757ce7ccbf390db6c2", size = 363232, upload-time = "2026-02-02T12:36:21.243Z" }, + { url = "https://files.pythonhosted.org/packages/1b/37/f17375e0bb2f6a812d4dd92d7616e41917f740f3e71343627da9db2824ce/jiter-0.13.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9d01ecc3a8cbdb6f25a37bd500510550b64ddf9f7d64a107d92f3ccb25035d0f", size = 483727, upload-time = "2026-02-02T12:36:22.688Z" }, + { url = "https://files.pythonhosted.org/packages/77/d2/a71160a5ae1a1e66c1395b37ef77da67513b0adba73b993a27fbe47eb048/jiter-0.13.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ed9bbc30f5d60a3bdf63ae76beb3f9db280d7f195dfcfa61af792d6ce912d159", size = 370799, upload-time = "2026-02-02T12:36:24.106Z" }, + { url = "https://files.pythonhosted.org/packages/01/99/ed5e478ff0eb4e8aa5fd998f9d69603c9fd3f32de3bd16c2b1194f68361c/jiter-0.13.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:98fbafb6e88256f4454de33c1f40203d09fc33ed19162a68b3b257b29ca7f663", size = 359120, upload-time = "2026-02-02T12:36:25.519Z" }, + { url = "https://files.pythonhosted.org/packages/16/be/7ffd08203277a813f732ba897352797fa9493faf8dc7995b31f3d9cb9488/jiter-0.13.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:5467696f6b827f1116556cb0db620440380434591e93ecee7fd14d1a491b6daa", size = 390664, upload-time = "2026-02-02T12:36:26.866Z" }, + { url = "https://files.pythonhosted.org/packages/d1/84/e0787856196d6d346264d6dcccb01f741e5f0bd014c1d9a2ebe149caf4f3/jiter-0.13.0-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:2d08c9475d48b92892583df9da592a0e2ac49bcd41fae1fec4f39ba6cf107820", size = 513543, upload-time = "2026-02-02T12:36:28.217Z" }, + { url = "https://files.pythonhosted.org/packages/65/50/ecbd258181c4313cf79bca6c88fb63207d04d5bf5e4f65174114d072aa55/jiter-0.13.0-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:aed40e099404721d7fcaf5b89bd3b4568a4666358bcac7b6b15c09fb6252ab68", size = 547262, upload-time = "2026-02-02T12:36:29.678Z" }, + { url = "https://files.pythonhosted.org/packages/27/da/68f38d12e7111d2016cd198161b36e1f042bd115c169255bcb7ec823a3bf/jiter-0.13.0-cp313-cp313-win32.whl", hash = "sha256:36ebfbcffafb146d0e6ffb3e74d51e03d9c35ce7c625c8066cdbfc7b953bdc72", size = 200630, upload-time = "2026-02-02T12:36:31.808Z" }, + { url = "https://files.pythonhosted.org/packages/25/65/3bd1a972c9a08ecd22eb3b08a95d1941ebe6938aea620c246cf426ae09c2/jiter-0.13.0-cp313-cp313-win_amd64.whl", hash = "sha256:8d76029f077379374cf0dbc78dbe45b38dec4a2eb78b08b5194ce836b2517afc", size = 202602, upload-time = "2026-02-02T12:36:33.679Z" }, + { url = "https://files.pythonhosted.org/packages/15/fe/13bd3678a311aa67686bb303654792c48206a112068f8b0b21426eb6851e/jiter-0.13.0-cp313-cp313-win_arm64.whl", hash = "sha256:bb7613e1a427cfcb6ea4544f9ac566b93d5bf67e0d48c787eca673ff9c9dff2b", size = 185939, upload-time = "2026-02-02T12:36:35.065Z" }, + { url = "https://files.pythonhosted.org/packages/49/19/a929ec002ad3228bc97ca01dbb14f7632fffdc84a95ec92ceaf4145688ae/jiter-0.13.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:fa476ab5dd49f3bf3a168e05f89358c75a17608dbabb080ef65f96b27c19ab10", size = 316616, upload-time = "2026-02-02T12:36:36.579Z" }, + { url = "https://files.pythonhosted.org/packages/52/56/d19a9a194afa37c1728831e5fb81b7722c3de18a3109e8f282bfc23e587a/jiter-0.13.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ade8cb6ff5632a62b7dbd4757d8c5573f7a2e9ae285d6b5b841707d8363205ef", size = 346850, upload-time = "2026-02-02T12:36:38.058Z" }, + { url = "https://files.pythonhosted.org/packages/36/4a/94e831c6bf287754a8a019cb966ed39ff8be6ab78cadecf08df3bb02d505/jiter-0.13.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9950290340acc1adaded363edd94baebcee7dabdfa8bee4790794cd5cfad2af6", size = 358551, upload-time = "2026-02-02T12:36:39.417Z" }, + { url = "https://files.pythonhosted.org/packages/a2/ec/a4c72c822695fa80e55d2b4142b73f0012035d9fcf90eccc56bc060db37c/jiter-0.13.0-cp313-cp313t-win_amd64.whl", hash = "sha256:2b4972c6df33731aac0742b64fd0d18e0a69bc7d6e03108ce7d40c85fd9e3e6d", size = 201950, upload-time = "2026-02-02T12:36:40.791Z" }, + { url = "https://files.pythonhosted.org/packages/b6/00/393553ec27b824fbc29047e9c7cd4a3951d7fbe4a76743f17e44034fa4e4/jiter-0.13.0-cp313-cp313t-win_arm64.whl", hash = "sha256:701a1e77d1e593c1b435315ff625fd071f0998c5f02792038a5ca98899261b7d", size = 185852, upload-time = "2026-02-02T12:36:42.077Z" }, + { url = "https://files.pythonhosted.org/packages/6e/f5/f1997e987211f6f9bd71b8083047b316208b4aca0b529bb5f8c96c89ef3e/jiter-0.13.0-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:cc5223ab19fe25e2f0bf2643204ad7318896fe3729bf12fde41b77bfc4fafff0", size = 308804, upload-time = "2026-02-02T12:36:43.496Z" }, + { url = "https://files.pythonhosted.org/packages/cd/8f/5482a7677731fd44881f0204981ce2d7175db271f82cba2085dd2212e095/jiter-0.13.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:9776ebe51713acf438fd9b4405fcd86893ae5d03487546dae7f34993217f8a91", size = 318787, upload-time = "2026-02-02T12:36:45.071Z" }, + { url = "https://files.pythonhosted.org/packages/f3/b9/7257ac59778f1cd025b26a23c5520a36a424f7f1b068f2442a5b499b7464/jiter-0.13.0-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:879e768938e7b49b5e90b7e3fecc0dbec01b8cb89595861fb39a8967c5220d09", size = 353880, upload-time = "2026-02-02T12:36:47.365Z" }, + { url = "https://files.pythonhosted.org/packages/c3/87/719eec4a3f0841dad99e3d3604ee4cba36af4419a76f3cb0b8e2e691ad67/jiter-0.13.0-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:682161a67adea11e3aae9038c06c8b4a9a71023228767477d683f69903ebc607", size = 366702, upload-time = "2026-02-02T12:36:48.871Z" }, + { url = "https://files.pythonhosted.org/packages/d2/65/415f0a75cf6921e43365a1bc227c565cb949caca8b7532776e430cbaa530/jiter-0.13.0-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a13b68cd1cd8cc9de8f244ebae18ccb3e4067ad205220ef324c39181e23bbf66", size = 486319, upload-time = "2026-02-02T12:36:53.006Z" }, + { url = "https://files.pythonhosted.org/packages/54/a2/9e12b48e82c6bbc6081fd81abf915e1443add1b13d8fc586e1d90bb02bb8/jiter-0.13.0-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:87ce0f14c6c08892b610686ae8be350bf368467b6acd5085a5b65441e2bf36d2", size = 372289, upload-time = "2026-02-02T12:36:54.593Z" }, + { url = "https://files.pythonhosted.org/packages/4e/c1/e4693f107a1789a239c759a432e9afc592366f04e901470c2af89cfd28e1/jiter-0.13.0-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0c365005b05505a90d1c47856420980d0237adf82f70c4aff7aebd3c1cc143ad", size = 360165, upload-time = "2026-02-02T12:36:56.112Z" }, + { url = "https://files.pythonhosted.org/packages/17/08/91b9ea976c1c758240614bd88442681a87672eebc3d9a6dde476874e706b/jiter-0.13.0-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:1317fdffd16f5873e46ce27d0e0f7f4f90f0cdf1d86bf6abeaea9f63ca2c401d", size = 389634, upload-time = "2026-02-02T12:36:57.495Z" }, + { url = "https://files.pythonhosted.org/packages/18/23/58325ef99390d6d40427ed6005bf1ad54f2577866594bcf13ce55675f87d/jiter-0.13.0-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:c05b450d37ba0c9e21c77fef1f205f56bcee2330bddca68d344baebfc55ae0df", size = 514933, upload-time = "2026-02-02T12:36:58.909Z" }, + { url = "https://files.pythonhosted.org/packages/5b/25/69f1120c7c395fd276c3996bb8adefa9c6b84c12bb7111e5c6ccdcd8526d/jiter-0.13.0-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:775e10de3849d0631a97c603f996f518159272db00fdda0a780f81752255ee9d", size = 548842, upload-time = "2026-02-02T12:37:00.433Z" }, + { url = "https://files.pythonhosted.org/packages/18/05/981c9669d86850c5fbb0d9e62bba144787f9fba84546ba43d624ee27ef29/jiter-0.13.0-cp314-cp314-win32.whl", hash = "sha256:632bf7c1d28421c00dd8bbb8a3bac5663e1f57d5cd5ed962bce3c73bf62608e6", size = 202108, upload-time = "2026-02-02T12:37:01.718Z" }, + { url = "https://files.pythonhosted.org/packages/8d/96/cdcf54dd0b0341db7d25413229888a346c7130bd20820530905fdb65727b/jiter-0.13.0-cp314-cp314-win_amd64.whl", hash = "sha256:f22ef501c3f87ede88f23f9b11e608581c14f04db59b6a801f354397ae13739f", size = 204027, upload-time = "2026-02-02T12:37:03.075Z" }, + { url = "https://files.pythonhosted.org/packages/fb/f9/724bcaaab7a3cd727031fe4f6995cb86c4bd344909177c186699c8dec51a/jiter-0.13.0-cp314-cp314-win_arm64.whl", hash = "sha256:07b75fe09a4ee8e0c606200622e571e44943f47254f95e2436c8bdcaceb36d7d", size = 187199, upload-time = "2026-02-02T12:37:04.414Z" }, + { url = "https://files.pythonhosted.org/packages/62/92/1661d8b9fd6a3d7a2d89831db26fe3c1509a287d83ad7838831c7b7a5c7e/jiter-0.13.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:964538479359059a35fb400e769295d4b315ae61e4105396d355a12f7fef09f0", size = 318423, upload-time = "2026-02-02T12:37:05.806Z" }, + { url = "https://files.pythonhosted.org/packages/4f/3b/f77d342a54d4ebcd128e520fc58ec2f5b30a423b0fd26acdfc0c6fef8e26/jiter-0.13.0-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e104da1db1c0991b3eaed391ccd650ae8d947eab1480c733e5a3fb28d4313e40", size = 351438, upload-time = "2026-02-02T12:37:07.189Z" }, + { url = "https://files.pythonhosted.org/packages/76/b3/ba9a69f0e4209bd3331470c723c2f5509e6f0482e416b612431a5061ed71/jiter-0.13.0-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:0e3a5f0cde8ff433b8e88e41aa40131455420fb3649a3c7abdda6145f8cb7202", size = 364774, upload-time = "2026-02-02T12:37:08.579Z" }, + { url = "https://files.pythonhosted.org/packages/b3/16/6cdb31fa342932602458dbb631bfbd47f601e03d2e4950740e0b2100b570/jiter-0.13.0-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:57aab48f40be1db920a582b30b116fe2435d184f77f0e4226f546794cedd9cf0", size = 487238, upload-time = "2026-02-02T12:37:10.066Z" }, + { url = "https://files.pythonhosted.org/packages/ed/b1/956cc7abaca8d95c13aa8d6c9b3f3797241c246cd6e792934cc4c8b250d2/jiter-0.13.0-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7772115877c53f62beeb8fd853cab692dbc04374ef623b30f997959a4c0e7e95", size = 372892, upload-time = "2026-02-02T12:37:11.656Z" }, + { url = "https://files.pythonhosted.org/packages/26/c4/97ecde8b1e74f67b8598c57c6fccf6df86ea7861ed29da84629cdbba76c4/jiter-0.13.0-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1211427574b17b633cfceba5040de8081e5abf114f7a7602f73d2e16f9fdaa59", size = 360309, upload-time = "2026-02-02T12:37:13.244Z" }, + { url = "https://files.pythonhosted.org/packages/4b/d7/eabe3cf46715854ccc80be2cd78dd4c36aedeb30751dbf85a1d08c14373c/jiter-0.13.0-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:7beae3a3d3b5212d3a55d2961db3c292e02e302feb43fce6a3f7a31b90ea6dfe", size = 389607, upload-time = "2026-02-02T12:37:14.881Z" }, + { url = "https://files.pythonhosted.org/packages/df/2d/03963fc0804e6109b82decfb9974eb92df3797fe7222428cae12f8ccaa0c/jiter-0.13.0-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:e5562a0f0e90a6223b704163ea28e831bd3a9faa3512a711f031611e6b06c939", size = 514986, upload-time = "2026-02-02T12:37:16.326Z" }, + { url = "https://files.pythonhosted.org/packages/f6/6c/8c83b45eb3eb1c1e18d841fe30b4b5bc5619d781267ca9bc03e005d8fd0a/jiter-0.13.0-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:6c26a424569a59140fb51160a56df13f438a2b0967365e987889186d5fc2f6f9", size = 548756, upload-time = "2026-02-02T12:37:17.736Z" }, + { url = "https://files.pythonhosted.org/packages/47/66/eea81dfff765ed66c68fd2ed8c96245109e13c896c2a5015c7839c92367e/jiter-0.13.0-cp314-cp314t-win32.whl", hash = "sha256:24dc96eca9f84da4131cdf87a95e6ce36765c3b156fc9ae33280873b1c32d5f6", size = 201196, upload-time = "2026-02-02T12:37:19.101Z" }, + { url = "https://files.pythonhosted.org/packages/ff/32/4ac9c7a76402f8f00d00842a7f6b83b284d0cf7c1e9d4227bc95aa6d17fa/jiter-0.13.0-cp314-cp314t-win_amd64.whl", hash = "sha256:0a8d76c7524087272c8ae913f5d9d608bd839154b62c4322ef65723d2e5bb0b8", size = 204215, upload-time = "2026-02-02T12:37:20.495Z" }, + { url = "https://files.pythonhosted.org/packages/f9/8e/7def204fea9f9be8b3c21a6f2dd6c020cf56c7d5ff753e0e23ed7f9ea57e/jiter-0.13.0-cp314-cp314t-win_arm64.whl", hash = "sha256:2c26cf47e2cad140fa23b6d58d435a7c0161f5c514284802f25e87fddfe11024", size = 187152, upload-time = "2026-02-02T12:37:22.124Z" }, + { url = "https://files.pythonhosted.org/packages/80/60/e50fa45dd7e2eae049f0ce964663849e897300433921198aef94b6ffa23a/jiter-0.13.0-graalpy312-graalpy250_312_native-macosx_10_12_x86_64.whl", hash = "sha256:3d744a6061afba08dd7ae375dcde870cffb14429b7477e10f67e9e6d68772a0a", size = 305169, upload-time = "2026-02-02T12:37:50.376Z" }, + { url = "https://files.pythonhosted.org/packages/d2/73/a009f41c5eed71c49bec53036c4b33555afcdee70682a18c6f66e396c039/jiter-0.13.0-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:ff732bd0a0e778f43d5009840f20b935e79087b4dc65bd36f1cd0f9b04b8ff7f", size = 303808, upload-time = "2026-02-02T12:37:52.092Z" }, + { url = "https://files.pythonhosted.org/packages/c4/10/528b439290763bff3d939268085d03382471b442f212dca4ff5f12802d43/jiter-0.13.0-graalpy312-graalpy250_312_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ab44b178f7981fcaea7e0a5df20e773c663d06ffda0198f1a524e91b2fde7e59", size = 337384, upload-time = "2026-02-02T12:37:53.582Z" }, + { url = "https://files.pythonhosted.org/packages/67/8a/a342b2f0251f3dac4ca17618265d93bf244a2a4d089126e81e4c1056ac50/jiter-0.13.0-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7bb00b6d26db67a05fe3e12c76edc75f32077fb51deed13822dc648fa373bc19", size = 343768, upload-time = "2026-02-02T12:37:55.055Z" }, +] + +[[package]] +name = "lxml" +version = "6.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/28/30/9abc9e34c657c33834eaf6cd02124c61bdf5944d802aa48e69be8da3585d/lxml-6.1.0.tar.gz", hash = "sha256:bfd57d8008c4965709a919c3e9a98f76c2c7cb319086b3d26858250620023b13", size = 4197006, upload-time = "2026-04-18T04:32:51.613Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d2/d4/9326838b59dc36dfae42eec9656b97520f9997eee1de47b8316aaeed169c/lxml-6.1.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:d2f17a16cd8751e8eb233a7e41aecdf8e511712e00088bf9be455f604cd0d28d", size = 8570663, upload-time = "2026-04-18T04:27:48.253Z" }, + { url = "https://files.pythonhosted.org/packages/d8/a4/053745ce1f8303ccbb788b86c0db3a91b973675cefc42566a188637b7c40/lxml-6.1.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:f0cea5b1d3e6e77d71bd2b9972eb2446221a69dc52bb0b9c3c6f6e5700592d93", size = 4624024, upload-time = "2026-04-18T04:27:52.594Z" }, + { url = "https://files.pythonhosted.org/packages/90/97/a517944b20f8fd0932ad2109482bee4e29fe721416387a363306667941f6/lxml-6.1.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:fc46da94826188ed45cb53bd8e3fc076ae22675aea2087843d4735627f867c6d", size = 4930895, upload-time = "2026-04-18T04:32:56.29Z" }, + { url = "https://files.pythonhosted.org/packages/94/7c/e08a970727d556caa040a44773c7b7e3ad0f0d73dedc863543e9a8b931f2/lxml-6.1.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:9147d8e386ec3b82c3b15d88927f734f565b0aaadef7def562b853adca45784a", size = 5093820, upload-time = "2026-04-18T04:32:58.94Z" }, + { url = "https://files.pythonhosted.org/packages/88/ee/2a5c2aa2c32016a226ca25d3e1056a8102ea6e1fe308bf50213586635400/lxml-6.1.0-cp312-cp312-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5715e0e28736a070f3f34a7ccc09e2fdcba0e3060abbcf61a1a5718ff6d6b105", size = 5005790, upload-time = "2026-04-18T04:33:01.272Z" }, + { url = "https://files.pythonhosted.org/packages/e3/38/a0db9be8f38ad6043ab9429487c128dd1d30f07956ef43040402f8da49e8/lxml-6.1.0-cp312-cp312-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4937460dc5df0cdd2f06a86c285c28afda06aefa3af949f9477d3e8df430c485", size = 5630827, upload-time = "2026-04-18T04:33:04.036Z" }, + { url = "https://files.pythonhosted.org/packages/31/ba/3c13d3fc24b7cacf675f808a3a1baabf43a30d0cd24c98f94548e9aa58eb/lxml-6.1.0-cp312-cp312-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bc783ee3147e60a25aa0445ea82b3e8aabb83b240f2b95d32cb75587ff781814", size = 5240445, upload-time = "2026-04-18T04:33:06.87Z" }, + { url = "https://files.pythonhosted.org/packages/55/ba/eeef4ccba09b2212fe239f46c1692a98db1878e0872ae320756488878a94/lxml-6.1.0-cp312-cp312-manylinux_2_28_i686.whl", hash = "sha256:40d9189f80075f2e1f88db21ef815a2b17b28adf8e50aaf5c789bfe737027f32", size = 5350121, upload-time = "2026-04-18T04:33:09.365Z" }, + { url = "https://files.pythonhosted.org/packages/7e/01/1da87c7b587c38d0cbe77a01aae3b9c1c49ed47d76918ef3db8fc151b1ca/lxml-6.1.0-cp312-cp312-manylinux_2_31_armv7l.whl", hash = "sha256:05b9b8787e35bec69e68daf4952b2e6dfcfb0db7ecf1a06f8cdfbbac4eb71aad", size = 4694949, upload-time = "2026-04-18T04:33:11.628Z" }, + { url = "https://files.pythonhosted.org/packages/a1/88/7db0fe66d5aaf128443ee1623dec3db1576f3e4c17751ec0ef5866468590/lxml-6.1.0-cp312-cp312-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0f0f08beb0182e3e9a86fae124b3c47a7b41b7b69b225e1377db983802404e54", size = 5243901, upload-time = "2026-04-18T04:33:13.95Z" }, + { url = "https://files.pythonhosted.org/packages/00/a8/1346726af7d1f6fca1f11223ba34001462b0a3660416986d37641708d57c/lxml-6.1.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:73becf6d8c81d4c76b1014dbd3584cb26d904492dcf73ca85dc8bff08dcd6d2d", size = 5048054, upload-time = "2026-04-18T04:33:16.965Z" }, + { url = "https://files.pythonhosted.org/packages/2e/b7/85057012f035d1a0c87e02f8c723ca3c3e6e0728bcf4cb62080b21b1c1e3/lxml-6.1.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:1ae225f66e5938f4fa29d37e009a3bb3b13032ac57eb4eb42afa44f6e4054e69", size = 4777324, upload-time = "2026-04-18T04:33:19.832Z" }, + { url = "https://files.pythonhosted.org/packages/75/6c/ad2f94a91073ef570f33718040e8e160d5fb93331cf1ab3ca1323f939e2d/lxml-6.1.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:690022c7fae793b0489aa68a658822cea83e0d5933781811cabbf5ea3bcfe73d", size = 5645702, upload-time = "2026-04-18T04:33:22.436Z" }, + { url = "https://files.pythonhosted.org/packages/3b/89/0bb6c0bd549c19004c60eea9dc554dd78fd647b72314ef25d460e0d208c6/lxml-6.1.0-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:63aeafc26aac0be8aff14af7871249e87ea1319be92090bfd632ec68e03b16a5", size = 5232901, upload-time = "2026-04-18T04:33:26.21Z" }, + { url = "https://files.pythonhosted.org/packages/a1/d9/d609a11fb567da9399f525193e2b49847b5a409cdebe737f06a8b7126bdc/lxml-6.1.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:264c605ab9c0e4aa1a679636f4582c4d3313700009fac3ec9c3412ed0d8f3e1d", size = 5261333, upload-time = "2026-04-18T04:33:28.984Z" }, + { url = "https://files.pythonhosted.org/packages/a6/3a/ac3f99ec8ac93089e7dd556f279e0d14c24de0a74a507e143a2e4b496e7c/lxml-6.1.0-cp312-cp312-win32.whl", hash = "sha256:56971379bc5ee8037c5a0f09fa88f66cdb7d37c3e38af3e45cf539f41131ac1f", size = 3596289, upload-time = "2026-04-18T04:27:42.819Z" }, + { url = "https://files.pythonhosted.org/packages/f2/a7/0a915557538593cb1bbeedcd40e13c7a261822c26fecbbdb71dad0c2f540/lxml-6.1.0-cp312-cp312-win_amd64.whl", hash = "sha256:bba078de0031c219e5dd06cf3e6bf8fb8e6e64a77819b358f53bb132e3e03366", size = 3997059, upload-time = "2026-04-18T04:27:46.764Z" }, + { url = "https://files.pythonhosted.org/packages/92/96/a5dc078cf0126fbfbc35611d77ecd5da80054b5893e28fb213a5613b9e1d/lxml-6.1.0-cp312-cp312-win_arm64.whl", hash = "sha256:c3592631e652afa34999a088f98ba7dfc7d6aff0d535c410bea77a71743f3819", size = 3659552, upload-time = "2026-04-18T04:27:51.133Z" }, + { url = "https://files.pythonhosted.org/packages/08/03/69347590f1cf4a6d5a4944bb6099e6d37f334784f16062234e1f892fdb1d/lxml-6.1.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:a0092f2b107b69601adf562a57c956fbb596e05e3e6651cabd3054113b007e45", size = 8559689, upload-time = "2026-04-18T04:31:57.785Z" }, + { url = "https://files.pythonhosted.org/packages/3f/58/25e00bb40b185c974cfe156c110474d9a8a8390d5f7c92a4e328189bb60e/lxml-6.1.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:fc7140d7a7386e6b545d41b7358f4d02b656d4053f5fa6859f92f4b9c2572c4d", size = 4617892, upload-time = "2026-04-18T04:32:01.78Z" }, + { url = "https://files.pythonhosted.org/packages/f5/54/92ad98a94ac318dc4f97aaac22ff8d1b94212b2ae8af5b6e9b354bf825f7/lxml-6.1.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:419c58fc92cc3a2c3fa5f78c63dbf5da70c1fa9c1b25f25727ecee89a96c7de2", size = 4923489, upload-time = "2026-04-18T04:33:31.401Z" }, + { url = "https://files.pythonhosted.org/packages/15/3b/a20aecfab42bdf4f9b390590d345857ad3ffd7c51988d1c89c53a0c73faf/lxml-6.1.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:37fabd1452852636cf38ecdcc9dd5ca4bba7a35d6c53fa09725deeb894a87491", size = 5082162, upload-time = "2026-04-18T04:33:34.262Z" }, + { url = "https://files.pythonhosted.org/packages/45/26/2cdb3d281ac1bd175603e290cbe4bad6eff127c0f8de90bafd6f8548f0fd/lxml-6.1.0-cp313-cp313-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a2853c8b2170cc6cd54a6b4d50d2c1a8a7aeca201f23804b4898525c7a152cfc", size = 4993247, upload-time = "2026-04-18T04:33:36.674Z" }, + { url = "https://files.pythonhosted.org/packages/f6/05/d735aef963740022a08185c84821f689fc903acb3d50326e6b1e9886cc22/lxml-6.1.0-cp313-cp313-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8e369cbd690e788c8d15e56222d91a09c6a417f49cbc543040cba0fe2e25a79e", size = 5613042, upload-time = "2026-04-18T04:33:39.205Z" }, + { url = "https://files.pythonhosted.org/packages/ee/b8/ead7c10efff731738c72e59ed6eb5791854879fbed7ae98781a12006263a/lxml-6.1.0-cp313-cp313-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e69aa6805905807186eb00e66c6d97a935c928275182eb02ee40ba00da9623b2", size = 5228304, upload-time = "2026-04-18T04:33:41.647Z" }, + { url = "https://files.pythonhosted.org/packages/6b/10/e9842d2ec322ea65f0a7270aa0315a53abed06058b88ef1b027f620e7a5f/lxml-6.1.0-cp313-cp313-manylinux_2_28_i686.whl", hash = "sha256:4bd1bdb8a9e0e2dd229de19b5f8aebac80e916921b4b2c6ef8a52bc131d0c1f9", size = 5341578, upload-time = "2026-04-18T04:33:44.596Z" }, + { url = "https://files.pythonhosted.org/packages/89/54/40d9403d7c2775fa7301d3ddd3464689bfe9ba71acc17dfff777071b4fdc/lxml-6.1.0-cp313-cp313-manylinux_2_31_armv7l.whl", hash = "sha256:cbd7b79cdcb4986ad78a2662625882747f09db5e4cd7b2ae178a88c9c51b3dfe", size = 4700209, upload-time = "2026-04-18T04:33:47.552Z" }, + { url = "https://files.pythonhosted.org/packages/85/b2/bbdcc2cf45dfc7dfffef4fd97e5c47b15919b6a365247d95d6f684ef5e82/lxml-6.1.0-cp313-cp313-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:43e4d297f11080ec9d64a4b1ad7ac02b4484c9f0e2179d9c4ef78e886e747b88", size = 5232365, upload-time = "2026-04-18T04:33:50.249Z" }, + { url = "https://files.pythonhosted.org/packages/48/5a/b06875665e53aaba7127611a7bed3b7b9658e20b22bc2dd217a0b7ab0091/lxml-6.1.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:cc16682cc987a3da00aa56a3aa3075b08edb10d9b1e476938cfdbee8f3b67181", size = 5043654, upload-time = "2026-04-18T04:33:52.71Z" }, + { url = "https://files.pythonhosted.org/packages/e9/9c/e71a069d09641c1a7abeb30e693f828c7c90a41cbe3d650b2d734d876f85/lxml-6.1.0-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:d6d8efe71429635f0559579092bb5e60560d7b9115ee38c4adbea35632e7fa24", size = 4769326, upload-time = "2026-04-18T04:33:55.244Z" }, + { url = "https://files.pythonhosted.org/packages/cc/06/7a9cd84b3d4ed79adf35f874750abb697dec0b4a81a836037b36e47c091a/lxml-6.1.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:7e39ab3a28af7784e206d8606ec0e4bcad0190f63a492bca95e94e5a4aef7f6e", size = 5635879, upload-time = "2026-04-18T04:33:58.509Z" }, + { url = "https://files.pythonhosted.org/packages/cc/f0/9d57916befc1e54c451712c7ee48e9e74e80ae4d03bdce49914e0aee42cd/lxml-6.1.0-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:9eb667bf50856c4a58145f8ca2d5e5be160191e79eb9e30855a476191b3c3495", size = 5224048, upload-time = "2026-04-18T04:34:00.943Z" }, + { url = "https://files.pythonhosted.org/packages/99/75/90c4eefda0c08c92221fe0753db2d6699a4c628f76ff4465ec20dea84cc1/lxml-6.1.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:7f4a77d6f7edf9230cee3e1f7f6764722a41604ee5681844f18db9a81ea0ec33", size = 5250241, upload-time = "2026-04-18T04:34:03.365Z" }, + { url = "https://files.pythonhosted.org/packages/5e/73/16596f7e4e38fa33084b9ccbccc22a15f82a290a055126f2c1541236d2ff/lxml-6.1.0-cp313-cp313-win32.whl", hash = "sha256:28902146ffbe5222df411c5d19e5352490122e14447e98cd118907ee3fd6ee62", size = 3596938, upload-time = "2026-04-18T04:31:56.206Z" }, + { url = "https://files.pythonhosted.org/packages/8e/63/981401c5680c1eb30893f00a19641ac80db5d1e7086c62cb4b13ed813038/lxml-6.1.0-cp313-cp313-win_amd64.whl", hash = "sha256:4a1503c56e4e2b38dc76f2f2da7bae69670c0f1933e27cfa34b2fa5876410b16", size = 3995728, upload-time = "2026-04-18T04:31:58.763Z" }, + { url = "https://files.pythonhosted.org/packages/e7/e8/c358a38ac3e541d16a1b527e4e9cb78c0419b0506a070ace11777e5e8404/lxml-6.1.0-cp313-cp313-win_arm64.whl", hash = "sha256:e0af85773850417d994d019741239b901b22c6680206f46a34766926e466141d", size = 3658372, upload-time = "2026-04-18T04:32:03.629Z" }, + { url = "https://files.pythonhosted.org/packages/eb/45/cee4cf203ef0bab5c52afc118da61d6b460c928f2893d40023cfa27e0b80/lxml-6.1.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:ab863fd37458fed6456525f297d21239d987800c46e67da5ef04fc6b3dd93ac8", size = 8576713, upload-time = "2026-04-18T04:32:06.831Z" }, + { url = "https://files.pythonhosted.org/packages/8a/a7/eda05babeb7e046839204eaf254cd4d7c9130ce2bbf0d9e90ea41af5654d/lxml-6.1.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:6fd8b1df8254ff4fd93fd31da1fc15770bde23ac045be9bb1f87425702f61cc9", size = 4623874, upload-time = "2026-04-18T04:32:10.755Z" }, + { url = "https://files.pythonhosted.org/packages/e7/e9/db5846de9b436b91890a62f29d80cd849ea17948a49bf532d5278ee69a9e/lxml-6.1.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:47024feaae386a92a146af0d2aeed65229bf6fff738e6a11dda6b0015fb8fd03", size = 4949535, upload-time = "2026-04-18T04:34:06.657Z" }, + { url = "https://files.pythonhosted.org/packages/5a/ba/0d3593373dcae1d68f40dc3c41a5a92f2544e68115eb2f62319a4c2a6500/lxml-6.1.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3f00972f84450204cd5d93a5395965e348956aaceaadec693a22ec743f8ae3eb", size = 5086881, upload-time = "2026-04-18T04:34:09.556Z" }, + { url = "https://files.pythonhosted.org/packages/43/76/759a7484539ad1af0d125a9afe9c3fb5f82a8779fd1f5f56319d9e4ea2fd/lxml-6.1.0-cp314-cp314-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:97faa0860e13b05b15a51fb4986421ef7a30f0b3334061c416e0981e9450ca4c", size = 5031305, upload-time = "2026-04-18T04:34:12.336Z" }, + { url = "https://files.pythonhosted.org/packages/dc/b9/c1f0daf981a11e47636126901fd4ab82429e18c57aeb0fc3ad2940b42d8b/lxml-6.1.0-cp314-cp314-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:972a6451204798675407beaad97b868d0c733d9a74dafefc63120b81b8c2de28", size = 5647522, upload-time = "2026-04-18T04:34:14.89Z" }, + { url = "https://files.pythonhosted.org/packages/31/e6/1f533dcd205275363d9ba3511bcec52fa2df86abf8abe6a5f2c599f0dc31/lxml-6.1.0-cp314-cp314-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fe022f20bc4569ec66b63b3fb275a3d628d9d32da6326b2982584104db6d3086", size = 5239310, upload-time = "2026-04-18T04:34:17.652Z" }, + { url = "https://files.pythonhosted.org/packages/c3/8c/4175fb709c78a6e315ed814ed33be3defd8b8721067e70419a6cf6f971da/lxml-6.1.0-cp314-cp314-manylinux_2_28_i686.whl", hash = "sha256:75c4c7c619a744f972f4451bf5adf6d0fb00992a1ffc9fd78e13b0bc817cc99f", size = 5350799, upload-time = "2026-04-18T04:34:20.529Z" }, + { url = "https://files.pythonhosted.org/packages/fd/77/6ffdebc5994975f0dde4acb59761902bd9d9bb84422b9a0bd239a7da9ca8/lxml-6.1.0-cp314-cp314-manylinux_2_31_armv7l.whl", hash = "sha256:3648f20d25102a22b6061c688beb3a805099ea4beb0a01ce62975d926944d292", size = 4697693, upload-time = "2026-04-18T04:34:23.541Z" }, + { url = "https://files.pythonhosted.org/packages/f8/f1/565f36bd5c73294602d48e04d23f81ff4c8736be6ba5e1d1ec670ac9be80/lxml-6.1.0-cp314-cp314-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:77b9f99b17cbf14026d1e618035077060fc7195dd940d025149f3e2e830fbfcb", size = 5250708, upload-time = "2026-04-18T04:34:26.001Z" }, + { url = "https://files.pythonhosted.org/packages/5a/11/a68ab9dd18c5c499404deb4005f4bc4e0e88e5b72cd755ad96efec81d18d/lxml-6.1.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:32662519149fd7a9db354175aa5e417d83485a8039b8aaa62f873ceee7ea4cad", size = 5084737, upload-time = "2026-04-18T04:34:28.32Z" }, + { url = "https://files.pythonhosted.org/packages/ab/78/e8f41e2c74f4af564e6a0348aea69fb6daaefa64bc071ef469823d22cc18/lxml-6.1.0-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:73d658216fc173cf2c939e90e07b941c5e12736b0bf6a99e7af95459cfe8eabb", size = 4737817, upload-time = "2026-04-18T04:34:30.784Z" }, + { url = "https://files.pythonhosted.org/packages/06/2d/aa4e117aa2ce2f3b35d9ff246be74a2f8e853baba5d2a92c64744474603a/lxml-6.1.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:ac4db068889f8772a4a698c5980ec302771bb545e10c4b095d4c8be26749616f", size = 5670753, upload-time = "2026-04-18T04:34:33.675Z" }, + { url = "https://files.pythonhosted.org/packages/08/f5/dd745d50c0409031dbfcc4881740542a01e54d6f0110bd420fa7782110b8/lxml-6.1.0-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:45e9dfbd1b661eb64ba0d4dbe762bd210c42d86dd1e5bd2bdf89d634231beb43", size = 5238071, upload-time = "2026-04-18T04:34:36.12Z" }, + { url = "https://files.pythonhosted.org/packages/3e/74/ad424f36d0340a904665867dab310a3f1f4c96ff4039698de83b77f44c1f/lxml-6.1.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:89e8d73d09ac696a5ba42ec69787913d53284f12092f651506779314f10ba585", size = 5264319, upload-time = "2026-04-18T04:34:39.035Z" }, + { url = "https://files.pythonhosted.org/packages/53/36/a15d8b3514ec889bfd6aa3609107fcb6c9189f8dc347f1c0b81eded8d87c/lxml-6.1.0-cp314-cp314-win32.whl", hash = "sha256:ebe33f4ec1b2de38ceb225a1749a2965855bffeef435ba93cd2d5d540783bf2f", size = 3657139, upload-time = "2026-04-18T04:32:20.006Z" }, + { url = "https://files.pythonhosted.org/packages/1a/a4/263ebb0710851a3c6c937180a9a86df1206fdfe53cc43005aa2237fd7736/lxml-6.1.0-cp314-cp314-win_amd64.whl", hash = "sha256:398443df51c538bd578529aa7e5f7afc6c292644174b47961f3bf87fe5741120", size = 4064195, upload-time = "2026-04-18T04:32:23.876Z" }, + { url = "https://files.pythonhosted.org/packages/80/68/2000f29d323b6c286de077ad20b429fc52272e44eae6d295467043e56012/lxml-6.1.0-cp314-cp314-win_arm64.whl", hash = "sha256:8c8984e1d8c4b3949e419158fda14d921ff703a9ed8a47236c6eb7a2b6cb4946", size = 3741870, upload-time = "2026-04-18T04:32:27.922Z" }, + { url = "https://files.pythonhosted.org/packages/30/e9/21383c7c8d43799f0da90224c0d7c921870d476ec9b3e01e1b2c0b8237c5/lxml-6.1.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:1081dd10bc6fa437db2500e13993abf7cc30716d0a2f40e65abb935f02ec559c", size = 8827548, upload-time = "2026-04-18T04:32:15.094Z" }, + { url = "https://files.pythonhosted.org/packages/a5/01/c6bc11cd587030dd4f719f65c5657960649fe3e19196c844c75bf32cd0d6/lxml-6.1.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:dabecc48db5f42ba348d1f5d5afdc54c6c4cc758e676926c7cd327045749517d", size = 4735866, upload-time = "2026-04-18T04:32:18.924Z" }, + { url = "https://files.pythonhosted.org/packages/f3/01/757132fff5f4acf25463b5298f1a46099f3a94480b806547b29ce5e385de/lxml-6.1.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:e3dd5fe19c9e0ac818a9c7f132a5e43c1339ec1cbbfecb1a938bd3a47875b7c9", size = 4969476, upload-time = "2026-04-18T04:34:41.889Z" }, + { url = "https://files.pythonhosted.org/packages/fd/fb/1bc8b9d27ed64be7c8903db6c89e74dc8c2cd9ec630a7462e4654316dc5b/lxml-6.1.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:9e7b0a4ca6dcc007a4cef00a761bba2dea959de4bd2df98f926b33c92ca5dfb9", size = 5103719, upload-time = "2026-04-18T04:34:44.797Z" }, + { url = "https://files.pythonhosted.org/packages/d5/e7/5bf82fa28133536a54601aae633b14988e89ed61d4c1eb6b899b023233aa/lxml-6.1.0-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5d27bbe326c6b539c64b42638b18bc6003a8d88f76213a97ac9ed4f885efeab7", size = 5027890, upload-time = "2026-04-18T04:34:47.634Z" }, + { url = "https://files.pythonhosted.org/packages/2d/20/e048db5d4b4ea0366648aa595f26bb764b2670903fc585b87436d0a5032c/lxml-6.1.0-cp314-cp314t-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c4e425db0c5445ef0ad56b0eec54f89b88b2d884656e536a90b2f52aecb4ca86", size = 5596008, upload-time = "2026-04-18T04:34:51.503Z" }, + { url = "https://files.pythonhosted.org/packages/9a/c2/d10807bc8da4824b39e5bd01b5d05c077b6fd01bd91584167edf6b269d22/lxml-6.1.0-cp314-cp314t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4b89b098105b8599dc57adac95d1813409ac476d3c948a498775d3d0c6124bfb", size = 5224451, upload-time = "2026-04-18T04:34:54.263Z" }, + { url = "https://files.pythonhosted.org/packages/3c/15/2ebea45bea427e7f0057e9ce7b2d62c5aba20c6b001cca89ed0aadb3ad41/lxml-6.1.0-cp314-cp314t-manylinux_2_28_i686.whl", hash = "sha256:c4a699432846df86cc3de502ee85f445ebad748a1c6021d445f3e514d2cd4b1c", size = 5312135, upload-time = "2026-04-18T04:34:56.818Z" }, + { url = "https://files.pythonhosted.org/packages/31/e2/87eeae151b0be2a308d49a7ec444ff3eb192b14251e62addb29d0bf3778f/lxml-6.1.0-cp314-cp314t-manylinux_2_31_armv7l.whl", hash = "sha256:30e7b2ed63b6c8e97cca8af048589a788ab5c9c905f36d9cf1c2bb549f450d2f", size = 4639126, upload-time = "2026-04-18T04:34:59.704Z" }, + { url = "https://files.pythonhosted.org/packages/a3/51/8a3f6a20902ad604dd746ec7b4000311b240d389dac5e9d95adefd349e0c/lxml-6.1.0-cp314-cp314t-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:022981127642fe19866d2907d76241bb07ed21749601f727d5d5dd1ce5d1b773", size = 5232579, upload-time = "2026-04-18T04:35:02.658Z" }, + { url = "https://files.pythonhosted.org/packages/6d/d2/650d619bdbe048d2c3f2c31edb00e35670a5e2d65b4fe3b61bce37b19121/lxml-6.1.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:23cad0cc86046d4222f7f418910e46b89971c5a45d3c8abfad0f64b7b05e4a9b", size = 5084206, upload-time = "2026-04-18T04:35:05.175Z" }, + { url = "https://files.pythonhosted.org/packages/dd/8a/672ca1a3cbeabd1f511ca275a916c0514b747f4b85bdaae103b8fa92f307/lxml-6.1.0-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:21c3302068f50d1e8728c67c87ba92aa87043abee517aa2576cca1855326b405", size = 4758906, upload-time = "2026-04-18T04:35:08.098Z" }, + { url = "https://files.pythonhosted.org/packages/be/f1/ef4b691da85c916cb2feb1eec7414f678162798ac85e042fa164419ac05c/lxml-6.1.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:be10838781cb3be19251e276910cd508fe127e27c3242e50521521a0f3781690", size = 5620553, upload-time = "2026-04-18T04:35:11.23Z" }, + { url = "https://files.pythonhosted.org/packages/59/17/94e81def74107809755ac2782fdad4404420f1c92ca83433d117a6d5acf0/lxml-6.1.0-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:2173a7bffe97667bbf0767f8a99e587740a8c56fdf3befac4b09cb29a80276fd", size = 5229458, upload-time = "2026-04-18T04:35:14.254Z" }, + { url = "https://files.pythonhosted.org/packages/21/55/c4be91b0f830a871fc1b0d730943d56013b683d4671d5198260e2eae722b/lxml-6.1.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:c6854e9cf99c84beb004eecd7d3a3868ef1109bf2b1df92d7bc11e96a36c2180", size = 5247861, upload-time = "2026-04-18T04:35:17.006Z" }, + { url = "https://files.pythonhosted.org/packages/c2/ca/77123e4d77df3cb1e968ade7b1f808f5d3a5c1c96b18a33895397de292c1/lxml-6.1.0-cp314-cp314t-win32.whl", hash = "sha256:00750d63ef0031a05331b9223463b1c7c02b9004cef2346a5b2877f0f9494dd2", size = 3897377, upload-time = "2026-04-18T04:32:07.656Z" }, + { url = "https://files.pythonhosted.org/packages/64/ce/3554833989d074267c063209bae8b09815e5656456a2d332b947806b05ff/lxml-6.1.0-cp314-cp314t-win_amd64.whl", hash = "sha256:80410c3a7e3c617af04de17caa9f9f20adaa817093293d69eae7d7d0522836f5", size = 4392701, upload-time = "2026-04-18T04:32:12.113Z" }, + { url = "https://files.pythonhosted.org/packages/2b/a0/9b916c68c0e57752c07f8f64b30138d9d4059dbeb27b90274dedbea128ff/lxml-6.1.0-cp314-cp314t-win_arm64.whl", hash = "sha256:26dd9f57ee3bd41e7d35b4c98a2ffd89ed11591649f421f0ec19f67d50ec67ac", size = 3817120, upload-time = "2026-04-18T04:32:15.803Z" }, +] + +[[package]] +name = "multidict" +version = "6.7.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/1a/c2/c2d94cbe6ac1753f3fc980da97b3d930efe1da3af3c9f5125354436c073d/multidict-6.7.1.tar.gz", hash = "sha256:ec6652a1bee61c53a3e5776b6049172c53b6aaba34f18c9ad04f82712bac623d", size = 102010, upload-time = "2026-01-26T02:46:45.979Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8d/9c/f20e0e2cf80e4b2e4b1c365bf5fe104ee633c751a724246262db8f1a0b13/multidict-6.7.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:a90f75c956e32891a4eda3639ce6dd86e87105271f43d43442a3aedf3cddf172", size = 76893, upload-time = "2026-01-26T02:43:52.754Z" }, + { url = "https://files.pythonhosted.org/packages/fe/cf/18ef143a81610136d3da8193da9d80bfe1cb548a1e2d1c775f26b23d024a/multidict-6.7.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:3fccb473e87eaa1382689053e4a4618e7ba7b9b9b8d6adf2027ee474597128cd", size = 45456, upload-time = "2026-01-26T02:43:53.893Z" }, + { url = "https://files.pythonhosted.org/packages/a9/65/1caac9d4cd32e8433908683446eebc953e82d22b03d10d41a5f0fefe991b/multidict-6.7.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:b0fa96985700739c4c7853a43c0b3e169360d6855780021bfc6d0f1ce7c123e7", size = 43872, upload-time = "2026-01-26T02:43:55.041Z" }, + { url = "https://files.pythonhosted.org/packages/cf/3b/d6bd75dc4f3ff7c73766e04e705b00ed6dbbaccf670d9e05a12b006f5a21/multidict-6.7.1-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:cb2a55f408c3043e42b40cc8eecd575afa27b7e0b956dfb190de0f8499a57a53", size = 251018, upload-time = "2026-01-26T02:43:56.198Z" }, + { url = "https://files.pythonhosted.org/packages/fd/80/c959c5933adedb9ac15152e4067c702a808ea183a8b64cf8f31af8ad3155/multidict-6.7.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:eb0ce7b2a32d09892b3dd6cc44877a0d02a33241fafca5f25c8b6b62374f8b75", size = 258883, upload-time = "2026-01-26T02:43:57.499Z" }, + { url = "https://files.pythonhosted.org/packages/86/85/7ed40adafea3d4f1c8b916e3b5cc3a8e07dfcdcb9cd72800f4ed3ca1b387/multidict-6.7.1-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:c3a32d23520ee37bf327d1e1a656fec76a2edd5c038bf43eddfa0572ec49c60b", size = 242413, upload-time = "2026-01-26T02:43:58.755Z" }, + { url = "https://files.pythonhosted.org/packages/d2/57/b8565ff533e48595503c785f8361ff9a4fde4d67de25c207cd0ba3befd03/multidict-6.7.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9c90fed18bffc0189ba814749fdcc102b536e83a9f738a9003e569acd540a733", size = 268404, upload-time = "2026-01-26T02:44:00.216Z" }, + { url = "https://files.pythonhosted.org/packages/e0/50/9810c5c29350f7258180dfdcb2e52783a0632862eb334c4896ac717cebcb/multidict-6.7.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:da62917e6076f512daccfbbde27f46fed1c98fee202f0559adec8ee0de67f71a", size = 269456, upload-time = "2026-01-26T02:44:02.202Z" }, + { url = "https://files.pythonhosted.org/packages/f3/8d/5e5be3ced1d12966fefb5c4ea3b2a5b480afcea36406559442c6e31d4a48/multidict-6.7.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bfde23ef6ed9db7eaee6c37dcec08524cb43903c60b285b172b6c094711b3961", size = 256322, upload-time = "2026-01-26T02:44:03.56Z" }, + { url = "https://files.pythonhosted.org/packages/31/6e/d8a26d81ac166a5592782d208dd90dfdc0a7a218adaa52b45a672b46c122/multidict-6.7.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3758692429e4e32f1ba0df23219cd0b4fc0a52f476726fff9337d1a57676a582", size = 253955, upload-time = "2026-01-26T02:44:04.845Z" }, + { url = "https://files.pythonhosted.org/packages/59/4c/7c672c8aad41534ba619bcd4ade7a0dc87ed6b8b5c06149b85d3dd03f0cd/multidict-6.7.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:398c1478926eca669f2fd6a5856b6de9c0acf23a2cb59a14c0ba5844fa38077e", size = 251254, upload-time = "2026-01-26T02:44:06.133Z" }, + { url = "https://files.pythonhosted.org/packages/7b/bd/84c24de512cbafbdbc39439f74e967f19570ce7924e3007174a29c348916/multidict-6.7.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:c102791b1c4f3ab36ce4101154549105a53dc828f016356b3e3bcae2e3a039d3", size = 252059, upload-time = "2026-01-26T02:44:07.518Z" }, + { url = "https://files.pythonhosted.org/packages/fa/ba/f5449385510825b73d01c2d4087bf6d2fccc20a2d42ac34df93191d3dd03/multidict-6.7.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:a088b62bd733e2ad12c50dad01b7d0166c30287c166e137433d3b410add807a6", size = 263588, upload-time = "2026-01-26T02:44:09.382Z" }, + { url = "https://files.pythonhosted.org/packages/d7/11/afc7c677f68f75c84a69fe37184f0f82fce13ce4b92f49f3db280b7e92b3/multidict-6.7.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:3d51ff4785d58d3f6c91bdbffcb5e1f7ddfda557727043aa20d20ec4f65e324a", size = 259642, upload-time = "2026-01-26T02:44:10.73Z" }, + { url = "https://files.pythonhosted.org/packages/2b/17/ebb9644da78c4ab36403739e0e6e0e30ebb135b9caf3440825001a0bddcb/multidict-6.7.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fc5907494fccf3e7d3f94f95c91d6336b092b5fc83811720fae5e2765890dfba", size = 251377, upload-time = "2026-01-26T02:44:12.042Z" }, + { url = "https://files.pythonhosted.org/packages/ca/a4/840f5b97339e27846c46307f2530a2805d9d537d8b8bd416af031cad7fa0/multidict-6.7.1-cp312-cp312-win32.whl", hash = "sha256:28ca5ce2fd9716631133d0e9a9b9a745ad7f60bac2bccafb56aa380fc0b6c511", size = 41887, upload-time = "2026-01-26T02:44:14.245Z" }, + { url = "https://files.pythonhosted.org/packages/80/31/0b2517913687895f5904325c2069d6a3b78f66cc641a86a2baf75a05dcbb/multidict-6.7.1-cp312-cp312-win_amd64.whl", hash = "sha256:fcee94dfbd638784645b066074b338bc9cc155d4b4bffa4adce1615c5a426c19", size = 46053, upload-time = "2026-01-26T02:44:15.371Z" }, + { url = "https://files.pythonhosted.org/packages/0c/5b/aba28e4ee4006ae4c7df8d327d31025d760ffa992ea23812a601d226e682/multidict-6.7.1-cp312-cp312-win_arm64.whl", hash = "sha256:ba0a9fb644d0c1a2194cf7ffb043bd852cea63a57f66fbd33959f7dae18517bf", size = 43307, upload-time = "2026-01-26T02:44:16.852Z" }, + { url = "https://files.pythonhosted.org/packages/f2/22/929c141d6c0dba87d3e1d38fbdf1ba8baba86b7776469f2bc2d3227a1e67/multidict-6.7.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:2b41f5fed0ed563624f1c17630cb9941cf2309d4df00e494b551b5f3e3d67a23", size = 76174, upload-time = "2026-01-26T02:44:18.509Z" }, + { url = "https://files.pythonhosted.org/packages/c7/75/bc704ae15fee974f8fccd871305e254754167dce5f9e42d88a2def741a1d/multidict-6.7.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:84e61e3af5463c19b67ced91f6c634effb89ef8bfc5ca0267f954451ed4bb6a2", size = 45116, upload-time = "2026-01-26T02:44:19.745Z" }, + { url = "https://files.pythonhosted.org/packages/79/76/55cd7186f498ed080a18440c9013011eb548f77ae1b297206d030eb1180a/multidict-6.7.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:935434b9853c7c112eee7ac891bc4cb86455aa631269ae35442cb316790c1445", size = 43524, upload-time = "2026-01-26T02:44:21.571Z" }, + { url = "https://files.pythonhosted.org/packages/e9/3c/414842ef8d5a1628d68edee29ba0e5bcf235dbfb3ccd3ea303a7fe8c72ff/multidict-6.7.1-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:432feb25a1cb67fe82a9680b4d65fb542e4635cb3166cd9c01560651ad60f177", size = 249368, upload-time = "2026-01-26T02:44:22.803Z" }, + { url = "https://files.pythonhosted.org/packages/f6/32/befed7f74c458b4a525e60519fe8d87eef72bb1e99924fa2b0f9d97a221e/multidict-6.7.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e82d14e3c948952a1a85503817e038cba5905a3352de76b9a465075d072fba23", size = 256952, upload-time = "2026-01-26T02:44:24.306Z" }, + { url = "https://files.pythonhosted.org/packages/03/d6/c878a44ba877f366630c860fdf74bfb203c33778f12b6ac274936853c451/multidict-6.7.1-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:4cfb48c6ea66c83bcaaf7e4dfa7ec1b6bbcf751b7db85a328902796dfde4c060", size = 240317, upload-time = "2026-01-26T02:44:25.772Z" }, + { url = "https://files.pythonhosted.org/packages/68/49/57421b4d7ad2e9e60e25922b08ceb37e077b90444bde6ead629095327a6f/multidict-6.7.1-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:1d540e51b7e8e170174555edecddbd5538105443754539193e3e1061864d444d", size = 267132, upload-time = "2026-01-26T02:44:27.648Z" }, + { url = "https://files.pythonhosted.org/packages/b7/fe/ec0edd52ddbcea2a2e89e174f0206444a61440b40f39704e64dc807a70bd/multidict-6.7.1-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:273d23f4b40f3dce4d6c8a821c741a86dec62cded82e1175ba3d99be128147ed", size = 268140, upload-time = "2026-01-26T02:44:29.588Z" }, + { url = "https://files.pythonhosted.org/packages/b0/73/6e1b01cbeb458807aa0831742232dbdd1fa92bfa33f52a3f176b4ff3dc11/multidict-6.7.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9d624335fd4fa1c08a53f8b4be7676ebde19cd092b3895c421045ca87895b429", size = 254277, upload-time = "2026-01-26T02:44:30.902Z" }, + { url = "https://files.pythonhosted.org/packages/6a/b2/5fb8c124d7561a4974c342bc8c778b471ebbeb3cc17df696f034a7e9afe7/multidict-6.7.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:12fad252f8b267cc75b66e8fc51b3079604e8d43a75428ffe193cd9e2195dfd6", size = 252291, upload-time = "2026-01-26T02:44:32.31Z" }, + { url = "https://files.pythonhosted.org/packages/5a/96/51d4e4e06bcce92577fcd488e22600bd38e4fd59c20cb49434d054903bd2/multidict-6.7.1-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:03ede2a6ffbe8ef936b92cb4529f27f42be7f56afcdab5ab739cd5f27fb1cbf9", size = 250156, upload-time = "2026-01-26T02:44:33.734Z" }, + { url = "https://files.pythonhosted.org/packages/db/6b/420e173eec5fba721a50e2a9f89eda89d9c98fded1124f8d5c675f7a0c0f/multidict-6.7.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:90efbcf47dbe33dcf643a1e400d67d59abeac5db07dc3f27d6bdeae497a2198c", size = 249742, upload-time = "2026-01-26T02:44:35.222Z" }, + { url = "https://files.pythonhosted.org/packages/44/a3/ec5b5bd98f306bc2aa297b8c6f11a46714a56b1e6ef5ebda50a4f5d7c5fb/multidict-6.7.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:5c4b9bfc148f5a91be9244d6264c53035c8a0dcd2f51f1c3c6e30e30ebaa1c84", size = 262221, upload-time = "2026-01-26T02:44:36.604Z" }, + { url = "https://files.pythonhosted.org/packages/cd/f7/e8c0d0da0cd1e28d10e624604e1a36bcc3353aaebdfdc3a43c72bc683a12/multidict-6.7.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:401c5a650f3add2472d1d288c26deebc540f99e2fb83e9525007a74cd2116f1d", size = 258664, upload-time = "2026-01-26T02:44:38.008Z" }, + { url = "https://files.pythonhosted.org/packages/52/da/151a44e8016dd33feed44f730bd856a66257c1ee7aed4f44b649fb7edeb3/multidict-6.7.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:97891f3b1b3ffbded884e2916cacf3c6fc87b66bb0dde46f7357404750559f33", size = 249490, upload-time = "2026-01-26T02:44:39.386Z" }, + { url = "https://files.pythonhosted.org/packages/87/af/a3b86bf9630b732897f6fc3f4c4714b90aa4361983ccbdcd6c0339b21b0c/multidict-6.7.1-cp313-cp313-win32.whl", hash = "sha256:e1c5988359516095535c4301af38d8a8838534158f649c05dd1050222321bcb3", size = 41695, upload-time = "2026-01-26T02:44:41.318Z" }, + { url = "https://files.pythonhosted.org/packages/b2/35/e994121b0e90e46134673422dd564623f93304614f5d11886b1b3e06f503/multidict-6.7.1-cp313-cp313-win_amd64.whl", hash = "sha256:960c83bf01a95b12b08fd54324a4eb1d5b52c88932b5cba5d6e712bb3ed12eb5", size = 45884, upload-time = "2026-01-26T02:44:42.488Z" }, + { url = "https://files.pythonhosted.org/packages/ca/61/42d3e5dbf661242a69c97ea363f2d7b46c567da8eadef8890022be6e2ab0/multidict-6.7.1-cp313-cp313-win_arm64.whl", hash = "sha256:563fe25c678aaba333d5399408f5ec3c383ca5b663e7f774dd179a520b8144df", size = 43122, upload-time = "2026-01-26T02:44:43.664Z" }, + { url = "https://files.pythonhosted.org/packages/6d/b3/e6b21c6c4f314bb956016b0b3ef2162590a529b84cb831c257519e7fde44/multidict-6.7.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:c76c4bec1538375dad9d452d246ca5368ad6e1c9039dadcf007ae59c70619ea1", size = 83175, upload-time = "2026-01-26T02:44:44.894Z" }, + { url = "https://files.pythonhosted.org/packages/fb/76/23ecd2abfe0957b234f6c960f4ade497f55f2c16aeb684d4ecdbf1c95791/multidict-6.7.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:57b46b24b5d5ebcc978da4ec23a819a9402b4228b8a90d9c656422b4bdd8a963", size = 48460, upload-time = "2026-01-26T02:44:46.106Z" }, + { url = "https://files.pythonhosted.org/packages/c4/57/a0ed92b23f3a042c36bc4227b72b97eca803f5f1801c1ab77c8a212d455e/multidict-6.7.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:e954b24433c768ce78ab7929e84ccf3422e46deb45a4dc9f93438f8217fa2d34", size = 46930, upload-time = "2026-01-26T02:44:47.278Z" }, + { url = "https://files.pythonhosted.org/packages/b5/66/02ec7ace29162e447f6382c495dc95826bf931d3818799bbef11e8f7df1a/multidict-6.7.1-cp313-cp313t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:3bd231490fa7217cc832528e1cd8752a96f0125ddd2b5749390f7c3ec8721b65", size = 242582, upload-time = "2026-01-26T02:44:48.604Z" }, + { url = "https://files.pythonhosted.org/packages/58/18/64f5a795e7677670e872673aca234162514696274597b3708b2c0d276cce/multidict-6.7.1-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:253282d70d67885a15c8a7716f3a73edf2d635793ceda8173b9ecc21f2fb8292", size = 250031, upload-time = "2026-01-26T02:44:50.544Z" }, + { url = "https://files.pythonhosted.org/packages/c8/ed/e192291dbbe51a8290c5686f482084d31bcd9d09af24f63358c3d42fd284/multidict-6.7.1-cp313-cp313t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:0b4c48648d7649c9335cf1927a8b87fa692de3dcb15faa676c6a6f1f1aabda43", size = 228596, upload-time = "2026-01-26T02:44:51.951Z" }, + { url = "https://files.pythonhosted.org/packages/1e/7e/3562a15a60cf747397e7f2180b0a11dc0c38d9175a650e75fa1b4d325e15/multidict-6.7.1-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:98bc624954ec4d2c7cb074b8eefc2b5d0ce7d482e410df446414355d158fe4ca", size = 257492, upload-time = "2026-01-26T02:44:53.902Z" }, + { url = "https://files.pythonhosted.org/packages/24/02/7d0f9eae92b5249bb50ac1595b295f10e263dd0078ebb55115c31e0eaccd/multidict-6.7.1-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:1b99af4d9eec0b49927b4402bcbb58dea89d3e0db8806a4086117019939ad3dd", size = 255899, upload-time = "2026-01-26T02:44:55.316Z" }, + { url = "https://files.pythonhosted.org/packages/00/e3/9b60ed9e23e64c73a5cde95269ef1330678e9c6e34dd4eb6b431b85b5a10/multidict-6.7.1-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6aac4f16b472d5b7dc6f66a0d49dd57b0e0902090be16594dc9ebfd3d17c47e7", size = 247970, upload-time = "2026-01-26T02:44:56.783Z" }, + { url = "https://files.pythonhosted.org/packages/3e/06/538e58a63ed5cfb0bd4517e346b91da32fde409d839720f664e9a4ae4f9d/multidict-6.7.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:21f830fe223215dffd51f538e78c172ed7c7f60c9b96a2bf05c4848ad49921c3", size = 245060, upload-time = "2026-01-26T02:44:58.195Z" }, + { url = "https://files.pythonhosted.org/packages/b2/2f/d743a3045a97c895d401e9bd29aaa09b94f5cbdf1bd561609e5a6c431c70/multidict-6.7.1-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:f5dd81c45b05518b9aa4da4aa74e1c93d715efa234fd3e8a179df611cc85e5f4", size = 235888, upload-time = "2026-01-26T02:44:59.57Z" }, + { url = "https://files.pythonhosted.org/packages/38/83/5a325cac191ab28b63c52f14f1131f3b0a55ba3b9aa65a6d0bf2a9b921a0/multidict-6.7.1-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:eb304767bca2bb92fb9c5bd33cedc95baee5bb5f6c88e63706533a1c06ad08c8", size = 243554, upload-time = "2026-01-26T02:45:01.054Z" }, + { url = "https://files.pythonhosted.org/packages/20/1f/9d2327086bd15da2725ef6aae624208e2ef828ed99892b17f60c344e57ed/multidict-6.7.1-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:c9035dde0f916702850ef66460bc4239d89d08df4d02023a5926e7446724212c", size = 252341, upload-time = "2026-01-26T02:45:02.484Z" }, + { url = "https://files.pythonhosted.org/packages/e8/2c/2a1aa0280cf579d0f6eed8ee5211c4f1730bd7e06c636ba2ee6aafda302e/multidict-6.7.1-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:af959b9beeb66c822380f222f0e0a1889331597e81f1ded7f374f3ecb0fd6c52", size = 246391, upload-time = "2026-01-26T02:45:03.862Z" }, + { url = "https://files.pythonhosted.org/packages/e5/03/7ca022ffc36c5a3f6e03b179a5ceb829be9da5783e6fe395f347c0794680/multidict-6.7.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:41f2952231456154ee479651491e94118229844dd7226541788be783be2b5108", size = 243422, upload-time = "2026-01-26T02:45:05.296Z" }, + { url = "https://files.pythonhosted.org/packages/dc/1d/b31650eab6c5778aceed46ba735bd97f7c7d2f54b319fa916c0f96e7805b/multidict-6.7.1-cp313-cp313t-win32.whl", hash = "sha256:df9f19c28adcb40b6aae30bbaa1478c389efd50c28d541d76760199fc1037c32", size = 47770, upload-time = "2026-01-26T02:45:06.754Z" }, + { url = "https://files.pythonhosted.org/packages/ac/5b/2d2d1d522e51285bd61b1e20df8f47ae1a9d80839db0b24ea783b3832832/multidict-6.7.1-cp313-cp313t-win_amd64.whl", hash = "sha256:d54ecf9f301853f2c5e802da559604b3e95bb7a3b01a9c295c6ee591b9882de8", size = 53109, upload-time = "2026-01-26T02:45:08.044Z" }, + { url = "https://files.pythonhosted.org/packages/3d/a3/cc409ba012c83ca024a308516703cf339bdc4b696195644a7215a5164a24/multidict-6.7.1-cp313-cp313t-win_arm64.whl", hash = "sha256:5a37ca18e360377cfda1d62f5f382ff41f2b8c4ccb329ed974cc2e1643440118", size = 45573, upload-time = "2026-01-26T02:45:09.349Z" }, + { url = "https://files.pythonhosted.org/packages/91/cc/db74228a8be41884a567e88a62fd589a913708fcf180d029898c17a9a371/multidict-6.7.1-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:8f333ec9c5eb1b7105e3b84b53141e66ca05a19a605368c55450b6ba208cb9ee", size = 75190, upload-time = "2026-01-26T02:45:10.651Z" }, + { url = "https://files.pythonhosted.org/packages/d5/22/492f2246bb5b534abd44804292e81eeaf835388901f0c574bac4eeec73c5/multidict-6.7.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:a407f13c188f804c759fc6a9f88286a565c242a76b27626594c133b82883b5c2", size = 44486, upload-time = "2026-01-26T02:45:11.938Z" }, + { url = "https://files.pythonhosted.org/packages/f1/4f/733c48f270565d78b4544f2baddc2fb2a245e5a8640254b12c36ac7ac68e/multidict-6.7.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:0e161ddf326db5577c3a4cc2d8648f81456e8a20d40415541587a71620d7a7d1", size = 43219, upload-time = "2026-01-26T02:45:14.346Z" }, + { url = "https://files.pythonhosted.org/packages/24/bb/2c0c2287963f4259c85e8bcbba9182ced8d7fca65c780c38e99e61629d11/multidict-6.7.1-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:1e3a8bb24342a8201d178c3b4984c26ba81a577c80d4d525727427460a50c22d", size = 245132, upload-time = "2026-01-26T02:45:15.712Z" }, + { url = "https://files.pythonhosted.org/packages/a7/f9/44d4b3064c65079d2467888794dea218d1601898ac50222ab8a9a8094460/multidict-6.7.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:97231140a50f5d447d3164f994b86a0bed7cd016e2682f8650d6a9158e14fd31", size = 252420, upload-time = "2026-01-26T02:45:17.293Z" }, + { url = "https://files.pythonhosted.org/packages/8b/13/78f7275e73fa17b24c9a51b0bd9d73ba64bb32d0ed51b02a746eb876abe7/multidict-6.7.1-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:6b10359683bd8806a200fd2909e7c8ca3a7b24ec1d8132e483d58e791d881048", size = 233510, upload-time = "2026-01-26T02:45:19.356Z" }, + { url = "https://files.pythonhosted.org/packages/4b/25/8167187f62ae3cbd52da7893f58cb036b47ea3fb67138787c76800158982/multidict-6.7.1-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:283ddac99f7ac25a4acadbf004cb5ae34480bbeb063520f70ce397b281859362", size = 264094, upload-time = "2026-01-26T02:45:20.834Z" }, + { url = "https://files.pythonhosted.org/packages/a1/e7/69a3a83b7b030cf283fb06ce074a05a02322359783424d7edf0f15fe5022/multidict-6.7.1-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:538cec1e18c067d0e6103aa9a74f9e832904c957adc260e61cd9d8cf0c3b3d37", size = 260786, upload-time = "2026-01-26T02:45:22.818Z" }, + { url = "https://files.pythonhosted.org/packages/fe/3b/8ec5074bcfc450fe84273713b4b0a0dd47c0249358f5d82eb8104ffe2520/multidict-6.7.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7eee46ccb30ff48a1e35bb818cc90846c6be2b68240e42a78599166722cea709", size = 248483, upload-time = "2026-01-26T02:45:24.368Z" }, + { url = "https://files.pythonhosted.org/packages/48/5a/d5a99e3acbca0e29c5d9cba8f92ceb15dce78bab963b308ae692981e3a5d/multidict-6.7.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:fa263a02f4f2dd2d11a7b1bb4362aa7cb1049f84a9235d31adf63f30143469a0", size = 248403, upload-time = "2026-01-26T02:45:25.982Z" }, + { url = "https://files.pythonhosted.org/packages/35/48/e58cd31f6c7d5102f2a4bf89f96b9cf7e00b6c6f3d04ecc44417c00a5a3c/multidict-6.7.1-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:2e1425e2f99ec5bd36c15a01b690a1a2456209c5deed58f95469ffb46039ccbb", size = 240315, upload-time = "2026-01-26T02:45:27.487Z" }, + { url = "https://files.pythonhosted.org/packages/94/33/1cd210229559cb90b6786c30676bb0c58249ff42f942765f88793b41fdce/multidict-6.7.1-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:497394b3239fc6f0e13a78a3e1b61296e72bf1c5f94b4c4eb80b265c37a131cd", size = 245528, upload-time = "2026-01-26T02:45:28.991Z" }, + { url = "https://files.pythonhosted.org/packages/64/f2/6e1107d226278c876c783056b7db43d800bb64c6131cec9c8dfb6903698e/multidict-6.7.1-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:233b398c29d3f1b9676b4b6f75c518a06fcb2ea0b925119fb2c1bc35c05e1601", size = 258784, upload-time = "2026-01-26T02:45:30.503Z" }, + { url = "https://files.pythonhosted.org/packages/4d/c1/11f664f14d525e4a1b5327a82d4de61a1db604ab34c6603bb3c2cc63ad34/multidict-6.7.1-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:93b1818e4a6e0930454f0f2af7dfce69307ca03cdcfb3739bf4d91241967b6c1", size = 251980, upload-time = "2026-01-26T02:45:32.603Z" }, + { url = "https://files.pythonhosted.org/packages/e1/9f/75a9ac888121d0c5bbd4ecf4eead45668b1766f6baabfb3b7f66a410e231/multidict-6.7.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:f33dc2a3abe9249ea5d8360f969ec7f4142e7ac45ee7014d8f8d5acddf178b7b", size = 243602, upload-time = "2026-01-26T02:45:34.043Z" }, + { url = "https://files.pythonhosted.org/packages/9a/e7/50bf7b004cc8525d80dbbbedfdc7aed3e4c323810890be4413e589074032/multidict-6.7.1-cp314-cp314-win32.whl", hash = "sha256:3ab8b9d8b75aef9df299595d5388b14530839f6422333357af1339443cff777d", size = 40930, upload-time = "2026-01-26T02:45:36.278Z" }, + { url = "https://files.pythonhosted.org/packages/e0/bf/52f25716bbe93745595800f36fb17b73711f14da59ed0bb2eba141bc9f0f/multidict-6.7.1-cp314-cp314-win_amd64.whl", hash = "sha256:5e01429a929600e7dab7b166062d9bb54a5eed752384c7384c968c2afab8f50f", size = 45074, upload-time = "2026-01-26T02:45:37.546Z" }, + { url = "https://files.pythonhosted.org/packages/97/ab/22803b03285fa3a525f48217963da3a65ae40f6a1b6f6cf2768879e208f9/multidict-6.7.1-cp314-cp314-win_arm64.whl", hash = "sha256:4885cb0e817aef5d00a2e8451d4665c1808378dc27c2705f1bf4ef8505c0d2e5", size = 42471, upload-time = "2026-01-26T02:45:38.889Z" }, + { url = "https://files.pythonhosted.org/packages/e0/6d/f9293baa6146ba9507e360ea0292b6422b016907c393e2f63fc40ab7b7b5/multidict-6.7.1-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:0458c978acd8e6ea53c81eefaddbbee9c6c5e591f41b3f5e8e194780fe026581", size = 82401, upload-time = "2026-01-26T02:45:40.254Z" }, + { url = "https://files.pythonhosted.org/packages/7a/68/53b5494738d83558d87c3c71a486504d8373421c3e0dbb6d0db48ad42ee0/multidict-6.7.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:c0abd12629b0af3cf590982c0b413b1e7395cd4ec026f30986818ab95bfaa94a", size = 48143, upload-time = "2026-01-26T02:45:41.635Z" }, + { url = "https://files.pythonhosted.org/packages/37/e8/5284c53310dcdc99ce5d66563f6e5773531a9b9fe9ec7a615e9bc306b05f/multidict-6.7.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:14525a5f61d7d0c94b368a42cff4c9a4e7ba2d52e2672a7b23d84dc86fb02b0c", size = 46507, upload-time = "2026-01-26T02:45:42.99Z" }, + { url = "https://files.pythonhosted.org/packages/e4/fc/6800d0e5b3875568b4083ecf5f310dcf91d86d52573160834fb4bfcf5e4f/multidict-6.7.1-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:17307b22c217b4cf05033dabefe68255a534d637c6c9b0cc8382718f87be4262", size = 239358, upload-time = "2026-01-26T02:45:44.376Z" }, + { url = "https://files.pythonhosted.org/packages/41/75/4ad0973179361cdf3a113905e6e088173198349131be2b390f9fa4da5fc6/multidict-6.7.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7a7e590ff876a3eaf1c02a4dfe0724b6e69a9e9de6d8f556816f29c496046e59", size = 246884, upload-time = "2026-01-26T02:45:47.167Z" }, + { url = "https://files.pythonhosted.org/packages/c3/9c/095bb28b5da139bd41fb9a5d5caff412584f377914bd8787c2aa98717130/multidict-6.7.1-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:5fa6a95dfee63893d80a34758cd0e0c118a30b8dcb46372bf75106c591b77889", size = 225878, upload-time = "2026-01-26T02:45:48.698Z" }, + { url = "https://files.pythonhosted.org/packages/07/d0/c0a72000243756e8f5a277b6b514fa005f2c73d481b7d9e47cd4568aa2e4/multidict-6.7.1-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a0543217a6a017692aa6ae5cc39adb75e587af0f3a82288b1492eb73dd6cc2a4", size = 253542, upload-time = "2026-01-26T02:45:50.164Z" }, + { url = "https://files.pythonhosted.org/packages/c0/6b/f69da15289e384ecf2a68837ec8b5ad8c33e973aa18b266f50fe55f24b8c/multidict-6.7.1-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f99fe611c312b3c1c0ace793f92464d8cd263cc3b26b5721950d977b006b6c4d", size = 252403, upload-time = "2026-01-26T02:45:51.779Z" }, + { url = "https://files.pythonhosted.org/packages/a2/76/b9669547afa5a1a25cd93eaca91c0da1c095b06b6d2d8ec25b713588d3a1/multidict-6.7.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9004d8386d133b7e6135679424c91b0b854d2d164af6ea3f289f8f2761064609", size = 244889, upload-time = "2026-01-26T02:45:53.27Z" }, + { url = "https://files.pythonhosted.org/packages/7e/a9/a50d2669e506dad33cfc45b5d574a205587b7b8a5f426f2fbb2e90882588/multidict-6.7.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e628ef0e6859ffd8273c69412a2465c4be4a9517d07261b33334b5ec6f3c7489", size = 241982, upload-time = "2026-01-26T02:45:54.919Z" }, + { url = "https://files.pythonhosted.org/packages/c5/bb/1609558ad8b456b4827d3c5a5b775c93b87878fd3117ed3db3423dfbce1b/multidict-6.7.1-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:841189848ba629c3552035a6a7f5bf3b02eb304e9fea7492ca220a8eda6b0e5c", size = 232415, upload-time = "2026-01-26T02:45:56.981Z" }, + { url = "https://files.pythonhosted.org/packages/d8/59/6f61039d2aa9261871e03ab9dc058a550d240f25859b05b67fd70f80d4b3/multidict-6.7.1-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:ce1bbd7d780bb5a0da032e095c951f7014d6b0a205f8318308140f1a6aba159e", size = 240337, upload-time = "2026-01-26T02:45:58.698Z" }, + { url = "https://files.pythonhosted.org/packages/a1/29/fdc6a43c203890dc2ae9249971ecd0c41deaedfe00d25cb6564b2edd99eb/multidict-6.7.1-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:b26684587228afed0d50cf804cc71062cc9c1cdf55051c4c6345d372947b268c", size = 248788, upload-time = "2026-01-26T02:46:00.862Z" }, + { url = "https://files.pythonhosted.org/packages/a9/14/a153a06101323e4cf086ecee3faadba52ff71633d471f9685c42e3736163/multidict-6.7.1-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:9f9af11306994335398293f9958071019e3ab95e9a707dc1383a35613f6abcb9", size = 242842, upload-time = "2026-01-26T02:46:02.824Z" }, + { url = "https://files.pythonhosted.org/packages/41/5f/604ae839e64a4a6efc80db94465348d3b328ee955e37acb24badbcd24d83/multidict-6.7.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:b4938326284c4f1224178a560987b6cf8b4d38458b113d9b8c1db1a836e640a2", size = 240237, upload-time = "2026-01-26T02:46:05.898Z" }, + { url = "https://files.pythonhosted.org/packages/5f/60/c3a5187bf66f6fb546ff4ab8fb5a077cbdd832d7b1908d4365c7f74a1917/multidict-6.7.1-cp314-cp314t-win32.whl", hash = "sha256:98655c737850c064a65e006a3df7c997cd3b220be4ec8fe26215760b9697d4d7", size = 48008, upload-time = "2026-01-26T02:46:07.468Z" }, + { url = "https://files.pythonhosted.org/packages/0c/f7/addf1087b860ac60e6f382240f64fb99f8bfb532bb06f7c542b83c29ca61/multidict-6.7.1-cp314-cp314t-win_amd64.whl", hash = "sha256:497bde6223c212ba11d462853cfa4f0ae6ef97465033e7dc9940cdb3ab5b48e5", size = 53542, upload-time = "2026-01-26T02:46:08.809Z" }, + { url = "https://files.pythonhosted.org/packages/4c/81/4629d0aa32302ef7b2ec65c75a728cc5ff4fa410c50096174c1632e70b3e/multidict-6.7.1-cp314-cp314t-win_arm64.whl", hash = "sha256:2bbd113e0d4af5db41d5ebfe9ccaff89de2120578164f86a5d17d5a576d1e5b2", size = 44719, upload-time = "2026-01-26T02:46:11.146Z" }, + { url = "https://files.pythonhosted.org/packages/81/08/7036c080d7117f28a4af526d794aab6a84463126db031b007717c1a6676e/multidict-6.7.1-py3-none-any.whl", hash = "sha256:55d97cc6dae627efa6a6e548885712d4864b81110ac76fa4e534c03819fa4a56", size = 12319, upload-time = "2026-01-26T02:46:44.004Z" }, +] + +[[package]] +name = "openai" +version = "2.30.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, + { name = "distro" }, + { name = "httpx" }, + { name = "jiter" }, + { name = "pydantic" }, + { name = "sniffio" }, + { name = "tqdm" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/88/15/52580c8fbc16d0675d516e8749806eda679b16de1e4434ea06fb6feaa610/openai-2.30.0.tar.gz", hash = "sha256:92f7661c990bda4b22a941806c83eabe4896c3094465030dd882a71abe80c885", size = 676084, upload-time = "2026-03-25T22:08:59.96Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2a/9e/5bfa2270f902d5b92ab7d41ce0475b8630572e71e349b2a4996d14bdda93/openai-2.30.0-py3-none-any.whl", hash = "sha256:9a5ae616888eb2748ec5e0c5b955a51592e0b201a11f4262db920f2a78c5231d", size = 1146656, upload-time = "2026-03-25T22:08:58.2Z" }, +] + +[[package]] +name = "packaging" +version = "26.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/65/ee/299d360cdc32edc7d2cf530f3accf79c4fca01e96ffc950d8a52213bd8e4/packaging-26.0.tar.gz", hash = "sha256:00243ae351a257117b6a241061796684b084ed1c516a08c48a3f7e147a9d80b4", size = 143416, upload-time = "2026-01-21T20:50:39.064Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b7/b9/c538f279a4e237a006a2c98387d081e9eb060d203d8ed34467cc0f0b9b53/packaging-26.0-py3-none-any.whl", hash = "sha256:b36f1fef9334a5588b4166f8bcd26a14e521f2b55e6b9de3aaa80d3ff7a37529", size = 74366, upload-time = "2026-01-21T20:50:37.788Z" }, +] + +[[package]] +name = "pluggy" +version = "1.6.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" }, +] + +[[package]] +name = "primp" +version = "1.2.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ee/ca/383bdf0df3dc87b60bf73c55da526ac743d42c5155a84a9014775b895e96/primp-1.2.3.tar.gz", hash = "sha256:a531b01f57cb59e3e7a3a2b526bb151b61dc7b2e15d2f6961615a553632e2889", size = 1342866, upload-time = "2026-04-20T08:34:09.018Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b6/b1/05bb7e00bd17a439aae7ed49b0c0834508e3ce50624dfa43c6dcb8b71bd0/primp-1.2.3-cp310-abi3-macosx_10_12_x86_64.whl", hash = "sha256:e96d6ab40fba41039947dad0fcc42b0b56b67180883e526715720bb2d90f3bfc", size = 4360352, upload-time = "2026-04-20T08:33:52.785Z" }, + { url = "https://files.pythonhosted.org/packages/7e/db/8bb1e4b6bb715f606b53793831e7910aebeb40169e439138e9124686820a/primp-1.2.3-cp310-abi3-macosx_11_0_arm64.whl", hash = "sha256:42f28679916ce080e643e7464786abeb659c8062c0f74bb411918c7f07e5b806", size = 4035926, upload-time = "2026-04-20T08:34:06.348Z" }, + { url = "https://files.pythonhosted.org/packages/45/91/52b5e6d840be4d5a8f689d9ba82dd616c67e29e3e1d13baf6a4c9be3f4b3/primp-1.2.3-cp310-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:643d47cf24962331ad2b049d6bb4329dce6b18a0914490dbf09541cb38596d39", size = 4309649, upload-time = "2026-04-20T08:34:01.369Z" }, + { url = "https://files.pythonhosted.org/packages/40/85/d98e20104429bb8393939396c2317ec6163a83d856b1fe555bf5f021e97a/primp-1.2.3-cp310-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:898a12b44af9aed20c10fd4b497314731e9f6dcab20f4aa64cf118f79df17fa0", size = 3910331, upload-time = "2026-04-20T08:33:37.294Z" }, + { url = "https://files.pythonhosted.org/packages/8e/c7/53f11e2e2fe758830f6f208cef5bd3d0ecc6f538c0a2ca8e15a1fa502bd1/primp-1.2.3-cp310-abi3-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d4bdf2b164c2908f7bdc845215dd21ebded1f2f43e9e9ae2d9a961ea56e5cb87", size = 4152054, upload-time = "2026-04-20T08:33:56.193Z" }, + { url = "https://files.pythonhosted.org/packages/0c/5a/48e8f985daeeb58c7f1789bb6748d9aba250ea3541d787bcbcb1243abfd3/primp-1.2.3-cp310-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:036884d4c6c866c93a88e591e49f67ed160f6a9d98c779fc652cce63de62996a", size = 4443286, upload-time = "2026-04-20T08:34:07.782Z" }, + { url = "https://files.pythonhosted.org/packages/5e/81/42b32337bd8c7b7b8184a1fcd79fd51d4773427553a8d2036eb0a93a137d/primp-1.2.3-cp310-abi3-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:bfc695c20f5c6e345abc3262bef3c246a571986db5cea73bdc41db6b166066c8", size = 4323757, upload-time = "2026-04-20T08:33:43.807Z" }, + { url = "https://files.pythonhosted.org/packages/37/43/9ee78c283cbca7fcd635c2a9bb5633aa6568b1925958017e1a979fffe56c/primp-1.2.3-cp310-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:13255b0826c60681478c787fbe29cfc773caf6242390fee047dac0f23f6e8c11", size = 4525772, upload-time = "2026-04-20T08:33:45.427Z" }, + { url = "https://files.pythonhosted.org/packages/c5/41/f10164485d84145a1ea18c7966d1ee098d1790b2088b7f122570463b7d5c/primp-1.2.3-cp310-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:9bc40f94c8e58444befaf7e78b8aadd96e94e32789dadbe4a03785db772aa4dc", size = 4471705, upload-time = "2026-04-20T08:33:54.317Z" }, + { url = "https://files.pythonhosted.org/packages/18/a2/5328d66dd8f63bacfc9ef0e1e5fde66b2bb43103108fe8f01dcb2d2f0e50/primp-1.2.3-cp310-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:2e0e8e245113ab3c9fd4b36014b3a04869cf08f72e8e7f36c4f5ef46d26da090", size = 4148309, upload-time = "2026-04-20T08:33:31.609Z" }, + { url = "https://files.pythonhosted.org/packages/c9/86/4d000d3ee341e5f1e73d81fb2c84e985f23b343a1aa4234c40987ec6eae7/primp-1.2.3-cp310-abi3-musllinux_1_2_i686.whl", hash = "sha256:3bb50934b5e209e7da4876d3419ebc23d1425fe6f089c0cd95382d21bd8a39bd", size = 4276881, upload-time = "2026-04-20T08:33:34.414Z" }, + { url = "https://files.pythonhosted.org/packages/22/f5/50acc3e349d22044abf4ed7c2abaaba11a01b9ccb6a7d66a3fbc2275c590/primp-1.2.3-cp310-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:b293f13078afee9d41b74c77d05a5eaeb57dfab5110648dd24bc3fb3c750a05c", size = 4775229, upload-time = "2026-04-20T08:34:10.241Z" }, + { url = "https://files.pythonhosted.org/packages/3a/d6/2c482973211666fdf2c4365babf343a88ea30f753ef650121cebd4ad7ece/primp-1.2.3-cp310-abi3-win32.whl", hash = "sha256:c600dd83e9c978bf494aab072cd5bbfdd59b131f3afc353850c53373a86992e5", size = 3504032, upload-time = "2026-04-20T08:33:28.344Z" }, + { url = "https://files.pythonhosted.org/packages/70/89/3d2032a8f5e986fcc03bc86ac98705ce2bd35ed0e182d4949c159214da6a/primp-1.2.3-cp310-abi3-win_amd64.whl", hash = "sha256:3cbbe52a6eb51a4831d3dd35055f13b28ff5b9be2487c14ffe66922bf8028b49", size = 3872596, upload-time = "2026-04-20T08:33:46.927Z" }, + { url = "https://files.pythonhosted.org/packages/79/00/f726d54ff00213641069a66ee2fadf17f01f77a2f1ba92de229830056419/primp-1.2.3-cp310-abi3-win_arm64.whl", hash = "sha256:03c668481b2cf34552880f4b6ebabfa913fdaeb2921ce982e42c428f451b630c", size = 3875239, upload-time = "2026-04-20T08:33:32.981Z" }, + { url = "https://files.pythonhosted.org/packages/5c/e6/1fe1bcaf7566d7e6c9b39748f0d6ded857c80cf3252acf6aa3c6b7b8dbb0/primp-1.2.3-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:0148fd5c0502bb88a26217b606ebb254de44a666dac52657ff97f727577bc7ce", size = 4348055, upload-time = "2026-04-20T08:33:48.193Z" }, + { url = "https://files.pythonhosted.org/packages/c0/46/cae79466969a31d885409ce716eb5a4af66f66d1121e63ee3ddd7d666b9e/primp-1.2.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:13bfc39172a083cc5520d9045a99988d7f8502458be139d6b1926de4d57e30e9", size = 4034114, upload-time = "2026-04-20T08:33:26.888Z" }, + { url = "https://files.pythonhosted.org/packages/f5/c3/e8b24ff42ef6bf71f8b4277fd6d83a139d9b9ad14b0ffb4c76a8e9225a15/primp-1.2.3-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:283e751671e78cbac9f1ff72e89225d74bcd9ea08886910160f485cd78a55f2b", size = 4303794, upload-time = "2026-04-20T08:34:04.947Z" }, + { url = "https://files.pythonhosted.org/packages/72/b4/9c59197fee68abdc53683b65b6b0e5ea6e0f098cc2527af29edd05b22ed4/primp-1.2.3-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ec5d94244f24c61b350791112c1687c97d144f400a7ea5d8476dbd2fad6de9af", size = 3908577, upload-time = "2026-04-20T08:33:59.567Z" }, + { url = "https://files.pythonhosted.org/packages/71/b2/25c7cfcfe33f2fa82ab8cc72f4082fc12c8f803ceb2624c787fa72c73e12/primp-1.2.3-cp314-cp314t-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:48d459dda86bfddce3a14b514694e0c8028f20cc461dd52e105aba400c622513", size = 4153501, upload-time = "2026-04-20T08:34:03.22Z" }, + { url = "https://files.pythonhosted.org/packages/04/9b/83e61b32b9049478f63c1956ff3244619691c3edf6e96b19254047756b36/primp-1.2.3-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d0d8441f07c948a54ff21bfc4094cd2967b5fb6f8a9ef0c9562a1eb35da0127e", size = 4440289, upload-time = "2026-04-20T08:33:24.734Z" }, + { url = "https://files.pythonhosted.org/packages/d2/3f/48c351f601f204c52d5a477d7a19efcd8b7deb6478c57195fbe8bf9c3632/primp-1.2.3-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:728b6f63552f1bc729e0490ee69a3a9fbd39698c1578b0e6313f3779de469a8c", size = 4306848, upload-time = "2026-04-20T08:33:40.482Z" }, + { url = "https://files.pythonhosted.org/packages/ee/9a/683b2fbb8c2df3b3d2b351e86eec0a873479b95bb804e5d882939057366b/primp-1.2.3-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9952509dcd8aa8750f4cdfc86b24cdcec96f9342a6525003bc3446ba466d5512", size = 4521679, upload-time = "2026-04-20T08:33:38.699Z" }, + { url = "https://files.pythonhosted.org/packages/80/eb/bbbbc79cf4132f2beeb0a0f99f41837dd66c158d0439f59df75a2d592d0a/primp-1.2.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e74a6aa83aa65d02665ad5d0e53d7877ea8abce6f3d50ed92495f9c4c9d10e2e", size = 4469041, upload-time = "2026-04-20T08:33:51.161Z" }, + { url = "https://files.pythonhosted.org/packages/f7/5c/208fe1c6e9d3a28c6eae530378ac9c60fe8ae389f68a4707ef7986d5b133/primp-1.2.3-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:1dfc4dd5bf7e4f9a45f9c7ae1256f957cc7ca8d5344f82d335129a13e1d7ffea", size = 4144925, upload-time = "2026-04-20T08:33:35.94Z" }, + { url = "https://files.pythonhosted.org/packages/da/06/ce175b54edecf22b750da67bc095bea53f2d87d191c4461b30122c7ddd1e/primp-1.2.3-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:97c37df6fc7eb989f324b326e0547b23757a82f9d8b334075d4b0bd29e310723", size = 4276929, upload-time = "2026-04-20T08:33:49.521Z" }, + { url = "https://files.pythonhosted.org/packages/2e/12/a913ab53ad61fe51d44ef0f8fee6b63a897d2b9c8a4b43299d7f5decc003/primp-1.2.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:ead9c8b660fa0ebb193317b85d61dd1bd840a3e97e882b33b896dc9e37ed6d63", size = 4772684, upload-time = "2026-04-20T08:33:42.456Z" }, + { url = "https://files.pythonhosted.org/packages/7c/2f/2c3aafb2814703979bf5a216575f4478bcf6070bc6ec143056cf3b56c134/primp-1.2.3-cp314-cp314t-win32.whl", hash = "sha256:cb52db4d54105097773c0df4e2ef0ce7b42461d9d4d3ec28a0622ca2d22945bb", size = 3499126, upload-time = "2026-04-20T08:33:29.953Z" }, + { url = "https://files.pythonhosted.org/packages/54/f0/bad9c739a35f4cf69e2f39c01f664c9a5969e753c4cfcdc33e113cc984af/primp-1.2.3-cp314-cp314t-win_amd64.whl", hash = "sha256:d85a44585df27038e18298f7e35335c4961926e7401edd1a1bf4f7f967b3f107", size = 3870129, upload-time = "2026-04-20T08:34:11.666Z" }, + { url = "https://files.pythonhosted.org/packages/67/78/882563dc554c5f710b4e47c58978586c2528703435800a7a84e81b339d90/primp-1.2.3-cp314-cp314t-win_arm64.whl", hash = "sha256:6513dcb55e6b511c1ae383a3a0e887929b09d8d6b2c70e2b188b425c51471a02", size = 3874087, upload-time = "2026-04-20T08:33:58.109Z" }, +] + +[[package]] +name = "propcache" +version = "0.5.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ec/44/c87281c333769159c50594f22610f77398a47ccbfbbf23074e744e86f87c/propcache-0.5.2.tar.gz", hash = "sha256:01c4fc7480cd0598bb4b57022df55b9ca296da7fc5a8760bd8451a7e63a7d427", size = 50208, upload-time = "2026-05-08T21:02:12.199Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4a/cb/e27bc2b2737a0bb49962b275efa051e8f1c35a936df7d5139b6b658b7dc9/propcache-0.5.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:806719138ecd720339a12410fb9614ac9b2b2d3a5fdf8235d56981c36f4039ba", size = 95887, upload-time = "2026-05-08T21:00:11.277Z" }, + { url = "https://files.pythonhosted.org/packages/e6/13/b8ae04c59392f8d11c6cd9fb4011d1dc7c86b81225c770280300e259ffe1/propcache-0.5.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:db2b80ea58eab4f86b2beec3cc8b39e8ff9276ac20e96b7cce43c8ae84cd6b5a", size = 54654, upload-time = "2026-05-08T21:00:12.604Z" }, + { url = "https://files.pythonhosted.org/packages/2c/7d/49777a3e20b55863d4794384a38acd460c04157b0a00f8602b0d508b8431/propcache-0.5.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:e5cbfac9f61484f7e9f3597775500cd3ebe8274e9b050c38f9525c77c97520bf", size = 55190, upload-time = "2026-05-08T21:00:13.935Z" }, + { url = "https://files.pythonhosted.org/packages/44/c7/085d0cd63062e84044e3f05797749c3f8e3938ff3aeb0eb2f69d43fafc91/propcache-0.5.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5dbc581d2814337da56222fab8dc5f161cd798a434e49bac27930aaef798e144", size = 59995, upload-time = "2026-05-08T21:00:15.526Z" }, + { url = "https://files.pythonhosted.org/packages/9c/42/32cf8e3009e92b2645cf1e944f701e8ea4e924dffde1ee26db860bcbf7e4/propcache-0.5.2-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:857187f381f88c8e2fa2fe56ab94879d011b883d5a2ee5a1b60a8cd2a06846d9", size = 63422, upload-time = "2026-05-08T21:00:16.824Z" }, + { url = "https://files.pythonhosted.org/packages/9e/1b/f112433f99fc979431b87a39ef169e3f8df070d99a72792c56d6937ac48b/propcache-0.5.2-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:178b4a2cdaac1818e2bf1c5a99b94383fa73ea5382e032a48dec07dc5668dc42", size = 64342, upload-time = "2026-05-08T21:00:18.362Z" }, + { url = "https://files.pythonhosted.org/packages/14/15/5574111ae50dd6e879456888c0eadd4c5a869959775854e18e18a6b345f3/propcache-0.5.2-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6f328175a2cde1f0ff2c4ed8ce968b9dcfb55f3a7153f39e2957ed994da13476", size = 61639, upload-time = "2026-05-08T21:00:19.692Z" }, + { url = "https://files.pythonhosted.org/packages/cc/da/4d775080b1490c0ae604acda868bd71aabe3a89ed16f2aa4339eb8a283e7/propcache-0.5.2-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:5671d09a36b06d0fd4a3da0fccbcae360e9b1570924171a15e9e0997f0249fba", size = 61588, upload-time = "2026-05-08T21:00:21.155Z" }, + { url = "https://files.pythonhosted.org/packages/04/ac/f076982cbe2195ee9cf32de5a1e46951d9fb399fc207f390562dd0fd8fb2/propcache-0.5.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:80168e2ebe4d3ec6599d10ad8f520304ae1cad9b6c5a95372aef1b66b7bfb53a", size = 60029, upload-time = "2026-05-08T21:00:22.713Z" }, + { url = "https://files.pythonhosted.org/packages/70/60/189be62e0dd898dce3b331e1b8c7a543cd3a405ac0c81fe8ee8a9d5d77e1/propcache-0.5.2-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:45f11346f884bc47444f6e6647131055844134c3175b629f84952e2b5cd62b64", size = 56774, upload-time = "2026-05-08T21:00:24.001Z" }, + { url = "https://files.pythonhosted.org/packages/ea/9e/93377b9c7939c1ffae98f878dee955efadfd638078bc86dbc21f9d52f651/propcache-0.5.2-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:8e778ebd44ef4f66ed60a0416b06b489687db264a9c0b3620362f26489492913", size = 63532, upload-time = "2026-05-08T21:00:25.545Z" }, + { url = "https://files.pythonhosted.org/packages/14/f9/590ef6cfb9b8028d516d287812ece32bb0bc5f11fbb9c8bf6b2e6313fec8/propcache-0.5.2-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:c0cb9ed24c8964e172768d455a38254c2dd8a552905729ce006cad3d3dda59b1", size = 61592, upload-time = "2026-05-08T21:00:27.186Z" }, + { url = "https://files.pythonhosted.org/packages/b4/5e/70958b3034c297a630bba2f17ca7abc2d5f39a803ad7e370ab79d1ecd022/propcache-0.5.2-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:1d1ad32d9d4355e2be65574fd0bfd3677e7066b009cd5b9b2dee8aa6a6393b33", size = 64788, upload-time = "2026-05-08T21:00:28.8Z" }, + { url = "https://files.pythonhosted.org/packages/12/fd/77fe5936d8c3086ca9048f7f415f122ed82e53884a9ec193646b42deef06/propcache-0.5.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:c80f4ba3e8f00189165999a742ee526ebeccedf6c3f7beb0c7df821e9772435a", size = 62514, upload-time = "2026-05-08T21:00:30.098Z" }, + { url = "https://files.pythonhosted.org/packages/cf/74/66bd798b5b3be70aa1b391f5cc9d6a0a5532d7fd3b19ec0b213e72e6ad9d/propcache-0.5.2-cp312-cp312-win32.whl", hash = "sha256:8c7972d8f193740d9175f0998ab38717e6cd322d5935c5b0fef8c0d323fd9031", size = 39018, upload-time = "2026-05-08T21:00:31.622Z" }, + { url = "https://files.pythonhosted.org/packages/61/7c/5c0d34aa3024694d6dcb9271cdbdd08c4e47c1c0ad95ec7e7bc74cdea145/propcache-0.5.2-cp312-cp312-win_amd64.whl", hash = "sha256:d9ee8826a7d47863a08ac44e1a5f611a462eefc3a194b492da242128bec75b42", size = 42322, upload-time = "2026-05-08T21:00:32.918Z" }, + { url = "https://files.pythonhosted.org/packages/4d/91/875812f1a3feb20ceba818ef39fbe4d92f1081e04ac815c822496d0d038b/propcache-0.5.2-cp312-cp312-win_arm64.whl", hash = "sha256:2800a4a8ead6b28cccd1ec54b59346f0def7922ee1c7598e8499c733cfbb7c84", size = 38172, upload-time = "2026-05-08T21:00:35.124Z" }, + { url = "https://files.pythonhosted.org/packages/c5/09/f049e45385503fe67db75a6b6186a7b9f0c3930366dc960522c312a825b1/propcache-0.5.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:099aaf4b4d1a02265b92a977edf00b5c4f63b3b17ac6de39b0d637c9cac0188a", size = 94457, upload-time = "2026-05-08T21:00:36.355Z" }, + { url = "https://files.pythonhosted.org/packages/6b/65/83d1d05655baf63113731bd5a1008435e14f8d1e5a06cbe4ec5b23ad7a31/propcache-0.5.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:68ce1c44c7a813a7f71ea04315a8c7b330b63db99d059a797a4651bb6f69f117", size = 53835, upload-time = "2026-05-08T21:00:38.072Z" }, + { url = "https://files.pythonhosted.org/packages/a9/12/a6ba6482bb5ea3260c000c9b20881c95fa11c6b30173715668259f844ed7/propcache-0.5.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:fc299c129490f55f254cd90be0deca4764e36e9a7c08b4aa588479a3bbed3098", size = 54545, upload-time = "2026-05-08T21:00:39.319Z" }, + { url = "https://files.pythonhosted.org/packages/a9/19/7fa086f5764c59ec8a8e157cd93aa8497acc00aba9dcdec56bfffb32602d/propcache-0.5.2-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a6ae2198be502c10f09b2516e7b5d019816924bc3183a43ce792a7bd6625e6f4", size = 59886, upload-time = "2026-05-08T21:00:40.621Z" }, + { url = "https://files.pythonhosted.org/packages/a1/e4/5d7663dc8235956c8f5281698a3af1d351d8820341ddd890f59d9a9127f2/propcache-0.5.2-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6041d31504dc1779d700e1edcfb08eea334b357620b06681a4eabb57a74e574e", size = 63261, upload-time = "2026-05-08T21:00:41.775Z" }, + { url = "https://files.pythonhosted.org/packages/4a/4a/15a03adee24d6350da4292caeac44c34c033d2afe5e87eb370f38854560f/propcache-0.5.2-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f7eabc04151c78a9f4d5bbb5f1faf571e4defeb4b585e0fe95b60ff2dbe4d3d7", size = 64184, upload-time = "2026-05-08T21:00:43.018Z" }, + { url = "https://files.pythonhosted.org/packages/8b/c6/979176efdaa3d239e36d503d5af63a0a773b36662ed8f52e5b6a6d9fd40e/propcache-0.5.2-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4db0ba63d693afd40d249bd93f842b5f144f8fcbb83de05660373bcf30517b1d", size = 61534, upload-time = "2026-05-08T21:00:44.507Z" }, + { url = "https://files.pythonhosted.org/packages/c8/22/63e8cd1bae4c2d2be6493b6b7d10566ddafad88137cfbc99964a1119853c/propcache-0.5.2-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:1dbcf7675229b35d31abb6547d8ebc8c27a830ac3f9a794edff6254873ec7c0a", size = 61500, upload-time = "2026-05-08T21:00:45.796Z" }, + { url = "https://files.pythonhosted.org/packages/60/5a/28e5d9acbac1cc9ccb67045e8c1b943aa8d79fdf39c93bd73cacd68008ea/propcache-0.5.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d310c013aad2c72f1c3f2f8dd3279d460a858c551f97aeb8c63e4693cca7b4d2", size = 59994, upload-time = "2026-05-08T21:00:47.093Z" }, + { url = "https://files.pythonhosted.org/packages/f3/40/db650677f554a95b9c01a7c9d93d629e93a15562f5deb4573c9ee136fed2/propcache-0.5.2-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:06187263ddad280d05b4d8a8b3bb7d164cbebd469236544a42e6d9b28ac6a4fa", size = 56884, upload-time = "2026-05-08T21:00:48.376Z" }, + { url = "https://files.pythonhosted.org/packages/80/45/70b39b89516ff8b96bf732fa6fded8cef20f293cb1508690101c3c07ec51/propcache-0.5.2-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:3115559b8effafd63b142ea5ed53d63a16ea6469cbc63dce4ee194b42db5d853", size = 63464, upload-time = "2026-05-08T21:00:49.954Z" }, + { url = "https://files.pythonhosted.org/packages/f9/e2/fa59d3a89eac5534293124af4f1d0d0ada091ce4a0ab4610ce03fd2bdd8d/propcache-0.5.2-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:c60462af8e6dc30c35407c7237ea908d777b22862bbee27bc4699c0d8bcdc45a", size = 61588, upload-time = "2026-05-08T21:00:51.281Z" }, + { url = "https://files.pythonhosted.org/packages/0b/97/efb547a55c4bc7381cfb202d6a2239ac621045277bc1ea5dfd3a7f0516c0/propcache-0.5.2-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:40314bca9ac559716fe374094fc81c11dcc34b64fd6c585360f5775690505704", size = 64667, upload-time = "2026-05-08T21:00:52.602Z" }, + { url = "https://files.pythonhosted.org/packages/92/56/f5c7d9b4b7595d5127da38974d791b2153f3d1eae6c674af3583ace92ad3/propcache-0.5.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:cfa21e036ce1e1db2be04ba3b85d2df1bb1702fa01932d984c5464c665228ff4", size = 62463, upload-time = "2026-05-08T21:00:54.303Z" }, + { url = "https://files.pythonhosted.org/packages/bd/3b/484a3a65fc9f9f60c41dcd17b428bace5389544e2c680994534a20755066/propcache-0.5.2-cp313-cp313-win32.whl", hash = "sha256:f156a3529f38063b6dbaf356e15602a7f95f8055b1295a438433a6386f10463d", size = 38621, upload-time = "2026-05-08T21:00:55.808Z" }, + { url = "https://files.pythonhosted.org/packages/1c/fd/3f0f10dba4dabad3bf53102be007abf55481067952bde0fdddff439e7c61/propcache-0.5.2-cp313-cp313-win_amd64.whl", hash = "sha256:dfed59d0a5aeb01e242e66ff0300bc4a265a7c05f612d30016f0b60b1017d757", size = 41649, upload-time = "2026-05-08T21:00:57.061Z" }, + { url = "https://files.pythonhosted.org/packages/90/ec/6ce619cc32bb500a482f811f9cd509368b4e58e638d13f2c68f370d6b475/propcache-0.5.2-cp313-cp313-win_arm64.whl", hash = "sha256:ba338430e87ceb9c8f0cf754de38a9860560261e56c00376debd628698a7364f", size = 37636, upload-time = "2026-05-08T21:00:58.646Z" }, + { url = "https://files.pythonhosted.org/packages/1b/82/c1d268bbbf2ef981c5bf0fbbe746db617c66e3bcefe431a1aa8943fbe23a/propcache-0.5.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:a592f5f3da71c8691c788c13cb6734b6d17663d2e1cb8caddf0673d01ef8847d", size = 98872, upload-time = "2026-05-08T21:00:59.889Z" }, + { url = "https://files.pythonhosted.org/packages/f4/d4/52c871e73e864e6b34c0e2d58ac1ec5ccd149497ddc7ad2137ae98323a35/propcache-0.5.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:6a997d0489e9668a384fcfd5061b857aa5361de73191cac204d04b889cfbbafa", size = 56257, upload-time = "2026-05-08T21:01:01.195Z" }, + { url = "https://files.pythonhosted.org/packages/67/f0/9b90ca2a210b3d09bcfcd96ecd0f55545c091535abce2a45de2775cfd357/propcache-0.5.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:10734b5484ea113152ee25a91dccedf81631791805d2c9ccb054958e51842c94", size = 56696, upload-time = "2026-05-08T21:01:02.941Z" }, + { url = "https://files.pythonhosted.org/packages/9d/0e/6e9d4ba07c8e56e21ddec1e75f12148142b21ca83a51871babce095334f4/propcache-0.5.2-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:cafca7e56c12bb02ae16d283742bef25a61122e9dab2b5b3f2ccbe589ce32164", size = 62378, upload-time = "2026-05-08T21:01:04.475Z" }, + { url = "https://files.pythonhosted.org/packages/65/19/c10badaa463dde8a27ce884f8ee2ec37e6035b7c9f5ff0c8f74f06f08dac/propcache-0.5.2-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f064f8d2b59177878b7615df1735cd8fe3462ed6be8c7b217d17a276489c2b7f", size = 65283, upload-time = "2026-05-08T21:01:05.959Z" }, + { url = "https://files.pythonhosted.org/packages/b0/b6/93bea99ca80e19cef6512a8580e5b7857bbe09422d9daa7fd4ef5723306c/propcache-0.5.2-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f78abfa8dfc32376fd1aacf597b2f2fbbe0ea751419aee718af5d4f82537ef8c", size = 66616, upload-time = "2026-05-08T21:01:07.228Z" }, + { url = "https://files.pythonhosted.org/packages/83/e4/5c7462e50625f051f37fb38b8224f7639f667184bbd34424ec83819bb1b7/propcache-0.5.2-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f7467da8a9822bf1a55336f877340c5bcbd3c482afc43a99771169f74a26dedc", size = 63773, upload-time = "2026-05-08T21:01:08.514Z" }, + { url = "https://files.pythonhosted.org/packages/ca/b6/99238894047b13c823be25027e736626cd414a52a5e30d2c3347c2733529/propcache-0.5.2-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a6ddc6ac9e25de626c1f129c1b467d7ecd33ce2237d3fd0c4e429feef0a7ee1f", size = 63664, upload-time = "2026-05-08T21:01:09.874Z" }, + { url = "https://files.pythonhosted.org/packages/85/1e/a3a1a63116a2b8edb415a8bb9a6f0c34bd03830b1e18e8ce2904e1dc1cf4/propcache-0.5.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:2f22cbbac9e26a8e864c0985ff1268d5d939d53d9d9411a9824279097e03a2cb", size = 62643, upload-time = "2026-05-08T21:01:11.132Z" }, + { url = "https://files.pythonhosted.org/packages/e4/03/893cf147de2fc6543c5eaa07ad833170e7e2a2385725bbebe8c0503723bb/propcache-0.5.2-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:fc76378c62a0f04d0cd82fbb1a2cd2d7e28fcb40d5873f28a6c44e388aaa2751", size = 59595, upload-time = "2026-05-08T21:01:12.387Z" }, + { url = "https://files.pythonhosted.org/packages/86/3b/04c1a2e12c57766568ba75ba72b3bf2042818d4c1425fab6fc07155c7cff/propcache-0.5.2-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:acd2c8edba48e31e58a363b8cf4e5c7db3b04b3f9e371f601df30d9b0d244836", size = 65711, upload-time = "2026-05-08T21:01:13.676Z" }, + { url = "https://files.pythonhosted.org/packages/1c/34/80f8d0099f8d6bacc4de1624c85672681c8cd1149ca2da0e38fd120b817f/propcache-0.5.2-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:452b5065457eb9991ec5eb38ff41d6cd4c991c9ac7c531c4d5849ae473a9a13f", size = 64247, upload-time = "2026-05-08T21:01:14.936Z" }, + { url = "https://files.pythonhosted.org/packages/f3/1a/8b08f3a5f1037e9e370c55883ceeeee0f6dd0416fb2d2d67b8bfc91f2a79/propcache-0.5.2-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:3430bb2bfe1331885c427745a751e774ee679fd4344f80b97bf879815fe8fa55", size = 67102, upload-time = "2026-05-08T21:01:16.281Z" }, + { url = "https://files.pythonhosted.org/packages/34/68/8bdb7bb7756d76e005490649d10e4a8369e610c74d619f71e1aedf889e9c/propcache-0.5.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:cef6cea3922890dd6c9654971001fa797b526c16ab5e1e46c05fd6f877be7568", size = 64964, upload-time = "2026-05-08T21:01:17.57Z" }, + { url = "https://files.pythonhosted.org/packages/0a/aa/50fb0b5d3968b61a510926ff8b8465f1d6e976b3ab74496d7a4b9fc42515/propcache-0.5.2-cp313-cp313t-win32.whl", hash = "sha256:72d61e16dd78228b58c5d47be830ff3da7e5f139abdf0aef9d86cde1c5cf2191", size = 42546, upload-time = "2026-05-08T21:01:18.946Z" }, + { url = "https://files.pythonhosted.org/packages/ae/4c/0ddbae64321bd4a95bcbfc19307238016b5b1fee645c84626c8d539e5b74/propcache-0.5.2-cp313-cp313t-win_amd64.whl", hash = "sha256:0958834041a0166d343b8d2cedcd8bcbaeb4fdbe0cf08320c5379f143c3be6e7", size = 46330, upload-time = "2026-05-08T21:01:20.162Z" }, + { url = "https://files.pythonhosted.org/packages/00/d9/9cddc8efb78d8af264c5ec9f6d10b62f57c515feda8d321595f56010fb23/propcache-0.5.2-cp313-cp313t-win_arm64.whl", hash = "sha256:6de8bd93ddde9b992cf2b2e0d796d501a19026b5b9fd87356d7d0779531a8d96", size = 40521, upload-time = "2026-05-08T21:01:21.399Z" }, + { url = "https://files.pythonhosted.org/packages/e2/ea/23ee535d90ce8bcc465a3028eb3cc0ce3bd1005f4bb27710b30587de798d/propcache-0.5.2-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:46088abff4cba581dea21ae0467a480526cb25aa5f3c269e909f800328bc3999", size = 94662, upload-time = "2026-05-08T21:01:22.683Z" }, + { url = "https://files.pythonhosted.org/packages/b5/06/c5a52f419b5d8972f8d46a7577476090d8e3263ff589ce40b5ca4968d5be/propcache-0.5.2-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:fc88b26f08d634f7bc819a7852e5214f5802641ab8d9fd5326892292eee1993e", size = 53928, upload-time = "2026-05-08T21:01:23.986Z" }, + { url = "https://files.pythonhosted.org/packages/63/b1/4260d67d6bd85e58a66b72d54ce15d5de789b6f3870cc6bedf8ff9667401/propcache-0.5.2-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:97797ebb098e670a2f92dd66f32897e30d7615b14e7f59711de23e30a9072539", size = 54650, upload-time = "2026-05-08T21:01:25.305Z" }, + { url = "https://files.pythonhosted.org/packages/70/06/2f46c318e3307cd7a6a7481def374ce838c0fe20084b39dd54b0879d0e99/propcache-0.5.2-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ba57fffe4ac99c5d30076161b5866336d97600769bad35cc68f7774b15298a4e", size = 59912, upload-time = "2026-05-08T21:01:26.545Z" }, + { url = "https://files.pythonhosted.org/packages/4c/29/fe1aebec2ce57ab985a9c382bded1124431f85078113aa222c5d278430d4/propcache-0.5.2-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:583c19759d9eec1e5b69e2fbef36a7d9c326041be9746cb822d335c8cedc2979", size = 63300, upload-time = "2026-05-08T21:01:27.937Z" }, + { url = "https://files.pythonhosted.org/packages/b4/18/2334b26768b6c82be8c69e83671b767d5ef426aa09b0cba6c2ea47816774/propcache-0.5.2-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d0326e2e5e1f3163fa306c834e48e8d490e5fae607a097a40c0648109b47ba80", size = 64208, upload-time = "2026-05-08T21:01:29.484Z" }, + { url = "https://files.pythonhosted.org/packages/2b/76/7f1bfd6afff4c5e38e36a3c6d68eb5f4b7311ea80baf693db78d95b603c4/propcache-0.5.2-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e00820e192c8dbebcafb383ebbf99030895f09905e7a0eb2e0340a0bcc2bc825", size = 61633, upload-time = "2026-05-08T21:01:31.068Z" }, + { url = "https://files.pythonhosted.org/packages/c4/46/b3ff8aba2b4953a3e50de2cf72f1b5748b8eca93b15f3dc2c84339084c09/propcache-0.5.2-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c66afea89b1e43725731d2004732a046fe6fe955d51f952c3e95a7314a284a39", size = 61724, upload-time = "2026-05-08T21:01:32.374Z" }, + { url = "https://files.pythonhosted.org/packages/c5/01/814cfcafbcff954f94c01cf30e097ddc88a076b5440fbcf4570753437d40/propcache-0.5.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:d4dc37dec6c6cdad0b57881a5658fd14fbf53e333b1a86cf86559f190e1d9ec4", size = 60069, upload-time = "2026-05-08T21:01:33.67Z" }, + { url = "https://files.pythonhosted.org/packages/da/68/5c6f7622d510cc666a300687e06fd060c1a43361c0c9b20d284f06d8096a/propcache-0.5.2-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:5570dbcc97571c15f68068e529c92715a12f8d54030e272d264b377e22bd17a5", size = 57099, upload-time = "2026-05-08T21:01:34.915Z" }, + { url = "https://files.pythonhosted.org/packages/55/27/9cb0b4c679124085327957d42521c99dba04c88c90c3e55a6f0b633ebccc/propcache-0.5.2-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:f814362777a9f841adddb200ecdf8f5cb1e5a3c4b7a86378edbd6ccb26edd702", size = 63391, upload-time = "2026-05-08T21:01:36.231Z" }, + { url = "https://files.pythonhosted.org/packages/f0/9d/7258aaa5bdf60fc6f27591eef6fe52768cb0beda7140be477c8b12c9794a/propcache-0.5.2-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:196913dea116aeb5a2ba95af4ddcb7ea85559ae07d8eee8751688310d09168c3", size = 61626, upload-time = "2026-05-08T21:01:37.545Z" }, + { url = "https://files.pythonhosted.org/packages/8e/0d/41c602003e8a9b16fe1e7eadf62c7bfba9d5474370b24200bf48b315f45f/propcache-0.5.2-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:6e7b8719005dd1175be4ab1cd25e9b98659a5e0347331506ec6760d2773a7fb5", size = 64781, upload-time = "2026-05-08T21:01:38.83Z" }, + { url = "https://files.pythonhosted.org/packages/8b/f3/38e66b1856e9bd079deea015bc4a55f7767c0e4db2f7dcf69e7e680ba4ce/propcache-0.5.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:51f96d685ab16e88cab128cd37a52c5da540809c8b879fa047731bfcb4ad35a4", size = 62570, upload-time = "2026-05-08T21:01:40.415Z" }, + { url = "https://files.pythonhosted.org/packages/95/ca/bbfe9b910ce57dde8bb4876b4520fc02a4e89497c10de26be936758a3aaa/propcache-0.5.2-cp314-cp314-win32.whl", hash = "sha256:cc6fc3cc62e8501d3ed62894425040d2728ecddb1ed072737a5c70bd537aa9f0", size = 39436, upload-time = "2026-05-08T21:01:41.654Z" }, + { url = "https://files.pythonhosted.org/packages/61/d2/45c9defbaa1ea297035d9d4cce9e8f80daafbf19319c6007f157c6256ea9/propcache-0.5.2-cp314-cp314-win_amd64.whl", hash = "sha256:81e3a30b0bb60caa22033dd0f8a3618d1d67356212514f62c57db75cb0ef410c", size = 42373, upload-time = "2026-05-08T21:01:43.041Z" }, + { url = "https://files.pythonhosted.org/packages/44/68/9ea5103f41d5217d7d6ec24db90018e23aebec070c3f9a6e54d12b841fd8/propcache-0.5.2-cp314-cp314-win_arm64.whl", hash = "sha256:0d2c9bf8528f135dbb805ce027567e09164f7efa51a2be07458a2c0420f292d0", size = 38554, upload-time = "2026-05-08T21:01:44.336Z" }, + { url = "https://files.pythonhosted.org/packages/8a/81/fadf555f42d3b762eea8a53950b0489fdc0aa9da5f8ed9e10ce0a4e01b48/propcache-0.5.2-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:4bc8ff1feffc6a61c7002ffe84634c41b822e104990ae009f44a0834430070bb", size = 99395, upload-time = "2026-05-08T21:01:45.883Z" }, + { url = "https://files.pythonhosted.org/packages/f5/c9/c61e134a686949cf7971af3a390148b1156f7be81c73bc0cd12c873e2d48/propcache-0.5.2-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:79aa3ff0a9b566633b642fa9caf7e21ed1c13d6feca718187873f199e1514078", size = 56653, upload-time = "2026-05-08T21:01:47.307Z" }, + { url = "https://files.pythonhosted.org/packages/cb/73/daf935ea7048ddd7ec8eec5345b4a40b619d2d178b3c0a0900796bc3c794/propcache-0.5.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:1b31822f4474c4036bae62de9402710051d431a606d6a0f907fec79935a071aa", size = 56914, upload-time = "2026-05-08T21:01:48.573Z" }, + { url = "https://files.pythonhosted.org/packages/79/9f/aba959b435ea18617edd7cf0a7ad0b9c574b8fc7e3d2cd55fb59cb255d33/propcache-0.5.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:13fef48778b5a2a756523fdb781326b028ca75e32858b04f2cdd19f394564917", size = 62567, upload-time = "2026-05-08T21:01:49.903Z" }, + { url = "https://files.pythonhosted.org/packages/6c/a1/859942de9a791ff42f6141736f5b37749b8f53e65edfa49638c67dd67e6a/propcache-0.5.2-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8b73ab70f1a3351fbc71f663b3e645af6dd0329100c353081cf69c37433fc6fe", size = 65542, upload-time = "2026-05-08T21:01:51.204Z" }, + { url = "https://files.pythonhosted.org/packages/b5/61/315bc0fd6c0fc7f80a528b8afd209e5fc4a875ea79571b91b8f50f442907/propcache-0.5.2-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5538d2c13d93e4698af7e092b57bc7298fd35d1d58e656ae18f23ee0d0378e03", size = 66845, upload-time = "2026-05-08T21:01:52.539Z" }, + { url = "https://files.pythonhosted.org/packages/47/f7/9f8122e3132e8e354ac41975ef8f1099be7d5a16bc7ae562734e993665c0/propcache-0.5.2-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:cd645f03898405cabe694fb8bc35241e3a9c332ec85627584fe3de201452b335", size = 63985, upload-time = "2026-05-08T21:01:53.847Z" }, + { url = "https://files.pythonhosted.org/packages/c8/54/c317819ec157cbf6f35df9df9657a6f82daf34d5faf15948b2f639c2192e/propcache-0.5.2-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a473b3440261e0c60706e732b2ed2f517857344fc21bf48fdfe211e2d98eb285", size = 63999, upload-time = "2026-05-08T21:01:55.179Z" }, + { url = "https://files.pythonhosted.org/packages/5a/56/387e3f7dfce0a9233df41fb888aa1c30222cb4bbbf09537c02dd9bd85fe2/propcache-0.5.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:7afa37062e6650640e932e4cc9297d81f9f42d9944029cc386b8247dea4da837", size = 62779, upload-time = "2026-05-08T21:01:57.489Z" }, + { url = "https://files.pythonhosted.org/packages/a1/9c/596784cb5824ed61ee960d3f8655a3f0993e107c6e98ab6c818b7fb92ccb/propcache-0.5.2-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:8a90efd5777e996e42d568db9ac740b944d691e565cbfd31b2f7832f9184b2b8", size = 59796, upload-time = "2026-05-08T21:01:58.736Z" }, + { url = "https://files.pythonhosted.org/packages/c2/3d/1a6cfa1726a48542c1e8784a0761421476a5b68e09b7f36bf95eb954aaba/propcache-0.5.2-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:f19bb891234d72535764d703bfed1153cc34f4214d5bd7150aee1eec9e8f4366", size = 66023, upload-time = "2026-05-08T21:02:00.228Z" }, + { url = "https://files.pythonhosted.org/packages/e4/0e/05fd6990369477076e4e280bcb970de760fddf0161a46e988bc95f7940ec/propcache-0.5.2-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:32775082acd2d807ee3db715c7770d38767b817870acfa08c29e057f3c4d5b56", size = 64448, upload-time = "2026-05-08T21:02:01.888Z" }, + { url = "https://files.pythonhosted.org/packages/cd/86/5f8da315a4309c62c10c0b2516b17492d5d3bbe1bb862b96604db67e2a37/propcache-0.5.2-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:9282fb1a3bccd038da9f768b927b24a0c753e466c086b7c4f3c6982851eefb2d", size = 67329, upload-time = "2026-05-08T21:02:03.484Z" }, + { url = "https://files.pythonhosted.org/packages/da/d3/3368efe79ab21f0cdf86ef49895811c9cc933131d4cde1f28a624e22e712/propcache-0.5.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:cc49723e2f60d6b32a0f0b08a3fd6d13203c07f1cd9566cfce0f12a917c967a2", size = 65172, upload-time = "2026-05-08T21:02:04.745Z" }, + { url = "https://files.pythonhosted.org/packages/d5/07/127e8b0bacfb325396196f9d976a22453049b89b9b2b08477cc3145faa44/propcache-0.5.2-cp314-cp314t-win32.whl", hash = "sha256:2d7aa89ebca5acc98cba9d1472d976e394782f587bad6661003602a619fd1821", size = 43813, upload-time = "2026-05-08T21:02:06.025Z" }, + { url = "https://files.pythonhosted.org/packages/88/fb/46dad6c0ae49ed230ab1b16c890c2b6314e2403e6c412976f4a72d64a527/propcache-0.5.2-cp314-cp314t-win_amd64.whl", hash = "sha256:d447bb0b3054be5818458fbb171208b1d9ff11eba14e18ca18b90cbb45767370", size = 47764, upload-time = "2026-05-08T21:02:07.353Z" }, + { url = "https://files.pythonhosted.org/packages/e7/c4/a47d0a63aa309d10d59ede6e9d4cff03a344a79d1f0f4cd0cd74997b53e0/propcache-0.5.2-cp314-cp314t-win_arm64.whl", hash = "sha256:fe67a3d11cd9b4efabfa45c3d00ffba2b26811442a73a581a94b67c2b5faccf6", size = 41140, upload-time = "2026-05-08T21:02:09.065Z" }, + { url = "https://files.pythonhosted.org/packages/3a/ed/1cdcab6ba3d6ab7feca11fc14f0eeea80755bb53ef4e892079f31b10a25f/propcache-0.5.2-py3-none-any.whl", hash = "sha256:be1ddfcbb376e3de5d2e2db1d58d6d67463e6b4f9f040c000de8e300295465fe", size = 14036, upload-time = "2026-05-08T21:02:10.673Z" }, +] + +[[package]] +name = "pydantic" +version = "2.12.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "annotated-types" }, + { name = "pydantic-core" }, + { name = "typing-extensions" }, + { name = "typing-inspection" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/69/44/36f1a6e523abc58ae5f928898e4aca2e0ea509b5aa6f6f392a5d882be928/pydantic-2.12.5.tar.gz", hash = "sha256:4d351024c75c0f085a9febbb665ce8c0c6ec5d30e903bdb6394b7ede26aebb49", size = 821591, upload-time = "2025-11-26T15:11:46.471Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5a/87/b70ad306ebb6f9b585f114d0ac2137d792b48be34d732d60e597c2f8465a/pydantic-2.12.5-py3-none-any.whl", hash = "sha256:e561593fccf61e8a20fc46dfc2dfe075b8be7d0188df33f221ad1f0139180f9d", size = 463580, upload-time = "2025-11-26T15:11:44.605Z" }, +] + +[[package]] +name = "pydantic-core" +version = "2.41.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/71/70/23b021c950c2addd24ec408e9ab05d59b035b39d97cdc1130e1bce647bb6/pydantic_core-2.41.5.tar.gz", hash = "sha256:08daa51ea16ad373ffd5e7606252cc32f07bc72b28284b6bc9c6df804816476e", size = 460952, upload-time = "2025-11-04T13:43:49.098Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5f/5d/5f6c63eebb5afee93bcaae4ce9a898f3373ca23df3ccaef086d0233a35a7/pydantic_core-2.41.5-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:f41a7489d32336dbf2199c8c0a215390a751c5b014c2c1c5366e817202e9cdf7", size = 2110990, upload-time = "2025-11-04T13:39:58.079Z" }, + { url = "https://files.pythonhosted.org/packages/aa/32/9c2e8ccb57c01111e0fd091f236c7b371c1bccea0fa85247ac55b1e2b6b6/pydantic_core-2.41.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:070259a8818988b9a84a449a2a7337c7f430a22acc0859c6b110aa7212a6d9c0", size = 1896003, upload-time = "2025-11-04T13:39:59.956Z" }, + { url = "https://files.pythonhosted.org/packages/68/b8/a01b53cb0e59139fbc9e4fda3e9724ede8de279097179be4ff31f1abb65a/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e96cea19e34778f8d59fe40775a7a574d95816eb150850a85a7a4c8f4b94ac69", size = 1919200, upload-time = "2025-11-04T13:40:02.241Z" }, + { url = "https://files.pythonhosted.org/packages/38/de/8c36b5198a29bdaade07b5985e80a233a5ac27137846f3bc2d3b40a47360/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ed2e99c456e3fadd05c991f8f437ef902e00eedf34320ba2b0842bd1c3ca3a75", size = 2052578, upload-time = "2025-11-04T13:40:04.401Z" }, + { url = "https://files.pythonhosted.org/packages/00/b5/0e8e4b5b081eac6cb3dbb7e60a65907549a1ce035a724368c330112adfdd/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:65840751b72fbfd82c3c640cff9284545342a4f1eb1586ad0636955b261b0b05", size = 2208504, upload-time = "2025-11-04T13:40:06.072Z" }, + { url = "https://files.pythonhosted.org/packages/77/56/87a61aad59c7c5b9dc8caad5a41a5545cba3810c3e828708b3d7404f6cef/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e536c98a7626a98feb2d3eaf75944ef6f3dbee447e1f841eae16f2f0a72d8ddc", size = 2335816, upload-time = "2025-11-04T13:40:07.835Z" }, + { url = "https://files.pythonhosted.org/packages/0d/76/941cc9f73529988688a665a5c0ecff1112b3d95ab48f81db5f7606f522d3/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eceb81a8d74f9267ef4081e246ffd6d129da5d87e37a77c9bde550cb04870c1c", size = 2075366, upload-time = "2025-11-04T13:40:09.804Z" }, + { url = "https://files.pythonhosted.org/packages/d3/43/ebef01f69baa07a482844faaa0a591bad1ef129253ffd0cdaa9d8a7f72d3/pydantic_core-2.41.5-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d38548150c39b74aeeb0ce8ee1d8e82696f4a4e16ddc6de7b1d8823f7de4b9b5", size = 2171698, upload-time = "2025-11-04T13:40:12.004Z" }, + { url = "https://files.pythonhosted.org/packages/b1/87/41f3202e4193e3bacfc2c065fab7706ebe81af46a83d3e27605029c1f5a6/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:c23e27686783f60290e36827f9c626e63154b82b116d7fe9adba1fda36da706c", size = 2132603, upload-time = "2025-11-04T13:40:13.868Z" }, + { url = "https://files.pythonhosted.org/packages/49/7d/4c00df99cb12070b6bccdef4a195255e6020a550d572768d92cc54dba91a/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:482c982f814460eabe1d3bb0adfdc583387bd4691ef00b90575ca0d2b6fe2294", size = 2329591, upload-time = "2025-11-04T13:40:15.672Z" }, + { url = "https://files.pythonhosted.org/packages/cc/6a/ebf4b1d65d458f3cda6a7335d141305dfa19bdc61140a884d165a8a1bbc7/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:bfea2a5f0b4d8d43adf9d7b8bf019fb46fdd10a2e5cde477fbcb9d1fa08c68e1", size = 2319068, upload-time = "2025-11-04T13:40:17.532Z" }, + { url = "https://files.pythonhosted.org/packages/49/3b/774f2b5cd4192d5ab75870ce4381fd89cf218af999515baf07e7206753f0/pydantic_core-2.41.5-cp312-cp312-win32.whl", hash = "sha256:b74557b16e390ec12dca509bce9264c3bbd128f8a2c376eaa68003d7f327276d", size = 1985908, upload-time = "2025-11-04T13:40:19.309Z" }, + { url = "https://files.pythonhosted.org/packages/86/45/00173a033c801cacf67c190fef088789394feaf88a98a7035b0e40d53dc9/pydantic_core-2.41.5-cp312-cp312-win_amd64.whl", hash = "sha256:1962293292865bca8e54702b08a4f26da73adc83dd1fcf26fbc875b35d81c815", size = 2020145, upload-time = "2025-11-04T13:40:21.548Z" }, + { url = "https://files.pythonhosted.org/packages/f9/22/91fbc821fa6d261b376a3f73809f907cec5ca6025642c463d3488aad22fb/pydantic_core-2.41.5-cp312-cp312-win_arm64.whl", hash = "sha256:1746d4a3d9a794cacae06a5eaaccb4b8643a131d45fbc9af23e353dc0a5ba5c3", size = 1976179, upload-time = "2025-11-04T13:40:23.393Z" }, + { url = "https://files.pythonhosted.org/packages/87/06/8806241ff1f70d9939f9af039c6c35f2360cf16e93c2ca76f184e76b1564/pydantic_core-2.41.5-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:941103c9be18ac8daf7b7adca8228f8ed6bb7a1849020f643b3a14d15b1924d9", size = 2120403, upload-time = "2025-11-04T13:40:25.248Z" }, + { url = "https://files.pythonhosted.org/packages/94/02/abfa0e0bda67faa65fef1c84971c7e45928e108fe24333c81f3bfe35d5f5/pydantic_core-2.41.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:112e305c3314f40c93998e567879e887a3160bb8689ef3d2c04b6cc62c33ac34", size = 1896206, upload-time = "2025-11-04T13:40:27.099Z" }, + { url = "https://files.pythonhosted.org/packages/15/df/a4c740c0943e93e6500f9eb23f4ca7ec9bf71b19e608ae5b579678c8d02f/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0cbaad15cb0c90aa221d43c00e77bb33c93e8d36e0bf74760cd00e732d10a6a0", size = 1919307, upload-time = "2025-11-04T13:40:29.806Z" }, + { url = "https://files.pythonhosted.org/packages/9a/e3/6324802931ae1d123528988e0e86587c2072ac2e5394b4bc2bc34b61ff6e/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:03ca43e12fab6023fc79d28ca6b39b05f794ad08ec2feccc59a339b02f2b3d33", size = 2063258, upload-time = "2025-11-04T13:40:33.544Z" }, + { url = "https://files.pythonhosted.org/packages/c9/d4/2230d7151d4957dd79c3044ea26346c148c98fbf0ee6ebd41056f2d62ab5/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:dc799088c08fa04e43144b164feb0c13f9a0bc40503f8df3e9fde58a3c0c101e", size = 2214917, upload-time = "2025-11-04T13:40:35.479Z" }, + { url = "https://files.pythonhosted.org/packages/e6/9f/eaac5df17a3672fef0081b6c1bb0b82b33ee89aa5cec0d7b05f52fd4a1fa/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:97aeba56665b4c3235a0e52b2c2f5ae9cd071b8a8310ad27bddb3f7fb30e9aa2", size = 2332186, upload-time = "2025-11-04T13:40:37.436Z" }, + { url = "https://files.pythonhosted.org/packages/cf/4e/35a80cae583a37cf15604b44240e45c05e04e86f9cfd766623149297e971/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:406bf18d345822d6c21366031003612b9c77b3e29ffdb0f612367352aab7d586", size = 2073164, upload-time = "2025-11-04T13:40:40.289Z" }, + { url = "https://files.pythonhosted.org/packages/bf/e3/f6e262673c6140dd3305d144d032f7bd5f7497d3871c1428521f19f9efa2/pydantic_core-2.41.5-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:b93590ae81f7010dbe380cdeab6f515902ebcbefe0b9327cc4804d74e93ae69d", size = 2179146, upload-time = "2025-11-04T13:40:42.809Z" }, + { url = "https://files.pythonhosted.org/packages/75/c7/20bd7fc05f0c6ea2056a4565c6f36f8968c0924f19b7d97bbfea55780e73/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:01a3d0ab748ee531f4ea6c3e48ad9dac84ddba4b0d82291f87248f2f9de8d740", size = 2137788, upload-time = "2025-11-04T13:40:44.752Z" }, + { url = "https://files.pythonhosted.org/packages/3a/8d/34318ef985c45196e004bc46c6eab2eda437e744c124ef0dbe1ff2c9d06b/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:6561e94ba9dacc9c61bce40e2d6bdc3bfaa0259d3ff36ace3b1e6901936d2e3e", size = 2340133, upload-time = "2025-11-04T13:40:46.66Z" }, + { url = "https://files.pythonhosted.org/packages/9c/59/013626bf8c78a5a5d9350d12e7697d3d4de951a75565496abd40ccd46bee/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:915c3d10f81bec3a74fbd4faebe8391013ba61e5a1a8d48c4455b923bdda7858", size = 2324852, upload-time = "2025-11-04T13:40:48.575Z" }, + { url = "https://files.pythonhosted.org/packages/1a/d9/c248c103856f807ef70c18a4f986693a46a8ffe1602e5d361485da502d20/pydantic_core-2.41.5-cp313-cp313-win32.whl", hash = "sha256:650ae77860b45cfa6e2cdafc42618ceafab3a2d9a3811fcfbd3bbf8ac3c40d36", size = 1994679, upload-time = "2025-11-04T13:40:50.619Z" }, + { url = "https://files.pythonhosted.org/packages/9e/8b/341991b158ddab181cff136acd2552c9f35bd30380422a639c0671e99a91/pydantic_core-2.41.5-cp313-cp313-win_amd64.whl", hash = "sha256:79ec52ec461e99e13791ec6508c722742ad745571f234ea6255bed38c6480f11", size = 2019766, upload-time = "2025-11-04T13:40:52.631Z" }, + { url = "https://files.pythonhosted.org/packages/73/7d/f2f9db34af103bea3e09735bb40b021788a5e834c81eedb541991badf8f5/pydantic_core-2.41.5-cp313-cp313-win_arm64.whl", hash = "sha256:3f84d5c1b4ab906093bdc1ff10484838aca54ef08de4afa9de0f5f14d69639cd", size = 1981005, upload-time = "2025-11-04T13:40:54.734Z" }, + { url = "https://files.pythonhosted.org/packages/ea/28/46b7c5c9635ae96ea0fbb779e271a38129df2550f763937659ee6c5dbc65/pydantic_core-2.41.5-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:3f37a19d7ebcdd20b96485056ba9e8b304e27d9904d233d7b1015db320e51f0a", size = 2119622, upload-time = "2025-11-04T13:40:56.68Z" }, + { url = "https://files.pythonhosted.org/packages/74/1a/145646e5687e8d9a1e8d09acb278c8535ebe9e972e1f162ed338a622f193/pydantic_core-2.41.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1d1d9764366c73f996edd17abb6d9d7649a7eb690006ab6adbda117717099b14", size = 1891725, upload-time = "2025-11-04T13:40:58.807Z" }, + { url = "https://files.pythonhosted.org/packages/23/04/e89c29e267b8060b40dca97bfc64a19b2a3cf99018167ea1677d96368273/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:25e1c2af0fce638d5f1988b686f3b3ea8cd7de5f244ca147c777769e798a9cd1", size = 1915040, upload-time = "2025-11-04T13:41:00.853Z" }, + { url = "https://files.pythonhosted.org/packages/84/a3/15a82ac7bd97992a82257f777b3583d3e84bdb06ba6858f745daa2ec8a85/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:506d766a8727beef16b7adaeb8ee6217c64fc813646b424d0804d67c16eddb66", size = 2063691, upload-time = "2025-11-04T13:41:03.504Z" }, + { url = "https://files.pythonhosted.org/packages/74/9b/0046701313c6ef08c0c1cf0e028c67c770a4e1275ca73131563c5f2a310a/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4819fa52133c9aa3c387b3328f25c1facc356491e6135b459f1de698ff64d869", size = 2213897, upload-time = "2025-11-04T13:41:05.804Z" }, + { url = "https://files.pythonhosted.org/packages/8a/cd/6bac76ecd1b27e75a95ca3a9a559c643b3afcd2dd62086d4b7a32a18b169/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2b761d210c9ea91feda40d25b4efe82a1707da2ef62901466a42492c028553a2", size = 2333302, upload-time = "2025-11-04T13:41:07.809Z" }, + { url = "https://files.pythonhosted.org/packages/4c/d2/ef2074dc020dd6e109611a8be4449b98cd25e1b9b8a303c2f0fca2f2bcf7/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:22f0fb8c1c583a3b6f24df2470833b40207e907b90c928cc8d3594b76f874375", size = 2064877, upload-time = "2025-11-04T13:41:09.827Z" }, + { url = "https://files.pythonhosted.org/packages/18/66/e9db17a9a763d72f03de903883c057b2592c09509ccfe468187f2a2eef29/pydantic_core-2.41.5-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2782c870e99878c634505236d81e5443092fba820f0373997ff75f90f68cd553", size = 2180680, upload-time = "2025-11-04T13:41:12.379Z" }, + { url = "https://files.pythonhosted.org/packages/d3/9e/3ce66cebb929f3ced22be85d4c2399b8e85b622db77dad36b73c5387f8f8/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:0177272f88ab8312479336e1d777f6b124537d47f2123f89cb37e0accea97f90", size = 2138960, upload-time = "2025-11-04T13:41:14.627Z" }, + { url = "https://files.pythonhosted.org/packages/a6/62/205a998f4327d2079326b01abee48e502ea739d174f0a89295c481a2272e/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_armv7l.whl", hash = "sha256:63510af5e38f8955b8ee5687740d6ebf7c2a0886d15a6d65c32814613681bc07", size = 2339102, upload-time = "2025-11-04T13:41:16.868Z" }, + { url = "https://files.pythonhosted.org/packages/3c/0d/f05e79471e889d74d3d88f5bd20d0ed189ad94c2423d81ff8d0000aab4ff/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:e56ba91f47764cc14f1daacd723e3e82d1a89d783f0f5afe9c364b8bb491ccdb", size = 2326039, upload-time = "2025-11-04T13:41:18.934Z" }, + { url = "https://files.pythonhosted.org/packages/ec/e1/e08a6208bb100da7e0c4b288eed624a703f4d129bde2da475721a80cab32/pydantic_core-2.41.5-cp314-cp314-win32.whl", hash = "sha256:aec5cf2fd867b4ff45b9959f8b20ea3993fc93e63c7363fe6851424c8a7e7c23", size = 1995126, upload-time = "2025-11-04T13:41:21.418Z" }, + { url = "https://files.pythonhosted.org/packages/48/5d/56ba7b24e9557f99c9237e29f5c09913c81eeb2f3217e40e922353668092/pydantic_core-2.41.5-cp314-cp314-win_amd64.whl", hash = "sha256:8e7c86f27c585ef37c35e56a96363ab8de4e549a95512445b85c96d3e2f7c1bf", size = 2015489, upload-time = "2025-11-04T13:41:24.076Z" }, + { url = "https://files.pythonhosted.org/packages/4e/bb/f7a190991ec9e3e0ba22e4993d8755bbc4a32925c0b5b42775c03e8148f9/pydantic_core-2.41.5-cp314-cp314-win_arm64.whl", hash = "sha256:e672ba74fbc2dc8eea59fb6d4aed6845e6905fc2a8afe93175d94a83ba2a01a0", size = 1977288, upload-time = "2025-11-04T13:41:26.33Z" }, + { url = "https://files.pythonhosted.org/packages/92/ed/77542d0c51538e32e15afe7899d79efce4b81eee631d99850edc2f5e9349/pydantic_core-2.41.5-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:8566def80554c3faa0e65ac30ab0932b9e3a5cd7f8323764303d468e5c37595a", size = 2120255, upload-time = "2025-11-04T13:41:28.569Z" }, + { url = "https://files.pythonhosted.org/packages/bb/3d/6913dde84d5be21e284439676168b28d8bbba5600d838b9dca99de0fad71/pydantic_core-2.41.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:b80aa5095cd3109962a298ce14110ae16b8c1aece8b72f9dafe81cf597ad80b3", size = 1863760, upload-time = "2025-11-04T13:41:31.055Z" }, + { url = "https://files.pythonhosted.org/packages/5a/f0/e5e6b99d4191da102f2b0eb9687aaa7f5bea5d9964071a84effc3e40f997/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3006c3dd9ba34b0c094c544c6006cc79e87d8612999f1a5d43b769b89181f23c", size = 1878092, upload-time = "2025-11-04T13:41:33.21Z" }, + { url = "https://files.pythonhosted.org/packages/71/48/36fb760642d568925953bcc8116455513d6e34c4beaa37544118c36aba6d/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:72f6c8b11857a856bcfa48c86f5368439f74453563f951e473514579d44aa612", size = 2053385, upload-time = "2025-11-04T13:41:35.508Z" }, + { url = "https://files.pythonhosted.org/packages/20/25/92dc684dd8eb75a234bc1c764b4210cf2646479d54b47bf46061657292a8/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5cb1b2f9742240e4bb26b652a5aeb840aa4b417c7748b6f8387927bc6e45e40d", size = 2218832, upload-time = "2025-11-04T13:41:37.732Z" }, + { url = "https://files.pythonhosted.org/packages/e2/09/f53e0b05023d3e30357d82eb35835d0f6340ca344720a4599cd663dca599/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:bd3d54f38609ff308209bd43acea66061494157703364ae40c951f83ba99a1a9", size = 2327585, upload-time = "2025-11-04T13:41:40Z" }, + { url = "https://files.pythonhosted.org/packages/aa/4e/2ae1aa85d6af35a39b236b1b1641de73f5a6ac4d5a7509f77b814885760c/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2ff4321e56e879ee8d2a879501c8e469414d948f4aba74a2d4593184eb326660", size = 2041078, upload-time = "2025-11-04T13:41:42.323Z" }, + { url = "https://files.pythonhosted.org/packages/cd/13/2e215f17f0ef326fc72afe94776edb77525142c693767fc347ed6288728d/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d0d2568a8c11bf8225044aa94409e21da0cb09dcdafe9ecd10250b2baad531a9", size = 2173914, upload-time = "2025-11-04T13:41:45.221Z" }, + { url = "https://files.pythonhosted.org/packages/02/7a/f999a6dcbcd0e5660bc348a3991c8915ce6599f4f2c6ac22f01d7a10816c/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:a39455728aabd58ceabb03c90e12f71fd30fa69615760a075b9fec596456ccc3", size = 2129560, upload-time = "2025-11-04T13:41:47.474Z" }, + { url = "https://files.pythonhosted.org/packages/3a/b1/6c990ac65e3b4c079a4fb9f5b05f5b013afa0f4ed6780a3dd236d2cbdc64/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_armv7l.whl", hash = "sha256:239edca560d05757817c13dc17c50766136d21f7cd0fac50295499ae24f90fdf", size = 2329244, upload-time = "2025-11-04T13:41:49.992Z" }, + { url = "https://files.pythonhosted.org/packages/d9/02/3c562f3a51afd4d88fff8dffb1771b30cfdfd79befd9883ee094f5b6c0d8/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:2a5e06546e19f24c6a96a129142a75cee553cc018ffee48a460059b1185f4470", size = 2331955, upload-time = "2025-11-04T13:41:54.079Z" }, + { url = "https://files.pythonhosted.org/packages/5c/96/5fb7d8c3c17bc8c62fdb031c47d77a1af698f1d7a406b0f79aaa1338f9ad/pydantic_core-2.41.5-cp314-cp314t-win32.whl", hash = "sha256:b4ececa40ac28afa90871c2cc2b9ffd2ff0bf749380fbdf57d165fd23da353aa", size = 1988906, upload-time = "2025-11-04T13:41:56.606Z" }, + { url = "https://files.pythonhosted.org/packages/22/ed/182129d83032702912c2e2d8bbe33c036f342cc735737064668585dac28f/pydantic_core-2.41.5-cp314-cp314t-win_amd64.whl", hash = "sha256:80aa89cad80b32a912a65332f64a4450ed00966111b6615ca6816153d3585a8c", size = 1981607, upload-time = "2025-11-04T13:41:58.889Z" }, + { url = "https://files.pythonhosted.org/packages/9f/ed/068e41660b832bb0b1aa5b58011dea2a3fe0ba7861ff38c4d4904c1c1a99/pydantic_core-2.41.5-cp314-cp314t-win_arm64.whl", hash = "sha256:35b44f37a3199f771c3eaa53051bc8a70cd7b54f333531c59e29fd4db5d15008", size = 1974769, upload-time = "2025-11-04T13:42:01.186Z" }, + { url = "https://files.pythonhosted.org/packages/09/32/59b0c7e63e277fa7911c2fc70ccfb45ce4b98991e7ef37110663437005af/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-macosx_10_12_x86_64.whl", hash = "sha256:7da7087d756b19037bc2c06edc6c170eeef3c3bafcb8f532ff17d64dc427adfd", size = 2110495, upload-time = "2025-11-04T13:42:49.689Z" }, + { url = "https://files.pythonhosted.org/packages/aa/81/05e400037eaf55ad400bcd318c05bb345b57e708887f07ddb2d20e3f0e98/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:aabf5777b5c8ca26f7824cb4a120a740c9588ed58df9b2d196ce92fba42ff8dc", size = 1915388, upload-time = "2025-11-04T13:42:52.215Z" }, + { url = "https://files.pythonhosted.org/packages/6e/0d/e3549b2399f71d56476b77dbf3cf8937cec5cd70536bdc0e374a421d0599/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c007fe8a43d43b3969e8469004e9845944f1a80e6acd47c150856bb87f230c56", size = 1942879, upload-time = "2025-11-04T13:42:56.483Z" }, + { url = "https://files.pythonhosted.org/packages/f7/07/34573da085946b6a313d7c42f82f16e8920bfd730665de2d11c0c37a74b5/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:76d0819de158cd855d1cbb8fcafdf6f5cf1eb8e470abe056d5d161106e38062b", size = 2139017, upload-time = "2025-11-04T13:42:59.471Z" }, +] + +[[package]] +name = "pygments" +version = "2.19.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b0/77/a5b8c569bf593b0140bde72ea885a803b82086995367bf2037de0159d924/pygments-2.19.2.tar.gz", hash = "sha256:636cb2477cec7f8952536970bc533bc43743542f70392ae026374600add5b887", size = 4968631, upload-time = "2025-06-21T13:39:12.283Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c7/21/705964c7812476f378728bdf590ca4b771ec72385c533964653c68e86bdc/pygments-2.19.2-py3-none-any.whl", hash = "sha256:86540386c03d588bb81d44bc3928634ff26449851e99741617ecb9037ee5ec0b", size = 1225217, upload-time = "2025-06-21T13:39:07.939Z" }, +] + +[[package]] +name = "pytest" +version = "9.0.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, + { name = "iniconfig" }, + { name = "packaging" }, + { name = "pluggy" }, + { name = "pygments" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/d1/db/7ef3487e0fb0049ddb5ce41d3a49c235bf9ad299b6a25d5780a89f19230f/pytest-9.0.2.tar.gz", hash = "sha256:75186651a92bd89611d1d9fc20f0b4345fd827c41ccd5c299a868a05d70edf11", size = 1568901, upload-time = "2025-12-06T21:30:51.014Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3b/ab/b3226f0bd7cdcf710fbede2b3548584366da3b19b5021e74f5bde2a8fa3f/pytest-9.0.2-py3-none-any.whl", hash = "sha256:711ffd45bf766d5264d487b917733b453d917afd2b0ad65223959f59089f875b", size = 374801, upload-time = "2025-12-06T21:30:49.154Z" }, +] + +[[package]] +name = "pytest-asyncio" +version = "1.3.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pytest" }, + { name = "typing-extensions", marker = "python_full_version < '3.13'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/90/2c/8af215c0f776415f3590cac4f9086ccefd6fd463befeae41cd4d3f193e5a/pytest_asyncio-1.3.0.tar.gz", hash = "sha256:d7f52f36d231b80ee124cd216ffb19369aa168fc10095013c6b014a34d3ee9e5", size = 50087, upload-time = "2025-11-10T16:07:47.256Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e5/35/f8b19922b6a25bc0880171a2f1a003eaeb93657475193ab516fd87cac9da/pytest_asyncio-1.3.0-py3-none-any.whl", hash = "sha256:611e26147c7f77640e6d0a92a38ed17c3e9848063698d5c93d5aa7aa11cebff5", size = 15075, upload-time = "2025-11-10T16:07:45.537Z" }, +] + +[[package]] +name = "python-dotenv" +version = "1.2.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/82/ed/0301aeeac3e5353ef3d94b6ec08bbcabd04a72018415dcb29e588514bba8/python_dotenv-1.2.2.tar.gz", hash = "sha256:2c371a91fbd7ba082c2c1dc1f8bf89ca22564a087c2c287cd9b662adde799cf3", size = 50135, upload-time = "2026-03-01T16:00:26.196Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0b/d7/1959b9648791274998a9c3526f6d0ec8fd2233e4d4acce81bbae76b44b2a/python_dotenv-1.2.2-py3-none-any.whl", hash = "sha256:1d8214789a24de455a8b8bd8ae6fe3c6b69a5e3d64aa8a8e5d68e694bbcb285a", size = 22101, upload-time = "2026-03-01T16:00:25.09Z" }, +] + +[[package]] +name = "python-telegram-bot" +version = "22.7" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "httpcore", marker = "python_full_version >= '3.14'" }, + { name = "httpx" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/e4/25/2258161b1069e66d6c39c0a602dbe57461d4767dc0012539970ea40bc9d6/python_telegram_bot-22.7.tar.gz", hash = "sha256:784b59ea3852fe4616ad63b4a0264c755637f5d725e87755ecdee28300febf61", size = 1516454, upload-time = "2026-03-16T09:36:03.174Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/94/f7/0e2f89dd62f45d46d4ea0d8aec5893ce5b37389638db010c117f46f11450/python_telegram_bot-22.7-py3-none-any.whl", hash = "sha256:d72eed532cf763758cd9331b57a6d790aff0bb4d37d8f4e92149436fe21c6475", size = 745365, upload-time = "2026-03-16T09:36:01.498Z" }, +] + +[[package]] +name = "ratelim" +version = "0.1.6" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "decorator" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/c5/5a/e1440017bccb14523bb76356e6f3a5468386b8a9192bd901e98babd1a1ea/ratelim-0.1.6.tar.gz", hash = "sha256:826d32177e11f9a12831901c9fda6679fd5bbea3605910820167088f5acbb11d", size = 2793, upload-time = "2015-02-27T18:06:08.53Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f2/98/7e6d147fd16a10a5f821db6e25f192265d6ecca3d82957a4fdd592cad49c/ratelim-0.1.6-py2.py3-none-any.whl", hash = "sha256:e1a7dd39e6b552b7cc7f52169cd66cdb826a1a30198e355d7016012987c9ad08", size = 4017, upload-time = "2015-02-27T18:06:06.464Z" }, +] + +[[package]] +name = "requests" +version = "2.32.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "certifi" }, + { name = "charset-normalizer" }, + { name = "idna" }, + { name = "urllib3" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/c9/74/b3ff8e6c8446842c3f5c837e9c3dfcfe2018ea6ecef224c710c85ef728f4/requests-2.32.5.tar.gz", hash = "sha256:dbba0bac56e100853db0ea71b82b4dfd5fe2bf6d3754a8893c3af500cec7d7cf", size = 134517, upload-time = "2025-08-18T20:46:02.573Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1e/db/4254e3eabe8020b458f1a747140d32277ec7a271daf1d235b70dc0b4e6e3/requests-2.32.5-py3-none-any.whl", hash = "sha256:2462f94637a34fd532264295e186976db0f5d453d1cdd31473c85a6a161affb6", size = 64738, upload-time = "2025-08-18T20:46:00.542Z" }, +] + +[[package]] +name = "ruff" +version = "0.15.6" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/51/df/f8629c19c5318601d3121e230f74cbee7a3732339c52b21daa2b82ef9c7d/ruff-0.15.6.tar.gz", hash = "sha256:8394c7bb153a4e3811a4ecdacd4a8e6a4fa8097028119160dffecdcdf9b56ae4", size = 4597916, upload-time = "2026-03-12T23:05:47.51Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9e/2f/4e03a7e5ce99b517e98d3b4951f411de2b0fa8348d39cf446671adcce9a2/ruff-0.15.6-py3-none-linux_armv6l.whl", hash = "sha256:7c98c3b16407b2cf3d0f2b80c80187384bc92c6774d85fefa913ecd941256fff", size = 10508953, upload-time = "2026-03-12T23:05:17.246Z" }, + { url = "https://files.pythonhosted.org/packages/70/60/55bcdc3e9f80bcf39edf0cd272da6fa511a3d94d5a0dd9e0adf76ceebdb4/ruff-0.15.6-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:ee7dcfaad8b282a284df4aa6ddc2741b3f4a18b0555d626805555a820ea181c3", size = 10942257, upload-time = "2026-03-12T23:05:23.076Z" }, + { url = "https://files.pythonhosted.org/packages/e7/f9/005c29bd1726c0f492bfa215e95154cf480574140cb5f867c797c18c790b/ruff-0.15.6-py3-none-macosx_11_0_arm64.whl", hash = "sha256:3bd9967851a25f038fc8b9ae88a7fbd1b609f30349231dffaa37b6804923c4bb", size = 10322683, upload-time = "2026-03-12T23:05:33.738Z" }, + { url = "https://files.pythonhosted.org/packages/5f/74/2f861f5fd7cbb2146bddb5501450300ce41562da36d21868c69b7a828169/ruff-0.15.6-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:13f4594b04e42cd24a41da653886b04d2ff87adbf57497ed4f728b0e8a4866f8", size = 10660986, upload-time = "2026-03-12T23:05:53.245Z" }, + { url = "https://files.pythonhosted.org/packages/c1/a1/309f2364a424eccb763cdafc49df843c282609f47fe53aa83f38272389e0/ruff-0.15.6-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e2ed8aea2f3fe57886d3f00ea5b8aae5bf68d5e195f487f037a955ff9fbaac9e", size = 10332177, upload-time = "2026-03-12T23:05:56.145Z" }, + { url = "https://files.pythonhosted.org/packages/30/41/7ebf1d32658b4bab20f8ac80972fb19cd4e2c6b78552be263a680edc55ac/ruff-0.15.6-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:70789d3e7830b848b548aae96766431c0dc01a6c78c13381f423bf7076c66d15", size = 11170783, upload-time = "2026-03-12T23:06:01.742Z" }, + { url = "https://files.pythonhosted.org/packages/76/be/6d488f6adca047df82cd62c304638bcb00821c36bd4881cfca221561fdfc/ruff-0.15.6-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:542aaf1de3154cea088ced5a819ce872611256ffe2498e750bbae5247a8114e9", size = 12044201, upload-time = "2026-03-12T23:05:28.697Z" }, + { url = "https://files.pythonhosted.org/packages/71/68/e6f125df4af7e6d0b498f8d373274794bc5156b324e8ab4bf5c1b4fc0ec7/ruff-0.15.6-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:1c22e6f02c16cfac3888aa636e9eba857254d15bbacc9906c9689fdecb1953ab", size = 11421561, upload-time = "2026-03-12T23:05:31.236Z" }, + { url = "https://files.pythonhosted.org/packages/f1/9f/f85ef5fd01a52e0b472b26dc1b4bd228b8f6f0435975442ffa4741278703/ruff-0.15.6-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:98893c4c0aadc8e448cfa315bd0cc343a5323d740fe5f28ef8a3f9e21b381f7e", size = 11310928, upload-time = "2026-03-12T23:05:45.288Z" }, + { url = "https://files.pythonhosted.org/packages/8c/26/b75f8c421f5654304b89471ed384ae8c7f42b4dff58fa6ce1626d7f2b59a/ruff-0.15.6-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:70d263770d234912374493e8cc1e7385c5d49376e41dfa51c5c3453169dc581c", size = 11235186, upload-time = "2026-03-12T23:05:50.677Z" }, + { url = "https://files.pythonhosted.org/packages/fc/d4/d5a6d065962ff7a68a86c9b4f5500f7d101a0792078de636526c0edd40da/ruff-0.15.6-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:55a1ad63c5a6e54b1f21b7514dfadc0c7fb40093fa22e95143cf3f64ebdcd512", size = 10635231, upload-time = "2026-03-12T23:05:37.044Z" }, + { url = "https://files.pythonhosted.org/packages/d6/56/7c3acf3d50910375349016cf33de24be021532042afbed87942858992491/ruff-0.15.6-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:8dc473ba093c5ec238bb1e7429ee676dca24643c471e11fbaa8a857925b061c0", size = 10340357, upload-time = "2026-03-12T23:06:04.748Z" }, + { url = "https://files.pythonhosted.org/packages/06/54/6faa39e9c1033ff6a3b6e76b5df536931cd30caf64988e112bbf91ef5ce5/ruff-0.15.6-py3-none-musllinux_1_2_i686.whl", hash = "sha256:85b042377c2a5561131767974617006f99f7e13c63c111b998f29fc1e58a4cfb", size = 10860583, upload-time = "2026-03-12T23:05:58.978Z" }, + { url = "https://files.pythonhosted.org/packages/cb/1e/509a201b843b4dfb0b32acdedf68d951d3377988cae43949ba4c4133a96a/ruff-0.15.6-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:cef49e30bc5a86a6a92098a7fbf6e467a234d90b63305d6f3ec01225a9d092e0", size = 11410976, upload-time = "2026-03-12T23:05:39.955Z" }, + { url = "https://files.pythonhosted.org/packages/6c/25/3fc9114abf979a41673ce877c08016f8e660ad6cf508c3957f537d2e9fa9/ruff-0.15.6-py3-none-win32.whl", hash = "sha256:bbf67d39832404812a2d23020dda68fee7f18ce15654e96fb1d3ad21a5fe436c", size = 10616872, upload-time = "2026-03-12T23:05:42.451Z" }, + { url = "https://files.pythonhosted.org/packages/89/7a/09ece68445ceac348df06e08bf75db72d0e8427765b96c9c0ffabc1be1d9/ruff-0.15.6-py3-none-win_amd64.whl", hash = "sha256:aee25bc84c2f1007ecb5037dff75cef00414fdf17c23f07dc13e577883dca406", size = 11787271, upload-time = "2026-03-12T23:05:20.168Z" }, + { url = "https://files.pythonhosted.org/packages/7f/d0/578c47dd68152ddddddf31cd7fc67dc30b7cdf639a86275fda821b0d9d98/ruff-0.15.6-py3-none-win_arm64.whl", hash = "sha256:c34de3dd0b0ba203be50ae70f5910b17188556630e2178fd7d79fc030eb0d837", size = 11060497, upload-time = "2026-03-12T23:05:25.968Z" }, +] + +[[package]] +name = "six" +version = "1.17.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81", size = 34031, upload-time = "2024-12-04T17:35:28.174Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050, upload-time = "2024-12-04T17:35:26.475Z" }, +] + +[[package]] +name = "sniffio" +version = "1.3.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a2/87/a6771e1546d97e7e041b6ae58d80074f81b7d5121207425c964ddf5cfdbd/sniffio-1.3.1.tar.gz", hash = "sha256:f4324edc670a0f49750a81b895f35c3adb843cca46f0530f79fc1babb23789dc", size = 20372, upload-time = "2024-02-25T23:20:04.057Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e9/44/75a9c9421471a6c4805dbf2356f7c181a29c1879239abab1ea2cc8f38b40/sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2", size = 10235, upload-time = "2024-02-25T23:20:01.196Z" }, +] + +[[package]] +name = "tqdm" +version = "4.67.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/09/a9/6ba95a270c6f1fbcd8dac228323f2777d886cb206987444e4bce66338dd4/tqdm-4.67.3.tar.gz", hash = "sha256:7d825f03f89244ef73f1d4ce193cb1774a8179fd96f31d7e1dcde62092b960bb", size = 169598, upload-time = "2026-02-03T17:35:53.048Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/16/e1/3079a9ff9b8e11b846c6ac5c8b5bfb7ff225eee721825310c91b3b50304f/tqdm-4.67.3-py3-none-any.whl", hash = "sha256:ee1e4c0e59148062281c49d80b25b67771a127c85fc9676d3be5f243206826bf", size = 78374, upload-time = "2026-02-03T17:35:50.982Z" }, +] + +[[package]] +name = "typing-extensions" +version = "4.15.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac84269196e94cf00f187f7ed21c242792a923cdb1c61f/typing_extensions-4.15.0.tar.gz", hash = "sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466", size = 109391, upload-time = "2025-08-25T13:49:26.313Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548", size = 44614, upload-time = "2025-08-25T13:49:24.86Z" }, +] + +[[package]] +name = "typing-inspection" +version = "0.4.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/55/e3/70399cb7dd41c10ac53367ae42139cf4b1ca5f36bb3dc6c9d33acdb43655/typing_inspection-0.4.2.tar.gz", hash = "sha256:ba561c48a67c5958007083d386c3295464928b01faa735ab8547c5692e87f464", size = 75949, upload-time = "2025-10-01T02:14:41.687Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/dc/9b/47798a6c91d8bdb567fe2698fe81e0c6b7cb7ef4d13da4114b41d239f65d/typing_inspection-0.4.2-py3-none-any.whl", hash = "sha256:4ed1cacbdc298c220f1bd249ed5287caa16f34d44ef4e9c3d0cbad5b521545e7", size = 14611, upload-time = "2025-10-01T02:14:40.154Z" }, +] + +[[package]] +name = "urllib3" +version = "2.6.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/c7/24/5f1b3bdffd70275f6661c76461e25f024d5a38a46f04aaca912426a2b1d3/urllib3-2.6.3.tar.gz", hash = "sha256:1b62b6884944a57dbe321509ab94fd4d3b307075e0c2eae991ac71ee15ad38ed", size = 435556, upload-time = "2026-01-07T16:24:43.925Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/39/08/aaaad47bc4e9dc8c725e68f9d04865dbcb2052843ff09c97b08904852d84/urllib3-2.6.3-py3-none-any.whl", hash = "sha256:bf272323e553dfb2e87d9bfd225ca7b0f467b919d7bbd355436d3fd37cb0acd4", size = 131584, upload-time = "2026-01-07T16:24:42.685Z" }, +] + +[[package]] +name = "yarl" +version = "1.23.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "idna" }, + { name = "multidict" }, + { name = "propcache" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/23/6e/beb1beec874a72f23815c1434518bfc4ed2175065173fb138c3705f658d4/yarl-1.23.0.tar.gz", hash = "sha256:53b1ea6ca88ebd4420379c330aea57e258408dd0df9af0992e5de2078dc9f5d5", size = 194676, upload-time = "2026-03-01T22:07:53.373Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/88/8a/94615bc31022f711add374097ad4144d569e95ff3c38d39215d07ac153a0/yarl-1.23.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:1932b6b8bba8d0160a9d1078aae5838a66039e8832d41d2992daa9a3a08f7860", size = 124737, upload-time = "2026-03-01T22:05:12.897Z" }, + { url = "https://files.pythonhosted.org/packages/e3/6f/c6554045d59d64052698add01226bc867b52fe4a12373415d7991fdca95d/yarl-1.23.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:411225bae281f114067578891bc75534cfb3d92a3b4dfef7a6ca78ba354e6069", size = 87029, upload-time = "2026-03-01T22:05:14.376Z" }, + { url = "https://files.pythonhosted.org/packages/19/2a/725ecc166d53438bc88f76822ed4b1e3b10756e790bafd7b523fe97c322d/yarl-1.23.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:13a563739ae600a631c36ce096615fe307f131344588b0bc0daec108cdb47b25", size = 86310, upload-time = "2026-03-01T22:05:15.71Z" }, + { url = "https://files.pythonhosted.org/packages/99/30/58260ed98e6ff7f90ba84442c1ddd758c9170d70327394a6227b310cd60f/yarl-1.23.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9cbf44c5cb4a7633d078788e1b56387e3d3cf2b8139a3be38040b22d6c3221c8", size = 97587, upload-time = "2026-03-01T22:05:17.384Z" }, + { url = "https://files.pythonhosted.org/packages/76/0a/8b08aac08b50682e65759f7f8dde98ae8168f72487e7357a5d684c581ef9/yarl-1.23.0-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:53ad387048f6f09a8969631e4de3f1bf70c50e93545d64af4f751b2498755072", size = 92528, upload-time = "2026-03-01T22:05:18.804Z" }, + { url = "https://files.pythonhosted.org/packages/52/07/0b7179101fe5f8385ec6c6bb5d0cb9f76bd9fb4a769591ab6fb5cdbfc69a/yarl-1.23.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4a59ba56f340334766f3a4442e0efd0af895fae9e2b204741ef885c446b3a1a8", size = 105339, upload-time = "2026-03-01T22:05:20.235Z" }, + { url = "https://files.pythonhosted.org/packages/d3/8a/36d82869ab5ec829ca8574dfcb92b51286fcfb1e9c7a73659616362dc880/yarl-1.23.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:803a3c3ce4acc62eaf01eaca1208dcf0783025ef27572c3336502b9c232005e7", size = 105061, upload-time = "2026-03-01T22:05:22.268Z" }, + { url = "https://files.pythonhosted.org/packages/66/3e/868e5c3364b6cee19ff3e1a122194fa4ce51def02c61023970442162859e/yarl-1.23.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a3d2bff8f37f8d0f96c7ec554d16945050d54462d6e95414babaa18bfafc7f51", size = 100132, upload-time = "2026-03-01T22:05:23.638Z" }, + { url = "https://files.pythonhosted.org/packages/cf/26/9c89acf82f08a52cb52d6d39454f8d18af15f9d386a23795389d1d423823/yarl-1.23.0-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c75eb09e8d55bceb4367e83496ff8ef2bc7ea6960efb38e978e8073ea59ecb67", size = 99289, upload-time = "2026-03-01T22:05:25.749Z" }, + { url = "https://files.pythonhosted.org/packages/6f/54/5b0db00d2cb056922356104468019c0a132e89c8d3ab67d8ede9f4483d2a/yarl-1.23.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:877b0738624280e34c55680d6054a307aa94f7d52fa0e3034a9cc6e790871da7", size = 96950, upload-time = "2026-03-01T22:05:27.318Z" }, + { url = "https://files.pythonhosted.org/packages/f6/40/10fa93811fd439341fad7e0718a86aca0de9548023bbb403668d6555acab/yarl-1.23.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:b5405bb8f0e783a988172993cfc627e4d9d00432d6bbac65a923041edacf997d", size = 93960, upload-time = "2026-03-01T22:05:28.738Z" }, + { url = "https://files.pythonhosted.org/packages/bc/d2/8ae2e6cd77d0805f4526e30ec43b6f9a3dfc542d401ac4990d178e4bf0cf/yarl-1.23.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:1c3a3598a832590c5a3ce56ab5576361b5688c12cb1d39429cf5dba30b510760", size = 104703, upload-time = "2026-03-01T22:05:30.438Z" }, + { url = "https://files.pythonhosted.org/packages/2f/0c/b3ceacf82c3fe21183ce35fa2acf5320af003d52bc1fcf5915077681142e/yarl-1.23.0-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:8419ebd326430d1cbb7efb5292330a2cf39114e82df5cc3d83c9a0d5ebeaf2f2", size = 98325, upload-time = "2026-03-01T22:05:31.835Z" }, + { url = "https://files.pythonhosted.org/packages/9d/e0/12900edd28bdab91a69bd2554b85ad7b151f64e8b521fe16f9ad2f56477a/yarl-1.23.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:be61f6fff406ca40e3b1d84716fde398fc08bc63dd96d15f3a14230a0973ed86", size = 105067, upload-time = "2026-03-01T22:05:33.358Z" }, + { url = "https://files.pythonhosted.org/packages/15/61/74bb1182cf79c9bbe4eb6b1f14a57a22d7a0be5e9cedf8e2d5c2086474c3/yarl-1.23.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3ceb13c5c858d01321b5d9bb65e4cf37a92169ea470b70fec6f236b2c9dd7e34", size = 100285, upload-time = "2026-03-01T22:05:35.4Z" }, + { url = "https://files.pythonhosted.org/packages/69/7f/cd5ef733f2550de6241bd8bd8c3febc78158b9d75f197d9c7baa113436af/yarl-1.23.0-cp312-cp312-win32.whl", hash = "sha256:fffc45637bcd6538de8b85f51e3df3223e4ad89bccbfca0481c08c7fc8b7ed7d", size = 82359, upload-time = "2026-03-01T22:05:36.811Z" }, + { url = "https://files.pythonhosted.org/packages/f5/be/25216a49daeeb7af2bec0db22d5e7df08ed1d7c9f65d78b14f3b74fd72fc/yarl-1.23.0-cp312-cp312-win_amd64.whl", hash = "sha256:f69f57305656a4852f2a7203efc661d8c042e6cc67f7acd97d8667fb448a426e", size = 87674, upload-time = "2026-03-01T22:05:38.171Z" }, + { url = "https://files.pythonhosted.org/packages/d2/35/aeab955d6c425b227d5b7247eafb24f2653fedc32f95373a001af5dfeb9e/yarl-1.23.0-cp312-cp312-win_arm64.whl", hash = "sha256:6e87a6e8735b44816e7db0b2fbc9686932df473c826b0d9743148432e10bb9b9", size = 81879, upload-time = "2026-03-01T22:05:40.006Z" }, + { url = "https://files.pythonhosted.org/packages/9a/4b/a0a6e5d0ee8a2f3a373ddef8a4097d74ac901ac363eea1440464ccbe0898/yarl-1.23.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:16c6994ac35c3e74fb0ae93323bf8b9c2a9088d55946109489667c510a7d010e", size = 123796, upload-time = "2026-03-01T22:05:41.412Z" }, + { url = "https://files.pythonhosted.org/packages/67/b6/8925d68af039b835ae876db5838e82e76ec87b9782ecc97e192b809c4831/yarl-1.23.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:4a42e651629dafb64fd5b0286a3580613702b5809ad3f24934ea87595804f2c5", size = 86547, upload-time = "2026-03-01T22:05:42.841Z" }, + { url = "https://files.pythonhosted.org/packages/ae/50/06d511cc4b8e0360d3c94af051a768e84b755c5eb031b12adaaab6dec6e5/yarl-1.23.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7c6b9461a2a8b47c65eef63bb1c76a4f1c119618ffa99ea79bc5bb1e46c5821b", size = 85854, upload-time = "2026-03-01T22:05:44.85Z" }, + { url = "https://files.pythonhosted.org/packages/c4/f4/4e30b250927ffdab4db70da08b9b8d2194d7c7b400167b8fbeca1e4701ca/yarl-1.23.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2569b67d616eab450d262ca7cb9f9e19d2f718c70a8b88712859359d0ab17035", size = 98351, upload-time = "2026-03-01T22:05:46.836Z" }, + { url = "https://files.pythonhosted.org/packages/86/fc/4118c5671ea948208bdb1492d8b76bdf1453d3e73df051f939f563e7dcc5/yarl-1.23.0-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e9d9a4d06d3481eab79803beb4d9bd6f6a8e781ec078ac70d7ef2dcc29d1bea5", size = 92711, upload-time = "2026-03-01T22:05:48.316Z" }, + { url = "https://files.pythonhosted.org/packages/56/11/1ed91d42bd9e73c13dc9e7eb0dd92298d75e7ac4dd7f046ad0c472e231cd/yarl-1.23.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f514f6474e04179d3d33175ed3f3e31434d3130d42ec153540d5b157deefd735", size = 106014, upload-time = "2026-03-01T22:05:50.028Z" }, + { url = "https://files.pythonhosted.org/packages/ce/c9/74e44e056a23fbc33aca71779ef450ca648a5bc472bdad7a82339918f818/yarl-1.23.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:fda207c815b253e34f7e1909840fd14299567b1c0eb4908f8c2ce01a41265401", size = 105557, upload-time = "2026-03-01T22:05:51.416Z" }, + { url = "https://files.pythonhosted.org/packages/66/fe/b1e10b08d287f518994f1e2ff9b6d26f0adeecd8dd7d533b01bab29a3eda/yarl-1.23.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:34b6cf500e61c90f305094911f9acc9c86da1a05a7a3f5be9f68817043f486e4", size = 101559, upload-time = "2026-03-01T22:05:52.872Z" }, + { url = "https://files.pythonhosted.org/packages/72/59/c5b8d94b14e3d3c2a9c20cb100119fd534ab5a14b93673ab4cc4a4141ea5/yarl-1.23.0-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d7504f2b476d21653e4d143f44a175f7f751cd41233525312696c76aa3dbb23f", size = 100502, upload-time = "2026-03-01T22:05:54.954Z" }, + { url = "https://files.pythonhosted.org/packages/77/4f/96976cb54cbfc5c9fd73ed4c51804f92f209481d1fb190981c0f8a07a1d7/yarl-1.23.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:578110dd426f0d209d1509244e6d4a3f1a3e9077655d98c5f22583d63252a08a", size = 98027, upload-time = "2026-03-01T22:05:56.409Z" }, + { url = "https://files.pythonhosted.org/packages/63/6e/904c4f476471afdbad6b7e5b70362fb5810e35cd7466529a97322b6f5556/yarl-1.23.0-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:609d3614d78d74ebe35f54953c5bbd2ac647a7ddb9c30a5d877580f5e86b22f2", size = 95369, upload-time = "2026-03-01T22:05:58.141Z" }, + { url = "https://files.pythonhosted.org/packages/9d/40/acfcdb3b5f9d68ef499e39e04d25e141fe90661f9d54114556cf83be8353/yarl-1.23.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:4966242ec68afc74c122f8459abd597afd7d8a60dc93d695c1334c5fd25f762f", size = 105565, upload-time = "2026-03-01T22:06:00.286Z" }, + { url = "https://files.pythonhosted.org/packages/5e/c6/31e28f3a6ba2869c43d124f37ea5260cac9c9281df803c354b31f4dd1f3c/yarl-1.23.0-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:e0fd068364a6759bc794459f0a735ab151d11304346332489c7972bacbe9e72b", size = 99813, upload-time = "2026-03-01T22:06:01.712Z" }, + { url = "https://files.pythonhosted.org/packages/08/1f/6f65f59e72d54aa467119b63fc0b0b1762eff0232db1f4720cd89e2f4a17/yarl-1.23.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:39004f0ad156da43e86aa71f44e033de68a44e5a31fc53507b36dd253970054a", size = 105632, upload-time = "2026-03-01T22:06:03.188Z" }, + { url = "https://files.pythonhosted.org/packages/a3/c4/18b178a69935f9e7a338127d5b77d868fdc0f0e49becd286d51b3a18c61d/yarl-1.23.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e5723c01a56c5028c807c701aa66722916d2747ad737a046853f6c46f4875543", size = 101895, upload-time = "2026-03-01T22:06:04.651Z" }, + { url = "https://files.pythonhosted.org/packages/8f/54/f5b870b5505663911dba950a8e4776a0dbd51c9c54c0ae88e823e4b874a0/yarl-1.23.0-cp313-cp313-win32.whl", hash = "sha256:1b6b572edd95b4fa8df75de10b04bc81acc87c1c7d16bcdd2035b09d30acc957", size = 82356, upload-time = "2026-03-01T22:06:06.04Z" }, + { url = "https://files.pythonhosted.org/packages/7a/84/266e8da36879c6edcd37b02b547e2d9ecdfea776be49598e75696e3316e1/yarl-1.23.0-cp313-cp313-win_amd64.whl", hash = "sha256:baaf55442359053c7d62f6f8413a62adba3205119bcb6f49594894d8be47e5e3", size = 87515, upload-time = "2026-03-01T22:06:08.107Z" }, + { url = "https://files.pythonhosted.org/packages/00/fd/7e1c66efad35e1649114fa13f17485f62881ad58edeeb7f49f8c5e748bf9/yarl-1.23.0-cp313-cp313-win_arm64.whl", hash = "sha256:fb4948814a2a98e3912505f09c9e7493b1506226afb1f881825368d6fb776ee3", size = 81785, upload-time = "2026-03-01T22:06:10.181Z" }, + { url = "https://files.pythonhosted.org/packages/9c/fc/119dd07004f17ea43bb91e3ece6587759edd7519d6b086d16bfbd3319982/yarl-1.23.0-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:aecfed0b41aa72b7881712c65cf764e39ce2ec352324f5e0837c7048d9e6daaa", size = 130719, upload-time = "2026-03-01T22:06:11.708Z" }, + { url = "https://files.pythonhosted.org/packages/e6/0d/9f2348502fbb3af409e8f47730282cd6bc80dec6630c1e06374d882d6eb2/yarl-1.23.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:a41bcf68efd19073376eb8cf948b8d9be0af26256403e512bb18f3966f1f9120", size = 89690, upload-time = "2026-03-01T22:06:13.429Z" }, + { url = "https://files.pythonhosted.org/packages/50/93/e88f3c80971b42cfc83f50a51b9d165a1dbf154b97005f2994a79f212a07/yarl-1.23.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:cde9a2ecd91668bcb7f077c4966d8ceddb60af01b52e6e3e2680e4cf00ad1a59", size = 89851, upload-time = "2026-03-01T22:06:15.53Z" }, + { url = "https://files.pythonhosted.org/packages/1c/07/61c9dd8ba8f86473263b4036f70fb594c09e99c0d9737a799dfd8bc85651/yarl-1.23.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5023346c4ee7992febc0068e7593de5fa2bf611848c08404b35ebbb76b1b0512", size = 95874, upload-time = "2026-03-01T22:06:17.553Z" }, + { url = "https://files.pythonhosted.org/packages/9e/e9/f9ff8ceefba599eac6abddcfb0b3bee9b9e636e96dbf54342a8577252379/yarl-1.23.0-cp313-cp313t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:d1009abedb49ae95b136a8904a3f71b342f849ffeced2d3747bf29caeda218c4", size = 88710, upload-time = "2026-03-01T22:06:19.004Z" }, + { url = "https://files.pythonhosted.org/packages/eb/78/0231bfcc5d4c8eec220bc2f9ef82cb4566192ea867a7c5b4148f44f6cbcd/yarl-1.23.0-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a8d00f29b42f534cc8aa3931cfe773b13b23e561e10d2b26f27a8d309b0e82a1", size = 101033, upload-time = "2026-03-01T22:06:21.203Z" }, + { url = "https://files.pythonhosted.org/packages/cd/9b/30ea5239a61786f18fd25797151a17fbb3be176977187a48d541b5447dd4/yarl-1.23.0-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:95451e6ce06c3e104556d73b559f5da6c34a069b6b62946d3ad66afcd51642ea", size = 100817, upload-time = "2026-03-01T22:06:22.738Z" }, + { url = "https://files.pythonhosted.org/packages/62/e2/a4980481071791bc83bce2b7a1a1f7adcabfa366007518b4b845e92eeee3/yarl-1.23.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:531ef597132086b6cf96faa7c6c1dcd0361dd5f1694e5cc30375907b9b7d3ea9", size = 97482, upload-time = "2026-03-01T22:06:24.21Z" }, + { url = "https://files.pythonhosted.org/packages/e5/1e/304a00cf5f6100414c4b5a01fc7ff9ee724b62158a08df2f8170dfc72a2d/yarl-1.23.0-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:88f9fb0116fbfcefcab70f85cf4b74a2b6ce5d199c41345296f49d974ddb4123", size = 95949, upload-time = "2026-03-01T22:06:25.697Z" }, + { url = "https://files.pythonhosted.org/packages/68/03/093f4055ed4cae649ac53bca3d180bd37102e9e11d048588e9ab0c0108d0/yarl-1.23.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:e7b0460976dc75cb87ad9cc1f9899a4b97751e7d4e77ab840fc9b6d377b8fd24", size = 95839, upload-time = "2026-03-01T22:06:27.309Z" }, + { url = "https://files.pythonhosted.org/packages/b9/28/4c75ebb108f322aa8f917ae10a8ffa4f07cae10a8a627b64e578617df6a0/yarl-1.23.0-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:115136c4a426f9da976187d238e84139ff6b51a20839aa6e3720cd1026d768de", size = 90696, upload-time = "2026-03-01T22:06:29.048Z" }, + { url = "https://files.pythonhosted.org/packages/23/9c/42c2e2dd91c1a570402f51bdf066bfdb1241c2240ba001967bad778e77b7/yarl-1.23.0-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:ead11956716a940c1abc816b7df3fa2b84d06eaed8832ca32f5c5e058c65506b", size = 100865, upload-time = "2026-03-01T22:06:30.525Z" }, + { url = "https://files.pythonhosted.org/packages/74/05/1bcd60a8a0a914d462c305137246b6f9d167628d73568505fce3f1cb2e65/yarl-1.23.0-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:fe8f8f5e70e6dbdfca9882cd9deaac058729bcf323cf7a58660901e55c9c94f6", size = 96234, upload-time = "2026-03-01T22:06:32.692Z" }, + { url = "https://files.pythonhosted.org/packages/90/b2/f52381aac396d6778ce516b7bc149c79e65bfc068b5de2857ab69eeea3b7/yarl-1.23.0-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:a0e317df055958a0c1e79e5d2aa5a5eaa4a6d05a20d4b0c9c3f48918139c9fc6", size = 100295, upload-time = "2026-03-01T22:06:34.268Z" }, + { url = "https://files.pythonhosted.org/packages/e5/e8/638bae5bbf1113a659b2435d8895474598afe38b4a837103764f603aba56/yarl-1.23.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:6f0fd84de0c957b2d280143522c4f91a73aada1923caee763e24a2b3fda9f8a5", size = 97784, upload-time = "2026-03-01T22:06:35.864Z" }, + { url = "https://files.pythonhosted.org/packages/80/25/a3892b46182c586c202629fc2159aa13975d3741d52ebd7347fd501d48d5/yarl-1.23.0-cp313-cp313t-win32.whl", hash = "sha256:93a784271881035ab4406a172edb0faecb6e7d00f4b53dc2f55919d6c9688595", size = 88313, upload-time = "2026-03-01T22:06:37.39Z" }, + { url = "https://files.pythonhosted.org/packages/43/68/8c5b36aa5178900b37387937bc2c2fe0e9505537f713495472dcf6f6fccc/yarl-1.23.0-cp313-cp313t-win_amd64.whl", hash = "sha256:dd00607bffbf30250fe108065f07453ec124dbf223420f57f5e749b04295e090", size = 94932, upload-time = "2026-03-01T22:06:39.579Z" }, + { url = "https://files.pythonhosted.org/packages/c6/cc/d79ba8292f51f81f4dc533a8ccfb9fc6992cabf0998ed3245de7589dc07c/yarl-1.23.0-cp313-cp313t-win_arm64.whl", hash = "sha256:ac09d42f48f80c9ee1635b2fcaa819496a44502737660d3c0f2ade7526d29144", size = 84786, upload-time = "2026-03-01T22:06:41.988Z" }, + { url = "https://files.pythonhosted.org/packages/90/98/b85a038d65d1b92c3903ab89444f48d3cee490a883477b716d7a24b1a78c/yarl-1.23.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:21d1b7305a71a15b4794b5ff22e8eef96ff4a6d7f9657155e5aa419444b28912", size = 124455, upload-time = "2026-03-01T22:06:43.615Z" }, + { url = "https://files.pythonhosted.org/packages/39/54/bc2b45559f86543d163b6e294417a107bb87557609007c007ad889afec18/yarl-1.23.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:85610b4f27f69984932a7abbe52703688de3724d9f72bceb1cca667deff27474", size = 86752, upload-time = "2026-03-01T22:06:45.425Z" }, + { url = "https://files.pythonhosted.org/packages/24/f9/e8242b68362bffe6fb536c8db5076861466fc780f0f1b479fc4ffbebb128/yarl-1.23.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:23f371bd662cf44a7630d4d113101eafc0cfa7518a2760d20760b26021454719", size = 86291, upload-time = "2026-03-01T22:06:46.974Z" }, + { url = "https://files.pythonhosted.org/packages/ea/d8/d1cb2378c81dd729e98c716582b1ccb08357e8488e4c24714658cc6630e8/yarl-1.23.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c4a80f77dc1acaaa61f0934176fccca7096d9b1ff08c8ba9cddf5ae034a24319", size = 99026, upload-time = "2026-03-01T22:06:48.459Z" }, + { url = "https://files.pythonhosted.org/packages/0a/ff/7196790538f31debe3341283b5b0707e7feb947620fc5e8236ef28d44f72/yarl-1.23.0-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:bd654fad46d8d9e823afbb4f87c79160b5a374ed1ff5bde24e542e6ba8f41434", size = 92355, upload-time = "2026-03-01T22:06:50.306Z" }, + { url = "https://files.pythonhosted.org/packages/c1/56/25d58c3eddde825890a5fe6aa1866228377354a3c39262235234ab5f616b/yarl-1.23.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:682bae25f0a0dd23a056739f23a134db9f52a63e2afd6bfb37ddc76292bbd723", size = 106417, upload-time = "2026-03-01T22:06:52.1Z" }, + { url = "https://files.pythonhosted.org/packages/51/8a/882c0e7bc8277eb895b31bce0138f51a1ba551fc2e1ec6753ffc1e7c1377/yarl-1.23.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a82836cab5f197a0514235aaf7ffccdc886ccdaa2324bc0aafdd4ae898103039", size = 106422, upload-time = "2026-03-01T22:06:54.424Z" }, + { url = "https://files.pythonhosted.org/packages/42/2b/fef67d616931055bf3d6764885990a3ac647d68734a2d6a9e1d13de437a2/yarl-1.23.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1c57676bdedc94cd3bc37724cf6f8cd2779f02f6aba48de45feca073e714fe52", size = 101915, upload-time = "2026-03-01T22:06:55.895Z" }, + { url = "https://files.pythonhosted.org/packages/18/6a/530e16aebce27c5937920f3431c628a29a4b6b430fab3fd1c117b26ff3f6/yarl-1.23.0-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c7f8dc16c498ff06497c015642333219871effba93e4a2e8604a06264aca5c5c", size = 100690, upload-time = "2026-03-01T22:06:58.21Z" }, + { url = "https://files.pythonhosted.org/packages/88/08/93749219179a45e27b036e03260fda05190b911de8e18225c294ac95bbc9/yarl-1.23.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:5ee586fb17ff8f90c91cf73c6108a434b02d69925f44f5f8e0d7f2f260607eae", size = 98750, upload-time = "2026-03-01T22:06:59.794Z" }, + { url = "https://files.pythonhosted.org/packages/d9/cf/ea424a004969f5d81a362110a6ac1496d79efdc6d50c2c4b2e3ea0fc2519/yarl-1.23.0-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:17235362f580149742739cc3828b80e24029d08cbb9c4bda0242c7b5bc610a8e", size = 94685, upload-time = "2026-03-01T22:07:01.375Z" }, + { url = "https://files.pythonhosted.org/packages/e2/b7/14341481fe568e2b0408bcf1484c652accafe06a0ade9387b5d3fd9df446/yarl-1.23.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:0793e2bd0cf14234983bbb371591e6bea9e876ddf6896cdcc93450996b0b5c85", size = 106009, upload-time = "2026-03-01T22:07:03.151Z" }, + { url = "https://files.pythonhosted.org/packages/0a/e6/5c744a9b54f4e8007ad35bce96fbc9218338e84812d36f3390cea616881a/yarl-1.23.0-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:3650dc2480f94f7116c364096bc84b1d602f44224ef7d5c7208425915c0475dd", size = 100033, upload-time = "2026-03-01T22:07:04.701Z" }, + { url = "https://files.pythonhosted.org/packages/0c/23/e3bfc188d0b400f025bc49d99793d02c9abe15752138dcc27e4eaf0c4a9e/yarl-1.23.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:f40e782d49630ad384db66d4d8b73ff4f1b8955dc12e26b09a3e3af064b3b9d6", size = 106483, upload-time = "2026-03-01T22:07:06.231Z" }, + { url = "https://files.pythonhosted.org/packages/72/42/f0505f949a90b3f8b7a363d6cbdf398f6e6c58946d85c6d3a3bc70595b26/yarl-1.23.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:94f8575fbdf81749008d980c17796097e645574a3b8c28ee313931068dad14fe", size = 102175, upload-time = "2026-03-01T22:07:08.4Z" }, + { url = "https://files.pythonhosted.org/packages/aa/65/b39290f1d892a9dd671d1c722014ca062a9c35d60885d57e5375db0404b5/yarl-1.23.0-cp314-cp314-win32.whl", hash = "sha256:c8aa34a5c864db1087d911a0b902d60d203ea3607d91f615acd3f3108ac32169", size = 83871, upload-time = "2026-03-01T22:07:09.968Z" }, + { url = "https://files.pythonhosted.org/packages/a9/5b/9b92f54c784c26e2a422e55a8d2607ab15b7ea3349e28359282f84f01d43/yarl-1.23.0-cp314-cp314-win_amd64.whl", hash = "sha256:63e92247f383c85ab00dd0091e8c3fa331a96e865459f5ee80353c70a4a42d70", size = 89093, upload-time = "2026-03-01T22:07:11.501Z" }, + { url = "https://files.pythonhosted.org/packages/e0/7d/8a84dc9381fd4412d5e7ff04926f9865f6372b4c2fd91e10092e65d29eb8/yarl-1.23.0-cp314-cp314-win_arm64.whl", hash = "sha256:70efd20be968c76ece7baa8dafe04c5be06abc57f754d6f36f3741f7aa7a208e", size = 83384, upload-time = "2026-03-01T22:07:13.069Z" }, + { url = "https://files.pythonhosted.org/packages/dd/8d/d2fad34b1c08aa161b74394183daa7d800141aaaee207317e82c790b418d/yarl-1.23.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:9a18d6f9359e45722c064c97464ec883eb0e0366d33eda61cb19a244bf222679", size = 131019, upload-time = "2026-03-01T22:07:14.903Z" }, + { url = "https://files.pythonhosted.org/packages/19/ff/33009a39d3ccf4b94d7d7880dfe17fb5816c5a4fe0096d9b56abceea9ac7/yarl-1.23.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:2803ed8b21ca47a43da80a6fd1ed3019d30061f7061daa35ac54f63933409412", size = 89894, upload-time = "2026-03-01T22:07:17.372Z" }, + { url = "https://files.pythonhosted.org/packages/0c/f1/dab7ac5e7306fb79c0190766a3c00b4cb8d09a1f390ded68c85a5934faf5/yarl-1.23.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:394906945aa8b19fc14a61cf69743a868bb8c465efe85eee687109cc540b98f4", size = 89979, upload-time = "2026-03-01T22:07:19.361Z" }, + { url = "https://files.pythonhosted.org/packages/aa/b1/08e95f3caee1fad6e65017b9f26c1d79877b502622d60e517de01e72f95d/yarl-1.23.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:71d006bee8397a4a89f469b8deb22469fe7508132d3c17fa6ed871e79832691c", size = 95943, upload-time = "2026-03-01T22:07:21.266Z" }, + { url = "https://files.pythonhosted.org/packages/c0/cc/6409f9018864a6aa186c61175b977131f373f1988e198e031236916e87e4/yarl-1.23.0-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:62694e275c93d54f7ccedcfef57d42761b2aad5234b6be1f3e3026cae4001cd4", size = 88786, upload-time = "2026-03-01T22:07:23.129Z" }, + { url = "https://files.pythonhosted.org/packages/76/40/cc22d1d7714b717fde2006fad2ced5efe5580606cb059ae42117542122f3/yarl-1.23.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a31de1613658308efdb21ada98cbc86a97c181aa050ba22a808120bb5be3ab94", size = 101307, upload-time = "2026-03-01T22:07:24.689Z" }, + { url = "https://files.pythonhosted.org/packages/8f/0d/476c38e85ddb4c6ec6b20b815bdd779aa386a013f3d8b85516feee55c8dc/yarl-1.23.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:fb1e8b8d66c278b21d13b0a7ca22c41dd757a7c209c6b12c313e445c31dd3b28", size = 100904, upload-time = "2026-03-01T22:07:26.287Z" }, + { url = "https://files.pythonhosted.org/packages/72/32/0abe4a76d59adf2081dcb0397168553ece4616ada1c54d1c49d8936c74f8/yarl-1.23.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:50f9d8d531dfb767c565f348f33dd5139a6c43f5cbdf3f67da40d54241df93f6", size = 97728, upload-time = "2026-03-01T22:07:27.906Z" }, + { url = "https://files.pythonhosted.org/packages/b7/35/7b30f4810fba112f60f5a43237545867504e15b1c7647a785fbaf588fac2/yarl-1.23.0-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:575aa4405a656e61a540f4a80eaa5260f2a38fff7bfdc4b5f611840d76e9e277", size = 95964, upload-time = "2026-03-01T22:07:30.198Z" }, + { url = "https://files.pythonhosted.org/packages/2d/86/ed7a73ab85ef00e8bb70b0cb5421d8a2a625b81a333941a469a6f4022828/yarl-1.23.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:041b1a4cefacf65840b4e295c6985f334ba83c30607441ae3cf206a0eed1a2e4", size = 95882, upload-time = "2026-03-01T22:07:32.132Z" }, + { url = "https://files.pythonhosted.org/packages/19/90/d56967f61a29d8498efb7afb651e0b2b422a1e9b47b0ab5f4e40a19b699b/yarl-1.23.0-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:d38c1e8231722c4ce40d7593f28d92b5fc72f3e9774fe73d7e800ec32299f63a", size = 90797, upload-time = "2026-03-01T22:07:34.404Z" }, + { url = "https://files.pythonhosted.org/packages/72/00/8b8f76909259f56647adb1011d7ed8b321bcf97e464515c65016a47ecdf0/yarl-1.23.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:d53834e23c015ee83a99377db6e5e37d8484f333edb03bd15b4bc312cc7254fb", size = 101023, upload-time = "2026-03-01T22:07:35.953Z" }, + { url = "https://files.pythonhosted.org/packages/ac/e2/cab11b126fb7d440281b7df8e9ddbe4851e70a4dde47a202b6642586b8d9/yarl-1.23.0-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:2e27c8841126e017dd2a054a95771569e6070b9ee1b133366d8b31beb5018a41", size = 96227, upload-time = "2026-03-01T22:07:37.594Z" }, + { url = "https://files.pythonhosted.org/packages/c2/9b/2c893e16bfc50e6b2edf76c1a9eb6cb0c744346197e74c65e99ad8d634d0/yarl-1.23.0-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:76855800ac56f878847a09ce6dba727c93ca2d89c9e9d63002d26b916810b0a2", size = 100302, upload-time = "2026-03-01T22:07:39.334Z" }, + { url = "https://files.pythonhosted.org/packages/28/ec/5498c4e3a6d5f1003beb23405671c2eb9cdbf3067d1c80f15eeafe301010/yarl-1.23.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:e09fd068c2e169a7070d83d3bde728a4d48de0549f975290be3c108c02e499b4", size = 98202, upload-time = "2026-03-01T22:07:41.717Z" }, + { url = "https://files.pythonhosted.org/packages/fe/c3/cd737e2d45e70717907f83e146f6949f20cc23cd4bf7b2688727763aa458/yarl-1.23.0-cp314-cp314t-win32.whl", hash = "sha256:73309162a6a571d4cbd3b6a1dcc703c7311843ae0d1578df6f09be4e98df38d4", size = 90558, upload-time = "2026-03-01T22:07:43.433Z" }, + { url = "https://files.pythonhosted.org/packages/e1/19/3774d162f6732d1cfb0b47b4140a942a35ca82bb19b6db1f80e9e7bdc8f8/yarl-1.23.0-cp314-cp314t-win_amd64.whl", hash = "sha256:4503053d296bc6e4cbd1fad61cf3b6e33b939886c4f249ba7c78b602214fabe2", size = 97610, upload-time = "2026-03-01T22:07:45.773Z" }, + { url = "https://files.pythonhosted.org/packages/51/47/3fa2286c3cb162c71cdb34c4224d5745a1ceceb391b2bd9b19b668a8d724/yarl-1.23.0-cp314-cp314t-win_arm64.whl", hash = "sha256:44bb7bef4ea409384e3f8bc36c063d77ea1b8d4a5b2706956c0d6695f07dcc25", size = 86041, upload-time = "2026-03-01T22:07:49.026Z" }, + { url = "https://files.pythonhosted.org/packages/69/68/c8739671f5699c7dc470580a4f821ef37c32c4cb0b047ce223a7f115757f/yarl-1.23.0-py3-none-any.whl", hash = "sha256:a2df6afe50dea8ae15fa34c9f824a3ee958d785fd5d089063d960bae1daa0a3f", size = 48288, upload-time = "2026-03-01T22:07:51.388Z" }, +] From b13ccb985ffa4294403897911de97631378f6482 Mon Sep 17 00:00:00 2001 From: "rikulpatel@gmail.com" Date: Wed, 13 May 2026 23:21:13 -0500 Subject: [PATCH 50/84] fix: dockerfile bug --- Dockerfile | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/Dockerfile b/Dockerfile index 65dc7ea..56c6b51 100644 --- a/Dockerfile +++ b/Dockerfile @@ -1,19 +1,20 @@ -FROM debian:current +FROM debian:bookworm # apt dependencies for Python, SQLite, and common tools -RUN apt update && apt install -y --no-install-recommends \ +RUN DEBIAN_FRONTEND=noninteractive apt update && apt install -y --no-install-recommends \ python3 python3-pip python3-venv \ sqlite3 \ curl ca-certificates \ git \ nodejs npm \ chromium \ + tzdata \ && rm -rf /var/lib/apt/lists/* ENV PUPPETEER_SKIP_CHROMIUM_DOWNLOAD=true \ PUPPETEER_EXECUTABLE_PATH=/usr/bin/chromium -RUN pip install uv --no-cache-dir +COPY --from=ghcr.io/astral-sh/uv:latest /uv /usr/local/bin/uv WORKDIR /app @@ -32,6 +33,7 @@ ENV LLM_BASE_URL="" ENV MODEL="" ENV TELEGRAM_ALLOW_FROM="" ENV DISCORD_ALLOW_FROM="" +ENV TZ=UTC # Secrets — pass at runtime only, never bake into the image: # docker run -d \ From 9602632b9a04b810524a7ca837a4f93d9e3bdf09 Mon Sep 17 00:00:00 2001 From: Rikul Date: Sat, 16 May 2026 22:55:47 -0500 Subject: [PATCH 51/84] feat: added a review-pr skill --- app/skills/review-pr/SKILL.md | 86 +++++++++++++++++++++++++++++++++++ 1 file changed, 86 insertions(+) create mode 100644 app/skills/review-pr/SKILL.md diff --git a/app/skills/review-pr/SKILL.md b/app/skills/review-pr/SKILL.md new file mode 100644 index 0000000..bea9363 --- /dev/null +++ b/app/skills/review-pr/SKILL.md @@ -0,0 +1,86 @@ +# Pull Request Review Skill + +## Overview +This skill provides a structured methodology for reviewing GitHub pull requests. It produces thorough, organized, and actionable reviews by following a four-section template that covers the change itself, each modified file, testing, and code quality. + +## When to Use +Use this skill when asked to: +- Review a specific GitHub pull request +- Review a diff or patch +- Evaluate a proposed code change +- Assess the quality, correctness, and completeness of a PR + +## Workflow + +### 1. Fetch the PR +Use a web fetch method to get the PR diff, or if the URL is a GitHub PR, fetch the diff URL directly (append `.diff` or `.patch` to the PR URL). + +### 2. Analyze the PR using the four-section template + +--- + +## PR Review Template + +### 1. Change Description +Answer these three questions clearly and concisely: +- **What change does this PR make?** — Summarize the overall purpose and mechanism of the change in plain language. +- **What was the behavior before this PR?** — Describe the old behavior, including any existing bugs, missing features, or dead code. +- **What is the behavior after this PR?** — Describe the new behavior. Be specific about what fields, APIs, or user-visible outputs changed. + +### 2. File-by-File Analysis +For each file changed in the PR, explain: +- **What changes were made?** — Be specific: added fields, modified queries, refactored methods, removed imports, etc. +- **Why these changes were made in the context of this PR?** — Connect each file change back to the overall goal of the PR. Explain how each file contributes. + +Use a consistent format per file, e.g.: +``` +### `path/to/file.go` +- **Changes**: ... +- **Why**: ... +``` + +### 3. Testing Review +- **What tests are recommended to test this PR?** — Think about what a complete test suite would look like. Cover: happy path, edge cases, nil/empty inputs, error paths, all layers (state → service → API → CLI). +- **If tests are included: which tests are missing?** — Explicitly list gaps. +- **If tests are included: provide a short review of the added tests** — Assess coverage, quality, edge case handling, and realism of test data. + +Use ✅/❌ markers for covered vs. missing test cases. + +### 4. Code Review +Create a list of issues found, organized by severity. For each, include: +- **Severity** (🔴 = potential bug / security / correctness, 🟡 = concern / best practice / missing coverage, 🟢 = positive observation) +- **A short title** describing the issue +- **File path and line numbers** where applicable +- **Explanation** of the issue and its impact + +Include at minimum: +- Things that are missing +- Things that are not done correctly +- Edge cases not handled +- Missing tests or documentation +- Code quality concerns +- Potential bugs or security issues +- Positive observations (well-done parts) + +End with a **Summary table**: + +| Area | Verdict | +|------|---------| +| **Problem** | ... | +| **Root cause** | ... | +| **Fix quality** | Solid / Needs work / etc. | +| **Bug fixes** | ... | +| **Code quality** | ... | +| **Test coverage** | ... | +| **Edge cases** | ... | + +And a **bottom line** sentence summarizing the overall assessment. + +--- + +## Tips +- Always verify file paths and line numbers from the actual diff, not from memory +- Distinguish between subjective style preferences and actual bugs +- For large PRs, group related file changes together +- When in doubt about a behavior, note the uncertainty explicitly (e.g., "the reviewer should confirm that...") +- Separate observations into **positive** (🟢), **concern** (🟡), and **critical** (🔴) categories From 13d72969fd402185c1f08c8cb44e9b3abc99033f Mon Sep 17 00:00:00 2001 From: "rikulpatel@gmail.com" Date: Mon, 18 May 2026 08:40:56 -0500 Subject: [PATCH 52/84] feat: unified command registry for Telegram and Discord Adds CommandRegistry per channel so /whoami, /help, /status, /stop are defined once and work across channels. Discord now intercepts slash commands before the MQ; unknown /cmd falls through to the agent. Co-Authored-By: Claude Sonnet 4.6 --- app/channels/commands.py | 58 ++++++++++++++++++ app/channels/discord.py | 34 ++++++++--- app/channels/telegram.py | 37 +++++++----- tests/test_commands.py | 110 ++++++++++++++++++++++++++++++++++ tests/test_discord_channel.py | 57 ++++++++++++++++++ 5 files changed, 274 insertions(+), 22 deletions(-) create mode 100644 app/channels/commands.py create mode 100644 tests/test_commands.py diff --git a/app/channels/commands.py b/app/channels/commands.py new file mode 100644 index 0000000..8f181fe --- /dev/null +++ b/app/channels/commands.py @@ -0,0 +1,58 @@ +from __future__ import annotations + +import logging +from dataclasses import dataclass +from datetime import datetime +from typing import Callable, Awaitable + +log = logging.getLogger(__name__) + +CommandHandler = Callable[[], Awaitable[str]] + +_STARTUP_TIME: datetime = datetime.now() + + +@dataclass +class BotCommand: + name: str + description: str + handler: CommandHandler + + +class CommandRegistry: + def __init__(self) -> None: + self._commands: dict[str, BotCommand] = {} + + def register(self, cmd: BotCommand) -> None: + self._commands[cmd.name] = cmd + + async def execute(self, name: str) -> str | None: + cmd = self._commands.get(name) + if cmd is None: + return None + try: + return await cmd.handler() + except Exception: + log.exception(f"Command /{name} raised an exception") + return "An error occurred running that command." + + def list(self) -> list[BotCommand]: + return list(self._commands.values()) + + +def help_cmd_handler(registry: CommandRegistry) -> CommandHandler: + async def _help() -> str: + lines = ["Available commands:"] + for cmd in registry.list(): + lines.append(f"/{cmd.name} — {cmd.description}") + return "\n".join(lines) + return _help + + +async def _status() -> str: + from .. import config + uptime = datetime.now() - _STARTUP_TIME + hours, remainder = divmod(int(uptime.total_seconds()), 3600) + minutes, seconds = divmod(remainder, 60) + model = config.get("model", "unknown") + return f"Bot status:\n Model: {model}\n Uptime: {hours}h {minutes}m {seconds}s" diff --git a/app/channels/discord.py b/app/channels/discord.py index dab7df7..e15c4bb 100644 --- a/app/channels/discord.py +++ b/app/channels/discord.py @@ -1,6 +1,7 @@ import discord import logging +from .commands import CommandRegistry, BotCommand, _status, help_cmd_handler from .message_queue import MessageQueue from .channel import Channel, ChannelType from .message import OutgoingMessage, IncomingMessage @@ -23,6 +24,9 @@ def __init__(self, mq: MessageQueue, token: str, allow_from: list[int] = None) - self.stopped = False self._last_channel_id: int | None = None mq.register(self, self.send_message) + self.registry = CommandRegistry() + self.registry.register(BotCommand("status", "Show bot status.", _status)) + self.registry.register(BotCommand("help", "Show this help message.", help_cmd_handler(self.registry))) @property def has_stopped(self) -> bool: @@ -50,15 +54,31 @@ async def on_message(self, message: discord.Message) -> None: log.warning(f"Discord: ignoring message from unauthorized user id={user_id}") await message.reply("Sorry, you are not authorized to use this bot.") return - if message.content and message.content.strip(): - self._last_channel_id = message.channel.id - await self.mq.incoming.put( - IncomingMessage( - content=message.content.strip(), - channel=ChannelType.DISCORD, - metadata={"channel_id": message.channel.id}, + content = message.content.strip() if message.content else "" + if not content: + return + + if content.startswith("/"): + cmd_name = content[1:].split()[0].lower() + if cmd_name == "whoami": + await message.reply( + f"Your user ID is {user_id} and your name is {message.author.display_name}.", + mention_author=False, ) + return + reply = await self.registry.execute(cmd_name) + if reply is not None: + await message.reply(reply, mention_author=False) + return + + self._last_channel_id = message.channel.id + await self.mq.incoming.put( + IncomingMessage( + content=content, + channel=ChannelType.DISCORD, + metadata={"channel_id": message.channel.id}, ) + ) async def _resolve_destination(self, channel_id: int | None) -> discord.abc.Messageable | None: if channel_id: diff --git a/app/channels/telegram.py b/app/channels/telegram.py index f24e96b..9c71eec 100755 --- a/app/channels/telegram.py +++ b/app/channels/telegram.py @@ -1,6 +1,7 @@ import asyncio import logging +from .commands import CommandRegistry, BotCommand, _status, help_cmd_handler from .message_queue import MessageQueue from .channel import Channel, ChannelType from .message import OutgoingMessage, IncomingMessage @@ -28,6 +29,10 @@ def __init__( self.mq = mq self.stopped = False mq.register(self, self.send_message) + self.registry = CommandRegistry() + self.registry.register(BotCommand("status", "Show bot status.", _status)) + self.registry.register(BotCommand("stop", "Pause the bot.", self._stop_cmd)) + self.registry.register(BotCommand("help", "Show this help message.", help_cmd_handler(self.registry))) @property def has_stopped(self) -> bool: @@ -55,25 +60,26 @@ async def error_handler( "⚠ An error occurred, please try again." ) - async def whoami(self,update: Update, context: ContextTypes.DEFAULT_TYPE) -> None: + async def _stop_cmd(self) -> str: + self.stopped = True + log.info("Received /stop in Telegram channel, setting stopped=True.") + return "Stopped." + + async def whoami(self, update: Update, context: ContextTypes.DEFAULT_TYPE) -> None: reply_text = f"Your user ID is {update.effective_user.id} and your name is {update.effective_user.first_name}." await update.message.reply_text(reply_text) - - async def help(self,update: Update, context: ContextTypes.DEFAULT_TYPE) -> None: - """ - List available commands and their descriptions. - """ - reply_text = ("Available commands:\n" - "/whoami - Display your user ID and name.\n" - "/help - Show this help message.\n" - "Just send any text message to interact with the bot.") - await update.message.reply_text(reply_text) + async def help(self, update: Update, context: ContextTypes.DEFAULT_TYPE) -> None: + reply = await self.registry.execute("help") + if reply: + await update.message.reply_text(reply) + + async def status(self, update: Update, context: ContextTypes.DEFAULT_TYPE) -> None: + reply = await self.registry.execute("status") + if reply: + await update.message.reply_text(reply) - async def stop(self,update: Update, context: ContextTypes.DEFAULT_TYPE) -> None: - """ - Stop the bot gracefully. - """ + async def stop(self, update: Update, context: ContextTypes.DEFAULT_TYPE) -> None: self.stopped = True await update.message.reply_text("Stopped.") log.info("Received /stop in Telegram channel, setting stopped=True.") @@ -135,6 +141,7 @@ def start(self) -> None: .build() ) self.app.add_handler(CommandHandler("whoami", self.whoami)) + self.app.add_handler(CommandHandler("status", self.status)) self.app.add_handler(CommandHandler("stop", self.stop)) self.app.add_handler(CommandHandler("help", self.help)) diff --git a/tests/test_commands.py b/tests/test_commands.py new file mode 100644 index 0000000..e3bb9f3 --- /dev/null +++ b/tests/test_commands.py @@ -0,0 +1,110 @@ +import pytest +from unittest.mock import AsyncMock, patch + +from app.channels.commands import BotCommand, CommandRegistry, _status, help_cmd_handler + + +def make_registry(*extra: BotCommand) -> CommandRegistry: + r = CommandRegistry() + r.register(BotCommand("status", "Show bot status.", _status)) + r.register(BotCommand("help", "Show this help message.", help_cmd_handler(r))) + for cmd in extra: + r.register(cmd) + return r + + +# --- BotCommand --- + +def test_botcommand_stores_fields(): + handler = AsyncMock(return_value="hi") + cmd = BotCommand("test", "A test command.", handler) + assert cmd.name == "test" + assert cmd.description == "A test command." + assert cmd.handler is handler + + +# --- CommandRegistry.list --- + +def test_registry_list_empty_by_default(): + assert CommandRegistry().list() == [] + + +def test_registry_list_returns_registered_commands(): + r = make_registry() + names = {c.name for c in r.list()} + assert {"status", "help"} <= names + + +def test_registry_register_overwrites_same_name(): + r = CommandRegistry() + r.register(BotCommand("x", "first", AsyncMock(return_value="a"))) + r.register(BotCommand("x", "second", AsyncMock(return_value="b"))) + assert len(r.list()) == 1 + assert r.list()[0].description == "second" + + +# --- CommandRegistry.execute --- + +@pytest.mark.asyncio +async def test_execute_returns_none_for_unknown_command(): + assert await CommandRegistry().execute("nope") is None + + +@pytest.mark.asyncio +async def test_execute_calls_handler_and_returns_result(): + handler = AsyncMock(return_value="pong") + r = CommandRegistry() + r.register(BotCommand("ping", "Ping.", handler)) + result = await r.execute("ping") + assert result == "pong" + handler.assert_called_once() + + +@pytest.mark.asyncio +async def test_execute_returns_error_string_on_exception(): + async def boom(): + raise RuntimeError("oops") + r = CommandRegistry() + r.register(BotCommand("bad", "Broken.", boom)) + result = await r.execute("bad") + assert isinstance(result, str) + assert result # non-empty + + +# --- _status --- + +@pytest.mark.asyncio +async def test_status_includes_model_name(): + with patch("app.config._config", {"model": "my-test-model"}): + result = await _status() + assert "my-test-model" in result + + +@pytest.mark.asyncio +async def test_status_includes_uptime(): + with patch("app.config._config", {"model": "m"}): + result = await _status() + assert "Uptime" in result + + +# --- help_cmd_handler --- + +@pytest.mark.asyncio +async def test_help_handler_lists_all_registered_commands(): + r = CommandRegistry() + r.register(BotCommand("foo", "Foo command.", AsyncMock(return_value=""))) + r.register(BotCommand("bar", "Bar command.", AsyncMock(return_value=""))) + r.register(BotCommand("help", "Help.", help_cmd_handler(r))) + result = await r.execute("help") + assert "/foo" in result + assert "/bar" in result + assert "/help" in result + + +@pytest.mark.asyncio +async def test_help_handler_reflects_commands_registered_after_creation(): + r = CommandRegistry() + r.register(BotCommand("help", "Help.", help_cmd_handler(r))) + r.register(BotCommand("late", "Registered after help.", AsyncMock(return_value=""))) + result = await r.execute("help") + assert "/late" in result diff --git a/tests/test_discord_channel.py b/tests/test_discord_channel.py index 44886cc..6fa8517 100644 --- a/tests/test_discord_channel.py +++ b/tests/test_discord_channel.py @@ -258,3 +258,60 @@ def test_clear_stopped_resets_state(): dc.stopped = True dc.clear_stopped() assert dc.has_stopped is False + + +# --- command handling --- + +@pytest.mark.asyncio +async def test_on_message_whoami_replies_with_user_info(): + dc, mq = make_discord_channel() + message = MagicMock() + message.author.id = 123 + message.author.display_name = "Alice" + message.channel.id = 456 + message.content = "/whoami" + message.reply = AsyncMock() + + await dc.on_message(message) + + message.reply.assert_called_once() + text = message.reply.call_args[0][0] + assert "123" in text + assert "Alice" in text + assert mq.incoming.empty() + + +@pytest.mark.asyncio +async def test_on_message_known_command_replies_and_skips_mq(): + dc, mq = make_discord_channel() + dc.registry.execute = AsyncMock(return_value="Bot status: running") + message = MagicMock() + message.author.id = 123 + message.author.display_name = "Alice" + message.channel.id = 456 + message.content = "/status" + message.reply = AsyncMock() + + await dc.on_message(message) + + dc.registry.execute.assert_called_once_with("status") + message.reply.assert_called_once() + assert mq.incoming.empty() + + +@pytest.mark.asyncio +async def test_on_message_unknown_command_falls_through_to_mq(): + dc, mq = make_discord_channel() + dc.registry.execute = AsyncMock(return_value=None) + message = MagicMock() + message.author.id = 123 + message.author.display_name = "Alice" + message.channel.id = 456 + message.content = "/notacommand" + message.reply = AsyncMock() + + await dc.on_message(message) + + assert not mq.incoming.empty() + msg = await mq.incoming.get() + assert msg.content == "/notacommand" From 67651051827387d0cff6ce90153f0501a0119e0f Mon Sep 17 00:00:00 2001 From: "rikulpatel@gmail.com" Date: Mon, 18 May 2026 09:13:09 -0500 Subject: [PATCH 53/84] fix / refactor: use send_message instead of channel-native reply Command handlers in Discord and Telegram now use send_message(OutgoingMessage(...)) instead of calling channel-native reply methods directly, ensuring consistent delivery behavior across all commands. --- app/channels/discord.py | 12 +++++++----- app/channels/telegram.py | 13 ++++++++----- tests/test_discord_channel.py | 16 ++++++++-------- tests/test_telegram_channel.py | 6 +++++- 4 files changed, 28 insertions(+), 19 deletions(-) diff --git a/app/channels/discord.py b/app/channels/discord.py index e15c4bb..35062a0 100644 --- a/app/channels/discord.py +++ b/app/channels/discord.py @@ -60,15 +60,17 @@ async def on_message(self, message: discord.Message) -> None: if content.startswith("/"): cmd_name = content[1:].split()[0].lower() + metadata = {"channel_id": message.channel.id} if cmd_name == "whoami": - await message.reply( - f"Your user ID is {user_id} and your name is {message.author.display_name}.", - mention_author=False, - ) + await self.send_message(OutgoingMessage( + content=f"Your user ID is {user_id} and your name is {message.author.display_name}.", + channel=ChannelType.DISCORD, + metadata=metadata, + )) return reply = await self.registry.execute(cmd_name) if reply is not None: - await message.reply(reply, mention_author=False) + await self.send_message(OutgoingMessage(content=reply, channel=ChannelType.DISCORD, metadata=metadata)) return self._last_channel_id = message.channel.id diff --git a/app/channels/telegram.py b/app/channels/telegram.py index 9c71eec..79d008e 100755 --- a/app/channels/telegram.py +++ b/app/channels/telegram.py @@ -65,23 +65,26 @@ async def _stop_cmd(self) -> str: log.info("Received /stop in Telegram channel, setting stopped=True.") return "Stopped." + async def _cmd_reply(self, text: str, chat_id: int) -> None: + await self.send_message(OutgoingMessage(content=text, channel=ChannelType.TELEGRAM, metadata={"chat_id": chat_id})) + async def whoami(self, update: Update, context: ContextTypes.DEFAULT_TYPE) -> None: - reply_text = f"Your user ID is {update.effective_user.id} and your name is {update.effective_user.first_name}." - await update.message.reply_text(reply_text) + text = f"Your user ID is {update.effective_user.id} and your name is {update.effective_user.first_name}." + await self._cmd_reply(text, update.effective_chat.id) async def help(self, update: Update, context: ContextTypes.DEFAULT_TYPE) -> None: reply = await self.registry.execute("help") if reply: - await update.message.reply_text(reply) + await self._cmd_reply(reply, update.effective_chat.id) async def status(self, update: Update, context: ContextTypes.DEFAULT_TYPE) -> None: reply = await self.registry.execute("status") if reply: - await update.message.reply_text(reply) + await self._cmd_reply(reply, update.effective_chat.id) async def stop(self, update: Update, context: ContextTypes.DEFAULT_TYPE) -> None: self.stopped = True - await update.message.reply_text("Stopped.") + await self._cmd_reply("Stopped.", update.effective_chat.id) log.info("Received /stop in Telegram channel, setting stopped=True.") async def send_message(self, message: OutgoingMessage) -> None: diff --git a/tests/test_discord_channel.py b/tests/test_discord_channel.py index 6fa8517..41d0e47 100644 --- a/tests/test_discord_channel.py +++ b/tests/test_discord_channel.py @@ -265,19 +265,20 @@ def test_clear_stopped_resets_state(): @pytest.mark.asyncio async def test_on_message_whoami_replies_with_user_info(): dc, mq = make_discord_channel() + dc.send_message = AsyncMock() message = MagicMock() message.author.id = 123 message.author.display_name = "Alice" message.channel.id = 456 message.content = "/whoami" - message.reply = AsyncMock() await dc.on_message(message) - message.reply.assert_called_once() - text = message.reply.call_args[0][0] - assert "123" in text - assert "Alice" in text + dc.send_message.assert_called_once() + sent = dc.send_message.call_args[0][0] + assert "123" in sent.content + assert "Alice" in sent.content + assert sent.metadata == {"channel_id": 456} assert mq.incoming.empty() @@ -285,17 +286,17 @@ async def test_on_message_whoami_replies_with_user_info(): async def test_on_message_known_command_replies_and_skips_mq(): dc, mq = make_discord_channel() dc.registry.execute = AsyncMock(return_value="Bot status: running") + dc.send_message = AsyncMock() message = MagicMock() message.author.id = 123 message.author.display_name = "Alice" message.channel.id = 456 message.content = "/status" - message.reply = AsyncMock() await dc.on_message(message) dc.registry.execute.assert_called_once_with("status") - message.reply.assert_called_once() + dc.send_message.assert_called_once() assert mq.incoming.empty() @@ -308,7 +309,6 @@ async def test_on_message_unknown_command_falls_through_to_mq(): message.author.display_name = "Alice" message.channel.id = 456 message.content = "/notacommand" - message.reply = AsyncMock() await dc.on_message(message) diff --git a/tests/test_telegram_channel.py b/tests/test_telegram_channel.py index 2322cf2..78094c2 100644 --- a/tests/test_telegram_channel.py +++ b/tests/test_telegram_channel.py @@ -159,6 +159,7 @@ async def test_error_handler_notifies_user_on_chat_update(): @pytest.mark.asyncio async def test_stop_sets_has_stopped(): tc, _ = make_telegram_channel() + tc.send_message = AsyncMock() assert tc.has_stopped is False update = make_update() @@ -170,15 +171,18 @@ async def test_stop_sets_has_stopped(): @pytest.mark.asyncio async def test_stop_replies_to_user(): tc, _ = make_telegram_channel() + tc.send_message = AsyncMock() update = make_update() await tc.stop(update, MagicMock()) - update.message.reply_text.assert_called_once_with("Stopped.") + tc.send_message.assert_called_once() + assert "Stopped" in tc.send_message.call_args[0][0].content @pytest.mark.asyncio async def test_clear_stopped_resets_state(): tc, _ = make_telegram_channel() + tc.send_message = AsyncMock() update = make_update() await tc.stop(update, MagicMock()) assert tc.has_stopped is True From 508ab3bdea5b35e06d5cd18341dc473f35d697ad Mon Sep 17 00:00:00 2001 From: "rikulpatel@gmail.com" Date: Mon, 18 May 2026 10:12:32 -0500 Subject: [PATCH 54/84] =?UTF-8?q?bumping=20the=20default=20model=20from=20?= =?UTF-8?q?=20=E2=86=92?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- app/config.py | 4 ++-- app/config.toml | 2 +- app/core/agent.py | 5 +++-- app/env.example | 2 +- tests/test_config.py | 8 ++++---- 5 files changed, 11 insertions(+), 10 deletions(-) diff --git a/app/config.py b/app/config.py index 36b6c3a..9c8664a 100644 --- a/app/config.py +++ b/app/config.py @@ -20,7 +20,7 @@ def load(path: Path | str = HOME_CONFIG_PATH) -> None: _config = tomllib.load(f) else: _config = { - "model": "deepseek/deepseek-v3.2", + "model": "deepseek/deepseek-v4-flash", "base_url": "https://openrouter.ai/api/v1", "max_iterations": 100, "telegram": {}, @@ -51,7 +51,7 @@ def __getattr__(name: str): def get_default_config() -> str: return """\ -model = "deepseek/deepseek-v3.2" +model = "deepseek/deepseek-v4-flash" max_iterations = 100 base_url = "https://openrouter.ai/api/v1" diff --git a/app/config.toml b/app/config.toml index 7fd5147..e90b0dc 100755 --- a/app/config.toml +++ b/app/config.toml @@ -1,3 +1,3 @@ -model = "deepseek/deepseek-v3.2" +model = "deepseek/deepseek-v4-flash" base_url = "https://openrouter.ai/api/v1" max_iterations = 100 \ No newline at end of file diff --git a/app/core/agent.py b/app/core/agent.py index 867f3a4..578f404 100755 --- a/app/core/agent.py +++ b/app/core/agent.py @@ -16,11 +16,12 @@ def __init__(self, max_iterations: int = 250) -> None: self.client = Client().get_client() self.messages: list[dict] = [] self.max_iterations = max_iterations + self.model = config.get("model", "deepseek/deepseek-v4-flash") def _trim_messages(self) -> None: if len(self.messages) > MAX_CONTEXT_MESSAGES: self.messages = self.messages[-MAX_CONTEXT_MESSAGES:] - + @staticmethod def _serialize_assistant_msg(msg) -> dict: d = {"role": msg.role, "content": msg.content} @@ -81,7 +82,7 @@ async def _loop(self, messages: list, tool_specs: list) -> str: iteration += 1 log.info("chat.completions.create...") chat = await self.client.chat.completions.create( - model=config.get("model", "deepseek/deepseek-v3.2"), + model=self.model, messages=messages, tools=tool_specs, ) diff --git a/app/env.example b/app/env.example index aa51f12..81161ec 100755 --- a/app/env.example +++ b/app/env.example @@ -1,3 +1,3 @@ LLM_API_KEY= LLM_BASE_URL=https://openrouter.ai/api/v1 -LLM_MODEL=deepseek/deepseek-v3.2 \ No newline at end of file +LLM_MODEL=deepseek/deepseek-v4-flash \ No newline at end of file diff --git a/tests/test_config.py b/tests/test_config.py index 7622c7e..be2bdfe 100644 --- a/tests/test_config.py +++ b/tests/test_config.py @@ -6,7 +6,7 @@ def test_load_uses_defaults_when_file_not_found(tmp_path): config.load(tmp_path / "missing.toml") - assert config.get("model") == "deepseek/deepseek-v3.2" + assert config.get("model") == "deepseek/deepseek-v4-flash" assert config.get("telegram") == {} @@ -57,7 +57,7 @@ def test_getattr_raises_for_missing_key(tmp_path): def test_model_env_overrides_file(tmp_path): toml_file = tmp_path / "config.toml" - toml_file.write_bytes(b'model = "deepseek/deepseek-v3.2"\n') + toml_file.write_bytes(b'model = "deepseek/deepseek-v4-flash"\n') with patch.dict(os.environ, {"MODEL": "gpt-4o"}, clear=False): config.load(toml_file) assert config.get("model") == "gpt-4o" @@ -93,13 +93,13 @@ def test_env_vars_override_file_values(tmp_path): def test_docker_scenario_no_file_all_env_vars(tmp_path): """No config file + env vars only — the expected Docker startup path.""" env = { - "MODEL": "deepseek/deepseek-v3.2", + "MODEL": "deepseek/deepseek-v4-flash", "TELEGRAM_BOT_TOKEN": "bot:token", "TELEGRAM_ALLOW_FROM": "99,100", } with patch.dict(os.environ, env, clear=False): config.load(tmp_path / "missing.toml") - assert config.get("model") == "deepseek/deepseek-v3.2" + assert config.get("model") == "deepseek/deepseek-v4-flash" assert config.get("telegram")["BOT_TOKEN"] == "bot:token" assert config.get("telegram")["ALLOW_FROM"] == [99, 100] From 34bcbbaa66a3d59048d3bd57b6ec3edd6893c559 Mon Sep 17 00:00:00 2001 From: "rikulpatel@gmail.com" Date: Mon, 18 May 2026 13:37:09 -0500 Subject: [PATCH 55/84] feat: slash commands with args, /model, and error surfacing to users - Commands now accept arguments: handler sig (args: str) -> str, execute(name, args="") - Add /model [name] to get or set the LLM model at runtime (config.set()) - Telegram: unified command_handler() replaces per-command methods; parses cmd + args from message text, dispatches through registry; /whoami handled inline - Discord: fix redundant double-split for cmd_name parsing - BackgroundAgent: surface agent_loop exceptions as messages to the user instead of silently logging them - Tests: model_cmd, execute args passing, error surfacing, command_handler dispatch with args --- app/channels/commands.py | 21 ++++++++----- app/channels/discord.py | 15 ++++++--- app/channels/telegram.py | 56 +++++++++++++--------------------- app/config.py | 4 ++- app/core/agent.py | 7 ++--- app/core/background_agent.py | 2 ++ tests/test_background_agent.py | 22 +++++++++++++ tests/test_commands.py | 47 ++++++++++++++++++++++------ tests/test_discord_channel.py | 20 +++++++++++- tests/test_telegram_channel.py | 37 +++++++++++++++++----- 10 files changed, 162 insertions(+), 69 deletions(-) diff --git a/app/channels/commands.py b/app/channels/commands.py index 8f181fe..cd959b7 100644 --- a/app/channels/commands.py +++ b/app/channels/commands.py @@ -7,7 +7,7 @@ log = logging.getLogger(__name__) -CommandHandler = Callable[[], Awaitable[str]] +CommandHandler = Callable[[str], Awaitable[str]] _STARTUP_TIME: datetime = datetime.now() @@ -26,12 +26,12 @@ def __init__(self) -> None: def register(self, cmd: BotCommand) -> None: self._commands[cmd.name] = cmd - async def execute(self, name: str) -> str | None: + async def execute(self, name: str, args : str = "") -> str | None: cmd = self._commands.get(name) if cmd is None: return None try: - return await cmd.handler() + return await cmd.handler(args) except Exception: log.exception(f"Command /{name} raised an exception") return "An error occurred running that command." @@ -40,16 +40,23 @@ def list(self) -> list[BotCommand]: return list(self._commands.values()) -def help_cmd_handler(registry: CommandRegistry) -> CommandHandler: - async def _help() -> str: +def help_cmd(registry: CommandRegistry) -> CommandHandler: + async def _help(args : str = "") -> str: lines = ["Available commands:"] for cmd in registry.list(): lines.append(f"/{cmd.name} — {cmd.description}") return "\n".join(lines) return _help - -async def _status() -> str: +async def model_cmd(args: str = "") -> str: + from .. import config + if not args.strip(): + return f"Current model: {config.get('model', 'unknown')}" + + config.set("model", args.strip()) + return f"Model set to: {args.strip()}" + +async def status_cmd(args: str = "") -> str: from .. import config uptime = datetime.now() - _STARTUP_TIME hours, remainder = divmod(int(uptime.total_seconds()), 3600) diff --git a/app/channels/discord.py b/app/channels/discord.py index 35062a0..42534af 100644 --- a/app/channels/discord.py +++ b/app/channels/discord.py @@ -1,7 +1,7 @@ import discord import logging -from .commands import CommandRegistry, BotCommand, _status, help_cmd_handler +from .commands import CommandRegistry, BotCommand, status_cmd, help_cmd, model_cmd from .message_queue import MessageQueue from .channel import Channel, ChannelType from .message import OutgoingMessage, IncomingMessage @@ -25,8 +25,9 @@ def __init__(self, mq: MessageQueue, token: str, allow_from: list[int] = None) - self._last_channel_id: int | None = None mq.register(self, self.send_message) self.registry = CommandRegistry() - self.registry.register(BotCommand("status", "Show bot status.", _status)) - self.registry.register(BotCommand("help", "Show this help message.", help_cmd_handler(self.registry))) + self.registry.register(BotCommand("model", "Get or set the current model. Usage: /model [model_name]", model_cmd)) + self.registry.register(BotCommand("status", "Show bot status.", status_cmd)) + self.registry.register(BotCommand("help", "Show this help message.", help_cmd(self.registry))) @property def has_stopped(self) -> bool: @@ -59,7 +60,11 @@ async def on_message(self, message: discord.Message) -> None: return if content.startswith("/"): - cmd_name = content[1:].split()[0].lower() + + parts = content[1:].split(maxsplit=1) + cmd_name = parts[0].lower() + args = parts[1] if len(parts) > 1 else "" + metadata = {"channel_id": message.channel.id} if cmd_name == "whoami": await self.send_message(OutgoingMessage( @@ -68,7 +73,7 @@ async def on_message(self, message: discord.Message) -> None: metadata=metadata, )) return - reply = await self.registry.execute(cmd_name) + reply = await self.registry.execute(cmd_name, args) if reply is not None: await self.send_message(OutgoingMessage(content=reply, channel=ChannelType.DISCORD, metadata=metadata)) return diff --git a/app/channels/telegram.py b/app/channels/telegram.py index 79d008e..3eb75a0 100755 --- a/app/channels/telegram.py +++ b/app/channels/telegram.py @@ -1,7 +1,7 @@ import asyncio import logging -from .commands import CommandRegistry, BotCommand, _status, help_cmd_handler +from .commands import CommandRegistry, BotCommand, status_cmd, help_cmd, model_cmd from .message_queue import MessageQueue from .channel import Channel, ChannelType from .message import OutgoingMessage, IncomingMessage @@ -30,9 +30,10 @@ def __init__( self.stopped = False mq.register(self, self.send_message) self.registry = CommandRegistry() - self.registry.register(BotCommand("status", "Show bot status.", _status)) + self.registry.register(BotCommand("model", "Get or set the LLM model. Usage: /model [name]", model_cmd)) + self.registry.register(BotCommand("status", "Show bot status.", status_cmd)) self.registry.register(BotCommand("stop", "Pause the bot.", self._stop_cmd)) - self.registry.register(BotCommand("help", "Show this help message.", help_cmd_handler(self.registry))) + self.registry.register(BotCommand("help", "Show this help message.", help_cmd(self.registry))) @property def has_stopped(self) -> bool: @@ -60,32 +61,26 @@ async def error_handler( "⚠ An error occurred, please try again." ) - async def _stop_cmd(self) -> str: + async def _stop_cmd(self, args: str = "") -> str: self.stopped = True log.info("Received /stop in Telegram channel, setting stopped=True.") return "Stopped." - async def _cmd_reply(self, text: str, chat_id: int) -> None: - await self.send_message(OutgoingMessage(content=text, channel=ChannelType.TELEGRAM, metadata={"chat_id": chat_id})) - - async def whoami(self, update: Update, context: ContextTypes.DEFAULT_TYPE) -> None: - text = f"Your user ID is {update.effective_user.id} and your name is {update.effective_user.first_name}." - await self._cmd_reply(text, update.effective_chat.id) - - async def help(self, update: Update, context: ContextTypes.DEFAULT_TYPE) -> None: - reply = await self.registry.execute("help") - if reply: - await self._cmd_reply(reply, update.effective_chat.id) - - async def status(self, update: Update, context: ContextTypes.DEFAULT_TYPE) -> None: - reply = await self.registry.execute("status") - if reply: - await self._cmd_reply(reply, update.effective_chat.id) - - async def stop(self, update: Update, context: ContextTypes.DEFAULT_TYPE) -> None: - self.stopped = True - await self._cmd_reply("Stopped.", update.effective_chat.id) - log.info("Received /stop in Telegram channel, setting stopped=True.") + async def command_handler(self, update: Update, context: ContextTypes.DEFAULT_TYPE) -> None: + if update.message and update.message.text: + content = update.message.text.strip() + if content.startswith("/"): + parts = content[1:].split(maxsplit=1) + cmd_name = parts[0].lower() + args = parts[1] if len(parts) > 1 else "" + metadata = {"chat_id": update.effective_chat.id} + if cmd_name == "whoami": + text = f"Your user ID is {update.effective_user.id} and your name is {update.effective_user.first_name}." + await self.send_message(OutgoingMessage(content=text, channel=ChannelType.TELEGRAM, metadata=metadata)) + return + reply = await self.registry.execute(cmd_name, args) + if reply: + await self.send_message(OutgoingMessage(content=reply, channel=ChannelType.TELEGRAM, metadata=metadata)) async def send_message(self, message: OutgoingMessage) -> None: # This function is called by the MessageQueue when there is an outgoing message for this channel @@ -143,15 +138,8 @@ def start(self) -> None: .write_timeout(30) .build() ) - self.app.add_handler(CommandHandler("whoami", self.whoami)) - self.app.add_handler(CommandHandler("status", self.status)) - self.app.add_handler(CommandHandler("stop", self.stop)) - self.app.add_handler(CommandHandler("help", self.help)) - - # Add handler for unrecognized commands - self.app.add_handler(MessageHandler(filters.COMMAND, self.help)) - - # Add handler for text messages that are not commands + + self.app.add_handler(MessageHandler(filters.COMMAND, self.command_handler)) self.app.add_handler( MessageHandler(filters.TEXT & ~filters.COMMAND, self.process_message) ) diff --git a/app/config.py b/app/config.py index 9c8664a..a8f9917 100644 --- a/app/config.py +++ b/app/config.py @@ -42,7 +42,9 @@ def load(path: Path | str = HOME_CONFIG_PATH) -> None: def get(key: str, default=None): return _config.get(key, default) - +def set(key: str, value) -> None: + _config[key] = value + def __getattr__(name: str): if name in _config: return _config[name] diff --git a/app/core/agent.py b/app/core/agent.py index 578f404..b1ebcbf 100755 --- a/app/core/agent.py +++ b/app/core/agent.py @@ -16,7 +16,6 @@ def __init__(self, max_iterations: int = 250) -> None: self.client = Client().get_client() self.messages: list[dict] = [] self.max_iterations = max_iterations - self.model = config.get("model", "deepseek/deepseek-v4-flash") def _trim_messages(self) -> None: if len(self.messages) > MAX_CONTEXT_MESSAGES: @@ -82,9 +81,9 @@ async def _loop(self, messages: list, tool_specs: list) -> str: iteration += 1 log.info("chat.completions.create...") chat = await self.client.chat.completions.create( - model=self.model, - messages=messages, - tools=tool_specs, + model = config.get("model", "deepseek/deepseek-v4-flash"), + messages = messages, + tools = tool_specs, ) if not chat.choices: diff --git a/app/core/background_agent.py b/app/core/background_agent.py index 9862183..578914f 100755 --- a/app/core/background_agent.py +++ b/app/core/background_agent.py @@ -64,6 +64,8 @@ async def process_incoming(self) -> None: await self.agent_loop(msg.content, msg.metadata) except Exception as e: log.error(f"Agent loop error: {e}") + await self.mq.outgoing_msg(OutgoingMessage(content="{str(e)}", + channel=self.channel, metadata=msg.metadata)) async def agent_loop(self, message: str, metadata: dict = None) -> str: self._trim_messages() diff --git a/tests/test_background_agent.py b/tests/test_background_agent.py index 791ec87..b8864b8 100644 --- a/tests/test_background_agent.py +++ b/tests/test_background_agent.py @@ -266,6 +266,28 @@ async def test_process_incoming_dispatches_to_agent_loop(): assert any(m.get("role") == "user" and m.get("content") == "hello from telegram" for m in agent.messages) +@pytest.mark.asyncio +async def test_process_incoming_sends_error_to_user_on_agent_loop_failure(): + agent, _, mq = make_agent() + + with patch.object(agent, "agent_loop", side_effect=RuntimeError("model not found")): + incoming = IncomingMessage(content="hi", channel=ChannelType.TELEGRAM, metadata={"chat_id": 99}) + await mq.incoming.put(incoming) + + task = asyncio.create_task(agent.process_incoming()) + await asyncio.sleep(0.05) + task.cancel() + try: + await task + except asyncio.CancelledError: + pass + + assert not mq.outgoing.empty() + error_msg = await mq.outgoing.get() + assert "model not found" in error_msg.content + assert error_msg.metadata == {"chat_id": 99} + + @pytest.mark.asyncio async def test_agent_loop_gathers_multiple_tool_calls_in_parallel(): agent, mock_client, mq = make_agent() diff --git a/tests/test_commands.py b/tests/test_commands.py index e3bb9f3..be0c34e 100644 --- a/tests/test_commands.py +++ b/tests/test_commands.py @@ -1,13 +1,13 @@ import pytest from unittest.mock import AsyncMock, patch -from app.channels.commands import BotCommand, CommandRegistry, _status, help_cmd_handler +from app.channels.commands import BotCommand, CommandRegistry, status_cmd, help_cmd, model_cmd def make_registry(*extra: BotCommand) -> CommandRegistry: r = CommandRegistry() - r.register(BotCommand("status", "Show bot status.", _status)) - r.register(BotCommand("help", "Show this help message.", help_cmd_handler(r))) + r.register(BotCommand("status", "Show bot status.", status_cmd)) + r.register(BotCommand("help", "Show this help message.", help_cmd(r))) for cmd in extra: r.register(cmd) return r @@ -62,7 +62,7 @@ async def test_execute_calls_handler_and_returns_result(): @pytest.mark.asyncio async def test_execute_returns_error_string_on_exception(): - async def boom(): + async def boom(args=""): raise RuntimeError("oops") r = CommandRegistry() r.register(BotCommand("bad", "Broken.", boom)) @@ -71,30 +71,39 @@ async def boom(): assert result # non-empty -# --- _status --- +@pytest.mark.asyncio +async def test_execute_passes_args_to_handler(): + handler = AsyncMock(return_value="ok") + r = CommandRegistry() + r.register(BotCommand("cmd", "Test.", handler)) + await r.execute("cmd", "some args") + handler.assert_called_once_with("some args") + + +# --- status_cmd --- @pytest.mark.asyncio async def test_status_includes_model_name(): with patch("app.config._config", {"model": "my-test-model"}): - result = await _status() + result = await status_cmd() assert "my-test-model" in result @pytest.mark.asyncio async def test_status_includes_uptime(): with patch("app.config._config", {"model": "m"}): - result = await _status() + result = await status_cmd() assert "Uptime" in result -# --- help_cmd_handler --- +# --- help_cmd --- @pytest.mark.asyncio async def test_help_handler_lists_all_registered_commands(): r = CommandRegistry() r.register(BotCommand("foo", "Foo command.", AsyncMock(return_value=""))) r.register(BotCommand("bar", "Bar command.", AsyncMock(return_value=""))) - r.register(BotCommand("help", "Help.", help_cmd_handler(r))) + r.register(BotCommand("help", "Help.", help_cmd(r))) result = await r.execute("help") assert "/foo" in result assert "/bar" in result @@ -104,7 +113,25 @@ async def test_help_handler_lists_all_registered_commands(): @pytest.mark.asyncio async def test_help_handler_reflects_commands_registered_after_creation(): r = CommandRegistry() - r.register(BotCommand("help", "Help.", help_cmd_handler(r))) + r.register(BotCommand("help", "Help.", help_cmd(r))) r.register(BotCommand("late", "Registered after help.", AsyncMock(return_value=""))) result = await r.execute("help") assert "/late" in result + + +# --- model_cmd --- + +@pytest.mark.asyncio +async def test_model_cmd_returns_current_model_when_no_args(): + with patch("app.config._config", {"model": "deepseek/v3"}): + result = await model_cmd("") + assert "deepseek/v3" in result + + +@pytest.mark.asyncio +async def test_model_cmd_sets_model(): + mock_cfg = {"model": "old-model"} + with patch("app.config._config", mock_cfg): + result = await model_cmd("new-model") + assert "new-model" in result + assert mock_cfg["model"] == "new-model" diff --git a/tests/test_discord_channel.py b/tests/test_discord_channel.py index 41d0e47..9645e6b 100644 --- a/tests/test_discord_channel.py +++ b/tests/test_discord_channel.py @@ -295,7 +295,25 @@ async def test_on_message_known_command_replies_and_skips_mq(): await dc.on_message(message) - dc.registry.execute.assert_called_once_with("status") + dc.registry.execute.assert_called_once_with("status", "") + dc.send_message.assert_called_once() + assert mq.incoming.empty() + + +@pytest.mark.asyncio +async def test_on_message_command_with_args(): + dc, mq = make_discord_channel() + dc.registry.execute = AsyncMock(return_value="Model set to: gpt-4") + dc.send_message = AsyncMock() + message = MagicMock() + message.author.id = 123 + message.author.display_name = "Alice" + message.channel.id = 456 + message.content = "/model gpt-4" + + await dc.on_message(message) + + dc.registry.execute.assert_called_once_with("model", "gpt-4") dc.send_message.assert_called_once() assert mq.incoming.empty() diff --git a/tests/test_telegram_channel.py b/tests/test_telegram_channel.py index 78094c2..0eb6708 100644 --- a/tests/test_telegram_channel.py +++ b/tests/test_telegram_channel.py @@ -154,7 +154,7 @@ async def test_error_handler_notifies_user_on_chat_update(): assert "error" in update.effective_message.reply_text.call_args[0][0].lower() -# --- stop --- +# --- command_handler --- @pytest.mark.asyncio async def test_stop_sets_has_stopped(): @@ -162,8 +162,7 @@ async def test_stop_sets_has_stopped(): tc.send_message = AsyncMock() assert tc.has_stopped is False - update = make_update() - await tc.stop(update, MagicMock()) + await tc.command_handler(make_update(text="/stop"), MagicMock()) assert tc.has_stopped is True @@ -172,8 +171,8 @@ async def test_stop_sets_has_stopped(): async def test_stop_replies_to_user(): tc, _ = make_telegram_channel() tc.send_message = AsyncMock() - update = make_update() - await tc.stop(update, MagicMock()) + + await tc.command_handler(make_update(text="/stop"), MagicMock()) tc.send_message.assert_called_once() assert "Stopped" in tc.send_message.call_args[0][0].content @@ -183,14 +182,38 @@ async def test_stop_replies_to_user(): async def test_clear_stopped_resets_state(): tc, _ = make_telegram_channel() tc.send_message = AsyncMock() - update = make_update() - await tc.stop(update, MagicMock()) + + await tc.command_handler(make_update(text="/stop"), MagicMock()) assert tc.has_stopped is True tc.clear_stopped() assert tc.has_stopped is False +@pytest.mark.asyncio +async def test_command_handler_whoami_replies_with_user_info(): + tc, _ = make_telegram_channel() + tc.send_message = AsyncMock() + + await tc.command_handler(make_update(text="/whoami", user_id=42), MagicMock()) + + tc.send_message.assert_called_once() + text = tc.send_message.call_args[0][0].content + assert "42" in text + + +@pytest.mark.asyncio +async def test_command_handler_dispatches_with_args(): + tc, _ = make_telegram_channel() + tc.registry.execute = AsyncMock(return_value="Model set to: gpt-4") + tc.send_message = AsyncMock() + + await tc.command_handler(make_update(text="/model gpt-4"), MagicMock()) + + tc.registry.execute.assert_called_once_with("model", "gpt-4") + tc.send_message.assert_called_once() + + # --- error_handler --- @pytest.mark.asyncio From f703fef6c8797799dbe3f987f3c0db865dbbc4b9 Mon Sep 17 00:00:00 2001 From: "rikulpatel@gmail.com" Date: Mon, 18 May 2026 13:45:43 -0500 Subject: [PATCH 56/84] fix: missing f str --- app/core/background_agent.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/app/core/background_agent.py b/app/core/background_agent.py index 578914f..ebb36a4 100755 --- a/app/core/background_agent.py +++ b/app/core/background_agent.py @@ -64,8 +64,7 @@ async def process_incoming(self) -> None: await self.agent_loop(msg.content, msg.metadata) except Exception as e: log.error(f"Agent loop error: {e}") - await self.mq.outgoing_msg(OutgoingMessage(content="{str(e)}", - channel=self.channel, metadata=msg.metadata)) + await self.mq.outgoing_msg(OutgoingMessage(content=str(e), channel=self.channel, metadata=msg.metadata)) async def agent_loop(self, message: str, metadata: dict = None) -> str: self._trim_messages() From 2540806d352458a0d21652932e07ad171bc64473 Mon Sep 17 00:00:00 2001 From: "rikulpatel@gmail.com" Date: Fri, 22 May 2026 23:22:12 -0500 Subject: [PATCH 57/84] refactor: runtime settings singleton for mutable config MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Adds app/core/runtime.py — a thin in-memory key-value store — so settings like `model` and `max_iterations` can be changed at runtime (e.g. via /model) without mutating the on-disk config.. --- CLAUDE.md | 30 ++++++++++++++++++++++-------- app/bg_server.py | 6 +++--- app/channels/commands.py | 10 ++++------ app/core/agent.py | 3 ++- app/core/background_agent.py | 1 + app/core/runtime.py | 27 +++++++++++++++++++++++++++ app/main.py | 20 +++++++++++--------- 7 files changed, 70 insertions(+), 27 deletions(-) mode change 100644 => 100755 CLAUDE.md create mode 100644 app/core/runtime.py mode change 100644 => 100755 app/main.py diff --git a/CLAUDE.md b/CLAUDE.md old mode 100644 new mode 100755 index b2d657c..10147f9 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -4,7 +4,7 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co ## Overview -This is a **CodeCrafters challenge** project implementing a Python-based AI agent CLI ("crafterscode") that uses an OpenAI-compatible API (defaulting to OpenRouter/DeepSeek) via the `openai` Python SDK. The agent supports interactive REPL mode, silent/non-interactive mode, and a background agent architecture for multi-channel messaging. +This is a Python-based AI agent ("crafterscode") that uses an OpenAI-compatible API (defaulting to OpenRouter/DeepSeek) via the `openai` Python SDK. It supports an interactive CLI REPL, silent/non-interactive mode, and a background server architecture with Telegram and Discord channels. ## Running & Development @@ -36,9 +36,11 @@ The project uses `uv` for dependency management. No compile step is needed. ## Configuration Config lives at `~/.crafterscode/config.toml` (created automatically on first run with defaults). Key fields: -- `model` — LLM model string (default: `"deepseek/deepseek-v3.2"`) +- `model` — LLM model string (default: `"deepseek/deepseek-v4-flash"`) - `max_iterations` — max agentic loop iterations (default: `100`) - `base_url` — API base URL (default: `"https://openrouter.ai/api/v1"`) +- `[telegram]` — `BOT_TOKEN`, `ALLOW_FROM` (list of integer user IDs) +- `[discord]` — `TOKEN`, `ALLOW_FROM` (list of integer user IDs; empty = allow all) Environment variables (all override config file values): - `LLM_API_KEY` — required @@ -46,6 +48,8 @@ Environment variables (all override config file values): - `MODEL` — optional model override - `TELEGRAM_BOT_TOKEN` — Telegram bot token (alternative to config file) - `TELEGRAM_ALLOW_FROM` — comma-separated Telegram user IDs (e.g. `"123,456"`) +- `DISCORD_BOT_TOKEN` — Discord bot token (alternative to config file) +- `DISCORD_ALLOW_FROM` — comma-separated Discord user IDs - `ANOTHERBOT_HOME` — overrides the data directory (default: `~/.crafterscode`) For Docker, no config file is needed — pass everything as env vars. See `Dockerfile` and the Docker section in README. @@ -69,21 +73,31 @@ Tool calls within a single LLM turn are dispatched in parallel via `asyncio.gath ### Tool System -Tools are registered in `app/tool_calls.py` in `tool_registry` — a dict mapping tool name → `{spec, func}`. Each tool in `app/tools/` exports a function and an OpenAI-format tool spec dict. `run_tool()` dispatches by name and restores `os.getcwd()` after each call. +Each tool is a class extending `Tool` (`app/core/tool.py`), an ABC requiring a static `spec()` (OpenAI function-call schema) and a static `call()` method. Tools are registered in `app/core/tool_calls.py` in `tool_registry` — a dict mapping tool name → `Tool` class. `run_tool()` dispatches by name and restores `os.getcwd()` after each call. Results are truncated to `MAX_TOOL_RESULT_LENGTH` (16 000 chars). -Current tools: `read_file`, `write_file`, `bash`, `web_fetch`, `get_skills_dir`, `todo_add/list/update/clear`, `calculator`, `hackernews`, `websearch_text/images/videos/news/books`, `list/add/update/remove_scheduled_task`, `get_scheduled_task_output`. +Current tools: `read_file`, `write_file`, `bash`, `web_fetch`, `get_skills_dir`, `todo_add/list/update/clear`, `calculator`, `hackernews`, `websearch_text/images/videos/news/books`, `list/add/update/remove_scheduled_task`, `get_scheduled_task_output`, `get_city_state`, `get_datetime`. -`_HELPER_AGENT_TOOLS` in `tool_calls.py` is an explicit allowlist of tools available to `HelperAgent` (used internally by scheduled tasks). Scheduled task management tools are excluded to prevent recursion. +`_HELPER_AGENT_TOOLS` in `tool_calls.py` is an explicit allowlist of tools available to `HelperAgent` (used internally by scheduled tasks). Scheduled task mutation tools (`add/update/remove_scheduled_task`) are excluded to prevent recursion. ### System Context On startup, `load_system_context()` (`app/infra/startup.py`) loads `app/core/sys_instructions.md` and prepends it as the system message to `self.messages`. -### Message Queue / Channel Architecture +### Runtime Settings -`MessageQueue` (`app/channels/message_queue.py`) holds two `asyncio.Queue`s (incoming/outgoing). `BackgroundAgent.process_incoming()` consumes the incoming queue and drives `agent_loop()`; `process_outgoing()` dispatches outbound messages to registered delivery functions. This is the intended extension point for adding new channels. +`app/core/runtime.py` is an in-memory key-value singleton (`set()` / `get()`) for mutable settings like `model`, `base_url`, and `max_iterations`. Values are populated from config during startup in `main.py` and can be changed at runtime via the `/model` slash command. -Each channel should have its own `MessageQueue` instance to avoid cross-channel message routing bugs (e.g., a Telegram message being handled by the Discord agent). +### Channels & Command Registry + +**Channel types** are defined in `ChannelType` enum (`app/channels/channel.py`): `CLI`, `TELEGRAM`, `DISCORD`, `WEB`. Each channel implements the `Channel` ABC and owns a `MessageQueue` instance. `bg_server.py` wires up enabled channels — each gets its own `MessageQueue`, `BackgroundAgent`, and set of coroutines (`run_polling`, `process_incoming`, `process_outgoing`) gathered into the event loop. + +**Slash commands** are handled by a `CommandRegistry` (`app/channels/commands.py`) shared across Telegram and Discord. Built-in commands: `/help`, `/status`, `/model [name]`, `/whoami`. Each channel constructs its own registry instance and registers the same `BotCommand`s. Commands are dispatched before the message reaches the agent loop. + +### Message Queue + +`MessageQueue` (`app/channels/message_queue.py`) holds two `asyncio.Queue`s (incoming/outgoing). `BackgroundAgent.process_incoming()` consumes the incoming queue and drives `agent_loop()`; `process_outgoing()` dispatches outbound messages to registered delivery functions. + +Each channel **must** have its own `MessageQueue` instance to avoid cross-channel message routing bugs. ### Scheduled Tasks diff --git a/app/bg_server.py b/app/bg_server.py index ce589dc..0db1606 100755 --- a/app/bg_server.py +++ b/app/bg_server.py @@ -6,7 +6,7 @@ from .core.background_agent import BackgroundAgent from .channels.message_queue import MessageQueue from .core.scheduled_tasks import ScheduledTasks - +from .core import runtime async def start_server() -> None: log.info("Starting server...") @@ -31,7 +31,7 @@ async def start_server() -> None: telegram_mq = MessageQueue() telegram_channel = TelegramChannel(telegram_mq, bot_token=bot_token, allow_from=config.telegram.get("ALLOW_FROM", [])) telegram_channel.start() - telegram_agent = BackgroundAgent(mq=telegram_mq, channel=telegram_channel) + telegram_agent = BackgroundAgent(mq=telegram_mq, channel=telegram_channel, max_iterations=runtime.get("max_iterations", 250)) if config.get("discord"): discord_token = config.discord.get("TOKEN") @@ -42,7 +42,7 @@ async def start_server() -> None: discord_mq = MessageQueue() discord_channel = DiscordChannel(discord_mq, token=discord_token, allow_from=config.discord.get("ALLOW_FROM", [])) discord_channel.start() - discord_agent = BackgroundAgent(mq=discord_mq, channel=discord_channel) + discord_agent = BackgroundAgent(mq=discord_mq, channel=discord_channel, max_iterations=runtime.get("max_iterations", 250)) if not telegram_channel and not discord_channel: log.error("No channels configured, exiting...") diff --git a/app/channels/commands.py b/app/channels/commands.py index cd959b7..176a560 100644 --- a/app/channels/commands.py +++ b/app/channels/commands.py @@ -4,6 +4,7 @@ from dataclasses import dataclass from datetime import datetime from typing import Callable, Awaitable +from ..core import runtime log = logging.getLogger(__name__) @@ -11,7 +12,6 @@ _STARTUP_TIME: datetime = datetime.now() - @dataclass class BotCommand: name: str @@ -49,17 +49,15 @@ async def _help(args : str = "") -> str: return _help async def model_cmd(args: str = "") -> str: - from .. import config if not args.strip(): - return f"Current model: {config.get('model', 'unknown')}" + return f"Current model: {runtime.get('model', 'unknown')}" - config.set("model", args.strip()) + runtime.set("model", args.strip()) return f"Model set to: {args.strip()}" async def status_cmd(args: str = "") -> str: - from .. import config uptime = datetime.now() - _STARTUP_TIME hours, remainder = divmod(int(uptime.total_seconds()), 3600) minutes, seconds = divmod(remainder, 60) - model = config.get("model", "unknown") + model = runtime.get("model", "unknown") return f"Bot status:\n Model: {model}\n Uptime: {hours}h {minutes}m {seconds}s" diff --git a/app/core/agent.py b/app/core/agent.py index b1ebcbf..69b50c7 100755 --- a/app/core/agent.py +++ b/app/core/agent.py @@ -5,6 +5,7 @@ from .. import config from .client import Client from ..infra.app_logging import log +from . import runtime MAX_CONTEXT_MESSAGES = 1000 TOOL_RESULT_HISTORY_LIMIT = 100 @@ -81,7 +82,7 @@ async def _loop(self, messages: list, tool_specs: list) -> str: iteration += 1 log.info("chat.completions.create...") chat = await self.client.chat.completions.create( - model = config.get("model", "deepseek/deepseek-v4-flash"), + model = runtime.get("model", "deepseek/deepseek-v4-flash"), messages = messages, tools = tool_specs, ) diff --git a/app/core/background_agent.py b/app/core/background_agent.py index ebb36a4..6d0bf82 100755 --- a/app/core/background_agent.py +++ b/app/core/background_agent.py @@ -10,6 +10,7 @@ from .agent import Agent, MAX_CONTEXT_MESSAGES from ..infra.startup import load_system_context from ..infra.message_history import MessageHistory +from . import runtime _MAX_EMPTY_RETRIES = 5 diff --git a/app/core/runtime.py b/app/core/runtime.py new file mode 100644 index 0000000..e56ca22 --- /dev/null +++ b/app/core/runtime.py @@ -0,0 +1,27 @@ +"""Simple in-memory singleton for storing runtime settings. + +Values are set during app initialisation and can be read or updated at any +time by long-running background agents or other components. + +""" + +from __future__ import annotations + +from typing import Any + +_store: dict[str, Any] = {} + + +def set(key: str, value: Any) -> None: + """Store a runtime variable.""" + _store[key] = value + + +def get(key: str, default: Any = None) -> Any: + """Retrieve a runtime variable, returning *default* if not found.""" + return _store.get(key, default) + + +def all_vars() -> dict[str, Any]: + """Return a shallow copy of all runtime variables.""" + return dict(_store) \ No newline at end of file diff --git a/app/main.py b/app/main.py old mode 100644 new mode 100755 index 63d312e..12c7b32 --- a/app/main.py +++ b/app/main.py @@ -11,6 +11,7 @@ from .cli.cli import input_loop from .cli.cli_agent import CliAgent from .bg_server import start_server +from .core import runtime from dotenv import load_dotenv load_dotenv() @@ -44,23 +45,21 @@ def parse_args(): subparsers.add_parser("background", help="Run in background") - return parser.parse_args() - -async def run_cli(args): + args = parser.parse_args() - # validate max_iterations - if args.max_iterations is None: + if not hasattr(args, "max_iterations") or args.max_iterations is None or args.max_iterations <= 0: args.max_iterations = config.get("max_iterations", 100) - if args.max_iterations <= 0: - log.error("max_iterations must be a positive integer") - return + return args + +async def run_cli(args): if args.silent: log.setLevel(logging.WARNING) log.info("Starting agent...") - agent = CliAgent(auto_approve=args.auto_approve or args.silent, max_iterations=args.max_iterations, silent=args.silent) + agent = CliAgent(auto_approve=args.auto_approve or args.silent, + max_iterations=runtime.get("max_iterations", 250), silent=args.silent) if args.prompt: await agent.agent_loop(args.prompt) @@ -95,6 +94,9 @@ async def main(): args = parse_args() + runtime.set("model", config.get("model", "deepseek/deepseek-v4-flash")) + runtime.set("max_iterations", args.max_iterations) + if args.command == "cli": await run_cli(args) elif args.command == "background": From 9d062ef5e6788309d61f311e7c90db21ef1a443f Mon Sep 17 00:00:00 2001 From: "rikulpatel@gmail.com" Date: Sat, 23 May 2026 10:18:06 -0500 Subject: [PATCH 58/84] Refactor: move system prompt loading into agent.py, read model from runtime MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Relocate `load_system_context()` from `app/infra/startup.py` → `app/core/agent.py` as `get_default_sys_prompt()` - Delete `app/infra/startup.py` (no remaining responsibilities) --- app/cli/cli_agent.py | 5 ++-- app/core/agent.py | 37 ++++++++++++++++++++++++++++++ app/core/background_agent.py | 5 ++-- app/infra/startup.py | 42 ---------------------------------- app/main.py | 6 ++++- tests/integration/test_cli.py | 2 +- tests/test_agent.py | 10 ++++---- tests/test_background_agent.py | 8 +++---- tests/test_bg_server.py | 4 ++-- tests/test_commands.py | 10 ++++---- tests/test_startup.py | 31 ++++++++----------------- 11 files changed, 72 insertions(+), 88 deletions(-) delete mode 100755 app/infra/startup.py diff --git a/app/cli/cli_agent.py b/app/cli/cli_agent.py index 53d4e3a..48bc433 100755 --- a/app/cli/cli_agent.py +++ b/app/cli/cli_agent.py @@ -2,10 +2,9 @@ from ..core.tool_calls import all_tool_specs from .cli import ask_permission -from ..core.agent import Agent, MAX_CONTEXT_MESSAGES +from ..core.agent import Agent, MAX_CONTEXT_MESSAGES, get_default_sys_prompt from ..infra.message_history import MessageHistory from ..channels.channel import ChannelType -from ..infra.startup import load_system_context class CliAgent(Agent): @@ -34,7 +33,7 @@ async def agent_loop(self, message: str, metadata: dict = None) -> str: self._trim_messages() self.history.add_message("user", message) - system_context = load_system_context() + system_context = get_default_sys_prompt({"channel": ChannelType.CLI.value}) system = [{"role": "system", "content": system_context}] if system_context else [] session_messages = system + self.messages[:] + [{"role": "user", "content": message}] diff --git a/app/core/agent.py b/app/core/agent.py index 69b50c7..90c7f16 100755 --- a/app/core/agent.py +++ b/app/core/agent.py @@ -1,6 +1,10 @@ import asyncio import json +import os +import platform from abc import ABC, abstractmethod +from datetime import datetime +from pathlib import Path from .. import config from .client import Client @@ -11,6 +15,39 @@ TOOL_RESULT_HISTORY_LIMIT = 100 +def get_default_sys_prompt(context: dict | None = None) -> str: + ctx = context or {} + channel = ctx.get("channel", "cli") + + now = datetime.now() + sys_instructions_path = Path(__file__).parent / "sys_instructions.md" + sys_prompt = "" + + try: + with open(sys_instructions_path, "r", encoding="utf-8") as f: + sys_prompt = f.read().strip() + except Exception as e: + log.error(f"Error loading system prompt: {e}") + + sys_prompt += f""" + +## Current System Context +- Conversation started on {now.strftime("%Y-%m-%d %H:%M:%S")} {now.astimezone().tzname()} +- Day of Week: {now.strftime("%A")} +- OS: {platform.system()} {platform.release()} +- Shell: {os.environ.get("SHELL", "unknown")} +- CWD: {Path.cwd()} +- Home: {Path.home()} +- workspace: {config.PROJECT_HOME / "workspace"} +- Python: {platform.python_version()} +- Starting LLM Model: {runtime.get("model", "unknown")} +- Current Channel: {channel} +""" + + log.info(f"Loaded system prompt: {len(sys_prompt)} characters") + return sys_prompt + + class Agent(ABC): def __init__(self, max_iterations: int = 250) -> None: diff --git a/app/core/background_agent.py b/app/core/background_agent.py index 6d0bf82..2359224 100755 --- a/app/core/background_agent.py +++ b/app/core/background_agent.py @@ -7,8 +7,7 @@ from ..channels.channel import Channel from ..channels.message import OutgoingMessage from ..channels.message_queue import MessageQueue -from .agent import Agent, MAX_CONTEXT_MESSAGES -from ..infra.startup import load_system_context +from .agent import Agent, MAX_CONTEXT_MESSAGES, get_default_sys_prompt from ..infra.message_history import MessageHistory from . import runtime @@ -73,7 +72,7 @@ async def agent_loop(self, message: str, metadata: dict = None) -> str: self._reply_metadata = metadata or {} self.history.add_message("user", message) - system_context = load_system_context() + system_context = get_default_sys_prompt({"channel" : self.channel.channel_type.value}) system = [{"role": "system", "content": system_context}] if system_context else [] session_messages = system + self.messages[:] + [{"role": "user", "content": message}] diff --git a/app/infra/startup.py b/app/infra/startup.py deleted file mode 100755 index 862a1d4..0000000 --- a/app/infra/startup.py +++ /dev/null @@ -1,42 +0,0 @@ -from pathlib import Path -import os -import platform -from datetime import datetime -from .app_logging import log -from .. import config - -def load_system_context() -> str: - """ - Load sys_instructions.md and return its contents as the system context string. - """ - - now = datetime.now() - sys_instructions_path = Path(__file__).parent.parent / "core" / "sys_instructions.md" - system_context = "" - - try: - with open(sys_instructions_path, "r", encoding="utf-8") as f: - system_context = f.read().strip() - except Exception as e: - log.error(f"Error loading system context: {e}") - - system_context += f""" - -## Current System Context -- Conversation started: {now.strftime("%Y-%m-%d %H:%M:%S")} {now.astimezone().tzname()} -- day of week: {now.strftime("%A")} -- os: {platform.system()} {platform.release()} -- shell: {os.environ.get("SHELL", "unknown")} -- cwd: {Path.cwd()} -- home: {Path.home()} -- workspace: {config.PROJECT_HOME / "workspace"} - -## Runtime -- python: {platform.python_version()} -- model: {config.get("model", "unknown")} -""" - - log.info(f"Loaded system context: {len(system_context)} characters") - - return system_context - diff --git a/app/main.py b/app/main.py index 12c7b32..1402310 100755 --- a/app/main.py +++ b/app/main.py @@ -47,13 +47,17 @@ def parse_args(): args = parser.parse_args() - if not hasattr(args, "max_iterations") or args.max_iterations is None or args.max_iterations <= 0: + if not hasattr(args, "max_iterations") or args.max_iterations is None: args.max_iterations = config.get("max_iterations", 100) return args async def run_cli(args): + if args.max_iterations <= 0: + log.warning(f"max_iterations must be positive (got {args.max_iterations}), exiting") + return + if args.silent: log.setLevel(logging.WARNING) diff --git a/tests/integration/test_cli.py b/tests/integration/test_cli.py index 175a810..e014363 100644 --- a/tests/integration/test_cli.py +++ b/tests/integration/test_cli.py @@ -49,7 +49,7 @@ async def test_cli_with_simple_prompt(capsys): try: with patch("sys.argv", ["prog", "cli", "-p", "say hello", "--silent"]), \ patch("app.core.agent.Client") as MockClient, \ - patch("app.cli.cli_agent.load_system_context", return_value=""), \ + patch("app.cli.cli_agent.get_default_sys_prompt", return_value=""), \ patch("app.cli.cli_agent.MessageHistory") as MockHistory, \ patch("app.main.config.load"), \ patch.object(config_module, "_config", {"model": "test-model"}): diff --git a/tests/test_agent.py b/tests/test_agent.py index 39fdf02..6da0e2d 100644 --- a/tests/test_agent.py +++ b/tests/test_agent.py @@ -29,7 +29,7 @@ def make_agent(auto_approve=True, silent=True, max_iterations=10): with patch("app.core.agent.Client") as MockClient: mock_openai = make_mock_client() MockClient.return_value.get_client.return_value = mock_openai - with patch("app.cli.cli_agent.load_system_context", return_value="You are a helpful assistant."): + with patch("app.cli.cli_agent.get_default_sys_prompt", return_value="You are a helpful assistant."): with patch("app.cli.cli_agent.MessageHistory") as MockHistory: MockHistory.return_value.get_history.return_value = [] agent = Agent( @@ -49,7 +49,7 @@ def patch_config(): @pytest.mark.asyncio async def test_agent_loop_sends_system_context_to_llm(): agent, mock_client = make_agent() - with patch("app.cli.cli_agent.load_system_context", return_value="system prompt"): + with patch("app.cli.cli_agent.get_default_sys_prompt", return_value="system prompt"): await agent.agent_loop("hello") call_messages = mock_client.chat.completions.create.call_args[1]["messages"] assert call_messages[0]["role"] == "system" @@ -89,7 +89,7 @@ async def test_agent_loop_respects_max_iterations(): with patch("app.core.agent.Client") as MockClient: mock_client = MagicMock() MockClient.return_value.get_client.return_value = mock_client - with patch("app.cli.cli_agent.load_system_context", return_value="You are a helpful assistant."): + with patch("app.cli.cli_agent.get_default_sys_prompt", return_value="You are a helpful assistant."): with patch("app.cli.cli_agent.MessageHistory") as MockHistory: MockHistory.return_value.get_history.return_value = [] agent = Agent(auto_approve=True, silent=True, max_iterations=3) @@ -125,7 +125,7 @@ async def test_agent_loop_runs_tool_when_auto_approve(): with patch("app.core.agent.Client") as MockClient: mock_client = MagicMock() MockClient.return_value.get_client.return_value = mock_client - with patch("app.cli.cli_agent.load_system_context", return_value="You are a helpful assistant."): + with patch("app.cli.cli_agent.get_default_sys_prompt", return_value="You are a helpful assistant."): with patch("app.cli.cli_agent.MessageHistory") as MockHistory: MockHistory.return_value.get_history.return_value = [] agent = Agent(auto_approve=True, silent=True, max_iterations=10) @@ -175,7 +175,7 @@ async def test_agent_loop_continues_when_finish_reason_not_stop(): with patch("app.core.agent.Client") as MockClient: mock_client = MagicMock() MockClient.return_value.get_client.return_value = mock_client - with patch("app.cli.cli_agent.load_system_context", return_value="You are a helpful assistant."): + with patch("app.cli.cli_agent.get_default_sys_prompt", return_value="You are a helpful assistant."): with patch("app.cli.cli_agent.MessageHistory") as MockHistory: MockHistory.return_value.get_history.return_value = [] agent = Agent(auto_approve=True, silent=True, max_iterations=10) diff --git a/tests/test_background_agent.py b/tests/test_background_agent.py index b8864b8..1b3e0df 100644 --- a/tests/test_background_agent.py +++ b/tests/test_background_agent.py @@ -36,7 +36,7 @@ def make_agent(max_iterations=10): with patch("app.core.agent.Client") as MockClient: mock_openai = make_mock_client() MockClient.return_value.get_client.return_value = mock_openai - with patch("app.core.background_agent.load_system_context", return_value="You are a helpful assistant."): + with patch("app.core.background_agent.get_default_sys_prompt", return_value="You are a helpful assistant."): with patch("app.core.background_agent.MessageHistory") as MockHistory: MockHistory.return_value.get_history.return_value = [] agent = BackgroundAgent(mq=mq, channel=_mock_channel, max_iterations=max_iterations) @@ -58,7 +58,7 @@ def test_agent_initializes_with_empty_messages(): @pytest.mark.asyncio async def test_agent_loop_sends_system_context_to_llm(): agent, mock_client, _ = make_agent() - with patch("app.core.background_agent.load_system_context", return_value="system prompt"): + with patch("app.core.background_agent.get_default_sys_prompt", return_value="system prompt"): await agent.agent_loop("hello") call_messages = mock_client.chat.completions.create.call_args[1]["messages"] assert call_messages[0]["role"] == "system" @@ -69,7 +69,7 @@ def test_agent_stores_channel_and_mq(): mq = MessageQueue() with patch("app.core.agent.Client") as MockClient: MockClient.return_value.get_client.return_value = MagicMock() - with patch("app.core.background_agent.load_system_context", return_value=""): + with patch("app.core.background_agent.get_default_sys_prompt", return_value=""): with patch("app.core.background_agent.MessageHistory") as MockHistory: MockHistory.return_value.get_history.return_value = [] agent = BackgroundAgent(mq=mq, channel=_mock_channel) @@ -235,7 +235,7 @@ async def test_agent_loop_clears_stopped_after_completion(): with patch("app.core.agent.Client") as MockClient: MockClient.return_value.get_client.return_value = make_mock_client() - with patch("app.core.background_agent.load_system_context", return_value=""): + with patch("app.core.background_agent.get_default_sys_prompt", return_value=""): with patch("app.core.background_agent.MessageHistory") as MockHistory: MockHistory.return_value.get_history.return_value = [] agent = BackgroundAgent(mq=mq, channel=local_channel, max_iterations=10) diff --git a/tests/test_bg_server.py b/tests/test_bg_server.py index 55553b6..718b111 100644 --- a/tests/test_bg_server.py +++ b/tests/test_bg_server.py @@ -1,6 +1,6 @@ import pytest from pathlib import Path -from unittest.mock import patch, MagicMock, AsyncMock +from unittest.mock import patch, MagicMock, AsyncMock, ANY from app.bg_server import start_server @@ -47,7 +47,7 @@ async def test_start_server_discord_only_starts_discord_agent(): await start_server() MockDC.assert_called_once_with(mock_mq, token="discord-token", allow_from=[]) - MockAgent.assert_called_once_with(mq=mock_mq, channel=mock_dc) + MockAgent.assert_called_once_with(mq=mock_mq, channel=mock_dc, max_iterations=ANY) assert mock_gather.called diff --git a/tests/test_commands.py b/tests/test_commands.py index be0c34e..02eddef 100644 --- a/tests/test_commands.py +++ b/tests/test_commands.py @@ -84,7 +84,7 @@ async def test_execute_passes_args_to_handler(): @pytest.mark.asyncio async def test_status_includes_model_name(): - with patch("app.config._config", {"model": "my-test-model"}): + with patch("app.core.runtime._store", {"model": "my-test-model"}): result = await status_cmd() assert "my-test-model" in result @@ -123,15 +123,15 @@ async def test_help_handler_reflects_commands_registered_after_creation(): @pytest.mark.asyncio async def test_model_cmd_returns_current_model_when_no_args(): - with patch("app.config._config", {"model": "deepseek/v3"}): + with patch("app.core.runtime._store", {"model": "deepseek/v3"}): result = await model_cmd("") assert "deepseek/v3" in result @pytest.mark.asyncio async def test_model_cmd_sets_model(): - mock_cfg = {"model": "old-model"} - with patch("app.config._config", mock_cfg): + mock_store = {"model": "old-model"} + with patch("app.core.runtime._store", mock_store): result = await model_cmd("new-model") assert "new-model" in result - assert mock_cfg["model"] == "new-model" + assert mock_store["model"] == "new-model" diff --git a/tests/test_startup.py b/tests/test_startup.py index 12491db..d0876c9 100644 --- a/tests/test_startup.py +++ b/tests/test_startup.py @@ -1,31 +1,18 @@ -import pathlib -from unittest.mock import patch +from unittest.mock import patch, mock_open -from app.infra.startup import load_system_context +from app.core.agent import get_default_sys_prompt -def test_load_system_context_returns_string(): - result = load_system_context() +def test_get_default_sys_prompt_returns_string(): + result = get_default_sys_prompt() assert isinstance(result, str) -def test_load_system_context_includes_file_content(): - # The real system.md directory ships with the app and should contain content - result = load_system_context() +def test_get_default_sys_prompt_includes_file_content(): + result = get_default_sys_prompt() assert len(result) > 0 -def test_load_system_context_skips_missing_files(tmp_path): - system_md_dir = tmp_path / "system.md" - system_md_dir.mkdir() - - with patch("app.infra.startup.Path") as MockPath: - instance = MockPath.return_value - instance.parent.__truediv__ = lambda self, key: system_md_dir - MockPath.side_effect = lambda *args, **kwargs: pathlib.Path(*args, **kwargs) - - # Only one file present; should not raise - (system_md_dir / "self.md").write_text("hello", encoding="utf-8") - result = load_system_context() - +def test_get_default_sys_prompt_skips_missing_file(): + with patch("builtins.open", side_effect=FileNotFoundError): + result = get_default_sys_prompt() assert isinstance(result, str) - From cd41e4973aaf0a85185443f6ec65e6d44715f865 Mon Sep 17 00:00:00 2001 From: "rikulpatel@gmail.com" Date: Sat, 23 May 2026 10:50:28 -0500 Subject: [PATCH 59/84] refactor/fix: removed old db stuff and fix a test --- app/core/scheduled_tasks.py | 16 ---------------- app/infra/message_history.py | 14 +++----------- app/infra/setup.py | 7 ------- app/main.py | 4 +--- tests/test_config.py | 3 ++- 5 files changed, 6 insertions(+), 38 deletions(-) diff --git a/app/core/scheduled_tasks.py b/app/core/scheduled_tasks.py index 39ed476..f145a35 100755 --- a/app/core/scheduled_tasks.py +++ b/app/core/scheduled_tasks.py @@ -18,12 +18,6 @@ def __init__(self, mqs: dict = None, channels: dict = None): self._channels = channels or {} self._init_tasks_db() - def _migrate(self, conn, table: str, columns: list[tuple[str, str]]): - existing = {row[1] for row in conn.execute(f"PRAGMA table_info({table})").fetchall()} - for col_name, col_def in columns: - if col_name not in existing: - conn.execute(f"ALTER TABLE {table} ADD COLUMN {col_name} {col_def}") - def _init_tasks_db(self): with sqlite3.connect(APP_DB) as conn: @@ -55,16 +49,6 @@ def _init_tasks_db(self): ) """) - self._migrate(conn, "tasks", [ - ("repeat", "INTEGER NOT NULL DEFAULT 0"), - ("next_run", "TEXT NOT NULL DEFAULT '1970-01-01T00:00:00'"), - ("delivery_channel", "TEXT NOT NULL DEFAULT 'telegram'"), - ("run_count", "INTEGER NOT NULL DEFAULT 0"), - ]) - self._migrate(conn, "task_outputs", [ - ("status", "TEXT NOT NULL DEFAULT 'success'"), - ("duration_secs", "REAL"), - ]) conn.commit() diff --git a/app/infra/message_history.py b/app/infra/message_history.py index 0f58ad2..aff3e45 100755 --- a/app/infra/message_history.py +++ b/app/infra/message_history.py @@ -23,8 +23,6 @@ def _ensure_db(self): CREATE TABLE IF NOT EXISTS messages ( id INTEGER PRIMARY KEY AUTOINCREMENT, channel text NOT NULL, - dir text, - project text, role TEXT NOT NULL, content TEXT NOT NULL, timestamp TEXT NOT NULL, @@ -35,25 +33,19 @@ def _ensure_db(self): CREATE INDEX IF NOT EXISTS idx_messages_channel ON messages(channel) """) - # migrate existing DBs that don't have est_tokens yet - try: - conn.execute("ALTER TABLE messages ADD COLUMN est_tokens INTEGER") - except sqlite3.OperationalError: - pass # column already exists - conn.commit() except sqlite3.Error as e: log.error(f"Error creating message history database: {str(e)}") raise - def add_message(self, role: str, content: str, dir: str | None = None, project: str | None = None): + def add_message(self, role: str, content: str): timestamp = datetime.now().isoformat() est = _est_tokens(content) with sqlite3.connect(self.db_path) as conn: conn.execute( - "INSERT INTO messages (channel, role, content, timestamp, dir, project, est_tokens) VALUES (?, ?, ?, ?, ?, ?, ?)", - (self.channel, role, content, timestamp, dir, project, est) + "INSERT INTO messages (channel, role, content, timestamp, est_tokens) VALUES (?, ?, ?, ?, ?)", + (self.channel, role, content, timestamp, est) ) conn.commit() log.info(f"Added message to history: role={role}, est_tokens={est}, content={content[:30]}...") diff --git a/app/infra/setup.py b/app/infra/setup.py index 8f95ec6..3a29fec 100755 --- a/app/infra/setup.py +++ b/app/infra/setup.py @@ -28,10 +28,3 @@ def ensure_home_dir() -> None: with open(config_path, "w", encoding="utf-8") as f: f.write(default_config) log.info(f"Created default config.toml in home directory: {config_path}") - - -def migrate_db_path(): - old = Path.home() / f".{APP_NAME}" / "history.db" - if old.exists() and not APP_DB.exists(): - old.rename(APP_DB) - log.info("Migrated database: history.db → app.db") diff --git a/app/main.py b/app/main.py index 1402310..3d85edf 100755 --- a/app/main.py +++ b/app/main.py @@ -7,7 +7,7 @@ from . import config from .infra.app_logging import setup_logging, log -from .infra.setup import ensure_home_dir, migrate_db_path +from .infra.setup import ensure_home_dir from .cli.cli import input_loop from .cli.cli_agent import CliAgent from .bg_server import start_server @@ -94,8 +94,6 @@ async def main(): await load_config() setup_logging(level=logging.INFO) - migrate_db_path() - args = parse_args() runtime.set("model", config.get("model", "deepseek/deepseek-v4-flash")) diff --git a/tests/test_config.py b/tests/test_config.py index be2bdfe..6199877 100644 --- a/tests/test_config.py +++ b/tests/test_config.py @@ -5,7 +5,8 @@ def test_load_uses_defaults_when_file_not_found(tmp_path): - config.load(tmp_path / "missing.toml") + with patch.dict(os.environ, {}, clear=True): + config.load(tmp_path / "missing.toml") assert config.get("model") == "deepseek/deepseek-v4-flash" assert config.get("telegram") == {} From 1fcbbadc94a2981ab161a7333b64a1cd70f6380b Mon Sep 17 00:00:00 2001 From: Claude Date: Sat, 23 May 2026 18:08:46 +0000 Subject: [PATCH 60/84] Add conversation management with persistent named conversations Introduces ConversationStore (SQLite-backed) to track named conversations per channel. Agents now load/save messages scoped to a conversation rather than the flat channel-wide history. A background HelperAgent auto-names new conversations after the first exchange. New slash commands: /list-conversations, /new-conversation, /load-conversation, /fork-conversation, /rename-conversation, /export-conversation, /help. CLI and BackgroundAgent both intercept / commands before forwarding to the agent loop. Unknown / commands return an error instead of being silently swallowed or passed to the LLM. Migration is transaction-safe and re-entrant: existing messages are assigned to a "History" conversation per channel on first boot. /status now shows the active conversation id and name. https://claude.ai/code/session_01AXnJ5ZXdQ9kxzsbjMtNfFH --- app/channels/commands.py | 143 ++++++++++++-- app/channels/discord.py | 4 +- app/channels/telegram.py | 10 +- app/cli/cli_agent.py | 45 ++++- app/core/agent.py | 20 ++ app/core/background_agent.py | 78 +++++++- app/infra/conversations.py | 244 +++++++++++++++++++++++ app/infra/message_history.py | 7 +- app/main.py | 29 ++- tests/test_agent.py | 27 ++- tests/test_background_agent.py | 23 ++- tests/test_conversations.py | 341 +++++++++++++++++++++++++++++++++ 12 files changed, 930 insertions(+), 41 deletions(-) create mode 100644 app/infra/conversations.py create mode 100644 tests/test_conversations.py diff --git a/app/channels/commands.py b/app/channels/commands.py index 176a560..17d1cd2 100644 --- a/app/channels/commands.py +++ b/app/channels/commands.py @@ -3,15 +3,19 @@ import logging from dataclasses import dataclass from datetime import datetime -from typing import Callable, Awaitable +from typing import Callable, Awaitable, TYPE_CHECKING from ..core import runtime +if TYPE_CHECKING: + from ..infra.conversations import ConversationStore + log = logging.getLogger(__name__) CommandHandler = Callable[[str], Awaitable[str]] _STARTUP_TIME: datetime = datetime.now() + @dataclass class BotCommand: name: str @@ -26,7 +30,7 @@ def __init__(self) -> None: def register(self, cmd: BotCommand) -> None: self._commands[cmd.name] = cmd - async def execute(self, name: str, args : str = "") -> str | None: + async def execute(self, name: str, args: str = "") -> str | None: cmd = self._commands.get(name) if cmd is None: return None @@ -41,23 +45,140 @@ def list(self) -> list[BotCommand]: def help_cmd(registry: CommandRegistry) -> CommandHandler: - async def _help(args : str = "") -> str: + async def _help(args: str = "") -> str: lines = ["Available commands:"] for cmd in registry.list(): lines.append(f"/{cmd.name} — {cmd.description}") return "\n".join(lines) return _help + async def model_cmd(args: str = "") -> str: if not args.strip(): return f"Current model: {runtime.get('model', 'unknown')}" - runtime.set("model", args.strip()) return f"Model set to: {args.strip()}" - -async def status_cmd(args: str = "") -> str: - uptime = datetime.now() - _STARTUP_TIME - hours, remainder = divmod(int(uptime.total_seconds()), 3600) - minutes, seconds = divmod(remainder, 60) - model = runtime.get("model", "unknown") - return f"Bot status:\n Model: {model}\n Uptime: {hours}h {minutes}m {seconds}s" + + +def make_status_cmd(channel_str: str = "") -> CommandHandler: + async def _status(args: str = "") -> str: + uptime = datetime.now() - _STARTUP_TIME + hours, remainder = divmod(int(uptime.total_seconds()), 3600) + minutes, seconds = divmod(remainder, 60) + model = runtime.get("model", "unknown") + if channel_str: + conv_id = runtime.get(f"conversation_id:{channel_str}", "—") + conv_name = runtime.get(f"conversation_name:{channel_str}", "—") + else: + conv_id = runtime.get("conversation_id", "—") + conv_name = runtime.get("conversation_name", "—") + return ( + f"Bot status:\n" + f" Model: {model}\n" + f" Uptime: {hours}h {minutes}m {seconds}s\n" + f" Conversation: [{conv_id}] {conv_name}" + ) + return _status + + +# Backward-compatible alias used by existing tests and CLI +status_cmd = make_status_cmd() + + +# --- Conversation management commands --- + +def list_conversations_cmd(store: ConversationStore, channel: str) -> CommandHandler: + async def _list(args: str = "") -> str: + convs = store.list(channel) + if not convs: + return "No conversations yet." + lines = [f"Conversations ({len(convs)}):"] + for c in convs: + lines.append(f" [{c['id']}] {c['name']} — {c['message_count']} messages, updated {c['updated_at'][:16]}") + return "\n".join(lines) + return _list + + +def new_conversation_cmd(agent) -> CommandHandler: + async def _new(args: str = "") -> str: + cid = agent._store.create(agent._channel_str) + conv = agent._store.get(cid) + agent._switch_conversation(conv) + return f"Started new conversation [{conv['id']}] {conv['name']}" + return _new + + +def load_conversation_cmd(agent) -> CommandHandler: + async def _load(args: str = "") -> str: + if not args.strip(): + return "Usage: /load-conversation " + try: + conv_id = int(args.strip()) + except ValueError: + return "Invalid id: must be an integer." + conv = agent._store.get(conv_id) + if conv is None or conv["channel"] != agent._channel_str: + return "Conversation not found or access denied." + agent._switch_conversation(conv) + return f"Loaded conversation [{conv['id']}] {conv['name']} ({agent._store.count_user_messages(conv_id)} messages)" + return _load + + +def fork_conversation_cmd(agent) -> CommandHandler: + async def _fork(args: str = "") -> str: + source_id = agent.conversation_id + if args.strip(): + try: + source_id = int(args.strip()) + except ValueError: + return "Invalid id: must be an integer." + try: + new_id = agent._store.fork(source_id, agent._channel_str) + except ValueError as e: + return str(e) + conv = agent._store.get(new_id) + agent._switch_conversation(conv) + return f"Forked into new conversation [{conv['id']}] {conv['name']}" + return _fork + + +def rename_conversation_cmd(store: ConversationStore, channel: str) -> CommandHandler: + async def _rename(args: str = "") -> str: + parts = args.strip().split(maxsplit=1) + if len(parts) < 2: + return "Usage: /rename-conversation " + try: + conv_id = int(parts[0]) + except ValueError: + return "Invalid id: must be an integer." + new_name = parts[1].strip() + if not new_name: + return "Name cannot be empty." + try: + store.rename(conv_id, new_name, channel) + except ValueError as e: + return str(e) + return f"Conversation [{conv_id}] renamed to \"{new_name[:80]}\"" + return _rename + + +def export_conversation_cmd(store: ConversationStore, channel: str) -> CommandHandler: + async def _export(args: str = "") -> str: + if args.strip(): + try: + conv_id = int(args.strip()) + except ValueError: + return "Invalid id: must be an integer." + else: + if channel: + conv_id = runtime.get(f"conversation_id:{channel}") + else: + conv_id = runtime.get("conversation_id") + if conv_id is None: + return "No active conversation." + try: + path = store.export(conv_id, channel) + except ValueError as e: + return str(e) + return f"Exported to {path}" + return _export diff --git a/app/channels/discord.py b/app/channels/discord.py index 42534af..f4f8f84 100644 --- a/app/channels/discord.py +++ b/app/channels/discord.py @@ -1,7 +1,7 @@ import discord import logging -from .commands import CommandRegistry, BotCommand, status_cmd, help_cmd, model_cmd +from .commands import CommandRegistry, BotCommand, make_status_cmd, help_cmd, model_cmd from .message_queue import MessageQueue from .channel import Channel, ChannelType from .message import OutgoingMessage, IncomingMessage @@ -26,7 +26,7 @@ def __init__(self, mq: MessageQueue, token: str, allow_from: list[int] = None) - mq.register(self, self.send_message) self.registry = CommandRegistry() self.registry.register(BotCommand("model", "Get or set the current model. Usage: /model [model_name]", model_cmd)) - self.registry.register(BotCommand("status", "Show bot status.", status_cmd)) + self.registry.register(BotCommand("status", "Show bot status.", make_status_cmd(ChannelType.DISCORD.value))) self.registry.register(BotCommand("help", "Show this help message.", help_cmd(self.registry))) @property diff --git a/app/channels/telegram.py b/app/channels/telegram.py index 3eb75a0..87d56c9 100755 --- a/app/channels/telegram.py +++ b/app/channels/telegram.py @@ -1,7 +1,7 @@ import asyncio import logging -from .commands import CommandRegistry, BotCommand, status_cmd, help_cmd, model_cmd +from .commands import CommandRegistry, BotCommand, make_status_cmd, help_cmd, model_cmd from .message_queue import MessageQueue from .channel import Channel, ChannelType from .message import OutgoingMessage, IncomingMessage @@ -31,7 +31,7 @@ def __init__( mq.register(self, self.send_message) self.registry = CommandRegistry() self.registry.register(BotCommand("model", "Get or set the LLM model. Usage: /model [name]", model_cmd)) - self.registry.register(BotCommand("status", "Show bot status.", status_cmd)) + self.registry.register(BotCommand("status", "Show bot status.", make_status_cmd(ChannelType.TELEGRAM.value))) self.registry.register(BotCommand("stop", "Pause the bot.", self._stop_cmd)) self.registry.register(BotCommand("help", "Show this help message.", help_cmd(self.registry))) @@ -79,8 +79,12 @@ async def command_handler(self, update: Update, context: ContextTypes.DEFAULT_TY await self.send_message(OutgoingMessage(content=text, channel=ChannelType.TELEGRAM, metadata=metadata)) return reply = await self.registry.execute(cmd_name, args) - if reply: + if reply is not None: await self.send_message(OutgoingMessage(content=reply, channel=ChannelType.TELEGRAM, metadata=metadata)) + else: + await self.mq.incoming.put(IncomingMessage( + content=content, channel=ChannelType.TELEGRAM, metadata=metadata + )) async def send_message(self, message: OutgoingMessage) -> None: # This function is called by the MessageQueue when there is an outgoing message for this channel diff --git a/app/cli/cli_agent.py b/app/cli/cli_agent.py index 48bc433..dbed168 100755 --- a/app/cli/cli_agent.py +++ b/app/cli/cli_agent.py @@ -1,9 +1,13 @@ from __future__ import annotations +import asyncio + from ..core.tool_calls import all_tool_specs from .cli import ask_permission from ..core.agent import Agent, MAX_CONTEXT_MESSAGES, get_default_sys_prompt +from ..core import runtime from ..infra.message_history import MessageHistory +from ..infra.conversations import ConversationStore from ..channels.channel import ChannelType @@ -13,8 +17,26 @@ def __init__(self, max_iterations: int = 250, auto_approve: bool = False, silent super().__init__(max_iterations) self.auto_approve = auto_approve or silent self.silent = silent - self.history = MessageHistory(channel_type=ChannelType.CLI.value) - self.messages.extend(self.history.get_history(limit=MAX_CONTEXT_MESSAGES)) + self._channel_str = ChannelType.CLI.value + + self.history = MessageHistory(channel_type=self._channel_str) + self._store = ConversationStore() + + conv = self._store.get_last(self._channel_str) + if conv is None: + cid = self._store.create(self._channel_str) + conv = self._store.get(cid) + + self.conversation_id: int = conv["id"] + runtime.set("conversation_id", conv["id"]) + runtime.set("conversation_name", conv["name"]) + self.messages.extend(self._store.load_messages(self.conversation_id, limit=MAX_CONTEXT_MESSAGES)) + + def _switch_conversation(self, conv: dict) -> None: + self.conversation_id = conv["id"] + self.messages = self._store.load_messages(conv["id"], limit=MAX_CONTEXT_MESSAGES) + runtime.set("conversation_id", conv["id"]) + runtime.set("conversation_name", conv["name"]) async def _on_thinking(self, content: str | None) -> None: if not self.silent and content and content.strip(): @@ -31,9 +53,14 @@ async def _on_response(self, content: str | None) -> None: async def agent_loop(self, message: str, metadata: dict = None) -> str: self._trim_messages() - self.history.add_message("user", message) + self.history.add_message("user", message, self.conversation_id) - system_context = get_default_sys_prompt({"channel": ChannelType.CLI.value}) + conv = self._store.get(self.conversation_id) + system_context = get_default_sys_prompt({ + "channel": self._channel_str, + "conversation_id": self.conversation_id, + "conversation_name": conv["name"] if conv else "New Conversation", + }) system = [{"role": "system", "content": system_context}] if system_context else [] session_messages = system + self.messages[:] + [{"role": "user", "content": message}] @@ -41,6 +68,14 @@ async def agent_loop(self, message: str, metadata: dict = None) -> str: self.messages.append({"role": "user", "content": message}) self.messages.append({"role": "assistant", "content": final_content}) - self.history.add_message("assistant", final_content) + self.history.add_message("assistant", final_content, self.conversation_id) + self._store.touch(self.conversation_id) + + if self._store.count_user_messages(self.conversation_id) == 1: + conv = self._store.get(self.conversation_id) + if conv and conv["name"] == "New Conversation": + asyncio.create_task( + self._auto_name(self._store, self.conversation_id, list(self.messages), "conversation_name") + ) return final_content diff --git a/app/core/agent.py b/app/core/agent.py index 90c7f16..63479e8 100755 --- a/app/core/agent.py +++ b/app/core/agent.py @@ -93,6 +93,26 @@ def _should_stop(self) -> bool: """Return True to break out of the loop early.""" return False + async def _auto_name(self, store, conv_id: int, messages: list[dict], name_runtime_key: str) -> None: + from .helper_agent import HelperAgent # lazy — helper_agent imports Agent + transcript = "\n".join( + f"{m['role']}: {m['content'][:200]}" for m in messages[:4] + ) + prompt = ( + "Summarize this conversation in 4-6 words as a title. " + "Reply with just the title, nothing else.\n\n" + transcript + ) + try: + name = await HelperAgent().run(prompt) + conv = store.get(conv_id) + if conv and conv["name"] == "New Conversation": + clean = name.strip()[:80] or "New Conversation" + store.rename(conv_id, clean, conv["channel"]) + runtime.set(name_runtime_key, clean) + log.info(f"Auto-named conversation {conv_id}: {clean!r}") + except Exception as e: + log.warning(f"Auto-naming conversation {conv_id} failed: {e}") + # --- shared tool dispatch --- async def handle_tool_call(self, tool_call) -> str: diff --git a/app/core/background_agent.py b/app/core/background_agent.py index 2359224..7e52b97 100755 --- a/app/core/background_agent.py +++ b/app/core/background_agent.py @@ -5,10 +5,11 @@ from .tool_calls import all_tool_specs from ..infra.app_logging import log from ..channels.channel import Channel -from ..channels.message import OutgoingMessage +from ..channels.message import OutgoingMessage, IncomingMessage from ..channels.message_queue import MessageQueue from .agent import Agent, MAX_CONTEXT_MESSAGES, get_default_sys_prompt from ..infra.message_history import MessageHistory +from ..infra.conversations import ConversationStore from . import runtime _MAX_EMPTY_RETRIES = 5 @@ -24,11 +25,46 @@ def __init__(self, mq: MessageQueue = None, channel: Channel = None, max_iterati if self.channel is None: raise ValueError("channel must be specified for BackgroundAgent") - self.history = MessageHistory(channel_type=channel.channel_type.value) - self.messages.extend(self.history.get_history(limit=MAX_CONTEXT_MESSAGES)) + self._channel_str = channel.channel_type.value + self.history = MessageHistory(channel_type=self._channel_str) + self._store = ConversationStore() + + conv = self._store.get_last(self._channel_str) + if conv is None: + cid = self._store.create(self._channel_str) + conv = self._store.get(cid) + + self.conversation_id: int = conv["id"] + runtime.set(f"conversation_id:{self._channel_str}", conv["id"]) + runtime.set(f"conversation_name:{self._channel_str}", conv["name"]) + self.messages.extend(self._store.load_messages(self.conversation_id, limit=MAX_CONTEXT_MESSAGES)) + self._reply_metadata: dict = {} self._empty_retries: int = 0 + # Lazy import to avoid circular: commands imports runtime which is fine, + # but conversation commands need self reference so we build registry here. + from ..channels.commands import ( + CommandRegistry, BotCommand, help_cmd, + list_conversations_cmd, new_conversation_cmd, load_conversation_cmd, + fork_conversation_cmd, rename_conversation_cmd, export_conversation_cmd, + ) + self.registry = CommandRegistry() + ch = self._channel_str + self.registry.register(BotCommand("list-conversations", "List conversations.", list_conversations_cmd(self._store, ch))) + self.registry.register(BotCommand("new-conversation", "Start a new conversation.", new_conversation_cmd(self))) + self.registry.register(BotCommand("load-conversation", "Load a conversation. Usage: /load-conversation ", load_conversation_cmd(self))) + self.registry.register(BotCommand("fork-conversation", "Fork a conversation. Usage: /fork-conversation [id]", fork_conversation_cmd(self))) + self.registry.register(BotCommand("rename-conversation", "Rename a conversation. Usage: /rename-conversation ", rename_conversation_cmd(self._store, ch))) + self.registry.register(BotCommand("export-conversation", "Export a conversation to JSON. Usage: /export-conversation [id]", export_conversation_cmd(self._store, ch))) + self.registry.register(BotCommand("help", "Show available commands.", help_cmd(self.registry))) + + def _switch_conversation(self, conv: dict) -> None: + self.conversation_id = conv["id"] + self.messages = self._store.load_messages(conv["id"], limit=MAX_CONTEXT_MESSAGES) + runtime.set(f"conversation_id:{self._channel_str}", conv["id"]) + runtime.set(f"conversation_name:{self._channel_str}", conv["name"]) + async def _on_thinking(self, content: str | None) -> None: if self.mq and content: text = content.strip().rstrip(":").strip() @@ -61,7 +97,17 @@ async def process_incoming(self) -> None: while True: msg = await self.mq.incoming.get() try: - await self.agent_loop(msg.content, msg.metadata) + if msg.content.startswith("/"): + parts = msg.content[1:].split(maxsplit=1) + cmd_name = parts[0].lower() + args = parts[1] if len(parts) > 1 else "" + result = await self.registry.execute(cmd_name, args) + reply = result if result is not None else f"Unknown command: /{cmd_name}" + await self.mq.outgoing_msg(OutgoingMessage( + content=reply, channel=self.channel, metadata=msg.metadata + )) + else: + await self.agent_loop(msg.content, msg.metadata) except Exception as e: log.error(f"Agent loop error: {e}") await self.mq.outgoing_msg(OutgoingMessage(content=str(e), channel=self.channel, metadata=msg.metadata)) @@ -70,9 +116,14 @@ async def agent_loop(self, message: str, metadata: dict = None) -> str: self._trim_messages() self._empty_retries = 0 self._reply_metadata = metadata or {} - self.history.add_message("user", message) - - system_context = get_default_sys_prompt({"channel" : self.channel.channel_type.value}) + self.history.add_message("user", message, self.conversation_id) + + conv = self._store.get(self.conversation_id) + system_context = get_default_sys_prompt({ + "channel": self._channel_str, + "conversation_id": self.conversation_id, + "conversation_name": conv["name"] if conv else "New Conversation", + }) system = [{"role": "system", "content": system_context}] if system_context else [] session_messages = system + self.messages[:] + [{"role": "user", "content": message}] @@ -82,6 +133,17 @@ async def agent_loop(self, message: str, metadata: dict = None) -> str: self.messages.append({"role": "user", "content": message}) self.messages.append({"role": "assistant", "content": final_content}) - self.history.add_message("assistant", final_content) + self.history.add_message("assistant", final_content, self.conversation_id) + self._store.touch(self.conversation_id) + + if self._store.count_user_messages(self.conversation_id) == 1: + conv = self._store.get(self.conversation_id) + if conv and conv["name"] == "New Conversation": + asyncio.create_task( + self._auto_name( + self._store, self.conversation_id, list(self.messages), + f"conversation_name:{self._channel_str}", + ) + ) return final_content diff --git a/app/infra/conversations.py b/app/infra/conversations.py new file mode 100644 index 0000000..987d753 --- /dev/null +++ b/app/infra/conversations.py @@ -0,0 +1,244 @@ +from __future__ import annotations + +import json +import re +import sqlite3 +from datetime import datetime +from pathlib import Path + +from ..config import APP_DB, PROJECT_HOME +from .app_logging import log + + +def _clean_name(name: str, fallback: str = "New Conversation") -> str: + n = name.strip()[:80] + return n or fallback + + +def _slug(name: str) -> str: + return re.sub(r"[^a-z0-9-]", "", name.lower().replace(" ", "-"))[:40] + + +class ConversationStore: + def __init__(self, db_path: Path = APP_DB): + self.db_path = db_path + self._ensure_schema() + + def _ensure_schema(self) -> None: + now = datetime.now().isoformat() + try: + self.db_path.parent.mkdir(parents=True, exist_ok=True) + with sqlite3.connect(self.db_path) as conn: + conn.execute(""" + CREATE TABLE IF NOT EXISTS conversations ( + id INTEGER PRIMARY KEY AUTOINCREMENT, + name TEXT NOT NULL DEFAULT 'New Conversation', + channel TEXT NOT NULL, + parent_id INTEGER REFERENCES conversations(id), + created_at TEXT NOT NULL, + updated_at TEXT NOT NULL + ) + """) + conn.execute(""" + CREATE INDEX IF NOT EXISTS idx_conversations_channel ON conversations(channel) + """) + + # Ensure messages table exists (MessageHistory may not have run yet) + conn.execute(""" + CREATE TABLE IF NOT EXISTS messages ( + id INTEGER PRIMARY KEY AUTOINCREMENT, + channel TEXT NOT NULL, + role TEXT NOT NULL, + content TEXT NOT NULL, + timestamp TEXT NOT NULL, + est_tokens INTEGER, + conversation_id INTEGER REFERENCES conversations(id) + ) + """) + conn.execute(""" + CREATE INDEX IF NOT EXISTS idx_messages_channel ON messages(channel) + """) + + # Add conversation_id to messages only if that table exists + tables = {row[0] for row in conn.execute( + "SELECT name FROM sqlite_master WHERE type='table'" + )} + if "messages" in tables: + cols = {row[1] for row in conn.execute("PRAGMA table_info(messages)")} + if "conversation_id" not in cols: + conn.execute( + "ALTER TABLE messages ADD COLUMN " + "conversation_id INTEGER REFERENCES conversations(id)" + ) + + # Migration: re-entrant (WHERE conversation_id IS NULL is the guard) + rows = conn.execute( + "SELECT DISTINCT channel FROM messages WHERE conversation_id IS NULL" + ).fetchall() + for (channel,) in rows: + oldest = conn.execute( + "SELECT MIN(timestamp) FROM messages " + "WHERE channel=? AND conversation_id IS NULL", + (channel,), + ).fetchone()[0] or now + cid = conn.execute( + "INSERT INTO conversations (name, channel, created_at, updated_at) " + "VALUES (?,?,?,?)", + ("History", channel, oldest, oldest), + ).lastrowid + conn.execute( + "UPDATE messages SET conversation_id=? " + "WHERE channel=? AND conversation_id IS NULL", + (cid, channel), + ) + + conn.commit() + except sqlite3.Error as e: + log.error(f"ConversationStore schema error: {e}") + raise + + def create(self, channel: str, name: str = "New Conversation", parent_id: int = None) -> int: + clean = _clean_name(name) + now = datetime.now().isoformat() + with sqlite3.connect(self.db_path) as conn: + cid = conn.execute( + "INSERT INTO conversations (name, channel, parent_id, created_at, updated_at) " + "VALUES (?,?,?,?,?)", + (clean, channel, parent_id, now, now), + ).lastrowid + conn.commit() + return cid + + def get(self, conversation_id: int) -> dict | None: + with sqlite3.connect(self.db_path) as conn: + row = conn.execute( + "SELECT id, name, channel, parent_id, created_at, updated_at " + "FROM conversations WHERE id=?", + (conversation_id,), + ).fetchone() + if row is None: + return None + return { + "id": row[0], "name": row[1], "channel": row[2], + "parent_id": row[3], "created_at": row[4], "updated_at": row[5], + } + + def get_last(self, channel: str) -> dict | None: + with sqlite3.connect(self.db_path) as conn: + row = conn.execute( + "SELECT id, name, channel, parent_id, created_at, updated_at " + "FROM conversations WHERE channel=? ORDER BY updated_at DESC, id DESC LIMIT 1", + (channel,), + ).fetchone() + if row is None: + return None + return { + "id": row[0], "name": row[1], "channel": row[2], + "parent_id": row[3], "created_at": row[4], "updated_at": row[5], + } + + def list(self, channel: str) -> list[dict]: + with sqlite3.connect(self.db_path) as conn: + rows = conn.execute( + """SELECT c.id, c.name, c.parent_id, c.created_at, c.updated_at, + COUNT(m.id) as message_count + FROM conversations c + LEFT JOIN messages m ON m.conversation_id = c.id + WHERE c.channel=? + GROUP BY c.id + ORDER BY c.updated_at DESC, c.id DESC""", + (channel,), + ).fetchall() + return [ + {"id": r[0], "name": r[1], "parent_id": r[2], + "created_at": r[3], "updated_at": r[4], "message_count": r[5]} + for r in rows + ] + + def rename(self, conversation_id: int, name: str, channel: str) -> None: + conv = self.get(conversation_id) + if conv is None: + raise ValueError(f"Conversation {conversation_id} not found") + if conv["channel"] != channel: + raise ValueError( + f"Conversation {conversation_id} does not belong to channel {channel!r}" + ) + clean = _clean_name(name) + now = datetime.now().isoformat() + with sqlite3.connect(self.db_path) as conn: + conn.execute( + "UPDATE conversations SET name=?, updated_at=? WHERE id=?", + (clean, now, conversation_id), + ) + conn.commit() + + def touch(self, conversation_id: int) -> None: + now = datetime.now().isoformat() + with sqlite3.connect(self.db_path) as conn: + conn.execute( + "UPDATE conversations SET updated_at=? WHERE id=?", + (now, conversation_id), + ) + conn.commit() + + def fork(self, conversation_id: int, channel: str) -> int: + conv = self.get(conversation_id) + if conv is None: + raise ValueError(f"Conversation {conversation_id} not found") + if conv["channel"] != channel: + raise ValueError( + f"Conversation {conversation_id} does not belong to channel {channel!r}" + ) + now = datetime.now().isoformat() + with sqlite3.connect(self.db_path) as conn: + new_id = conn.execute( + "INSERT INTO conversations (name, channel, parent_id, created_at, updated_at) " + "VALUES (?,?,?,?,?)", + (conv["name"], channel, conversation_id, now, now), + ).lastrowid + conn.execute( + """INSERT INTO messages + (channel, role, content, timestamp, est_tokens, conversation_id) + SELECT ?, role, content, timestamp, est_tokens, ? + FROM messages WHERE conversation_id=? + ORDER BY timestamp ASC, id ASC""", + (channel, new_id, conversation_id), + ) + conn.commit() + return new_id + + def load_messages(self, conversation_id: int, limit: int = 1000) -> list[dict]: + with sqlite3.connect(self.db_path) as conn: + rows = conn.execute( + "SELECT role, content FROM messages WHERE conversation_id=? " + "ORDER BY timestamp ASC, id ASC LIMIT ?", + (conversation_id, limit), + ).fetchall() + return [{"role": row[0], "content": row[1]} for row in rows] + + def count_user_messages(self, conversation_id: int) -> int: + with sqlite3.connect(self.db_path) as conn: + return conn.execute( + "SELECT COUNT(*) FROM messages WHERE conversation_id=? AND role='user'", + (conversation_id,), + ).fetchone()[0] + + def export(self, conversation_id: int, channel: str) -> Path: + conv = self.get(conversation_id) + if conv is None: + raise ValueError(f"Conversation {conversation_id} not found") + if conv["channel"] != channel: + raise ValueError( + f"Conversation {conversation_id} does not belong to channel {channel!r}" + ) + messages = self.load_messages(conversation_id) + payload = {**conv, "messages": messages} + + export_dir = PROJECT_HOME / "conversations" + export_dir.mkdir(parents=True, exist_ok=True) + slug = _slug(conv["name"]) or "conversation" + filename = f"{conversation_id}-{slug}.json" + path = export_dir / filename + with open(path, "w", encoding="utf-8") as f: + json.dump(payload, f, indent=2, ensure_ascii=False) + return path diff --git a/app/infra/message_history.py b/app/infra/message_history.py index aff3e45..b79a896 100755 --- a/app/infra/message_history.py +++ b/app/infra/message_history.py @@ -39,13 +39,14 @@ def _ensure_db(self): log.error(f"Error creating message history database: {str(e)}") raise - def add_message(self, role: str, content: str): + def add_message(self, role: str, content: str, conversation_id: int = None): timestamp = datetime.now().isoformat() est = _est_tokens(content) with sqlite3.connect(self.db_path) as conn: conn.execute( - "INSERT INTO messages (channel, role, content, timestamp, est_tokens) VALUES (?, ?, ?, ?, ?)", - (self.channel, role, content, timestamp, est) + "INSERT INTO messages (channel, role, content, timestamp, est_tokens, conversation_id) " + "VALUES (?, ?, ?, ?, ?, ?)", + (self.channel, role, content, timestamp, est, conversation_id), ) conn.commit() log.info(f"Added message to history: role={role}, est_tokens={est}, content={content[:30]}...") diff --git a/app/main.py b/app/main.py index 3d85edf..6c2c2ed 100755 --- a/app/main.py +++ b/app/main.py @@ -62,20 +62,43 @@ async def run_cli(args): log.setLevel(logging.WARNING) log.info("Starting agent...") - agent = CliAgent(auto_approve=args.auto_approve or args.silent, + agent = CliAgent(auto_approve=args.auto_approve or args.silent, max_iterations=runtime.get("max_iterations", 250), silent=args.silent) if args.prompt: await agent.agent_loop(args.prompt) elif not (args.no_repl or args.silent): print("Starting interactive session. Type your prompts below. Press Ctrl+C to exit.") - + if args.no_repl or args.silent: return + from .channels.commands import ( + CommandRegistry, BotCommand, make_status_cmd, help_cmd, model_cmd, + list_conversations_cmd, new_conversation_cmd, load_conversation_cmd, + fork_conversation_cmd, rename_conversation_cmd, export_conversation_cmd, + ) + cli_registry = CommandRegistry() + cli_registry.register(BotCommand("status", "Show bot status.", make_status_cmd())) + cli_registry.register(BotCommand("model", "Get or set model. Usage: /model [name]", model_cmd)) + cli_registry.register(BotCommand("list-conversations", "List conversations.", list_conversations_cmd(agent._store, agent._channel_str))) + cli_registry.register(BotCommand("new-conversation", "Start a new conversation.", new_conversation_cmd(agent))) + cli_registry.register(BotCommand("load-conversation", "Load a conversation. Usage: /load-conversation ", load_conversation_cmd(agent))) + cli_registry.register(BotCommand("fork-conversation", "Fork a conversation. Usage: /fork-conversation [id]", fork_conversation_cmd(agent))) + cli_registry.register(BotCommand("rename-conversation", "Rename a conversation. Usage: /rename-conversation ", rename_conversation_cmd(agent._store, agent._channel_str))) + cli_registry.register(BotCommand("export-conversation", "Export a conversation to JSON. Usage: /export-conversation [id]", export_conversation_cmd(agent._store, agent._channel_str))) + cli_registry.register(BotCommand("help", "Show available commands.", help_cmd(cli_registry))) + try: async for user_input in input_loop(): - await agent.agent_loop(user_input) + if user_input.startswith("/"): + parts = user_input[1:].split(maxsplit=1) + cmd_name = parts[0].lower() + cmd_args = parts[1] if len(parts) > 1 else "" + result = await cli_registry.execute(cmd_name, cmd_args) + print(result if result is not None else f"Unknown command: /{cmd_name}") + else: + await agent.agent_loop(user_input) except KeyboardInterrupt: log.info("Exiting...") os._exit(0) diff --git a/tests/test_agent.py b/tests/test_agent.py index 6da0e2d..4cd818f 100644 --- a/tests/test_agent.py +++ b/tests/test_agent.py @@ -25,6 +25,10 @@ def make_mock_client(tool_calls=None, content="Hello!", finish_reason="stop"): return mock_client +_MOCK_CONV = {"id": 1, "name": "Test Conv", "channel": "cli", + "parent_id": None, "created_at": "2024-01-01", "updated_at": "2024-01-01"} + + def make_agent(auto_approve=True, silent=True, max_iterations=10): with patch("app.core.agent.Client") as MockClient: mock_openai = make_mock_client() @@ -32,9 +36,14 @@ def make_agent(auto_approve=True, silent=True, max_iterations=10): with patch("app.cli.cli_agent.get_default_sys_prompt", return_value="You are a helpful assistant."): with patch("app.cli.cli_agent.MessageHistory") as MockHistory: MockHistory.return_value.get_history.return_value = [] - agent = Agent( - auto_approve=auto_approve, silent=silent, max_iterations=max_iterations - ) + with patch("app.cli.cli_agent.ConversationStore") as MockStore: + MockStore.return_value.get_last.return_value = _MOCK_CONV + MockStore.return_value.get.return_value = _MOCK_CONV + MockStore.return_value.load_messages.return_value = [] + MockStore.return_value.count_user_messages.return_value = 0 + agent = Agent( + auto_approve=auto_approve, silent=silent, max_iterations=max_iterations + ) # Attach the mock client so callers can reconfigure it after construction agent.client = mock_openai return agent, mock_openai @@ -42,10 +51,20 @@ def make_agent(auto_approve=True, silent=True, max_iterations=10): @pytest.fixture(autouse=True) def patch_config(): - with patch.object(config, "_config", {"agent": {"model": "test-model"}}): + with patch.object(config, "_config", {"agent": {"model": "test-model"}}): yield +@pytest.fixture(autouse=True) +def patch_store(): + with patch("app.cli.cli_agent.ConversationStore") as MockStore: + MockStore.return_value.get_last.return_value = _MOCK_CONV + MockStore.return_value.get.return_value = _MOCK_CONV + MockStore.return_value.load_messages.return_value = [] + MockStore.return_value.count_user_messages.return_value = 0 + yield MockStore + + @pytest.mark.asyncio async def test_agent_loop_sends_system_context_to_llm(): agent, mock_client = make_agent() diff --git a/tests/test_background_agent.py b/tests/test_background_agent.py index 1b3e0df..608e2cd 100644 --- a/tests/test_background_agent.py +++ b/tests/test_background_agent.py @@ -31,6 +31,10 @@ def make_mock_client(tool_calls=None, content="Hello!", finish_reason="stop"): return mock_client +_MOCK_CONV = {"id": 1, "name": "Test Conv", "channel": "telegram", + "parent_id": None, "created_at": "2024-01-01", "updated_at": "2024-01-01"} + + def make_agent(max_iterations=10): mq = MessageQueue() with patch("app.core.agent.Client") as MockClient: @@ -39,7 +43,12 @@ def make_agent(max_iterations=10): with patch("app.core.background_agent.get_default_sys_prompt", return_value="You are a helpful assistant."): with patch("app.core.background_agent.MessageHistory") as MockHistory: MockHistory.return_value.get_history.return_value = [] - agent = BackgroundAgent(mq=mq, channel=_mock_channel, max_iterations=max_iterations) + with patch("app.core.background_agent.ConversationStore") as MockStore: + MockStore.return_value.get_last.return_value = _MOCK_CONV + MockStore.return_value.get.return_value = _MOCK_CONV + MockStore.return_value.load_messages.return_value = [] + MockStore.return_value.count_user_messages.return_value = 0 + agent = BackgroundAgent(mq=mq, channel=_mock_channel, max_iterations=max_iterations) agent.client = mock_openai return agent, mock_openai, mq @@ -50,6 +59,16 @@ def patch_config(): yield +@pytest.fixture(autouse=True) +def patch_store(): + with patch("app.core.background_agent.ConversationStore") as MockStore: + MockStore.return_value.get_last.return_value = _MOCK_CONV + MockStore.return_value.get.return_value = _MOCK_CONV + MockStore.return_value.load_messages.return_value = [] + MockStore.return_value.count_user_messages.return_value = 0 + yield MockStore + + def test_agent_initializes_with_empty_messages(): agent, _, _ = make_agent() assert len(agent.messages) == 0 @@ -88,7 +107,7 @@ async def test_agent_loop_adds_user_message(): async def test_agent_loop_appends_assistant_message(): agent, _, _ = make_agent() await agent.agent_loop("Hello") - agent.history.add_message.assert_called_with("assistant", "Hello!") + agent.history.add_message.assert_called_with("assistant", "Hello!", agent.conversation_id) assert agent.messages[-1]["content"] == "Hello!" diff --git a/tests/test_conversations.py b/tests/test_conversations.py new file mode 100644 index 0000000..b2a28b0 --- /dev/null +++ b/tests/test_conversations.py @@ -0,0 +1,341 @@ +"""Tests for ConversationStore.""" +from __future__ import annotations + +import asyncio +import sqlite3 +import pytest +from pathlib import Path +from unittest.mock import patch, MagicMock, AsyncMock + +from app.infra.conversations import ConversationStore + + +@pytest.fixture +def db(tmp_path) -> Path: + return tmp_path / "test.db" + + +@pytest.fixture +def store(db) -> ConversationStore: + return ConversationStore(db_path=db) + + +# --- Schema idempotency --- + +def test_ensure_schema_idempotent(db): + ConversationStore(db_path=db) + # Second call must not raise + ConversationStore(db_path=db) + + +def test_conversations_table_created(store, db): + with sqlite3.connect(db) as conn: + tables = {r[0] for r in conn.execute("SELECT name FROM sqlite_master WHERE type='table'")} + assert "conversations" in tables + + +# --- create / get --- + +def test_create_returns_integer_id(store): + cid = store.create("cli") + assert isinstance(cid, int) + assert cid > 0 + + +def test_get_returns_correct_fields(store): + cid = store.create("cli", "My Conv") + conv = store.get(cid) + assert conv["id"] == cid + assert conv["name"] == "My Conv" + assert conv["channel"] == "cli" + assert conv["parent_id"] is None + + +def test_get_returns_none_for_missing(store): + assert store.get(9999) is None + + +def test_create_trims_and_caps_name(store): + long_name = "x" * 100 + cid = store.create("cli", " " + long_name + " ") + conv = store.get(cid) + assert len(conv["name"]) == 80 + assert not conv["name"].startswith(" ") + + +def test_create_falls_back_for_empty_name(store): + cid = store.create("cli", " ") + conv = store.get(cid) + assert conv["name"] == "New Conversation" + + +# --- get_last --- + +def test_get_last_returns_none_when_empty(store): + assert store.get_last("cli") is None + + +def test_get_last_returns_most_recently_updated(store): + cid1 = store.create("cli", "First") + import time; time.sleep(0.01) + cid2 = store.create("cli", "Second") + store.touch(cid2) + last = store.get_last("cli") + assert last["id"] == cid2 + + +def test_get_last_respects_channel(store): + cid = store.create("cli", "CLI conv") + store.create("telegram", "TG conv") + last = store.get_last("cli") + assert last["id"] == cid + + +# --- list --- + +def test_list_returns_all_for_channel(store): + store.create("cli", "A") + store.create("cli", "B") + store.create("telegram", "T") + convs = store.list("cli") + assert len(convs) == 2 + names = {c["name"] for c in convs} + assert names == {"A", "B"} + + +def test_list_includes_message_count(store, db): + cid = store.create("cli", "With messages") + with sqlite3.connect(db) as conn: + conn.execute(""" + CREATE TABLE IF NOT EXISTS messages ( + id INTEGER PRIMARY KEY AUTOINCREMENT, + channel TEXT, role TEXT, content TEXT, + timestamp TEXT, est_tokens INTEGER, conversation_id INTEGER + ) + """) + conn.execute( + "INSERT INTO messages (channel, role, content, timestamp, conversation_id) VALUES (?,?,?,?,?)", + ("cli", "user", "hello", "2024-01-01T00:00:00", cid), + ) + conn.commit() + convs = store.list("cli") + assert convs[0]["message_count"] == 1 + + +# --- rename --- + +def test_rename_updates_name(store): + cid = store.create("cli", "Old Name") + store.rename(cid, "New Name", "cli") + assert store.get(cid)["name"] == "New Name" + + +def test_rename_rejects_cross_channel(store): + cid = store.create("cli", "My Conv") + with pytest.raises(ValueError, match="does not belong"): + store.rename(cid, "Other", "telegram") + + +def test_rename_rejects_missing_conversation(store): + with pytest.raises(ValueError, match="not found"): + store.rename(9999, "Name", "cli") + + +# --- fork --- + +def _setup_messages(db: Path, channel: str, conv_id: int, count: int = 2): + with sqlite3.connect(db) as conn: + conn.execute(""" + CREATE TABLE IF NOT EXISTS messages ( + id INTEGER PRIMARY KEY AUTOINCREMENT, + channel TEXT, role TEXT, content TEXT, + timestamp TEXT, est_tokens INTEGER, conversation_id INTEGER + ) + """) + for i in range(count): + conn.execute( + "INSERT INTO messages (channel, role, content, timestamp, est_tokens, conversation_id) " + "VALUES (?,?,?,?,?,?)", + (channel, "user", f"msg{i}", f"2024-01-01T00:00:0{i}", 1, conv_id), + ) + conn.commit() + + +def test_fork_creates_new_conversation(store, db): + cid = store.create("cli", "Source") + _setup_messages(db, "cli", cid, 2) + new_id = store.fork(cid, "cli") + assert new_id != cid + assert store.get(new_id)["parent_id"] == cid + + +def test_fork_copies_messages_with_new_channel(store, db): + cid = store.create("cli", "Source") + _setup_messages(db, "cli", cid, 2) + new_id = store.fork(cid, "cli") + msgs = store.load_messages(new_id) + assert len(msgs) == 2 + # Verify messages are stored with the new channel + with sqlite3.connect(db) as conn: + rows = conn.execute( + "SELECT channel FROM messages WHERE conversation_id=?", (new_id,) + ).fetchall() + assert all(r[0] == "cli" for r in rows) + + +def test_fork_rejects_cross_channel(store): + cid = store.create("cli") + with pytest.raises(ValueError, match="does not belong"): + store.fork(cid, "telegram") + + +def test_fork_rejects_missing_conversation(store): + with pytest.raises(ValueError, match="not found"): + store.fork(9999, "cli") + + +# --- load_messages ordering --- + +def test_load_messages_ordered_by_timestamp_then_id(store, db): + cid = store.create("cli") + with sqlite3.connect(db) as conn: + conn.execute(""" + CREATE TABLE IF NOT EXISTS messages ( + id INTEGER PRIMARY KEY AUTOINCREMENT, + channel TEXT, role TEXT, content TEXT, + timestamp TEXT, est_tokens INTEGER, conversation_id INTEGER + ) + """) + conn.execute( + "INSERT INTO messages (channel, role, content, timestamp, conversation_id) VALUES (?,?,?,?,?)", + ("cli", "user", "second", "2024-01-01T00:00:02", cid), + ) + conn.execute( + "INSERT INTO messages (channel, role, content, timestamp, conversation_id) VALUES (?,?,?,?,?)", + ("cli", "user", "first", "2024-01-01T00:00:01", cid), + ) + conn.commit() + msgs = store.load_messages(cid) + assert msgs[0]["content"] == "first" + assert msgs[1]["content"] == "second" + + +# --- count_user_messages --- + +def test_count_user_messages(store, db): + cid = store.create("cli") + with sqlite3.connect(db) as conn: + conn.execute(""" + CREATE TABLE IF NOT EXISTS messages ( + id INTEGER PRIMARY KEY AUTOINCREMENT, + channel TEXT, role TEXT, content TEXT, + timestamp TEXT, est_tokens INTEGER, conversation_id INTEGER + ) + """) + conn.execute( + "INSERT INTO messages (channel, role, content, timestamp, conversation_id) VALUES (?,?,?,?,?)", + ("cli", "user", "hello", "2024-01-01T00:00:00", cid), + ) + conn.execute( + "INSERT INTO messages (channel, role, content, timestamp, conversation_id) VALUES (?,?,?,?,?)", + ("cli", "assistant", "hi", "2024-01-01T00:00:01", cid), + ) + conn.commit() + assert store.count_user_messages(cid) == 1 + + +# --- Migration --- + +def test_migration_assigns_existing_messages(db): + # Seed the db with messages table and no conversation_id column + with sqlite3.connect(db) as conn: + conn.execute(""" + CREATE TABLE messages ( + id INTEGER PRIMARY KEY AUTOINCREMENT, + channel TEXT, role TEXT, content TEXT, + timestamp TEXT, est_tokens INTEGER + ) + """) + conn.execute( + "INSERT INTO messages (channel, role, content, timestamp) VALUES (?,?,?,?)", + ("cli", "user", "old message", "2024-01-01T00:00:00"), + ) + conn.commit() + + store = ConversationStore(db_path=db) + + # Migration should have created a "History" conversation and linked messages + convs = store.list("cli") + assert len(convs) == 1 + assert convs[0]["name"] == "History" + msgs = store.load_messages(convs[0]["id"]) + assert len(msgs) == 1 + assert msgs[0]["content"] == "old message" + + +def test_migration_is_reentrant(db): + with sqlite3.connect(db) as conn: + conn.execute(""" + CREATE TABLE messages ( + id INTEGER PRIMARY KEY AUTOINCREMENT, + channel TEXT, role TEXT, content TEXT, + timestamp TEXT, est_tokens INTEGER + ) + """) + conn.execute( + "INSERT INTO messages (channel, role, content, timestamp) VALUES (?,?,?,?)", + ("cli", "user", "hello", "2024-01-01T00:00:00"), + ) + conn.commit() + + ConversationStore(db_path=db) + # Second init: migration WHERE conversation_id IS NULL finds nothing → no duplicate + ConversationStore(db_path=db) + + with sqlite3.connect(db) as conn: + count = conn.execute("SELECT COUNT(*) FROM conversations").fetchone()[0] + assert count == 1 + + +# --- Auto-name guard --- + +@pytest.mark.asyncio +async def test_auto_name_does_not_overwrite_manual_rename(store): + cid = store.create("cli", "New Conversation") + + # Simulate manual rename before auto-name fires + store.rename(cid, "My Manual Name", "cli") + + mock_helper_instance = AsyncMock() + mock_helper_instance.run = AsyncMock(return_value="Auto Title") + + with patch("app.core.helper_agent.HelperAgent", return_value=mock_helper_instance): + from app.core.agent import Agent + agent_stub = MagicMock(spec=[]) # _auto_name doesn't use self + from app.core import runtime + await Agent._auto_name(agent_stub, store, cid, [], "conversation_name") + + # Name should still be the manually set name + assert store.get(cid)["name"] == "My Manual Name" + + +# --- Export --- + +def test_export_writes_json(store, db, tmp_path): + cid = store.create("cli", "Test Export") + from app import config + with patch.object(config, "PROJECT_HOME", tmp_path): + from app.infra import conversations + with patch.object(conversations, "PROJECT_HOME", tmp_path): + path = store.export(cid, "cli") + assert path.exists() + import json + data = json.loads(path.read_text()) + assert data["name"] == "Test Export" + assert data["channel"] == "cli" + + +def test_export_rejects_cross_channel(store): + cid = store.create("cli") + with pytest.raises(ValueError, match="does not belong"): + store.export(cid, "telegram") From a1dee4aee835be18c59dadce5fc2f3549d48aab9 Mon Sep 17 00:00:00 2001 From: Claude Date: Sat, 23 May 2026 19:08:06 +0000 Subject: [PATCH 61/84] Address PR review: FK enforcement, index, typing, lint fixes - Enable PRAGMA foreign_keys = ON on all sqlite3 connections via _fk_conn helper; use BEGIN IMMEDIATE for the migration phase to prevent race conditions when two processes start simultaneously - Add idx_messages_conversation_id index (improves load_messages, list join, count_user_messages, fork queries) - MessageHistory._ensure_db() now adds conversation_id column if missing so it stays self-consistent without requiring ConversationStore to run first - get_default_sys_prompt() renders conversation_id and conversation_name in the system context block so the LLM is aware of the active conversation - Add ConversationAgent Protocol in commands.py for type-safe agent parameter - Fix load_conversation_cmd success message to report total message count (not user-only count) by reading from the list() result - Remove unused IncomingMessage import from background_agent.py - test_conversations: remove unused asyncio/runtime imports, replace time.sleep with deterministic timestamp pinning https://claude.ai/code/session_01AXnJ5ZXdQ9kxzsbjMtNfFH --- app/channels/commands.py | 21 ++++-- app/core/agent.py | 6 +- app/core/background_agent.py | 2 +- app/infra/conversations.py | 134 ++++++++++++++++++++--------------- app/infra/message_history.py | 8 ++- tests/test_conversations.py | 12 ++-- 6 files changed, 113 insertions(+), 70 deletions(-) diff --git a/app/channels/commands.py b/app/channels/commands.py index 17d1cd2..19dc709 100644 --- a/app/channels/commands.py +++ b/app/channels/commands.py @@ -3,12 +3,21 @@ import logging from dataclasses import dataclass from datetime import datetime -from typing import Callable, Awaitable, TYPE_CHECKING +from typing import Any, Callable, Awaitable, Protocol, TYPE_CHECKING from ..core import runtime if TYPE_CHECKING: from ..infra.conversations import ConversationStore + +class ConversationAgent(Protocol): + """Structural type for agents that support conversation management.""" + _store: Any # ConversationStore + _channel_str: str + conversation_id: int + + def _switch_conversation(self, conv: dict) -> None: ... + log = logging.getLogger(__name__) CommandHandler = Callable[[str], Awaitable[str]] @@ -99,7 +108,7 @@ async def _list(args: str = "") -> str: return _list -def new_conversation_cmd(agent) -> CommandHandler: +def new_conversation_cmd(agent: ConversationAgent) -> CommandHandler: async def _new(args: str = "") -> str: cid = agent._store.create(agent._channel_str) conv = agent._store.get(cid) @@ -108,7 +117,7 @@ async def _new(args: str = "") -> str: return _new -def load_conversation_cmd(agent) -> CommandHandler: +def load_conversation_cmd(agent: ConversationAgent) -> CommandHandler: async def _load(args: str = "") -> str: if not args.strip(): return "Usage: /load-conversation " @@ -120,11 +129,13 @@ async def _load(args: str = "") -> str: if conv is None or conv["channel"] != agent._channel_str: return "Conversation not found or access denied." agent._switch_conversation(conv) - return f"Loaded conversation [{conv['id']}] {conv['name']} ({agent._store.count_user_messages(conv_id)} messages)" + convs = agent._store.list(agent._channel_str) + msg_count = next((c["message_count"] for c in convs if c["id"] == conv_id), 0) + return f"Loaded conversation [{conv['id']}] {conv['name']} ({msg_count} messages)" return _load -def fork_conversation_cmd(agent) -> CommandHandler: +def fork_conversation_cmd(agent: ConversationAgent) -> CommandHandler: async def _fork(args: str = "") -> str: source_id = agent.conversation_id if args.strip(): diff --git a/app/core/agent.py b/app/core/agent.py index 63479e8..114c954 100755 --- a/app/core/agent.py +++ b/app/core/agent.py @@ -29,6 +29,10 @@ def get_default_sys_prompt(context: dict | None = None) -> str: except Exception as e: log.error(f"Error loading system prompt: {e}") + conv_id = ctx.get("conversation_id", "") + conv_name = ctx.get("conversation_name", "") + conv_line = f"\n- Conversation: [{conv_id}] {conv_name}" if conv_id else "" + sys_prompt += f""" ## Current System Context @@ -41,7 +45,7 @@ def get_default_sys_prompt(context: dict | None = None) -> str: - workspace: {config.PROJECT_HOME / "workspace"} - Python: {platform.python_version()} - Starting LLM Model: {runtime.get("model", "unknown")} -- Current Channel: {channel} +- Current Channel: {channel}{conv_line} """ log.info(f"Loaded system prompt: {len(sys_prompt)} characters") diff --git a/app/core/background_agent.py b/app/core/background_agent.py index 7e52b97..2fef6c4 100755 --- a/app/core/background_agent.py +++ b/app/core/background_agent.py @@ -5,7 +5,7 @@ from .tool_calls import all_tool_specs from ..infra.app_logging import log from ..channels.channel import Channel -from ..channels.message import OutgoingMessage, IncomingMessage +from ..channels.message import OutgoingMessage from ..channels.message_queue import MessageQueue from .agent import Agent, MAX_CONTEXT_MESSAGES, get_default_sys_prompt from ..infra.message_history import MessageHistory diff --git a/app/infra/conversations.py b/app/infra/conversations.py index 987d753..66b8b52 100644 --- a/app/infra/conversations.py +++ b/app/infra/conversations.py @@ -1,5 +1,6 @@ from __future__ import annotations +import contextlib import json import re import sqlite3 @@ -19,6 +20,14 @@ def _slug(name: str) -> str: return re.sub(r"[^a-z0-9-]", "", name.lower().replace(" ", "-"))[:40] +@contextlib.contextmanager +def _fk_conn(db_path: Path): + """sqlite3 connection with FK constraints enforced.""" + with sqlite3.connect(db_path) as conn: + conn.execute("PRAGMA foreign_keys = ON") + yield conn + + class ConversationStore: def __init__(self, db_path: Path = APP_DB): self.db_path = db_path @@ -28,7 +37,9 @@ def _ensure_schema(self) -> None: now = datetime.now().isoformat() try: self.db_path.parent.mkdir(parents=True, exist_ok=True) - with sqlite3.connect(self.db_path) as conn: + + # Phase 1: DDL — idempotent CREATE TABLE/INDEX and optional ALTER TABLE + with _fk_conn(self.db_path) as conn: conn.execute(""" CREATE TABLE IF NOT EXISTS conversations ( id INTEGER PRIMARY KEY AUTOINCREMENT, @@ -40,59 +51,72 @@ def _ensure_schema(self) -> None: ) """) conn.execute(""" - CREATE INDEX IF NOT EXISTS idx_conversations_channel ON conversations(channel) + CREATE INDEX IF NOT EXISTS idx_conversations_channel + ON conversations(channel) """) - # Ensure messages table exists (MessageHistory may not have run yet) conn.execute(""" CREATE TABLE IF NOT EXISTS messages ( - id INTEGER PRIMARY KEY AUTOINCREMENT, - channel TEXT NOT NULL, - role TEXT NOT NULL, - content TEXT NOT NULL, - timestamp TEXT NOT NULL, - est_tokens INTEGER, + id INTEGER PRIMARY KEY AUTOINCREMENT, + channel TEXT NOT NULL, + role TEXT NOT NULL, + content TEXT NOT NULL, + timestamp TEXT NOT NULL, + est_tokens INTEGER, conversation_id INTEGER REFERENCES conversations(id) ) """) conn.execute(""" - CREATE INDEX IF NOT EXISTS idx_messages_channel ON messages(channel) + CREATE INDEX IF NOT EXISTS idx_messages_channel + ON messages(channel) """) + # Guard: ALTER TABLE is not idempotent in SQLite; add index after column exists + cols = {row[1] for row in conn.execute("PRAGMA table_info(messages)")} + if "conversation_id" not in cols: + conn.execute( + "ALTER TABLE messages ADD COLUMN " + "conversation_id INTEGER REFERENCES conversations(id)" + ) + conn.execute(""" + CREATE INDEX IF NOT EXISTS idx_messages_conversation_id + ON messages(conversation_id) + """) + + # Phase 2: Migration — BEGIN IMMEDIATE for concurrency safety. + # The WHERE conversation_id IS NULL guard makes this re-entrant. + mconn = sqlite3.connect(self.db_path, isolation_level=None) + try: + mconn.execute("PRAGMA foreign_keys = ON") + mconn.execute("BEGIN IMMEDIATE") + rows = mconn.execute( + "SELECT DISTINCT channel FROM messages WHERE conversation_id IS NULL" + ).fetchall() + for (channel,) in rows: + oldest = mconn.execute( + "SELECT MIN(timestamp) FROM messages " + "WHERE channel=? AND conversation_id IS NULL", + (channel,), + ).fetchone()[0] or now + cid = mconn.execute( + "INSERT INTO conversations (name, channel, created_at, updated_at) " + "VALUES (?,?,?,?)", + ("History", channel, oldest, oldest), + ).lastrowid + mconn.execute( + "UPDATE messages SET conversation_id=? " + "WHERE channel=? AND conversation_id IS NULL", + (cid, channel), + ) + mconn.execute("COMMIT") + except Exception: + try: + mconn.execute("ROLLBACK") + except Exception: + pass + raise + finally: + mconn.close() - # Add conversation_id to messages only if that table exists - tables = {row[0] for row in conn.execute( - "SELECT name FROM sqlite_master WHERE type='table'" - )} - if "messages" in tables: - cols = {row[1] for row in conn.execute("PRAGMA table_info(messages)")} - if "conversation_id" not in cols: - conn.execute( - "ALTER TABLE messages ADD COLUMN " - "conversation_id INTEGER REFERENCES conversations(id)" - ) - - # Migration: re-entrant (WHERE conversation_id IS NULL is the guard) - rows = conn.execute( - "SELECT DISTINCT channel FROM messages WHERE conversation_id IS NULL" - ).fetchall() - for (channel,) in rows: - oldest = conn.execute( - "SELECT MIN(timestamp) FROM messages " - "WHERE channel=? AND conversation_id IS NULL", - (channel,), - ).fetchone()[0] or now - cid = conn.execute( - "INSERT INTO conversations (name, channel, created_at, updated_at) " - "VALUES (?,?,?,?)", - ("History", channel, oldest, oldest), - ).lastrowid - conn.execute( - "UPDATE messages SET conversation_id=? " - "WHERE channel=? AND conversation_id IS NULL", - (cid, channel), - ) - - conn.commit() except sqlite3.Error as e: log.error(f"ConversationStore schema error: {e}") raise @@ -100,17 +124,16 @@ def _ensure_schema(self) -> None: def create(self, channel: str, name: str = "New Conversation", parent_id: int = None) -> int: clean = _clean_name(name) now = datetime.now().isoformat() - with sqlite3.connect(self.db_path) as conn: + with _fk_conn(self.db_path) as conn: cid = conn.execute( "INSERT INTO conversations (name, channel, parent_id, created_at, updated_at) " "VALUES (?,?,?,?,?)", (clean, channel, parent_id, now, now), ).lastrowid - conn.commit() return cid def get(self, conversation_id: int) -> dict | None: - with sqlite3.connect(self.db_path) as conn: + with _fk_conn(self.db_path) as conn: row = conn.execute( "SELECT id, name, channel, parent_id, created_at, updated_at " "FROM conversations WHERE id=?", @@ -124,7 +147,7 @@ def get(self, conversation_id: int) -> dict | None: } def get_last(self, channel: str) -> dict | None: - with sqlite3.connect(self.db_path) as conn: + with _fk_conn(self.db_path) as conn: row = conn.execute( "SELECT id, name, channel, parent_id, created_at, updated_at " "FROM conversations WHERE channel=? ORDER BY updated_at DESC, id DESC LIMIT 1", @@ -138,7 +161,7 @@ def get_last(self, channel: str) -> dict | None: } def list(self, channel: str) -> list[dict]: - with sqlite3.connect(self.db_path) as conn: + with _fk_conn(self.db_path) as conn: rows = conn.execute( """SELECT c.id, c.name, c.parent_id, c.created_at, c.updated_at, COUNT(m.id) as message_count @@ -165,21 +188,19 @@ def rename(self, conversation_id: int, name: str, channel: str) -> None: ) clean = _clean_name(name) now = datetime.now().isoformat() - with sqlite3.connect(self.db_path) as conn: + with _fk_conn(self.db_path) as conn: conn.execute( "UPDATE conversations SET name=?, updated_at=? WHERE id=?", (clean, now, conversation_id), ) - conn.commit() def touch(self, conversation_id: int) -> None: now = datetime.now().isoformat() - with sqlite3.connect(self.db_path) as conn: + with _fk_conn(self.db_path) as conn: conn.execute( "UPDATE conversations SET updated_at=? WHERE id=?", (now, conversation_id), ) - conn.commit() def fork(self, conversation_id: int, channel: str) -> int: conv = self.get(conversation_id) @@ -190,7 +211,7 @@ def fork(self, conversation_id: int, channel: str) -> int: f"Conversation {conversation_id} does not belong to channel {channel!r}" ) now = datetime.now().isoformat() - with sqlite3.connect(self.db_path) as conn: + with _fk_conn(self.db_path) as conn: new_id = conn.execute( "INSERT INTO conversations (name, channel, parent_id, created_at, updated_at) " "VALUES (?,?,?,?,?)", @@ -204,11 +225,10 @@ def fork(self, conversation_id: int, channel: str) -> int: ORDER BY timestamp ASC, id ASC""", (channel, new_id, conversation_id), ) - conn.commit() return new_id def load_messages(self, conversation_id: int, limit: int = 1000) -> list[dict]: - with sqlite3.connect(self.db_path) as conn: + with _fk_conn(self.db_path) as conn: rows = conn.execute( "SELECT role, content FROM messages WHERE conversation_id=? " "ORDER BY timestamp ASC, id ASC LIMIT ?", @@ -217,7 +237,7 @@ def load_messages(self, conversation_id: int, limit: int = 1000) -> list[dict]: return [{"role": row[0], "content": row[1]} for row in rows] def count_user_messages(self, conversation_id: int) -> int: - with sqlite3.connect(self.db_path) as conn: + with _fk_conn(self.db_path) as conn: return conn.execute( "SELECT COUNT(*) FROM messages WHERE conversation_id=? AND role='user'", (conversation_id,), diff --git a/app/infra/message_history.py b/app/infra/message_history.py index b79a896..12a3471 100755 --- a/app/infra/message_history.py +++ b/app/infra/message_history.py @@ -32,7 +32,13 @@ def _ensure_db(self): conn.execute(""" CREATE INDEX IF NOT EXISTS idx_messages_channel ON messages(channel) """) - + # Add conversation_id if missing (ConversationStore adds it too, + # but MessageHistory must be self-consistent for standalone use) + cols = {row[1] for row in conn.execute("PRAGMA table_info(messages)")} + if "conversation_id" not in cols: + conn.execute( + "ALTER TABLE messages ADD COLUMN conversation_id INTEGER" + ) conn.commit() except sqlite3.Error as e: diff --git a/tests/test_conversations.py b/tests/test_conversations.py index b2a28b0..7e00dc1 100644 --- a/tests/test_conversations.py +++ b/tests/test_conversations.py @@ -1,7 +1,6 @@ """Tests for ConversationStore.""" from __future__ import annotations -import asyncio import sqlite3 import pytest from pathlib import Path @@ -75,11 +74,15 @@ def test_get_last_returns_none_when_empty(store): assert store.get_last("cli") is None -def test_get_last_returns_most_recently_updated(store): +def test_get_last_returns_most_recently_updated(store, db): cid1 = store.create("cli", "First") - import time; time.sleep(0.01) cid2 = store.create("cli", "Second") - store.touch(cid2) + # Pin cid2 to a future timestamp so ordering is deterministic + with sqlite3.connect(db) as conn: + conn.execute( + "UPDATE conversations SET updated_at='2099-01-01T00:00:00' WHERE id=?", (cid2,) + ) + conn.commit() last = store.get_last("cli") assert last["id"] == cid2 @@ -312,7 +315,6 @@ async def test_auto_name_does_not_overwrite_manual_rename(store): with patch("app.core.helper_agent.HelperAgent", return_value=mock_helper_instance): from app.core.agent import Agent agent_stub = MagicMock(spec=[]) # _auto_name doesn't use self - from app.core import runtime await Agent._auto_name(agent_stub, store, cid, [], "conversation_name") # Name should still be the manually set name From 49638479458f280bc1971cc0ee9b25295047b695 Mon Sep 17 00:00:00 2001 From: Rikul Patel Date: Sat, 23 May 2026 14:17:00 -0500 Subject: [PATCH 62/84] Potential fix for pull request finding Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com> --- app/cli/cli_agent.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/app/cli/cli_agent.py b/app/cli/cli_agent.py index dbed168..ba229a7 100755 --- a/app/cli/cli_agent.py +++ b/app/cli/cli_agent.py @@ -19,8 +19,8 @@ def __init__(self, max_iterations: int = 250, auto_approve: bool = False, silent self.silent = silent self._channel_str = ChannelType.CLI.value - self.history = MessageHistory(channel_type=self._channel_str) self._store = ConversationStore() + self.history = MessageHistory(channel_type=self._channel_str) conv = self._store.get_last(self._channel_str) if conv is None: From 48a3d518bc3a6e9c16c45c1de6f766f2ddef58d8 Mon Sep 17 00:00:00 2001 From: Rikul Patel Date: Sat, 23 May 2026 14:17:33 -0500 Subject: [PATCH 63/84] Potential fix for pull request finding Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com> --- app/core/background_agent.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/app/core/background_agent.py b/app/core/background_agent.py index 2fef6c4..040d329 100755 --- a/app/core/background_agent.py +++ b/app/core/background_agent.py @@ -26,8 +26,8 @@ def __init__(self, mq: MessageQueue = None, channel: Channel = None, max_iterati raise ValueError("channel must be specified for BackgroundAgent") self._channel_str = channel.channel_type.value - self.history = MessageHistory(channel_type=self._channel_str) self._store = ConversationStore() + self.history = MessageHistory(channel_type=self._channel_str) conv = self._store.get_last(self._channel_str) if conv is None: From 65e3b4191b1a41f614535fb44ac5511e086652d1 Mon Sep 17 00:00:00 2001 From: Rikul Patel Date: Sat, 23 May 2026 14:18:53 -0500 Subject: [PATCH 64/84] Potential fix for pull request finding Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com> --- app/channels/commands.py | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/app/channels/commands.py b/app/channels/commands.py index 19dc709..fffa199 100644 --- a/app/channels/commands.py +++ b/app/channels/commands.py @@ -169,6 +169,12 @@ async def _rename(args: str = "") -> str: store.rename(conv_id, new_name, channel) except ValueError as e: return str(e) + + if runtime.get("conversation_id") == conv_id: + runtime.set("conversation_name", new_name) + if channel and runtime.get(f"conversation_id:{channel}") == conv_id: + runtime.set(f"conversation_name:{channel}", new_name) + return f"Conversation [{conv_id}] renamed to \"{new_name[:80]}\"" return _rename From 9cdb489b476e1fc53f74f1b314c74f664d81b096 Mon Sep 17 00:00:00 2001 From: Claude Date: Sat, 23 May 2026 19:29:07 +0000 Subject: [PATCH 65/84] Add idx_messages_conversation_id index in MessageHistory._ensure_db() MessageHistory already adds the conversation_id column; it should also own the index so queries that filter on conversation_id (load_messages, list join, fork) are covered even when ConversationStore hasn't run. https://claude.ai/code/session_01AXnJ5ZXdQ9kxzsbjMtNfFH --- app/infra/message_history.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/app/infra/message_history.py b/app/infra/message_history.py index 12a3471..cfbc930 100755 --- a/app/infra/message_history.py +++ b/app/infra/message_history.py @@ -39,6 +39,10 @@ def _ensure_db(self): conn.execute( "ALTER TABLE messages ADD COLUMN conversation_id INTEGER" ) + conn.execute(""" + CREATE INDEX IF NOT EXISTS idx_messages_conversation_id + ON messages(conversation_id) + """) conn.commit() except sqlite3.Error as e: From be8fc662df5b67ea55b97dffce53534c0bd8af61 Mon Sep 17 00:00:00 2001 From: Claude Date: Sat, 23 May 2026 19:31:56 +0000 Subject: [PATCH 66/84] Fix load_messages() to return most recent messages, not oldest ORDER BY ASC LIMIT truncated to the oldest N messages, so after restart or /load-conversation on a long conversation the agent continued from stale early history. Changed to ORDER BY DESC LIMIT then reverse (same pattern as MessageHistory.get_history()), and added a regression test. https://claude.ai/code/session_01AXnJ5ZXdQ9kxzsbjMtNfFH --- app/infra/conversations.py | 4 ++-- tests/test_conversations.py | 24 +++++++++++++++++------- 2 files changed, 19 insertions(+), 9 deletions(-) diff --git a/app/infra/conversations.py b/app/infra/conversations.py index 66b8b52..67848ff 100644 --- a/app/infra/conversations.py +++ b/app/infra/conversations.py @@ -231,10 +231,10 @@ def load_messages(self, conversation_id: int, limit: int = 1000) -> list[dict]: with _fk_conn(self.db_path) as conn: rows = conn.execute( "SELECT role, content FROM messages WHERE conversation_id=? " - "ORDER BY timestamp ASC, id ASC LIMIT ?", + "ORDER BY timestamp DESC, id DESC LIMIT ?", (conversation_id, limit), ).fetchall() - return [{"role": row[0], "content": row[1]} for row in rows] + return [{"role": row[0], "content": row[1]} for row in reversed(rows)] def count_user_messages(self, conversation_id: int) -> int: with _fk_conn(self.db_path) as conn: diff --git a/tests/test_conversations.py b/tests/test_conversations.py index 7e00dc1..7d56322 100644 --- a/tests/test_conversations.py +++ b/tests/test_conversations.py @@ -202,13 +202,6 @@ def test_fork_rejects_missing_conversation(store): def test_load_messages_ordered_by_timestamp_then_id(store, db): cid = store.create("cli") with sqlite3.connect(db) as conn: - conn.execute(""" - CREATE TABLE IF NOT EXISTS messages ( - id INTEGER PRIMARY KEY AUTOINCREMENT, - channel TEXT, role TEXT, content TEXT, - timestamp TEXT, est_tokens INTEGER, conversation_id INTEGER - ) - """) conn.execute( "INSERT INTO messages (channel, role, content, timestamp, conversation_id) VALUES (?,?,?,?,?)", ("cli", "user", "second", "2024-01-01T00:00:02", cid), @@ -223,6 +216,23 @@ def test_load_messages_ordered_by_timestamp_then_id(store, db): assert msgs[1]["content"] == "second" +def test_load_messages_returns_most_recent_when_truncated(store, db): + """With limit=2, load_messages must return the 2 newest messages, not the 2 oldest.""" + cid = store.create("cli") + with sqlite3.connect(db) as conn: + for i in range(5): + conn.execute( + "INSERT INTO messages (channel, role, content, timestamp, conversation_id) VALUES (?,?,?,?,?)", + ("cli", "user", f"msg{i}", f"2024-01-01T00:00:0{i}", cid), + ) + conn.commit() + msgs = store.load_messages(cid, limit=2) + assert len(msgs) == 2 + # Should be the two most recent, in chronological order + assert msgs[0]["content"] == "msg3" + assert msgs[1]["content"] == "msg4" + + # --- count_user_messages --- def test_count_user_messages(store, db): From 5bf484ea8dfc84265d3bb7f9a25bb0804bc356b5 Mon Sep 17 00:00:00 2001 From: Claude Date: Sat, 23 May 2026 19:47:02 +0000 Subject: [PATCH 67/84] fix: use persisted name after rename to keep runtime and response consistent store.rename() sanitizes via _clean_name (trim, 80-char cap, empty fallback), but the command was propagating the raw user input into runtime and the response. Re-read the stored name after renaming so /status and the confirmation message always reflect the value actually saved to the DB. https://claude.ai/code/session_01AXnJ5ZXdQ9kxzsbjMtNfFH --- app/channels/commands.py | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/app/channels/commands.py b/app/channels/commands.py index fffa199..d9bd895 100644 --- a/app/channels/commands.py +++ b/app/channels/commands.py @@ -170,12 +170,13 @@ async def _rename(args: str = "") -> str: except ValueError as e: return str(e) + persisted_name = store.get(conv_id)["name"] if runtime.get("conversation_id") == conv_id: - runtime.set("conversation_name", new_name) + runtime.set("conversation_name", persisted_name) if channel and runtime.get(f"conversation_id:{channel}") == conv_id: - runtime.set(f"conversation_name:{channel}", new_name) + runtime.set(f"conversation_name:{channel}", persisted_name) - return f"Conversation [{conv_id}] renamed to \"{new_name[:80]}\"" + return f"Conversation [{conv_id}] renamed to \"{persisted_name}\"" return _rename From e43201a49ec9fce372ac0e9c236083a187127827 Mon Sep 17 00:00:00 2001 From: "rikulpatel@gmail.com" Date: Sat, 23 May 2026 23:17:33 -0500 Subject: [PATCH 68/84] refactor: - Remove channel-level CommandRegistry from Telegram and Discord. Both channels now only handle /whoami inline; all other slash commands are enqueued as plain IncomingMessages and dispatched by BackgroundAgent.process_incoming() via its own registry. - Add /model, /status, /stop to BackgroundAgent's registry. Add _stop_cmd() to BackgroundAgent (was only on TelegramChannel before). - Slugify auto-generated conversation names at the source (_slugify in agent.py applied immediately after HelperAgent returns the title), so the slug is stored in DB and propagated to runtime consistently. - Clean up conversations.py: remove _clean_name() helper (inlined at two call sites) and _slug() (logic moved to agent.py as _slugify). --- CLAUDE.md | 2 +- README.md | 2 +- app/channels/discord.py | 18 ++++-------------- app/channels/telegram.py | 29 ++++++++--------------------- app/core/agent.py | 15 +++++++++++---- app/core/background_agent.py | 9 ++++++++- app/infra/conversations.py | 15 +++------------ tests/test_discord_channel.py | 22 ++++++++++------------ tests/test_telegram_channel.py | 26 +++++++------------------- 9 files changed, 53 insertions(+), 85 deletions(-) diff --git a/CLAUDE.md b/CLAUDE.md index 10147f9..de75c81 100755 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -91,7 +91,7 @@ On startup, `load_system_context()` (`app/infra/startup.py`) loads `app/core/sys **Channel types** are defined in `ChannelType` enum (`app/channels/channel.py`): `CLI`, `TELEGRAM`, `DISCORD`, `WEB`. Each channel implements the `Channel` ABC and owns a `MessageQueue` instance. `bg_server.py` wires up enabled channels — each gets its own `MessageQueue`, `BackgroundAgent`, and set of coroutines (`run_polling`, `process_incoming`, `process_outgoing`) gathered into the event loop. -**Slash commands** are handled by a `CommandRegistry` (`app/channels/commands.py`) shared across Telegram and Discord. Built-in commands: `/help`, `/status`, `/model [name]`, `/whoami`. Each channel constructs its own registry instance and registers the same `BotCommand`s. Commands are dispatched before the message reaches the agent loop. +**Slash commands** are handled entirely by `BackgroundAgent`. Channel handlers (`command_handler` in Telegram, `on_message` in Discord) intercept only `/whoami` (resolved inline using the platform user object) and enqueue everything else as a plain `IncomingMessage`. `BackgroundAgent.process_incoming()` detects the leading `/` and dispatches via its own `CommandRegistry`. That registry owns the full command set: `/model`, `/status`, `/stop`, `/help`, `/list-conversations`, `/new-conversation`, `/load-conversation`, `/fork-conversation`, `/rename-conversation`, `/export-conversation`. ### Message Queue diff --git a/README.md b/README.md index 1f0cfda..af4f423 100644 --- a/README.md +++ b/README.md @@ -102,7 +102,7 @@ ALLOW_FROM = [] # restrict by user ID; empty = allow all Each channel gets its own message queue and agent. Scheduled task results are delivered to the channel the task was created from; if no context is available, the Discord bot owner is DM'd. -**Telegram commands:** `/help` — list commands; `/whoami` — show your Telegram user ID. +**Bot commands:** `/help` — list all commands; `/model [name]` — get or set the model; `/status` — show uptime and current conversation; `/stop` — pause the bot; `/whoami` — show your user ID (Telegram only); `/list-conversations`, `/new-conversation`, `/load-conversation `, `/fork-conversation [id]`, `/rename-conversation `, `/export-conversation [id]` — manage conversation history. ### Scheduled Tasks diff --git a/app/channels/discord.py b/app/channels/discord.py index f4f8f84..9b97997 100644 --- a/app/channels/discord.py +++ b/app/channels/discord.py @@ -1,7 +1,6 @@ import discord import logging -from .commands import CommandRegistry, BotCommand, make_status_cmd, help_cmd, model_cmd from .message_queue import MessageQueue from .channel import Channel, ChannelType from .message import OutgoingMessage, IncomingMessage @@ -24,10 +23,6 @@ def __init__(self, mq: MessageQueue, token: str, allow_from: list[int] = None) - self.stopped = False self._last_channel_id: int | None = None mq.register(self, self.send_message) - self.registry = CommandRegistry() - self.registry.register(BotCommand("model", "Get or set the current model. Usage: /model [model_name]", model_cmd)) - self.registry.register(BotCommand("status", "Show bot status.", make_status_cmd(ChannelType.DISCORD.value))) - self.registry.register(BotCommand("help", "Show this help message.", help_cmd(self.registry))) @property def has_stopped(self) -> bool: @@ -60,11 +55,7 @@ async def on_message(self, message: discord.Message) -> None: return if content.startswith("/"): - - parts = content[1:].split(maxsplit=1) - cmd_name = parts[0].lower() - args = parts[1] if len(parts) > 1 else "" - + cmd_name = content[1:].split(maxsplit=1)[0].lower() metadata = {"channel_id": message.channel.id} if cmd_name == "whoami": await self.send_message(OutgoingMessage( @@ -73,11 +64,10 @@ async def on_message(self, message: discord.Message) -> None: metadata=metadata, )) return - reply = await self.registry.execute(cmd_name, args) - if reply is not None: - await self.send_message(OutgoingMessage(content=reply, channel=ChannelType.DISCORD, metadata=metadata)) + if cmd_name == "stop": + self.stopped = True + await self.send_message(OutgoingMessage(content="Stopped.", channel=ChannelType.DISCORD, metadata=metadata)) return - self._last_channel_id = message.channel.id await self.mq.incoming.put( IncomingMessage( diff --git a/app/channels/telegram.py b/app/channels/telegram.py index 87d56c9..27ae922 100755 --- a/app/channels/telegram.py +++ b/app/channels/telegram.py @@ -1,7 +1,6 @@ import asyncio import logging -from .commands import CommandRegistry, BotCommand, make_status_cmd, help_cmd, model_cmd from .message_queue import MessageQueue from .channel import Channel, ChannelType from .message import OutgoingMessage, IncomingMessage @@ -29,11 +28,6 @@ def __init__( self.mq = mq self.stopped = False mq.register(self, self.send_message) - self.registry = CommandRegistry() - self.registry.register(BotCommand("model", "Get or set the LLM model. Usage: /model [name]", model_cmd)) - self.registry.register(BotCommand("status", "Show bot status.", make_status_cmd(ChannelType.TELEGRAM.value))) - self.registry.register(BotCommand("stop", "Pause the bot.", self._stop_cmd)) - self.registry.register(BotCommand("help", "Show this help message.", help_cmd(self.registry))) @property def has_stopped(self) -> bool: @@ -61,30 +55,23 @@ async def error_handler( "⚠ An error occurred, please try again." ) - async def _stop_cmd(self, args: str = "") -> str: - self.stopped = True - log.info("Received /stop in Telegram channel, setting stopped=True.") - return "Stopped." - async def command_handler(self, update: Update, context: ContextTypes.DEFAULT_TYPE) -> None: if update.message and update.message.text: content = update.message.text.strip() if content.startswith("/"): - parts = content[1:].split(maxsplit=1) - cmd_name = parts[0].lower() - args = parts[1] if len(parts) > 1 else "" + cmd_name = content[1:].split(maxsplit=1)[0].lower() metadata = {"chat_id": update.effective_chat.id} if cmd_name == "whoami": text = f"Your user ID is {update.effective_user.id} and your name is {update.effective_user.first_name}." await self.send_message(OutgoingMessage(content=text, channel=ChannelType.TELEGRAM, metadata=metadata)) return - reply = await self.registry.execute(cmd_name, args) - if reply is not None: - await self.send_message(OutgoingMessage(content=reply, channel=ChannelType.TELEGRAM, metadata=metadata)) - else: - await self.mq.incoming.put(IncomingMessage( - content=content, channel=ChannelType.TELEGRAM, metadata=metadata - )) + if cmd_name == "stop": + self.stopped = True + await self.send_message(OutgoingMessage(content="Stopped.", channel=ChannelType.TELEGRAM, metadata=metadata)) + return + await self.mq.incoming.put(IncomingMessage( + content=content, channel=ChannelType.TELEGRAM, metadata=metadata + )) async def send_message(self, message: OutgoingMessage) -> None: # This function is called by the MessageQueue when there is an outgoing message for this channel diff --git a/app/core/agent.py b/app/core/agent.py index 114c954..a8b0244 100755 --- a/app/core/agent.py +++ b/app/core/agent.py @@ -2,6 +2,7 @@ import json import os import platform +import re from abc import ABC, abstractmethod from datetime import datetime from pathlib import Path @@ -12,6 +13,12 @@ from . import runtime MAX_CONTEXT_MESSAGES = 1000 + + +def _slugify(name: str) -> str: + return re.sub(r"[^a-z0-9-]", "", name.strip().lower().replace(" ", "-"))[:40] + + TOOL_RESULT_HISTORY_LIMIT = 100 @@ -108,12 +115,12 @@ async def _auto_name(self, store, conv_id: int, messages: list[dict], name_runti ) try: name = await HelperAgent().run(prompt) + name = _slugify(name) or "new-conversation" conv = store.get(conv_id) if conv and conv["name"] == "New Conversation": - clean = name.strip()[:80] or "New Conversation" - store.rename(conv_id, clean, conv["channel"]) - runtime.set(name_runtime_key, clean) - log.info(f"Auto-named conversation {conv_id}: {clean!r}") + store.rename(conv_id, name, conv["channel"]) + runtime.set(name_runtime_key, name) + log.info(f"Auto-named conversation {conv_id}: {name!r}") except Exception as e: log.warning(f"Auto-naming conversation {conv_id} failed: {e}") diff --git a/app/core/background_agent.py b/app/core/background_agent.py index 040d329..e471a1e 100755 --- a/app/core/background_agent.py +++ b/app/core/background_agent.py @@ -45,12 +45,15 @@ def __init__(self, mq: MessageQueue = None, channel: Channel = None, max_iterati # Lazy import to avoid circular: commands imports runtime which is fine, # but conversation commands need self reference so we build registry here. from ..channels.commands import ( - CommandRegistry, BotCommand, help_cmd, + CommandRegistry, BotCommand, help_cmd, make_status_cmd, model_cmd, list_conversations_cmd, new_conversation_cmd, load_conversation_cmd, fork_conversation_cmd, rename_conversation_cmd, export_conversation_cmd, ) self.registry = CommandRegistry() ch = self._channel_str + self.registry.register(BotCommand("model", "Get or set model. Usage: /model [name]", model_cmd)) + self.registry.register(BotCommand("status", "Show bot status.", make_status_cmd(ch))) + self.registry.register(BotCommand("stop", "Pause the bot.", self._stop_cmd)) self.registry.register(BotCommand("list-conversations", "List conversations.", list_conversations_cmd(self._store, ch))) self.registry.register(BotCommand("new-conversation", "Start a new conversation.", new_conversation_cmd(self))) self.registry.register(BotCommand("load-conversation", "Load a conversation. Usage: /load-conversation ", load_conversation_cmd(self))) @@ -59,6 +62,10 @@ def __init__(self, mq: MessageQueue = None, channel: Channel = None, max_iterati self.registry.register(BotCommand("export-conversation", "Export a conversation to JSON. Usage: /export-conversation [id]", export_conversation_cmd(self._store, ch))) self.registry.register(BotCommand("help", "Show available commands.", help_cmd(self.registry))) + async def _stop_cmd(self, args: str = "") -> str: + self.channel.stopped = True + return "Stopped." + def _switch_conversation(self, conv: dict) -> None: self.conversation_id = conv["id"] self.messages = self._store.load_messages(conv["id"], limit=MAX_CONTEXT_MESSAGES) diff --git a/app/infra/conversations.py b/app/infra/conversations.py index 67848ff..b002190 100644 --- a/app/infra/conversations.py +++ b/app/infra/conversations.py @@ -11,15 +11,6 @@ from .app_logging import log -def _clean_name(name: str, fallback: str = "New Conversation") -> str: - n = name.strip()[:80] - return n or fallback - - -def _slug(name: str) -> str: - return re.sub(r"[^a-z0-9-]", "", name.lower().replace(" ", "-"))[:40] - - @contextlib.contextmanager def _fk_conn(db_path: Path): """sqlite3 connection with FK constraints enforced.""" @@ -122,7 +113,7 @@ def _ensure_schema(self) -> None: raise def create(self, channel: str, name: str = "New Conversation", parent_id: int = None) -> int: - clean = _clean_name(name) + clean = name.strip()[:80] or "New Conversation" now = datetime.now().isoformat() with _fk_conn(self.db_path) as conn: cid = conn.execute( @@ -186,7 +177,7 @@ def rename(self, conversation_id: int, name: str, channel: str) -> None: raise ValueError( f"Conversation {conversation_id} does not belong to channel {channel!r}" ) - clean = _clean_name(name) + clean = name.strip()[:80] or "New Conversation" now = datetime.now().isoformat() with _fk_conn(self.db_path) as conn: conn.execute( @@ -256,7 +247,7 @@ def export(self, conversation_id: int, channel: str) -> Path: export_dir = PROJECT_HOME / "conversations" export_dir.mkdir(parents=True, exist_ok=True) - slug = _slug(conv["name"]) or "conversation" + slug = re.sub(r"[^a-z0-9-]", "", conv["name"].lower().replace(" ", "-"))[:40] or "conversation" filename = f"{conversation_id}-{slug}.json" path = export_dir / filename with open(path, "w", encoding="utf-8") as f: diff --git a/tests/test_discord_channel.py b/tests/test_discord_channel.py index 9645e6b..abf5285 100644 --- a/tests/test_discord_channel.py +++ b/tests/test_discord_channel.py @@ -283,9 +283,8 @@ async def test_on_message_whoami_replies_with_user_info(): @pytest.mark.asyncio -async def test_on_message_known_command_replies_and_skips_mq(): +async def test_on_message_command_enqueued(): dc, mq = make_discord_channel() - dc.registry.execute = AsyncMock(return_value="Bot status: running") dc.send_message = AsyncMock() message = MagicMock() message.author.id = 123 @@ -295,15 +294,15 @@ async def test_on_message_known_command_replies_and_skips_mq(): await dc.on_message(message) - dc.registry.execute.assert_called_once_with("status", "") - dc.send_message.assert_called_once() - assert mq.incoming.empty() + assert not mq.incoming.empty() + msg = await mq.incoming.get() + assert msg.content == "/status" + dc.send_message.assert_not_called() @pytest.mark.asyncio -async def test_on_message_command_with_args(): +async def test_on_message_command_with_args_enqueued(): dc, mq = make_discord_channel() - dc.registry.execute = AsyncMock(return_value="Model set to: gpt-4") dc.send_message = AsyncMock() message = MagicMock() message.author.id = 123 @@ -313,15 +312,14 @@ async def test_on_message_command_with_args(): await dc.on_message(message) - dc.registry.execute.assert_called_once_with("model", "gpt-4") - dc.send_message.assert_called_once() - assert mq.incoming.empty() + assert not mq.incoming.empty() + msg = await mq.incoming.get() + assert msg.content == "/model gpt-4" @pytest.mark.asyncio -async def test_on_message_unknown_command_falls_through_to_mq(): +async def test_on_message_unknown_command_enqueued(): dc, mq = make_discord_channel() - dc.registry.execute = AsyncMock(return_value=None) message = MagicMock() message.author.id = 123 message.author.display_name = "Alice" diff --git a/tests/test_telegram_channel.py b/tests/test_telegram_channel.py index 0eb6708..9b7ad39 100644 --- a/tests/test_telegram_channel.py +++ b/tests/test_telegram_channel.py @@ -158,32 +158,20 @@ async def test_error_handler_notifies_user_on_chat_update(): @pytest.mark.asyncio async def test_stop_sets_has_stopped(): - tc, _ = make_telegram_channel() + tc, mq = make_telegram_channel() tc.send_message = AsyncMock() - assert tc.has_stopped is False await tc.command_handler(make_update(text="/stop"), MagicMock()) assert tc.has_stopped is True - - -@pytest.mark.asyncio -async def test_stop_replies_to_user(): - tc, _ = make_telegram_channel() - tc.send_message = AsyncMock() - - await tc.command_handler(make_update(text="/stop"), MagicMock()) - + assert mq.incoming.empty() tc.send_message.assert_called_once() - assert "Stopped" in tc.send_message.call_args[0][0].content @pytest.mark.asyncio async def test_clear_stopped_resets_state(): tc, _ = make_telegram_channel() - tc.send_message = AsyncMock() - - await tc.command_handler(make_update(text="/stop"), MagicMock()) + tc.stopped = True assert tc.has_stopped is True tc.clear_stopped() @@ -204,14 +192,14 @@ async def test_command_handler_whoami_replies_with_user_info(): @pytest.mark.asyncio async def test_command_handler_dispatches_with_args(): - tc, _ = make_telegram_channel() - tc.registry.execute = AsyncMock(return_value="Model set to: gpt-4") + tc, mq = make_telegram_channel() tc.send_message = AsyncMock() await tc.command_handler(make_update(text="/model gpt-4"), MagicMock()) - tc.registry.execute.assert_called_once_with("model", "gpt-4") - tc.send_message.assert_called_once() + assert not mq.incoming.empty() + msg = await mq.incoming.get() + assert msg.content == "/model gpt-4" # --- error_handler --- From b009d47caedda326a8548238ababbfcdc1e29e50 Mon Sep 17 00:00:00 2001 From: "rikulpatel@gmail.com" Date: Sun, 24 May 2026 11:12:04 -0500 Subject: [PATCH 69/84] refactor: renamed cmds so they are easier to write; updated CLAUDE.md and README --- CLAUDE.md | 2 +- README.md | 2 +- app/channels/commands.py | 4 ++-- app/core/background_agent.py | 12 ++++++------ app/main.py | 12 ++++++------ 5 files changed, 16 insertions(+), 16 deletions(-) diff --git a/CLAUDE.md b/CLAUDE.md index de75c81..4f25c7b 100755 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -91,7 +91,7 @@ On startup, `load_system_context()` (`app/infra/startup.py`) loads `app/core/sys **Channel types** are defined in `ChannelType` enum (`app/channels/channel.py`): `CLI`, `TELEGRAM`, `DISCORD`, `WEB`. Each channel implements the `Channel` ABC and owns a `MessageQueue` instance. `bg_server.py` wires up enabled channels — each gets its own `MessageQueue`, `BackgroundAgent`, and set of coroutines (`run_polling`, `process_incoming`, `process_outgoing`) gathered into the event loop. -**Slash commands** are handled entirely by `BackgroundAgent`. Channel handlers (`command_handler` in Telegram, `on_message` in Discord) intercept only `/whoami` (resolved inline using the platform user object) and enqueue everything else as a plain `IncomingMessage`. `BackgroundAgent.process_incoming()` detects the leading `/` and dispatches via its own `CommandRegistry`. That registry owns the full command set: `/model`, `/status`, `/stop`, `/help`, `/list-conversations`, `/new-conversation`, `/load-conversation`, `/fork-conversation`, `/rename-conversation`, `/export-conversation`. +**Slash commands** are handled entirely by `BackgroundAgent`. Channel handlers (`command_handler` in Telegram, `on_message` in Discord) intercept only `/whoami` (resolved inline using the platform user object) and enqueue everything else as a plain `IncomingMessage`. `BackgroundAgent.process_incoming()` detects the leading `/` and dispatches via its own `CommandRegistry`. That registry owns the full command set: `/model`, `/status`, `/stop`, `/help`, `/list`, `/new`, `/load`, `/fork`, `/rename`, `/export`. ### Message Queue diff --git a/README.md b/README.md index af4f423..8f8739e 100644 --- a/README.md +++ b/README.md @@ -102,7 +102,7 @@ ALLOW_FROM = [] # restrict by user ID; empty = allow all Each channel gets its own message queue and agent. Scheduled task results are delivered to the channel the task was created from; if no context is available, the Discord bot owner is DM'd. -**Bot commands:** `/help` — list all commands; `/model [name]` — get or set the model; `/status` — show uptime and current conversation; `/stop` — pause the bot; `/whoami` — show your user ID (Telegram only); `/list-conversations`, `/new-conversation`, `/load-conversation `, `/fork-conversation [id]`, `/rename-conversation `, `/export-conversation [id]` — manage conversation history. +**Bot commands:** `/help` — list all commands; `/model [name]` — get or set the model; `/status` — show uptime and current conversation; `/stop` — pause the bot; `/whoami` — show your user ID (Telegram only); `/list`, `/new`, `/load `, `/fork [id]`, `/rename `, `/export [id]` — manage conversation history. ### Scheduled Tasks diff --git a/app/channels/commands.py b/app/channels/commands.py index d9bd895..17e428c 100644 --- a/app/channels/commands.py +++ b/app/channels/commands.py @@ -120,7 +120,7 @@ async def _new(args: str = "") -> str: def load_conversation_cmd(agent: ConversationAgent) -> CommandHandler: async def _load(args: str = "") -> str: if not args.strip(): - return "Usage: /load-conversation " + return "Usage: /load " try: conv_id = int(args.strip()) except ValueError: @@ -157,7 +157,7 @@ def rename_conversation_cmd(store: ConversationStore, channel: str) -> CommandHa async def _rename(args: str = "") -> str: parts = args.strip().split(maxsplit=1) if len(parts) < 2: - return "Usage: /rename-conversation " + return "Usage: /rename " try: conv_id = int(parts[0]) except ValueError: diff --git a/app/core/background_agent.py b/app/core/background_agent.py index e471a1e..0efa8d9 100755 --- a/app/core/background_agent.py +++ b/app/core/background_agent.py @@ -54,12 +54,12 @@ def __init__(self, mq: MessageQueue = None, channel: Channel = None, max_iterati self.registry.register(BotCommand("model", "Get or set model. Usage: /model [name]", model_cmd)) self.registry.register(BotCommand("status", "Show bot status.", make_status_cmd(ch))) self.registry.register(BotCommand("stop", "Pause the bot.", self._stop_cmd)) - self.registry.register(BotCommand("list-conversations", "List conversations.", list_conversations_cmd(self._store, ch))) - self.registry.register(BotCommand("new-conversation", "Start a new conversation.", new_conversation_cmd(self))) - self.registry.register(BotCommand("load-conversation", "Load a conversation. Usage: /load-conversation ", load_conversation_cmd(self))) - self.registry.register(BotCommand("fork-conversation", "Fork a conversation. Usage: /fork-conversation [id]", fork_conversation_cmd(self))) - self.registry.register(BotCommand("rename-conversation", "Rename a conversation. Usage: /rename-conversation ", rename_conversation_cmd(self._store, ch))) - self.registry.register(BotCommand("export-conversation", "Export a conversation to JSON. Usage: /export-conversation [id]", export_conversation_cmd(self._store, ch))) + self.registry.register(BotCommand("list", "List conversations.", list_conversations_cmd(self._store, ch))) + self.registry.register(BotCommand("new", "Start a new conversation.", new_conversation_cmd(self))) + self.registry.register(BotCommand("load", "Load a conversation. Usage: /load ", load_conversation_cmd(self))) + self.registry.register(BotCommand("fork", "Fork a conversation. Usage: /fork [id]", fork_conversation_cmd(self))) + self.registry.register(BotCommand("rename", "Rename a conversation. Usage: /rename ", rename_conversation_cmd(self._store, ch))) + self.registry.register(BotCommand("export", "Export a conversation to JSON. Usage: /export [id]", export_conversation_cmd(self._store, ch))) self.registry.register(BotCommand("help", "Show available commands.", help_cmd(self.registry))) async def _stop_cmd(self, args: str = "") -> str: diff --git a/app/main.py b/app/main.py index 6c2c2ed..b565190 100755 --- a/app/main.py +++ b/app/main.py @@ -81,12 +81,12 @@ async def run_cli(args): cli_registry = CommandRegistry() cli_registry.register(BotCommand("status", "Show bot status.", make_status_cmd())) cli_registry.register(BotCommand("model", "Get or set model. Usage: /model [name]", model_cmd)) - cli_registry.register(BotCommand("list-conversations", "List conversations.", list_conversations_cmd(agent._store, agent._channel_str))) - cli_registry.register(BotCommand("new-conversation", "Start a new conversation.", new_conversation_cmd(agent))) - cli_registry.register(BotCommand("load-conversation", "Load a conversation. Usage: /load-conversation ", load_conversation_cmd(agent))) - cli_registry.register(BotCommand("fork-conversation", "Fork a conversation. Usage: /fork-conversation [id]", fork_conversation_cmd(agent))) - cli_registry.register(BotCommand("rename-conversation", "Rename a conversation. Usage: /rename-conversation ", rename_conversation_cmd(agent._store, agent._channel_str))) - cli_registry.register(BotCommand("export-conversation", "Export a conversation to JSON. Usage: /export-conversation [id]", export_conversation_cmd(agent._store, agent._channel_str))) + cli_registry.register(BotCommand("list", "List conversations.", list_conversations_cmd(agent._store, agent._channel_str))) + cli_registry.register(BotCommand("new", "Start a new conversation.", new_conversation_cmd(agent))) + cli_registry.register(BotCommand("load", "Load a conversation. Usage: /load ", load_conversation_cmd(agent))) + cli_registry.register(BotCommand("fork", "Fork a conversation. Usage: /fork [id]", fork_conversation_cmd(agent))) + cli_registry.register(BotCommand("rename", "Rename a conversation. Usage: /rename ", rename_conversation_cmd(agent._store, agent._channel_str))) + cli_registry.register(BotCommand("export", "Export a conversation to JSON. Usage: /export [id]", export_conversation_cmd(agent._store, agent._channel_str))) cli_registry.register(BotCommand("help", "Show available commands.", help_cmd(cli_registry))) try: From 9522cb93fa20eb9ac71bf3da3a2cf507527d1d06 Mon Sep 17 00:00:00 2001 From: "rikulpatel@gmail.com" Date: Tue, 26 May 2026 16:16:33 -0500 Subject: [PATCH 70/84] feat: added helper_agent tool, make run_tool async --- .gitignore | 1 + CLAUDE.md | 4 ++-- app/core/agent.py | 2 +- app/core/sys_instructions.md | 6 ++++-- app/core/tool_calls.py | 9 +++++++-- app/tools/helper_agent.py | 35 +++++++++++++++++++++++++++++++++ tests/test_helper_agent_tool.py | 23 ++++++++++++++++++++++ tests/test_tool_calls.py | 13 +++++++----- 8 files changed, 81 insertions(+), 12 deletions(-) create mode 100755 app/tools/helper_agent.py create mode 100755 tests/test_helper_agent_tool.py diff --git a/.gitignore b/.gitignore index a3b2b0a..67b1d02 100644 --- a/.gitignore +++ b/.gitignore @@ -130,6 +130,7 @@ celerybeat.pid # Environments .env .venv +.venv_win env/ venv/ ENV/ diff --git a/CLAUDE.md b/CLAUDE.md index 4f25c7b..067d6e7 100755 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -73,9 +73,9 @@ Tool calls within a single LLM turn are dispatched in parallel via `asyncio.gath ### Tool System -Each tool is a class extending `Tool` (`app/core/tool.py`), an ABC requiring a static `spec()` (OpenAI function-call schema) and a static `call()` method. Tools are registered in `app/core/tool_calls.py` in `tool_registry` — a dict mapping tool name → `Tool` class. `run_tool()` dispatches by name and restores `os.getcwd()` after each call. Results are truncated to `MAX_TOOL_RESULT_LENGTH` (16 000 chars). +Each tool is a class extending `Tool` (`app/core/tool.py`), an ABC requiring a static `spec()` (OpenAI function-call schema) and a static `call()` method. Tools are registered in `app/core/tool_calls.py` in `tool_registry` — a dict mapping tool name → `Tool` class. `run_tool()` is asynchronous and dispatches by name, awaiting the tool's `call` if it is a coroutine function, and restores `os.getcwd()` after execution. Results are truncated to `MAX_TOOL_RESULT_LENGTH` (16 000 chars). -Current tools: `read_file`, `write_file`, `bash`, `web_fetch`, `get_skills_dir`, `todo_add/list/update/clear`, `calculator`, `hackernews`, `websearch_text/images/videos/news/books`, `list/add/update/remove_scheduled_task`, `get_scheduled_task_output`, `get_city_state`, `get_datetime`. +Current tools: `read_file`, `write_file`, `bash`, `web_fetch`, `get_skills_dir`, `todo_add/list/update/clear`, `calculator`, `hackernews`, `websearch_text/images/videos/news/books`, `list/add/update/remove_scheduled_task`, `get_scheduled_task_output`, `get_city_state`, `get_datetime`, `helper_agent`. `_HELPER_AGENT_TOOLS` in `tool_calls.py` is an explicit allowlist of tools available to `HelperAgent` (used internally by scheduled tasks). Scheduled task mutation tools (`add/update/remove_scheduled_task`) are excluded to prevent recursion. diff --git a/app/core/agent.py b/app/core/agent.py index a8b0244..32b0b3b 100755 --- a/app/core/agent.py +++ b/app/core/agent.py @@ -134,7 +134,7 @@ async def handle_tool_call(self, tool_call) -> str: if not await self._check_permission(tool_name, tool_args): return "User denied permission to run this tool. Ask for permission to run the tool again if you want to try running it." await self._on_tool_start(tool_name, tool_args) - return run_tool(tool_name=tool_name, tool_args=tool_args) + return await run_tool(tool_name=tool_name, tool_args=tool_args) except Exception as e: error_msg = f"Error running tool {tool_name}: {str(e)}" log.error(error_msg) diff --git a/app/core/sys_instructions.md b/app/core/sys_instructions.md index 8a82955..a8ce328 100644 --- a/app/core/sys_instructions.md +++ b/app/core/sys_instructions.md @@ -50,6 +50,8 @@ Value careful execution, verified results, clear communication, and practical er The following tools are available. Use them fully and never fake or skip a call. -File and shell: bash, read_file, write_file. Web: web_fetch, websearch_text, websearch_images, websearch_videos, websearch_news, websearch_books, hackernews. Utilities: calculator. Todo: todo_add, todo_list, todo_update, todo_clear. +File and shell: bash, read_file, write_file. Web: web_fetch, websearch_text, websearch_images, websearch_videos, websearch_news, websearch_books, hackernews. Utilities: calculator. Todo: todo_add, todo_list, todo_update, todo_clear. Helper Agent: helper_agent. -Scheduled tasks run in the background via the background agent. Use add_scheduled_task(name, prompt, interval_minutes, repeat, next_run, delivery_channel) to create one, update_scheduled_task to modify or enable/disable, remove_scheduled_task to delete, list_scheduled_tasks to inspect, and get_scheduled_task_output(name, num_entries) to read recent results. For a repeating task: add_scheduled_task(name="morning-news", prompt="Fetch top 5 HN stories and summarize", interval_minutes=60, repeat=true, delivery_channel="telegram"). For a one-shot task: add_scheduled_task(name="reminder", prompt="Remind user to take a break", repeat=false, next_run="2026-05-04T15:00:00"). \ No newline at end of file +Scheduled tasks run in the background via the background agent. Use add_scheduled_task(name, prompt, interval_minutes, repeat, next_run, delivery_channel) to create one, update_scheduled_task to modify or enable/disable, remove_scheduled_task to delete, list_scheduled_tasks to inspect, and get_scheduled_task_output(name, num_entries) to read recent results. For a repeating task: add_scheduled_task(name="morning-news", prompt="Fetch top 5 HN stories and summarize", interval_minutes=60, repeat=true, delivery_channel="telegram"). For a one-shot task: add_scheduled_task(name="reminder", prompt="Remind user to take a break", repeat=false, next_run="2026-05-04T15:00:00"). + +Helper Agent: helper_agent(prompt, system_prompt) runs a helper agent session to perform a task or research. The helper has a subset of tools (e.g. read_file, write_file, bash, web_fetch, calculator, hackernews, websearch_text, get_city_state, get_datetime) but no scheduled task mutation capabilities. Use it to delegate sub-tasks, run calculations, or research in a clean environment without cluttering your main conversation context. diff --git a/app/core/tool_calls.py b/app/core/tool_calls.py index 9a508d6..d07af34 100755 --- a/app/core/tool_calls.py +++ b/app/core/tool_calls.py @@ -1,3 +1,4 @@ +import asyncio import os from ..infra.app_logging import log @@ -22,6 +23,7 @@ from ..tools.get_city_state import GetCityState from ..tools.get_datetime import GetDateTime +from ..tools.helper_agent import HelperAgentTool import json @@ -53,7 +55,8 @@ "get_scheduled_task_output": GetScheduledTaskOutput, "get_city_state": GetCityState, - "get_datetime": GetDateTime + "get_datetime": GetDateTime, + "helper_agent": HelperAgentTool } all_tool_specs = [tool.spec() for tool in tool_registry.values()] @@ -65,12 +68,14 @@ MAX_TOOL_RESULT_LENGTH = 16000 -def run_tool(tool_name: str, tool_args: dict) -> str: +async def run_tool(tool_name: str, tool_args: dict) -> str: original_cwd = os.getcwd() try: func = tool_registry[tool_name].call result = func(**tool_args) + if asyncio.iscoroutine(result): + result = await result except Exception as e: log.error(f"Error running tool {tool_name}: {str(e)}") result = f"Error running tool {tool_name}: {str(e)}" diff --git a/app/tools/helper_agent.py b/app/tools/helper_agent.py new file mode 100755 index 0000000..5315d31 --- /dev/null +++ b/app/tools/helper_agent.py @@ -0,0 +1,35 @@ +from ..core.tool import Tool +from ..infra.app_logging import log + +class HelperAgentTool(Tool): + + @staticmethod + def spec(): + return { + "type": "function", + "function": { + "name": "helper_agent", + "description": "Run a helper agent to perform a task or research. Use this to delegate sub-tasks.", + "parameters": { + "type": "object", + "properties": { + "prompt": { + "type": "string", + "description": "The prompt or task instructions for the helper agent." + }, + "system_prompt": { + "type": "string", + "description": "Optional system instructions to define the role, guidelines, or constraints for the helper agent." + } + }, + "required": ["prompt"] + } + } + } + + @staticmethod + async def call(prompt: str, system_prompt: str = None) -> str: + log.info(f"helper_agent tool called with prompt: {prompt}") + from ..core.helper_agent import HelperAgent + agent = HelperAgent(system_prompt=system_prompt) + return await agent.run(prompt) diff --git a/tests/test_helper_agent_tool.py b/tests/test_helper_agent_tool.py new file mode 100755 index 0000000..e49467c --- /dev/null +++ b/tests/test_helper_agent_tool.py @@ -0,0 +1,23 @@ +import pytest +from unittest.mock import patch, AsyncMock +from app.tools.helper_agent import HelperAgentTool + + +def test_helper_agent_tool_spec(): + spec = HelperAgentTool.spec() + assert spec["type"] == "function" + assert spec["function"]["name"] == "helper_agent" + assert "prompt" in spec["function"]["parameters"]["required"] + + +@pytest.mark.asyncio +async def test_helper_agent_tool_call(): + mock_helper = AsyncMock() + mock_helper.run = AsyncMock(return_value="delegated result") + + with patch("app.core.helper_agent.HelperAgent", return_value=mock_helper) as MockHelperAgent: + result = await HelperAgentTool.call(prompt="do something", system_prompt="be helpful") + + MockHelperAgent.assert_called_once_with(system_prompt="be helpful") + mock_helper.run.assert_called_once_with("do something") + assert result == "delegated result" diff --git a/tests/test_tool_calls.py b/tests/test_tool_calls.py index 559bcc9..2cb21b8 100644 --- a/tests/test_tool_calls.py +++ b/tests/test_tool_calls.py @@ -1,4 +1,4 @@ - +import pytest from app.core.tool_calls import run_tool, tool_registry @@ -8,16 +8,19 @@ def test_tool_registry_contains_expected_tools(): assert "bash" in tool_registry assert "web_fetch" in tool_registry assert "get_skills_dir" in tool_registry + assert "helper_agent" in tool_registry -def test_run_tool_calls_correct_function(tmp_path): +@pytest.mark.asyncio +async def test_run_tool_calls_correct_function(tmp_path): file_path = str(tmp_path / "test.txt") with open(file_path, "w", encoding="utf-8") as f: f.write("content") - result = run_tool("read_file", {"file_path": file_path}) + result = await run_tool("read_file", {"file_path": file_path}) assert result == "content" -def test_run_tool_unknown_tool_returns_error(): - result = run_tool("nonexistent_tool", {}) +@pytest.mark.asyncio +async def test_run_tool_unknown_tool_returns_error(): + result = await run_tool("nonexistent_tool", {}) assert "Error" in result From e56f46e28aa80d63e1d62efa05cfc432c6ac4d86 Mon Sep 17 00:00:00 2001 From: Rikul Date: Tue, 26 May 2026 20:41:52 -0500 Subject: [PATCH 71/84] fix: prevent scheduled task timing drift - Use original next_run time (not current time) to compute the next schedule for repeating tasks. This prevents cumulative drift from task execution time. - Reduce poll interval from 60s to 30s for better responsiveness. - Add docstring explaining the catch-up behavior (Option A). --- app/core/scheduled_tasks.py | 17 +++++++++++++++-- 1 file changed, 15 insertions(+), 2 deletions(-) diff --git a/app/core/scheduled_tasks.py b/app/core/scheduled_tasks.py index f145a35..262d33a 100755 --- a/app/core/scheduled_tasks.py +++ b/app/core/scheduled_tasks.py @@ -114,9 +114,22 @@ def get_output(self, name: str, num_entries: int = 5) -> list[dict]: for p, o, s, d, t in reversed(rows)] def _after_run(self, task: dict, now: datetime): + """Update task state after execution. + + For repeating tasks, the next run is derived from the task's original + scheduled time (next_run) rather than the current time. This prevents + timing drift that would otherwise accumulate if task execution takes + significant time. + + If the task is already overdue (e.g. after a server restart), the next + run is still advanced by exactly one interval from the original + schedule — meaning the task will fire again next cycle to catch up one + period at a time (Option A). + """ name = task["name"] if task["repeat"]: - next_run = (now + timedelta(minutes=task["interval_mins"])).isoformat() + original_next = datetime.fromisoformat(task["next_run"]) + next_run = (original_next + timedelta(minutes=task["interval_mins"])).isoformat() with sqlite3.connect(APP_DB) as conn: conn.execute("""UPDATE tasks SET last_run = ?, next_run = ?, run_count = run_count + 1 WHERE name = ?""", (now.isoformat(), next_run, name)) @@ -170,4 +183,4 @@ async def run(self): await asyncio.gather(*[self.run_task(t) for t in due], return_exceptions=True) except Exception as e: log.error(f"ScheduledTasks.run error: {e}", exc_info=True) - await asyncio.sleep(60) + await asyncio.sleep(30) From e31efd4cf2e315f0bdc69c1d5a616438775894ce Mon Sep 17 00:00:00 2001 From: Rikul Date: Tue, 26 May 2026 21:23:00 -0500 Subject: [PATCH 72/84] fix: skip missed scheduled task runs instead of catching up Changes _after_run to fast-forward past missed intervals rather than catching up one interval per poll cycle. This prevents a catch-up storm where many runs fire in rapid succession after prolonged downtime. If multiple intervals have passed since the original next_run, the next run is scheduled at: original_next_run + (intervals_passed + 1) * interval This keeps the original cadence locked while safely skipping over any missed executions. --- app/core/scheduled_tasks.py | 29 ++++++++++++++++++++++------- 1 file changed, 22 insertions(+), 7 deletions(-) diff --git a/app/core/scheduled_tasks.py b/app/core/scheduled_tasks.py index 262d33a..cb8dff2 100755 --- a/app/core/scheduled_tasks.py +++ b/app/core/scheduled_tasks.py @@ -116,20 +116,35 @@ def get_output(self, name: str, num_entries: int = 5) -> list[dict]: def _after_run(self, task: dict, now: datetime): """Update task state after execution. - For repeating tasks, the next run is derived from the task's original - scheduled time (next_run) rather than the current time. This prevents + For repeating tasks, the next run is always advanced by exactly one + interval from the original scheduled time (next_run). This prevents timing drift that would otherwise accumulate if task execution takes significant time. - If the task is already overdue (e.g. after a server restart), the next - run is still advanced by exactly one interval from the original - schedule — meaning the task will fire again next cycle to catch up one - period at a time (Option A). + If multiple intervals have passed since the original next_run (e.g. + after a server restart or prolonged downtime), skipped intervals are + fast-forwarded rather than caught up one at a time. This avoids a + catch-up storm where many runs would fire in rapid succession. + + Specifically: + - Calculate how many full intervals have passed since the task's + original next_run. + - Schedule the next run at the next future slot: + original_next_run + (intervals_passed + 1) * interval """ name = task["name"] if task["repeat"]: original_next = datetime.fromisoformat(task["next_run"]) - next_run = (original_next + timedelta(minutes=task["interval_mins"])).isoformat() + interval = timedelta(minutes=task["interval_mins"]) + # Advance by one interval from original schedule + next_due = original_next + interval + # If we're already past that due time, skip missed intervals + # by jumping to the next future slot + if now >= next_due: + elapsed_secs = (now - original_next).total_seconds() + intervals_passed = int(elapsed_secs // interval.total_seconds()) + next_due = original_next + (intervals_passed + 1) * interval + next_run = next_due.isoformat() with sqlite3.connect(APP_DB) as conn: conn.execute("""UPDATE tasks SET last_run = ?, next_run = ?, run_count = run_count + 1 WHERE name = ?""", (now.isoformat(), next_run, name)) From fc081d9babbbef678f5300a60624447f0159f83e Mon Sep 17 00:00:00 2001 From: Rikul Patel Date: Tue, 2 Jun 2026 14:30:13 -0500 Subject: [PATCH 73/84] feat: FastHTML web channel with chat UI (#9) * feat: add FastHTML web channel with clean chat UI Adds a WebChannel class (app/channels/web_channel.py) that serves both a FastHTML chat UI at GET / and a JSON WebSocket endpoint at WS /ws on the same uvicorn server. The UI features dark theme, user/AI message bubbles, auto-reconnect with status indicator, and a streaming-friendly input area. bg_server.py wires the new channel when [websocket] config is present; config.py adds WEBSOCKET_HOST/PORT env var overrides. --- .gitignore | 2 + CLAUDE.md | 7 +- Dockerfile | 9 + README.md | 95 +++++- app/bg_server.py | 21 +- app/channels/static/web_channel.css | 320 +++++++++++++++++++ app/channels/static/web_channel.js | 248 +++++++++++++++ app/channels/web_channel.py | 349 +++++++++++++++++++++ app/config.py | 11 + pyproject.toml | 2 + tests/test_web_channel.py | 289 +++++++++++++++++ uv.lock | 463 ++++++++++++++++++++++++++++ 12 files changed, 1810 insertions(+), 6 deletions(-) create mode 100644 app/channels/static/web_channel.css create mode 100644 app/channels/static/web_channel.js create mode 100644 app/channels/web_channel.py create mode 100644 tests/test_web_channel.py diff --git a/.gitignore b/.gitignore index 67b1d02..cae5323 100644 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1,5 @@ +.sesskey + # Byte-compiled / optimized / DLL files __pycache__/ *.py[cod] diff --git a/CLAUDE.md b/CLAUDE.md index 067d6e7..396de2d 100755 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -4,7 +4,7 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co ## Overview -This is a Python-based AI agent ("crafterscode") that uses an OpenAI-compatible API (defaulting to OpenRouter/DeepSeek) via the `openai` Python SDK. It supports an interactive CLI REPL, silent/non-interactive mode, and a background server architecture with Telegram and Discord channels. +This is a Python-based AI agent ("crafterscode") that uses an OpenAI-compatible API (defaulting to OpenRouter/DeepSeek) via the `openai` Python SDK. It supports an interactive CLI REPL, silent/non-interactive mode, and a background server architecture with Telegram, Discord, and a FastHTML web UI channel. ## Running & Development @@ -41,6 +41,7 @@ Config lives at `~/.crafterscode/config.toml` (created automatically on first ru - `base_url` — API base URL (default: `"https://openrouter.ai/api/v1"`) - `[telegram]` — `BOT_TOKEN`, `ALLOW_FROM` (list of integer user IDs) - `[discord]` — `TOKEN`, `ALLOW_FROM` (list of integer user IDs; empty = allow all) +- `[websocket]` — `HOST` (default `"127.0.0.1"`), `PORT` (default `8765`) Environment variables (all override config file values): - `LLM_API_KEY` — required @@ -50,6 +51,8 @@ Environment variables (all override config file values): - `TELEGRAM_ALLOW_FROM` — comma-separated Telegram user IDs (e.g. `"123,456"`) - `DISCORD_BOT_TOKEN` — Discord bot token (alternative to config file) - `DISCORD_ALLOW_FROM` — comma-separated Discord user IDs +- `WEBSOCKET_HOST` — bind host for the web UI (set to `0.0.0.0` in Docker) +- `WEBSOCKET_PORT` — port for web UI + WebSocket (default: `8765`) - `ANOTHERBOT_HOME` — overrides the data directory (default: `~/.crafterscode`) For Docker, no config file is needed — pass everything as env vars. See `Dockerfile` and the Docker section in README. @@ -91,6 +94,8 @@ On startup, `load_system_context()` (`app/infra/startup.py`) loads `app/core/sys **Channel types** are defined in `ChannelType` enum (`app/channels/channel.py`): `CLI`, `TELEGRAM`, `DISCORD`, `WEB`. Each channel implements the `Channel` ABC and owns a `MessageQueue` instance. `bg_server.py` wires up enabled channels — each gets its own `MessageQueue`, `BackgroundAgent`, and set of coroutines (`run_polling`, `process_incoming`, `process_outgoing`) gathered into the event loop. +**WebChannel** (`app/channels/web_channel.py`) uses `python-fasthtml` + uvicorn to serve both a browser chat UI (`GET /`) and a JSON WebSocket endpoint (`WS /ws`) on the same port. Multiple concurrent browser tabs are supported — each connection gets a UUID tracked in `_connections`. A per-connection `asyncio.Lock` in `_send_locks` serializes writes to each WebSocket. The channel also exposes `GET /api/conversations`, `GET /api/messages` (scoped to web channel only), and `GET /api/status` REST endpoints. Only `/whoami` is handled inline (it needs the per-connection client ID); all other slash commands — including `/help`, `/status`, `/stop` — are forwarded to `BackgroundAgent`'s `CommandRegistry` via the message queue with `is_command=True` in metadata so `send_message()` emits `{"type":"system"}` responses, enabling the sidebar to refresh after conversation-mutating commands. + **Slash commands** are handled entirely by `BackgroundAgent`. Channel handlers (`command_handler` in Telegram, `on_message` in Discord) intercept only `/whoami` (resolved inline using the platform user object) and enqueue everything else as a plain `IncomingMessage`. `BackgroundAgent.process_incoming()` detects the leading `/` and dispatches via its own `CommandRegistry`. That registry owns the full command set: `/model`, `/status`, `/stop`, `/help`, `/list`, `/new`, `/load`, `/fork`, `/rename`, `/export`. ### Message Queue diff --git a/Dockerfile b/Dockerfile index 56c6b51..f0baaab 100644 --- a/Dockerfile +++ b/Dockerfile @@ -35,12 +35,21 @@ ENV TELEGRAM_ALLOW_FROM="" ENV DISCORD_ALLOW_FROM="" ENV TZ=UTC +# Web channel — bind to all interfaces inside the container so Docker +# port mapping (-p 8765:8765) works. Without this the server listens on +# 127.0.0.1 only and is unreachable from outside the container. +ENV WEBSOCKET_HOST=0.0.0.0 +ENV WEBSOCKET_PORT=8765 + # Secrets — pass at runtime only, never bake into the image: # docker run -d \ # -e LLM_API_KEY=sk-... \ # -e DISCORD_BOT_TOKEN=your-discord-token \ # -e DISCORD_ALLOW_FROM=123456789 \ +# -p 8765:8765 \ # -v ./anotherbot-data:/data \ # or: docker run --env-file .env +EXPOSE 8765 + CMD ["bash", "run.sh", "background"] diff --git a/README.md b/README.md index 8f8739e..95c8776 100644 --- a/README.md +++ b/README.md @@ -4,6 +4,7 @@ A Python-based AI agent that can execute prompts, interact with the filesystem, - **Interactive CLI**: Multi-turn REPL sessions with tool use - **Background Agent**: Runs as a persistent bot, receiving and sending messages via channels +- **Web UI**: Browser-based chat interface served by FastHTML + uvicorn — dark/light theme, collapsible conversation sidebar, full conversation history - **Telegram Integration**: Built-in Telegram bot — receive messages, respond, run tools, deliver results - **Discord Integration**: Discord bot — same agent loop, per-channel message isolation, owner DM fallback for scheduled tasks - **Scheduled Tasks**: SQLite-backed task scheduler — run prompts on a recurring or one-shot schedule and deliver results to a channel @@ -52,6 +53,10 @@ ALLOW_FROM = [] # List of allowed Telegram user IDs (integers). [discord] TOKEN = "" ALLOW_FROM = [] # List of allowed Discord user IDs (integers). Empty means allow all. + +[websocket] +HOST = "127.0.0.1" # use 0.0.0.0 to expose on all interfaces (required for Docker) +PORT = 8765 ``` Message history is stored in `~/.crafterscode/history.db` (SQLite). Each channel maintains its own history with estimated token counts per message. @@ -82,6 +87,24 @@ Message history is stored in `~/.crafterscode/history.db` (SQLite). Each channel ./run.sh cli -p "Summarize this repo" -s ``` +### Web UI + +The background agent can serve a browser-based chat UI on the same port as the WebSocket endpoint. Enable it by adding a `[websocket]` section to `config.toml` or by setting the `WEBSOCKET_*` env vars: + +```bash +# Start the background server with the web channel enabled +WEBSOCKET_HOST=127.0.0.1 WEBSOCKET_PORT=8765 LLM_API_KEY=... ./run.sh background +``` + +Then open `http://localhost:8765/` in a browser. + +**Features:** +- Dark/light theme toggle (persisted in `localStorage`) +- Collapsible sidebar listing all conversations — click to load history +- `+ New` button and `/new` command to start a fresh conversation +- `/help`, `/status`, `/whoami`, `/stop` answered instantly without an LLM call +- All other slash commands (`/model`, `/load`, `/fork`, `/rename`, `/export`) forwarded to the agent + ### Background Agent (Telegram / Discord) Configure one or both channels in `~/.crafterscode/config.toml`: @@ -119,18 +142,56 @@ Tasks persist in `~/.crafterscode/app.db` (shared with message history) and surv ## Docker +### Build + ```bash docker build -t anotherbot . +``` + +### Run — Web UI + +**All flags inline:** +```bash +docker run -d \ + -e LLM_API_KEY=sk-... \ + -e WEBSOCKET_HOST=0.0.0.0 \ + -e WEBSOCKET_PORT=8765 \ + -p 8765:8765 \ + -v anotherbot-data:/data \ + anotherbot +``` + +**Using `export` first (keeps the run command clean):** +```bash +export LLM_API_KEY=sk-... +export WEBSOCKET_HOST=0.0.0.0 +export WEBSOCKET_PORT=8765 -# Telegram +docker run -d \ + -e LLM_API_KEY \ + -e WEBSOCKET_HOST \ + -e WEBSOCKET_PORT \ + -p 8765:8765 \ + -v anotherbot-data:/data \ + anotherbot +``` + +Then open `http://localhost:8765/` in a browser. `WEBSOCKET_HOST=0.0.0.0` is required — the default `127.0.0.1` is the container's own loopback and is not reachable via Docker port mapping. + +### Run — Telegram + +```bash docker run -d \ -e LLM_API_KEY=sk-... \ -e TELEGRAM_BOT_TOKEN=123:abc... \ -e TELEGRAM_ALLOW_FROM=123456789 \ -v anotherbot-data:/data \ anotherbot +``` + +### Run — Discord -# Discord +```bash docker run -d \ -e LLM_API_KEY=sk-... \ -e DISCORD_BOT_TOKEN=your-discord-token \ @@ -139,9 +200,35 @@ docker run -d \ anotherbot ``` +### Run — all channels at once + +```bash +export LLM_API_KEY=sk-... +export TELEGRAM_BOT_TOKEN=123:abc... +export TELEGRAM_ALLOW_FROM=123456789 +export DISCORD_BOT_TOKEN=your-discord-token +export WEBSOCKET_HOST=0.0.0.0 +export WEBSOCKET_PORT=8765 + +docker run -d \ + -e LLM_API_KEY \ + -e TELEGRAM_BOT_TOKEN \ + -e TELEGRAM_ALLOW_FROM \ + -e DISCORD_BOT_TOKEN \ + -e WEBSOCKET_HOST \ + -e WEBSOCKET_PORT \ + -p 8765:8765 \ + -v anotherbot-data:/data \ + anotherbot +``` + +### Environment variables + | Env var | Required | Description | |---|---|---| -| `LLM_API_KEY` | yes | OpenRouter / OpenAI-compatible API key | +| `LLM_API_KEY` | **yes** | OpenRouter / OpenAI-compatible API key | +| `WEBSOCKET_HOST` | — | Bind host for web UI (use `0.0.0.0` in Docker; default: `127.0.0.1`) | +| `WEBSOCKET_PORT` | — | Port for web UI and WebSocket (default: `8765`) | | `TELEGRAM_BOT_TOKEN` | — | Telegram bot token from @BotFather | | `TELEGRAM_ALLOW_FROM` | — | Comma-separated Telegram user IDs (empty = allow all) | | `DISCORD_BOT_TOKEN` | — | Discord bot token from developer portal | @@ -150,7 +237,7 @@ docker run -d \ | `MODEL` | no | Model string (default: `deepseek/deepseek-v3.2`) | | `ANOTHERBOT_HOME` | no | Data directory for DB and workspace (default: `/data` in container) | -At least one channel (`TELEGRAM_BOT_TOKEN` or `DISCORD_BOT_TOKEN`) must be set. +At least one channel (`WEBSOCKET_HOST`, `TELEGRAM_BOT_TOKEN`, or `DISCORD_BOT_TOKEN`) must be set or the server will exit. The `/data` volume persists the SQLite database and workspace across restarts. To supply a `config.toml` instead of env vars, mount it at `/data/config.toml` — env vars always take precedence over the file. diff --git a/app/bg_server.py b/app/bg_server.py index 0db1606..4409e01 100755 --- a/app/bg_server.py +++ b/app/bg_server.py @@ -44,7 +44,20 @@ async def start_server() -> None: discord_channel.start() discord_agent = BackgroundAgent(mq=discord_mq, channel=discord_channel, max_iterations=runtime.get("max_iterations", 250)) - if not telegram_channel and not discord_channel: + web_channel = None + web_agent = None + if config.get("websocket"): + from .channels.web_channel import WebChannel + ws_config = config.get("websocket") + ws_host = ws_config.get("HOST", "127.0.0.1") + ws_port = ws_config.get("PORT", 8765) + log.info(f"Starting web channel on {ws_host}:{ws_port}") + web_mq = MessageQueue() + web_channel = WebChannel(web_mq, host=ws_host, port=ws_port) + web_channel.start() + web_agent = BackgroundAgent(mq=web_mq, channel=web_channel, max_iterations=runtime.get("max_iterations", 250)) + + if not telegram_channel and not discord_channel and not web_channel: log.error("No channels configured, exiting...") return @@ -56,6 +69,10 @@ async def start_server() -> None: if discord_channel: channels["discord"] = discord_channel mqs["discord"] = discord_mq + if web_channel: + from .channels.channel import ChannelType + channels[ChannelType.WEB.value] = web_channel + mqs[ChannelType.WEB.value] = web_mq tasks = ScheduledTasks(mqs=mqs, channels=channels) @@ -64,5 +81,7 @@ async def start_server() -> None: coros.extend([telegram_channel.run_polling(), telegram_agent.process_incoming(), telegram_mq.process_outgoing()]) if discord_channel: coros.extend([discord_channel.run_polling(), discord_agent.process_incoming(), discord_mq.process_outgoing()]) + if web_channel: + coros.extend([web_channel.run_polling(), web_agent.process_incoming(), web_mq.process_outgoing()]) await asyncio.gather(*coros) diff --git a/app/channels/static/web_channel.css b/app/channels/static/web_channel.css new file mode 100644 index 0000000..942dfbb --- /dev/null +++ b/app/channels/static/web_channel.css @@ -0,0 +1,320 @@ +*, *::before, *::after { box-sizing: border-box; margin: 0; padding: 0; } + +:root { + --bg: #0f172a; + --surface: #1e293b; + --surface2: #273548; + --border: #334155; + --text: #e2e8f0; + --text-muted: #94a3b8; + --accent: #6366f1; + --accent-h: #818cf8; + --user-bg: #6366f1; + --ai-bg: #1e293b; + --sidebar-w: 260px; + --radius: 14px; + --font: 'Inter', 'Segoe UI', system-ui, sans-serif; +} + +[data-theme="light"] { + --bg: #f8fafc; + --surface: #ffffff; + --surface2: #f1f5f9; + --border: #e2e8f0; + --text: #0f172a; + --text-muted:#64748b; + --accent: #6366f1; + --accent-h: #4f46e5; + --user-bg: #6366f1; + --ai-bg: #f1f5f9; +} + +html, body { height: 100%; overflow: hidden; } + +body { + background: var(--bg); + color: var(--text); + font-family: var(--font); + font-size: 15px; + line-height: 1.6; + display: flex; + transition: background .2s, color .2s; +} + +/* ---- top-level layout: header on top, then sidebar + chat ---- */ +#app { + display: flex; + flex-direction: column; + width: 100%; + height: 100vh; +} + +#body-row { + display: flex; + flex-direction: row; + flex: 1; + overflow: hidden; +} + +/* ---- sidebar ---- */ +#sidebar { + width: var(--sidebar-w); + min-width: var(--sidebar-w); + background: var(--surface); + border-right: 1px solid var(--border); + display: flex; + flex-direction: column; + overflow: hidden; + transition: width .25s ease, min-width .25s ease, border-color .2s; + flex-shrink: 0; +} +#sidebar.collapsed { + width: 0; + min-width: 0; + border-right-width: 0; +} + +#sidebar-header { + display: flex; + align-items: center; + justify-content: space-between; + padding: 14px 16px 10px; + flex-shrink: 0; +} +#sidebar-header span { + font-size: 0.75rem; + font-weight: 600; + letter-spacing: .06em; + text-transform: uppercase; + color: var(--text-muted); + white-space: nowrap; +} +#new-conv-btn { + background: var(--accent); + border: none; + border-radius: 8px; + color: #fff; + cursor: pointer; + font-size: 0.78rem; + font-weight: 600; + padding: 5px 10px; + white-space: nowrap; + transition: background .15s; +} +#new-conv-btn:hover { background: var(--accent-h); } + +#conv-list { + flex: 1; + overflow-y: auto; + padding: 4px 8px 12px; +} +#conv-list::-webkit-scrollbar { width: 3px; } +#conv-list::-webkit-scrollbar-thumb { background: var(--border); border-radius: 3px; } + +.conv-item { + display: flex; + flex-direction: column; + gap: 2px; + padding: 8px 10px; + border-radius: 8px; + cursor: pointer; + transition: background .12s; + white-space: nowrap; + overflow: hidden; +} +.conv-item:hover { background: var(--surface2); } +.conv-item.active { background: var(--surface2); } +.conv-item.active .conv-name { color: var(--accent); } +.conv-name { + font-size: 0.86rem; + font-weight: 500; + overflow: hidden; + text-overflow: ellipsis; + color: var(--text); +} +.conv-meta { + font-size: 0.74rem; + color: var(--text-muted); +} + +/* ---- header (full-width, top of page) ---- */ +#header { + display: flex; + align-items: center; + justify-content: space-between; + padding: 14px 20px; + border-bottom: 1px solid var(--border); + background: var(--surface); + flex-shrink: 0; + width: 100%; + transition: background .2s, border-color .2s; +} + +/* ---- chat panel ---- */ +#main { + flex: 1; + display: flex; + flex-direction: column; + min-width: 0; + max-width: 820px; + margin: 0 auto; + width: 100%; +} +#header-left { display: flex; align-items: center; gap: 10px; } +#header h1 { + font-size: 1.1rem; + font-weight: 600; + letter-spacing: -0.01em; +} +#header-right { display: flex; align-items: center; gap: 14px; } +#sidebar-toggle { + background: none; + border: 1px solid var(--border); + border-radius: 8px; + color: var(--text-muted); + cursor: pointer; + font-size: 1rem; + padding: 4px 8px; + line-height: 1; + transition: border-color .15s, color .15s; +} +#sidebar-toggle:hover { border-color: var(--accent); color: var(--accent); } +#status { + display: flex; + align-items: center; + gap: 6px; + font-size: 0.8rem; + color: var(--text-muted); +} +#theme-btn { + background: none; + border: 1px solid var(--border); + border-radius: 8px; + color: var(--text-muted); + cursor: pointer; + font-size: 1rem; + line-height: 1; + padding: 4px 8px; + transition: border-color .15s, color .15s; +} +#theme-btn:hover { border-color: var(--accent); color: var(--accent); } +#status-dot { + width: 8px; height: 8px; + border-radius: 50%; + background: #ef4444; + transition: background .3s; +} +#status-dot.connected { background: #22c55e; } +#status-dot.thinking { background: #f59e0b; animation: pulse 1s infinite; } +@keyframes pulse { 0%,100%{opacity:1} 50%{opacity:.4} } + +/* ---- messages ---- */ +/* Outer scroll container — must be separate from the flex container to allow scrolling to top */ +#messages-wrap { + flex: 1; + overflow-y: auto; + scroll-behavior: smooth; +} +#messages-wrap::-webkit-scrollbar { width: 4px; } +#messages-wrap::-webkit-scrollbar-track { background: transparent; } +#messages-wrap::-webkit-scrollbar-thumb { background: var(--border); border-radius: 4px; } + +/* Inner flex container — min-height: 100% + justify-content: flex-end anchors messages to bottom */ +#messages { + display: flex; + flex-direction: column; + justify-content: flex-end; + min-height: 100%; + padding: 20px; + gap: 16px; +} + +.msg-row { + display: flex; + gap: 10px; + max-width: 80%; + animation: fadeUp .2s ease; +} +@keyframes fadeUp { + from { opacity:0; transform:translateY(8px); } + to { opacity:1; transform:translateY(0); } +} +.msg-row.user { align-self: flex-end; } +.msg-row.ai { align-self: flex-start; } +.msg-row.system { align-self: center; } + +.bubble { + padding: 10px 14px; + border-radius: var(--radius); + word-break: break-word; + white-space: pre-wrap; + max-width: 100%; + font-size: 0.92rem; +} +.user .bubble { background: var(--user-bg); color: #fff; border-bottom-right-radius: 4px; } +.ai .bubble { background: var(--ai-bg); border: 1px solid var(--border); border-bottom-left-radius: 4px; transition: background .2s, border-color .2s; } +.system .bubble { background: transparent; border: 1px dashed var(--border); color: var(--text-muted); font-size: 0.82rem; padding: 6px 12px; border-radius: 8px; } + +.bubble code { background: var(--surface2); border-radius: 4px; padding: 1px 5px; font-size: .85em; font-family: 'Fira Code','Cascadia Code',monospace; } +.bubble pre { background: var(--surface2); border: 1px solid var(--border); border-radius: 8px; padding: 12px; overflow-x: auto; margin-top: 6px; } +.bubble pre code { background: none; padding: 0; } + +/* thinking dots — sits between scroll area and input, always above the input box */ +#thinking { display:none; align-self:flex-start; gap:10px; padding: 4px 20px 8px; flex-shrink: 0; } +#thinking.visible { display:flex; } +.thinking-bubble { background:var(--ai-bg); border:1px solid var(--border); border-radius:var(--radius); border-bottom-left-radius:4px; padding:12px 16px; } +.dots span { display:inline-block; width:6px; height:6px; background:var(--text-muted); border-radius:50%; margin:0 2px; animation:bounce .9s infinite; } +.dots span:nth-child(2) { animation-delay:.15s; } +.dots span:nth-child(3) { animation-delay:.3s; } +@keyframes bounce { 0%,60%,100%{transform:translateY(0)} 30%{transform:translateY(-6px)} } + +/* ---- empty state ---- */ +#empty { flex:1; display:flex; flex-direction:column; align-items:center; justify-content:center; gap:12px; color:var(--text-muted); pointer-events:none; } +#empty .icon { font-size:2.5rem; } +#empty p { font-size:0.9rem; } + +/* ---- input area ---- */ +#input-area { + padding: 14px 20px; + border-top: 1px solid var(--border); + background: var(--surface); + display: flex; + gap: 10px; + align-items: flex-end; + flex-shrink: 0; +} +#msg-input { + flex: 1; + background: var(--surface2); + border: 1px solid var(--border); + border-radius: 10px; + color: var(--text); + font-family: var(--font); + font-size: 0.92rem; + padding: 10px 14px; + resize: none; + outline: none; + min-height: 42px; + max-height: 160px; + transition: border-color .2s; + overflow-y: auto; +} +#msg-input:focus { border-color: var(--accent); } +#msg-input::placeholder { color: var(--text-muted); } + +#send-btn { + background: var(--accent); + border: none; + border-radius: 10px; + color: #fff; + cursor: pointer; + padding: 10px 16px; + font-size: 0.9rem; + font-weight: 600; + transition: background .15s, transform .1s; + height: 42px; + white-space: nowrap; +} +#send-btn:hover { background: var(--accent-h); } +#send-btn:active { transform: scale(.97); } +#send-btn:disabled { background: var(--border); cursor: not-allowed; } diff --git a/app/channels/static/web_channel.js b/app/channels/static/web_channel.js new file mode 100644 index 0000000..3fe1bc4 --- /dev/null +++ b/app/channels/static/web_channel.js @@ -0,0 +1,248 @@ +(function() { + const wsProto = location.protocol === 'https:' ? 'wss' : 'ws'; + const wsUrl = `${wsProto}://${location.host}/ws`; + + let ws = null; + let reconnectDelay = 1000; + let activeConvId = null; + + const messagesEl = document.getElementById('messages'); + const scrollEl = document.getElementById('messages-wrap'); + const thinkingEl = document.getElementById('thinking'); + const inputEl = document.getElementById('msg-input'); + const sendBtn = document.getElementById('send-btn'); + const statusDot = document.getElementById('status-dot'); + const statusTxt = document.getElementById('status-text'); + const themeBtn = document.getElementById('theme-btn'); + const sidebarEl = document.getElementById('sidebar'); + const toggleBtn = document.getElementById('sidebar-toggle'); + const convListEl = document.getElementById('conv-list'); + const newConvBtn = document.getElementById('new-conv-btn'); + + // ---- theme ---- + const savedTheme = localStorage.getItem('ab-theme') || 'dark'; + applyTheme(savedTheme); + function applyTheme(theme) { + document.documentElement.setAttribute('data-theme', theme); + themeBtn.textContent = theme === 'dark' ? '☀' : '☾'; + localStorage.setItem('ab-theme', theme); + } + themeBtn.addEventListener('click', () => { + applyTheme(document.documentElement.getAttribute('data-theme') === 'dark' ? 'light' : 'dark'); + }); + + // ---- sidebar toggle ---- + const sidebarOpen = localStorage.getItem('ab-sidebar') !== 'closed'; + if (!sidebarOpen) sidebarEl.classList.add('collapsed'); + toggleBtn.addEventListener('click', () => { + const collapsed = sidebarEl.classList.toggle('collapsed'); + localStorage.setItem('ab-sidebar', collapsed ? 'closed' : 'open'); + if (!collapsed) loadConversations(false); + }); + + // ---- conversations ---- + async function loadConversations(populateMessages) { + try { + const url = '/api/conversations'; + const res = await fetch(url); + if (!res.ok) return; + const { conversations, active_id } = await res.json(); + activeConvId = active_id; + renderConversations(conversations, active_id); + if (populateMessages && active_id) await loadMessages(active_id); + } catch (e) { /* server may not be fully up yet */ } + } + + async function loadMessages(convId) { + if (!convId) return; + try { + const url = `/api/messages?conv_id=${convId}`; + const res = await fetch(url); + if (!res.ok) return; + const { messages } = await res.json(); + if (!messages || !messages.length) return; + const empty = document.getElementById('empty'); + if (empty) empty.style.display = 'none'; + messages.forEach(msg => appendMessage(msg.content, msg.role === 'user' ? 'user' : 'ai')); + } catch (e) { /* ignore */ } + } + + function fmtDate(iso) { + if (!iso) return ''; + const d = new Date(iso); + const now = new Date(); + const diffDays = Math.floor((now - d) / 86400000); + if (diffDays === 0) return d.toLocaleTimeString([], {hour:'2-digit', minute:'2-digit'}); + if (diffDays === 1) return 'Yesterday'; + if (diffDays < 7) return d.toLocaleDateString([], {weekday:'short'}); + return d.toLocaleDateString([], {month:'short', day:'numeric'}); + } + + function renderConversations(list, activeId) { + convListEl.innerHTML = ''; + if (!list || !list.length) { + convListEl.innerHTML = '

No conversations yet

'; + return; + } + list.forEach(conv => { + const item = document.createElement('div'); + item.className = 'conv-item' + (conv.id === activeId ? ' active' : ''); + item.dataset.id = conv.id; + item.innerHTML = `${escapeHtml(conv.name || 'Untitled')}` + + `${fmtDate(conv.updated_at)} · ${conv.message_count || 0} msgs`; + item.addEventListener('click', () => loadConv(conv.id)); + convListEl.appendChild(item); + }); + } + + function loadConv(id) { + if (!ws || ws.readyState !== WebSocket.OPEN) return; + ws.send(JSON.stringify({ type: 'message', content: `/load ${id}` })); + activeConvId = id; + convListEl.querySelectorAll('.conv-item').forEach(el => { + el.classList.toggle('active', parseInt(el.dataset.id) === id); + }); + clearMessages(); + loadMessages(id); + } + + newConvBtn.addEventListener('click', () => { + if (!ws || ws.readyState !== WebSocket.OPEN) return; + ws.send(JSON.stringify({ type: 'message', content: '/new' })); + clearMessages(); + // list refresh is driven by the ws.onmessage handler when server responds with "created" + }); + + function clearMessages() { + messagesEl.querySelectorAll('.msg-row').forEach(el => el.remove()); + const empty = document.getElementById('empty'); + if (empty) { + empty.style.display = ''; + } else { + const d = document.createElement('div'); + d.id = 'empty'; + d.innerHTML = '
✦

Ask me anything, or try /help for available commands.

'; + messagesEl.appendChild(d); + } + hideThinking(); + } + + // ---- status ---- + function setStatus(state, text) { + statusDot.className = state; + statusTxt.textContent = text; + } + + // ---- WebSocket ---- + function connect() { + setStatus('', 'Connecting…'); + ws = new WebSocket(wsUrl); + + ws.onopen = () => { + reconnectDelay = 1000; + setStatus('connected', 'Connected'); + sendBtn.disabled = false; + clearMessages(); // always reset DOM before reloading — prevents duplicates on reconnect + loadConversations(true); + }; + + ws.onclose = () => { + setStatus('', 'Disconnected'); + sendBtn.disabled = true; + hideThinking(); + setTimeout(connect, reconnectDelay); + reconnectDelay = Math.min(reconnectDelay * 2, 30000); + }; + + ws.onerror = () => setStatus('', 'Error'); + + ws.onmessage = (evt) => { + hideThinking(); + try { + const data = JSON.parse(evt.data); + if (data.type === 'message') { + appendMessage(data.content, 'ai'); + // agent_loop() calls _store.touch() after every response, so the + // sidebar's updated_at and message count change — refresh it + setTimeout(() => loadConversations(false), 300); + } else if (data.type === 'system') { + appendMessage(data.content, 'system'); + // always refresh after any system message; conversation-mutating + // commands (new, load, fork, rename) change the sidebar list too + setTimeout(() => loadConversations(false), 150); + } + } catch (e) { + appendMessage(evt.data, 'ai'); + setTimeout(() => loadConversations(false), 300); + } + }; + } + + function showThinking() { + thinkingEl.classList.add('visible'); + setStatus('thinking', 'Thinking…'); + scrollBottom(); + } + function hideThinking() { + thinkingEl.classList.remove('visible'); + if (ws && ws.readyState === WebSocket.OPEN) setStatus('connected', 'Connected'); + } + + // ---- rendering ---- + function escapeHtml(t) { + return String(t).replace(/&/g,'&').replace(//g,'>'); + } + function formatMessage(text) { + text = escapeHtml(text); + text = text.replace(/```[\w]*\n?([\s\S]*?)```/g, '
$1
'); + text = text.replace(/`([^`]+)`/g, '$1'); + return text; + } + function appendMessage(content, role) { + const empty = document.getElementById('empty'); + if (empty) empty.style.display = 'none'; + + const row = document.createElement('div'); + row.className = `msg-row ${role}`; + const bubble = document.createElement('div'); + bubble.className = 'bubble'; + bubble.innerHTML = role === 'system' ? escapeHtml(content) : formatMessage(content); + row.appendChild(bubble); + messagesEl.appendChild(row); + scrollBottom(); + } + function scrollBottom() { scrollEl.scrollTop = scrollEl.scrollHeight; } + + // ---- send ---- + function send() { + const text = inputEl.value.trim(); + if (!text || !ws || ws.readyState !== WebSocket.OPEN) return; + appendMessage(text, 'user'); + ws.send(JSON.stringify({ type: 'message', content: text })); + inputEl.value = ''; + inputEl.style.height = '42px'; + if (text === '/new') { + clearMessages(); + } else if (/^\/load\s+\d+/.test(text)) { + const id = parseInt(text.split(/\s+/)[1]); + clearMessages(); + loadMessages(id); + } else if (!text.startsWith('/')) { + showThinking(); + } + } + + sendBtn.addEventListener('click', send); + inputEl.addEventListener('keydown', (e) => { + if (e.key === 'Enter' && !e.shiftKey) { e.preventDefault(); send(); } + }); + inputEl.addEventListener('input', () => { + inputEl.style.height = 'auto'; + inputEl.style.height = Math.min(inputEl.scrollHeight, 160) + 'px'; + }); + + // sidebar pre-populate (messages already loaded via ws.onopen → loadConversations(true)) + if (sidebarOpen) loadConversations(false); + + connect(); +})(); diff --git a/app/channels/web_channel.py b/app/channels/web_channel.py new file mode 100644 index 0000000..c7b768a --- /dev/null +++ b/app/channels/web_channel.py @@ -0,0 +1,349 @@ +"""FastHTML web channel — serves a chat UI and a JSON WebSocket endpoint. + +The channel exposes two endpoints on the same uvicorn server: + + GET / — FastHTML chat UI (HTML page, served to browsers) + WS /ws — WebSocket endpoint (JSON framing) + +WebSocket message framing:: + + {"type": "message", "content": "..."} + +Plain text is also accepted as a convenience. +""" + +from __future__ import annotations + +import asyncio +import json +import logging +import uuid +import uvicorn +from pathlib import Path +from fasthtml.common import ( + Button, Div, Head, Html, Link, Meta, Script, Span, + Textarea, Title, Body, H1, P, fast_app, +) +from starlette.routing import WebSocketRoute +from starlette.websockets import WebSocket, WebSocketDisconnect + +from .channel import Channel, ChannelType +from .message import IncomingMessage, OutgoingMessage +from .message_queue import MessageQueue + +log = logging.getLogger(__name__) + + +# --------------------------------------------------------------------------- # +# FastHTML page builder # +# --------------------------------------------------------------------------- # + +def _build_page() -> Html: + return Html( + Head( + Meta(charset="utf-8"), + Meta(name="viewport", content="width=device-width, initial-scale=1"), + Title("anotherbot"), + Link(rel="preconnect", href="https://fonts.googleapis.com"), + Link(rel="stylesheet", + href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600&display=swap"), + Link(rel="stylesheet", href="/static/web_channel.css"), + ), + Body( + Div( + # ---- Header (full width) ---- + Div( + Div( + Button("☰", id="sidebar-toggle", title="Toggle sidebar"), + H1("anotherbot"), + id="header-left", + ), + Div( + Div( + Span(id="status-dot"), + Span("Connecting…", id="status-text"), + id="status", + ), + Button("☾", id="theme-btn", title="Toggle light/dark"), + id="header-right", + ), + id="header", + ), + # ---- Body row: sidebar + chat ---- + Div( + # Sidebar + Div( + Div( + Span("Conversations"), + Button("+ New", id="new-conv-btn"), + id="sidebar-header", + ), + Div(id="conv-list"), + id="sidebar", + ), + # Chat panel + Div( + # Scroll container (outer) + messages (inner flex, bottom-anchored) + Div( + Div( + Div( + Div("✦", cls="icon"), + P("Ask me anything, or try /help for available commands."), + id="empty", + ), + id="messages", + ), + id="messages-wrap", + ), + # Thinking dots — always just above the input box + Div( + Div(Div(Span(), Span(), Span(), cls="dots"), cls="thinking-bubble"), + id="thinking", + ), + # Input area + Div( + Textarea( + id="msg-input", + placeholder="Message anotherbot… (Enter to send, Shift+Enter for newline)", + autocomplete="off", + rows="1", + ), + Button("Send", id="send-btn", disabled=True), + id="input-area", + ), + id="main", + ), + id="body-row", + ), + id="app", + ), + Script(src="/static/web_channel.js"), + ), + lang="en", + ) + + +# --------------------------------------------------------------------------- # +# Channel class # +# --------------------------------------------------------------------------- # + +class WebChannel(Channel): + """FastHTML web channel. + + Serves the chat UI at ``GET /`` and accepts WebSocket connections at + ``WS /ws``. Multiple concurrent clients are supported — each gets a + unique UUID stored in ``_connections``. + """ + + def __init__( + self, + mq: MessageQueue, + host: str = "127.0.0.1", + port: int = 8765, + ) -> None: + self.mq = mq + self.host = host + self.port = port + self.stopped: bool = False + self._connections: dict[str, WebSocket] = {} + self._send_locks: dict[str, asyncio.Lock] = {} + self._conn_lock = asyncio.Lock() + mq.register(self, self.send_message) + + # -- Channel ABC -------------------------------------------------------- + + @property + def has_stopped(self) -> bool: + return self.stopped + + def clear_stopped(self) -> None: + self.stopped = False + + @property + def channel_type(self) -> ChannelType: + return ChannelType.WEB + + @property + def default_metadata(self) -> dict: + return {} + + async def error_handler(self, update: object, context: object) -> None: + log.error(f"WebChannel error: {context}") + + async def process_message(self, message: object) -> None: + pass # handled inline in the WebSocket endpoint + + # -- Lifecycle ---------------------------------------------------------- + + def start(self) -> None: + """Build the FastHTML app + WebSocket route.""" + log.info(f"Building web channel on {self.host}:{self.port}") + + self._fasthtml_app, rt = fast_app(hdrs=()) + + @rt("/") + def index(): + return _build_page() + + @rt("/api/conversations") + def conversations_api(req): + from starlette.responses import JSONResponse + from ..infra.conversations import ConversationStore + from ..core import runtime as _rt + store = ConversationStore() + ch = ChannelType.WEB.value + convs = store.list(ch) + active_id = _rt.get(f"conversation_id:{ch}") + return JSONResponse({"conversations": convs, "active_id": active_id}) + + @rt("/api/messages") + def messages_api(req): + from starlette.responses import JSONResponse, Response + from ..infra.conversations import ConversationStore + try: + conv_id = int(req.query_params.get("conv_id", 0)) + except (ValueError, TypeError): + return Response(status_code=400) + if not conv_id: + return Response(status_code=400) + store = ConversationStore() + conv = store.get(conv_id) + if conv is None or conv.get("channel") != ChannelType.WEB.value: + return Response(status_code=404) + msgs = store.load_messages(conv_id) + return JSONResponse({"messages": msgs}) + + @rt("/api/status") + def status_api(req): + from starlette.responses import JSONResponse + from .. import config as _cfg + from ..core import runtime as _rt + model = _rt.get("model", _cfg.get("model", "AI")) + return JSONResponse({"model": model}) + + # Starlette WebSocket route (low-level, for multi-client management) + async def _ws_endpoint(ws: WebSocket) -> None: + await ws.accept() + + client_id = str(uuid.uuid4()) + log.info(f"WebSocket client connected: {client_id}") + + async with self._conn_lock: + self._connections[client_id] = ws + + try: + while True: + raw = await ws.receive_text() + if len(raw) > 65_536: + await ws.close(code=1009, reason="Message too large") + return + content = self._extract_content(raw) + if not content: + continue + + if content.startswith("/"): + cmd = content[1:].split(maxsplit=1) + if not cmd: + continue + name = cmd[0].lower() + # /whoami is handled inline — it needs the per-connection client_id. + # All other commands (/help, /status, /stop, /new, /load, …) are + # forwarded to BackgroundAgent's CommandRegistry for consistency + # with the Telegram and Discord channels. + if name == "whoami": + await self._safe_send_json( + client_id, + {"type": "system", "content": f"Connection ID: {client_id}"}, + ) + continue + + await self.mq.incoming.put( + IncomingMessage( + content=content, + channel=ChannelType.WEB, + metadata={ + "websocket_id": client_id, + "is_command": content.startswith("/"), + }, + ) + ) + except WebSocketDisconnect: + log.info(f"WebSocket client disconnected: {client_id}") + except Exception: + log.exception(f"WebSocket error for client {client_id}") + finally: + async with self._conn_lock: + self._connections.pop(client_id, None) + self._send_locks.pop(client_id, None) + + # Mount the WebSocket route on the FastHTML (Starlette) app + self._fasthtml_app.router.routes.insert( + 0, WebSocketRoute("/ws", _ws_endpoint) + ) + + # Serve static assets (CSS, JS) + from starlette.routing import Mount + from starlette.staticfiles import StaticFiles + static_dir = Path(__file__).parent / "static" + self._fasthtml_app.router.routes.append( + Mount("/static", StaticFiles(directory=str(static_dir)), name="static") + ) + + async def run_polling(self) -> None: + """Start uvicorn and serve until cancelled.""" + config = uvicorn.Config( + app=self._fasthtml_app, + host=self.host, + port=self.port, + log_level="info", + ) + server = uvicorn.Server(config) + log.info(f"Web UI at http://{self.host}:{self.port}/") + log.info(f"WebSocket at ws://{self.host}:{self.port}/ws") + await server.serve() + + # -- Message delivery --------------------------------------------------- + + async def send_message(self, message: OutgoingMessage) -> None: + client_id = message.metadata.get("websocket_id") + is_command = message.metadata.get("is_command", False) + msg_type = "system" if is_command else "message" + payload = {"type": msg_type, "content": message.content} + if client_id: + await self._safe_send_json(client_id, payload) + else: + # No specific client (e.g. scheduled task delivery) — broadcast to all connected clients + async with self._conn_lock: + targets = list(self._connections.keys()) + for cid in targets: + await self._safe_send_json(cid, payload) + + # -- Helpers ------------------------------------------------------------ + + @staticmethod + def _extract_content(raw: str) -> str | None: + raw = raw.strip() + if not raw: + return None + try: + data = json.loads(raw) + except (json.JSONDecodeError, TypeError): + return raw + if isinstance(data, dict) and data.get("type") == "message": + return str(data.get("content") or "").strip() or None + return raw + + async def _safe_send_json(self, client_id: str, payload: dict) -> None: + async with self._conn_lock: + ws = self._connections.get(client_id) + if ws is None: + return + lock = self._send_locks.setdefault(client_id, asyncio.Lock()) + async with lock: + try: + await ws.send_json(payload) + except Exception: + log.exception(f"Failed to send to WebSocket client {client_id}") + async with self._conn_lock: + self._connections.pop(client_id, None) + self._send_locks.pop(client_id, None) diff --git a/app/config.py b/app/config.py index a8f9917..ed9f4d8 100644 --- a/app/config.py +++ b/app/config.py @@ -37,6 +37,13 @@ def load(path: Path | str = HOME_CONFIG_PATH) -> None: _config.setdefault("discord", {})["TOKEN"] = v if v := os.environ.get("DISCORD_ALLOW_FROM"): _config.setdefault("discord", {})["ALLOW_FROM"] = [int(x.strip()) for x in v.split(",") if x.strip()] + if v := os.environ.get("WEBSOCKET_HOST"): + _config.setdefault("websocket", {})["HOST"] = v + if v := os.environ.get("WEBSOCKET_PORT"): + try: + _config.setdefault("websocket", {})["PORT"] = int(v) + except ValueError: + raise ValueError(f"WEBSOCKET_PORT must be an integer, got: {v!r}") from None def get(key: str, default=None): @@ -64,4 +71,8 @@ def get_default_config() -> str: [discord] TOKEN = "" ALLOW_FROM = [] # List of allowed Discord user IDs (integers). Empty means allow all. + +[websocket] +HOST = "127.0.0.1" +PORT = 8765 """ diff --git a/pyproject.toml b/pyproject.toml index 54ad969..f20fb52 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -10,6 +10,8 @@ dependencies = [ "ddgs>=9.14.1", "geocoder>=1.38.1", "discord-py>=2.7.1", + "python-fasthtml>=0.14.2", + "uvicorn[standard]>=0.48.0", ] [dependency-groups] diff --git a/tests/test_web_channel.py b/tests/test_web_channel.py new file mode 100644 index 0000000..3cee7bb --- /dev/null +++ b/tests/test_web_channel.py @@ -0,0 +1,289 @@ +import json +import pytest +from pathlib import Path +from unittest.mock import AsyncMock, MagicMock + +from app.channels.channel import ChannelType +from app.channels.message import OutgoingMessage +from app.channels.message_queue import MessageQueue +from app.channels.web_channel import WebChannel, _build_page + + +def make_web_channel(): + mq = MessageQueue() + ch = WebChannel(mq=mq, host="127.0.0.1", port=8765) + return ch, mq + + +# --- Initialization --- + +def test_registers_delivery_function(): + ch, mq = make_web_channel() + assert ch in mq._delivery + + +def test_stores_host_and_port(): + ch, _ = make_web_channel() + assert ch.host == "127.0.0.1" + assert ch.port == 8765 + + +def test_initial_stopped_false(): + ch, _ = make_web_channel() + assert ch.has_stopped is False + + +def test_clear_stopped_resets_state(): + ch, _ = make_web_channel() + ch.stopped = True + ch.clear_stopped() + assert ch.has_stopped is False + + +def test_channel_type(): + ch, _ = make_web_channel() + assert ch.channel_type == ChannelType.WEB + + +def test_default_metadata_empty(): + ch, _ = make_web_channel() + assert ch.default_metadata == {} + + +# --- _extract_content --- + +def test_extract_plain_text(): + assert WebChannel._extract_content("hello world") == "hello world" + + +def test_extract_json_message_framing(): + raw = json.dumps({"type": "message", "content": "hi there"}) + assert WebChannel._extract_content(raw) == "hi there" + + +def test_extract_trims_content_whitespace(): + raw = json.dumps({"type": "message", "content": " trimmed "}) + assert WebChannel._extract_content(raw) == "trimmed" + + +def test_extract_empty_string_returns_none(): + assert WebChannel._extract_content("") is None + + +def test_extract_whitespace_only_returns_none(): + assert WebChannel._extract_content(" ") is None + + +def test_extract_invalid_json_returns_raw(): + assert WebChannel._extract_content("{not valid json}") == "{not valid json}" + + +def test_extract_json_wrong_type_returns_raw(): + raw = json.dumps({"type": "system", "content": "ignored"}) + assert WebChannel._extract_content(raw) == raw + + +def test_extract_json_null_content_returns_none(): + raw = json.dumps({"type": "message", "content": None}) + assert WebChannel._extract_content(raw) is None + + +def test_extract_json_empty_content_returns_none(): + raw = json.dumps({"type": "message", "content": " "}) + assert WebChannel._extract_content(raw) is None + + +# --- _build_page: static file references --- + +def test_build_page_references_static_css(): + html = str(_build_page()) + assert "/static/web_channel.css" in html + + +def test_build_page_references_static_js(): + html = str(_build_page()) + assert "/static/web_channel.js" in html + + +def test_build_page_has_no_inline_css(): + html = str(_build_page()) + # --sidebar-w is a custom variable only found in our CSS file, not inline + assert "--sidebar-w" not in html + + +def test_build_page_has_no_inline_js(): + html = str(_build_page()) + # connect() is the WebSocket reconnect function from our JS IIFE + assert "function connect()" not in html + + +def test_build_page_key_structural_elements(): + html = str(_build_page()) + for element_id in ("messages", "input-area", "sidebar", "header", "messages-wrap", "thinking"): + assert f'id="{element_id}"' in html, f"Missing element #{element_id}" + + +# --- Static files on disk --- + +_STATIC_DIR = Path(__file__).parent.parent / "app" / "channels" / "static" + + +def test_static_css_file_exists(): + assert (_STATIC_DIR / "web_channel.css").is_file() + + +def test_static_js_file_exists(): + assert (_STATIC_DIR / "web_channel.js").is_file() + + +def test_static_css_is_non_empty(): + assert (_STATIC_DIR / "web_channel.css").stat().st_size > 0 + + +def test_static_js_is_non_empty(): + assert (_STATIC_DIR / "web_channel.js").stat().st_size > 0 + + +def test_static_css_has_theme_variables(): + content = (_STATIC_DIR / "web_channel.css").read_text() + assert "--bg:" in content + assert "--accent:" in content + + + +def test_static_js_has_iife(): + content = (_STATIC_DIR / "web_channel.js").read_text() + assert "(function()" in content + + +def test_static_js_regex_uses_single_backslash(): + content = (_STATIC_DIR / "web_channel.js").read_text() + # The formatMessage regex must use single-backslash escapes (\w, \s, \S), + # not the doubled Python-string escapes (\\w, \\s, \\S) that would be a bug. + assert r"[\w]*" in content + assert r"[\s\S]" in content + assert r"[\\w]" not in content + + +# --- send_message --- + +@pytest.mark.asyncio +async def test_send_message_targeted(): + ch, _ = make_web_channel() + mock_ws = AsyncMock() + ch._connections["conn1"] = mock_ws + + msg = OutgoingMessage(content="hello", channel=ChannelType.WEB, metadata={"websocket_id": "conn1"}) + await ch.send_message(msg) + + mock_ws.send_json.assert_called_once_with({"type": "message", "content": "hello"}) + + +def test_send_message_uses_system_type_for_commands(): + ch, _ = make_web_channel() + mock_ws = AsyncMock() + ch._connections["conn1"] = mock_ws + + # Verify the type selection logic directly (send_message is async but we + # can inspect metadata → msg_type mapping without awaiting). + is_command = True + msg_type = "system" if is_command else "message" + assert msg_type == "system" + + is_command = False + msg_type = "system" if is_command else "message" + assert msg_type == "message" + + +@pytest.mark.asyncio +async def test_send_message_sends_system_type_when_is_command(): + ch, _ = make_web_channel() + mock_ws = AsyncMock() + ch._connections["conn1"] = mock_ws + + msg = OutgoingMessage(content="ok", channel=ChannelType.WEB, + metadata={"websocket_id": "conn1", "is_command": True}) + await ch.send_message(msg) + + mock_ws.send_json.assert_called_once_with({"type": "system", "content": "ok"}) + + +@pytest.mark.asyncio +async def test_send_message_broadcasts_when_no_websocket_id(): + ch, _ = make_web_channel() + ws1, ws2 = AsyncMock(), AsyncMock() + ch._connections["a"] = ws1 + ch._connections["b"] = ws2 + + msg = OutgoingMessage(content="broadcast", channel=ChannelType.WEB, metadata={}) + await ch.send_message(msg) + + ws1.send_json.assert_called_once_with({"type": "message", "content": "broadcast"}) + ws2.send_json.assert_called_once_with({"type": "message", "content": "broadcast"}) + + +@pytest.mark.asyncio +async def test_send_message_skips_missing_client(): + ch, _ = make_web_channel() + # No connection registered — should not raise + msg = OutgoingMessage(content="hello", channel=ChannelType.WEB, metadata={"websocket_id": "ghost"}) + await ch.send_message(msg) # must not raise + + +@pytest.mark.asyncio +async def test_send_message_removes_dead_connection_on_error(): + ch, _ = make_web_channel() + mock_ws = AsyncMock() + mock_ws.send_json.side_effect = Exception("broken pipe") + ch._connections["dead"] = mock_ws + + msg = OutgoingMessage(content="oops", channel=ChannelType.WEB, metadata={"websocket_id": "dead"}) + await ch.send_message(msg) + + assert "dead" not in ch._connections + + +# --- /api/messages channel isolation --- + +def test_api_messages_rejects_foreign_channel_conv(): + from unittest.mock import patch + ch, _ = make_web_channel() + ch.start() + + from starlette.testclient import TestClient + # Conversation exists but belongs to 'telegram', not 'web' + foreign_conv = {"id": 5, "channel": "telegram", "name": "TG conv"} + with patch("app.infra.conversations.ConversationStore.get", return_value=foreign_conv): + client = TestClient(ch._fasthtml_app, raise_server_exceptions=True) + resp = client.get("/api/messages?conv_id=5") + assert resp.status_code == 404 + + +def test_api_messages_rejects_missing_conv(): + from unittest.mock import patch + ch, _ = make_web_channel() + ch.start() + + from starlette.testclient import TestClient + with patch("app.infra.conversations.ConversationStore.get", return_value=None): + client = TestClient(ch._fasthtml_app, raise_server_exceptions=True) + resp = client.get("/api/messages?conv_id=99") + assert resp.status_code == 404 + + +# --- start(): route registration --- + +def test_start_registers_websocket_route(): + from starlette.routing import WebSocketRoute + ch, _ = make_web_channel() + ch.start() + ws_routes = [r for r in ch._fasthtml_app.router.routes if isinstance(r, WebSocketRoute)] + assert any(r.path == "/ws" for r in ws_routes) + + +def test_start_mounts_static_files(): + from starlette.routing import Mount + ch, _ = make_web_channel() + ch.start() + mounts = [r for r in ch._fasthtml_app.router.routes if isinstance(r, Mount)] + assert any(getattr(r, "path", None) == "/static" for r in mounts) diff --git a/uv.lock b/uv.lock index f33ee6c..ae9276e 100644 --- a/uv.lock +++ b/uv.lock @@ -136,6 +136,79 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/38/0e/27be9fdef66e72d64c0cdc3cc2823101b80585f8119b5c112c2e8f5f7dab/anyio-4.12.1-py3-none-any.whl", hash = "sha256:d405828884fc140aa80a3c667b8beed277f1dfedec42ba031bd6ac3db606ab6c", size = 113592, upload-time = "2026-01-06T11:45:19.497Z" }, ] +[[package]] +name = "apsw" +version = "3.53.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/5a/5f/0fabac91b26d222f5ad1bf8af92f6c80d82af2e50dafb401a250a02b2f53/apsw-3.53.1.0.tar.gz", hash = "sha256:4f8978ae8c7c405d0133a6ea590f3342f839143bdf39e46029cb36e2fa418692", size = 1242069, upload-time = "2026-05-05T18:49:59.721Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2b/a6/6fe7389415d0b57879870fc8a40800b13dd8efd346a2979745c00eab6880/apsw-3.53.1.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:92c2597c5d5b1b916f3e90384a6361c7b553d918a9591c1b71d1321f381b2cc7", size = 3271352, upload-time = "2026-05-05T18:48:20.597Z" }, + { url = "https://files.pythonhosted.org/packages/23/9c/0b33ce05221eedeb71a644618c417f3349dd5c785ad860931199cd5657ff/apsw-3.53.1.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ab7a8a0c61e784b429b8b109fa15fe41561bf40cc3fe9fa8b4afc44cdfa18e39", size = 3067463, upload-time = "2026-05-05T18:48:22.385Z" }, + { url = "https://files.pythonhosted.org/packages/ac/bf/94352cdd603e159efb0de1669f19e75579171158f5331adeba08538ad8b4/apsw-3.53.1.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:ee7e61b7496a8cdecd238d154b525e48531e99ba6def117466a6dcfbc01d6299", size = 3486388, upload-time = "2026-05-05T18:48:23.997Z" }, + { url = "https://files.pythonhosted.org/packages/76/0b/c793186312df0ad7ce49ad6215f6184dd08a9d87f9dd9e1b09cf0548caf2/apsw-3.53.1.0-cp312-cp312-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:1eaf42de9782b1d43c6d2f8d281a0fb7f7d6998818cd9c6e9918e36557499ec8", size = 3270824, upload-time = "2026-05-05T18:48:25.66Z" }, + { url = "https://files.pythonhosted.org/packages/08/15/e703f205f82ff53a6a196a35fd2df76545fd7e891ad4a11ce695d5faf3c6/apsw-3.53.1.0-cp312-cp312-manylinux_2_28_i686.whl", hash = "sha256:93a3ba00b64e5ada05d25e3c57cd911f1e3a8a0bf241c76ab20f61876137c523", size = 3879312, upload-time = "2026-05-05T18:48:27.287Z" }, + { url = "https://files.pythonhosted.org/packages/0d/ba/527c0697db61f59f376567437a681c2fa47fc828085a6676a3aa8e72864d/apsw-3.53.1.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:892a7b63db72280e42c388684bb41144822a25fd2d5a6c28e2f719b09468d5f0", size = 3640415, upload-time = "2026-05-05T18:48:29.392Z" }, + { url = "https://files.pythonhosted.org/packages/ea/df/02ba47709eff8f4e8df7a245f569803422aba22d50cc878575382b84b929/apsw-3.53.1.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:a026dccbf8716bc5e3f041fdc1b853cace802aa215a3a4a18a060a4dd16cd421", size = 3493205, upload-time = "2026-05-05T18:48:31.412Z" }, + { url = "https://files.pythonhosted.org/packages/10/c1/6a8485acba0383d1c1674537d0da679a5a72ba996f2d96a1cc6b17fae3f7/apsw-3.53.1.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:908d0a1b393eb434e79bb38c8c7f8a1946db88a0d63a11a0ed615976d03a0435", size = 3278486, upload-time = "2026-05-05T18:48:33.463Z" }, + { url = "https://files.pythonhosted.org/packages/e5/b8/8ef2b5173f2e0c552c396c5ff51d35b5a9b7f25dd0b91f2a6c5a51d04c22/apsw-3.53.1.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:3241518163ced48c31c660b76fff6035cbb40c838705e47f6f687d348bd94602", size = 3896255, upload-time = "2026-05-05T18:48:35.207Z" }, + { url = "https://files.pythonhosted.org/packages/0f/66/9e72093a080afcd40dfa6f4aa3f2794ca59c5602a65ed570e3679536990e/apsw-3.53.1.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:2e6a8f5b5c0cdf5dbb9574d3fbe941b1065bbe23281ff11c7be4ae223391cece", size = 3648722, upload-time = "2026-05-05T18:48:37.04Z" }, + { url = "https://files.pythonhosted.org/packages/50/9c/51e1b8b075d92660a7375ac7d2dda89a31f196e051cf4353f98b820e8603/apsw-3.53.1.0-cp312-cp312-win32.whl", hash = "sha256:e526dadd9544885c47dfd9179cae6c37aed81b303ab962afe085be840d6d0993", size = 2909476, upload-time = "2026-05-05T18:48:38.721Z" }, + { url = "https://files.pythonhosted.org/packages/57/3d/ee6bfbe2dac4b3d2735083e2e3f781d388ffa4445830eb180fda193169f5/apsw-3.53.1.0-cp312-cp312-win_amd64.whl", hash = "sha256:8a97dd446862cc28c4c2b611413cb9ea994dda8fb9d6e2d7a4239bfda09ce347", size = 3220782, upload-time = "2026-05-05T18:48:40.786Z" }, + { url = "https://files.pythonhosted.org/packages/2c/d1/c875f4a521d717f1effaaf36c9456a42a525d1f46e23ee4a74b60b200ba4/apsw-3.53.1.0-cp312-cp312-win_arm64.whl", hash = "sha256:56e1ad4847adc0f785dff374004c4cd9bfb095470f6ba60063758ab9df08fc43", size = 2875529, upload-time = "2026-05-05T18:48:42.393Z" }, + { url = "https://files.pythonhosted.org/packages/41/b5/262c63adb3b9f4e4021a9326ddedc5d5026c43a749303e622949e9f4227f/apsw-3.53.1.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:12bf947396fc8ac652f63e52de754459865c50500073627d200ba4c800e909a9", size = 3268427, upload-time = "2026-05-05T18:48:44.434Z" }, + { url = "https://files.pythonhosted.org/packages/ae/e5/e8ecbd46eaaef62600e54d237808f92ce91a309d50afb6e2552c49279743/apsw-3.53.1.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:5c81c4854c70d69a472e897d238a874032abf4df23717f925c75e1859b8f4912", size = 3065309, upload-time = "2026-05-05T18:48:46.076Z" }, + { url = "https://files.pythonhosted.org/packages/9d/2b/fc45e8746414a2311bd5cea4627a5645f5339a863837f2d2c3ef0d245b65/apsw-3.53.1.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:d8525ebbc4b9a77110fd0c69d7c1859619d55b1455e4750b7260be8959fcbd6b", size = 3486465, upload-time = "2026-05-05T18:48:48.658Z" }, + { url = "https://files.pythonhosted.org/packages/88/cc/2051660762aefa2aa5a55b82952dc5034b46bce1959b29713adefebd8b51/apsw-3.53.1.0-cp313-cp313-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:bf295a288f46e6f8f018b940e6555b238699adc5ae61980bbbf15abf1644c47a", size = 3272768, upload-time = "2026-05-05T18:48:50.342Z" }, + { url = "https://files.pythonhosted.org/packages/87/4e/1c7c318ad5497a238ec1e0311e4722a012237ee88cb29888ca6d9b0e8f36/apsw-3.53.1.0-cp313-cp313-manylinux_2_28_i686.whl", hash = "sha256:e2e9b4abc58d375bb79c35136d0107e7efb804f64e6592e620dc665f8a9985d5", size = 3871154, upload-time = "2026-05-05T18:48:51.958Z" }, + { url = "https://files.pythonhosted.org/packages/d0/e4/aedd6ecd2f63d3c08ba8009adeea3b9f25fab277f6877206e3b2471f9b72/apsw-3.53.1.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:e477a06eef7e17454487837db88506fc9581e9167f9a0ecc7ac17dfb10623fda", size = 3642123, upload-time = "2026-05-05T18:48:53.889Z" }, + { url = "https://files.pythonhosted.org/packages/60/77/61fedaa8ee285e63242b20162c4465d94993887fb8f2860affb2aa18dbdd/apsw-3.53.1.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:fd47f31af34eb054430cdc2f7468c6d28f993bcf2ef0f5584402c12d6f0e798b", size = 3489257, upload-time = "2026-05-05T18:48:55.727Z" }, + { url = "https://files.pythonhosted.org/packages/be/c6/9ff3673bf4dc59fb9d7a51eded0f0752a35097922dab6ec6b4a4f3829903/apsw-3.53.1.0-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:51321e757ae553df2feb2854fb727f660d21201863faf691ffcf0b6190b72bb3", size = 3281737, upload-time = "2026-05-05T18:48:57.598Z" }, + { url = "https://files.pythonhosted.org/packages/f1/df/f40c83870f508d2bda148516ac9755591d0ac290545cfc80bb4c506029be/apsw-3.53.1.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:b8dad0d22c93ca7a1e9f8b981708ce25ebdf2a252ee1bd9ede7959e9fc3f24b4", size = 3889131, upload-time = "2026-05-05T18:48:59.457Z" }, + { url = "https://files.pythonhosted.org/packages/29/7c/ce760653165df3284d6d4c2f7def44105f9cc080da51a10f9411e0491189/apsw-3.53.1.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:bb89433a540c572040fe3cfa3104bfb5039730bed473b5d54c6285bd06f821cb", size = 3650898, upload-time = "2026-05-05T18:49:01.752Z" }, + { url = "https://files.pythonhosted.org/packages/2c/8e/3c6ad293b7e637c4f9ba82db6777c8a26c81035abd7d9d0ab4d77c6c0831/apsw-3.53.1.0-cp313-cp313-win32.whl", hash = "sha256:e19ef1981681225ea66c90bdc04bf01767854132ab328dd2ec9ae7729a57ed54", size = 2908457, upload-time = "2026-05-05T18:49:03.53Z" }, + { url = "https://files.pythonhosted.org/packages/ab/11/71c1afe3bbd2dba9654480445c9d98ef6805f947ee4980c8436440c9e7e1/apsw-3.53.1.0-cp313-cp313-win_amd64.whl", hash = "sha256:f039e2947f16b95fc4f8705e348c6e916b7eaf7fb48dbbf8751ddec9c7529b93", size = 3219700, upload-time = "2026-05-05T18:49:05.364Z" }, + { url = "https://files.pythonhosted.org/packages/69/03/cba7d6d4eec3c8d04fcbfd3b931250e9a290b161c77f1d7f2da0374a1956/apsw-3.53.1.0-cp313-cp313-win_arm64.whl", hash = "sha256:805a9a11b6aec22c7e0ecb31e8e08f250efce5d4cedb222113c5fdc80be2250c", size = 2874907, upload-time = "2026-05-05T18:49:07.475Z" }, + { url = "https://files.pythonhosted.org/packages/47/68/0652d2de5140c51b727a1395f251f83e21092171445ad591c43e1b2a322c/apsw-3.53.1.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:b420e3c3b2805bdbbe9f32e3badc6923e7344ffd932b9be2a811c045837f3880", size = 3272671, upload-time = "2026-05-05T18:49:09.419Z" }, + { url = "https://files.pythonhosted.org/packages/7e/3b/f4a93929c4a633ddeeed58e67506aa9f03dab98057a2e73dc5c2408dabcf/apsw-3.53.1.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:ee3ede9d7e6360da95983a4481f3375873aeadbd2c405a59bcf4de3e4a6c568d", size = 3065765, upload-time = "2026-05-05T18:49:11.156Z" }, + { url = "https://files.pythonhosted.org/packages/18/3b/840e0389155828e16028a0dc94db5742ab154445a7af9a0b4c421d576cd1/apsw-3.53.1.0-cp314-cp314-manylinux_2_28_aarch64.whl", hash = "sha256:668010ec0751d17a6980dbe2cbe646fa8787abb5d37614745e2b260bb5bdce23", size = 3486748, upload-time = "2026-05-05T18:49:12.958Z" }, + { url = "https://files.pythonhosted.org/packages/ee/c0/06104cb012a9850d46053e0fc32e06cca4401230105c2550cab19554b80b/apsw-3.53.1.0-cp314-cp314-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:f9a3d6b911c2e502391c700005696d255c88317aa0460723689854727ec59c6d", size = 3271733, upload-time = "2026-05-05T18:49:14.894Z" }, + { url = "https://files.pythonhosted.org/packages/c1/54/15272dfd87cfc05a2bdfb7141b7f38ca8aaac3628991a3847c31102254e1/apsw-3.53.1.0-cp314-cp314-manylinux_2_28_i686.whl", hash = "sha256:2c42b5d1e6249ea1e0d9751d2a9cf89e26466d4b2f61517f450fcf711790424d", size = 3871553, upload-time = "2026-05-05T18:49:17.574Z" }, + { url = "https://files.pythonhosted.org/packages/22/90/e6515ff917ad2c6a6ce9e738f5322023c9e3a26b0be75ab4edecda4094c8/apsw-3.53.1.0-cp314-cp314-manylinux_2_28_x86_64.whl", hash = "sha256:9e60a0806171dacd69c85b28db6712c502f08b6b7ae679395127fe8b664170c8", size = 3641685, upload-time = "2026-05-05T18:49:19.648Z" }, + { url = "https://files.pythonhosted.org/packages/48/7d/75c34344c7440bfaf05e649e8fac4d6aab883efea2807f4193c4daa4175e/apsw-3.53.1.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:60b41d360dcad2238b13f89bc84c4d226d9a0e7062414c65b0095af311fc71f3", size = 3489852, upload-time = "2026-05-05T18:49:21.922Z" }, + { url = "https://files.pythonhosted.org/packages/a2/da/467afc2fddc7244410dbce70f0dd0d83ebceeb79e37fa4f7a4d2ba04ed6a/apsw-3.53.1.0-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:400a3d2ef918aca7970bca7d68b8cc0a8854a1c2c689cc0790f1bb0ae8fcdf17", size = 3279539, upload-time = "2026-05-05T18:49:23.757Z" }, + { url = "https://files.pythonhosted.org/packages/d4/62/9559cac2112cc9fee73d39f8cc10152a6dbbc23cd4c61ed16282abf98493/apsw-3.53.1.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:bf2c428b0f33a0458dfd952c818fe09330152439f44994ffd3bb9c73b819462d", size = 3889124, upload-time = "2026-05-05T18:49:25.659Z" }, + { url = "https://files.pythonhosted.org/packages/79/dc/d79de5565b8c4c3787d30878a436c56e7ea082c3034367b517ab87f2b1b9/apsw-3.53.1.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:db1636427f24f4cfbffeb616ccb3689bb9b7af029a92c50e565f43755a5ba20b", size = 3650776, upload-time = "2026-05-05T18:49:27.359Z" }, + { url = "https://files.pythonhosted.org/packages/bd/6e/faccb565607146d0aee0635a32a2ee72e83fdd750810db3d836b8c6cb82e/apsw-3.53.1.0-cp314-cp314-win32.whl", hash = "sha256:31c7c293cb426a22f2e045d5a3b1bdedb1c87808175d46982a80068171287c18", size = 2977195, upload-time = "2026-05-05T18:49:29.275Z" }, + { url = "https://files.pythonhosted.org/packages/38/db/9dfa71127bac4fee50c0e91f3b71161300ec41294974b32c05358b5569a9/apsw-3.53.1.0-cp314-cp314-win_amd64.whl", hash = "sha256:5c1a18a175ee64968d2440f9ae0399accaaab3c77a4dc49331000e025c89a5d3", size = 3299067, upload-time = "2026-05-05T18:49:31.091Z" }, + { url = "https://files.pythonhosted.org/packages/f6/89/15b2310eec1c08bc54226e5d8095ce2455046e11509b024973f13a850902/apsw-3.53.1.0-cp314-cp314-win_arm64.whl", hash = "sha256:4715e6bf3f93bdefc2ad07859757ca7a9cf04b654ed5d5531f177de903405eda", size = 2948915, upload-time = "2026-05-05T18:49:33.099Z" }, + { url = "https://files.pythonhosted.org/packages/88/a1/cba969fc5b9a94c95ac2a94b9ad048816f575e2974eac61f0f60d28bf618/apsw-3.53.1.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:e6bb77d3a0abf3f4e6e967da48cd891d53dc3749c523751ef042b3c81269a1f2", size = 3281983, upload-time = "2026-05-05T18:49:34.959Z" }, + { url = "https://files.pythonhosted.org/packages/3c/06/29c595b70fea64a1ef846360d63c7dc546f63979dd214bfe14d07925f1d8/apsw-3.53.1.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:26af656a6bf4a45cb60d75550d7bae25d4d22940b9ecc9973a3bcc5f5c53b159", size = 3075203, upload-time = "2026-05-05T18:49:36.759Z" }, + { url = "https://files.pythonhosted.org/packages/8c/fc/11e42e77b2797c8cfc95cfa0c975dd2f473b81ee856627b8dba47bc5deab/apsw-3.53.1.0-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:92501b0633d683554393f3e422692aaa22ebdd221424e3349edb97ede291c0a2", size = 3462395, upload-time = "2026-05-05T18:49:38.646Z" }, + { url = "https://files.pythonhosted.org/packages/ef/cf/5dc6d0f34cb51293655ee28926e4a7eb3a51696d286e6f0da9faeda823a5/apsw-3.53.1.0-cp314-cp314t-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:22ac2ed00e42b94918b484f4d29b8d39eb3c09c376b6d8e2ecc43828b23b68c3", size = 3251985, upload-time = "2026-05-05T18:49:40.465Z" }, + { url = "https://files.pythonhosted.org/packages/b2/a6/817e0433f497743b2e82d868e128003bd76c8b7ed3fbe0522b5332e8d4f4/apsw-3.53.1.0-cp314-cp314t-manylinux_2_28_i686.whl", hash = "sha256:6658020f966995e7f9e87384f84e1e7785804609c9080df8a66d0e1723d3836e", size = 3843056, upload-time = "2026-05-05T18:49:42.435Z" }, + { url = "https://files.pythonhosted.org/packages/cc/0f/4c3f0178a0ec419c0568808e0c3ce172d032aa6df1bb9adee74fee132356/apsw-3.53.1.0-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:39ef0857da46c1827e35f9d49bd5b548a21894409d4fa072667a333c542faf4f", size = 3618201, upload-time = "2026-05-05T18:49:44.382Z" }, + { url = "https://files.pythonhosted.org/packages/ee/76/6565a97ae2e800935716d7b1eb884a2b9bf7fbc6222d65ecff03da0df666/apsw-3.53.1.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:5b026bc42008622a115cf8c235c9f9c96363d52e6ea0914633659265a639fe1c", size = 3465453, upload-time = "2026-05-05T18:49:46.186Z" }, + { url = "https://files.pythonhosted.org/packages/ad/00/d68a27a17ffb991ffbd739d86526b562a86cd5e97f953adbe8005ad392b0/apsw-3.53.1.0-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:6166755e34d11b2e51926cc1c749ad7a66596dbc0376c312fe5f843ca8f8650b", size = 3256806, upload-time = "2026-05-05T18:49:48.099Z" }, + { url = "https://files.pythonhosted.org/packages/05/c2/9931e56ba32b80cb0f28f33af85cbe413dd504bbf14f7845bf39fa4d4eb0/apsw-3.53.1.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:bce33072929b57c72812d7ecf8517e82d3d38524ee556f59282270ecbf33b942", size = 3860492, upload-time = "2026-05-05T18:49:49.905Z" }, + { url = "https://files.pythonhosted.org/packages/0d/d2/66ad79db6ad6e941649972c5814d569bf5c86830ff844b24f7577a9b0959/apsw-3.53.1.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:1248e3e432aa7a5461be32d2313732f0590c6fa6cba24abf223a061a03b17983", size = 3627536, upload-time = "2026-05-05T18:49:51.794Z" }, + { url = "https://files.pythonhosted.org/packages/87/40/be8f8166b3b8c58ff57c6aa4d62e8422524e072d0607eadc84f6feee62da/apsw-3.53.1.0-cp314-cp314t-win32.whl", hash = "sha256:adc9d3196a764b6413e33209845c170315670fa86a31cac4bcd9c9fe9a20aa0b", size = 2989839, upload-time = "2026-05-05T18:49:53.934Z" }, + { url = "https://files.pythonhosted.org/packages/f9/48/ea8b2cef1c32d8bd0d4978bcefe31ff669fc4248fba4530bf13a3d4f561f/apsw-3.53.1.0-cp314-cp314t-win_amd64.whl", hash = "sha256:5ffce724a757c0b57210c1189c033cc264a8be8b45335a694839f6918c71a842", size = 3315024, upload-time = "2026-05-05T18:49:55.731Z" }, + { url = "https://files.pythonhosted.org/packages/ea/5c/fac06fc153fb1634651e4fbed5a9343d0415a72920b5bb3c8c0f7422eb47/apsw-3.53.1.0-cp314-cp314t-win_arm64.whl", hash = "sha256:bbabe95cc743ae70cc20d5675d35f84d7612a2e9d13c6894404410518c350269", size = 2951484, upload-time = "2026-05-05T18:49:58.051Z" }, +] + +[[package]] +name = "apswutils" +version = "0.1.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "apsw" }, + { name = "fastcore" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/62/77/722db5da148dfac20cff44abe56ac017e82ee4a4a8535f4584d21c266e23/apswutils-0.1.2.tar.gz", hash = "sha256:7992828cc4f7261925685e9e40ab189728050bdee049648481ce6a52ddb5d5dd", size = 52561, upload-time = "2025-12-18T06:24:32.862Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/af/77/43b27c14865dd4204ef353b875b4251e270b2518296e90b9bda479776c58/apswutils-0.1.2-py3-none-any.whl", hash = "sha256:9cd73744f9ae83c2e6f4337d4fcb092f5ea2f1814037e9ff7d953e2bc9c8362a", size = 48171, upload-time = "2025-12-18T06:24:31.312Z" }, +] + [[package]] name = "attrs" version = "26.1.0" @@ -201,6 +274,19 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/f6/22/91616fe707a5c5510de2cac9b046a30defe7007ba8a0c04f9c08f27df312/audioop_lts-0.2.2-cp314-cp314t-win_arm64.whl", hash = "sha256:b492c3b040153e68b9fdaff5913305aaaba5bb433d8a7f73d5cf6a64ed3cc1dd", size = 25206, upload-time = "2025-08-05T16:43:16.444Z" }, ] +[[package]] +name = "beautifulsoup4" +version = "4.14.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "soupsieve" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/c3/b0/1c6a16426d389813b48d95e26898aff79abbde42ad353958ad95cc8c9b21/beautifulsoup4-4.14.3.tar.gz", hash = "sha256:6292b1c5186d356bba669ef9f7f051757099565ad9ada5dd630bd9de5fa7fb86", size = 627737, upload-time = "2025-11-30T15:08:26.084Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1a/39/47f9197bdd44df24d67ac8893641e16f386c984a0619ef2ee4c51fbbc019/beautifulsoup4-4.14.3-py3-none-any.whl", hash = "sha256:0918bfe44902e6ad8d57732ba310582e98da931428d231a5ecb9e7c703a735bb", size = 107721, upload-time = "2025-11-30T15:08:24.087Z" }, +] + [[package]] name = "certifi" version = "2026.2.25" @@ -289,8 +375,10 @@ dependencies = [ { name = "geocoder" }, { name = "openai" }, { name = "python-dotenv" }, + { name = "python-fasthtml" }, { name = "python-telegram-bot" }, { name = "requests" }, + { name = "uvicorn", extra = ["standard"] }, ] [package.dev-dependencies] @@ -308,8 +396,10 @@ requires-dist = [ { name = "geocoder", specifier = ">=1.38.1" }, { name = "openai", specifier = ">=2.15.0" }, { name = "python-dotenv", specifier = ">=0.9.9" }, + { name = "python-fasthtml", specifier = ">=0.14.2" }, { name = "python-telegram-bot", specifier = ">=22.7" }, { name = "requests", specifier = ">=2.32.5" }, + { name = "uvicorn", extras = ["standard"], specifier = ">=0.48.0" }, ] [package.metadata.requires-dev] @@ -374,6 +464,28 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/12/b3/231ffd4ab1fc9d679809f356cebee130ac7daa00d6d6f3206dd4fd137e9e/distro-1.9.0-py3-none-any.whl", hash = "sha256:7bffd925d65168f85027d8da9af6bddab658135b840670a223589bc0c8ef02b2", size = 20277, upload-time = "2023-12-24T09:54:30.421Z" }, ] +[[package]] +name = "fastcore" +version = "1.13.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/70/65/99f599a285033febf95f9c608d91d629ac5d9995f57e5b3ac3397097f440/fastcore-1.13.2.tar.gz", hash = "sha256:f660b3448de48ba31973b2866c994ea3cd5e0a654847f57d6911a1a4bffda777", size = 100337, upload-time = "2026-05-17T06:02:24.383Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c7/41/2c368f804bb9bd918da3b61324207fc4b410d0f32352c372c0680fc1f670/fastcore-1.13.2-py3-none-any.whl", hash = "sha256:2103c9e9e613311c0b36eab17299a221e778fd214ec526e8df1d32908928277c", size = 105060, upload-time = "2026-05-17T06:02:22.28Z" }, +] + +[[package]] +name = "fastlite" +version = "0.2.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "apswutils" }, + { name = "fastcore" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/19/a9/8b6d2a16e483e2ceb2fe67174f47e4523c73ee1b436f03c4355fa6011287/fastlite-0.2.4.tar.gz", hash = "sha256:f1ac4329fe18c7bf027a09d05e856215ae9c2fc8e1c0044e110f9a8a36ea1995", size = 22554, upload-time = "2026-01-12T06:52:50.623Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fe/a7/af33584fa6d17b911cfaba460efd3409cb5dd47083c181a4fdfec4bef840/fastlite-0.2.4-py3-none-any.whl", hash = "sha256:869d96791b06535845b42f7ddef6e12f8e14f6b120f96b9701a4f16867189c63", size = 17638, upload-time = "2026-01-12T06:52:49.225Z" }, +] + [[package]] name = "frozenlist" version = "1.8.0" @@ -510,6 +622,42 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", hash = "sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55", size = 78784, upload-time = "2025-04-24T22:06:20.566Z" }, ] +[[package]] +name = "httptools" +version = "0.8.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/43/e5/d471fcb0e14523fe1c3f4ba58ca52480e7bd70ad7109a3846bc75892f7fb/httptools-0.8.0.tar.gz", hash = "sha256:6b2a32f18d97e16e90827d7a819ffa8dbd8cc245fc4e1fa9d1095b54ef4bd999", size = 271342, upload-time = "2026-05-25T22:17:48.841Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/14/88/1d21a36da8f5cb0fa49eafd4b169eba5608d57e75bbcf61845cbc6243216/httptools-0.8.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:880490234c10f70a9830743097e8958d6e4b9f5a0ffc24515023afeef984054d", size = 208247, upload-time = "2026-05-25T22:17:07.843Z" }, + { url = "https://files.pythonhosted.org/packages/a5/42/cc4feea2945cb3051038f090c9b36bd5b8a9d7f5a894a506a8983e33fd1c/httptools-0.8.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:5931891fb7b441b8a3853cf1b85c82c903defce084dd5f6771ca46e31bf862c5", size = 113064, upload-time = "2026-05-25T22:17:09.136Z" }, + { url = "https://files.pythonhosted.org/packages/e3/a6/febbb8b8db0f58b38e44ad6cb946e6a255ae49b55f2e8543408fb7501ccd/httptools-0.8.0-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:b15fc622b0f869d19207c4089a501d9bcc63ca5e071ffdd2f03f922df882dcb2", size = 523851, upload-time = "2026-05-25T22:17:10.106Z" }, + { url = "https://files.pythonhosted.org/packages/b7/e4/f90a0df0b83beff265b7e3b65f2a4cefd95792d4be0ac3e16049f2acd3c2/httptools-0.8.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:425f83884fd6343828d8c565f046cb72b6d19063f6924093e11bcd8e1548cd09", size = 518842, upload-time = "2026-05-25T22:17:11.218Z" }, + { url = "https://files.pythonhosted.org/packages/9e/2d/0c9ac76dd2c893841fbf6498d6acec4f2442e1b7067f6e3e316a80e494e8/httptools-0.8.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:ef7c3c97f4311c7be57e2986629df89d49cb434dbff78eafcd48c2bff986b15a", size = 501238, upload-time = "2026-05-25T22:17:12.728Z" }, + { url = "https://files.pythonhosted.org/packages/ca/42/906adc91ae3a5fa9c59c0a2f21c139725bd7e5b41ae6acd485cd14123ebf/httptools-0.8.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:a1afd7c9fbff0d9f5d489c4ce2768bd09c84a46ddefc7161e6aa82ae35c85745", size = 509567, upload-time = "2026-05-25T22:17:13.842Z" }, + { url = "https://files.pythonhosted.org/packages/05/0b/4240efeb672751ee5b9b380cb0e3fdc050bc05f68adc7a8aefc4fcd9a69a/httptools-0.8.0-cp312-cp312-win_amd64.whl", hash = "sha256:cd96f29b4bab1d42fa6e3d008711c75e0f79e94e06827330160e3a304227f150", size = 90918, upload-time = "2026-05-25T22:17:15.155Z" }, + { url = "https://files.pythonhosted.org/packages/5e/e5/8cfcabc5546e8022f168be28bcdaa128a240a0befdd03b59d558b4f18bd6/httptools-0.8.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:614ceea8ea606848bece2338ac03b3ce5324bcb4be8dc7d377ed708012fa4db8", size = 205148, upload-time = "2026-05-25T22:17:16.333Z" }, + { url = "https://files.pythonhosted.org/packages/2a/0e/0fb14848c19a686c8062ff9067c1a48793e3224b47bc5b201535b6036fce/httptools-0.8.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2d689918c15a013c65ef52d9fd495d766893ab831a2c8d89f2ac5940a5df847c", size = 111368, upload-time = "2026-05-25T22:17:17.586Z" }, + { url = "https://files.pythonhosted.org/packages/2e/1b/46f1cecf06b9bbde8e4b8c88034ac7908989e5ff7a3a388ef38392949c1f/httptools-0.8.0-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:eb3028cca2fc0a6d720e52ef61d8ebb62fcbfeb1de56874546d858d3f25a26b7", size = 486447, upload-time = "2026-05-25T22:17:18.564Z" }, + { url = "https://files.pythonhosted.org/packages/77/00/258bfc0837221f81d9725c45f9b948a6a6b2994a147a4fb66e85100c668f/httptools-0.8.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:88bdd940f2b5d487b4d032c6afa5489a7dc4694410d43de3c38c4fb3af0dc45d", size = 482448, upload-time = "2026-05-25T22:17:19.912Z" }, + { url = "https://files.pythonhosted.org/packages/04/ab/d1cef3b5523f4d272a70f42a776c3169a2dddfe3a54de4b2ce4a36341528/httptools-0.8.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:6a43c9dd399758ccc0531acb0a3c4a6c299ee893ee9400e9c893b7bdcfae0681", size = 464460, upload-time = "2026-05-25T22:17:20.882Z" }, + { url = "https://files.pythonhosted.org/packages/ce/48/5d1d072442277bb2b3434e0e60690b8e8c23840ef7de8b6ea54040a536d3/httptools-0.8.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:0770728beb05094c809b98e814edff5fef69d26ad7d21185f2f6d5884a0ba683", size = 471312, upload-time = "2026-05-25T22:17:22.085Z" }, + { url = "https://files.pythonhosted.org/packages/0d/66/b96623b27e51a68199ef4efdda0613cced9233fe3062ac74e50749c5ad37/httptools-0.8.0-cp313-cp313-win_amd64.whl", hash = "sha256:7685df791fad561384bfb139e77fde27a1ffd93134e016f95a0db424ffbf77b1", size = 90117, upload-time = "2026-05-25T22:17:23.074Z" }, + { url = "https://files.pythonhosted.org/packages/1a/12/fa3fbf5f9517b273edea2dc982aa82a8c634091e67c590792b729017bc6f/httptools-0.8.0-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:de242a49b5d18e0a8776e654e9f6bf6d89f3875a5c35b425a0e7ce940feb3fd6", size = 206183, upload-time = "2026-05-25T22:17:24.004Z" }, + { url = "https://files.pythonhosted.org/packages/30/fc/5e7c4cb443370f2090a3aba0453a07384d29ff66b7435bb90e77e1037599/httptools-0.8.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:159e9ab5f701ccd42e555a12f1ad8ff69702910fc1c996cf2bb66e5fcb7a231b", size = 112079, upload-time = "2026-05-25T22:17:25.216Z" }, + { url = "https://files.pythonhosted.org/packages/ba/53/771bd891eb0f236f32145d6a1775777ec85745f3cc983a1f23d1a3b8ddfe/httptools-0.8.0-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:c4a9f1707e4823d54dfec6c33fa3697d302aed536ed352a7ebb5a061ddb869d0", size = 481596, upload-time = "2026-05-25T22:17:26.186Z" }, + { url = "https://files.pythonhosted.org/packages/62/42/94e15bc68ce3d423243c45d7f1b0c7561f13844f97dc52ae23182fb65628/httptools-0.8.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d76ad7b951387e3632c8716a9bb03ac5b45c5f16119aa409db0459520887944e", size = 480865, upload-time = "2026-05-25T22:17:27.542Z" }, + { url = "https://files.pythonhosted.org/packages/1c/7c/fe2980fc03723272e30f135b62360b075f513dfe7cc73aef36c7f04012bd/httptools-0.8.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:a3b7387147361c3fd47a0bde763c5c91b5b4cd4dc9989b8ece84ff436c99843b", size = 463189, upload-time = "2026-05-25T22:17:28.546Z" }, + { url = "https://files.pythonhosted.org/packages/15/1b/47fc5fff68acd1bfa20b4734059c9a06cadb88119dcd5258b5b0d21d91c8/httptools-0.8.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:f256d6ce930c52ca1cb2a960b7da03548c454e7d28b06059ad41bfe789036ce0", size = 466610, upload-time = "2026-05-25T22:17:29.816Z" }, + { url = "https://files.pythonhosted.org/packages/60/bd/07b13c93ffd9bec9546e0d43f8e19378dd696dbd278511406bc07371ef1f/httptools-0.8.0-cp314-cp314-win_amd64.whl", hash = "sha256:19d1ee275bb59ba2643ba9a3a1e51cc0c788caf2b8df506368e03f56fdd08527", size = 92705, upload-time = "2026-05-25T22:17:31.133Z" }, + { url = "https://files.pythonhosted.org/packages/fd/c4/121648f68ce066d7bd762d6b6d97e620847642d38d54f3d90ff11d947629/httptools-0.8.0-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:de1ed58a974e75d56560acc7e7fed01a454994429456f65209789992e41f2568", size = 215023, upload-time = "2026-05-25T22:17:32.401Z" }, + { url = "https://files.pythonhosted.org/packages/b9/b0/312a062ae741ae3e8baa8c8bf20be81b2e67337b259ab4349bebc7b6142e/httptools-0.8.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:e93c227b595c6926c1acee96891dd9da4be338cfbe82e5cd3bb9d8dd7dc4ac0b", size = 117405, upload-time = "2026-05-25T22:17:33.742Z" }, + { url = "https://files.pythonhosted.org/packages/fc/37/fccd705f795386bb05bf413012fecff2a33e5aa8c2f069096de3e9fd8702/httptools-0.8.0-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:2a021c3a8e65cc125390d72f59b968afca3bdcaff25bd67965e0a055a14946ca", size = 558497, upload-time = "2026-05-25T22:17:34.732Z" }, + { url = "https://files.pythonhosted.org/packages/bd/39/f172e8003576de35f5ba77ff417cf0e34429d35dc014deef15afa337a72c/httptools-0.8.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:48774d39cbb70e2b1f71f88852a3087ae1d3a1eb80482bb48c13067ab080c14f", size = 571585, upload-time = "2026-05-25T22:17:35.813Z" }, + { url = "https://files.pythonhosted.org/packages/3e/b9/f5564760af99f3dbbf3f9104dc00e5da27e96cf433c6bdcf77617f70bf3f/httptools-0.8.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:88eead8ec8680a9f146c655bc88445a325bd7921cfd8194c7337e9467282427d", size = 543297, upload-time = "2026-05-25T22:17:37.08Z" }, + { url = "https://files.pythonhosted.org/packages/99/67/8d9f2c313618e161b82f3873188e7196126da1d6e29688df40eb3997c77a/httptools-0.8.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:2c032fa028f46871ec7e1fc59fc15e8023eab3e6bbe6ece786a1611719a5d081", size = 539535, upload-time = "2026-05-25T22:17:38.032Z" }, + { url = "https://files.pythonhosted.org/packages/48/63/b906c01e53f50d432c0defe43ce52764a111dc1bdd028bafbeb54dcfd008/httptools-0.8.0-cp314-cp314t-win_amd64.whl", hash = "sha256:384c17174464c8e873398b7af24f0b1f44d992c820328413951a625323155d77", size = 108209, upload-time = "2026-05-25T22:17:39.473Z" }, +] + [[package]] name = "httpx" version = "0.28.1" @@ -543,6 +691,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" }, ] +[[package]] +name = "itsdangerous" +version = "2.2.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/9c/cb/8ac0172223afbccb63986cc25049b154ecfb5e85932587206f42317be31d/itsdangerous-2.2.0.tar.gz", hash = "sha256:e0050c0b7da1eea53ffaf149c0cfbb5c6e2e2b69c4bef22c81fa6eb73e5f6173", size = 54410, upload-time = "2024-04-16T21:28:15.614Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/04/96/92447566d16df59b2a776c0fb82dbc4d9e07cd95062562af01e408583fc4/itsdangerous-2.2.0-py3-none-any.whl", hash = "sha256:c6242fc49e35958c8b15141343aa660db5fc54d4f13a1db01a3f5891b98700ef", size = 16234, upload-time = "2024-04-16T21:28:14.499Z" }, +] + [[package]] name = "jiter" version = "0.13.0" @@ -790,6 +947,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/81/08/7036c080d7117f28a4af526d794aab6a84463126db031b007717c1a6676e/multidict-6.7.1-py3-none-any.whl", hash = "sha256:55d97cc6dae627efa6a6e548885712d4864b81110ac76fa4e534c03819fa4a56", size = 12319, upload-time = "2026-01-26T02:46:44.004Z" }, ] +[[package]] +name = "oauthlib" +version = "3.3.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/0b/5f/19930f824ffeb0ad4372da4812c50edbd1434f678c90c2733e1188edfc63/oauthlib-3.3.1.tar.gz", hash = "sha256:0f0f8aa759826a193cf66c12ea1af1637f87b9b4622d46e866952bb022e538c9", size = 185918, upload-time = "2025-06-19T22:48:08.269Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/be/9c/92789c596b8df838baa98fa71844d84283302f7604ed565dafe5a6b5041a/oauthlib-3.3.1-py3-none-any.whl", hash = "sha256:88119c938d2b8fb88561af5f6ee0eec8cc8d552b7bb1f712743136eb7523b7a1", size = 160065, upload-time = "2025-06-19T22:48:06.508Z" }, +] + [[package]] name = "openai" version = "2.30.0" @@ -1083,6 +1249,18 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/e5/35/f8b19922b6a25bc0880171a2f1a003eaeb93657475193ab516fd87cac9da/pytest_asyncio-1.3.0-py3-none-any.whl", hash = "sha256:611e26147c7f77640e6d0a92a38ed17c3e9848063698d5c93d5aa7aa11cebff5", size = 15075, upload-time = "2025-11-10T16:07:45.537Z" }, ] +[[package]] +name = "python-dateutil" +version = "2.9.0.post0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "six" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3", size = 342432, upload-time = "2024-03-01T18:36:20.211Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427", size = 229892, upload-time = "2024-03-01T18:36:18.57Z" }, +] + [[package]] name = "python-dotenv" version = "1.2.2" @@ -1092,6 +1270,36 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/0b/d7/1959b9648791274998a9c3526f6d0ec8fd2233e4d4acce81bbae76b44b2a/python_dotenv-1.2.2-py3-none-any.whl", hash = "sha256:1d8214789a24de455a8b8bd8ae6fe3c6b69a5e3d64aa8a8e5d68e694bbcb285a", size = 22101, upload-time = "2026-03-01T16:00:25.09Z" }, ] +[[package]] +name = "python-fasthtml" +version = "0.14.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "beautifulsoup4" }, + { name = "fastcore" }, + { name = "fastlite" }, + { name = "httpx" }, + { name = "itsdangerous" }, + { name = "oauthlib" }, + { name = "python-dateutil" }, + { name = "python-multipart" }, + { name = "starlette" }, + { name = "uvicorn", extra = ["standard"] }, +] +sdist = { url = "https://files.pythonhosted.org/packages/64/b1/0b790908aa4c215df307ee703758049fb4ed6c1652c7ce530f5bc38d1d43/python_fasthtml-0.14.2.tar.gz", hash = "sha256:27e2ccc13f30c270abbdf7d08ab7c062eb5c3f5d8a40b6be0e4c888f455af090", size = 76011, upload-time = "2026-05-29T02:43:00.48Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5f/84/933ac0a0b5c272496f448a683741cbf1fae680ee24336eaafc7871338e02/python_fasthtml-0.14.2-py3-none-any.whl", hash = "sha256:0237d244b77ebed4b02fd1500243d295729b8b7fa22eeff7b0f58dfaaef82f1b", size = 79701, upload-time = "2026-05-29T02:42:58.655Z" }, +] + +[[package]] +name = "python-multipart" +version = "0.0.30" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/4b/82/c8cd43a6e0719bf5a3b034f6726dd701f75829c08944c83d4b95d02ed0e8/python_multipart-0.0.30.tar.gz", hash = "sha256:0edfe0475c1f46ddd3ff7785a626f6118af32bdcf359bb21260367313bb32118", size = 46316, upload-time = "2026-05-31T19:24:55.198Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1c/fd/0318007beb234790993d3ec5afd051d1dbceb733e81e3afe2b981ece3f37/python_multipart-0.0.30-py3-none-any.whl", hash = "sha256:830964def8c90607ac5daa00514e3987815865713ade8d20febc9177ac0c3c5b", size = 29730, upload-time = "2026-05-31T19:24:53.814Z" }, +] + [[package]] name = "python-telegram-bot" version = "22.7" @@ -1105,6 +1313,52 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/94/f7/0e2f89dd62f45d46d4ea0d8aec5893ce5b37389638db010c117f46f11450/python_telegram_bot-22.7-py3-none-any.whl", hash = "sha256:d72eed532cf763758cd9331b57a6d790aff0bb4d37d8f4e92149436fe21c6475", size = 745365, upload-time = "2026-03-16T09:36:01.498Z" }, ] +[[package]] +name = "pyyaml" +version = "6.0.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f", size = 130960, upload-time = "2025-09-25T21:33:16.546Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d1/33/422b98d2195232ca1826284a76852ad5a86fe23e31b009c9886b2d0fb8b2/pyyaml-6.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7f047e29dcae44602496db43be01ad42fc6f1cc0d8cd6c83d342306c32270196", size = 182063, upload-time = "2025-09-25T21:32:11.445Z" }, + { url = "https://files.pythonhosted.org/packages/89/a0/6cf41a19a1f2f3feab0e9c0b74134aa2ce6849093d5517a0c550fe37a648/pyyaml-6.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fc09d0aa354569bc501d4e787133afc08552722d3ab34836a80547331bb5d4a0", size = 173973, upload-time = "2025-09-25T21:32:12.492Z" }, + { url = "https://files.pythonhosted.org/packages/ed/23/7a778b6bd0b9a8039df8b1b1d80e2e2ad78aa04171592c8a5c43a56a6af4/pyyaml-6.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9149cad251584d5fb4981be1ecde53a1ca46c891a79788c0df828d2f166bda28", size = 775116, upload-time = "2025-09-25T21:32:13.652Z" }, + { url = "https://files.pythonhosted.org/packages/65/30/d7353c338e12baef4ecc1b09e877c1970bd3382789c159b4f89d6a70dc09/pyyaml-6.0.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5fdec68f91a0c6739b380c83b951e2c72ac0197ace422360e6d5a959d8d97b2c", size = 844011, upload-time = "2025-09-25T21:32:15.21Z" }, + { url = "https://files.pythonhosted.org/packages/8b/9d/b3589d3877982d4f2329302ef98a8026e7f4443c765c46cfecc8858c6b4b/pyyaml-6.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc", size = 807870, upload-time = "2025-09-25T21:32:16.431Z" }, + { url = "https://files.pythonhosted.org/packages/05/c0/b3be26a015601b822b97d9149ff8cb5ead58c66f981e04fedf4e762f4bd4/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8dc52c23056b9ddd46818a57b78404882310fb473d63f17b07d5c40421e47f8e", size = 761089, upload-time = "2025-09-25T21:32:17.56Z" }, + { url = "https://files.pythonhosted.org/packages/be/8e/98435a21d1d4b46590d5459a22d88128103f8da4c2d4cb8f14f2a96504e1/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:41715c910c881bc081f1e8872880d3c650acf13dfa8214bad49ed4cede7c34ea", size = 790181, upload-time = "2025-09-25T21:32:18.834Z" }, + { url = "https://files.pythonhosted.org/packages/74/93/7baea19427dcfbe1e5a372d81473250b379f04b1bd3c4c5ff825e2327202/pyyaml-6.0.3-cp312-cp312-win32.whl", hash = "sha256:96b533f0e99f6579b3d4d4995707cf36df9100d67e0c8303a0c55b27b5f99bc5", size = 137658, upload-time = "2025-09-25T21:32:20.209Z" }, + { url = "https://files.pythonhosted.org/packages/86/bf/899e81e4cce32febab4fb42bb97dcdf66bc135272882d1987881a4b519e9/pyyaml-6.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:5fcd34e47f6e0b794d17de1b4ff496c00986e1c83f7ab2fb8fcfe9616ff7477b", size = 154003, upload-time = "2025-09-25T21:32:21.167Z" }, + { url = "https://files.pythonhosted.org/packages/1a/08/67bd04656199bbb51dbed1439b7f27601dfb576fb864099c7ef0c3e55531/pyyaml-6.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:64386e5e707d03a7e172c0701abfb7e10f0fb753ee1d773128192742712a98fd", size = 140344, upload-time = "2025-09-25T21:32:22.617Z" }, + { url = "https://files.pythonhosted.org/packages/d1/11/0fd08f8192109f7169db964b5707a2f1e8b745d4e239b784a5a1dd80d1db/pyyaml-6.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8da9669d359f02c0b91ccc01cac4a67f16afec0dac22c2ad09f46bee0697eba8", size = 181669, upload-time = "2025-09-25T21:32:23.673Z" }, + { url = "https://files.pythonhosted.org/packages/b1/16/95309993f1d3748cd644e02e38b75d50cbc0d9561d21f390a76242ce073f/pyyaml-6.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2283a07e2c21a2aa78d9c4442724ec1eb15f5e42a723b99cb3d822d48f5f7ad1", size = 173252, upload-time = "2025-09-25T21:32:25.149Z" }, + { url = "https://files.pythonhosted.org/packages/50/31/b20f376d3f810b9b2371e72ef5adb33879b25edb7a6d072cb7ca0c486398/pyyaml-6.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee2922902c45ae8ccada2c5b501ab86c36525b883eff4255313a253a3160861c", size = 767081, upload-time = "2025-09-25T21:32:26.575Z" }, + { url = "https://files.pythonhosted.org/packages/49/1e/a55ca81e949270d5d4432fbbd19dfea5321eda7c41a849d443dc92fd1ff7/pyyaml-6.0.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a33284e20b78bd4a18c8c2282d549d10bc8408a2a7ff57653c0cf0b9be0afce5", size = 841159, upload-time = "2025-09-25T21:32:27.727Z" }, + { url = "https://files.pythonhosted.org/packages/74/27/e5b8f34d02d9995b80abcef563ea1f8b56d20134d8f4e5e81733b1feceb2/pyyaml-6.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0f29edc409a6392443abf94b9cf89ce99889a1dd5376d94316ae5145dfedd5d6", size = 801626, upload-time = "2025-09-25T21:32:28.878Z" }, + { url = "https://files.pythonhosted.org/packages/f9/11/ba845c23988798f40e52ba45f34849aa8a1f2d4af4b798588010792ebad6/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f7057c9a337546edc7973c0d3ba84ddcdf0daa14533c2065749c9075001090e6", size = 753613, upload-time = "2025-09-25T21:32:30.178Z" }, + { url = "https://files.pythonhosted.org/packages/3d/e0/7966e1a7bfc0a45bf0a7fb6b98ea03fc9b8d84fa7f2229e9659680b69ee3/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:eda16858a3cab07b80edaf74336ece1f986ba330fdb8ee0d6c0d68fe82bc96be", size = 794115, upload-time = "2025-09-25T21:32:31.353Z" }, + { url = "https://files.pythonhosted.org/packages/de/94/980b50a6531b3019e45ddeada0626d45fa85cbe22300844a7983285bed3b/pyyaml-6.0.3-cp313-cp313-win32.whl", hash = "sha256:d0eae10f8159e8fdad514efdc92d74fd8d682c933a6dd088030f3834bc8e6b26", size = 137427, upload-time = "2025-09-25T21:32:32.58Z" }, + { url = "https://files.pythonhosted.org/packages/97/c9/39d5b874e8b28845e4ec2202b5da735d0199dbe5b8fb85f91398814a9a46/pyyaml-6.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:79005a0d97d5ddabfeeea4cf676af11e647e41d81c9a7722a193022accdb6b7c", size = 154090, upload-time = "2025-09-25T21:32:33.659Z" }, + { url = "https://files.pythonhosted.org/packages/73/e8/2bdf3ca2090f68bb3d75b44da7bbc71843b19c9f2b9cb9b0f4ab7a5a4329/pyyaml-6.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:5498cd1645aa724a7c71c8f378eb29ebe23da2fc0d7a08071d89469bf1d2defb", size = 140246, upload-time = "2025-09-25T21:32:34.663Z" }, + { url = "https://files.pythonhosted.org/packages/9d/8c/f4bd7f6465179953d3ac9bc44ac1a8a3e6122cf8ada906b4f96c60172d43/pyyaml-6.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:8d1fab6bb153a416f9aeb4b8763bc0f22a5586065f86f7664fc23339fc1c1fac", size = 181814, upload-time = "2025-09-25T21:32:35.712Z" }, + { url = "https://files.pythonhosted.org/packages/bd/9c/4d95bb87eb2063d20db7b60faa3840c1b18025517ae857371c4dd55a6b3a/pyyaml-6.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:34d5fcd24b8445fadc33f9cf348c1047101756fd760b4dacb5c3e99755703310", size = 173809, upload-time = "2025-09-25T21:32:36.789Z" }, + { url = "https://files.pythonhosted.org/packages/92/b5/47e807c2623074914e29dabd16cbbdd4bf5e9b2db9f8090fa64411fc5382/pyyaml-6.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:501a031947e3a9025ed4405a168e6ef5ae3126c59f90ce0cd6f2bfc477be31b7", size = 766454, upload-time = "2025-09-25T21:32:37.966Z" }, + { url = "https://files.pythonhosted.org/packages/02/9e/e5e9b168be58564121efb3de6859c452fccde0ab093d8438905899a3a483/pyyaml-6.0.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b3bc83488de33889877a0f2543ade9f70c67d66d9ebb4ac959502e12de895788", size = 836355, upload-time = "2025-09-25T21:32:39.178Z" }, + { url = "https://files.pythonhosted.org/packages/88/f9/16491d7ed2a919954993e48aa941b200f38040928474c9e85ea9e64222c3/pyyaml-6.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c458b6d084f9b935061bc36216e8a69a7e293a2f1e68bf956dcd9e6cbcd143f5", size = 794175, upload-time = "2025-09-25T21:32:40.865Z" }, + { url = "https://files.pythonhosted.org/packages/dd/3f/5989debef34dc6397317802b527dbbafb2b4760878a53d4166579111411e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7c6610def4f163542a622a73fb39f534f8c101d690126992300bf3207eab9764", size = 755228, upload-time = "2025-09-25T21:32:42.084Z" }, + { url = "https://files.pythonhosted.org/packages/d7/ce/af88a49043cd2e265be63d083fc75b27b6ed062f5f9fd6cdc223ad62f03e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5190d403f121660ce8d1d2c1bb2ef1bd05b5f68533fc5c2ea899bd15f4399b35", size = 789194, upload-time = "2025-09-25T21:32:43.362Z" }, + { url = "https://files.pythonhosted.org/packages/23/20/bb6982b26a40bb43951265ba29d4c246ef0ff59c9fdcdf0ed04e0687de4d/pyyaml-6.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:4a2e8cebe2ff6ab7d1050ecd59c25d4c8bd7e6f400f5f82b96557ac0abafd0ac", size = 156429, upload-time = "2025-09-25T21:32:57.844Z" }, + { url = "https://files.pythonhosted.org/packages/f4/f4/a4541072bb9422c8a883ab55255f918fa378ecf083f5b85e87fc2b4eda1b/pyyaml-6.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:93dda82c9c22deb0a405ea4dc5f2d0cda384168e466364dec6255b293923b2f3", size = 143912, upload-time = "2025-09-25T21:32:59.247Z" }, + { url = "https://files.pythonhosted.org/packages/7c/f9/07dd09ae774e4616edf6cda684ee78f97777bdd15847253637a6f052a62f/pyyaml-6.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:02893d100e99e03eda1c8fd5c441d8c60103fd175728e23e431db1b589cf5ab3", size = 189108, upload-time = "2025-09-25T21:32:44.377Z" }, + { url = "https://files.pythonhosted.org/packages/4e/78/8d08c9fb7ce09ad8c38ad533c1191cf27f7ae1effe5bb9400a46d9437fcf/pyyaml-6.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c1ff362665ae507275af2853520967820d9124984e0f7466736aea23d8611fba", size = 183641, upload-time = "2025-09-25T21:32:45.407Z" }, + { url = "https://files.pythonhosted.org/packages/7b/5b/3babb19104a46945cf816d047db2788bcaf8c94527a805610b0289a01c6b/pyyaml-6.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6adc77889b628398debc7b65c073bcb99c4a0237b248cacaf3fe8a557563ef6c", size = 831901, upload-time = "2025-09-25T21:32:48.83Z" }, + { url = "https://files.pythonhosted.org/packages/8b/cc/dff0684d8dc44da4d22a13f35f073d558c268780ce3c6ba1b87055bb0b87/pyyaml-6.0.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a80cb027f6b349846a3bf6d73b5e95e782175e52f22108cfa17876aaeff93702", size = 861132, upload-time = "2025-09-25T21:32:50.149Z" }, + { url = "https://files.pythonhosted.org/packages/b1/5e/f77dc6b9036943e285ba76b49e118d9ea929885becb0a29ba8a7c75e29fe/pyyaml-6.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:00c4bdeba853cc34e7dd471f16b4114f4162dc03e6b7afcc2128711f0eca823c", size = 839261, upload-time = "2025-09-25T21:32:51.808Z" }, + { url = "https://files.pythonhosted.org/packages/ce/88/a9db1376aa2a228197c58b37302f284b5617f56a5d959fd1763fb1675ce6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:66e1674c3ef6f541c35191caae2d429b967b99e02040f5ba928632d9a7f0f065", size = 805272, upload-time = "2025-09-25T21:32:52.941Z" }, + { url = "https://files.pythonhosted.org/packages/da/92/1446574745d74df0c92e6aa4a7b0b3130706a4142b2d1a5869f2eaa423c6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:16249ee61e95f858e83976573de0f5b2893b3677ba71c9dd36b9cf8be9ac6d65", size = 829923, upload-time = "2025-09-25T21:32:54.537Z" }, + { url = "https://files.pythonhosted.org/packages/f0/7a/1c7270340330e575b92f397352af856a8c06f230aa3e76f86b39d01b416a/pyyaml-6.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4ad1906908f2f5ae4e5a8ddfce73c320c2a1429ec52eafd27138b7f1cbe341c9", size = 174062, upload-time = "2025-09-25T21:32:55.767Z" }, + { url = "https://files.pythonhosted.org/packages/f1/12/de94a39c2ef588c7e6455cfbe7343d3b2dc9d6b6b2f40c4c6565744c873d/pyyaml-6.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b", size = 149341, upload-time = "2025-09-25T21:32:56.828Z" }, +] + [[package]] name = "ratelim" version = "0.1.6" @@ -1175,6 +1429,28 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/e9/44/75a9c9421471a6c4805dbf2356f7c181a29c1879239abab1ea2cc8f38b40/sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2", size = 10235, upload-time = "2024-02-25T23:20:01.196Z" }, ] +[[package]] +name = "soupsieve" +version = "2.8.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/47/2c/0a5f6f8ee0d5589e48c7640213ed5175d52cf540a06725b628cc1a45d6ce/soupsieve-2.8.4.tar.gz", hash = "sha256:e121fd02e975c695e4e9e8774a5ee35d74714b59307868dcc5319ad2d9e3328e", size = 121110, upload-time = "2026-05-24T13:55:57.154Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5e/f5/0c41cb68dcae6b7de4fac4188a3a9589e21fb31df21ea3a2e888db95e6c9/soupsieve-2.8.4-py3-none-any.whl", hash = "sha256:e7e6b0769c8f51ed59acab6e994b00621096cfb1c640a7509295987388fbaf65", size = 37304, upload-time = "2026-05-24T13:55:55.406Z" }, +] + +[[package]] +name = "starlette" +version = "1.2.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, + { name = "typing-extensions", marker = "python_full_version < '3.13'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/25/44/ec35f1b6e83094b997da438a02c8c9b0ade2b1e84cfc48bd4656780760a6/starlette-1.2.1.tar.gz", hash = "sha256:9b9b5ebb992e67d6093741e63c2f59e4f6fff986f81163c087867bd7b924b3f6", size = 2701854, upload-time = "2026-05-31T01:07:51.847Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1c/54/196d0c1db10af76baa4f64894448505d60d3cdf70ef92cbb35f46a4e4c71/starlette-1.2.1-py3-none-any.whl", hash = "sha256:4de0082d08c8f6764a85a54cf1120d6939507a19905c7768acad2a9f875d2b89", size = 73350, upload-time = "2026-05-31T01:07:50.09Z" }, +] + [[package]] name = "tqdm" version = "4.67.3" @@ -1217,6 +1493,193 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/39/08/aaaad47bc4e9dc8c725e68f9d04865dbcb2052843ff09c97b08904852d84/urllib3-2.6.3-py3-none-any.whl", hash = "sha256:bf272323e553dfb2e87d9bfd225ca7b0f467b919d7bbd355436d3fd37cb0acd4", size = 131584, upload-time = "2026-01-07T16:24:42.685Z" }, ] +[[package]] +name = "uvicorn" +version = "0.48.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "click" }, + { name = "h11" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/e6/bf/f6544ba992ddb9a6077343a576f9844f7f8f06ab819aefd00206e9255f18/uvicorn-0.48.0.tar.gz", hash = "sha256:a5504207195d08c2511bf9125ede5ac4a4b71725d519e758d01dcf0bc2d31c37", size = 91074, upload-time = "2026-05-24T12:08:41.925Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/01/be/72532be3da7acc5fdfbccdb95215cd04f995a0886532a5b423f929cda4cc/uvicorn-0.48.0-py3-none-any.whl", hash = "sha256:48097851328b87ec36117d3d575234519eb58c2b22d79666e9bbc6c49a761dad", size = 71410, upload-time = "2026-05-24T12:08:40.258Z" }, +] + +[package.optional-dependencies] +standard = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, + { name = "httptools" }, + { name = "python-dotenv" }, + { name = "pyyaml" }, + { name = "uvloop", marker = "platform_python_implementation != 'PyPy' and sys_platform != 'cygwin' and sys_platform != 'win32'" }, + { name = "watchfiles" }, + { name = "websockets" }, +] + +[[package]] +name = "uvloop" +version = "0.22.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/06/f0/18d39dbd1971d6d62c4629cc7fa67f74821b0dc1f5a77af43719de7936a7/uvloop-0.22.1.tar.gz", hash = "sha256:6c84bae345b9147082b17371e3dd5d42775bddce91f885499017f4607fdaf39f", size = 2443250, upload-time = "2025-10-16T22:17:19.342Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3d/ff/7f72e8170be527b4977b033239a83a68d5c881cc4775fca255c677f7ac5d/uvloop-0.22.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:fe94b4564e865d968414598eea1a6de60adba0c040ba4ed05ac1300de402cd42", size = 1359936, upload-time = "2025-10-16T22:16:29.436Z" }, + { url = "https://files.pythonhosted.org/packages/c3/c6/e5d433f88fd54d81ef4be58b2b7b0cea13c442454a1db703a1eea0db1a59/uvloop-0.22.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:51eb9bd88391483410daad430813d982010f9c9c89512321f5b60e2cddbdddd6", size = 752769, upload-time = "2025-10-16T22:16:30.493Z" }, + { url = "https://files.pythonhosted.org/packages/24/68/a6ac446820273e71aa762fa21cdcc09861edd3536ff47c5cd3b7afb10eeb/uvloop-0.22.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:700e674a166ca5778255e0e1dc4e9d79ab2acc57b9171b79e65feba7184b3370", size = 4317413, upload-time = "2025-10-16T22:16:31.644Z" }, + { url = "https://files.pythonhosted.org/packages/5f/6f/e62b4dfc7ad6518e7eff2516f680d02a0f6eb62c0c212e152ca708a0085e/uvloop-0.22.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7b5b1ac819a3f946d3b2ee07f09149578ae76066d70b44df3fa990add49a82e4", size = 4426307, upload-time = "2025-10-16T22:16:32.917Z" }, + { url = "https://files.pythonhosted.org/packages/90/60/97362554ac21e20e81bcef1150cb2a7e4ffdaf8ea1e5b2e8bf7a053caa18/uvloop-0.22.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e047cc068570bac9866237739607d1313b9253c3051ad84738cbb095be0537b2", size = 4131970, upload-time = "2025-10-16T22:16:34.015Z" }, + { url = "https://files.pythonhosted.org/packages/99/39/6b3f7d234ba3964c428a6e40006340f53ba37993f46ed6e111c6e9141d18/uvloop-0.22.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:512fec6815e2dd45161054592441ef76c830eddaad55c8aa30952e6fe1ed07c0", size = 4296343, upload-time = "2025-10-16T22:16:35.149Z" }, + { url = "https://files.pythonhosted.org/packages/89/8c/182a2a593195bfd39842ea68ebc084e20c850806117213f5a299dfc513d9/uvloop-0.22.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:561577354eb94200d75aca23fbde86ee11be36b00e52a4eaf8f50fb0c86b7705", size = 1358611, upload-time = "2025-10-16T22:16:36.833Z" }, + { url = "https://files.pythonhosted.org/packages/d2/14/e301ee96a6dc95224b6f1162cd3312f6d1217be3907b79173b06785f2fe7/uvloop-0.22.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:1cdf5192ab3e674ca26da2eada35b288d2fa49fdd0f357a19f0e7c4e7d5077c8", size = 751811, upload-time = "2025-10-16T22:16:38.275Z" }, + { url = "https://files.pythonhosted.org/packages/b7/02/654426ce265ac19e2980bfd9ea6590ca96a56f10c76e63801a2df01c0486/uvloop-0.22.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6e2ea3d6190a2968f4a14a23019d3b16870dd2190cd69c8180f7c632d21de68d", size = 4288562, upload-time = "2025-10-16T22:16:39.375Z" }, + { url = "https://files.pythonhosted.org/packages/15/c0/0be24758891ef825f2065cd5db8741aaddabe3e248ee6acc5e8a80f04005/uvloop-0.22.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0530a5fbad9c9e4ee3f2b33b148c6a64d47bbad8000ea63704fa8260f4cf728e", size = 4366890, upload-time = "2025-10-16T22:16:40.547Z" }, + { url = "https://files.pythonhosted.org/packages/d2/53/8369e5219a5855869bcee5f4d317f6da0e2c669aecf0ef7d371e3d084449/uvloop-0.22.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:bc5ef13bbc10b5335792360623cc378d52d7e62c2de64660616478c32cd0598e", size = 4119472, upload-time = "2025-10-16T22:16:41.694Z" }, + { url = "https://files.pythonhosted.org/packages/f8/ba/d69adbe699b768f6b29a5eec7b47dd610bd17a69de51b251126a801369ea/uvloop-0.22.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:1f38ec5e3f18c8a10ded09742f7fb8de0108796eb673f30ce7762ce1b8550cad", size = 4239051, upload-time = "2025-10-16T22:16:43.224Z" }, + { url = "https://files.pythonhosted.org/packages/90/cd/b62bdeaa429758aee8de8b00ac0dd26593a9de93d302bff3d21439e9791d/uvloop-0.22.1-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:3879b88423ec7e97cd4eba2a443aa26ed4e59b45e6b76aabf13fe2f27023a142", size = 1362067, upload-time = "2025-10-16T22:16:44.503Z" }, + { url = "https://files.pythonhosted.org/packages/0d/f8/a132124dfda0777e489ca86732e85e69afcd1ff7686647000050ba670689/uvloop-0.22.1-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:4baa86acedf1d62115c1dc6ad1e17134476688f08c6efd8a2ab076e815665c74", size = 752423, upload-time = "2025-10-16T22:16:45.968Z" }, + { url = "https://files.pythonhosted.org/packages/a3/94/94af78c156f88da4b3a733773ad5ba0b164393e357cc4bd0ab2e2677a7d6/uvloop-0.22.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:297c27d8003520596236bdb2335e6b3f649480bd09e00d1e3a99144b691d2a35", size = 4272437, upload-time = "2025-10-16T22:16:47.451Z" }, + { url = "https://files.pythonhosted.org/packages/b5/35/60249e9fd07b32c665192cec7af29e06c7cd96fa1d08b84f012a56a0b38e/uvloop-0.22.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c1955d5a1dd43198244d47664a5858082a3239766a839b2102a269aaff7a4e25", size = 4292101, upload-time = "2025-10-16T22:16:49.318Z" }, + { url = "https://files.pythonhosted.org/packages/02/62/67d382dfcb25d0a98ce73c11ed1a6fba5037a1a1d533dcbb7cab033a2636/uvloop-0.22.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:b31dc2fccbd42adc73bc4e7cdbae4fc5086cf378979e53ca5d0301838c5682c6", size = 4114158, upload-time = "2025-10-16T22:16:50.517Z" }, + { url = "https://files.pythonhosted.org/packages/f0/7a/f1171b4a882a5d13c8b7576f348acfe6074d72eaf52cccef752f748d4a9f/uvloop-0.22.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:93f617675b2d03af4e72a5333ef89450dfaa5321303ede6e67ba9c9d26878079", size = 4177360, upload-time = "2025-10-16T22:16:52.646Z" }, + { url = "https://files.pythonhosted.org/packages/79/7b/b01414f31546caf0919da80ad57cbfe24c56b151d12af68cee1b04922ca8/uvloop-0.22.1-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:37554f70528f60cad66945b885eb01f1bb514f132d92b6eeed1c90fd54ed6289", size = 1454790, upload-time = "2025-10-16T22:16:54.355Z" }, + { url = "https://files.pythonhosted.org/packages/d4/31/0bb232318dd838cad3fa8fb0c68c8b40e1145b32025581975e18b11fab40/uvloop-0.22.1-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:b76324e2dc033a0b2f435f33eb88ff9913c156ef78e153fb210e03c13da746b3", size = 796783, upload-time = "2025-10-16T22:16:55.906Z" }, + { url = "https://files.pythonhosted.org/packages/42/38/c9b09f3271a7a723a5de69f8e237ab8e7803183131bc57c890db0b6bb872/uvloop-0.22.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:badb4d8e58ee08dad957002027830d5c3b06aea446a6a3744483c2b3b745345c", size = 4647548, upload-time = "2025-10-16T22:16:57.008Z" }, + { url = "https://files.pythonhosted.org/packages/c1/37/945b4ca0ac27e3dc4952642d4c900edd030b3da6c9634875af6e13ae80e5/uvloop-0.22.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b91328c72635f6f9e0282e4a57da7470c7350ab1c9f48546c0f2866205349d21", size = 4467065, upload-time = "2025-10-16T22:16:58.206Z" }, + { url = "https://files.pythonhosted.org/packages/97/cc/48d232f33d60e2e2e0b42f4e73455b146b76ebe216487e862700457fbf3c/uvloop-0.22.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:daf620c2995d193449393d6c62131b3fbd40a63bf7b307a1527856ace637fe88", size = 4328384, upload-time = "2025-10-16T22:16:59.36Z" }, + { url = "https://files.pythonhosted.org/packages/e4/16/c1fd27e9549f3c4baf1dc9c20c456cd2f822dbf8de9f463824b0c0357e06/uvloop-0.22.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6cde23eeda1a25c75b2e07d39970f3374105d5eafbaab2a4482be82f272d5a5e", size = 4296730, upload-time = "2025-10-16T22:17:00.744Z" }, +] + +[[package]] +name = "watchfiles" +version = "1.2.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/cd/41/5e1a4bb12aac5f1493fa1bdc11154eca3b258ca4eba65d39c473fe19d8e9/watchfiles-1.2.0.tar.gz", hash = "sha256:c995fba777f1ea992f090f9236e9284cf7a5d1a0130dd5a3d82c598cacd76838", size = 108252, upload-time = "2026-05-18T04:32:04.251Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b8/2f/e42c992d2afda3108ea1c02acecc991b9f31d05c14adc2a7cee9ee211fc4/watchfiles-1.2.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:bc13eb17538be00c874699dc0abe4ee2bc8d50bb1166a6b9e175ef3fd7eb8f26", size = 400115, upload-time = "2026-05-18T04:32:02.06Z" }, + { url = "https://files.pythonhosted.org/packages/5f/8f/6af2ea19065c91d8b0ea3516fdfc8c0d349f407e8e9fbf4e5a17360de8ad/watchfiles-1.2.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:2d95ddc1eb6914154253d239089900813f6a767e174b8e6a50e7fdacb7e4236c", size = 393659, upload-time = "2026-05-18T04:30:50.951Z" }, + { url = "https://files.pythonhosted.org/packages/13/01/b32a967c56fb3e3e5be3db52c3d3b87fa4513aa367d8ed1ad96d42952e5f/watchfiles-1.2.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8f70d8b291ef6e88d19b1f297a6905ddb978888d9272b0d05e6f53309856bcfc", size = 453207, upload-time = "2026-05-18T04:31:04.231Z" }, + { url = "https://files.pythonhosted.org/packages/04/98/97557a812180338cb1abd32e1cffcc4588f59b5f23e0cb006b2ba95ba64a/watchfiles-1.2.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:56d8641cf834c2836922899105bd3ce3d0dfc69291d52edf0b4d0436829b34c0", size = 459273, upload-time = "2026-05-18T04:31:50.377Z" }, + { url = "https://files.pythonhosted.org/packages/e8/a8/b4b08dcb7653b8087c6586f7ce649505900e866bbcfe40dc9587af02e686/watchfiles-1.2.0-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:2581a94056e55d7d0a31a823ea92bf73749c489ca2285bfdc0fbe6b2bb49d50c", size = 489927, upload-time = "2026-05-18T04:31:42.485Z" }, + { url = "https://files.pythonhosted.org/packages/50/94/3dceea03545d2e5ddfd839f0ddd5e1cecbf1697b5a428d5ba11cef6af95d/watchfiles-1.2.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:41bc1199f7523b3f82843c88cbb979180c949caef0342cf90968f178e5d49b01", size = 570476, upload-time = "2026-05-18T04:31:03.071Z" }, + { url = "https://files.pythonhosted.org/packages/cc/f2/d39a5450c3532092b91f81d274360e613c2371bc874a89c7a1a3c5e8d138/watchfiles-1.2.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7571e4464cb6e434958f867f7f730b8ab0b75e3f8e5eac0499168486ab3c33a8", size = 465650, upload-time = "2026-05-18T04:30:12.701Z" }, + { url = "https://files.pythonhosted.org/packages/22/24/ed72f68cbc1333ca9b9f2200aa048bb6658ae41709bc1caad4310f4bdffd/watchfiles-1.2.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e53a384f76b631c3ae5334ce6a52f0baa3a911eb94a4eac7f160079868b716d5", size = 456398, upload-time = "2026-05-18T04:30:13.784Z" }, + { url = "https://files.pythonhosted.org/packages/0d/64/982ef4a4e5bab5b6e5b6becc8cd5e732f6130a78b855f0abec6439a9a135/watchfiles-1.2.0-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:d20029a60a71a052a24c4db7673bc4de39ab89adbaccbfb5d67987c5d73f424d", size = 465140, upload-time = "2026-05-18T04:31:52.111Z" }, + { url = "https://files.pythonhosted.org/packages/a0/0c/95282abf4ed680b6096010bcfc30c5fa7a041fc5aa5a2ad17a2cc6c75bba/watchfiles-1.2.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:2cb93af48550faf1cea04c303107c8b75833de7013e57ce27d3b8d21d8d0f58c", size = 630259, upload-time = "2026-05-18T04:31:25.676Z" }, + { url = "https://files.pythonhosted.org/packages/30/45/607c1de1530c4bdcf2cf1d1ecc2505ddba5d96bd43ba9f2b0e79876f850f/watchfiles-1.2.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:2995c176de7692b86a2e4c58d9ec718f753150a979cb4a754e2b4ffa38e70906", size = 659859, upload-time = "2026-05-18T04:30:24.333Z" }, + { url = "https://files.pythonhosted.org/packages/fa/08/d9e2e0f9e8e6791d33aefc694ad7eefa7f901f63caff84a81ded38692f9c/watchfiles-1.2.0-cp312-cp312-win32.whl", hash = "sha256:7a2cffd17d27d2ecbb310c2b1d8174f222a5495b1a721894afa88ec11e25b898", size = 275480, upload-time = "2026-05-18T04:30:31.307Z" }, + { url = "https://files.pythonhosted.org/packages/1c/e6/9d42569c0102645cc8cea5d8c7d8a1e9d4ada2cb7f05f75e554b8aa2202a/watchfiles-1.2.0-cp312-cp312-win_amd64.whl", hash = "sha256:f155b3a1b2a5fc89cdc70d47ee5d54e3b75e88efa34982028a35daef9ba00379", size = 288718, upload-time = "2026-05-18T04:32:10.745Z" }, + { url = "https://files.pythonhosted.org/packages/0a/26/88e0dc6ee3898169d7fa22bb6a69cabf2502d2ee25cb8c876d1262d204f8/watchfiles-1.2.0-cp312-cp312-win_arm64.whl", hash = "sha256:8fa585ede612ee9f9e91b18bebf9ba11b9ae29a4e3a0d0cf6fca3e382133f0d5", size = 281026, upload-time = "2026-05-18T04:30:22.23Z" }, + { url = "https://files.pythonhosted.org/packages/d1/4d/70a7feced9f87e2ff26dba42667290f41694fc64646c67261fbb8cab5d5c/watchfiles-1.2.0-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:01ea8d66f0693b9b60a6541c8d10263091ca9a9060d242f3c1f3143f9aad2c98", size = 399730, upload-time = "2026-05-18T04:31:38.162Z" }, + { url = "https://files.pythonhosted.org/packages/31/3a/0da302f2307aee316922806ebd5726c542cbd787c938271cf14a074c7daf/watchfiles-1.2.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7ba0480b9a74af058f43b337e937a451e109295c420916d68ad24e3dc02f5e44", size = 392842, upload-time = "2026-05-18T04:30:27.051Z" }, + { url = "https://files.pythonhosted.org/packages/db/ef/d5bdb705c224dbc256aa0c1ec47bf4e61ec52558f2afb44a71a1fe4d7015/watchfiles-1.2.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4f34e26a19f91f710c08e0183429f0d1d15df734e6bc78c31e77b9ea9c433658", size = 452989, upload-time = "2026-05-18T04:31:11.945Z" }, + { url = "https://files.pythonhosted.org/packages/71/29/5495f2c1661949ef7a35e4d71111d129cfe7606414a26887a919d0a55406/watchfiles-1.2.0-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b4e77f6a55f858504069abd35d336a637555c09bca453dde1ee1e5ada8a6a1fb", size = 458978, upload-time = "2026-05-18T04:30:52.606Z" }, + { url = "https://files.pythonhosted.org/packages/d5/8c/7f9c07c433811c2fffd93e13fdfb7135de9aab5f2ae41be08960fa0047dc/watchfiles-1.2.0-cp313-cp313-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0cb4d80e212f116474a545c21c912b445f16bb0cef9e6a73a498164223e14e2f", size = 490248, upload-time = "2026-05-18T04:31:36.003Z" }, + { url = "https://files.pythonhosted.org/packages/3c/11/d93632febc52fbc21be90231bb7c17fd5387f46c9076fd40a5f9c2ae6910/watchfiles-1.2.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b974946a10af379d425e2eef5b62f5c6ebeaccf91d45eaad6f5b27ecd4f91aa0", size = 571847, upload-time = "2026-05-18T04:31:10.862Z" }, + { url = "https://files.pythonhosted.org/packages/55/b4/383173e73aabb07ad1d9c7aa859d95437ac46a6d6a1e11005facda0c9d19/watchfiles-1.2.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:86bc13c25a8d1fcd70b51d0ce7c9b65e90de5666fcbfd3e34957cc73ee19aeb5", size = 465974, upload-time = "2026-05-18T04:30:17.006Z" }, + { url = "https://files.pythonhosted.org/packages/a7/6c/89b1a230a78f57c52dd8893adb1f92f94411721b6ec12596c56d98c74356/watchfiles-1.2.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ca148d73dea36c9763aaa351e4d7a51780ec1584217c45276f4fe8239c768b71", size = 454782, upload-time = "2026-05-18T04:30:35.656Z" }, + { url = "https://files.pythonhosted.org/packages/24/62/1732118367cfff0a9fce3bf62ff4bfded09ef5df21d9d446b858b3f70a96/watchfiles-1.2.0-cp313-cp313-manylinux_2_31_riscv64.whl", hash = "sha256:c525543d91961c6955b2636b308569e84a1d1c5f5f2932041ab9ef46422f43e3", size = 465182, upload-time = "2026-05-18T04:30:20.846Z" }, + { url = "https://files.pythonhosted.org/packages/28/96/716f7e5f51339bf22963f3345f9f27d7f3b30e2eadc597e257c881dd3c53/watchfiles-1.2.0-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:a204794696ffb8f9b10fba6f7cb5216d42f3b2b71860ccac6b6e42f5f10973b0", size = 629841, upload-time = "2026-05-18T04:31:05.397Z" }, + { url = "https://files.pythonhosted.org/packages/4c/fe/c40783950fd771ccf66ab3ec2722d188a9af1c7f96c6e811f36e40c6e03f/watchfiles-1.2.0-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:10d86db20695afe7997ac9e1717637d6714a8d0220458c33f3d2061f54cec427", size = 658028, upload-time = "2026-05-18T04:31:48.22Z" }, + { url = "https://files.pythonhosted.org/packages/71/72/4508db1856d1d87fcbb3b63f4839bab1b5682cb0e8d224d122263c09654a/watchfiles-1.2.0-cp313-cp313-win32.whl", hash = "sha256:eb283ee99e21ad6443c8cdb06ac5b34b1308c329cbdf03fa02b445363714c799", size = 275183, upload-time = "2026-05-18T04:30:59.57Z" }, + { url = "https://files.pythonhosted.org/packages/f9/36/14b76ca57652e5cc5fd1c11f32a261292c08a0d19a00351013c2549cbfb2/watchfiles-1.2.0-cp313-cp313-win_amd64.whl", hash = "sha256:a0f27f01bee51861392bb6b7c4fdb290b27d1eb194e9e28788d68102a0e898d9", size = 288059, upload-time = "2026-05-18T04:32:07.937Z" }, + { url = "https://files.pythonhosted.org/packages/1b/8d/0a85e395398d8d20fadfe5c5d32c726eee17a519e78fb356f2cf7531bffe/watchfiles-1.2.0-cp313-cp313-win_arm64.whl", hash = "sha256:3651aa7058595e9cfb75d35dd5ada2bf9f48a5b8a0f3562821d3e210c507e077", size = 280186, upload-time = "2026-05-18T04:31:54.484Z" }, + { url = "https://files.pythonhosted.org/packages/37/68/36db056f1fdcc5f07302f56e631774d6835bcd6fa3ace402304621d5f9e5/watchfiles-1.2.0-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:faea288b6f0ab1902ef08f4ca6de005dccf856c4e0c4f21b8c5fce02d90a1b08", size = 399031, upload-time = "2026-05-18T04:30:44.576Z" }, + { url = "https://files.pythonhosted.org/packages/c1/64/01a9d6f66a82a5c101ce939274106cc72759d62427e153f01edd2b9f87c2/watchfiles-1.2.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:01859b11fd9fbca670f4d5da00fbac282cfea9bd67a2125d8b2833a3b5617ea9", size = 391205, upload-time = "2026-05-18T04:30:25.413Z" }, + { url = "https://files.pythonhosted.org/packages/84/2c/0a44fe058cb4bb7b8ede6b6670698bbb7c0400740e378d00022189b7b31d/watchfiles-1.2.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fff610d7bb2256a317bb1e96f0d7862c7aa8076733ee5df0fd41bbe76a24a4f4", size = 451892, upload-time = "2026-05-18T04:32:14.005Z" }, + { url = "https://files.pythonhosted.org/packages/67/a1/351e0d56cd35e6488b5c8b4fb11a809a5bc923e8fe8fed9faf8920be0c89/watchfiles-1.2.0-cp313-cp313t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b141a4891c995a039cd89e9a49e62df1dc8a559a5d1a6e4c7106d16c12777a55", size = 458867, upload-time = "2026-05-18T04:31:22.279Z" }, + { url = "https://files.pythonhosted.org/packages/d5/7d/9d09605187f1b838998624049fcf8bf47b73c1a3b76901fcac1782f62277/watchfiles-1.2.0-cp313-cp313t-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f22943b7770483f6ea0721c6b11d022947a98eb0acae14694de034f4d0d38925", size = 490217, upload-time = "2026-05-18T04:31:43.657Z" }, + { url = "https://files.pythonhosted.org/packages/60/5d/a17a16eccb182f04188cd308ec24b1a71a9b5c4e7098269cf35d9fa56d02/watchfiles-1.2.0-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1bc6195825b7dcd217968bb1f801a60fd4c16e8eeab5bedc7fe917d7d5995ab4", size = 571458, upload-time = "2026-05-18T04:32:11.875Z" }, + { url = "https://files.pythonhosted.org/packages/d3/3d/4dd457062083ab1938e5dfd45032eb425cee2ac817287ca8ff4356183e5d/watchfiles-1.2.0-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d4a4b147f5dca2a5d325a06a832fb43f345751adfbc63204aec30e0d9ca965a2", size = 464707, upload-time = "2026-05-18T04:30:43.492Z" }, + { url = "https://files.pythonhosted.org/packages/c6/71/ea8c57b128f5383de74d0c7d2d9c57ad7c9a65a930c451bd25d524b295b7/watchfiles-1.2.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4543579a9bdb0c9560039b4ffddbdb39545707659fbc430ce4c10f3f68d557f9", size = 454663, upload-time = "2026-05-18T04:30:16.061Z" }, + { url = "https://files.pythonhosted.org/packages/53/fd/2e812bf938406d7db351f0703ddd3fc6c061cf30d96153a77bc79a943a44/watchfiles-1.2.0-cp313-cp313t-manylinux_2_31_riscv64.whl", hash = "sha256:20aa0e708b920bde876a4aa82dc7dd6ebea228a63a67cda6632c2fc87b787efa", size = 463537, upload-time = "2026-05-18T04:31:44.9Z" }, + { url = "https://files.pythonhosted.org/packages/86/56/d17a7f1dd1bc3035f1072694a551301272f1739c2d8e319c927cb9e29b38/watchfiles-1.2.0-cp313-cp313t-musllinux_1_1_aarch64.whl", hash = "sha256:d413349d565dab74297f2a63e84a097936be69bf8f3b3801f27f380e32040f44", size = 629194, upload-time = "2026-05-18T04:31:14.141Z" }, + { url = "https://files.pythonhosted.org/packages/be/06/f1ff66bf5cae50aa4062779a0ecd0bbaf15e466195719074078947d9a17d/watchfiles-1.2.0-cp313-cp313t-musllinux_1_1_x86_64.whl", hash = "sha256:f28b2725eb8cce327b9b3ab02415c853011dc55c95832fe90de6bc56f5315f72", size = 656194, upload-time = "2026-05-18T04:31:47.14Z" }, + { url = "https://files.pythonhosted.org/packages/e7/54/a9c7ea9a82a4ac65e7004c0a03920b5cdd2f9c3b678757d9cd425aa51d53/watchfiles-1.2.0-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:b8c8358484d5fa12ef34f05b7f4168eaf1932f408725ff6d023c33ec17bd79d4", size = 400205, upload-time = "2026-05-18T04:32:05.153Z" }, + { url = "https://files.pythonhosted.org/packages/aa/5d/c9ab3534374a4a67450696905d6ef16a04405448b8dc52bd752ae50423d4/watchfiles-1.2.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:9f04b092229ad2c50126dd3c922c8822e51e605993764a33058d4a791ab42281", size = 392508, upload-time = "2026-05-18T04:30:54.849Z" }, + { url = "https://files.pythonhosted.org/packages/26/ca/1ad30103535cf0cecd7b993e8d50edc5351b1820e38f2d22e3df58962feb/watchfiles-1.2.0-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7a7ce236284f002a156f70add88efe5c70879cccbb658be0822c54b1306fc09d", size = 452448, upload-time = "2026-05-18T04:30:53.727Z" }, + { url = "https://files.pythonhosted.org/packages/37/a1/ceee2cdf2afbd715fa07758d39c9859513eae411b23196f7fd039e5feedd/watchfiles-1.2.0-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b9909cc2b48468b575eefa944919e1fe8a36c5849d5c7c168f80a8c1db69398e", size = 459605, upload-time = "2026-05-18T04:30:23.312Z" }, + { url = "https://files.pythonhosted.org/packages/e8/f6/421e30fd1cb3907a84ed92ab3f1983e37ba2dca015e9a894a048418417a2/watchfiles-1.2.0-cp314-cp314-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0a37faaed405c67e28e6be45a1fa4f206ef5a2860f27c237db9fa30704c38242", size = 490757, upload-time = "2026-05-18T04:30:47.358Z" }, + { url = "https://files.pythonhosted.org/packages/41/b0/55ed1b97ed08be7bba6f9a541cac15f2a858e1d74d2b07b6da70a82aab00/watchfiles-1.2.0-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9649193aa27bd9ff2e80ff29bfaa93085496c7a3a377592823cc58b77ee88add", size = 568672, upload-time = "2026-05-18T04:30:38.915Z" }, + { url = "https://files.pythonhosted.org/packages/d1/cf/d8ae8a80dd7bafab395ea7681c10237311bbf34d37704a8c744e7cf31fc7/watchfiles-1.2.0-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4e4ff8e37f99cf1da89e255e07c9c4b37c214038c4283707bdec308cb1b0ea1f", size = 464197, upload-time = "2026-05-18T04:30:09.914Z" }, + { url = "https://files.pythonhosted.org/packages/7c/8a/3076c496ca8dafe0e8cd03fcebdfc47be4b1174b4e5b24ff6e396e6b3af2/watchfiles-1.2.0-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:054dc20fd2e3132b4c3883b4a00d72fd6e1f56fdaf89fccd12e8057d74cd74d7", size = 453181, upload-time = "2026-05-18T04:30:14.829Z" }, + { url = "https://files.pythonhosted.org/packages/e5/10/9745e17c98e7b8a86454df0a3c7b5686bd650383f1e9f26e4ebcbd6cc0c0/watchfiles-1.2.0-cp314-cp314-manylinux_2_31_riscv64.whl", hash = "sha256:e140ed30ebde76796b686e67c182cff10ea2fbab186fafd1560f74bb5a473a6e", size = 465109, upload-time = "2026-05-18T04:30:28.123Z" }, + { url = "https://files.pythonhosted.org/packages/8f/95/8ef4a95481d3e0cb52d62a06fa6e972e81424be2d9698b91a2fecca9904c/watchfiles-1.2.0-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:bb7e52ecf68ba46d22df23467b87cffeb2146908aa523ebfe803019618cfda06", size = 630653, upload-time = "2026-05-18T04:31:49.304Z" }, + { url = "https://files.pythonhosted.org/packages/fd/e4/3b3bf36b0f829b50c6ebcb8d031583863c59f923d6a6af3d485e470d0fac/watchfiles-1.2.0-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:23282a321c8baf9b3a3c4afff673f9fe65eb7fdc2338d765ccad9d3d1916a5ba", size = 657838, upload-time = "2026-05-18T04:31:06.497Z" }, + { url = "https://files.pythonhosted.org/packages/21/b1/6cbbb50c1f3002ab568777d44aa21206dfb8807a840990c4037523b51812/watchfiles-1.2.0-cp314-cp314-win32.whl", hash = "sha256:c0db965c5f79aa49fe672d297cf1febc5ad149b658594944f49a54a2b96270a7", size = 275108, upload-time = "2026-05-18T04:30:06.891Z" }, + { url = "https://files.pythonhosted.org/packages/92/45/190ce6db8dcb4536682cf75d3889ff1a27182a58cb519d343cb6d9ea63d8/watchfiles-1.2.0-cp314-cp314-win_amd64.whl", hash = "sha256:71283b39fd17e5408eb123bd37aeecfd9d54c81fc184421943208aadb879d103", size = 288441, upload-time = "2026-05-18T04:32:12.901Z" }, + { url = "https://files.pythonhosted.org/packages/74/0d/3eae1c2313ab08378431d907c3f8095ecca00f3eda33111cf4f0f2591799/watchfiles-1.2.0-cp314-cp314-win_arm64.whl", hash = "sha256:c5c19526f4e54a00f2666a6c0e9e40d582c09e865055ea7378bf0009aab857b3", size = 280684, upload-time = "2026-05-18T04:31:26.902Z" }, + { url = "https://files.pythonhosted.org/packages/b1/75/fb64e6c25d6b5ca636d03df34ffb1c6e9873303e76d27967e045f8df088f/watchfiles-1.2.0-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:d73a585accffa5ae39c17264c36ec3166d2fad7000c780f5ef83b2722afb9dd2", size = 398857, upload-time = "2026-05-18T04:32:17.108Z" }, + { url = "https://files.pythonhosted.org/packages/73/4e/9f7adf01754cbf81843722ccfec169d8f26c69778281a302855cecd2ee08/watchfiles-1.2.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:ae99b14c5f21e026e0e9d96f40e07d8570ebee6cafd9d8fc318354606daa7a28", size = 392413, upload-time = "2026-05-18T04:31:07.911Z" }, + { url = "https://files.pythonhosted.org/packages/47/c8/bec626bcc2d69f44b9acb24ce7d60ed7b16b73628eea747fcbd169d8edda/watchfiles-1.2.0-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4429f3b105524a10b72c3a819b091c495d2811d419c1e1e8df773a5a5974f831", size = 452409, upload-time = "2026-05-18T04:31:20.142Z" }, + { url = "https://files.pythonhosted.org/packages/00/b7/b6362068e81e7c556d155a34c35d40ac3ef42d747b06d7f6e5bf58e359c2/watchfiles-1.2.0-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:43d818978d06062d9b22c4fab2ebe44cf5213d42dc8e62bda8c2760cfa2eeb33", size = 458827, upload-time = "2026-05-18T04:32:06.219Z" }, + { url = "https://files.pythonhosted.org/packages/67/f8/9a813fa42afb1e0b4625e75f0479826644d3ee8dc287e093799bc01f390c/watchfiles-1.2.0-cp314-cp314t-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b9f732dc58b2dbe69e464ccf8fff7a03b0dd0be439da4c0720d3558527d3d6b4", size = 490104, upload-time = "2026-05-18T04:31:56.034Z" }, + { url = "https://files.pythonhosted.org/packages/2f/bf/27dfb6094ca4c9aad21298b5525b6c53cb36121ee454331d05161e58d130/watchfiles-1.2.0-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8f200104103feb097de4cab8fe4f5dd18a2026934c7dea98c55a2f5fd6d5a33b", size = 571360, upload-time = "2026-05-18T04:31:57.133Z" }, + { url = "https://files.pythonhosted.org/packages/fb/39/44a096d67270ea93df91d33877dbe91fbda3aa4f8ec2edf799d93eda8736/watchfiles-1.2.0-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:63ac26eefbf4af1741247d6fb68b11c49a25b2f7413fbd318a83a12aaa9cf666", size = 464644, upload-time = "2026-05-18T04:30:57.33Z" }, + { url = "https://files.pythonhosted.org/packages/0e/80/c7472203bad6268e3ef1ad260739704847898938ad7ea8b63a5131f46b50/watchfiles-1.2.0-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0c4997d4e4a55f0d02b6cde327322daf3a0400e5df6c6b15948994bf72497925", size = 454771, upload-time = "2026-05-18T04:30:48.736Z" }, + { url = "https://files.pythonhosted.org/packages/51/cf/3b10b268b4b7f0fc26e9debb5eef1998b515887840f444cd3ec80c688755/watchfiles-1.2.0-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:4c887eba18b7945ac73067a8b4a66f21cd46c2539b2bc68588f7be6c7eb6d26b", size = 463494, upload-time = "2026-05-18T04:31:33.826Z" }, + { url = "https://files.pythonhosted.org/packages/3d/3e/a4302545cd589262a0dc7d140e86f7688eba3f9c72776c27f7e23b8864c4/watchfiles-1.2.0-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:3416ff151bb6b5a8d8d11664974fbef4d9305b9b2957839ab5a270468fd8df30", size = 629383, upload-time = "2026-05-18T04:31:15.596Z" }, + { url = "https://files.pythonhosted.org/packages/db/99/d5649df0a9a410d45b7c882304d0b790903ac9b6e8f2cfd12114e0c6b9f2/watchfiles-1.2.0-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:0e831a271c035d89789cffc386b6aa1375f39f1cd25eb7ca0997e4970d152fc5", size = 656093, upload-time = "2026-05-18T04:31:58.707Z" }, + { url = "https://files.pythonhosted.org/packages/92/b9/362702539275019a54dd2e94511b31a9b89c5f9e6a21966de7eb692549fc/watchfiles-1.2.0-cp315-cp315-macosx_10_12_x86_64.whl", hash = "sha256:37a6721cdf3f65dbb13aa9503510ccb4451603ac837e44d265d7992a597e1374", size = 400109, upload-time = "2026-05-18T04:31:16.879Z" }, + { url = "https://files.pythonhosted.org/packages/8f/75/71d5ba62db781e5587bded1d944c675374bc4aa37ff33d5018d98e8b6538/watchfiles-1.2.0-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:2b37d10b5a63bd4d87e18472d80fa525bd670586fae62e5dd580452764879b65", size = 392167, upload-time = "2026-05-18T04:31:28.058Z" }, + { url = "https://files.pythonhosted.org/packages/3c/01/c66dd95d0423fe30d31820e2d1d5bda773764131bbb6ac0cb1cf303ac328/watchfiles-1.2.0-cp315-cp315-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0a105bc2283f67e8fbec74253ec2d94925de92ed72c0393f1206bf326b7b7b69", size = 452372, upload-time = "2026-05-18T04:31:00.836Z" }, + { url = "https://files.pythonhosted.org/packages/91/15/2fe99557e72f85627c6a8eed50d889e8d101623e060a22ad75b875cb932d/watchfiles-1.2.0-cp315-cp315-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:5327989a465505f05cfe06f04fa9d0c2fd5432bb243e10e6f012b1bdca3c8579", size = 459596, upload-time = "2026-05-18T04:31:34.96Z" }, + { url = "https://files.pythonhosted.org/packages/ed/23/d4acfa0023367428ed48351b3b9b267893037b6cadae55620c61c24bcfd4/watchfiles-1.2.0-cp315-cp315-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ecb47f183a8025b2aa18b546725c3657e542112ae9c0613a2af79b4fa8d04ad7", size = 490869, upload-time = "2026-05-18T04:31:59.923Z" }, + { url = "https://files.pythonhosted.org/packages/a4/5f/3164cbdce06c9fb95c4f7b9e2f9760b5e2797af43a9ecc317ef42a23a278/watchfiles-1.2.0-cp315-cp315-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8520a4ab0e37f770afc34459c4f8f7019e153f9124dc101c15538365875d1ab2", size = 571641, upload-time = "2026-05-18T04:32:00.948Z" }, + { url = "https://files.pythonhosted.org/packages/41/e6/85d3731c55e65cd7690f3f803d24c139588aaf863e4bf2148fe7a7fa1a19/watchfiles-1.2.0-cp315-cp315-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:71cd71740ed2c15211ebb237ced4e39a1cdf6f80566e5fe95428da1626f4fde6", size = 464444, upload-time = "2026-05-18T04:30:34.298Z" }, + { url = "https://files.pythonhosted.org/packages/f4/7d/562641012b8b09872742c3b8adf9629ec479fd78f8d68ae4a0c13da8add6/watchfiles-1.2.0-cp315-cp315-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f88af53d6ddaf72179ef613ddc905e6f4785f712b49b80b3bef9f3525e6194b4", size = 453593, upload-time = "2026-05-18T04:31:23.464Z" }, + { url = "https://files.pythonhosted.org/packages/56/fe/cb8ef3d6f929d14158fdaaad9925985b7310abc9384dcd4d82dd0016fb59/watchfiles-1.2.0-cp315-cp315-manylinux_2_31_riscv64.whl", hash = "sha256:cee9d5efd929efdac5f7e58f72b3376f676b64050a91c5b99a7094c5b2317488", size = 465096, upload-time = "2026-05-18T04:31:30.384Z" }, + { url = "https://files.pythonhosted.org/packages/25/91/80908e835e100527a9267147b08c0eee1fa6ab0ffec15edc04d1d44885f7/watchfiles-1.2.0-cp315-cp315-musllinux_1_1_aarch64.whl", hash = "sha256:b718bf356bbc15e559bd8ef41782b573b8ae0e3f177ab244b440568d7ea02cfb", size = 630638, upload-time = "2026-05-18T04:30:49.89Z" }, + { url = "https://files.pythonhosted.org/packages/46/4b/95ab2f256bb4af3cb2eb23b9317bda984ee6e0f11733a5c004a6c95b06e3/watchfiles-1.2.0-cp315-cp315-musllinux_1_1_x86_64.whl", hash = "sha256:922c0e019fe68b3ae392965a766b02a71ba1168c932cebc3733cd52c5fe5b377", size = 657684, upload-time = "2026-05-18T04:31:32.027Z" }, +] + +[[package]] +name = "websockets" +version = "16.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/04/24/4b2031d72e840ce4c1ccb255f693b15c334757fc50023e4db9537080b8c4/websockets-16.0.tar.gz", hash = "sha256:5f6261a5e56e8d5c42a4497b364ea24d94d9563e8fbd44e78ac40879c60179b5", size = 179346, upload-time = "2026-01-10T09:23:47.181Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/84/7b/bac442e6b96c9d25092695578dda82403c77936104b5682307bd4deb1ad4/websockets-16.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:71c989cbf3254fbd5e84d3bff31e4da39c43f884e64f2551d14bb3c186230f00", size = 177365, upload-time = "2026-01-10T09:22:46.787Z" }, + { url = "https://files.pythonhosted.org/packages/b0/fe/136ccece61bd690d9c1f715baaeefd953bb2360134de73519d5df19d29ca/websockets-16.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:8b6e209ffee39ff1b6d0fa7bfef6de950c60dfb91b8fcead17da4ee539121a79", size = 175038, upload-time = "2026-01-10T09:22:47.999Z" }, + { url = "https://files.pythonhosted.org/packages/40/1e/9771421ac2286eaab95b8575b0cb701ae3663abf8b5e1f64f1fd90d0a673/websockets-16.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:86890e837d61574c92a97496d590968b23c2ef0aeb8a9bc9421d174cd378ae39", size = 175328, upload-time = "2026-01-10T09:22:49.809Z" }, + { url = "https://files.pythonhosted.org/packages/18/29/71729b4671f21e1eaa5d6573031ab810ad2936c8175f03f97f3ff164c802/websockets-16.0-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:9b5aca38b67492ef518a8ab76851862488a478602229112c4b0d58d63a7a4d5c", size = 184915, upload-time = "2026-01-10T09:22:51.071Z" }, + { url = "https://files.pythonhosted.org/packages/97/bb/21c36b7dbbafc85d2d480cd65df02a1dc93bf76d97147605a8e27ff9409d/websockets-16.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e0334872c0a37b606418ac52f6ab9cfd17317ac26365f7f65e203e2d0d0d359f", size = 186152, upload-time = "2026-01-10T09:22:52.224Z" }, + { url = "https://files.pythonhosted.org/packages/4a/34/9bf8df0c0cf88fa7bfe36678dc7b02970c9a7d5e065a3099292db87b1be2/websockets-16.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:a0b31e0b424cc6b5a04b8838bbaec1688834b2383256688cf47eb97412531da1", size = 185583, upload-time = "2026-01-10T09:22:53.443Z" }, + { url = "https://files.pythonhosted.org/packages/47/88/4dd516068e1a3d6ab3c7c183288404cd424a9a02d585efbac226cb61ff2d/websockets-16.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:485c49116d0af10ac698623c513c1cc01c9446c058a4e61e3bf6c19dff7335a2", size = 184880, upload-time = "2026-01-10T09:22:55.033Z" }, + { url = "https://files.pythonhosted.org/packages/91/d6/7d4553ad4bf1c0421e1ebd4b18de5d9098383b5caa1d937b63df8d04b565/websockets-16.0-cp312-cp312-win32.whl", hash = "sha256:eaded469f5e5b7294e2bdca0ab06becb6756ea86894a47806456089298813c89", size = 178261, upload-time = "2026-01-10T09:22:56.251Z" }, + { url = "https://files.pythonhosted.org/packages/c3/f0/f3a17365441ed1c27f850a80b2bc680a0fa9505d733fe152fdf5e98c1c0b/websockets-16.0-cp312-cp312-win_amd64.whl", hash = "sha256:5569417dc80977fc8c2d43a86f78e0a5a22fee17565d78621b6bb264a115d4ea", size = 178693, upload-time = "2026-01-10T09:22:57.478Z" }, + { url = "https://files.pythonhosted.org/packages/cc/9c/baa8456050d1c1b08dd0ec7346026668cbc6f145ab4e314d707bb845bf0d/websockets-16.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:878b336ac47938b474c8f982ac2f7266a540adc3fa4ad74ae96fea9823a02cc9", size = 177364, upload-time = "2026-01-10T09:22:59.333Z" }, + { url = "https://files.pythonhosted.org/packages/7e/0c/8811fc53e9bcff68fe7de2bcbe75116a8d959ac699a3200f4847a8925210/websockets-16.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:52a0fec0e6c8d9a784c2c78276a48a2bdf099e4ccc2a4cad53b27718dbfd0230", size = 175039, upload-time = "2026-01-10T09:23:01.171Z" }, + { url = "https://files.pythonhosted.org/packages/aa/82/39a5f910cb99ec0b59e482971238c845af9220d3ab9fa76dd9162cda9d62/websockets-16.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:e6578ed5b6981005df1860a56e3617f14a6c307e6a71b4fff8c48fdc50f3ed2c", size = 175323, upload-time = "2026-01-10T09:23:02.341Z" }, + { url = "https://files.pythonhosted.org/packages/bd/28/0a25ee5342eb5d5f297d992a77e56892ecb65e7854c7898fb7d35e9b33bd/websockets-16.0-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:95724e638f0f9c350bb1c2b0a7ad0e83d9cc0c9259f3ea94e40d7b02a2179ae5", size = 184975, upload-time = "2026-01-10T09:23:03.756Z" }, + { url = "https://files.pythonhosted.org/packages/f9/66/27ea52741752f5107c2e41fda05e8395a682a1e11c4e592a809a90c6a506/websockets-16.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c0204dc62a89dc9d50d682412c10b3542d748260d743500a85c13cd1ee4bde82", size = 186203, upload-time = "2026-01-10T09:23:05.01Z" }, + { url = "https://files.pythonhosted.org/packages/37/e5/8e32857371406a757816a2b471939d51c463509be73fa538216ea52b792a/websockets-16.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:52ac480f44d32970d66763115edea932f1c5b1312de36df06d6b219f6741eed8", size = 185653, upload-time = "2026-01-10T09:23:06.301Z" }, + { url = "https://files.pythonhosted.org/packages/9b/67/f926bac29882894669368dc73f4da900fcdf47955d0a0185d60103df5737/websockets-16.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6e5a82b677f8f6f59e8dfc34ec06ca6b5b48bc4fcda346acd093694cc2c24d8f", size = 184920, upload-time = "2026-01-10T09:23:07.492Z" }, + { url = "https://files.pythonhosted.org/packages/3c/a1/3d6ccdcd125b0a42a311bcd15a7f705d688f73b2a22d8cf1c0875d35d34a/websockets-16.0-cp313-cp313-win32.whl", hash = "sha256:abf050a199613f64c886ea10f38b47770a65154dc37181bfaff70c160f45315a", size = 178255, upload-time = "2026-01-10T09:23:09.245Z" }, + { url = "https://files.pythonhosted.org/packages/6b/ae/90366304d7c2ce80f9b826096a9e9048b4bb760e44d3b873bb272cba696b/websockets-16.0-cp313-cp313-win_amd64.whl", hash = "sha256:3425ac5cf448801335d6fdc7ae1eb22072055417a96cc6b31b3861f455fbc156", size = 178689, upload-time = "2026-01-10T09:23:10.483Z" }, + { url = "https://files.pythonhosted.org/packages/f3/1d/e88022630271f5bd349ed82417136281931e558d628dd52c4d8621b4a0b2/websockets-16.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:8cc451a50f2aee53042ac52d2d053d08bf89bcb31ae799cb4487587661c038a0", size = 177406, upload-time = "2026-01-10T09:23:12.178Z" }, + { url = "https://files.pythonhosted.org/packages/f2/78/e63be1bf0724eeb4616efb1ae1c9044f7c3953b7957799abb5915bffd38e/websockets-16.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:daa3b6ff70a9241cf6c7fc9e949d41232d9d7d26fd3522b1ad2b4d62487e9904", size = 175085, upload-time = "2026-01-10T09:23:13.511Z" }, + { url = "https://files.pythonhosted.org/packages/bb/f4/d3c9220d818ee955ae390cf319a7c7a467beceb24f05ee7aaaa2414345ba/websockets-16.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:fd3cb4adb94a2a6e2b7c0d8d05cb94e6f1c81a0cf9dc2694fb65c7e8d94c42e4", size = 175328, upload-time = "2026-01-10T09:23:14.727Z" }, + { url = "https://files.pythonhosted.org/packages/63/bc/d3e208028de777087e6fb2b122051a6ff7bbcca0d6df9d9c2bf1dd869ae9/websockets-16.0-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:781caf5e8eee67f663126490c2f96f40906594cb86b408a703630f95550a8c3e", size = 185044, upload-time = "2026-01-10T09:23:15.939Z" }, + { url = "https://files.pythonhosted.org/packages/ad/6e/9a0927ac24bd33a0a9af834d89e0abc7cfd8e13bed17a86407a66773cc0e/websockets-16.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:caab51a72c51973ca21fa8a18bd8165e1a0183f1ac7066a182ff27107b71e1a4", size = 186279, upload-time = "2026-01-10T09:23:17.148Z" }, + { url = "https://files.pythonhosted.org/packages/b9/ca/bf1c68440d7a868180e11be653c85959502efd3a709323230314fda6e0b3/websockets-16.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:19c4dc84098e523fd63711e563077d39e90ec6702aff4b5d9e344a60cb3c0cb1", size = 185711, upload-time = "2026-01-10T09:23:18.372Z" }, + { url = "https://files.pythonhosted.org/packages/c4/f8/fdc34643a989561f217bb477cbc47a3a07212cbda91c0e4389c43c296ebf/websockets-16.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:a5e18a238a2b2249c9a9235466b90e96ae4795672598a58772dd806edc7ac6d3", size = 184982, upload-time = "2026-01-10T09:23:19.652Z" }, + { url = "https://files.pythonhosted.org/packages/dd/d1/574fa27e233764dbac9c52730d63fcf2823b16f0856b3329fc6268d6ae4f/websockets-16.0-cp314-cp314-win32.whl", hash = "sha256:a069d734c4a043182729edd3e9f247c3b2a4035415a9172fd0f1b71658a320a8", size = 177915, upload-time = "2026-01-10T09:23:21.458Z" }, + { url = "https://files.pythonhosted.org/packages/8a/f1/ae6b937bf3126b5134ce1f482365fde31a357c784ac51852978768b5eff4/websockets-16.0-cp314-cp314-win_amd64.whl", hash = "sha256:c0ee0e63f23914732c6d7e0cce24915c48f3f1512ec1d079ed01fc629dab269d", size = 178381, upload-time = "2026-01-10T09:23:22.715Z" }, + { url = "https://files.pythonhosted.org/packages/06/9b/f791d1db48403e1f0a27577a6beb37afae94254a8c6f08be4a23e4930bc0/websockets-16.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:a35539cacc3febb22b8f4d4a99cc79b104226a756aa7400adc722e83b0d03244", size = 177737, upload-time = "2026-01-10T09:23:24.523Z" }, + { url = "https://files.pythonhosted.org/packages/bd/40/53ad02341fa33b3ce489023f635367a4ac98b73570102ad2cdd770dacc9a/websockets-16.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:b784ca5de850f4ce93ec85d3269d24d4c82f22b7212023c974c401d4980ebc5e", size = 175268, upload-time = "2026-01-10T09:23:25.781Z" }, + { url = "https://files.pythonhosted.org/packages/74/9b/6158d4e459b984f949dcbbb0c5d270154c7618e11c01029b9bbd1bb4c4f9/websockets-16.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:569d01a4e7fba956c5ae4fc988f0d4e187900f5497ce46339c996dbf24f17641", size = 175486, upload-time = "2026-01-10T09:23:27.033Z" }, + { url = "https://files.pythonhosted.org/packages/e5/2d/7583b30208b639c8090206f95073646c2c9ffd66f44df967981a64f849ad/websockets-16.0-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:50f23cdd8343b984957e4077839841146f67a3d31ab0d00e6b824e74c5b2f6e8", size = 185331, upload-time = "2026-01-10T09:23:28.259Z" }, + { url = "https://files.pythonhosted.org/packages/45/b0/cce3784eb519b7b5ad680d14b9673a31ab8dcb7aad8b64d81709d2430aa8/websockets-16.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:152284a83a00c59b759697b7f9e9cddf4e3c7861dd0d964b472b70f78f89e80e", size = 186501, upload-time = "2026-01-10T09:23:29.449Z" }, + { url = "https://files.pythonhosted.org/packages/19/60/b8ebe4c7e89fb5f6cdf080623c9d92789a53636950f7abacfc33fe2b3135/websockets-16.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:bc59589ab64b0022385f429b94697348a6a234e8ce22544e3681b2e9331b5944", size = 186062, upload-time = "2026-01-10T09:23:31.368Z" }, + { url = "https://files.pythonhosted.org/packages/88/a8/a080593f89b0138b6cba1b28f8df5673b5506f72879322288b031337c0b8/websockets-16.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:32da954ffa2814258030e5a57bc73a3635463238e797c7375dc8091327434206", size = 185356, upload-time = "2026-01-10T09:23:32.627Z" }, + { url = "https://files.pythonhosted.org/packages/c2/b6/b9afed2afadddaf5ebb2afa801abf4b0868f42f8539bfe4b071b5266c9fe/websockets-16.0-cp314-cp314t-win32.whl", hash = "sha256:5a4b4cc550cb665dd8a47f868c8d04c8230f857363ad3c9caf7a0c3bf8c61ca6", size = 178085, upload-time = "2026-01-10T09:23:33.816Z" }, + { url = "https://files.pythonhosted.org/packages/9f/3e/28135a24e384493fa804216b79a6a6759a38cc4ff59118787b9fb693df93/websockets-16.0-cp314-cp314t-win_amd64.whl", hash = "sha256:b14dc141ed6d2dde437cddb216004bcac6a1df0935d79656387bd41632ba0bbd", size = 178531, upload-time = "2026-01-10T09:23:35.016Z" }, + { url = "https://files.pythonhosted.org/packages/6f/28/258ebab549c2bf3e64d2b0217b973467394a9cea8c42f70418ca2c5d0d2e/websockets-16.0-py3-none-any.whl", hash = "sha256:1637db62fad1dc833276dded54215f2c7fa46912301a24bd94d45d46a011ceec", size = 171598, upload-time = "2026-01-10T09:23:45.395Z" }, +] + [[package]] name = "yarl" version = "1.23.0" From e1779201ab09380824b1869ec9dc4c574d9c7253 Mon Sep 17 00:00:00 2001 From: "rikulpatel@gmail.com" Date: Tue, 2 Jun 2026 15:45:19 -0500 Subject: [PATCH 74/84] fix: /static routes fixed now --- app/channels/web_channel.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/app/channels/web_channel.py b/app/channels/web_channel.py index c7b768a..bee8d8c 100644 --- a/app/channels/web_channel.py +++ b/app/channels/web_channel.py @@ -285,8 +285,8 @@ async def _ws_endpoint(ws: WebSocket) -> None: from starlette.routing import Mount from starlette.staticfiles import StaticFiles static_dir = Path(__file__).parent / "static" - self._fasthtml_app.router.routes.append( - Mount("/static", StaticFiles(directory=str(static_dir)), name="static") + self._fasthtml_app.router.routes.insert( + 1, Mount("/static", StaticFiles(directory=str(static_dir)), name="static") ) async def run_polling(self) -> None: From 5d2044bc78e51c11fe129d0bfa8845acb6c5d8a0 Mon Sep 17 00:00:00 2001 From: "rikulpatel@gmail.com" Date: Sun, 14 Jun 2026 19:52:20 -0500 Subject: [PATCH 75/84] chore: removed some dead code --- CLAUDE.md | 2 +- app/channels/commands.py | 1 - app/core/agent.py | 7 ++----- app/infra/message_history.py | 3 +-- app/infra/setup.py | 2 +- 5 files changed, 5 insertions(+), 10 deletions(-) diff --git a/CLAUDE.md b/CLAUDE.md index 000cb11..4e65795 100755 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -74,7 +74,7 @@ The shared loop lives in `Agent._loop()` (`app/core/agent.py`). Subclasses overr | `_on_no_choices` | raise | exponential backoff | raise | | `_should_stop` | — | `channel.has_stopped` | — | -Tool calls within a single LLM turn are dispatched in parallel via `asyncio.gather`. After each turn, the full message chain (assistant tool-call message + tool results + final response) is saved to `self.messages` with tool results truncated to `TOOL_RESULT_HISTORY_LIMIT` chars to keep context lean. `MessageHistory` (SQLite) stores only user + final assistant text for cross-session persistence. +Tool calls within a single LLM turn are dispatched in parallel via `asyncio.gather`. After each turn, the full message chain (assistant tool-call message + tool results + final response) is saved to `self.messages` at full length. `MessageHistory` (SQLite) stores only user + final assistant text for cross-session persistence. ### Tool System diff --git a/app/channels/commands.py b/app/channels/commands.py index fb8d9c5..79fba3a 100644 --- a/app/channels/commands.py +++ b/app/channels/commands.py @@ -225,7 +225,6 @@ async def _mcp(args: str = "") -> str: desc = fn.get("description", "") lines.append(f" {bare}" + (f" — {desc}" if desc else "")) return "\n".join(lines) - return "\n".join(lines) else: specs = mcp_manager.get_tool_specs() if not specs: diff --git a/app/core/agent.py b/app/core/agent.py index b9e8b88..f7d9d35 100755 --- a/app/core/agent.py +++ b/app/core/agent.py @@ -19,9 +19,6 @@ def _slugify(name: str) -> str: return re.sub(r"[^a-z0-9-]", "", name.strip().lower().replace(" ", "-"))[:40] -TOOL_RESULT_HISTORY_LIMIT = 100 - - def get_default_sys_prompt(context: dict | None = None) -> str: ctx = context or {} channel = ctx.get("channel", "cli") @@ -130,7 +127,7 @@ async def handle_tool_call(self, tool_call) -> str: from .tool_calls import run_tool_async # lazy — tool_calls imports scheduled_tasks which imports Agent tool_name = tool_call.function.name try: - tool_args = json.loads(tool_call.function.arguments) + tool_args = json.loads(tool_call.function.arguments or "{}") if not await self._check_permission(tool_name, tool_args): return "User denied permission to run this tool. Ask for permission to run the tool again if you want to try running it." await self._on_tool_start(tool_name, tool_args) @@ -176,7 +173,7 @@ async def _loop(self, messages: list, tool_specs: list) -> str: log.info(f"{result[:250]}...") else: await self._on_response(assistant_message.content) - if finish_reason == "stop": + if finish_reason in ("stop", "length"): messages.append(self._serialize_assistant_msg(assistant_message)) break diff --git a/app/infra/message_history.py b/app/infra/message_history.py index cfbc930..9ab15ca 100755 --- a/app/infra/message_history.py +++ b/app/infra/message_history.py @@ -68,5 +68,4 @@ def get_history(self, limit: int = 100) -> list[dict]: ORDER BY id DESC LIMIT ?""", (self.channel, limit)).fetchall() return [{"role": row[0], "content": row[1]} for row in reversed(rows)] - def prune_old_messages(self, older_than_days: int) -> None: - pass + diff --git a/app/infra/setup.py b/app/infra/setup.py index 3a29fec..338a342 100755 --- a/app/infra/setup.py +++ b/app/infra/setup.py @@ -1,7 +1,7 @@ from __future__ import annotations from pathlib import Path -from ..config import get_default_config, APP_NAME, APP_DB +from ..config import get_default_config, APP_NAME from .app_logging import log def ensure_home_dir() -> None: From e7375529e91fadff6227c4803070d5853a535a5f Mon Sep 17 00:00:00 2001 From: "rikulpatel@gmail.com" Date: Sun, 14 Jun 2026 22:19:02 -0500 Subject: [PATCH 76/84] fix: failing test due to change --- tests/test_agent.py | 21 +++++---------------- 1 file changed, 5 insertions(+), 16 deletions(-) diff --git a/tests/test_agent.py b/tests/test_agent.py index 4cd818f..463fc8f 100644 --- a/tests/test_agent.py +++ b/tests/test_agent.py @@ -190,7 +190,7 @@ async def test_agent_loop_runs_tool_when_auto_approve(): @pytest.mark.asyncio -async def test_agent_loop_continues_when_finish_reason_not_stop(): +async def test_agent_loop_breaks_on_length_finish_reason(): with patch("app.core.agent.Client") as MockClient: mock_client = MagicMock() MockClient.return_value.get_client.return_value = mock_client @@ -210,23 +210,12 @@ async def test_agent_loop_continues_when_finish_reason_not_stop(): response_partial = MagicMock() response_partial.choices = [choice_partial] - msg_final = MagicMock() - msg_final.tool_calls = None - msg_final.content = "final" - msg_final.model_dump.return_value = {"role": "assistant", "content": "final"} - choice_final = MagicMock() - choice_final.message = msg_final - choice_final.finish_reason = "stop" - response_final = MagicMock() - response_final.choices = [choice_final] - - mock_client.chat.completions.create = AsyncMock( - side_effect=[response_partial, response_final] - ) + mock_client.chat.completions.create = AsyncMock(return_value=response_partial) - await agent.agent_loop("continue") + result = await agent.agent_loop("continue") - assert mock_client.chat.completions.create.call_count == 2 + assert mock_client.chat.completions.create.call_count == 1 + assert result == "partial" @pytest.mark.asyncio From 570050026eae3041b9bd2a50f670274620a816ca Mon Sep 17 00:00:00 2001 From: "rikulpatel@gmail.com" Date: Sun, 14 Jun 2026 23:01:40 -0500 Subject: [PATCH 77/84] feat: Added tracing with command line --trace and --tracedir flags. Added /trace on|off command for bg agents. Tests for the trace feature. --- app/channels/commands.py | 20 +++++++++- app/cli/cli_agent.py | 4 ++ app/core/background_agent.py | 9 ++++- app/infra/tracer.py | 27 +++++++++++++ app/main.py | 10 ++++- tests/test_agent.py | 21 ++++++++++ tests/test_background_agent.py | 31 +++++++++++++++ tests/test_commands.py | 71 +++++++++++++++++++++++++++++++++- tests/test_main.py | 41 ++++++++++++++++++++ tests/test_tracer.py | 44 +++++++++++++++++++++ 10 files changed, 274 insertions(+), 4 deletions(-) create mode 100644 app/infra/tracer.py create mode 100644 tests/test_tracer.py diff --git a/app/channels/commands.py b/app/channels/commands.py index 79fba3a..f469d89 100644 --- a/app/channels/commands.py +++ b/app/channels/commands.py @@ -69,6 +69,20 @@ async def model_cmd(args: str = "") -> str: return f"Model set to: {args.strip()}" +async def trace_cmd(args: str = "") -> str: + arg = args.strip().lower() + tracedir = runtime.get("tracedir") + if arg == "on": + runtime.set("trace", True) + return f"Tracing on. Writing to {tracedir}" + elif arg == "off": + runtime.set("trace", False) + return "Tracing off." + else: + state = runtime.get("trace", False) + return f"Tracing is {'on' if state else 'off'}. Dir: {tracedir}" + + def make_status_cmd(channel_str: str = "") -> CommandHandler: async def _status(args: str = "") -> str: uptime = datetime.now() - _STARTUP_TIME @@ -81,11 +95,15 @@ async def _status(args: str = "") -> str: else: conv_id = runtime.get("conversation_id", "—") conv_name = runtime.get("conversation_name", "—") + tracing = runtime.get("trace", False) + last_trace = runtime.get("last_trace") + trace_line = f"on ({last_trace})" if (tracing and last_trace) else ("on" if tracing else "off") return ( f"Bot status:\n" f" Model: {model}\n" f" Uptime: {hours}h {minutes}m {seconds}s\n" - f" Conversation: [{conv_id}] {conv_name}" + f" Conversation: [{conv_id}] {conv_name}\n" + f" Tracing: {trace_line}" ) return _status diff --git a/app/cli/cli_agent.py b/app/cli/cli_agent.py index a330744..1253fe2 100755 --- a/app/cli/cli_agent.py +++ b/app/cli/cli_agent.py @@ -66,6 +66,10 @@ async def agent_loop(self, message: str, metadata: dict = None) -> str: final_content = await self._loop(session_messages, get_all_tool_specs()) + if runtime.get("trace"): + from ..infra.tracer import write_trace + write_trace(session_messages, runtime.get("tracedir"), runtime.get("model", "unknown")) + self.messages.append({"role": "user", "content": message}) self.messages.append({"role": "assistant", "content": final_content}) self.history.add_message("assistant", final_content, self.conversation_id) diff --git a/app/core/background_agent.py b/app/core/background_agent.py index 0a73d16..b713459 100755 --- a/app/core/background_agent.py +++ b/app/core/background_agent.py @@ -45,7 +45,7 @@ def __init__(self, mq: MessageQueue = None, channel: Channel = None, max_iterati # Lazy import to avoid circular: commands imports runtime which is fine, # but conversation commands need self reference so we build registry here. from ..channels.commands import ( - CommandRegistry, BotCommand, help_cmd, make_status_cmd, model_cmd, + CommandRegistry, BotCommand, help_cmd, make_status_cmd, model_cmd, trace_cmd, list_conversations_cmd, new_conversation_cmd, load_conversation_cmd, fork_conversation_cmd, rename_conversation_cmd, export_conversation_cmd, mcp_cmd, @@ -53,6 +53,7 @@ def __init__(self, mq: MessageQueue = None, channel: Channel = None, max_iterati self.registry = CommandRegistry() ch = self._channel_str self.registry.register(BotCommand("model", "Get or set model. Usage: /model [name]", model_cmd)) + self.registry.register(BotCommand("trace", "Toggle LLM tracing. Usage: /trace [on|off]", trace_cmd)) self.registry.register(BotCommand("status", "Show bot status.", make_status_cmd(ch))) self.registry.register(BotCommand("stop", "Pause the bot.", self._stop_cmd)) self.registry.register(BotCommand("list", "List conversations.", list_conversations_cmd(self._store, ch))) @@ -138,6 +139,12 @@ async def agent_loop(self, message: str, metadata: dict = None) -> str: final_content = await self._loop(session_messages, get_all_tool_specs()) + if runtime.get("trace"): + from ..infra.tracer import write_trace + path = write_trace(session_messages, runtime.get("tracedir"), runtime.get("model", "unknown")) + if path: + runtime.set("last_trace", path.name) + self.channel.clear_stopped() self.messages.append({"role": "user", "content": message}) diff --git a/app/infra/tracer.py b/app/infra/tracer.py new file mode 100644 index 0000000..87475ff --- /dev/null +++ b/app/infra/tracer.py @@ -0,0 +1,27 @@ +from __future__ import annotations + +import json +import logging +from datetime import datetime +from pathlib import Path + +log = logging.getLogger(__name__) + + +def write_trace(messages: list, tracedir: Path, model: str) -> Path | None: + try: + tracedir.mkdir(parents=True, exist_ok=True) + ts = datetime.now().strftime("%m%d%Y_%H%M%S") + path = tracedir / f"trace_{ts}.json" + data = { + "timestamp": datetime.now().isoformat(), + "model": model, + "messages": messages, + } + with open(path, "w", encoding="utf-8") as f: + json.dump(data, f, indent=2, default=str) + log.info(f"Trace written to {path}") + return path + except Exception as e: + log.warning(f"Failed to write trace: {e}") + return None diff --git a/app/main.py b/app/main.py index 5852e06..54da01c 100755 --- a/app/main.py +++ b/app/main.py @@ -4,6 +4,7 @@ import asyncio import logging import os +from pathlib import Path from . import config from .infra.app_logging import setup_logging, log @@ -60,6 +61,10 @@ async def load_config() -> None: def parse_args(): parser = argparse.ArgumentParser(prog="app") + parser.add_argument("--trace", action="store_true", default=False, + help="Enable LLM call tracing") + parser.add_argument("--tracedir", default=str(config.PROJECT_HOME / "trace"), metavar="DIR", + help="Trace output directory (default: ~/.crafterscode/trace)") subparsers = parser.add_subparsers(dest="command", required=True) cli_parser = subparsers.add_parser("cli", help="Run interactive CLI") @@ -106,7 +111,7 @@ async def run_cli(args): return from .channels.commands import ( - CommandRegistry, BotCommand, make_status_cmd, help_cmd, model_cmd, + CommandRegistry, BotCommand, make_status_cmd, help_cmd, model_cmd, trace_cmd, list_conversations_cmd, new_conversation_cmd, load_conversation_cmd, fork_conversation_cmd, rename_conversation_cmd, export_conversation_cmd, mcp_cmd, @@ -114,6 +119,7 @@ async def run_cli(args): cli_registry = CommandRegistry() cli_registry.register(BotCommand("status", "Show bot status.", make_status_cmd())) cli_registry.register(BotCommand("model", "Get or set model. Usage: /model [name]", model_cmd)) + cli_registry.register(BotCommand("trace", "Toggle LLM tracing. Usage: /trace [on|off]", trace_cmd)) cli_registry.register(BotCommand("list", "List conversations.", list_conversations_cmd(agent._store, agent._channel_str))) cli_registry.register(BotCommand("new", "Start a new conversation.", new_conversation_cmd(agent))) cli_registry.register(BotCommand("load", "Load a conversation. Usage: /load ", load_conversation_cmd(agent))) @@ -155,6 +161,8 @@ async def main(): runtime.set("model", config.get("model", "deepseek/deepseek-v4-flash")) runtime.set("max_iterations", args.max_iterations) + runtime.set("trace", args.trace) + runtime.set("tracedir", Path(args.tracedir)) from .core.mcp_manager import mcp_manager try: diff --git a/tests/test_agent.py b/tests/test_agent.py index 463fc8f..cb35a9b 100644 --- a/tests/test_agent.py +++ b/tests/test_agent.py @@ -218,6 +218,27 @@ async def test_agent_loop_breaks_on_length_finish_reason(): assert result == "partial" +@pytest.mark.asyncio +async def test_agent_loop_calls_write_trace_when_enabled(tmp_path): + agent, _ = make_agent() + fake_path = tmp_path / "trace_01012026_120000.json" + with patch("app.core.runtime._store", {"trace": True, "tracedir": tmp_path, "model": "m"}): + with patch("app.infra.tracer.write_trace", return_value=fake_path) as mock_write: + await agent.agent_loop("hello") + mock_write.assert_called_once() + args = mock_write.call_args[0] + assert args[1] == tmp_path # tracedir + + +@pytest.mark.asyncio +async def test_agent_loop_does_not_call_write_trace_when_disabled(tmp_path): + agent, _ = make_agent() + with patch("app.core.runtime._store", {"trace": False, "tracedir": tmp_path, "model": "m"}): + with patch("app.infra.tracer.write_trace") as mock_write: + await agent.agent_loop("hello") + mock_write.assert_not_called() + + @pytest.mark.asyncio async def test_agent_loop_gathers_multiple_tool_calls_in_parallel(): agent, mock_client = make_agent() diff --git a/tests/test_background_agent.py b/tests/test_background_agent.py index 608e2cd..a089a0e 100644 --- a/tests/test_background_agent.py +++ b/tests/test_background_agent.py @@ -307,6 +307,37 @@ async def test_process_incoming_sends_error_to_user_on_agent_loop_failure(): assert error_msg.metadata == {"chat_id": 99} +@pytest.mark.asyncio +async def test_agent_loop_calls_write_trace_when_enabled(tmp_path): + agent, _, _ = make_agent() + fake_path = tmp_path / "trace_01012026_120000.json" + with patch("app.core.runtime._store", {"trace": True, "tracedir": tmp_path, "model": "m"}): + with patch("app.infra.tracer.write_trace", return_value=fake_path) as mock_write: + await agent.agent_loop("hello") + mock_write.assert_called_once() + assert mock_write.call_args[0][1] == tmp_path # tracedir + + +@pytest.mark.asyncio +async def test_agent_loop_does_not_call_write_trace_when_disabled(tmp_path): + agent, _, _ = make_agent() + with patch("app.core.runtime._store", {"trace": False, "tracedir": tmp_path, "model": "m"}): + with patch("app.infra.tracer.write_trace") as mock_write: + await agent.agent_loop("hello") + mock_write.assert_not_called() + + +@pytest.mark.asyncio +async def test_agent_loop_sets_last_trace_on_success(tmp_path): + agent, _, _ = make_agent() + fake_path = tmp_path / "trace_01012026_120000.json" + mock_store = {"trace": True, "tracedir": tmp_path, "model": "m"} + with patch("app.core.runtime._store", mock_store): + with patch("app.infra.tracer.write_trace", return_value=fake_path): + await agent.agent_loop("hello") + assert mock_store.get("last_trace") == fake_path.name + + @pytest.mark.asyncio async def test_agent_loop_gathers_multiple_tool_calls_in_parallel(): agent, mock_client, mq = make_agent() diff --git a/tests/test_commands.py b/tests/test_commands.py index 02eddef..93b37d6 100644 --- a/tests/test_commands.py +++ b/tests/test_commands.py @@ -1,7 +1,8 @@ import pytest +from pathlib import Path from unittest.mock import AsyncMock, patch -from app.channels.commands import BotCommand, CommandRegistry, status_cmd, help_cmd, model_cmd +from app.channels.commands import BotCommand, CommandRegistry, status_cmd, help_cmd, model_cmd, trace_cmd def make_registry(*extra: BotCommand) -> CommandRegistry: @@ -135,3 +136,71 @@ async def test_model_cmd_sets_model(): result = await model_cmd("new-model") assert "new-model" in result assert mock_store["model"] == "new-model" + + +# --- trace_cmd --- + +@pytest.mark.asyncio +async def test_trace_cmd_shows_off_when_no_args(): + with patch("app.core.runtime._store", {"trace": False, "tracedir": Path("/tmp/traces")}): + result = await trace_cmd("") + assert "off" in result + + +@pytest.mark.asyncio +async def test_trace_cmd_shows_on_when_no_args(): + with patch("app.core.runtime._store", {"trace": True, "tracedir": Path("/tmp/traces")}): + result = await trace_cmd("") + assert "on" in result + + +@pytest.mark.asyncio +async def test_trace_cmd_on_enables_tracing(): + mock_store = {"trace": False, "tracedir": Path("/tmp/traces")} + with patch("app.core.runtime._store", mock_store): + result = await trace_cmd("on") + assert mock_store["trace"] is True + assert "on" in result.lower() + + +@pytest.mark.asyncio +async def test_trace_cmd_off_disables_tracing(): + mock_store = {"trace": True, "tracedir": Path("/tmp/traces")} + with patch("app.core.runtime._store", mock_store): + result = await trace_cmd("off") + assert mock_store["trace"] is False + assert "off" in result.lower() + + +@pytest.mark.asyncio +async def test_trace_cmd_includes_tracedir_in_response(): + with patch("app.core.runtime._store", {"trace": False, "tracedir": Path("/my/traces")}): + result = await trace_cmd("on") + assert "/my/traces" in result + + +# --- status_cmd tracing line --- + +@pytest.mark.asyncio +async def test_status_includes_tracing_off(): + with patch("app.core.runtime._store", {"trace": False, "model": "m"}): + result = await status_cmd() + assert "Tracing" in result + assert "off" in result + + +@pytest.mark.asyncio +async def test_status_shows_tracing_on_with_filename(): + mock_store = {"trace": True, "last_trace": "trace_06142026_103045.json", "model": "m"} + with patch("app.core.runtime._store", mock_store): + result = await status_cmd() + assert "on" in result + assert "trace_06142026_103045.json" in result + + +@pytest.mark.asyncio +async def test_status_shows_tracing_on_without_filename(): + with patch("app.core.runtime._store", {"trace": True, "model": "m"}): + result = await status_cmd() + assert "Tracing" in result + assert "on" in result diff --git a/tests/test_main.py b/tests/test_main.py index e00af01..ceecb03 100644 --- a/tests/test_main.py +++ b/tests/test_main.py @@ -224,6 +224,47 @@ async def fake_input_loop(): agent_mock.agent_loop.assert_any_call("third") +# --------------------------------------------------------------------------- +# --trace / --tracedir +# --------------------------------------------------------------------------- + +@pytest.mark.asyncio +async def test_main_trace_defaults_to_false(): + mock_store = {} + agent_mock = MagicMock() + agent_mock.agent_loop = AsyncMock() + with patch("sys.argv", ["prog", "cli", "-p", "hi", "--no-repl"]), \ + patch("app.main.CliAgent", return_value=agent_mock), \ + patch("app.core.runtime._store", mock_store): + await main() + assert mock_store.get("trace") is False + + +@pytest.mark.asyncio +async def test_main_trace_flag_sets_runtime_true(tmp_path): + mock_store = {} + agent_mock = MagicMock() + agent_mock.agent_loop = AsyncMock() + with patch("sys.argv", ["prog", "--trace", "--tracedir", str(tmp_path), "cli", "-p", "hi", "--no-repl"]), \ + patch("app.main.CliAgent", return_value=agent_mock), \ + patch("app.core.runtime._store", mock_store): + await main() + assert mock_store.get("trace") is True + assert mock_store.get("tracedir") == tmp_path + + +@pytest.mark.asyncio +async def test_main_tracedir_defaults_to_project_home_trace(): + mock_store = {} + agent_mock = MagicMock() + agent_mock.agent_loop = AsyncMock() + with patch("sys.argv", ["prog", "cli", "-p", "hi", "--no-repl"]), \ + patch("app.main.CliAgent", return_value=agent_mock), \ + patch("app.core.runtime._store", mock_store): + await main() + assert "trace" in str(mock_store.get("tracedir")) + + # --------------------------------------------------------------------------- # initialize_mcp # --------------------------------------------------------------------------- diff --git a/tests/test_tracer.py b/tests/test_tracer.py new file mode 100644 index 0000000..42fd64f --- /dev/null +++ b/tests/test_tracer.py @@ -0,0 +1,44 @@ +import json +import pytest +from pathlib import Path +from unittest.mock import patch + +from app.infra.tracer import write_trace + + +def test_write_trace_creates_file(tmp_path): + messages = [{"role": "user", "content": "hello"}, {"role": "assistant", "content": "hi"}] + path = write_trace(messages, tmp_path, "test-model") + assert path is not None + assert path.exists() + + +def test_write_trace_file_content(tmp_path): + messages = [{"role": "user", "content": "hello"}] + path = write_trace(messages, tmp_path, "test-model") + data = json.loads(path.read_text()) + assert data["model"] == "test-model" + assert data["messages"] == messages + assert "timestamp" in data + + +def test_write_trace_filename_format(tmp_path): + path = write_trace([{"role": "user", "content": "hi"}], tmp_path, "m") + assert path.name.startswith("trace_") + assert path.suffix == ".json" + + +def test_write_trace_creates_missing_directory(tmp_path): + tracedir = tmp_path / "nested" / "traces" + path = write_trace([{"role": "user", "content": "hi"}], tracedir, "m") + assert tracedir.exists() + assert path is not None + assert path.exists() + + +def test_write_trace_returns_none_on_error(tmp_path): + # Create a file where the tracedir would need to be created as a directory + blocker = tmp_path / "blocker" + blocker.write_text("I am a file") + result = write_trace([], blocker / "subdir", "m") + assert result is None From 62f6202e8a6eaad81fbf52a818976e8b4d437b5f Mon Sep 17 00:00:00 2001 From: "rikulpatel@gmail.com" Date: Mon, 15 Jun 2026 19:02:38 -0500 Subject: [PATCH 78/84] fix: agent loop robustness and reasoning content extraction --- app/core/agent.py | 17 +++++++++-------- 1 file changed, 9 insertions(+), 8 deletions(-) diff --git a/app/core/agent.py b/app/core/agent.py index f7d9d35..719d695 100755 --- a/app/core/agent.py +++ b/app/core/agent.py @@ -72,10 +72,10 @@ def _serialize_assistant_msg(msg) -> dict: d = {"role": msg.role, "content": msg.content} if msg.tool_calls: d["tool_calls"] = [tc.model_dump() for tc in msg.tool_calls] - raw = msg.model_dump() - reasoning = raw.get("reasoning_content") or raw.get("reasoning") - if reasoning: - d["reasoning_content"] = reasoning + raw = msg.model_dump() + reasoning = raw.get("reasoning_content") or raw.get("reasoning") + if reasoning: + d["reasoning_content"] = reasoning return d # --- hooks --- @@ -127,7 +127,7 @@ async def handle_tool_call(self, tool_call) -> str: from .tool_calls import run_tool_async # lazy — tool_calls imports scheduled_tasks which imports Agent tool_name = tool_call.function.name try: - tool_args = json.loads(tool_call.function.arguments or "{}") + tool_args = json.loads((tool_call.function.arguments or "").strip() or "{}") if not await self._check_permission(tool_name, tool_args): return "User denied permission to run this tool. Ask for permission to run the tool again if you want to try running it." await self._on_tool_start(tool_name, tool_args) @@ -172,10 +172,11 @@ async def _loop(self, messages: list, tool_specs: list) -> str: messages.append({"role": "tool", "tool_call_id": tc.id, "name": tc.function.name, "content": result}) log.info(f"{result[:250]}...") else: + messages.append(self._serialize_assistant_msg(assistant_message)) await self._on_response(assistant_message.content) - if finish_reason in ("stop", "length"): - messages.append(self._serialize_assistant_msg(assistant_message)) - break + if finish_reason not in ("stop", "length") and finish_reason is not None: + log.warning(f"Unexpected finish_reason={finish_reason!r}, treating as terminal") + break if self._should_stop(): break From 08c0c6306bdd9ef7dd2d7fb342c40e10d59bf006 Mon Sep 17 00:00:00 2001 From: Rikul Patel Date: Tue, 16 Jun 2026 17:36:08 -0500 Subject: [PATCH 79/84] Add support for file/image attachments in user messages (data URL encoding) (#13) * Use files metadata for all attachments * Attachments: 5MB combined limit, placeholder in history after first turn - session_messages for the current turn still carries full base64 data so the LLM sees the files; subsequent turns store a plain-text placeholder instead: "message [Attachment: ~/file.pdf]" - self.messages always holds plain strings now, eliminating token bloat across turns, DB storage concerns, and any need for redaction helpers - Add tests for the empty-string path, the missing-file-bypasses-size-check case, and the no-history-write-on-fail Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com> Co-authored-by: Claude --- app/cli/cli_agent.py | 6 +- app/core/agent.py | 83 ++++++++++++++++++++ app/core/background_agent.py | 6 +- app/core/helper_agent.py | 2 +- tests/test_agent.py | 143 ++++++++++++++++++++++++++++++++++- 5 files changed, 234 insertions(+), 6 deletions(-) diff --git a/app/cli/cli_agent.py b/app/cli/cli_agent.py index 1253fe2..7be8fa4 100755 --- a/app/cli/cli_agent.py +++ b/app/cli/cli_agent.py @@ -53,6 +53,8 @@ async def _on_response(self, content: str | None) -> None: async def agent_loop(self, message: str, metadata: dict = None) -> str: self._trim_messages() + attachments = self._as_list((metadata or {}).get("files")) + user_msg = self._build_user_message(message, metadata) self.history.add_message("user", message, self.conversation_id) conv = self._store.get(self.conversation_id) @@ -62,7 +64,7 @@ async def agent_loop(self, message: str, metadata: dict = None) -> str: "conversation_name": conv["name"] if conv else "New Conversation", }) system = [{"role": "system", "content": system_context}] if system_context else [] - session_messages = system + self.messages[:] + [{"role": "user", "content": message}] + session_messages = system + self.messages[:] + [user_msg] final_content = await self._loop(session_messages, get_all_tool_specs()) @@ -70,7 +72,7 @@ async def agent_loop(self, message: str, metadata: dict = None) -> str: from ..infra.tracer import write_trace write_trace(session_messages, runtime.get("tracedir"), runtime.get("model", "unknown")) - self.messages.append({"role": "user", "content": message}) + self.messages.append({"role": "user", "content": self._build_placeholder_content(message, attachments)}) self.messages.append({"role": "assistant", "content": final_content}) self.history.add_message("assistant", final_content, self.conversation_id) self._store.touch(self.conversation_id) diff --git a/app/core/agent.py b/app/core/agent.py index 719d695..fc66266 100755 --- a/app/core/agent.py +++ b/app/core/agent.py @@ -1,5 +1,7 @@ import asyncio +import base64 import json +import mimetypes import os import platform import re @@ -78,6 +80,87 @@ def _serialize_assistant_msg(msg) -> dict: d["reasoning_content"] = reasoning return d + + @staticmethod + def _as_list(value) -> list: + if value is None: + return [] + if isinstance(value, (str, os.PathLike)): + return [value] + if isinstance(value, (list, tuple)): + for item in value: + if not isinstance(item, (str, os.PathLike)): + raise TypeError( + f"metadata['files'] entries must be paths, got {type(item).__name__}" + ) + return list(value) + raise TypeError(f"metadata['files'] must be a path or list of paths, got {type(value).__name__}") + + _MAX_COMBINED_ATTACHMENT_BYTES = 5 * 1024 * 1024 # 5 MB combined across all attachments + + @classmethod + def _attachment_part(cls, attachment: str) -> dict: + path = Path(attachment).expanduser() + if not path.is_file(): + raise FileNotFoundError(f"Attachment not found: {path}") + + mime_type = mimetypes.guess_type(path.name)[0] or "application/octet-stream" + try: + raw = path.read_bytes() + except PermissionError as e: + raise PermissionError(f"Cannot read attachment: {path}") from e + + data_url = f"data:{mime_type};base64,{base64.b64encode(raw).decode('ascii')}" + + if mime_type.startswith("image/"): + return { + "type": "image_url", + "image_url": {"url": data_url}, + } + + return { + "type": "file", + "file": { + "filename": path.name, + "file_data": data_url, + }, + } + + @classmethod + def _build_user_message(cls, message: str, metadata: dict | None = None) -> dict: + metadata = metadata or {} + attachments = cls._as_list(metadata.get("files")) + if not attachments: + return {"role": "user", "content": message} + + # Validate every path and accumulate size before encoding anything, + # so a bad path always raises the same clear error regardless of order. + total_size = 0 + for a in attachments: + p = Path(a).expanduser() + if not p.is_file(): + raise FileNotFoundError(f"Attachment not found: {p}") + try: + total_size += p.stat().st_size + except PermissionError as e: + raise PermissionError(f"Cannot stat attachment: {p}") from e + if total_size > cls._MAX_COMBINED_ATTACHMENT_BYTES: + raise ValueError( + f"Total attachment size {total_size / 1024 / 1024:.1f} MB exceeds " + f"{cls._MAX_COMBINED_ATTACHMENT_BYTES / 1024 / 1024:.0f} MB combined limit" + ) + + content = [{"type": "text", "text": message}] + content.extend(cls._attachment_part(str(a)) for a in attachments) + return {"role": "user", "content": content} + + @staticmethod + def _build_placeholder_content(message: str, attachments: list) -> str: + if not attachments: + return message + placeholders = " ".join(f"[Attachment: {a}]" for a in attachments) + return f"{message} {placeholders}" + # --- hooks --- async def _on_thinking(self, content: str | None) -> None: diff --git a/app/core/background_agent.py b/app/core/background_agent.py index b713459..5c37a6b 100755 --- a/app/core/background_agent.py +++ b/app/core/background_agent.py @@ -126,6 +126,8 @@ async def agent_loop(self, message: str, metadata: dict = None) -> str: self._trim_messages() self._empty_retries = 0 self._reply_metadata = metadata or {} + attachments = self._as_list((metadata or {}).get("files")) + user_msg = self._build_user_message(message, metadata) self.history.add_message("user", message, self.conversation_id) conv = self._store.get(self.conversation_id) @@ -135,7 +137,7 @@ async def agent_loop(self, message: str, metadata: dict = None) -> str: "conversation_name": conv["name"] if conv else "New Conversation", }) system = [{"role": "system", "content": system_context}] if system_context else [] - session_messages = system + self.messages[:] + [{"role": "user", "content": message}] + session_messages = system + self.messages[:] + [user_msg] final_content = await self._loop(session_messages, get_all_tool_specs()) @@ -147,7 +149,7 @@ async def agent_loop(self, message: str, metadata: dict = None) -> str: self.channel.clear_stopped() - self.messages.append({"role": "user", "content": message}) + self.messages.append({"role": "user", "content": self._build_placeholder_content(message, attachments)}) self.messages.append({"role": "assistant", "content": final_content}) self.history.add_message("assistant", final_content, self.conversation_id) self._store.touch(self.conversation_id) diff --git a/app/core/helper_agent.py b/app/core/helper_agent.py index f70e100..46e8132 100644 --- a/app/core/helper_agent.py +++ b/app/core/helper_agent.py @@ -17,5 +17,5 @@ async def run(self, prompt: str) -> str: async def agent_loop(self, message: str, metadata: dict = None) -> str: from .tool_calls import helper_tool_specs # lazy — avoids circular import via scheduled_tasks - self.messages.append({"role": "user", "content": message}) + self.messages.append(self._build_user_message(message, metadata)) return await self._loop(self.messages, helper_tool_specs) diff --git a/tests/test_agent.py b/tests/test_agent.py index cb35a9b..b8d7943 100644 --- a/tests/test_agent.py +++ b/tests/test_agent.py @@ -70,7 +70,7 @@ async def test_agent_loop_sends_system_context_to_llm(): agent, mock_client = make_agent() with patch("app.cli.cli_agent.get_default_sys_prompt", return_value="system prompt"): await agent.agent_loop("hello") - call_messages = mock_client.chat.completions.create.call_args[1]["messages"] + call_messages = mock_client.chat.completions.create.call_args_list[0][1]["messages"] assert call_messages[0]["role"] == "system" assert call_messages[0]["content"] == "system prompt" @@ -278,3 +278,144 @@ async def test_agent_loop_gathers_multiple_tool_calls_in_parallel(): mock_gather.assert_called_once() assert len(mock_gather.call_args[0]) == 2 + + +@pytest.mark.asyncio +async def test_agent_loop_sends_image_file_to_llm(tmp_path): + agent, mock_client = make_agent() + image_path = tmp_path / "screenshot.png" + image_path.write_bytes(b"fake image data") + + await agent.agent_loop("What is in this image?", metadata={"files": [str(image_path)]}) + + call_messages = mock_client.chat.completions.create.call_args_list[0][1]["messages"] + user_message = call_messages[1] + assert user_message["role"] == "user" + assert user_message["content"][0] == {"type": "text", "text": "What is in this image?"} + assert user_message["content"][1]["type"] == "image_url" + assert user_message["content"][1]["image_url"]["url"].startswith("data:image/png;base64,") + stored_user_msg = agent.messages[-2] + assert stored_user_msg["role"] == "user" + assert stored_user_msg["content"] == f"What is in this image? [Attachment: {image_path}]" + + +@pytest.mark.asyncio +async def test_agent_loop_accepts_single_metadata_file_path(tmp_path): + agent, mock_client = make_agent() + image_path = tmp_path / "screenshot.jpg" + image_path.write_bytes(b"fake image data") + + await agent.agent_loop("Describe this", metadata={"files": str(image_path)}) + + user_message = mock_client.chat.completions.create.call_args_list[0][1]["messages"][1] + assert user_message["content"][1]["image_url"]["url"].startswith("data:image/jpeg;base64,") + + +@pytest.mark.asyncio +async def test_agent_loop_sends_multiple_image_files_to_llm(tmp_path): + agent, mock_client = make_agent() + png_path = tmp_path / "first.png" + jpg_path = tmp_path / "second.jpg" + png_path.write_bytes(b"first fake image data") + jpg_path.write_bytes(b"second fake image data") + + await agent.agent_loop( + "Compare these images", + metadata={"files": [str(png_path), str(jpg_path)]}, + ) + + user_message = mock_client.chat.completions.create.call_args_list[0][1]["messages"][1] + assert user_message["content"][0] == {"type": "text", "text": "Compare these images"} + assert len(user_message["content"]) == 3 + assert user_message["content"][1]["image_url"]["url"].startswith("data:image/png;base64,") + assert user_message["content"][2]["image_url"]["url"].startswith("data:image/jpeg;base64,") + + +@pytest.mark.asyncio +async def test_agent_loop_sends_metadata_files_to_llm(tmp_path): + agent, mock_client = make_agent() + file_path = tmp_path / "notes.txt" + file_path.write_text("plain text attachment", encoding="utf-8") + + await agent.agent_loop("Summarize this file", metadata={"files": [str(file_path)]}) + + user_message = mock_client.chat.completions.create.call_args_list[0][1]["messages"][1] + assert user_message["content"][0] == {"type": "text", "text": "Summarize this file"} + assert user_message["content"][1]["type"] == "file" + assert user_message["content"][1]["file"]["filename"] == "notes.txt" + assert user_message["content"][1]["file"]["file_data"].startswith("data:text/plain;base64,") + + +@pytest.mark.asyncio +async def test_agent_loop_sends_image_files_as_images(tmp_path): + agent, mock_client = make_agent() + image_path = tmp_path / "diagram.png" + file_path = tmp_path / "report.pdf" + image_path.write_bytes(b"fake image data") + file_path.write_bytes(b"%PDF-1.4 fake pdf data") + + await agent.agent_loop( + "Use these attachments", + metadata={"files": [str(image_path), str(file_path)]}, + ) + + user_message = mock_client.chat.completions.create.call_args_list[0][1]["messages"][1] + assert user_message["content"][1]["type"] == "image_url" + assert user_message["content"][1]["image_url"]["url"].startswith("data:image/png;base64,") + assert user_message["content"][2]["type"] == "file" + assert user_message["content"][2]["file"]["file_data"].startswith("data:application/pdf;base64,") + + +def test_as_list_rejects_non_path_entries(): + with pytest.raises(TypeError): + Agent._as_list([123]) + with pytest.raises(TypeError): + Agent._as_list(123) + assert Agent._as_list(["a", "b"]) == ["a", "b"] + assert Agent._as_list("a") == ["a"] + assert Agent._as_list(None) == [] + + +def test_as_list_does_not_silently_drop_empty_string(): + # Only None means "no attachments"; an empty string path must surface + # as a loud failure downstream rather than being dropped. + assert Agent._as_list("") == [""] + + +def test_build_user_message_rejects_combined_oversized(tmp_path, monkeypatch): + f1 = tmp_path / "a.txt" + f2 = tmp_path / "b.txt" + f1.write_bytes(b"x" * 60) + f2.write_bytes(b"x" * 60) + monkeypatch.setattr(Agent, "_MAX_COMBINED_ATTACHMENT_BYTES", 100) + with pytest.raises(ValueError, match="combined limit"): + Agent._build_user_message("hi", {"files": [str(f1), str(f2)]}) + + +def test_build_user_message_does_not_skip_size_check_for_missing_file(tmp_path, monkeypatch): + ok = tmp_path / "ok.txt" + ok.write_bytes(b"x" * 60) + missing = tmp_path / "missing.txt" + monkeypatch.setattr(Agent, "_MAX_COMBINED_ATTACHMENT_BYTES", 100) + # A missing path must raise FileNotFoundError, not be silently skipped + # from the size accounting and fail later with a different error. + with pytest.raises(FileNotFoundError): + Agent._build_user_message("hi", {"files": [str(ok), str(missing)]}) + + +def test_build_placeholder_content(): + assert Agent._build_placeholder_content("hello", []) == "hello" + assert Agent._build_placeholder_content("look", ["/tmp/a.png"]) == "look [Attachment: /tmp/a.png]" + assert Agent._build_placeholder_content("check", ["/a.pdf", "/b.png"]) == "check [Attachment: /a.pdf] [Attachment: /b.png]" + + +@pytest.mark.asyncio +async def test_agent_loop_does_not_persist_history_when_attachment_invalid(tmp_path): + agent, mock_client = make_agent() + missing = tmp_path / "missing.png" + + with pytest.raises(FileNotFoundError): + await agent.agent_loop("look at this", metadata={"files": [str(missing)]}) + + agent.history.add_message.assert_not_called() + assert agent.messages == [] From 23da9b5f23c316594f2e0506b6e19d0fe2d5cc98 Mon Sep 17 00:00:00 2001 From: "rikulpatel@gmail.com" Date: Tue, 16 Jun 2026 22:59:31 -0500 Subject: [PATCH 80/84] fix: history adds [attachment] placeholder to messages --- app/cli/cli_agent.py | 5 +++-- app/core/background_agent.py | 5 +++-- tests/test_agent.py | 3 +++ 3 files changed, 9 insertions(+), 4 deletions(-) diff --git a/app/cli/cli_agent.py b/app/cli/cli_agent.py index 7be8fa4..307b513 100755 --- a/app/cli/cli_agent.py +++ b/app/cli/cli_agent.py @@ -55,7 +55,8 @@ async def agent_loop(self, message: str, metadata: dict = None) -> str: self._trim_messages() attachments = self._as_list((metadata or {}).get("files")) user_msg = self._build_user_message(message, metadata) - self.history.add_message("user", message, self.conversation_id) + placeholder_content = self._build_placeholder_content(message, attachments) + self.history.add_message("user", placeholder_content, self.conversation_id) conv = self._store.get(self.conversation_id) system_context = get_default_sys_prompt({ @@ -72,7 +73,7 @@ async def agent_loop(self, message: str, metadata: dict = None) -> str: from ..infra.tracer import write_trace write_trace(session_messages, runtime.get("tracedir"), runtime.get("model", "unknown")) - self.messages.append({"role": "user", "content": self._build_placeholder_content(message, attachments)}) + self.messages.append({"role": "user", "content": placeholder_content}) self.messages.append({"role": "assistant", "content": final_content}) self.history.add_message("assistant", final_content, self.conversation_id) self._store.touch(self.conversation_id) diff --git a/app/core/background_agent.py b/app/core/background_agent.py index 5c37a6b..a75a967 100755 --- a/app/core/background_agent.py +++ b/app/core/background_agent.py @@ -128,7 +128,8 @@ async def agent_loop(self, message: str, metadata: dict = None) -> str: self._reply_metadata = metadata or {} attachments = self._as_list((metadata or {}).get("files")) user_msg = self._build_user_message(message, metadata) - self.history.add_message("user", message, self.conversation_id) + placeholder_content = self._build_placeholder_content(message, attachments) + self.history.add_message("user", placeholder_content, self.conversation_id) conv = self._store.get(self.conversation_id) system_context = get_default_sys_prompt({ @@ -149,7 +150,7 @@ async def agent_loop(self, message: str, metadata: dict = None) -> str: self.channel.clear_stopped() - self.messages.append({"role": "user", "content": self._build_placeholder_content(message, attachments)}) + self.messages.append({"role": "user", "content": placeholder_content}) self.messages.append({"role": "assistant", "content": final_content}) self.history.add_message("assistant", final_content, self.conversation_id) self._store.touch(self.conversation_id) diff --git a/tests/test_agent.py b/tests/test_agent.py index b8d7943..df5b652 100644 --- a/tests/test_agent.py +++ b/tests/test_agent.py @@ -297,6 +297,9 @@ async def test_agent_loop_sends_image_file_to_llm(tmp_path): stored_user_msg = agent.messages[-2] assert stored_user_msg["role"] == "user" assert stored_user_msg["content"] == f"What is in this image? [Attachment: {image_path}]" + agent.history.add_message.assert_any_call( + "user", f"What is in this image? [Attachment: {image_path}]", agent.conversation_id + ) @pytest.mark.asyncio From 4d2c49b5637c288c3add941a2e1e4517ab7ab0f1 Mon Sep 17 00:00:00 2001 From: Rikul Patel Date: Wed, 17 Jun 2026 14:02:31 -0500 Subject: [PATCH 81/84] Add file attachment support to web channel (#14) * Add multi-file attachment support to the web channel Add a paperclip button next to the chat input that opens a native multi-file picker. Selected files render as removable chips and are uploaded via a new POST /api/upload endpoint, which stores them under $ANOTHERBOT_HOME/uploads with a UUID prefix and returns their basenames. Co-Authored-By: Claude Opus 4.8 Co-authored-by: gemini-code-assist[bot] <176961590+gemini-code-assist[bot]@users.noreply.github.com> Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com> --- CLAUDE.md | 2 +- app/channels/static/web_channel.css | 79 +++++++++++++ app/channels/static/web_channel.js | 113 +++++++++++++++++- app/channels/web_channel.py | 172 +++++++++++++++++++++++++--- tests/test_web_channel.py | 112 ++++++++++++++++++ 5 files changed, 458 insertions(+), 20 deletions(-) diff --git a/CLAUDE.md b/CLAUDE.md index 4e65795..192d8c5 100755 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -104,7 +104,7 @@ On startup, `load_system_context()` (`app/infra/startup.py`) loads `app/core/sys **Channel types** are defined in `ChannelType` enum (`app/channels/channel.py`): `CLI`, `TELEGRAM`, `DISCORD`, `WEB`. Each channel implements the `Channel` ABC and owns a `MessageQueue` instance. `bg_server.py` wires up enabled channels — each gets its own `MessageQueue`, `BackgroundAgent`, and set of coroutines (`run_polling`, `process_incoming`, `process_outgoing`) gathered into the event loop. -**WebChannel** (`app/channels/web_channel.py`) uses `python-fasthtml` + uvicorn to serve both a browser chat UI (`GET /`) and a JSON WebSocket endpoint (`WS /ws`) on the same port. Multiple concurrent browser tabs are supported — each connection gets a UUID tracked in `_connections`. A per-connection `asyncio.Lock` in `_send_locks` serializes writes to each WebSocket. The channel also exposes `GET /api/conversations`, `GET /api/messages` (scoped to web channel only), and `GET /api/status` REST endpoints. Only `/whoami` is handled inline (it needs the per-connection client ID); all other slash commands — including `/help`, `/status`, `/stop` — are forwarded to `BackgroundAgent`'s `CommandRegistry` via the message queue with `is_command=True` in metadata so `send_message()` emits `{"type":"system"}` responses, enabling the sidebar to refresh after conversation-mutating commands. +**WebChannel** (`app/channels/web_channel.py`) uses `python-fasthtml` + uvicorn to serve both a browser chat UI (`GET /`) and a JSON WebSocket endpoint (`WS /ws`) on the same port. Multiple concurrent browser tabs are supported — each connection gets a UUID tracked in `_connections`. A per-connection `asyncio.Lock` in `_send_locks` serializes writes to each WebSocket. The channel also exposes `GET /api/conversations`, `GET /api/messages` (scoped to web channel only), `GET /api/status`, and `POST /api/upload` REST endpoints. `POST /api/upload` accepts multipart `files` (one or more), writes each under `$ANOTHERBOT_HOME/uploads` with a UUID prefix, and returns the stored basenames; the browser (paperclip button next to the input) sends those basenames back in the WebSocket `message` frame's `files` field. `_resolve_upload_paths()` joins each basename to the upload dir (basename-only, so client paths can't traverse out) and the resolved absolute paths reach the agent via `metadata["files"]`, which `Agent._build_user_message()` encodes as image/file parts. Only `/whoami` is handled inline (it needs the per-connection client ID); all other slash commands — including `/help`, `/status`, `/stop` — are forwarded to `BackgroundAgent`'s `CommandRegistry` via the message queue with `is_command=True` in metadata so `send_message()` emits `{"type":"system"}` responses, enabling the sidebar to refresh after conversation-mutating commands. **Slash commands** are handled entirely by `BackgroundAgent`. Channel handlers (`command_handler` in Telegram, `on_message` in Discord) intercept only `/whoami` (resolved inline using the platform user object) and enqueue everything else as a plain `IncomingMessage`. `BackgroundAgent.process_incoming()` detects the leading `/` and dispatches via its own `CommandRegistry`. That registry owns the full command set: `/model`, `/status`, `/stop`, `/help`, `/list`, `/new`, `/load`, `/fork`, `/rename`, `/export`. diff --git a/app/channels/static/web_channel.css b/app/channels/static/web_channel.css index 942dfbb..94b9069 100644 --- a/app/channels/static/web_channel.css +++ b/app/channels/static/web_channel.css @@ -318,3 +318,82 @@ body { #send-btn:hover { background: var(--accent-h); } #send-btn:active { transform: scale(.97); } #send-btn:disabled { background: var(--border); cursor: not-allowed; } + +/* Hide the file input without display:none — keeps it in the layout/event + tree so its `change` event fires reliably (Edge) when opened via the label. */ +.visually-hidden { + position: absolute; + width: 1px; + height: 1px; + padding: 0; + margin: -1px; + overflow: hidden; + clip: rect(0, 0, 0, 0); + white-space: nowrap; + border: 0; +} + +/* ---- attach button (a