milan/own_assist
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

update dependencies

Browse Source
This commit is contained in:
milan
2026-07-19 11:16:10 +02:00
parent 78ba2b7b3d
commit 06ef1ba2dd
11 changed files with 478 additions and 654 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Cargo.lock
Generated
+399 -601
View File
File diff suppressed because it is too large Load Diff
Cargo.toml
+1
View File
@@ -1,2 +1,3 @@
[workspace]
members = ["cli", "common", "mcp_server_collection", "own_mcp"]
resolver = "3"
cli/Cargo.toml
+2 -2
View File
@@ -7,7 +7,7 @@ license = "GPL-3.0"
[dependencies]
ollama-rs = { version = "0.3.4", features = ["macros", "headers"] }
tokio = { version = "1.50.0", features = ["rt", "rt-multi-thread", "macros", "io-std"] }
rmcp = { version = "1.3.0", features = ["client"] }
rmcp = { version = "2.2.0", features = ["client"] }
log = { version = "0.4.29" }
serde = { version = "1.0.228", features = ["derive"] }
url = "2.5.8"
@@ -20,7 +20,7 @@ indicatif = "0.18.4"
console = "0.16.3"
clap = { version = "4.6.0", features = ["derive"] }
base64 = "0.22.1"
cpal = "0.17.3"
cpal = "0.18.1"
rodio = "0.22.2"
tokio-util = { version = "0.7.18", optional = true }
cli/src/main.rs
+8 -5
View File
@@ -10,11 +10,11 @@ use crate::model::create_model_from_config;
use base64::Engine;
use clap::Parser;
use cpal::traits::HostTrait;
use mcp_server_collection::McpServerError;
use own_assist_common::{exit_msg, init_tracing_subscriber};
use own_mcp::AgentChat;
use tokio::task::JoinHandle;
use tokio_util::sync::CancellationToken;
use mcp_server_collection::McpServerError;
/// partial mcp client with cli and voice interaction
#[derive(Parser, Debug)]
@@ -68,7 +68,9 @@ async fn chat_loop(mut human_interface: impl HumanInterface, mut agent_chat: Age
}
#[cfg(feature = "built-in-mcp-collection")]
async fn launch_mcp_server(config: mcp_server_collection::config::Config) -> Result<(CancellationToken, JoinHandle<std::io::Result<()>>), McpServerError> {
async fn launch_mcp_server(
config: mcp_server_collection::config::Config,
) -> Result<(CancellationToken, JoinHandle<std::io::Result<()>>), McpServerError> {
let handle = mcp_server_collection::serve_in_background(config).await?;
Ok(handle)
@@ -85,14 +87,15 @@ async fn main() {
init_tracing_subscriber();
#[cfg(feature = "built-in-mcp-collection")]
let mcp_config = mcp_server_collection::config::Config::from_file().inspect_err(exit_msg!("error loading server.toml"))
let mcp_config = mcp_server_collection::config::Config::from_file()
.inspect_err(exit_msg!("error loading server.toml"))
.unwrap();
#[cfg(feature = "built-in-mcp-collection")]
let (mcp_server_ct, mcp_server_task) = launch_mcp_server(mcp_config).await
let (mcp_server_ct, mcp_server_task) = launch_mcp_server(mcp_config)
.await
.inspect_err(exit_msg!("error launching mcp server"))
.unwrap();
let config = Config::from_file()
.inspect_err(exit_msg!("error loading assist.toml"))
.unwrap();
mcp_server_collection/Cargo.toml
+2 -2
View File
@@ -5,7 +5,7 @@ edition = "2024"
license = "GPL-3.0"
[dependencies]
rmcp = { version = "1.7.0", features = ["server", "transport-streamable-http-server-session", "transport-streamable-http-server"] }
rmcp = { version = "2.2.0", features = ["server", "transport-streamable-http-server-session", "transport-streamable-http-server"] }
chrono = "0.4.44"
axum = "0.8.9"
serde = { version = "1.0.228", features = ["derive"] }
@@ -15,7 +15,7 @@ tokio-util = "0.7.18"
tracing = "0.1.44"
url = { version = "2.5.8", features = ["serde"] }
uuid = { version = "1.23.1", features = ["v4"], optional = true }
tower-http = { version = "0.6.11", features = ["auth"], optional = true }
tower-http = { version = "0.7.0", features = ["auth"], optional = true }
thiserror = { version = "2.0.18", optional = true }
libdav = { version = "0.10.5", optional = true }
icalendar = { version = "0.17.10", optional = true, features = ["chrono-tz", "recurrence"] }
mcp_server_collection/src/caldav/client.rs
+9 -2
View File
@@ -23,8 +23,15 @@ pub(crate) fn get_caldav_client(
username: &str,
password: &str,
) -> AuthorizedCaldavClient {
let https_connector: HttpsConnector<HttpConnector> = HttpsConnectorBuilder::new()
.with_webpki_roots()
let https_connector = HttpsConnectorBuilder::new()
.with_native_roots()
.unwrap_or_else(|_| {
event!(
Level::WARN,
"unable to use native root certificates. Using webpki instead"
);
HttpsConnectorBuilder::new().with_webpki_roots()
})
.https_only()
.enable_http1()
.build();
mcp_server_collection/src/lib.rs
+9 -5
View File
@@ -69,7 +69,9 @@ pub enum McpServerError {
IoError(#[from] std::io::Error),
}
pub async fn serve_in_background(config: Config) -> Result<(CancellationToken, JoinHandle<std::io::Result<()>>), McpServerError> {
pub async fn serve_in_background(
config: Config,
) -> Result<(CancellationToken, JoinHandle<std::io::Result<()>>), McpServerError> {
let routes = Json(
config
.servers
@@ -88,19 +90,21 @@ pub async fn serve_in_background(config: Config) -> Result<(CancellationToken, J
.unwrap_or(url::Url::parse("http://localhost:8000").unwrap());
event!(Level::INFO, "binding address at {bind_address}");
let tcp_listener = tokio::net::TcpListener::bind(bind_address_format(bind_address))
.await?;
let tcp_listener = tokio::net::TcpListener::bind(bind_address_format(bind_address)).await?;
let cancellation_token = CancellationToken::new();
let cloned_cancellation_token = cancellation_token.clone();
let handle = tokio::task::spawn(axum::serve(tcp_listener, router)
let handle = tokio::task::spawn(
axum::serve(tcp_listener, router)
.with_graceful_shutdown(async move {
select! {
_ = cloned_cancellation_token.cancelled() => (),
_ = tokio::signal::ctrl_c() => (),
}
}).into_future());
})
.into_future(),
);
Ok((cancellation_token, handle))
}
mcp_server_collection/src/main.rs
+13 -6
View File
@@ -1,7 +1,7 @@
use mcp_server_collection::config::Config;
use mcp_server_collection::{serve_in_background, McpServerError};
use mcp_server_collection::{McpServerError, serve_in_background};
use own_assist_common::{exit_msg, exit_with_error_message, init_tracing_subscriber};
use tokio::{main};
use tokio::main;
#[main]
async fn main() {
@@ -11,10 +11,17 @@ async fn main() {
.inspect_err(exit_msg!("Error loading config"))
.unwrap();
let (_, join_handle) = serve_in_background(config).await.inspect_err(|err| match err {
McpServerError::McpServerHandlerError(error) => exit_with_error_message(error, "Error handling server"),
McpServerError::IoError(error) => exit_with_error_message(error, "Error binding tcp listener")
}).unwrap();
let (_, join_handle) = serve_in_background(config)
.await
.inspect_err(|err| match err {
McpServerError::McpServerHandlerError(error) => {
exit_with_error_message(error, "Error handling server")
}
McpServerError::IoError(error) => {
exit_with_error_message(error, "Error binding tcp listener")
}
})
.unwrap();
join_handle.await.unwrap().unwrap();
}
own_mcp/Cargo.toml
+2 -2
View File
@@ -8,13 +8,13 @@ license = "GPL-3.0"
ollama-rs = {version = "0.3.4", features = ["macros", "headers"]}
reqwest = { version = "0.13.2", features = ["stream", "multipart", "form"] }
tokio = { version = "1.50.0", features = ["rt", "rt-multi-thread", "macros"] }
rmcp = {version="1.3.0", features = ["transport-streamable-http-client-reqwest", "reqwest", "client", "auth", "transport-child-process"]}
rmcp = {version="2.2.0", features = ["transport-streamable-http-client-reqwest", "reqwest", "client", "auth", "transport-child-process"]}
log = {version = "0.4.29"}
env_logger = "0.11.10"
serde = { version = "1.0.228", features = ["derive"] }
thiserror = "2.0.17"
url = "2.5.8"
rand = "0.10.0"
cpal = "0.17.3"
cpal = "0.18.1"
hound = "3.5.1"
bytes = "1.11.1"
own_mcp/src/audio/recording.rs
+11 -13
View File
@@ -1,5 +1,5 @@
use cpal::traits::{DeviceTrait, StreamTrait};
use cpal::{BuildStreamError, Device, SampleFormat, SizedSample, Stream, SupportedStreamConfig};
use cpal::{Device, Error, SampleFormat, SizedSample, Stream, SupportedStreamConfig};
use hound::WavSpec;
use log::{debug, error, info, trace};
use std::fmt::Debug;
@@ -38,9 +38,9 @@ fn build_stream<T: SizedSample + Debug + hound::Sample + Send + Into<f64>>(
device_config: SupportedStreamConfig,
samples: SampleArc,
sample_format: SampleFormat,
) -> Result<Stream, BuildStreamError> {
) -> Result<Stream, Error> {
mic.build_input_stream(
&device_config.into(),
device_config.into(),
move |input: &[T], _info| stream_callback::<T>(input, samples.clone(), sample_format),
|e| {
error!("a stream error occurred while trying to record: {:?}", e);
@@ -70,9 +70,7 @@ pub enum RecordingError {
#[error("unsupported sample format")]
UnsupportedSampleFormat(SampleFormat),
#[error(transparent)]
PlayStreamError(#[from] cpal::PlayStreamError),
#[error(transparent)]
BuildStreamError(#[from] BuildStreamError),
StreamError(#[from] cpal::Error),
#[error("thread poisoned")]
ThreadPoison,
#[error("recording was already stopped")]
@@ -81,23 +79,23 @@ pub enum RecordingError {
fn start_recording_blocking_with_parameters(
mic: &Device,
device_config: &SupportedStreamConfig,
device_config: SupportedStreamConfig,
sample_format: SampleFormat,
samples: SampleArc,
should_stop: Arc<Mutex<bool>>,
) -> Result<(), RecordingError> {
let stream = match sample_format {
SampleFormat::I8 => {
build_stream::<i8>(mic, device_config.clone(), samples.clone(), sample_format)?
build_stream::<i8>(mic, device_config, samples.clone(), sample_format)?
}
SampleFormat::I16 => {
build_stream::<i16>(mic, device_config.clone(), samples.clone(), sample_format)?
build_stream::<i16>(mic, device_config, samples.clone(), sample_format)?
}
SampleFormat::I32 => {
build_stream::<i32>(mic, device_config.clone(), samples.clone(), sample_format)?
build_stream::<i32>(mic, device_config, samples.clone(), sample_format)?
}
SampleFormat::F32 => {
build_stream::<f32>(mic, device_config.clone(), samples.clone(), sample_format)?
build_stream::<f32>(mic, device_config, samples.clone(), sample_format)?
}
sample_format => {
return Err(RecordingError::UnsupportedSampleFormat(sample_format));
@@ -135,11 +133,11 @@ pub fn start(
let thread_samples = samples.clone();
let thread_recording_stop = recording_should_stop.clone();
let thread_device_config = device_config.clone();
let thread_device_config = device_config;
let record_thread_handle = thread::spawn(move || {
start_recording_blocking_with_parameters(
&microphone,
&thread_device_config,
thread_device_config,
sample_format,
thread_samples,
thread_recording_stop,
own_mcp/src/mcp/chat.rs
+12 -6
View File
@@ -1,6 +1,6 @@
use crate::mcp::MCPClient;
use ollama_rs::Ollama;
use ollama_rs::error::{OllamaError};
use ollama_rs::error::OllamaError;
use ollama_rs::generation::chat::ChatMessage;
use ollama_rs::generation::chat::request::ChatMessageRequest;
use ollama_rs::generation::completion::request::GenerationRequest;
@@ -102,13 +102,13 @@ pub enum ChatError {
#[derive(Debug, Clone)]
pub enum RestrictedToolCallResult {
Granted(CallToolResult),
Denied
Denied,
}
#[derive(Debug, Clone)]
pub struct ToolUsage {
pub call: ToolCall,
pub result: RestrictedToolCallResult
pub result: RestrictedToolCallResult,
}
impl AgentChat {
@@ -255,10 +255,14 @@ impl AgentChat {
.call_tool(tool_call, &mut permission_request_callback)
.await?;
tool_usages.push(ToolUsage{call: tool_call.clone(), result: restricted_result.clone()});
tool_usages.push(ToolUsage {
call: tool_call.clone(),
result: restricted_result.clone(),
});
// serialize structured content if it exists
if let RestrictedToolCallResult::Granted(result) = restricted_result.clone() && let Some(structured_content) = result.structured_content
if let RestrictedToolCallResult::Granted(result) = restricted_result.clone()
&& let Some(structured_content) = result.structured_content
{
log::debug!("structured content: {structured_content:#?}");
@@ -272,7 +276,9 @@ impl AgentChat {
.filter_map(|content| content.as_text())
.map(|text_content| text_content.text.clone())
.collect::<Vec<_>>(),
RestrictedToolCallResult::Denied => vec![String::from("Tool Permission Denied by the user")],
RestrictedToolCallResult::Denied => {
vec![String::from("Tool Permission Denied by the user")]
}
};
log::debug!("contents: {contents:#?}");