Monkey Coder SDK

The official TypeScript/JavaScript and Python SDK for Monkey Coder - an AI-powered code generation and analysis platform.

Features

🚀 Multiple Runtime Support: Works with Node.js, Bun, Deno, and Python
🔐 Authentication: Built-in API key management and token handling
🔄 Automatic Retries: Exponential backoff with configurable retry logic
📡 Streaming Support: Real-time execution progress with Server-Sent Events
🎯 Type Safety: Full TypeScript definitions and Python type hints
⚡ Performance: Optimized for speed and efficiency
🛠️ Developer Experience: Rich error handling and debugging tools

Quick Start

$3

``bash


Install via npm

npm install @monkey-coder/sdk

Install via yarn

yarn add @monkey-coder/sdk

Install via pnpm

pnpm add @monkey-coder/sdk
`

`typescript
import { MonkeyCoderClient, createCodeGenerationRequest } from '@monkey-coder/sdk';

const client = new MonkeyCoderClient({
baseURL: 'https://api.monkeycoder.dev',
apiKey: 'your-api-key',
retries: 3
});

// Generate code
const request = createCodeGenerationRequest(
'Create a REST API server with authentication',
'user-123'
);

const response = await client.execute(request);
console.log(response.result?.result);
`

$3

`bash


Install via pip


pip install monkey-coder-sdk
`

`python
from monkey_coder_sdk import MonkeyCoderClient, create_code_generation_request

client = MonkeyCoderClient({
'base_url': 'https://api.monkeycoder.dev',
'api_key': 'your-api-key',
'retries': 3
})

Generate code

request = create_code_generation_request(
prompt='Create a REST API server with authentication',
user_id='user-123'
)

response = client.execute(request)
print(response.result.result)
`

Documentation

$3

#### MonkeyCoderClient

The main client class for interacting with the Monkey Coder API.

`typescript
interface MonkeyCoderClientConfig {
baseURL?: string; // API base URL
apiKey?: string; // API key for authentication
timeout?: number; // Request timeout in ms (default: 300000)
retries?: number; // Number of retries (default: 3)
retryDelay?: number; // Initial retry delay in ms (default: 1000)
maxRetryDelay?: number; // Maximum retry delay in ms (default: 10000)
retryCondition?: (error: AxiosError) => boolean;
onRetry?: (retryCount: number, error: AxiosError) => void;
}
`

#### Core Methods

`typescript
// Health check
await client.health(): Promise

// Execute task
await client.execute(request: ExecuteRequest): Promise

// Execute with streaming
await client.executeStream(
request: ExecuteRequest,
onEvent: (event: StreamEvent) => void
): Promise

// Get usage metrics
await client.getUsage(params?: UsageRequest): Promise

// List providers and models
await client.listProviders(): Promise>
await client.listModels(provider?: ProviderType): Promise>

// Debug routing decisions
await client.debugRouting(request: ExecuteRequest): Promise>
`

#### Helper Functions

`typescript
// Create basic execute request
createExecuteRequest(
taskType: TaskType,
prompt: string,
context: ExecutionContext,
persona?: PersonaType,
options?: Partial
): ExecuteRequest

// Create code generation request
createCodeGenerationRequest(
prompt: string,
userId: string,
options?: Partial
): ExecuteRequest

// Create code review request
createCodeReviewRequest(
prompt: string,
userId: string,
files: Array<{ path: string; content: string; type?: string }>,
options?: Partial
): ExecuteRequest
`

$3

#### MonkeyCoderClient

`python
@dataclass
class MonkeyCoderClientConfig:
base_url: str = "http://localhost:8000"
api_key: Optional[str] = None
timeout: float = 300.0
retries: int = 3
retry_delay: float = 1.0
max_retry_delay: float = 10.0
retry_condition: Optional[Callable[[Exception], bool]] = None
on_retry: Optional[Callable[[int, Exception], None]] = None
`

#### Core Methods

`python


Health check

client.health() -> HealthResponse

Execute task

client.execute(request: ExecuteRequest) -> ExecuteResponse

Execute with streaming

client.execute_stream(
request: ExecuteRequest,
on_event: Callable[[StreamEvent], None]
) -> None

