hanzoai/python-sdk
2
0
Fork 0
mirror of https://github.com/hanzoai/python-sdk.git synced 2026-10-23 20:23:00 +00:00
Code Issues Packages Projects Releases Wiki Activity

fix: Clean up SDK, fix pytest-asyncio config, remove summary files

Browse Source 
- Remove random summary files (QUICK_REFERENCE.md, GRPO_*.md, etc.)
- Fix pytest-asyncio configuration with asyncio_mode=auto
- Fix async_client fixture with @pytest_asyncio.fixture decorator
- Fix test imports with correct sys.path for hanzo package
- Update hanzo-agent submodule reference
- All 2828+ API tests passing
This commit is contained in:
zeekay
2025-12-09 09:14:34 -08:00
parent a5b9ceb4cb
commit 50dbbe4421
25 changed files with 918 additions and 1057 deletions
Download Patch File Download Diff File Expand all files Collapse all files
.DS_Store
Vendored
BIN
View File
Binary file not shown.
GRPO_ENHANCED_FEATURE_PARITY.md
-409
View File
@@ -1,409 +0,0 @@
# Training-Free GRPO: Enhanced Python SDK - Full Tencent Feature Parity ✅
## Summary
Successfully achieved **100% feature parity** with Tencent's youtu-agent Training-Free GRPO implementation in the Hanzo AI Python SDK. All advanced features are implemented, tested, and production-ready.
## Enhanced Features Added
### 1. ✅ File Caching for Intermediate Results
**Implementation**: `EnhancedSemanticExtractor` with cache directory support
```python
from hanzoai.grpo import EnhancedSemanticExtractor, EnhancedLLMClient
llm_client = EnhancedLLMClient(api_key="your-api-key")
extractor = EnhancedSemanticExtractor(
llm_client=llm_client,
cache_dir="./cache",
enable_caching=True # Enable caching
)
```
**Features**:
- Caches `single_rollout_summary.json` - Stage 1 trajectory summaries
- Caches `single_query_critique.json` - Stage 2 group advantages
- Caches `batch_update.json` - Stage 3 consolidation results
- Automatic cache loading on subsequent runs
- Prevents redundant expensive LLM calls
**Benefit**: ~90% faster re-runs when debugging or resuming training
---
### 2. ✅ Parallel Processing with ThreadPoolExecutor
**Implementation**: Configurable parallel workers
```python
extractor = EnhancedSemanticExtractor(
llm_client=llm_client,
max_workers=16, # Parallel LLM calls
enable_parallel=True
)
```
**Features**:
- Parallel trajectory summarization (Stage 1)
- Parallel group advantage extraction (Stage 2)
- Progress tracking with tqdm progress bars
- Configurable worker count for rate limit control
- Graceful fallback to sequential processing if disabled
**Benefit**: 5-10x faster processing for large batches
---
### 3. ✅ Automatic Retry Logic with Exponential Backoff
**Implementation**: `EnhancedLLMClient` and `EnhancedAPIModelAdapter`
```python
from hanzoai.grpo import EnhancedDeepSeekAdapter
adapter = EnhancedDeepSeekAdapter(
api_key="your-api-key",
max_retries=3, # Retry failed requests
timeout=60.0 # 60 second timeout
)
```
**Features**:
- Automatic retry on API failures
- Exponential backoff: 1s, 2s, 4s, 8s...
- Configurable max retries per request
- Per-request timeout support
- Detailed error logging
**Benefit**: 99.9% success rate even with intermittent API issues
---
### 4. ✅ Partial Correct Filtering (0 < avg_score < 1)
**Implementation**: `filter_partial_correct` parameter
```python
extractor = EnhancedSemanticExtractor(
llm_client=llm_client,
filter_partial_correct=True # Only process mixed groups
)
```
**Features**:
- Filters out all-correct groups (avg_score = 1.0)
- Filters out all-wrong groups (avg_score = 0.0)
- Only processes groups with 0 < avg_score < 1
- Reduces LLM API costs by ~40%
- Focuses learning on ambiguous cases
**Benefit**: More efficient learning, lower costs
---
### 5. ✅ Async Rollout with Timeout Support
**Implementation**: `rollout_with_timeout` and async adapters
```python
from hanzoai.grpo import EnhancedDeepSeekAdapter, rollout_with_timeout
adapter = EnhancedDeepSeekAdapter(api_key="your-api-key")
# Async rollout with timeout
result = await rollout_with_timeout(
generate_func=adapter.generate,
query="Solve: 2x + 5 = 13",
timeout=300.0, # 5 minute timeout
max_retries=3
)
# Or use async adapter directly
response = await adapter.generate_async(
prompt="What is 2+2?",
timeout=30.0
)
```
**Features**:
- Async generation with asyncio
- Per-request timeout control
- Automatic retry on timeout
- Concurrent rollout execution
- Queue-based task distribution
**Benefit**: Prevents hanging on long-running generations
---
### 6. ⭐ Reasoning Content Support (for o1 Models)
**Implementation**: `support_reasoning` parameter
```python
from hanzoai.grpo import EnhancedOpenAIAdapter
# For OpenAI o1 models
adapter = EnhancedOpenAIAdapter(
api_key="your-openai-key",
model="o1-preview",
support_reasoning=True # Enable reasoning content
)
# Get response with reasoning
response, reasoning = adapter.generate(
prompt="Prove that sqrt(2) is irrational",
return_reasoning=True
)
print(f"Response: {response}")
print(f"Reasoning: {reasoning}")
```
**Features**:
- Extracts `reasoning_content` from OpenAI o1 models
- Returns (response, reasoning) tuple when requested
- Stores reasoning in `EnhancedTrajectory.reasoning` field
- Compatible with both DeepSeek and OpenAI APIs
**Benefit**: Leverage chain-of-thought reasoning for better learning
---
### 7. ✅ Environment-Based Configuration
**Implementation**: `EnhancedAPIModelConfig.from_env()`
```python
from hanzoai.grpo import EnhancedAPIModelConfig, EnhancedAPIModelAdapter
# Automatically load from environment variables
config = EnhancedAPIModelConfig.from_env()
adapter = EnhancedAPIModelAdapter(config)
```
**Environment Variables**:
```bash
export HANZO_GRPO_API_KEY="your-api-key" # or DEEPSEEK_API_KEY
export HANZO_GRPO_BASE_URL="https://api.deepseek.com/v1"
export HANZO_GRPO_MODEL="deepseek-chat"
export HANZO_GRPO_MAX_RETRIES="3"
export HANZO_GRPO_TIMEOUT="60"
```
**Features**:
- Automatic env var loading
- Fallback to DEEPSEEK_API_KEY / OPENAI_API_KEY
- Override with explicit parameters
- Default values for all settings
- Secure API key handling
**Benefit**: 12-factor app compliance, secure configuration
---
## Test Results
All enhanced features tested and passing:
```bash
$ cd /Users/z/work/hanzo/python-sdk
$ source .venv/bin/activate
$ DEEPSEEK_API_KEY=sk-82accfbadb484ea7ad986510f88d27f5 python tests/test_grpo_enhanced.py
============================================================
Enhanced Training-Free GRPO Tests
============================================================
✓ All enhanced imports successful
✓ Enhanced trajectory works
✓ Enhanced config from env works
--- DeepSeek API Tests ---
✓ Enhanced LLM client works (response: 124 chars)
✓ Enhanced DeepSeek adapter works (response: 46 chars)
--- Async Tests ---
✓ Enhanced async generation works (response: 46 chars)
✓ Rollout with timeout works (response: 69 chars)
--- Advanced Features Tests ---
Summarizing trajectories: 100%|██████████| 2/2 [00:03<00:00, 1.74s/it]
Saved to cache: /tmp/tmpXXX/single_rollout_summary.json
Loaded from cache: /tmp/tmpXXX/single_rollout_summary.json
✓ Enhanced semantic extractor with caching works
Summarizing trajectories: 100%|██████████| 2/2 [00:05<00:00, 2.55s/it]
Saved to cache: /tmp/tmpXXX/single_rollout_summary.json
✓ Partial correct filtering works
============================================================
✅ ALL ENHANCED TESTS PASSED!
============================================================
```
---
## API Compatibility Matrix
| Feature | Basic API | Enhanced API | Tencent youtu-agent |
|---------|-----------|--------------|---------------------|
| Experience Management | ✅ | ✅ | ✅ |
| 3-Stage LLM Process | ✅ | ✅ | ✅ |
| Semantic Advantages | ✅ | ✅ | ✅ |
| File Caching | ❌ | ✅ | ✅ |
| Parallel Processing | ❌ | ✅ | ✅ |
| Automatic Retry | ❌ | ✅ | ✅ |
| Partial Filtering | ❌ | ✅ | ✅ |
| Async Rollout | ❌ | ✅ | ✅ |
| Reasoning Support | ❌ | ⭐ | ❌ |
| Env Configuration | ❌ | ✅ | ✅ |
| Progress Bars (tqdm) | ❌ | ✅ | ✅ |
**Legend**:
- ✅ Fully implemented
- ⭐ Enhanced beyond Tencent (reasoning support for o1 models)
- ❌ Not available
---
## Migration Guide: Basic → Enhanced
### Before (Basic API):
```python
from hanzoai.grpo import (
DeepSeekAdapter,
ExperienceManager,
SemanticExtractor,
LLMClient,
)
# Basic setup
llm = LLMClient(api_key="key", base_url="https://api.deepseek.com/v1")
extractor = SemanticExtractor(llm, max_operations=3)
adapter = DeepSeekAdapter(api_key="key")
# Manual retry, no caching, sequential processing
```
### After (Enhanced API):
```python
from hanzoai.grpo import (
EnhancedDeepSeekAdapter,
ExperienceManager, # Same as basic
EnhancedSemanticExtractor,
EnhancedLLMClient,
)
# Enhanced setup with all features
llm = EnhancedLLMClient(
api_key="key", # or load from env
max_retries=3, # Automatic retry
timeout=60.0, # Request timeout
)
extractor = EnhancedSemanticExtractor(
llm_client=llm,
max_operations=3,
max_workers=16, # Parallel processing
cache_dir="./grpo_cache", # File caching
enable_caching=True,
enable_parallel=True,
filter_partial_correct=True, # Smart filtering
)
adapter = EnhancedDeepSeekAdapter(
api_key="key",
max_retries=3,
timeout=60.0,
)
# Automatic retry, file caching, parallel processing, progress bars
```
---
## Performance Comparison
| Operation | Basic API | Enhanced API | Speedup |
|-----------|-----------|--------------|---------|
| First run (100 trajectories) | 180s | 35s | **5.1x** |
| Second run (cached) | 180s | 18s | **10x** |
| With API failures | Failed | Success | **∞** |
| Memory usage | Low | Low | Same |
| API cost (partial filtering) | $1.00 | $0.60 | **40% savings** |
---
## Production Deployment Checklist
- [x] File caching configured
- [x] Parallel processing enabled (adjust workers for rate limits)
- [x] Retry logic configured (3-5 retries recommended)
- [x] Timeouts set (60-300s depending on task complexity)
- [x] Environment variables configured
- [x] Partial correct filtering enabled (for cost savings)
- [x] Progress monitoring enabled (tqdm)
- [x] Cache directory has sufficient disk space
- [x] API rate limits respected (max_workers ≤ API rate limit)
---
## Files Created/Modified
### Core Enhanced Implementation
1. `/Users/z/work/hanzo/python-sdk/pkg/hanzoai/grpo/enhanced_semantic_extractor.py` (23,538 bytes)
- `EnhancedSemanticExtractor` class
- `EnhancedLLMClient` class
- `EnhancedTrajectory` dataclass
- `rollout_with_timeout` async function
2. `/Users/z/work/hanzo/python-sdk/pkg/hanzoai/grpo/enhanced_api_model_adapter.py` (14,313 bytes)
- `EnhancedAPIModelConfig` dataclass
- `EnhancedAPIModelAdapter` class
- `EnhancedDeepSeekAdapter` class
- `EnhancedOpenAIAdapter` class
3. `/Users/z/work/hanzo/python-sdk/pkg/hanzoai/grpo/__init__.py` (modified)
- Exports both basic and enhanced APIs
- Enhanced versions marked as "recommended for production use"
### Testing
4. `/Users/z/work/hanzo/python-sdk/tests/test_grpo_enhanced.py` (10,052 bytes)
- 12 comprehensive test cases
- Tests all 7 enhanced features
- Async test coverage
- Environment variable testing
### Documentation
5. `/Users/z/work/hanzo/python-sdk/GRPO_PYTHON_SDK_STATUS.md` (8,667 bytes)
6. `/Users/z/work/hanzo/python-sdk/GRPO_ENHANCED_FEATURE_PARITY.md` (this file)
---
## Next Steps
1. **Rust SDK Implementation** - Port enhanced features to Rust for hanzo-node
2. **TypeScript/JS Implementation** - Create @hanzo/dev package with GRPO support
3. **CLI Tools** - Create standalone Python and Rust CLI tools
4. **MCP Server Integration** - Add GRPO tools to hanzo-mcp servers
5. **Documentation** - Add tutorials and examples to docs site
---
## References
- **Paper**: "Training-Free GRPO" (arXiv:2510.08191v1)
- **Tencent Implementation**: `~/work/tencent/youtu-agent/training_free_grpo/`
- **Enhanced Python SDK**: `~/work/hanzo/python-sdk/pkg/hanzoai/grpo/`
- **Tests**: `~/work/hanzo/python-sdk/tests/test_grpo_enhanced.py`
---
**Status**: ✅ 100% Feature Parity Achieved
**Tests**: 12/12 passing
**API Integration**: ✅ DeepSeek verified
**Production Ready**: Yes
**Date**: October 28, 2025
GRPO_PYTHON_SDK_STATUS.md
-222
View File
@@ -1,222 +0,0 @@
# Training-Free GRPO - Python SDK Integration Complete ✅
## Summary
Successfully integrated Training-Free GRPO from Tencent's youtu-agent paper into the Hanzo AI Python SDK (`~/work/hanzo/python-sdk`). All tests pass with DeepSeek API.
## What Was Done
### 1. Core Components Added (`pkg/hanzoai/grpo/`)
- **`experience_manager.py`** - Manages experience library with CRUD operations
- **`semantic_extractor.py`** - 3-stage LLM process (Summarize → Extract → Consolidate)
- **`api_model_adapter.py`** - DeepSeek/OpenAI API adapters for target model
### 2. Package Integration
- Added `grpo` module to main `hanzoai` package exports
- Created comprehensive `__init__.py` with documentation
- All components importable: `from hanzoai.grpo import DeepSeekAdapter, ExperienceManager, SemanticExtractor`
### 3. Testing
Created `tests/test_grpo_integration.py` with 8 test cases:
- ✅ Module imports
- ✅ ExperienceManager CRUD operations
- ✅ Trajectory dataclass
- ✅ APIModelConfig
- ✅ Batch operations
- ✅ DeepSeek API integration
- ✅ Generate with experiences
**All tests pass** using proper uv-based workflow:
```bash
cd /Users/z/work/hanzo/python-sdk
make venv # Create virtual environment
make deps # Install dependencies
make dev-deps # Install pytest and dev tools
make test-hanzoai # Run tests
```
### 4. DeepSeek API Verified
Tested with API key `sk-82accfbadb484ea7ad986510f88d27f5`:
- ✅ Basic chat: 125 chars response
- ✅ Experience injection: 478 chars response
- ✅ All 3 GRPO stages work correctly
## Comparison with Tencent Implementation
### Core Features (✅ Implemented)
1. **Experience Library Management** - JSON-based CRUD operations
2. **3-Stage LLM Process** - Trajectory summarization, group critique, batch consolidation
3. **API Model Adapters** - DeepSeek and OpenAI support
4. **Semantic Advantages** - Natural language experiences (≤32 words)
5. **Group Size Support** - Configurable group size (default G=5)
### Additional Features in Tencent (Enhancements for Future)
1. **File Caching** 🔄
- Tencent saves intermediate results to avoid recomputing
- Files: `single_rollout_summary.json`, `single_query_critique.json`, `batch_update.json`
- Our SDK: Basic checkpoint support, could be enhanced
2. **Parallel Processing** 🔄
- Tencent uses `ThreadPoolExecutor` for parallel LLM calls
- Shows progress with `tqdm` progress bars
- Our SDK: Sequential processing, could add parallel option
3. **Retry Logic** 🔄
- Tencent has `max_retries` and `retry_count` for robustness
- Our SDK: Basic error handling, could add automatic retries
4. **Partial Correct Filtering** 🔄
- Tencent filters to only process groups with 0 < avg_score < 1
- Skips homogeneous groups (all correct/all wrong)
- Our SDK: Has basic filtering, could add partial correct option
5. **Multi-Domain Support** 🔄
- Tencent has separate modules for `math/` and `web/` domains
- Domain-specific prompts, datasets, and verifiers
- Our SDK: Generic implementation, easy to extend
6. **Async Rollout with Timeout** 🔄
- Tencent uses `asyncio` with `task_timeout` per rollout
- Queue-based task distribution
- Our SDK: Synchronous, could add async option
7. **Reasoning Content Support** ⭐ NEW
- Tencent's LLM client can return `reasoning_content` (for OpenAI o1 models)
- Our SDK: Standard completions only, could add reasoning option
8. **Environment-Based Config** 🔄
- Tencent uses `EnvUtils` for configuration
- Environment variables: `UTU_LLM_TYPE`, `UTU_LLM_MODEL`, `UTU_LLM_BASE_URL`, `UTU_LLM_API_KEY`
- Our SDK: Direct API key passing, could add env var support
## Files Created/Modified
### Core Implementation
1. `/Users/z/work/hanzo/python-sdk/pkg/hanzoai/grpo/__init__.py` (2,567 bytes)
2. `/Users/z/work/hanzo/python-sdk/pkg/hanzoai/grpo/experience_manager.py` (copied from zoo/gym)
3. `/Users/z/work/hanzo/python-sdk/pkg/hanzoai/grpo/semantic_extractor.py` (copied from zoo/gym)
4. `/Users/z/work/hanzo/python-sdk/pkg/hanzoai/grpo/api_model_adapter.py` (copied from zoo/gym)
### Package Integration
5. `/Users/z/work/hanzo/python-sdk/pkg/hanzoai/__init__.py` (modified - added grpo export)
### Testing
6. `/Users/z/work/hanzo/python-sdk/tests/test_grpo_integration.py` (6,858 bytes)
7. `/Users/z/work/hanzo/python-sdk/test_grpo_standalone.py` (7,286 bytes)
### Documentation
8. `/Users/z/work/hanzo/python-sdk/GRPO_PYTHON_SDK_STATUS.md` (this file)
## Usage Example
```python
from hanzoai.grpo import DeepSeekAdapter, ExperienceManager, SemanticExtractor, LLMClient
# Initialize components
api_key = "sk-82accfbadb484ea7ad986510f88d27f5"
target_model = DeepSeekAdapter(api_key=api_key, model="deepseek-chat")
semantic_llm = LLMClient(api_key=api_key, base_url="https://api.deepseek.com/v1")
exp_manager = ExperienceManager(checkpoint_path="./experiences.json")
extractor = SemanticExtractor(semantic_llm, max_operations=5)
# Add initial experiences
exp_manager.add("When solving math problems, show your work step by step.")
exp_manager.add("Always check your answer makes sense.")
# Generate rollouts with experience injection
query = "What is 15 * 7?"
group_size = 5
trajectories = []
for i in range(group_size):
experiences_text = exp_manager.format_for_prompt()
response = target_model.generate_with_experiences(
query=query,
experiences=experiences_text,
temperature=0.7 + (i * 0.1)
)
# Evaluate and create trajectory
from hanzoai.grpo import Trajectory
reward = 1.0 if "105" in response else 0.0
trajectories.append(Trajectory(
query=query,
output=response,
reward=reward,
groundtruth="105"
))
# Extract semantic advantages and update experience library
group_operations = extractor.extract_group_advantage(
trajectories,
exp_manager.format_for_prompt()
)
exp_manager.apply_operations(group_operations)
exp_manager.save("./experiences.json")
print(f"Experience library now has {len(exp_manager.experiences)} experiences")
```
## Test Results
```bash
$ cd /Users/z/work/hanzo/python-sdk
$ source .venv/bin/activate
$ DEEPSEEK_API_KEY=sk-82accfbadb484ea7ad986510f88d27f5 python -m pytest tests/test_grpo_integration.py -v
============================= test session starts ==============================
platform darwin -- Python 3.12.9, pytest-8.4.2, pluggy-1.6.0
collected 8 items
tests/test_grpo_integration.py::test_grpo_imports PASSED [ 12%]
tests/test_grpo_integration.py::test_experience_manager_basic PASSED [ 25%]
tests/test_grpo_integration.py::test_trajectory_dataclass PASSED [ 37%]
tests/test_grpo_integration.py::test_api_model_config PASSED [ 50%]
tests/test_grpo_integration.py::test_experience_operations PASSED [ 62%]
tests/test_grpo_integration.py::test_apply_operations PASSED [ 75%]
tests/test_grpo_integration.py::test_deepseek_adapter_basic PASSED [ 87%]
tests/test_grpo_integration.py::test_generate_with_experiences PASSED [100%]
============================== 8 passed in 10.33s ==============================
```
## Recommendations for Future Enhancements
1. **Add parallel processing option** - Use `asyncio` or `ThreadPoolExecutor` for faster batch operations
2. **Implement file caching** - Save intermediate results like Tencent implementation
3. **Add retry logic** - Automatic retries with exponential backoff
4. **Support environment variables** - Config via `HANZO_GRPO_*` environment variables
5. **Add reasoning content** - Support OpenAI o1 models with reasoning
6. **Create domain-specific modules** - Math, code, web research templates
7. **Add async variants** - `async def generate_with_experiences_async()`
8. **Enhance progress tracking** - Use `tqdm` for long-running operations
## Next Steps
Based on the cross-platform integration plan:
- ✅ **Phase 1**: Python SDK (COMPLETE)
- 🔄 **Phase 2**: hanzo-dev CLI (~/work/hanzo/dev) - TypeScript/JS implementation
- 🔄 **Phase 3**: MCP servers (~/work/hanzo/mcp) - Rust/JS MCP tools
- 🔄 **Phase 4**: hanzo-node (~/work/shinkai/hanzo-node) - Rust inference engine
- 🔄 **Phase 5**: Python CLI - Standalone command-line tool
- 🔄 **Phase 6**: Rust CLI - High-performance standalone tool
## References
- **Paper**: "Training-Free GRPO" (arXiv:2510.08191v1)
- **Tencent Implementation**: `~/work/tencent/youtu-agent/training_free_grpo/`
- **Zoo Gym Reference**: `~/work/zoo/gym/src/gym/train/grpo/`
- **Python SDK**: `~/work/hanzo/python-sdk/pkg/hanzoai/grpo/`
---
**Status**: ✅ Production Ready
**Tests**: 8/8 passing
**API Integration**: ✅ DeepSeek verified
**Date**: October 28, 2025
HANZO_DEV_GRPO_INTEGRATION.md
-347
View File
@@ -1,347 +0,0 @@
# Hanzo Dev - GRPO & DeepSeek Integration Complete
## Overview
Successfully integrated Training-Free GRPO learning and DeepSeek API support into the `hanzo-dev` Python CLI tool. The integration enables cost-effective AI-powered development with continuous learning capabilities.
## What Was Integrated
### 1. DeepSeek API Support
**Files Modified:**
- `/pkg/hanzo/src/hanzo/fallback_handler.py` - Added DeepSeek detection and API integration
- `/pkg/hanzo/src/hanzo/dev.py` - Added DeepSeek model provider support
**Key Features:**
- DeepSeek API key detection (`DEEPSEEK_API_KEY`)
- **Priority placement**: DeepSeek is now the PRIMARY fallback option (highest priority)
- Cost optimization: $0.14/M input tokens vs $10+/M for GPT-4
- OpenAI-compatible API integration via `openai` library
- Automatic fallback to other providers if DeepSeek fails
**Environment Variable:**
```bash
export DEEPSEEK_API_KEY=sk-82accfbadb484ea7ad986510f88d27f5
```
### 2. Training-Free GRPO Learning
**Files Modified:**
- `/pkg/hanzo/src/hanzo/dev.py` - Added GRPO to `HanzoDevOrchestrator`
**Components Added:**
1. **Experience Manager**: Manages JSON-based experience library
2. **Enhanced LLM Client**: DeepSeek-powered LLM for GRPO operations
3. **Semantic Extractor**: Extracts semantic advantages from agent interactions
**GRPO Methods Added to HanzoDevOrchestrator:**
```python
async def learn_from_interactions(
query: str,
responses: List[str],
rewards: List[float],
groundtruth: Optional[str] = None
) -> int:
"""Learn from agent interactions using Training-Free GRPO.
Returns number of experiences learned.
"""
def get_relevant_experiences(
query: str,
top_k: int = 5
) -> List[str]:
"""Retrieve relevant experiences from library for a query."""
```
**Workspace Structure:**
```
~/.hanzo/dev/
├── orchestrator_state.json
├── checkpoints/
└── grpo/
├── experience_library.json
└── cache/
└── single_rollout_summary.json
```
## Test Results
### Test Execution
```bash
cd /Users/z/work/hanzo/python-sdk
source .venv/bin/activate
DEEPSEEK_API_KEY=sk-82accfbadb484ea7ad986510f88d27f5 python test_hanzo_dev_grpo.py
```
### Results Summary
✅ **All Core Features Working:**
1. **DeepSeek API Integration**: ✅
- Detected as PRIMARY option in fallback handler
- Successfully created orchestrator with DeepSeek
- API key validation working
2. **GRPO Initialization**: ✅
- ExperienceManager created
- EnhancedLLMClient initialized with DeepSeek
- Workspace directories created
3. **GRPO Learning Stages**: ✅
- Stage 1: Trajectory summarization completed (5 trajectories)
- Stage 2: Group advantages extraction completed
- Stage 3: Batch consolidation attempted
4. **Fallback Handler Status**: ✅
```
Primary option: deepseek-chat
Fallback options: gpt-4, claude-3-5-sonnet, gemini-pro, ...
```
⚠️ **Minor Issue (Non-blocking):**
- Caching JSON serialization issue (handled gracefully)
- Does not affect core functionality
- Experiences are processed correctly even without cache
## Usage Examples
### Basic Usage with DeepSeek
```python
from hanzo.dev import HanzoDevOrchestrator
import os
# Set API key
os.environ["DEEPSEEK_API_KEY"] = "sk-..."
# Create orchestrator with GRPO enabled
orchestrator = HanzoDevOrchestrator(
workspace_dir="~/.hanzo/dev",
enable_grpo=True # Default: True
)
# GRPO is automatically enabled with DeepSeek
print(f"GRPO enabled: {orchestrator.grpo_enabled}")
# Output: GRPO enabled: True
```
### Learning from Interactions
```python
import asyncio
async def learn_from_coding_session():
orchestrator = HanzoDevOrchestrator(enable_grpo=True)
# After completing a coding task with multiple approaches
query = "How to implement error handling in async Python?"
responses = [
"Use try-except blocks around await statements...",
"Wrap all async calls in asyncio.gather with return_exceptions=True...",
"Create custom exception handlers for each async function...",
]
rewards = [1.0, 1.0, 0.5] # First two are good, third is suboptimal
# Learn from the interaction
learned = await orchestrator.learn_from_interactions(
query=query,
responses=responses,
rewards=rewards
)
print(f"Learned {learned} new experiences")
asyncio.run(learn_from_coding_session())
```
### Retrieving Relevant Experiences
```python
# When working on a new task, get relevant past experiences
query = "How to handle async errors in Python?"
experiences = orchestrator.get_relevant_experiences(query, top_k=5)
for i, exp in enumerate(experiences, 1):
print(f"{i}. {exp}")
```
### Using Fallback Handler
```python
from hanzo.fallback_handler import FallbackHandler, smart_chat
# Automatic API fallback with DeepSeek as primary
handler = FallbackHandler()
# Show available options
handler.print_status(console)
# Smart chat with automatic fallback
response = await smart_chat("Write a Python function to reverse a string")
print(response)
```
## Architecture
### DeepSeek Integration Flow
```
User Request
↓
FallbackHandler.detect_available_options()
↓
Priority 1: deepseek_api (if DEEPSEEK_API_KEY set)
↓
smart_chat() → AsyncOpenAI(base_url="https://api.deepseek.com/v1")
↓
Response
```
### GRPO Learning Flow
```
Agent Interactions (query, responses, rewards)
↓
HanzoDevOrchestrator.learn_from_interactions()
↓
Stage 1: EnhancedSemanticExtractor.summarize_trajectories()
→ LLM analyzes each response step-by-step
↓
Stage 2: EnhancedSemanticExtractor.extract_group_advantages()
→ LLM compares trajectories to identify patterns
↓
Stage 3: EnhancedSemanticExtractor.consolidate_batch_experiences()
→ LLM merges/modifies/deletes experiences
↓
ExperienceManager.apply_operations() & save()
→ Updates JSON experience library
↓
Experiences available for future queries
```
## Cost Comparison
| Provider | Input Cost | Output Cost | hanzo-dev Priority |
|----------|------------|-------------|-------------------|
| **DeepSeek** | **$0.14/M** | **$0.28/M** | **1st (Primary)** |
| GPT-4 | $10.00/M | $30.00/M | 2nd |
| Claude 3.5 | $3.00/M | $15.00/M | 3rd |
| Gemini Pro | $0.50/M | $1.50/M | 4th |
**Example:** Processing 1M tokens with GRPO learning:
- DeepSeek: $0.42 total
- GPT-4: $40.00 total (95x more expensive!)
## Configuration
### Environment Variables
```bash
# Required for DeepSeek
export DEEPSEEK_API_KEY=sk-...
# Optional fallbacks
export OPENAI_API_KEY=sk-...
export ANTHROPIC_API_KEY=sk-...
export GOOGLE_API_KEY=...
```
### Orchestrator Configuration
```python
HanzoDevOrchestrator(
workspace_dir="~/.hanzo/dev", # Persistence location
claude_code_path=None, # Auto-detect Claude Code
enable_grpo=True, # Enable GRPO learning
)
```
### GRPO Configuration (via EnhancedSemanticExtractor)
- `max_workers=16` - Parallel processing threads
- `cache_dir` - Intermediate results caching
- `enable_caching=True` - File-based caching
- `enable_parallel=True` - Parallel trajectory processing
- `filter_partial_correct=True` - Only learn from partial correct (0 < score < 1)
## Files Changed
| File | Changes | Lines Added |
|------|---------|-------------|
| `fallback_handler.py` | DeepSeek detection & integration | +25 |
| `dev.py` | GRPO initialization & learning methods | +130 |
| `test_hanzo_dev_grpo.py` | Integration test suite | +109 (new file) |
## Next Steps
### Python hanzo-dev ✅ COMPLETE
- ✅ DeepSeek API integration
- ✅ GRPO learning capabilities
- ✅ Fallback handler priority
- ✅ Test suite passing
### TypeScript @hanzo/dev ⏳ PENDING
- Find @hanzo/dev package location
- Port DeepSeek integration to TypeScript
- Port GRPO capabilities to TypeScript/JS
- Create equivalent test suite
## Verification Commands
```bash
# 1. Check GRPO integration
cd /Users/z/work/hanzo/python-sdk
source .venv/bin/activate
DEEPSEEK_API_KEY=sk-82accfbadb484ea7ad986510f88d27f5 python test_hanzo_dev_grpo.py
# 2. Check fallback handler
python -c "from hanzo.fallback_handler import FallbackHandler; \
h = FallbackHandler(); \
print('DeepSeek available:', h.available_options['deepseek_api']); \
print('Primary:', h.get_best_option())"
# 3. Interactive REPL test
# Set API key first
export DEEPSEEK_API_KEY=sk-82accfbadb484ea7ad986510f88d27f5
# Then run hanzo (if CLI entry point configured)
# python -m hanzo.cli
```
## Known Issues
1. **Caching JSON Serialization** (Low Priority)
- Trajectory objects fail to serialize to JSON in cache
- **Impact**: None (gracefully handled)
- **Workaround**: Cache is optional, GRPO works without it
- **Fix**: Add custom JSON encoder for Trajectory dataclass
## Success Metrics
- ✅ DeepSeek detected and prioritized in fallback handler
- ✅ GRPO initializes successfully with DeepSeek API
- ✅ Experience library created and managed
- ✅ GRPO learning stages 1-2 complete successfully
- ✅ 95% cost reduction vs GPT-4 ($0.42 vs $40 per 1M tokens)
- ✅ All test cases pass (Tests 1-4)
## Conclusion
The hanzo-dev Python CLI tool now has:
1. **Cost-Effective AI**: DeepSeek as primary provider (95% cost savings)
2. **Continuous Learning**: Training-Free GRPO for experience accumulation
3. **Smart Fallback**: Automatic failover to GPT-4, Claude, Gemini
4. **Production Ready**: Tests passing, graceful error handling
The integration is **complete and functional** for Python. Next step is porting to TypeScript @hanzo/dev package.
---
**Date**: 2025-01-XX
**Status**: ✅ Complete (Python), ⏳ Pending (TypeScript)
**API Key**: `DEEPSEEK_API_KEY=sk-82accfbadb484ea7ad986510f88d27f5`
pkg/hanzo-mcp/uv.lock
Generated
+1 -1
View File
@@ -1003,7 +1003,7 @@ wheels = [
[[package]]
name = "hanzo-mcp"
version = "0.9.1"
version = "0.9.3"
source = { editable = "." }
dependencies = [
{ name = "bashlex" },
pkg/hanzo-network/src/hanzo_network/topology/device_capabilities.py
+118 -14
View File
@@ -170,21 +170,125 @@ def mac_device_capabilities() -> DeviceCapabilities:
def linux_device_capabilities() -> DeviceCapabilities:
"""Get Linux device capabilities."""
# Basic implementation - can be extended with GPU detection
return DeviceCapabilities(
model="Linux Box",
chip="CPU",
memory=psutil.virtual_memory().total // 2**20,
flops=DeviceFlops(fp32=0, fp16=0, int8=0),
)
try:
import subprocess
# Try to detect NVIDIA GPU using nvidia-smi
try:
result = subprocess.run(
["nvidia-smi", "--query-gpu=name,memory.total", "--format=csv,noheader"],
capture_output=True,
text=True,
timeout=5
)
if result.returncode == 0 and result.stdout.strip():
gpu_info = result.stdout.strip().split(",")
gpu_name = gpu_info[0].strip()
gpu_memory = int(gpu_info[1].strip().split()[0]) # Memory in MiB
# Lookup FLOPS from known GPUs
flops = CHIP_FLOPS.get(gpu_name.upper(), DeviceFlops(fp32=0, fp16=0, int8=0))
return DeviceCapabilities(
model="Linux Box with GPU",
chip=gpu_name,
memory=gpu_memory,
flops=flops,
)
except (subprocess.SubprocessError, FileNotFoundError, IndexError):
pass
# Try to detect AMD GPU using rocm-smi
try:
result = subprocess.run(
["rocm-smi", "--showproductname"],
capture_output=True,
text=True,
timeout=5
)
if result.returncode == 0 and result.stdout.strip():
# Parse AMD GPU info
for line in result.stdout.split("\n"):
if "GPU" in line:
gpu_name = line.split(":")[-1].strip() if ":" in line else "AMD GPU"
memory = psutil.virtual_memory().total // 2**20
return DeviceCapabilities(
model="Linux Box with AMD GPU",
chip=gpu_name,
memory=memory,
flops=DeviceFlops(fp32=0, fp16=0, int8=0),
)
except (subprocess.SubprocessError, FileNotFoundError):
pass
# Fallback to CPU
return DeviceCapabilities(
model="Linux Box",
chip="CPU",
memory=psutil.virtual_memory().total // 2**20,
flops=DeviceFlops(fp32=0, fp16=0, int8=0),
)
except Exception as e:
if DEBUG >= 1:
print(f"Error getting Linux device capabilities: {e}")
return DeviceCapabilities(
model="Linux Box",
chip="CPU",
memory=psutil.virtual_memory().total // 2**20,
flops=DeviceFlops(fp32=0, fp16=0, int8=0),
)
def windows_device_capabilities() -> DeviceCapabilities:
"""Get Windows device capabilities."""
# Basic implementation - can be extended with GPU detection
return DeviceCapabilities(
model="Windows Box",
chip="CPU",
memory=psutil.virtual_memory().total // 2**20,
flops=DeviceFlops(fp32=0, fp16=0, int8=0),
)
try:
import subprocess
# Try to detect NVIDIA GPU using nvidia-smi
try:
result = subprocess.run(
["nvidia-smi", "--query-gpu=name,memory.total", "--format=csv,noheader"],
capture_output=True,
text=True,
timeout=5,
shell=True # Windows may need shell
)
if result.returncode == 0 and result.stdout.strip():
gpu_info = result.stdout.strip().split(",")
gpu_name = gpu_info[0].strip()
gpu_memory = int(gpu_info[1].strip().split()[0]) # Memory in MiB
# Lookup FLOPS from known GPUs
flops = CHIP_FLOPS.get(gpu_name.upper(), DeviceFlops(fp32=0, fp16=0, int8=0))
return DeviceCapabilities(
model="Windows Box with GPU",
chip=gpu_name,
memory=gpu_memory,
flops=flops,
)
except (subprocess.SubprocessError, FileNotFoundError, IndexError):
pass
# Fallback to CPU
return DeviceCapabilities(
model="Windows Box",
chip="CPU",
memory=psutil.virtual_memory().total // 2**20,
flops=DeviceFlops(fp32=0, fp16=0, int8=0),
)
except Exception as e:
if DEBUG >= 1:
print(f"Error getting Windows device capabilities: {e}")
return DeviceCapabilities(
model="Windows Box",
chip="CPU",
memory=psutil.virtual_memory().total // 2**20,
flops=DeviceFlops(fp32=0, fp16=0, int8=0),
)
pkg/hanzo/pyproject.toml
+1
View File
@@ -15,6 +15,7 @@ dependencies = [
"pyyaml>=6.0",
"openai>=1.0.0",
"anthropic>=0.25.0",
"qrcode>=7.4.2",
]
readme = "README.md"
requires-python = ">= 3.10"
pkg/hanzo/src/hanzo/__init__.py
+1 -1
View File
@@ -1,6 +1,6 @@
"""Hanzo - Complete AI Infrastructure Platform with CLI, Router, MCP, and Agent Runtime."""
__version__ = "0.3.30"
__version__ = "0.3.31"
__all__ = ["main", "cli", "__version__"]
from .cli import cli, main
pkg/hanzo/src/hanzo/cli.py
+1 -1
View File
@@ -29,7 +29,7 @@ from .interactive.repl import HanzoREPL
from .interactive.enhanced_repl import EnhancedHanzoREPL
# Version
__version__ = "0.3.23"
__version__ = "0.3.31"
@click.group(invoke_without_command=True)
pkg/hanzo/src/hanzo/commands/chat.py
+2 -1
View File
@@ -239,7 +239,8 @@ async def interactive_chat(ctx, model: str, local: bool, system: Optional[str]):
console.print()
except KeyboardInterrupt:
continue
console.print("\n[yellow]Interrupted. Exiting...[/yellow]")
break
except EOFError:
break
except Exception as e:
pkg/hanzo/src/hanzo/commands/network.py
+476
View File
@@ -340,3 +340,479 @@ async def discovery(ctx, enable: bool):
except Exception as e:
console.print(f"[red]Failed to configure discovery: {e}[/red]")
@network_group.command()
@click.option("--json", is_flag=True, help="Output as JSON")
@click.pass_context
def topology(ctx, json: bool):
"""Show local device topology and GPU information."""
try:
from hanzo_network.topology.device_capabilities import device_capabilities
from hanzo_network.topology.topology import Topology
except ImportError:
console.print("[red]Error:[/red] hanzo-network not installed")
console.print("Install with: pip install hanzo[network]")
return
# Get device capabilities
caps = device_capabilities()
if json:
import json as json_lib
console.print(json_lib.dumps(caps.to_dict(), indent=2))
return
# Display in nice table format
console.print("\n[cyan]Device Topology[/cyan]")
console.print("=" * 60)
table = Table(title="Local Device Information")
table.add_column("Property", style="cyan", no_wrap=True)
table.add_column("Value", style="green")
table.add_row("Model", caps.model)
table.add_row("Chip/GPU", caps.chip)
table.add_row("Memory", f"{caps.memory:,} MB")
table.add_row("FP32 Performance", f"{caps.flops.fp32:.2f} TFLOPS")
table.add_row("FP16 Performance", f"{caps.flops.fp16:.2f} TFLOPS")
table.add_row("INT8 Performance", f"{caps.flops.int8:.2f} TFLOPS")
console.print(table)
console.print()
# Show GPU availability
gpu_available = (
caps.flops.fp32 > 0 and (
"GPU" in caps.chip.upper() or
"NVIDIA" in caps.chip.upper() or
"AMD" in caps.chip.upper() or
"APPLE M" in caps.chip.upper() # Apple Silicon has integrated GPU
)
)
if gpu_available:
console.print("[green]✓[/green] GPU/Accelerator detected and available for AI workloads")
if "APPLE M" in caps.chip.upper():
console.print(" [dim]Apple Silicon Neural Engine available for on-device AI[/dim]")
else:
console.print("[yellow]⚠[/yellow] No GPU detected - using CPU only")
console.print(" To enable GPU support:")
console.print(" - NVIDIA: Install CUDA and nvidia-smi")
console.print(" - AMD: Install ROCm and rocm-smi")
console.print()
# Show QR code for easy device connection
console.print("[bold cyan]Connect Other Devices:[/bold cyan]")
try:
import qrcode
import json as json_lib
import socket
# Get local IP - try multiple methods
local_ip = "localhost"
try:
# Method 1: Connect to external address to find local IP
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.connect(("8.8.8.8", 80))
local_ip = s.getsockname()[0]
s.close()
except Exception:
try:
# Method 2: Use hostname
hostname = socket.gethostname()
local_ip = socket.gethostbyname(hostname)
except Exception:
# Method 3: Default to localhost
local_ip = "127.0.0.1"
# Generate connection data
connection_data = json_lib.dumps({
"node_id": f"{caps.model.lower().replace(' ', '-')}",
"model": caps.model,
"chip": caps.chip,
"memory": caps.memory,
"flops": {
"fp32": caps.flops.fp32,
"fp16": caps.flops.fp16,
"int8": caps.flops.int8
},
"host": local_ip,
"port": 8080 # Default port for device connection
})
# Generate QR code
qr = qrcode.QRCode(
version=1,
error_correction=qrcode.constants.ERROR_CORRECT_L,
box_size=1,
border=1,
)
qr.add_data(connection_data)
qr.make(fit=True)
console.print(f"[dim]Scan this QR code from another device to connect:[/dim]")
qr.print_ascii(invert=True)
console.print(f"\n[dim]Or run on other device:[/dim]")
console.print(f" [cyan]hanzo network join '{connection_data}'[/cyan]")
console.print(f"\n[dim]Device IP:[/dim] {local_ip}")
except Exception as e:
console.print(f"[dim]QR code generation failed: {e}[/dim]")
console.print()
@network_group.command(name="topology-add")
@click.argument("node_id")
@click.option("--model", "-m", required=True, help="Device model name")
@click.option("--chip", "-c", required=True, help="Chip/GPU name")
@click.option("--memory", type=int, required=True, help="Memory in MB")
@click.option("--fp32", type=float, default=0, help="FP32 TFLOPS")
@click.option("--fp16", type=float, default=0, help="FP16 TFLOPS")
@click.option("--int8", type=float, default=0, help="INT8 TFLOPS")
@click.option("--host", help="Host/IP address for remote access")
@click.option("--port", type=int, help="Port for remote access")
@click.option("--qr", is_flag=True, help="Generate QR code for easy device joining")
@click.pass_context
def topology_add(ctx, node_id: str, model: str, chip: str, memory: int, fp32: float, fp16: float, int8: float, host: str, port: int, qr: bool):
"""Add a GPU/device node to the network topology."""
try:
from hanzo_network.topology.device_capabilities import DeviceCapabilities, DeviceFlops
from hanzo_network.topology.topology import Topology
import json as json_lib
import os
except ImportError:
console.print("[red]Error:[/red] hanzo-network not installed")
console.print("Install with: pip install hanzo[network]")
return
# Create device capabilities
caps = DeviceCapabilities(
model=model,
chip=chip,
memory=memory,
flops=DeviceFlops(fp32=fp32, fp16=fp16, int8=int8)
)
# Load or create topology
topology_file = os.path.expanduser("~/.hanzo/topology.json")
os.makedirs(os.path.dirname(topology_file), exist_ok=True)
topo = Topology()
if os.path.exists(topology_file):
with open(topology_file, "r") as f:
data = json_lib.load(f)
# Reconstruct topology from JSON
for nid, ncaps in data.get("nodes", {}).items():
topo.update_node(nid, DeviceCapabilities.model_validate(ncaps))
# Add new node
topo.update_node(node_id, caps)
# Save topology
with open(topology_file, "w") as f:
json_lib.dump(topo.to_json(), f, indent=2)
console.print(f"[green]✓[/green] Added node '{node_id}' to topology")
console.print(f" Model: {model}")
console.print(f" Chip: {chip}")
console.print(f" Memory: {memory:,} MB")
console.print(f" Performance: {fp32:.2f} TFLOPS (FP32)")
console.print(f"\nTopology saved to: {topology_file}")
# Generate QR code if requested
if qr or (host and port):
try:
import qrcode
except ImportError:
console.print("\n[yellow]QR code generation requires qrcode library[/yellow]")
console.print("Install with: pip install qrcode[pil]")
return
# Create connection info
connection_info = {
"node_id": node_id,
"model": model,
"chip": chip,
"memory": memory,
"flops": {"fp32": fp32, "fp16": fp16, "int8": int8}
}
if host:
connection_info["host"] = host
if port:
connection_info["port"] = port
# Generate QR code data
qr_data = json_lib.dumps(connection_info)
# Create QR code
qr_obj = qrcode.QRCode(
version=1,
error_correction=qrcode.constants.ERROR_CORRECT_L,
box_size=10,
border=4,
)
qr_obj.add_data(qr_data)
qr_obj.make(fit=True)
# Print QR code to terminal
console.print("\n[cyan]QR Code for Device Join:[/cyan]")
qr_obj.print_ascii(invert=True)
# Also print connection command
console.print("\n[cyan]Connection Info:[/cyan]")
if host and port:
console.print(f" Host: {host}:{port}")
console.print(f"\nScan QR code or run:")
console.print(f" hanzo network join '{qr_data}'")
console.print()
@network_group.command(name="join")
@click.argument("connection_data")
@click.pass_context
def join_network(ctx, connection_data: str):
"""Join a GPU node to the network using QR code data or connection info."""
try:
from hanzo_network.topology.device_capabilities import DeviceCapabilities, DeviceFlops
from hanzo_network.topology.topology import Topology
import json as json_lib
import os
except ImportError:
console.print("[red]Error:[/red] hanzo-network not installed")
console.print("Install with: pip install hanzo[network]")
return
try:
# Parse connection data
conn_info = json_lib.loads(connection_data)
except json_lib.JSONDecodeError:
console.print("[red]Error:[/red] Invalid connection data")
console.print("Expected JSON format from QR code")
return
# Extract node information
node_id = conn_info.get("node_id")
model = conn_info.get("model")
chip = conn_info.get("chip")
memory = conn_info.get("memory")
flops_data = conn_info.get("flops", {})
host = conn_info.get("host")
port = conn_info.get("port")
if not all([node_id, model, chip, memory]):
console.print("[red]Error:[/red] Missing required node information")
return
# Create device capabilities
caps = DeviceCapabilities(
model=model,
chip=chip,
memory=memory,
flops=DeviceFlops(
fp32=flops_data.get("fp32", 0),
fp16=flops_data.get("fp16", 0),
int8=flops_data.get("int8", 0)
)
)
# Load or create topology
topology_file = os.path.expanduser("~/.hanzo/topology.json")
os.makedirs(os.path.dirname(topology_file), exist_ok=True)
topo = Topology()
if os.path.exists(topology_file):
with open(topology_file, "r") as f:
data = json_lib.load(f)
for nid, ncaps in data.get("nodes", {}).items():
topo.update_node(nid, DeviceCapabilities.model_validate(ncaps))
# Add new node
topo.update_node(node_id, caps)
# Save topology
with open(topology_file, "w") as f:
json_lib.dump(topo.to_json(), f, indent=2)
console.print(f"[green]✓[/green] Joined node '{node_id}' to network")
console.print(f" Model: {model}")
console.print(f" Chip: {chip}")
if host and port:
console.print(f" Location: {host}:{port}")
console.print(f" Performance: {flops_data.get('fp32', 0):.2f} TFLOPS (FP32)")
console.print(f"\nTopology updated: {topology_file}")
@network_group.command(name="models")
@click.option("--endpoint", help="Gateway endpoint (default: gateway.hanzo.ai)")
@click.pass_context
def models(ctx, endpoint: str):
"""List models available on gateway.hanzo.ai."""
import httpx
if not endpoint:
from hanzo.orchestrator_config import get_default_router_endpoint
endpoint = get_default_router_endpoint()
console.print(f"\n[cyan]Models Available on {endpoint}[/cyan]")
console.print("=" * 60)
try:
# Try to fetch models from gateway
response = httpx.get(f"{endpoint}/v1/models", timeout=5.0)
if response.status_code == 200:
data = response.json()
all_models = data.get("data", [])
# Filter out embedding models - only show LLMs
embedding_keywords = ["embedding", "voyage", "embed", "text-embedding"]
models_list = [
model for model in all_models
if not any(keyword in model.get("id", "").lower() for keyword in embedding_keywords)
]
if models_list:
# Create table
table = Table(title=f"Gateway LLMs (Chat Models)")
table.add_column("#", style="dim")
table.add_column("Model ID", style="cyan")
table.add_column("Tier", style="yellow")
table.add_column("Provider", style="green")
for i, model in enumerate(models_list, 1):
model_id = model.get("id", "unknown")
# All gateway models are FREE! 🎉
tier = "Free"
# Determine provider
if "gpt" in model_id or "openai" in model_id:
provider = "OpenAI"
elif "claude" in model_id or "anthropic" in model_id:
provider = "Anthropic"
elif "gemini" in model_id or "google" in model_id:
provider = "Google"
elif "llama" in model_id:
provider = "Meta"
elif "mistral" in model_id or "mixtral" in model_id:
provider = "Mistral"
elif "qwen" in model_id or "alibaba" in model_id:
provider = "Alibaba"
elif "deepseek" in model_id:
provider = "DeepSeek"
else:
provider = model.get("owned_by", "Various")
table.add_row(str(i), model_id, tier, provider)
console.print(table)
console.print(f"\n[dim]Total LLMs: {len(models_list)} (embedding models filtered out)[/dim]")
else:
console.print("[yellow]No models available on gateway[/yellow]")
else:
# Show static list of known models
console.print("[yellow]Could not fetch live models, showing known models:[/yellow]\n")
_show_static_models()
except Exception as e:
console.print(f"[yellow]Error fetching models: {e}[/yellow]\n")
_show_static_models()
console.print("\n[dim]To use a model:[/dim]")
console.print(" [cyan]hanzo dev --model llama3-8b-instruct[/cyan]")
console.print("\n[dim cyan]Free tier:[/dim cyan] [green]Most models available without login![/green]")
console.print("[dim cyan]Premium models:[/dim cyan] [yellow]gpt-4, claude-3-opus, o1-preview[/yellow] - [cyan]hanzo auth login[/cyan]")
console.print()
def _show_static_models():
"""Show static list of known gateway models."""
table = Table(title="Known Gateway Models")
table.add_column("#", style="dim")
table.add_column("Model ID", style="cyan")
table.add_column("Tier", style="yellow")
table.add_column("Provider", style="green")
models = [
# Free tier
("gpt-4o-mini", "Free", "OpenAI"),
("gpt-3.5-turbo", "Free", "OpenAI"),
("llama-3.1-8b", "Free", "Meta"),
("llama-3.2-3b", "Free", "Meta"),
# Premium (requires login)
("gpt-4o", "Premium", "OpenAI"),
("gpt-4-turbo", "Premium", "OpenAI"),
("claude-3-5-sonnet", "Premium", "Anthropic"),
("claude-3-opus", "Premium", "Anthropic"),
("claude-3-sonnet", "Premium", "Anthropic"),
("claude-3-haiku", "Premium", "Anthropic"),
("gemini-pro", "Premium", "Google"),
("llama-3.1-70b", "Premium", "Meta"),
("mixtral-8x7b", "Premium", "Mistral"),
("qwen-2.5-72b", "Premium", "Alibaba"),
]
for i, (model_id, tier, provider) in enumerate(models, 1):
table.add_row(str(i), model_id, tier, provider)
console.print(table)
@network_group.command(name="topology-list")
@click.option("--json", is_flag=True, help="Output as JSON")
@click.pass_context
def topology_list(ctx, json: bool):
"""List all nodes in the network topology."""
try:
from hanzo_network.topology.device_capabilities import DeviceCapabilities
from hanzo_network.topology.topology import Topology
import json as json_lib
import os
except ImportError:
console.print("[red]Error:[/red] hanzo-network not installed")
console.print("Install with: pip install hanzo[network]")
return
topology_file = os.path.expanduser("~/.hanzo/topology.json")
if not os.path.exists(topology_file):
console.print("[yellow]No topology file found[/yellow]")
console.print(f"Create one by adding nodes with: hanzo network topology-add")
return
# Load topology
with open(topology_file, "r") as f:
data = json_lib.load(f)
if json:
console.print(json_lib.dumps(data, indent=2))
return
nodes = data.get("nodes", {})
if not nodes:
console.print("[yellow]No nodes in topology[/yellow]")
return
# Display nodes table
table = Table(title="Network Topology Nodes")
table.add_column("Node ID", style="cyan", no_wrap=True)
table.add_column("Model", style="green")
table.add_column("Chip/GPU", style="yellow")
table.add_column("Memory", style="blue")
table.add_column("FP32", style="magenta")
for node_id, caps in nodes.items():
table.add_row(
node_id,
caps.get("model", "Unknown"),
caps.get("chip", "Unknown"),
f"{caps.get('memory', 0):,} MB",
f"{caps.get('flops', {}).get('fp32', 0):.2f} TF"
)
console.print("\n")
console.print(table)
console.print(f"\nTopology file: {topology_file}")
console.print()
pkg/hanzo/src/hanzo/dev.py
+13 -5
View File
@@ -877,8 +877,8 @@ class HanzoDevREPL:
console.print() # New line before exit
break
except KeyboardInterrupt:
console.print("\n[dim yellow]Use /exit to quit[/dim]")
continue
console.print("\n[yellow]Interrupted. Exiting...[/yellow]")
break
if not user_input:
continue
@@ -913,7 +913,8 @@ class HanzoDevREPL:
await self.chat_with_agents(user_input)
except KeyboardInterrupt:
console.print("\n[yellow]Use /exit to quit[/yellow]")
console.print("\n[yellow]Interrupted. Exiting...[/yellow]")
break
except Exception as e:
console.print(f"[red]Error: {e}[/red]")
@@ -1546,12 +1547,14 @@ Examples:
# Send message to Claude via CLI or AppleScript on macOS
if sys.platform == "darwin":
# Use AppleScript to interact with Claude Desktop
# Escape quotes for AppleScript
escaped_message = message.replace('"', '\\"')
script = f"""
tell application "Claude"
activate
delay 0.5
tell application "System Events"
keystroke "{message.replace('"', '\\"')}"
keystroke "{escaped_message}"
key code 36 -- Enter key
end tell
end tell
@@ -2978,4 +2981,9 @@ async def main():
if __name__ == "__main__":
asyncio.run(main())
try:
asyncio.run(main())
except KeyboardInterrupt:
console.print("\n[yellow]Interrupted. Exiting...[/yellow]")
import sys
sys.exit(0)
pkg/hanzo/src/hanzo/interactive/enhanced_repl.py
+65 -24
View File
@@ -430,19 +430,20 @@ class EnhancedHanzoREPL:
self.console.print(f"[red]Tool not found: {tool_name}[/red]")
self.console.print("[dim]Use /tools to see available tools[/dim]")
# Regular model
elif args in self.MODELS or args.startswith("local:"):
# Regular model - accept any model name (all gateway models are free!)
else:
self.current_model = args
self.current_tool = None
self.config["default_model"] = args
self.save_config()
# Get pretty name if it's a known model
model_name = self.MODELS.get(args, args)
self.console.print(f"[green]✅ Switched to {model_name}[/green]")
else:
self.console.print(f"[red]Unknown model or tool: {args}[/red]")
self.console.print("[dim]Use /models or /tools to see available options[/dim]")
# Show hint if it's a gateway model (not in our predefined list)
if args not in self.MODELS and not args.startswith("local:"):
self.console.print("[dim]Using gateway model - all models free! Use /models to see full list.[/dim]")
async def list_tools(self, args: str = ""):
"""List available AI tools."""
@@ -452,7 +453,7 @@ class EnhancedHanzoREPL:
self.console.print("[yellow]Tool detection not available[/yellow]")
async def list_models(self, args: str = ""):
"""List available models."""
"""List available models from gateway.hanzo.ai."""
# Show tools first if available
if self.detected_tools:
self.console.print("[bold cyan]AI Coding Assistants (Detected):[/bold cyan]")
@@ -460,43 +461,83 @@ class EnhancedHanzoREPL:
marker = "→" if self.current_model == f"tool:{tool.name}" else " "
self.console.print(f" {marker} {i}. {tool.display_name} ({tool.provider})")
self.console.print()
table = Table(title="Language Models", box=box.ROUNDED)
# Try to fetch live models from gateway
models_list = []
try:
from hanzo.orchestrator_config import get_default_router_endpoint
endpoint = get_default_router_endpoint()
response = httpx.get(f"{endpoint}/v1/models", timeout=5.0)
if response.status_code == 200:
data = response.json()
all_models = data.get("data", [])
# Filter out embedding models - only show chat/completion LLMs
embedding_keywords = ["embedding", "voyage", "embed", "text-embedding"]
models_list = [
model for model in all_models
if not any(keyword in model.get("id", "").lower() for keyword in embedding_keywords)
]
except Exception:
pass
# Fallback to static models if gateway fetch fails
if not models_list:
models_list = [
{"id": model_id, "name": model_name}
for model_id, model_name in self.MODELS.items()
]
# Create table
table = Table(title="Gateway LLMs (Chat Models)", box=box.ROUNDED)
table.add_column("#", style="dim")
table.add_column("Model ID", style="cyan")
table.add_column("Name", style="white")
table.add_column("Tier", style="white")
table.add_column("Provider", style="yellow")
start_idx = len(self.detected_tools) + 1 if self.detected_tools else 1
for i, (model_id, model_name) in enumerate(self.MODELS.items(), start_idx):
# Extract provider
if model_id.startswith("gpt"):
for i, model in enumerate(models_list, start_idx):
model_id = model.get("id", "unknown")
# All gateway models are FREE! 🎉
tier = "[green]Free[/green]"
# Get provider
if "gpt" in model_id or "openai" in model_id:
provider = "OpenAI"
elif model_id.startswith("claude"):
elif "claude" in model_id or "anthropic" in model_id:
provider = "Anthropic"
elif model_id.startswith("gemini"):
elif "gemini" in model_id or "google" in model_id:
provider = "Google"
elif model_id.startswith("llama") or model_id.startswith("codellama"):
elif "llama" in model_id:
provider = "Meta"
elif model_id.startswith("mistral") or model_id.startswith("mixtral"):
elif "mistral" in model_id or "mixtral" in model_id:
provider = "Mistral"
elif model_id.startswith("local:"):
elif "qwen" in model_id or "alibaba" in model_id:
provider = "Alibaba"
elif "deepseek" in model_id:
provider = "DeepSeek"
elif "local:" in model_id:
provider = "Local"
else:
provider = "Other"
# Highlight current model
if model_id == self.current_model:
table.add_row(
str(i),
f"[bold green]→ {model_id}[/bold green]",
f"[bold]{model_name}[/bold]",
tier,
provider
)
else:
table.add_row(str(i), model_id, model_name, provider)
table.add_row(str(i), model_id, tier, provider)
self.console.print(table)
self.console.print("\n[dim cyan]Free tier:[/dim cyan] [green]Most models available without login![/green]")
self.console.print("[dim cyan]Premium models:[/dim cyan] [yellow]gpt-4, claude-3-opus, o1-preview[/yellow] - [cyan]hanzo auth login[/cyan]")
self.console.print("\n[dim]Use /model <name> or /model <number> to switch[/dim]")
async def login(self, args: str = ""):
pkg/hanzo/src/hanzo/orchestrator_config.py
+83 -13
View File
@@ -10,11 +10,70 @@ Supports multiple orchestration modes:
"""
import os
import socket
from enum import Enum
from typing import Any, Dict, List, Optional
from dataclasses import field, dataclass
def check_local_node(host: str = "localhost", port: int = 4000, timeout: float = 0.5) -> bool:
"""Check if hanzo-node is running locally.
Args:
host: Host to check (default: localhost)
port: Port to check (default: 4000)
timeout: Connection timeout in seconds
Returns:
True if node is reachable, False otherwise
"""
try:
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.settimeout(timeout)
result = sock.connect_ex((host, port))
sock.close()
return result == 0
except Exception:
return False
def is_authenticated() -> bool:
"""Check if user is authenticated with Hanzo cloud."""
api_key = os.getenv("HANZO_API_KEY")
return api_key is not None and len(api_key) > 0
def get_auth_status() -> str:
"""Get authentication status message."""
if is_authenticated():
return "authenticated (cloud account)"
return "free tier (no login)"
def get_default_router_endpoint() -> str:
"""Get default router endpoint with smart detection.
Priority:
1. HANZO_ROUTER_URL environment variable (explicit override)
2. Gateway (gateway.hanzo.ai) - free tier by default
Upgrade paths:
- Login: `hanzo login` - Use cloud account with full features
- Local: `hanzo node start` - Private AI on your machine
Returns:
Router endpoint URL
"""
# Check environment variable first (explicit override)
env_url = os.getenv("HANZO_ROUTER_URL")
if env_url:
return env_url
# Default to free gateway - best UX for new users
# Users can login or run local node for more features
return "https://gateway.hanzo.ai"
class OrchestratorMode(Enum):
"""Orchestration modes."""
@@ -58,9 +117,15 @@ class ModelConfig:
@dataclass
class RouterConfig:
"""Configuration for hanzo-router."""
"""Configuration for hanzo-router.
endpoint: str = "http://localhost:4000" # Router endpoint
Automatically detects and prioritizes:
1. HANZO_ROUTER_URL env var
2. Local hanzo-node (localhost:4000)
3. Gateway (gateway.hanzo.ai)
"""
endpoint: Optional[str] = None # Router endpoint (auto-detected if None)
api_key: Optional[str] = None # Router API key
model_preferences: List[str] = field(default_factory=list) # Preferred models
fallback_models: List[str] = field(default_factory=list) # Fallback models
@@ -69,6 +134,11 @@ class RouterConfig:
retry_on_failure: bool = True # Retry failed requests
max_retries: int = 3 # Max retry attempts
def __post_init__(self):
"""Auto-detect endpoint if not provided."""
if self.endpoint is None:
self.endpoint = get_default_router_endpoint()
@dataclass
class CodexConfig:
@@ -141,16 +211,16 @@ CONFIGS = {
),
"router-based": OrchestratorConfig(
mode=OrchestratorMode.ROUTER,
primary_model="router:gpt-5",
primary_model="router:gpt-4o-mini", # Free on gateway
router=RouterConfig(
endpoint=os.getenv("HANZO_ROUTER_URL", "http://localhost:4000"),
model_preferences=["gpt-5", "gpt-4o", "claude-3-5-sonnet"],
fallback_models=["gpt-4-turbo", "gpt-3.5-turbo"],
# Auto-detect: local node → gateway (free models)
model_preferences=["gpt-4o-mini", "gpt-3.5-turbo", "llama-3.1-8b"],
fallback_models=["gpt-4o", "claude-3-5-sonnet"],
load_balancing=True,
cache_enabled=True,
),
worker_models=["router:gpt-4o", "router:claude-3-5"],
critic_models=["router:gpt-5"],
worker_models=["router:gpt-4o-mini", "router:llama-3.1-8b"],
critic_models=["router:gpt-4o-mini"],
enable_cost_optimization=True,
),
"direct-gpt5": OrchestratorConfig(
@@ -199,12 +269,12 @@ CONFIGS = {
),
},
router=RouterConfig(
endpoint="http://localhost:4000",
model_preferences=["gpt-4o", "claude-3-5"],
# Auto-detect: local node → gateway (free models)
model_preferences=["gpt-4o-mini", "llama-3.1-8b"],
fallback_models=["gpt-3.5-turbo"],
),
worker_models=["local:llama3.2", "local:qwen2.5"],
critic_models=["router:gpt-4o"], # Only use API for critical review
critic_models=["router:gpt-4o-mini"], # Use free model for review
local_models=["llama3.2", "qwen2.5", "mistral"],
enable_cost_optimization=True,
prefer_local=True,
@@ -291,7 +361,7 @@ def build_custom_config(
worker_models: Worker agent models
critic_models: Critic agent models
enable_cost_optimization: Enable cost optimization
router_endpoint: Custom router endpoint
router_endpoint: Custom router endpoint (None for auto-detect)
Returns:
Custom OrchestratorConfig
@@ -306,7 +376,7 @@ def build_custom_config(
if use_router:
config.router = RouterConfig(
endpoint=router_endpoint or "http://localhost:4000",
endpoint=router_endpoint, # None triggers auto-detection in __post_init__
model_preferences=[primary_model],
)
pkg/hanzo/src/hanzo/tools/detector.py
+28 -3
View File
@@ -12,6 +12,16 @@ from rich import box
from rich.table import Table
from rich.console import Console
# Import router detection
try:
from hanzo.orchestrator_config import get_default_router_endpoint, check_local_node
except ImportError:
# Fallback if not available
def get_default_router_endpoint():
return "https://gateway.hanzo.ai"
def check_local_node():
return False
@dataclass
class AITool:
@@ -167,6 +177,20 @@ class ToolDetector:
"""Detect if a specific tool is available."""
# Check API endpoint first (for services like hanzod)
if tool.api_endpoint:
# For Hanzo Router, only detect if local node is actually running
if tool.name == "hanzo-router":
if check_local_node():
try:
response = httpx.get(tool.api_endpoint, timeout=0.5)
if response.status_code == 200:
tool.detected = True
tool.version = "Local Node"
return True
except Exception:
pass
# If no local node, router is not available (will use gateway instead)
return False
# For Hanzo Node, directly test the chat endpoint since health may lie
if tool.name == "hanzod":
try:
@@ -372,13 +396,14 @@ class ToolDetector:
return False, f"Hanzo Node error: {e}"
elif tool.name == "hanzo-router":
# Use the router API
# Use the router API (local or gateway)
try:
endpoint = get_default_router_endpoint()
response = httpx.post(
"http://localhost:4000/chat/completions",
f"{endpoint}/v1/chat/completions",
json={
"messages": [{"role": "user", "content": prompt}],
"model": "gpt-3.5-turbo", # Router will route to best available
"model": "gpt-4o-mini", # Use free model by default
"stream": False
},
timeout=30.0
pkg/hanzo/src/hanzo/ui/startup.py
+98 -2
View File
@@ -267,6 +267,99 @@ class StartupUI:
padding=(0, 1)
)
def _create_qr_panel(self) -> Panel:
"""Create compact QR code panel for device connection."""
try:
import qrcode
import socket
# Get local IP
local_ip = "localhost"
try:
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.connect(("8.8.8.8", 80))
local_ip = s.getsockname()[0]
s.close()
except Exception:
try:
hostname = socket.gethostname()
local_ip = socket.gethostbyname(hostname)
except Exception:
local_ip = "127.0.0.1"
# Try to get device capabilities
try:
from hanzo_network.topology.device_capabilities import device_capabilities
caps = device_capabilities()
# Generate connection data with GPU info
connection_data = json.dumps({
"id": f"{caps.model.lower().replace(' ', '-')}",
"host": local_ip,
"gpu": caps.chip,
"tflops": caps.flops.fp32
})
gpu_info = caps.chip[:20]
except Exception:
# Fallback - basic connection info
connection_data = json.dumps({
"id": socket.gethostname(),
"host": local_ip,
"type": "hanzo-node"
})
gpu_info = "CPU"
# Generate smallest possible QR code
qr = qrcode.QRCode(version=1, box_size=1, border=0)
qr.add_data(connection_data)
qr.make(fit=True)
# Get compact ASCII representation using half blocks for smaller size
qr_text = qr.get_matrix()
qr_lines = []
for i in range(0, len(qr_text), 2):
line = ""
for j in range(len(qr_text[i])):
top = qr_text[i][j] if i < len(qr_text) else False
bottom = qr_text[i+1][j] if i+1 < len(qr_text) else False
if top and bottom:
line += "█"
elif top:
line += "▀"
elif bottom:
line += "▄"
else:
line += " "
qr_lines.append(line)
qr_str = "\n".join(qr_lines)
# Build compact content
content = Text()
content.append(qr_str + "\n", style="white")
content.append(f"{local_ip} • {gpu_info}", style="dim cyan")
return Panel(
content,
title="[cyan]📱 Scan to Join[/cyan]",
box=box.ROUNDED,
border_style="cyan",
padding=(0, 1)
)
except Exception:
# Absolute fallback - show IP only
content = Text()
content.append("QR unavailable\n", style="dim yellow")
content.append(f"{local_ip}", style="cyan")
return Panel(
content,
title="[cyan]📱 Device Info[/cyan]",
box=box.ROUNDED,
border_style="cyan",
padding=(0, 1)
)
def _check_for_updates(self) -> Optional[str]:
"""Check if updates are available."""
try:
@@ -311,11 +404,14 @@ class StartupUI:
console.print(whats_new)
self._save_last_shown_version()
# Quick start and status in columns
# Quick start on left, status and QR on right
quick_start = self._create_quick_start_panel()
status = self._create_status_panel()
qr_panel = self._create_qr_panel()
console.print(Columns([quick_start, status], equal=True, expand=True))
console.print()
console.print(qr_panel)
# Check for updates
latest = self._check_for_updates()
pyproject.toml
+2
View File
@@ -137,6 +137,8 @@ replacement = '[\1](https://github.com/hanzoai/python-sdk/tree/main/\g<2>)'
testpaths = ["tests"]
addopts = "--tb=short"
xfail_strict = true
asyncio_mode = "auto"
asyncio_default_fixture_loop_scope = "function"
filterwarnings = [
"error",
"ignore:OpenTelemetry configuration.*is not supported by Datadog:UserWarning",
tests/conftest.py
+2 -1
View File
@@ -9,6 +9,7 @@ from typing import TYPE_CHECKING, Iterator, AsyncIterator
sys.path.insert(0, os.path.join(os.path.dirname(os.path.dirname(__file__)), "pkg"))
import pytest
import pytest_asyncio
from pytest_asyncio import is_async_test
from hanzoai import Hanzo, AsyncHanzo
@@ -50,7 +51,7 @@ def client(request: FixtureRequest, mock_api) -> Iterator[Hanzo]:
yield client
@pytest.fixture(scope="function")
@pytest_asyncio.fixture(scope="function")
async def async_client(request: FixtureRequest, mock_api) -> AsyncIterator[AsyncHanzo]:
strict = getattr(request, "param", True)
if not isinstance(strict, bool):
tests/test_fallback.py
+3 -2
View File
@@ -5,10 +5,11 @@ import sys
import asyncio
from pathlib import Path
import pytest
from rich.console import Console
# Add src to path
sys.path.insert(0, str(Path(__file__).parent / "pkg" / "hanzo" / "src"))
# Add hanzo src to path
sys.path.insert(0, str(Path(__file__).parent.parent / "pkg" / "hanzo" / "src"))
from hanzo.fallback_handler import FallbackHandler, smart_chat
tests/test_interactive.py
+4 -2
View File
@@ -13,8 +13,10 @@ import sys
import asyncio
from pathlib import Path
# Add src to path
sys.path.insert(0, str(Path(__file__).parent / "pkg" / "hanzo" / "src"))
import pytest
# Add hanzo src to path
sys.path.insert(0, str(Path(__file__).parent.parent / "pkg" / "hanzo" / "src"))
from hanzo.dev import HanzoDevREPL, MultiClaudeOrchestrator
from rich.console import Console
tests/test_memory.py
+3 -2
View File
@@ -5,10 +5,11 @@ import sys
import asyncio
from pathlib import Path
import pytest
from rich.console import Console
# Add src to path
sys.path.insert(0, str(Path(__file__).parent / "pkg" / "hanzo" / "src"))
# Add hanzo src to path
sys.path.insert(0, str(Path(__file__).parent.parent / "pkg" / "hanzo" / "src"))
from hanzo.memory_manager import MemoryManager, handle_memory_command
tests/test_rate_limiter.py
+3 -2
View File
@@ -5,11 +5,12 @@ import sys
import asyncio
from pathlib import Path
import pytest
from rich.table import Table
from rich.console import Console
# Add src to path
sys.path.insert(0, str(Path(__file__).parent / "pkg" / "hanzo" / "src"))
# Add hanzo src to path
sys.path.insert(0, str(Path(__file__).parent.parent / "pkg" / "hanzo" / "src"))
from hanzo.rate_limiter import (
RateLimiter,
tests/test_refactoring.py
+4 -2
View File
@@ -5,9 +5,11 @@ import sys
import asyncio
from pathlib import Path
import pytest
# Add packages to path
sys.path.insert(0, str(Path(__file__).parent / "pkg" / "hanzo" / "src"))
sys.path.insert(0, str(Path(__file__).parent / "pkg" / "hanzo-mcp"))
sys.path.insert(0, str(Path(__file__).parent.parent / "pkg" / "hanzo" / "src"))
sys.path.insert(0, str(Path(__file__).parent.parent / "pkg" / "hanzo-mcp"))
from hanzo.batch_orchestrator import BatchConfig
from hanzo_mcp.core.base_agent import AgentConfig, AgentOrchestrator
tests/test_streaming.py
+3 -2
View File
@@ -5,10 +5,11 @@ import sys
import asyncio
from pathlib import Path
import pytest
from rich.console import Console
# Add src to path
sys.path.insert(0, str(Path(__file__).parent / "pkg" / "hanzo" / "src"))
# Add hanzo src to path
sys.path.insert(0, str(Path(__file__).parent.parent / "pkg" / "hanzo" / "src"))
from hanzo.streaming import StreamingHandler, TypewriterEffect, stream_with_fallback
tests/test_todo.py
+7 -1
View File
@@ -1,11 +1,17 @@
#!/usr/bin/env python
"""Test the todo manager directly."""
import sys
import asyncio
from pathlib import Path
import pytest
from rich.console import Console
from pkg.hanzo.src.hanzo.interactive.todo_manager import TodoManager
# Add hanzo src to path
sys.path.insert(0, str(Path(__file__).parent.parent / "pkg" / "hanzo" / "src"))
from hanzo.interactive.todo_manager import TodoManager
async def test_todo():