feat: iPet → iAs 完整迁移，Rust 版微信 AI 助手

Phase 1 ✅ CLI 框架 + 配置系统
  - clap 子命令: login / listen / send / whoami / usage
  - config.json + env var 替换
  - tracing 日志系统
  - state 持久化（auth/runtime 文件存 + PostgreSQL）

Phase 2 ✅ 微信通道
  - wechat::client — 完整 iLink Bot HTTP API 实现
  - 扫码登录（终端二维码 + 轮询状态）
  - 长轮询 getupdates / 消息收发 / 监听注册

Phase 3 ✅ AI 对话（纯文本 + function calling）
  - LlmProvider trait: DeepSeek + LM Studio 实现
  - SSE 流式解析（text / reasoning / tool_calls delta / usage）
  - Conversation: 消息历史 + chat / chat_with_tools 工具循环

Phase 4 ✅ PostgreSQL 集成
  - app_state（认证 KV 存储）
  - chat_records（消息收发记录）
  - llm_usage（Token 用量统计缓存命中率）
  - user_memories（长期记忆持久化）
  - pending_approvals（审批确认码）
  - scheduled_tasks（定时任务表）

Phase 5 ✅ 一切皆 Skill（工具系统）
  - SkillRegistry: 系统 + 用户 skills 双目录合并
  - SKILL.md 解析器 + 子进程执行器（stdin JSON → stdout）
  - 9 个系统 Skills: datetime / weather / search / email /
    shell / schedule / memos / read_memories / read_summaries
  - ApprovalManager: High 风险技能 → 确认码审批（透明模式）
  - High 风险技能：确认码审批（透明模式）

Phase 6 ✅ 定时任务调度器

上下文管理
  - ChatSession: checkpoint + token budget (28K) + summaries
  - Token 估算器（中英文自适应）
  - 12h 空闲 → trigger_idle_summary（不入会话）
  - Budget 溢出 → trigger_overflow_summary（入会话 + drain 旧消息）
  - Summarizer: LLM 生成自然语言摘要（fallback 简单截断）
  - 长期记忆 / 摘要 通过 read_memories / read_summaries 工具按需读取

工具调用日志 + Token 统计
  - INFO: 工具名 + 参数 + 结果摘要
  - DEBUG: 子进程 exit/stdout/stderr
  - ias usage --since --until --model 查看用量和缓存命中率

src/llm/provider.rs

