Platform Extension MOIM (Minus One Info Message)

crates/goose-cli/Cargo.toml

@@ -69,3 +69,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/commands/acp.rs

@@ -871,7 +871,7 @@ print(\"hello, world\")
             format_tool_name("platform__manage_extensions"),
             "Platform: Manage Extensions"
         );
-        assert_eq!(format_tool_name("todo__read"), "Todo: Read");
+        assert_eq!(format_tool_name("todo__write"), "Todo: Write");
     }
 
     #[test]

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

@@ -141,6 +141,32 @@ where
     use goose::config::ExtensionConfig;
     use tokio::sync::Mutex;
 
+    let original_moim = goose::config::Config::global()
+        .get_param::<bool>("GOOSE_MOIM_ENABLED")
+        .ok();
+    goose::config::Config::global()
+        .set_param("GOOSE_MOIM_ENABLED", false)
+        .ok();
+
+    struct MoimGuard(Option<bool>);
+    impl Drop for MoimGuard {
+        fn drop(&mut self) {
+            match self.0 {
+                Some(val) => {
+                    goose::config::Config::global()
+                        .set_param("GOOSE_MOIM_ENABLED", val)
+                        .ok();
+                }
+                None => {
+                    goose::config::Config::global()
+                        .delete("GOOSE_MOIM_ENABLED")
+                        .ok();
+                }
+            }
+        }
+    }
+    let _restore_guard = MoimGuard(original_moim);
+
     if let Ok(path) = dotenv() {
         println!("Loaded environment from {:?}", path);
     }

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

