feat: Add complete Agentic Compaction & Pipeline System

- Context Compaction System with token counting and summarization
- Deterministic State Machine for flow control (no LLM decisions)
- Parallel Execution Engine (up to 12 concurrent sessions)
- Event-Driven Coordination via Event Bus
- Agent Workspace Isolation (tools, memory, identity, files)
- YAML Workflow Integration (OpenClaw/Lobster compatible)
- Claude Code integration layer
- Complete demo UI with real-time visualization
- Comprehensive documentation and README

Components:
- agent-system/: Context management, token counting, subagent spawning
- pipeline-system/: State machine, parallel executor, event bus, workflows
- skills/: AI capabilities (LLM, ASR, TTS, VLM, image generation, etc.)
- src/app/: Next.js demo application

Total: ~100KB of production-ready TypeScript code
This commit is contained in:
Z User
2026-03-03 12:40:47 +00:00
Unverified
parent 63a8b123c9
commit 2380d33861
152 changed files with 51569 additions and 817 deletions

View File

@@ -0,0 +1,168 @@
import ZAI from "z-ai-web-dev-sdk";
import fs from "fs";
async function create() {
try {
const zai = await ZAI.create();
console.log("Creating video generation task...");
const task = await zai.video.generations.create({
prompt: "A cat is playing with a ball.",
quality: "speed",
with_audio: false,
size: "1920x1080",
fps: 30,
duration: 5,
});
console.log(`Task created!`);
console.log(`Task ID: ${task.id}`);
console.log(`Task Status: ${task.task_status}`);
console.log(`Model: ${task.model || 'N/A'}`);
return { zai, task };
} catch (err: any) {
console.error("Video generation failed:", err?.message || err);
throw err;
}
}
/**
* Example: Image-to-Video Generation using base64
* IMPORTANT: Using base64-encoded image data is STRONGLY RECOMMENDED over URLs
* for better reliability and to avoid network-related issues.
*
* CRITICAL: Always match the MIME type to your actual image format.
*/
async function createFromImage(imagePath: string) {
try {
const zai = await ZAI.create();
console.log("Creating image-to-video generation task...");
console.log(`Reading image from: ${imagePath}`);
// Read image file and convert to base64
const imageBuffer = fs.readFileSync(imagePath);
// Detect MIME type from file extension
const imageExt = imagePath.split('.').pop()?.toLowerCase() || '';
const mimeTypeMap: Record<string, string> = {
'jpg': 'image/jpeg',
'jpeg': 'image/jpeg',
'png': 'image/png',
'gif': 'image/gif',
'webp': 'image/webp',
'bmp': 'image/bmp'
};
const mimeType = mimeTypeMap[imageExt] || 'image/jpeg'; // Default to JPEG if unknown
const base64Image = `data:${mimeType};base64,${imageBuffer.toString('base64')}`;
console.log(`Image format detected: ${mimeType}`);
console.log(`Image converted to base64 (${base64Image.substring(0, 50)}...)`);
// Create video generation task with base64 image
const task = await zai.video.generations.create({
image_url: base64Image, // Use base64 with correct MIME type
prompt: "Animate this scene with gentle motion",
quality: "quality",
size: "1920x1080",
fps: 30,
duration: 5,
});
console.log(`Task created!`);
console.log(`Task ID: ${task.id}`);
console.log(`Task Status: ${task.task_status}`);
console.log(`Model: ${task.model || 'N/A'}`);
return { zai, task };
} catch (err: any) {
console.error("Image-to-video generation failed:", err?.message || err);
throw err;
}
}
async function query(zai: any, taskId: string) {
try {
// 首次查询
let result = await zai.async.result.query(taskId);
if (result.task_status === 'SUCCESS') {
// 如果任务立即完成,直接返回结果
console.log("\nTask completed immediately, fetching result...");
displayResult(result);
return result;
}
// 轮询查询结果
console.log("\nPolling for result...");
let pollCount = 0;
const maxPolls = 30; // 最多轮询30次
const pollInterval = 10000; // 每10秒查询一次
while (result.task_status === 'PROCESSING' && pollCount < maxPolls) {
pollCount++;
console.log(`Poll ${pollCount}/${maxPolls}: Status is ${result.task_status}, waiting ${pollInterval / 1000}s...`);
await new Promise(resolve => setTimeout(resolve, pollInterval));
result = await zai.async.result.query(taskId);
}
displayResult(result);
return result;
} catch (err: any) {
console.error("Query failed:", err?.message || err);
throw err;
}
}
async function main() {
try {
// Method 1: Text-to-Video (default)
const { zai, task } = await create();
// Method 2: Image-to-Video with base64 (RECOMMENDED for image input)
// Uncomment the lines below and comment out the lines above to use image-to-video
// Make sure to provide a valid image path
// const { zai, task } = await createFromImage('./path/to/your/image.jpg');
await query(zai, task.id);
} catch (err: any) {
console.error("Video generation failed:", err?.message || err);
process.exit(1);
}
}
function displayResult(result: any) {
console.log("\n=== Result ===");
console.log(`Task Status: ${result.task_status}`);
console.log(`Model: ${result.model || 'N/A'}`);
console.log(`Request ID: ${result.request_id || 'N/A'}`);
if (result.task_status === 'SUCCESS') {
// 尝试从多种可能的字段中获取视频URL
const videoUrl =
result.video_result?.[0]?.url ||
result.video_url ||
result.url ||
result.video;
if (videoUrl) {
console.log(`\n✅ Video generated successfully!`);
console.log(`Video URL: ${videoUrl}`);
console.log(`\nYou can open this URL in your browser or download it.`);
} else {
console.log(`\n⚠ Task completed but video URL not found in response.`);
console.log(`Full response:`, JSON.stringify(result, null, 2));
}
} else if (result.task_status === 'PROCESSING') {
console.log(`\n⏳ Task is still processing. Please try again later.`);
console.log(`Task ID: ${result.id || 'N/A'}`);
} else if (result.task_status === 'FAIL') {
console.log(`\n❌ Task failed.`);
console.log(`Full response:`, JSON.stringify(result, null, 2));
}
}
main();