@@ -0,0 +1,187 @@
+use crate::llm::types::{ConversationConfig, Message, StreamChunk};
+use serde::Deserialize;
+use async_trait::async_trait;
+use std::sync::Arc;
+use tokio::sync::mpsc;
+
+/// 流式返回：每个 StreamChunk 是 delta 或控制信号
+pub type StreamReceiver = mpsc::Receiver<StreamChunk>;
+pub type StreamSender = mpsc::Sender<StreamChunk>;
+
+/// LLM 提供商抽象
+#[async_trait]
+pub trait LlmProvider: Send + Sync {
+    /// 提供商名称
+    fn name(&self) -> &str;
+
+    /// 发起流式对话
+    async fn chat_stream(
+        &self,
+        config: &ConversationConfig,
+        messages: &[Message],
+    ) -> Result<StreamReceiver, String>;
+}
+
+// ─── 内置提供商注册 ───
+
+pub type BoxedProvider = Arc<dyn LlmProvider>;
+
+/// 从配置创建恰当的提供商
+pub fn create_provider(_config: &ConversationConfig) -> Result<BoxedProvider, String> {
+    // 根据 model 前缀或环境变量选择
+    let provider = std::env::var("LLM_PROVIDER")
+        .unwrap_or_else(|_| "deepseek".to_string())
+        .to_lowercase();
+
+    match provider.as_str() {
+        "deepseek" => Ok(Arc::new(super::deepseek::DeepSeekProvider::new()?)),
+        "lmstudio" => Ok(Arc::new(super::lmstudio::LmStudioProvider::new()?)),
+        _ => Err(format!("不支持的 LLM 提供商: {}", provider)),
+    }
+}
+
+// ─── 内部：SSE 解析工具 ───
+
+/// 从字节流中解析 SSE 行
+pub(crate) fn parse_sse_line(line: &str) -> Option<(String, String)> {
+    // 支持两种格式:
+    //   data: {...}
+    //   event: ...
+    let line = line.trim();
+    if line.is_empty() || line.starts_with(':') {
+        return None;
+    }
+
+    if let Some(pos) = line.find(": ") {
+        let field = line[..pos].trim().to_string();
+        let value = line[pos + 2..].trim_start().to_string();
+        Some((field, value))
+    } else if let Some(pos) = line.find(':') {
+        let field = line[..pos].trim().to_string();
+        let value = line[pos + 1..].trim_start().to_string();
+        Some((field, value))
+    } else {
+        None
+    }
+}
+
+/// 流式块解析结果
+pub(crate) enum ParsedChunk {
+    Text(String),
+    Reasoning(String),
+    ToolCallDelta {
+        index: i32,
+        id: Option<String>,
+        name: Option<String>,
+        arguments: String,
+    },
+    FinishReason(String),
+    Usage(super::types::Usage),
+}
+
+/// 从 JSON body 中解析 DeepSeek/OpenAI 流式 delta
+pub(crate) fn parse_chat_chunk(
+    line: &str,
+) -> Option<ParsedChunk> {
+    if !line.starts_with("data: ") {
+        return None;
+    }
+
+    let data = line["data: ".len()..].trim();
+    if data == "[DONE]" {
+        return None;
+    }
+
+    #[derive(Deserialize)]
+    struct ToolCallDelta {
+        #[serde(default)]
+        index: Option<i32>,
+        #[serde(default)]
+        id: Option<String>,
+        #[serde(rename = "type", default)]
+        call_type: Option<String>,
+        #[serde(default)]
+        function: Option<ToolFunctionDelta>,
+    }
+
+    #[derive(Deserialize)]
+    struct ToolFunctionDelta {
+        #[serde(default)]
+        name: Option<String>,
+        #[serde(default)]
+        arguments: Option<String>,
+    }
+
+    #[derive(Deserialize)]
+    struct Delta {
+        #[serde(default)]
+        content: Option<String>,
+        #[serde(default)]
+        reasoning_content: Option<String>,
+        #[serde(default)]
+        tool_calls: Option<Vec<ToolCallDelta>>,
+    }
+
+    #[derive(Deserialize)]
+    struct ChunkChoice {
+        delta: Delta,
+        #[serde(default)]
+        finish_reason: Option<String>,
+    }
+
+    #[derive(Deserialize)]
+    struct ChunkResponse {
+        choices: Vec<ChunkChoice>,
+        #[serde(default)]
+        usage: Option<super::types::Usage>,
+    }
+
+    let parsed: ChunkResponse = match serde_json::from_str(data) {
+        Ok(p) => p,
+        Err(_) => return None,
+    };
+
+    // 提取 usage（可能在最后一个 chunk）
+    if let Some(ref usage) = parsed.usage {
+        if usage.total_tokens > 0 {
+            return Some(ParsedChunk::Usage(usage.clone()));
+        }
+    }
+
+    for choice in parsed.choices {
+        // 工具调用 delta
+        if let Some(tool_calls) = &choice.delta.tool_calls {
+            for tc in tool_calls {
+                let idx = tc.index.unwrap_or(0);
+                let args = tc.function.as_ref()
+                    .and_then(|f| f.arguments.clone())
+                    .unwrap_or_default();
+                let name = tc.function.as_ref().and_then(|f| f.name.clone());
+                return Some(ParsedChunk::ToolCallDelta {
+                    index: idx,
+                    id: tc.id.clone(),
+                    name,
+                    arguments: args,
+                });
+            }
+        }
+
+        if let Some(reasoning) = &choice.delta.reasoning_content {
+            if !reasoning.is_empty() {
+                return Some(ParsedChunk::Reasoning(reasoning.clone()));
+            }
+        }
+        if let Some(content) = &choice.delta.content {
+            if !content.is_empty() {
+                return Some(ParsedChunk::Text(content.clone()));
+            }
+        }
+        if let Some(reason) = &choice.finish_reason {
+            if !reason.is_empty() {
+                return Some(ParsedChunk::FinishReason(reason.clone()));
+            }
+        }
+    }
+
+    None
+}