Get usage metrics

client.get_usage(usage_request: UsageRequest) -> Dict

List providers and models

client.list_providers() -> Dict
client.list_models(provider: Optional[ProviderType] = None) -> Dict

Debug routing decisions

client.debug_routing(request: ExecuteRequest) -> Dict
`

#### Helper Functions

`python


Create basic execute request

create_execute_request(
task_type: TaskType,
prompt: str,
context: ExecutionContext,
persona: PersonaType = PersonaType.DEVELOPER,
**kwargs
) -> ExecuteRequest

Create code generation request

create_code_generation_request(
prompt: str,
user_id: str,
language: Optional[str] = None,
temperature: float = 0.1,
max_tokens: int = 4096,
**kwargs
) -> ExecuteRequest

Specialized request creators

create_code_review_request(...)
create_documentation_request(...)
create_security_analysis_request(...)
create_testing_request(...)
create_performance_optimization_request(...)
`

Examples

$3

`typescript
await client.executeStream(request, (event) => {
switch (event.type) {
case 'start':
console.log('🚀 Starting execution...');
break;
case 'progress':
console.log(📊 ${event.progress?.percentage}% - ${event.progress?.step});
break;
case 'complete':
console.log('✅ Execution completed');
console.log(event.data?.result?.result);
break;
case 'error':
console.error('❌ Error:', event.error?.message);
break;
}
});
`

$3

`typescript
try {
const response = await client.execute(request);
} catch (error) {
if (error instanceof MonkeyCoderError) {
console.error('API Error:', error.message);
console.error('Status Code:', error.statusCode);
console.error('Error Code:', error.code);
}
}
`

$3

`typescript
// Update API key dynamically
client.setApiKey('new-api-key');

// Update base URL
client.setBaseURL('https://api-staging.monkeycoder.dev');

// Custom retry logic
const client = new MonkeyCoderClient({
retryCondition: (error) => error.response?.status >= 500,
onRetry: (retryCount, error) => {
console.log(Retry ${retryCount}: ${error.message});
}
});
`

Task Types

- code_generation - Generate new code from prompts
- code_analysis - Analyze existing code for issues
- code_review - Review code for quality and best practices
- documentation - Generate documentation from code
- testing - Create unit tests for code
- debugging - Debug and fix code issues
- refactoring - Refactor and optimize code
- custom - Custom tasks with specific requirements

Personas

- developer - General development tasks
- architect - System design and architecture
- reviewer - Code review and quality assessment
- security_analyst - Security analysis and vulnerability scanning
- performance_expert - Performance optimization
- tester - Test generation and quality assurance
- technical_writer - Documentation and technical writing
- custom - Custom persona with specific instructions

Runtime Examples

$3


`bash
cd examples/node
npm install
node index.js
`

$3

`bash
cd examples/bun
bun install
bun run index.ts
`

$3

`bash
cd examples/deno
deno run --allow-net index.ts
`

$3

`bash
cd examples/python
pip install -r requirements.txt
python main.py
`

Advanced Configuration

$3

`typescript
const monkey1Config: Monkey1Config = {
agent_count: 5,
coordination_strategy: 'collaborative',
consensus_threshold: 0.8,
enable_reflection: true,
max_iterations: 10
};
`

$3

`typescript
const gary8dConfig: Gary8DConfig = {
parallel_futures: true,
collapse_strategy: 'weighted_average',
quantum_coherence: 0.9,
execution_branches: 5,
uncertainty_threshold: 0.05
};
`

Error Codes

- NO_RESPONSE - No response from server
- REQUEST_ERROR - Request configuration error
- STREAM_INCOMPLETE - Streaming ended without completion
- EXECUTION_ERROR - Task execution failed
- PROVIDER_ERROR - AI provider error
- VALIDATION_ERROR` - Request validation failed

Contributing

We welcome contributions! Please see our Contributing Guide for details.

License

This project is licensed under the MIT License - see the LICENSE file for details.

Support

- 📧 Email: support@monkeycoder.dev
- 💬 Discord: Join our community
- 📖 Documentation: https://docs.monkeycoder.dev
- 🐛 Issues: GitHub Issues