break up acp/server.rs

crates/goose/src/acp/server/config.rs

@@ -0,0 +1,36 @@
+use super::*;
+
+impl GooseAcpAgent {
+    pub(super) async fn on_read_config(
+        &self,
+        req: ReadConfigRequest,
+    ) -> Result<ReadConfigResponse, sacp::Error> {
+        let config = self.config()?;
+        let response = match config.get_param::<serde_json::Value>(&req.key) {
+            Ok(value) => ReadConfigResponse { value },
+            Err(crate::config::ConfigError::NotFound(_)) => ReadConfigResponse {
+                value: serde_json::Value::Null,
+            },
+            Err(e) => return Err(sacp::Error::internal_error().data(e.to_string())),
+        };
+        Ok(response)
+    }
+
+    pub(super) async fn on_upsert_config(
+        &self,
+        req: UpsertConfigRequest,
+    ) -> Result<EmptyResponse, sacp::Error> {
+        let config = self.config()?;
+        config.set_param(&req.key, &req.value).internal_err()?;
+        Ok(EmptyResponse {})
+    }
+
+    pub(super) async fn on_remove_config(
+        &self,
+        req: RemoveConfigRequest,
+    ) -> Result<EmptyResponse, sacp::Error> {
+        let config = self.config()?;
+        config.delete(&req.key).internal_err()?;
+        Ok(EmptyResponse {})
+    }
+}

crates/goose/src/acp/server/custom_dispatch.rs

