admin/Agentic-Compaction-and-Pipleline-by-GLM-5
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add Delegation System with 3rd Party AI Tool Integration

Browse Source 
NEW: Delegation System (v1.2.0)
- Request Classifier for fast request analysis (<50ms)
- Agent Pool Manager with auto-scaling (8 agent types)
- Delegation Engine with 4 strategies (full, parallel, hierarchical, hybrid)
- Progress Streamer for real-time updates
- Context Handoff Protocol for inter-agent communication
- Quality Gate with confidence thresholds and auto-escalation

NEW: 3rd Party Integration Adapters
- OpenClaw adapter with parallel execution support
- Claude Code CLI adapter with tool registration
- Generic adapter for custom integrations
- Standardized IntegrationAdapter interface

Agent Types Added:
- fast-responder (quick answers < 2s)
- explorer (code navigation)
- researcher (deep analysis)
- coder (implementation)
- reviewer (quality checks)
- planner (architecture)
- executor (commands)
- analyzer (debugging)

Tests: All 6 tests passing

This project was 100% autonomously built by Z.AI GLM-5
This commit is contained in:
admin
2026-03-04 10:06:17 +00:00
Unverified
parent e6981ee8f8
commit 8329636696
41 changed files with 4582 additions and 494 deletions
Download Patch File Download Diff File Expand all files Collapse all files

839
README.md Normal file → Executable file
View File

