src/gateway/session.rs

@@ -33,7 +33,6 @@ const MANAGED_AGENT_MEMORY_TITLE: &str = "## 用户记忆摘要";
 const MEMORY_MAINTENANCE_SYSTEM_PROMPT: &str =
     include_str!("memory_maintenance_system_prompt.md");
 const MEMORY_MAINTENANCE_RETRY_DELAYS_MS: &[u64] = &[1_000, 3_000];
-const SCHEDULED_TASK_EXECUTION_SYSTEM_PROMPT: &str = "系统说明：当前输入来自一次已经触发的定时任务执行。你现在需要执行任务内容本身，而不是创建、修改、恢复、暂停或查询新的定时任务。除非当前任务内容明确要求管理调度器，否则不要调用任何定时任务管理工具；像“每小时”、“每天”、“cron”、“定时”等词，只应视为任务背景，不应再解释为新的建任务请求。";
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 enum MemoryMaintenanceCategory {
@@ -1482,15 +1481,15 @@ impl SessionManager {
             session_guard.ensure_chat_loaded(chat_id)?;
             session_guard.ensure_agent_prompt_before_user_message(chat_id)?;
 
-            let scheduled_system_prompt =
+            if let Some(system_prompt) = options.system_prompt.as_deref() {
-                compose_scheduled_task_system_prompt(options.system_prompt.as_deref());
+                session_guard.append_persisted_message(
-            session_guard.append_persisted_message(
+                    chat_id,
-                chat_id,
+                    ChatMessage::system_with_context(
-                ChatMessage::system_with_context(
+                        system_prompt,
-                    &scheduled_system_prompt,
+                        Some(SYSTEM_CONTEXT_SCHEDULED_PROMPT.to_string()),
-                    Some(SYSTEM_CONTEXT_SCHEDULED_PROMPT.to_string()),
+                    ),
-                ),
+                )?;
-            )?;
+            }
 
             let user_message = session_guard.create_user_message(prompt, Vec::new());
             let user_message_id = user_message.id.clone();
@@ -1576,17 +1575,6 @@ fn should_display_message_to_user(show_tool_results: bool, message: &ChatMessage
         )
 }
 
-fn compose_scheduled_task_system_prompt(system_prompt: Option<&str>) -> String {
-    match system_prompt.map(str::trim).filter(|value| !value.is_empty()) {
-        Some(system_prompt) => format!(
-            "{}\n\n任务专属要求：{}",
-            SCHEDULED_TASK_EXECUTION_SYSTEM_PROMPT,
-            system_prompt
-        ),
-        None => SCHEDULED_TASK_EXECUTION_SYSTEM_PROMPT.to_string(),
-    }
-}
-
 fn select_provider_config(
     default_provider_config: &LLMProviderConfig,
     provider_configs: &HashMap<String, LLMProviderConfig>,
@@ -1948,66 +1936,6 @@ mod tests {
         assert!(default_outbound[0].content.contains("default-model"));
     }
 
-    #[tokio::test]
-    async fn test_run_scheduled_agent_task_persists_execution_guard_prompt() {
-        let base_url = start_mock_openai_server().await;
-        let provider_config = LLMProviderConfig {
-            provider_type: "openai".to_string(),
-            name: "default-provider".to_string(),
-            base_url,
-            api_key: "test-key".to_string(),
-            extra_headers: HashMap::new(),
-            model_id: "default-model".to_string(),
-            temperature: Some(0.0),
-            max_tokens: Some(32),
-            model_extra: HashMap::new(),
-            max_tool_iterations: 1,
-            llm_timeout_secs: 30,
-            tool_result_max_chars: 20_000,
-            context_tool_result_trim_chars: 20_000,
-        };
-
-        let session_manager = SessionManager::new(
-            4,
-            100,
-            false,
-            provider_config.clone(),
-            HashMap::from([("default".to_string(), provider_config)]),
-            Arc::new(SkillRuntime::default()),
-        )
-        .unwrap();
-
-        session_manager
-            .run_scheduled_agent_task(
-                "feishu",
-                "chat-guard",
-                "每小时执行以下流程：检查邮箱并同步待办",
-                ScheduledAgentTaskOptions {
-                    fresh_session: true,
-                    system_prompt: Some("你是邮箱待办同步助手。".to_string()),
-                    ..Default::default()
-                },
-            )
-            .await
-            .unwrap();
-
-        let session = session_manager.get("feishu").await.unwrap();
-        let session_guard = session.lock().await;
-        let persisted_messages = session_guard
-            .store
-            .load_messages(&session_guard.persistent_session_id("chat-guard"))
-            .unwrap();
-
-        let scheduled_prompt = persisted_messages
-            .iter()
-            .find(|message| message.has_system_context(SYSTEM_CONTEXT_SCHEDULED_PROMPT))
-            .expect("missing scheduled system prompt");
-
-        assert!(scheduled_prompt.content.contains("已经触发的定时任务执行"));
-        assert!(scheduled_prompt.content.contains("不要调用任何定时任务管理工具"));
-        assert!(scheduled_prompt.content.contains("你是邮箱待办同步助手。"));
-    }
-
     #[tokio::test]
     async fn test_summarize_memory_maintenance_for_scope_uses_model_output() {
         let base_url = start_mock_openai_server().await;

src/providers/openai.rs

@@ -36,13 +36,6 @@ pub struct OpenAIProvider {
     model_extra: HashMap<String, serde_json::Value>,
 }
 
-#[derive(Deserialize)]
-#[serde(untagged)]
-enum OAIFunctionArguments {
-    Json(Value),
-    String(String),
-}
-
 impl OpenAIProvider {
     pub fn new(
         name: String,
@@ -74,23 +67,6 @@ impl OpenAIProvider {
         }
     }
 
-    fn uses_json_tool_arguments(&self) -> bool {
-        self.model_extra
-            .get("tool_call_arguments_json")
-            .and_then(|value| value.as_bool())
-            .unwrap_or(false)
-    }
-
-    fn serialize_tool_arguments(&self, arguments: &Value) -> Value {
-        if self.uses_json_tool_arguments() {
-            arguments.clone()
-        } else {
-            Value::String(
-                serde_json::to_string(arguments).unwrap_or_else(|_| "null".to_string()),
-            )
-        }
-    }
-
     fn build_request_body(&self, request: &ChatCompletionRequest) -> Value {
         let mut body = json!({
             "model": self.model_id,
@@ -112,7 +88,7 @@ impl OpenAIProvider {
                                 "type": "function",
                                 "function": {
                                     "name": call.name,
-                                    "arguments": self.serialize_tool_arguments(&call.arguments)
+                                    "arguments": serde_json::to_string(&call.arguments).unwrap_or_else(|_| "null".to_string())
                                 }
                             })).collect::<Vec<_>>()
                         })
@@ -194,7 +170,7 @@ struct OpenAIToolCall {
 #[derive(Deserialize)]
 struct OAIFunction {
     name: String,
-    arguments: OAIFunctionArguments,
+    arguments: String,
 }
 
 #[derive(Deserialize, Default)]
@@ -284,12 +260,7 @@ impl LLMProvider for OpenAIProvider {
             .map(|tc| ToolCall {
                 id: tc.id.clone(),
                 name: tc.function.name.clone(),
-                arguments: match &tc.function.arguments {
+                arguments: serde_json::from_str(&tc.function.arguments).unwrap_or(serde_json::Value::Null),
-                    OAIFunctionArguments::Json(arguments) => arguments.clone(),
-                    OAIFunctionArguments::String(arguments) => {
-                        serde_json::from_str(arguments).unwrap_or(serde_json::Value::Null)
-                    }
-                },
             })
             .collect();
 
@@ -368,48 +339,6 @@ mod tests {
         assert_eq!(tool_calls[0]["function"]["arguments"], "{\"expression\":\"1+1\"}");
     }
 
-    #[test]
-    fn test_build_request_body_uses_json_tool_arguments_when_enabled() {
-        let provider = OpenAIProvider::new(
-            "test".to_string(),
-            "key".to_string(),
-            "https://example.com/v1".to_string(),
-            HashMap::new(),
-            120,
-            "gpt-test".to_string(),
-            None,
-            None,
-            HashMap::from([(
-                "tool_call_arguments_json".to_string(),
-                Value::Bool(true),
-            )]),
-        );
-
-        let request = ChatCompletionRequest {
-            messages: vec![Message {
-                role: "assistant".to_string(),
-                content: vec![ContentBlock::text("calling tool")],
-                reasoning_content: None,
-                tool_call_id: None,
-                name: None,
-                tool_calls: Some(vec![ToolCall {
-                    id: "call_1".to_string(),
-                    name: "calculator".to_string(),
-                    arguments: json!({"expression": "1+1"}),
-                }]),
-            }],
-            temperature: None,
-            max_tokens: None,
-            tools: None,
-        };
-
-        let body = provider.build_request_body(&request);
-        let messages = body["messages"].as_array().unwrap();
-        let tool_calls = messages[0]["tool_calls"].as_array().unwrap();
-
-        assert_eq!(tool_calls[0]["function"]["arguments"], json!({"expression": "1+1"}));
-    }
-
     #[test]
     fn test_build_request_body_includes_assistant_reasoning_content() {
         let provider = OpenAIProvider::new(
@@ -466,37 +395,4 @@ mod tests {
 
         assert_eq!(response.choices[0].message.reasoning_content.as_deref(), Some("hidden reasoning"));
     }
-
-    #[test]
-    fn test_openai_response_parses_json_tool_arguments() {
-        let response: OpenAIResponse = serde_json::from_value(json!({
-            "id": "resp_1",
-            "model": "gpt-test",
-            "choices": [{
-                "message": {
-                    "content": "",
-                    "tool_calls": [{
-                        "id": "call_1",
-                        "function": {
-                            "name": "scheduler_manage",
-                            "arguments": {"action": "list"}
-                        }
-                    }]
-                }
-            }],
-            "usage": {
-                "prompt_tokens": 1,
-                "completion_tokens": 1,
-                "total_tokens": 2
-            }
-        }))
-        .unwrap();
-
-        match &response.choices[0].message.tool_calls[0].function.arguments {
-            OAIFunctionArguments::Json(arguments) => {
-                assert_eq!(arguments, &json!({"action": "list"}));
-            }
-            OAIFunctionArguments::String(_) => panic!("expected JSON tool arguments"),
-        }
-    }
 }

src/tools/scheduler_manage.rs

@@ -31,25 +31,10 @@ impl Tool for SchedulerManageTool {
     }
 
     fn description(&self) -> &str {
-        "Manage DB-backed scheduled jobs. Supports actions: list, get, put, delete, pause, resume. Jobs persist in SQLite and are executed by the scheduler runtime. When creating agent_task jobs, keep prompt/system_prompt focused on the work to perform; do not restate execution times unless the task logic truly depends on them, because the trigger already controls timing."
+        "Manage DB-backed scheduled jobs. Supports actions: list, get, put, delete, pause, resume. Jobs persist in SQLite and are executed by the scheduler runtime."
     }
 
     fn parameters_schema(&self) -> serde_json::Value {
-        let mut allowed_agents = self
-            .known_agents
-            .iter()
-            .cloned()
-            .collect::<Vec<_>>();
-        allowed_agents.sort();
-        let agent_hint = if allowed_agents.is_empty() {
-            "agent_task payload.agent may be omitted or set to 'default'.".to_string()
-        } else {
-            format!(
-                "agent_task payload.agent may be omitted, set to 'default', or use one of configured agents: {}.",
-                allowed_agents.join(", ")
-            )
-        };
-
         json!({
             "type": "object",
             "properties": {
@@ -78,7 +63,7 @@ impl Tool for SchedulerManageTool {
                 },
                 "payload": {
                     "type": "object",
-                    "description": format!("Job payload. agent_task supports prompt, agent, fresh_session, system_prompt, sender_id, metadata. For agent_task, write prompt/system_prompt as execution instructions and avoid repeating schedule phrases or execution times such as 每天9点 or 每小时 unless the task itself must reason about time. {} outbound_message expects content. internal_event expects event.", agent_hint)
+                    "description": "Job payload. agent_task supports prompt, agent, fresh_session, system_prompt, sender_id, metadata. outbound_message expects content. internal_event expects event."
                 },
                 "max_runs": {
                     "type": ["integer", "null"]
@@ -98,18 +83,6 @@ impl Tool for SchedulerManageTool {
         context: &crate::tools::ToolContext,
         args: serde_json::Value,
     ) -> anyhow::Result<ToolResult> {
-        if args.is_null() {
-            return Ok(error_result(
-                "Missing required parameters: scheduler_manage expects a JSON object like {\"action\":\"list\"}",
-            ));
-        }
-
-        if !args.is_object() {
-            return Ok(error_result(
-                "Invalid parameters: scheduler_manage expects a JSON object",
-            ));
-        }
-
         let action = match args.get("action").and_then(|value| value.as_str()) {
             Some(action) => action,
             None => return Ok(error_result("Missing required parameter: action")),
@@ -290,28 +263,7 @@ fn validate_agent_task_payload(payload: &serde_json::Value, known_agents: &HashS
         return Ok(());
     }
 
-    anyhow::bail!(unknown_agent_message(normalized, known_agents))
+    anyhow::bail!("Unknown agent '{}' for agent_task payload.agent", normalized)
-}
-
-fn unknown_agent_message(agent_name: &str, known_agents: &HashSet<String>) -> String {
-    let mut configured_agents = known_agents.iter().cloned().collect::<Vec<_>>();
-    configured_agents.sort();
-
-    let configured_hint = if configured_agents.is_empty() {
-        "No named agents are configured; use payload.agent='default' or omit payload.agent.".to_string()
-    } else {
-        format!(
-            "payload.agent must be omitted, set to 'default', or use one of configured agents: default, {}.",
-            configured_agents.join(", ")
-        )
-    };
-
-    format!(
-        "Unknown agent '{}' for agent_task payload.agent. {} '{}' is not an agent. If you mean a skill, do not put it in payload.agent.",
-        agent_name,
-        configured_hint,
-        agent_name,
-    )
 }
 
 fn validate_outbound_message_payload(payload: &serde_json::Value) -> anyhow::Result<()> {
@@ -572,66 +524,6 @@ mod tests {
 
         assert!(put_result.is_err());
         let error = put_result.err().unwrap().to_string();
-        assert!(error.contains("Unknown agent 'missing-agent' for agent_task payload.agent"));
+        assert!(error.contains("Unknown agent 'missing-agent'"));
-        assert!(error.contains("payload.agent must be omitted, set to 'default', or use one of configured agents: default, planner"));
-        assert!(error.contains("If you mean a skill, do not put it in payload.agent"));
-    }
-
-    #[tokio::test]
-    async fn test_scheduler_manage_accepts_default_agent() {
-        let store = Arc::new(SessionStore::in_memory().unwrap());
-        let tool = SchedulerManageTool::new(store, HashSet::from(["planner".to_string()]));
-
-        let put_result = tool
-            .execute(json!({
-                "action": "put",
-                "id": "agent.default_summary",
-                "kind": "agent_task",
-                "schedule": {
-                    "type": "cron",
-                    "expression": "0 9 * * *"
-                },
-                "target": {
-                    "channel": "feishu",
-                    "chat_id": "oc_demo"
-                },
-                "payload": {
-                    "prompt": "请总结今天待办",
-                    "agent": "default"
-                }
-            }))
-            .await
-            .unwrap();
-
-        assert!(put_result.success);
-    }
-
-    #[tokio::test]
-    async fn test_scheduler_manage_rejects_null_args_locally() {
-        let store = Arc::new(SessionStore::in_memory().unwrap());
-        let tool = SchedulerManageTool::new(store, HashSet::new());
-
-        let result = tool.execute(serde_json::Value::Null).await.unwrap();
-
-        assert!(!result.success);
-        assert_eq!(
-            result.error.as_deref(),
-            Some("Missing required parameters: scheduler_manage expects a JSON object like {\"action\":\"list\"}")
-        );
-    }
-
-    #[test]
-    fn test_scheduler_manage_schema_advises_against_repeating_schedule_in_agent_task_prompt() {
-        let store = Arc::new(SessionStore::in_memory().unwrap());
-        let tool = SchedulerManageTool::new(store, HashSet::new());
-
-        let schema = tool.parameters_schema();
-        let payload_description = schema["properties"]["payload"]["description"]
-            .as_str()
-            .unwrap();
-
-        assert!(payload_description.contains("avoid repeating schedule phrases or execution times"));
-        assert!(payload_description.contains("每天9点"));
-        assert!(payload_description.contains("每小时"));
     }
 }