@@ -0,0 +1,354 @@
+use super::*;
+use goose_acp_macros::custom_methods;
+
+#[custom_methods]
+impl GooseAcpAgent {
+    pub async fn dispatch_custom_request(
+        &self,
+        method: &str,
+        params: serde_json::Value,
+    ) -> Result<serde_json::Value, sacp::Error> {
+        self.handle_custom_request(method, params).await
+    }
+
+    #[custom_method(AddExtensionRequest)]
+    async fn dispatch_add_extension(
+        &self,
+        req: AddExtensionRequest,
+    ) -> Result<EmptyResponse, sacp::Error> {
+        self.on_add_extension(req).await
+    }
+
+    #[custom_method(RemoveExtensionRequest)]
+    async fn dispatch_remove_extension(
+        &self,
+        req: RemoveExtensionRequest,
+    ) -> Result<EmptyResponse, sacp::Error> {
+        self.on_remove_extension(req).await
+    }
+
+    #[custom_method(GetToolsRequest)]
+    async fn dispatch_get_tools(
+        &self,
+        req: GetToolsRequest,
+    ) -> Result<GetToolsResponse, sacp::Error> {
+        self.on_get_tools(req).await
+    }
+
+    #[custom_method(ReadResourceRequest)]
+    async fn dispatch_read_resource(
+        &self,
+        req: ReadResourceRequest,
+    ) -> Result<ReadResourceResponse, sacp::Error> {
+        self.on_read_resource(req).await
+    }
+
+    #[custom_method(UpdateWorkingDirRequest)]
+    async fn dispatch_update_working_dir(
+        &self,
+        req: UpdateWorkingDirRequest,
+    ) -> Result<EmptyResponse, sacp::Error> {
+        self.on_update_working_dir(req).await
+    }
+
+    #[custom_method(DeleteSessionRequest)]
+    async fn dispatch_delete_session(
+        &self,
+        req: DeleteSessionRequest,
+    ) -> Result<EmptyResponse, sacp::Error> {
+        self.on_delete_session(req).await
+    }
+
+    #[custom_method(GetExtensionsRequest)]
+    async fn dispatch_get_extensions(&self) -> Result<GetExtensionsResponse, sacp::Error> {
+        self.on_get_extensions().await
+    }
+
+    #[custom_method(AddConfigExtensionRequest)]
+    async fn dispatch_add_config_extension(
+        &self,
+        req: AddConfigExtensionRequest,
+    ) -> Result<EmptyResponse, sacp::Error> {
+        self.on_add_config_extension(req).await
+    }
+
+    #[custom_method(RemoveConfigExtensionRequest)]
+    async fn dispatch_remove_config_extension(
+        &self,
+        req: RemoveConfigExtensionRequest,
+    ) -> Result<EmptyResponse, sacp::Error> {
+        self.on_remove_config_extension(req).await
+    }
+
+    #[custom_method(ToggleConfigExtensionRequest)]
+    async fn dispatch_toggle_config_extension(
+        &self,
+        req: ToggleConfigExtensionRequest,
+    ) -> Result<EmptyResponse, sacp::Error> {
+        self.on_toggle_config_extension(req).await
+    }
+
+    #[custom_method(GetSessionExtensionsRequest)]
+    async fn dispatch_get_session_extensions(
+        &self,
+        req: GetSessionExtensionsRequest,
+    ) -> Result<GetSessionExtensionsResponse, sacp::Error> {
+        self.on_get_session_extensions(req).await
+    }
+
+    #[custom_method(ListProvidersRequest)]
+    async fn dispatch_list_providers(
+        &self,
+        req: ListProvidersRequest,
+    ) -> Result<ListProvidersResponse, sacp::Error> {
+        self.on_list_providers(req).await
+    }
+
+    #[custom_method(RefreshProviderInventoryRequest)]
+    async fn dispatch_refresh_provider_inventory(
+        &self,
+        req: RefreshProviderInventoryRequest,
+    ) -> Result<RefreshProviderInventoryResponse, sacp::Error> {
+        self.on_refresh_provider_inventory(req).await
+    }
+
+    #[custom_method(ProviderConfigReadRequest)]
+    async fn dispatch_read_provider_config(
+        &self,
+        req: ProviderConfigReadRequest,
+    ) -> Result<ProviderConfigReadResponse, sacp::Error> {
+        self.on_read_provider_config(req).await
+    }
+
+    #[custom_method(ProviderConfigStatusRequest)]
+    async fn dispatch_provider_config_status(
+        &self,
+        req: ProviderConfigStatusRequest,
+    ) -> Result<ProviderConfigStatusResponse, sacp::Error> {
+        self.on_provider_config_status(req).await
+    }
+
+    #[custom_method(ProviderConfigSaveRequest)]
+    async fn dispatch_save_provider_config(
+        &self,
+        req: ProviderConfigSaveRequest,
+    ) -> Result<ProviderConfigChangeResponse, sacp::Error> {
+        self.on_save_provider_config(req).await
+    }
+
+    #[custom_method(ProviderConfigDeleteRequest)]
+    async fn dispatch_delete_provider_config(
+        &self,
+        req: ProviderConfigDeleteRequest,
+    ) -> Result<ProviderConfigChangeResponse, sacp::Error> {
+        self.on_delete_provider_config(req).await
+    }
+
+    #[custom_method(ReadConfigRequest)]
+    async fn dispatch_read_config(
+        &self,
+        req: ReadConfigRequest,
+    ) -> Result<ReadConfigResponse, sacp::Error> {
+        self.on_read_config(req).await
+    }
+
+    #[custom_method(UpsertConfigRequest)]
+    async fn dispatch_upsert_config(
+        &self,
+        req: UpsertConfigRequest,
+    ) -> Result<EmptyResponse, sacp::Error> {
+        self.on_upsert_config(req).await
+    }
+
+    #[custom_method(RemoveConfigRequest)]
+    async fn dispatch_remove_config(
+        &self,
+        req: RemoveConfigRequest,
+    ) -> Result<EmptyResponse, sacp::Error> {
+        self.on_remove_config(req).await
+    }
+
+    #[custom_method(CheckSecretRequest)]
+    async fn dispatch_check_secret(
+        &self,
+        req: CheckSecretRequest,
+    ) -> Result<CheckSecretResponse, sacp::Error> {
+        self.on_check_secret(req).await
+    }
+
+    #[custom_method(UpsertSecretRequest)]
+    async fn dispatch_upsert_secret(
+        &self,
+        req: UpsertSecretRequest,
+    ) -> Result<EmptyResponse, sacp::Error> {
+        self.on_upsert_secret(req).await
+    }
+
+    #[custom_method(RemoveSecretRequest)]
+    async fn dispatch_remove_secret(
+        &self,
+        req: RemoveSecretRequest,
+    ) -> Result<EmptyResponse, sacp::Error> {
+        self.on_remove_secret(req).await
+    }
+
+    #[custom_method(ExportSessionRequest)]
+    async fn dispatch_export_session(
+        &self,
+        req: ExportSessionRequest,
+    ) -> Result<ExportSessionResponse, sacp::Error> {
+        self.on_export_session(req).await
+    }
+
+    #[custom_method(ImportSessionRequest)]
+    async fn dispatch_import_session(
+        &self,
+        req: ImportSessionRequest,
+    ) -> Result<ImportSessionResponse, sacp::Error> {
+        self.on_import_session(req).await
+    }
+
+    #[custom_method(UpdateSessionProjectRequest)]
+    async fn dispatch_update_session_project(
+        &self,
+        req: UpdateSessionProjectRequest,
+    ) -> Result<EmptyResponse, sacp::Error> {
+        self.on_update_session_project(req).await
+    }
+
+    #[custom_method(RenameSessionRequest)]
+    async fn dispatch_rename_session(
+        &self,
+        req: RenameSessionRequest,
+    ) -> Result<EmptyResponse, sacp::Error> {
+        self.on_rename_session(req).await
+    }
+
+    #[custom_method(ArchiveSessionRequest)]
+    async fn dispatch_archive_session(
+        &self,
+        req: ArchiveSessionRequest,
+    ) -> Result<EmptyResponse, sacp::Error> {
+        self.on_archive_session(req).await
+    }
+
+    #[custom_method(UnarchiveSessionRequest)]
+    async fn dispatch_unarchive_session(
+        &self,
+        req: UnarchiveSessionRequest,
+    ) -> Result<EmptyResponse, sacp::Error> {
+        self.on_unarchive_session(req).await
+    }
+
+    #[custom_method(CreateSourceRequest)]
+    async fn dispatch_create_source(
+        &self,
+        req: CreateSourceRequest,
+    ) -> Result<CreateSourceResponse, sacp::Error> {
+        self.on_create_source(req).await
+    }
+
+    #[custom_method(ListSourcesRequest)]
+    async fn dispatch_list_sources(
+        &self,
+        req: ListSourcesRequest,
+    ) -> Result<ListSourcesResponse, sacp::Error> {
+        self.on_list_sources(req).await
+    }
+
+    #[custom_method(UpdateSourceRequest)]
+    async fn dispatch_update_source(
+        &self,
+        req: UpdateSourceRequest,
+    ) -> Result<UpdateSourceResponse, sacp::Error> {
+        self.on_update_source(req).await
+    }
+
+    #[custom_method(DeleteSourceRequest)]
+    async fn dispatch_delete_source(
+        &self,
+        req: DeleteSourceRequest,
+    ) -> Result<EmptyResponse, sacp::Error> {
+        self.on_delete_source(req).await
+    }
+
+    #[custom_method(ExportSourceRequest)]
+    async fn dispatch_export_source(
+        &self,
+        req: ExportSourceRequest,
+    ) -> Result<ExportSourceResponse, sacp::Error> {
+        self.on_export_source(req).await
+    }
+
+    #[custom_method(ImportSourcesRequest)]
+    async fn dispatch_import_sources(
+        &self,
+        req: ImportSourcesRequest,
+    ) -> Result<ImportSourcesResponse, sacp::Error> {
+        self.on_import_sources(req).await
+    }
+
+    #[custom_method(DictationTranscribeRequest)]
+    async fn dispatch_dictation_transcribe(
+        &self,
+        req: DictationTranscribeRequest,
+    ) -> Result<DictationTranscribeResponse, sacp::Error> {
+        self.on_dictation_transcribe(req).await
+    }
+
+    #[custom_method(DictationConfigRequest)]
+    async fn dispatch_dictation_config(
+        &self,
+        _req: DictationConfigRequest,
+    ) -> Result<DictationConfigResponse, sacp::Error> {
+        self.on_dictation_config(_req).await
+    }
+
+    #[custom_method(DictationModelsListRequest)]
+    async fn dispatch_dictation_models_list(
+        &self,
+        _req: DictationModelsListRequest,
+    ) -> Result<DictationModelsListResponse, sacp::Error> {
+        self.on_dictation_models_list(_req).await
+    }
+
+    #[custom_method(DictationModelDownloadRequest)]
+    async fn dispatch_dictation_model_download(
+        &self,
+        _req: DictationModelDownloadRequest,
+    ) -> Result<EmptyResponse, sacp::Error> {
+        self.on_dictation_model_download(_req).await
+    }
+
+    #[custom_method(DictationModelDownloadProgressRequest)]
+    async fn dispatch_dictation_model_download_progress(
+        &self,
+        _req: DictationModelDownloadProgressRequest,
+    ) -> Result<DictationModelDownloadProgressResponse, sacp::Error> {
+        self.on_dictation_model_download_progress(_req).await
+    }
+
+    #[custom_method(DictationModelCancelRequest)]
+    async fn dispatch_dictation_model_cancel(
+        &self,
+        _req: DictationModelCancelRequest,
+    ) -> Result<EmptyResponse, sacp::Error> {
+        self.on_dictation_model_cancel(_req).await
+    }
+
+    #[custom_method(DictationModelDeleteRequest)]
+    async fn dispatch_dictation_model_delete(
+        &self,
+        _req: DictationModelDeleteRequest,
+    ) -> Result<EmptyResponse, sacp::Error> {
+        self.on_dictation_model_delete(_req).await
+    }
+
+    #[custom_method(DictationModelSelectRequest)]
+    async fn dispatch_dictation_model_select(
+        &self,
+        req: DictationModelSelectRequest,
+    ) -> Result<EmptyResponse, sacp::Error> {
+        self.on_dictation_model_select(req).await
+    }
+}