@pheem49/mint 1.14.0 → 1.15.0

package/crates/mint-core/src/lib.rs

@@ -67,6 +67,7 @@ pub use system::docker_sandbox;
 pub use system::shell;
 pub use system::stock;
 pub use system::weather;
+pub use system::workspace;
 
 pub use agent_loop::{AgentActionFuture, AgentLoopError, parse_agent_json, run_agent_loop};
 pub use auth::{
@@ -75,8 +76,9 @@ pub use auth::{
     user_db_path,
 };
 pub use chat::{
-    ChatError, ChatMessage, ChatRequest, ChatResponse, ChatRole, ContentBlock, ToolCall, ToolSpec,
-    send_chat, send_chat_with_fallback, stream_chat, stream_chat_with_fallback,
+    ChatError, ChatMessage, ChatRequest, ChatResponse, ChatRole, ChatStreamEvent, ContentBlock,
+    ToolCall, ToolSpec, send_chat, send_chat_with_fallback, stream_chat, stream_chat_events,
+    stream_chat_events_with_fallback, stream_chat_with_fallback,
 };
 
 pub use auto_shorts::{
@@ -84,9 +86,9 @@ pub use auto_shorts::{
     MakeShortsResult, ShortClipInfo, ai_edit_video, make_shorts,
 };
 pub use browser::{
-    BrowserTab, click, get_element_coordinates, is_browser_running, key_press, list_tabs,
-    mouse_click, mouse_move, navigate, read_page_text, screenshot, spawn_automation_browser,
-    type_text, type_text_native,
+    BrowserTab, click, enable_browser_tools, get_element_coordinates, is_browser_running,
+    key_press, list_tabs, mouse_click, mouse_move, navigate, read_page_text, screenshot,
+    spawn_automation_browser, spawn_automation_browser_with_url, type_text, type_text_native,
 };
 pub use calculation::{CalculationError, CalculationReport, calculate};
 pub use code_tools::{
@@ -113,9 +115,11 @@ pub use gemini_live::{
     GeminiLiveEvent, GeminiLiveHandle, start_session as start_gemini_live_session,
 };
 pub use git::{
-    Checkpoint, commit_task_changes, create_checkpoint, create_task_branch,
-    generate_commit_message, get_head_hash, is_git_repo, list_checkpoints, record_checkpoint,
-    restore_file, rollback_checkpoint, rollback_task_changes, rollback_to_step, undo_rollback,
+    BranchChange, BranchChangeOutcome, BranchInfo, Checkpoint, DiffHunk, WorkspaceFileChange,
+    change_branch, checkout_remote_branch, commit_task_changes, create_branch, create_checkpoint,
+    create_task_branch, generate_commit_message, get_head_hash, is_git_repo, list_checkpoints,
+    read_branch_info, read_graph, read_workspace_git_diff, record_checkpoint, restore_file,
+    rollback_checkpoint, rollback_task_changes, rollback_to_step, switch_branch, undo_rollback,
 };
 pub use hooks::{
     HookEntry, HookError, HookEvent, PreHookOutcome, add_hook, clear_hooks, list_hooks,
@@ -129,8 +133,10 @@ pub use knowledge::{
     KnowledgeError, KnowledgeHit, KnowledgeSource, KnowledgeStore, extract_document_text,
 };
 pub use linked_folders::{
-    LinkedFolder, LinkedFolderDraft, LinkedFolderError, add_linked_folder,
-    configured_linked_folders, list_linked_folders, remove_linked_folder, spawn_linked_folder_note,
+    LinkedFolder, LinkedFolderDraft, LinkedFolderError, LinkedFolderNote, LinkedFolderStatus,
+    add_linked_folder, configured_linked_folders, linked_folder_status, list_linked_folder_notes,
+    list_linked_folders, read_linked_folder_note, refresh_linked_folder, remove_linked_folder,
+    save_linked_folder_note, spawn_linked_folder_note,
 };
 pub use mcp::{
     McpError, McpRegistryArgInput, McpRegistryEntry, McpRegistryEnvVar, McpServer, add_mcp_server,
@@ -145,8 +151,9 @@ pub use mcp::{
     upsert_server_in,
 };
 pub use memory::{
-    CHAT_CLI_ID, ChatSession, DEFAULT_CONVERSATION_ID, Fact, InteractionMemory, LearnedSkill,
-    MemoryError, MemoryStore, WorkspaceSession, memory_path, scoped_chat_id, subagent_name,
+    CHAT_CLI_ID, ChatSession, ConversationChanges, ConversationSnapshot, DEFAULT_CONVERSATION_ID,
+    Fact, InteractionMemory, LearnedSkill, MemoryError, MemoryStore, WorkspaceSession,
+    generate_cli_session_id, is_cli_chat_id, memory_path, scoped_chat_id, subagent_name,
 };
 pub use mic_transcribe::{
     MicRecordingHandle, MicTranscribeError, start_recording, stop_recording, transcribe_recording,
@@ -154,8 +161,9 @@ pub use mic_transcribe::{
 pub use orchestration::{
     ActivePlan, AgentApproval, AgentProgress, AgentResult, ApprovalOutcome, AskUserOption,
     MCP_ALLOW_ALL_SENTINEL, OrchestrationError, PlanTaskItem, RunTelemetrySummary,
-    ToolExecutionRecord, orchestrate_agent_loop, orchestrate_chat, orchestrate_chat_stream,
-    orchestrate_chat_stream_with_fallback, orchestrate_chat_with_fallback,
+    ToolExecutionRecord, compact_agent_progress, orchestrate_agent_loop, orchestrate_chat,
+    orchestrate_chat_stream, orchestrate_chat_stream_with_fallback, orchestrate_chat_with_fallback,
+    with_turn_start_listener,
 };
 pub use pictures::{
     PictureEntry, PictureError, delete_saved_picture, list_saved_pictures, parse_data_uri,

package/crates/mint-core/src/live_sync.rs

@@ -37,7 +37,10 @@ const PREVIEW_CHARS: usize = 60;
 
 static LIVE_SYNC_NOTICES: LazyLock<Mutex<Vec<String>>> = LazyLock::new(|| Mutex::new(Vec::new()));
 
-/// Highest `interaction_memories.id` (chat_id = "cli") this process already
+static ACTIVE_CHAT_ID: LazyLock<std::sync::RwLock<String>> =
+    LazyLock::new(|| std::sync::RwLock::new(String::new()));
+
+/// Highest `interaction_memories.id` this process already
 /// accounts for — either because it wrote the row itself (see
 /// [`note_own_interaction`]) or because a previous poll tick already
 /// surfaced it. `-1` until `start_live_sync_poller`'s first tick establishes
@@ -53,6 +56,15 @@ pub fn take_live_sync_notices() -> Vec<String> {
     std::mem::take(&mut *LIVE_SYNC_NOTICES.lock().unwrap())
 }
 
+/// Dynamically updates the active chat_id being polled by the live sync loop
+/// (e.g. when resuming or switching sessions via `/resume`) and re-seeds the watermark.
+pub fn update_live_sync_chat_id(new_chat_id: &str) {
+    if let Ok(mut lock) = ACTIVE_CHAT_ID.write() {
+        *lock = new_chat_id.to_string();
+    }
+    initialize_watermark(new_chat_id);
+}
+
 /// Raise the watermark to at least `id`. Called by `mint-cli` right after it
 /// finishes writing its own turn to chat_id="cli", so the next poll tick
 /// doesn't mistake the user's own just-sent message for one that arrived
@@ -82,30 +94,33 @@ pub fn note_own_interaction(id: i64) {
 /// `mint gateway` or any other headless path that has no prompt loop to
 /// drain notices into.
 pub fn start_live_sync_poller(chat_id: String) {
+    update_live_sync_chat_id(&chat_id);
     if tokio::runtime::Handle::try_current().is_ok() {
-        tokio::spawn(restarting_loop(chat_id));
+        tokio::spawn(restarting_loop());
     } else {
         std::thread::spawn(move || {
             if let Ok(runtime) = tokio::runtime::Runtime::new() {
-                runtime.block_on(restarting_loop(chat_id));
+                runtime.block_on(restarting_loop());
             }
         });
     }
 }
 
-async fn restarting_loop(chat_id: String) {
-    initialize_watermark(&chat_id).await;
+async fn restarting_loop() {
     loop {
-        tick(&chat_id).await;
+        let active_id = ACTIVE_CHAT_ID.read().map(|l| l.clone()).unwrap_or_default();
+        if !active_id.is_empty() {
+            tick(&active_id).await;
+        }
         tokio::time::sleep(POLL_INTERVAL).await;
     }
 }
 
 /// Seeds `LAST_SEEN_ID` from whatever is already in the DB at startup, so
 /// the CLI's own prior history never gets replayed as a "live" notice.
-async fn initialize_watermark(chat_id: &str) {
+fn initialize_watermark(chat_id: &str) {
     if let Ok(memory) = MemoryStore::open_default()
-        && let Ok(latest) = memory.recent_interactions_for_chat(chat_id, 1)
+        && let Ok(latest) = memory.recent_completed_interactions_for_chat(chat_id, 1)
     {
         let start_id = latest.first().map(|row| row.id).unwrap_or(0);
         LAST_SEEN_ID.store(start_id, Ordering::SeqCst);
@@ -121,7 +136,7 @@ async fn tick(chat_id: &str) {
     let Ok(memory) = MemoryStore::open_default() else {
         return;
     };
-    let Ok(rows) = memory.recent_interactions_for_chat(chat_id, POLL_BATCH) else {
+    let Ok(rows) = memory.recent_completed_interactions_for_chat(chat_id, POLL_BATCH) else {
         return;
     };
     let last_seen = LAST_SEEN_ID.load(Ordering::SeqCst);
@@ -141,6 +156,10 @@ async fn tick(chat_id: &str) {
             preview(&row.ai_text)
         ));
     }
+    if queue.len() > 100 {
+        let excess = queue.len() - 100;
+        queue.drain(..excess);
+    }
     drop(queue);
     note_own_interaction(max_id);
 }

package/crates/mint-core/src/media/auto_shorts.rs

@@ -297,6 +297,7 @@ async fn detect_highlights(
             messages: None,
             tools: None,
             temperature: config.temperature,
+            ..Default::default()
         };
 
         if let Ok((res, _)) = crate::chat::send_chat_with_fallback(config, &chat_req).await {

package/crates/mint-core/src/media/gemini_live.rs

@@ -87,7 +87,7 @@ where
 {
     let (audio_tx, audio_rx) = mpsc::unbounded_channel::<Vec<u8>>();
 
-    tokio::spawn(async move {
+    spawn_live_session(async move {
         let mut audio_rx = audio_rx;
         if let Err(message) = run_session(
             &config,
@@ -107,6 +107,17 @@ where
     GeminiLiveHandle { audio_tx }
 }
 
+/// Keep browser targeting, evidence, and recovery state for the entire voice
+/// task, including successive tool-call batches and spoken turns. Dropping the
+/// task releases its tab leases; the next voice session starts independently.
+pub(crate) fn spawn_live_session<F>(future: F) -> tokio::task::JoinHandle<F::Output>
+where
+    F: std::future::Future + Send + 'static,
+    F::Output: Send + 'static,
+{
+    tokio::spawn(crate::browser::run_session(future))
+}
+
 fn resolve_api_key(config: &MintConfig) -> String {
     if config.api_key.trim().is_empty() {
         std::env::var("GEMINI_API_KEY").unwrap_or_default()

package/crates/mint-core/src/media/mic_transcribe.rs

@@ -126,6 +126,7 @@ pub async fn transcribe_recording(
         messages: None,
         tools: None,
         temperature: config.temperature,
+        ..Default::default()
     };
 
     // Deliberately `send_chat`, not `send_chat_with_fallback` — the fallback path

package/crates/mint-core/src/media/subtitle.rs

@@ -269,6 +269,7 @@ pub async fn translate_subtitles(
             messages: None,
             tools: None,
             temperature: config.temperature,
+            ..Default::default()
         };
 
         match crate::chat::send_chat_with_fallback(config, &chat_req).await {

package/crates/mint-core/src/orchestration/context_render.rs

@@ -96,6 +96,7 @@ pub(super) async fn compact_native_messages(
             messages: None,
             tools: None,
             temperature: config.temperature,
+            ..Default::default()
         },
     )
     .await?;

package/crates/mint-core/src/orchestration/memory_skill.rs

@@ -181,7 +181,9 @@ pub(crate) fn append_memory_context(
         *system_prompt = format!("{}\n\nRemembered facts:\n{}", system_prompt.trim(), facts);
     }
 
-    if let Ok(mut interactions) = memory.recent_interactions_for_chat(chat_id, CONTEXT_LIMIT) {
+    if let Ok(mut interactions) =
+        memory.recent_completed_interactions_for_chat(chat_id, CONTEXT_LIMIT)
+    {
         interactions.reverse();
         let transcript = interactions
             .into_iter()
@@ -318,6 +320,7 @@ Worth saving:
         messages: None,
         tools: None,
         temperature: config.temperature,
+        ..Default::default()
     };
 
     let response = send_chat(config, &request).await?;
@@ -546,6 +549,7 @@ Example response:
         messages: None,
         tools: None,
         temperature: config.temperature,
+        ..Default::default()
     };
 
     // Send the chat request to LLM
@@ -905,6 +909,7 @@ Emit at most {MAX_FACT_OPS_PER_TURN} ops."#
         messages: None,
         tools: None,
         temperature: config.temperature,
+        ..Default::default()
     };
 
     let response = send_chat(config, &request).await?;