feat: add lesson export and import functionality

- Implemented `LessonExport` and `LessonImport` actions in the action module.
- Added corresponding command parsing for lesson export and import.
- Created functions to handle lesson export and import in the memory module.
- Updated state management to reflect changes after lesson operations.
- Introduced deferred operations for handling asynchronous tasks in the event loop.
- Enhanced the tool execution context to include graduated checks for file operations.
- Added OAuth support with PKCE for secure authorization flows.
- Implemented a loopback server for handling OAuth redirects.
- Refactored various modules to improve code organization and maintainability.

src/app/subagent/engine.rs

@@ -1,19 +1,83 @@
 use tokio::sync::mpsc;
+use crate::dto::chat::message::ChatMessage;
 use super::context::SubagentContext;
 use super::event::SubagentEvent;
 
 pub const MAX_AGENT_STEPS: usize = 25;
 
+fn tool_call_from_response(response: &str) -> Vec<String> {
+    let mut calls = Vec::new();
+    for line in response.lines() {
+        let trimmed = line.trim();
+        if let Some(tool_call) = trimmed.strip_prefix("Tool: ") {
+            calls.push(tool_call.to_string());
+        }
+    }
+    calls
+}
+
 pub fn run_subagent(ctx: SubagentContext, tx: mpsc::Sender<SubagentEvent>) -> anyhow::Result<String> {
     let mut output = String::new();
-    for step in 0..ctx.max_steps.min(MAX_AGENT_STEPS) {
-        let event = SubagentEvent::StepCompleted {
-            step,
-            output: format!("step {} completed", step),
+    let mut messages: Vec<ChatMessage> = Vec::new();
+    messages.push(ChatMessage::system(ctx.system_prompt.clone()));
+
+    let max_steps = ctx.max_steps.min(MAX_AGENT_STEPS);
+    for step in 0..max_steps {
+        let api_key = std::env::var("OPENROUTER_API_KEY").unwrap_or_default();
+        let model = std::env::var("OPENROUTER_MODEL").unwrap_or_else(|_| "anthropic/claude-sonnet-5".to_string());
+
+        let client = crate::service::openrouter::OpenRouterClient::new(api_key, model);
+        let response = match client.chat(&messages) {
+            Ok(r) => r,
+            Err(e) => {
+                let _ = tx.blocking_send(SubagentEvent::StepFailed {
+                    step,
+                    error: e.to_string(),
+                });
+                anyhow::bail!("subagent call failed at step {}: {}", step, e);
+            }
         };
-        let _ = tx.blocking_send(event);
-        output.push_str(&format!("step {} completed\n", step));
+
+        let _ = tx.blocking_send(SubagentEvent::ToolCall {
+            tool: "api".to_string(),
+            args: serde_json::json!({"response": response}),
+        });
+
+        let tool_calls = tool_call_from_response(&response);
+        if tool_calls.is_empty() {
+            output.push_str(&response);
+            output.push('\n');
+            let _ = tx.blocking_send(SubagentEvent::StepCompleted {
+                step,
+                output: response.clone(),
+            });
+            if !response.contains("Tool:") {
+                break;
+            }
+        } else {
+            for tool_name in &tool_calls {
+                if !ctx.allowed_tools.is_empty() && !ctx.allowed_tools.contains(tool_name) {
+                    let msg = format!("tool '{}' not allowed for this subagent", tool_name);
+                    messages.push(ChatMessage::tool_result("subagent".to_string(), msg));
+                    continue;
+                }
+                let _ = tx.blocking_send(SubagentEvent::ToolResult {
+                    tool: tool_name.clone(),
+                    output: format!("{} executed", tool_name),
+                });
+            }
+            let _ = tx.blocking_send(SubagentEvent::StepCompleted {
+                step,
+                output: response.clone(),
+            });
+        }
+
+        let assistant_msg = ChatMessage::assistant(Some(response.clone()));
+        messages.push(assistant_msg);
+        let user_msg = ChatMessage::user("Continue with the next step based on the tool results above.".to_string());
+        messages.push(user_msg);
     }
+
     let _ = tx.blocking_send(SubagentEvent::Completed { output: output.clone() });
     Ok(output)
 }