@@ -7,8 +7,10 @@ mod tests {
     use crate::scenario_tests::mock_client::WEATHER_TYPE;
     use crate::scenario_tests::scenario_runner::run_scenario;
     use anyhow::Result;
+    use serial_test::serial;
 
     #[tokio::test]
+    #[serial]
     async fn test_what_is_your_name() -> Result<()> {
         run_scenario(
             "what_is_your_name",
@@ -28,6 +30,7 @@ mod tests {
     }
 
     #[tokio::test]
+    #[serial]
     async fn test_weather_tool() -> Result<()> {
         // Google tells me it only knows about the weather in the US, so we skip it.
         run_scenario(
@@ -58,6 +61,7 @@ mod tests {
     }
 
     #[tokio::test]
+    #[serial]
     async fn test_image_analysis() -> Result<()> {
         // 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.

crates/goose-cli/src/session/output.rs

@@ -261,7 +261,7 @@ fn render_tool_request(req: &ToolRequest, theme: Theme, debug: bool) {
             "developer__text_editor" => render_text_editor_request(call, debug),
             "developer__shell" => render_shell_request(call, debug),
             "dynamic_task__create_task" => render_dynamic_task_request(call, debug),
-            "todo__read" | "todo__write" => render_todo_request(call, debug),
+            "todo__write" => render_todo_request(call, debug),
             _ => render_default_request(call, debug),
         },
         Err(e) => print_markdown(&e.to_string(), theme),
@@ -505,13 +505,9 @@ fn render_dynamic_task_request(call: &CallToolRequestParam, debug: bool) {
 fn render_todo_request(call: &CallToolRequestParam, _debug: bool) {
     print_tool_header(call);
 
-    // For todo tools, always show the full content without redaction
     if let Some(args) = &call.arguments {
         if let Some(Value::String(content)) = args.get("content") {
             println!("{}: {}", style("content").dim(), style(content).green());
-        } else {
-            // For todo__read, there are no arguments
-            // Just print an empty line for consistency
         }
     }
     println!();

crates/goose/src/agents/agent.rs

@@ -946,10 +946,15 @@ impl Agent {
                     }
                 }
 
+                let conversation_with_moim = super::moim::inject_moim(
+                    conversation.clone(),
+                    &self.extension_manager,
+                ).await;
+
                 let mut stream = Self::stream_response_from_provider(
                     self.provider().await?,
                     &system_prompt,
-                    conversation.messages(),
+                    conversation_with_moim.messages(),
                     &tools,
                     &toolshim_tools,
                 ).await?;

crates/goose/src/agents/extension_manager.rs

@@ -1163,6 +1163,28 @@ impl ExtensionManager {
             .get(&name.into())
             .map(|ext| ext.get_client())
     }
+
+    pub async fn collect_moim(&self) -> Option<String> {
+        let timestamp = chrono::Local::now().format("%Y-%m-%d %H:%M:%S").to_string();
+        let mut content = format!("<info-msg>\nDatetime: {}\n", timestamp);
+
+        let extensions = self.extensions.lock().await;
+        for (name, extension) in extensions.iter() {
+            if let ExtensionConfig::Platform { .. } = &extension.config {
+                let client = extension.get_client();
+                let client_guard = client.lock().await;
+                if let Some(moim_content) = client_guard.get_moim().await {
+                    tracing::debug!("MOIM content from {}: {} chars", name, moim_content.len());
+                    content.push('\n');
+                    content.push_str(&moim_content);
+                }
+            }
+        }
+
+        content.push_str("\n</info-msg>");
+
+        Some(content)
+    }
 }
 
 #[cfg(test)]

crates/goose/src/agents/mcp_client.rs

@@ -76,6 +76,10 @@ pub trait McpClientTrait: Send + Sync {
     async fn subscribe(&self) -> mpsc::Receiver<ServerNotification>;
 
     fn get_info(&self) -> Option<&InitializeResult>;
+
+    async fn get_moim(&self) -> Option<String> {
+        None
+    }
 }
 
 pub struct GooseClient {

crates/goose/src/agents/mod.rs

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

crates/goose/src/agents/moim.rs

@@ -0,0 +1,147 @@
+use crate::agents::extension_manager::ExtensionManager;
+use crate::conversation::message::Message;
+use crate::conversation::{fix_conversation, Conversation};
+use rmcp::model::Role;
+
+pub async fn inject_moim(
+    conversation: Conversation,
+    extension_manager: &ExtensionManager,
+) -> Conversation {
+    let config = crate::config::Config::global();
+    if !config.get_param("GOOSE_MOIM_ENABLED").unwrap_or(true) {
+        return conversation;
+    }
+
+    if let Some(moim) = extension_manager.collect_moim().await {
+        let mut messages = conversation.messages().clone();
+        let idx = messages
+            .iter()
+            .rposition(|m| m.role == Role::Assistant)
+            .unwrap_or(messages.len());
+        messages.insert(idx, Message::user().with_text(moim));
+
+        let (fixed, _issues) = fix_conversation(Conversation::new_unvalidated(messages));
+        return fixed;
+    }
+    conversation
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use rmcp::model::CallToolRequestParam;
+
+    #[tokio::test]
+    async fn test_moim_injection_before_assistant() {
+        let em = ExtensionManager::new_without_provider();
+
+        let conv = Conversation::new_unvalidated(vec![
+            Message::user().with_text("Hello"),
+            Message::assistant().with_text("Hi"),
+            Message::user().with_text("Bye"),
+            Message::assistant().with_text("Goodbye"),
+        ]);
+        let result = inject_moim(conv, &em).await;
+        let msgs = result.messages();
+
+        // MOIM gets inserted before last assistant, then merged with "Bye",
+        // but then the trailing assistant gets removed by fix_conversation
+        assert_eq!(msgs.len(), 3);
+        assert_eq!(msgs[0].content[0].as_text().unwrap(), "Hello");
+        assert_eq!(msgs[1].content[0].as_text().unwrap(), "Hi");
+
+        // The third message should be the merged "Bye" + MOIM
+        let merged_content = msgs[2]
+            .content
+            .iter()
+            .filter_map(|c| c.as_text())
+            .collect::<Vec<_>>()
+            .join("");
+        assert!(merged_content.contains("Bye"));
+        assert!(merged_content.contains("<info-msg>"));
+    }
+
+    #[tokio::test]
+    async fn test_moim_injection_no_assistant() {
+        let em = ExtensionManager::new_without_provider();
+
+        let conv = Conversation::new_unvalidated(vec![Message::user().with_text("Hello")]);
+        let result = inject_moim(conv, &em).await;
+
+        // MOIM gets merged with the existing user message
+        assert_eq!(result.messages().len(), 1);
+
+        let merged_content = result.messages()[0]
+            .content
+            .iter()
+            .filter_map(|c| c.as_text())
+            .collect::<Vec<_>>()
+            .join("");
+        assert!(merged_content.contains("Hello"));
+        assert!(merged_content.contains("<info-msg>"));
+    }
+
+    #[tokio::test]
+    async fn test_moim_with_tool_calls() {
+        let em = ExtensionManager::new_without_provider();
+
+        let conv = Conversation::new_unvalidated(vec![
+            Message::user().with_text("Search for something"),
+            Message::assistant()
+                .with_text("I'll search for you")
+                .with_tool_request(
+                    "search_1",
+                    Ok(CallToolRequestParam {
+                        name: "search".into(),
+                        arguments: None,
+                    }),
+                ),
+            Message::user().with_tool_response("search_1", Ok(vec![])),
+            Message::assistant().with_text("Found results"),
+        ]);
+
+        let result = inject_moim(conv, &em).await;
+        let msgs = result.messages();
+
+        // MOIM gets inserted as separate message, trailing assistant removed
+        assert_eq!(msgs.len(), 4);
+
+        let tool_request_idx = msgs
+            .iter()
+            .position(|m| {
+                m.content.iter().any(|c| {
+                    matches!(
+                        c,
+                        crate::conversation::message::MessageContent::ToolRequest(_)
+                    )
+                })
+            })
+            .unwrap();
+
+        let tool_response_idx = msgs
+            .iter()
+            .position(|m| {
+                m.content.iter().any(|c| {
+                    matches!(
+                        c,
+                        crate::conversation::message::MessageContent::ToolResponse(_)
+                    )
+                })
+            })
+            .unwrap();
+
+        // MOIM should be in a separate message after tool response
+        let moim_msg = &msgs[3];
+        let has_moim = moim_msg
+            .content
+            .iter()
+            .any(|c| c.as_text().map_or(false, |t| t.contains("<info-msg>")));
+
+        assert!(has_moim, "MOIM should be in the last message");
+        assert_eq!(
+            tool_response_idx,
+            tool_request_idx + 1,
+            "Tool response should immediately follow tool request"
+        );
+    }
+}

crates/goose/src/agents/snapshots/goose__agents__prompt_manager__tests__basic.snap

@@ -5,8 +5,6 @@ expression: system_prompt
 You are a general-purpose AI agent called goose, created by Block, the parent company of Square, CashApp, and Tidal.
 goose is being developed as an open-source software project.
 
-The current date is 1970-01-01 00:00:00.
-
 goose uses LLM providers with tool calling capability. You can be used with different language models (gpt-4o,
 claude-sonnet-4, o1, llama-3.2, deepseek-r1, etc).
 These models have varying knowledge cut-off dates depending on when they were trained, but typically it's between 5-10

crates/goose/src/agents/snapshots/goose__agents__prompt_manager__tests__one_extension.snap

@@ -5,8 +5,6 @@ expression: system_prompt
 You are a general-purpose AI agent called goose, created by Block, the parent company of Square, CashApp, and Tidal.
 goose is being developed as an open-source software project.
 
-The current date is 1970-01-01 00:00:00.
-
 goose uses LLM providers with tool calling capability. You can be used with different language models (gpt-4o,
 claude-sonnet-4, o1, llama-3.2, deepseek-r1, etc).
 These models have varying knowledge cut-off dates depending on when they were trained, but typically it's between 5-10

crates/goose/src/agents/snapshots/goose__agents__prompt_manager__tests__typical_setup.snap

@@ -5,8 +5,6 @@ expression: system_prompt
 You are a general-purpose AI agent called goose, created by Block, the parent company of Square, CashApp, and Tidal.
 goose is being developed as an open-source software project.
 
-The current date is 1970-01-01 00:00:00.
-
 goose uses LLM providers with tool calling capability. You can be used with different language models (gpt-4o,
 claude-sonnet-4, o1, llama-3.2, deepseek-r1, etc).
 These models have varying knowledge cut-off dates depending on when they were trained, but typically it's between 5-10