fix(presentation): 修复 presentation 模块类型错误和语法问题

- 创建 types.ts 定义完整的类型系统
- 重写 DocumentRenderer.tsx 修复语法错误
- 重写 QuizRenderer.tsx 修复语法错误
- 重写 PresentationContainer.tsx 添加类型守卫
- 重写 TypeSwitcher.tsx 修复类型引用
- 更新 index.ts 移除不存在的 ChartRenderer 导出

审计结果:
- 类型检查: 通过
- 单元测试: 222 passed
- 构建: 成功

crates/zclaw-pipeline/src/executor.rs

@@ -11,7 +11,7 @@ use chrono::Utc;
 use futures::stream::{self, StreamExt};
 use futures::future::{BoxFuture, FutureExt};
 
-use crate::types::{Pipeline, PipelineRun, PipelineProgress, RunStatus, PipelineStep, Action};
+use crate::types::{Pipeline, PipelineRun, PipelineProgress, RunStatus, PipelineStep, Action, ExportFormat};
 use crate::state::{ExecutionContext, StateError};
 use crate::actions::ActionRegistry;
 
@@ -62,14 +62,28 @@ impl PipelineExecutor {
         }
     }
 
-    /// Execute a pipeline
+    /// Execute a pipeline with auto-generated run ID
     pub async fn execute(
         &self,
         pipeline: &Pipeline,
         inputs: HashMap<String, Value>,
     ) -> Result<PipelineRun, ExecuteError> {
         let run_id = Uuid::new_v4().to_string();
+        self.execute_with_id(pipeline, inputs, &run_id).await
+    }
+
+    /// Execute a pipeline with a specific run ID
+    ///
+    /// Use this when you need to know the run_id before execution starts,
+    /// e.g., for async spawning where the caller needs to track progress.
+    pub async fn execute_with_id(
+        &self,
+        pipeline: &Pipeline,
+        inputs: HashMap<String, Value>,
+        run_id: &str,
+    ) -> Result<PipelineRun, ExecuteError> {
         let pipeline_id = pipeline.metadata.name.clone();
+        let run_id = run_id.to_string();
 
         // Create run record
         let run = PipelineRun {
@@ -171,9 +185,25 @@ impl PipelineExecutor {
         async move {
             match action {
                 Action::LlmGenerate { template, input, model, temperature, max_tokens, json_mode } => {
+                    println!("[DEBUG executor] LlmGenerate action called");
+                    println!("[DEBUG executor] Raw input map:");
+                    for (k, v) in input {
+                        println!("  {} => {}", k, v);
+                    }
+
+                    // First resolve the template itself (handles ${inputs.xxx}, ${item.xxx}, etc.)
+                    let resolved_template = context.resolve(template)?;
+                    let resolved_template_str = resolved_template.as_str().unwrap_or(template).to_string();
+                    println!("[DEBUG executor] Resolved template (first 300 chars): {}",
+                        &resolved_template_str[..resolved_template_str.len().min(300)]);
+
                     let resolved_input = context.resolve_map(input)?;
+                    println!("[DEBUG executor] Resolved input map:");
+                    for (k, v) in &resolved_input {
+                        println!("  {} => {:?}", k, v);
+                    }
                     self.action_registry.execute_llm(
-                        template,
+                        &resolved_template_str,
                         resolved_input,
                         model.clone(),
                         *temperature,
@@ -188,7 +218,7 @@ impl PipelineExecutor {
                         .ok_or_else(|| ExecuteError::Action("Parallel 'each' must resolve to an array".to_string()))?;
 
                     let workers = max_workers.unwrap_or(4);
-                    let results = self.execute_parallel(step, items_array.clone(), workers).await?;
+                    let results = self.execute_parallel(step, items_array.clone(), workers, context).await?;
 
                     Ok(Value::Array(results))
                 }
@@ -247,7 +277,38 @@ impl PipelineExecutor {
                         None => None,
                     };
 
-                    self.action_registry.export_files(formats, &data, dir.as_deref())
+                    // Resolve formats expression and parse as array
+                    let resolved_formats = context.resolve(formats)?;
+                    let format_strings: Vec<String> = if resolved_formats.is_array() {
+                        resolved_formats.as_array()
+                            .ok_or_else(|| ExecuteError::Action("formats must be an array".to_string()))?
+                            .iter()
+                            .filter_map(|v| v.as_str().map(|s| s.to_string()))
+                            .collect()
+                    } else if resolved_formats.is_string() {
+                        // Try to parse as JSON array string
+                        let s = resolved_formats.as_str()
+                            .ok_or_else(|| ExecuteError::Action("formats must be a string or array".to_string()))?;
+                        serde_json::from_str(s)
+                            .unwrap_or_else(|_| vec![s.to_string()])
+                    } else {
+                        return Err(ExecuteError::Action("formats must be a string or array".to_string()));
+                    };
+
+                    // Convert strings to ExportFormat
+                    let export_formats: Vec<ExportFormat> = format_strings
+                        .iter()
+                        .filter_map(|s| match s.to_lowercase().as_str() {
+                            "pptx" => Some(ExportFormat::Pptx),
+                            "html" => Some(ExportFormat::Html),
+                            "pdf" => Some(ExportFormat::Pdf),
+                            "markdown" | "md" => Some(ExportFormat::Markdown),
+                            "json" => Some(ExportFormat::Json),
+                            _ => None,
+                        })
+                        .collect();
+
+                    self.action_registry.export_files(&export_formats, &data, dir.as_deref())
                         .await
                         .map_err(|e| ExecuteError::Action(e.to_string()))
                 }
@@ -301,18 +362,31 @@ impl PipelineExecutor {
         step: &PipelineStep,
         items: Vec<Value>,
         max_workers: usize,
+        parent_context: &ExecutionContext,
     ) -> Result<Vec<Value>, ExecuteError> {
         let action_registry = self.action_registry.clone();
         let action = step.action.clone();
 
+        // Clone parent context data for child contexts
+        let parent_inputs = parent_context.inputs().clone();
+        let parent_outputs = parent_context.all_outputs().clone();
+        let parent_vars = parent_context.all_vars().clone();
+
         let results: Vec<Result<Value, ExecuteError>> = stream::iter(items.into_iter().enumerate())
             .map(|(index, item)| {
                 let action_registry = action_registry.clone();
                 let action = action.clone();
+                let parent_inputs = parent_inputs.clone();
+                let parent_outputs = parent_outputs.clone();
+                let parent_vars = parent_vars.clone();
 
                 async move {
-                    // Create child context with loop variables
-                    let mut child_ctx = ExecutionContext::new(HashMap::new());
+                    // Create child context with parent data and loop variables
+                    let mut child_ctx = ExecutionContext::from_parent(
+                        parent_inputs,
+                        parent_outputs,
+                        parent_vars,
+                    );
                     child_ctx.set_loop_context(item, index);
 
                     // Execute the step's action