@@ -16,6 +16,7 @@
<a href="#installation">Installation</a> •
<a href="#quick-start">Quick Start</a> •
<a href="#integrations">Integrations</a> •
<a href="#delegation-system">Delegation System</a> •
<a href="#api-reference">API Reference</a>
</p>
@@ -41,16 +42,17 @@ and even pushing everything to this Git repository.
## Overview
This project provides two complementary systems:
This project provides three complementary systems:
1. **Agent System** - Context compaction, token management, and agent orchestration
2. **Pipeline System** - Deterministic state machine, parallel execution, and event-driven coordination
3. **Delegation System** - Intelligent request routing, agent pool management, and busy-state handling
Built based on the architectural principles described in [How I Built a Deterministic Multi-Agent Dev Pipeline Inside OpenClaw](https://dev.to/ggondim/how-i-built-a-deterministic-multi-agent-dev-pipeline-inside-openclaw-and-contributed-a-missing-4ool).
---
## Features
## ✨ Features
### Agent System
@@ -70,67 +72,92 @@ Built based on the architectural principles described in [How I Built a Determin
- ✅ **Event-Driven Coordination** - Pub/sub event bus with automatic trigger chains
- ✅ **Workspace Isolation** - Per-agent tools, memory, identity, permissions
- ✅ **YAML Workflow Parser** - Lobster-compatible workflow definitions
- ✅ **Claude Code Integration** - Ready-to-use integration layer
### 🆕 Delegation System (NEW!)
- ✅ **Request Classification** - Fast analysis (<50ms) for optimal routing
- ✅ **Agent Pool Management** - Auto-scaling pool with 8 agent types
- ✅ **Delegation Engine** - 4 strategies: full, parallel, hierarchical, hybrid
- ✅ **Progress Streaming** - Real-time updates with SSE/WebSocket support
- ✅ **Context Handoff Protocol** - Seamless inter-agent context transfer
- ✅ **Quality Gate** - Confidence thresholds and auto-escalation
- ✅ **3rd Party Adapters** - Native support for OpenClaw, Claude Code CLI, Cursor, Aider
---
## Architecture
```
┌─────────────────────────────────────────────────────────────────┐
│ AGENTIC PIPELINE SYSTEM │
├─────────────────────────────────────────────────────────────────┤
│ │
│ ┌───────────────────────┐ ┌───────────────────────┐ │
│ │ AGENT SYSTEM │ │ PIPELINE SYSTEM │ │
│ ├───────────────────────┤ ├───────────────────────┤ │
│ │ • Token Counter │ │ • State Machine │ │
│ │ • Context Manager │ │ • Parallel Executor │ │
│ │ • Summarizer │ │ • Event Bus │ │
│ │ • Orchestrator │ │ • Workspace Manager │ │
│ │ • Subagent Spawner │ │ • YAML Workflows │ │
│ │ • Memory Store │ │ • Claude Integration │ │
│ │ ───────────────────── │ └───────────────────────┘ │
│ │ INTEGRATIONS: │ │
│ │ • Claude Code ✅ │ │
│ │ • OpenClaw ✅ │ │
│ └───────────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ INTEGRATION LAYER │ │
│ │ Claude Code │ OpenClaw │ Lobster │ Custom Applications │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────────────┐
│ AGENTIC PIPELINE SYSTEM │
├─────────────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐ │
│ │ AGENT SYSTEM │ │ PIPELINE SYSTEM │ │DELEGATION SYSTEM│ │
│ ├─────────────────┤ ├─────────────────┤ ├─────────────────┤ │
│ │ • Token Counter │ │ • State Machine │ │ • Classifier │ │
│ │ • Context Mgr │ │ • Parallel Exec │ │ • Pool Manager │ │
│ │ • Summarizer │ │ • Event Bus │ │ • Deleg. Engine │ │
│ │ • Orchestrator │ │ • Workspace │ │ • Progress Str. │ │
│ │ • Subagent Sp. │ │ • YAML Workflow │ │ • Quality Gate │ │
│ │ • Memory Store │ │ • Integration │ │ • Handoff Proto │ │
│ │ ─────────────── │ └─────────────────┘ └─────────────────┘ │
│ │ INTEGRATIONS: │ │
│ │ • Claude Code ✅ │ │
│ │ • OpenClaw ✅ │ │
│ └─────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ INTEGRATION LAYER │ │
│ │ Claude Code │ OpenClaw │ Cursor │ Aider │ Copilot │ Custom │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────┘
```
### Data Flow
### Delegation Flow (Busy-State Handling)
```
User Request → Pipeline Orchestrator → State Machine
│
▼
Parallel Executor (Worker Pool)
│
┌─────────────────┼─────────────────┐
▼ ▼ ▼
Agent 1 Agent 2 Agent N
│ │ │
▼ ▼ ▼
Workspace Workspace Workspace
│ │ │
└─────────────────┼─────────────────┘
▼
Event Bus
│
▼
Context Manager
│
▼
Summarizer (if needed)
│
▼
Response/Next State
User Request → Request Classifier (<50ms)
│
▼
┌───────────────┐
│ Classification │
│ • Complexity │
│ • Agent Type │
│ • Priority │
└───────────────┘
│
▼
┌───────────────┐
│ Pool Manager │
│ • Find Agent │
│ • Scale Pool │
└───────────────┘
│
┌───────────┴───────────┐
▼ ▼
┌───────────────┐ ┌───────────────┐
│ Delegate │ │ Queue/Wait │
│ to Agent │ │ (if busy) │
└───────────────┘ └───────────────┘
│ │
▼ ▼
┌───────────────┐ ┌───────────────┐
│ Progress │ │ Escalate │
│ Streaming │ │ to Main │
└───────────────┘ └───────────────┘
│ │
└───────────┬───────────┘
▼
┌───────────────┐
│ Quality Gate │
│ • Validate │
│ • Confidence │
└───────────────┘
│
▼
Response
```
---
@@ -152,8 +179,8 @@ cd Agentic-Compaction-and-Pipleline-by-GLM-5
# Install dependencies
bun install
# Build (if needed)
bun run build
# Run tests
bun run delegation-system/test.ts
```
### Using Zip Packages
@@ -164,19 +191,47 @@ Download the appropriate package from the `downloads/` directory:
|---------|-------------|----------|
| `agent-system.zip` | Context compaction & orchestration | Building custom AI agents |
| `pipeline-system.zip` | Deterministic pipelines | Multi-agent workflows |
| `delegation-system.zip` | Busy-state handling | High-traffic AI services |
| `complete-agent-pipeline-system.zip` | Full system | Complete integration |
---
## Quick Start
### Delegation System (Busy-State Handling)
```typescript
import { DelegationSystem } from './delegation-system';
// Initialize the system
const system = new DelegationSystem();
await system.initialize();
// Process a request (auto-delegates when busy)
const response = await system.process({
id: 'req-1',
content: 'Review this code for security issues',
type: 'review',
streamProgress: true
});
console.log(response.result);
console.log(`Processed by: ${response.agentsUsed.join(', ')}`);
console.log(`Confidence: ${response.confidence}`);
// Subscribe to progress updates
system.onProgress('req-1', (event) => {
console.log(`[${event.type}] ${event.message}`);
});
```
### Agent System
```typescript
import { ContextManager, TokenCounter, Summarizer } from './agent-system';
// Initialize components
const tokenCounter = new TokenCounter(128000); // 128k token budget
const tokenCounter = new TokenCounter(128000);
const summarizer = new Summarizer();
const contextManager = new ContextManager(tokenCounter, summarizer, {
maxTokens: 100000,
@@ -184,413 +239,281 @@ const contextManager = new ContextManager(tokenCounter, summarizer, {
reserveTokens: 20000
});
// Add messages
// Add messages with auto-compaction
contextManager.addMessage({ role: 'user', content: 'Hello!' });
contextManager.addMessage({ role: 'assistant', content: 'Hi there!' });
// Check if compaction needed
if (contextManager.needsCompaction()) {
const result = await contextManager.compact();
console.log(`Compacted: ${result.messagesRemoved} messages removed`);
console.log(`Saved ${result.tokensSaved} tokens`);
}
```
### Pipeline System
```typescript
import { DeterministicStateMachine, ParallelExecutionEngine, EventBus } from './pipeline-system';
import { DeterministicStateMachine, ParallelExecutionEngine } from './pipeline-system';
// Define workflow
const workflow = `
name: code-pipeline
states:
- name: analyze
transitions:
- to: implement
event: analyzed
- name: implement
transitions:
- to: test
event: implemented
- name: test
transitions:
- to: complete
event: passed
`;
// Create pipeline
const eventBus = new EventBus();
const stateMachine = new DeterministicStateMachine(workflow);
const executor = new ParallelExecutionEngine({ maxConcurrency: 4 });
// Run pipeline
await stateMachine.start();
const executor = new ParallelExecutionEngine({ maxConcurrency: 12 });
const results = await executor.executeAll([
{ id: 1, type: 'analyze', data: { target: 'module-a' } },
{ id: 2, type: 'analyze', data: { target: 'module-b' } }
]);
```
---
## Integrations
### Claude Code Integration
### 3rd Party AI Coding Tools Integration
Full integration with Claude Code CLI and IDE extensions:
The delegation system provides **native integration** for popular AI coding tools:
#### OpenClaw Integration
```typescript
import { ClaudeCodeIntegration } from './agent-system/integrations/claude-code';
import { DelegationSystem } from './delegation-system';
// Initialize with Claude Code defaults
const claude = new ClaudeCodeIntegration({
maxContextTokens: 200000, // Claude's context window
reserveTokens: 40000, // Reserve for response
compactionStrategy: 'hybrid',
autoCompact: true,
compactionThreshold: 0.8,
enableSubagents: true,
maxSubagents: 6,
persistentMemory: true
const system = new DelegationSystem();
await system.initialize();
// Get OpenClaw adapter
const openclaw = system.getAdapter('openclaw');
// Configure for OpenClaw pattern (4 projects × 3 roles)
await openclaw.initialize({
pool: { maxParallelAgents: 12 },
delegation: { autoDelegate: true }
});
// Add messages with automatic compaction
claude.addMessage({ role: 'user', content: 'Analyze this codebase...' });
// Get context for Claude API
const { messages, systemPrompt } = claude.getContextForAPI();
// Spawn subagents for complex tasks
const result = await claude.spawnSubagent({
type: 'researcher',
prompt: 'Research authentication patterns',
priority: 'high'
// Process with OpenClaw-compatible workflow
const response = await system.process({
content: 'Analyze security across all modules',
metadata: { integration: 'openclaw' }
});
// Parallel subagent execution (4 projects × 3 roles pattern)
const results = await claude.executeParallelSubagents([
{ type: 'explorer', prompt: 'Find security issues in frontend' },
{ type: 'explorer', prompt: 'Find security issues in backend' },
{ type: 'reviewer', prompt: 'Review API endpoints' }
]);
// Memory management
await claude.remember('userPreference', { theme: 'dark' });
const pref = await claude.recall('userPreference');
// Save/restore context
await claude.saveContext('milestone-1');
await claude.loadContext('milestone-1');
// Monitor session
const stats = claude.getTokenStats();
console.log(`Using ${stats.percentage}% of context (${stats.used}/${stats.total} tokens)`);
```
### OpenClaw Integration
Native integration with OpenClaw's deterministic multi-agent architecture:
#### Claude Code CLI Integration
```typescript
import { OpenClawIntegration } from './agent-system/integrations/openclaw';
import { DelegationSystem } from './delegation-system';
// Initialize with OpenClaw-compatible config
const openclaw = new OpenClawIntegration({
maxContextTokens: 200000,
compactionStrategy: 'hybrid',
workspaceIsolation: true,
enableLobsterWorkflows: true,
enableParallelExecution: true,
maxParallelAgents: 12, // 4 projects × 3 roles
hooks: {
onCompactionStart: (ctx) => console.log('Compacting...'),
onCompactionEnd: (result) => console.log(`Saved ${result.tokensSaved} tokens`),
onStateTransition: (from, to, ctx) => console.log(`${from} → ${to}`)
}
});
const system = new DelegationSystem();
await system.initialize();
// Add messages with OpenClaw context
openclaw.addMessage({
role: 'user',
const claudeCode = system.getAdapter('claude-code');
// Get Claude Code compatible tools
const tools = claudeCode.getTools();
// [
// { name: 'delegate_task', ... },
// { name: 'check_pool_status', ... }
// ]
// Process with context compaction
const response = await system.process({
content: 'Implement user authentication',
tags: ['feature', 'auth'],
references: {
files: ['src/auth.ts', 'src/middleware.ts']
}
});
// Spawn agents for parallel execution
const agents = await openclaw.executeParallelAgents([
{ type: 'planner', prompt: 'Plan auth architecture' },
{ type: 'researcher', prompt: 'Research JWT best practices' },
{ type: 'explorer', prompt: 'Find existing auth patterns' }
]);
// Create deterministic pipeline
const pipeline = openclaw.createPipeline({
name: 'feature-development',
description: 'Complete feature development workflow',
states: [
{
name: 'analyze',
type: 'parallel',
agents: ['explorer', 'researcher'],
transitions: [
{ target: 'design', event: 'analysis_complete' }
]
},
{
name: 'design',
type: 'sequential',
agents: ['planner'],
transitions: [
{ target: 'implement', event: 'design_approved' }
]
},
{
name: 'implement',
type: 'parallel',
agents: ['coder'],
transitions: [
{ target: 'review', event: 'implementation_complete' }
]
},
{
name: 'review',
type: 'sequential',
agents: ['reviewer'],
transitions: [
{ target: 'complete', event: 'approved' },
{ target: 'implement', event: 'rejected' }
]
},
{
name: 'complete',
type: 'sequential',
transitions: []
}
]
});
// Execute pipeline
await openclaw.startPipeline(pipeline.id);
await openclaw.transitionPipeline(pipeline.id, 'analysis_complete');
await openclaw.transitionPipeline(pipeline.id, 'design_approved');
// ... continue transitions
// Create isolated workspaces
const workspace = await openclaw.createWorkspace({
permissions: ['read', 'write'],
quota: { maxFiles: 1000, maxSize: 100 * 1024 * 1024 }
metadata: { integration: 'claude-code' }
});
```
### Custom Integration
Build your own integration:
#### Custom Integration
```typescript
import {
ContextManager,
TokenCounter,
Summarizer,
EventBus,
DeterministicStateMachine,
ParallelExecutionEngine
} from './agent-system';
import { DelegationSystem } from './delegation-system';
class CustomAISystem {
private contextManager: ContextManager;
private eventBus: EventBus;
private executor: ParallelExecutionEngine;
constructor(config: any) {
const tokenCounter = new TokenCounter(config.maxTokens);
const summarizer = new Summarizer();
this.contextManager = new ContextManager(
tokenCounter,
summarizer,
config.compaction
);
this.eventBus = new EventBus();
this.executor = new ParallelExecutionEngine(config.parallel);
this.setupEventHandlers();
}
private setupEventHandlers() {
this.eventBus.subscribe('context:full', async () => {
await this.contextManager.compact();
});
}
async process(input: string) {
this.contextManager.addMessage({
role: 'user',
content: input
});
// Your custom processing logic
}
}
const system = new DelegationSystem();
// Register custom adapter
await system.registerIntegration('my-tool', {
delegation: { enabled: true },
pool: { maxSize: 20 }
});
// Use the custom integration
const response = await system.process({
content: 'Process this request',
metadata: { integration: 'my-tool' }
});
```
---
## Delegation System
### Agent Types
| Type | Purpose | Timeout | Concurrency |
|------|---------|---------|-------------|
| `fast-responder` | Quick answers, status checks | 5s | 10 |
| `explorer` | Code navigation, file search | 30s | 4 |
| `researcher` | Deep analysis, documentation | 60s | 3 |
| `coder` | Code generation, implementation | 45s | 4 |
| `reviewer` | Code review, quality checks | 30s | 3 |
| `planner` | Architecture, planning | 60s | 2 |
| `executor` | Command execution, file ops | 30s | 3 |
| `analyzer` | Debugging, profiling | 45s | 3 |
### Delegation Strategies
| Strategy | Description | When Used |
|----------|-------------|-----------|
| `full` | Complete delegation to single agent | Quick tasks, simple requests |
| `parallel` | Multiple agents work together | Multi-file, high complexity |
| `hierarchical` | Main agent + subagent collaboration | Complex, needs oversight |
| `hybrid` | Combination based on context | Streaming, progressive results |
### Request Classification
Requests are classified into 4 complexity levels:
| Level | Response Time | Example |
|-------|--------------|---------|
| `quick` | < 2s | "What is TypeScript?" |
| `moderate` | 2-15s | "Review this function for bugs" |
| `streaming` | 5-60s | "Analyze the entire codebase" |
| `complex` | 15-120s | "Implement a new authentication system" |
---
## API Reference
### Agent System API
### Delegation System API
| Class | Method | Description |
|-------|--------|-------------|
| `TokenCounter` | `countTokens(text)` | Estimate token count |
| | `getRemainingBudget()` | Get remaining tokens |
| | `addUsage(count)` | Track token usage |
| `ContextManager` | `addMessage(message)` | Add message to context |
| | `needsCompaction()` | Check if compaction needed |
| | `compact()` | Perform context compaction |
| | `getActiveContext()` | Get current context |
| `Summarizer` | `summarize(messages, options)` | Generate summary |
| `Orchestrator` | `registerAgent(type, config)` | Register agent |
| | `routeTask(task)` | Route to appropriate agent |
| | `getAgentStatus(id)` | Check agent status |
| `SubagentSpawner` | `spawn(type, options)` | Create subagent |
| | `getSubagentTypes()` | List available types |
| `ClaudeCodeIntegration` | `addMessage(message)` | Add message with auto-compact |
| | `spawnSubagent(task)` | Spawn Claude Code subagent |
| | `saveContext(name)` | Persist context |
| `OpenClawIntegration` | `createPipeline(definition)` | Create OpenClaw pipeline |
| | `executeParallelAgents(tasks)` | Execute 4×3 pattern |
| | `createWorkspace(options)` | Isolated workspace |
```typescript
class DelegationSystem {
// Initialization
initialize(): Promise<void>;
registerIntegration(type: IntegrationType, config?): Promise<Adapter>;
// Main operations
process(request: DelegationRequest): Promise<DelegationResponse>;
quickClassify(content: string): { complexity: string; agent: AgentType };
// Progress streaming
onProgress(requestId: string, callback: (event: ProgressEvent) => void): () => void;
onAllProgress(callback: (event: ProgressEvent) => void): () => void;
// Status
getStatus(): SystemStatus;
getPoolStats(): PoolStats;
isReady(): boolean;
// Lifecycle
shutdown(): Promise<void>;
reset(): Promise<void>;
}
```
### Pipeline System API
### Integration Adapters API
| Class | Method | Description |
|-------|--------|-------------|
| `DeterministicStateMachine` | `start(context)` | Start state machine |
| | `transition(event, payload)` | Trigger transition |
| | `getState()` | Get current state |
| | `canTransition(event)` | Check valid transition |
| `ParallelExecutionEngine` | `executeAll(tasks)` | Execute tasks in parallel |
| | `submitTask(task)` | Add to queue |
| | `startWorkers(count)` | Start worker threads |
| `EventBus` | `subscribe(pattern, handler)` | Subscribe to events |
| | `publish(event, data)` | Publish event |
| | `getHistory(filter)` | Get event history |
| `WorkspaceManager` | `createWorkspace(id, options)` | Create workspace |
| | `getWorkspace(id)` | Access workspace |
| | `destroyWorkspace(id)` | Cleanup workspace |
| `YAMLWorkflow` | `parse(yaml)` | Parse workflow definition |
| | `validate()` | Validate workflow |
| | `toStateMachine()` | Convert to state machine |
```typescript
interface IntegrationAdapter {
type: IntegrationType;
name: string;
version: string;
initialize(config: any): Promise<void>;
shutdown(): Promise<void>;
classifyRequest(request: any): Promise<RequestClassification>;
delegateRequest(request: any, decision: DelegationDecision): Promise<DelegationResult>;
streamProgress(requestId: string, callback: (event: ProgressEvent) => void): void;
getStatus(): IntegrationStatus;
getCapabilities(): string[];
}
```
---
## Examples
### Example 1: Multi-Project Analysis (OpenClaw Pattern)
### Example 1: Busy-State Handling
```typescript
import { OpenClawIntegration } from './agent-system/integrations/openclaw';
import { DelegationSystem } from './delegation-system';
const openclaw = new OpenClawIntegration({
maxParallelAgents: 12 // 4 projects × 3 roles
const system = new DelegationSystem();
await system.initialize();
// Simulate high load
for (let i = 0; i < 20; i++) {
system.process({
content: `Task ${i}`,
type: 'code'
});
}
// This request will be delegated to available agent or queued
const response = await system.process({
content: 'Urgent: Fix security vulnerability',
type: 'debug',
priority: 'critical'
});
const projects = ['frontend', 'backend', 'mobile', 'docs'];
const roles = ['security', 'performance', 'quality'] as const;
// Check pool status
const stats = system.getPoolStats();
console.log(`Pool: ${stats.busyCount} busy, ${stats.idleCount} idle`);
```
const tasks = projects.flatMap(project =>
roles.map(role => ({
type: 'explorer' as const,
prompt: `Analyze ${project} for ${role} issues`,
context: { project, role }
}))
### Example 2: Progress Streaming
```typescript
const system = new DelegationSystem();
await system.initialize();
const requestId = 'analysis-1';
// Subscribe to progress
const unsubscribe = system.onProgress(requestId, (event) => {
switch (event.type) {
case 'acknowledgment':
console.log('🤖 Got it!');
break;
case 'delegation':
console.log(`📋 Delegated to ${event.data?.agentType}`);
break;
case 'progress':
console.log(`⏳ ${event.progress}% - ${event.message}`);
break;
case 'completion':
console.log('✅ Done!');
break;
}
});
// Process with streaming
await system.process({
id: requestId,
content: 'Analyze entire codebase for security issues',
type: 'analysis',
streamProgress: true
});
unsubscribe();
```
### Example 3: Multi-Agent Parallel Execution
```typescript
const system = new DelegationSystem();
await system.initialize();
// OpenClaw pattern: 4 projects × 3 roles
const projects = ['frontend', 'backend', 'mobile', 'docs'];
const roles = ['security', 'performance', 'quality'];
const results = await Promise.all(
projects.flatMap(project =>
roles.map(role =>
system.process({
content: `Analyze ${project} for ${role} issues`,
type: 'analysis',
metadata: { project, role }
})
)
)
);
const results = await openclaw.executeParallelAgents(tasks);
// Aggregate results by project
for (const [agentId, result] of results) {
console.log(`Agent ${agentId}:`, result.output);
}
```
### Example 2: Context-Aware Chat with Claude Code
```typescript
import { ClaudeCodeIntegration } from './agent-system/integrations/claude-code';
class ContextAwareChat {
private claude: ClaudeCodeIntegration;
constructor() {
this.claude = new ClaudeCodeIntegration({
maxContextTokens: 200000,
compactionStrategy: 'hybrid',
priorityKeywords: ['important', 'remember', 'decision', 'error'],
autoCompact: true,
compactionThreshold: 0.75
});
}
async chat(userMessage: string): Promise<string> {
// Add user message (auto-compacts if needed)
this.claude.addMessage({ role: 'user', content: userMessage });
// Get optimized context for API
const { messages, systemPrompt } = this.claude.getContextForAPI();
// ... call Claude API with messages ...
const response = await this.callClaudeAPI(messages, systemPrompt);
// Add response to context
this.claude.addMessage({ role: 'assistant', content: response });
return response;
}
private async callClaudeAPI(messages: any[], systemPrompt?: string): Promise<string> {
// Your Claude API implementation
return "Response from Claude...";
}
}
```
### Example 3: Human-in-the-Loop Workflow
```typescript
import { OpenClawIntegration } from './agent-system/integrations/openclaw';
const openclaw = new OpenClawIntegration();
const pipeline = openclaw.createPipeline({
name: 'human-approval-workflow',
states: [
{
name: 'draft',
type: 'sequential',
agents: ['coder'],
transitions: [{ target: 'review', event: 'drafted' }]
},
{
name: 'review',
type: 'human-approval',
agents: ['reviewer'],
timeout: 86400000, // 24 hours
transitions: [
{ target: 'publish', event: 'approved' },
{ target: 'draft', event: 'rejected' }
]
},
{
name: 'publish',
type: 'sequential',
agents: ['executor'],
transitions: []
}
]
});
await openclaw.startPipeline(pipeline.id);
console.log(`Completed ${results.length} parallel analyses`);
```
---
@@ -599,95 +522,35 @@ await openclaw.startPipeline(pipeline.id);
```
├── agent-system/ # Context compaction system
│ ├── core/
│ │ ├── token-counter.ts # Token counting
│ │ ├── summarizer.ts # LLM summarization
│ │ ├── context-manager.ts # Context compaction
│ │ ├── orchestrator.ts # Agent orchestration
│ │ └── subagent-spawner.ts # Subagent creation
│ ├── agents/
│ │ ├── base-agent.ts # Base agent class
│ │ └── task-agent.ts # Task-specific agent
│ ├── integrations/
│ │ ├── claude-code.ts # Claude Code integration ✅
│ │ └── openclaw.ts # OpenClaw integration ✅
│ ├── storage/
│ │ └── memory-store.ts # Persistent storage
│ ├── utils/
│ │ └── helpers.ts # Utility functions
│ └── index.ts # Main exports
│ ├── core/ # Core components
│ ├── agents/ # Agent implementations
│ ├── integrations/ # Claude Code & OpenClaw integrations
│ ├── storage/ # Persistent storage
│ └── utils/ # Utilities
│
├── pipeline-system/ # Deterministic pipeline system
│ ├── core/
│ │ └── state-machine.ts # State machine
│ ├── engine/
│ │ └── parallel-executor.ts # Parallel execution
│ ├── events/
│ │ └── event-bus.ts # Event coordination
│ ├── workspace/
│ │ └── agent-workspace.ts # Workspace isolation
│ ├── workflows/
│ │ └── yaml-workflow.ts # YAML parser
│ ├── integrations/
│ │ └── claude-code.ts # Claude Code integration
│ ├── core/ # State machine
│ ├── engine/ # Parallel execution
│ ├── events/ # Event bus
│ ├── workspace/ # Workspace isolation
│ └── workflows/ # YAML parser
│
├── delegation-system/ # 🆕 Delegation system
│ ├── core/ # Types, classifier, engine, handoff
│ ├── pool/ # Agent pool management
│ ├── streaming/ # Progress streaming
│ ├── quality/ # Quality gates
│ ├── integrations/ # 3rd party adapters
│ ├── test.ts # Test suite
│ └── index.ts # Main exports
│
├── examples/ # Usage examples
├── downloads/ # Zip packages
│ ├── agent-system.zip
│ ├── pipeline-system.zip
│ └── complete-agent-pipeline-system.zip
│
└── README.md # This file
```
---
## Compaction Strategies
### 1. Sliding Window
Keeps the most recent N messages:
```typescript
const contextManager = new ContextManager(tokenCounter, summarizer, {
compactionStrategy: 'sliding-window',
slidingWindowSize: 50 // Keep last 50 messages
});
```
### 2. Summarize Old
Summarizes older messages into a compact summary:
```typescript
const contextManager = new ContextManager(tokenCounter, summarizer, {
compactionStrategy: 'summarize-old',
preserveRecentCount: 10 // Keep last 10 messages verbatim
});
```
### 3. Priority Retention
Keeps messages containing priority keywords:
```typescript
const contextManager = new ContextManager(tokenCounter, summarizer, {
compactionStrategy: 'priority-retention',
priorityKeywords: ['error', 'important', 'decision', 'critical']
});
```
### 4. Hybrid (Recommended)
Combines all strategies for optimal results:
```typescript
const contextManager = new ContextManager(tokenCounter, summarizer, {
compactionStrategy: 'hybrid',
slidingWindowSize: 30,
preserveRecentCount: 10,
priorityKeywords: ['error', 'important', 'decision']
});
├── package.json
├── tsconfig.json
├── LICENSE
├── CHANGELOG.md
└── README.md
```
---