Add MOIM (Minus One Info Message) for automatic context injection (TODO list and current time)

crates/goose-cli/Cargo.toml

@@ -70,3 +70,4 @@ tempfile = "3"
 temp-env = { version = "0.3.6", features = ["async_closure"] }
 test-case = "3.3"
 tokio = { version = "1.43", features = ["rt", "macros"] }
+serial_test = "3.2.0"

crates/goose-cli/src/scenario_tests/scenarios.rs

@@ -8,10 +8,13 @@ mod tests {
     use crate::scenario_tests::scenario_runner::run_scenario;
     use anyhow::Result;
     use goose::conversation::message::Message;
+    use serial_test::serial;
 
     #[tokio::test]
+    #[serial]
     async fn test_what_is_your_name() -> Result<()> {
-        run_scenario(
+        std::env::set_var("GOOSE_MOIM_ENABLED", "false");
+        let result = run_scenario(
             "what_is_your_name",
             text("what is your name"),
             None,
@@ -25,13 +28,17 @@ mod tests {
                 Ok(())
             },
         )
-        .await
+        .await;
+        std::env::remove_var("GOOSE_MOIM_ENABLED");
+        result
     }
 
     #[tokio::test]
+    #[serial]
     async fn test_weather_tool() -> Result<()> {
+        std::env::set_var("GOOSE_MOIM_ENABLED", "false");
         // Google tells me it only knows about the weather in the US, so we skip it.
-        run_scenario(
+        let result = run_scenario(
             "weather_tool",
             text("tell me what the weather is in Berlin, Germany"),
             Some(&["Google"]),
@@ -55,14 +62,18 @@ mod tests {
                 Ok(())
             },
         )
-        .await
+        .await;
+        std::env::remove_var("GOOSE_MOIM_ENABLED");
+        result
     }
 
     #[tokio::test]
+    #[serial]
     async fn test_image_analysis() -> Result<()> {
+        std::env::set_var("GOOSE_MOIM_ENABLED", "false");
         // Google says it doesn't know about images, the other providers complain about
         // the image format, so we only run this for OpenAI and Anthropic.
-        run_scenario(
+        let result = run_scenario(
             "image_analysis",
             image("What do you see in this image?", "test_image"),
             Some(&["Google", "azure_openai", "groq"]),
@@ -73,12 +84,16 @@ mod tests {
                 Ok(())
             },
         )
-        .await
+        .await;
+        std::env::remove_var("GOOSE_MOIM_ENABLED");
+        result
     }
 
     #[tokio::test]
+    #[serial]
     async fn test_context_length_exceeded_error() -> Result<()> {
-        run_scenario(
+        std::env::set_var("GOOSE_MOIM_ENABLED", "false");
+        let result = run_scenario(
             "context_length_exceeded",
             Box::new(|provider| {
                 let model_config = provider.get_model_config();
@@ -100,6 +115,8 @@ mod tests {
                 Ok(())
             },
         )
-        .await
+        .await;
+        std::env::remove_var("GOOSE_MOIM_ENABLED");
+        result
     }
 }

crates/goose/src/agents/agent.rs

@@ -60,9 +60,7 @@ use super::model_selector::autopilot::AutoPilot;
 use super::platform_tools;
 use super::tool_execution::{ToolCallResult, CHAT_MODE_TOOL_SKIPPED_RESPONSE, DECLINED_RESPONSE};
 use crate::agents::subagent_task_config::TaskConfig;
-use crate::agents::todo_tools::{
-    todo_read_tool, todo_write_tool, TODO_READ_TOOL_NAME, TODO_WRITE_TOOL_NAME,
-};
+use crate::agents::todo_tools::{todo_write_tool, TODO_WRITE_TOOL_NAME};
 use crate::conversation::message::{Message, ToolRequest};
 use crate::session::extension_data::ExtensionState;
 use crate::session::{extension_data, SessionManager};
@@ -504,22 +502,6 @@ impl Agent {
                 "Frontend tool execution required".to_string(),
                 None,
             )))
-        } else if tool_call.name == TODO_READ_TOOL_NAME {
-            // Handle task planner read tool
-            let todo_content = if let Some(session_config) = session {
-                SessionManager::get_session(&session_config.id, false)
-                    .await
-                    .ok()
-                    .and_then(|metadata| {
-                        extension_data::TodoState::from_extension_data(&metadata.extension_data)
-                            .map(|state| state.content)
-                    })
-                    .unwrap_or_default()
-            } else {
-                String::new()
-            };
-
-            ToolCallResult::from(Ok(vec![Content::text(todo_content)]))
         } else if tool_call.name == TODO_WRITE_TOOL_NAME {
             // Handle task planner write tool
             let content = tool_call
@@ -816,8 +798,8 @@ impl Agent {
                 platform_tools::manage_schedule_tool(),
             ]);
 
-            // Add task planner tools
-            prefixed_tools.extend([todo_read_tool(), todo_write_tool()]);
+            // Add task planner tool (write only, read happens via MOIM)
+            prefixed_tools.push(todo_write_tool());
 
             // Dynamic task tool
             prefixed_tools.push(create_dynamic_task_tool());
@@ -1105,6 +1087,7 @@ impl Agent {
                     conversation.messages(),
                     &tools,
                     &toolshim_tools,
+                    &session,
                 ).await?;
 
                 let mut no_tools_called = true;
@@ -1741,13 +1724,11 @@ mod tests {
     async fn test_todo_tools_integration() -> Result<()> {
         let agent = Agent::new();
 
-        // Test that task planner tools are listed
+        // Test that task planner tool is listed (write only, read happens via MOIM)
         let tools = agent.list_tools(None).await;
 
-        let todo_read = tools.iter().find(|tool| tool.name == TODO_READ_TOOL_NAME);
         let todo_write = tools.iter().find(|tool| tool.name == TODO_WRITE_TOOL_NAME);
 
-        assert!(todo_read.is_some(), "TODO read tool should be present");
         assert!(todo_write.is_some(), "TODO write tool should be present");
         Ok(())
     }

crates/goose/src/agents/mod.rs

@@ -6,6 +6,7 @@ pub mod extension_manager;
 pub mod final_output_tool;
 mod large_response_handler;
 pub mod model_selector;
+pub mod moim;
 pub mod platform_tools;
 pub mod prompt_manager;
 pub mod recipe_tools;

crates/goose/src/agents/moim.rs

@@ -0,0 +1,94 @@
+use crate::agents::types::SessionConfig;
+use crate::conversation::message::Message;
+use crate::conversation::Conversation;
+use crate::session::extension_data::{ExtensionState, TodoState};
+use crate::session::SessionManager;
+use chrono::Local;
+
+async fn build_moim_content(session: &Option<SessionConfig>) -> Option<String> {
+    let timestamp = Local::now().format("%Y-%m-%d %H:%M:%S").to_string();
+    let mut content = format!("Current date and time: {}\n", timestamp);
+
+    if let Some(todo_content) = get_todo_context(session).await {
+        content.push_str("\nCurrent tasks and notes:\n");
+        content.push_str(&todo_content);
+        content.push('\n');
+    }
+
+    Some(content)
+}
+
+/// Find a safe insertion point for MOIM.
+///
+/// We want to insert as close to the end as possible, but we must avoid
+/// breaking tool call/response pairs. We check if inserting at a position
+/// would separate a tool call from its response.
+pub fn find_safe_insertion_point(messages: &[Message]) -> usize {
+    if messages.is_empty() {
+        return 0;
+    }
+
+    // Default to inserting before the last message
+    let last_pos = messages.len() - 1;
+
+    // Check if inserting at last_pos would break a tool pair
+    if last_pos > 0 {
+        let prev_msg = &messages[last_pos - 1];
+        let curr_msg = &messages[last_pos];
+
+        // If previous message has tool calls and current has matching responses,
+        // we can't insert between them
+        if prev_msg.is_tool_call() && curr_msg.is_tool_response() {
+            // Find the next best position (before the tool call)
+            return last_pos.saturating_sub(1);
+        }
+    }
+
+    last_pos
+}
+
+pub async fn inject_moim_if_enabled(
+    messages_for_provider: Conversation,
+    session: &Option<SessionConfig>,
+) -> Conversation {
+    // Check if MOIM is enabled
+    let moim_enabled = crate::config::Config::global()
+        .get_param::<bool>("goose_moim_enabled")
+        .unwrap_or(true);
+
+    if !moim_enabled {
+        return messages_for_provider;
+    }
+
+    if let Some(moim_content) = build_moim_content(session).await {
+        let mut msgs = messages_for_provider.messages().to_vec();
+        let moim_msg = Message::user().with_text(moim_content);
+
+        if msgs.is_empty() {
+            // If conversation is empty, just add the MOIM
+            msgs.push(moim_msg);
+        } else {
+            // Find a safe position that won't break tool call/response pairs
+            let insert_pos = find_safe_insertion_point(&msgs);
+            msgs.insert(insert_pos, moim_msg);
+        }
+
+        Conversation::new_unvalidated(msgs)
+    } else {
+        messages_for_provider
+    }
+}
+
+async fn get_todo_context(session: &Option<SessionConfig>) -> Option<String> {
+    let session_config = session.as_ref()?;
+
+    match SessionManager::get_session(&session_config.id, false).await {
+        Ok(session_data) => TodoState::from_extension_data(&session_data.extension_data)
+            .map(|state| state.content)
+            .filter(|content| !content.trim().is_empty()),
+        Err(e) => {
+            tracing::debug!("Could not read session for MOIM: {}", e);
+            None
+        }
+    }
+}

crates/goose/src/agents/prompt_manager.rs

@@ -1,4 +1,3 @@
-use chrono::Utc;
 use serde_json::Value;
 use std::collections::HashMap;
 
@@ -10,7 +9,6 @@ use crate::{config::Config, prompt_template, utils::sanitize_unicode_tags};
 pub struct PromptManager {
     system_prompt_override: Option<String>,
     system_prompt_extras: Vec<String>,
-    current_date_timestamp: String,
 }
 
 impl Default for PromptManager {
@@ -24,8 +22,6 @@ impl PromptManager {
         PromptManager {
             system_prompt_override: None,
             system_prompt_extras: Vec::new(),
-            // Use the fixed current date time so that prompt cache can be used.
-            current_date_timestamp: Utc::now().format("%Y-%m-%d %H:%M:%S").to_string(),
         }
     }
 
@@ -102,11 +98,6 @@ impl PromptManager {
             );
         }
 
-        context.insert(
-            "current_date_time",
-            Value::String(self.current_date_timestamp.clone()),
-        );
-
         // Add the suggestion about disabling extensions if flag is true
         context.insert(
             "suggest_disable",

crates/goose/src/agents/reply_parts.rs

@@ -134,6 +134,7 @@ impl Agent {
         messages: &[Message],
         tools: &[Tool],
         toolshim_tools: &[Tool],
+        session: &Option<crate::agents::types::SessionConfig>,
     ) -> Result<MessageStream, ProviderError> {
         let config = provider.get_model_config();
 
@@ -144,6 +145,10 @@ impl Agent {
             Conversation::new_unvalidated(messages.to_vec())
         };
 
+        // Inject MOIM (timestamp + TODO content) if enabled
+        let messages_for_provider =
+            super::moim::inject_moim_if_enabled(messages_for_provider, session).await;
+
         // Clone owned data to move into the async stream
         let system_prompt = system_prompt.to_owned();
         let tools = tools.to_owned();